Initial import.

.gitignore

@@ -0,0 +1,2 @@
+*.o
+mptsd

.gitmodules

@@ -0,0 +1,6 @@
+[submodule "libfuncs"]
+	path = libfuncs
+	url = git://github.com/gfto/libfuncs.git
+[submodule "libtsfuncs"]
+	path = libtsfuncs
+	url = git://github.com/gfto/libtsfuncs.git

Makefile

@@ -0,0 +1,56 @@
+CC = $(CROSS)$(TARGET)gcc
+STRIP = $(CROSS)$(TARGET)strip
+BUILD_ID = $(shell date +%F_%R)
+GIT_VER = $(shell git describe --tags --dirty --always)
+CFLAGS = -ggdb -Wall -Wextra -Wshadow -Wformat-security -Wno-strict-aliasing -O2 -D_GNU_SOURCE -DBUILD_ID=\"$(BUILD_ID)\" -DGIT_VER=\"$(GIT_VER)\"
+RM = /bin/rm -f
+Q = @
+
+LIBS = -lpthread -lm -lrt
+
+FUNCS_DIR = libfuncs
+FUNCS_LIB = $(FUNCS_DIR)/libfuncs.a
+
+TSFUNCS_DIR = libtsfuncs
+TSFUNCS_LIB = $(TSFUNCS_DIR)/libtsfuncs.a
+
+mptsd_OBJS =  $(FUNCS_LIB) $(TSFUNCS_LIB) \
+	iniparser.o inidict.o pidref.o data.o config.o \
+	sleep.o network.o \
+	input.o \
+	output_psi.o output_mix.o output_write.o \
+	web_pages.o web_server.o \
+	mptsd.o
+
+PROGS = mptsd
+CLEAN_OBJS = $(PROGS) $(mptsd_OBJS) *~
+
+all: $(PROGS)
+
+$(FUNCS_LIB):
+	$(Q)echo "  MAKE	$(FUNCS_LIB)"
+	$(Q)$(MAKE) -s -C $(FUNCS_DIR)
+
+$(TSFUNCS_LIB):
+	$(Q)echo "  MAKE	$(TSFUNCS_LIB)"
+	$(Q)$(MAKE) -s -C $(TSFUNCS_DIR)
+
+mptsd: $(mptsd_OBJS)
+	$(Q)echo "  LINK	mptsd"
+	$(Q)$(CC) $(CFLAGS) $(mptsd_OBJS) $(LIBS) -o mptsd
+
+%.o: %.c data.h
+	$(Q)echo "  CC	mptsd		$<"
+	$(Q)$(CC) $(CFLAGS)  -c $<
+
+strip:
+	$(Q)echo "  STRIP	$(PROGS)"
+	$(Q)$(STRIP) $(PROGS)
+
+clean:
+	$(Q)echo "  RM	$(CLEAN_OBJS)"
+	$(Q)$(RM) $(CLEAN_OBJS)
+
+distclean: clean
+	$(Q)$(MAKE) -s -C $(TSFUNCS_DIR) clean
+	$(Q)$(MAKE) -s -C $(FUNCS_DIR) clean

TODO

@@ -0,0 +1,8 @@
+mptsd todo
+- Add web access to stats
+- Support rewritting of incomming EIT tables
+- Add live reconfiguration
+  - Adding removing channels
+  - Changing of output address and bitrate
+  - Reloading of nit/eit
+- Add support for schedule eit

config.c

@@ -0,0 +1,625 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <fcntl.h>
+#include <regex.h>
+#include <math.h>
+#include <netdb.h> // for uint32_t
+
+#include "libfuncs/log.h"
+#include "libfuncs/list.h"
+#include "libfuncs/server.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "data.h"
+#include "sleep.h"
+#include "config.h"
+#include "inidict.h"
+#include "iniparser.h"
+
+extern char *server_sig;
+extern char *server_ver;
+extern char *copyright;
+
+int is_valid_url(char *url) {
+	regex_t re;
+	regmatch_t res[5];
+	int ret;
+	regcomp(&re, "^([a-z]+)://([^:/?]+):?([0-9]*)/?(.*)", REG_EXTENDED);
+	ret = regexec(&re,url,5,res,0);
+	regfree(&re);
+	return ret == 0;
+}
+
+CONFIG *config_alloc() {
+	CONFIG *conf = calloc(1, sizeof(CONFIG));
+	conf->inputs = list_new("input");
+	conf->nit    = list_new("nit");
+	conf->output = output_new();
+	return conf;
+}
+
+void config_free(CONFIG **pconf) {
+	CONFIG *conf = *pconf;
+	if (conf) {
+		conf->output->dienow = 1;
+
+		list_free(&conf->nit, NULL, nit_free);
+		list_free(&conf->inputs, NULL, input_free);
+		list_free(&conf->channels, NULL, channel_free);
+		output_free(&conf->output);
+
+		FREE(conf->ident);
+		FREE(conf->pidfile);
+		FREE(conf->server_addr);
+		FREE(conf->loghost);
+		FREE(conf->logident);
+		FREE(conf->global_conf);
+		FREE(conf->channels_conf);
+		FREE(conf->nit_conf);
+		FREE(conf->epg_conf);
+		FREE(conf->network_name);
+		FREE(conf->provider_name);
+		FREE(*pconf);
+	}
+}
+
+
+int config_load_channels(CONFIG *conf) {
+	int num_channels = 0, i, j;
+
+	LOGf("CONFIG: Loading channels config %s\n", conf->channels_conf);
+	dictionary *ini = iniparser_load(conf->channels_conf);
+	if (!ini) {
+		LOGf("CONFIG: Error loading channels config (%s)\n", conf->channels_conf);
+		return 0;
+	}
+
+	//iniparser_dump(ini, stdout);
+	LIST *channels = list_new("channels");
+
+	// Parse channels file
+	conf->provider_name = ini_get_string_copy(ini, NULL, "Global:provider_name");
+	conf->transport_stream_id = ini_get_int(ini, 0, "Global:transport_stream_id");
+	for (i=1;i<32;i++) {
+		CHANNEL *channel = NULL;
+		int service_id = ini_get_int(ini, 0, "Channel%d:service_id", i);
+		if (!service_id)
+			continue;
+
+		int is_radio = ini_get_bool(ini, 0, "Channel%d:radio", i);
+
+		char *id = ini_get_string(ini, NULL, "Channel%d:id", i);
+		if (!id) {
+			LOGf("CONFIG: Channel%d have no defined id\n", i);
+			continue;
+		}
+
+		char *name = ini_get_string(ini, NULL, "Channel%d:name", i);
+		if (!name) {
+			LOGf("CONFIG: Channel%d have no defined name\n", i);
+			continue;
+		}
+
+		for (j=1;j<8;j++) {
+			char *source = ini_get_string(ini, NULL, "Channel%d:source%d", i, j);
+			if (j == 1 && !source) {
+				source = ini_get_string(ini, NULL, "Channel%d:source", i);
+			}
+			if (source) {
+				if (!is_valid_url(source)) {
+					LOGf("CONFIG: Invalid url: %s\n", source);
+					continue;
+				}
+				// Init channel
+				if (channel == NULL) {
+					channel = channel_new(service_id, is_radio, id, name, source);
+				} else {
+					chansrc_add(channel, source);
+				}
+			}
+		}
+
+		char *worktime = ini_get_string(ini, NULL, "Channel%d:worktime", i);
+		int sh=0,sm=0,eh=0,em=0;
+		if (worktime && sscanf(worktime, "%02d:%02d-%02d:%02d", &sh, &sm, &eh, &em) == 4) {
+			channel->worktime_start = sh * 3600 + sm * 60;
+			channel->worktime_end   = eh * 3600 + em * 60;
+		}
+
+		// Channel is initialized, add it to channels list
+		if (channel) {
+			num_channels++;
+			list_add(channels, channel);
+		}
+	}
+//	iniparser_dump(ini, stderr);
+	iniparser_freedict(&ini);
+
+	// Check for channel changes
+	struct timeval tv;
+	gettimeofday(&tv, NULL);
+	unsigned int randstate = tv.tv_usec;
+	int cookie = rand_r(&randstate);
+
+	/* Save current channels config */
+	LIST *old_channels = conf->channels;
+
+	/* Switch new channels config */
+	conf->channels = channels;
+
+	/* Rewrite restreamer channels */
+	LNODE *lc, *lr, *lctmp, *lrtmp;
+	CHANNEL *chan;
+	list_lock(conf->inputs);	// Unlocked after second list_for_each(restreamer)
+	list_lock(conf->channels);
+	list_for_each(conf->channels, lc, lctmp) {
+		chan = lc->data;
+		list_for_each(conf->inputs, lr, lrtmp) {
+			if (strcmp(chan->name, ((INPUT *)lr->data)->name)==0) {
+				INPUT *restr = lr->data;
+				/* Mark the restreamer as valid */
+				restr->cookie = cookie;
+				/* Check if current source exists in new channel configuration */
+				int src_found = -1;
+				char *old_source = restr->channel->source;
+				for (i=0; i<chan->num_src; i++) {
+					if (strcmp(old_source, chan->sources[i]) == 0) {
+						src_found = i;
+					}
+				}
+				if (src_found > -1) {
+					/* New configuration contains existing source, just update the reference */
+					chansrc_set(chan, src_found);
+					restr->channel = chan;
+				} else {
+					/* New configuration *DO NOT* contain existing source. Force reconnect */
+					LOGf("INPUT: Source changed | Channel: %s srv_fd: %d Old:%s New:%s\n", chan->name, restr->sock, restr->channel->source, chan->source);
+					/* The order is important! */
+					chansrc_set(chan, chan->num_src-1); /* Set source to last one. On reconnect next source will be used. */
+					restr->channel = chan;
+					restr->reconnect = 1;
+				}
+				break;
+			}
+		}
+	}
+	list_unlock(conf->channels);
+
+	/* Kill restreamers that serve channels that no longer exist */
+	list_for_each(conf->inputs, lr, lrtmp) {
+		INPUT *r = lr->data;
+		/* This restreamer should no longer serve clients */
+		if (r->cookie != cookie) {
+			proxy_log(r, "Remove");
+			/* Replace channel reference with real object and instruct free_restreamer to free it */
+			r->channel = channel_new(r->channel->service_id, r->channel->radio, r->channel->id, r->channel->name, r->channel->source);
+			r->freechannel = 1;
+			r->dienow = 1;
+		}
+	}
+	list_unlock(conf->inputs);
+
+	/* Free old_channels */
+	list_free(&old_channels, NULL, channel_free);
+
+	LOGf("CONFIG: %d channels loaded\n", num_channels);
+	return num_channels;
+}
+
+int config_load_global(CONFIG *conf) {
+	LOGf("CONFIG: Loading global config %s\n", conf->global_conf);
+	dictionary *ini = iniparser_load(conf->global_conf);
+	if (!ini) {
+		LOGf("CONFIG: Error loading global config (%s)\n", conf->global_conf);
+		return 0;
+	}
+	conf->network_id		= ini_get_int(ini, 0,    "Global:network_id");
+	conf->timeouts.pat		= ini_get_int(ini, 100,  "Timeouts:pat");
+	conf->timeouts.pmt		= ini_get_int(ini, 200,  "Timeouts:pmt");
+	conf->timeouts.sdt		= ini_get_int(ini, 500,  "Timeouts:sdt");
+	conf->timeouts.nit		= ini_get_int(ini, 2000, "Timeouts:nit");
+	conf->timeouts.eit		= ini_get_int(ini, 1000, "Timeouts:eit");
+	conf->timeouts.tdt		= ini_get_int(ini, 7500, "Timeouts:tdt");
+	conf->timeouts.tot		= ini_get_int(ini, 1500, "Timeouts:tot");
+	conf->timeouts.stats	= ini_get_int(ini, 0,    "Timeouts:stats");
+	//iniparser_dump(ini, stderr);
+	iniparser_freedict(&ini);
+	return 1;
+}
+
+int config_load_nit(CONFIG *conf) {
+	LOGf("CONFIG: Loading nit config %s\n", conf->nit_conf);
+	dictionary *ini = iniparser_load(conf->nit_conf);
+	if (!ini) {
+		LOGf("CONFIG: Error loading nit config (%s)\n", conf->nit_conf);
+		return 0;
+	}
+	conf->network_name = ini_get_string_copy(ini, NULL, "Global:network_name");
+	int i;
+	for (i=1;i<32;i++) {
+		uint16_t ts_id = ini_get_int   (ini, 0, "Transponder%d:transport_stream_id", i);
+		char *freq     = ini_get_string(ini, NULL, "Transponder%d:frequency", i);
+		char *mod      = ini_get_string(ini, NULL, "Transponder%d:modulation", i);
+		char *sr       = ini_get_string(ini, NULL, "Transponder%d:symbol_rate", i);
+		if (ts_id && freq && mod && sr) {
+			if (strlen(freq) == 9 && strlen(sr) == 8) {
+				list_add(conf->nit, nit_new(ts_id, freq, mod, sr));
+			}
+		}
+	}
+	//iniparser_dump(ini, stderr);
+	iniparser_freedict(&ini);
+	return 1;
+}
+
+static void config_reset_channels_epg(CONFIG *conf) {
+	LNODE *lc, *lctmp;
+	list_lock(conf->channels);
+	list_for_each(conf->channels, lc, lctmp) {
+		CHANNEL *c = lc->data;
+		channel_free_epg(c);
+	}
+	list_unlock(conf->channels);
+	conf->epg_conf_mtime = 0;
+}
+
+static EPG_ENTRY *config_load_epg_entry(dictionary *ini, char *entry, char *channel) {
+	EPG_ENTRY *e = NULL;
+	time_t start = ini_get_int(ini, 0, "%s-%s:start", channel, entry);
+	int duration = ini_get_int(ini, 0, "%s-%s:duration", channel, entry);
+	char *event  = ini_get_string(ini, NULL, "%s-%s:event", channel, entry);
+	char *sdesc  = ini_get_string(ini, NULL, "%s-%s:sdescr", channel, entry);
+	char *ldesc  = ini_get_string(ini, NULL, "%s-%s:descr", channel, entry);
+	char *enc    = ini_get_string(ini, NULL, "%s-%s:encoding", channel, entry);
+	if (start && duration && event) {
+		e = epg_new(start, duration, enc, event, sdesc, ldesc);
+	}
+	return e;
+}
+
+static void config_channel_init_epg(CONFIG *conf, CHANNEL *c, EPG_ENTRY *now, EPG_ENTRY *next) {
+	int updated = 0;
+
+	if (epg_changed(now, c->epg_now)) {
+		LOGf("EPG  : %s | Now data changed\n", c->id);
+		updated++;
+	}
+
+	if (epg_changed(next, c->epg_next)) {
+		LOGf("EPG  : %s | Next data changed\n", c->id);
+		updated++;
+	}
+
+	if (!updated)
+		return;
+
+	// LOGf("EPG  : %s | Version %d\n", c->epg_version);
+	c->epg_version++;
+
+	struct ts_eit *eit_now = ts_eit_alloc_init_pf(c->service_id, conf->transport_stream_id, conf->network_id, 0, 1);
+	eit_now->section_header->version_number = c->epg_version;
+	if (now) {
+		ts_eit_add_short_event_descriptor(eit_now, now->event_id, 1, now->start, now->duration, now->event, now->short_desc);
+		ts_eit_add_extended_event_descriptor(eit_now, now->event_id, 1, now->start, now->duration, now->long_desc);
+	}
+	ts_eit_regenerate_packets(eit_now);
+
+	struct ts_eit *eit_next = ts_eit_alloc_init_pf(c->service_id, conf->transport_stream_id, conf->network_id, 1, 1);
+	eit_next->section_header->version_number = c->epg_version;
+	if (next) {
+		ts_eit_add_short_event_descriptor(eit_next, next->event_id, 1, next->start, next->duration, next->event, next->short_desc);
+		ts_eit_add_extended_event_descriptor(eit_next, next->event_id, 1, next->start, next->duration, next->long_desc);
+	}
+	ts_eit_regenerate_packets(eit_next);
+
+	channel_free_epg(c);
+
+	c->epg_now  = now;
+	c->epg_next = next;
+
+	if (now || next) {
+		c->eit_now  = eit_now;
+		c->eit_next = eit_next;
+		//LOGf(" ***** NOW ******\n");
+		//ts_eit_dump(eit_now);
+		//LOGf(" ***** NEXT *****\n");
+		//ts_eit_dump(eit_next);
+	} else {
+		ts_eit_free(&eit_now);
+		ts_eit_free(&eit_next);
+	}
+}
+
+
+int config_load_epg(CONFIG *conf) {
+	struct stat st;
+	if (stat(conf->epg_conf, &st) == 0) {
+		if (st.st_mtime > conf->epg_conf_mtime) {
+			// Set config last change time
+			conf->epg_conf_mtime = st.st_mtime;
+		} else {
+			// LOGf("CONFIG: EPG config not changed since last check.\n");
+			return 0; // The config has not changed!
+		}
+	} else {
+		// Config file not found!
+		LOGf("CONFIG: EPG config file is not found (%s)\n", conf->epg_conf);
+		config_reset_channels_epg(conf);
+		return 0;
+	}
+
+	// LOGf("CONFIG: Loading EPG config %s\n", conf->epg_conf);
+	dictionary *ini = iniparser_load(conf->epg_conf);
+	if (!ini) {
+		LOGf("CONFIG: Error parsing EPG config (%s)\n", conf->epg_conf);
+		config_reset_channels_epg(conf);
+		return 0;
+	}
+
+	LNODE *lc, *lctmp;
+	list_lock(conf->channels);
+	list_for_each(conf->channels, lc, lctmp) {
+		CHANNEL *c = lc->data;
+		EPG_ENTRY *enow  = config_load_epg_entry(ini, "now", c->id);
+		EPG_ENTRY *enext = config_load_epg_entry(ini, "next", c->id);
+		config_channel_init_epg(conf, c, enow, enext);
+	}
+	list_unlock(conf->channels);
+	//iniparser_dump(ini, stderr);
+	iniparser_freedict(&ini);
+
+	return 1;
+}
+
+extern char *program_id;
+
+static void show_usage() {
+	printf("%s\n", program_id);
+	puts(copyright);
+	puts("");
+	puts("Identification:");
+	puts("\t-i ident\tServer ident.               (default: ux/mptsd)");
+	puts("");
+	puts("Server settings:");
+	puts("\t-b addr\t\tLocal IP address to bind.   (default: 0.0.0.0)");
+	puts("\t-p port\t\tPort to listen.             (default: 0)");
+	puts("\t-d pidfile\tDaemonize with pidfile");
+	puts("\t-l host\t\tSyslog host                 (default: disabled)");
+	puts("\t-L port\t\tSyslog port                 (default: 514)");
+	puts("");
+	puts("Configuration files:");
+	puts("\t-g file\t\tGlobal configuration file   (default: mptsd.conf)");
+	puts("\t-c file\t\tChannels configuration file (default: mptsd_channels.conf)");
+	puts("\t-e file\t\tEPG configuration file      (default: mptsd_epg.conf)");
+	puts("\t-n file\t\tNIT configuration file      (default: mptsd_nit.conf)");
+	puts("");
+	puts("Output settings:");
+	puts("\t-O ip\t\tOutput udp address");
+	puts("\t-P ip\t\tOutput udp port             (default: 5000)");
+	puts("\t-o ip\t\tOutput interface address    (default: 0.0.0.0)");
+	puts("\t-t ttl\t\tSet multicast ttl           (default: 1)");
+	puts("");
+	puts("\t-B Mbps\t\tOutput bitrate in Mbps      (default: 38.00)");
+	puts("\t-m mode\t\tPCR mode (modes list bellow)");
+	puts("\t\t\t- Mode 0: do not touch PCRs (default)");
+	puts("\t\t\t- Mode 1: move PCRs to their calculated place");
+	puts("\t\t\t- Mode 2: rewrite PCRs using output bitrate");
+	puts("\t\t\t- Mode 3: move PCRs and rewrite them");
+	puts("");
+	puts("Other settings:");
+	puts("\t-q\t\tQuiet");
+	puts("\t-D\t\tDebug");
+	puts("");
+	puts("\t-W\t\tWrite output file");
+	puts("\t-E\t\tWrite input file");
+	puts("");
+}
+
+void config_load(CONFIG *conf, int argc, char **argv) {
+	int j, ttl;
+
+	conf->multicast_ttl = 1;
+	conf->output->out_port = 5000;
+	conf->output_bitrate = 38;
+	conf->logport = 514;
+	conf->server_port = 0;
+	conf->server_socket = -1;
+
+	while ((j = getopt(argc, argv, "i:b:p:g:c:n:e:d:t:o:O:P:l:L:B:m:qDHhWE")) != -1) {
+		switch (j) {
+			case 'i':
+				conf->ident = strdup(optarg);
+				conf->logident = strdup(optarg);
+				char *c = conf->logident;
+				while (*c) {
+					if (*c=='/')
+						*c='-';
+					c++;
+				}
+				break;
+			case 'b':
+				conf->server_addr = strdup(optarg);
+				break;
+			case 'p':
+				conf->server_port = atoi(optarg);
+				break;
+			case 'd':
+				conf->pidfile = strdup(optarg);
+				break;
+			case 'g':
+				conf->global_conf = strdup(optarg);
+				break;
+			case 'c':
+				conf->channels_conf = strdup(optarg);
+				break;
+			case 'n':
+				conf->nit_conf = strdup(optarg);
+				break;
+			case 'e':
+				conf->epg_conf = strdup(optarg);
+				break;
+			case 'o':
+				if (inet_aton(optarg, &conf->output_intf) == 0) {
+					fprintf(stderr, "Invalid interface address: %s\n", optarg);
+					exit(1);
+				}
+				break;
+			case 'O':
+				if (inet_aton(optarg, &(conf->output->out_host)) == 0) {
+					fprintf(stderr, "Invalid output address: %s\n", optarg);
+					exit(1);
+				}
+				break;
+			case 'P':
+				conf->output->out_port = atoi(optarg);
+				if (!conf->output->out_port || conf->output->out_port < 1024) {
+					fprintf(stderr, "Invalid output port: %s\n", optarg);
+					exit(1);
+				}
+				break;
+			case 'm':
+				conf->pcr_mode = atoi(optarg);
+				if (conf->pcr_mode < 0 || conf->pcr_mode > 4)
+					conf->pcr_mode = 0;
+				break;
+			case 't':
+				ttl = atoi(optarg);
+				conf->multicast_ttl = (ttl && ttl < 127) ? ttl : 1;
+				break;
+			case 'l':
+				conf->loghost = strdup(optarg);
+				conf->syslog_active = 1;
+				break;
+			case 'L':
+				conf->logport = atoi(optarg);
+				break;
+			case 'B':
+				conf->output_bitrate = atof(optarg);
+				if (conf->output_bitrate < 2 || conf->output_bitrate > 75) {
+					fprintf(stderr, "Invalid output bitrate: %.2f (valid 2-75)\n", conf->output_bitrate);
+					exit(1);
+				}
+				break;
+			case 'W':
+				conf->write_output_file = 1;
+				output_open_file(conf->output);
+				break;
+			case 'E':
+				conf->write_input_file = 1;
+				break;
+			case 'D':
+				conf->debug = 1;
+				break;
+			case 'q':
+				conf->quiet = 1;
+				break;
+			case 'H':
+			case 'h':
+				show_usage(0);
+				exit(0);
+				break;
+		}
+	}
+	if (!conf->output->out_host.s_addr) {
+		fprintf(stderr, "ERROR: Output address is not set (use -O x.x.x.x)\n");
+		show_usage();
+		goto ERR;
+	}
+	// Set defaults
+	if (!conf->ident) {
+		conf->ident = strdup("ux/mptsd");
+		conf->logident = strdup("ux-mptsd");
+	}
+	if (!conf->global_conf) {
+		conf->global_conf = strdup("mptsd.conf");
+	}
+	if (!conf->channels_conf) {
+		conf->channels_conf = strdup("mptsd_channels.conf");
+	}
+	if (!conf->nit_conf) {
+		conf->nit_conf = strdup("mptsd_nit.conf");
+	}
+	if (!conf->epg_conf) {
+		conf->epg_conf = strdup("mptsd_epg.conf");
+	}
+
+	// Align bitrate to 1 packet (1316 bytes)
+	conf->output_bitrate        *= 1000000; // In bytes
+	conf->output_packets_per_sec = ceil(conf->output_bitrate / (1316 * 8));
+	conf->output_bitrate         = conf->output_packets_per_sec * (1316 * 8);
+	conf->output_tmout           = 1000000 / conf->output_packets_per_sec;
+
+	if (conf->server_port)
+		init_server_socket(conf->server_addr, conf->server_port, &conf->server, &conf->server_socket);
+
+	if (!conf->quiet) {
+		printf("Configuration:\n");
+		printf("\tServer ident      : %s\n", conf->ident);
+		printf("\tGlobal config     : %s\n", conf->global_conf);
+		printf("\tChannels config   : %s\n", conf->channels_conf);
+		printf("\tNIT config        : %s\n", conf->nit_conf);
+		printf("\tOutput addr       : udp://%s:%d\n", inet_ntoa(conf->output->out_host), conf->output->out_port);
+		if (conf->output_intf.s_addr)
+			printf("\tOutput iface addr : %s\n", inet_ntoa(conf->output_intf));
+		printf("\tMulticast ttl     : %d\n", conf->multicast_ttl);
+		if (conf->syslog_active) {
+			printf("\tSyslog host       : %s\n", conf->loghost);
+			printf("\tSyslog port       : %d\n", conf->logport);
+		} else {
+			printf("\tSyslog disabled.\n");
+		}
+		printf("\tOutput bitrate    : %.0f bps, %.2f Kbps, %.2f Mbps\n", conf->output_bitrate, conf->output_bitrate / 1000, conf->output_bitrate / 1000000);
+		printf("\tOutput pkt tmout  : %ld us\n", conf->output_tmout);
+		printf("\tPackets per second: %ld\n", conf->output_packets_per_sec);
+		printf("\tPCR mode          : %s\n",
+			conf->pcr_mode == 0 ? "Do not touch PCRs" :
+			conf->pcr_mode == 1 ? "Move PCRs to their calculated place" :
+			conf->pcr_mode == 2 ? "Rewrite PCRs using output bitrate" :
+			conf->pcr_mode == 3 ? "Move PCRs and rewrite them" : "???"
+		);
+		if (conf->write_output_file)
+			printf("\tWrite output file\n");
+		if (conf->write_input_file)
+			printf("\tWrite input file(s)\n");
+	}
+
+	pthread_t sleepthread;
+	if (pthread_create(&sleepthread, NULL, &calibrate_sleep, conf) == 0) {
+		pthread_join(sleepthread, NULL);
+	} else {
+		perror("calibrate_thread");
+		exit(1);
+	}
+	if (!conf->output_tmout)
+		exit(1);
+
+	output_buffer_alloc(conf->output, conf->output_bitrate);
+
+	if (!config_load_global(conf))
+		goto ERR;
+	if (!config_load_nit(conf))
+		goto ERR;
+	if (!config_load_channels(conf))
+		goto ERR;
+
+	config_load_epg(conf);
+
+	return;
+
+ERR:
+	config_free(&conf);
+	exit(1);
+}

