X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=audiod.c;h=6fd8eef15a5b3c5f0c07c16795155daa63691ddc;hp=12e8f7bb4345df416f2cdc0bc4c615fa7609129f;hb=3e3c069366dbb2bf8f157ad0a406bda67dd51783;hpb=41f13bf6cac519b46ed24892e2c84384ef5dc500;ds=sidebyside diff --git a/audiod.c b/audiod.c index 12e8f7bb..6fd8eef1 100644 --- a/audiod.c +++ b/audiod.c @@ -1,35 +1,24 @@ /* - * Copyright (C) 2005-2006 Andre Noll + * Copyright (C) 2005-2008 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 "para.h" - +#include "error.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" #include "grab_client.h" - -#include "error.h" +#include "client.cmdline.h" +#include "client.h" #include "audiod.h" #include "net.h" #include "daemon.h" @@ -37,22 +26,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}; -/** - * the possible modes of operation - * - * - off: disconnect from para_server - * - on: receive status information from para_server and play the audio stream - * - sb: only receive status information but not the audio stream -*/ -enum {AUDIOD_OFF, AUDIOD_ON, AUDIOD_STANDBY}; - -/** 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; @@ -75,205 +56,57 @@ struct audio_format_info { }; /** - * describes one instance of a receiver-filter-writer chain + * 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 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 */ - int format; - /** writer start time */ - struct timeval wstime; - /** the receiver info associated with this slot */ - struct receiver_node *receiver_node; - /** 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]; - -extern const char *status_item_list[NUM_STAT_ITEMS]; - -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; -static char *af_status, /* the audio format announced in server status */ - *socket_name, *hostname; -static char *stat_item_values[NUM_STAT_ITEMS]; + * \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; + +/** + * 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 const struct timeval restart_delay = {0, 300 * 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; +static struct status_task status_task_struct; + /** - * the task for handling audiod commands + * the task that calls the status command of para_server * - * \sa struct task, struct sched + * \sa struct status_task */ -struct command_task { - /** the local listening socket */ - int fd; - /** the associated task structure */ - struct task task; -}; +struct status_task *stat_task = &status_task_struct; +static struct timeval initial_delay_barrier; /** - * the task for audiod's child (para_client stat) + * the task for handling audiod commands * * \sa struct task, struct sched */ -struct status_task { - /** the output of the stat command is read from this fd */ +struct command_task { + /** the local listening socket */ 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; }; -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_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 struct audiod_command cmds[] = { -{ -.name = "cycle", -.handler = com_cycle, -.description = "switch to next mode", -.synopsis = "cycle", -.help = - -"on -> standby -> off -> on\n" - -}, -{ -.name = "grab", -.line_handler = com_grab, -.description = "grab the audio stream", -.synopsis = "-- grab [grab_options]", -.help = - -"grab ('splice') the audio stream at any position in the filter \n" -"chain and send that data back to the client. Try\n" -"\t para_audioc -- grab -h\n" -"for the list of available options.\n" -}, - -{ -.name = "help", -.handler = com_help, -.description = "display command list or help for given command", -.synopsis = "help [command]", -.help = - -"When I was younger, so much younger than today, I never needed\n" -"anybody's help in any way. But now these days are gone, I'm not so\n" -"self assured. Now I find I've changed my mind and opened up the doors.\n" -"\n" -" -- Beatles: Help\n" - -}, -{ -.name = "off", -.handler = com_off, -.description = "deactivate para_audiod", -.synopsis = "off", -.help = - -"Close connection to para_server and stop all decoders.\n" - -}, -{ -.name = "on", -.handler = com_on, -.description = "activate para_audiod", -.synopsis = "on", -.help = - -"Establish connection to para_server, retrieve para_server's current\n" -"status. If playing, start corresponding decoder. Otherwise stop\n" -"all decoders.\n" -}, -{ -.name = "sb", -.handler = com_sb, -.description = "enter standby mode", -.synopsis = "sb", -.help = - -"Stop all decoders but leave connection to para_server open.\n" - -}, -{ -.name = "stat", -.handler = com_stat, -.description = "print status information", -.synopsis = "stat [item1 ...]", -.help = - -"Dump given status items (all if none given) to stdout.\n" - -}, -{ -.name = "term", -.handler = com_term, -.description = "terminate audiod", -.synopsis = "term", -.help = - -"Stop all decoders, shut down connection to para_server and exit.\n" - -}, -{ -.name = NULL, -} -}; - -/** iterate over all slots */ -#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 */ -#define FOR_EACH_COMMAND(c) for (c = 0; cmds[c].name; c++) /** * get the audio format number @@ -285,14 +118,20 @@ static struct audiod_command cmds[] = { 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. +/** + * the log function of para_audiod + * + * \param ll loglevel + * \param fmt the format string */ void para_log(int ll, const char* fmt,...) { @@ -301,9 +140,14 @@ void para_log(int ll, const char* fmt,...) struct tm *tm; time_t t1; char str[MAXLINE] = ""; + static char *hostname; if (ll < conf.loglevel_arg) return; + if (!logfile && conf.daemon_given) + return; + if (!hostname) + hostname = para_hostname(); outfd = logfile? logfile : stderr; time(&t1); tm = localtime(&t1); @@ -316,110 +160,16 @@ void para_log(int ll, const char* fmt,...) va_end(argp); } -static int client_write(int fd, const char *buf) -{ - size_t len = strlen(buf); - return write(fd, buf, len) != len? -E_CLIENT_WRITE: 1; -} - -static char *get_time_string(struct timeval *newest_stime) -{ - struct timeval diff, adj_stream_start, tmp; - int total = 0, use_server_time = 1; - - if (!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 (sa_time_diff_sign > 0) - tv_diff(&server_stream_start, &sa_time_diff, - &adj_stream_start); - else - tv_add(&server_stream_start, &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 + 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 - ); -} - -__malloc static char *audiod_status_string(void) -{ - const char *status = (audiod_status == AUDIOD_ON)? - "on" : (audiod_status == AUDIOD_OFF)? "off": "sb"; - return make_message("%s:%s\n", status_item_list[SI_AUDIOD_STATUS], status); -} - -static struct timeval *wstime(void) -{ - int i; - struct timeval *max = NULL; - FOR_EACH_SLOT(i) { - struct slot_info *s = &slot[i]; - if (!s->wng) - continue; - if (max && tv_diff(&s->wstime, max, NULL) <= 0) - continue; - max = &s->wstime; - } - return max; -} -__malloc static char *decoder_flags(void) -{ - int i; - char decoder_flags[MAX_STREAM_SLOTS + 1]; - - FOR_EACH_SLOT(i) { - struct slot_info *s = &slot[i]; - char flag = '0'; - if (s->receiver_node) - flag += 1; - if (s->wng) - flag += 2; - decoder_flags[i] = flag; - } - decoder_flags[MAX_STREAM_SLOTS] = '\0'; - return make_message("%s:%s\n", status_item_list[SI_DECODER_FLAGS], - decoder_flags); -} - static char *configfile_exists(void) { - static char *config_file; - - if (!config_file) { - char *home = para_homedir(); - config_file = make_message("%s/.paraslash/audiod.conf", home); - free(home); - } - return file_exists(config_file)? config_file : NULL; + char *home = para_homedir(); + char *config_file = make_message("%s/.paraslash/audiod.conf", + home); + free(home); + if (file_exists(config_file)) + return config_file; + free(config_file); + return NULL; } static void setup_signal_handling(void) @@ -428,43 +178,10 @@ 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); signal(SIGPIPE, SIG_IGN); } -static void audiod_status_dump(void) -{ - static char *p_ts, *p_us, *p_as, *p_df; - struct timeval *t = wstime(); - char *us, *tmp = get_time_string(t); - - if (tmp && (!p_ts || strcmp(tmp, p_ts))) - stat_client_write(tmp, SI_PLAY_TIME); - free(p_ts); - p_ts = tmp; - - us = uptime_str(); - tmp = make_message("%s:%s\n", status_item_list[SI_AUDIOD_UPTIME], us); - free(us); - if (!p_us || strcmp(p_us, tmp)) - stat_client_write(tmp, SI_AUDIOD_UPTIME); - free(p_us); - p_us = tmp; - - tmp = audiod_status_string(); - if (!p_as || strcmp(p_as, tmp)) - stat_client_write(tmp, SI_AUDIOD_STATUS); - free(p_as); - p_as = tmp; - - tmp = decoder_flags(); - if (!p_df || strcmp(p_df, tmp)) - stat_client_write(tmp, SI_DECODER_FLAGS); - free(p_df); - p_df = tmp; -} - static void clear_slot(int slot_num) { struct slot_info *s = &slot[slot_num]; @@ -482,25 +199,35 @@ static void close_receiver(int slot_num) 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->receiver_node) - s->receiver_node->eof = 1; + if (s->wng && !s->wng->error) { + PARA_INFO_LOG("unregistering writer node group in slot %d\n", + i); + wng_unregister(s->wng); + s->wng->error = error; + } + if (s->fc && !s->fc->error) { + PARA_INFO_LOG("unregistering filter chain in slot %d\n", i); + unregister_task(&s->fc->task); + s->fc->error = error; + } + if (s->receiver_node && !s->receiver_node->error) { + PARA_INFO_LOG("unregistering receiver_node in slot %d\n", i); + unregister_task(&s->receiver_node->task); + s->receiver_node->error = error; + } } } @@ -523,57 +250,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_item_values[i]); - stat_item_values[i] = NULL; - } - dump_empty_status(); - length_seconds = 0; - offset_seconds = 0; - audiod_status_dump(); - playing = 0; - 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); -} - -static void __noreturn clean_exit(int status, const char *msg) -{ - PARA_EMERG_LOG("%s\n", msg); - if (socket_name) - unlink(socket_name); - if (stat_task->fd >= 0) - close_stat_pipe(); - exit(status); -} - /** * get the number of filters * @@ -590,7 +266,9 @@ int num_filters(int audio_format_num) static void filter_event_handler(struct task *t) { - PARA_NOTICE_LOG("%s\n", PARA_STRERROR(-t->ret)); + PARA_NOTICE_LOG("%s\n", para_strerror(-t->ret)); + struct filter_chain *fc = t->private_data; + fc->error = t->ret; unregister_task(t); } @@ -609,13 +287,13 @@ static void open_filters(int slot_num) 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->input_error = &s->receiver_node->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->task.flags = 0; - s->fc->eof = 0; + s->fc->error = 0; + + s->receiver_node->output_error = &s->fc->error; sprintf(s->fc->task.status, "filter chain"); for (i = 0; i < nf; i++) { struct filter_node *fn = para_calloc(sizeof(struct filter_node)); @@ -632,39 +310,15 @@ static void open_filters(int slot_num) s->fc->out_loaded = &fn->loaded; } register_task(&s->fc->task); -// PARA_DEBUG_LOG("output loaded for filter chain %p: %p\n", s->fc, -// s->fc->out_loaded); -} - -static struct filter_node *find_filter_node(int slot_num, int format, int filternum) -{ - struct filter_node *fn; - int i, j; - - FOR_EACH_SLOT(i) { - struct slot_info *s = &slot[i]; - if (s->format < 0 || !s->fc) - continue; - if (slot_num >= 0 && slot_num != i) - continue; - if (format >= 0 && s->format != format) - continue; - if (num_filters(i) < filternum) - continue; - /* success */ - j = 1; - list_for_each_entry(fn, &s->fc->filters, node) - if (filternum <= 0 || j++ == filternum) - break; - return fn; - } - return NULL; } static void wng_event_handler(struct task *t) { - PARA_INFO_LOG("%s\n", PARA_STRERROR(-t->ret)); - unregister_task(t); + struct writer_node_group *wng = t->private_data; + + PARA_INFO_LOG("%s\n", para_strerror(-t->ret)); + wng->error = t->ret; + wng_unregister(wng); } static void open_writers(int slot_num) @@ -681,42 +335,62 @@ 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->fc->output_eof = &s->wng->eof; + s->wng->input_error = &s->fc->error; + s->wng->channels = &s->fc->channels; + s->wng->samplerate = &s->fc->samplerate; + s->fc->output_error = &s->wng->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->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]; - sprintf(s->wng->writer_nodes[i].task.status, "writer_node"); } ret = wng_open(s->wng); + if (ret < 0) { + PARA_ERROR_LOG("%s\n", para_strerror(-ret)); + return; + } s->wstime = *now; - current_decoder = slot_num; 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)); + int i; + + PARA_NOTICE_LOG("%s\n", para_strerror(-t->ret)); unregister_task(t); + rn->error = t->ret; + /* set restart barrier */ + FOR_EACH_SLOT(i) { + struct timeval restart_delay = {0, 10 * 1000}; + if (slot[i].receiver_node != rn) + continue; + if (rn->error != -E_RECV_EOF) + /* don't reconnect immediately on errors */ + restart_delay.tv_sec = 5; + 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)); @@ -725,11 +399,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); @@ -737,70 +409,87 @@ static void open_receiver(int format) rn->task.pre_select = a->receiver->pre_select; rn->task.post_select = a->receiver->post_select; rn->task.event_handler = rn_event_handler; - rn->task.flags = 0; - sprintf(rn->task.status, "receiver node"); + 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 is_frozen(int format) +static int receiver_running(int format) { - struct audio_format_info *a = &afi[format]; + int i; - return (tv_diff(now, &a->restart_barrier, NULL) > 0)? 0 : 1; + FOR_EACH_SLOT(i) { + struct slot_info *s = &slot[i]; + if (s->format == format && s->receiver_node + && !s->receiver_node->error) + return 1; + } + return 0; } -static void open_current_receiver(void) +static int open_current_receiver(struct sched *s) { - int i; + struct timeval diff; + int cafn = stat_task->current_audio_format_num; - if (!af_status) - return; - i = get_audio_format_num(af_status); - if (i < 0) - return; - if (decoder_running(i) || is_frozen(i)) - return; - open_receiver(i); + if (cafn < 0 || !stat_task->pcd) + return 0; + if (receiver_running(cafn)) + return 0; + if (tv_diff(now, &afi[cafn].restart_barrier, &diff) < 0) { + s->timeout = diff; + return 0; + } + 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; - int sign; + 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); if (!count) { sa_time_diff_sign = sign; - sa_time_diff = diff; + stat_task->sa_time_diff = diff; count++; - return; + goto out; } if (count > 5) { - int s = tv_diff(&diff, &sa_time_diff, &tmp); + int s = tv_diff(&diff, &stat_task->sa_time_diff, &tmp); if (tv_diff(&max_deviation, &tmp, NULL) < 0) PARA_WARNING_LOG("time diff jump: %lims\n", s * tv2ms(&tmp)); } count++; sa_time_diff_sign = tv_convex_combination( - sa_time_diff_sign * time_smooth, &sa_time_diff, + sa_time_diff_sign * time_smooth, &stat_task->sa_time_diff, count > 10? sign : sign * time_smooth, &diff, &tmp); - sa_time_diff = tmp; + stat_task->sa_time_diff = tmp; PARA_INFO_LOG("time diff (cur/avg): %s%lums/%s%lums\n", sign > 0? "+" : "-", tv2ms(&diff), sa_time_diff_sign ? "+" : "-", - tv2ms(&sa_time_diff) + 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; @@ -809,36 +498,46 @@ static void check_stat_line(char *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_item_values[itemnum]); - stat_item_values[itemnum] = para_strdup(line); + free(stat_task->stat_item_values[itemnum]); + stat_task->stat_item_values[itemnum] = para_strdup(line); ilen = strlen(status_item_list[itemnum]); switch (itemnum) { case SI_STATUS: - playing = strstr(line, "playing")? 1 : 0; - break; - case SI_FORMAT: - free(af_status); - af_status = para_strdup(line + ilen + 1); + stat_task->playing = strstr(line, "playing")? 1 : 0; break; case SI_OFFSET: - offset_seconds = atoi(line + ilen + 1); + stat_task->offset_seconds = atoi(line + ilen + 1); break; - case SI_LENGTH: - length_seconds = atoi(line + ilen + 1); + 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) { - server_stream_start.tv_sec = sec; - server_stream_start.tv_usec = usec; + 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: @@ -846,27 +545,14 @@ 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; + 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; - } + return 1; } static void try_to_close_slot(int slot_num) @@ -875,48 +561,82 @@ static void try_to_close_slot(int slot_num) if (s->format < 0) return; - if (s->receiver_node && !s->receiver_node->eof) + if (s->receiver_node && !s->receiver_node->error) return; - if (s->fc && !s->fc->eof) + if (s->fc && !s->fc->error) return; - if (s->wng && !s->wng->eof) + if (s->wng && !s->wng->error) return; - PARA_INFO_LOG("closing slot %d \n", slot_num); + PARA_INFO_LOG("closing slot %d\n", slot_num); wng_close(s->wng); - wng_destroy(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. 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}; - now = &s->now; - if (audiod_status != AUDIOD_ON) - kill_all_decoders(); - else if (playing) - open_current_receiver(); + t->ret = 1; + if (audiod_status != AUDIOD_ON || !stat_task->playing) + return kill_all_decoders(-E_NOT_PLAYING); + if (open_current_receiver(s)) + s->timeout = min_delay; FOR_EACH_SLOT(i) { - struct receiver_node *rn; + struct slot_info *sl = &slot[i]; + struct audio_format_info *a; + struct timeval diff; - try_to_close_slot(i); - if (slot[i].format < 0) + if (sl->format < 0) + continue; + a = &afi[sl->format]; + if (!sl->receiver_node) continue; - rn = slot[i].receiver_node; - if (rn && rn->loaded && !slot[i].wng) { + 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); + s->timeout = min_delay; + } + continue; + } + if (sl->receiver_node->loaded && !sl->fc) { open_filters(i); + s->timeout = min_delay; + continue; + } + if (sl->wng || !sl->fc || !*sl->fc->out_loaded) + continue; + if (tv_diff(now, &initial_delay_barrier, &diff) > 0) { open_writers(i); + s->timeout = min_delay; + continue; + } + PARA_INFO_LOG("initial delay: %lu ms left\n", tv2ms(&diff)); + if (tv_diff(&s->timeout, &diff, NULL) > 0) { + s->timeout = diff; } } } -static void audiod_post_select(struct sched *s, __a_unused struct task *t) +static void audiod_post_select(__a_unused struct sched *s, + __a_unused struct task *t) { - /* only save away the current time for other users */ - now = &s->now; + int i; + + t->ret = 1; + FOR_EACH_SLOT(i) + try_to_close_slot(i); } static void init_audiod_task(struct task *t) @@ -925,7 +645,6 @@ static void init_audiod_task(struct task *t) t->post_select = audiod_post_select; t->event_handler = NULL; t->private_data = t; - t->flags = 0; sprintf(t->status, "audiod task"); } @@ -1010,18 +729,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; @@ -1129,287 +848,11 @@ static int init_stream_io(void) return 1; } -static int dump_commands(int fd) -{ - char *buf = para_strdup(""), *tmp = NULL; - int i; - ssize_t ret; - - FOR_EACH_COMMAND(i) { - tmp = make_message("%s%s\t%s\n", buf, cmds[i].name, - cmds[i].description); - free(buf); - buf = tmp; - } - ret = client_write(fd, buf); - free(buf); - return ret; -} - -/* - * command handlers don't close their fd on errors (ret < 0) so that - * its caller can send an error message. Otherwise (ret >= 0) it's up - * to each individual command to close the fd if necessary. - */ - -static int com_help(int fd, int argc, char **argv) -{ - int i, ret; - char *buf; - const char *dflt = "No such command. Available commands:\n"; - - if (argc < 2) { - ret = dump_commands(fd); - goto out; - } - FOR_EACH_COMMAND(i) { - if (strcmp(cmds[i].name, argv[1])) - continue; - buf = make_message( - "NAME\n\t%s -- %s\n" - "SYNOPSIS\n\tpara_audioc %s\n" - "DESCRIPTION\n%s\n", - argv[1], - cmds[i].description, - cmds[i].synopsis, - cmds[i].help - ); - ret = client_write(fd, buf); - free(buf); - goto out; - } - ret = client_write(fd, dflt); - if (ret > 0) - ret = dump_commands(fd); -out: - 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; - long unsigned mask = ~0LU; - - if (argc > 1) { - mask = 0; - for (i = 1; i < argc; i++) { - ret = stat_item_valid(argv[i]); - if (ret < 0) - return ret; - mask |= (1 << ret); - } - } - PARA_INFO_LOG("mask: 0x%lx\n", mask); - if (mask & (1 << SI_PLAY_TIME)) { - struct timeval *t = wstime(); - char *ts = get_time_string(t); - if (ts) { - ret = client_write(fd, ts); - if (ret < 0) - goto out; - free(ts); - } - } - if (mask & (1 << SI_AUDIOD_UPTIME)) { - char *tmp, *us = uptime_str(); - tmp = make_message("%s:%s\n", - status_item_list[SI_AUDIOD_UPTIME], us); - free(us); - ret = client_write(fd, tmp); - if (ret < 0) - goto out; - free(tmp); - } - if (mask & (1 << SI_AUDIOD_STATUS)) { - char *s = audiod_status_string(); - ret = client_write(fd, s); - if (ret < 0) - goto out; - free(s); - } - if (mask & (1 << SI_DECODER_FLAGS)) { - char *df =decoder_flags(); - ret = client_write(fd, df); - if (ret < 0) - goto out; - free(df); - } - - for (i = 0; i < NUM_STAT_ITEMS; i++) { - char *tmp, *v; - if (!((1 << i) & mask)) - continue; - v = stat_item_values[i]; - tmp = make_message("%s%s%s", buf? buf: "", - v? v : "", v? "\n" : ""); - free(buf); - buf = tmp; - } - ret = client_write(fd, buf); -out: - if (ret > 0) - ret = stat_client_add(fd, mask); - free(buf); - return ret; -} - -static int com_grab(int fd, char *cmdline) -{ - struct grab_client *gc; - struct filter_node *fn; - int i, err; - char *msg; - - 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); - if (fn) - activate_grab_client(gc, fn); - return 1; -err_out: - if (err != -E_GC_HELP_GIVEN && err != -E_GC_VERSION_GIVEN) - return err; - if (err == -E_GC_HELP_GIVEN) { - msg = make_message("%s\n\n", grab_client_args_info_usage); - for (i = 0; grab_client_args_info_help[i]; i++) { - char *tmp = make_message("%s%s\n", msg, - grab_client_args_info_help[i]); - free(msg); - msg = tmp; - } - } else - msg = make_message("%s %s\n", - GRAB_CLIENT_CMDLINE_PARSER_PACKAGE, - GRAB_CLIENT_CMDLINE_PARSER_VERSION); - err = client_write(fd, msg); - free(msg); - if (err < 0) - return err; - close(fd); - return 1; -} - -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, __a_unused int argc, __a_unused char **argv) -{ - audiod_status = AUDIOD_ON; - close(fd); - return 1; -} - -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, __a_unused int argc, __a_unused char **argv) -{ - audiod_status = AUDIOD_STANDBY; - close(fd); - return 1; -} - -static int com_cycle(int fd, int argc, char **argv) -{ - switch (audiod_status) { - case AUDIOD_ON: - return com_sb(fd, argc, argv); - break; - case AUDIOD_OFF: - return com_on(fd, argc, argv); - break; - case AUDIOD_STANDBY: - return com_off(fd, argc, argv); - break; - } - close(fd); - return 1; -} - -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 (uid == conf.user_allow_arg[i]) - return 1; - return -E_UCRED_PERM; -} - -static int handle_connect(int accept_fd) -{ - int i, argc, ret, clifd = -1; - char *cmd = NULL, *p, *buf = para_calloc(MAXLINE), **argv = NULL; - struct sockaddr_un unix_addr; - - 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); - if (ret < 0) - goto out; - PARA_INFO_LOG("connection from user %i, buf: %s\n", ret, buf); - ret = check_perms(ret); - if (ret < 0) - goto out; - 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++) { - int j; - if (strcmp(cmds[i].name, cmd)) - continue; - 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) { - char *tmp = make_message("%s\n", PARA_STRERROR(-ret)); - client_write(clifd, tmp); - free(tmp); - close(clifd); - } - return ret; -} - +/* 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); @@ -1422,48 +865,45 @@ 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); + 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); - } 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; - 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; @@ -1473,18 +913,18 @@ 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; st->task.private_data = st; - st->task.flags = 0; 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; para_fd_set(ct->fd, &s->rfds, &s->max_fileno); } @@ -1494,14 +934,13 @@ static void command_post_select(struct sched *s, struct task *t) int ret; struct command_task *ct = t->private_data; - if (audiod_status != AUDIOD_OFF) - audiod_status_dump(); t->ret = 1; /* always successful */ + 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) @@ -1510,57 +949,149 @@ static void init_command_task(struct command_task *ct) ct->task.post_select = command_post_select; ct->task.event_handler = NULL; ct->task.private_data = ct; - ct->task.flags = 0; ct->fd = audiod_get_socket(); /* doesn't return on errors */ sprintf(ct->task.status, "command task"); } +static void close_stat_pipe(void) +{ + int i; + + if (!stat_task->pcd) + return; + client_close(stat_task->pcd); + stat_task->pcd = NULL; + FOR_EACH_STATUS_ITEM(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_BASENAME] = make_message( + "%s: no connection to para_server\n", + status_item_list[SI_BASENAME]); + stat_client_write(stat_task->stat_item_values[SI_BASENAME], + SI_BASENAME); + 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); +} + +/* avoid busy loop if server is down */ +static void set_stat_task_restart_barrier(void) +{ + struct timeval delay = {5, 0}; + tv_add(now, &delay, &stat_task->restart_barrier); +} + +static void client_task_event_handler(__a_unused struct task *t) +{ + int i; + + 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; + set_stat_task_restart_barrier(); + FOR_EACH_AUDIO_FORMAT(i) + 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) { - 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); + set_stat_task_restart_barrier(); + 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; - int ret; + 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; - ret = read(st->fd, st->buf + st->loaded, - STRINGSIZE - 1 - st->loaded); - if (ret <= 0) { + if (st->pcd && audiod_status == AUDIOD_OFF) { + unregister_task(&st->pcd->task); close_stat_pipe(); - /* avoid busy loop if server is down */ - while (sleep(1) > 0) /* FIXME */ - ; /* try again*/ + st->clock_diff_count = conf.clock_diff_count_arg; + return; + } + bytes_left = for_each_line(st->pcd->buf, st->pcd->loaded, + &check_stat_line, NULL); + if (st->pcd->loaded != bytes_left) { + st->last_status_read = *now; + st->pcd->loaded = bytes_left; } else { - st->buf[ret + st->loaded] = '\0'; - st->loaded = for_each_line(st->buf, ret + st->loaded, - &check_stat_line); + 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) { + memset(st, 0, sizeof(struct status_task)); st->task.pre_select = status_pre_select; st->task.post_select = status_post_select; st->task.private_data = st; - st->task.flags = 0; - st->loaded = 0; - st->fd = -1; - st->buf[0] = '\0'; + 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"); } @@ -1578,36 +1109,52 @@ 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"); } +/** + * 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; + char *config_file; 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); + 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)) { - PARA_EMERG_LOG("%s", "parse error in config file\n"); + config_file = configfile_exists(); + if (config_file) { + struct audiod_cmdline_parser_params params = { + .override = 0, + .initialize = 0, + .check_required = 0, + .check_ambiguity = 0 + + }; + if (audiod_cmdline_parser_config_file(config_file, &conf, ¶ms)) { + PARA_EMERG_LOG("parse error in config file\n"); exit(EXIT_FAILURE); } + free(config_file); } if (conf.logfile_given) logfile = open_log(conf.logfile_arg); log_welcome("para_audiod", conf.loglevel_arg); i = init_stream_io(); 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); } server_uptime(UPTIME_SET); @@ -1632,8 +1179,8 @@ int main(int argc, char *argv[]) register_task(audiod_task); 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; }