X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=audiod.c;h=2367d9cb443ecc1d0f52f64e31f76a731b13c8b4;hp=1f1f1aa666ffa0a63dfbd8bb72e591b264c3a20e;hb=70677862e5548461918ce42af206cdca61dc250f;hpb=d70cae532cf1c06a393d6e63b491179c900557a9

diff --git a/audiod.c b/audiod.c
index 1f1f1aa6..2367d9cb 100644
--- a/audiod.c
+++ b/audiod.c
@@ -1,14 +1,13 @@
 /*
- * Copyright (C) 2005-2011 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2005-2013 Andre Noll <maan@systemlinux.org>
  *
  * Licensed under the GPL v2. For licencing details see COPYING.
  */
 
-/** \file audiod.c the paraslash's audio daemon */
+/** \file audiod.c The paraslash's audio daemon. */
 #include <regex.h>
 #include <sys/types.h>
 #include <signal.h>
-#include <stdbool.h>
 
 #include "para.h"
 #include "error.h"
@@ -17,8 +16,8 @@
 #include "list.h"
 #include "sched.h"
 #include "ggo.h"
-#include "recv.h"
 #include "buffer_tree.h"
+#include "recv.h"
 #include "filter.h"
 #include "grab_client.h"
 #include "client.cmdline.h"
@@ -33,11 +32,14 @@
 #include "signal.h"
 #include "version.h"
 
+__printf_2_3 void (*para_log)(int, const char*, ...) = daemon_log;
 /** define the array of error lists needed by para_audiod */
 INIT_AUDIOD_ERRLISTS;
 /** define the array containing all supported audio formats */
 const char *audio_formats[] = {AUDIOD_AUDIO_FORMAT_ARRAY NULL};
 
