Add --status-file (-0) option. This file keeps latest program status.

ChangeLog

    running of several notification scripts in parallel which can lead to
    races if the scripts are used for logging.
  * Start passing _INPUT_ADDR and _OUTPUT_ADDR variables to notify script.
+ * Add --status-file (-0) option. This file keeps latest program status.
 
 2013-09-12 : Version 10.0
  * Add --ecm-only (-v) option. This allows processing of ECMs but without

README

  -N --notify-program <prg>  | Execute <prg> to report events. Default: empty
  -9 --notify-wait           | Enable one by one notification delivery.
                             . Default: not set (async, deliver ASAP)
+ -0 --status-file <file>    | Save current program status in file.
 
 Input options:
  -I --input <source>        | Where to read from. File or multicast address.

data.c

 	// unhappy it is a good idea to free the memory (ONCE!).
 	FREE(ts->camd.newcamd.crypt_passwd);
 
+	ts->status_file = NULL;
+	FREE(ts->status_file_tmp);
+
 	pthread_attr_destroy(&ts->thread_attr);
 }

data.h

 	struct notify		*notify;
 	char				*notify_program;
 	int					notify_wait;
+	char				*status_file;
+	char				*status_file_tmp;
 
 	unsigned int		input_buffer_time;
 	LIST				*input_buffer;

notify-script.example

 
 LOG_ENABLED="yes"
 LOG_DIR="."
-LOG_FILE="$LOGDIR/notify.${_IDENT}.notify.log"
+LOG_FILE="$LOG_DIR/notify.${_IDENT}.notify.log"
+
+STATUS_ENABLED="yes"
+STATUS_FILE="$LOG_DIR/status.${_IDENT}"
 
 # Environmental vars that are set by the calling process (tsdecrypt):
 #   _TS             Unix timestamp of the event.
 		"${_IDENT}" \
 		"${_MESSAGE_ID}" \
 		"${_MESSAGE_TEXT}" \
-		  >> $LOG_DIR/$LOG_FILE
+		  >> $LOG_FILE
+fi
+
+if [ "$STATUS_ENABLED" = "yes" ]; then
+	# Run tsdecrypt with --notify-wait otherwise the events might get here out of order
+	echo "${_IDENT}|${_TS}|${_MESSAGE_ID}|${_MESSAGE_TEXT}|${_INPUT_ADDR}|${_OUTPUT_ADDR}" > $STATUS_FILE.tmp
+	mv $STATUS_FILE.tmp $STATUS_FILE
 fi
 
 if [ "$EMAIL_ENABLED" = "yes" ]

notify.c

 #include "util.h"
 
 struct npriv {
-	char	ident[512];
+	char	ident[128];
 	char	program[512];
-	char	msg_id[512];
-	char	text[512];
+	char	msg_id[64];
+	char	text[256];
 	char	input[128];
 	char	output[128];
+	time_t	ts;
 	int		sync;			/* Wait for message to be delivered */
 };
 
 		int e = 0;
 		unsigned int i, r;
 		char **env = calloc(32, sizeof(char *));
-		if (asprintf(&env[e++], "_TS=%ld"			, time(NULL)) < 0) exit(EXIT_FAILURE);
+		if (asprintf(&env[e++], "_TS=%ld"			, shared->ts) < 0) exit(EXIT_FAILURE);
 		if (asprintf(&env[e++], "_IDENT=%s"			, shared->ident) < 0) exit(EXIT_FAILURE);
 		if (asprintf(&env[e++], "_INPUT_ADDR=%s"	, shared->input) < 0) exit(EXIT_FAILURE);
 		if (asprintf(&env[e++], "_OUTPUT_ADDR=%s"	, shared->output) < 0) exit(EXIT_FAILURE);
 
 struct notify *notify_alloc(struct ts *ts) {
 	unsigned int i;
-	if (!ts->ident || !ts->notify_program)
-		return NULL;
 	struct notify *n = calloc(1, sizeof(struct notify));
-	n->notifications = queue_new();
-	strncpy(n->ident, ts->ident, sizeof(n->ident) - 1);
-	n->ident[sizeof(n->ident) - 1] = '\0';
+	if (!n)
+		return NULL;
+
+	if (!ts->ident)
+		return NULL;
+
+	// Init notify members
+	strncpy(n->ident, ts->ident, sizeof(n->ident) - 2);
 	for (i=0; i<strlen(n->ident); i++) {
 		if (n->ident[i] == '/')
 			n->ident[i] = '-';
 	}
-	strncpy(n->program, ts->notify_program, sizeof(n->program) - 1);
-	n->program[sizeof(n->program) - 1] = '\0';
-	pthread_create(&n->thread, &ts->thread_attr , &notify_thread, n);
+
+	// We'll need the notify thread and the queue only if 'notify_program' is set
+	if (ts->ident && ts->notify_program) {
+		strncpy(n->program, ts->notify_program, sizeof(n->program) - 2);
+		n->notifications = queue_new();
+		pthread_create(&n->thread, &ts->thread_attr , &notify_thread, n);
+	}
 	return n;
 }
 
