X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=audiod.c;h=9d0d0741cb86dd2e94c78eff1ed3503df5edbdd6;hp=8b9f181b80edfb74b31ec08aed23d61d74c8c19f;hb=101e1fd3252d838458a6ad4015f497818c54c897;hpb=27638103f249ffbe9768603b9baff199950fd9f6 diff --git a/audiod.c b/audiod.c index 8b9f181b..9d0d0741 100644 --- a/audiod.c +++ b/audiod.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2005-2006 Andre Noll + * Copyright (C) 2005-2007 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 @@ -22,14 +22,13 @@ #include "audiod.cmdline.h" #include "list.h" -#include "close_on_fork.h" #include "sched.h" #include "recv.h" #include "filter.h" #include "grab_client.cmdline.h" #include "grab_client.h" - -#include "error.h" +#include "client.cmdline.h" +#include "client.h" #include "audiod.h" #include "net.h" #include "daemon.h" @@ -37,11 +36,13 @@ #include "fd.h" #include "write.h" #include "write_common.h" +#include "error.h" +#include "signal.h" /** define the array of error lists needed by para_audiod */ INIT_AUDIOD_ERRLISTS; /** define the array containing all supported audio formats */ -DEFINE_AUDIO_FORMAT_ARRAY; +const char *audio_formats[] = {AUDIOD_AUDIO_FORMAT_ARRAY NULL}; /** defines how to handle one supported audio format */ struct audio_format_info { @@ -65,12 +66,28 @@ struct audio_format_info { struct timeval restart_barrier; }; +/** + * para_audiod uses \p MAX_STREAM_SLOTS different slots, each of which may + * be associated with a receiver/filter/writer triple. This array holds all + * information on the status of these slots. + * + * \sa struct slot_info + * */ struct slot_info slot[MAX_STREAM_SLOTS]; +/** + * the current mode of operation of which can be changed by the on/off/cycle + * commands. It is either, AUDIOD_OFF, AUDIOD_ON or AUDIOD_STANDBY. + */ int audiod_status = AUDIOD_ON; -struct gengetopt_args_info conf; +/** + * the gengetopt args_info struct that holds information on all command line + * arguments + */ +struct audiod_args_info conf; + static char *socket_name; static FILE *logfile; static struct audio_format_info afi[NUM_AUDIO_FORMATS]; @@ -78,7 +95,14 @@ static struct audio_format_info afi[NUM_AUDIO_FORMATS]; static struct signal_task signal_task_struct, *sig_task = &signal_task_struct; static struct status_task status_task_struct; + +/** + * the task that calls the status command of para_server + * + * \sa struct status_task + */ struct status_task *stat_task = &status_task_struct; +static struct timeval initial_delay_barrier; /** * the task for handling audiod commands @@ -92,9 +116,15 @@ struct command_task { struct task task; }; +/** + * task for signal handling + */ struct signal_task { + /** the signal pipe */ int fd; + /** the number of the most recent signal */ int signum; + /** the associated task structure */ struct task task; }; @@ -117,8 +147,11 @@ int get_audio_format_num(char *name) return -E_UNSUPPORTED_AUDIO_FORMAT; } -/* - * log function. first argument is loglevel. +/** + * the log function of para_audiod + * + * \param ll loglevel + * \param fmt the format string */ void para_log(int ll, const char* fmt,...) { @@ -163,10 +196,8 @@ static void setup_signal_handling(void) PARA_INFO_LOG("signal pipe: fd %d\n", sig_task->fd); para_install_sighandler(SIGINT); para_install_sighandler(SIGTERM); - para_install_sighandler(SIGCHLD); para_install_sighandler(SIGHUP); - para_install_sighandler(SIGPIPE); -// signal(SIGPIPE, SIG_IGN); + signal(SIGPIPE, SIG_IGN); } static void clear_slot(int slot_num) @@ -182,20 +213,15 @@ static void close_receiver(int slot_num) { struct slot_info *s = &slot[slot_num]; struct audio_format_info *a; - const struct timeval restart_delay = {0, 200 * 1000}; if (s->format < 0 || !s->receiver_node) return; a = &afi[s->format]; PARA_NOTICE_LOG("closing %s receiver in slot %d (eof = %d)\n", audio_formats[s->format] , slot_num, s->receiver_node->eof); -// if (!s->receiver_node->eof) -// unregister_task(&s->receiver_node->task); a->receiver->close(s->receiver_node); free(s->receiver_node); s->receiver_node = NULL; - /* set restart barrier */ - tv_add(now, &restart_delay, &afi[s->format].restart_barrier); } static void kill_all_decoders(void) @@ -242,56 +268,6 @@ static int get_empty_slot(void) return -E_NO_MORE_SLOTS; } -static int decoder_running(int format) -{ - int i, ret = 0; - struct slot_info *s; - - FOR_EACH_SLOT(i) { - s = &slot[i]; - if (s->format == format && s->receiver_node) - ret |= 1; - if (s->format == format && s->wng) - ret |= 2; - } - return ret; -} - -static void close_stat_pipe(void) -{ - int i; - - if (stat_task->fd < 0) - return; - PARA_NOTICE_LOG("%s", "closing status pipe\n"); - close(stat_task->fd); - del_close_on_fork_list(stat_task->fd); - stat_task->fd = -1; -// kill_all_decoders(); - for (i = 0; i < NUM_STAT_ITEMS; i++) { - free(stat_task->stat_item_values[i]); - stat_task->stat_item_values[i] = NULL; - } - dump_empty_status(); - stat_task->length_seconds = 0; - stat_task->offset_seconds = 0; - audiod_status_dump(); - stat_task->playing = 0; - stat_task->stat_item_values[SI_STATUS_BAR] = make_message( - "%s:no connection to para_server\n", - status_item_list[SI_STATUS_BAR]); - stat_client_write(stat_task->stat_item_values[SI_STATUS_BAR], SI_STATUS_BAR); -} - -void __noreturn clean_exit(int status, const char *msg) -{ - PARA_EMERG_LOG("%s\n", msg); - if (socket_name) - unlink(socket_name); - close_stat_pipe(); - exit(status); -} - /** * get the number of filters * @@ -404,22 +380,32 @@ static void open_writers(int slot_num) static void rn_event_handler(struct task *t) { struct receiver_node *rn = t->private_data; + const struct timeval restart_delay = {0, 10 * 1000}; + int i; PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret)); unregister_task(t); rn->eof = 1; + /* set restart barrier */ + FOR_EACH_SLOT(i) { + if (slot[i].receiver_node != rn) + continue; + tv_add(now, &restart_delay, &afi[slot[i].format].restart_barrier); + } } -static void open_receiver(int format) +static int open_receiver(int format) { struct audio_format_info *a = &afi[format]; struct slot_info *s; int ret, slot_num; struct receiver_node *rn; + const struct timeval restart_delay = {1, 0}; - slot_num = get_empty_slot(); - if (slot_num < 0) - clean_exit(EXIT_FAILURE, PARA_STRERROR(-slot_num)); + ret = get_empty_slot(); + if (ret < 0) + goto err; + slot_num = ret; s = &slot[slot_num]; s->format = format; s->receiver_node = para_calloc(sizeof(struct receiver_node)); @@ -428,11 +414,9 @@ static void open_receiver(int format) rn->conf = a->receiver_conf; ret = a->receiver->open(s->receiver_node); if (ret < 0) { - PARA_ERROR_LOG("failed to open receiver (%s)\n", - PARA_STRERROR(-ret)); free(s->receiver_node); s->receiver_node = NULL; - return; + goto err; } PARA_NOTICE_LOG("started %s: %s receiver in slot %d\n", audio_formats[s->format], a->receiver->name, slot_num); @@ -442,26 +426,45 @@ static void open_receiver(int format) rn->task.event_handler = rn_event_handler; sprintf(rn->task.status, "%s receiver node", rn->receiver->name); register_task(&rn->task); + return 1; +err: + PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); + tv_add(now, &restart_delay, &afi[format].restart_barrier); + return ret; +} + +static int receiver_running(int format) +{ + int i; + + FOR_EACH_SLOT(i) { + struct slot_info *s = &slot[i]; + if (s->format == format && s->receiver_node + && !s->receiver_node->eof) + return 1; + } + return 0; } static int open_current_receiver(struct sched *s) { int i; struct timeval diff; + char *audio_format = stat_task->stat_item_values[SI_FORMAT]; - if (!stat_task->af_status) + if (!audio_format || !stat_task->pcd) return 0; - i = get_audio_format_num(stat_task->af_status); + i = get_audio_format_num(audio_format + strlen( + status_item_list[SI_FORMAT]) + 1); if (i < 0) return 0; - if (decoder_running(i)) + if (receiver_running(i)) return 0; if (tv_diff(now, &afi[i].restart_barrier, &diff) < 0) { s->timeout = diff; return 0; } - open_receiver(i); - return 1; + return open_receiver(i) < 0? 0 : 1; } static void compute_time_diff(const struct timeval *status_time) @@ -479,7 +482,7 @@ static void compute_time_diff(const struct timeval *status_time) sa_time_diff_sign = sign; stat_task->sa_time_diff = diff; count++; - return; + goto out; } if (count > 5) { int s = tv_diff(&diff, &stat_task->sa_time_diff, &tmp); @@ -493,12 +496,14 @@ static void compute_time_diff(const struct timeval *status_time) count > 10? sign : sign * time_smooth, &diff, &tmp); stat_task->sa_time_diff = tmp; - PARA_DEBUG_LOG("time diff (cur/avg): %s%lums/%s%lums\n", + PARA_INFO_LOG("time diff (cur/avg): %s%lums/%s%lums\n", sign > 0? "+" : "-", tv2ms(&diff), sa_time_diff_sign ? "+" : "-", tv2ms(&stat_task->sa_time_diff) ); +out: + stat_task->sa_time_diff_sign = sa_time_diff_sign; } static void check_stat_line(char *line) @@ -516,6 +521,8 @@ static void check_stat_line(char *line) PARA_WARNING_LOG("invalid status line: %s\n", line); return; } + if (stat_task->clock_diff_count && itemnum != SI_CURRENT_TIME) + return; tmp = make_message("%s\n", line); stat_client_write(tmp, itemnum); free(tmp); @@ -526,10 +533,6 @@ static void check_stat_line(char *line) case SI_STATUS: stat_task->playing = strstr(line, "playing")? 1 : 0; break; - case SI_FORMAT: - free(stat_task->af_status); - stat_task->af_status = para_strdup(line + ilen + 1); - break; case SI_OFFSET: stat_task->offset_seconds = atoi(line + ilen + 1); break; @@ -538,8 +541,18 @@ static void check_stat_line(char *line) break; case SI_STREAM_START: if (sscanf(line + ilen + 1, "%lu.%lu", &sec, &usec) == 2) { + struct timeval a_start, delay; + delay.tv_sec = conf.stream_delay_arg / 1000; + delay.tv_usec = (conf.stream_delay_arg % 1000) * 1000; stat_task->server_stream_start.tv_sec = sec; stat_task->server_stream_start.tv_usec = usec; + if (stat_task->sa_time_diff_sign < 0) + tv_add(&stat_task->server_stream_start, + &stat_task->sa_time_diff, &a_start); + else + tv_diff(&stat_task->server_stream_start, + &stat_task->sa_time_diff, &a_start); + tv_add(&a_start, &delay, &initial_delay_barrier); } break; case SI_CURRENT_TIME: @@ -547,29 +560,12 @@ static void check_stat_line(char *line) struct timeval tv = {sec, usec}; compute_time_diff(&tv); } + if (stat_task->clock_diff_count) + stat_task->clock_diff_count--; break; } } -static void handle_signal(int sig) -{ - switch (sig) { - case SIGCHLD: - for (;;) { - pid_t pid = para_reap_child(); - if (pid <= 0) - return; - PARA_CRIT_LOG("para_client died (pid %d)\n", pid); - } - case SIGINT: - case SIGTERM: - case SIGHUP: - PARA_EMERG_LOG("terminating on signal %d\n", sig); - clean_exit(EXIT_FAILURE, "caught deadly signal"); - return; - } -} - static void try_to_close_slot(int slot_num) { struct slot_info *s = &slot[slot_num]; @@ -609,6 +605,7 @@ static void audiod_pre_select(struct sched *s, __a_unused struct task *t) FOR_EACH_SLOT(i) { struct slot_info *sl = &slot[i]; struct audio_format_info *a; + struct timeval diff; if (sl->format < 0) continue; @@ -627,9 +624,16 @@ static void audiod_pre_select(struct sched *s, __a_unused struct task *t) s->timeout = min_delay; continue; } - if (sl->fc && *sl->fc->out_loaded && !sl->wng) { + if (!sl->fc || !*sl->fc->out_loaded || sl->wng) + continue; + if (tv_diff(now, &initial_delay_barrier, &diff) > 0) { open_writers(i); s->timeout = min_delay; + continue; + } + PARA_INFO_LOG("inital delay: %lu ms left\n", tv2ms(&diff)); + if (tv_diff(&s->timeout, &diff, NULL) > 0) { + s->timeout = diff; } } } @@ -639,7 +643,6 @@ static void audiod_post_select(__a_unused struct sched *s, { int i; - /* save away the current time for other users */ t->ret = 1; FOR_EACH_SLOT(i) try_to_close_slot(i); @@ -735,18 +738,18 @@ static int init_receivers(void) PARA_INFO_LOG("initializing %s receiver\n", receivers[i].name); receivers[i].init(&receivers[i]); } - for (i = 0; i < conf.receiver_given; i++) { + for (i = conf.receiver_given - 1; i >= 0; i--) { char *arg = conf.receiver_arg[i]; - char *recv = strchr(arg, ':'); + char *recv_arg = strchr(arg, ':'); ret = -E_MISSING_COLON; - if (!recv) + if (!recv_arg) goto out; - *recv = '\0'; - recv++; + *recv_arg = '\0'; + recv_arg++; ret = get_audio_format_num(arg); if (ret < 0) goto out; - afi[ret].receiver_conf = check_receiver_arg(recv, &receiver_num); + afi[ret].receiver_conf = check_receiver_arg(recv_arg, &receiver_num); if (!afi[ret].receiver_conf) { ret = -E_RECV_SYNTAX; goto out; @@ -880,44 +883,31 @@ static int audiod_get_socket(void) PARA_EMERG_LOG("%s", "can not listen on socket\n"); exit(EXIT_FAILURE); /* do not unlink socket */ } - add_close_on_fork_list(fd); mark_fd_nonblock(fd); return fd; } -static int open_stat_pipe(void) -{ - int ret, fd[3] = {-1, 1, 0}; - pid_t pid; - ret = para_exec_cmdline_pid(&pid, BINDIR "/para_client stat", fd); - if (ret >= 0) { - ret = fd[1]; - PARA_NOTICE_LOG("stat pipe opened, fd %d\n", ret); - add_close_on_fork_list(ret); - mark_fd_nonblock(ret); - } else - clean_exit(EXIT_FAILURE, "failed to open status pipe"); - return ret; -} - -void signal_event_handler(struct task *t) +static void signal_event_handler(struct task *t) { struct signal_task *st = t->private_data; - if (t->ret != -E_SIGNAL_CAUGHT) - PARA_ERROR_LOG("%s (ignored)\n", PARA_STRERROR(-t->ret)); - else - handle_signal(st->signum); + switch (st->signum) { + case SIGINT: + case SIGTERM: + case SIGHUP: + PARA_EMERG_LOG("terminating on signal %d\n", st->signum); + clean_exit(EXIT_FAILURE, "caught deadly signal"); + } } -void signal_pre_select(struct sched *s, struct task *t) +static void signal_pre_select(struct sched *s, struct task *t) { struct signal_task *st = t->private_data; t->ret = 1; para_fd_set(st->fd, &s->rfds, &s->max_fileno); } -void signal_post_select(struct sched *s, struct task *t) +static void signal_post_select(struct sched *s, struct task *t) { struct signal_task *st = t->private_data; t->ret = 1; @@ -927,7 +917,7 @@ void signal_post_select(struct sched *s, struct task *t) st->signum = para_next_signal(); } -void signal_setup_default(struct signal_task *st) +static void signal_setup_default(struct signal_task *st) { st->task.pre_select = signal_pre_select; st->task.post_select = signal_post_select; @@ -949,8 +939,7 @@ static void command_post_select(struct sched *s, struct task *t) struct command_task *ct = t->private_data; t->ret = 1; /* always successful */ - if (audiod_status != AUDIOD_OFF) - audiod_status_dump(); + audiod_status_dump(); if (!FD_ISSET(ct->fd, &s->rfds)) return; ret = handle_connect(ct->fd); @@ -968,52 +957,129 @@ static void init_command_task(struct command_task *ct) sprintf(ct->task.status, "command task"); } -static void status_event_handler(__a_unused struct task *t) +static void close_stat_pipe(void) { - struct timeval delay = {1, 0}; int i; - struct status_task *st = t->private_data; - PARA_ERROR_LOG("%s\n", PARA_STRERROR(-t->ret)); + if (!stat_task->pcd) + return; + client_close(stat_task->pcd); + stat_task->pcd = NULL; + for (i = 0; i < NUM_STAT_ITEMS; i++) { + free(stat_task->stat_item_values[i]); + stat_task->stat_item_values[i] = NULL; + } + dump_empty_status(); + stat_task->length_seconds = 0; + stat_task->offset_seconds = 0; + audiod_status_dump(); + stat_task->playing = 0; + stat_task->stat_item_values[SI_STATUS_BAR] = make_message( + "%s:no connection to para_server\n", + status_item_list[SI_STATUS_BAR]); + stat_client_write(stat_task->stat_item_values[SI_STATUS_BAR], + SI_STATUS_BAR); + if (stat_task->clock_diff_count) { + stat_task->clock_diff_barrier.tv_sec = now->tv_sec + 1; + stat_task->clock_diff_barrier.tv_usec = now->tv_usec; + } +} + +/** + * close the connection to para_server and exit + * + * \param status the exit status which is passed to exit(3) + * \param msg the log message + * + * Log \a msg with loglevel \p EMERG, close the connection to para_server if + * open, and call \p exit(status). \a status should be either EXIT_SUCCESS or + * EXIT_FAILURE. + * + * \sa exit(3) + */ +void __noreturn clean_exit(int status, const char *msg) +{ + PARA_EMERG_LOG("%s\n", msg); + if (socket_name) + unlink(socket_name); + close_stat_pipe(); + exit(status); +} + + +static void client_task_event_handler(__a_unused struct task *t) +{ + int i; + struct timeval delay = {1, 0}; + + if (t->ret == -E_HANDSHAKE_COMPLETE) + return; + unregister_task(t); close_stat_pipe(); + if (t->ret != -E_SERVER_EOF) + stat_task->clock_diff_count = conf.clock_diff_count_arg; /* avoid busy loop if server is down */ - tv_add(now, &delay, &st->restart_barrier); + tv_add(now, &delay, &stat_task->restart_barrier); FOR_EACH_AUDIO_FORMAT(i) - afi[i].restart_barrier = st->restart_barrier; + afi[i].restart_barrier = stat_task->restart_barrier; } static void status_pre_select(struct sched *s, struct task *t) { struct status_task *st = t->private_data; - t->ret = 1; - if (st->fd >= 0 && audiod_status == AUDIOD_OFF) - close_stat_pipe(); - if (st->fd < 0 && audiod_status != AUDIOD_OFF - && tv_diff(now, &st->restart_barrier, NULL) > 0) { - st->fd = open_stat_pipe(); - st->loaded = 0; - st->buf[0] = '\0'; + int ret; + + t->ret = 1; /* always successful */ + if (st->pcd || audiod_status == AUDIOD_OFF) + return; + if (!st->clock_diff_count && tv_diff(now, &st->restart_barrier, NULL) + < 0) + return; + if (st->clock_diff_count) { + char *argv[] = {"audiod", "stat", "1", NULL}; + int argc = 3; + if (tv_diff(now, &st->clock_diff_barrier, NULL) < 0) + return; + PARA_INFO_LOG("clock diff count: %d\n", st->clock_diff_count); + ret = client_open(argc, argv, &st->pcd); + + } else { + char *argv[] = {"audiod", "stat", NULL}; + int argc = 2; + ret = client_open(argc, argv, &st->pcd); } - if (st->fd >= 0 && audiod_status != AUDIOD_OFF) - para_fd_set(st->fd, &s->rfds, &s->max_fileno); + if (ret < 0) + return; + st->pcd->task.event_handler = client_task_event_handler; + s->timeout.tv_sec = 0; + s->timeout.tv_usec = 1; } -static void status_post_select(struct sched *s, struct task *t) +static void status_post_select(__a_unused struct sched *s, struct task *t) { struct status_task *st = t->private_data; + unsigned bytes_left; t->ret = 1; - if (st->fd < 0 || !FD_ISSET(st->fd, &s->rfds)) + if (!st->pcd || st->pcd->status != CL_RECEIVING) return; - t->ret = read(st->fd, st->buf + st->loaded, STRINGSIZE - 1 - st->loaded); - if (t->ret <= 0) { - if (!t->ret) - t->ret = -E_STATUS_EOF; + if (st->pcd && audiod_status == AUDIOD_OFF) { + unregister_task(&st->pcd->task); + close_stat_pipe(); + st->clock_diff_count = conf.clock_diff_count_arg; return; } - st->buf[t->ret + st->loaded] = '\0'; - st->loaded = for_each_line(st->buf, t->ret + st->loaded, + bytes_left = for_each_line(st->pcd->buf, st->pcd->loaded, &check_stat_line); + if (st->pcd->loaded != bytes_left) { + st->last_status_read = *now; + st->pcd->loaded = bytes_left; + } else { + struct timeval diff; + tv_diff(now, &st->last_status_read, &diff); + if (diff.tv_sec > 61) + close_stat_pipe(); + } } static void init_status_task(struct status_task *st) @@ -1021,10 +1087,9 @@ static void init_status_task(struct status_task *st) memset(st, 0, sizeof(struct status_task)); st->task.pre_select = status_pre_select; st->task.post_select = status_post_select; - st->task.event_handler = status_event_handler; st->task.private_data = st; - st->fd = -1; st->sa_time_diff_sign = 1; + st->clock_diff_count = conf.clock_diff_count_arg; sprintf(st->task.status, "status task"); } @@ -1045,6 +1110,16 @@ static void set_initial_status(void) PARA_WARNING_LOG("%s", "invalid mode\n"); } +/** + * the main function of para_audiod + * + * \param argc usual argument count + * \param argv usual argument vector + * + * \return EXIT_SUCCESS or EXIT_FAILURE + * + * \sa para_audiod(1) + * */ int main(int argc, char *argv[]) { char *cf; @@ -1054,11 +1129,12 @@ int main(int argc, char *argv[]) struct task audiod_task_struct, *audiod_task = &audiod_task_struct; valid_fd_012(); - cmdline_parser(argc, argv, &conf); + audiod_cmdline_parser(argc, argv, &conf); + HANDLE_VERSION_FLAG("audiod", conf); para_drop_privileges(conf.user_arg, conf.group_arg); cf = configfile_exists(); if (cf) { - if (cmdline_parser_configfile(cf, &conf, 0, 0, 0)) { + if (audiod_cmdline_parser_configfile(cf, &conf, 0, 0, 0)) { PARA_EMERG_LOG("%s", "parse error in config file\n"); exit(EXIT_FAILURE); } @@ -1091,7 +1167,7 @@ int main(int argc, char *argv[]) register_task(&cmd_task->task); register_task(&stat_task->task); register_task(audiod_task); - s.default_timeout.tv_sec = 3; + s.default_timeout.tv_sec = 0; s.default_timeout.tv_usec = 99 * 1000; ret = sched(&s);