X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=server.c;h=43ede2a91b752667ad4090e2742c4a844bf66250;hb=99b0bab8fcabc62aa154bc81da5b20ae9a3e3658;hp=2391e07c360d93f68e85a76c99bc783e1f2d4bc0;hpb=af2518cf1943cb1b6b4b4a32ca687e8f416ed563;p=paraslash.git diff --git a/server.c b/server.c index 2391e07c..43ede2a9 100644 --- a/server.c +++ b/server.c @@ -1,539 +1,615 @@ /* - * Copyright (C) 1997-2006 Andre Noll + * Copyright (C) 1997 Andre Noll * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; either version 2 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program; if not, write to the Free Software - * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA. + * Licensed under the GPL v2. For licencing details see COPYING. */ -/** \file server.c Paraslash's main server */ - +/** \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 "db.h" -#include "server.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 "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" + +/** Array of error strings. */ +DEFINE_PARA_ERRLIST; -/** define the array of error lists needed by para_server */ -INIT_SERVER_ERRLISTS; +__printf_2_3 void (*para_log)(int, const char*, ...) = daemon_log; -/** shut down non-authorized connections after that many seconds */ +/** Shut down non-authorized connections after that many seconds. */ #define ALARM_TIMEOUT 10 -/* these are exported to afs.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 - * - * It also contains the options for all audio file selectors and all supported - * senders. -*/ -struct gengetopt_args_info conf; -char *user_list = 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, - } -}; -/** 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, - } +/** + * The active value for all config options of para_server. + * + * It is computed by merging the parse result of the command line options with + * the parse result of the config file. + */ +struct lls_parse_result *server_lpr = NULL; + +/* Command line options (no config file options). Used in handle_sighup(). */ +static struct lls_parse_result *cmdline_lpr; + +/** A random value used in child context for authentication. */ +uint32_t afs_socket_cookie; + +/** The mutex protecting the shared memory area containing the mmd struct. */ +int mmd_mutex; + +static struct sched sched; +static struct signal_task *signal_task; + +/** The task responsible for server command handling. */ +struct server_command_task { + /** TCP port on which para_server listens for connections. */ + int listen_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; }; - -/* global variables for server-internal use */ -static FILE *logfile; -static int mmd_mutex, mmd_shm_id; -static int signal_pipe; - /** - * para_server's log function + * Return the list of tasks for the server process. * - * \param ll the log level - * \param fmt the format string describing the log message + * 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. */ -void para_log(int ll, const char* fmt,...) +char *server_get_tasks(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); + return get_task_list(&sched); } /* * setup shared memory area and get mutex for locking */ -static void shm_init(void) +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; - 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->afs_status_flags = AFS_NEXT; - mmd->new_afs_status_flags = AFS_NEXT; - mmd->sender_cmd_data.cmd_num = -1; + mmd->vss_status_flags = VSS_NEXT; + mmd->new_vss_status_flags = VSS_NEXT; return; 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; + daemon_close_log(); + 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); - if (!conf.user_list_given) - user_list = make_message("%s/.paraslash/server.users", home); - else - user_list = 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() != mmd->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; - cmdline_parser_configfile(cf, &conf, override, 0, 0); - 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; + ret = 0; + 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 overrride 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) + init_user_list(user_list_file); ret = 1; -out: +free_cf: free(cf); - free(home); - if (ret > 0) - return; - free(user_list); - user_list = NULL; - exit(EXIT_FAILURE); + free(user_list_file); + 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 (mmd->afs_pid) + kill(mmd->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 signum = para_next_signal(&s->rfds); + + switch (signum) { + case 0: + return 0; + case SIGHUP: + handle_sighup(); + break; + case SIGCHLD: + for (;;) { + pid_t pid; + int ret = para_reap_child(&pid); + if (ret <= 0) + break; + if (pid != mmd->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 afs because afs catches SIGINT/SIGTERM. + * Before reacting to the signal, afs 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. + * + * There's no such problem with the other children of the + * server process (the command handlers) as these reset their + * SIGINT/SIGTERM handlers to the default action, i.e. these + * processes get killed immediately by the above kill(). + */ + PARA_INFO_LOG("waiting for afs (pid %d) to die\n", + (int)mmd->afs_pid); + waitpid(mmd->afs_pid, NULL, 0); +cleanup: + free(mmd->afd.afhi.chunk_table); + close_listed_fds(); + mutex_destroy(mmd_mutex); + shm_detach(mmd); + exit(EXIT_FAILURE); } - 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 sockfd = 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 (sockfd < 0) - exit(EXIT_FAILURE); - return sockfd; +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, len = sizeof(unsigned int); - unsigned int seed; + 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 = para_accept(sct->listen_fd, &s->rfds, NULL, 0, &new_fd); + if (ret <= 0) goto out; - ret = -2; - if (read(fd, &seed, len) != len) + peer_name = remote_name(new_fd); + PARA_INFO_LOG("got connection from %s, forking\n", peer_name); + 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; + } + /* mmd might already have changed at this point */ + free(chunk_table); + alarm(ALARM_TIMEOUT); + close_listed_fds(); + signal_shutdown(signal_task); + /* + * 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); + handle_connect(new_fd, peer_name); + /* never reached*/ 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(int argc, char **argv) +{ + int ret; + static struct server_command_task server_command_task_struct, + *sct = &server_command_task_struct; + + PARA_NOTICE_LOG("initializing tcp command socket\n"); + 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]; + pid_t afs_pid; + char c; - init_random_seed(); - /* parse command line options */ - cmdline_parser(argc, argv, &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 */ - /* become daemon */ - if (conf.daemon_given) - daemon_init(); - init_selector(); - PARA_NOTICE_LOG("%s", "initializing audio file sender\n"); - /* audio file sender */ - afs_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(); - if (conf.autoplay_given) { - mmd->afs_status_flags |= AFS_PLAYING; - mmd->new_afs_status_flags |= AFS_PLAYING; + 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; + + 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_socket_cookie, afs_server_socket[1]); + } + mmd->afs_pid = afs_pid; + close(afs_server_socket[1]); + if (read(afs_server_socket[0], &c, 1) <= 0) { + PARA_EMERG_LOG("early afs exit\n"); + exit(EXIT_FAILURE); } - PARA_NOTICE_LOG("%s", "init complete\n"); - return sockfd; + 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) { - 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 */ + 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 */); + init_random_seed_or_die(); + daemon_log_welcome("server"); + init_ipc_or_die(); /* init mmd struct and mmd->lock */ + daemon_set_start_time(); + 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"); + init_vss_task(afs_socket, &sched); + init_server_command_task(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_afs_status_flags != mmd->afs_status_flags) - goto out; + if (mmd->new_vss_status_flags != mmd->vss_status_flags) + 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->afs_status_flags = mmd->new_afs_status_flags; - if (ret) { - PARA_DEBUG_LOG("%d events, forcing status update, af = %d\n", - mmd->events, mmd->audio_format); - killpg(0, SIGUSR1); - } + mmd->vss_status_flags = mmd->new_vss_status_flags; + PARA_DEBUG_LOG("%u events, forcing status update\n", mmd->events); + killpg(0, SIGUSR1); } -/* - * MAIN +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. + * + * \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; - 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 = afs_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); - } - afs_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 */ - /* - * put info on who we are serving into argv[0] to make - * client ip visible in top/ps - */ - 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); + server_init(argc, argv); + mutex_lock(mmd_mutex); + ret = schedule(&sched); + sched_shutdown(&sched); + lls_free_parse_result(server_lpr, CMD_PTR); + if (server_lpr != cmdline_lpr) + lls_free_parse_result(cmdline_lpr, CMD_PTR); + if (ret < 0) + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); + exit(ret < 0? EXIT_FAILURE : EXIT_SUCCESS); }