-static void npriv_init_defaults(struct notify *n, struct npriv *np) {
-	strncpy(np->program, n->program, sizeof(np->program) - 1);
-	strncpy(np->ident, n->ident, sizeof(np->ident) - 1);
-}
-
-static void notify_func(struct ts *ts, int sync_msg, char *msg_id, char *msg_text) {
-	struct npriv *np;
-
-	if (!ts->notify)
-		return;
-
-	np = calloc(1, sizeof(struct npriv));
-
+static void npriv_struct_fill(struct npriv *np, struct ts *ts, int sync_msg, char *msg_id, char *msg_text) {
 	np->sync = sync_msg;
 	if (ts->notify_wait)
 		np->sync = 1;
-	npriv_init_defaults(ts->notify, np);
+	np->ts = time(NULL);
 
-	strncpy(np->msg_id, msg_id, sizeof(np->ident) - 1);
-	np->msg_id[sizeof(np->ident) - 1] = 0;
-
-	strncpy(np->text, msg_text, sizeof(np->text) - 1);
-	np->text[sizeof(np->text) - 1] = 0;
+	strncpy(np->program, ts->notify->program, sizeof(np->program) - 2);
+	strncpy(np->ident, ts->notify->ident, sizeof(np->ident) - 2);
+	strncpy(np->msg_id, msg_id, sizeof(np->msg_id) - 2);
+	strncpy(np->text, msg_text, sizeof(np->text) - 2);
 
 	if (ts->input.type == NET_IO) {
 		snprintf(np->input, sizeof(np->input), "%s:%s", ts->input.hostname, ts->input.service);
 	} else {
 		snprintf(np->output, sizeof(np->output), "DISABLED");
 	}
+}
 
-	queue_add(ts->notify->notifications, np);
+static void notify_func(struct ts *ts, int sync_msg, char *msg_id, char *msg_text) {
+	struct npriv np_local;
+	int np_local_inited = 0;
+
+	if (ts->status_file) {
+		memset(&np_local, 0, sizeof(np_local));
+		npriv_struct_fill(&np_local, ts, sync_msg, msg_id, msg_text);
+		np_local_inited = 1;
+		// Write status file
+		FILE *status_file = fopen(ts->status_file_tmp, "w");
+		if (status_file) {
+			fprintf(status_file, "%s|%ld|%s|%s|%s|%s\n", np_local.ident, np_local.ts, np_local.msg_id, np_local.text, np_local.input, np_local.output);
+			rename(ts->status_file_tmp, ts->status_file);
+			fclose(status_file);
+		}
+	}
+
+	if (ts->notify->notifications) {
+		struct npriv *np = calloc(1, sizeof(struct npriv));
+		if (np) {
+			if (np_local_inited) {
+				memcpy(np, &np_local, sizeof(*np));
+			} else {
+				npriv_struct_fill(np, ts, sync_msg, msg_id, msg_text);
+			}
+			queue_add(ts->notify->notifications, np);
+		}
+	}
 }
 
 #define MAX_MSG_TEXT 256
 void notify_free(struct notify **pn) {
 	struct notify *n = *pn;
 	if (n) {
-		queue_add(n->notifications, NULL);
-		pthread_join(n->thread, NULL);
-		queue_free(&n->notifications);
+		if (n->notifications) {
+			queue_add(n->notifications, NULL);
+			pthread_join(n->thread, NULL);
+			queue_free(&n->notifications);
+		}
 		FREE(*pn);
 	}
 }

tsdecrypt.1

 running. \fB*NOTE*\fR if you set this option make sure that notification
 script does not take a lot of time to run or you'll run into problems.
 .TP
+\fB\-0\fR, \fB\-\-status-file\fR <filename>
+Write latest notification in file named <filename>. You can monitor this
+file to know what is the current tsdecrypt status.
+
+The file contains the following fields (see \fBEVENTS\fR bellow) separated
+by the pipe symbol (|).
+
+  _IDENT
+  _TS
+  _MESSAGE_ID
+  _MESSAGE_TEXT
+  _INPUT_ADDR
+  _OUTPUT_ADDR
+
+See \fBEVENTS\fR section for detailed description of the events.
+
+See \fBnotify-script.example\fR for example how to implement
+\fB--status-file\fR by using external notification script.
+.TP
 \fB\-S\fR, \fB\-\-syslog\fR
 Write log messages to local syslog.
 .TP

tsdecrypt.c

 		LOG(msg);
 }
 
