Add web status/info/control interface

Makefile

 FUNCS_DIR = libfuncs
 FUNCS_LIB = $(FUNCS_DIR)/libfuncs.a
 
-tomcast_OBJS =  tomcast.o $(FUNCS_LIB)
+tomcast_OBJS =  tomcast.o web_pages.o web_server.o $(FUNCS_LIB)
 
 all: tomcast
 

README.WEB_ACCESS

+To enable the web access start tomcast with -b (listen address) and
+-p (listen port parameters).
+
+For example: tomcast -b 127.0.0.1 -p 8081
+
+Now you can access the web interface exposed by tomcast at
+
+    http://127.0.0.1:8081/
+
+The following endpoints are accessible:
+
+    http://127.0.0.1:8081/getconfig
+
+  Return currently configured channels in channels.conf format
+  that tomcast uses.
+
+
+    http://127.0.0.1:8081/reconnect
+
+  Reconnect all sources. If channels have more than one source
+  the source will be changed to the next available source.
+
+
+    http://127.0.0.1:8081/reload
+
+  Reload config file. This would start/stop new/removed channels.
+
+
+    http://127.0.0.1:8081/status
+
+  Return current channels status. The status looks like this:
+
+# Status   DestAddr             ConnTime  ReadBytes ChanName           ChanSource                                                       ProxyStatus
+CONN_OK    239.78.78.78:5000         123     148708 chan1              http://example.com:8080/stb/chan1.mpg                            Synced
+CONN_ERROR 239.79.79.79:5000          60      65800 chan2              http://ux.iptv.bg:8080/stb/chan2.mpg                             Synced
+CONN_ERROR 239.80.80.80:5000           0          0 chan3              udp://239.1.2.3:5000/                                            Connected
+
+  "Status" - current channel status which can be CONN_OK or CONN_ERROR
+
+    CONN_ERROR - Means that the source of the channel is currently
+                 not connected or bytes read are at least 1316 or
+                 ConnTime is 0
+
+  "ProxyStatus" - Last connection status
+
+    Connected
+    Working
+
+    Reconnecting
+
+    Dying
+    Forced reconnect
+
+    ERROR: Can not connect to source
+    ERROR: Can not resolve source host
+    ERROR: Can not sync mpeg
+    ERROR: Dns resolve timeout
+    ERROR: Read timeout
+    ERROR: Source returned invalid HTTP code
+    ERROR: Source returned no-signal
+    ERROR: Source returned unhandled error code
+    ERROR: Timeout while syncing mpeg
+    ERROR: Too many zero reads
+    ERROR: fdread() timeout while syncing mpeg
+    ERROR: fdread() timeout while syncing mpeg

config.h

+/*
+ * mptsd configuration header file
+ * Copyright (C) 2010-2011 Unix Solutions Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ */
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <pthread.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
+#include "libfuncs/libfuncs.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 {
+	char *name;
+	char *source; /* Full source url */
+	char *sources[MAX_CHANNEL_SOURCES];
+	uint8_t num_src;
+	uint8_t curr_src;
+	char *dest_host;
+	int dest_port;
+} CHANNEL;
+
+typedef struct {
+	char  *name;
+	CHANNEL *channel;
+	int sock;				/* Server socket */
+	struct sockaddr_in src_sockname;
+	int clientsock;			/* The udp socket */
+	struct sockaddr_in dst_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 */
+	    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 */
+	pthread_t thread;
+	pthread_rwlock_t lock;
+	time_t conn_ts;
+	uint64_t read_bytes;
+	char status[64];
+} RESTREAMER;
+
+
+struct config {
+	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;
+
+	char				*channels_file;
+
+	LIST				*chanconf;
+	LIST				*restreamer;
+
+	pthread_mutex_t		channels_lock;
+};
+
+extern void do_reconnect();
+extern void do_reconf();
+extern struct config *get_config(void);
+
+#endif

tomcast.c

 #include <netdb.h> // for uint32_t
 
 #include "libfuncs/libfuncs.h"
+#include "config.h"
+
+#include "web_server.h"
 
 #define DNS_RESOLVER_TIMEOUT 5000
 
 char *server_ver = "1.15";
 char *copyright  = "Copyright (C) 2010-2013 Unix Solutions Ltd.";
 
