Subversion Repositories general

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

 * rebootd.

 *

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

 * (password) and reboots the computer.

 *

 * Command line: rebootd [--version] [--help] [--interface IP] [--port PORT] [--config CONFIG_FILE]

 * Defaults are port 19 and config /etc/rebootd.conf.

 *

 * Config file looks like:

 * --------------------------

 * interface=192.168.0.1

 * port=19

 * password="some password"

 * --------------------------

 *

 * Usage example (from any other host):

 * echo -n "some password" | nc host_to_rebot 19

 *

 * 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 <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 VERSION           "1.0"

#define REVISION          "$Rev: 1164 $"

#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_1   "-v"

#define PARAM_VERSION_2   "--version"

#define PARAM_INTERFACE_1 "-i"

#define PARAM_INTERFACE_2 "--interface"

#define PARAM_PORT_1      "-p"

#define PARAM_PORT_2      "--port"

#define PARAM_CONFIG_1    "-c"

#define PARAM_CONFIG_2    "--config"

#define CONFIG_INTERFACE  "interface"

#define CONFIG_PORT       "port"

#define CONFIG_PASSWORD   "password"

struct config {

	char           config_file[FILENAME_MAX];

	struct in_addr interface;

	ushort         port;

	char           password[MAX_CONFIG_LINE];

};

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 int get_revision(void);

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_STREAM, 0)) < 0)

		return -1;

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

		close(s);

		return -1;

	}

	if(listen(s, 1) != 0) {

		close(s);

		return -1;

	}

	return s;

}

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

{

	int                t;

	char               cmd[CMDSIZE];

	char               buf[BUFSIZE];

	int                br;

	struct sockaddr_in sa;

	socklen_t          sa_len;

	int                cmdlen;

	for(;;) {

		sa_len = sizeof(sa);

		if((t = accept(soc, (struct sockaddr *)&sa, &sa_len)) < 0) {

			if(errno == EINTR) /* EINTR might happen on accept(), */

				continue;        /* try again */

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

			continue;

		}

		syslog(LOG_INFO, "connect from %s", inet_ntoa(sa.sin_addr));

		cmd[0] = '\0';

		cmdlen = 0;

		while((br = recv(t, buf, BUFSIZE, 0)) > 0) {

			strncat(cmd, buf, min((uint)br, sizeof(cmd) - cmdlen - 1));

			cmdlen += min((uint)br, sizeof(cmd) - cmdlen - 1);

		}

		sleep(1);

		close(t);

		syslog(LOG_INFO, "got command");

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

			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.%d\n", APP_NAME, VERSION, get_revision());

}

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

{

	print_version();

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

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

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

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

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

	printf("Defaults are port 19 and config /etc/rebootd.conf.\n\n");

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

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

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

}

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)

{

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

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

	fprintf(stderr, "\n");

	return RESULT_ERROR;

}

/* return: 0 - no error, continue; 1 - no error, but exit; 2 - user error, exit; 3 - unexpected error, exit */

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;

	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') {

		fprintf(stderr, "Password is not set\n");

		return RESULT_ERROR;

	}

	/* save parsed values to general config */

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

	if(cmd_cfg.interface.s_addr)

		cfg->interface = cmd_cfg.interface;

	else if(file_cfg.interface.s_addr)

		cfg->interface = file_cfg.interface;

	if(cmd_cfg.port > 0)

		cfg->port = cmd_cfg.port;

	else if(file_cfg.port > 0)

		cfg->port = file_cfg.port;

	else

		cfg->port = DEFAULT_PORT;

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

	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_1) || 0 == strcmp(argv[i], PARAM_INTERFACE_2)) {

			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_1) || 0 == strcmp(argv[i], PARAM_PORT_2)) {

			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_1) || 0 == strcmp(argv[i], PARAM_CONFIG_2)) {

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

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

			if(++i < argc) {

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

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

					return print_cmd_error(argc, argv,

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

			}

			else {

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

			}

		}

		else if(0 == strcmp(argv[i], PARAM_VERSION_1) || 0 == strcmp(argv[i], PARAM_VERSION_2)) {

			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_quoted(const char *config_name, const int count, char **subline, char *string, uint len)

{

	uint cur_len;

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

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

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

	(*subline)++;

	cur_len = 0;

	while(cur_len < len && *subline[0] != '\0' && *subline[0] != '"')

	{

		string[0] = *subline[0];

		string++;

		(*subline)++;

		cur_len++;

	}

	string[0] = '\0';

	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) {

		fprintf(stderr, "Can not open config file %s: %s\n", config_name, strerror(errno));

		return RESULT_ERROR;

	}

	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_quoted(config_name, count, &subline,

				cfg->password, sizeof(cfg->password))) != 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)) {

		fprintf(stderr, "Config file %s reading failed\n", config_name);

	}

	if(fclose(config_file) != 0) {

		fprintf(stderr, "Can not close config file %s: %s\n", config_name, strerror(errno));

		return RESULT_UNEXPECTED;

	}

	return RESULT_OK;

}

static int get_revision(void)

{

	int        r;

	const char *begin;

	begin = REVISION;

	while(begin[0] != '\0' && begin[0] != ':') begin++;

	if(begin[0] == '\0') return 0;

	begin++;

	r = (int)strtol(begin, (char**)NULL, 10);

	return r;

}

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;

}

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

{

	int           soc;

	struct config cfg;

	/* get config */

	switch(read_config(&cfg, argc, argv)) {

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

		case RESULT_ERROR:      return EXIT_USER_ERROR;   /* user error */

		case RESULT_UNEXPECTED: return EXIT_UNEXPECTED;   /* unexpected error */

	}

	/* 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 */

	switch(create_child(soc)) {

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

		case RESULT_ERROR:      return EXIT_USER_ERROR;   /* user error */

		case RESULT_UNEXPECTED: return EXIT_UNEXPECTED;   /* unexpected error */

	}

	/* continue as first child */

	if(setsid() == -1) {

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

		return EXIT_UNEXPECTED;

	}

	/* fork the second time */

	switch(create_child(soc)) {

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

		case RESULT_ERROR:      return EXIT_USER_ERROR;   /* user error */

		case RESULT_UNEXPECTED: return EXIT_UNEXPECTED;   /* unexpected error */

	}

	/* continue as final child, from now do not use console for error output */

	chdir("/");

	umask(0);

	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;

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

	listen_socket(&cfg, soc);

	return EXIT_OK; /* unreachedable */

}