X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=audiod.c;h=fc4ac6f5017b2eb5c4876d0c29a0bd53ba512b8f;hp=8b9f181b80edfb74b31ec08aed23d61d74c8c19f;hb=9627e8157c8c916555b993d7254b0b638815ebc1;hpb=27638103f249ffbe9768603b9baff199950fd9f6 diff --git a/audiod.c b/audiod.c index 8b9f181b..fc4ac6f5 100644 --- a/audiod.c +++ b/audiod.c @@ -1,35 +1,26 @@ /* - * Copyright (C) 2005-2006 Andre Noll + * Copyright (C) 2005-2009 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 audiod.c the paraslash's audio daemon */ +#include +#include +#include #include "para.h" - +#include "error.h" #include "audiod.cmdline.h" #include "list.h" -#include "close_on_fork.h" #include "sched.h" +#include "ggo.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,13 +28,14 @@ #include "fd.h" #include "write.h" #include "write_common.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 */ +/** Defines how audiod handles one supported audio format. */ struct audio_format_info { /** pointer to the receiver for this audio format */ struct receiver *receiver; @@ -51,9 +43,9 @@ struct audio_format_info { void *receiver_conf; /** the number of filters that should be activated for this audio format */ unsigned int num_filters; - /** pointer to the array of filters to be activated */ - struct filter **filters; - /** pointer to the array of filter configurations */ + /** Array of filter numbers to be activated. */ + unsigned *filter_nums; + /** Pointer to the array of filter configurations. */ void **filter_conf; /** the number of filters that should be activated for this audio format */ unsigned int num_writers; @@ -65,12 +57,31 @@ 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 array of status items sent by para_server. */ +char *stat_item_values[NUM_STAT_ITEMS] = {NULL}; + +/** + * 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 +89,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; -struct status_task *stat_task = &status_task_struct; + +/** + * the task that calls the status command of para_server + * + * \sa struct status_task + */ +static struct status_task *stat_task = &status_task_struct; +static struct timeval initial_delay_barrier; /** * the task for handling audiod commands @@ -92,12 +110,6 @@ struct command_task { struct task task; }; -struct signal_task { - int fd; - int signum; - struct task task; -}; - /** iterate over all supported audio formats */ #define FOR_EACH_AUDIO_FORMAT(af) for (af = 0; af < NUM_AUDIO_FORMATS; af++) @@ -111,16 +123,71 @@ struct signal_task { int get_audio_format_num(char *name) { int i; + + while (para_isspace(*name)) + name++; FOR_EACH_AUDIO_FORMAT(i) if (!strcmp(name, audio_formats[i])) return i; return -E_UNSUPPORTED_AUDIO_FORMAT; } -/* - * log function. first argument is loglevel. +char *get_time_string(struct timeval *newest_stime) +{ + struct timeval diff, adj_stream_start, tmp; + int total = 0, use_server_time = 1, + length_seconds = stat_task->length_seconds; + + if (!stat_task->playing) { + if (length_seconds) + return NULL; + return make_message("%s:\n", status_item_list[SI_PLAY_TIME]); + } + if (audiod_status == AUDIOD_OFF) + goto out; + if (stat_task->sa_time_diff_sign > 0) + tv_diff(&stat_task->server_stream_start, &stat_task->sa_time_diff, + &adj_stream_start); + else + tv_add(&stat_task->server_stream_start, &stat_task->sa_time_diff, + &adj_stream_start); + tmp = adj_stream_start; + if (newest_stime && audiod_status == AUDIOD_ON) { + tv_diff(newest_stime, &adj_stream_start, &diff); + if (tv2ms(&diff) < 5000) { + tmp = *newest_stime; + use_server_time = 0; + } + } + tv_diff(now, &tmp, &diff); + total = diff.tv_sec + stat_task->offset_seconds; + if (total > length_seconds) + total = length_seconds; + if (total < 0) + total = 0; +out: + return make_message( + "%s: %s%d:%02d [%d:%02d] (%d%%/%d:%02d)\n", + status_item_list[SI_PLAY_TIME], + use_server_time? "~" : "", + total / 60, + total % 60, + (length_seconds - total) / 60, + (length_seconds - total) % 60, + length_seconds? (total * 100 + length_seconds / 2) / + length_seconds : 0, + length_seconds / 60, + length_seconds % 60 + ); +} + +/** + * the log function of para_audiod + * + * \param ll loglevel + * \param fmt the format string */ -void para_log(int ll, const char* fmt,...) +__printf_2_3 void para_log(int ll, const char* fmt,...) { va_list argp; FILE *outfd; @@ -131,6 +198,8 @@ void para_log(int ll, const char* fmt,...) if (ll < conf.loglevel_arg) return; + if (!logfile && conf.daemon_given) + return; if (!hostname) hostname = para_hostname(); outfd = logfile? logfile : stderr; @@ -145,16 +214,39 @@ void para_log(int ll, const char* fmt,...) va_end(argp); } -static char *configfile_exists(void) +static void parse_config_or_die(void) { - static char *config_file; + char *config_file; - if (!config_file) { + if (conf.config_file_given) + config_file = para_strdup(conf.config_file_arg); + else { char *home = para_homedir(); config_file = make_message("%s/.paraslash/audiod.conf", home); free(home); } - return file_exists(config_file)? config_file : NULL; + if (conf.config_file_given && !file_exists(config_file)) { + PARA_EMERG_LOG("can not read config file %s\n", config_file); + goto err; + } + if (config_file) { + struct audiod_cmdline_parser_params params = { + .override = 0, + .initialize = 0, + .check_required = 1, + .check_ambiguity = 0, + .print_errors = 1 + }; + if (audiod_cmdline_parser_config_file(config_file, &conf, ¶ms)) { + PARA_EMERG_LOG("parse error in config file\n"); + goto err; + } + } + free(config_file); + return; +err: + free(config_file); + exit(EXIT_FAILURE); } static void setup_signal_handling(void) @@ -163,10 +255,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,43 +272,35 @@ 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); + PARA_NOTICE_LOG("closing %s receiver in slot %d\n", + audio_formats[s->format], slot_num); 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) +static void kill_all_decoders(int error) { int i; FOR_EACH_SLOT(i) { struct slot_info *s = &slot[i]; - if (s->wng && !s->wng->eof) { - PARA_INFO_LOG("unregistering writer node group in slot %d\n", + if (s->wng && s->wng->task.error >= 0) { + PARA_INFO_LOG("deactivating wng in slot %d\n", i); - wng_unregister(s->wng); - s->wng->eof = 1; + s->wng->task.error = error; } - if (s->fc && !s->fc->eof) { - PARA_INFO_LOG("unregistering filter chain in slot %d\n", i); - unregister_task(&s->fc->task); - s->fc->eof = 1; + if (s->fc && s->fc->task.error >= 0) { + PARA_INFO_LOG("deactivatimg filter chain in slot %d\n", i); + s->fc->task.error = error; } - if (s->receiver_node && !s->receiver_node->eof) { - PARA_INFO_LOG("unregistering receiver_node in slot %d\n", i); - unregister_task(&s->receiver_node->task); - s->receiver_node->eof = 1; + if (s->receiver_node && s->receiver_node->task.error >= 0) { + PARA_INFO_LOG("deactivating receiver_node in slot %d\n", i); + s->receiver_node->task.error = error; } } } @@ -242,56 +324,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 * @@ -306,18 +338,11 @@ int num_filters(int audio_format_num) return afi[audio_format_num].num_filters; } -static void filter_event_handler(struct task *t) -{ - PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret)); - struct filter_chain *fc = t->private_data; - fc->eof = 1; - unregister_task(t); -} - static void open_filters(int slot_num) { struct slot_info *s = &slot[slot_num]; struct audio_format_info *a = &afi[s->format]; + struct filter_node *fn; int nf = a->num_filters; int i; @@ -326,43 +351,33 @@ static void open_filters(int slot_num) return; PARA_INFO_LOG("opening %s filters\n", audio_formats[s->format]); s->fc = para_calloc(sizeof(struct filter_chain)); - INIT_LIST_HEAD(&s->fc->filters); + s->fc->filter_nodes = para_malloc(nf * sizeof(struct filter_node)); s->fc->inbuf = s->receiver_node->buf; s->fc->in_loaded = &s->receiver_node->loaded; - s->fc->input_eof = &s->receiver_node->eof; + s->fc->input_error = &s->receiver_node->task.error; s->fc->task.pre_select = filter_pre_select; - s->fc->task.event_handler = filter_event_handler; - s->fc->task.private_data = s->fc; - s->fc->eof = 0; + s->fc->task.post_select = NULL; + s->fc->task.error = 0; + s->fc->num_filters = nf; - s->receiver_node->output_eof = &s->fc->eof; + s->receiver_node->output_error = &s->fc->task.error; sprintf(s->fc->task.status, "filter chain"); - for (i = 0; i < nf; i++) { - struct filter_node *fn = para_calloc(sizeof(struct filter_node)); + FOR_EACH_FILTER_NODE(fn, s->fc, i) { + struct filter *f = filters + a->filter_nums[i]; + fn->filter_num = a->filter_nums[i]; fn->conf = a->filter_conf[i]; fn->fc = s->fc; - fn->filter = a->filters[i]; + fn->loaded = 0; INIT_LIST_HEAD(&fn->callbacks); - list_add_tail(&fn->node, &s->fc->filters); - fn->filter->open(fn); + f->open(fn); PARA_NOTICE_LOG("%s filter %d/%d (%s) started in slot %d\n", - audio_formats[s->format], i + 1, nf, - fn->filter->name, slot_num); + audio_formats[s->format], i, nf, f->name, slot_num); s->fc->outbuf = fn->buf; s->fc->out_loaded = &fn->loaded; } register_task(&s->fc->task); } -static void wng_event_handler(struct task *t) -{ - struct writer_node_group *wng = t->private_data; - - PARA_INFO_LOG("%s\n", PARA_STRERROR(-t->ret)); - wng->eof = 1; - wng_unregister(wng); -} - static void open_writers(int slot_num) { int ret, i; @@ -377,49 +392,41 @@ static void open_writers(int slot_num) if (s->fc) { s->wng->buf = s->fc->outbuf; s->wng->loaded = s->fc->out_loaded; - s->wng->input_eof = &s->fc->eof; + s->wng->input_error = &s->fc->task.error; s->wng->channels = &s->fc->channels; s->wng->samplerate = &s->fc->samplerate; - s->fc->output_eof = &s->wng->eof; + s->fc->output_error = &s->wng->task.error; PARA_INFO_LOG("samplerate: %d\n", *s->wng->samplerate); } else { s->wng->buf = s->receiver_node->buf; s->wng->loaded = &s->receiver_node->loaded; - s->wng->input_eof = &s->receiver_node->eof; + s->wng->input_error = &s->receiver_node->task.error; } - s->wng->task.event_handler = wng_event_handler; for (i = 0; i < a->num_writers; i++) { s->wng->writer_nodes[i].conf = a->writer_conf[i]; s->wng->writer_nodes[i].writer = a->writers[i]; } ret = wng_open(s->wng); if (ret < 0) { - PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); return; } s->wstime = *now; - activate_inactive_grab_clients(slot_num, s->format, &s->fc->filters); -} - -static void rn_event_handler(struct task *t) -{ - struct receiver_node *rn = t->private_data; - - PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret)); - unregister_task(t); - rn->eof = 1; + activate_inactive_grab_clients(slot_num, s->format, s->fc); } -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 = {2, 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,50 +435,62 @@ 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); - rn->task.private_data = s->receiver_node; rn->task.pre_select = a->receiver->pre_select; rn->task.post_select = a->receiver->post_select; - rn->task.event_handler = rn_event_handler; sprintf(rn->task.status, "%s receiver node", rn->receiver->name); register_task(&rn->task); + ret = 1; +err: + if (ret < 0) + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + tv_add(now, &restart_delay, &afi[format].restart_barrier); + return ret; } -static int open_current_receiver(struct sched *s) +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) + return 1; + } + return 0; +} + +static int open_current_receiver(struct sched *s) +{ struct timeval diff; + int cafn = stat_task->current_audio_format_num; - if (!stat_task->af_status) + if (cafn < 0 || !stat_task->ct) return 0; - i = get_audio_format_num(stat_task->af_status); - if (i < 0) + if (receiver_running(cafn)) return 0; - if (decoder_running(i)) - return 0; - if (tv_diff(now, &afi[i].restart_barrier, &diff) < 0) { + if (tv_diff(now, &afi[cafn].restart_barrier, &diff) < 0) { s->timeout = diff; return 0; } - open_receiver(i); - return 1; + return open_receiver(cafn) < 0? 0 : 1; } -static void compute_time_diff(const struct timeval *status_time) +static unsigned compute_time_diff(const struct timeval *status_time) { struct timeval tmp, diff; - static int count; + static unsigned count; int sign, sa_time_diff_sign = stat_task->sa_time_diff_sign; const struct timeval max_deviation = {0, 500 * 1000}; const int time_smooth = 5; + if (!status_time) + return count; sign = tv_diff(status_time, now, &diff); // PARA_NOTICE_LOG("%s: sign = %i, sa_time_diff_sign = %i\n", __func__, // sign, sa_time_diff_sign); @@ -479,7 +498,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,53 +512,67 @@ 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; + return count; } -static void check_stat_line(char *line) +static int check_stat_line(char *line, __a_unused void *data) { int itemnum; size_t ilen = 0; long unsigned sec, usec; char *tmp; -// PARA_INFO_LOG("line: %s\n", line); + //PARA_INFO_LOG("line: %s\n", line); if (!line) - return; + return 1; itemnum = stat_line_valid(line); if (itemnum < 0) { PARA_WARNING_LOG("invalid status line: %s\n", line); - return; + return 1; } + if (stat_task->clock_diff_count && itemnum != SI_CURRENT_TIME) + return 1; tmp = make_message("%s\n", line); stat_client_write(tmp, itemnum); free(tmp); - free(stat_task->stat_item_values[itemnum]); - stat_task->stat_item_values[itemnum] = para_strdup(line); + free(stat_item_values[itemnum]); + stat_item_values[itemnum] = para_strdup(line); ilen = strlen(status_item_list[itemnum]); switch (itemnum) { 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); + PARA_INFO_LOG("stat task playing: %d\n", stat_task->playing); break; case SI_OFFSET: stat_task->offset_seconds = atoi(line + ilen + 1); break; - case SI_LENGTH: + case SI_SECONDS_TOTAL: stat_task->length_seconds = atoi(line + ilen + 1); 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 (compute_time_diff(NULL) > 2) { + 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: @@ -548,110 +581,11 @@ static void check_stat_line(char *line) compute_time_diff(&tv); } break; + case SI_FORMAT: + stat_task->current_audio_format_num = get_audio_format_num( + line + ilen + 1); } -} - -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]; - - if (s->format < 0) - return; - if (s->receiver_node && !s->receiver_node->eof) - return; - if (s->fc && !s->fc->eof) - return; - if (s->wng && !s->wng->eof) - return; - PARA_INFO_LOG("closing slot %d \n", slot_num); - wng_close(s->wng); - close_filters(s->fc); - free(s->fc); - close_receiver(slot_num); - clear_slot(slot_num); -} - -/* - * Check if any receivers/filters/writers need to be started and do so if - * neccessary. Since the pre_select function didn't have a chance yet to put - * file descriptors into the fd sets given by s, make the upcoming select() - * return immediately to avoid a long timeout in case we started something. - */ -static void audiod_pre_select(struct sched *s, __a_unused struct task *t) -{ - int i; - struct timeval min_delay = {0, 1}; - - t->ret = 1; - if (audiod_status != AUDIOD_ON || !stat_task->playing) - return kill_all_decoders(); - if (open_current_receiver(s)) - s->timeout = min_delay; - FOR_EACH_SLOT(i) { - struct slot_info *sl = &slot[i]; - struct audio_format_info *a; - - if (sl->format < 0) - continue; - a = &afi[sl->format]; - if (!sl->receiver_node) - continue; - if (!a->num_filters) { - if (sl->receiver_node->loaded && !sl->wng) { - open_writers(i); - s->timeout = min_delay; - } - continue; - } - if (sl->receiver_node->loaded && !sl->fc) { - open_filters(i); - s->timeout = min_delay; - continue; - } - if (sl->fc && *sl->fc->out_loaded && !sl->wng) { - open_writers(i); - s->timeout = min_delay; - } - } -} - -static void audiod_post_select(__a_unused struct sched *s, - __a_unused struct task *t) -{ - int i; - - /* save away the current time for other users */ - t->ret = 1; - FOR_EACH_SLOT(i) - try_to_close_slot(i); -} - -static void init_audiod_task(struct task *t) -{ - t->pre_select = audiod_pre_select; - t->post_select = audiod_post_select; - t->event_handler = NULL; - t->private_data = t; - sprintf(t->status, "audiod task"); + return 1; } static int parse_stream_command(const char *txt, char **cmd) @@ -679,10 +613,10 @@ static int add_filter(int format, char *cmdline) filter_num = check_filter_arg(cmdline, &a->filter_conf[nf]); if (filter_num < 0) return filter_num; - a->filters[nf] = &filters[filter_num]; + a->filter_nums[nf] = filter_num; a->num_filters++; - PARA_INFO_LOG("%s filter %d: %s\n", audio_formats[format], nf + 1, - a->filters[nf]->name); + PARA_INFO_LOG("%s filter %d: %s\n", audio_formats[format], nf, + filters[filter_num].name); return filter_num; } @@ -693,7 +627,7 @@ static int init_writers(void) struct audio_format_info *a; init_supported_writers(); - nw = PARA_MAX(1, conf.writer_given); + nw = PARA_MAX(1U, conf.writer_given); PARA_INFO_LOG("maximal number of writers: %d\n", nw); FOR_EACH_AUDIO_FORMAT(i) { a = &afi[i]; @@ -735,18 +669,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; @@ -810,11 +744,11 @@ static int init_filters(void) int i, ret, nf; filter_init(filters); - nf = PARA_MAX(1, conf.filter_given); + nf = PARA_MAX(1U, conf.filter_given); PARA_INFO_LOG("maximal number of filters: %d\n", nf); FOR_EACH_AUDIO_FORMAT(i) { afi[i].filter_conf = para_malloc(nf * sizeof(void *)); - afi[i].filters = para_malloc(nf * sizeof(struct filter *)); + afi[i].filter_nums = para_malloc(nf * sizeof(unsigned)); } if (!conf.no_default_filters_given) return init_default_filters(); @@ -854,10 +788,11 @@ static int init_stream_io(void) return 1; } +/* does not unlink socket on errors */ static int audiod_get_socket(void) { struct sockaddr_un unix_addr; - int fd; + int ret, fd; if (conf.socket_given) socket_name = para_strdup(conf.socket_arg); @@ -870,161 +805,273 @@ static int audiod_get_socket(void) PARA_NOTICE_LOG("local socket: %s\n", socket_name); if (conf.force_given) unlink(socket_name); - fd = create_pf_socket(socket_name, &unix_addr, - S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IWOTH); - if (fd < 0) { - PARA_EMERG_LOG("%s", "can not connect to socket\n"); - exit(EXIT_FAILURE); /* do not unlink socket */ - } + ret = create_local_socket(socket_name, &unix_addr, + S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IWOTH); + if (ret < 0) + goto err; + fd = ret; if (listen(fd , 5) < 0) { - PARA_EMERG_LOG("%s", "can not listen on socket\n"); - exit(EXIT_FAILURE); /* do not unlink socket */ + ret = -ERRNO_TO_PARA_ERROR(errno); + goto err; } - add_close_on_fork_list(fd); - mark_fd_nonblock(fd); + ret = mark_fd_nonblocking(fd); + if (ret < 0) + goto err; return fd; +err: + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); + exit(EXIT_FAILURE); } -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) -{ - 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); -} - -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; + struct signal_task *st = container_of(t, struct signal_task, task); 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; + struct signal_task *st = container_of(t, struct signal_task, task); + if (!FD_ISSET(st->fd, &s->rfds)) return; - t->ret = -E_SIGNAL_CAUGHT; + st->signum = para_next_signal(); + 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_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; - st->task.private_data = st; sprintf(st->task.status, "signal task"); } static void command_pre_select(struct sched *s, struct task *t) { - struct command_task *ct = t->private_data; - t->ret = 1; + struct command_task *ct = container_of(t, struct command_task, task); para_fd_set(ct->fd, &s->rfds, &s->max_fileno); - } static void command_post_select(struct sched *s, struct task *t) { int ret; - struct command_task *ct = t->private_data; + struct command_task *ct = container_of(t, struct command_task, task); - 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); if (ret < 0) - PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); } static void init_command_task(struct command_task *ct) { ct->task.pre_select = command_pre_select; ct->task.post_select = command_post_select; - ct->task.event_handler = NULL; - ct->task.private_data = ct; + ct->task.error = 0; ct->fd = audiod_get_socket(); /* doesn't return on errors */ 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->ct) + return; + client_close(stat_task->ct); + stat_task->ct = NULL; + FOR_EACH_STATUS_ITEM(i) { + free(stat_item_values[i]); + 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; +} + +/** + * 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(); - /* avoid busy loop if server is down */ - tv_add(now, &delay, &st->restart_barrier); - FOR_EACH_AUDIO_FORMAT(i) - afi[i].restart_barrier = st->restart_barrier; + exit(status); } -static void status_pre_select(struct sched *s, struct task *t) +/* avoid busy loop if server is down */ +static void set_stat_task_restart_barrier(unsigned seconds) { - 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'; - } - if (st->fd >= 0 && audiod_status != AUDIOD_OFF) - para_fd_set(st->fd, &s->rfds, &s->max_fileno); + struct timeval delay = {seconds, 0}; + tv_add(now, &delay, &stat_task->restart_barrier); } -static void status_post_select(struct sched *s, struct task *t) +static void try_to_close_slot(int slot_num) { - struct status_task *st = t->private_data; + struct slot_info *s = &slot[slot_num]; - t->ret = 1; - if (st->fd < 0 || !FD_ISSET(st->fd, &s->rfds)) + if (s->format < 0) 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 (s->receiver_node && s->receiver_node->task.error != -E_TASK_UNREGISTERED) return; + if (s->fc && s->fc->task.error != -E_TASK_UNREGISTERED) + return; + if (s->wng && s->wng->task.error != -E_TASK_UNREGISTERED) + return; + PARA_INFO_LOG("closing slot %d\n", slot_num); + wng_close(s->wng); + close_filters(s->fc); + free(s->fc); + close_receiver(slot_num); + clear_slot(slot_num); +} + +/* + * Check if any receivers/filters/writers need to be started and do so if + * necessary. + */ +static void start_stop_decoders(struct sched *s) +{ + int i; + + FOR_EACH_SLOT(i) + try_to_close_slot(i); + if (audiod_status != AUDIOD_ON || !stat_task->playing) + return kill_all_decoders(-E_NOT_PLAYING); + open_current_receiver(s); + FOR_EACH_SLOT(i) { + struct slot_info *sl = &slot[i]; + struct audio_format_info *a; + struct timeval diff; + + if (sl->format < 0) + continue; + a = &afi[sl->format]; + if (!sl->receiver_node) + continue; + if ((!a->num_filters || sl->fc) && sl->wng) + continue; /* everything already started */ + if (!a->num_filters) { + if (sl->receiver_node->loaded && !sl->wng) { + open_writers(i); + } + continue; + } + if (sl->receiver_node->loaded && !sl->fc) { + open_filters(i); + continue; + } + if (sl->wng || !sl->fc || !*sl->fc->out_loaded) + continue; + if (tv_diff(now, &initial_delay_barrier, &diff) > 0) { + open_writers(i); + continue; + } + PARA_INFO_LOG("initial delay: %lu ms left\n", tv2ms(&diff)); + if (tv_diff(&s->timeout, &diff, NULL) > 0) { + s->timeout = diff; + } } - st->buf[t->ret + st->loaded] = '\0'; - st->loaded = for_each_line(st->buf, t->ret + st->loaded, - &check_stat_line); +} + + +/* restart the client task if necessary */ +static void status_pre_select(struct sched *s, struct task *t) +{ + struct status_task *st = container_of(t, struct status_task, task); + + if (audiod_status == AUDIOD_OFF) { + if (!st->ct) + goto out; + if (st->ct->task.error >= 0) { + st->ct->task.error = -E_AUDIOD_OFF; + goto out; + } + if (st->ct->task.error != -E_TASK_UNREGISTERED) + goto out; + close_stat_pipe(); + st->clock_diff_count = conf.clock_diff_count_arg; + goto out; + } + if (st->ct) { + unsigned bytes_left; + if (st->ct->task.error < 0) { + if (st->ct->task.error != -E_TASK_UNREGISTERED) + goto out; + close_stat_pipe(); + goto out; + } + if (st->ct->status != CL_RECEIVING) + goto out; + bytes_left = for_each_line(st->ct->buf, st->ct->loaded, + &check_stat_line, NULL); + if (st->ct->loaded != bytes_left) { + st->last_status_read = *now; + st->ct->loaded = bytes_left; + } else { + struct timeval diff; + tv_diff(now, &st->last_status_read, &diff); + if (diff.tv_sec > 61) + st->ct->task.error = -E_STATUS_TIMEOUT; + } + goto out; + } + if (tv_diff(now, &st->restart_barrier, NULL) < 0) + goto out; + if (st->clock_diff_count) { /* get status only one time */ + char *argv[] = {"audiod", "stat", "1", NULL}; + int argc = 3; + PARA_INFO_LOG("clock diff count: %d\n", st->clock_diff_count); + st->clock_diff_count--; + client_open(argc, argv, &st->ct); + set_stat_task_restart_barrier(2); + + } else { + char *argv[] = {"audiod", "stat", NULL}; + int argc = 2; + client_open(argc, argv, &st->ct); + set_stat_task_restart_barrier(5); + } + free(stat_item_values[SI_BASENAME]); + stat_item_values[SI_BASENAME] = make_message( + "%s: no connection to para_server\n", + status_item_list[SI_BASENAME]); + stat_client_write(stat_item_values[SI_BASENAME], + SI_BASENAME); + st->last_status_read = *now; +out: + start_stop_decoders(s); } 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; + st->current_audio_format_num = -1; sprintf(st->task.status, "status task"); } @@ -1042,35 +1089,65 @@ static void set_initial_status(void) return; } if (strcmp(conf.mode_arg, "on")) - PARA_WARNING_LOG("%s", "invalid mode\n"); + PARA_WARNING_LOG("invalid mode\n"); +} + +__noreturn static void print_help_and_die(void) +{ + int d = conf.detailed_help_given; + const char **p = d? audiod_args_info_detailed_help + : audiod_args_info_help; + + printf_or_die("%s\n\n", AUDIOD_CMDLINE_PARSER_PACKAGE "-" + AUDIOD_CMDLINE_PARSER_VERSION); + printf_or_die("%s\n\n", audiod_args_info_usage); + for (; *p; p++) + printf_or_die("%s\n", *p); + print_receiver_helps(d); + print_filter_helps(d); + print_writer_helps(d); + exit(0); } + +/** + * 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; int ret, i; - struct sched s; + static struct sched s; struct command_task command_task_struct, *cmd_task = &command_task_struct; - struct task audiod_task_struct, *audiod_task = &audiod_task_struct; + struct audiod_cmdline_parser_params params = { + .override = 0, + .initialize = 1, + .check_required = 0, + .check_ambiguity = 0, + .print_errors = 1 + }; valid_fd_012(); - cmdline_parser(argc, argv, &conf); - para_drop_privileges(conf.user_arg, conf.group_arg); - cf = configfile_exists(); - if (cf) { - if (cmdline_parser_configfile(cf, &conf, 0, 0, 0)) { - PARA_EMERG_LOG("%s", "parse error in config file\n"); - exit(EXIT_FAILURE); - } - } + audiod_cmdline_parser_ext(argc, argv, &conf, ¶ms); + HANDLE_VERSION_FLAG("audiod", conf); + drop_privileges_or_die(conf.user_arg, conf.group_arg); + parse_config_or_die(); if (conf.logfile_given) logfile = open_log(conf.logfile_arg); - log_welcome("para_audiod", conf.loglevel_arg); i = init_stream_io(); + if (conf.help_given || conf.detailed_help_given) + print_help_and_die(); if (i < 0) { - PARA_EMERG_LOG("init stream io error: %s\n", PARA_STRERROR(-i)); + PARA_EMERG_LOG("init stream io error: %s\n", para_strerror(-i)); exit(EXIT_FAILURE); } + log_welcome("para_audiod", conf.loglevel_arg); server_uptime(UPTIME_SET); set_initial_status(); FOR_EACH_SLOT(i) @@ -1078,11 +1155,9 @@ int main(int argc, char *argv[]) init_grabbing(); setup_signal_handling(); signal_setup_default(sig_task); - sig_task->task.event_handler = signal_event_handler; init_status_task(stat_task); init_command_task(cmd_task); - init_audiod_task(audiod_task); if (conf.daemon_given) daemon_init(); @@ -1090,11 +1165,10 @@ int main(int argc, char *argv[]) register_task(&sig_task->task); 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); + ret = schedule(&s); - PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret)); + PARA_EMERG_LOG("%s\n", para_strerror(-ret)); return EXIT_FAILURE; }