+DEFINE_RECEIVER_ARRAY;
+
 /** Defines how audiod handles one supported audio format. */
 struct audio_format_info {
 	/** pointer to the receiver for this audio format */
@@ -77,6 +79,14 @@ enum vss_status_flags {
 	VSS_STATUS_FLAG_PLAYING = 2,
 };
 
+/**
+ * The scheduler instance of para_audiod.
+ *
+ * This is needed also in audiod_command.c (for the tasks command), so it can
+ * not be made static.
+ */
+struct sched sched = {.max_fileno = 0};
+
 /**
  * The task for obtaining para_server's status (para_client stat).
  *
@@ -242,7 +252,7 @@ char *get_time_string(int slot_num)
 	 */
 	length = stat_task->length_seconds;
 	tmp = &stat_task->server_stream_start;
-	if (s && s->wns) { /* writer active in this slot */
+	if (s && s->wns && s->wns[0].btrn) { /* writer active in this slot */
 		btr_get_node_start(s->wns[0].btrn, &wstime);
 		if (wstime.tv_sec != 0) { /* writer wrote something */
 			if (s->server_stream_start.tv_sec == 0) {
@@ -259,7 +269,7 @@ char *get_time_string(int slot_num)
 		tv_diff(tmp, &stat_task->sa_time_diff, &sss);
 	else
 		tv_add(tmp, &stat_task->sa_time_diff, &sss);
-	if (!s || !s->wns) {
+	if (!s || !s->wns || !s->wns[0].btrn) {
 		struct timeval diff;
 		tv_diff(now, &sss, &diff);
 		seconds = diff.tv_sec + stat_task->offset_seconds;
@@ -268,11 +278,14 @@ char *get_time_string(int slot_num)
 	tv_diff(now, &wstime, &wtime);
 	//PARA_CRIT_LOG("offset %d\n", s->offset_seconds);
 	seconds = s->offset_seconds;
-	btr_get_node_start(s->receiver_node->btrn, &rstime);
-	ret = tv_diff(&rstime, &sss, &rskip);
-	if (ret > 0) { /* audiod was started in the middle of the stream */
-		tv_add(&wtime, &rskip, &sum);
-		seconds += sum.tv_sec;
+	if (s->receiver_node->btrn) {
+		btr_get_node_start(s->receiver_node->btrn, &rstime);
+		ret = tv_diff(&rstime, &sss, &rskip);
+		if (ret > 0) { /* audiod was started in the middle of the stream */
+			tv_add(&wtime, &rskip, &sum);
+			seconds += sum.tv_sec;
+		} else
+			seconds += wtime.tv_sec;
 	} else
 		seconds += wtime.tv_sec;
 out:
@@ -289,7 +302,7 @@ out:
 		length / 60,
 		length % 60
 	);
-	PARA_DEBUG_LOG("slot %d: %s\n", slot_num, msg);
+	//PARA_DEBUG_LOG("slot %d: %s\n", slot_num, msg);
 	return msg;
 empty:
 	return para_strdup(NULL);
@@ -330,10 +343,11 @@ static void parse_config_or_die(void)
 		PARA_EMERG_LOG("can not read config file %s\n", config_file);
 		goto err;
 	}
-	if (ret)
+	if (ret) {
 		audiod_cmdline_parser_config_file(config_file, &conf, &params);
+		daemon_set_loglevel(conf.loglevel_arg);
+	}
 	free(config_file);
-	daemon_set_loglevel(conf.loglevel_arg);
 	return;
 err:
 	free(config_file);
@@ -370,7 +384,7 @@ static void close_receiver(int slot_num)
 	PARA_NOTICE_LOG("closing %s receiver in slot %d\n",
 		audio_formats[s->format], slot_num);
 	a->receiver->close(s->receiver_node);
-	btr_free_node(s->receiver_node->btrn);
+	btr_remove_node(&s->receiver_node->btrn);
 	free(s->receiver_node);
 	s->receiver_node = NULL;
 	tv_add(now, &(struct timeval)EMBRACE(0, 200 * 1000),
@@ -386,7 +400,7 @@ static void writer_cleanup(struct writer_node *wn)
 	w = writers + wn->writer_num;
 	PARA_INFO_LOG("closing %s\n", writer_names[wn->writer_num]);
 	w->close(wn);
-	btr_free_node(wn->btrn);
+	btr_remove_node(&wn->btrn);
 }
 
 static void close_writers(struct slot_info *s)
@@ -414,7 +428,7 @@ static void close_filters(struct slot_info *s)
 	struct audio_format_info *a = afi + s->format;
 	if (a->num_filters == 0)
 		return;
-	for (i = 0; i < a->num_filters; i++) {
+	for (i = a->num_filters - 1; i >= 0; i--) {
 		struct filter_node *fn = s->fns + i;
 		struct filter *f;
 
@@ -423,27 +437,13 @@ static void close_filters(struct slot_info *s)
 		f = filters + fn->filter_num;
 		if (f->close)
 			f->close(fn);
-		btr_free_node(fn->btrn);
+		btr_remove_node(&fn->btrn);
 	}
 	free(s->fns);
 	s->fns = NULL;
 }
 
-/*
- * Whenever a task commits suicide by returning from post_select with t->error
- * < 0, it also removes its btr node. We do exactly that to kill a running
- * task. Note that the scheduler checks t->error also _before_ each pre/post
- * select call, so the victim will never be scheduled again.
- */
-static void kill_btrn(struct btr_node *btrn, struct task *t, int error)
-{
-	if (t->error < 0)
-		return;
-	t->error = error;
-	btr_remove_node(btrn);
-}
-
-static void kill_all_decoders(int error)
+static void notify_receivers(int error)
 {
 	int i;
 
@@ -453,8 +453,7 @@ static void kill_all_decoders(int error)
 			continue;
 		if (!s->receiver_node)
 			continue;
-		kill_btrn(s->receiver_node->btrn, &s->receiver_node->task,
-				error);
+		task_notify(&s->receiver_node->task, error);
 	}
 }
 
@@ -498,13 +497,12 @@ static void open_filters(struct slot_info *s)
 		fn->conf = a->filter_conf[i];
 		fn->task.pre_select = f->pre_select;
 		fn->task.post_select = f->post_select;
-
 		fn->btrn = btr_new_node(&(struct btr_node_description)
 			EMBRACE(.name = f->name, .parent = parent,
 				.handler = f->execute, .context = fn));
 
 		f->open(fn);
-		register_task(&fn->task);
+		register_task(&sched, &fn->task);
 		parent = fn->btrn;
 		PARA_NOTICE_LOG("%s filter %d/%d (%s) started in slot %d\n",
 			audio_formats[s->format], i,  nf, f->name, (int)(s - slot));
@@ -522,16 +520,13 @@ static void open_writers(struct slot_info *s)
 	assert(s->wns == NULL);
 	s->wns = para_calloc(PARA_MAX(1U, a->num_writers)
 		* sizeof(struct writer_node));
-	if (a->num_writers == 0)
-		setup_writer_node(NULL, parent, s->wns);
-	else {
-		PARA_INFO_LOG("opening %s writers\n", audio_formats[s->format]);
-		for (i = 0; i < a->num_writers; i++) {
-			wn = s->wns + i;
-			wn->conf = a->writer_conf[i];
-			wn->writer_num = a->writer_nums[i];
-			register_writer_node(wn, parent);
-		}
+	for (i = 0; i < a->num_writers; i++) {
+		wn = s->wns + i;
+		wn->conf = a->writer_conf[i];
+		wn->writer_num = a->writer_nums[i];
+		register_writer_node(wn, parent, &sched);
+		PARA_NOTICE_LOG("%s writer started in slot %d\n",
+			writer_names[a->writer_nums[i]], (int)(s - slot));
 	}
 }
 
@@ -556,7 +551,7 @@ static int open_receiver(int format)
 		EMBRACE(.name = r->name, .context = rn));
 	ret = r->open(rn);
 	if (ret < 0) {
-		btr_free_node(rn->btrn);
+		btr_remove_node(&rn->btrn);
 		free(rn);
 		return ret;
 	}
@@ -568,7 +563,7 @@ static int open_receiver(int format)
 	rn->task.pre_select = r->pre_select;
 	rn->task.post_select = r->post_select;
 	sprintf(rn->task.status, "%s receiver node", r->name);
-	register_task(&rn->task);
+	register_task(&sched, &rn->task);
 	return slot_num;
 }
 
@@ -732,30 +727,36 @@ static int update_item(int itemnum, char *buf)
 
 static int parse_stream_command(const char *txt, char **cmd)
 {
-	char *p = strchr(txt, ':');
-	int i;
+	int ret, len;
+	char *re, *p = strchr(txt, ':');
 
 	if (!p)
 		return -E_MISSING_COLON;
-	p++;
-	FOR_EACH_AUDIO_FORMAT(i) {
-		if (strncmp(txt, audio_formats[i], strlen(audio_formats[i])))
-			continue;
-		*cmd = p;
-		return i;
-	}
-	return -E_UNSUPPORTED_AUDIO_FORMAT;
+	*cmd = p + 1;
+	len = p - txt;
+	re = malloc(len + 1);
+	strncpy(re, txt, len);
+	re[len] = '\0';
+	ret = get_matching_audio_format_nums(re);
+	free(re);
+	return ret;
 }
 
 static int add_filter(int format, char *cmdline)
 {
 	struct audio_format_info *a = &afi[format];
 	int filter_num, nf = a->num_filters;
+	void *cfg;
 
-	filter_num = check_filter_arg(cmdline, &a->filter_conf[nf]);
+	filter_num = check_filter_arg(cmdline, &cfg);
 	if (filter_num < 0)
 		return filter_num;
+	a->filter_conf = para_realloc(a->filter_conf,
+		(nf + 1) * sizeof(void *));
+	a->filter_nums = para_realloc(a->filter_nums,
+		(nf + 1) * sizeof(unsigned));
 	a->filter_nums[nf] = filter_num;
+	a->filter_conf[nf] = cfg;
 	a->num_filters++;
 	PARA_INFO_LOG("%s filter %d: %s\n", audio_formats[format], nf,
 		filters[filter_num].name);
@@ -764,40 +765,50 @@ static int add_filter(int format, char *cmdline)
 
 static int parse_writer_args(void)
 {
-	int i, ret, nw;
+	int i, ret;
 	char *cmd;
 	struct audio_format_info *a;
 
-	nw = PARA_MAX(1U, conf.writer_given);
-	PARA_INFO_LOG("maximal number of writers: %d\n", nw);
-	FOR_EACH_AUDIO_FORMAT(i) {
-		a = &afi[i];
-		a->writer_conf = para_malloc(nw * sizeof(void *));
-		a->writer_nums = para_malloc(nw * sizeof(int));
-		a->num_writers = 0;
-	}
 	for (i = 0; i < conf.writer_given; i++) {
 		void *wconf;
-		int writer_num;
+		int j, nw, writer_num, af_mask;
+
 		ret = parse_stream_command(conf.writer_arg[i], &cmd);
 		if (ret < 0)
-			goto out;
-		a = &afi[ret];
-		nw = a->num_writers;
-		wconf = check_writer_arg(cmd, &writer_num);
-		if (!wconf) {
-			ret = writer_num;
-			goto out;
+			return ret;
+		af_mask = ret;
+		FOR_EACH_AUDIO_FORMAT(j) {
+			a = afi + j;
+			if ((af_mask & (1 << j)) == 0) /* no match */
+				continue;
+			wconf = check_writer_arg_or_die(cmd, &writer_num);
+			nw = a->num_writers;
+			a->writer_nums = para_realloc(a->writer_nums, (nw + 1) * sizeof(int));
+			a->writer_conf = para_realloc(a->writer_conf, (nw + 1) * sizeof(void *));
+			a->writer_nums[nw] = writer_num;
+			a->writer_conf[nw] = wconf;
+			PARA_INFO_LOG("%s writer #%d: %s\n", audio_formats[j],
+				nw, writer_names[writer_num]);
+			a->num_writers++;
 		}
-		a->writer_nums[nw] = 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;
+	/* Use default writer for audio formats which are not yet set up. */
+	FOR_EACH_AUDIO_FORMAT(i) {
+		void *writer_conf;
+		int writer_num;
+		a = afi + i;
+		if (a->num_writers > 0)
+			continue; /* already set up */
+		writer_conf = check_writer_arg_or_die(NULL, &writer_num);
+		a->writer_nums = para_malloc(sizeof(int));
+		a->writer_nums[0] = writer_num;
+		a->writer_conf = para_malloc(sizeof(void *));
+		a->writer_conf[0] = writer_conf;
+		a->num_writers = 1;
+		PARA_INFO_LOG("%s writer: %s (default)\n", audio_formats[i],
+			writer_names[writer_num]);
+	}
+	return 1;
 }
 
 static int parse_receiver_args(void)
@@ -807,16 +818,10 @@ static int parse_receiver_args(void)
 	struct audio_format_info *a;
 
 	for (i = conf.receiver_given - 1; i >= 0; i--) {
-		char *arg = conf.receiver_arg[i];
-		char *recv_arg = strchr(arg, ':');
-		int af_mask, j;
+		char *arg;
+		int j, af_mask;
 
-		ret = -E_MISSING_COLON;
-		if (!recv_arg)
-			goto out;
-		*recv_arg = '\0';
-		recv_arg++;
-		ret = get_matching_audio_format_nums(arg);
+		ret = parse_stream_command(conf.receiver_arg[i], &arg);
 		if (ret < 0)
 			goto out;
 		af_mask = ret;
@@ -832,7 +837,7 @@ static int parse_receiver_args(void)
 			 */
 			if (a->receiver_conf)
 				a->receiver->free_config(a->receiver_conf);
-			a->receiver_conf = check_receiver_arg(recv_arg, &receiver_num);
+			a->receiver_conf = check_receiver_arg(arg, &receiver_num);
 			ret = -E_RECV_SYNTAX;
 			if (!a->receiver_conf)
 				goto out;
@@ -876,8 +881,8 @@ static int init_default_filters(void)
 		if (a->num_filters)
 			continue; /* no default -- nothing to to */
 		/*
-		 * If udp is used to receive this audiod format, add fecdec as
-		 * the first filter.
+		 * udp and dccp streams are fec-encoded, so add fecdec as the
+		 * first filter.
 		 */
 		if (strcmp(afi[i].receiver->name, "udp") == 0 ||
 				strcmp(afi[i].receiver->name, "dccp") == 0) {
@@ -910,30 +915,26 @@ out:
 
 static int parse_filter_args(void)
 {
-	int i, ret, nf;
+	int i, j, ret, af_mask, num_matches;
 
-	nf = PARA_MAX(2U, conf.filter_given);
-	PARA_INFO_LOG("maximal number of filters: %d\n", nf);
-	FOR_EACH_AUDIO_FORMAT(i) {
-		afi[i].filter_conf = para_malloc(nf * sizeof(void *));
-		afi[i].filter_nums = para_malloc(nf * sizeof(unsigned));
-	}
-	if (!conf.no_default_filters_given)
-		return init_default_filters();
 	for (i = 0; i < conf.filter_given; i++) {
-		char *arg = conf.filter_arg[i];
-		char *filter_name = strchr(arg, ':');
-		ret = -E_MISSING_COLON;
-		if (!filter_name)
-			goto out;
-		*filter_name = '\0';
-		filter_name++;
-		ret = get_audio_format_num(arg);
-		if (ret < 0)
-			goto out;
-		ret = add_filter(ret, filter_name);
+		char *arg;
+		ret = parse_stream_command(conf.filter_arg[i], &arg);
 		if (ret < 0)
 			goto out;
+		af_mask = ret;
+		num_matches = 0;
+		FOR_EACH_AUDIO_FORMAT(j) {
+			if ((af_mask & (1 << j)) == 0) /* no match */
+				continue;
+			ret = add_filter(j, arg);
+			if (ret < 0)
+				goto out;
+			num_matches++;
+		}
+		if (num_matches == 0)
+			PARA_WARNING_LOG("ignoring filter spec: %s\n",
+				conf.filter_arg[i]);
 	}
 	ret = init_default_filters(); /* use default values for the rest */
 out:
@@ -997,7 +998,7 @@ static void signal_pre_select(struct sched *s, struct task *t)
 	para_fd_set(st->fd, &s->rfds, &s->max_fileno);
 }
 
-static void signal_post_select(struct sched *s, __a_unused struct task *t)
+static int signal_post_select(struct sched *s, __a_unused struct task *t)
 {
 	int signum;
 
@@ -1009,6 +1010,7 @@ static void signal_post_select(struct sched *s, __a_unused struct task *t)
 		PARA_EMERG_LOG("terminating on signal %d\n", signum);
 		clean_exit(EXIT_FAILURE, "caught deadly signal");
 	}
+	return 0;
 }
 
 static void signal_setup_default(struct signal_task *st)
@@ -1024,7 +1026,7 @@ static void command_pre_select(struct sched *s, struct task *t)
 	para_fd_set(ct->fd, &s->rfds, &s->max_fileno);
 }
 
-static void command_post_select(struct sched *s, struct task *t)
+static int command_post_select(struct sched *s, struct task *t)
 {
 	int ret;
 	struct command_task *ct = container_of(t, struct command_task, task);
@@ -1041,6 +1043,7 @@ static void command_post_select(struct sched *s, struct task *t)
 	if (ret < 0)
 		PARA_ERROR_LOG("%s\n", para_strerror(-ret));
 	audiod_status_dump();
+	return 0;
 }
 
 static void init_command_task(struct command_task *ct)
@@ -1056,7 +1059,6 @@ static void close_stat_pipe(void)
 {
 	if (!stat_task->ct)
 		return;
-	btr_free_node(stat_task->ct->btrn);
 	client_close(stat_task->ct);
 	stat_task->ct = NULL;
 	clear_and_dump_items();
@@ -1067,27 +1069,6 @@ static void close_stat_pipe(void)
 	audiod_status_dump();
 }
 
-/**
- * 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(unsigned seconds)
 {
@@ -1095,27 +1076,34 @@ static void set_stat_task_restart_barrier(unsigned seconds)
 	tv_add(now, &delay, &stat_task->restart_barrier);
 }
 
-static void try_to_close_slot(int slot_num)
+static bool must_close_slot(int slot_num)
 {
 	struct slot_info *s = &slot[slot_num];
 	struct audio_format_info *a = afi + s->format;
 	int i;
 
 	if (s->format < 0)
-		return;
+		return false;
 	if (s->receiver_node && s->receiver_node->task.error >= 0)
-		return;
+		return false;
 	for (i = 0; i < a->num_filters; i++)
 		if (s->fns && s->fns[i].task.error >= 0)
-			return;
+			return false;
 	if (a->num_writers > 0) {
 		for (i = 0; i < a->num_writers; i++)
 			if (s->wns && s->wns[i].task.error >= 0)
-				return;
+				return false;
 	} else {
 		if (s->wns && s->wns[0].task.error >= 0)
-			return;
+			return false;
 	}
+	return true;
+}
+
+static void close_slot(int slot_num)
+{
+	struct slot_info *s = slot + slot_num;
+
 	PARA_INFO_LOG("closing slot %d\n", slot_num);
 	close_writers(s);
 	close_filters(s);
@@ -1123,21 +1111,55 @@ static void try_to_close_slot(int slot_num)
 	clear_slot(slot_num);
 }
 
+static void close_unused_slots(void)
+{
+	int i;
+
+	FOR_EACH_SLOT(i)
+		if (must_close_slot(i))
+			close_slot(i);
+}
+
+/**
+ * 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 and
+ * all slots, 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)
+{
+	int i;
+
+	PARA_EMERG_LOG("%s\n", msg);
+	if (socket_name)
+		unlink(socket_name);
+	close_stat_pipe();
+	FOR_EACH_SLOT(i)
+		close_slot(i);
+	audiod_cmdline_parser_free(&conf);
+	exit(status);
+}
+
 /*
  * Check if any receivers/filters/writers need to be started and do so if
  * necessary.
  */
 static void start_stop_decoders(void)
 {
-	int i, ret;
+	int ret;
 	struct slot_info *sl;
 	struct audio_format_info *a;
 
-	FOR_EACH_SLOT(i)
-		try_to_close_slot(i);
+	close_unused_slots();
 	if (audiod_status != AUDIOD_ON ||
 			!(stat_task->vss_status & VSS_STATUS_FLAG_PLAYING))
-		return kill_all_decoders(-E_NOT_PLAYING);
+		return notify_receivers(E_NOT_PLAYING);
 	if (!must_start_decoder())
 		return;
 	ret = open_receiver(stat_task->current_audio_format_num);
@@ -1150,18 +1172,21 @@ static void start_stop_decoders(void)
 	if (a->num_filters)
 		open_filters(sl);
 	open_writers(sl);
-	activate_grab_clients();
+	activate_grab_clients(&sched);
 	btr_log_tree(sl->receiver_node->btrn, LL_NOTICE);
 }
 
 static void status_pre_select(struct sched *s, struct task *t)
 {
 	struct status_task *st = container_of(t, struct status_task, task);
-	int ret, cafn = stat_task->current_audio_format_num;
+	int i, ret, cafn = stat_task->current_audio_format_num;
 
 	if (must_start_decoder())
 		goto min_delay;
-	ret = btr_node_status(st->btrn, 0, BTR_NT_LEAF);
+	FOR_EACH_SLOT(i)
+		if (must_close_slot(i))
+			goto min_delay;
+	ret = btr_node_status(st->btrn, st->min_iqs, BTR_NT_LEAF);
 	if (ret > 0)
 		goto min_delay;
 	if (st->ct && audiod_status == AUDIOD_OFF)
@@ -1183,7 +1208,7 @@ min_delay:
 }
 
 /* restart the client task if necessary */
-static void status_post_select(__a_unused struct sched *s, struct task *t)
+static int status_post_select(struct sched *s, struct task *t)
 {
 	struct status_task *st = container_of(t, struct status_task, task);
 
@@ -1191,11 +1216,9 @@ static void status_post_select(__a_unused struct sched *s, struct task *t)
 		if (!st->ct)
 			goto out;
 		if (st->ct->task.error >= 0) {
-			kill_btrn(st->ct->btrn, &st->ct->task, -E_AUDIOD_OFF);
+			task_notify(&st->ct->task, E_AUDIOD_OFF);
 			goto out;
 		}
-		if (st->ct->task.error >= 0)
-			goto out;
 		close_stat_pipe();
 		st->clock_diff_count = conf.clock_diff_count_arg;
 		goto out;
@@ -1205,27 +1228,24 @@ static void status_post_select(__a_unused struct sched *s, struct task *t)
 		size_t sz;
 		int ret;
 		if (st->ct->task.error < 0) {
-			if (st->ct->task.error >= 0)
-				goto out;
 			close_stat_pipe();
 			goto out;
 		}
-		if (st->ct->status != CL_RECEIVING)
+		if (st->ct->status != CL_EXECUTING)
 			goto out;
 		ret = btr_node_status(st->btrn, st->min_iqs, BTR_NT_LEAF);
 		if (ret <= 0) {
 			struct timeval diff;
 			tv_diff(now, &st->last_status_read, &diff);
 			if (diff.tv_sec > 61)
-				kill_btrn(st->ct->btrn, &st->ct->task,
-					-E_STATUS_TIMEOUT);
+				task_notify(&st->ct->task, E_STATUS_TIMEOUT);
 			goto out;
 		}
 		btr_merge(st->btrn, st->min_iqs);
 		sz = btr_next_buffer(st->btrn, &buf);
 		ret = for_each_stat_item(buf, sz, update_item);
 		if (ret < 0) {
-			kill_btrn(st->ct->btrn, &st->ct->task, ret);
+			task_notify(&st->ct->task, -ret);
 			goto out;
 		}
 		if (sz != ret) {
@@ -1245,13 +1265,13 @@ static void status_post_select(__a_unused struct sched *s, struct task *t)
 		int argc = 5;
 		PARA_INFO_LOG("clock diff count: %d\n", st->clock_diff_count);
 		st->clock_diff_count--;
-		client_open(argc, argv, &st->ct, NULL, NULL, st->btrn);
+		client_open(argc, argv, &st->ct, NULL, NULL, st->btrn, s);
 		set_stat_task_restart_barrier(2);
 
 	} else {
 		char *argv[] = {"audiod", "--", "stat", "-p", NULL};
 		int argc = 4;
-		client_open(argc, argv, &st->ct, NULL, NULL, st->btrn);
+		client_open(argc, argv, &st->ct, NULL, NULL, st->btrn, s);
 		set_stat_task_restart_barrier(5);
 	}
 	free(stat_item_values[SI_BASENAME]);
@@ -1261,6 +1281,7 @@ static void status_post_select(__a_unused struct sched *s, struct task *t)
 	st->last_status_read = *now;
 out:
 	start_stop_decoders();
+	return 0;
 }
 
 static void init_status_task(struct status_task *st)
@@ -1295,18 +1316,17 @@ static void set_initial_status(void)
 
 __noreturn static void print_help_and_die(void)
 {
-	int d = conf.detailed_help_given;
-	const char **p = d? audiod_args_info_detailed_help
-		: audiod_args_info_help;
-
-	printf_or_die("%s\n\n", AUDIOD_CMDLINE_PARSER_PACKAGE "-"
-		AUDIOD_CMDLINE_PARSER_VERSION);
-	printf_or_die("%s\n\n", audiod_args_info_usage);
-	for (; *p; p++)
-		printf_or_die("%s\n", *p);
-	print_receiver_helps(d);
-	print_filter_helps(d);
-	print_writer_helps(d);
+	struct ggo_help h = DEFINE_GGO_HELP(audiod);
+	bool d = conf.detailed_help_given;
+	unsigned flags;
+
+	flags = d? GPH_STANDARD_FLAGS_DETAILED : GPH_STANDARD_FLAGS;
+	ggo_print_help(&h, flags);
+
+	flags = d? GPH_MODULE_FLAGS_DETAILED : GPH_MODULE_FLAGS;
+	print_receiver_helps(flags);
+	print_filter_helps(flags);
+	print_writer_helps(flags);
 	exit(0);
 }
 
@@ -1335,7 +1355,6 @@ static void init_colors_or_die(void)
 int main(int argc, char *argv[])
 {
 	int ret, i;
-	static struct sched s;
 	struct command_task command_task_struct, *cmd_task = &command_task_struct;
 	struct audiod_cmdline_parser_params params = {
 		.override = 0,
@@ -1346,9 +1365,9 @@ int main(int argc, char *argv[])
 	};
 
 	valid_fd_012();
-	if (audiod_cmdline_parser_ext(argc, argv, &conf, &params))
-		exit(EXIT_FAILURE);
-	HANDLE_VERSION_FLAG("audiod", conf);
+	audiod_cmdline_parser_ext(argc, argv, &conf, &params);
+	daemon_set_loglevel(conf.loglevel_arg);
+	version_handle_flag("audiod", conf.version_given);
 	/* init receivers/filters/writers early to make help work */
 	recv_init();
 	filter_init();
@@ -1374,7 +1393,7 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 	}
 	log_welcome("para_audiod");
-	server_uptime(UPTIME_SET);
+	set_server_start_time(NULL);
 	set_initial_status();
 	FOR_EACH_SLOT(i)
 		clear_slot(i);
@@ -1385,14 +1404,14 @@ int main(int argc, char *argv[])
 	init_command_task(cmd_task);
 
 	if (conf.daemon_given)
-		daemonize();
-
-	register_task(&sig_task->task);
-	register_task(&cmd_task->task);
-	register_task(&stat_task->task);
-	s.default_timeout.tv_sec = 2;
-	s.default_timeout.tv_usec = 999 * 1000;
-	ret = schedule(&s);
+		daemonize(false /* parent exits immediately */);
+
+	register_task(&sched, &sig_task->task);
+	register_task(&sched, &cmd_task->task);
+	register_task(&sched, &stat_task->task);
+	sched.default_timeout.tv_sec = 2;
+	sched.default_timeout.tv_usec = 999 * 1000;
+	ret = schedule(&sched);
 
 	PARA_EMERG_LOG("%s\n", para_strerror(-ret));
 	return EXIT_FAILURE;