-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 {
-	char *name;
-	char *source; /* Full source url */
-	char *sources[MAX_CHANNEL_SOURCES];
-	uint8_t num_src;
-	uint8_t curr_src;
-	char *dest_host;
-	int dest_port;
-} CHANNEL;
-
-typedef struct {
-	char  *name;
-	CHANNEL *channel;
-	int sock;				/* Server socket */
-	struct sockaddr_in src_sockname;
-	int clientsock;			/* The udp socket */
-	struct sockaddr_in dst_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 */
-	    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 */
-	pthread_t thread;
-} RESTREAMER;
+static struct config config;
 
 channel_source get_sproto(char *url) {
 	return strncmp(url, "http", 4)==0 ? tcp_sock : udp_sock;
 	return sendsock;
 }
 
+void proxy_set_status(RESTREAMER *r, const char *proxy_status) {
+	pthread_rwlock_wrlock(&r->lock);
+	snprintf(r->status, sizeof(r->status), "%s", proxy_status);
+	pthread_rwlock_unlock(&r->lock);
+}
 
 void connect_destination(RESTREAMER *r) {
 	CHANNEL *c = r->channel;
 	r->channel = channel;
 	r->clientsock = -1;
 	r->dst_sockname = sockname;
+	pthread_rwlock_init(&r->lock, NULL);
 	connect_destination(r);
 	return r;
 }
 	FREE(r);
 }
 
-
-
-
-char *pidfile = NULL;
-char *ident = NULL;
-char *logident = NULL;
-char *loghost = NULL;
-int logport = 514;
-
-char *channels_file = NULL;
-int syslog_active = 0;
-
 char TS_NULL_FRAME[FRAME_PACKET_SIZE];
 
 regex_t http_response;
 
-LIST *chanconf = NULL;
-LIST *restreamer = NULL;
-
-static pthread_mutex_t channels_lock = PTHREAD_MUTEX_INITIALIZER;
-
 void proxy_log(RESTREAMER *r, char *msg, char *info) {
 	LOGf("%s: %sChan: %s Src: %s Dst: udp://%s:%d SrcIP: %s SrcFD: %i DstFD: %i\n",
 		msg,
 	);
 }
 
-int load_channels_config() {
+int load_channels_config(struct config *cfg) {
 	regex_t re;
 	regmatch_t res[5];
 	char line[1024];
 	int fd;
 	int num_channels = 0;
 
-	if (pthread_mutex_trylock(&channels_lock) != 0)
+	if (pthread_mutex_trylock(&cfg->channels_lock) != 0)
 		return -1;
 
-	fd = open(channels_file, O_RDONLY);
+	fd = open(cfg->channels_file, O_RDONLY);
 
 	if (fd != -1) {
 		struct timeval tv;
 		regfree(&re);
 		shutdown_fd(&fd);
 		/* Save current chanconf */
-		old_chanconf = chanconf;
+		old_chanconf = cfg->chanconf;
 		/* Switch chanconf */
-		chanconf = new_chanconf;
+		cfg->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(cfg->restreamer);	// Unlocked after second list_for_each(restreamer)
 
-		list_lock(chanconf);
-		list_for_each(chanconf, lc, lctmp) {
+		list_lock(cfg->chanconf);
+		list_for_each(cfg->chanconf, lc, lctmp) {
 			chan = lc->data;
-			list_for_each(restreamer, lr, lrtmp) {
+			list_for_each(cfg->restreamer, lr, lrtmp) {
 				if (strcmp(chan->name, ((RESTREAMER *)lr->data)->name)==0) {
 					RESTREAMER *restr = lr->data;
 					/* Mark the restreamer as valid */
 				}
 			}
 		}
-		list_unlock(chanconf);
+		list_unlock(cfg->chanconf);
 
 		/* Kill restreamers that serve channels that no longer exist */
-		list_for_each(restreamer, lr, lrtmp) {
+		list_for_each(cfg->restreamer, lr, lrtmp) {
 			RESTREAMER *r = lr->data;
 			/* This restreamer should no longer serve clients */
 			if (r->cookie != cookie) {
 				r->dienow = 1;
 			}
 		}
-		list_unlock(restreamer);
+		list_unlock(cfg->restreamer);
 
 		/* Free old_chanconf */
 		list_free(&old_chanconf, free_channel_p, NULL);
 	} else {
 		num_channels = -1;
 	}
-	pthread_mutex_unlock(&channels_lock);
+	pthread_mutex_unlock(&cfg->channels_lock);
 	if (num_channels == -1)
 		LOGf("CONF : Error loading channels!\n");
 	else
 void proxy_close(RESTREAMER *r) {
 	proxy_log(r, "STOP ","");
 	// If there are no clients left, no "Timeout" messages will be logged
-	list_del_entry(restreamer, r);
+	list_del_entry(config.restreamer, r);
 	free_restreamer(r);
 }
 
 	int active = 1;
 	int dret = async_resolve_host(src->host, src->port, &(r->src_sockname), DNS_RESOLVER_TIMEOUT, &active);
 	if (dret != 0) {
-		if (dret == 1)
+		if (dret == 1) {
 			proxy_log(r, "ERR  ","Can't resolve src host");
-		if (dret == 2)
+			proxy_set_status(r, "ERROR: Can not resolve source host");
+		}
+		if (dret == 2) {
 			proxy_log(r, "ERR  ","Timeout resolving src host");
+			proxy_set_status(r, "ERROR: Dns resolve timeout");
+		}
 		DO_RECONNECT;
 	}
 
 		proxy_log(r, "NEW  ","");
 		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));
+			proxy_set_status(r, "ERROR: Can not connect to source");
 			DO_RECONNECT;
 		}
 
 		snprintf(buf,sizeof(buf)-1, "GET /%s HTTP/1.0\r\nHost: %s:%u\r\nX-Smart-Client: yes\r\nUser-Agent: %s %s (%s)\r\n\r\n",
-		         src->path, src->host, src->port, server_sig, server_ver, ident);
+		         src->path, src->host, src->port, server_sig, server_ver, config.ident);
 		buf[sizeof(buf)-1] = 0;
 		fdwrite(r->sock, buf, strlen(buf));
 
 		}
 		if (*http_code == 0) { // No valid HTTP response, retry
 			LOGf("DEBUG: Server returned not valid HTTP code | srv_fd: %i\n", r->sock);
+			proxy_set_status(r, "ERROR: Source returned invalid HTTP code");
 			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);
