X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;ds=sidebyside;f=server.c;h=a4115eb65734391128481f6fa421d548aba78e20;hb=e2167286448ce2ed9a01a548e7e9832563035088;hp=e39354e769ec04dc629c63f0bd590df30893dc8d;hpb=77264e47dcd6a606ecff2f86f14359f25ab0eba0;p=paraslash.git diff --git a/server.c b/server.c index e39354e7..f19fc996 100644 --- a/server.c +++ b/server.c @@ -1,556 +1,707 @@ -/* - * Copyright (C) 1997-2007 Andre Noll - * - * Licensed under the GPL v2. For licencing details see COPYING. - */ - -/** \file server.c Paraslash's main server */ +/* Copyright (C) 1997 Andre Noll , see file COPYING. */ +/** \file server.c Paraslash's main server. */ -/** \mainpage Paraslash API Reference - * - * Good starting points for reading are probably \ref audio_file_selector, - * \ref sender, \ref receiver, \ref receiver_node, \ref filter, \ref - * filter_node. +/** + * \mainpage Main data structures and selected APIs: * + * - Senders: \ref sender, + * - Audio file selector: \ref afs_info, \ref afs_table, + * - Audio format handler: \ref audio_format_handler, \ref afh_info + * - Receivers/filters/writers: \ref receiver, \ref receiver_node, + * \ref filter, \ref filter_node, \ref writer_node, \ref writer. + * - Scheduling: \ref sched.h, + * - Buffer trees: \ref buffer_tree.h, + * - Sideband API: \ref sideband.h, + * - Crypto: \ref crypt.h, \ref crypt_backend.h, + * - Error subsystem: \ref error.h, + * - Inter process communication: \ref ipc.h, + * - Forward error correction: \ref fec.h, + * - Daemons: \ref daemon.h, + * - Mixer API: \ref mix.h, + * - Interactive sessions: \ref interactive.h, + * - File descriptors: \ref fd.h, + * - Signals: \ref signal.h, + * - Networking: \ref net.h, + * - Time: \ref time.c, + * - Doubly linked lists: \ref list.h. */ - - -#include "server.cmdline.h" -#include "afs_common.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "server.lsg.h" +#include "para.h" +#include "error.h" +#include "crypt.h" +#include "afh.h" +#include "string.h" +#include "afs.h" +#include "net.h" #include "server.h" +#include "list.h" +#include "send.h" +#include "sched.h" #include "vss.h" #include "config.h" #include "close_on_fork.h" -#include "send.h" -#include "error.h" -#include "net.h" #include "daemon.h" -#include "string.h" #include "ipc.h" #include "fd.h" #include "signal.h" #include "user_list.h" +#include "color.h" +#include "version.h" -/** define the array of error lists needed by para_server */ -INIT_SERVER_ERRLISTS; +/** Array of error strings. */ +DEFINE_PARA_ERRLIST; -/** shut down non-authorized connections after that many seconds */ +__printf_2_3 void (*para_log)(int, const char*, ...) = daemon_log; + +/** Shut down non-authorized connections after that many seconds. */ #define ALARM_TIMEOUT 10 /** - * pointer to shared memory area for communication between para_server - * and its children. exported to vss.c. command.c and to all selectors. + * Pointer to shared memory area for communication between para_server + * and its children. Exported to vss.c, command.c and to afs. */ struct misc_meta_data *mmd; /** - * the configuration of para_server + * The active value for all config options of para_server. * - * It also contains the options for all audio file selectors, audio format handler - * and all supported senders. + * It is computed by merging the parse result of the command line options with + * the parse result of the config file. */ -struct server_args_info conf; - -/** the file containing user information (public key, permissions) */ -char *user_list_file = NULL; - -extern void dccp_send_init(struct sender *); -extern void http_send_init(struct sender *); -extern void ortp_send_init(struct sender *); - -/* TODO: This is better handled by autoconf */ -/** the list of supported audio file selectors */ -struct audio_file_selector selectors[] = { - { - .name = "random", - .init = random_selector_init, - .update_audio_file = NULL, - }, - { - .name = "playlist", - .init = playlist_selector_init, - .update_audio_file = NULL, - .pre_select = NULL, - .post_select = NULL, - }, -#ifdef HAVE_MYSQL - { - .name = "mysql", - .init = mysql_selector_init, - .update_audio_file = NULL, - .pre_select = NULL, - .post_select = NULL, - }, -#endif - { - .name = NULL, - } -}; +struct lls_parse_result *server_lpr = NULL; -/** the list of supported senders */ -struct sender senders[] = { - { - .name = "http", - .init = http_send_init, - }, - { - .name = "dccp", - .init = dccp_send_init, - }, -#ifdef HAVE_ORTP - { - .name = "ortp", - .init = ortp_send_init, - }, -#endif - { - .name = NULL, - } -}; +/* Command line options (no config file options). Used in handle_sighup(). */ +static struct lls_parse_result *cmdline_lpr; + +/** + * A random number used to "authenticate" the afs connection. + * + * para_server picks this number by random before it forks the afs process. The + * command handlers know this number as well and write it to the afs socket, + * together with the id of the shared memory area which contains the payload of + * the afs command. A local process has to know this number to abuse the afs + * service provided by the local socket. + */ +uint32_t afs_socket_cookie; +/** The mutex protecting the shared memory area containing the mmd struct. */ +int mmd_mutex; -/* global variables for server-internal use */ -static FILE *logfile; -static int mmd_mutex, mmd_shm_id; -static int signal_pipe; +/* Serializes log output. */ +static int log_mutex; + +static struct sched sched; +static struct signal_task *signal_task; + +/** The process id of the audio file selector process. */ +pid_t afs_pid = 0; + +/* The the main server process (parent of afs and the command handlers). */ +static pid_t server_pid; /** - * para_server's log function + * Tell whether the executing process is a command handler. * - * \param ll the log level - * \param fmt the format string describing the log message + * Cleanup on exit must be performed differently for command handlers. + * + * \return True if the pid of the executing process is neither the server pid + * nor the afs pid. */ -void para_log(int ll, const char* fmt,...) +bool process_is_command_handler(void) { - va_list argp; - FILE *outfd; - struct tm *tm; - time_t t1; - char str[MAXLINE] = ""; - pid_t mypid; - - if (ll < conf.loglevel_arg) - return; - outfd = logfile? logfile : stderr; - time(&t1); - tm = localtime(&t1); - strftime(str, MAXLINE, "%b %d %H:%M:%S", tm); - fprintf(outfd, "%s ", str); - if (conf.loglevel_arg <= INFO) - fprintf(outfd, "%i: ", ll); - mypid = getpid(); - if (conf.loglevel_arg <= INFO) - fprintf(outfd, "(%d) ", mypid); - va_start(argp, fmt); - vfprintf(outfd, fmt, argp); - va_end(argp); + pid_t pid = getpid(); + + return pid != afs_pid && pid != server_pid; } -/* - * setup shared memory area and get mutex for locking +/** The task responsible for server command handling. */ +struct server_command_task { + /** TCP port on which para_server listens for connections. */ + int listen_fd; + /* File descriptor for the accepted socket. */ + int child_fd; + /** Copied from para_server's main function. */ + int argc; + /** Argument vector passed to para_server's main function. */ + char **argv; + /** The command task structure for scheduling. */ + struct task *task; +}; + +/** + * Return the list of tasks for the server process. + * + * This is called from \a com_tasks(). The helper is necessary since command + * handlers can not access the scheduler structure directly. + * + * \return A dynamically allocated string that must be freed by the caller. */ -static void shm_init(void) +char *server_get_tasks(void) +{ + return get_task_list(&sched); +} + +static void pre_log_hook(void) +{ + mutex_lock(log_mutex); +} + +static void post_log_hook(void) +{ + mutex_unlock(log_mutex); +} + +/* Setup shared memory area and init mutexes */ +static void init_ipc_or_die(void) { void *shm; - int ret = shm_new(sizeof(struct misc_meta_data)); + int shmid, ret = shm_new(sizeof(struct misc_meta_data)); if (ret < 0) goto err_out; - - ret = shm_attach(ret, ATTACH_RW, &shm); + shmid = ret; + ret = shm_attach(shmid, ATTACH_RW, &shm); + shm_destroy(shmid); if (ret < 0) goto err_out; mmd = shm; - mmd_shm_id = ret; ret = mutex_new(); if (ret < 0) goto err_out; mmd_mutex = ret; + ret = mutex_new(); + if (ret < 0) + goto destroy_mmd_mutex; + log_mutex = ret; - mmd->selector_num = 0; mmd->num_played = 0; mmd->num_commands = 0; mmd->events = 0; mmd->num_connects = 0; mmd->active_connections = 0; - strcpy(mmd->filename, "(none)"); - mmd->audio_format = -1; mmd->vss_status_flags = VSS_NEXT; mmd->new_vss_status_flags = VSS_NEXT; - mmd->sender_cmd_data.cmd_num = -1; return; +destroy_mmd_mutex: + mutex_destroy(mmd_mutex); err_out: - PARA_EMERG_LOG("%s", PARA_STRERROR(-ret)); + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); exit(EXIT_FAILURE); } /** - * lock the shared memory area containing the mmd struct + * (Re-)read the server configuration files. * - * \sa semop(2), struct misc_meta_data - */ -void mmd_lock(void) -{ - mutex_lock(mmd_mutex); -} - -/** - * unlock the shared memory area containing the mmd struct + * \param reload Whether config file overrides command line. * - * \sa semop(2), struct misc_meta_data + * This function also re-opens the logfile and the user list. On SIGHUP it is + * called from both server and afs context. */ - -void mmd_unlock(void) +void parse_config_or_die(bool reload) { - mutex_unlock(mmd_mutex); -} - -static void parse_config(int override) -{ - char *home = para_homedir(); - struct stat statbuf; int ret; - char *cf; + char *cf = NULL, *errctx = NULL, *user_list_file = NULL; + void *map; + size_t sz; + int cf_argc; + char **cf_argv; + struct lls_parse_result *cf_lpr, *merged_lpr; + char *home = para_homedir(); - if (conf.config_file_given) - cf = conf.config_file_arg; + if (OPT_GIVEN(CONFIG_FILE)) + cf = para_strdup(OPT_STRING_VAL(CONFIG_FILE)); else cf = make_message("%s/.paraslash/server.conf", home); - free(user_list_file); - if (!conf.user_list_given) - user_list_file = make_message("%s/.paraslash/server.users", home); - else - user_list_file = para_strdup(conf.user_list_arg); - ret = stat(cf, &statbuf); - if (ret && conf.config_file_given) { - ret = -1; - PARA_EMERG_LOG("can not stat config file %s\n", cf); - goto out; + if (!mmd || getpid() != afs_pid) { + if (OPT_GIVEN(USER_LIST)) + user_list_file = para_strdup(OPT_STRING_VAL(USER_LIST)); + else + user_list_file = make_message("%s/.paraslash/server.users", home); } - if (!ret) { - int tmp = conf.daemon_given; - struct server_cmdline_parser_params params = { - .override = override, - .initialize = 0, - .check_required = 0, - .check_ambiguity = 0 - }; - server_cmdline_parser_config_file(cf, &conf, ¶ms); - conf.daemon_given = tmp; + free(home); + ret = mmap_full_file(cf, O_RDONLY, &map, &sz, NULL); + if (ret < 0) { + if (ret != -E_EMPTY && ret != -ERRNO_TO_PARA_ERROR(ENOENT)) + goto free_cf; + if (ret == -ERRNO_TO_PARA_ERROR(ENOENT) && OPT_GIVEN(CONFIG_FILE)) + goto free_cf; + server_lpr = cmdline_lpr; + goto success; } - /* logfile */ - if (!conf.logfile_given && conf.daemon_given) { - ret = -1; - PARA_EMERG_LOG("%s", "daemon, but no log file\n"); - goto out; + ret = lls(lls_convert_config(map, sz, NULL, &cf_argv, &errctx)); + para_munmap(map, sz); + if (ret < 0) + goto free_cf; + cf_argc = ret; + ret = lls(lls_parse(cf_argc, cf_argv, CMD_PTR, &cf_lpr, &errctx)); + lls_free_argv(cf_argv); + if (ret < 0) + goto free_cf; + if (reload) /* config file overrides command line */ + ret = lls(lls_merge(cf_lpr, cmdline_lpr, CMD_PTR, &merged_lpr, + &errctx)); + else /* command line options override config file options */ + ret = lls(lls_merge(cmdline_lpr, cf_lpr, CMD_PTR, &merged_lpr, + &errctx)); + lls_free_parse_result(cf_lpr, CMD_PTR); + if (ret < 0) + goto free_cf; + if (server_lpr != cmdline_lpr) + lls_free_parse_result(server_lpr, CMD_PTR); + server_lpr = merged_lpr; +success: + daemon_set_loglevel(ENUM_STRING_VAL(LOGLEVEL)); + if (OPT_GIVEN(LOGFILE)) { + daemon_set_logfile(OPT_STRING_VAL(LOGFILE)); + daemon_open_log_or_die(); + } + if (daemon_init_colors_or_die(OPT_UINT32_VAL(COLOR), COLOR_AUTO, + COLOR_NO, OPT_GIVEN(LOGFILE))) { + int i; + for (i = 0; i < OPT_GIVEN(LOG_COLOR); i++) + daemon_set_log_color_or_die(lls_string_val(i, + OPT_RESULT(LOG_COLOR))); } - if (conf.logfile_given) - logfile = open_log(conf.logfile_arg); + daemon_set_flag(DF_LOG_PID); + daemon_set_flag(DF_LOG_LL); + daemon_set_flag(DF_LOG_TIME); + if (OPT_GIVEN(LOG_TIMING)) + daemon_set_flag(DF_LOG_TIMING); + daemon_set_priority(OPT_UINT32_VAL(PRIORITY)); + if (user_list_file) + user_list_init(user_list_file); ret = 1; -out: +free_cf: free(cf); - free(home); - if (ret > 0) - return; free(user_list_file); - user_list_file = NULL; - exit(EXIT_FAILURE); + if (ret < 0) { + if (errctx) + PARA_ERROR_LOG("%s\n", errctx); + free(errctx); + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); + exit(EXIT_FAILURE); + } } -static void setup_signal_handling(void) +/* + * called when server gets SIGHUP or when client invokes hup command. + */ +static void handle_sighup(void) { - int ret = 0; - - signal_pipe = para_signal_init(); - PARA_NOTICE_LOG("%s", "setting up signal handlers\n"); - ret += para_install_sighandler(SIGINT); - ret += para_install_sighandler(SIGTERM); - ret += para_install_sighandler(SIGHUP); - ret += para_install_sighandler(SIGCHLD); - ret += para_install_sighandler(SIGUSR1); - signal(SIGPIPE, SIG_IGN); - if (ret != 5) { - PARA_EMERG_LOG("%s", "could not install signal handlers\n"); - exit(EXIT_FAILURE); - } + + PARA_NOTICE_LOG("SIGHUP\n"); + parse_config_or_die(true); + if (afs_pid != 0) + kill(afs_pid, SIGHUP); } -static void init_selector(void) +static int signal_post_select(struct sched *s, __a_unused void *context) { - int i, ret; - - mmd->selector_change = -1; /* no change nec., set to new num by com_chs */ - if (!conf.selector_given) - goto random; - for (i = 0; selectors[i].name; i++) { - if (strcmp(selectors[i].name, conf.selector_arg)) - continue; - PARA_NOTICE_LOG("initializing %s audio file selector\n", - selectors[i].name); - ret = selectors[i].init(&selectors[i]); - if (ret < 0) { - PARA_WARNING_LOG("%s", PARA_STRERROR(-ret)); - break; + int ret, signum; + + ret = task_get_notification(signal_task->task); + if (ret < 0) + return ret; + signum = para_next_signal(&s->rfds); + switch (signum) { + case 0: + return 0; + case SIGHUP: + handle_sighup(); + break; + case SIGCHLD: + for (;;) { + pid_t pid; + ret = para_reap_child(&pid); + if (ret <= 0) + break; + if (pid != afs_pid) + continue; + PARA_EMERG_LOG("fatal: afs died\n"); + kill(0, SIGTERM); + goto cleanup; } - mmd->selector_num = i; - return; + break; + /* die on sigint/sigterm. Kill all children too. */ + case SIGINT: + case SIGTERM: + PARA_EMERG_LOG("terminating on signal %d\n", signum); + kill(0, SIGTERM); + /* + * We must wait for all of our children to die. For the afs + * process or a command handler might want to use the + * shared memory area and the mmd mutex. If we destroy this + * mutex too early and afs tries to lock the shared memory + * area, the call to mutex_lock() will fail and terminate the + * afs process. This leads to dirty osl tables. + */ + PARA_INFO_LOG("waiting for child processes to die\n"); + mutex_unlock(mmd_mutex); + while (wait(NULL) != -1 || errno != ECHILD) + ; /* still at least one child alive */ + mutex_lock(mmd_mutex); +cleanup: + free(mmd->afd.afhi.chunk_table); + task_notify_all(s, E_DEADLY_SIGNAL); + return -E_DEADLY_SIGNAL; } - PARA_WARNING_LOG("%s", "falling back to the random selector\n"); -random: - mmd->selector_num = 0; - selectors[0].init(&selectors[0]); /* always successful */ + return 0; } -static unsigned init_network(void) +static void init_signal_task(void) { - int fd, ret = init_tcp_socket(conf.port_arg); + signal_task = signal_init_or_die(); + para_install_sighandler(SIGINT); + para_install_sighandler(SIGTERM); + para_install_sighandler(SIGHUP); + para_install_sighandler(SIGCHLD); + para_sigaction(SIGPIPE, SIG_IGN); + add_close_on_fork_list(signal_task->fd); + signal_task->task = task_register(&(struct task_info) { + .name = "signal", + .pre_select = signal_pre_select, + .post_select = signal_post_select, + .context = signal_task, + + }, &sched); +} - if (ret < 0) - goto err; - fd = ret; - ret = mark_fd_nonblock(fd); - if (ret < 0) - goto err; - return fd; -err: - PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret)); - exit(EXIT_FAILURE); +static void command_pre_select(struct sched *s, void *context) +{ + struct server_command_task *sct = context; + para_fd_set(sct->listen_fd, &s->rfds, &s->max_fileno); } -static void init_random_seed(void) +static int command_post_select(struct sched *s, void *context) { - int fd, ret = -1; - unsigned int seed; - size_t len = sizeof(unsigned int); + struct server_command_task *sct = context; + int new_fd, ret, i; + char *peer_name; + pid_t child_pid; + uint32_t *chunk_table; - fd = open("/dev/urandom", O_RDONLY); - if (fd < 0) + ret = task_get_notification(sct->task); + if (ret < 0) + return ret; + ret = para_accept(sct->listen_fd, &s->rfds, NULL, 0, &new_fd); + if (ret <= 0) goto out; - ret = -2; - if (read(fd, &seed, len) != len) + mmd->num_connects++; + mmd->active_connections++; + /* + * The chunk table is a pointer located in the mmd struct that points + * to dynamically allocated memory, i.e. it must be freed by the parent + * and the child. However, as the mmd struct is in a shared memory + * area, there's no guarantee that after the fork this pointer is still + * valid in child context. As it is not used in the child anyway, we + * save it to a local variable before the fork and free the memory via + * that copy in the child directly after the fork. + */ + chunk_table = mmd->afd.afhi.chunk_table; + child_pid = fork(); + if (child_pid < 0) { + ret = -ERRNO_TO_PARA_ERROR(errno); goto out; - srandom(seed); - ret = 1; + } + if (child_pid) { + /* avoid problems with non-fork-safe PRNGs */ + unsigned char buf[16]; + get_random_bytes_or_die(buf, sizeof(buf)); + close(new_fd); + /* parent keeps accepting connections */ + return 0; + } + peer_name = remote_name(new_fd); + PARA_INFO_LOG("accepted connection from %s\n", peer_name); + /* mmd might already have changed at this point */ + free(chunk_table); + sct->child_fd = new_fd; + /* + * put info on who we are serving into argv[0] to make + * client ip visible in top/ps + */ + for (i = sct->argc - 1; i >= 0; i--) + memset(sct->argv[i], 0, strlen(sct->argv[i])); + i = sct->argc - 1 - lls_num_inputs(cmdline_lpr); + sprintf(sct->argv[i], "para_server (serving %s)", peer_name); + /* ask other tasks to terminate */ + task_notify_all(s, E_CHILD_CONTEXT); + /* + * After we return, the scheduler calls server_select() with a minimal + * timeout value, because the remaining tasks have a notification + * pending. Next it calls the ->post_select method of these tasks, + * which will return negative in view of the notification. This causes + * schedule() to return as there are no more runnable tasks. + * + * Note that semaphores are not inherited across a fork(), so we don't + * hold the lock at this point. Since server_select() drops the lock + * prior to calling para_select(), we need to acquire it here. + */ + mutex_lock(mmd_mutex); + return -E_CHILD_CONTEXT; out: - if (fd >= 0) - close(fd); - if (ret > 0) - return; - PARA_EMERG_LOG("can not seed pseudo random generator (ret = %d)\n", - ret); + if (ret < 0) + PARA_CRIT_LOG("%s\n", para_strerror(-ret)); + return 0; +} + +static void init_server_command_task(struct server_command_task *sct, + int argc, char **argv) +{ + int ret; + + PARA_NOTICE_LOG("initializing tcp command socket\n"); + sct->child_fd = -1; + sct->argc = argc; + sct->argv = argv; + ret = para_listen_simple(IPPROTO_TCP, OPT_UINT32_VAL(PORT)); + if (ret < 0) + goto err; + sct->listen_fd = ret; + ret = mark_fd_nonblocking(sct->listen_fd); + if (ret < 0) + goto err; + add_close_on_fork_list(sct->listen_fd); /* child doesn't need the listener */ + sct->task = task_register(&(struct task_info) { + .name = "server command", + .pre_select = command_pre_select, + .post_select = command_post_select, + .context = sct, + }, &sched); + return; +err: + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); exit(EXIT_FAILURE); } -static unsigned do_inits(int argc, char **argv) +static int init_afs(int argc, char **argv) { - /* connector's address information */ - int sockfd; + int ret, afs_server_socket[2]; + char c; - init_random_seed(); - /* parse command line options */ - server_cmdline_parser(argc, argv, &conf); - HANDLE_VERSION_FLAG("server", conf); - para_drop_privileges(conf.user_arg, conf.group_arg); - /* parse config file, open log and set defaults */ - parse_config(0); - log_welcome("para_server", conf.loglevel_arg); - shm_init(); /* init mmd struct */ - server_uptime(UPTIME_SET); /* reset server uptime */ - init_user_list(user_list_file); - /* become daemon */ - if (conf.daemon_given) - daemon_init(); - init_selector(); -// PARA_ERROR_LOG("num: %d\n", mmd->selector_num); - PARA_NOTICE_LOG("%s", "initializing virtual streaming system\n"); - vss_init(); - mmd->server_pid = getpid(); - setup_signal_handling(); - mmd_lock(); - /* init network socket */ - PARA_NOTICE_LOG("%s", "initializing tcp command socket\n"); - sockfd = init_network(); - PARA_NOTICE_LOG("%s", "init complete\n"); - return sockfd; + ret = socketpair(PF_UNIX, SOCK_STREAM, 0, afs_server_socket); + if (ret < 0) + exit(EXIT_FAILURE); + get_random_bytes_or_die((unsigned char *)&afs_socket_cookie, + sizeof(afs_socket_cookie)); + afs_pid = fork(); + if (afs_pid < 0) + exit(EXIT_FAILURE); + if (afs_pid == 0) { /* child (afs) */ + int i; + + afs_pid = getpid(); + crypt_shutdown(); + user_list_deplete(); + for (i = argc - 1; i >= 0; i--) + memset(argv[i], 0, strlen(argv[i])); + i = argc - lls_num_inputs(cmdline_lpr) - 1; + sprintf(argv[i], "para_server (afs)"); + close(afs_server_socket[0]); + afs_init(afs_server_socket[1]); + } + close(afs_server_socket[1]); + if (read(afs_server_socket[0], &c, 1) <= 0) { + PARA_EMERG_LOG("early afs exit\n"); + exit(EXIT_FAILURE); + } + ret = mark_fd_nonblocking(afs_server_socket[0]); + if (ret < 0) + exit(EXIT_FAILURE); + add_close_on_fork_list(afs_server_socket[0]); + PARA_INFO_LOG("afs_socket: %d, afs_socket_cookie: %u\n", + afs_server_socket[0], (unsigned) afs_socket_cookie); + return afs_server_socket[0]; } -static void change_selector(void) +static void handle_help_flags(void) { - int ret, old = mmd->selector_num, new = mmd->selector_change; + char *help; + bool d = OPT_GIVEN(DETAILED_HELP); - selectors[old].shutdown(); - ret = selectors[new].init(&selectors[new]); - mmd->selector_change = -1; /* reset */ - if (ret >= 0) { - mmd->selector_num = new; + if (d) + help = lls_long_help(CMD_PTR); + else if (OPT_GIVEN(HELP)) + help = lls_short_help(CMD_PTR); + else return; - } - /* init failed */ - PARA_ERROR_LOG("%s -- switching to the random selector\n", PARA_STRERROR(-ret)); - selectors[0].init(&selectors[0]); - mmd->selector_num = 0; + printf("%s\n", help); + free(help); + exit(EXIT_SUCCESS); } -/* - * called when server gets SIGHUP or when client invokes hup command. - */ -static void handle_sighup(void) +static void server_init(int argc, char **argv, struct server_command_task *sct) { - PARA_NOTICE_LOG("%s", "SIGHUP\n"); - close_log(logfile); /* gets reopened if necessary by parse_config */ - logfile = NULL; - parse_config(1); /* reopens log */ - mmd->selector_change = mmd->selector_num; /* do not change selector.. */ - change_selector(); /* .. just reload */ - init_user_list(user_list_file); /* reload user list */ + int ret, afs_socket, daemon_pipe = -1; + char *errctx; + + valid_fd_012(); + /* parse command line options */ + ret = lls(lls_parse(argc, argv, CMD_PTR, &cmdline_lpr, &errctx)); + if (ret < 0) + goto fail; + server_lpr = cmdline_lpr; + daemon_set_loglevel(ENUM_STRING_VAL(LOGLEVEL)); + daemon_drop_privileges_or_die(OPT_STRING_VAL(USER), + OPT_STRING_VAL(GROUP)); + version_handle_flag("server", OPT_GIVEN(VERSION)); + handle_help_flags(); + parse_config_or_die(false); + /* become daemon */ + if (OPT_GIVEN(DAEMON)) + daemon_pipe = daemonize(true /* parent waits for SIGTERM */); + server_pid = getpid(); + crypt_init(); + daemon_log_welcome("server"); + init_ipc_or_die(); /* init mmd struct, mmd and log mutex */ + daemon_set_start_time(); + daemon_set_hooks(pre_log_hook, post_log_hook); + PARA_NOTICE_LOG("initializing audio format handlers\n"); + afh_init(); + + /* + * Although afs uses its own signal handling we must ignore SIGUSR1 + * _before_ the afs child process gets born by init_afs() below. It's + * racy to do this in the child because the parent might send SIGUSR1 + * before the child gets a chance to ignore this signal. + * + * We also have to block SIGCHLD before the afs process is created + * because otherwise para_server does not notice if afs dies before the + * SIGCHLD handler has been installed for the parent process by + * init_signal_task() below. + */ + para_sigaction(SIGUSR1, SIG_IGN); + para_block_signal(SIGCHLD); + PARA_NOTICE_LOG("initializing the audio file selector\n"); + afs_socket = init_afs(argc, argv); + init_signal_task(); + para_unblock_signal(SIGCHLD); + PARA_NOTICE_LOG("initializing virtual streaming system\n"); + vss_init(afs_socket, &sched); + init_server_command_task(sct, argc, argv); + if (daemon_pipe >= 0) { + if (write(daemon_pipe, "\0", 1) < 0) { + PARA_EMERG_LOG("daemon_pipe: %s", strerror(errno)); + exit(EXIT_FAILURE); + } + close(daemon_pipe); + } + PARA_NOTICE_LOG("server init complete\n"); + return; +fail: + assert(ret < 0); + if (errctx) + PARA_ERROR_LOG("%s\n", errctx); + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); + exit(EXIT_FAILURE); } static void status_refresh(void) { static int prev_uptime = -1, prev_events = -1; - int uptime = server_uptime(UPTIME_GET), ret = 1; + int uptime = daemon_get_uptime(now); if (prev_events != mmd->events) goto out; if (mmd->new_vss_status_flags != mmd->vss_status_flags) - goto out; + goto out_inc_events; if (uptime / 60 != prev_uptime / 60) - goto out; - ret = 0; + goto out_inc_events; + return; +out_inc_events: + mmd->events++; out: prev_uptime = uptime; prev_events = mmd->events; mmd->vss_status_flags = mmd->new_vss_status_flags; - if (ret) { - PARA_DEBUG_LOG("%d events, forcing status update, af = %d\n", - mmd->events, mmd->audio_format); - killpg(0, SIGUSR1); - } + PARA_DEBUG_LOG("%u events, forcing status update\n", mmd->events); + killpg(0, SIGUSR1); +} + +static int server_select(int max_fileno, fd_set *readfds, fd_set *writefds, + struct timeval *timeout_tv) +{ + int ret; + + status_refresh(); + mutex_unlock(mmd_mutex); + ret = para_select(max_fileno + 1, readfds, writefds, timeout_tv); + mutex_lock(mmd_mutex); + return ret; } /** - * the main function of para_server + * Deallocate all lopsub parse results. * - * \param argc usual argument count - * \param argv usual argument vector + * The server allocates a parse result for command line options and optionally + * a second parse result for the effective configuration, defined by merging + * the command line options with the options stored in the configuration file. + * This function frees both structures. + */ +void free_lpr(void) +{ + lls_free_parse_result(server_lpr, CMD_PTR); + if (server_lpr != cmdline_lpr) + lls_free_parse_result(cmdline_lpr, CMD_PTR); +} + +/** + * The main function of para_server. * - * \return EXIT_SUCCESS or EXIT_FAILURE + * \param argc Usual argument count. + * \param argv Usual argument vector. * + * \return EXIT_SUCCESS or EXIT_FAILURE. */ int main(int argc, char *argv[]) { - /* listen on sock_fd, new connection on new_fd */ - int sockfd, new_fd; - struct sockaddr_in their_addr; - int i, max_fileno, ret; - pid_t chld_pid; - fd_set rfds, wfds; - struct timeval *timeout; + int ret; + struct server_command_task server_command_task_struct, + *sct = &server_command_task_struct; - valid_fd_012(); - sockfd = do_inits(argc, argv); -repeat: - FD_ZERO(&rfds); - FD_ZERO(&wfds); - max_fileno = -1; - /* check socket and signal pipe in any case */ - para_fd_set(sockfd, &rfds, &max_fileno); - para_fd_set(signal_pipe, &rfds, &max_fileno); - timeout = vss_preselect(); - status_refresh(); - for (i = 0; senders[i].name; i++) { - if (senders[i].status != SENDER_ON) - continue; - if (!senders[i].pre_select) - continue; - senders[i].pre_select( &max_fileno, &rfds, &wfds); - } - if (selectors[mmd->selector_num].pre_select) { - ret = selectors[mmd->selector_num].pre_select(&rfds, &wfds); - max_fileno = PARA_MAX(max_fileno, ret); - } - mmd_unlock(); - ret = para_select(max_fileno + 1, &rfds, &wfds, timeout); - mmd_lock(); - if (mmd->selector_change >= 0) - change_selector(); - if (selectors[mmd->selector_num].post_select) - selectors[mmd->selector_num].post_select(&rfds, &wfds); - if (ret < 0) - goto repeat; - for (i = 0; senders[i].name; i++) { - if (senders[i].status != SENDER_ON) - continue; - if (!senders[i].post_select) - continue; - senders[i].post_select(&rfds, &wfds); - } - vss_send_chunk(); - status_refresh(); - if (FD_ISSET(signal_pipe, &rfds)) { - int sig; - sig = para_next_signal(); - switch (sig) { - case SIGHUP: - handle_sighup(); - break; - case SIGCHLD: - para_reap_children(); - break; - /* die on sigint/sigterm. Kill all children too. */ - case SIGINT: - case SIGTERM: - PARA_EMERG_LOG("terminating on signal %d\n", sig); - kill(0, SIGTERM); - selectors[mmd->selector_num].shutdown(); - mutex_destroy(mmd_mutex); - shm_detach(mmd); - shm_destroy(mmd_shm_id); - exit(EXIT_FAILURE); - } - } - if (mmd->sender_cmd_data.cmd_num >= 0) { - int num = mmd->sender_cmd_data.cmd_num, - s = mmd->sender_cmd_data.sender_num; + sched.default_timeout.tv_sec = 1; + sched.select_function = server_select; - if (senders[s].client_cmds[num]) - senders[s].client_cmds[num](&mmd->sender_cmd_data); - mmd->sender_cmd_data.cmd_num = -1; - } - if (!FD_ISSET(sockfd, &rfds)) - goto repeat; - - new_fd = para_accept(sockfd, &their_addr, sizeof(struct sockaddr_in)); - if (new_fd < 0) - goto repeat; - PARA_INFO_LOG("got connection from %s, forking\n", - inet_ntoa(their_addr.sin_addr)); - mmd->num_connects++; - mmd->active_connections++; - random(); - chld_pid = fork(); - if (chld_pid < 0) { - PARA_CRIT_LOG("%s", "fork failed\n"); - goto repeat; - } - if (chld_pid) { - close(new_fd); - /* parent keeps accepting connections */ - goto repeat; - } - alarm(ALARM_TIMEOUT); - close_listed_fds(); - close(sockfd); /* child doesn't need the listener */ + server_init(argc, argv, sct); + mutex_lock(mmd_mutex); + ret = schedule(&sched); /* - * put info on who we are serving into argv[0] to make - * client ip visible in top/ps + * We hold the mmd lock: it was re-acquired in server_select() + * after the select call. */ - for (i = argc - 1; i >= 0; i--) - memset(argv[i], 0, strlen(argv[i])); - sprintf(argv[0], "para_server (serving %s)", - inet_ntoa(their_addr.sin_addr)); - return handle_connect(new_fd, &their_addr); + mutex_unlock(mmd_mutex); + sched_shutdown(&sched); + crypt_shutdown(); + signal_shutdown(signal_task); + if (!process_is_command_handler()) { /* parent (server) */ + mutex_destroy(mmd_mutex); + daemon_set_hooks(NULL, NULL); /* only one process remaining */ + mutex_destroy(log_mutex); + deplete_close_on_fork_list(); + if (ret < 0) + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); + } else { + alarm(ALARM_TIMEOUT); + close_listed_fds(); + ret = handle_connect(sct->child_fd); + } + vss_shutdown(); + shm_detach(mmd); + user_list_deplete(); + free_lpr(); + exit(ret < 0? EXIT_FAILURE : EXIT_SUCCESS); }