Subversion Repositories general

/******************************************************************

 * rebootd.

 *

 * A daemon which waits on specified UDP port for special string

 * (password) and reboots the computer.

 *

 * Run "./rebootd --help" to see options and parameters.

 *

 * Copyleft 2005 Anatoli Klassen

 *

 ******************************************************************/

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <ctype.h>

#include <errno.h>

#include <signal.h>

#include <unistd.h>

#include <netdb.h>

#include <syslog.h>

#include <signal.h>

#include <fcntl.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <sys/wait.h>

#include <sys/reboot.h>

#include <netinet/in.h>

#include <arpa/inet.h>

/* name version number */

#define APP_NAME          "rebootd"

#define DEFAULT_PORT      19

#define DEFAULT_CFG_FILE  "/etc/rebootd.conf"

#define CMDSIZE           4096

#define BUFSIZE           4096

#define MAX_CONFIG_LINE   4096

#define PORT_MIN          1

#define PORT_MAX          65535

/* return values of functions */

#define RESULT_OK         0

#define RESULT_EXIT       1

#define RESULT_ERROR      2

#define RESULT_UNEXPECTED 3

/* return values for the whole program */

#define EXIT_OK           0

#define EXIT_USER_ERROR   1

#define EXIT_UNEXPECTED   2

/* command line and config file parameters */

#define PARAM_HELP_1      "-h"

#define PARAM_HELP_2      "--help"

#define PARAM_VERSION     "--version"

#define PARAM_INTERFACE   "--interface"

#define PARAM_PORT        "--port"

#define PARAM_CONFIG      "--config"

#define PARAM_PID_FILE    "--pid"

#define PARAM_DEBUG       "--debug"

#define CONFIG_INTERFACE  "interface"

#define CONFIG_PORT       "port"

#define CONFIG_PASSWORD   "password"

#define CONFIG_PID_FILE   "pid"

/* priority of defferent sources of options */

#define CFG_PRIO_CMD      1

#define CFG_PRIO_CONFIG   2

#define CFG_PRIO_DEFAULT  3

struct config {

	char           config_file[FILENAME_MAX];

	char           config_file_prio;

	struct in_addr interface;

	char           interface_prio;

	ushort         port;

	char           port_prio;

	char           password[MAX_CONFIG_LINE];

	char           password_prio;

	char           pid_file[FILENAME_MAX];

	char           pid_file_prio;

	char           debug_mode;

};

static struct config global_cfg;

static int           daemonized        = 0; /* we are already a daemon */

volatile static int  reconfig_required = 0; /* we have to stop socket listening and reread config */

volatile static int  quit_required     = 0; /* we have to stop socket listening and exit */

static int parse_cmd_line(struct config *cfg, int argc, const char* argv[]);

static int parse_config_file(struct config *cfg, const char *config_name);

static void check_return(int res);

static uint min(uint a, uint b)

{

	return (a < b) ? a : b;

}

static int establish(const struct config *cfg)

