[bpdyndnsd] / src / main.cpp

/** @file
 * @brief The main function.
 *
 *
 *
 * @copyright Intra2net AG
 * @license GPLv2
*/

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#define PIDFILE "/var/run/bpdyndnsd/bpdyndnsd.pid"

#include <iostream>
#include <fstream>
#include <list>
#include <string>
#include <boost/foreach.hpp>
#include <sys/types.h>
#include <signal.h>

#include "updater.hpp"

using namespace std;

Updater::Ptr updater;
volatile bool caught_sig_hup = false;
volatile bool caught_sig_usr1 = false;
volatile bool caught_sig_usr2 = false;
volatile bool caught_sig_rtmin = false;
volatile bool caught_sig_rtmax = false;
volatile bool caught_sig_term = false;

/**
 * Checks if a bpdyndnsd process is already running.
 * @param updater Shared Pointer to updater, needed for logging.
 * @return 0 if process not running already or pid of already running process.
 */
int check_for_running_process()
{
    ifstream pidfile(PIDFILE);
    if ( pidfile.is_open() )
    {
        int pid;
        pidfile >> pid;
        if ( pid > 0 )
            updater->get_logger()->print_pid_found(pid);
        else
            return 0;

        // check if process still running ret_val==-1 -> not runnig, ret_val==0 -> running
        if ( kill(pid,0) == 0)
        {
            updater->get_logger()->print_process_already_running(pid);
            pidfile.close();
            return pid;
        }
    }
    pidfile.close();
    return 0;
}


/**
 * Writes the pid into the pidfile.
 * @param pid The process's pid.
 */
int write_pidfile(int pid)
{
    ofstream pidfile(PIDFILE);
    if ( pidfile.is_open() )
    {
        pidfile << pid << endl;
    }
    else
    {
        updater->get_logger()->print_error_opening_rw(PIDFILE);
        return -1;
    }
    pidfile.close();
    return 0;
}


/**
 * Parent shutdown function
 * @return 0 if all is fine, -1 otherwise
 */
int shutdown_parent(bool remove_pid, int ret_val)
{
    // starting shutdown_parent
    updater->get_logger()->print_starting_shutdown_parent();

    // remove pidfile if requested
    if(remove_pid)
        unlink(PIDFILE);

    // shutdown parent complete
    updater->get_logger()->print_shutdown_parent_succeeded();

    // release shared pointer
    updater.reset();

    exit(ret_val);
}


/**
 * Shutdown function
 * @return 0 if all is fine, -1 otherwise
 */
int shutdown()
{
    int ret_val = 0;

    // starting shutdown
    updater->get_logger()->print_starting_shutdown();

    // serialize actual service objects
    if ( updater->get_service_holder()->serialize_services() != 0 )
        ret_val = -1;

    // unlink pidfile
    unlink(PIDFILE);

    // shutdown complete
    updater->get_logger()->print_shutdown_succeeded();

    // release shared pointer
    updater.reset();

    return ret_val;
}


/**
 * Signal SIGTERM caught (exit program)
 * @param param Parameter from the signal interface.
 */
void sigterm_func(int param)
{
    caught_sig_term = true;
} /*lint !e715 */


/**
 * Signal SIGUSR1 caught (switch to offline mode)
 * @param param Parameter from the signal interface.
 */
void sigusr1_func(int param)
{
    caught_sig_usr1 = true;
} /*lint !e715 */


/**
 * Signal SIGHUP caught (reload config and reset log level)
 * @param param Parameter from the signal interface.
 */
void sighup_func(int param)
{
    caught_sig_hup = true;
} /*lint !e715 */


/**
 * Signal SIGUSR2 caught (switch to online mode)
 * @param param Parameter from the signal interface.
 */
void sigusr2_func(int param)
{
    caught_sig_usr2 = true;
} /*lint !e715 */


/**
 * Signal SIGRTMIN caught (switch to online mode with webcheck enabled)
 * @param param Parameter from the signal interface.
 */
void sigrtmin_func(int param)
{
    caught_sig_rtmin = true;
} /*lint !e715 */


/**
 * Signal SIGRTMAX caught (increase log level)
 * @param param Parameter from the signal interface.
 */
void sigrtmax_func(int param)
{
    caught_sig_rtmax = true;
} /*lint !e715 */


/**
 * Initialize the signals we handle.
 * @return 0 if all is fine, -1 on error.
 */