+			proxy_set_status(r, "ERROR: Source returned no-signal");
 			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);
+			proxy_set_status(r, "ERROR: Source returned unhandled error code");
 			FATAL_ERROR;
 		}
 		// connected ok, continue
 	if (setsockopt(r->sock, SOL_SOCKET, SO_RCVBUF, (const char *)&readbuflen, sizeof(readbuflen)) < 0)
 		log_perror("play(): setsockopt(SO_RCVBUF)", errno);
 
+	proxy_set_status(r, "Connected");
 	r->connected = 1;
 
 	free_chansrc(src);
 int check_restreamer_state(RESTREAMER *r) {
 	if (r->dienow) {
 		// LOGf("PROXY: Forced disconnect on srv_fd: %i | Channel: %s Source: %s\n", r->sock, r->channel->name, r->channel->source);
+		proxy_set_status(r, "Dying");
 		return 2;
 	}
 	if (r->reconnect) {
 		LOGf("PROXY: Forced reconnect on srv_fd: %i | Channel: %s Source: %s\n", r->sock, r->channel->name, r->channel->source);
+		proxy_set_status(r, "Forced reconnect");
 		return 1;
 	}
 	return 0;
 		0 = synced ok
 		1 = not synced, reconnect
 */
-int mpeg_sync(int proxysock, char *channel, channel_source source_proto) {
+int mpeg_sync(RESTREAMER *r, int proxysock, char *channel, channel_source source_proto) {
 	time_t sync_start = time(NULL);
 	unsigned int sync_packets = 0;
 	unsigned int read_bytes = 0;
 resync:
 		if (fdread_ex(proxysock, syncframe, 1, _timeout, _retries, 1) != 1) {
 			LOGf("DEBUG: mpeg_sync fdread() timeout | Channel: %s\n", channel);
+			proxy_set_status(r, "ERROR: fdread() timeout while syncing mpeg");
 			return 1; // reconnect
 		}
 		// LOGf("DEBUG:     Read 0x%02x Offset %u Sync: %u\n", (uint8_t)syncframe[0], read_bytes, sync_packets);
 			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);
+				proxy_set_status(r, "ERROR: fdread() timeout while syncing mpeg");
 				return 1; // reconnect
 			}
 			read_bytes += 188-1;
 		}
 		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);
