Initial import

.gitignore

+*.o
+*.a
+tsiproxy

.gitmodules

+[submodule "libfuncs"]
+	path = libfuncs
+	url = https://georgi.unixsol.org/git/gfto/libfuncs.git

Makefile

+CC = $(CROSS)$(TARGET)gcc
+STRIP = $(CROSS)$(TARGET)strip
+INCLUDES = -include defines.h -I.
+BUILD_ID = $(shell git describe --tags)
+CFLAGS ?= $(INCLUDES) -DGIT_BUILD_ID=\"$(BUILD_ID)\" -D_GNU_SOURCE=1 \
+ -O2 -ggdb -pipe -ffunction-sections -fdata-sections \
+ -W -Wall -Wextra \
+ -Wshadow -Wformat-security \
+ -Wredundant-decls -Wold-style-definition
+
+RM = /bin/rm -f
+Q=@
+
+LIBS = -lpthread
+FUNCS_DIR = libfuncs
+FUNCS_LIB = $(FUNCS_DIR)/libfuncs.a
+
+tsiproxy_OBJS = data.o conf.o commands.o \
+	request_tsiproxy.o \
+	proxy_common.o proxy_ts.o \
+	tsiproxy.o \
+	$(FUNCS_LIB)
+
+tsiproxy: $(tsiproxy_OBJS)
+	$(Q)echo "  LINK	tsiproxy"
+	$(Q)$(CC) $(CFLAGS) $(tsiproxy_OBJS) $(LIBS) -o tsiproxy
+
+
+$(FUNCS_LIB):
+	$(Q)echo "  MAKE	$(FUNCS_LIB)"
+	$(Q)$(MAKE) -s -C $(FUNCS_DIR)
+
+%.o: %.c defines.h
+	$(Q)echo "  CC	tsiproxy	$<"
+	$(Q)$(CC) -Dtsiproxy=1 $(CFLAGS)  -c $<
+
+strip:
+	$(Q)echo "  STRIP"
+	$(Q)$(STRIP) tsiproxy vod
+
+clean:
+	$(Q)echo "  RM	$(tsiproxy_OBJS)"
+	$(Q)$(RM) $(tsiproxy_OBJS) tsiproxy *~
+
+distclean: clean
+	$(Q)$(MAKE) -s -C $(FUNCS_DIR) clean
+
+client:
+	rm -rf *.h *.c *.o *.vo *.eo Makefile libfuncs

commands.c

+/* tsiproxy server commands */
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#include <errno.h>
+#include <dirent.h>
+#include <fcntl.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "data.h"
+#include "conf.h"
+
+extern CONFIG *config;
+extern char *server_ver;
+extern LIST *netconf, *clients, *chanconf, *restreamer;
+extern STATS allstats;
+
+static void std_headers(int clientsock, char *IP) {
+	fdputsf(clientsock, "X-IP: %s\n", IP);
+	send_header_textplain(clientsock);
+	fdputs(clientsock, "\n");
+}
+
+void run_ping(unsigned int clientsock, acl_t acl, uint32_t src_ip, char *IP) {
+	unused(src_ip);
+	char flags[6] = "-----";
+	send_200_ok(clientsock);
+	if (acl.stats ) flags[1] = 'S';
+	if (acl.reconf) flags[2] = 'F';
+	if (acl.access) flags[3] = 'A';
+	fdputsf(clientsock, "X-Access: %s\n", flags);
+	std_headers(clientsock, IP);
+	fdputs(clientsock, "PONG\n");
+}
+
+int __show_stats(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!acl.stats) {
+		LOGf("DENY : Stats access denied | IP: %s\n", IP);
+		send_403_forbidden(clientsock);
+		return 0;
+	}
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	return 1;
+}
+
+void show_stats(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!__show_stats(clientsock, acl, IP))
+		return;
+	time_t now = time(NULL);
+	LNODE *l, *tmp;
+	list_lock(clients);
+	list_for_each_reverse(clients, l, tmp) {
+		CLIENT *c = l->data;
+		// Workaround for unknown bug that leaves records in clients list but not in restreamerX->clients list
+		// Such a client hangs forever taking memory. The bug was seen on snaps server
+		if (now - c->ts >= NO_TRAFFIC_SECONDS + 5) {
+			list_unlock(clients);
+			stop_client_shutdown(c);
+			list_lock(clients);
+			continue;
+		}
+		if (c->traffic_out == 0)
+			continue;
+		//                  IP   A  FD   PROV  CID         TRA TM  CHAN  AGENT
+		fdputsf(clientsock,"%s\t%c\t%i\t%-12s\t%lu\t%14llu\t%6lu\t%-22s\t%s\n",
+			c->IP,
+			'-',
+			c->fno,
+			"-",
+			c->clientid,
+			c->traffic_out,
+			now - c->start,
+			c->chan,
+			c->agent);
+	}
+	list_unlock(clients);
+}
+
+int __show_info(unsigned int clientsock, acl_t acl, char *IP,
+	unsigned long total_clients,
+	unsigned long clients_current, unsigned long clients_gone,
+	unsigned long long traffic_in, unsigned long long traffic_out)
+{
+	int used_fds = -1;
+	if (!acl.stats) {
+		LOGf("DENY : Info access denied | IP: %s\n", IP);
+		send_403_forbidden(clientsock);
+		return 0;
+	}
+	time_t now = time(NULL);
+	time_t uptime = now - allstats.start_ts;
+	unsigned int t_sec,t_min,t_hour,t_days;
+	struct rlimit limit;
+	double load_avg[3];
+
+	t_sec = uptime % 60;
+	t_min  = (uptime - t_sec) / 60;
+	t_hour = (t_min - t_min % 60) / 60;
+	t_min  = t_min - t_hour * 60;
+	t_days = (t_hour - t_hour % 24) / 24;
+	t_hour = t_hour - t_days * 24;
+
+	getrlimit(RLIMIT_NOFILE, &limit);
+	getloadavg(load_avg, 3);
+
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	fdputs (clientsock,  "Server info\n");
+	fdputsf(clientsock, "  Ident            : %s\n", config->ident);
+	fdputsf(clientsock, "  Version          : %s\n", server_ver);
+	fdputsf(clientsock, "  Server           : %s %s %s %s %s\n",
+		allstats.utsdata.sysname,
+		allstats.utsdata.nodename,
+		allstats.utsdata.release,
+		allstats.utsdata.version,
+		allstats.utsdata.machine);
+	fdputsf(clientsock, "  Cores            : %ld\n", (long)sysconf(_SC_NPROCESSORS_ONLN));
+
+	DIR *d = opendir("/proc/self/fd");
+	if (d) {
+		struct dirent *dir;
+		while ((dir = readdir(d))) {
+			if (dir->d_name[0] == '.') // Ignore . and ..
+				continue;
+			used_fds++;
+		}
+		closedir(d);
+	}
+	fdputsf(clientsock, "  Max FDs          : %ld\n",(long)limit.rlim_max);
+	fdputsf(clientsock, "  Used FDs         : %ld\n",(long)used_fds);
+	fdputsf(clientsock, "  Load average     : %4.2f %4.2f %4.2f\n",load_avg[0],load_avg[1],load_avg[2]);
+	fdputsf(clientsock, "  Localtime        : %s", ctime(&now));
+	fdputsf(clientsock, "  Uptime           : %d %02d:%02d:%02d\n", t_days, t_hour, t_min, t_sec);
+	fdputsf(clientsock, "  Redirect         : %s %s\n\n",
+		config->redirect_url ? "enabled" : "disabled",
+		config->redirect_url ? config->redirect_url : ""
+	);
+
+	fdputs (clientsock, "Statistics\n");
+	fdputsf(clientsock, "  Clients current  : %lu\n",     clients_current);
+	fdputsf(clientsock, "  Clients cur+gone : %lu\n",     clients_current + clients_gone);
+	fdputsf(clientsock, "  Traffic in       : %llu MB\n", traffic_in / (1024*1024));
+	fdputsf(clientsock, "  Traffic out      : %llu MB\n", traffic_out / (1024*1024));
+	fdputsf(clientsock, "  Total clients    : %lu\n\n",   total_clients);
+
+	return 1;
+}
+
+void show_info(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!__show_info(clientsock, acl, IP, allstats.clients, allstats.clients_current, allstats.clients_gone, allstats.traffic_in, allstats.traffic_out))
+		return;
+
+	time_t now = time(NULL);
+	time_t uptime = now - allstats.start_ts;
+	fdputs (clientsock, "IPTVD statistics\n");
+	fdputsf(clientsock, "  Proxies current  : %u\n",      restreamer->items);
+	fdputsf(clientsock, "  Restreamers      : %lu\n",     allstats.child_servers);
+	fdputsf(clientsock, "  Connects         : %lu\n",     allstats.clients_all);
+	fdputsf(clientsock, "  Errors           : %lu\n",     allstats.errors);
+	fdputs (clientsock, "                     current cur+gone trafic_in traffic_out clients servers connects errors localtime uptime\n");
+	fdputsf(clientsock, "AllStats           : %lu %lu %llu %llu %lu %lu %lu %lu %lu %lu\n\n",
+		allstats.clients_current,
+		allstats.clients_current + allstats.clients_gone,
+		allstats.traffic_in,
+		allstats.traffic_out,
+		allstats.clients,
+		allstats.child_servers,
+		allstats.clients_all,
+		allstats.errors,
+		now,
+		uptime);
+
+	LNODE *l, *tmp;
+	unsigned int t_sec,t_min,t_hour,t_days;
+	fdputs(clientsock, "Running restreamers\n");
+	list_lock(restreamer);
+	list_for_each_reverse(restreamer, l, tmp) {
+		RESTREAMER *r = l->data;
+		uptime = time(NULL) - r->started;
+
+		t_sec = uptime % 60;
+		t_min  = (uptime - t_sec) / 60;
+		t_hour = (t_min - t_min % 60) / 60;
+		t_min  = t_min - t_hour * 60;
+		t_days = (t_hour - t_hour % 24) / 24;
+		t_hour = t_hour - t_days * 24;
+
+		fdputsf(clientsock,"  %-27sClients: %i Served: %li Conn: %li Uptime: %d %02d:%02d:%02d In: %lli %lli MB Out: %lli %lli MB\n",
+			r->name,
+			r->clients->items,
+			r->served,
+			r->connects,
+			t_days, t_hour, t_min, t_sec,
+			r->traffic_in, r->traffic_in / (1024*1024),
+			r->traffic_out, r->traffic_out / (1024*1024)
+		);
+	}
+	list_unlock(restreamer);
+	fdputs(clientsock,"\n");
+}
+
+void run_livecheck(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!acl.reconf) {
+		LOGf("DENY : LiveCheck access denied | IP: %s\n", IP);
+		send_403_forbidden(clientsock);
+		return;
+	}
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	do {
+		char outbuf[128];
+		int size;
+		memset(outbuf, ' ', sizeof(outbuf));
+		outbuf[sizeof(outbuf)-1] = '\n';
+		STATS ls = allstats;
+		sleep(1);
+		time_t now = time(NULL);
+		time_t uptime = now - allstats.start_ts;
+		/* The traffic passed in the 1 second sleep above */
+		ls.traffic_in = allstats.traffic_in - ls.traffic_in;
+		ls.traffic_out = allstats.traffic_out - ls.traffic_out;
+		size = sprintf(outbuf, "%lu %lu %lu %u %llu %llu",
+				now,
+				uptime,
+				allstats.clients_current,
+				restreamer ? restreamer->items : 0,
+				ls.traffic_in,
+				ls.traffic_out);
+		outbuf[size]=' ';
+		if (fdwrite(clientsock, outbuf, sizeof(outbuf)) <= 0)
+			break;
+	} while (1);
+}
+
+void read_info(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!acl.stats) {
+		LOGf("DENY : Info access denied | IP: %s\n", IP);
+		send_403_forbidden(clientsock);
+		return;
+	}
+	time_t now = time(NULL);
+	time_t uptime = now - allstats.start_ts;
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	unsigned int gone = allstats.clients_gone;	/* Reset it first because fdputsf can block */
+	allstats.clients_gone = 0;
+	fdputsf(clientsock, "%lu %lu %llu %llu %lu %lu %lu %lu %lu %lu\n",
+		allstats.clients_current,
+		allstats.clients_current + gone,
+		allstats.traffic_in,
+		allstats.traffic_out,
+		allstats.clients,
+		allstats.child_servers,
+		allstats.clients_all,
+		allstats.errors,
+		now,
+		uptime);
+}
+
+void run_netconf(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!acl.reconf) {
+		LOGf("DENY : NetConf access denied | IP: %s\n", IP);
+		send_403_forbidden(clientsock);
+		return;
+	}
+	int nets = load_networks(config);
+	if (nets > -1)
+		LOGf("CONF : NetConf reloaded | IP: %s Loaded: %i\n", IP, nets);
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	if (nets > -1)
+		fdputsf(clientsock,"OK %i networks read\n", nets);
+	else
+		fdputs(clientsock,"Networks are already up to date\n");
+}
+
+void run_chanconf(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!acl.reconf) {
+		LOGf("DENY : ChanConf access denied | IP: %s\n", IP);
+		send_403_forbidden(clientsock);
+		return;
+	}
+	int j = load_channels(config);
+	if (j > -1)
+		LOGf("CONF : ChanConf reloaded | IP: %s Loaded: %i\n", IP, j);
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	if (j > -1)
+		fdputsf(clientsock,"OK %i channels read\n",j);
+	else
+		fdputs(clientsock,"Channels are already up to date\n");
+}
+
+void run_getnetconf(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!acl.reconf) {
+		send_403_forbidden(clientsock);
+		return;
+	}
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	LNODE *l, *tmp;
+	list_lock(netconf);
+	list_for_each(netconf, l, tmp) {
+		NETWORK *n = l->data;
+		fdputsf(clientsock,"%d.%d.%d.%d/%d.%d.%d.%d\t%s%s%s\n",
+			(n->net >> 0 ) & 0xFF,
+			(n->net >> 8 ) & 0xFF,
+			(n->net >> 16) & 0xFF,
+			(n->net >> 24) & 0xFF,
+
+			(n->mask >> 0 ) & 0xFF,
+			(n->mask >> 8 ) & 0xFF,
+			(n->mask >> 16) & 0xFF,
+			(n->mask >> 24) & 0xFF,
+
+			n->acl.stats  ? "S" : "",
+			n->acl.reconf ? "F" : "",
+			n->acl.access ? "A" : ""
+		);
+	}
+	list_unlock(netconf);
+}
+
+void run_getchanconf(unsigned int clientsock, acl_t acl, char *IP) {
+	if (!acl.reconf) {
+		send_403_forbidden(clientsock);
+		return;
+	}
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	LNODE *l, *tmp;
+	list_lock(chanconf);
+	list_for_each(chanconf, l, tmp) {
+		CHANNEL *c = l->data;
+		int r = 0;
+		while (c->sources[r] && r < MAX_CHANNEL_SOURCES) {
+			fdputsf(clientsock,"%s\t%s\n", c->name, c->sources[r]);
+			r++;
+		}
+	}
+	list_unlock(chanconf);
+}
+
+void run_channels(unsigned int clientsock, acl_t acl, char *IP) {
+	time_t now = time(NULL);
+	LNODE *l, *tmp;
+	if (!acl.stats) {
+		LOGf("DENY : Channels access denied | IP: %s\n", IP);
+		send_403_forbidden(clientsock);
+		return;
+	}
+	send_200_ok(clientsock);
+	std_headers(clientsock, IP);
+	list_lock(restreamer);
+	list_for_each_reverse(restreamer, l, tmp) {
+		RESTREAMER *r = l->data;
+		time_t uptime = now - r->started;
+		fdputsf(clientsock,"%-20s\t%5i\t%5li\t%5li\t%7ld\t%12lli\t%12lli\n",
+			r->name,
+			r->clients->items,
+			r->served,
+			r->connects,
+			uptime,
+			r->traffic_in,
+			r->traffic_out
+		);
+	}
+	list_unlock(restreamer);
+}