int init_signals()
{
    sighandler_t ret_val;
    ret_val = signal(SIGTERM, sigterm_func);
    if ( ret_val == SIG_ERR )
    {
        updater->get_logger()->print_error_setting_signal("SIGTERM");
        return -1;
    }
    ret_val = signal(SIGUSR1, sigusr1_func);
    if ( ret_val == SIG_ERR )
    {
        updater->get_logger()->print_error_setting_signal("SIGUSR1");
        return -1;
    }
    ret_val = signal(SIGHUP, sighup_func);
    if ( ret_val == SIG_ERR )
    {
        updater->get_logger()->print_error_setting_signal("SIGHUP");
        return -1;
    }
    ret_val = signal(SIGUSR2, sigusr2_func);
    if ( ret_val == SIG_ERR )
    {
        updater->get_logger()->print_error_setting_signal("SIGUSR2");
        return -1;
    }
    ret_val = signal(SIGRTMIN, sigrtmin_func);
    if ( ret_val == SIG_ERR )
    {
        updater->get_logger()->print_error_setting_signal("SIGRTMIN");
        return -1;
    }
    ret_val = signal(SIGRTMAX, sigrtmax_func);
    if ( ret_val == SIG_ERR )
    {
        updater->get_logger()->print_error_setting_signal("SIGRTMAX");
        return -1;
    }

    return 0;
}


/**
 * Try to run in daemon mode if enabled in config.
 * @param daemon_mode True if process should detach to init (run as daemon), false if not detach to init.
 * @return 0 if all is fine, -1 on error.
 */
int init_daemon_mode(bool daemon_mode)
{
    updater->get_logger()->print_daemon_mode(daemon_mode);
    if ( daemon_mode == true )
    {
        int pid = fork();
        if ( pid < 0 )
        {
            // error fork
            updater->get_logger()->print_error_fork();
            return -1;
        }
        else if ( pid > 0 )
        {
            // parent continues here
            if ( write_pidfile(pid) != 0 )
            {
                if ( kill(pid,SIGTERM) != 0 )
                {
                    updater->get_logger()->print_error_kill_child(pid);
                    shutdown_parent(false,-1); /*lint !e534 */
                }
                else
                {
                    updater->get_logger()->print_child_killed(pid);
                    shutdown_parent(true,-1); /*lint !e534 */
                }
            }
            updater->get_logger()->print_runnig_as_daemon(pid);
            shutdown_parent(false,0); /*lint !e534 */
        }
        // child starts here
    }
    else
    {
        if ( write_pidfile(getpid()) != 0 )
        {
            shutdown(); /*lint !e534 */
            exit(-1);
        }
    }
    return 0;
}

/**
 * Calculate how long the dialup mode burst period will last (dialup mode only)
 * @return Timestamp until dialup period lasts or zero if dialup mode is disabled
*/
time_t calc_dialup_mode_burst_period()
{
    if (updater->get_config()->get_dialup_mode() )
        return time(NULL) + updater->get_config()->get_dialup_burst_period_seconds();

    return 0;
}

/**
 * @brief The main part.
 * @param argc Number of arguments
 * @param argv Command line arguments
 * @return 0 if all is fine.
 */