+			proxy_set_status(r, "ERROR: Can not sync mpeg");
 			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);
+			proxy_set_status(r, "ERROR: Timeout while syncing mpeg");
 			return 1; // reconnect
 		}
 	} while (1);
+	pthread_rwlock_wrlock(&r->lock);
+	r->conn_ts = time(NULL);
+	r->read_bytes = read_bytes;
+	pthread_rwlock_unlock(&r->lock);
 	LOGf("SYNC : TS synced after %u bytes | Channel: %s\n", read_bytes-FRAME_PACKET_SIZE, channel);
+	proxy_set_status(r, "Working");
 	return 0;
 }
 
 
 	int http_code = 0;
 	while (1) {
+		r->conn_ts = 0;
+		r->read_bytes = 0;
+
 		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);
 
-		int mpgsync = mpeg_sync(r->sock, r->channel->name, sproto);
+		int mpgsync = mpeg_sync(r, r->sock, r->channel->name, sproto);
 		if (mpgsync == 1) // Timeout
 			goto RECONNECT;
 
 				LOGf("PROXY: zero read on srv_fd: %i | Channel: %s Source: %s\n", r->sock, r->channel->name, r->channel->source);
 				if (--max_zero_reads == 0) {
 					LOGf("PROXY: %d zero reads on srv_fd: %i | Channel: %s Source: %s\n", MAX_ZERO_READS, r->sock, r->channel->name, r->channel->source);
+					proxy_set_status(r, "ERROR: Too many zero reads");
 					break;
 				}
 				continue;
 				//LOGf("DEBUG: Short read (%d) on retreamer srv_fd: %i | Channel: %s\n", readen, sock, chan->name);
 				memcpy(buf+readen, TS_NULL_FRAME+readen, FRAME_PACKET_SIZE - readen);
 			}
+			pthread_rwlock_wrlock(&r->lock);
+			r->read_bytes += readen;
+			pthread_rwlock_unlock(&r->lock);
 
 			if (send_reset) {
 				send_reset = 0;
 			}
 		}
 		LOGf("DEBUG: fdread timeout restreamer srv_fd: %i | Channel: %s\n", r->sock, r->channel->name);
+		proxy_set_status(r, "ERROR: Read timeout");
 RECONNECT:
+		pthread_rwlock_wrlock(&r->lock);
+		r->conn_ts = 0;
+		pthread_rwlock_unlock(&r->lock);
 		LOGf("DEBUG: reconnect srv_fd: %i | Channel: %s\n", r->sock, r->channel->name);
+		proxy_set_status(r, "Reconnecting");
 		shutdown_fd(&(r->sock));
 		next_channel_source(r->channel);
 		continue;
 	puts("\t-l host\t\tSyslog host (default: disabled)");
 	puts("\t-L port\t\tSyslog port (default: 514)");
 	puts("\t-R\t\tSend reset packets when changing sources.");
+	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("");
 }
 
