ConfigurationReader::ConfigurationReader() :
     Config(),
-    VersionCmdStr( "version" ),
-    VersionCmdDesc( "Print the version string and exit." ),
     HelpCmdStr( "help" ),
     HelpCmdDesc( "Print this help and exit." ),
+    VersionCmdStr( "version" ),
+    VersionCmdDesc( "Print the version string and exit." ),
+    DaemonCmdStr( "daemon" ),
+    DaemonCmdDesc( "Run the program as a deamon." ),
     DefaultConfigFileName( "pingcheck.conf" ),
     ConfigFileCmdStr( "config-file" ),
     ConfigFileCmdDesc( "Name of the configuration file." ),
 {
     options_description options( "Generic options" );
     options.add_options()
-        ( VersionCmdStr.c_str(), VersionCmdDesc.c_str() )
         ( HelpCmdStr.c_str(), HelpCmdDesc.c_str() )
+        ( VersionCmdStr.c_str(), VersionCmdDesc.c_str() )
+        ( DaemonCmdStr.c_str(), DaemonCmdDesc.c_str() )
         ( ConfigFileCmdStr.c_str(), value<string>()->default_value( DefaultConfigFileName ), ConfigFileCmdDesc.c_str() )
     ;
 
 {
     bool is_help = ( vm.count( HelpCmdStr ) > 0 );
     bool is_version = ( vm.count( VersionCmdStr ) > 0 );
-    bool is_a_generic_option = is_help || is_version;
+    bool is_daemon = ( vm.count( DaemonCmdStr ) > 0 );
+    bool is_a_generic_option = is_help || is_version || is_daemon;
 
     return is_a_generic_option;
 }
 bool ConfigurationReader::parse_generic_options(
         const variables_map& vm,
         const options_description& visible_options
-) const
+)
 {
+    // TODO how to make clear that returning false makes the application abort
+    // and returning true lets it continue processing the configuration file?
     if ( vm.count( HelpCmdStr ) )
     {
         cout << visible_options << endl;
-        return true;
+        return false;
     }
 
     if ( vm.count( VersionCmdStr ) )
     {
         cout << PROJECT_NAME << " version " << VERSION_STRING << endl;
+        return false;
+    }
+
+    if ( vm.count( DaemonCmdStr ) )
+    {
+        Config.set_daemon( true );
         return true;
     }
 
         const int argc,
         char *argv[],
         variables_map &vm
-) const
+)
 {
     try
     {
 
         if ( is_generic_options( vm ) )
         {
-            (void) parse_generic_options( vm, visible );
-
-            return false;
+            return parse_generic_options( vm, visible );
         }
 
     }
 
     bool parse_generic_options(
             const boost::program_options::variables_map &vm,
             const boost::program_options::options_description &visible_options
-    ) const;
+    );
 
     boost::program_options::options_description get_configuration_options() const;
     bool parse_configuration_options(
             const int argc,
             char *argv[],
             boost::program_options::variables_map &vm
-    ) const;
+    );
     bool process_configuration_file(
             boost::program_options::variables_map &vm
     );
 private:
     Configuration Config;
 
-    const std::string VersionCmdStr;
-    const std::string VersionCmdDesc;
     const std::string HelpCmdStr;
     const std::string HelpCmdDesc;
+    const std::string VersionCmdStr;
+    const std::string VersionCmdDesc;
+    const std::string DaemonCmdStr;
+    const std::string DaemonCmdDesc;
     const std::string DefaultConfigFileName;
     const std::string ConfigFileCmdStr;
     const std::string ConfigFileCmdDesc;
 
 #include <boost/foreach.hpp>
 #include <boost/shared_ptr.hpp>
 
+#include "daemonfunc.hpp"
+
 #include "config/configurationreader.h"
 #include "config/host.h"
 #include "link/linkstatusanalyzer.h"
 
         Configuration config = config_reader.get_configuration();
 
+        bool daemon_mode = config.get_daemon();
+        if ( daemon_mode )
+        {
+            I2n::Daemon::daemonize();
+        }
         int ping_fail_limit = config.get_ping_fail_limit();
         int link_up_interval_in_min = config.get_link_up_interval_in_min();