Port web server code from mptsd

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
 

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"
+
+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;
+};
+
+#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
 
 	pthread_t thread;
 } RESTREAMER;
 
+static struct config config;
+
 channel_source get_sproto(char *url) {
 	return strncmp(url, "http", 4)==0 ? tcp_sock : udp_sock;
 }
 	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);
 }
 
 		}
 
 		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));
 
 	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) {
 		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);
 }
 
-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);
 }
 
 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 <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_reconnect(int clientsock) {
+	send_200_ok(clientsock);
+	send_header_textplain(clientsock);
+	fdputsf(clientsock, "\nReconnecting %d inputs.\n", 123);
+//	fdputsf(clientsock, "\nReconnecting %d inputs.\n", config->inputs->items);
+}

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_reconnect(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,"reconnect")==path) {
+		cmd_reconnect(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