-void set_ident(char *new_ident) {
-	ident = new_ident;
-	logident = strdup(ident);
-	char *c = logident;
+void set_ident(char *new_ident, struct config *cfg) {
+	cfg->ident = new_ident;
+	cfg->logident = strdup(new_ident);
+	char *c = cfg->logident;
 	while (*c) {
 		if (*c=='/')
 			*c='-';
 	}
 }
 
-void parse_options(int argc, char **argv) {
+void parse_options(int argc, char **argv, struct config *cfg) {
 	int j, ttl;
-	while ((j = getopt(argc, argv, "i:c:d:t:o:l:L:RHh")) != -1) {
+	cfg->server_socket = -1;
+	pthread_mutex_init(&cfg->channels_lock, NULL);
+	while ((j = getopt(argc, argv, "i:b:p:c:d:t:o:l:L:RHh")) != -1) {
 		switch (j) {
+			case 'b':
+				cfg->server_addr = optarg;
+				break;
+			case 'p':
+				cfg->server_port = atoi(optarg);
+				break;
 			case 'i':
-				set_ident(optarg);
+				set_ident(optarg, cfg);
 				break;
 			case 'c':
-				channels_file = optarg;
+				cfg->channels_file = optarg;
 				break;
 			case 'd':
-				pidfile = optarg;
+				cfg->pidfile = optarg;
 				break;
 			case 'o':
 				if (inet_aton(optarg, &output_intf) == 0) {
 				multicast_ttl = (ttl && ttl < 127) ? ttl : 1;
 				break;
 			case 'l':
-				loghost = optarg;
-				syslog_active = 1;
+				cfg->loghost = optarg;
+				cfg->syslog_active = 1;
 				break;
 			case 'L':
-				logport = atoi(optarg);
+				cfg->logport = atoi(optarg);
 				break;
 			case 'R':
 				send_reset_opt = 1;
 		}
 	}
 
-	if (!channels_file) {
+	if (!cfg->channels_file) {
 		show_usage(0);
 		fprintf(stderr, "ERROR: No channels file is set (use -c option).\n");
 		exit(1);
 	}
 
-	if (!ident) {
-		set_ident("unixsol/tomcast");
+	if (!cfg->ident) {
+		set_ident("unixsol/tomcast", cfg);
 	}
 
 	printf("Configuration:\n");
-	printf("\tServer ident      : %s\n", ident);
-	printf("\tChannels file     : %s\n", channels_file);
+	printf("\tServer ident      : %s\n", cfg->ident);
+	printf("\tChannels file     : %s\n", cfg->channels_file);
 	printf("\tOutput iface addr : %s\n", inet_ntoa(output_intf));
 	printf("\tMulticast ttl     : %d\n", multicast_ttl);
-	if (syslog_active) {
-		printf("\tSyslog host       : %s\n", loghost);
-		printf("\tSyslog port       : %d\n", logport);
+	if (cfg->syslog_active) {
+		printf("\tSyslog host       : %s\n", cfg->loghost);
+		printf("\tSyslog port       : %d\n", cfg->logport);
 	} else {
 		printf("\tSyslog disabled.\n");
 	}
 	if (send_reset_opt)
 		printf("\tSend reset packets.\n");
-	if (pidfile) {
-		printf("\tDaemonize         : %s\n", pidfile);
+	if (cfg->pidfile) {
+		printf("\tDaemonize         : %s\n", cfg->pidfile);
 	} else {
 		printf("\tDo not daemonize.\n");
 	}
+	if (cfg->server_port) {
+		init_server_socket(cfg->server_addr, cfg->server_port, &cfg->server, &cfg->server_socket);
+		printf("\tStarting web srv  : http://%s:%d/status (sock: %d)\n", cfg->server_addr, cfg->server_port, cfg->server_socket);
+	} else {
+		printf("\tNo web server\n");
+	}
 }
 
-void init_vars() {
-	restreamer = list_new("restreamer");
+void init_vars(struct config *cfg) {
+	cfg->restreamer = list_new("restreamer");
 	regcomp(&http_response, "^HTTP/1.[0-1] (([0-9]{3}) .*)", REG_EXTENDED);
 	memset(&TS_NULL_FRAME, 0xff, FRAME_PACKET_SIZE);
 	int i;
 	}
 }
 
-void spawn_proxy_threads() {
+void spawn_proxy_threads(struct config *cfg) {
 	LNODE *lc, *lctmp;
 	LNODE *lr, *lrtmp;
 	int spawned = 0;
-	list_for_each(chanconf, lc, lctmp) {
+	list_for_each(cfg->chanconf, lc, lctmp) {
 		CHANNEL *c = lc->data;
 		int restreamer_active = 0;
-		list_lock(restreamer);
-		list_for_each(restreamer, lr, lrtmp) {
+		list_lock(cfg->restreamer);
+		list_for_each(cfg->restreamer, lr, lrtmp) {
 			RESTREAMER *r = lr->data;
 			if (strcmp(r->name, c->name)==0) {
 				restreamer_active = 1;
 				break;
 			}
 		}
-		list_unlock(restreamer);
+		list_unlock(cfg->restreamer);
 		if (!restreamer_active) {
 			RESTREAMER *nr = new_restreamer(c->name, c);
 			if (nr->clientsock < 0) {
 				LOGf("Error creating proxy socket for %s\n", c->name);
 				free_restreamer(nr);
 			} else {
-				list_add(restreamer, nr);
+				list_add(cfg->restreamer, nr);
 				if (pthread_create(&nr->thread, NULL, &proxy_ts_stream, nr) == 0) {
 					spawned++;
 					pthread_detach(nr->thread);
 	LOGf("INFO : %d proxy threads spawned\n", spawned);
 }
 
-void kill_proxy_threads() {
+void kill_proxy_threads(struct config *cfg) {
 	LNODE *l, *tmp;
 	int killed = 0;
-	list_lock(restreamer);
-	list_for_each(restreamer, l, tmp) {
+	list_lock(cfg->restreamer);
+	list_for_each(cfg->restreamer, l, tmp) {
 		RESTREAMER *r = l->data;
 		r->dienow = 1;
 		killed++;
 	}
-	list_unlock(restreamer);
+	list_unlock(cfg->restreamer);
 	LOGf("INFO : %d proxy threads killed\n", killed);
 }
 
+int keep_going = 1;
+
 void signal_quit(int sig) {
-	kill_proxy_threads();
+	keep_going = 0;
+	kill_proxy_threads(&config);
 	usleep(500000);
-	LOGf("KILL : Signal %i | %s %s (%s)\n", sig, server_sig, server_ver, ident);
+	LOGf("KILL : Signal %i | %s %s (%s)\n", sig, server_sig, server_ver, config.ident);
 	usleep(100000);
 	log_close();
-	if (pidfile && strlen(pidfile))
-		unlink(pidfile);
+	if (config.pidfile && strlen(config.pidfile))
+		unlink(config.pidfile);
 	signal(sig, SIG_DFL);
 	raise(sig);
 }
 
+struct config *get_config(void) {
+	return &config;
+}
+
 void do_reconnect() {
 	LNODE *l, *tmp;
-	list_lock(restreamer);
-	list_for_each(restreamer, l, tmp) {
+	list_lock(config.restreamer);
+	list_for_each(config.restreamer, l, tmp) {
 		RESTREAMER *r = l->data;
 		r->reconnect = 1;
 	}
-	list_unlock(restreamer);
+	list_unlock(config.restreamer);
 }
 
 void do_reconf() {
-	load_channels_config();
-	spawn_proxy_threads();
+	load_channels_config(&config);
+	spawn_proxy_threads(&config);
 }
 
 void init_signals() {
 	signal(SIGTERM, signal_quit);
 }
 
-void do_daemonize() {
-	if (!pidfile)
+void do_daemonize(struct config *cfg) {
+	if (!cfg->pidfile)
 		return;
 	fprintf(stderr, "Daemonizing.\n");
 	pid_t pid = fork();
 	if (pid > 0) {
-		FILE *F = fopen(pidfile,"w");
+		FILE *F = fopen(cfg->pidfile,"w");
 		if (F) {
 			fprintf(F,"%i\n",pid);
 			fclose(F);
 }
 
 /* Must be called after daemonize! */
-void init_logger() {
-	if (syslog_active)
-		fprintf(stderr, "Logging to %s:%d\n", loghost, logport);
-	log_init(logident, syslog_active, pidfile == NULL, loghost, logport);
+void init_logger(struct config *cfg) {
+	if (cfg->syslog_active)
+		fprintf(stderr, "Logging to %s:%d\n", cfg->loghost, cfg->logport);
+	log_init(cfg->logident, cfg->syslog_active, cfg->pidfile == NULL, cfg->loghost, cfg->logport);
 }
 
 int main(int argc, char **argv) {
 	set_http_response_server_ident(server_sig, server_ver);
 	show_usage(1); // Show copyright and version
-	init_vars();
-	parse_options(argc, argv);
-	do_daemonize();
-	init_logger();
+	init_vars(&config);
+	parse_options(argc, argv, &config);
+	do_daemonize(&config);
+	init_logger(&config);
 	init_signals();
 
-	LOGf("INIT : %s %s (%s)\n" , server_sig, server_ver, ident);
+	LOGf("INIT : %s %s (%s)\n" , server_sig, server_ver, config.ident);
 
-	load_channels_config();
-	spawn_proxy_threads();
+	load_channels_config(&config);
+	spawn_proxy_threads(&config);
+	web_server_start(&config);
 
 	do {
 		sleep(60);

web_pages.c

+/*
+ * mptsd internal web pages
+ * Copyright (C) 2010-2011 Unix Solutions Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ */
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <ctype.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 struct config *config;
+
+void cmd_index(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputs(clientsock, "\nHi from tomcast.\n");
+}
+
+void cmd_status(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputs(clientsock, "\n");
+
+	LNODE *l, *tmp;
+	struct config *cfg = get_config();
+
+	time_t now = time(NULL);
+	fdputsf(clientsock, "%-10s %-20s %8s %10s %-18s %-64s %s\n",
+		"# Status",
+		"DestAddr",
+		"ConnTime",
+		"ReadBytes",
+		"ChanName",
+		"ChanSource",
+		"ProxyStatus"
+	);
+	pthread_mutex_lock(&cfg->channels_lock);
+	list_lock(cfg->restreamer);
+	list_for_each(cfg->restreamer, l, tmp) {
+		char dest[32];
+		int conn_status = 0;
+		RESTREAMER *r = l->data;
+		pthread_rwlock_rdlock(&r->lock);
+		snprintf(dest, sizeof(dest), "%s:%d", r->channel->dest_host, r->channel->dest_port);
+		if (r->connected && r->conn_ts > 0 && r->read_bytes >= 1316)
+			conn_status = 1;
+		fdputsf(clientsock, "%-10s %-20s %8lu %10llu %-18s %-64s %s\n",
+			conn_status ? "CONN_OK" : "CONN_ERROR",
+			dest,
+			r->conn_ts ? now - r->conn_ts : 0,
+			r->read_bytes,
+			r->channel->name,
+			r->channel->source,
+			r->status
+		);
+		pthread_rwlock_unlock(&r->lock);
+	}
+	list_unlock(cfg->restreamer);
+	pthread_mutex_unlock(&cfg->channels_lock);
+}
+
+void cmd_getconfig(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputs(clientsock, "\n");
+
+	LNODE *l, *tmp;
+	struct config *cfg = get_config();
+
+	pthread_mutex_lock(&cfg->channels_lock);
+	list_lock(cfg->restreamer);
+	list_for_each(cfg->restreamer, l, tmp) {
+		RESTREAMER *r = l->data;
+		pthread_rwlock_rdlock(&r->lock);
+		int i;
+		for (i = 0; i < r->channel->num_src; i++) {
+			fdputsf(clientsock, "%s\t%s:%d\t%s\n",
+				r->channel->name,
+				r->channel->dest_host,
+				r->channel->dest_port,
+				r->channel->sources[i]
+			);
+		}
+		pthread_rwlock_unlock(&r->lock);
+	}
+	list_unlock(cfg->restreamer);
+	pthread_mutex_unlock(&cfg->channels_lock);
+}
+
+void cmd_reconnect(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	struct config *cfg = get_config();
+	pthread_mutex_lock(&cfg->channels_lock);
+	fdputsf(clientsock, "\nReconnecting %d inputs.\n", cfg->chanconf->items);
+	pthread_mutex_unlock(&cfg->channels_lock);
+	do_reconnect();
+}
+
+void cmd_reload(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputs(clientsock, "\nReloading config\n");
+	do_reconf();
+}

web_pages.h

+/*
+ * mptsd internal web pages header file
+ * Copyright (C) 2010-2011 Unix Solutions Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ */
+#ifndef WEB_PAGES_H
+#define WEB_PAGES_H
+
+void cmd_index(int clientsock);
+void cmd_status(int clientsock);
+void cmd_getconfig(int clientsock);
+void cmd_reconnect(int clientsock);
+void cmd_reload(int clientsock);
+
+#endif

web_server.c

+/*
+ * mptsd internal web server
+ * Copyright (C) 2010-2011 Unix Solutions Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ */
+#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) {
+	struct 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(struct config *conf) {
+	if (conf->server_socket > -1)
+		pthread_create(&conf->server_thread, NULL, &web_server_thread, conf);
+}
+
+void web_server_stop(struct 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,"getconfig")==path) {
+		cmd_getconfig(clientsock);
+	} else if (strstr(path,"reconnect")==path) {
+		cmd_reconnect(clientsock);
+	} else if (strstr(path,"reload")==path) {
+		cmd_reload(clientsock);
+	} else if (strstr(path,"status")==path) {
+		cmd_status(clientsock);
+	} else {
+		send_404_not_found(clientsock);
+	}
+
+	SHUTDOWN_CLIENT;
+}
+

web_server.h

+/*
+ * mptsd internal web server header file
+ * Copyright (C) 2010-2011 Unix Solutions Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ */
+#ifndef WEB_SERVER_H
+# define WEB_SERVER_H
+
+#include "config.h"
+
+void web_server_start(struct config *conf);
+void web_server_stop(struct config *conf);
+
+#endif