commands.h

+/* tsiproxy server commands */
+#ifndef COMMANDS_H
+# define COMMANDS_H
+
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+void run_ping(unsigned int clientsock, acl_t acl, uint32_t src_ip, char *IP);
+void show_stats(unsigned int clientsock, acl_t acl, char *IP);
+void show_info(unsigned int clientsock, acl_t acl, char *IP);
+void read_info(unsigned int clientsock, acl_t acl, char *IP);
+void run_netconf(unsigned int clientsock, acl_t acl, char *IP);
+void run_chanconf(unsigned int clientsock, acl_t acl, char *IP);
+void run_getnetconf(unsigned int clientsock, acl_t acl, char *IP);
+void run_getchanconf(unsigned int clientsock, acl_t acl, char *IP);
+void run_livecheck(unsigned int clientsock, acl_t acl, char *IP);
+void run_channels(unsigned int clientsock, acl_t acl, char *IP);
+
+#endif

conf.c

+/* tsiproxy server configuration */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/time.h>
+
+#include <fcntl.h>
+#include <errno.h>
+#include <regex.h>
+#include <pthread.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "data.h"
+#include "conf.h"
+
+extern LIST *netconf, *chanconf, *restreamer;
+
+static pthread_mutex_t networks_lock  = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t channels_lock  = PTHREAD_MUTEX_INITIALIZER;
+
+int load_channels(CONFIG *config) {
+	regex_t re;
+	regmatch_t res[3];
+	char line[1024];
+	int fd;
+	int num_channels = 0;
+
+	if (pthread_mutex_trylock(&channels_lock) != 0)
+		return -1;
+
+	fd = open(config->channels_file, O_RDONLY);
+
+	if (fd != -1) {
+		struct timeval tv;
+		gettimeofday(&tv, NULL);
+		unsigned int randstate = tv.tv_usec;
+		int cookie = rand_r(&randstate);
+
+		regcomp(&re, "^([A-Za-z0-9/\\.]+)\t+([A-Za-z0-9/\\.:-]+)", REG_EXTENDED);
+		time_t curtime = time(NULL);
+		LIST *old_chanconf;
+		LIST *new_chanconf = list_new("chanconf");
+		while (fdgetline(fd,line,sizeof(line)) > 0) {
+			chomp(line);
+			if (regexec(&re,line,3,res,0)==0) {
+				char *name, *source;
+				char *org = strdup(line);
+				name   = org+res[1].rm_so; org[res[1].rm_eo]=0;
+				source = org+res[2].rm_so; org[res[2].rm_eo]=0;
+				if (!is_valid_url(source)) {
+					LOGf("CCONF: Invalid url: %s\n", source);
+					FREE(org);
+					goto report_error;
+				}
+				/* Search for already added channel */
+				LNODE *l, *tmp;
+				CHANNEL *chan = NULL;
+				list_for_each_reverse(new_chanconf, l, tmp) {
+					if (strcmp(name, ((CHANNEL *)l->data)->name)==0) {
+						chan = l->data;
+						break;
+					}
+				}
+				if (!chan) {
+					list_add(new_chanconf, new_channel(name, source));
+					num_channels++;
+				} else {
+					add_channel_source(chan, source);
+				}
+				FREE(org);
+			} else {
+report_error:
+				if (strlen(line) > 2 && line[0] != '#') {
+					LOGf("CCONF: Invalid config line: %s\n", line);
+				}
+			}
+			if (time(NULL) - curtime > CONFIG_LOAD_TIMEOUT) {
+				LOGf("CCONF: Read timeout after %d lines on %s\n", num_channels, line);
+				break;
+			}
+		}
+		regfree(&re);
+		shutdown_fd(&fd);
+		/* Save current chanconf */
+		old_chanconf = chanconf;
+		/* Switch chanconf */
+		chanconf = new_chanconf;
+		/* Rewrite restreamer channels */
+		LNODE *lc, *lr, *lctmp, *lrtmp;
+		CHANNEL *chan;
+		list_lock(restreamer);	// Unlocked after second list_for_each(restreamer)
+
+		list_lock(chanconf);
+		list_for_each(chanconf, lc, lctmp) {
+			chan = lc->data;
+			list_for_each(restreamer, lr, lrtmp) {
+				if (strcmp(chan->name, ((RESTREAMER *)lr->data)->name)==0) {
+					RESTREAMER *restr = lr->data;
+					/* Mark the restreamer as valid */
+					restr->cookie = cookie;
+					/* Check if current source exists in new channel configuration */
+					int i, 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 */
+						set_channel_source(chan, src_found);
+						restr->channel = chan;
+					} else {
+						/* New configuration *DO NOT* contain existing source. Force reconnect */
+						LOGf("RESTR: 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! */
+						set_channel_source(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(chanconf);
+
+		/* Kill restreamers that serve channels that no longer exist */
+		list_for_each(restreamer, lr, lrtmp) {
+			RESTREAMER *r = lr->data;
+			/* This restreamer should no longer serve clients */
+			if (r->cookie != cookie) {
+				LOGf("RESTR: Channel removed | Channel: %s Source: %s\n", r->channel->name, r->channel->source);
+				/* Replace channel reference with real object and instruct free_restreamer to free it */
+				r->channel = new_channel(r->channel->name, r->channel->source);
+				r->freechannel = 1;
+				r->dienow = 1;
+			}
+		}
+		list_unlock(restreamer);
+
+		/* Free old_chanconf */
+		list_free(&old_chanconf, (void (*)(void *))free_channel, NULL);
+	} else {
+		num_channels = -1;
+	}
+	pthread_mutex_unlock(&channels_lock);
+	return num_channels;
+}
+
+int load_networks(CONFIG *config) {
+	char line[1024];
+	regex_t re;
+	regmatch_t res[8];
+	int fd;
+	int num_networks = 0;
+
+	if (pthread_mutex_trylock(&networks_lock) != 0)
+		return -1;
+
+	fd = open(config->networks_file, O_RDONLY);
+
+	if (fd != -1) {
+		regcomp(&re,"^([0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3})/([0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3})\t*([CFNSA]*)", REG_EXTENDED);
+		time_t curtime = time(NULL);
+		LIST *new_netconf = list_new("netconf");
+		while (fdgetline(fd,line,sizeof(line))>0){
+			if (regexec(&re,line,4,res,0)==0){
+				chomp(line);
+				char *_net, *_mask, *_flags;
+				_net  = line+res[1].rm_so; line[res[1].rm_eo]=0;
+				_mask = line+res[2].rm_so; line[res[2].rm_eo]=0;
+				_flags= line+res[3].rm_so; line[res[3].rm_eo]=0;
+
+				uint32_t net, mask;
+				inet_pton(AF_INET, _net, &net);
+				inet_pton(AF_INET,_mask, &mask);
+				net = net & mask;
+
+				acl_t acl;
+				acl.reconf = strchr(_flags,'F') != NULL;
+				acl.stats  = strchr(_flags,'S') != NULL;
+				acl.access = strchr(_flags,'A') != NULL; // bg network?
+
+				list_add(new_netconf, new_network(net, mask, acl));
+				num_networks++;
+			} else {
+				if (strlen(line) > 2 && line[0] != '#') {
+					LOGf("NCONF: Invalid config line: %s\n", line);
+				}
+			}
+			if (time(NULL) - curtime > CONFIG_LOAD_TIMEOUT) {
+				LOGf("NCONF: Read timeout after %d lines on %s\n", num_networks, line);
+				break;
+			}
+		}
+		regfree(&re);
+		shutdown_fd(&fd);
+		/* Save current netconf */
+		LIST *old_netconf = netconf;
+		/* Switch chanconf */
+		netconf = new_netconf;
+		/* Free old_netconf */
+		list_free(&old_netconf, (void (*)(void *))free_network, NULL);
+	} else {
+		num_networks = -1;
+	}
+	pthread_mutex_unlock(&networks_lock);
+	return num_networks;
+}
+
+CONFIG *config_alloc(void) {
+	CONFIG *c = calloc(1, sizeof(CONFIG));
+	c->server_port    = 8080;
+	return c;
+}
+
+int config_redirect_enabled(CONFIG *conf, int clientsock, char *path) {
+	char *url;
+	if (!conf->redirect_url)
+		return 0;
+	asprintf(&url, "%s%s", conf->redirect_url, path);
+	send_302_redirect(clientsock, url);
+	free(url);
+	return 1;
+}
+
+void config_free(CONFIG **pconf) {
+	CONFIG *conf = *pconf;
+	if (conf) {
+		if (conf->pidfile)
+			unlink(conf->pidfile);
+		FREE(conf->host_ptr);
+		FREE(conf->logident);
+		FREE(conf->redirect_url);
+		FREE(*pconf);
+	}
+}

conf.h

+/* tsiproxy server configuration */
+#ifndef CONF_H
+# define CONF_H
+
+#include "data.h"
+
+typedef struct {
+	unsigned int			server_port; /* The port that iptvd will bind to */
+	int						server_socket;
+	struct sockaddr_in		server_name;
+	struct hostent			*host_ptr;
+
+	char					*pidfile;
+
+	char					*ident;
+	char					*logident;
+
+	char					*bind_to;			/* The address that ipdv will bind to */
+
+	char					*channels_file;		/* File in channels format (used for debugging) */
+	char					*networks_file;		/* File in networks format (used for debugging) */
+
+	char					*redirect_url;		/* Redirect all requests to this server */
+
+	int						disable_burst;		/* burst mpeg buffer to clients */
+	int						ts_sync;			/* ts proxy syncronises first 7 packets */
+} CONFIG;
+
+int load_channels(CONFIG *config);
+int load_networks(CONFIG *config);
+
+CONFIG *	config_alloc	();
+void		config_free		(CONFIG **conf);
+
+int			config_redirect_enabled(CONFIG *conf, int clientsock, char *path);
+
+#endif

config.channels

+# Format of this file
+#
+#access_path		source_address
+#
+# Access path is where that stream is accessible via:
+#
+#  http://$TSIPROXY_HOST:$TSIPROXY_PORT/$access_path
+#
+# Source_address can be:
+#
+#  UDP input via unicast or multicast UDP:
+#    Example: udp://237.151.0.1:5000/
+#
+#  HTTP input via URL:
+#    Example: http://10.0.1.151:9090/channels/1.mpg
+#    Example: http://source.example.com:8080/something/2.mpg
+
+channels/1.mpg		udp://237.151.0.1:5000/
+channels/2.mpg		http://10.0.1.151:9090/channels/test.mpg
+channels/3.mpg		http://isp4.iptv.bg:8080/channels/input.mpg

config.networks

+# Format of this file:
+#network/netmask		FLAGS
+#
+# Flags:
+#   A - access
+#   F - allow reconf
+#   S - allow access to stats
+#
+# Setting F or S assumes that A is also se
+#
+
+# The following address are allowed to access server config commands and stats
+10.0.1.0/255.255.255.0			AFS
+10.0.2.128/255.255.255.128		AFS
+127.0.0.0/255.0.0.0				AFS
+
+# The following addresses can "watch" the server streams
+12.34.56.78/255.255.255.255		A
+
+# The whole IPv4 internet is allowed
+0.0.0.0/128.0.0.0				A
+128.0.0.0/128.0.0.0				A

data.c

+/* tsiproxy data functions */
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+
+#include <fcntl.h>
+#include <errno.h>
+#include <regex.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "conf.h"
+#include "data.h"
+
+extern int clean_on_exit;
+extern LIST *clients;
+extern STATS allstats;
+extern CONFIG *config;
+
+channel_source get_sproto(char *url) {
+	return strncmp(url, "http", 4)==0 ? tcp_sock : udp_sock;
+}
+
+CHANSRC *init_chansrc(char *url) {
+	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 free_chansrc(CHANSRC *url) {
+	if (url) {
+		FREE(url->proto);
+		FREE(url->host);
+		FREE(url->path);
+		FREE(url);
+	}
+};
+
+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;
+}
+
+void add_channel_source(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 next_channel_source(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 set_channel_source(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 * new_channel(char *name, char *source) {
+	CHANNEL *c = calloc(1, sizeof(CHANNEL));
+	c->name = strdup(name);
+	add_channel_source(c, source);
+	return c;
+}
+
+void free_channel(CHANNEL *c) {
+	int i;
+	for (i=c->num_src-1; i>=0; i--) {
+		FREE(c->sources[i]);
+	}
+	FREE(c->name);
+	c->source = NULL;
+	FREE(c);
+}
+
+int channel_search(LIST *channels_list, char *name, CHANNEL **found_channel) {
+	int found = 0;
+	LNODE *l, *tmp;
+	list_for_each(channels_list, l, tmp) {
+		CHANNEL *c = l->data;
+		if (strcmp(c->name, name) == 0) {
+			*found_channel = c;
+			found = 1;
+			break;
+		}
+	}
+	return found;
+}
+
+
+NETWORK * new_network(uint32_t net, uint32_t mask, acl_t acl) {
+	NETWORK *n = calloc(1, sizeof(NETWORK));
+	n->net  = net;
+	n->mask = mask;
+	n->acl  = acl;
+	return n;
+}
+
+void free_network(NETWORK *n) {
+	FREE(n);
+}
+
+int acl_search(LIST *acl_list, uint32_t search_ip, acl_t *found_acl) {
+	int found = 0;
+	LNODE *l, *tmp;
+	list_lock(acl_list);
+	list_for_each(acl_list, l, tmp) {
+		NETWORK *n = l->data;
+		if ((search_ip & n->mask) == n->net) {
+			*found_acl = n->acl;
+			found = 1;
+			break;
+		}
+	}
+	list_unlock(acl_list);
+	return found;
+}
+
+RESTREAMER * new_restreamer(const char *name, CHANNEL *channel) {
+	RESTREAMER *r = calloc(1, sizeof(RESTREAMER));
+	r->started = time(NULL);
+	r->name = strdup(name);
+	r->sock = -1;
+	r->queue = queue_new();
+	r->clients = list_new("r->clients");
+	r->channel = channel;
+	return r;
+}
+
+void free_restreamer(RESTREAMER *r) {
+	if (r->sock > -1)
+		shutdown_fd(&(r->sock));
+	if (r->freechannel)
+		free_channel(r->channel);
+	queue_free(&r->queue);
+	list_free(&r->clients, (void (*)(void *))stop_client_shutdown, NULL);
+	FREE(r->name);
+	FREE(r);
+}
+
+int restreamer_stop(LIST *proxys, char *channel) {
+	int matched = 0;
+	LNODE *l, *tmp;
+	list_lock(proxys);
+	list_for_each(proxys, l, tmp) {
+		RESTREAMER *r = l->data;
+		int doit = !channel || strcmp(channel, r->channel->name) == 0;
+		if (doit) {
+			matched++;
+			r->dienow = 1;
+		}
+	}
+	list_unlock(proxys);
+	return matched;
+}
+
+int restreamer_reconnect(LIST *proxys, char *channel) {
+	int matched = 0;
+	LNODE *l, *tmp;
+	list_lock(proxys);
+	list_for_each(proxys, l, tmp) {
+		RESTREAMER *r = l->data;
+		int doit = !channel || strcmp(channel, r->channel->name) == 0;
+		if (doit) {
+			matched++;
+			r->reconnect = 1;
+		}
+	}
+	list_unlock(proxys);
+	return matched;
+}
+
+void restreamer_stop_all(LIST *proxys) {
+	if (restreamer_stop(proxys, NULL)) {
+		int max_loops = 30; // 3 seconds
+		while (proxys->items > 0 && max_loops-- > 0)
+			usleep(100000);
+		if (proxys->items)
+			clean_on_exit = 0;
+	}
+}
+
+
+/* CLIENT FUNCTIONS */
+
+int is_child_server(char *user_agent, unsigned int client_id) {
+	if (!user_agent)
+		return 0;
+	return client_id == 0 && strcasestr(user_agent,"iptvd") == user_agent;
+}
+
+int is_ext(char *path, char *ext) {
+	return strncmp(ext, (path+strlen(path)-strlen(ext)), strlen(ext)) == 0;
+}
+
+CLIENT * new_client(int fd, time_t expire, char *chan, char *IP, char *agent, unsigned long clientid, acl_t acl, uint16_t client_port, int smart_client) {
+	CLIENT *nc = calloc(sizeof(CLIENT),1);
+
+	nc->fno      = fd;
+	nc->start    = time(NULL);
+	nc->ts       = nc->start;
+	nc->expire   = expire;
+	nc->chan	 = strdup(chan);
+	nc->IP       = strdup(IP);
+	inet_pton(AF_INET, IP, &(nc->ip));
+	nc->acl      = acl;
+	nc->clientid = clientid;
+	nc->client_port = client_port;
+	if (agent) {
+		nc->agent = strdup(agent);
+		nc->is_child_server = is_child_server(agent, clientid);
+	}
+	if (nc->is_child_server || smart_client)
+		nc->smart_client = 1;
+	list_add(clients, nc);
+	set_sock_nonblock(fd);
+	allstats.clients_all++;
+	return nc;
+}
+
+static void __client_log_connect(CLIENT *c) {
+	c->logged = 1;
+	if (c->client_port == 0) {
+		LOGf("NEW  : fd: %i Valid: %li | Client: %lu IP: %s Channel: %s Agent: %s\n",
+		      c->fno,
+		     (c->expire < 0 ? c->expire : -(c->start - c->expire)),
+		      c->clientid, c->IP, c->chan, c->agent);
+	} else {
+		LOGf("NEW  : fd: %i Valid: %li Port: %u | Client: %lu IP: %s Channel: %s Agent: %s\n",
+		      c->fno,
+		     (c->expire < 0 ? c->expire : -(c->start - c->expire)),
+		      c->client_port,
+		      c->clientid, c->IP, c->chan, c->agent);
+	}
+	allstats.clients_current++;
+	if (c->is_child_server)
+		allstats.child_servers++;
+	else
+		allstats.clients++;
+}
+
+void client_log_connect(CLIENT *c) {
+	if (c->logged)
+		return;
+	__client_log_connect(c);
+}
+
+void client_log_disconnect(CLIENT *c, char mark) {
+	if (!c->logged)
+		return;
+	allstats.clients_current--;
+	allstats.clients_gone++;
+	LOGf("STOP%c: fd: %i Bytes: %llu Seconds: %li | Client: %lu IP: %s Channel: %s Agent: %s\n",
+	     mark, c->fno, c->traffic_out, time(NULL)-c->start,
+	     c->clientid, c->IP, c->chan, c->agent);
+	time_t now = time(NULL);
+	if (now - c->start > NO_LOG_END_SECONDS) {
+		if (c->traffic_out > 0) {
+			char date[256];
+			struct tm tmres;
+			strftime(date,sizeof(date),"%d/%b/%Y:%H:%M:%S %z",localtime_r(&c->start, &tmres));
+			LOGf("LOG{%s %li - [%s] \"%s %lu %s\" 200 %llu \"%lu\" \"%s\"}\n",c->IP,now-c->start,date,
+				"-", c->clientid, c->chan, c->traffic_out, c->start, c->agent);
+		}
+	}
+}
+
+void free_client(CLIENT *c) {
+	FREE(c->chan);
+	FREE(c->IP);
+	FREE(c->agent);
+	FREE(c);
+}
+
+void stop_client(CLIENT *c, int socket_shutdown, char mark) {
+	if (!c || c->stopping)
+		return;
+	c->stopping = 1;
+	int client_socket = c->fno;
+	client_log_disconnect(c, mark);
+	list_del_entry(clients, c);
+	free_client(c);
+	if (socket_shutdown)
+		shutdown_fd(&client_socket);
+}
+
+void stop_client_noshutdown(CLIENT *c) {
+	stop_client(c, 0, ' ');
+}
+
+void stop_client_shutdown(CLIENT *c) {
+	stop_client(c, 1, ' ');
+}
+
+void stop_client_shutdown_mark(CLIENT *c, char mark) {
+	stop_client(c, 1, mark);
+}
+
+int control_client_stop(long clientid) {
+	int found = 0;
+	LNODE *l, *tmp;
+	list_lock(clients);
+	list_for_each(clients, l, tmp) {
+		CLIENT *c = l->data;
+		if (clientid == -1 || clientid == (long)c->clientid) {
+			c->dienow = 1;
+			found++;
+		}
+	}
+	list_unlock(clients);
+	return found;
+}
+
+int control_client_extend(unsigned long clientid, char *chan, time_t expire) {
+	int found = 0;
+	LNODE *l, *tmp;
+	list_lock(clients);
+	list_for_each(clients, l, tmp) {
+		CLIENT *c = l->data;
+		if (c->clientid == clientid && strcmp(chan, c->chan)==0) {
+			c->expire = expire;
+			found++;
+		}
+	}
+	list_unlock(clients);
+	return found;
+}
+
+int netmsg_send(long client_id, char *channel, char *netmsg) {
+	int found = 0;
+	LNODE *l, *tmp;
+	list_lock(clients);
+	list_for_each(clients, l, tmp) {
+		CLIENT *c = l->data;
+		int nsend =	(client_id == -1          && !channel) ||                                     // Send to all clients
+					(client_id == -1          && channel && strcmp(channel, c->chan)==0) ||       // Send to all clients on the channel X
+					(client_id == (long)c->clientid && !channel) ||                               // Send to client X
+					(client_id == (long)c->clientid && channel && strcmp(channel, c->chan)==0);   // Send to client X on the channel X
+		if (nsend) {
+			strncpy(c->netmsg, netmsg, sizeof(c->netmsg)-1);
+			c->netmsg[sizeof(c->netmsg)-1] = 0;
+			found++;
+		}
+	}
+	list_unlock(clients);
+	return found;
+}
+
+extern char TS_NULL_FRAME[FRAME_PACKET_SIZE];
+
+char *get_netmsg_packet(const char *msg) {
+	if (!strlen(msg) || strlen(msg) > 60)
+		return NULL;
+	char *ret = (char *)calloc(1, FRAME_PACKET_SIZE);
+	memcpy(ret, TS_NULL_FRAME, FRAME_PACKET_SIZE);
+	int i;
+	for (i=0; i<7; i++) {
+		int ofs = i * 188;
+		ret[ofs + 60] = 0x78;
+		ret[ofs + 61] = 0x55;
+		ret[ofs + 62] = 0x58;
+		ret[ofs + 63] = 0x78;
+		strcpy(ret + ofs + 64, msg);
+	}
+	return ret;
+}
+
+int is_netmsg_packet(const unsigned char *buf, int bufsize) {
+	if (bufsize < 64 || bufsize > FRAME_PACKET_SIZE)
+		return 0;
+	if (buf[1] != 0x1f && buf[2] != 0xff) // Look only at NULL packets
+		return 0;
+	// xUXx
+	if (buf[60] == 0x78 && buf[61] == 0x55 && buf[62] == 0x58 && buf[63] == 0x78)
+		return 1;
+	return 0;
+}

data.h

+/* tsiproxy data functions */
+#ifndef DATA_H
+# define DATA_H
+
+#include <netdb.h> // for uint32_t
+#include <sys/resource.h> // for rlim_t
+#include <sys/utsname.h> // for utsdata
+
+#include "libfuncs/queue.h"
+#include "libfuncs/list.h"
+
+typedef enum { udp_sock, tcp_sock } channel_source;
+
+typedef struct {
+	int stats :1,		/* S - STATS  | allow access to stats and info server pages /used by data collection tools/ */
+	    reconf:1,		/* F - RECONF | allow server reconfiguration request /used for sys admins/ (ex: http://XXX/{chanconf,netconf}) */
+		access:1;		/* A - ACCESS | Allow access from this network (used for bg networks) */
+} acl_t;
+
+typedef struct {
+	uint32_t net;
+	uint32_t mask;
+	acl_t acl;
+} NETWORK;
+
+typedef struct {
+	rlim_t rlim_cur;   /* Soft limit */
+	rlim_t rlim_max;   /* Hard limit (ceiling for rlim_cur) */
+} RLIMIT;
+
+typedef struct  {
+	int	  fno;
+	char  *chan;
+	char  *IP;
+	char  *agent;
+	unsigned long clientid;	//from the web
+	time_t expire;			//end of the validity of the signature
+	time_t start;
+	time_t ts;				//timestamp for staled connections
+	unsigned pos;			
+	unsigned long long traffic_out; // How much traffic has been send to this client
+	uint32_t ip;			// Client ip
+	acl_t acl;				//ACL for the IP from netconf
+	uint32_t start_pts;		//client started on this global pts 
+	uint16_t client_port;	//the udp port that client is listening to
+	int 
+	    smart_client:1,		// The client has it's own reconnect logic and will be disconnected on channel reconnect (child servers)
+	    is_child_server:1,	// The client is really a child server (have iptvd user agent)
+	    headers_sent:1,     // headers have been sent
+	    logged:1,			//connection is logged
+	    data_send:1,		//The client has received at least one data packets
+	    dienow:1,			//When this is set the client must be disconnected immedietly
+	    stopping:1;			//The client is being stopped. This flag prevents double client_stop entry
+	char netmsg[48];
+} CLIENT;
+
+typedef struct {
+	channel_source sproto;
+	char *proto;
+	char *host;
+	char *path;
+	unsigned int port;
+} CHANSRC;
+
+#define MAX_CHANNEL_SOURCES 8
+
+typedef struct {
+	char *name;
+	char *source; /* Full source url */
+	char *sources[MAX_CHANNEL_SOURCES];
+	uint8_t num_src;
+	uint8_t curr_src;
+} CHANNEL;
+
+typedef struct {
+	char  *name;
+	QUEUE *queue;			/* Waiting clients */
+	LIST *clients;			/* List of clients connected to this restreamer */
+	CHANNEL *channel;
+	int sock;
+	struct sockaddr_in sockname;
+	int reconnect;			/* Set to 1 to force proxy reconnect */
+	int connected;			/* It's set to 1 when proxy is connected and serving clients */
+	int dienow;				/* Stop serving clients and exit now */
+	int freechannel;		/* Free channel data on object free (this is used in chanconf) */
+	time_t started;
+	int cookie;				/* Used in chanconf to determine if the restreamer is alrady checked */
+	unsigned long connects;	/* How many times the proxy has connected successfully to parent */
+	unsigned long served;	/* How much clients has been served by this proxy */
+	unsigned long long traffic_in;
+	unsigned long long traffic_out;
+} RESTREAMER;
+
+typedef struct {
+	unsigned long clients;				/* Number of clients requested channel and stay connected at least 3 seconds */
+	unsigned long child_servers;		/* Number of child servers */
+	unsigned long clients_all;			/* Number of clients + child servers + clients not watched at least 3 seconds */
+	unsigned long clients_current;		/* Number of current clients */
+	unsigned long clients_gone;			/* Number of stoped clients since last "readinfo" command was issued */
+	unsigned long errors;				/* Number of error videos served */
+	unsigned long long traffic_in;		/* How much traffic was downloaded from parent server */
+	unsigned long long traffic_out;		/* How much traffic was served to clients and sub restreamers */
+	time_t start_ts;					/* When the server was started */
+	struct utsname utsdata;
+} STATS;
+
+typedef struct {
+	int client;
+	int file;
+	char *msg;
+	char *content_type;
+} ERRMSG;
+
+channel_source get_sproto(char *url);
+
+CHANSRC *init_chansrc(char *url);
+void free_chansrc(CHANSRC *url);
+int is_valid_url(char *url);
+
+void add_channel_source(CHANNEL *c, char *src);
+void next_channel_source(CHANNEL *c);
+void set_channel_source(CHANNEL *c, uint8_t src_id);
+
+CHANNEL * new_channel(char *id, char *source);
+void free_channel(CHANNEL *c);
+int channel_search(LIST *channels_list, char *name, CHANNEL **found_channel);
+
+NETWORK * new_network(uint32_t net, uint32_t mask, acl_t acl);
+void free_network(NETWORK *n);
+int acl_search(LIST *acl_list, uint32_t search_ip, acl_t *found_acl);
+
+RESTREAMER * new_restreamer(const char *name, CHANNEL *channel);
+void free_restreamer(RESTREAMER *r);
+
+void	restreamer_stop_all		(LIST *proxys);
+int		restreamer_stop			(LIST *proxys, char *channel);
+int		restreamer_reconnect	(LIST *proxys, char *channel);
+
+int is_ext(char *path, char *ext);
+
+CLIENT * new_client(int fd, time_t expire, char *chan, char *IP, char *agent, unsigned long clientid, acl_t acl, uint16_t client_port, int smart_client);
+void free_client(CLIENT *c);
+
+void stop_client(CLIENT *c, int socket_shutdown, char mark);
+
+void stop_client_noshutdown(CLIENT *c);
+void stop_client_shutdown_mark(CLIENT *c, char mark);
+void stop_client_shutdown(CLIENT *c);
+
+void client_log_connect(CLIENT *c);
+
+int control_client_stop(long clientid);
+int control_client_extend(unsigned long clientid, char *chan, time_t expire);
+
+int netmsg_send(long client_id, char *channel, char *netmsg);
+
+char *get_netmsg_packet(const char *msg);
+int is_netmsg_packet(const unsigned char *buf, int bufsize);
+
+#endif

defines.h

+#ifndef DEFINES_H
+# define DEFINES_H
+
+#undef DEBUG
+//#define DEBUG 1
+
+#define VERSION_ID "1.00"
+#define BUILD_ID GIT_BUILD_ID
+
+#define SERVER_SIGNATURE "tsiproxy"
+#define COPYRIGHT "Copyright (c) 2020 Georgi Chorbadzhiiyski <georgi@unixsol.net>"
+
+/*
+  This define is used to compensate for servers clock drift.
+  It allows to watch URLs which otherwise will be active after
+  upto URL_START_TOLERANCE seconds in the future. If the server
+  clock is more than URL_START_TOLERANCE late or the URL is
+  generated too far in the future, the client will get
+  not-active video.
+*/
+#define URL_START_TOLERANCE 180
+
+/*
+  This define is used to set after how many seconds with no
+  traffic the client will be disconnected.
+*/
+#define NO_TRAFFIC_SECONDS 30
+
+/*
+  How many seconds after start of connection NEW message will be logged.
+  The check is > NO_LOG_START_SECONDS
+*/
+#define NO_LOG_START_SECONDS 3
+
+/*
+  How many seconds minimum should LOG{} be emitted.
+  The check is > NO_LOG_END_SECONDS
+*/
+#define NO_LOG_END_SECONDS 3
+
+/* How much miliseconds to wait for connection to be established with config server */
+#define CONFIG_CONNECT_TIMEOUT 10*1000
+
+#define CONFIG_LOAD_TIMEOUT 60
+
+
+
+
+/* How much to wait for connection to be established with channel source (miliseconds) */
+#define PROXY_CONNECT_TIMEOUT 1000
+
+/*
+	The total time it takes to return no-signal is equal to
+		PROXY_CONNECT_RETRIES * PROXY_RETRY_TIMEOUT
+*/
+
+/* How many times to try to connect to channel */
+#define PROXY_CONNECT_RETRIES 5
+
+/* Seconds to sleep between retries (miliseconds) */
+#define PROXY_RETRY_TIMEOUT 1000
+
+#define FRAME_PACKET_SIZE 1316
+
+#define NEW_DURATION_WEIGHT 0.5
+#define TIME_ADJUSTMENT_FACTOR 0.8
+#define MAX_PLAYOUT_BUFFER_DURATION 0.1 // (seconds)
+#define PCR_PERIOD_VARIATION_RATIO 0.5
+
+#define unused(x) (void)x
+
+#define BUF 1536
+
+#endif

libfuncs

+Subproject commit 8fcac8dd4db1e1e382f072a722ef360b8d8b8251

proxy_common.c

+/* tsiproxy stream proxy */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <netdb.h>
+#include <pthread.h>
+#include <regex.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/utsname.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/utsname.h>
+#include <sys/resource.h>
+
+#include <fcntl.h>
+#include <errno.h>
+#include <poll.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "data.h"
+#include "conf.h"
+#include "proxy_common.h"
+
+extern char *server_sig;
+extern char *server_ver;
+
+extern regex_t http_response;
+
+extern LIST *restreamer, *chanconf;
+extern STATS allstats;
+
+extern CONFIG *config;
+extern int keep_running;
+
+extern void * proxy_ts_stream(void *channel_id);
+
+void process_client(int clientsock, CLIENT *client) {
+	list_lock(chanconf);
+
+	LNODE *l, *tmp;
+	CHANNEL *chan = NULL;
+	list_for_each(chanconf, l, tmp) {
+		if (strcmp(client->chan, ((CHANNEL *)l->data)->name)==0) {
+			chan = l->data;
+			break;
+		}
+	}
+
+	/* Check if requested channel exists? */
+	if (!chan) {
+		LOGf("ERROR: No such channel | IP: %s Path: /%s Agent: %s\n", client->IP, client->chan, client->agent);
+		send_404_not_found(client->fno);
+		stop_client_shutdown(client);
+		list_unlock(chanconf);
+		return;
+	}
+
+	/* Is there an active restreamer for the requested channel */
+	list_lock(restreamer);
+	RESTREAMER *r = NULL;
+	list_for_each(restreamer, l, tmp) {
+		if (strcmp(client->chan, ((RESTREAMER *)l->data)->name)==0) {
+			r = l->data;
+			break;
+		}
+	}
+	if (r) {
+		/* Active restreamer found. Add client to it's queue. Do it here while restreamer is locked otherwise there is a race! */
+		queue_add(r->queue, client);
+		list_unlock(restreamer);
+		list_unlock(chanconf);
+		return;
+	}
+	list_unlock(restreamer);
+
+	/* No active restreamer found, start new one */
+	RESTREAMER *nr = new_restreamer(client->chan, chan);
+	queue_add(nr->queue, client);
+	list_add(restreamer, nr);
+	list_unlock(chanconf);
+
+	pthread_t newthread;
+	LOGf("SPAWN: Restreamer | Channel: %s Source: %s client_fd: %i\n", chan->name, chan->source, clientsock);
+	if (pthread_create(&newthread, NULL, &proxy_ts_stream, nr)) {
+		log_perror("Error TS proxy creating thread.", errno);
+		exit(1);
+	}
+	pthread_detach(newthread);
+}
+
+static void remove_clients(RESTREAMER *r, const char *text, int error_code) {
+	CLIENT *c;
+	while ((c=queue_get_nowait(r->queue))) {
+		LOGf("NOSIG: fd: %i srv_fd: %i {Op:%s} {Err:%d} | Client: %lu IP: %s Channel: %s Agent: %s\n",
+		     c->fno, r->sock, text, error_code,
+		     c->clientid, c->IP, c->chan, c->agent);
+		// Headers are already sent or the client is using udp, just yank it
+		if (c->headers_sent || c->client_port) {
+			stop_client_shutdown(c);
+		} else {
+			char *code = "504 Gateway Timeout";
+			char *msg = "no-signal";
+			if (error_code >= 300) {
+				send_http_response(c->fno, code);
+				send_header_textplain(c->fno);
+				fdputsf(c->fno, "X-ErrorCode: %d\nX-Error: %s\n\n%s\n", error_code, msg, msg);
+			} else {
+				send_http_error(c->fno, code, msg);
+			}
+			stop_client_shutdown(c);
+		}
+	}
+}
+
+static void remove_smart_clients(RESTREAMER *r) {
+	CLIENT *c;
+	LNODE *l, *tmp;
+	list_for_each(r->clients, l, tmp) {
+		c = l->data;
+		if (!c->smart_client)
+			continue;
+		list_del(r->clients, &l);
+		if (c->headers_sent || c->client_port) {
+			stop_client_shutdown(c);
+		} else {
+			send_http_error(c->fno, "504 Gateway Timeout", "no-signal");
+			stop_client_shutdown(c);
+		}
+	}
+}
+
+void proxy_close(RESTREAMER *r, int error_code) {
+	LOGf("CLOSE: Restreamer | Channel: %s Source: %s IP: %s srv_fd: %i Conn: %ld Serv: %ld TrafIn: %lld TrafOut: %lld\n",
+		r->channel->name,
+		r->channel->source,
+		inet_ntoa(r->sockname.sin_addr),
+		r->sock,
+		r->connects,
+		r->served,
+		r->traffic_in,
+		r->traffic_out);
+	// If there are no clients left, no "Timeout" messages will be logged
+	remove_clients(r, "Timeout", error_code);
+	list_del_entry(restreamer, r);
+	free_restreamer(r);
+}
+
+void proxy_begin_reconnect(RESTREAMER *r) {
+	shutdown_fd(&(r->sock));
+	next_channel_source(r->channel);
+	remove_smart_clients(r);
+}
+
+#define FATAL_ERROR(__no_signal_msg) do \
+{ \
+	remove_clients(r, __no_signal_msg, *http_code); \
+	free_chansrc(src); \
+	return -1; \
+} while (0)
+
+/*
+	On the last try, send no-signal to clients and exit
+	otherwise wait a little bit before trying again
+*/
+#define DO_RECONNECT do \
+{ \
+	if (retries == 0) { \
+		FATAL_ERROR("Connect"); \
+	} else { \
+		free_chansrc(src); \
+		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); \
+		return 1; \
+	} \
+} while(0)
+
+/*
+	Returns:
+		-1 = exit thread
+		 1 = retry
+		 0 = connected ok
+*/
+int connect_source(RESTREAMER *r, int retries, int readbuflen, int *http_code) {
+	CHANSRC *src = init_chansrc(r->channel->source);
+	if (!src) {
+		LOGf("ERROR: Can't parse channel source | Channel: %s Source: %s\n", r->channel->name, r->channel->source);
+		FATAL_ERROR("cant-parse-channel-source");
+	}
+	r->connected = 0;
+	r->reconnect = 0;
+
+	int active = 1;
+	int dret = async_resolve_host(src->host, src->port, &(r->sockname), DNS_RESOLVER_TIMEOUT, &active);
+	if (dret != 0) {
+		if (dret == 1)
+			LOGf("ERROR: Can't resolve host | Channel: %s Source: %s Host: %s\n", r->channel->name, r->channel->source, src->host);
+		if (dret == 2)
+			LOGf("ERROR: DNS timeout | Channel: %s Source: %s Host: %s\n", r->channel->name, r->channel->source, src->host);
+		DO_RECONNECT;
+	}
+
+	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("connect_source(): Could not create SOCK_STREAM socket.", errno);
+			FATAL_ERROR("cant-create-sock-stream-socket");
+		}
+		LOGf("RCONN: Connecting | Channel: %s Source: %s IP: %s src_fd: %i TriesLeft: %i\n",
+			r->channel->name,
+			r->channel->source,
+			inet_ntoa(r->sockname.sin_addr),
+			r->sock,
+			retries
+		);
+		if (do_connect(r->sock, (struct sockaddr *)&(r->sockname), sizeof(r->sockname), PROXY_CONNECT_TIMEOUT) < 0) {
+			LOGf("ERROR: 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\nUser-Agent: %s %s (%s)\n\n",
+		         src->path, src->host, src->port, server_sig, server_ver, config->ident);
+		buf[sizeof(buf)-1] = 0;
+		allstats.traffic_out += safe_write(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) {
+				if (regexec(&http_response,buf,3,res,0) != REG_NOMATCH) {
+					char codestr[4];
+					if ((unsigned int)res[1].rm_eo-res[1].rm_so < (unsigned)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);
+					}
+				}
+			}
+			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("ERROR: Get no-signal for %s from %s on srv_fd: %i\n", r->channel->name, r->channel->source, r->sock);
+			FATAL_ERROR("no-signal");
+		}
+		if (*http_code > 300) { // Unhandled or error codes, exit
+			LOGf("ERROR: 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("unhandled-http-code");
+		}
+		// connected ok, continue
+	} else {
+		if (!IN_MULTICAST(ntohl(r->sockname.sin_addr.s_addr))) {
+			LOGf("ERROR: %s is not multicast address\n", r->channel->source);
+			FATAL_ERROR("source-is-not-multicast-address");
+		}
+		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("cant-create-sock-dgram-socket");
+		}
+		LOGf("RCONN: 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->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("ERROR: Failed to add IP membership on %s srv_fd: %i\n", r->channel->source, r->sock);
+			FATAL_ERROR("failed-to-add-membership");
+		}
+		// 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->sockname.sin_addr;
+		receiving_from.sin_port   = htons(src->port);
+		if (bind(r->sock, (struct sockaddr *) &receiving_from, sizeof(receiving_from)) < 0) {
+			LOGf("ERROR: Failed to bind to %s srv_fd: %i\n", r->channel->source, r->sock);
+			FATAL_ERROR("failed-to-bind");
+		}
+	}
+
+	if (setsockopt(r->sock, SOL_SOCKET, SO_RCVBUF, (const char *)&readbuflen, sizeof(readbuflen)) < 0)
+		log_perror("play(): setsockopt(SO_RCVBUF)", errno);
+
+	r->connects++;
+	r->connected = 1;
+
+	free_chansrc(src);
+	return 0;
+}
+
+
+int connect_udp_client(CLIENT *c) {
+	int newsock = -1;
+	int client_socket = c->fno;
+	struct sockaddr_in sockname;
+	struct in_addr client_ip;
+	inet_aton(c->IP, &client_ip);
+	sockname.sin_family = AF_INET;
+	sockname.sin_port = htons(c->client_port);
+	sockname.sin_addr = client_ip;
+	// Create new udp socket to the client
+	newsock = socket(PF_INET, SOCK_DGRAM, 0);
+	if (newsock < 0) {
+		log_perror("process_new_clients(): Could not create SOCK_DGRAM socket.", errno);
+		stop_client_noshutdown(c); // ??
+		return -1;
+	}
+	// Connect to the client
+	// Connect on udp socket never returns an error
+	// The error will be returned on the first send/write
+	do_connect(newsock, (struct sockaddr *)&sockname, sizeof(sockname), 1000);
+	// Return pls playlist (vlc supports it)
+	send_200_ok(c->fno);
+	if (c->agent && strstr(c->agent,"VLC")==c->agent) { // VLC support pls playlists
+		fdputsf(c->fno, "Content-type: application/pls+xml\n\n[playlist]\nFile1=%s://@:%u\nTitle1=LiveTV\n", "udp", c->client_port);
+		// sleep a little bit so VLC can start listening to the udp port
+		shutdown_fd(&client_socket);
+		usleep(500000);
+	} else {
+		fdputsf(c->fno, "Content-type: text/plain\n\n%s://@:%u\n", "udp", c->client_port);
+		shutdown_fd(&client_socket);
+	}
+	// Change client socket to the new udp socket
+	c->fno = newsock;
+	return newsock;
+}
+
+void process_new_clients(RESTREAMER *r, int bufsz, uint32_t start_pts, unsigned int pos) {
+	CLIENT *c;
+	while ((c=queue_get_nowait(r->queue))) {
+		if (c->clientid) {
+			int client_exists = 0;
+			{
+				LNODE *l, *tmp;
+				CLIENT *n = NULL;
+				list_lock(r->clients);
+				list_for_each_reverse(r->clients, l, tmp) {
+					if (c->clientid == ((CLIENT *)l->data)->clientid) {
+						n = l->data;
+						break;
+					}
+				}
+				// if the same client is already watching the channel but from different IP
+				// or the same client is already watching the channel on the same port
+				if (n && (strcmp(n->IP,c->IP)!=0 || (n->client_port && n->client_port==c->client_port)))
+					client_exists = 1;
+				list_unlock(r->clients);
+			}
+			if (client_exists) {
+				LOGf("2ND  : fd: %i | Client: %lu IP: %s Channel: %s Agent: %s\n", 
+					c->fno, c->clientid, c->IP, c->chan, c->agent);
+				send_400_bad_request(c->fno, "already-watching-the-channel");
+				stop_client_shutdown(c);
+				continue;
+			}
+		}
+		// Connect with udp to the client, closing incomming http req socket
+		if (c->client_port && connect_udp_client(c) == -1) {
+			continue;
+		}
+		if (setsockopt(c->fno, SOL_SOCKET, SO_SNDBUF, (const char *) &bufsz,sizeof(bufsz))<0)
+			log_perror("play(): setsockopt(SO_SNDBUF)", errno);
+		c->pos = pos;
+		c->start_pts = start_pts;
+		list_add(r->clients, c);
+	}
+}
+
+int shout(RESTREAMER *r, char *buf, const size_t bufsz, const size_t framelen, unsigned int pos, const char *content_type, char *header, unsigned int header_len) {
+	CLIENT *n;
+	int num_clients=0, nfds=0;
+	struct timeval tv;
+	fd_set wfds,efds,rfds;
+	time_t now = time(NULL);
+
+	if (r->clients==NULL || r->clients->items == 0)
+		return 0;
+
+	FD_ZERO(&wfds);
+	FD_ZERO(&rfds);
+	FD_ZERO(&efds);
+
+	LNODE *l, *tmp;
+	list_for_each_reverse(r->clients, l, tmp) {
+		n = l->data;
+		/* EXPR: No traffic in XX seconds. Kill the client. X seconds have passed and 0 traffic send - kill */
+		if ((now-n->ts >= NO_TRAFFIC_SECONDS) ||
+		    (n->traffic_out == 0 && now-n->start >= NO_TRAFFIC_SECONDS))
+		{
+			n->start   += NO_TRAFFIC_SECONDS;
+			stop_client_shutdown_mark(n, 'x');
+			list_del(r->clients, &l);
+			continue;
+		}
+		FD_SET(n->fno,&wfds);
+		FD_SET(n->fno,&efds);
+		FD_SET(n->fno,&rfds);
+		if (n->fno>nfds) nfds=n->fno;
+		num_clients++;
+
+		if (!n->logged) {
+			client_log_connect(n);
+			r->served++;
+		}
+	}
+	tv.tv_sec = 0;
+	tv.tv_usec= 0;
+
+	if (select(nfds+1,&rfds,&wfds,&efds,&tv)>0) {
+		list_for_each_reverse(r->clients, l, tmp) {
+			n = l->data;
+			if ((FD_ISSET(n->fno,&rfds)) || (FD_ISSET(n->fno,&efds)) || // closed connection
+				((n->expire > 0) && (now > n->expire)) || // expired session
+				n->dienow) // Forcefully stopped client
+			{
+				stop_client_shutdown(n);
+				list_del(r->clients, &l);
+				num_clients--;
+				continue;
+			}
+			// OK, send him the stream if is ready
+			if ((buf!=NULL)&&(FD_ISSET(n->fno,&wfds))){
+				// Sent headers to the client (http client)
+				if (!n->client_port && !n->headers_sent) {
+					n->headers_sent = 1;
+					send_200_ok(n->fno); // Standart http client response
+					fdputsf(n->fno, "%s", content_type);
+					if (header != NULL && header_len > 0) {
+						allstats.traffic_out += safe_write(n->fno, header, header_len);
+					}
+				}
+				int i,j;
+				// When in mpeg mode the first packet is always 1316 also the client is at current buffer position
+				if (!n->data_send && framelen == FRAME_PACKET_SIZE) {
+					i = framelen;
+					n->data_send = 1;
+					if (config->disable_burst) {
+						if (pos >= FRAME_PACKET_SIZE)
+							n->pos = pos - FRAME_PACKET_SIZE;
+						else
+							n->pos = pos;
+					}
+				}
+				if (pos > n->pos) {
+					i = pos - n->pos;
+				} else {
+					i = bufsz * framelen - n->pos;
+				}
+				// Sent it
+				j = safe_write(n->fno, buf+n->pos, i);
+				if (j >= 0) {
+					/* 0 bytes written is not an error per se, but here we threat
+					   it special, because there are buggy clients that connect and
+					   start reading 0 bytes. If we do not set n->ts these clients
+					   will be disconnected when NO_TRAFFIC_SECONDS pass */
+					if (j > 0) {
+						allstats.traffic_out += j;
+						r->traffic_out += j;
+						n->traffic_out += j;
+						n->pos += j;
+						n->ts = time(NULL);
+					}
+					if (n->pos == bufsz * framelen)
+						n->pos = 0;
+					// Send netmsg
+					if (framelen == FRAME_PACKET_SIZE && n->netmsg[0]) {
+						char *netmsg = get_netmsg_packet(n->netmsg);
+						if (netmsg) {
+							safe_write(n->fno, netmsg, FRAME_PACKET_SIZE);
+							n->netmsg[0] = 0;
+							FREE(netmsg);
+						}
+					}
+				} else {
+					stop_client_shutdown(n);
+					list_del(r->clients, &l);
+					num_clients--;
+				}
+			}
+		}
+	}
+	return num_clients;
+}
+
+int check_restreamer_state(RESTREAMER *r) {
+	if (!keep_running)
+		return 2;
+	if (r->dienow) {
+		LOGf("RESTR: Forced disconnect on srv_fd: %i | Channel: %s Source: %s\n", r->sock, r->channel->name, r->channel->source);
+		return 2;
+	}
+	if (r->reconnect) {
+		LOGf("RESTR: Forced reconnect on srv_fd: %i | Channel: %s Source: %s\n", r->sock, r->channel->name, r->channel->source);
+		return 1;
+	}
+	return 0;
+}

proxy_common.h

+/* tsiproxy stream proxy */
+#ifndef PROXY_COMMON_H
+# define PROXY_COMMON_H
+
+#include "data.h"
+
+void process_client(int clientsock, CLIENT *client);
+
+void proxy_begin_reconnect(RESTREAMER *r);
+
+void proxy_close(RESTREAMER *r, int error_code);
+
+int connect_source(RESTREAMER *r, int retries, int readbuflen, int *http_code);
+
+void process_new_clients(RESTREAMER *r, int bufsz, uint32_t start_pts, unsigned int pos);
+
+int shout(RESTREAMER *r, char *buf, const size_t bufsz, const size_t framelen, unsigned int pos, const char *content_type, char *header, unsigned int header_len);
+
+int check_restreamer_state(RESTREAMER *r);
+
+#endif

proxy_ts.c

+/* tsiproxy mpeg transport stream proxy */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <netdb.h>
+#include <pthread.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <fcntl.h>
+#include <errno.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "data.h"
+#include "conf.h"
+#include "proxy_common.h"
+
+extern LIST *restreamer;
+extern STATS allstats;
+extern CONFIG *config;
+
+extern char TS_NULL_FRAME[FRAME_PACKET_SIZE];
+extern int keep_running;
+
+#define MAX_ZERO_READS 3
+
+#define CONNECT_RETRIES 2
+
+/*         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(int proxysock, char *channel, channel_source source_proto) {
+	time_t sync_start = time(NULL);
+	unsigned int sync_packets = 0;
+	unsigned int read_bytes = 0;
+	char syncframe[188];
+
+	if (!config->ts_sync)
+		return 0;
+
+	int _timeout = TCP_READ_TIMEOUT;
+	int _retries = TCP_READ_RETRIES;
+	if (source_proto == udp_sock) {
+		_timeout = UDP_READ_TIMEOUT;
+		_retries = UDP_READ_RETRIES;
+	}
+	do {
+resync:
+		if (!keep_running)
+			return 1;
+		if (fdread_ex(proxysock, syncframe, 1, _timeout, _retries, 1) != 1) {
+			LOGf("DEBUG: mpeg_sync fdread() timeout | Channel: %s\n", channel);
+			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(proxysock, syncframe, 188-1, _timeout, _retries, 1);
+			if (rdsz != 188-1) {
+				LOGf("DEBUG: mpeg_sync fdread() timeout | Channel: %s\n", channel);
+				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
+			LOGf("DEBUG: Can't sync after %d bytes | Channel: %s\n", FRAME_PACKET_SIZE, channel);
+			return 1; // reconnect
+		}
+		if (sync_start+2 <= time(NULL)) { // Do not sync in two seconds
+			LOGf("DEBUG: Timeout while syncing (read %u bytes) | Channel: %s\n", read_bytes, channel);
+			return 1; // reconnect
+		}
+	} while (1);
+	LOGf("SYNC : TS synced after %u bytes | Channel: %s\n", read_bytes-FRAME_PACKET_SIZE, channel);
+	return 0;
+}
+
+void * proxy_ts_stream(void *self) {
+	RESTREAMER *r = self;
+	int retries = CONNECT_RETRIES;
+	unsigned int pos = 0;
+	int first_connect = 1;
+
+	signal(SIGPIPE, SIG_IGN);
+
+#define BUFFER_SIZE (FRAME_PACKET_SIZE * BUF)
+
+	char buff[BUFFER_SIZE];
+	char *buff_end = buff + BUFFER_SIZE;
+
+	int http_code = 0;
+	while (retries--) {
+		int result = connect_source(self, retries, BUFFER_SIZE, &http_code);
+		if (result > 0) {
+			if (!first_connect) {
+				goto RECONNECT;
+			} else {
+				goto EXIT_THREAD;
+			}
+		}
+		if (result < 0)
+			goto EXIT_THREAD;
+
+		switch (check_restreamer_state(r)) {
+			case 1: goto RECONNECT;		// r->reconnect is on
+			case 2: goto QUIT;			// r->dienow is on
+		}
+
+		channel_source sproto = get_sproto(r->channel->source);
+
+		int mpgsync = mpeg_sync(r->sock, r->channel->name, sproto);
+		if (mpgsync == 1 && first_connect) { // Timeout
+			if (sproto == udp_sock) {
+				goto RECONNECT;
+			} else {
+				goto EXIT_THREAD;
+			}
+		}
+
+
+		char *p = buff;
+		pos = 0;
+		ssize_t readen = 0;
+		int max_zero_reads = MAX_ZERO_READS;
+		for (;;) {
+			switch (check_restreamer_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, p, FRAME_PACKET_SIZE, TCP_READ_TIMEOUT, TCP_READ_RETRIES, 1);
+			} else {
+				int read_so_far = 0;
+				int buffer_left;
+AGAIN:
+				buffer_left = buff_end - (p + read_so_far);
+				if (buffer_left >= FRAME_PACKET_SIZE) { // There is enough size for one frame in the buffer
+					readen = fdread_ex(r->sock, p+read_so_far, FRAME_PACKET_SIZE, UDP_READ_TIMEOUT, UDP_READ_RETRIES, 0);
+					if (readen > 0) {
+						read_so_far += readen;
+						if (read_so_far < FRAME_PACKET_SIZE)
+							goto AGAIN;
+						readen = read_so_far;
+						buffer_left = buff_end - (p + read_so_far);
+						if (buffer_left < FRAME_PACKET_SIZE) {
+							memcpy(p+read_so_far, TS_NULL_FRAME, buffer_left);
+						}
+					}
+				} else { // Not enough buffer space, wait a bit so the buffer can wrap around
+					if (buffer_left > 0) {
+						//LOGf("no read : only %d bytes left to the end of buffer, pos:%d/%d\n", buffer_left, pos, BUF);
+						readen = FRAME_PACKET_SIZE; // Oh, yeah we have that many bytes already read
+						if (pos+1 == BUF) { // Buffer will wrap now
+							//LOGf("Reached buffer end correcting last frame\n");
+							p -= FRAME_PACKET_SIZE - buffer_left; // That last packet must be sended now
+						} else {
+							p -= readen; // Prevent p from moving further (it will be added to bellow)
+						}
+					}
+				}
+			}
+			if (readen == -1) { // timeout
+				if (first_connect || sproto == udp_sock)
+					goto EXIT_THREAD;
+				break;
+			}
+			if (readen == 0) { // ho, hum, wtf is going on here?
+				if (--max_zero_reads == 0) {
+					LOGf("RESTR: %d zero reads on srv_fd: %i | Channel: %s Source: %s\n", MAX_ZERO_READS, r->sock, r->channel->name, r->channel->source);
+					break;
+				}
+				continue;
+			}
+
+			max_zero_reads = MAX_ZERO_READS;
+			allstats.traffic_in += readen;
+			r->traffic_in += readen;
+
+			// Fill short frame with NULL packets
+			if (readen < FRAME_PACKET_SIZE) {
+				LOGf("DEBUG: Short read (%d) on retreamer srv_fd: %i | Channel: %s\n", (int)readen, r->sock, r->channel->name);
+				memcpy(p+readen, TS_NULL_FRAME+readen, FRAME_PACKET_SIZE - readen);
+				readen = FRAME_PACKET_SIZE;
+			}
+
+			process_new_clients(r, BUFFER_SIZE, 0, 0);
+			pos++;
+			p += readen;
+			if (pos == BUF) {
+				pos = 0;
+				p=buff;
+			}
+
+			int num_clients = shout(r, buff, BUF, FRAME_PACKET_SIZE, pos*FRAME_PACKET_SIZE, "Content-Type: video/mpeg\n\n", NULL, 0);
+			if (!num_clients)
+				goto QUIT;
+			first_connect = 0;
+			retries = CONNECT_RETRIES;
+		}
+		LOGf("DEBUG: fdread timeout restreamer srv_fd: %i | Channel: %s\n", r->sock, r->channel->name);
+RECONNECT:
+		if (!keep_running)
+			goto QUIT;
+		proxy_begin_reconnect(r);
+		if (r->clients && r->clients->items)
+			continue;
+QUIT:
+		break;
+	}
+EXIT_THREAD:
+	proxy_close(r, http_code);
+	return 0;
+}

request.h

+/* tsiproxy mpeg transport stream proxy */
+#ifndef REQUEST_H
+# define REQUEST_H
+
+#include <sys/time.h>
+
+typedef struct req_info {
+	int clientsock;
+	struct sockaddr_in client;
+} request_info;
+
+void process_request(void *in_req); /* Uses struct req_info */
+
+#endif

request_tsiproxy.c

+/* tsiproxy request handling */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <netdb.h>
+#include <pthread.h>
+#include <regex.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <sys/time.h>
+#include <sys/types.h>
+
+#include <fcntl.h>
+#include <errno.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "data.h"
+#include "conf.h"
+#include "commands.h"
+#include "request.h"
+#include "proxy_common.h"
+
+extern LIST *netconf;
+
+extern regex_t request_get;
+extern regex_t request_authmatch;
+
+extern CONFIG *config;
+extern STATS allstats;
+
+#define FREE_DATA       { FREE(path); FREE(IP); FREE(agent); FREE(buf); }
+#define NEXT_CLIENT     { FREE_DATA; pthread_exit(0); }
+#define SHUTDOWN_CLIENT { FREE_DATA; shutdown_fd(&clientsock); pthread_exit(0); }
+#define BUF_SIZE        1024
+
+void process_request(void *in_req) {
+	request_info *req = (request_info *)in_req;
+	regmatch_t res[8];
+	uint32_t src_ip;
+	char *path=NULL, *IP=NULL, *agent=NULL, *buf=NULL;
+	unsigned long client_id = 0;
+	int client_udp_port = 0;
+	int smart_client = 0;
+	int clientsock = req->clientsock;
+	struct sockaddr_in client = req->client;
+	time_t expire = -1;
+	acl_t acl;
+	FREE(req);
+
+	buf = calloc(1, BUF_SIZE);
+	if (!buf) {
+		log_perror("Can't allocate buffer", errno);
+		SHUTDOWN_CLIENT;
+	}
+
+	IP=strdup(inet_ntoa(client.sin_addr));
+	src_ip = client.sin_addr.s_addr;
+
+	if (fdgetline(clientsock, buf, BUF_SIZE-1)<=0) {
+		SHUTDOWN_CLIENT;
+	}
+
+	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);
+	int plen = strlen(path);
+	{
+		int k = 0;
+		int qmarkpos = 0;
+		int esc_7e = 2; // max replaces
+		int esc_2b = 32; // max replaces
+		int esc_2c = 8; // max replaces
+		while (k < plen) {
+			/* Fix escaped symbols only when it's safe */
+			if (path[k]=='%' && k+2 <= plen) {
+				int mv = 0;
+				if (esc_7e >= 0 && path[k+1]=='7' && (path[k+2]=='E' || path[k+2]=='e')) { /* %7E -> ~ */
+					path[k] = '~';
+					esc_7e--;
+					mv = 1;
+				}
+				if (esc_2b >= 0 && path[k+1]=='2' && (path[k+2]=='B' || path[k+2]=='b')) { /* %2B -> + */
+					path[k] = '+';
+					esc_2b--;
+					mv = 1;
+				}
+				if (esc_2c >= 0 && path[k+1]=='2' && (path[k+2]=='C' || path[k+2]=='c')) { /* %2C -> , */
+					path[k] = ',';
+					esc_2c--;
+					mv = 1;
+				}
+				if (mv) {
+					memmove(&path[k+1], &path[k+3], plen-(k+2));
+					plen -= 2;
+				}
+			}
+			/* Bugfix for Windows Media Player. If path have // sequence
+			   (in base64 it is happening) WMP send just one / thus invalidating signature
+			   To fix this, URL generator replaces // with /_ so now we change _ back to / */
+			if (path[k] == '_')
+				path[k] = '/';
+			/* Some shitty player replaces // with /~ */
+			if (path[k] == '~')
+				path[k] = '/';
+			/* Leave only "safe" characters */
+			if (path[k] < '*' || path[k] > 'z' || path[k]=='`')
+				path[k] = '*';
+			if (path[k] == '?')
+				qmarkpos = k;
+			k++;
+		}
+		if (qmarkpos && qmarkpos < plen) {
+			path[qmarkpos] = 0;
+			client_udp_port = atoi(path+qmarkpos+1);
+		}
+	}
+	while (fdgetline(clientsock, buf, BUF_SIZE-1) > 0) {
+		if (buf[0] == '\n' || buf[0] == '\r') // End of headers
+			break;
+		if (strstr(buf, "X-Smart-Client: yes")==buf) {
+			smart_client = 1;
+		}
+		if (memcmp(buf,"User-Agent: ",12)==0 && strlen(buf) > 12) {
+			unsigned int k = 0;
+			agent=chomp(strdup(buf+12));
+			while(k<strlen(agent)) {
+				if (agent[k] < 32 || agent[k] > 122 || agent[k]==96) /* Do not allow ( < && > z && ` */
+					agent[k]=' ';
+				k++;
+			}
+		}
+	}
+
+	int pathlen = strlen(path);
+	if (!pathlen) {
+		send_302_redirect(clientsock, "https://georgi.unixsol.org/");
+		SHUTDOWN_CLIENT;
+	}
+
+	int acl_found = acl_search(netconf, client.sin_addr.s_addr, &acl);
+
+	if (!acl_found) {
+		LOGf("DENY : Access denied | IP: %s Path: /%s Agent: %s\n", IP, path, agent);
+		send_403_forbidden_msg(clientsock, "access-denied");
+		SHUTDOWN_CLIENT;
+	}
+
+	if (strncmp(path,"ping",4)==0) {
+		run_ping(clientsock, acl, src_ip, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"stats",5)==0) {
+		show_stats(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"info",4)==0) {
+		show_info(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"readinfo",8)==0) {
+		read_info(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"netconf",7)==0) {
+		run_netconf(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"chanconf",8)==0) {
+		run_chanconf(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"getnetconf",10)==0) {
+		run_getnetconf(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"getchanconf",10)==0) {
+		run_getchanconf(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"livecheck",9)==0) {
+		run_livecheck(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+	if (strncmp(path,"channels",8)==0) {
+		run_channels(clientsock, acl, IP);
+		SHUTDOWN_CLIENT;
+	}
+
+	if (!is_ext(path, ".asf") && !is_ext(path, ".mpg") && !is_ext(path, ".ts")) {
+		if (!is_ext(path, ".ico") &&	// favicon.ico 
+		    !is_ext(path, ".txt") &&	// robots.txt 
+		    !is_ext(path, ".asx") &&	// Playlists 
+		    !is_ext(path, ".m3u") &&	// Playlists 
+		    !is_ext(path, ".smi") &&	// Subtitles 
+		    !is_ext(path, ".ass") &&
+		    !is_ext(path, ".wse") &&
+		    !is_ext(path, ".idx") &&
+		    !is_ext(path, ".psb") &&
+		    !is_ext(path, ".srt") &&
+		    !is_ext(path, ".ssa") &&
+		    !is_ext(path, ".sub") &&
+		    !is_ext(path, ".ASF") &&	// some crap player desides to UPPERCASE the request
+		    !is_ext(path, ".wmv") &&	// No wmv files here
+		    !is_ext(path, "atus") &&	// apstatus 
+		    !is_ext(path, ".exe") &&	// ShitZ 
+		    !is_ext(path, ".php") &&
+		    !is_ext(path, ".pl") &&
+		    !is_ext(path, ".dll"))
+		{
+			LOGf("404  : File not found | IP: %s Path: /%s Agent: %s\n", IP, path, agent);
+		}
+		send_404_not_found(clientsock);
+		SHUTDOWN_CLIENT;
+	}
+
+	if (config_redirect_enabled(config, clientsock, path)) {
+		SHUTDOWN_CLIENT;
+	}
+
+	CLIENT *c = new_client(clientsock, expire, path, IP, agent, client_id, acl, client_udp_port, smart_client);
+	process_client(clientsock, c);
+
+	NEXT_CLIENT;
+}

tsiproxy.c

+/* tsiproxy - mpeg transport stream proxy */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <pthread.h>
+#include <errno.h>
+#include <signal.h>
+#include <regex.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include "libfuncs/libfuncs.h"
+
+#include "data.h"
+#include "conf.h"
+#include "request.h"
+
+char *server_sig = SERVER_SIGNATURE;
+char *server_ver = VERSION_ID;
+
+int keep_running = 1;
+int rcvsig = 0;
+int clean_on_exit = 0;
+
+CONFIG *config;
+
+regex_t request_get;
+regex_t http_response;
+
+STATS allstats;
+
+LIST *netconf = NULL;
+LIST *clients = NULL;
+LIST *chanconf = NULL;
+LIST *restreamer = NULL;
+
+char TS_NULL_FRAME[FRAME_PACKET_SIZE];
+
+static int usage_shown = 0;
+
+static void show_usage(void) {
+	if (usage_shown)
+		return;
+	puts("Identification:");
+	puts("");
+	puts("    -i ident            Streamer identification. Must be formated as PROVIDER/STREAMER");
+	puts("    -c <channels_file>  Channel definitions file");
+	puts("    -n <networks_file>  Network definitions file");
+	puts("");
+	puts("Server settings:");
+	puts("");
+	puts("    -b addr     Local IP address to bind (Default: 0.0.0.0)");
+	puts("    -p port     Port to listen (Default: 8080)");
+	puts("    -d pidfile  Run in daemon mode and write PID file");
+	puts("");
+	puts("Stream settings:");
+	puts("");
+	puts("    -B          Disable stream burst for new clients (usefull for master servers)");
+	puts("");
+	usage_shown = 1;
+}
+
+static void config_parse(CONFIG *conf, int argc, char **argv) {
+	int j;
+	conf->channels_file = "config.channels";
+	conf->networks_file = "config.networks";
+	while ((j = getopt(argc, argv, "TRBhXmvb:c:C:d:i:l:L:n:p:s:x:V:H:P:F")) != -1) {
+		switch (j) {
+			case 'b':
+				conf->bind_to = optarg;
+				break;
+			case 'c':
+				conf->channels_file = optarg;
+				break;
+			case 'd':
+				conf->pidfile = optarg;
+				break;
+			case 'i':
+				conf->ident = optarg;
+				conf->logident = strdup(conf->ident);
+				char *c = conf->logident;
+				while (*c) {
+					if (*c=='/')
+						*c='-';
+					c++;
+				}
+				break;
+			case 'n':
+				conf->networks_file = optarg;
+				break;
+			case 'T':
+				conf->ts_sync = 1;
+				break;
+			case 'B':
+				conf->disable_burst = 1;
+				break;
+			case 'p':
+				conf->server_port = atoi(optarg);
+				break;
+			case 'F':
+				clean_on_exit = 1;
+				break;
+			case 'h':
+				show_usage();
+				exit(1);
+				break;
+		}
+	}
+	int is_error = 0;
+	if (!conf->ident) {
+		show_usage();
+		fprintf(stderr, "ERROR: Server ident is not set. Use '-i provider/streamer'\n");
+		is_error++;
+	}
+	if (!conf->channels_file) {
+		show_usage();
+		fprintf(stderr, "ERROR: Channel definitions file is not set, use '-c channels_file'\n");
+		is_error++;
+	}
+	if (!conf->networks_file) {
+		show_usage();
+		fprintf(stderr, "ERROR: Network definitions file is not set, use '-n networks_file'\n");
+		is_error++;
+	}
+	if (is_error)
+		exit(3);
+}
+
+static void init_channels(void) {
+	/* Init channels */
+	fputs("Reading channels map:\t\t",stderr);
+	int j = load_channels(config);
+	if (j != -1) {
+		fprintf(stderr,"[OK] %i channels read\n", j);
+	} else {
+		fprintf(stderr,"[ERR] Can't read channels.\n");
+		exit(1);
+	}
+}
+
+static void init_networks(void) {
+	/* Init networks */
+	fputs("Reading networks ACL:\t\t",stderr);
+	int j = load_networks(config);
+	if (j != -1) {
+		fprintf(stderr,"[OK] %i networks read\n", j);
+	} else {
+		fprintf(stderr,"[ERR] Can't read networks.\n");
+		exit(1);
+	}
+}
+
+static void handle_signal(int sig) {
+	if (!keep_running)
+		return;
+	rcvsig = sig;
+	keep_running = 0;
+	shutdown_fd(&config->server_socket);
+}
+
+int main(int argc, char **argv) {
+	set_http_response_server_ident(server_sig, server_ver);
+
+	printf("%s %s Git: %s\n", server_sig, server_ver, BUILD_ID);
+	printf("%s\n\n", COPYRIGHT);
+
+	restreamer = list_new("restreamer");
+	clients = list_new("clients");
+
+	memset(&allstats, 0, sizeof(allstats));
+	allstats.start_ts = time(NULL);
+	uname(&allstats.utsdata);
+
+	memset(&TS_NULL_FRAME, 0xff, FRAME_PACKET_SIZE);
+	int i;
+	for (i=0; i<FRAME_PACKET_SIZE; i=i+188) {
+		TS_NULL_FRAME[i+0] = 0x47;
+		TS_NULL_FRAME[i+1] = 0x1f;
+		TS_NULL_FRAME[i+2] = 0xff;
+		TS_NULL_FRAME[i+3] = 0x00;
+	}
+
+	regcomp(&request_get, "^GET /([^ ]*) HTTP/1.*$", REG_EXTENDED);
+	regcomp(&http_response, "^HTTP/1.[0-1] (([0-9]{3}) .*)", REG_EXTENDED);
+
+	config = config_alloc();
+	config_parse(config, argc, argv);
+
+	init_channels();
+	init_networks();
+	init_server_socket(config->bind_to, config->server_port, &config->server_name, &config->server_socket);
+	daemonize(config->pidfile);
+
+	/* Must be called after daemonize! */
+	log_init(config->logident, 0, config->pidfile == NULL, NULL, 0);
+
+	/* Catch some signals */
+	signal(SIGCHLD, SIG_IGN);
+	signal(SIGPIPE, SIG_IGN);
+	signal(SIGHUP, SIG_IGN);
+	signal(SIGINT, handle_signal);
+	signal(SIGTERM, handle_signal);
+
+	LOGf("START: %s %s (%s)\n" , server_sig, server_ver, config->ident);
+
+	while(keep_running) {
+		struct sockaddr_in client;
+		unsigned int clientlen = sizeof(client);
+		int clientsock;
+		clientsock = accept(config->server_socket, (struct sockaddr *) &client, &clientlen);
+		if (clientsock < 0) {
+			if (config->server_socket > -1 && errno != EINVAL)	// 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_request, (void *)req)) {
+				log_perror("Error creating request processing thread.", errno);
+				exit(1);
+			}
+			pthread_detach(req_thread); 
+		}
+	}
+
+	restreamer_stop_all(restreamer);
+
+	LOGf("SHUTDOWN: Signal %i | %s %s (%s)\n", rcvsig, server_sig, server_ver, config->ident);
+
+	if (clean_on_exit) {
+		regfree(&http_response);
+		regfree(&request_get);
+		list_free(&restreamer, (void (*)(void *))free_restreamer, NULL);
+		list_free(&clients, (void (*)(void *))stop_client_shutdown, NULL);
+		list_free(&netconf, (void (*)(void *))free, NULL);
+		list_free(&chanconf, (void (*)(void *))free_channel, NULL);
+	}
+
+	log_close();
+
+	config_free(&config);
+
+	exit(0);
+}