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 <errno.h>

#include <syslog.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/stat.h>

#include <sys/reboot.h>

#include "common.h"

#include "rebootd.h"

#include "config.h"

#include "signals.h"

#include "network.h"

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

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

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

void handle_command(const struct config *cfg, const char *cmd, const int cmd_len)		

{

	if(0 != strncmp(cmd, cfg->password, cmd_len)) return; /* wrong password */

	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 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(const char *pid_file)

{

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

		if(unlink(pid_file) != 0) {

			syslog(LOG_ERR, "Cannot delete PID file %s: %s\n", pid_file, strerror(errno));

		}

	}

}

static void check_return(int res, const struct config *cfg)

{

	if(daemonized && res != RESULT_OK) {

		delete_pid_file(cfg->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;

	struct config cfg;

	/* get config */

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

	/* try to listen the port */

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

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

		return EXIT_USER_ERROR;

	}

	/* fork and release the console */

	check_return(create_child(soc), &cfg);

	/* 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), &cfg);

	/* 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(cfg.pid_file, getpid()), &cfg);

	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", cfg.port);

		listen_socket(&cfg, soc);

		if(quit_required) {

			break;

		}

		else if(reconfig_required) {

			reconfig_required = 0;

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

			if(reinit_needed) {

				close(soc);

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

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

					check_return(RESULT_ERROR, &cfg);

				}

			}

		}

	}

	delete_pid_file(cfg.pid_file);

	return EXIT_OK;

}