- status-notifier-cmd: the command line that is called when a host is down, or
   up. Accepted variables are:
     ${status} - down or up
+- stable-link-up-interval: how long (in minutes) the pings don't have to fail
+  in order to consider the link up, or stable.
 
 
 4.2. Host
 
 hosts-down-limit=4
 ping-fail-limit=40
 status-notifier-cmd=./system_status_alert.sh ${status}
+stable-link-up-interval=10
 
 [host]
 name=www.intra2net.com
 
 
 up()
 {
-    echo "SYSTEM OK"
+    echo "LINK UP"
 }
 
 
 down()
 {
-    echo "SYSTEM DOWN"
+    echo "LINK DOWN"
 }
 
 
 
     MinPingFailLimit( 0 ),
     MaxPingFailLimit( 100 ),
     StatusNotifierCmd( "" ),
+    StableLinkUpInterval( 0 ),
+    MinStableLinkUpInterval( 0 ),
+    MaxStableLinkUpInterval( 60 ),
     Hosts()
 {
 }
     StatusNotifierCmd = status_notifier_cmd;
 }
 
+int Configuration::get_stable_link_up_interval() const
+{
+    return StableLinkUpInterval;
+}
+
+void Configuration::set_stable_link_up_interval( const int stable_link_up_interval )
+{
+    StableLinkUpInterval = stable_link_up_interval;
+}
+
 vector< HostItem > Configuration::get_hosts() const
 {
     return Hosts;
 
     std::string get_status_notifier_cmd() const;
     void set_status_notifier_cmd( const std::string &status_notifier_cmd );
 
+    int get_stable_link_up_interval() const;
+    void set_stable_link_up_interval( const int stable_link_up_interval );
+
     std::vector<HostItem> get_hosts() const;
     void set_hosts( const std::vector<HostItem> &hosts_list );
 
     const int MinPingFailLimit;
     const int MaxPingFailLimit;
     std::string StatusNotifierCmd;
+    int StableLinkUpInterval;
+    const int MinStableLinkUpInterval;
+    const int MaxStableLinkUpInterval;
     std::vector<HostItem> Hosts;
 
 };
 
     PingFailLimitCmdDesc( "Maximum percentage of pings that can fail for a given host." ),
     StatusNotifierCmdCmdStr( "status-notifier-cmd" ),
     StatusNotifierCmdCmdDesc( "The command to execute to alert about host status." ),
+    DefaultStableLinkUpInterval( 5 ), // 5 minutes
+    StableLinkUpIntervalCmdStr( "stable-link-up-interval" ),
+    StableLinkUpIntervalCmdDesc( "How long the link must be responsive in order to consider it stable" ),
     HostNameCmdStr( "host.name" ),
     HostNameCmdDesc( "Host address" ),
     DefaultHostInterval( 60 ), // 60 seconds
         ( 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() )
+        ( StableLinkUpIntervalCmdStr.c_str(), value<int>()->default_value( DefaultStableLinkUpInterval ), StableLinkUpIntervalCmdDesc.c_str() )
         ( HostNameCmdStr.c_str(), value< vector<string> >(), HostNameCmdDesc.c_str() )
         ( HostIntervalCmdStr.c_str(), value< vector<int> >(), HostIntervalCmdDesc.c_str() )
     ;
         cout << StatusNotifierCmdCmdStr << "=" << status_notifier_cmd << endl;
     }
 
+    // stable-link-up-interval
+    if ( vm.count( StableLinkUpIntervalCmdStr ) )
+    {
+        int stable_link_up_interval = vm[ StableLinkUpIntervalCmdStr ].as<int>();
+        Config.set_stable_link_up_interval( stable_link_up_interval );
+
+        cout << StableLinkUpIntervalCmdStr << "=" << stable_link_up_interval
+             << endl;
+    }
+
     // [host] name
     int hosts_names_count = 0;
     if ( vm.count( HostNameCmdStr ) )
 
     const std::string PingFailLimitCmdDesc;
     const std::string StatusNotifierCmdCmdStr;
     const std::string StatusNotifierCmdCmdDesc;
+    const int DefaultStableLinkUpInterval;
+    const std::string StableLinkUpIntervalCmdStr;
+    const std::string StableLinkUpIntervalCmdDesc;
     const std::string HostNameCmdStr;
     const std::string HostNameCmdDesc;
     const int DefaultHostInterval;