| 0,0 → 1,829 |
|---|
| /****************************************************************** |
| * 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; |
| } |
| |
| Property changes: |
|---|
| Added: svn:keywords |
|---|
| +Rev |
|---|
| \ No newline at end of property |
|---|