config.h

@@ -0,0 +1,84 @@
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <pthread.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+#include "libfuncs/list.h"
+
+#include "data.h"
+
+typedef struct {
+	char			*ident;
+	char			*pidfile;
+
+	int				syslog_active;
+	char			*logident;
+	char			*loghost;
+	int				logport;
+
+	struct sockaddr_in	server;
+	char				*server_addr;
+	int					server_port;
+	int					server_socket;
+	pthread_t			server_thread;
+
+	int				multicast_ttl;
+	struct in_addr	output_intf;
+
+	char			*global_conf;
+	char			*channels_conf;
+	char			*nit_conf;
+	char			*epg_conf;
+
+	int				debug;
+	int				quiet;
+
+	int				write_input_file;
+	int				write_output_file;
+	int				pcr_mode;			// 0 - do not touch PCRs
+										// 1 - move PCRs to their calculated place
+										// 2 - rewrite PCRs using output bitrate
+										// 3 - move PCRs and rewrite them
+
+	uint16_t		network_id;			// For NIT && SDT
+	uint16_t		transport_stream_id;// For NIT
+	char 			*network_name;		// For NIT
+	char 			*provider_name;		// For SDT
+
+	double			output_bitrate;		// Output bitrate (bps)
+	long			output_tmout;		// Smooth interval miliseconds
+	long			usleep_overhead;		// How much more usecs uslep(1) takes
+	long			output_packets_per_sec;	// How much packets should be sent in one second
+
+	time_t			epg_conf_mtime;		// Last change time of epg config
+
+	LIST *			channels;			// List of channels
+	LIST *			inputs;				// Input threads
+	LIST *			nit;
+	OUTPUT *		output;				// Output
+
+	struct {
+		unsigned int	pat;			// DVB section id 0x00 (program_association_section)
+		unsigned int	pmt;			// DVB section id 0x02 (program_map_section)
+		unsigned int	nit;			// DVB section id 0x40 (network_information_section - actual_network)
+		unsigned int	sdt;			// DVB section id 0x42 (service_description_section - actual_transport_stream)
+		unsigned int	eit;			// DVB section id 0x4e (event_information_section - actual_transport_stream, present/following)
+		unsigned int	tdt;			// DVB section id 0x70 (time_date_section)
+		unsigned int	tot;			// DVB section id 0x73 (time_offset_section)
+		unsigned int	stats;			// Local
+	} timeouts;
+} CONFIG;
+
+
+CONFIG *	config_alloc	();
+void		config_free		(CONFIG **conf);
+void		config_load		(CONFIG *conf, int argc, char **argv);
+
+int			config_load_global		(CONFIG *conf);
+int			config_load_channels	(CONFIG *conf);
+int			config_load_nit			(CONFIG *conf);
+int			config_load_epg			(CONFIG *conf);
+
+#endif

data.c

@@ -0,0 +1,389 @@
+#include <stdlib.h>
+#include <math.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/time.h>
+#include <regex.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "libfuncs/io.h"
+#include "libfuncs/log.h"
+#include "libfuncs/list.h"
+#include "libfuncs/asyncdns.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "data.h"
+#include "config.h"
+#include "output.h"
+
+extern CONFIG *config;
+
+channel_source get_sproto(char *url) {
+	return strncmp(url, "http", 4)==0 ? tcp_sock : udp_sock;
+}
+
+CHANSRC *chansrc_init(char *url) {
+	if (!url)
+		return NULL;
+	regex_t re;
+	regmatch_t res[5];
+	regcomp(&re, "^([a-z]+)://([^:/?]+):?([0-9]*)/?(.*)", REG_EXTENDED);
+	if (regexec(&re,url,5,res,0)==0) {
+		char *data = strdup(url);
+		char *proto, *host, *port, *path;
+		int iport;
+		proto= data+res[1].rm_so; data[res[1].rm_eo]=0;
+		host = data+res[2].rm_so; data[res[2].rm_eo]=0;
+		port = data+res[3].rm_so; data[res[3].rm_eo]=0;
+		path = data+res[4].rm_so; data[res[4].rm_eo]=0;
+		iport = atoi(port);
+		/* Setup */
+		CHANSRC *src = calloc(1, sizeof(CHANSRC));
+		src->proto = strdup(proto);
+		src->sproto= get_sproto(url);
+		src->host  = strdup(host);
+		src->port  = iport ? iport : 80;
+		src->path  = strdup(path);
+		FREE(data);
+		regfree(&re);
+		return src;
+	}
+	regfree(&re);
+	return NULL;
+}
+
+void chansrc_free(CHANSRC **purl) {
+	CHANSRC *url = *purl;
+	if (url) {
+		FREE(url->proto);
+		FREE(url->host);
+		FREE(url->path);
+		FREE(*purl);
+	}
+};
+
+void chansrc_add(CHANNEL *c, char *src) {
+	if (c->num_src >= MAX_CHANNEL_SOURCES-1)
+		return;
+	c->sources[c->num_src] = strdup(src);
+	if (c->num_src == 0) /* Set default source to first one */
+		c->source = c->sources[c->num_src];
+	c->num_src++;
+}
+
+void chansrc_next(CHANNEL *c) {
+	if (c->num_src <= 1)
+		return;
+	// uint8_t old_src = c->curr_src;
+	c->curr_src++;
+	if (c->curr_src >= MAX_CHANNEL_SOURCES-1 || c->sources[c->curr_src] == NULL)
+		c->curr_src = 0;
+	c->source = c->sources[c->curr_src];
+	// LOGf("CHAN : Switch source | Channel: %s OldSrc: %d %s NewSrc: %d %s\n", c->name, old_src, c->sources[old_src], c->curr_src, c->source);
+}
+
+void chansrc_set(CHANNEL *c, uint8_t src_id) {
+	if (src_id >= MAX_CHANNEL_SOURCES-1 || c->sources[src_id] == NULL)
+		return;
+	// uint8_t old_src = c->curr_src;
+	c->curr_src = src_id;
+	c->source = c->sources[c->curr_src];
+	// LOGf("CHAN : Set source    | Channel: %s OldSrc: %d %s NewSrc: %d %s\n", c->name, old_src, c->sources[old_src], c->curr_src, c->source);
+}
+
+
+
+
+
+CHANNEL *channel_new(int service_id, int is_radio, char *id, char *name, char *source) {
+	CHANNEL *c = calloc(1, sizeof(CHANNEL));
+	c->service_id = service_id;
+	c->radio = is_radio;
+	c->base_pid = service_id * 32; // The first pid is saved for PMT
+	c->pmt_pid = c->base_pid; // The first pid is saved for PMT
+	c->id = strdup(id);
+	c->name = strdup(name);
+	chansrc_add(c, source);
+	return c;
+}
+
+void channel_free_epg(CHANNEL *c) {
+	epg_free(&c->epg_now);
+	epg_free(&c->epg_next);
+
+	ts_eit_free(&c->eit_now);
+	ts_eit_free(&c->eit_next);
+}
+
+void channel_free(CHANNEL **pc) {
+	CHANNEL *c = *pc;
+	if (c) {
+		channel_free_epg(c);
+		FREE(c->id);
+		FREE(c->name);
+		int i;
+		for (i=c->num_src-1; i>=0; i--) {
+			FREE(c->sources[i]);
+		}
+		c->source = NULL;
+		FREE(*pc);
+	}
+}
+
+
+EPG_ENTRY *epg_new(time_t start, int duration, char *encoding, char *event, char *short_desc, char *long_desc) {
+	EPG_ENTRY *e;
+	if (!event)
+		return NULL;
+	e             = calloc(1, sizeof(EPG_ENTRY));
+	e->event_id   = (start / 60) &~ 0xffff0000;
+	e->start      = start;
+	e->duration   = duration;
+	if (encoding && strcmp(encoding, "iso-8859-5")==0) {
+		e->event      = init_dvb_string_iso_8859_5(event);
+		e->short_desc = init_dvb_string_iso_8859_5(short_desc);
+		e->long_desc  = init_dvb_string_iso_8859_5(long_desc);
+	} else {	// Default is utf-8
+		e->event      = init_dvb_string_utf8(event);
+		e->short_desc = init_dvb_string_utf8(short_desc);
+		e->long_desc  = init_dvb_string_utf8(long_desc);
+	}
+	return e;
+}
+
+void epg_free(EPG_ENTRY **pe) {
+	EPG_ENTRY *e = *pe;
+	if (e) {
+		FREE(e->event);
+		FREE(e->short_desc);
+		FREE(e->long_desc);
+		FREE(*pe);
+	}
+}
+
+
+// Return 1 if they are different
+// Return 0 if they are the same
+int epg_changed(EPG_ENTRY *a, EPG_ENTRY *b) {
+	if (!a && b) return 1;
+	if (!b && a) return 1;
+	if (!a && !b) return 0;
+	if (a->event_id != b->event_id) return 1;
+	if (a->start != b->start) return 1;
+	if (a->duration != b->duration) return 1;
+	if (xstrcmp(a->event, b->event) != 0) return 1;
+	if (xstrcmp(a->short_desc, b->short_desc) != 0) return 1;
+	if (xstrcmp(a->long_desc, b->long_desc) != 0) return 1;
+	return 0;
+}
+
+void input_stream_alloc(INPUT *input) {
+	input->stream.pidref = pidref_init(64, input->channel->base_pid);
+	input->stream.pat = ts_pat_alloc();
+	input->stream.pmt = ts_pmt_alloc();
+	input->stream.last_pat = ts_pat_alloc();
+	input->stream.last_pmt = ts_pmt_alloc();
+}
+
+void input_stream_free(INPUT *input) {
+	ts_pmt_free(&input->stream.pmt);
+	ts_pmt_free(&input->stream.pmt_rewritten);
+	ts_pmt_free(&input->stream.last_pmt);
+	ts_pat_free(&input->stream.pat);
+	ts_pat_free(&input->stream.pat_rewritten);
+	ts_pat_free(&input->stream.last_pat);
+	pidref_free(&input->stream.pidref);
+	input->stream.nit_pid    = 0;
+	input->stream.pmt_pid    = 0;
+	input->stream.pcr_pid    = 0;
+	input->stream.input_pcr  = 0;
+}
+
+void input_stream_reset(INPUT *input) {
+	input_stream_free(input);
+	input_stream_alloc(input);
+}
+
+INPUT * input_new(const char *name, CHANNEL *channel) {
+	char *tmp;
+	INPUT *r = calloc(1, sizeof(INPUT));
+
+	r->name = strdup(name);
+	r->sock = -1;
+	r->channel = channel;
+
+	if (config->write_input_file) {
+		asprintf(&tmp, "mptsd-input-%s.ts", channel->id);
+		r->ifd = open(tmp, O_CREAT | O_WRONLY | O_TRUNC, 0644);
+		FREE(tmp);
+	}
+
+	r->buf = cbuf_init(1428 * 1316, channel->id); // ~ 10000 x 188
+
+	input_stream_alloc(r);
+
+	return r;
+}
+
+void input_free(INPUT **pinput) {
+	INPUT *r = *pinput;
+	if (!r)
+		return;
+	if (r->sock > -1)
+		shutdown_fd(&(r->sock));
+	if (r->freechannel)
+		channel_free(&r->channel);
+	if (r->ifd)
+		close(r->ifd);
+
+	input_stream_free(r);
+
+	cbuf_free(&r->buf);
+
+	FREE(r->name);
+	FREE(*pinput);
+}
+
+
+
+OUTPUT *output_new() {
+	OUTPUT *o = calloc(1, sizeof(OUTPUT));
+	o->obuf_ms = 100;
+
+	o->psibuf = cbuf_init(50 * 1316, "psi");
+	if (!o->psibuf) {
+		LOGf("ERROR: Can't allocate PSI input buffer\n");
+		exit(1);
+	}
+	cbuf_poison(o->psibuf, 'Y');
+
+	return o;
+}
+
+void output_open_file(OUTPUT *o) {
+	o->ofd = open("mptsd-output.ts", O_CREAT | O_WRONLY | O_TRUNC, 0644);
+}
+
+void obuf_reset(OBUF *ob) {
+	int i;
+	memset(ob->buf, 0xff, ob->size);
+	for (i=0; i<ob->size; i+=188) {
+		ob->buf[i+0] = 0x47;
+		ob->buf[i+1] = 0x1f;
+		ob->buf[i+2] = 0xff;
+		ob->buf[i+3] = 0x00;
+	}
+	ob->written = 0;
+	ob->status  = obuf_empty;
+}
+
+void output_buffer_alloc(OUTPUT *o, double output_bitrate) {
+	if (!output_bitrate) {
+		LOGf("No output bitrate, can't determine buffer!\n");
+		exit(1);
+	}
+
+	o->output_bitrate = output_bitrate;
+
+	long pps  = ceil((double)output_bitrate / (FRAME_PACKET_SIZE * 8));	// Packets per second
+	long ppms = ceil((double)pps / ((double)1000 / o->obuf_ms));		// Packets per o->buffer_ms miliseconds
+	long obuf_size = ppms * 1316;
+
+	o->obuf[0].size   = obuf_size;
+	o->obuf[0].status = obuf_empty;
+	o->obuf[0].buf    = malloc(o->obuf[0].size);
+	obuf_reset(&o->obuf[0]);
+
+	o->obuf[1].size   = obuf_size;
+	o->obuf[1].status = obuf_empty;
+	o->obuf[1].buf    = malloc(o->obuf[0].size);
+	obuf_reset(&o->obuf[1]);
+
+	LOGf("\tOutput buf size   : %ld * 2 = %ld\n", obuf_size, obuf_size * 2);
+	LOGf("\tOutput buf packets: %ld (188 bytes)\n", obuf_size / 188);
+	LOGf("\tOutput buf frames : %ld (1316 bytes)\n", obuf_size / 1316);
+	LOGf("\tOutput buf ms     : %u ms\n", o->obuf_ms);
+}
+
+void output_free(OUTPUT **po) {
+	OUTPUT *o = *po;
+	if (!o)
+		return;
+	if (o->out_sock > -1)
+		shutdown_fd(&(o->out_sock));
+	if (o->ofd)
+		close(o->ofd);
+	cbuf_free(&o->psibuf);
+	FREE(o->obuf[0].buf);
+	FREE(o->obuf[1].buf);
+	output_psi_free(o);
+	FREE(*po);
+}
+
+
+NIT *nit_new(uint16_t ts_id, char *freq, char *mod, char *symbol_rate) {
+	char tmp[9];
+	unsigned i, pos;
+
+	NIT *n = calloc(1, sizeof(NIT));
+	if (strlen(freq) != 9 || strlen(symbol_rate) != 8)
+		return NULL;
+	n->freq        = strdup(freq);
+	n->modulation  = strdup(mod);
+	n->symbol_rate = strdup(symbol_rate);
+	n->ts_id       = ts_id;
+
+	n->_modulation =
+		strcmp(mod, "16-QAM") == 0  ? 0x01 :
+		strcmp(mod, "32-QAM") == 0  ? 0x02 :
+		strcmp(mod, "64-QAM") == 0  ? 0x03 :
+		strcmp(mod, "128-QAM") == 0 ? 0x04 :
+		strcmp(mod, "256-QAM") == 0 ? 0x05 : 0x00;
+
+	memset(tmp, 0, sizeof(tmp));
+	pos = 0;
+	for (i=0;i<strlen(freq);i++) {
+		if (isdigit(freq[i])) {
+			tmp[pos] = freq[i];
+			pos++;
+		}
+	}
+	n->_freq = strtol(tmp, NULL, 16);
+
+	memset(tmp, 0, sizeof(tmp));
+	pos = 0;
+	for (i=0;i<strlen(symbol_rate);i++) {
+		if (isdigit(symbol_rate[i])) {
+			tmp[pos] = symbol_rate[i];
+			pos++;
+		}
+	}
+	n->_symbol_rate = strtol(tmp, NULL, 16);
+
+	return n;
+}
+
+void nit_free(NIT **pn) {
+	NIT *n = *pn;
+	if (n) {
+		FREE(n->freq);
+		FREE(n->modulation);
+		FREE(n->symbol_rate);
+		FREE(*pn);
+	}
+}
+
+void proxy_log(INPUT *r, char *msg) {
+	LOGf("INPUT : [%-12s] %s fd: %d src: %s\n", r->channel->id, msg, r->sock, r->channel->source);
+}
+
+void proxy_close(LIST *inputs, INPUT **input) {
+	proxy_log(*input, "Stop");
+	// If there are no clients left, no "Timeout" messages will be logged
+	list_del_entry(inputs, *input);
+	input_free(input);
+}

data.h

