X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=audiod.c;h=0f8fb1a7bd5bba86cc046dbd3224053ef5b079d2;hp=9708f4fa363f4ffa6d3540fc7cb27c79917f76ca;hb=9337bed6e84a4068e750fb6597646b45778eeba7;hpb=e57d2b9211bb734b71838142a7936fe6dfdc449c diff --git a/audiod.c b/audiod.c index 9708f4fa..0f8fb1a7 100644 --- a/audiod.c +++ b/audiod.c @@ -18,12 +18,12 @@ /** \file audiod.c the paraslash's audio daemon */ -#include /* gettimeofday */ #include "para.h" #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" @@ -35,6 +35,8 @@ #include "daemon.h" #include "string.h" #include "fd.h" +#include "write.h" +#include "write_common.h" /** define the array of error lists needed by para_audiod */ INIT_AUDIOD_ERRLISTS; @@ -52,91 +54,129 @@ enum {AUDIOD_OFF, AUDIOD_ON, AUDIOD_STANDBY}; /** defines how to handle one supported audio format */ struct audio_format_info { -/** pointer to the receiver for this audio format */ + /** pointer to the receiver for this audio format */ struct receiver *receiver; -/** the receiver configuration */ + /** the receiver configuration */ void *receiver_conf; -/** the number of filters that should be activated for this audio format */ + /** 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 */ + /** pointer to the array of filters to be activated */ struct filter **filters; -/** pointer to the array of filter configurations */ + /** pointer to the array of filter configurations */ void **filter_conf; -/** output of the last filter is written to stdin of this command */ - char *write_cmd; -/** do not start receiver/filters/writer before this time */ + /** the number of filters that should be activated for this audio format */ + unsigned int num_writers; + /** pointer to the array of writers to be activated */ + struct writer **writers; + /** pointer to the array of writer configurations */ + void **writer_conf; + /** do not start receiver/filters/writer before this time */ struct timeval restart_barrier; }; /** * describes one instance of a receiver-filter-writer chain * - * \sa receier_node, receiver, filter, filter_node, filter_chain_info + * \sa receier_node, receiver, filter, filter_node, filter_chain, writer, + * writer_node, writer_node_group. */ struct slot_info { -/** number of the audio format in this slot */ + /** number of the audio format in this slot */ int format; -/** the file descriptor of the writer */ - int write_fd; -/** the process id of the writer */ - pid_t wpid; -/** time of the last successful read from the receiver */ - struct timeval rtime; -/** time the last write to the write fd happend */ - struct timeval wtime; -/** writer start time */ + /** writer start time */ struct timeval wstime; -/** did we include \a write_fd in the fdset */ - int wcheck; -/** set to one if we have sent the TERM signal to \a wpid */ - int wkilled; -/** the receiver info associated with this slot */ + /** the receiver info associated with this slot */ struct receiver_node *receiver_node; -/** the active filter chain */ - struct filter_chain_info *fci; + /** the active filter chain */ + struct filter_chain *fc; + /** the active writer node group */ + struct writer_node_group *wng; }; - static struct slot_info slot[MAX_STREAM_SLOTS]; -/** defines one command of para_audiod */ -struct audiod_command { -/** the name of the command */ -const char *name; -/** pointer to the function that handles the command */ -int (*handler)(int, int, char**); -/** one-line description of the command */ -const char *description; -/** summary of the command line options */ -const char *synopsis; -/** the long help text */ -const char *help; -}; - extern const char *status_item_list[NUM_STAT_ITEMS]; -static int com_grab(int, int, char **); -static int com_cycle(int, int, char **); -static int com_help(int, int, char **); -static int com_off(int, int, char **); -static int com_on(int, int, char **); -static int com_sb(int, int, char **); -static int com_stat(int, int, char **); -static int com_term(int, int, char **); -static int stat_pipe = -1, signal_pipe; - static struct gengetopt_args_info conf; static struct timeval server_stream_start, sa_time_diff; static int playing, current_decoder = -1, audiod_status = AUDIOD_ON, offset_seconds, length_seconds, - sa_time_diff_sign = 1, audiod_socket = -1; + sa_time_diff_sign = 1; static char *af_status, /* the audio format announced in server status */ *socket_name, *hostname; static char *stat_item_values[NUM_STAT_ITEMS]; static FILE *logfile; -static const struct timeval restart_delay = {0, 300 * 1000}; - +static const struct timeval restart_delay = {0, 200 * 1000}; static struct audio_format_info afi[NUM_AUDIO_FORMATS]; +static struct timeval *now; + +static struct signal_task signal_task_struct, *sig_task = &signal_task_struct; + +/** + * the task for handling audiod commands + * + * \sa struct task, struct sched + */ +struct command_task { + /** the local listening socket */ + int fd; + /** the associated task structure */ + struct task task; +}; + +/** + * the task for audiod's child (para_client stat) + * + * \sa struct task, struct sched + */ +struct status_task { + /** the output of the stat command is read from this fd */ + int fd; + /** stat data is stored here */ + char buf[STRINGSIZE]; + /** number of bytes loaded in \a buf */ + unsigned loaded; + /** the associated task structure */ + struct task task; + /** do not restart client command until this time */ + struct timeval restart_barrier; +}; +static struct status_task status_task_struct, *stat_task = &status_task_struct; +struct signal_task { + int fd; + int signum; + struct task task; +}; + +/** defines one command of para_audiod */ +struct audiod_command { + /** the name of the command */ + const char *name; + /** pointer to the function that handles the command */ + int (*handler)(int, int, char**); + /** + * if the command prefers to handle the full line (rather than the usual + * argv[] array), it stores a pointer to the corresponding line handling + * function here. In this case, the above \a handler pointer must be NULL. + */ + int (*line_handler)(int, char*); + /** one-line description of the command */ + const char *description; + /** summary of the command line options */ + const char *synopsis; + /** the long help text */ + const char *help; +}; +static int com_grab(int, char *); +static int com_cycle(int, int, char **); +static int com_help(int, int, char **); +static int com_kill(int, int, char **); +static int com_off(int, int, char **); +static int com_on(int, int, char **); +static int com_sb(int, int, char **); +static int com_stat(int, int, char **); +static int com_tasks(int, int, char **); +static int com_term(int, int, char **); static struct audiod_command cmds[] = { { .name = "cycle", @@ -150,7 +190,7 @@ static struct audiod_command cmds[] = { }, { .name = "grab", -.handler = com_grab, +.line_handler = com_grab, .description = "grab the audio stream", .synopsis = "-- grab [grab_options]", .help = @@ -174,6 +214,16 @@ static struct audiod_command cmds[] = { "\n" " -- Beatles: Help\n" +}, +{ +.name = "kill", +.handler = com_kill, +.description = "kill an active audiod task", +.synopsis = "kill task_id [task_id ...]", +.help = + +"call sched_unregister() and the event_handler of the given task(s)\n" + }, { .name = "off", @@ -216,6 +266,16 @@ static struct audiod_command cmds[] = { "Dump given status items (all if none given) to stdout.\n" +}, +{ +.name = "tasks", +.handler = com_tasks, +.description = "list current tasks", +.synopsis = "tasks", +.help = + +"print the list of task ids together with the status of each task\n" + }, { .name = "term", @@ -233,7 +293,7 @@ static struct audiod_command cmds[] = { }; /** iterate over all slots */ -#define FOR_EACH_SLOT(slot) for (slot = 0; slot < MAX_STREAM_SLOTS; slot++) +#define FOR_EACH_SLOT(_slot) for (_slot = 0; _slot < MAX_STREAM_SLOTS; _slot++) /** iterate over all supported audio formats */ #define FOR_EACH_AUDIO_FORMAT(af) for (af = 0; af < NUM_AUDIO_FORMATS; af++) /** iterate over the array of all audiod commands */ @@ -268,17 +328,7 @@ void para_log(int ll, const char* fmt,...) if (ll < conf.loglevel_arg) return; - if (!logfile && conf.logfile_given) - logfile = open_log(conf.logfile_arg); - if (!logfile && conf.daemon_given) - return; - if (!logfile) { - if (ll < WARNING) - outfd = stdout; - else - outfd = stderr; - } else - outfd = logfile; + outfd = logfile? logfile : stderr; time(&t1); tm = localtime(&t1); strftime(str, MAXLINE, "%b %d %H:%M:%S", tm); @@ -298,7 +348,7 @@ static int client_write(int fd, const char *buf) static char *get_time_string(struct timeval *newest_stime) { - struct timeval now, diff, adj_stream_start, tmp; + struct timeval diff, adj_stream_start, tmp; int total = 0, use_server_time = 1; if (!playing) { @@ -322,8 +372,7 @@ static char *get_time_string(struct timeval *newest_stime) use_server_time = 0; } } - gettimeofday(&now, NULL); - tv_diff(&now, &tmp, &diff); + tv_diff(now, &tmp, &diff); total = diff.tv_sec + offset_seconds; if (total > length_seconds) total = length_seconds; @@ -358,7 +407,7 @@ static struct timeval *wstime(void) struct timeval *max = NULL; FOR_EACH_SLOT(i) { struct slot_info *s = &slot[i]; - if (s->wpid <= 0) + if (!s->wng) continue; if (max && tv_diff(&s->wstime, max, NULL) <= 0) continue; @@ -376,10 +425,8 @@ __malloc static char *decoder_flags(void) char flag = '0'; if (s->receiver_node) flag += 1; - if (s->wpid > 0) + if (s->wng) flag += 2; - if (flag != '0') - flag += s->format * 4; decoder_flags[i] = flag; } decoder_flags[MAX_STREAM_SLOTS] = '\0'; @@ -401,13 +448,14 @@ static char *configfile_exists(void) static void setup_signal_handling(void) { - signal_pipe = para_signal_init(); - PARA_INFO_LOG("signal pipe: fd %d\n", signal_pipe); + sig_task->fd = para_signal_init(); + 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); - signal(SIGPIPE, SIG_IGN); + para_install_sighandler(SIGPIPE); +// signal(SIGPIPE, SIG_IGN); } static void audiod_status_dump(void) @@ -451,30 +499,6 @@ static void clear_slot(int slot_num) s->format = -1; } -static void kill_stream_writer(int slot_num) -{ - struct slot_info *s = &slot[slot_num]; - - if (s->format < 0 || s->wkilled || s->wpid <= 0) - return; - PARA_DEBUG_LOG("kill -TERM %d (%s stream writer in slot %d)\n", - s->wpid, audio_formats[s->format], slot_num); - kill(s->wpid, SIGTERM); - s->wkilled = 1; - s->fci->error = 1; -} - -static void set_restart_barrier(int format, struct timeval *now) -{ - struct timeval tmp; - - if (now) - tmp = *now; - else - gettimeofday(&tmp, NULL); - tv_add(&tmp, &restart_delay, &afi[format].restart_barrier); -} - static void close_receiver(int slot_num) { struct slot_info *s = &slot[slot_num]; @@ -483,53 +507,40 @@ static void close_receiver(int slot_num) if (s->format < 0 || !s->receiver_node) return; a = &afi[s->format]; - PARA_NOTICE_LOG("closing %s recevier in slot %d\n", - audio_formats[s->format] , slot_num); + 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(s->format, NULL); + /* set restart barrier */ + tv_add(now, &restart_delay, &afi[s->format].restart_barrier); } static void kill_all_decoders(void) { int i; - FOR_EACH_SLOT(i) - if (slot[i].format >= 0) { - PARA_INFO_LOG("stopping decoder in slot %d\n", i); - kill_stream_writer(i); - } -} - -static void check_sigchld(void) -{ - pid_t pid; - int i; - struct timeval now; - gettimeofday(&now, NULL); - -reap_next_child: - pid = para_reap_child(); - if (pid <= 0) - return; FOR_EACH_SLOT(i) { struct slot_info *s = &slot[i]; - long lifetime; - if (s->format < 0) - continue; - if (pid == s->wpid) { - s->wpid = -1; - lifetime = now.tv_sec - s->wstime.tv_sec; - PARA_INFO_LOG("%s stream writer in slot %d died " - "after %li secs\n", - audio_formats[s->format], i, lifetime); - set_restart_barrier(s->format, &now); - goto reap_next_child; + if (s->wng && !s->wng->eof) { + PARA_INFO_LOG("unregistering writer node group in slot %d\n", + i); + wng_unregister(s->wng); + s->wng->eof = 1; + } + 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->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; } } - PARA_CRIT_LOG("para_client died (pid %d)\n", pid); - goto reap_next_child; } static int get_empty_slot(void) @@ -543,11 +554,7 @@ static int get_empty_slot(void) clear_slot(i); return i; } - if (s->write_fd > 0 || s->wpid > 0) - continue; - if (s->receiver_node) - continue; - if (s->fci) + if (s->wng || s->receiver_node || s->fc) continue; clear_slot(i); return i; @@ -564,7 +571,7 @@ static int decoder_running(int format) s = &slot[i]; if (s->format == format && s->receiver_node) ret |= 1; - if (s->format == format && s->wpid > 0) + if (s->format == format && s->wng) ret |= 2; } return ret; @@ -574,13 +581,13 @@ static void close_stat_pipe(void) { int i; - if (stat_pipe < 0) + if (stat_task->fd < 0) return; PARA_NOTICE_LOG("%s", "closing status pipe\n"); - close(stat_pipe); - del_close_on_fork_list(stat_pipe); - stat_pipe = -1; - kill_all_decoders(); + 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_item_values[i]); stat_item_values[i] = NULL; @@ -590,7 +597,8 @@ static void close_stat_pipe(void) offset_seconds = 0; audiod_status_dump(); playing = 0; - stat_item_values[SI_STATUS_BAR] = make_message("%s:no connection to para_server\n", + 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_item_values[SI_STATUS_BAR], SI_STATUS_BAR); } @@ -598,46 +606,33 @@ static void close_stat_pipe(void) static void __noreturn clean_exit(int status, const char *msg) { PARA_EMERG_LOG("%s\n", msg); - kill_all_decoders(); if (socket_name) unlink(socket_name); - if (stat_pipe >= 0) + if (stat_task->fd >= 0) close_stat_pipe(); exit(status); } -__malloc static char *glob_cmd(char *cmd) +/** + * get the number of filters + * + * \param audio_format_num the number identifying the audio format + * + * \return the number of filters for the given audio format + * + * \sa struct filter; + */ +int num_filters(int audio_format_num) { - char *ret, *replacement; - struct timeval tmp, delay, rss; /* real stream start */ - - delay.tv_sec = conf.stream_delay_arg / 1000; - delay.tv_usec = (conf.stream_delay_arg % 1000) * 1000; -// PARA_INFO_LOG("delay: %lu:%lu\n", delay.tv_sec, delay.tv_usec); - if (sa_time_diff_sign < 0) - tv_add(&server_stream_start, &sa_time_diff, &rss); - else - tv_diff(&server_stream_start, &sa_time_diff, &rss); - tv_add(&rss, &delay, &tmp); - replacement = make_message("%lu:%lu", tmp.tv_sec, tmp.tv_usec); - ret = s_a_r(cmd, "STREAM_START", replacement); - free(replacement); - if (!ret) - goto out; - PARA_INFO_LOG("cmd: %s, repl: %s\n", cmd, ret); - { - struct timeval now; - gettimeofday(&now, NULL); - PARA_INFO_LOG("now: %lu:%lu\n", now.tv_sec, now.tv_usec); - } -out: - return ret; + return afi[audio_format_num].num_filters; } -/** get the number of filters for the given audio format */ -int num_filters(int audio_format_num) +static void filter_event_handler(struct task *t) { - return afi[audio_format_num].num_filters; + 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) @@ -647,31 +642,37 @@ static void open_filters(int slot_num) int nf = a->num_filters; int i; - s->fci = para_calloc(sizeof(struct filter_chain_info)); - INIT_LIST_HEAD(&s->fci->filters); + s->fc = NULL; if (!nf) return; - s->fci->inbuf = s->receiver_node->buf; - s->fci->in_loaded = &s->receiver_node->loaded; - s->fci->outbuf = s->receiver_node->buf; - s->fci->out_loaded = &s->receiver_node->loaded; - s->fci->eof = &s->receiver_node->eof; + 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->inbuf = s->receiver_node->buf; + s->fc->in_loaded = &s->receiver_node->loaded; + s->fc->input_eof = &s->receiver_node->eof; + 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->receiver_node->output_eof = &s->fc->eof; + sprintf(s->fc->task.status, "filter chain"); for (i = 0; i < nf; i++) { struct filter_node *fn = para_calloc(sizeof(struct filter_node)); fn->conf = a->filter_conf[i]; - fn->fci = s->fci; + fn->fc = s->fc; fn->filter = a->filters[i]; INIT_LIST_HEAD(&fn->callbacks); - list_add_tail(&fn->node, &s->fci->filters); + list_add_tail(&fn->node, &s->fc->filters); fn->filter->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); - s->fci->outbuf = fn->buf; - s->fci->out_loaded = &fn->loaded; + s->fc->outbuf = fn->buf; + s->fc->out_loaded = &fn->loaded; } - PARA_DEBUG_LOG("output buffer for filter chain %p: %p\n", s->fci, - s->fci->outbuf); + register_task(&s->fc->task); } static struct filter_node *find_filter_node(int slot_num, int format, int filternum) @@ -681,7 +682,7 @@ static struct filter_node *find_filter_node(int slot_num, int format, int filter FOR_EACH_SLOT(i) { struct slot_info *s = &slot[i]; - if (s->format < 0 || !s->fci) + if (s->format < 0 || !s->fc) continue; if (slot_num >= 0 && slot_num != i) continue; @@ -691,7 +692,7 @@ static struct filter_node *find_filter_node(int slot_num, int format, int filter continue; /* success */ j = 1; - list_for_each_entry(fn, &s->fci->filters, node) + list_for_each_entry(fn, &s->fc->filters, node) if (filternum <= 0 || j++ == filternum) break; return fn; @@ -699,32 +700,61 @@ static struct filter_node *find_filter_node(int slot_num, int format, int filter return NULL; } -static void start_stream_writer(int slot_num) +static void wng_event_handler(struct task *t) { - int ret, fds[3] = {1, -1, -1}; + 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; struct slot_info *s = &slot[slot_num]; struct audio_format_info *a = &afi[s->format]; - char *glob = NULL; - - if (a->write_cmd) - glob = glob_cmd(a->write_cmd); - if (!glob) - glob = para_strdup("para_play"); - PARA_INFO_LOG("starting stream writer: %s\n", glob); - open_filters(slot_num); - ret = para_exec_cmdline_pid(&s->wpid, glob, fds); - free(glob); + + PARA_INFO_LOG("opening %s writers\n", audio_formats[s->format]); + if (!a->num_writers) + s->wng = setup_default_wng(); + else + s->wng = wng_new(a->num_writers); + 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->channels = &s->fc->channels; + s->wng->samplerate = &s->fc->samplerate; + s->fc->output_eof = &s->wng->eof; + 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->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("exec failed (%d)\n", ret); + PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); return; } - s->write_fd = fds[0]; - add_close_on_fork_list(s->write_fd); - /* we write to this fd in do_select, so we need non-blocking */ - mark_fd_nonblock(s->write_fd); - gettimeofday(&s->wstime, NULL); + s->wstime = *now; current_decoder = slot_num; - activate_inactive_grab_clients(slot_num, s->format, &s->fci->filters); + 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; } static void open_receiver(int format) @@ -732,16 +762,17 @@ static void open_receiver(int format) struct audio_format_info *a = &afi[format]; struct slot_info *s; int ret, slot_num; + struct receiver_node *rn; slot_num = get_empty_slot(); if (slot_num < 0) clean_exit(EXIT_FAILURE, PARA_STRERROR(-slot_num)); s = &slot[slot_num]; s->format = format; - gettimeofday(&s->rtime, NULL); - s->wtime = s->rtime; s->receiver_node = para_calloc(sizeof(struct receiver_node)); - s->receiver_node->conf = a->receiver_conf; + rn = s->receiver_node; + rn->receiver = a->receiver; + rn->conf = a->receiver_conf; ret = a->receiver->open(s->receiver_node); if (ret < 0) { PARA_ERROR_LOG("failed to open receiver (%s)\n", @@ -752,18 +783,22 @@ static void open_receiver(int format) } 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); } static int is_frozen(int format) { - struct timeval now; struct audio_format_info *a = &afi[format]; - gettimeofday(&now, NULL); - return (tv_diff(&now, &a->restart_barrier, NULL) > 0)? 0 : 1; + return (tv_diff(now, &a->restart_barrier, NULL) > 0)? 0 : 1; } -static void start_current_receiver(void) +static void open_current_receiver(struct sched *s) { int i; @@ -772,21 +807,27 @@ static void start_current_receiver(void) i = get_audio_format_num(af_status); if (i < 0) return; - if ((decoder_running(i) & 1) || is_frozen(i)) + if (decoder_running(i) || is_frozen(i)) return; open_receiver(i); + /* + * the receiver didn't get a chance to put his fd to the fd set. + * Make the upcoming select() return immediately to avoid a long + * timeout. + */ + s->timeout.tv_sec = 0; + s->timeout.tv_usec = 1; } static void compute_time_diff(const struct timeval *status_time) { - struct timeval now, tmp, diff; + struct timeval tmp, diff; static int count; int sign; const struct timeval max_deviation = {0, 500 * 1000}; const int time_smooth = 5; - gettimeofday(&now, NULL); - sign = tv_diff(status_time, &now, &diff); + 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); if (!count) { @@ -807,20 +848,22 @@ static void compute_time_diff(const struct timeval *status_time) count > 10? sign : sign * time_smooth, &diff, &tmp); sa_time_diff = tmp; - PARA_INFO_LOG("time diff (cur/avg): " - "%li:%lu/%li:%lu\n", - sign * diff.tv_sec, (diff.tv_usec + 500) / 1000, - sa_time_diff_sign * sa_time_diff.tv_sec, - (sa_time_diff.tv_usec + 500)/ 1000); + PARA_DEBUG_LOG("time diff (cur/avg): %s%lums/%s%lums\n", + sign > 0? "+" : "-", + tv2ms(&diff), + sa_time_diff_sign ? "+" : "-", + tv2ms(&sa_time_diff) + ); } static void check_stat_line(char *line) { int itemnum; size_t ilen = 0; - struct timeval tv; + long unsigned sec, usec; char *tmp; +// PARA_INFO_LOG("line: %s\n", line); if (!line) return; itemnum = stat_line_valid(line); @@ -849,14 +892,16 @@ static void check_stat_line(char *line) length_seconds = atoi(line + ilen + 1); break; case SI_STREAM_START: - if (sscanf(line + ilen + 1, "%lu.%lu", - &tv.tv_sec, &tv.tv_usec) == 2) - server_stream_start = tv; + if (sscanf(line + ilen + 1, "%lu.%lu", &sec, &usec) == 2) { + server_stream_start.tv_sec = sec; + server_stream_start.tv_usec = usec; + } break; case SI_CURRENT_TIME: - if (sscanf(line + ilen + 1, "%lu.%lu", &tv.tv_sec, - &tv.tv_usec) == 2) + if (sscanf(line + ilen + 1, "%lu.%lu", &sec, &usec) == 2) { + struct timeval tv = {sec, usec}; compute_time_diff(&tv); + } break; } } @@ -865,7 +910,12 @@ static void handle_signal(int sig) { switch (sig) { case SIGCHLD: - return check_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: @@ -875,181 +925,77 @@ static void handle_signal(int sig) } } -static void check_timeouts(void) +static void try_to_close_slot(int slot_num) { - struct timeval now; - int slot_num, timeout = conf.stream_timeout_arg; - - gettimeofday(&now, NULL); - FOR_EACH_SLOT(slot_num) { - struct slot_info *s = &slot[slot_num]; - if (s->format < 0) - continue; - /* check read time */ - if (s->receiver_node && - now.tv_sec > s->rtime.tv_sec + timeout) { - PARA_INFO_LOG("%s input buffer (slot %d) not ready\n", - audio_formats[s->format], slot_num); - if (s->fci) - s->fci->error = 42; - else - close_receiver(slot_num); - } - /* check write time */ - if (s->wpid > 0 && !s->wkilled && - now.tv_sec > s->wtime.tv_sec + timeout) { - PARA_INFO_LOG("%s output buffer (slot %d) not ready\n", - audio_formats[s->format], slot_num); - if (s->fci) - s->fci->error = 42; - } - } -} - -static size_t get_loaded_bytes(int slot_num) -{ - size_t loaded = 0; struct slot_info *s = &slot[slot_num]; - struct receiver_node *rn = s->receiver_node; - - if (s->format < 0) - goto out; - - if (afi[s->format].num_filters) { - if (s->fci) - loaded = *s->fci->out_loaded; - } else { - if (rn) - loaded = rn->loaded; - } -out: - return loaded; -} - - -static void close_decoder_if_idle(int slot_num) -{ - struct slot_info *s = &slot[slot_num]; - struct receiver_node *rn = s->receiver_node; if (s->format < 0) return; - if (!s->fci) + if (s->receiver_node && !s->receiver_node->eof) return; - if (!rn->eof && !s->fci->error && s->wpid > 0) + if (s->fc && !s->fc->eof) return; - if (!s->fci->error && s->wpid > 0) { /* eof */ - if (filter_io(s->fci) > 0) - return; - if (get_loaded_bytes(slot_num)) - return; - } - if (s->write_fd > 0) { - PARA_INFO_LOG("slot %d: closing write fd %d\n", slot_num, - s->write_fd); - close(s->write_fd); - del_close_on_fork_list(s->write_fd); - s->write_fd = -1; - } - if (s->wpid > 0) - return; /* wait until writer dies before closing filters */ - PARA_INFO_LOG("closing all filters in slot %d (filter_chain %p)\n", - slot_num, s->fci); - close_filters(s->fci); - free(s->fci); + 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); } -static int set_stream_fds(fd_set *wfds) +static void audiod_pre_select(struct sched *s, __a_unused struct task *t) { - int i, max_fileno = -1; + int i; - check_timeouts(); + t->ret = 1; + now = &s->now; + if (audiod_status != AUDIOD_ON || !playing) + kill_all_decoders(); + else if (playing) + open_current_receiver(s); FOR_EACH_SLOT(i) { struct slot_info *s = &slot[i]; struct audio_format_info *a; - struct receiver_node *rn; - close_decoder_if_idle(i); - s->wcheck = 0; if (s->format < 0) continue; a = &afi[s->format]; - rn = s->receiver_node; - if (rn && rn->loaded && !s->wpid) { - PARA_INFO_LOG("no writer in slot %d\n", i); - start_stream_writer(i); - } - if (s->write_fd <= 0) + if (!s->receiver_node) + continue; + if (!a->num_filters) { + if (s->receiver_node->loaded && !s->wng) + open_writers(i); continue; - if (!get_loaded_bytes(i)) + } + if (s->receiver_node->loaded && !s->fc) { + open_filters(i); continue; - FD_SET(s->write_fd, wfds); - s->wcheck = 1; - max_fileno = MAX(s->write_fd, max_fileno); + } + if (s->fc && *s->fc->out_loaded && !s->wng) + open_writers(i); } -// PARA_INFO_LOG("return %d\n", max_fileno); - return max_fileno; } -static int write_audio_data(int slot_num) +static void audiod_post_select(struct sched *s, __a_unused struct task *t) { - struct slot_info *s = &slot[slot_num]; - struct audio_format_info *a = &afi[s->format]; - struct receiver_node *rn = s->receiver_node; - int rv; - char **buf; - size_t *len; - - if (a->num_filters) { - buf = &s->fci->outbuf; - len = s->fci->out_loaded; - } else { - buf = &rn->buf; - len = &rn->loaded; - } - PARA_DEBUG_LOG("writing %p (%zd bytes)\n", *buf, *len); - rv = write(s->write_fd, *buf, *len); - PARA_DEBUG_LOG("wrote %d/%zd\n", rv, *len); - if (rv < 0) { - PARA_WARNING_LOG("write error in slot %d (fd %d): %s\n", - slot_num, s->write_fd, strerror(errno)); - *len = 0; - s->fci->error = E_WRITE_AUDIO_DATA; - } else if (rv != *len) { - PARA_DEBUG_LOG("partial %s write (%i/%zd) for slot %d\n", - audio_formats[s->format], rv, *len, slot_num); - *len -= rv; - memmove(*buf, *buf + rv, *len); - } else - *len = 0; - if (rv > 0) - gettimeofday(&s->wtime, NULL); - return rv; + int i; + + /* save away the current time for other users */ + now = &s->now; + t->ret = 1; + FOR_EACH_SLOT(i) + try_to_close_slot(i); } -static void slot_io(fd_set *wfds) +static void init_audiod_task(struct task *t) { - int ret, i; - - FOR_EACH_SLOT(i) { - struct slot_info *s = &slot[i]; - struct receiver_node *rn = s->receiver_node; - - if (rn && rn->loaded) - gettimeofday(&s->rtime, NULL); - if (s->format >= 0 && s->write_fd > 0 && s->fci) { - ret = filter_io(s->fci); - if (ret < 0) - s->fci->error = -ret; -// PARA_DEBUG_LOG("slot %d, filter io %d bytes, check write: %d, loaded: %d/%d, eof: %d\n", -// i, ret, s->wcheck, rn->loaded, *s->fci->out_loaded, rn->eof); - } - if (s->write_fd <= 0 || !s->wcheck || !FD_ISSET(s->write_fd, wfds)) - continue; - write_audio_data(i); - } + 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"); } static int parse_stream_command(const char *txt, char **cmd) @@ -1084,52 +1030,51 @@ static int add_filter(int format, char *cmdline) return filter_num; } -static int setup_default_filters(void) +static int init_writers(void) { - int i, ret = 1; + int i, ret, nw; + char *cmd; + struct audio_format_info *a; + init_supported_writers(); + nw = PARA_MAX(1, conf.writer_given); + PARA_INFO_LOG("maximal number of writers: %d\n", nw); FOR_EACH_AUDIO_FORMAT(i) { - struct audio_format_info *a = &afi[i]; - char *tmp; - int j; - if (a->num_filters) - continue; - /* add "dec" to audio format name */ - tmp = make_message("%sdec", audio_formats[i]); - for (j = 0; filters[j].name; j++) - if (!strcmp(tmp, filters[j].name)) - break; - free(tmp); - ret = -E_UNSUPPORTED_FILTER; - if (!filters[j].name) - goto out; - tmp = para_strdup(filters[j].name); - ret = add_filter(i, tmp); - free(tmp); + a = &afi[i]; + a->writer_conf = para_malloc(nw * sizeof(void *)); + a->writers = para_malloc(nw * sizeof(struct writer *)); + a->num_writers = 0; + } + for (i = 0; i < conf.writer_given; i++) { + void *wconf; + int writer_num; + ret = parse_stream_command(conf.writer_arg[i], &cmd); if (ret < 0) goto out; - PARA_INFO_LOG("%s -> default filter: %s\n", audio_formats[i], filters[j].name); - ret = add_filter(i, para_strdup("wav")); - if (ret < 0) + a = &afi[ret]; + nw = a->num_writers; + wconf = check_writer_arg(cmd, &writer_num); + if (!wconf) { + ret = writer_num; goto out; - PARA_INFO_LOG("%s -> default filter: wav\n", audio_formats[i]); + } + a->writers[nw] = &writers[writer_num]; + a->writer_conf[nw] = wconf; + PARA_INFO_LOG("%s writer #%d: %s\n", audio_formats[ret], + nw, writer_names[writer_num]); + a->num_writers++; } + ret = 1; out: return ret; } -static int init_stream_io(void) +static int init_receivers(void) { int i, ret, receiver_num; - char *cmd; + char *cmd = NULL; + struct audio_format_info *a; - for (i = 0; i < conf.stream_write_cmd_given; i++) { - ret = parse_stream_command(conf.stream_write_cmd_arg[i], &cmd); - if (ret < 0) - goto out; - afi[ret].write_cmd = para_strdup(cmd); - PARA_INFO_LOG("%s write command: %s\n", audio_formats[ret], afi[ret].write_cmd); - } for (i = 0; receivers[i].name; i++) { PARA_INFO_LOG("initializing %s receiver\n", receivers[i].name); receivers[i].init(&receivers[i]); @@ -1158,7 +1103,7 @@ static int init_stream_io(void) */ cmd = para_strdup(receivers[0].name); FOR_EACH_AUDIO_FORMAT(i) { - struct audio_format_info *a = &afi[i]; + a = &afi[i]; if (a->receiver_conf) continue; a->receiver_conf = check_receiver_arg(cmd, &receiver_num); @@ -1166,15 +1111,57 @@ static int init_stream_io(void) return -E_RECV_SYNTAX; a->receiver = &receivers[receiver_num]; } + ret = 1; +out: free(cmd); - /* filters */ + return ret; +} + +static int init_default_filters(void) +{ + int i, ret = 1; + + FOR_EACH_AUDIO_FORMAT(i) { + struct audio_format_info *a = &afi[i]; + char *tmp; + int j; + + if (a->num_filters) + continue; /* no default -- nothing to to */ + /* add "dec" to audio format name */ + tmp = make_message("%sdec", audio_formats[i]); + for (j = 0; filters[j].name; j++) + if (!strcmp(tmp, filters[j].name)) + break; + free(tmp); + ret = -E_UNSUPPORTED_FILTER; + if (!filters[j].name) + goto out; + tmp = para_strdup(filters[j].name); + ret = add_filter(i, tmp); + free(tmp); + if (ret < 0) + goto out; + PARA_INFO_LOG("%s -> default filter: %s\n", audio_formats[i], + filters[j].name); + } +out: + return ret; +} + +static int init_filters(void) +{ + int i, ret, nf; + filter_init(filters); + nf = PARA_MAX(1, conf.filter_given); + PARA_INFO_LOG("maximal number of filters: %d\n", nf); FOR_EACH_AUDIO_FORMAT(i) { - afi[i].filter_conf = para_malloc((conf.filter_given + 1) * sizeof(char *)); - afi[i].filters = para_malloc((conf.filter_given + 1) * sizeof(struct filter *)); + afi[i].filter_conf = para_malloc(nf * sizeof(void *)); + afi[i].filters = para_malloc(nf * sizeof(struct filter *)); } if (!conf.no_default_filters_given) - return setup_default_filters(); + return init_default_filters(); for (i = 0; i < conf.filter_given; i++) { char *arg = conf.filter_arg[i]; char *filter_name = strchr(arg, ':'); @@ -1190,11 +1177,27 @@ static int init_stream_io(void) if (ret < 0) goto out; } - ret = 1; + ret = init_default_filters(); /* use default values for the rest */ out: return ret; } +static int init_stream_io(void) +{ + int ret; + + ret = init_writers(); + if (ret < 0) + return ret; + ret = init_receivers(); + if (ret < 0) + return ret; + ret = init_filters(); + if (ret < 0) + return ret; + return 1; +} + static int dump_commands(int fd) { char *buf = para_strdup(""), *tmp = NULL; @@ -1253,7 +1256,34 @@ out: return ret; } -static int com_stat(int fd, __unused int argc, __unused char **argv) +static int com_tasks(int fd, __a_unused int argc, __a_unused char **argv) +{ + char *tl = get_task_list(); + int ret = 1; + if (tl) + ret = client_write(fd, tl); + free(tl); + if (ret > 0) + close(fd); + return ret; +} + +static int com_kill(int fd, int argc, char **argv) +{ + int i, ret = 1; + if (argc < 2) + return -E_AUDIOD_SYNTAX; + for (i = 1; i < argc; i++) { + ret = kill_task(argv[i]); + if (ret < 0) + break; + } + if (ret > 0) + close(fd); + return ret; +} + +static int com_stat(int fd, __a_unused int argc, __a_unused char **argv) { int i, ret; char *buf = NULL; @@ -1322,38 +1352,14 @@ out: return ret; } -#if 0 -static char *list_filters(void) -{ - int i, j; - char *tmp, *msg = make_message("format\tnum\tcmd\n"); - - FOR_EACH_AUDIO_FORMAT(i) { - for (j = 0; j < afi[i].num_filters; j++) { - tmp = make_message("%s\t%i\t%s\n", - afi[i].name, j, afi[i].filter_cmds[j]); - msg = para_strcat(msg, tmp); - free(tmp); - } - tmp = make_message("%s\t%i\t%s\n", afi[i].name, - j, afi[i].write_cmd); - msg = para_strcat(msg, tmp); - free(tmp); - } - return msg; -} -#endif - -static int com_grab(int fd, int argc, char **argv) +static int com_grab(int fd, char *cmdline) { struct grab_client *gc; struct filter_node *fn; int i, err; char *msg; - PARA_INFO_LOG("argc: %d, argv[0]: %s, optind: %d\n", argc, argv[0], optind); - gc = grab_client_new(fd, argc, argv, &err); - PARA_INFO_LOG("argc: %d, argv[0]: %s, optind: %d\n", argc, argv[0], optind); + gc = grab_client_new(fd, cmdline, &err); if (!gc) goto err_out; fn = find_filter_node(gc->conf->slot_arg, gc->audio_format_num, gc->conf->filter_num_arg); @@ -1383,27 +1389,27 @@ err_out: return 1; } -static int __noreturn com_term(int fd, __unused int argc, __unused char **argv) +static int __noreturn com_term(int fd, __a_unused int argc, __a_unused char **argv) { close(fd); clean_exit(EXIT_SUCCESS, "terminating on user request"); } -static int com_on(int fd, __unused int argc, __unused char **argv) +static int com_on(int fd, __a_unused int argc, __a_unused char **argv) { audiod_status = AUDIOD_ON; close(fd); return 1; } -static int com_off(int fd, __unused int argc, __unused char **argv) +static int com_off(int fd, __a_unused int argc, __a_unused char **argv) { audiod_status = AUDIOD_OFF; close(fd); return 1; } -static int com_sb(int fd, __unused int argc, __unused char **argv) +static int com_sb(int fd, __a_unused int argc, __a_unused char **argv) { audiod_status = AUDIOD_STANDBY; close(fd); @@ -1427,47 +1433,64 @@ static int com_cycle(int fd, int argc, char **argv) return 1; } -static int check_perms(struct ucred *c) +static int check_perms(uid_t uid) { int i; if (!conf.user_allow_given) return 1; for (i = 0; i < conf.user_allow_given; i++) - if (c->uid == conf.user_allow_arg[i]) + if (uid == conf.user_allow_arg[i]) return 1; return -E_UCRED_PERM; } -static int handle_connect(void) +static int handle_connect(int accept_fd) { int i, argc, ret, clifd = -1; - struct ucred c; - char *buf = para_malloc(MAXLINE), **argv = NULL; + char *cmd = NULL, *p, *buf = para_calloc(MAXLINE), **argv = NULL; struct sockaddr_un unix_addr; - ret = para_accept(audiod_socket, &unix_addr, sizeof(struct sockaddr_un)); + ret = para_accept(accept_fd, &unix_addr, sizeof(struct sockaddr_un)); if (ret < 0) goto out; clifd = ret; - ret = recv_cred_buffer(clifd, buf, MAXLINE - 1, &c); + ret = recv_cred_buffer(clifd, buf, MAXLINE - 1); if (ret < 0) goto out; - PARA_INFO_LOG("pid: %i, uid: %i, gid: %i, ret: %i, buf: %s\n", c.pid, c.uid, c.gid, ret, buf); - buf[ret] = '\0'; - ret = check_perms(&c); + PARA_INFO_LOG("connection from user %i, buf: %s\n", ret, buf); + ret = check_perms(ret); if (ret < 0) goto out; - argc = split_args(buf, &argv, '\n'); - PARA_INFO_LOG("argv[0]: %s\n", argv[0]); + ret = -E_INVALID_AUDIOD_CMD; + cmd = para_strdup(buf); + p = strchr(cmd, '\n'); + if (!p) + p = ""; + else { + *p = '\0'; + p++; + } for (i = 0; cmds[i].name; i++) { - if (strcmp(cmds[i].name, argv[0])) + int j; + if (strcmp(cmds[i].name, cmd)) continue; - ret = cmds[i].handler(clifd, argc + 1, argv); + if (cmds[i].handler) { + argc = split_args(buf, &argv, "\n"); + PARA_INFO_LOG("argv[0]: %s, argc= %d\n", argv[0], argc); + ret = cmds[i].handler(clifd, argc, argv); + goto out; + } + for (j = 0; p[j]; j++) + if (p[j] == '\n') + p[j] = ' '; + PARA_INFO_LOG("cmd: %s, options: %s\n", cmd, p); + ret = cmds[i].line_handler(clifd, p); goto out; } ret = -E_INVALID_AUDIOD_CMD; /* cmd not found */ out: + free(cmd); free(buf); free(argv); if (clifd > 0 && ret < 0 && ret != -E_CLIENT_WRITE) { @@ -1479,9 +1502,10 @@ out: return ret; } -static void audiod_get_socket(void) +static int audiod_get_socket(void) { struct sockaddr_un unix_addr; + int fd; if (conf.socket_given) socket_name = para_strdup(conf.socket_arg); @@ -1491,20 +1515,21 @@ static void audiod_get_socket(void) hn); free(hn); } - PARA_NOTICE_LOG("connecting to local socket %s\n", socket_name); + PARA_NOTICE_LOG("local socket: %s\n", socket_name); if (conf.force_given) unlink(socket_name); - audiod_socket = create_pf_socket(socket_name, &unix_addr, + fd = create_pf_socket(socket_name, &unix_addr, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IWOTH); - if (audiod_socket < 0) { + if (fd < 0) { PARA_EMERG_LOG("%s", "can not connect to socket\n"); exit(EXIT_FAILURE); /* do not unlink socket */ } - if (listen(audiod_socket, 5) < 0) { + if (listen(fd , 5) < 0) { PARA_EMERG_LOG("%s", "can not listen on socket\n"); exit(EXIT_FAILURE); /* do not unlink socket */ } - add_close_on_fork_list(audiod_socket); + add_close_on_fork_list(fd); + return fd; } static int open_stat_pipe(void) @@ -1521,123 +1546,131 @@ static int open_stat_pipe(void) return ret; } -static int audiod_pre_select(fd_set *rfds, fd_set *wfds, struct timeval *tv) +void signal_event_handler(struct task *t) { - int i, ret, max = -1; + struct signal_task *st = t->private_data; - FOR_EACH_SLOT(i) { - struct slot_info *s = &slot[i]; - struct audio_format_info *a; - struct receiver_node *rn = s->receiver_node; - if (s->format < 0 || !rn) - continue; - a = &afi[s->format]; - ret = a->receiver->pre_select(rn, rfds, wfds, tv); -// PARA_NOTICE_LOG("%s preselect: %d\n", a->receiver->name, ret); - max = MAX(max, ret); - } - return max; + 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) +{ + struct signal_task *st = t->private_data; + t->ret = 1; + para_fd_set(st->fd, &s->rfds, &s->max_fileno); } -static void audiod_post_select(int select_ret, fd_set *rfds, fd_set *wfds) + +void signal_post_select(struct sched *s, struct task *t) { - int i, ret; + struct signal_task *st = t->private_data; + t->ret = 1; + if (!FD_ISSET(st->fd, &s->rfds)) + return; + t->ret = -E_SIGNAL_CAUGHT; + st->signum = para_next_signal(); +} - FOR_EACH_SLOT(i) { - struct slot_info *s = &slot[i]; - struct audio_format_info *a; - struct receiver_node *rn = s->receiver_node; - if (s->format < 0 || !rn || rn->eof) - continue; - a = &afi[s->format]; - ret = a->receiver->post_select(rn, select_ret, rfds, wfds); - if (ret <= 0) { - if (ret) - PARA_ERROR_LOG("%s post select failed: %s (slot %d)\n", - a->receiver->name, PARA_STRERROR(-ret), i); - else - PARA_INFO_LOG("eof in slot %d\n", i); - rn->eof = 1; - } - if (ret < 0 && s->fci) - s->fci->error = ret; - } +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"); } -/* TODO: move everything before the select call to pre_select() */ -static void __noreturn audiod_mainloop(void) +static void command_pre_select(struct sched *s, struct task *t) { - fd_set rfds, wfds; - int ret, max_fileno, sbo = 0; - char status_buf[STRINGSIZE] = ""; - struct timeval tv; -repeat: - FD_ZERO(&wfds); - FD_ZERO(&rfds); - /* always check signal pipe and the local socket */ - FD_SET(signal_pipe, &rfds); - max_fileno = signal_pipe; - FD_SET(audiod_socket, &rfds); - max_fileno = MAX(max_fileno, audiod_socket); + struct command_task *ct = t->private_data; + t->ret = 1; + para_fd_set(ct->fd, &s->rfds, &s->max_fileno); - if (audiod_status != AUDIOD_ON) - kill_all_decoders(); - else if (playing) - start_current_receiver(); +} - max_fileno = MAX(max_fileno, set_stream_fds(&wfds)); - /* status pipe */ - if (stat_pipe >= 0 && audiod_status == AUDIOD_OFF) - close_stat_pipe(); - if (stat_pipe < 0 && audiod_status != AUDIOD_OFF) { - stat_pipe = open_stat_pipe(); - sbo = 0; - status_buf[0] = '\0'; - } - if (stat_pipe >= 0 && audiod_status != AUDIOD_OFF) { - FD_SET(stat_pipe, &rfds); - max_fileno = MAX(max_fileno, stat_pipe); - } - /* local socket */ - tv.tv_sec = 0; - tv.tv_usec = 200 * 1000; - ret = audiod_pre_select(&rfds, &wfds, &tv); - max_fileno = MAX(max_fileno, ret); +static void command_post_select(struct sched *s, struct task *t) +{ + int ret; + struct command_task *ct = t->private_data; - ret = para_select(max_fileno + 1, &rfds, &wfds, &tv); - if (ret < 0) - goto repeat; + t->ret = 1; /* always successful */ if (audiod_status != AUDIOD_OFF) audiod_status_dump(); - audiod_post_select(ret, &rfds, &wfds); - /* read status pipe */ - if (stat_pipe >=0 && FD_ISSET(stat_pipe, &rfds)) { - ret = read(stat_pipe, status_buf + sbo, STRINGSIZE - 1 - sbo); - if (ret <= 0) { - close_stat_pipe(); - /* avoid busy loop if server is down */ - while (sleep(1) > 0) - ; /* try again*/ - } else { - status_buf[ret + sbo] = '\0'; - sbo = for_each_line(status_buf, ret + sbo, - &check_stat_line); - } - } - slot_io(&wfds); - if (FD_ISSET(audiod_socket, &rfds)) { - ret = handle_connect(); - if (ret < 0) { - PARA_ERROR_LOG("%s\n", PARA_STRERROR(-ret)); - } + if (!FD_ISSET(ct->fd, &s->rfds)) + return; + ret = handle_connect(ct->fd); + if (ret < 0) + 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->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) +{ + struct timeval delay = {1, 0}; + int i; + struct status_task *st = t->private_data; + + PARA_ERROR_LOG("%s\n", PARA_STRERROR(-t->ret)); + 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; +} + +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'; } - /* signals */ - if (FD_ISSET(signal_pipe, &rfds)) { - int sig_nr = para_next_signal(); - if (sig_nr > 0) - handle_signal(sig_nr); + if (st->fd >= 0 && audiod_status != AUDIOD_OFF) + para_fd_set(st->fd, &s->rfds, &s->max_fileno); +} + +static void status_post_select(struct sched *s, struct task *t) +{ + struct status_task *st = t->private_data; + + t->ret = 1; + if (st->fd < 0 || !FD_ISSET(st->fd, &s->rfds)) + 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; + return; } - goto repeat; + st->buf[t->ret + st->loaded] = '\0'; + st->loaded = for_each_line(st->buf, t->ret + st->loaded, + &check_stat_line); +} + +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; + sprintf(st->task.status, "status task"); } static void set_initial_status(void) @@ -1657,27 +1690,33 @@ static void set_initial_status(void) PARA_WARNING_LOG("%s", "invalid mode\n"); } -int __noreturn main(int argc, char *argv[]) +int main(int argc, char *argv[]) { char *cf; - int i; + int ret, i; + struct sched s; + struct command_task command_task_struct, *cmd_task = &command_task_struct; + struct task audiod_task_struct, *audiod_task = &audiod_task_struct; + + init_sched(); valid_fd_012(); hostname = para_hostname(); cmdline_parser(argc, argv, &conf); - para_drop_privileges(conf.user_arg); + para_drop_privileges(conf.user_arg, conf.group_arg); cf = configfile_exists(); if (cf) { if (cmdline_parser_configfile(cf, &conf, 0, 0, 0)) { - fprintf(stderr, "parse error in config file\n"); + PARA_EMERG_LOG("%s", "parse error in config file\n"); exit(EXIT_FAILURE); } } + if (conf.logfile_given) + logfile = open_log(conf.logfile_arg); log_welcome("para_audiod", conf.loglevel_arg); i = init_stream_io(); if (i < 0) { - fprintf(stderr, "init stream io error: %s\n", - PARA_STRERROR(-i)); + PARA_EMERG_LOG("init stream io error: %s\n", PARA_STRERROR(-i)); exit(EXIT_FAILURE); } server_uptime(UPTIME_SET); @@ -1686,8 +1725,24 @@ int __noreturn main(int argc, char *argv[]) clear_slot(i); 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(); - audiod_get_socket(); /* doesn't return on errors */ - audiod_mainloop(); + + 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_usec = 99 * 1000; + ret = sched(&s); + + PARA_EMERG_LOG("%s\n", PARA_STRERROR(-ret)); + return EXIT_FAILURE; }