-static const char short_options[] = "i:d:N:9Sl:L:F:I:1:RzM:T:W:O:o:t:rk:g:upwxyc:C:Y:Q:A:s:U:P:B:46eZ:Ef:a:X:vqH:G:2:KJ:D:jbhVn:m:";
+static const char short_options[] = "i:d:N:90:Sl:L:F:I:1:RzM:T:W:O:o:t:rk:g:upwxyc:C:Y:Q:A:s:U:P:B:46eZ:Ef:a:X:vqH:G:2:KJ:D:jbhVn:m:";
 
-// Unused short options: 035789
+// Unused short options: 3578
 static const struct option long_options[] = {
 	{ "ident",				required_argument, NULL, 'i' },
 	{ "daemon",				required_argument, NULL, 'd' },
 	{ "log-file",			required_argument, NULL, 'F' },
 	{ "notify-program",		required_argument, NULL, 'N' },
 	{ "notify-wait",		no_argument,       NULL, '9' },
+	{ "status-file",		required_argument, NULL, '0' },
 
 	{ "input",				required_argument, NULL, 'I' },
 	{ "input-source",		required_argument, NULL, '1' },
 	printf(" -N --notify-program <prg>  | Execute <prg> to report events. Default: empty\n");
 	printf(" -9 --notify-wait           | Enable one by one notification delivery.\n");
 	printf("                            . Default: not set (async, deliver ASAP)\n");
+	printf(" -0 --status-file <file>    | Save current program status in file.\n");
 	printf("\n");
 	printf("Input options:\n");
 	printf(" -I --input <source>        | Where to read from. File or multicast address.\n");
 			case '9': // --notify-wait
 				ts->notify_wait = !ts->notify_wait;
 				break;
+			case '0': // --status-file
+				ts->status_file = optarg;
+				ts->status_file_tmp = calloc(1, strlen(optarg) + 16);
+				snprintf(ts->status_file_tmp, strlen(optarg) + 16, "%s.tmp", optarg);
+				break;
 			case 'S': // --syslog
 				ts->syslog_active = 1;
 				ts->syslog_remote = 0;
 		}
 	}
 	if (!ts->ident) {
-		if (ts->syslog_active || ts->notify_program)
+		if (ts->syslog_active || ts->notify_program || ts->status_file)
 			ident_err = 1;
 	}
 
 	}
 
 	if (ident_err || ca_err || server_err || input_addr_err || output_addr_err || ts->input.type == WTF_IO || ts->output.type == WTF_IO) {
-		show_help(ts);
 		if (ident_err)
 			fprintf(stderr, "ERROR: Ident is not set, please use --ident option.\n");
 		if (ca_err)
 		ts_LOGf("Ident      : %s\n", ts->ident);
 	if (ts->notify_program)
 		ts_LOGf("Notify prg : %s (%s)\n", ts->notify_program, ts->notify_wait ? "sync" : "async");
+	if (ts->status_file)
+		ts_LOGf("Status file: %s\n", ts->status_file);
 	if (ts->pidfile)
 		ts_LOGf("Daemonize  : %s pid file.\n", ts->pidfile);
 	if (ts->syslog_active) {