int main(int argc, char *argv[])
{
    // initialize Updater
    updater = Updater::Ptr(new Updater);

    // load config and initialize helper classes
    if ( updater->load_config(argc,argv) != 0 )
        return -1;

    // open pidfile and check for running process
    if ( check_for_running_process() != 0)
        return -1;

    // init signal handling
    if ( init_signals() != 0)
        return -1;

    // init daemon_mode if enabled
    if ( init_daemon_mode(updater->get_config()->get_daemon_mode()) != 0 )
        return -1;

    // Should we start in offline mode?
    bool old_online_state = false;
    bool is_online = !updater->get_config()->get_start_offline();
    bool webcheck_enabled = updater->get_config()->get_webcheck_enabled();
    bool exit_now = false;

    // One shot run if daemon mode is disabled
    if (updater->get_config()->get_daemon_mode() != 1)
        exit_now = true;

    // Tell the world we are running
    updater->get_logger()->print_started();

    int original_log_level = updater->get_logger()->get_loglevel();

    // Dialup mode: Sleep a specified number of seconds between network traffic
    time_t dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
    time_t dialup_mode_sleep_until = 0;

    // service processing starts here
    do
    {
        // Signal processing
        if (caught_sig_usr1)
        {
            caught_sig_usr1 = false;
            updater->get_logger()->print_caught_siguser1();

            // Go offline
            is_online = false;
        } else if (caught_sig_usr2)
        {
            caught_sig_usr2 = false;
            updater->get_logger()->print_caught_siguser2();

            // Go online
            is_online = true;
            webcheck_enabled = false;
            dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
        } else if (caught_sig_rtmin)
        {
            caught_sig_rtmin = false;
            updater->get_logger()->print_caught_sigrtmin();

            // Go online - with webcheck
            is_online = true;
            webcheck_enabled = true;
            dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
        } else if (caught_sig_rtmax)
        {
            caught_sig_rtmax = false;

            // Increase log level
            int new_loglevel = updater->get_logger()->get_loglevel() + 1;
            updater->get_logger()->print_caught_sigrtmax(new_loglevel);
            updater->get_logger()->set_loglevel(new_loglevel);
        } else if (caught_sig_term)
        {
            caught_sig_term = false;
            updater->get_logger()->print_caught_sigterm();

            exit_now = true;
        } else if (caught_sig_hup)
        {
            caught_sig_hup = false;
            updater->get_logger()->print_caught_sighup();

            if ( updater->reload_config() != 0 )
            {
                updater->get_logger()->print_conf_reload_failed_exit();
                exit(-1);
            }

            // Reset log level to startup log level in case it got elevated by SIGRTMAX
            updater->get_logger()->set_loglevel(original_log_level);

            // Reset dialup mode burst period on config reload
            dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
        }

        // State handling
        if ( is_online == true )
        {
            // Check if webcheck_enabled differs due to caught singnal then set it in config correspondingly
            if ( updater->get_config()->get_webcheck_enabled() != webcheck_enabled )    /*lint !e731 */
                updater->get_config()->set_webcheck_enabled(webcheck_enabled);

            if (updater->get_config()->get_dialup_mode() == false ||
                (time(NULL) > dialup_mode_sleep_until || time(NULL) < dialup_mode_burst_mode_until) )
            {
                // update all configured services
                updater->update_services(is_online != old_online_state);

                // Refresh sleep state (dialup mode only)
                dialup_mode_sleep_until = time(NULL) + updater->get_config()->get_dialup_sleep_seconds();
            } else
                updater->get_logger()->print_sleep_dialup_mode(dialup_mode_sleep_until);
        }
        else
        {
            // We are in offline mode, do nothing, expect printing "offline mode".
            updater->get_logger()->print_offline_mode();
        }

        // Keep old online state so we can determine
        // if we switched from offline to online
        old_online_state = is_online;

        // Snore, snore... don't hog the cpu if we are in daemon_mode.
        if ( !exit_now )
            sleep(10); /*lint !e534 */
    } while ( !exit_now );

    // Serialize services to save their actual state.
    if ( shutdown() != 0 )
        return -1;

    return 0;
}
Commit	Line	Data
	1	/** @file
	2	* @brief The main function.
	3	*
	4	*
	5	*
	6	* @copyright Intra2net AG
	7	* @license GPLv2
	8	*/
	9
	10	#ifdef HAVE_CONFIG_H
	11	#include <config.h>
	12	#endif
	13
	14	#define PIDFILE "/var/run/bpdyndnsd/bpdyndnsd.pid"
	15
	16	#include <iostream>
	17	#include <fstream>
	18	#include <list>
	19	#include <string>
	20	#include <boost/foreach.hpp>
	21	#include <sys/types.h>
	22	#include <signal.h>
	23
	24	#include "updater.hpp"
	25
	26	using namespace std;
	27
	28	Updater::Ptr updater;
	29	volatile bool caught_sig_hup = false;
	30	volatile bool caught_sig_usr1 = false;
	31	volatile bool caught_sig_usr2 = false;
	32	volatile bool caught_sig_rtmin = false;
	33	volatile bool caught_sig_rtmax = false;
	34	volatile bool caught_sig_term = false;
	35
	36	/**
	37	* Checks if a bpdyndnsd process is already running.
	38	* @param updater Shared Pointer to updater, needed for logging.
	39	* @return 0 if process not running already or pid of already running process.
	40	*/
	41	int check_for_running_process()
	42	{
	43	ifstream pidfile(PIDFILE);
	44	if ( pidfile.is_open() )
	45	{
	46	int pid;
	47	pidfile >> pid;
	48	if ( pid > 0 )
	49	updater->get_logger()->print_pid_found(pid);
	50	else
	51	return 0;
	52
	53	// check if process still running ret_val==-1 -> not runnig, ret_val==0 -> running
	54	if ( kill(pid,0) == 0)
	55	{
	56	updater->get_logger()->print_process_already_running(pid);
	57	pidfile.close();
	58	return pid;
	59	}
	60	}
	61	pidfile.close();
	62	return 0;
	63	}
	64
	65
	66	/**
	67	* Writes the pid into the pidfile.
	68	* @param pid The process's pid.
	69	*/
	70	int write_pidfile(int pid)
	71	{
	72	ofstream pidfile(PIDFILE);
	73	if ( pidfile.is_open() )
	74	{
	75	pidfile << pid << endl;
	76	}
	77	else
	78	{
	79	updater->get_logger()->print_error_opening_rw(PIDFILE);
	80	return -1;
	81	}
	82	pidfile.close();
	83	return 0;
	84	}
	85
	86
	87	/**
	88	* Parent shutdown function
	89	* @return 0 if all is fine, -1 otherwise
	90	*/
	91	int shutdown_parent(bool remove_pid, int ret_val)
	92	{
	93	// starting shutdown_parent
	94	updater->get_logger()->print_starting_shutdown_parent();
	95
	96	// remove pidfile if requested
	97	if(remove_pid)
	98	unlink(PIDFILE);
	99
	100	// shutdown parent complete
	101	updater->get_logger()->print_shutdown_parent_succeeded();
	102
	103	// release shared pointer
	104	updater.reset();
	105
	106	exit(ret_val);
	107	}
	108
	109
	110	/**
	111	* Shutdown function
	112	* @return 0 if all is fine, -1 otherwise
	113	*/
	114	int shutdown()
	115	{
	116	int ret_val = 0;
	117
	118	// starting shutdown
	119	updater->get_logger()->print_starting_shutdown();
	120
	121	// serialize actual service objects
	122	if ( updater->get_service_holder()->serialize_services() != 0 )
	123	ret_val = -1;
	124
	125	// unlink pidfile
	126	unlink(PIDFILE);
	127
	128	// shutdown complete
	129	updater->get_logger()->print_shutdown_succeeded();
	130
	131	// release shared pointer
	132	updater.reset();
	133
	134	return ret_val;
	135	}
	136
	137
	138	/**
	139	* Signal SIGTERM caught (exit program)
	140	* @param param Parameter from the signal interface.
	141	*/
	142	void sigterm_func(int param)
	143	{
	144	caught_sig_term = true;
	145	} /lint !e715 /
	146
	147
	148	/**
	149	* Signal SIGUSR1 caught (switch to offline mode)
	150	* @param param Parameter from the signal interface.
	151	*/
	152	void sigusr1_func(int param)
	153	{
	154	caught_sig_usr1 = true;
	155	} /lint !e715 /
	156
	157
	158	/**
	159	* Signal SIGHUP caught (reload config and reset log level)
	160	* @param param Parameter from the signal interface.
	161	*/
	162	void sighup_func(int param)
	163	{
	164	caught_sig_hup = true;
	165	} /lint !e715 /
	166
	167
	168	/**
	169	* Signal SIGUSR2 caught (switch to online mode)
	170	* @param param Parameter from the signal interface.
	171	*/
	172	void sigusr2_func(int param)
	173	{
	174	caught_sig_usr2 = true;
	175	} /lint !e715 /
	176
	177
	178	/**
	179	* Signal SIGRTMIN caught (switch to online mode with webcheck enabled)
	180	* @param param Parameter from the signal interface.
	181	*/
	182	void sigrtmin_func(int param)
	183	{
	184	caught_sig_rtmin = true;
	185	} /lint !e715 /
	186
	187
	188	/**
	189	* Signal SIGRTMAX caught (increase log level)
	190	* @param param Parameter from the signal interface.
	191	*/
	192	void sigrtmax_func(int param)
	193	{
	194	caught_sig_rtmax = true;
	195	} /lint !e715 /
	196
	197
	198	/**
	199	* Initialize the signals we handle.
	200	* @return 0 if all is fine, -1 on error.
	201	*/
	202	int init_signals()
	203	{
	204	sighandler_t ret_val;
	205	ret_val = signal(SIGTERM, sigterm_func);
	206	if ( ret_val == SIG_ERR )
	207	{
	208	updater->get_logger()->print_error_setting_signal("SIGTERM");
	209	return -1;
	210	}
	211	ret_val = signal(SIGUSR1, sigusr1_func);
	212	if ( ret_val == SIG_ERR )
	213	{
	214	updater->get_logger()->print_error_setting_signal("SIGUSR1");
	215	return -1;
	216	}
	217	ret_val = signal(SIGHUP, sighup_func);
	218	if ( ret_val == SIG_ERR )
	219	{
	220	updater->get_logger()->print_error_setting_signal("SIGHUP");
	221	return -1;
	222	}
	223	ret_val = signal(SIGUSR2, sigusr2_func);
	224	if ( ret_val == SIG_ERR )
	225	{
	226	updater->get_logger()->print_error_setting_signal("SIGUSR2");
	227	return -1;
	228	}
	229	ret_val = signal(SIGRTMIN, sigrtmin_func);
	230	if ( ret_val == SIG_ERR )
	231	{
	232	updater->get_logger()->print_error_setting_signal("SIGRTMIN");
	233	return -1;
	234	}
	235	ret_val = signal(SIGRTMAX, sigrtmax_func);
	236	if ( ret_val == SIG_ERR )
	237	{
	238	updater->get_logger()->print_error_setting_signal("SIGRTMAX");
	239	return -1;
	240	}
	241
	242	return 0;
	243	}
	244
	245
	246	/**
	247	* Try to run in daemon mode if enabled in config.
	248	* @param daemon_mode True if process should detach to init (run as daemon), false if not detach to init.
	249	* @return 0 if all is fine, -1 on error.
	250	*/
	251	int init_daemon_mode(bool daemon_mode)
	252	{
	253	updater->get_logger()->print_daemon_mode(daemon_mode);
	254	if ( daemon_mode == true )
	255	{
	256	int pid = fork();
	257	if ( pid < 0 )
	258	{
	259	// error fork
	260	updater->get_logger()->print_error_fork();
	261	return -1;
	262	}
	263	else if ( pid > 0 )
	264	{
	265	// parent continues here
	266	if ( write_pidfile(pid) != 0 )
	267	{
	268	if ( kill(pid,SIGTERM) != 0 )
	269	{
	270	updater->get_logger()->print_error_kill_child(pid);
	271	shutdown_parent(false,-1); /lint !e534 /
	272	}
	273	else
	274	{
	275	updater->get_logger()->print_child_killed(pid);
	276	shutdown_parent(true,-1); /lint !e534 /
	277	}
	278	}
	279	updater->get_logger()->print_runnig_as_daemon(pid);
	280	shutdown_parent(false,0); /lint !e534 /
	281	}
	282	// child starts here
	283	}
	284	else
	285	{
	286	if ( write_pidfile(getpid()) != 0 )
	287	{
	288	shutdown(); /lint !e534 /
	289	exit(-1);
	290	}
	291	}
	292	return 0;
	293	}
	294
	295	/**
	296	* Calculate how long the dialup mode burst period will last (dialup mode only)
	297	* @return Timestamp until dialup period lasts or zero if dialup mode is disabled
	298	*/
	299	time_t calc_dialup_mode_burst_period()
	300	{
	301	if (updater->get_config()->get_dialup_mode() )
	302	return time(NULL) + updater->get_config()->get_dialup_burst_period_seconds();
	303
	304	return 0;
	305	}
	306
	307	/**
	308	* @brief The main part.
	309	* @param argc Number of arguments
	310	* @param argv Command line arguments
	311	* @return 0 if all is fine.
	312	*/
	313	int main(int argc, char *argv[])
	314	{
	315	// initialize Updater
	316	updater = Updater::Ptr(new Updater);
	317
	318	// load config and initialize helper classes
	319	if ( updater->load_config(argc,argv) != 0 )
	320	return -1;
	321
	322	// open pidfile and check for running process
	323	if ( check_for_running_process() != 0)
	324	return -1;
	325
	326	// init signal handling
	327	if ( init_signals() != 0)
	328	return -1;
	329
	330	// init daemon_mode if enabled
	331	if ( init_daemon_mode(updater->get_config()->get_daemon_mode()) != 0 )
	332	return -1;
	333
	334	// Should we start in offline mode?
	335	bool old_online_state = false;
	336	bool is_online = !updater->get_config()->get_start_offline();
	337	bool webcheck_enabled = updater->get_config()->get_webcheck_enabled();
	338	bool exit_now = false;
	339
	340	// One shot run if daemon mode is disabled
	341	if (updater->get_config()->get_daemon_mode() != 1)
	342	exit_now = true;
	343
	344	// Tell the world we are running
	345	updater->get_logger()->print_started();
	346
	347	int original_log_level = updater->get_logger()->get_loglevel();
	348
	349	// Dialup mode: Sleep a specified number of seconds between network traffic
	350	time_t dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
	351	time_t dialup_mode_sleep_until = 0;
	352
	353	// service processing starts here
	354	do
	355	{
	356	// Signal processing
	357	if (caught_sig_usr1)
	358	{
	359	caught_sig_usr1 = false;
	360	updater->get_logger()->print_caught_siguser1();
	361
	362	// Go offline
	363	is_online = false;
	364	} else if (caught_sig_usr2)
	365	{
	366	caught_sig_usr2 = false;
	367	updater->get_logger()->print_caught_siguser2();
	368
	369	// Go online
	370	is_online = true;
	371	webcheck_enabled = false;
	372	dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
	373	} else if (caught_sig_rtmin)
	374	{
	375	caught_sig_rtmin = false;
	376	updater->get_logger()->print_caught_sigrtmin();
	377
	378	// Go online - with webcheck
	379	is_online = true;
	380	webcheck_enabled = true;
	381	dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
	382	} else if (caught_sig_rtmax)
	383	{
	384	caught_sig_rtmax = false;
	385
	386	// Increase log level
	387	int new_loglevel = updater->get_logger()->get_loglevel() + 1;
	388	updater->get_logger()->print_caught_sigrtmax(new_loglevel);
	389	updater->get_logger()->set_loglevel(new_loglevel);
	390	} else if (caught_sig_term)
	391	{
	392	caught_sig_term = false;
	393	updater->get_logger()->print_caught_sigterm();
	394
	395	exit_now = true;
	396	} else if (caught_sig_hup)
	397	{
	398	caught_sig_hup = false;
	399	updater->get_logger()->print_caught_sighup();
	400
	401	if ( updater->reload_config() != 0 )
	402	{
	403	updater->get_logger()->print_conf_reload_failed_exit();
	404	exit(-1);
	405	}
	406
	407	// Reset log level to startup log level in case it got elevated by SIGRTMAX
	408	updater->get_logger()->set_loglevel(original_log_level);
	409
	410	// Reset dialup mode burst period on config reload
	411	dialup_mode_burst_mode_until = calc_dialup_mode_burst_period();
	412	}
	413
	414	// State handling
	415	if ( is_online == true )
	416	{
	417	// Check if webcheck_enabled differs due to caught singnal then set it in config correspondingly
	418	if ( updater->get_config()->get_webcheck_enabled() != webcheck_enabled ) /lint !e731 /
	419	updater->get_config()->set_webcheck_enabled(webcheck_enabled);
	420
	421	if (updater->get_config()->get_dialup_mode() == false \|\|
	422	(time(NULL) > dialup_mode_sleep_until \|\| time(NULL) < dialup_mode_burst_mode_until) )
	423	{
	424	// update all configured services
	425	updater->update_services(is_online != old_online_state);
	426
	427	// Refresh sleep state (dialup mode only)
	428	dialup_mode_sleep_until = time(NULL) + updater->get_config()->get_dialup_sleep_seconds();
	429	} else
	430	updater->get_logger()->print_sleep_dialup_mode(dialup_mode_sleep_until);
	431	}
	432	else
	433	{
	434	// We are in offline mode, do nothing, expect printing "offline mode".
	435	updater->get_logger()->print_offline_mode();
	436	}
	437
	438	// Keep old online state so we can determine
	439	// if we switched from offline to online
	440	old_online_state = is_online;
	441
	442	// Snore, snore... don't hog the cpu if we are in daemon_mode.
	443	if ( !exit_now )
	444	sleep(10); /lint !e534 /
	445	} while ( !exit_now );
	446
	447	// Serialize services to save their actual state.
	448	if ( shutdown() != 0 )
	449	return -1;
	450
	451	return 0;
	452	}