@@ -0,0 +1,230 @@
+#ifndef DATA_H
+#define DATA_H
+
+/* How much to wait for connection to be established with channel source (miliseconds) */
+#define PROXY_CONNECT_TIMEOUT 1000
+
+/* Seconds to sleep between retries (miliseconds) */
+#define PROXY_RETRY_TIMEOUT 1000
+
+/* 7 * 188 */
+#define FRAME_PACKET_SIZE 1316
+
+#include "libfuncs/libfuncs.h"
+
+#include "libtsfuncs/tsdata.h"
+
+#include "pidref.h"
+
+typedef enum { udp_sock, tcp_sock } channel_source;
+
+typedef struct {
+	channel_source sproto;
+	char *proto;
+	char *host;
+	char *path;
+	unsigned int port;
+} CHANSRC;
+
+#define MAX_CHANNEL_SOURCES 8
+
+typedef struct {
+	uint16_t	event_id;
+	time_t		start;
+	int			duration;
+	char *		event;
+	char *		short_desc;
+	char *		long_desc;
+} EPG_ENTRY;
+
+typedef struct {
+	/* Config */
+	int			base_pid;
+	int			service_id;
+	int			pmt_pid;
+	int			radio;
+	char *		id;
+	char *		name;
+	/* Sources */
+	char *		source; /* Full source url */
+	char *		sources[MAX_CHANNEL_SOURCES];
+	uint8_t		num_src;
+	uint8_t		curr_src;
+	int			worktime_start;
+	int			worktime_end;
+
+	/* EPG */
+	uint8_t			epg_version:5;
+
+	EPG_ENTRY *		epg_now;
+	EPG_ENTRY *		epg_next;
+
+	struct ts_eit *	eit_now;
+	struct ts_eit *	eit_next;
+} CHANNEL;
+
+typedef struct {
+	uint64_t pcr;
+	uint64_t last_pcr;
+	int bytes;
+	int ts_packets_per_output_bitrate;
+} PCR;
+
+typedef struct {
+	PIDREF *pidref;			/* Rewritten pids list */
+
+	uint16_t nit_pid;		/* Pid of the NIT, default 0x10 */
+	uint16_t pmt_pid;		/* Pid of the original PMT, used to replace PMT */
+	uint16_t pcr_pid;		/* PCR pid */
+
+	struct ts_pat *pat;		/* The PAT */
+	struct ts_pmt *pmt;		/* The PMT */
+
+	uint64_t input_pcr;		// Latest PCR entered into input buffer
+
+	uint8_t pid_pat_cont:4;
+	uint8_t pid_pmt_cont:4;
+	struct ts_pat *pat_rewritten;	/* The rewritten PAT */
+	struct ts_pmt *pmt_rewritten;	/* The rewritten PMT */
+
+	struct ts_pat *last_pat;		/* The last incoming PAT */
+	struct ts_pmt *last_pmt;		/* The last incoming PMT */
+} INPUT_STREAM;
+
+typedef struct {
+	char  *name;
+	CHANNEL *channel;
+	int sock;				/* Server socket */
+	struct sockaddr_in src_sockname;
+	int reconnect:1,		/* Set to 1 to force proxy reconnect */
+	    connected:1,		/* It's set to 1 when proxy is connected and serving clients */
+	    insert_eit:1,		/* When set to 1 input adds EIT table into stream (if there is info) */
+	    working:1,			/* Set to 1 if the input is in worktime */
+	    dienow:1,			/* Stop serving clients and exit now */
+	    freechannel:1;		/* Free channel data on object free (this is used in chanconf) */
+	int cookie;				/* Used in chanconf to determine if the restreamer is alrady checked */
+	int ifd;
+
+	pthread_t thread;
+
+	uint16_t output_pcr_pid;
+	uint64_t output_last_pcr;			// The PCR before latest outputed
+	uint64_t output_pcr;				// Latest outputed PCR
+	int output_pcr_packets_needed;		// Based on selected output rate how much packets should be between output_pcr and output_last_pcr
+	int outputed_packets;				// How much packets have been sent. This is reset on every PCR and incremented on every sent packet (every input and output padding)
+
+	int disabled;			/* Input is disabled, no data is fed to output buffers */
+	int input_ready;		/* Set to 1 from INPUT thread when input is ready to be mixed in output */
+
+	CBUF *buf;				// Input buffer */
+
+	INPUT_STREAM stream;
+} INPUT;
+
+typedef enum {
+	obuf_empty    = 0,		// Buffer is empty and can be used by mix thread
+	obuf_filling  = 1,		// Buffer is being filled by mix thread
+	obuf_full     = 2,		// Buffer is filled and can be used by write thread
+	obuf_emptying = 3,		// Buffer is being emptyed by write thread
+} OBUF_STATUS;
+
+typedef struct {
+	uint8_t *	buf;
+	int			size;		// Output buffer size (must be size % 1316 == 0)
+	int			written;
+	OBUF_STATUS	status;
+} OBUF;
+
+typedef struct {
+	struct in_addr out_host;
+	int out_port;
+	int out_sock;			/* The udp socket */
+	int ofd;
+	int dienow;				/* Instruct output to die */
+
+	pthread_t psi_thread;
+	pthread_t mix_thread;
+	pthread_t write_thread;
+
+	CBUF *psibuf;			// Input buffer */
+
+	unsigned int obuf_ms;	// How much miliseconds of data output buffer holds
+	OBUF obuf[2];			// Output buffers
+	double output_bitrate;	// Output bitrate (bps)
+
+	uint64_t traffic;
+
+	uint64_t traffic_period;
+	uint64_t padding_period;
+
+	uint8_t pid_pat_cont:4;
+	uint8_t pid_nit_cont:4;
+	uint8_t pid_sdt_cont:4;
+	uint8_t pid_eit_cont:4;
+	uint8_t pid_tdt_cont:4;
+
+	struct ts_pat *pat;
+	struct timeval pat_ts;
+
+	struct ts_sdt *sdt;
+	struct timeval sdt_ts;
+
+	struct ts_nit *nit;
+	struct timeval nit_ts;
+
+	struct ts_tdt *tdt;
+	struct timeval tdt_ts;
+
+	struct ts_tdt *tot;
+	struct timeval tot_ts;
+
+	struct timeval eit_ts;
+
+	uint64_t last_org_pcr[8193];	// Last PCR value indexed by PID x
+	uint64_t last_pcr[8193];		// Last PCR value indexed by PID x
+	uint64_t last_traffic[8193];	// Last traffic when PCR with PID x was seen
+} OUTPUT;
+
+typedef struct {
+	char		*freq;
+	char		*modulation;
+	char		*symbol_rate;
+	uint16_t	ts_id;
+	uint32_t	_freq;
+	uint8_t		_modulation;
+	uint32_t	_symbol_rate;
+} NIT;
+
+EPG_ENTRY *	epg_new			(time_t start, int duration, char *encoding, char *event, char *short_desc, char *long_desc);
+void		epg_free		(EPG_ENTRY **e);
+int			epg_changed		(EPG_ENTRY *a, EPG_ENTRY *b);
+
+CHANNEL *	channel_new		(int service_id, int is_radio, char *id, char *name, char *source);
+void		channel_free	(CHANNEL **c);
+void		channel_free_epg(CHANNEL *c);
+
+channel_source get_sproto(char *url);
+CHANSRC *	chansrc_init	(char *url);
+void		chansrc_free	(CHANSRC **url);
+void		chansrc_add		(CHANNEL *c, char *src);
+void		chansrc_next	(CHANNEL *c);
+void		chansrc_set		(CHANNEL *c, uint8_t src_id);
+
+INPUT *		input_new		(const char *name, CHANNEL *channel);
+void		input_free		(INPUT **input);
+
+void		input_stream_reset	(INPUT *input);
+
+OUTPUT *	output_new			();
+void		output_free			(OUTPUT **output);
+void		output_open_file	(OUTPUT *o);
+void		output_buffer_alloc	(OUTPUT *o, double output_bitrate);
+void		obuf_reset			(OBUF *ob);
+
+NIT *		nit_new			(uint16_t ts_id, char *freq, char *modulation, char *symbol_rate);
+void		nit_free		(NIT **nit);
+
+void		proxy_log		(INPUT *r, char *msg);
+void		proxy_close		(LIST *inputs, INPUT **input);
+
+#endif

inidict.c