{

	int s;

	struct sockaddr_in sa;

	memset(&sa, 0, sizeof(struct sockaddr_in));

	sa.sin_family      = AF_INET;

	sa.sin_port        = htons(cfg->port);

	sa.sin_addr.s_addr = (cfg->interface.s_addr ? cfg->interface.s_addr : INADDR_ANY);

	if((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0)

		return -1;

	if(bind(s, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {

		close(s);

		return -1;

	}

	return s;

}

static void listen_socket(const struct config *cfg, int soc)

{

	char                    buf[BUFSIZE];

	int                     br;

	struct sockaddr_storage ss;

	socklen_t               ss_size;

	for(;;) {

		ss_size = sizeof(ss);

		br = recvfrom(soc, buf, sizeof(buf)-1, 0, (struct sockaddr *)&ss, &ss_size);

		if(br < 0) {

			if(errno == EINTR) {

				if(reconfig_required || quit_required) break;

			}

			else {

				syslog(LOG_INFO, "cannot receive: %s", strerror(errno));

			}

			continue;

		}

		buf[br] = '\0';

		sleep(1);

		syslog(LOG_INFO, "got command");

		if(0 == strncmp(buf, cfg->password, sizeof(buf))) {

			if(cfg->debug_mode) {

				syslog(LOG_INFO, "REBOOT, debug mode");

			}

			else {

				syslog(LOG_EMERG, "REBOOT");

				sleep(5);

				if(reboot(RB_AUTOBOOT) < 0) {

					syslog(LOG_ERR, "cannot reboot, %s", strerror(errno));

				}

			}

		}

	}

}

static void print_version(void)

{

	printf("%s %s.%s.%s\n", APP_NAME, VER_MAJOR, VER_MINOR, VER_REVISION);

}

static void pring_usage(int argc, const char* argv[])

{

	print_version();

	printf("\nA daemon which waits on specified UDP port for special");

	printf(" string (password) and reboots the computer.\n\n");

	printf("Usage: %s [--debug] [--interface IP] [--port PORT]\n", argv[0]);

	printf("       [--config CONFIG_FILE] [--pid FILE]\n");

	printf("   or: %s --version\n", argv[0]);

	printf("   or: %s --help\n\n", argv[0]);

	printf("Defaults are port 19, all interfaces, config /etc/rebootd.conf and no PID file.\n");

	printf("In debug mode do not reboot, just write to log.\n\n");

	printf("Config file looks like:\n--------------------------\n");

	printf("interface=192.168.0.1\nport=19\npassword=\"some password\"\n");

	printf("pid=/var/run/rebootd.pid\n--------------------------\n\n");

	printf("Then run from any other host:\necho -n \"some password\" | nc -uo host_to_rebot 19\n");

}

static int print_error(const char *msg, const char *value)

{

	if(daemonized) {

		syslog(LOG_ERR, "%s", msg);

		if(value) syslog(LOG_ERR, " - %s\n", value);

		syslog(LOG_ERR, "\n");

	}

	else {

		fprintf(stderr, "%s", msg);

		if(value) fprintf(stderr, " - %s\n", value);

		fprintf(stderr, "\n");

	}

	return RESULT_ERROR;

}

static int print_cmd_error(int argc, const char* argv[], const char *msg, const char *value)

{

	fprintf(stderr, "%s", msg);

	if(value) fprintf(stderr, " - %s\n", value);

	fprintf(stderr, "\n");

	pring_usage(argc, argv);

	return RESULT_ERROR;

}

static int print_config_error(const char *config_name, int line, const char *msg, const char *value)

{

	if(daemonized) {

		syslog(LOG_ERR, "Error in %s, line %d: %s", config_name, line, msg);

		if(value) syslog(LOG_ERR, " - %s", value);

		syslog(LOG_ERR, "\n");

	}

	else {

		fprintf(stderr, "Error in %s, line %d: %s", config_name, line, msg);

		if(value) fprintf(stderr, " - %s", value);

		fprintf(stderr, "\n");

	}

	return RESULT_ERROR;

}

static int check_abs_path(const char *file_name)

{

	if(file_name && file_name[0] != '\0' && file_name[0] != '/') {

		return print_error("File must have an absolute path", file_name);

	}

	return RESULT_OK;

}

static int read_config(struct config *cfg, int argc, const char* argv[])

{

	int           res_cmd_line;

	int           res_config_file;

	struct config cmd_cfg;

	struct config file_cfg;

	memset(cfg, 0, sizeof(struct config));

	res_cmd_line = parse_cmd_line(&cmd_cfg, argc, argv);

	if(res_cmd_line != RESULT_OK) return res_cmd_line;

	if(check_abs_path(cmd_cfg.config_file) != RESULT_OK) return RESULT_ERROR;

	res_config_file = parse_config_file(&file_cfg,

		cmd_cfg.config_file[0] != '\0' ? cmd_cfg.config_file : DEFAULT_CFG_FILE);

	if(res_config_file != RESULT_OK) return res_config_file;

	if(file_cfg.password[0] == '\0')

		return print_error("Password is not set", NULL);

	/* save parsed values to general config */

	if(cmd_cfg.config_file[0] != '\0') {

		strncpy(cfg->config_file, cmd_cfg.config_file, sizeof(cfg->config_file));

		cfg->config_file_prio = CFG_PRIO_CMD;

	}

	else {

		strncpy(cfg->config_file, DEFAULT_CFG_FILE, sizeof(cfg->config_file));

		cfg->config_file_prio = CFG_PRIO_DEFAULT;

	}

	if(cmd_cfg.interface.s_addr) {

		cfg->interface      = cmd_cfg.interface;

		cfg->interface_prio = CFG_PRIO_CMD;

	}

	else if(file_cfg.interface.s_addr) {

		cfg->interface      = file_cfg.interface;

		cfg->interface_prio = CFG_PRIO_CONFIG;

	}

	else {

		cfg->interface_prio = CFG_PRIO_DEFAULT;

	}

	if(cmd_cfg.port) {

		cfg->port      = cmd_cfg.port;

		cfg->port_prio = CFG_PRIO_CMD;

	}

	else if(file_cfg.port) {

		cfg->port      = file_cfg.port;

		cfg->port_prio = CFG_PRIO_CONFIG;

	}

	else {

		cfg->port      = DEFAULT_PORT;

		cfg->port_prio = CFG_PRIO_DEFAULT;

	}

	if(cmd_cfg.pid_file[0] != '\0') {

		strncpy(cfg->pid_file, cmd_cfg.pid_file, sizeof(cfg->pid_file));

		cfg->pid_file_prio = CFG_PRIO_CMD;

	}

	else if(file_cfg.pid_file[0] != '\0') {

		strncpy(cfg->pid_file, file_cfg.pid_file, sizeof(cfg->pid_file));

		cfg->pid_file_prio = CFG_PRIO_CONFIG;

	}

	else {

		cfg->pid_file_prio = CFG_PRIO_DEFAULT;

	}

	if(check_abs_path(cfg->config_file) != RESULT_OK) return RESULT_ERROR;

	strncpy(cfg->password, file_cfg.password, sizeof(cfg->password));

	cfg->password_prio = CFG_PRIO_CONFIG;

	cfg->debug_mode = cmd_cfg.debug_mode;

	return RESULT_OK;

}

static int reread_config(struct config *cfg, int *reinit_needed)

{

	int           res_config_file;

	struct config file_cfg;

	*reinit_needed = 0;

	res_config_file = parse_config_file(&file_cfg, cfg->config_file);

	if(res_config_file != RESULT_OK) return res_config_file;

	if(file_cfg.password[0] == '\0')

		return print_error("Password is not set", NULL);

	/* save parsed values to general config */

	if(cfg->interface_prio >= CFG_PRIO_CONFIG && cfg->interface.s_addr != file_cfg.interface.s_addr)

	{

		*reinit_needed      = 1;

		cfg->interface      = file_cfg.interface;

		cfg->interface_prio = CFG_PRIO_CONFIG;

	}

	if(cfg->port_prio >= CFG_PRIO_CONFIG && cfg->port != file_cfg.port && file_cfg.port) {

		*reinit_needed = 1;

		cfg->port      = file_cfg.port;

		cfg->port_prio = CFG_PRIO_CONFIG;

	}

	if(check_abs_path(cfg->config_file) != RESULT_OK) return RESULT_ERROR;

	strncpy(cfg->password, file_cfg.password, sizeof(cfg->password));

	cfg->password_prio = CFG_PRIO_CONFIG;

	return RESULT_OK;

}

static int parse_interface(const char *s, char **end, struct in_addr *ip)

{

	char       buf[MAX_CONFIG_LINE];

	int        count;

	const char *c;

	c     = s;

	count = 0;

	while(c[0] != '\0' && !isspace(c[0])) c++, count++;

	if(count > MAX_CONFIG_LINE) return RESULT_ERROR;

	strncpy(buf, s, count);

	buf[count] = '\0';

	c++;

	if(end) *end = (char *)c;

	if(inet_aton(buf, ip) == 1)

		return RESULT_OK;

	else

		return RESULT_ERROR;

}

static int parse_cmd_line(struct config *cfg, int argc, const char* argv[])

{

	char *end;

	int  i;

	long port;

	memset(cfg, 0, sizeof(struct config));

	for(i = 1; i < argc; i++) {

		if(0 == strcmp(argv[i], PARAM_INTERFACE)) {

			if(cfg->interface.s_addr)

				return print_cmd_error(argc, argv, "Interface is already set", NULL);

			if(++i < argc) {

				if(parse_interface(argv[i], (char **)NULL, &cfg->interface) != RESULT_OK)

					return print_cmd_error(argc, argv, 

						"Cannot parse interface", argv[i]);

			}

			else {

				return print_cmd_error(argc, argv, "Interface expected", NULL);

			}

		}

		else if(0 == strcmp(argv[i], PARAM_PORT)) {

			if(cfg->port)

				return print_cmd_error(argc, argv, "Port is already set", NULL);

			if(++i < argc) {

				port = strtol(argv[i], &end, 10);

				if(*end != '\0' || port < PORT_MIN || port > PORT_MAX)

					return print_cmd_error(argc, argv, 

						"Port number must be integer between 1 and 65535", NULL);

				cfg->port = (ushort)port;

			}

			else {

				return print_cmd_error(argc, argv, "Port number expected", NULL);

			}

		}

		else if(0 == strcmp(argv[i], PARAM_CONFIG)) {

			if(cfg->config_file[0] != '\0')

				return print_cmd_error(argc, argv, "Config file name is already set", NULL);

			if(++i < argc) {

				strncpy(cfg->config_file, argv[i], FILENAME_MAX);

				if(cfg->config_file[FILENAME_MAX - 1] != '\0')

					return print_cmd_error(argc, argv,

						"Config file name is too long", NULL);

			}

			else {

				return print_cmd_error(argc, argv, "Config file name expected", NULL);

			}

		}

		else if(0 == strcmp(argv[i], PARAM_PID_FILE)) {

			if(cfg->pid_file[0] != '\0')

				return print_cmd_error(argc, argv, "PID file name is already set", NULL);

			if(++i < argc) {

				strncpy(cfg->pid_file, argv[i], FILENAME_MAX);

				if(cfg->pid_file[FILENAME_MAX - 1] != '\0')

					return print_cmd_error(argc, argv,

						"PID file name is too long", NULL);

			}

			else {

				return print_cmd_error(argc, argv, "PID file name expected", NULL);

			}

		}

		else if(0 == strcmp(argv[i], PARAM_DEBUG)) {

			cfg->debug_mode = 1;

		}

		else if(0 == strcmp(argv[i], PARAM_VERSION)) {

			print_version();

			return RESULT_EXIT;

		}

		else if(0 == strcmp(argv[i], PARAM_HELP_1) || 0 == strcmp(argv[i], PARAM_HELP_2)) {

			pring_usage(argc, argv);

			return RESULT_EXIT;

		}

		else {

			return print_cmd_error(argc, argv, "Unknown parameter", argv[i]);

		}

	}

	return RESULT_OK;

}

static int validate_equal_sign(const char *config_name, const int count, const char *line,

	uint name_len, char **subline)

{

	const char *c;

	c = line + name_len - 1;

	if('=' != c[0] && !isspace(c[0]))

		return print_config_error(config_name, count, "Unknown config parameter", line);

	while(c[0] != '\0' && isspace(c[0])) c++;

	if('=' != c[0])

		return print_config_error(config_name, count, "Equal sign expected", NULL);

	c++;

	if(subline) *subline = (char *)c;

	return RESULT_OK;

}

static int validate_eol(const char *config_name, const int count, const char *line)

{

	while(line[0] != '\0' && isspace(line[0])) line++;

	if('\0' != line[0] && '#' != line[0])

		return print_config_error(config_name, count, "End of line expected", NULL);

	return RESULT_OK;

}

static int extract_string_value(const char *config_name, const int count, char **subline, int must_quot,

	char *string, uint len)

{

	uint cur_len;

	int  quot;

	while(*subline[0] != '\0' && isspace(*subline[0])) (*subline)++;

	if('"' == *subline[0]) {

		quot = 1;

		(*subline)++;

	}

	else {

		if(must_quot) {

			return print_config_error(config_name, count, "Open quot expected", NULL);

		}

		else {

			quot = 0;

			/* skip spaces if not quoted */

			while(*subline[0] != '\0' && isspace(*subline[0])) (*subline)++;

		}

	}

	cur_len = 0;

	while(*subline[0] != '\0')

	{

		if(cur_len >= len) return print_config_error(config_name, count, "Value too long", NULL);

		if(quot && *subline[0] == '"') break;

		if(!quot && isspace(*subline[0])) break;

		string[0] = *subline[0];

		string++;

		(*subline)++;

		cur_len++;

	}

	string[0] = '\0';

	if(quot) {

		if('"' != *subline[0])

			return print_config_error(config_name, count, "Close quot expected", NULL);

		(*subline)++;

	}

	return RESULT_OK;

}

static int parse_config_file(struct config *cfg, const char *config_name)

{

	FILE *config_file;

	char buf[MAX_CONFIG_LINE];

	char *line;

	char *subline;

	int  count;

	uint len;

	long port;

	int  res;

	memset(cfg, 0, sizeof(struct config));

	config_file = fopen(config_name, "r");

	if(!config_file)

		return print_error("Can not open config file", strerror(errno));

	count = 0;

	while(fgets(buf, sizeof(buf), config_file)) {

		count++;

		line = buf;

		/* skip end spaces */

		len = strlen(line);

		if(len == MAX_CONFIG_LINE-1)

			return print_config_error(config_name, count, "Line is too long", NULL);

		while(len && isspace(line[len-1])) --len;

		if(!len) continue;

		line[len] = '\0';

		/* skip begin spaces */

		while(line[0] != '\0' && isspace(line[0])) line++;

		if('#' == line[0]) { /* skip comment lines */

			continue;

		}

		else if(strncmp(line, CONFIG_INTERFACE, min(sizeof(CONFIG_INTERFACE) - 1, len)) == 0) {

			if((res = validate_equal_sign(config_name, count, line,

				sizeof(CONFIG_INTERFACE), &subline)) != RESULT_OK) return res;

			if(parse_interface(subline, &subline, &cfg->interface) != RESULT_OK)

				return print_config_error(config_name, count,

					"Cannot parse interface", NULL);

			if((res = validate_eol(config_name, count, subline)) != RESULT_OK) return res;

		}

		else if(strncmp(line, CONFIG_PORT, min(sizeof(CONFIG_PORT) - 1, len)) == 0) {

			if((res = validate_equal_sign(config_name, count, line, sizeof(CONFIG_PORT),

				&subline)) != RESULT_OK) return res;

			port = strtol(subline, &subline, 10);

			if(port < PORT_MIN || port > PORT_MAX)

				return print_config_error(config_name, count, 

					"Port number must be integer between 1 and 65535", NULL);

			if((res = validate_eol(config_name, count, subline)) != RESULT_OK) return res;

			cfg->port = (ushort)port;

		}

		else if(strncmp(line, CONFIG_PASSWORD, min(sizeof(CONFIG_PASSWORD) - 1, len)) == 0) {

			if((res = validate_equal_sign(config_name, count, line,

				sizeof(CONFIG_PASSWORD), &subline)) != RESULT_OK) return res;

			if((res = extract_string_value(config_name, count, &subline, 1,

				cfg->password, sizeof(cfg->password))) != RESULT_OK) return res;

			if((res = validate_eol(config_name, count, subline)) != RESULT_OK) return res;

		}

		else if(strncmp(line, CONFIG_PID_FILE, min(sizeof(CONFIG_PID_FILE) - 1, len)) == 0) {

			if((res = validate_equal_sign(config_name, count, line,

				sizeof(CONFIG_PID_FILE), &subline)) != RESULT_OK) return res;

			if((res = extract_string_value(config_name, count, &subline, 0,

				cfg->pid_file, sizeof(cfg->pid_file))) != RESULT_OK) return res;

			if((res = validate_eol(config_name, count, subline)) != RESULT_OK) return res;

		}

		else {

			return print_config_error(config_name, count, "Unknown config parameter", line);

		}

	}

	if(ferror(config_file)) {

		print_error("Config file reading failed", strerror(errno));

	}

	if(fclose(config_file) != 0)

		return print_error("Can not close config file", strerror(errno));

	return RESULT_OK;

}

static int save_pid(const char *pid_file, const pid_t pid)

{

	int  fd;

	FILE *file;

	if(!pid_file || pid_file[0] == '\0') return RESULT_OK;

	unlink(pid_file);

	fd = open(pid_file, O_WRONLY | O_CREAT | O_EXCL, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);

	if(fd < 0) {

		syslog(LOG_ERR, "Can open PID file %s for write: %s\n", pid_file, strerror(errno));

		return RESULT_ERROR;

	}

	file = fdopen(fd, "w");

	if(!file) {

		syslog(LOG_ERR, "Can open PID file %s for write: %s\n", pid_file, strerror(errno));

		return RESULT_ERROR;

	}

	if(fprintf(file, "%d\n", pid) < 0) {

		syslog(LOG_ERR, "Can write PID to file %s: %s\n", pid_file, strerror(errno));

		return RESULT_ERROR;

	}

	if(fclose(file) != 0) {

		syslog(LOG_ERR, "Can not close PID file %s: %s\n", pid_file, strerror(errno));

		return RESULT_UNEXPECTED;

	}

	return RESULT_OK;

}

static int create_child(int soc)

{

	pid_t child;

	child = fork();

	if(child == -1) {

		fprintf(stderr, "Cannot fork: %s\n", strerror(errno));

		return RESULT_UNEXPECTED; /* an unexpected error */

	}

	else if(child > 0) {

		if(close(soc) != 0) {

			fprintf(stderr, "Cannot close socket: %s\n", strerror(errno));

			return RESULT_UNEXPECTED; /* an unexpected error */

		}

		return RESULT_EXIT; /* we are the parent */

	}

	else {

		return RESULT_OK; /* we are the child */

	}

}

static int close_descr(int d)

{

	if(close(d) != 0) {

		syslog(LOG_ERR, "Cannot close descriptor %d: %s\n", d, strerror(errno));

		return RESULT_UNEXPECTED;

	}

	return RESULT_OK;

}

static void delete_pid_file(void)

{

	if(global_cfg.pid_file && global_cfg.pid_file[0] != '\0') {

		if(unlink(global_cfg.pid_file) != 0) {

			syslog(LOG_ERR, "Cannot delete PID file %s: %s\n",

				global_cfg.pid_file, strerror(errno));

		}

	}

}

static void reconfig_signal(void)

{

	syslog(LOG_INFO, "reconfig");

	reconfig_required = 1;

}

static void quit_signal(void)

{

	syslog(LOG_WARNING, "quit");

	quit_required = 1;

}

static void signal_handler(int sig)

{

	int saved_errno = errno;

	switch(sig) {

		case SIGHUP:

			reconfig_signal();

			break;

		case SIGINT:

		case SIGTERM:

		case SIGQUIT:

			quit_signal();

			break;

	}

	errno = saved_errno;

}

static int init_signal_handler(int sig)

{

	struct sigaction sa;

	sa.sa_flags   = 0;

	sa.sa_handler = signal_handler;

	sigemptyset(&sa.sa_mask);

	if(sigaction(sig, &sa, (struct sigaction *)NULL) != 0) {

		syslog(LOG_ERR, "Cannot register handler for signal %d: %s\n", sig, strerror(errno));

		return RESULT_UNEXPECTED;

	}

	return RESULT_OK;

}

static int init_signals(void)

{

	if(init_signal_handler(SIGHUP)  != RESULT_OK) return RESULT_UNEXPECTED;

	if(init_signal_handler(SIGINT)  != RESULT_OK) return RESULT_UNEXPECTED;

	if(init_signal_handler(SIGTERM) != RESULT_OK) return RESULT_UNEXPECTED;

	if(init_signal_handler(SIGQUIT) != RESULT_OK) return RESULT_UNEXPECTED;

	return RESULT_OK;

}

static void check_return(int res)

{

	if(daemonized && res != RESULT_OK) {

		delete_pid_file();

		syslog(LOG_WARNING, "quit");

	}

	switch(res) {

		case RESULT_EXIT:       exit(EXIT_OK);         return;  /* no error but exit */

		case RESULT_ERROR:      exit(EXIT_USER_ERROR); return;  /* user error */

		case RESULT_UNEXPECTED: exit(EXIT_UNEXPECTED); return;  /* unexpected error */

	}

}

int main(int argc, const char* argv[])

{

	int soc;

	int reinit_needed;

	/* get config */

	check_return(read_config(&global_cfg, argc, argv));

	/* try to listen the port */

	if((soc = establish(&global_cfg)) < 0) {

		fprintf(stderr, "Cannot listen to port %i\n", global_cfg.port);

		return EXIT_USER_ERROR;

	}

	/* fork and release the console */

	check_return(create_child(soc));

	/* continue as first child */

	if(setsid() == -1) {

		fprintf(stderr, "Cannot create session: %s\n", strerror(errno));

		return EXIT_UNEXPECTED;

	}

	/* fork the second time */

	check_return(create_child(soc));

	/* continue as final child */

	if(init_signals() != RESULT_OK) return EXIT_UNEXPECTED;

	if(chdir("/") < 0) {

		fprintf(stderr, "Cannot chdir to /: %s\n", strerror(errno));

		return EXIT_UNEXPECTED;

	}

	umask(0);

	check_return(save_pid(global_cfg.pid_file, getpid()));

	daemonized = 1;

	/* from now do not use console for error output */

	if(close_descr(0) != RESULT_OK) return EXIT_UNEXPECTED;

	if(close_descr(1) != RESULT_OK) return EXIT_UNEXPECTED;

	if(close_descr(2) != RESULT_OK) return EXIT_UNEXPECTED;

	for(;;) {

		syslog(LOG_INFO, "listen on %d", global_cfg.port);

		listen_socket(&global_cfg, soc);

		if(quit_required) {

			break;

		}

		else if(reconfig_required) {

			reconfig_required = 0;

			check_return(reread_config(&global_cfg, &reinit_needed));

			if(reinit_needed) {

				close(soc);

				if((soc = establish(&global_cfg)) < 0) {

					syslog(LOG_ERR, "Cannot listen to port %i\n", global_cfg.port);

					check_return(RESULT_ERROR);

				}

			}

		}

	}

	delete_pid_file();

	return EXIT_OK;

}