ConfigFileName( "" ),
     SourceNetworkInterface( "" ),
     NameServer( "" ),
+    Protocol( PingProtocol_ICMP ),
     HostsDownLimit( 0 ),
     MinHostsDownLimit( 0 ),
     MaxHostsDownLimit( 50 ),
     SourceNetworkInterface = source_network_interface;
 }
 
+PingProtocol Configuration::get_ping_protocol() const
+{
+    return Protocol;
+}
+
+void Configuration::set_ping_protocol( const PingProtocol ping_protocol )
+{
+    BOOST_ASSERT( ( PingProtocol_First <= ping_protocol ) && ( ping_protocol <= PingProtocol_Last ) );
+
+    Protocol = ping_protocol;
+}
+
 int Configuration::get_hosts_down_limit() const
 {
     return HostsDownLimit;
     return LinkUpIntervalInMin;
 }
 
-void Configuration::set_link_up_interval_in_min( const int link_up_interval_in_min )
+void Configuration::set_link_up_interval_in_min(
+        const int link_up_interval_in_min
+)
 {
     BOOST_ASSERT( ( MinStableLinkIntervalInMin <= link_up_interval_in_min ) && ( link_up_interval_in_min <= MaxStableLinkIntervalInMin ) );
 
     return LinkDownIntervalInMin;
 }
 
-void Configuration::set_link_down_interval_in_min( const int link_down_interval_in_min )
+void Configuration::set_link_down_interval_in_min(
+        const int link_down_interval_in_min
+)
 {
     BOOST_ASSERT( ( MinStableLinkIntervalInMin <= link_down_interval_in_min ) && ( link_down_interval_in_min <= MaxStableLinkIntervalInMin ) );
 
 
 #include <boost/shared_ptr.hpp>
 
 #include "config/host.h"
+#include "host/pingprotocol.h"
 
 //-----------------------------------------------------------------------------
 // Configuration
             const std::string &source_network_interface
     );
 
+    PingProtocol get_ping_protocol() const;
+    void set_ping_protocol( const PingProtocol ping_protocol );
+
     int get_hosts_down_limit() const;
     void set_hosts_down_limit( const int hosts_down_limit );
 
     std::string ConfigFileName;
     std::string SourceNetworkInterface;
     std::string NameServer;
+    PingProtocol Protocol;
     int HostsDownLimit;
     int MinHostsDownLimit;
     int MaxHostsDownLimit;
 
     DefaultNameServer( "127.0.0.1" ),
     NameServerCmdStr( "nameserver" ),
     NameServerCmdDesc( "The local address from where the DNS query will be made." ),
+    PingProtocolCmdStr( "ping-protocol" ),
+    PingProtocolCmdDesc( "Defines which protocol will be used to ping the destination." ),
     DefaultHostsDownLimit( 0 ), // no host down
     HostsDownLimitCmdStr( "hosts-down-limit" ),
     HostsDownLimitCmdDesc( "Limit of host that have to be down in order to notify." ),
     options.add_options()
         ( SourceNetworkInterfaceCmdStr.c_str(), value<string>(), SourceNetworkInterfaceCmdDesc.c_str() )
         ( NameServerCmdStr.c_str(), value<string>()->default_value( DefaultNameServer ), NameServerCmdDesc.c_str() )
+        ( PingProtocolCmdStr.c_str(), value<string>(), PingProtocolCmdDesc.c_str() )
         ( HostsDownLimitCmdStr.c_str(), value<int>()->default_value( DefaultHostsDownLimit ), HostsDownLimitCmdDesc.c_str() )
         ( PingFailLimitCmdStr.c_str(), value<int>()->default_value( DefaultPingFailLimit ), PingFailLimitCmdDesc.c_str() )
         ( StatusNotifierCmdCmdStr.c_str(), value<string>(), StatusNotifierCmdCmdDesc.c_str() )
                 << nameserver << endl;
     }
 
+    // ping-protocol
+    if ( vm.count( PingProtocolCmdStr ) > 0 )
+    {
+        string protocol_string = vm[ PingProtocolCmdStr ].as<string> ();
+        PingProtocol protocol = get_ping_protocol_from_string( protocol_string );
+        Config.set_ping_protocol( protocol );
+
+        GlobalLogger.info() << PingProtocolCmdStr << "="
+                << protocol_string << endl;
+    }
+
     // hosts-down-limit
     int host_down_limit = 0;
     if ( vm.count( HostsDownLimitCmdStr ) > 0 )
 
     const std::string DefaultNameServer;
     const std::string NameServerCmdStr;
     const std::string NameServerCmdDesc;
+    const std::string PingProtocolCmdStr;
+    const std::string PingProtocolCmdDesc;
     const int DefaultHostsDownLimit;
     const std::string HostsDownLimitCmdStr;
     const std::string HostsDownLimitCmdDesc;