@@ -0,0 +1,428 @@
+/*
+Copyright (c) 2000-2007 by Nicolas Devillard.
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+/*-------------------------------------------------------------------------*/
+/**
+   @file	dictionary.c
+   @author	N. Devillard
+   @date	Sep 2007
+   @version	Revision: 1.27
+   @brief	Implements a dictionary for string variables.
+
+   This module implements a simple dictionary object, i.e. a list
+   of string/string associations. This object is useful to store e.g.
+   informations retrieved from a configuration file (ini files).
+*/
+/*--------------------------------------------------------------------------*/
+
+/*
+	Id: inidict.c,v 1.2 2010/04/26 09:35:52 gf Exp
+	Revision: 1.2
+*/
+/*---------------------------------------------------------------------------
+   								Includes
+ ---------------------------------------------------------------------------*/
+#include "inidict.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/** Maximum value size for integers and doubles. */
+#define MAXVALSZ	1024
+
+/** Minimal allocated number of entries in a dictionary */
+#define DICTMINSZ	128
+
+/** Invalid key token */
+#define DICT_INVALID_KEY    ((char*)-1)
+
+/*---------------------------------------------------------------------------
+  							Private functions
+ ---------------------------------------------------------------------------*/
+
+/* Doubles the allocated size associated to a pointer */
+/* 'size' is the current allocated size. */
+static void * mem_double(void * ptr, int size)
+{
+    void * newptr ;
+ 
+    newptr = calloc(2*size, 1);
+    if (newptr==NULL) {
+        return NULL ;
+    }
+    memcpy(newptr, ptr, size);
+    free(ptr);
+    return newptr ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Duplicate a string
+  @param    s String to duplicate
+  @return   Pointer to a newly allocated string, to be freed with free()
+
+  This is a replacement for strdup(). This implementation is provided
+  for systems that do not have it.
+ */
+/*--------------------------------------------------------------------------*/
+static char * xstrdup(char * s)
+{
+    char * t ;
+    if (!s)
+        return NULL ;
+    t = malloc(strlen(s)+1) ;
+    if (t) {
+        strcpy(t,s);
+    }
+    return t ;
+}
+
+/*---------------------------------------------------------------------------
+  							Function codes
+ ---------------------------------------------------------------------------*/
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Compute the hash key for a string.
+  @param	key		Character string to use for key.
+  @return	1 unsigned int on at least 32 bits.
+
+  This hash function has been taken from an Article in Dr Dobbs Journal.
+  This is normally a collision-free function, distributing keys evenly.
+  The key is stored anyway in the struct so that collision can be avoided
+  by comparing the key itself in last resort.
+ */
+/*--------------------------------------------------------------------------*/
+unsigned dictionary_hash(char * key)
+{
+	int			len ;
+	unsigned	hash ;
+	int			i ;
+
+	len = strlen(key);
+	for (hash=0, i=0 ; i<len ; i++) {
+		hash += (unsigned)key[i] ;
+		hash += (hash<<10);
+		hash ^= (hash>>6) ;
+	}
+	hash += (hash <<3);
+	hash ^= (hash >>11);
+	hash += (hash <<15);
+	return hash ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Create a new dictionary object.
+  @param	size	Optional initial size of the dictionary.
+  @return	1 newly allocated dictionary objet.
+
+  This function allocates a new dictionary object of given size and returns
+  it. If you do not know in advance (roughly) the number of entries in the
+  dictionary, give size=0.
+ */
+/*--------------------------------------------------------------------------*/
+dictionary * dictionary_new(int size)
+{
+	dictionary	*	d ;
+
+	/* If no size was specified, allocate space for DICTMINSZ */
+	if (size<DICTMINSZ) size=DICTMINSZ ;
+
+	if (!(d = (dictionary *)calloc(1, sizeof(dictionary)))) {
+		return NULL;
+	}
+	d->size = size ;
+	d->val  = (char **)calloc(size, sizeof(char*));
+	d->key  = (char **)calloc(size, sizeof(char*));
+	d->hash = (unsigned int *)calloc(size, sizeof(unsigned));
+	return d ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Delete a dictionary object
+  @param	d	dictionary object to deallocate.
+  @return	void
+
+  Deallocate a dictionary object and all memory associated to it.
+ */
+/*--------------------------------------------------------------------------*/
+void dictionary_del(dictionary * d)
+{
+	int		i ;
+
+	if (d==NULL) return ;
+	for (i=0 ; i<d->size ; i++) {
+		if (d->key[i]!=NULL)
+			free(d->key[i]);
+		if (d->val[i]!=NULL)
+			free(d->val[i]);
+	}
+	free(d->val);
+	free(d->key);
+	free(d->hash);
+	free(d);
+	return ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Get a value from a dictionary.
+  @param	d		dictionary object to search.
+  @param	key		Key to look for in the dictionary.
+  @param    def     Default value to return if key not found.
+  @return	1 pointer to internally allocated character string.
+
+  This function locates a key in a dictionary and returns a pointer to its
+  value, or the passed 'def' pointer if no such key can be found in
+  dictionary. The returned character pointer points to data internal to the
+  dictionary object, you should not try to free it or modify it.
+ */
+/*--------------------------------------------------------------------------*/
+char * dictionary_get(dictionary * d, char * key, char * def)
+{
+	unsigned	hash ;
+	int			i ;
+
+	hash = dictionary_hash(key);
+	for (i=0 ; i<d->size ; i++) {
+        if (d->key[i]==NULL)
+            continue ;
+        /* Compare hash */
+		if (hash==d->hash[i]) {
+            /* Compare string, to avoid hash collisions */
+            if (!strcmp(key, d->key[i])) {
+				return d->val[i] ;
+			}
+		}
+	}
+	return def ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Set a value in a dictionary.
+  @param    d       dictionary object to modify.
+  @param    key     Key to modify or add.
+  @param    val     Value to add.
+  @return   int     0 if Ok, anything else otherwise
+
+  If the given key is found in the dictionary, the associated value is
+  replaced by the provided one. If the key cannot be found in the
+  dictionary, it is added to it.
+
+  It is Ok to provide a NULL value for val, but NULL values for the dictionary
+  or the key are considered as errors: the function will return immediately
+  in such a case.
+
+  Notice that if you dictionary_set a variable to NULL, a call to
+  dictionary_get will return a NULL value: the variable will be found, and
+  its value (NULL) is returned. In other words, setting the variable
+  content to NULL is equivalent to deleting the variable from the
+  dictionary. It is not possible (in this implementation) to have a key in
+  the dictionary without value.
+
+  This function returns non-zero in case of failure.
+ */
+/*--------------------------------------------------------------------------*/
+int dictionary_set(dictionary * d, char * key, char * val)
+{
+	int			i ;
+	unsigned	hash ;
+
+	if (d==NULL || key==NULL) return -1 ;
+	
+	/* Compute hash for this key */
+	hash = dictionary_hash(key) ;
+	/* Find if value is already in dictionary */
+	if (d->n>0) {
+		for (i=0 ; i<d->size ; i++) {
+            if (d->key[i]==NULL)
+                continue ;
+			if (hash==d->hash[i]) { /* Same hash value */
+				if (!strcmp(key, d->key[i])) {	 /* Same key */
+					/* Found a value: modify and return */
+					if (d->val[i]!=NULL)
+						free(d->val[i]);
+                    d->val[i] = val ? xstrdup(val) : NULL ;
+                    /* Value has been modified: return */
+					return 0 ;
+				}
+			}
+		}
+	}
+	/* Add a new value */
+	/* See if dictionary needs to grow */
+	if (d->n==d->size) {
+
+		/* Reached maximum size: reallocate dictionary */
+		d->val  = (char **)mem_double(d->val,  d->size * sizeof(char*)) ;
+		d->key  = (char **)mem_double(d->key,  d->size * sizeof(char*)) ;
+		d->hash = (unsigned int *)mem_double(d->hash, d->size * sizeof(unsigned)) ;
+        if ((d->val==NULL) || (d->key==NULL) || (d->hash==NULL)) {
+            /* Cannot grow dictionary */
+            return -1 ;
+        }
+		/* Double size */
+		d->size *= 2 ;
+	}
+
+    /* Insert key in the first empty slot */
+    for (i=0 ; i<d->size ; i++) {
+        if (d->key[i]==NULL) {
+            /* Add key here */
+            break ;
+        }
+    }
+	/* Copy key */
+	d->key[i]  = xstrdup(key);
+    d->val[i]  = val ? xstrdup(val) : NULL ;
+	d->hash[i] = hash;
+	d->n ++ ;
+	return 0 ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Delete a key in a dictionary
+  @param	d		dictionary object to modify.
+  @param	key		Key to remove.
+  @return   void
+
+  This function deletes a key in a dictionary. Nothing is done if the
+  key cannot be found.
+ */
+/*--------------------------------------------------------------------------*/
+void dictionary_unset(dictionary * d, char * key)
+{
+	unsigned	hash ;
+	int			i ;
+
+	if (key == NULL) {
+		return;
+	}
+
+	hash = dictionary_hash(key);
+	for (i=0 ; i<d->size ; i++) {
+        if (d->key[i]==NULL)
+            continue ;
+        /* Compare hash */
+		if (hash==d->hash[i]) {
+            /* Compare string, to avoid hash collisions */
+            if (!strcmp(key, d->key[i])) {
+                /* Found key */
+                break ;
+			}
+		}
+	}
+    if (i>=d->size)
+        /* Key not found */
+        return ;
+
+    free(d->key[i]);
+    d->key[i] = NULL ;
+    if (d->val[i]!=NULL) {
+        free(d->val[i]);
+        d->val[i] = NULL ;
+    }
+    d->hash[i] = 0 ;
+    d->n -- ;
+    return ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Dump a dictionary to an opened file pointer.
+  @param	d	Dictionary to dump
+  @param	f	Opened file pointer.
+  @return	void
+
+  Dumps a dictionary onto an opened file pointer. Key pairs are printed out
+  as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
+  output file pointers.
+ */
+/*--------------------------------------------------------------------------*/
+void dictionary_dump(dictionary * d, FILE * out)
+{
+	int		i ;
+
+	if (d==NULL || out==NULL) return ;
+	if (d->n<1) {
+		fprintf(out, "empty dictionary\n");
+		return ;
+	}
+	for (i=0 ; i<d->size ; i++) {
+        if (d->key[i]) {
+            fprintf(out, "%20s\t[%s]\n",
+                    d->key[i],
+                    d->val[i] ? d->val[i] : "UNDEF");
+        }
+	}
+	return ;
+}
+
+
+/* Test code */
+#ifdef TESTDIC
+#define NVALS 20000
+int main(int argc, char *argv[])
+{
+	dictionary	*	d ;
+	char	*	val ;
+	int			i ;
+	char		cval[90] ;
+
+	/* Allocate dictionary */
+	printf("allocating...\n");
+	d = dictionary_new(0);
+	
+	/* Set values in dictionary */
+	printf("setting %d values...\n", NVALS);
+	for (i=0 ; i<NVALS ; i++) {
+		sprintf(cval, "%04d", i);
+		dictionary_set(d, cval, "salut");
+	}
+	printf("getting %d values...\n", NVALS);
+	for (i=0 ; i<NVALS ; i++) {
+		sprintf(cval, "%04d", i);
+		val = dictionary_get(d, cval, DICT_INVALID_KEY);
+		if (val==DICT_INVALID_KEY) {
+			printf("cannot get value for key [%s]\n", cval);
+		}
+	}
+    printf("unsetting %d values...\n", NVALS);
+	for (i=0 ; i<NVALS ; i++) {
+		sprintf(cval, "%04d", i);
+		dictionary_unset(d, cval);
+	}
+    if (d->n != 0) {
+        printf("error deleting values\n");
+    }
+	printf("deallocating...\n");
+	dictionary_del(d);
+	return 0 ;
+}
+#endif
+/* vim: set ts=4 et sw=4 tw=75 */

inidict.h

@@ -0,0 +1,174 @@
+
+/*-------------------------------------------------------------------------*/
+/**
+   @file    dictionary.h
+   @author  N. Devillard
+   @date    Sep 2007
+   @version Revision: 1.12
+   @brief   Implements a dictionary for string variables.
+
+   This module implements a simple dictionary object, i.e. a list
+   of string/string associations. This object is useful to store e.g.
+   informations retrieved from a configuration file (ini files).
+*/
+/*--------------------------------------------------------------------------*/
+
+/*
+	Id: dictionary.h,v 1.12 2007-11-23 21:37:00 ndevilla Exp
+	Author: ndevilla
+	Date: 2007-11-23 21:37:00
+	Revision: 1.12
+*/
+
+#ifndef _DICTIONARY_H_
+#define _DICTIONARY_H_
+
+/*---------------------------------------------------------------------------
+   								Includes
+ ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*---------------------------------------------------------------------------
+   								New types
+ ---------------------------------------------------------------------------*/
+
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Dictionary object
+
+  This object contains a list of string/string associations. Each
+  association is identified by a unique string key. Looking up values
+  in the dictionary is speeded up by the use of a (hopefully collision-free)
+  hash function.
+ */
+/*-------------------------------------------------------------------------*/
+typedef struct _dictionary_ {
+	int				n ;		/** Number of entries in dictionary */
+	int				size ;	/** Storage size */
+	char 		**	val ;	/** List of string values */
+	char 		**  key ;	/** List of string keys */
+	unsigned	 *	hash ;	/** List of hash values for keys */
+} dictionary ;
+
+
+/*---------------------------------------------------------------------------
+  							Function prototypes
+ ---------------------------------------------------------------------------*/
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Compute the hash key for a string.
+  @param    key     Character string to use for key.
+  @return   1 unsigned int on at least 32 bits.
+
+  This hash function has been taken from an Article in Dr Dobbs Journal.
+  This is normally a collision-free function, distributing keys evenly.
+  The key is stored anyway in the struct so that collision can be avoided
+  by comparing the key itself in last resort.
+ */
+/*--------------------------------------------------------------------------*/
+unsigned dictionary_hash(char * key);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Create a new dictionary object.
+  @param    size    Optional initial size of the dictionary.
+  @return   1 newly allocated dictionary objet.
+
+  This function allocates a new dictionary object of given size and returns
+  it. If you do not know in advance (roughly) the number of entries in the
+  dictionary, give size=0.
+ */
+/*--------------------------------------------------------------------------*/
+dictionary * dictionary_new(int size);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Delete a dictionary object
+  @param    d   dictionary object to deallocate.
+  @return   void
+
+  Deallocate a dictionary object and all memory associated to it.
+ */
+/*--------------------------------------------------------------------------*/
+void dictionary_del(dictionary * vd);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get a value from a dictionary.
+  @param    d       dictionary object to search.
+  @param    key     Key to look for in the dictionary.
+  @param    def     Default value to return if key not found.
+  @return   1 pointer to internally allocated character string.
+
+  This function locates a key in a dictionary and returns a pointer to its
+  value, or the passed 'def' pointer if no such key can be found in
+  dictionary. The returned character pointer points to data internal to the
+  dictionary object, you should not try to free it or modify it.
+ */
+/*--------------------------------------------------------------------------*/
+char * dictionary_get(dictionary * d, char * key, char * def);
+
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Set a value in a dictionary.
+  @param    d       dictionary object to modify.
+  @param    key     Key to modify or add.
+  @param    val     Value to add.
+  @return   int     0 if Ok, anything else otherwise
+
+  If the given key is found in the dictionary, the associated value is
+  replaced by the provided one. If the key cannot be found in the
+  dictionary, it is added to it.
+
+  It is Ok to provide a NULL value for val, but NULL values for the dictionary
+  or the key are considered as errors: the function will return immediately
+  in such a case.
+
+  Notice that if you dictionary_set a variable to NULL, a call to
+  dictionary_get will return a NULL value: the variable will be found, and
+  its value (NULL) is returned. In other words, setting the variable
+  content to NULL is equivalent to deleting the variable from the
+  dictionary. It is not possible (in this implementation) to have a key in
+  the dictionary without value.
+
+  This function returns non-zero in case of failure.
+ */
+/*--------------------------------------------------------------------------*/
+int dictionary_set(dictionary * vd, char * key, char * val);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Delete a key in a dictionary
+  @param    d       dictionary object to modify.
+  @param    key     Key to remove.
+  @return   void
+
+  This function deletes a key in a dictionary. Nothing is done if the
+  key cannot be found.
+ */
+/*--------------------------------------------------------------------------*/
+void dictionary_unset(dictionary * d, char * key);
+
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Dump a dictionary to an opened file pointer.
+  @param    d   Dictionary to dump
+  @param    f   Opened file pointer.
+  @return   void
+
+  Dumps a dictionary onto an opened file pointer. Key pairs are printed out
+  as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as
+  output file pointers.
+ */
+/*--------------------------------------------------------------------------*/
+void dictionary_dump(dictionary * d, FILE * out);
+
+#endif

iniparser.c

@@ -0,0 +1,712 @@
+/*
+Copyright (c) 2000-2007 by Nicolas Devillard.
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+/*-------------------------------------------------------------------------*/
+/**
+   @file    iniparser.c
+   @author  N. Devillard
+   @date    Sep 2007
+   @version 3.0
+   @brief   Parser for ini files.
+*/
+/*--------------------------------------------------------------------------*/
+/*
+    Id: iniparser.c,v 2.18 2008-01-03 18:35:39 ndevilla Exp
+    Revision: 2.18
+    Date: 2008-01-03 18:35:39
+*/
+/*---------------------------- Includes ------------------------------------*/
+#include <ctype.h>
+#include "iniparser.h"
+
+/*---------------------------- Defines -------------------------------------*/
+#define ASCIILINESZ         (1024)
+#define INI_INVALID_KEY     ((char*)-1)
+#define MSG_PREFIX          "confparser: "
+
+/*---------------------------------------------------------------------------
+                        Private to this module
+ ---------------------------------------------------------------------------*/
+/**
+ * This enum stores the status for each parsed line (internal use only).
+ */
+typedef enum _line_status_ {
+    LINE_UNPROCESSED,
+    LINE_ERROR,
+    LINE_EMPTY,
+    LINE_COMMENT,
+    LINE_SECTION,
+    LINE_VALUE
+} line_status ;
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Convert a string to lowercase.
+  @param	s	String to convert.
+  @return	ptr to statically allocated string.
+
+  This function returns a pointer to a statically allocated string
+  containing a lowercased version of the input string. Do not free
+  or modify the returned string! Since the returned string is statically
+  allocated, it will be modified at each function call (not re-entrant).
+ */
+/*--------------------------------------------------------------------------*/
+static char * strlwc(const char * s)
+{
+    static char l[ASCIILINESZ+1];
+    int i ;
+
+    if (s==NULL) return NULL ;
+    memset(l, 0, ASCIILINESZ+1);
+    i=0 ;
+    while (s[i] && i<ASCIILINESZ) {
+        l[i] = (char)tolower((int)s[i]);
+        i++ ;
+    }
+    l[ASCIILINESZ]=(char)0;
+    return l ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Remove blanks at the beginning and the end of a string.
+  @param	s	String to parse.
+  @return	ptr to statically allocated string.
+
+  This function returns a pointer to a statically allocated string,
+  which is identical to the input string, except that all blank
+  characters at the end and the beg. of the string have been removed.
+  Do not free or modify the returned string! Since the returned string
+  is statically allocated, it will be modified at each function call
+  (not re-entrant).
+ */
+/*--------------------------------------------------------------------------*/
+static char * strstrip(char * s)
+{
+    static char l[ASCIILINESZ+1];
+	char * last ;
+	
+    if (s==NULL) return NULL ;
+    
+	while (isspace((int)*s) && *s) s++;
+	memset(l, 0, ASCIILINESZ+1);
+	strcpy(l, s);
+	last = l + strlen(l);
+	while (last > l) {
+		if (!isspace((int)*(last-1)))
+			break ;
+		last -- ;
+	}
+	*last = (char)0;
+	return (char*)l ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get number of sections in a dictionary
+  @param    d   Dictionary to examine
+  @return   int Number of sections found in dictionary
+
+  This function returns the number of sections found in a dictionary.
+  The test to recognize sections is done on the string stored in the
+  dictionary: a section name is given as "section" whereas a key is
+  stored as "section:key", thus the test looks for entries that do not
+  contain a colon.
+
+  This clearly fails in the case a section name contains a colon, but
+  this should simply be avoided.
+
+  This function returns -1 in case of error.
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_getnsec(dictionary * d)
+{
+    int i ;
+    int nsec ;
+
+    if (d==NULL) return -1 ;
+    nsec=0 ;
+    for (i=0 ; i<d->size ; i++) {
+        if (d->key[i]==NULL)
+            continue ;
+        if (strchr(d->key[i], ':')==NULL) {
+            nsec ++ ;
+        }
+    }
+    return nsec ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get name for section n in a dictionary.
+  @param    d   Dictionary to examine
+  @param    n   Section number (from 0 to nsec-1).
+  @return   Pointer to char string
+
+  This function locates the n-th section in a dictionary and returns
+  its name as a pointer to a string statically allocated inside the
+  dictionary. Do not free or modify the returned string!
+
+  This function returns NULL in case of error.
+ */
+/*--------------------------------------------------------------------------*/
+char * iniparser_getsecname(dictionary * d, int n)
+{
+    int i ;
+    int foundsec ;
+
+    if (d==NULL || n<0) return NULL ;
+    foundsec=0 ;
+    for (i=0 ; i<d->size ; i++) {
+        if (d->key[i]==NULL)
+            continue ;
+        if (strchr(d->key[i], ':')==NULL) {
+            foundsec++ ;
+            if (foundsec>n)
+                break ;
+        }
+    }
+    if (foundsec<=n) {
+        return NULL ;
+    }
+    return d->key[i] ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Dump a dictionary to an opened file pointer.
+  @param    d   Dictionary to dump.
+  @param    f   Opened file pointer to dump to.
+  @return   void
+
+  This function prints out the contents of a dictionary, one element by
+  line, onto the provided file pointer. It is OK to specify @c stderr
+  or @c stdout as output files. This function is meant for debugging
+  purposes mostly.
+ */
+/*--------------------------------------------------------------------------*/
+void iniparser_dump(dictionary * d, FILE * f)
+{
+    int     i ;
+
+    if (d==NULL || f==NULL) return ;
+    for (i=0 ; i<d->size ; i++) {
+        if (d->key[i]==NULL)
+            continue ;
+        if (d->val[i]!=NULL) {
+            fprintf(f, "[%s]=[%s]\n", d->key[i], d->val[i]);
+        } else {
+            fprintf(f, "[%s]=UNDEF\n", d->key[i]);
+        }
+    }
+    return ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Save a dictionary to a loadable ini file
+  @param    d   Dictionary to dump
+  @param    f   Opened file pointer to dump to
+  @return   void
+
+  This function dumps a given dictionary into a loadable ini file.
+  It is Ok to specify @c stderr or @c stdout as output files.
+ */
+/*--------------------------------------------------------------------------*/
+void iniparser_dump_ini(dictionary * d, FILE * f)
+{
+    int     i, j ;
+    char    keym[ASCIILINESZ+1];
+    int     nsec ;
+    char *  secname ;
+    int     seclen ;
+
+    if (d==NULL || f==NULL) return ;
+
+    nsec = iniparser_getnsec(d);
+    if (nsec<1) {
+        /* No section in file: dump all keys as they are */
+        for (i=0 ; i<d->size ; i++) {
+            if (d->key[i]==NULL)
+                continue ;
+            fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
+        }
+        return ;
+    }
+    for (i=0 ; i<nsec ; i++) {
+        secname = iniparser_getsecname(d, i) ;
+        seclen  = (int)strlen(secname);
+        fprintf(f, "\n[%s]\n", secname);
+        sprintf(keym, "%s:", secname);
+        for (j=0 ; j<d->size ; j++) {
+            if (d->key[j]==NULL)
+                continue ;
+            if (!strncmp(d->key[j], keym, seclen+1)) {
+                fprintf(f,
+                        "%-30s = %s\n",
+                        d->key[j]+seclen+1,
+                        d->val[j] ? d->val[j] : "");
+            }
+        }
+    }
+    fprintf(f, "\n");
+    return ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key
+  @param    d       Dictionary to search
+  @param    key     Key string to look for
+  @param    def     Default value to return if key not found.
+  @return   pointer to statically allocated character string
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the pointer passed as 'def' is returned.
+  The returned char pointer is pointing to a string allocated in
+  the dictionary, do not free or modify it.
+ */
+/*--------------------------------------------------------------------------*/
+char * iniparser_getstring(dictionary * d, const char * key, char * def)
+{
+    char * lc_key ;
+    char * sval ;
+
+    if (d==NULL || key==NULL)
+        return def ;
+
+    lc_key = strlwc(key);
+    sval = dictionary_get(d, lc_key, def);
+    return sval ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key, convert to an int
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  Supported values for integers include the usual C notation
+  so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
+  are supported. Examples:
+
+  "42"      ->  42
+  "042"     ->  34 (octal -> decimal)
+  "0x42"    ->  66 (hexa  -> decimal)
+
+  Warning: the conversion may overflow in various ways. Conversion is
+  totally outsourced to strtol(), see the associated man page for overflow
+  handling.
+
+  Credits: Thanks to A. Becker for suggesting strtol()
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_getint(dictionary * d, const char * key, int notfound)
+{
+    char    *   str ;
+
+    str = iniparser_getstring(d, key, INI_INVALID_KEY);
+    if (str==INI_INVALID_KEY) return notfound ;
+    return (int)strtol(str, NULL, 0);
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key, convert to a double
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   double
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+ */
+/*--------------------------------------------------------------------------*/
+double iniparser_getdouble(dictionary * d, char * key, double notfound)
+{
+    char    *   str ;
+
+    str = iniparser_getstring(d, key, INI_INVALID_KEY);
+    if (str==INI_INVALID_KEY) return notfound ;
+    return atof(str);
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key, convert to a boolean
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  A true boolean is found if one of the following is matched:
+
+  - A string starting with 'y'
+  - A string starting with 'Y'
+  - A string starting with 't'
+  - A string starting with 'T'
+  - A string starting with '1'
+
+  A false boolean is found if one of the following is matched:
+
+  - A string starting with 'n'
+  - A string starting with 'N'
+  - A string starting with 'f'
+  - A string starting with 'F'
+  - A string starting with '0'
+
+  The notfound value returned if no boolean is identified, does not
+  necessarily have to be 0 or 1.
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_getboolean(dictionary * d, const char * key, int notfound)
+{
+    char    *   c ;
+    int         ret ;
+
+    c = iniparser_getstring(d, key, INI_INVALID_KEY);
+    if (c==INI_INVALID_KEY) return notfound ;
+    if (c[0]=='y' || c[0]=='Y' || c[0]=='1' || c[0]=='t' || c[0]=='T') {
+        ret = 1 ;
+    } else if (c[0]=='n' || c[0]=='N' || c[0]=='0' || c[0]=='f' || c[0]=='F') {
+        ret = 0 ;
+    } else {
+        ret = notfound ;
+    }
+    return ret;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Finds out if a given entry exists in a dictionary
+  @param    ini     Dictionary to search
+  @param    entry   Name of the entry to look for
+  @return   integer 1 if entry exists, 0 otherwise
+
+  Finds out if a given entry exists in the dictionary. Since sections
+  are stored as keys with NULL associated values, this is the only way
+  of querying for the presence of sections in a dictionary.
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_find_entry(
+    dictionary  *   ini,
+    char        *   entry
+)
+{
+    int found=0 ;
+    if (iniparser_getstring(ini, entry, INI_INVALID_KEY)!=INI_INVALID_KEY) {
+        found = 1 ;
+    }
+    return found ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Set an entry in a dictionary.
+  @param    ini     Dictionary to modify.
+  @param    entry   Entry to modify (entry name)
+  @param    val     New value to associate to the entry.
+  @return   int 0 if Ok, -1 otherwise.
+
+  If the given entry can be found in the dictionary, it is modified to
+  contain the provided value. If it cannot be found, -1 is returned.
+  It is Ok to set val to NULL.
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_set(dictionary * ini, char * entry, char * val)
+{
+    return dictionary_set(ini, strlwc(entry), val) ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Delete an entry in a dictionary
+  @param    ini     Dictionary to modify
+  @param    entry   Entry to delete (entry name)
+  @return   void
+
+  If the given entry can be found, it is deleted from the dictionary.
+ */
+/*--------------------------------------------------------------------------*/
+void iniparser_unset(dictionary * ini, char * entry)
+{
+    dictionary_unset(ini, strlwc(entry));
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief	Load a single line from an INI file
+  @param    input_line  Input line, may be concatenated multi-line input
+  @param    section     Output space to store section
+  @param    key         Output space to store key
+  @param    value       Output space to store value
+  @return   line_status value
+ */
+/*--------------------------------------------------------------------------*/
+static line_status iniparser_line(
+    char * input_line,
+    char * section,
+    char * key,
+    char * value)
+{   
+    line_status sta ;
+    char        line[ASCIILINESZ+1];
+    int         len ;
+
+    strcpy(line, strstrip(input_line));
+    len = (int)strlen(line);
+
+    sta = LINE_UNPROCESSED ;
+    if (len<1) {
+        /* Empty line */
+        sta = LINE_EMPTY ;
+    } else if (line[0]=='#') {
+        /* Comment line */
+        sta = LINE_COMMENT ; 
+    } else if (line[0]=='[' && line[len-1]==']') {
+        /* Section name */
+        sscanf(line, "[%[^]]", section);
+        strcpy(section, strstrip(section));
+        strcpy(section, strlwc(section));
+        sta = LINE_SECTION ;
+    } else if (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2
+           ||  sscanf (line, "%[^=] = '%[^\']'",   key, value) == 2
+           ||  sscanf (line, "%[^=] = %[^;#]",     key, value) == 2) {
+        /* Usual key=value, with or without comments */
+        strcpy(key, strstrip(key));
+        strcpy(key, strlwc(key));
+        strcpy(value, strstrip(value));
+        /*
+         * sscanf cannot handle '' or "" as empty values
+         * this is done here
+         */
+        if (!strcmp(value, "\"\"") || (!strcmp(value, "''"))) {
+            value[0]=0 ;
+        }
+        sta = LINE_VALUE ;
+    } else if (sscanf(line, "%[^=] = %[;#]", key, value)==2
+           ||  sscanf(line, "%[^=] %[=]", key, value) == 2) {
+        /*
+         * Special cases:
+         * key=
+         * key=;
+         * key=#
+         */
+        strcpy(key, strstrip(key));
+        strcpy(key, strlwc(key));
+        value[0]=0 ;
+        sta = LINE_VALUE ;
+    } else {
+        /* Generate syntax error */
+        sta = LINE_ERROR ;
+    }
+    return sta ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Parse an ini file and return an allocated dictionary object
+  @param    ininame Name of the ini file to read.
+  @return   Pointer to newly allocated dictionary
+
+  This is the parser for ini files. This function is called, providing
+  the name of the file to be read. It returns a dictionary object that
+  should not be accessed directly, but through accessor functions
+  instead.
+
+  The returned dictionary must be freed using iniparser_freedict().
+ */
+/*--------------------------------------------------------------------------*/
+dictionary * iniparser_load(const char * ininame)
+{
+    FILE * in ;
+
+    char line    [ASCIILINESZ+1] ;
+    char section [ASCIILINESZ+1] ;
+    char key     [ASCIILINESZ+1] ;
+    char tmp     [ASCIILINESZ+1] ;
+    char val     [ASCIILINESZ+1] ;
+
+    int  last=0 ;
+    int  len ;
+    int  lineno=0 ;
+    int  errs=0;
+
+    dictionary * dict ;
+
+    if ((in=fopen(ininame, "r"))==NULL) {
+        fprintf(stderr, MSG_PREFIX "cannot open %s\n", ininame);
+        return NULL ;
+    }
+
+    dict = dictionary_new(0) ;
+    if (!dict) {
+        fclose(in);
+        return NULL ;
+    }
+
+    memset(line,    0, ASCIILINESZ);
+    memset(section, 0, ASCIILINESZ);
+    memset(key,     0, ASCIILINESZ);
+    memset(val,     0, ASCIILINESZ);
+    last=0 ;
+
+    while (fgets(line+last, ASCIILINESZ-last, in)!=NULL) {
+        lineno++ ;
+        len = (int)strlen(line)-1;
+        /* Safety check against buffer overflows */
+        if (line[len]!='\n') {
+            fprintf(stderr,
+                    MSG_PREFIX "input line too long in %s (%d)\n",
+                    ininame,
+                    lineno);
+            dictionary_del(dict);
+            fclose(in);
+            return NULL ;
+        }
+        /* Get rid of \n and spaces at end of line */
+        while ((len>=0) &&
+                ((line[len]=='\n') || (isspace(line[len])))) {
+            line[len]=0 ;
+            len-- ;
+        }
+        /* Detect multi-line */
+        if (line[len]=='\\') {
+            /* Multi-line value */
+            last=len ;
+            continue ;
+        } else {
+            last=0 ;
+        }
+        switch (iniparser_line(line, section, key, val)) {
+            case LINE_EMPTY:
+            case LINE_COMMENT:
+            break ;
+
+            case LINE_SECTION:
+            errs = dictionary_set(dict, section, NULL);
+            break ;
+
+            case LINE_VALUE:
+            sprintf(tmp, "%s:%s", section, key);
+            errs = dictionary_set(dict, tmp, val) ;
+            break ;
+
+            case LINE_ERROR:
+            fprintf(stderr, MSG_PREFIX "syntax error in %s (%d):\n",
+                    ininame,
+                    lineno);
+            fprintf(stderr, "-> %s\n", line);
+            errs++ ;
+            break;
+
+            default:
+            break ;
+        }
+        memset(line, 0, ASCIILINESZ);
+        last=0;
+        if (errs<0) {
+            fprintf(stderr, MSG_PREFIX "memory allocation failure\n");
+            break ;
+        }
+    }
+    if (errs) {
+        dictionary_del(dict);
+        dict = NULL ;
+    }
+    fclose(in);
+    return dict ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Free all memory associated to an ini dictionary
+  @param    d Dictionary to free
+  @return   void
+
+  Free all memory associated to an ini dictionary.
+  It is mandatory to call this function before the dictionary object
+  gets out of the current context.
+ */
+/*--------------------------------------------------------------------------*/
+void iniparser_freedict(dictionary **d)
+{
+	if (*d) {
+		dictionary_del(*d);
+		*d = NULL;
+	}
+}
+
+/* vim: set ts=4 et sw=4 tw=75 */
+#include <stdarg.h>
+
+#define __handle_format \
+	char key[128]; \
+	{ \
+		va_list args; \
+		va_start(args, keyfmt); \
+		vsnprintf(key, sizeof(key)-1, keyfmt, args); \
+		va_end(args); \
+	}
+
+char *ini_get_string(dictionary *d, char *def, const char *keyfmt, ...) {
+	__handle_format;
+	return iniparser_getstring(d, key, def);
+}
+
+char *ini_get_string_copy(dictionary *d, char *def , const char *keyfmt, ...) {
+	__handle_format;
+	char *ret = iniparser_getstring(d, key, def);
+	if (ret)
+		ret = strdup(ret);
+	return ret;
+}
+
+int ini_get_int(dictionary *d, int def, const char *keyfmt, ...) {
+	__handle_format;
+	return iniparser_getint(d, key, def);
+}
+
+double ini_get_double(dictionary *d, double def, const char *keyfmt, ...) {
+	__handle_format;
+	return iniparser_getdouble(d, key, def);
+}
+
+int ini_get_bool(dictionary *d, int def   , const char *keyfmt, ...) {
+	__handle_format;
+	return iniparser_getboolean(d, key, def);
+}
+
+#undef __handle_format

iniparser.h

@@ -0,0 +1,309 @@
+/*
+Copyright (c) 2000-2007 by Nicolas Devillard.
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+*/
+
+/*-------------------------------------------------------------------------*/
+/**
+   @file    iniparser.h
+   @author  N. Devillard
+   @date    Sep 2007
+   @version 3.0
+   @brief   Parser for ini files.
+*/
+/*--------------------------------------------------------------------------*/
+
+/*
+	Id: iniparser.h,v 1.24 2007-11-23 21:38:19 ndevilla Exp
+	Revision: 1.24
+*/
+
+#ifndef _INIPARSER_H_
+#define _INIPARSER_H_
+
+/*---------------------------------------------------------------------------
+   								Includes
+ ---------------------------------------------------------------------------*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * The following #include is necessary on many Unixes but not Linux.
+ * It is not needed for Windows platforms.
+ * Uncomment it if needed.
+ */
+#include <unistd.h>
+
+#include "inidict.h"
+
+/* Local extras */
+char *	ini_get_string		(dictionary *d, char *def , const char *keyfmt, ...);
+char *	ini_get_string_copy	(dictionary *d, char *def , const char *keyfmt, ...);
+int		ini_get_int			(dictionary *d, int def   , const char *keyfmt, ...);
+double	ini_get_double		(dictionary *d, double def, const char *keyfmt, ...);
+int		ini_get_bool		(dictionary *d, int def   , const char *keyfmt, ...);
+
+/*---------------------------------------------------------------------------
+   								Macros
+ ---------------------------------------------------------------------------*/
+/** For backwards compatibility only */
+#define iniparser_getstr(d, k)  iniparser_getstring(d, k, NULL)
+#define iniparser_setstr        iniparser_setstring
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get number of sections in a dictionary
+  @param    d   Dictionary to examine
+  @return   int Number of sections found in dictionary
+
+  This function returns the number of sections found in a dictionary.
+  The test to recognize sections is done on the string stored in the
+  dictionary: a section name is given as "section" whereas a key is
+  stored as "section:key", thus the test looks for entries that do not
+  contain a colon.
+
+  This clearly fails in the case a section name contains a colon, but
+  this should simply be avoided.
+
+  This function returns -1 in case of error.
+ */
+/*--------------------------------------------------------------------------*/
+
+int iniparser_getnsec(dictionary * d);
+
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get name for section n in a dictionary.
+  @param    d   Dictionary to examine
+  @param    n   Section number (from 0 to nsec-1).
+  @return   Pointer to char string
+
+  This function locates the n-th section in a dictionary and returns
+  its name as a pointer to a string statically allocated inside the
+  dictionary. Do not free or modify the returned string!
+
+  This function returns NULL in case of error.
+ */
+/*--------------------------------------------------------------------------*/
+
+char * iniparser_getsecname(dictionary * d, int n);
+
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Save a dictionary to a loadable ini file
+  @param    d   Dictionary to dump
+  @param    f   Opened file pointer to dump to
+  @return   void
+
+  This function dumps a given dictionary into a loadable ini file.
+  It is Ok to specify @c stderr or @c stdout as output files.
+ */
+/*--------------------------------------------------------------------------*/
+
+void iniparser_dump_ini(dictionary * d, FILE * f);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Dump a dictionary to an opened file pointer.
+  @param    d   Dictionary to dump.
+  @param    f   Opened file pointer to dump to.
+  @return   void
+
+  This function prints out the contents of a dictionary, one element by
+  line, onto the provided file pointer. It is OK to specify @c stderr
+  or @c stdout as output files. This function is meant for debugging
+  purposes mostly.
+ */
+/*--------------------------------------------------------------------------*/
+void iniparser_dump(dictionary * d, FILE * f);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key
+  @param    d       Dictionary to search
+  @param    key     Key string to look for
+  @param    def     Default value to return if key not found.
+  @return   pointer to statically allocated character string
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the pointer passed as 'def' is returned.
+  The returned char pointer is pointing to a string allocated in
+  the dictionary, do not free or modify it.
+ */
+/*--------------------------------------------------------------------------*/
+char * iniparser_getstring(dictionary * d, const char * key, char * def);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key, convert to an int
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  Supported values for integers include the usual C notation
+  so decimal, octal (starting with 0) and hexadecimal (starting with 0x)
+  are supported. Examples:
+
+  - "42"      ->  42
+  - "042"     ->  34 (octal -> decimal)
+  - "0x42"    ->  66 (hexa  -> decimal)
+
+  Warning: the conversion may overflow in various ways. Conversion is
+  totally outsourced to strtol(), see the associated man page for overflow
+  handling.
+
+  Credits: Thanks to A. Becker for suggesting strtol()
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_getint(dictionary * d, const char * key, int notfound);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key, convert to a double
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   double
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+ */
+/*--------------------------------------------------------------------------*/
+double iniparser_getdouble(dictionary * d, char * key, double notfound);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Get the string associated to a key, convert to a boolean
+  @param    d Dictionary to search
+  @param    key Key string to look for
+  @param    notfound Value to return in case of error
+  @return   integer
+
+  This function queries a dictionary for a key. A key as read from an
+  ini file is given as "section:key". If the key cannot be found,
+  the notfound value is returned.
+
+  A true boolean is found if one of the following is matched:
+
+  - A string starting with 'y'
+  - A string starting with 'Y'
+  - A string starting with 't'
+  - A string starting with 'T'
+  - A string starting with '1'
+
+  A false boolean is found if one of the following is matched:
+
+  - A string starting with 'n'
+  - A string starting with 'N'
+  - A string starting with 'f'
+  - A string starting with 'F'
+  - A string starting with '0'
+
+  The notfound value returned if no boolean is identified, does not
+  necessarily have to be 0 or 1.
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_getboolean(dictionary * d, const char * key, int notfound);
+
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Set an entry in a dictionary.
+  @param    ini     Dictionary to modify.
+  @param    entry   Entry to modify (entry name)
+  @param    val     New value to associate to the entry.
+  @return   int 0 if Ok, -1 otherwise.
+
+  If the given entry can be found in the dictionary, it is modified to
+  contain the provided value. If it cannot be found, -1 is returned.
+  It is Ok to set val to NULL.
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_setstring(dictionary * ini, char * entry, char * val);
+
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Delete an entry in a dictionary
+  @param    ini     Dictionary to modify
+  @param    entry   Entry to delete (entry name)
+  @return   void
+
+  If the given entry can be found, it is deleted from the dictionary.
+ */
+/*--------------------------------------------------------------------------*/
+void iniparser_unset(dictionary * ini, char * entry);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Finds out if a given entry exists in a dictionary
+  @param    ini     Dictionary to search
+  @param    entry   Name of the entry to look for
+  @return   integer 1 if entry exists, 0 otherwise
+
+  Finds out if a given entry exists in the dictionary. Since sections
+  are stored as keys with NULL associated values, this is the only way
+  of querying for the presence of sections in a dictionary.
+ */
+/*--------------------------------------------------------------------------*/
+int iniparser_find_entry(dictionary * ini, char * entry) ;
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Parse an ini file and return an allocated dictionary object
+  @param    ininame Name of the ini file to read.
+  @return   Pointer to newly allocated dictionary
+
+  This is the parser for ini files. This function is called, providing
+  the name of the file to be read. It returns a dictionary object that
+  should not be accessed directly, but through accessor functions
+  instead.
+
+  The returned dictionary must be freed using iniparser_freedict().
+ */
+/*--------------------------------------------------------------------------*/
+dictionary * iniparser_load(const char * ininame);
+
+/*-------------------------------------------------------------------------*/
+/**
+  @brief    Free all memory associated to an ini dictionary
+  @param    d Dictionary to free
+  @return   void
+
+  Free all memory associated to an ini dictionary.
+  It is mandatory to call this function before the dictionary object
+  gets out of the current context.
+ */
+/*--------------------------------------------------------------------------*/
+void iniparser_freedict(dictionary **d);
+
+#endif

input.c

@@ -0,0 +1,420 @@
+#include <stdio.h>
+#include <math.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <string.h>
+
+#include "libfuncs/io.h"
+#include "libfuncs/log.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "data.h"
+#include "config.h"
+#include "network.h"
+
+extern int keep_going;
+
+// #define dump_tables 1
+
+#define MAX_ZERO_READS 3
+
+/*         Start: 3 seconds on connect */
+/* In connection: Max UDP timeout == 3 seconds (read) + 2 seconds (connect) == 5 seconds */
+#define UDP_READ_RETRIES 3
+#define UDP_READ_TIMEOUT 1000
+
+/*         Start: 1/4 seconds on connect */
+/* In connection: Max TCP timeout == 5 seconds (read) + 2 seconds (connect)             == 7 seconds */
+/* In connection: Max TCP timeout == 5 seconds (read) + 8 seconds (connect, host unrch) == 13 seconds */
+#define TCP_READ_RETRIES 5
+#define TCP_READ_TIMEOUT 1000
+
+// Init pmt_pid and nit_pid
+// Return 0 on error, 1 on success
+int input_process_pat(INPUT *r) {
+	int i;
+	int num_programs = 0;
+	INPUT_STREAM *s = &r->stream;
+	struct ts_pat *pat = s->pat;
+
+	s->nit_pid = 0x10; // Default NIT pid
+	for (i=0;i<pat->programs_num;i++) {
+		struct ts_pat_program *prg = pat->programs[i];
+		if (prg->pid) {
+			if (prg->program == 0) { // NIT
+				s->nit_pid = prg->pid;
+			} else { // PAT
+				s->pmt_pid = prg->pid;
+				num_programs++;
+				break; // Get only the first program
+			}
+		}
+	}
+
+	// MPTS is not supported as input stream in the moment
+	if (num_programs > 1) {
+		LOGf("INPUT : %-10s | Can't handle MPTS (%d programs) as input stream\n", r->channel->id, num_programs);
+		return 0;
+	}
+
+	return 1;
+}
+
+void input_rewrite_pat(INPUT *r) {
+	int i;
+	INPUT_STREAM *s = &r->stream;
+	struct ts_pat *new_pat = ts_pat_copy(s->pat);
+	if (!new_pat)
+		return;
+
+	// Rewrite PAT pids
+	for (i=0;i<new_pat->programs_num;i++) {
+		struct ts_pat_program *prg = new_pat->programs[i];
+		if (prg->program != 0) { // Skip NIT
+			// Add pid to rewriter
+			pidref_add(s->pidref, prg->pid, s->pidref->base_pid);
+			// Rewrite PAT
+			prg->program = r->channel->service_id;
+			prg->pid     = s->pidref->base_pid;
+			s->pidref->base_pid++;
+		}
+	}
+
+	// Save rewritten packet
+	ts_pat_regenerate_packets(new_pat);
+	s->pat_rewritten = new_pat;
+}
+
+void input_rewrite_pmt(INPUT *r) {
+	INPUT_STREAM *s = &r->stream;
+	struct ts_pmt *new_pmt = ts_pmt_copy(s->pmt);
+	if (!new_pmt)
+		return;
+
+	// Rewrite PMT pids
+	new_pmt->ts_header.pid = pidref_get_new_pid(s->pidref, s->pmt_pid);
+	new_pmt->section_header->ts_id_number = r->channel->service_id;
+
+	uint16_t org_pcr_pid = new_pmt->PCR_pid;
+	s->pcr_pid = new_pmt->PCR_pid;
+	pidref_add(s->pidref, org_pcr_pid, s->pidref->base_pid);
+	new_pmt->PCR_pid = s->pidref->base_pid;
+	r->output_pcr_pid = new_pmt->PCR_pid;
+	s->pidref->base_pid++;
+
+	int i;
+	for (i=0;i<new_pmt->streams_num;i++) {
+		struct ts_pmt_stream *stream = new_pmt->streams[i];
+		if (stream->pid == org_pcr_pid) { // Already rewritten and added to pidref
+			stream->pid = new_pmt->PCR_pid;
+			continue;
+		}
+		pidref_add(s->pidref, stream->pid, s->pidref->base_pid);
+		stream->pid = s->pidref->base_pid;
+		s->pidref->base_pid++;
+	}
+
+	ts_pmt_regenerate_packets(new_pmt);
+	s->pmt_rewritten = new_pmt;
+}
+
+
+extern CONFIG *config;
+
+void input_buffer_add(INPUT *r, uint8_t *data, int datasize) {
+	if (r->dienow)
+		return;
+	if (r->ifd)
+		write(r->ifd, data, datasize);
+	if (r->disabled) {
+		unsigned long bufsize = r->buf->input - r->buf->output;
+		double buffull = ((double)bufsize / r->buf->size) * 100;
+		if (buffull <= 50) {
+			proxy_log(r, "Enable input");
+			r->disabled = 0;
+		} else {
+			return;
+		}
+	}
+	if (cbuf_fill(r->buf, data, datasize) != 0) {
+		proxy_log(r, "Disable input, buffer is full.");
+		r->disabled = 1;
+	}
+}
+
+int input_check_state(INPUT *r) {
+	if (r->dienow) {
+		// proxy_log(r, "Forced disconnect.");
+		return 2;
+	}
+	if (r->reconnect) {
+		proxy_log(r, "Forced reconnect.");
+		return 1;
+	}
+	return 0;
+}
+
+int process_pat(INPUT *r, uint16_t pid, uint8_t *ts_packet) {
+	INPUT_STREAM *s = &r->stream;
+
+	if (pid != 0)
+		return 0;
+
+	// Process PAT
+	s->pat = ts_pat_push_packet(s->pat, ts_packet);
+
+	s->last_pat = ts_pat_push_packet(s->last_pat, ts_packet);
+	if (s->last_pat->initialized) {
+		if (!ts_pat_is_same(s->pat, s->last_pat)) {
+			proxy_log(r, "PAT changed.");
+			return -1; // Reconnect
+		}
+		ts_pat_free(&s->last_pat);
+		s->last_pat = ts_pat_alloc();
+	}
+
+	if (s->pat->initialized) {
+		// PMT pid is still unknown
+		if (!s->pmt_pid) {
+			if (!input_process_pat(r)) {
+				proxy_log(r, "Can't parse PAT to find PMT pid.");
+				return -1;
+			}
+		}
+		// Rewritten PAT is not yet initialized
+		if (!s->pat_rewritten || !s->pat_rewritten->initialized) {
+			input_rewrite_pat(r);
+#if dump_tables
+			proxy_log(r, "PAT found!");
+			proxy_log(r, "*** Original PAT ***");
+			ts_pat_dump(s->pat);
+			proxy_log(r, "*** Rewritten PAT ***");
+			ts_pat_dump(s->pat_rewritten);
+			pidref_dump(s->pidref);
+#endif
+		}
+
+		// Only if output file is written
+		if (r->ifd && s->pat_rewritten && s->pat_rewritten->initialized) {
+			int j;
+			struct ts_pat *P = s->pat_rewritten;
+			for (j=0;j<P->section_header->num_packets;j++) {
+				ts_packet_set_cont(P->section_header->packet_data + (j * TS_PACKET_SIZE), j + s->pid_pat_cont);
+			}
+			P->ts_header.continuity = s->pid_pat_cont;
+			s->pid_pat_cont += P->section_header->num_packets;
+			write(r->ifd, P->section_header->packet_data, P->section_header->num_packets * TS_PACKET_SIZE);
+		}
+	}
+	// Stuff packet with NULL data
+	memset(ts_packet, 0xff, TS_PACKET_SIZE);
+	ts_packet[0] = 0x47;
+	ts_packet[1] = 0x1F;
+	ts_packet[2] = 0xFF;
+	ts_packet[3] = 0x10;
+
+	return 1;
+}
+
+int process_pmt(INPUT *r, uint16_t pid, uint8_t *ts_packet) {
+	INPUT_STREAM *s = &r->stream;
+
+	if (!pid || pid != s->pmt_pid)
+		return 0;
+
+	s->pmt = ts_pmt_push_packet(s->pmt, ts_packet);
+
+	s->last_pmt = ts_pmt_push_packet(s->last_pmt, ts_packet);
+	if (s->last_pmt->initialized) {
+		if (!ts_pmt_is_same(s->pmt, s->last_pmt)) {
+			proxy_log(r, "PMT changed.");
+			return -2; // Reconnect
+		}
+		ts_pmt_free(&s->last_pmt);
+		s->last_pmt = ts_pmt_alloc();
+	}
+
+	if (s->pmt->initialized) {
+		if (!s->pmt_rewritten || !s->pmt_rewritten->initialized) {
+			input_rewrite_pmt(r);
+#if dump_tables
+			proxy_log(r, "PMT found!");
+			proxy_log(r, "*** Original PMT ***");
+			ts_pmt_dump(s->pmt);
+			proxy_log(r, "*** Rewritten PMT ***");
+			ts_pmt_dump(s->pmt_rewritten);
+			// pidref_dump(s->pidref);
+#endif
+		}
+		if (s->pmt_rewritten && s->pmt_rewritten->initialized) {
+			int j;
+			struct ts_pmt *P = s->pmt_rewritten;
+			for (j=0;j<P->section_header->num_packets;j++) {
+				ts_packet_set_cont(P->section_header->packet_data + (j * TS_PACKET_SIZE), j + s->pid_pmt_cont);
+			}
+			P->ts_header.continuity = s->pid_pmt_cont;
+			s->pid_pmt_cont += P->section_header->num_packets;
+			input_buffer_add(r, P->section_header->packet_data, P->section_header->num_packets * TS_PACKET_SIZE);
+		}
+		return -1;
+	}
+	return 1;
+}
+
+int in_worktime(int start, int end) {
+	if (!start && !end)
+		return 1;
+	struct tm ltime;
+	struct tm *ltimep = &ltime;
+	time_t timep = time(NULL);
+	ltimep = localtime_r(&timep, ltimep);
+	int seconds = ltime.tm_sec + ltime.tm_min * 60 + ltime.tm_hour * 3600;
+	if (start > end) {
+		if (start >= seconds && end < seconds)
+			return 0;
+		else
+			return 1;
+	} else {
+		if (start <= seconds && end > seconds)
+			return 1;
+		else
+			return 0;
+	}
+	return 1;
+}
+
+void * input_stream(void *self) {
+	INPUT *r = self;
+	INPUT_STREAM *s = &r->stream;
+	char buf[FRAME_PACKET_SIZE];
+
+	signal(SIGPIPE, SIG_IGN);
+
+	proxy_log(r, "Start");
+	r->working = in_worktime(r->channel->worktime_start, r->channel->worktime_end);
+	if (!r->working)
+		proxy_log(r, "Worktime has not yet begin, sleeping.");
+
+	int http_code = 0;
+	while (keep_going) {
+		if (input_check_state(r) == 2) // r->dienow is on
+			goto QUIT;
+
+		while (!r->working) {
+			usleep(250000);
+			r->working = in_worktime(r->channel->worktime_start, r->channel->worktime_end);
+			if (r->working)
+				proxy_log(r, "Worktime started.");
+			if (!keep_going)
+				goto QUIT;
+		}
+
+		r->working = in_worktime(r->channel->worktime_start, r->channel->worktime_end);
+
+		int result = connect_source(self, 1, FRAME_PACKET_SIZE * 1000, &http_code);
+		if (result != 0)
+			goto RECONNECT;
+
+		channel_source sproto = get_sproto(r->channel->source);
+
+		if (mpeg_sync(r, sproto) != 0) {
+			proxy_log(r, "Can't sync input MPEG TS");
+			sleep(2);
+			goto RECONNECT;
+		}
+
+		ssize_t readen;
+		int max_zero_reads = MAX_ZERO_READS;
+
+		// Reset all stream parameters on reconnect.
+		input_stream_reset(r);
+
+		for (;;) {
+			r->working = in_worktime(r->channel->worktime_start, r->channel->worktime_end);
+			if (!r->working) {
+				proxy_log(r, "Worktime ended.");
+				goto STOP;
+			}
+
+			switch (input_check_state(r)) {
+				case 1: goto RECONNECT;		// r->reconnect is on
+				case 2: goto QUIT;			// r->dienow is on
+			}
+
+			if (sproto == tcp_sock) {
+				readen = fdread_ex(r->sock, buf, FRAME_PACKET_SIZE, TCP_READ_TIMEOUT, TCP_READ_RETRIES, 1);
+			} else {
+				readen = fdread_ex(r->sock, buf, FRAME_PACKET_SIZE, UDP_READ_TIMEOUT, UDP_READ_RETRIES, 0);
+			}
+
+			if (readen < 0)
+				goto RECONNECT;
+			if (readen == 0) { // ho, hum, wtf is going on here?
+				proxy_log(r, "Zero read, continuing...");
+				if (--max_zero_reads == 0) {
+					proxy_log(r, "Max zero reads reached, reconnecting.");
+					break;
+				}
+				continue;
+			}
+
+			int i;
+			for (i=0; i<readen; i+=188) {
+
+				if (r->dienow)
+					goto QUIT;
+				uint8_t *ts_packet = (uint8_t *)buf + i;
+				uint16_t pid = ts_packet_get_pid(ts_packet);
+
+				if (process_pat(r, pid, ts_packet) < 0)
+					goto RECONNECT;
+
+				int pmt_result = process_pmt(r, pid, ts_packet);
+				if (pmt_result == -2)
+					goto RECONNECT;
+				if (pmt_result < 0) // PMT rewritten
+					continue;
+
+				pid = ts_packet_get_pid(ts_packet);
+				// Kill incomming NIT, SDT, EIT, RST, TDT/TOT
+				if (pid == s->nit_pid || pid == 0x10 || pid == 0x11 || pid == 0x12 || pid == 0x13 || pid == 0x14 || pid == 0x1fff) {
+					// LOGf("INPUT: %-10s: Remove PID %03x\n", r->channel->id, pid);
+					continue;
+				}
+
+				// Do we have PAT and PMT? (if we have pmt we have PAT, so check only for PMT)
+				if (s->pmt_rewritten && pid == s->pcr_pid && ts_packet_has_pcr(ts_packet)) {
+					s->input_pcr = ts_packet_get_pcr(ts_packet);
+					// LOGf("INPUT : [%-12s] PCR: %llu\n", r->channel->id, s->input_pcr);
+				}
+
+				// Yes, we have enough data to start outputing
+				if (s->input_pcr) {
+					pidref_change_packet_pid(ts_packet, pid, s->pidref);
+					input_buffer_add(r, ts_packet, TS_PACKET_SIZE);
+					if (!r->input_ready)
+						r->input_ready = 1;
+				}
+			}
+
+			max_zero_reads = MAX_ZERO_READS;
+		}
+		proxy_log(r, "fdread timeout");
+RECONNECT:
+		proxy_log(r, "Reconnect");
+		shutdown_fd(&(r->sock));
+		chansrc_next(r->channel);
+		continue;
+STOP:
+		proxy_log(r, "Stop");
+		shutdown_fd(&(r->sock));
+		continue;
+QUIT:
+		break;
+	}
+	proxy_close(config->inputs, &r);
+
+	return 0;
+}

input.h

@@ -0,0 +1,6 @@
+#ifndef INPUT_H
+#define INPUT_H
+
+void * input_stream(void *);
+
+#endif

libfuncs

@@ -0,0 +1 @@
+Subproject commit f68888b2d07d55acaafc9882c8e06162e882e263

libtsfuncs

@@ -0,0 +1 @@
+Subproject commit 5627d6d019dcc605862181231bb3841fb5dd4a6b

mptsd.c

@@ -0,0 +1,167 @@
+/*
+ * MPTS Generator
+ * Reads MPEG TS over HTTP/UDP and generate MPTS
+ * Copyright (C) 2010 Unix Solutions Ltd.
+ */
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "iniparser.h"
+#include "data.h"
+#include "config.h"
+#include "network.h"
+#include "input.h"
+#include "output.h"
+#include "web_server.h"
+
+#define PROGRAM_NAME "ux-mptsd"
+
+const char *program_id = PROGRAM_NAME " " GIT_VER " build " BUILD_ID;
+
+char *server_sig = PROGRAM_NAME;
+char *server_ver = GIT_VER;
+char *copyright  = "Copyright (C) 2010-2011 Unix Solutions Ltd.";
+
+CONFIG *config;
+int keep_going = 1;
+int rcvsig = 0;
+
+void spawn_input_threads(CONFIG *conf) {
+	LNODE *lc, *lctmp;
+	LNODE *lr, *lrtmp;
+	int spawned = 0;
+	list_for_each(conf->channels, lc, lctmp) {
+		CHANNEL *c = lc->data;
+		int restreamer_active = 0;
+		list_lock(conf->inputs);
+		list_for_each(conf->inputs, lr, lrtmp) {
+			INPUT *r = lr->data;
+			if (xstrcmp(r->name, c->name)==0) {
+				restreamer_active = 1;
+				break;
+			}
+		}
+		list_unlock(conf->inputs);
+		if (!restreamer_active) {
+			INPUT *nr = input_new(c->name, c);
+			if (nr) {
+				list_add(conf->inputs, nr);
+//				LOGf("SPAWN : %s thread.\n", c->name);
+				if (pthread_create(&nr->thread, NULL, &input_stream, nr) == 0) {
+					spawned++;
+					pthread_detach(nr->thread);
+				} else {
+					LOGf("ERROR: Can't create proxy for %s\n", c->name);
+				}
+			} else {
+				LOGf("ERROR: Error creating proxy for %s\n", c->name);
+			}
+		}
+	}
+	LOGf("INPUT : %d thread%s spawned.\n", spawned, spawned > 1 ? "s" : "");
+}
+
+void spawn_output_threads(CONFIG *conf) {
+	if (pthread_create(&conf->output->psi_thread, NULL, &output_handle_psi, conf) == 0) {
+		pthread_detach(conf->output->psi_thread);
+	} else {
+		LOGf("ERROR: Can't spawn PSI output thread: %s\n", strerror(errno));
+		exit(1);
+	}
+
+	if (pthread_create(&conf->output->mix_thread, NULL, &output_handle_mix, conf) == 0) {
+		pthread_detach(conf->output->mix_thread);
+	} else {
+		LOGf("ERROR: Can't spawn MIX output thread: %s\n", strerror(errno));
+		exit(1);
+	}
+
+	if (pthread_create(&conf->output->write_thread, NULL, &output_handle_write, conf) == 0) {
+		pthread_detach(conf->output->write_thread);
+	} else {
+		LOGf("ERROR: Can't spawn WRITE output thread: %s\n", strerror(errno));
+		exit(1);
+	}
+}
+
+void kill_threads(CONFIG *conf) {
+	int loops = 0;
+	conf->output->dienow = 1;
+	while (conf->inputs->items || conf->output->dienow < 4) {
+		usleep(50000);
+		if (loops++ > 60) // 3 seconds
+			exit(0);
+	}
+}
+
+/*
+void do_reconnect(CONFIG *conf) {
+	LNODE *l, *tmp;
+	list_lock(conf->inputs);
+	list_for_each(conf->inputs, l, tmp) {
+		INPUT *r = l->data;
+		r->reconnect = 1;
+	}
+	list_unlock(conf->inputs);
+}
+
+void do_reconf(CONFIG *conf) {
+//	load_channels_config();
+	spawn_input_threads(conf);
+}
+*/
+
+void signal_quit(int sig) {
+	rcvsig = sig;
+	keep_going = 0;
+}
+
+void init_signals() {
+	signal(SIGCHLD, SIG_IGN);
+	signal(SIGPIPE, SIG_IGN);
+
+//	signal(SIGHUP , do_reconf);
+//	signal(SIGUSR1, do_reconnect);
+
+	signal(SIGINT , signal_quit);
+	signal(SIGTERM, signal_quit);
+}
+
+int main(int argc, char **argv) {
+	set_http_response_server_ident(server_sig, server_ver);
+	ts_set_log_func(LOG);
+
+	config = config_alloc();
+	config_load(config, argc, argv);
+
+	output_psi_init(config, config->output);
+
+	daemonize(config->pidfile);
+	web_server_start(config);
+	log_init(config->logident, config->syslog_active, config->pidfile == NULL, config->loghost, config->logport);
+	init_signals(config);
+
+	LOGf("INIT  : %s %s (%s)\n" , server_sig, server_ver, config->ident);
+
+	connect_output(config->output);
+	spawn_input_threads(config);
+	spawn_output_threads(config);
+
+	do { usleep(50000); } while(keep_going);
+
+	kill_threads(config);
+	web_server_stop(config);
+
+	LOGf("SHUTDOWN: Signal %d | %s %s (%s)\n", rcvsig, server_sig, server_ver, config->ident);
+	config_free(&config);
+
+	log_close();
+
+	exit(0);
+}

mptsd.conf

@@ -0,0 +1,12 @@
+[Global]
+network_id=1
+
+[Timeouts]
+pat = 100
+pmt = 200
+sdt = 500
+nit = 2000
+eit = 1000
+tdt = 5000
+tot = 15000
+stats = 1000

mptsd_channels.conf

@@ -0,0 +1,63 @@
+[Global]
+provider_name = Unix Solutions
+transport_stream_id = 1
+
+[Channel1]
+service_id	= 1
+id			= btv
+name		= bTV
+source1		= http://signal-server/stb/btv.mpg
+#source2		= http://signal-server2/stb/btv.mpg
+#source3		= http://signal-server3/stb/btv.mpg
+#source4		= udp://239.0.0.1:5000/
+#worktime	= 14:18-14:19
+
+[Channel2]
+service_id	= 2
+id			= kanal1
+name		= "Kanal 1"
+source		= http://signal-server/stb/kanal1.mpg
+
+[Channel3]
+service_id	= 3
+id			= novatv
+name		= "Nova"
+source1		= http://signal-server/stb/novatv.mpg
+
+[Channel4]
+service_id	= 4
+id			= tv2
+name		= "TV 2"
+source1		= http://signal-server/stb/tv2.mpg
+
+[Channel5]
+service_id	= 5
+id			= ngc
+name		= "NatGeo"
+source1		= http://signal-server/stb/ngc.mpg
+
+[Channel6]
+service_id	= 6
+id			= tv1
+name		= "TV 1"
+source1		= http://signal-server/stb/tv1.mpg
+
+[Channel7]
+service_id	= 7
+id			= planetahit
+name		= "Planeta HIT"
+source1		= http://signal-server/stb/planetahit.mpg
+
+[Channel8]
+service_id	= 8
+id			= fresh
+name		= "Radio Fresh"
+radio		= yes
+source		= http://signal-server/stb/fresh.mpg
+
+[Channel9]
+service_id	= 9
+id			= bgradio
+name		= "BG Radio"
+radio		= yes
+source1		= http://signal-server/stb/bgradio.mpg

mptsd_epg.conf

@@ -0,0 +1,70 @@
+[btv-now]
+start=1271055600
+duration=3600
+event=Денят е прекрасен
+sdescr=женско токшоу с водещи Ива и Боги
+descr=123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890xxxxxxyy
+
+[btv-next]
+start=1271059200
+duration=3600
+event=Вятър от долината
+sdescr=сериал, еп. 69
+descr=
+
+[kanal1-now]
+start=1271056500
+duration=2700
+event=Дързост и красота
+sdescr=тв филм /2477 епизод/
+descr=
+
+[kanal1-next]
+start=1271059200
+duration=2700
+event=Жените с Марта Вачкова /токшоу/
+sdescr=
+descr=
+
+[novatv-now]
+start=1271052900
+duration=8100
+event=На кафе
+sdescr=предаване на НТВ
+descr=
+
+[novatv-next]
+start=1271061000
+duration=5400
+event=Къщата на парите
+sdescr=забавно предаване на НТВ
+descr=
+
+[tv2-now]
+start=1271055600
+duration=3600
+event=Антракт
+sdescr=
+descr=
+
+[tv2-next]
+start=1271059200
+duration=7200
+event=Парола. Риба меч
+sdescr=криминален с Джон Траволта, Холи Бери
+descr=
+
+[ngc-now]
+start=1271055600
+duration=3600
+event=Невероятната мечка
+sdescr=
+descr=
+
+[ngc-next]
+start=1271059200
+duration=3600
+event=Гигантската риба на Амазонка
+sdescr=
+descr=
+

mptsd_nit.conf

@@ -0,0 +1,50 @@
+[Global]
+network_name = "Unixsol DVB-C network"
+
+[Transponder1]
+transport_stream_id = 1
+frequency           = 0658,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
+[Transponder2]
+transport_stream_id = 2
+frequency           = 0666,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
+[Transponder3]
+transport_stream_id = 3
+frequency           = 0674,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
+[Transponder4]
+transport_stream_id = 4
+frequency           = 0682,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
+[Transponder5]
+transport_stream_id = 5
+frequency           = 0690,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
+[Transponder6]
+transport_stream_id = 6
+frequency           = 0698,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
+[Transponder7]
+transport_stream_id = 7
+frequency           = 0706,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
+[Transponder8]
+transport_stream_id = 8
+frequency           = 0714,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750

mptsd_valgrind

@@ -0,0 +1,11 @@
+ulimit -c unlimited
+valgrind \
+	--log-file=mptsd-$(date +%F-%H:%M:%S).log \
+	--leak-check=full \
+	--show-reachable=yes \
+	--undef-value-errors=no \
+	--trace-children=yes \
+	--run-libc-freeres=yes \
+	--time-stamp=yes \
+		-- \
+	./mptsd -O 239.78.78.78

network.c

@@ -0,0 +1,294 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+#include <errno.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <regex.h>
+
+#include "libfuncs/io.h"
+#include "libfuncs/log.h"
+#include "libfuncs/list.h"
+#include "libfuncs/asyncdns.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "data.h"
+#include "config.h"
+
+extern char *server_sig;
+extern char *server_ver;
+extern CONFIG *config;
+
+int connect_udp(struct sockaddr_in send_to) {
+	int sendsock = socket(AF_INET, SOCK_DGRAM, 0);
+	if (sendsock < 0) {
+		LOGf("socket(SOCK_DGRAM): %s\n", strerror(errno));
+		return -1;
+	}
+	int on = 1;
+	setsockopt(sendsock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+	// subscribe to multicast group
+	// LOGf("Using ttl %d\n", multicast_ttl);
+	if (IN_MULTICAST(ntohl(send_to.sin_addr.s_addr))) {
+		if (setsockopt(sendsock, IPPROTO_IP, IP_MULTICAST_TTL, &config->multicast_ttl, sizeof(config->multicast_ttl)) < 0) {
+			LOGf("setsockopt(IP_MUTICAST_TTL): %s\n", strerror(errno));
+			close(sendsock);
+			return -1;
+		}
+		if (setsockopt(sendsock, IPPROTO_IP, IP_MULTICAST_IF, &config->output_intf, sizeof(config->output_intf)) < 0) {
+			LOGf("setsockopt(IP_MUTICAST_IF, %s): %s\n", strerror(errno), inet_ntoa(config->output_intf));
+			close(sendsock);
+			return -1;
+		}
+	}
+	int writebuflen = 1316 * 100;
+	if (setsockopt(sendsock, SOL_SOCKET, SO_SNDBUF, (const char *)&writebuflen, sizeof(writebuflen)) < 0)
+		log_perror("play(): setsockopt(SO_SNDBUF)", errno);
+
+	// call connect to get errors
+	if (connect(sendsock, (struct sockaddr *)&send_to, sizeof send_to)) {
+		LOGf("udp_connect() error: %s\n", strerror(errno));
+		close(sendsock);
+		return -1;
+	}
+	return sendsock;
+}
+
+void connect_output(OUTPUT *o) {
+	struct sockaddr_in sock;
+	sock.sin_family = AF_INET;
+	sock.sin_port   = htons(o->out_port);
+	sock.sin_addr   = o->out_host;
+	o->out_sock = connect_udp(sock);
+	if (o->out_sock > -1) {
+		//LOGf("OUTPUT: Connected out_fd: %i | Output: udp://%s:%d\n", o->out_sock, inet_ntoa(o->out_host), o->out_port);
+	} else {
+		LOGf("ERROR: Can't connect output | Output: udp://%s:%d\n", inet_ntoa(o->out_host), o->out_port);
+		exit(1);
+	}
+}
+
+/*
+	On the last try, send no-signal to clients and exit
+	otherwise wait a little bit before trying again
+*/
+#define DO_RECONNECT do \
+{ \
+	chansrc_free(&src); \
+	if (retries == 0) { \
+		return -1; \
+	} else { \
+		if (errno != EHOSTUNREACH) /* When host is unreachable there is already a delay of ~4 secs per try so no sleep is needed */ \
+			usleep(PROXY_RETRY_TIMEOUT * 1000); \
+		if (r->dienow) \
+			return -1; \
+		return 1; \
+	} \
+} while(0)
+
+#define FATAL_ERROR do \
+{ \
+	chansrc_free(&src); \
+	return -1; \
+} while (0)
+
+/*
+	Returns:
+		-1 = exit thread
+		 1 = retry
+		 0 = connected ok
+*/
+int connect_source(INPUT *r, int retries, int readbuflen, int *http_code) {
+	CHANSRC *src = chansrc_init(r->channel->source);
+	if (!src) {
+		LOGf("ERR  : Can't parse channel source | Channel: %s Source: %s\n", r->channel->name, r->channel->source);
+		FATAL_ERROR;
+	}
+	r->connected = 0;
+	r->reconnect = 0;
+
+	int active = 1;
+	int dret = async_resolve_host(src->host, src->port, &(r->src_sockname), 5000, &active);
+	if (dret != 0) {
+		if (dret == 1)
+			proxy_log(r, "Can't resolve host");
+		if (dret == 2)
+			proxy_log(r, "Timeout resolving host");
+		DO_RECONNECT;
+	}
+
+	proxy_log(r, "Connecting");
+
+	char buf[1024];
+	*http_code = 0;
+	if (src->sproto == tcp_sock) {
+		r->sock = socket(PF_INET, SOCK_STREAM, 0);
+		if (r->sock < 0) {
+			log_perror("play(): Could not create SOCK_STREAM socket.", errno);
+			FATAL_ERROR;
+		}
+		//proxy_log(r, "Add");
+		if (do_connect(r->sock, (struct sockaddr *)&(r->src_sockname), sizeof(r->src_sockname), PROXY_CONNECT_TIMEOUT) < 0) {
+			LOGf("ERR  : Error connecting to %s srv_fd: %i err: %s\n", r->channel->source, r->sock, strerror(errno));
+			DO_RECONNECT;
+		}
+
+		snprintf(buf,sizeof(buf)-1, "GET /%s HTTP/1.0\nHost: %s:%u\nX-Smart-Client: yes\nUser-Agent: %s %s (%s)\n\n",
+		         src->path, src->host, src->port, server_sig, server_ver, config->ident);
+		buf[sizeof(buf)-1] = 0;
+		fdwrite(r->sock, buf, strlen(buf));
+
+		char xresponse[128];
+		memset(xresponse, 0, sizeof(xresponse));
+		memset(buf, 0, sizeof(buf));
+		regmatch_t res[4];
+		while (fdgetline(r->sock,buf,sizeof(buf)-1)) {
+			if (buf[0] == '\n' || buf[0] == '\r')
+				break;
+			if (strstr(buf,"HTTP/1.") != NULL) {
+				regex_t http_response;
+				regcomp(&http_response, "^HTTP/1.[0-1] (([0-9]{3}) .*)", REG_EXTENDED);
+				if (regexec(&http_response,buf,3,res,0) != REG_NOMATCH) {
+					char codestr[4];
+					if ((unsigned int)res[1].rm_eo-res[1].rm_so < sizeof(xresponse)) {
+						strncpy(xresponse, &buf[res[1].rm_so], res[1].rm_eo-res[1].rm_so);
+						xresponse[res[1].rm_eo-res[1].rm_so] = '\0';
+						chomp(xresponse);
+						strncpy(codestr, &buf[res[2].rm_so], res[2].rm_eo-res[2].rm_so);
+						codestr[3] = 0;
+						*http_code = atoi(codestr);
+					}
+				}
+				regfree(&http_response);
+			}
+			if (*http_code == 504) { // Extract extra error code
+				if (strstr(buf, "X-ErrorCode: ") != NULL) {
+					*http_code = atoi(buf+13);
+					break;
+				}
+			}
+		}
+		if (*http_code == 0) { // No valid HTTP response, retry
+			LOGf("DEBUG: Server returned not valid HTTP code | srv_fd: %i\n", r->sock);
+			DO_RECONNECT;
+		}
+		if (*http_code == 504) { // No signal, exit
+			LOGf("ERR  : Get no-signal for %s from %s on srv_fd: %i\n", r->channel->name, r->channel->source, r->sock);
+			FATAL_ERROR;
+		}
+		if (*http_code > 300) { // Unhandled or error codes, exit
+			LOGf("ERR  : Get code %i for %s from %s on srv_fd: %i exiting.\n", *http_code, r->channel->name, r->channel->source, r->sock);
+			FATAL_ERROR;
+		}
+		// connected ok, continue
+	} else {
+		if (!IN_MULTICAST(ntohl(r->src_sockname.sin_addr.s_addr))) {
+			LOGf("ERR  : %s is not multicast address\n", r->channel->source);
+			FATAL_ERROR;
+		}
+		struct ip_mreq mreq;
+		struct sockaddr_in receiving_from;
+
+		r->sock = socket(PF_INET, SOCK_DGRAM, 0);
+		if (r->sock < 0) {
+			log_perror("play(): Could not create SOCK_DGRAM socket.", errno);
+			FATAL_ERROR;
+		}
+		// LOGf("CONN : Listening on multicast socket %s srv_fd: %i retries left: %i\n", r->channel->source, r->sock, retries);
+		int on = 1;
+		setsockopt(r->sock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
+		// subscribe to multicast group
+		memcpy(&mreq.imr_multiaddr, &(r->src_sockname.sin_addr), sizeof(struct in_addr));
+		mreq.imr_interface.s_addr = htonl(INADDR_ANY);
+		if (setsockopt(r->sock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
+			LOGf("ERR  : Failed to add IP membership on %s srv_fd: %i\n", r->channel->source, r->sock);
+			FATAL_ERROR;
+		}
+		// bind to the socket so data can be read
+		memset(&receiving_from, 0, sizeof(receiving_from));
+		receiving_from.sin_family = AF_INET;
+		receiving_from.sin_addr   = r->src_sockname.sin_addr;
+		receiving_from.sin_port   = htons(src->port);
+		if (bind(r->sock, (struct sockaddr *) &receiving_from, sizeof(receiving_from)) < 0) {
+			LOGf("ERR  : Failed to bind to %s srv_fd: %i\n", r->channel->source, r->sock);
+			FATAL_ERROR;
+		}
+	}
+
+	if (setsockopt(r->sock, SOL_SOCKET, SO_RCVBUF, (const char *)&readbuflen, sizeof(readbuflen)) < 0)
+		log_perror("play(): setsockopt(SO_RCVBUF)", errno);
+
+	r->connected = 1;
+
+//	proxy_log(r, "Connected");
+	chansrc_free(&src);
+	return 0;
+}
+
+/*         Start: 3 seconds on connect */
+/* In connection: Max UDP timeout == 3 seconds (read) + 2 seconds (connect) == 5 seconds */
+#define UDP_READ_RETRIES 3
+#define UDP_READ_TIMEOUT 1000
+
+/*         Start: 1/4 seconds on connect */
+/* In connection: Max TCP timeout == 5 seconds (read) + 2 seconds (connect)             == 7 seconds */
+/* In connection: Max TCP timeout == 5 seconds (read) + 8 seconds (connect, host unrch) == 13 seconds */
+#define TCP_READ_RETRIES 5
+#define TCP_READ_TIMEOUT 1000
+
+/*
+	Returns:
+		0 = synced ok
+		1 = not synced, reconnect
+*/
+int mpeg_sync(INPUT *r, channel_source source_proto) {
+	time_t sync_start = time(NULL);
+	unsigned int sync_packets = 0;
+	unsigned int read_bytes = 0;
+	char syncframe[188];
+
+	int _timeout = TCP_READ_TIMEOUT;
+	int _retries = TCP_READ_RETRIES;
+	if (source_proto == udp_sock) {
+		_timeout = UDP_READ_TIMEOUT;
+		_retries = UDP_READ_RETRIES;
+	}
+	do {
+		if (r->dienow)
+			return 1;
+resync:
+		if (fdread_ex(r->sock, syncframe, 1, _timeout, _retries, 1) != 1) {
+			proxy_log(r, "mpeg_sync fdread() timeoutA");
+			return 1; // reconnect
+		}
+		// LOGf("DEBUG:     Read 0x%02x Offset %u Sync: %u\n", (uint8_t)syncframe[0], read_bytes, sync_packets);
+		read_bytes++;
+		if (syncframe[0] == 0x47) {
+			ssize_t rdsz = fdread_ex(r->sock, syncframe, 188-1, _timeout, _retries, 1);
+			if (rdsz != 188-1) {
+				proxy_log(r, "mpeg_sync fdread() timeoutB");
+				return 1; // reconnect
+			}
+			read_bytes += 188-1;
+			if (++sync_packets == 7) // sync 7 packets
+				break;
+			goto resync;
+		} else {
+			sync_packets = 0;
+		}
+		if (read_bytes > FRAME_PACKET_SIZE) { // Can't sync in 1316 bytes
+			proxy_log(r, "mpeg_sync can't sync after 1316 bytes");
+			return 1; // reconnect
+		}
+		if (sync_start+2 <= time(NULL)) { // Do not sync in two seconds
+			proxy_log(r, "mpeg_sync can't sync in 2 seconds");
+			return 1; // reconnect
+		}
+	} while (1);
+	if (read_bytes-FRAME_PACKET_SIZE != 0)
+		LOGf("INPUT : [%-12s] TS synced after %u bytes\n", r->channel->id, read_bytes-FRAME_PACKET_SIZE);
+	return 0;
+}

network.h

@@ -0,0 +1,10 @@
+#ifndef NETWORK_H
+#define NETWORK_H
+
+#include "data.h"
+
+void	connect_output	(OUTPUT *o);
+int		connect_source	(INPUT *r, int retries, int readbuflen, int *http_code);
+int     mpeg_sync       (INPUT *r, channel_source source_proto);
+
+#endif

output.h

@@ -0,0 +1,13 @@
+#ifndef OUTPUT_H
+#define OUTPUT_H
+
+#include "config.h"
+
+void output_psi_init			(CONFIG *conf, OUTPUT *output);
+void output_psi_free			(OUTPUT *output);
+
+void * output_handle_psi		(void *_config);
+void * output_handle_mix		(void *_config);
+void * output_handle_write		(void *_config);
+
+#endif

output_mix.c

@@ -0,0 +1,215 @@
+#include <math.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <errno.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "data.h"
+#include "config.h"
+#include "input.h"
+
+void output_show_programs(CONFIG *conf) {
+	LNODE *lr, *lrtmp;
+	list_for_each(conf->inputs, lr, lrtmp) {
+		INPUT *r = lr->data;
+		if (r->input_ready == 1) {
+			LOGf("OUTPUT: [%-12s] Service %d appeared.\n", r->channel->id, r->channel->service_id);
+			r->input_ready++;
+		}
+	}
+}
+
+void * output_handle_mix(void *_config) {
+	LNODE *lr, *lrtmp;
+	LNODE *inpt; // Track last used input
+	CONFIG *conf = _config;
+	OUTPUT *o = conf->output;
+	int buf_in_use = 0;
+	unsigned int o_datasize, o_packets, packets;
+	unsigned int o_maxpackets = o->obuf[0].size / TS_PACKET_SIZE;
+
+	signal(SIGPIPE, SIG_IGN);
+
+	inpt = conf->inputs->tail; // Next is the first one
+	while (!o->dienow) {
+		OBUF *curbuf = &o->obuf[buf_in_use];
+
+		usleep(o->obuf_ms); // Fill interval
+
+		output_show_programs(conf);
+
+		while (curbuf->status != obuf_empty) {
+			if (o->dienow)
+				goto OUT;
+			//LOGf("MIX: Waiting for obuf %d\n", buf_in_use);
+			usleep(1);
+		}
+
+		list_lock(conf->inputs);
+
+		o_datasize = o->psibuf->input - o->psibuf->output; // PSI data
+		list_for_each(conf->inputs, lr, lrtmp) { // INPUT data
+			INPUT *r = lr->data;
+			o_datasize += r->buf->input - r->buf->output;
+		}
+
+		o_packets  = o_datasize / TS_PACKET_SIZE;
+		packets = min(o_packets, o_maxpackets);
+
+		double null_per_data = 1;
+		double data_per_null = 0;
+		if (o_maxpackets - packets) {
+			data_per_null = (double)packets / (o_maxpackets-packets);
+			if (data_per_null < 1) {
+				null_per_data = (double)(o_maxpackets-packets) / packets;
+				data_per_null = 1;
+			}
+		}
+
+		curbuf->status = obuf_filling; // Mark buffer as being filled
+
+		if (conf->debug) {
+			LOGf("MIX[%2d]: Data:%6u | Bufsz:%6d | Packs:%4u | D/N:%5.2f/%5.2f\n",
+				buf_in_use,
+				o_datasize,
+				curbuf->size,
+				packets,
+				((double)packets / o_maxpackets) * 100,
+				(double)100 - ((double)packets / o_maxpackets) * 100
+			);
+			LOGf("datapacks:%5d maxpacks:%5d null:%5d (%5.2f) | null_per_data:%5.2f data_per_null:%5.2f\n",
+				packets,
+				o_maxpackets,
+				o_maxpackets-packets,
+				100-((double)packets / o_maxpackets)*100,
+				null_per_data,
+				data_per_null
+			);
+		}
+
+		unsigned int nulls=0, null_packets_count = o_maxpackets - packets;
+		// The is no data in the input buffer, send only NULLs
+		if (null_packets_count == o_maxpackets) {
+			// Increase sended packets
+			list_for_each(conf->inputs, lr, lrtmp) {
+				INPUT *r = lr->data;
+				r->outputed_packets += o_maxpackets;
+			}
+			goto NEXT_BUFFER;
+		}
+
+		unsigned int data_packets;
+		int data_size;
+		uint8_t *data;
+		for (data_packets=0;data_packets<packets;data_packets++) {
+			if (o->dienow)
+				break;
+
+			// Try the PSI data first
+			data = cbuf_get(o->psibuf, TS_PACKET_SIZE, &data_size);
+			if (data && data_size == TS_PACKET_SIZE)
+				goto SEND_PACKET;
+
+			// Loop over inputs
+			int inputs_left = conf->inputs->items;
+			while (inputs_left--) {
+				inpt = inpt->next;
+				INPUT *r = inpt->data;
+				if (!r || !r->buf)
+					continue;
+
+				// Move pcrs || Move & rewrite prcs
+				if (conf->pcr_mode == 1 || conf->pcr_mode == 3) {
+					// Is there any data in this input?
+					data = cbuf_peek(r->buf, TS_PACKET_SIZE, &data_size);
+					if (data_size == TS_PACKET_SIZE) {
+						uint16_t pid = ts_packet_get_pid(data);
+						// Do we have PCR packet?
+						if (pid == r->output_pcr_pid && ts_packet_has_pcr(data)) {
+							if (r->output_pcr_packets_needed > 0 && r->outputed_packets < r->output_pcr_packets_needed) {
+								data = NULL;
+								data_size = 0;
+								continue;
+							}
+/*
+							LOGf("%10s | pcr:%15llu last_pcr:%15llu diff:%10lld packets:%5d needed_packs:%d diff:%d\n",
+								r->channel->id,
+								r->output_pcr,
+								r->output_last_pcr,
+								r->output_pcr - r->output_last_pcr,
+								r->outputed_packets,
+								r->output_pcr_packets_needed,
+								r->outputed_packets - r->output_pcr_packets_needed
+							);
+*/
+							uint64_t last_last_pcr = r->output_last_pcr;
+							r->output_last_pcr = r->output_pcr;
+							r->output_pcr = ts_packet_get_pcr(data);
+							if (last_last_pcr)
+								r->output_pcr_packets_needed = round(conf->output_bitrate / 8 * (r->output_pcr - r->output_last_pcr) / 27000000 / 188);
+							r->outputed_packets = 0;
+						}
+						data = cbuf_get(r->buf, TS_PACKET_SIZE, &data_size);
+						if (data_size == TS_PACKET_SIZE) // We have our data, no need to look at other inputs
+							break;
+					}
+				// Do not move PCRs
+				} else {
+					data = cbuf_get(r->buf, TS_PACKET_SIZE, &data_size);
+					if (data_size == TS_PACKET_SIZE) // We have our data, no need to look at other inputs
+						break;
+				}
+			} // while (inputs_left--)
+
+			// We have data. Mix it with NULLs and stuff it in the output buffer
+			// If the have no data, the output buffer will automaticaly be left
+			// with NULL packets
+SEND_PACKET:
+			if (data && data_size == TS_PACKET_SIZE) {
+				// Mix data with NULLs
+				if (nulls < null_packets_count) {
+					if (round(nulls * data_per_null) < round(data_packets * null_per_data)) {
+						nulls += round(data_packets * null_per_data) - round(nulls * data_per_null);
+					}
+					if (nulls > null_packets_count)
+						nulls = null_packets_count;
+				}
+				if (data_packets+nulls >= o_maxpackets) { // Can't happen
+					LOGf("wtf: %d packets:%d\n", data_packets+nulls, o_maxpackets);
+					break;
+				}
+				uint8_t *bufptr = curbuf->buf + ((data_packets + nulls) * TS_PACKET_SIZE);
+				memcpy(bufptr, data, TS_PACKET_SIZE);
+			}
+
+			// Increase sended packets
+			list_for_each(conf->inputs, lr, lrtmp) {
+				INPUT *r = lr->data;
+				r->outputed_packets++;
+			}
+		}
+
+NEXT_BUFFER:
+		list_unlock(conf->inputs);
+		curbuf->status = obuf_full; // Mark buffer as full
+
+		buf_in_use = buf_in_use ? 0 : 1; // Switch buffer
+	}
+
+OUT:
+	LOG("OUTPUT: MIX thread stopped.\n");
+	o->dienow++;
+
+	LNODE *l, *tmp;
+	list_for_each(conf->inputs, l, tmp) {
+		INPUT *r = l->data;
+		r->dienow = 1;
+	}
+
+	return 0;
+}

output_psi.c

@@ -0,0 +1,249 @@
+#include <stdlib.h>
+#include <unistd.h>
+#include <signal.h>
+
+#include "libfuncs/log.h"
+#include "libfuncs/list.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "config.h"
+#include "data.h"
+
+static void output_psi_init_pat(CONFIG *conf, OUTPUT *o) {
+	LNODE *lc, *lctmp;
+	o->pat = ts_pat_alloc_init(conf->transport_stream_id);
+	list_lock(conf->channels);
+	list_for_each(conf->channels, lc, lctmp) {
+		CHANNEL *c = lc->data;
+		ts_pat_add_program(o->pat, c->service_id, c->pmt_pid);
+	}
+	list_unlock(conf->channels);
+	gettimeofday(&o->pat_ts, NULL);
+}
+
+static void output_psi_init_nit(CONFIG *conf, OUTPUT *o) {
+	struct ts_nit *nit = ts_nit_alloc_init(conf->network_id);
+
+	ts_nit_add_network_name_descriptor(nit, conf->network_name);
+
+	if (conf->nit->items < 64) {
+		int num;
+		LNODE *lc, *lctmp;
+		uint32_t *freqs = malloc(conf->nit->items * sizeof(uint32_t));
+		uint32_t *services = malloc(conf->channels->items * sizeof(uint32_t));
+		num = 0;
+		list_lock(conf->nit);
+		list_for_each(conf->nit, lc, lctmp) {
+			NIT *ndata = lc->data;
+			freqs[num++] = ndata->_freq;
+		}
+		ts_nit_add_frequency_list_descriptor_cable(nit, conf->transport_stream_id, conf->network_id, freqs, num);
+		list_for_each(conf->nit, lc, lctmp) {
+			NIT *ndata = lc->data;
+			ts_nit_add_cable_delivery_descriptor(nit, ndata->ts_id, conf->network_id, ndata->_freq, ndata->_modulation, ndata->_symbol_rate);
+		}
+		list_unlock(conf->nit);
+		num = 0;
+		list_lock(conf->channels);
+		list_for_each(conf->channels, lc, lctmp) {
+			CHANNEL *c = lc->data;
+			uint32_t srv = 0;
+			srv  = (c->service_id &~ 0x00ff) << 16;
+			srv |= (c->service_id &~ 0xff00) << 8;
+			srv |= c->radio ? 0x02 : 0x01;
+			services[num++] = srv;
+		}
+		list_unlock(conf->channels);
+		ts_nit_add_service_list_descriptor(nit, conf->transport_stream_id, conf->network_id, services, num);
+		free(freqs);
+		free(services);
+	} else {
+		LOG("CONF  : Too much items in the NIT, maximum is 64! NIT not generated.\n");
+	}
+	gettimeofday(&o->nit_ts, NULL);
+	o->nit = nit;
+}
+
+static void output_psi_init_sdt(CONFIG *conf, OUTPUT *o) {
+	LNODE *lc, *lctmp;
+	struct ts_sdt *sdt = ts_sdt_alloc_init(conf->network_id, conf->transport_stream_id);
+	list_lock(conf->channels);
+	list_for_each(conf->channels, lc, lctmp) {
+		CHANNEL *c = lc->data;
+		ts_sdt_add_service_descriptor(sdt, c->service_id, c->radio == 0, conf->provider_name, c->name);
+	}
+	list_unlock(conf->channels);
+	gettimeofday(&o->sdt_ts, NULL);
+	o->sdt = sdt;
+}
+
+static void output_psi_init_tdt_tot(CONFIG *conf, OUTPUT *o) {
+	conf = conf; // Silence warning
+	o->pid_tdt_cont = 15;
+	o->tdt = ts_tdt_alloc_init(time(NULL));
+	o->tot = ts_tot_alloc_init(time(NULL));
+	gettimeofday(&o->tdt_ts, NULL);
+	gettimeofday(&o->tot_ts, NULL);
+}
+
+
+static void output_add_pat(OUTPUT *o) {
+	if (!o->pat->programs_num) {
+		LOG("OUTPUT: Error no programs in PAT!\n");
+		return;
+	}
+	int i;
+	struct ts_pat *pat = o->pat;
+//	LOGf("OUTPUT: Outputing PAT with %d programs\n", o->pat->programs_num);
+	for (i=0;i<pat->section_header->num_packets;i++) {
+		ts_packet_set_cont(pat->section_header->packet_data + (i * TS_PACKET_SIZE), i + o->pid_pat_cont);
+	}
+	pat->ts_header.continuity = o->pid_pat_cont;
+	o->pid_pat_cont += pat->section_header->num_packets;
+	cbuf_fill(o->psibuf, pat->section_header->packet_data, pat->section_header->num_packets * TS_PACKET_SIZE);
+//	ts_pat_dump(o->pat);
+}
+
+void output_add_nit(OUTPUT *o) {
+	if (!o || !o->nit)
+		return;
+	int i;
+	struct ts_nit *nit = o->nit;
+//	LOGf("OUTPUT: Outputing NIT\n");
+	for (i=0;i<nit->section_header->num_packets;i++) {
+		ts_packet_set_cont(nit->section_header->packet_data + (i * TS_PACKET_SIZE), i + o->pid_nit_cont);
+	}
+	nit->ts_header.continuity = o->pid_nit_cont;
+	o->pid_nit_cont += nit->section_header->num_packets;
+	cbuf_fill(o->psibuf, nit->section_header->packet_data, nit->section_header->num_packets * TS_PACKET_SIZE);
+//	ts_nit_dump(nit);
+}
+
+void output_add_sdt(OUTPUT *o) {
+	if (!o || !o->sdt)
+		return;
+	int i;
+	struct ts_sdt *sdt = o->sdt;
+//	LOGf("OUTPUT: Outputing SDT\n");
+	for (i=0;i<sdt->section_header->num_packets;i++) {
+		ts_packet_set_cont(sdt->section_header->packet_data + (i * TS_PACKET_SIZE), i + o->pid_sdt_cont);
+	}
+	sdt->ts_header.continuity = o->pid_sdt_cont;
+	o->pid_sdt_cont += sdt->section_header->num_packets;
+	cbuf_fill(o->psibuf, sdt->section_header->packet_data, sdt->section_header->num_packets * TS_PACKET_SIZE);
+//	ts_sdt_dump(o->sdt);
+}
+
+static void output_add_pid0x14(OUTPUT *o, struct ts_tdt *tdt) {
+	if (!o || !o->tdt)
+		return;
+	int i;
+//	LOGf("OUTPUT: Outputing TDT\n");
+	for (i=0;i<tdt->section_header->num_packets;i++) {
+		ts_packet_set_cont(tdt->section_header->packet_data + (i * TS_PACKET_SIZE), i + o->pid_tdt_cont);
+	}
+	tdt->ts_header.continuity = o->pid_tdt_cont;
+	o->pid_tdt_cont += tdt->section_header->num_packets;
+	cbuf_fill(o->psibuf, tdt->section_header->packet_data, tdt->section_header->num_packets * TS_PACKET_SIZE);
+}
+
+static void output_add_tdt(OUTPUT *o) {
+//	LOGf("OUTPUT: Outputing TDT\n");
+	ts_tdt_set_time(o->tdt, time(NULL));
+	output_add_pid0x14(o, o->tdt);
+//	ts_tdt_dump(o->tdt);
+}
+
+static void output_add_tot(OUTPUT *o) {
+//	LOGf("OUTPUT: Outputing TOT\n");
+	ts_tot_set_localtime_offset_sofia(o->tot, time(NULL));
+	output_add_pid0x14(o, o->tot);
+//	ts_tdt_dump(o->tot);
+}
+
+static void __output_add_eit(OUTPUT *o, struct ts_eit *eit) {
+	if (!eit)
+		return;
+//	LOGf("OUTPUT: Outputing EIT\n");
+	int i, pcnt = o->pid_eit_cont;
+	if (eit->section_header && eit->section_header->packet_data) {
+		for (i=0;i<eit->section_header->num_packets;i++) {
+			ts_packet_set_cont(eit->section_header->packet_data + (i * TS_PACKET_SIZE), i + pcnt);
+		}
+		eit->ts_header.continuity = pcnt;
+		o->pid_eit_cont += eit->section_header->num_packets;
+		cbuf_fill(o->psibuf, eit->section_header->packet_data, eit->section_header->num_packets * TS_PACKET_SIZE);
+	}
+//	ts_eit_dump(eit);
+}
+
+static void output_add_eit(CONFIG *conf, OUTPUT *o) {
+	LNODE *lr, *lrtmp;
+	config_load_epg(conf);
+	list_for_each(conf->inputs, lr, lrtmp) {
+		INPUT *r = lr->data;
+		__output_add_eit(o, r->channel->eit_now);
+		__output_add_eit(o, r->channel->eit_next);
+	}
+}
+
+static void output_psi_add(CONFIG *conf, OUTPUT *o, struct timeval *now) {
+	if (timeval_diff_msec(&o->pat_ts, now) >= conf->timeouts.pat) {
+		o->pat_ts = *now;
+		output_add_pat(o);
+	}
+	if (timeval_diff_msec(&o->nit_ts, now) >= conf->timeouts.nit) {
+		o->nit_ts = *now;
+		output_add_nit(o);
+	}
+	if (timeval_diff_msec(&o->sdt_ts, now) >= conf->timeouts.sdt) {
+		o->sdt_ts = *now;
+		output_add_sdt(o);
+	}
+	if (timeval_diff_msec(&o->tdt_ts, now) >= conf->timeouts.tdt) {
+		o->tdt_ts = *now;
+		output_add_tdt(o);
+	}
+	if (timeval_diff_msec(&o->tot_ts, now) >= conf->timeouts.tot) {
+		o->tot_ts = *now;
+		output_add_tot(o);
+	}
+	if (timeval_diff_msec(&o->eit_ts, now) >= conf->timeouts.eit) {
+		o->eit_ts = *now;
+		output_add_eit(conf, o);
+	}
+}
+
+
+void output_psi_init(CONFIG *conf, OUTPUT *output) {
+	output_psi_init_pat(conf, output);
+	output_psi_init_nit(conf, output);
+	output_psi_init_sdt(conf, output);
+	output_psi_init_tdt_tot(conf, output);
+	gettimeofday(&output->eit_ts, NULL);
+}
+
+void output_psi_free(OUTPUT *o) {
+	ts_pat_free(&o->pat);
+	ts_nit_free(&o->nit);
+	ts_sdt_free(&o->sdt);
+	ts_tdt_free(&o->tdt);
+	ts_tdt_free(&o->tot);
+}
+
+void * output_handle_psi(void *_config) {
+	CONFIG *conf = _config;
+	OUTPUT *o = conf->output;
+	struct timeval now;
+
+	signal(SIGPIPE, SIG_IGN);
+	while (!o->dienow) {
+		gettimeofday(&now, NULL);
+		output_psi_add(conf, o, &now);
+		usleep(10000); // 10 ms
+	}
+	LOG("OUTPUT: PSI thread stopped.\n");
+	o->dienow++;
+	return 0;
+}

output_write.c

@@ -0,0 +1,211 @@
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <math.h>
+
+#include "libfuncs/io.h"
+#include "libfuncs/log.h"
+#include "libfuncs/list.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "sleep.h"
+#include "data.h"
+#include "config.h"
+#include "network.h"
+
+void increase_process_priority() {
+	return;
+#ifdef __linux__
+	struct sched_param param;
+	param.sched_priority = 99;
+	if (sched_setscheduler(0, SCHED_FIFO, &param)==-1) {
+		log_perror("sched_setscheduler() failed!", errno);
+	} else {
+		LOGf("PRIO : sched_setschedule() succeded.\n");
+	}
+#endif
+}
+
+void ts_frame_process(CONFIG *conf, OUTPUT *o, uint8_t *data) {
+	int i;
+	uint16_t pid;
+	uint8_t *ts_packet;
+	for (i=0; i<FRAME_PACKET_SIZE; i+=TS_PACKET_SIZE) {
+		ts_packet = data + i;
+		pid = ts_packet_get_pid(ts_packet);
+
+		if (pid == 0x1fff) // NULL packet
+			o->padding_period += TS_PACKET_SIZE;
+
+		if (ts_packet_has_pcr(ts_packet)) {
+			uint64_t pcr = ts_packet_get_pcr(ts_packet);	// Current PCR
+			uint64_t new_pcr = pcr;
+			uint64_t bytes = o->traffic + i;
+
+			if (o->last_pcr[pid]) {
+				uint64_t old_pcr     = o->last_pcr[pid];
+				uint64_t old_org_pcr = o->last_org_pcr[pid];
+				uint64_t old_bytes   = o->last_traffic[pid];
+				if (old_org_pcr < pcr) { // Detect PCR wraparound
+					new_pcr = old_pcr + (double)((bytes - old_bytes) * 8 * 27000000) / o->output_bitrate;
+					// Rewrite pcrs || Move pcrs & rewrite prcs
+					if (conf->pcr_mode == 2 || conf->pcr_mode == 3) {
+						ts_packet_set_pcr(ts_packet, new_pcr);
+					}
+					if (conf->debug) {
+						uint64_t ts_rate = (double)(((bytes - old_bytes) * 8) * 27000000) / (pcr - old_org_pcr);
+						uint64_t ts_rate_new = (double)(((bytes - old_bytes) * 8) * 27000000) / (new_pcr - old_pcr);
+						LOGf("PCR[%03x]: old:%14llu new:%14llu pcr_diff:%8lld ts_rate:%9llu ts_rate_new:%9llu diff:%9lld | passed:%llu\n",
+							pid,
+							pcr,
+							new_pcr,
+							pcr - new_pcr,
+							ts_rate,
+							ts_rate_new,
+							ts_rate - ts_rate_new,
+							bytes - old_bytes
+						);
+					}
+ 				}
+			} else {
+//				if (config->debug) {
+//					LOGf("PCR[%03x]: %10llu init\n", pid, pcr);
+//				}
+			}
+			o->last_pcr[pid] = new_pcr;
+			o->last_org_pcr[pid] = pcr;
+			o->last_traffic[pid] = bytes;
+		}
+	}
+}
+
+ssize_t ts_frame_write(OUTPUT *o, uint8_t *data) {
+	ssize_t written;
+	written = fdwrite(o->out_sock, (char *)data, FRAME_PACKET_SIZE);
+	if (written >= 0) {
+		o->traffic        += written;
+		o->traffic_period += written;
+	}
+
+	if (o->ofd)
+		write(o->ofd, data, FRAME_PACKET_SIZE);
+
+	return written;
+}
+
+void * output_handle_write(void *_config) {
+	CONFIG *conf = _config;
+	OUTPUT *o = conf->output;
+	int buf_in_use = 0;
+	unsigned int o_datasize = 0;
+	struct timeval stats_ts, now;
+	struct timeval start_write_ts, end_write_ts, used_ts;
+	unsigned long long stats_interval;
+
+	signal(SIGPIPE, SIG_IGN);
+
+	increase_process_priority();
+
+	gettimeofday(&stats_ts, NULL);
+	while (!o->dienow) {
+		gettimeofday(&now, NULL);
+		OBUF *curbuf = &o->obuf[buf_in_use];
+
+		while (curbuf->status != obuf_full) { // Wait untill the buffer is ready ot it is already emptying
+			if (o->dienow)
+				goto OUT;
+			//LOGf("MIX: Waiting for obuf %d\n", buf_in_use);
+			usleep(1);
+		}
+		curbuf->status = obuf_emptying; // Mark buffer as being filled
+
+		// Show stats
+		stats_interval = timeval_diff_msec(&stats_ts, &now);
+		if (stats_interval > conf->timeouts.stats) {
+			stats_ts = now;
+			double out_kbps = (double)(o->traffic_period * 8) / 1000;
+			double out_mbps = (double)out_kbps / 1000;
+			double opadding = ((double)o->padding_period / o->traffic_period) * 100;
+
+			if (!conf->quiet) {
+				LOGf("STAT  : Pad:%6.2f%% Traf:%5.2f Mbps | %8.2f | %7llu\n",
+					opadding,
+					out_mbps,
+					out_kbps,
+					o->traffic_period
+				);
+			}
+			o->traffic_period = 0;
+			o->padding_period = 0;
+			o_datasize = 0;
+		}
+
+		gettimeofday(&start_write_ts, NULL);
+		int packets_written = 0, real_sleep_time = conf->output_tmout - conf->usleep_overhead;
+		long time_taken, time_diff, real_time, overhead = 0, overhead_total = 0;
+		ssize_t written = 0;
+		while (curbuf->written < curbuf->size) {
+			if (o->dienow)
+				goto OUT;
+			long sleep_interval = conf->output_tmout;
+			uint8_t *ts_frame = curbuf->buf + curbuf->written;
+			ts_frame_process(conf, o, ts_frame);	// Fix PCR and count NULL packets
+			written += ts_frame_write(o, ts_frame);	// Write packet to network/file
+			curbuf->written += FRAME_PACKET_SIZE;
+			if (packets_written) {
+				time_taken = timeval_diff_usec(&start_write_ts, &used_ts);
+				real_time  = packets_written * (conf->output_tmout + conf->usleep_overhead);
+				time_diff = real_time - time_taken;
+				overhead = (time_taken / packets_written) - sleep_interval;
+				overhead_total += overhead;
+/*
+				LOGf("[%5d] time_taken:%5ld real_time:%5ld time_diff:%ld | overhead:%5ld overhead_total:%5ld\n",
+					packets_written,
+					time_taken,
+					real_time,
+					time_diff,
+					overhead,
+					overhead_total
+				);
+*/
+				if (time_diff > real_sleep_time) {
+					sleep_interval = time_diff - conf->usleep_overhead;
+					if (sleep_interval < 0)
+						sleep_interval = 1;
+					// LOGf("Add sleep. time_diff: %ld sleep_interval: %ld\n", time_diff, sleep_interval);
+				} else {
+					//LOGf("Skip sleep %ld\n", time_diff);
+					sleep_interval = 0;
+				}
+
+			}
+			if (sleep_interval > 0)
+				usleep(sleep_interval);
+			gettimeofday(&used_ts, NULL);
+			packets_written++;
+		}
+		gettimeofday(&end_write_ts, NULL);
+		unsigned long long write_time = timeval_diff_usec(&start_write_ts, &end_write_ts);
+		if (write_time < o->obuf_ms * 1000) {
+			//LOGf("Writen for -%llu us less\n", o->obuf_ms*1000 - write_time);
+			usleep(o->obuf_ms*1000 - write_time);
+		} else {
+			//LOGf("Writen for +%llu us more\n", write_time - o->obuf_ms*1000);
+		}
+
+		obuf_reset(curbuf); // Buffer us all used up
+		buf_in_use = buf_in_use ? 0 : 1; // Switch buffer
+		if (written < 0) {
+			LOG("OUTPUT: Error writing into output socket.\n");
+			shutdown_fd(&o->out_sock);
+			connect_output(o);
+		}
+	}
+OUT:
+	LOG("OUTPUT: WRITE thread stopped.\n");
+	o->dienow++;
+	return 0;
+}

pidref.c

@@ -0,0 +1,85 @@
+#include <stdlib.h>
+
+#include "libfuncs/log.h"
+#include "libtsfuncs/tsfuncs.h"
+#include "pidref.h"
+
+PIDREF *pidref_init(int num, uint16_t base_pid) {
+	PIDREF *ref = calloc(1, sizeof(PIDREF));
+	ref->num = num;
+	ref->base_pid = base_pid;
+	ref->entries = calloc(ref->num, sizeof(PIDREF_ENTRY));
+	return ref;
+}
+
+void pidref_free(PIDREF **pref) {
+	PIDREF *ref = *pref;
+	if (!ref)
+		return;
+	FREE(ref->entries);
+	FREE(*pref);
+}
+
+int pidref_add(PIDREF *ref, uint16_t org_pid, uint16_t new_pid) {
+	int i;
+	if (!org_pid)
+		return 0;
+	for (i=0;i<ref->num;i++) {
+		PIDREF_ENTRY *entry = &ref->entries[i];
+		if (!entry->org_pid) {
+			entry->org_pid = org_pid;
+			entry->new_pid = new_pid;
+			return 1;
+		}
+	}
+	return 0;
+}
+
+int pidref_del(PIDREF *ref, uint16_t org_pid) {
+	int i;
+	if (!org_pid)
+		return 0;
+	for (i=0;i<ref->num;i++) {
+		PIDREF_ENTRY *entry = &ref->entries[i];
+		if (entry->org_pid == org_pid) {
+			entry->org_pid = 0;
+			entry->new_pid = 0;
+			return 1;
+		}
+	}
+	return 0;
+}
+
+uint16_t pidref_get_new_pid(PIDREF *ref, uint16_t org_pid) {
+	int i;
+	if (!org_pid)
+		return 0;
+	for (i=0;i<ref->num;i++) {
+		PIDREF_ENTRY *entry = &ref->entries[i];
+		if (entry->org_pid == org_pid) {
+			return entry->new_pid;
+		}
+	}
+	return 0;
+}
+
+int pidref_change_packet_pid(uint8_t *ts_packet, uint16_t packet_pid, PIDREF *ref) {
+	uint16_t new_pid = pidref_get_new_pid(ref, packet_pid);
+	if (new_pid) {
+		ts_packet_set_pid(ts_packet, new_pid);
+		return new_pid;
+	}
+	return 0;
+}
+
+void pidref_dump(PIDREF *ref) {
+	int i;
+	LOGf("pidref->base_pid = 0x%04x\n", ref->base_pid);
+	LOGf("pidref->num      = %d\n"    , ref->num);
+	LOG ("pidref->entries     org_pid  new_pid\n");
+	for (i=0;i<ref->num;i++) {
+		PIDREF_ENTRY *entry = &ref->entries[i];
+		if (entry->org_pid)
+			LOGf("pidref->entry[%02d] = 0x%04x   0x%04x\n", i, entry->org_pid, entry->new_pid);
+	}
+}

pidref.h

@@ -0,0 +1,29 @@
+#ifndef PIDREF_H
+#define PIDREF_H
+
+#include <netdb.h>
+
+typedef struct {
+	uint16_t org_pid;
+	uint16_t new_pid;
+} PIDREF_ENTRY;
+
+typedef struct {
+	uint16_t base_pid;		// From this pid on there will be rewrites
+	int num;
+	PIDREF_ENTRY *entries;
+} PIDREF;
+
+PIDREF *	pidref_init	(int num, uint16_t base_pid);
+void		pidref_free	(PIDREF **ref);
+
+int			pidref_add	(PIDREF *ref, uint16_t org_pid, uint16_t new_pid);
+int			pidref_del	(PIDREF *ref, uint16_t org_pid);
+
+uint16_t	pidref_get_new_pid			(PIDREF *ref, uint16_t org_pid);
+
+int			pidref_change_packet_pid	(uint8_t *ts_packet, uint16_t packet_pid, PIDREF *ref);
+
+void		pidref_dump	(PIDREF *ref);
+
+#endif

rc.mptsd

@@ -0,0 +1,149 @@
+#!/bin/sh
+# Server control script
+# Copyright (C) 2007-2010 Unix Solutions Ltd.
+
+PATH="/home/iptv:/bin:/sbin:/usr/bin:/usr/local/bin"
+export PATH
+cd $(dirname $0)
+
+CONFIG="$(basename $0).conf"
+
+if [ ! -r $CONFIG ]
+then
+	echo "[ERROR] $CONFIG is not found."
+	exit 1
+fi
+
+. ./$CONFIG
+
+istart() {
+	echo "[START] Starting $PRGNAME."
+	if [ ! -f "$SERVER" -o ! -x "$SERVER" ]
+	then
+		echo "[ERROR] $SERVER does not exist or it's not executable."
+		exit 1
+	fi
+	if [ -r "$PIDFILE" ]
+	then
+		fpid=$(cat "$PIDFILE" 2>/dev/null)
+		rpid=$(pidof $PRGNAME 2>/dev/null)
+		if [ -n "$rpid" -a "0$fpid" -eq "0$rpid" ]
+		then
+			echo "[ERROR] $PRGNAME is already running: (pid $rpid)"
+			exit 1
+		else
+			echo "[ERROR] $PIDFILE is stale, $PRGNAME is not running. Deleting it pid file."
+			rm $PIDFILE
+		fi
+	fi
+	echo "[CMD  ] $SERVER $PARAMS"
+	cd $(dirname $SERVER)
+	$SERVER $PARAMS
+	if [ $? -eq 0 ]
+	then
+		echo "[OK   ] $PRGNAME started."
+	else
+		echo "[ERROR] $PRGNAME not started."
+	fi
+}
+
+istop() {
+	echo "[STOP ] Stopping $PRGNAME."
+	killall $PRGNAME
+	if [ $? -eq 0 ]
+	then
+		echo -n "[WAIT ] Waiting"
+		echo -n "." && sleep .3
+		echo -n "." && sleep .3
+		echo -n "." && sleep .3
+		echo -n "." && sleep .2
+		echo "."
+		if [ -r "$PIDFILE" ]
+		then
+			RPID=$(pidof $PRGNAME 2>/dev/null)
+			if [ "0$RPID" -ne "0" ]
+			then
+				echo "[ERROR] $PRGNAME is still running: (pid $(cat $PIDFILE)). Kill -9ing it."
+				killall -9 $PRGNAME
+			fi
+		fi
+		echo "[OK   ] $PRGNAME is stopped."
+	fi
+}
+
+icheck() {
+	if [ -r "$PIDFILE" ]
+	then
+		fpid=$(cat "$PIDFILE" 2>/dev/null)
+		rpid=$(pidof $PRGNAME 2>/dev/null)
+		if [ -n "$rpid" -a "0$fpid" -eq "0$rpid" ]
+		then
+			echo "[CHECK] $PRGNAME is already running: (pid $rpid)"
+		else
+			istart
+		fi
+	else
+		echo "[CHECK] Stop and start"
+		istop
+		istart
+	fi
+}
+
+istatus() {
+	rpid=$(pidof $PRGNAME 2>/dev/null)
+	echo "[STATUS] $PRGNAME pidfile pid: $(cat $PIDFILE 2>/dev/null)"
+	echo "[STATUS] $PRGNAME pidof   pid: $rpid"
+	if [ -z "$rpid" ]
+	then
+		echo "[STATUS] $PRGNAME is not running."
+	else
+		if [ -n "$rpid" -a "0$(cat $PIDFILE 2>/dev/null)" -eq "0$rpid" ]
+		then
+			echo "[STATUS] $PRGNAME is running"
+		else
+			echo "[STATUS] $PRGNAME is running but no pid file exist: $PIDFILE"
+		fi
+		ps ax | grep "$PRGNAME -i" | grep -v grep
+	fi
+}
+
+ireconnect() {
+	echo "[RECONN] Sending SIGUSR1 to $PRGNAME causing reconnect"
+	kill -USR1 $(pidof $PRGNAME)
+}
+
+ireload() {
+	echo "[RECONN] Sending SIGHUP to $PRGNAME causing configuration reload"
+	kill -HUP $(pidof $PRGNAME)
+}
+
+case "$1" in
+'start')
+	if [ "$2" != "" ]
+	then
+		sleep "$2"
+	fi
+	istart
+	;;
+'stop')
+	istop
+	;;
+'check')
+	icheck
+	;;
+'status')
+	istatus
+	;;
+'restart')
+	istop
+	istart
+	;;
+'reload')
+	ireload
+	;;
+'reconnect')
+	ireconnect
+	;;
+*)
+	echo "Usage: `basename $0` start|stop|check|restart|reload|reconnect|status"
+esac

rc.mptsd.conf

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+ulimit -c unlimited -s 128 2>/dev/null
+
+PROVIDER="ux"
+IDENT="mptsd"
+LOGHOST="gf.unixsol.bg"
+OUTPUT_HOST="239.78.78.78"
+OUTPUT_PORT="5000"
+BITRATE="-B 37.3"
+CONFS="-g mptsd.conf -n mptsd_nit.conf -c mptsd_channels.conf -e mptsd_epg.conf"
+
+OUTPUT_HOST="238.0.0.10"
+OUTPUT_PORT="5010"
+CONFS=""
+
+BASEDIR="."
+PRGNAME="mptsd"
+
+SERVER="$BASEDIR/$PRGNAME"
+PIDFILE="$BASEDIR/$PRGNAME.pid"
+PARAMS="-i $PROVIDER/$IDENT $BITRATE -O $OUTPUT_HOST -P $OUTPUT_PORT $CONFS"
+#PARAMS="-i $PROVIDER/$IDENT $BITRATE -O $OUTPUT_HOST -P $OUTPUT_PORT $CONFS -l $LOGHOST"
+#PARAMS="-i $PROVIDER/$IDENT $BITRATE -O $OUTPUT_HOST -P $OUTPUT_PORT $CONFS -d $PIDFILE"
+#PARAMS="-i $PROVIDER/$IDENT $BITRATE -O $OUTPUT_HOST -P $OUTPUT_PORT $CONFS -l $LOGHOST -d $PIDFILE"

sleep.c

@@ -0,0 +1,43 @@
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <math.h>
+
+#include "libfuncs/log.h"
+
+#include "config.h"
+
+void * calibrate_sleep(void *_config) {
+	struct timeval tv1, tv2;
+	unsigned long diff = 0, loops = 0;
+	CONFIG *conf = _config;
+
+	if (!conf->quiet) {
+		LOGf("\tCalibrating sleep timeout...\n");
+		LOGf("\tRequest timeout   : %ld us\n", conf->output_tmout);
+	}
+
+	do {
+		gettimeofday(&tv1, NULL);
+		usleep(1);
+		gettimeofday(&tv2, NULL);
+		diff += timeval_diff_usec(&tv1, &tv2) - 1;
+	} while (loops++ != 3000);
+
+	conf->usleep_overhead = diff / loops;
+	conf->output_tmout -= conf->usleep_overhead;
+
+	if (!conf->quiet) {
+		LOGf("\tusleep(1) overhead: %ld us\n", conf->usleep_overhead);
+		LOGf("\tOutput pkt tmout  : %ld us\n", conf->output_tmout);
+	}
+
+	if (conf->output_tmout < 0) {
+		LOGf("usleep overhead is to much!! Disabling output rate control.\n");
+		conf->output_tmout = 0;
+	}
+
+	pthread_exit(0);
+}

sleep.h

@@ -0,0 +1,6 @@
+#ifndef SLEEP_H
+#define SLEEP_H
+
+void * calibrate_sleep(void *_config);
+
+#endif

web_pages.c

@@ -0,0 +1,27 @@
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include "libfuncs/io.h"
+#include "libfuncs/log.h"
+#include "libfuncs/list.h"
+#include "libfuncs/http_response.h"
+
+#include "config.h"
+
+extern CONFIG *config;
+
+void cmd_index(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputs(clientsock, "\nHi from mptsd.\n");
+}
+
+void cmd_reconnect(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputsf(clientsock, "\nReconnecting %d inputs.\n", config->inputs->items);
+}

web_pages.h

@@ -0,0 +1,7 @@
+#ifndef WEB_PAGES_H
+#define WEB_PAGES_H
+
+void cmd_index(int clientsock);
+void cmd_reconnect(int clientsock);
+
+#endif

web_server.c

@@ -0,0 +1,122 @@
+#include <stdlib.h>
+#include <regex.h>
+#include <errno.h>
+#include <string.h>
+#include <signal.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "web_pages.h"
+#include "web_server.h"
+
+typedef struct req_info {
+	int clientsock;
+	struct sockaddr_in client;
+} request_info;
+
+extern int keep_going;
+
+#define NEXT_CLIENT { FREE(path); FREE(buf); pthread_exit(0); }
+#define SHUTDOWN_CLIENT { FREE(path); FREE(buf); shutdown_fd(&clientsock); pthread_exit(0); }
+#define BUF_SIZE 1024
+
+void *process_web_request(void *);
+
+void *web_server_thread(void *data) {
+	CONFIG *conf = data;
+	while (keep_going) {
+		struct sockaddr_in client;
+		unsigned int clientlen = sizeof(client);
+		int clientsock;
+		clientsock = accept(conf->server_socket, (struct sockaddr *) &client, &clientlen);
+		if (clientsock < 0) {
+			if (conf->server_socket > -1)	// The server_socket is closed on exit, so do not report errors
+				LOGf("ERROR : Failed to accept client fd: %i err: %s\n", clientsock, strerror(errno));
+			if (errno==EMFILE || errno==ENFILE) /* No more FDs */
+				break;
+		} else {
+			request_info *req;
+			pthread_t req_thread;
+			req = malloc(sizeof(request_info));
+			if (!req) {
+				log_perror("Can't allocate request_info", errno);
+				continue;
+			}
+			req->clientsock = clientsock;
+			req->client = client;
+			if (pthread_create(&req_thread, NULL, (void *)&process_web_request, (void *)req)) {
+				log_perror("Error creating request processing thread.", errno);
+				exit(1);
+			}
+			pthread_detach(req_thread);
+		}
+	}
+
+	pthread_exit(0);
+}
+
+void web_server_start(CONFIG *conf) {
+	if (conf->server_socket > -1)
+		pthread_create(&conf->server_thread, NULL, &web_server_thread, conf);
+}
+
+void web_server_stop(CONFIG *conf) {
+	if (conf->server_socket > -1) {
+		shutdown_fd(&conf->server_socket);
+		pthread_join(conf->server_thread, NULL);
+	}
+}
+
+void *process_web_request(void *in_req) {
+	request_info *req = (request_info *)in_req;
+	int clientsock = req->clientsock;
+	regmatch_t res[3];
+	char *path=NULL, *buf=NULL;
+	FREE(req);
+
+	signal(SIGPIPE, SIG_IGN);
+
+	if (!keep_going)
+		pthread_exit(0);
+
+	buf = malloc(BUF_SIZE);
+	if (!buf) {
+		log_perror("Can't allocate buffer", errno);
+		SHUTDOWN_CLIENT;
+	}
+
+	if (fdgetline(clientsock,buf,BUF_SIZE)<=0) {
+		SHUTDOWN_CLIENT;
+	}
+
+	regex_t request_get;
+	regcomp(&request_get, "^GET /([^ ]*) HTTP/1.*$", REG_EXTENDED);
+	if (regexec(&request_get,buf,2,res,0)==REG_NOMATCH) {
+		send_501_not_implemented(clientsock);
+		SHUTDOWN_CLIENT;
+	}
+
+	buf[res[1].rm_eo]=0;
+	chomp(buf+res[1].rm_so);
+	if (buf[res[1].rm_eo-1]=='/') buf[res[1].rm_eo-1]=0;
+	path = strdup(buf+res[1].rm_so);
+	regfree(&request_get);
+
+	while (fdgetline(clientsock,buf,BUF_SIZE) > 0) {
+		if (buf[0] == '\n' || buf[0] == '\r') // End of headers
+			break;
+	}
+
+	if (strlen(path) == 0) {
+		cmd_index(clientsock);
+	} else if (strstr(path,"reconnect")==path) {
+		cmd_reconnect(clientsock);
+	} else {
+		send_404_not_found(clientsock);
+	}
+
+	SHUTDOWN_CLIENT;
+}
+

web_server.h

@@ -0,0 +1,9 @@
+#ifndef WEB_SERVER_H
+# define WEB_SERVER_H
+
+#include "config.h"
+
+void web_server_start(CONFIG *conf);
+void web_server_stop(CONFIG *conf);
+
+#endif