Add support for LCN.

Makefile

 	sleep.o network.o \
 	input.o \
 	output_psi.o output_mix.o output_write.o \
-	web_pages.o web_server.o \
+	web_pages.o web_server.o udp_server.o\
 	mptsd.o
 
 PROGS = mptsd

config.c

 	// Parse channels file
 	conf->provider_name = ini_get_string_copy(ini, NULL, "Global:provider_name");
 	conf->transport_stream_id = ini_get_int(ini, 0, "Global:transport_stream_id");
+	conf->frequency = ini_get_string_copy(ini, NULL, "Global:frequency");
+	conf->modulation = ini_get_string_copy(ini, NULL, "Global:modulation");
+	conf->symbol_rate = ini_get_string_copy(ini, NULL, "Global:symbol_rate");
+
+//	conf->epg_source = ini_get_string(ini, NULL, "EPG:source");
+
+
+
 	for (i=1;i<32;i++) {
 		CHANNEL *channel = NULL;
 		int service_id = ini_get_int(ini, 0, "Channel%d:service_id", i);
 			continue;
 
 		int is_radio = ini_get_bool(ini, 0, "Channel%d:radio", i);
+		int lcn = ini_get_int(ini, 0, "Channel%d:lcn", i);
+		int is_lcn_visible = ini_get_bool(ini, 0, "Channel%d:lcn_visible", i);
+
 
 		char *id = ini_get_string(ini, NULL, "Channel%d:id", i);
 		if (!id) {
 				}
 				// Init channel
 				if (channel == NULL) {
-					channel = channel_new(service_id, is_radio, id, name, source);
+					channel = channel_new(service_id, is_radio, id, name, source, lcn, is_lcn_visible);
 				} else {
 					chansrc_add(channel, source);
 				}
 		if (r->cookie != cookie) {
 			proxy_log(r, "Remove");
 			/* Replace channel reference with real object and instruct free_restreamer to free it */
-			r->channel = channel_new(r->channel->service_id, r->channel->radio, r->channel->id, r->channel->name, r->channel->source);
+			r->channel = channel_new(r->channel->service_id, r->channel->radio, r->channel->id, r->channel->name, r->channel->source, r->channel->lcn, r->channel->lcn_visible);
 			r->freechannel = 1;
 			r->dienow = 1;
 		}
 		LOGf("CONFIG: Error loading global config (%s)\n", conf->global_conf);
 		return 0;
 	}
-	conf->network_id		= ini_get_int(ini, 0,    "Global:network_id");
+	conf->network_id				= ini_get_int(ini, 0,    "Global:network_id");
 	conf->timeouts.pat		= ini_get_int(ini, 100,  "Timeouts:pat");
 	conf->timeouts.pmt		= ini_get_int(ini, 200,  "Timeouts:pmt");
 	conf->timeouts.sdt		= ini_get_int(ini, 500,  "Timeouts:sdt");
 	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("UDP Server settings:");
+	puts("\t-s addr\t\tLocal IP address to bind.   (default: 0.0.0.0)");
+	puts("\t-u port\t\tPort to listen.             (default: 2000)");
+
 	puts("\t-d pidfile\tDaemonize with pidfile");
 	puts("\t-l host\t\tSyslog host                 (default: disabled)");
 	puts("\t-L port\t\tSyslog port                 (default: 514)");
 	conf->logport = 514;
 	conf->server_port = 0;
 	conf->server_socket = -1;
+	conf->udp_server_port = 2000;
+	conf->udp_server_socket = -1;
 
-	while ((j = getopt(argc, argv, "i:b:p:g:c:n:e:d:t:o:O:P:l:L:B:m:qDHhWE")) != -1) {
+	while ((j = getopt(argc, argv, "i:b:p:s:u:g:c:n:e:d:t:o:O:P:l:L:B:m:qDHhWE")) != -1) {
 		switch (j) {
 			case 'i':
 				conf->ident = strdup(optarg);
 			case 'p':
 				conf->server_port = atoi(optarg);
 				break;
+			case 's':
+				conf->udp_server_addr = strdup(optarg);
+				break;
+			case 'u':
+				conf->udp_server_port = atoi(optarg);
+				break;
 			case 'd':
 				conf->pidfile = strdup(optarg);
 				break;
 	if (conf->server_port)
 		init_server_socket(conf->server_addr, conf->server_port, &conf->server, &conf->server_socket);
 
+//	if (conf->udp_server_port)
+//		init_server_socket_udp(conf->server_addr, conf->udp_server_port, &conf->server, &conf->udp_server_socket);
+
 	if (!conf->quiet) {
 		printf("Configuration:\n");
 		printf("\tServer ident      : %s\n", conf->ident);
 	if (!config_load_channels(conf))
 		goto ERR;
 
-	config_load_epg(conf);
+	if (!config_load_epg(conf))
+		LOGf("CONFIG: Run without EIT (%s)\n", conf->epg_conf);
 
 	return;
 

config.h

 	char			*loghost;
 	int				logport;
 
-	struct sockaddr_in	server;
-	char				*server_addr;
-	int					server_port;
-	int					server_socket;
-	pthread_t			server_thread;
+	struct sockaddr_in		server;
+	char			*server_addr;
+	int				server_port;
+	int				server_socket;
+	pthread_t		server_thread;
+
+	struct sockaddr_in		udp_server;
+	char			*udp_server_addr;
+	int				udp_server_port;
+	int				udp_server_socket;
+	pthread_t		udp_server_thread;
 
 	int				multicast_ttl;
+
 	struct in_addr	output_intf;
 
 	char			*global_conf;
 
 	uint16_t		network_id;			// For NIT && SDT
 	uint16_t		transport_stream_id;// For NIT
+	char			*frequency;			// For NIT
+	char			*modulation;		// For NIT
+	char			*symbol_rate;		// For NIT
+
 	char 			*network_name;		// For NIT
 	char 			*provider_name;		// For SDT
 
 void		config_load		(CONFIG *conf, int argc, char **argv);
 
 int			config_load_global		(CONFIG *conf);
-int			config_load_channels	(CONFIG *conf);
+int			config_load_channels		(CONFIG *conf);
 int			config_load_nit			(CONFIG *conf);
 int			config_load_epg			(CONFIG *conf);
 

data.c

 
 
 
-CHANNEL *channel_new(int service_id, int is_radio, char *id, char *name, char *source) {
+CHANNEL *channel_new(int service_id, int is_radio, char *id, char *name, char *source, int lcn, int is_lcn_visible) {
 	CHANNEL *c = calloc(1, sizeof(CHANNEL));
 	c->service_id = service_id;
 	c->radio = is_radio;
+	c->lcn = lcn;
+	c->lcn_visible = is_lcn_visible;
 	c->base_pid = service_id * 32; // The first pid is saved for PMT
 	c->pmt_pid = c->base_pid; // The first pid is saved for PMT
 	c->id = strdup(id);

data.h

 	int			service_id;
 	int			pmt_pid;
 	int			radio;
+	int			lcn;
+	int			lcn_visible;
 	char *		id;
 	char *		name;
 	/* Sources */
 void		epg_free		(EPG_ENTRY **e);
 int			epg_changed		(EPG_ENTRY *a, EPG_ENTRY *b);
 
-CHANNEL *	channel_new		(int service_id, int is_radio, char *id, char *name, char *source);
+CHANNEL *	channel_new		(int service_id, int is_radio, char *id, char *name, char *source, int lcn, int is_lcn_visible);
 void		channel_free	(CHANNEL **c);
 void		channel_free_epg(CHANNEL *c);
 
 NIT *		nit_new			(uint16_t ts_id, char *freq, char *modulation, char *symbol_rate);
 void		nit_free		(NIT **nit);
 
+
 void		proxy_log		(INPUT *r, char *msg);
 void		proxy_close		(LIST *inputs, INPUT **input);
 

input.c

 				pid = ts_packet_get_pid(ts_packet);
 				// Kill incomming NIT, SDT, EIT, RST, TDT/TOT
 				if (pid == s->nit_pid || pid == 0x10 || pid == 0x11 || pid == 0x12 || pid == 0x13 || pid == 0x14 || pid == 0x1fff) {
-					// LOGf("INPUT: %-10s: Remove PID %03x\n", r->channel->id, pid);
+				//	 LOGf("INPUT: %-10s: Remove PID %03x\n", r->channel->id, pid);
 					continue;
 				}
 

mptsd.c

 #include "input.h"
 #include "output.h"
 #include "web_server.h"
+#include "udp_server.h"
 
 #define PROGRAM_NAME "ux-mptsd"
 
 			INPUT *nr = input_new(c->name, c);
 			if (nr) {
 				list_add(conf->inputs, nr);
-//				LOGf("SPAWN : %s thread.\n", c->name);
+				LOGf("SPAWN : %s thread.\n", c->name);
 				if (pthread_create(&nr->thread, NULL, &input_stream, nr) == 0) {
 					spawned++;
 					pthread_detach(nr->thread);
 
 	daemonize(config->pidfile);
 	web_server_start(config);
+	udp_server_start(config);
 	log_init(config->logident, config->syslog_active, config->pidfile == NULL, config->loghost, config->logport);
 	init_signals(config);
 
 
 	kill_threads(config);
 	web_server_stop(config);
+	udp_server_stop(config);
 
 	LOGf("SHUTDOWN: Signal %d | %s %s (%s)\n", rcvsig, server_sig, server_ver, config->ident);
 	config_free(&config);

mptsd_channels.conf

 [Global]
 provider_name = Unix Solutions
 transport_stream_id = 1
+frequency           = 0658,0000
+modulation          = 64-QAM
+symbol_rate         = 006,8750
+
 
 [Channel1]
 service_id	= 1
 #source4		= udp://239.0.0.1:5000/
 #source5        = rtp://239.78.78.2:5000/
 #worktime	= 14:18-14:19
+lcn		= 2
+lcn_visible	= yes
 
 [Channel2]
 service_id	= 2
 id			= kanal1
 name		= "Kanal 1"
 source		= http://signal-server/stb/kanal1.mpg
+lcn		= 2
+lcn_visible	= yes
 
 [Channel3]
 service_id	= 3
 id			= novatv
 name		= "Nova"
 source1		= http://signal-server/stb/novatv.mpg
+lcn		= 3
+lcn_visible	= yes
 
 [Channel4]
 service_id	= 4
 id			= tv2
 name		= "TV 2"
 source1		= http://signal-server/stb/tv2.mpg
+lcn		= 7
+lcn_visible	= no
 
 [Channel5]
 service_id	= 5
 id			= ngc
 name		= "NatGeo"
 source1		= http://signal-server/stb/ngc.mpg
+lcn		= 72
+lcn_visible	= yes
 
 [Channel6]
 service_id	= 6
 id			= tv1
 name		= "TV 1"
 source1		= http://signal-server/stb/tv1.mpg
+lcn		= 25
+lcn_visible	= yes
 
 [Channel7]
 service_id	= 7
 id			= planetahit
 name		= "Planeta HIT"
 source1		= http://signal-server/stb/planetahit.mpg
+lcn		= 33
+lcn_visible	= no
 
 [Channel8]
 service_id	= 8
 name		= "Radio Fresh"
 radio		= yes
 source		= http://signal-server/stb/fresh.mpg
+lcn		= 201
+lcn_visible	= no
 
 [Channel9]
 service_id	= 9
 name		= "BG Radio"
 radio		= yes
 source1		= http://signal-server/stb/bgradio.mpg
+lcn		= 202
+lcn_visible	= yes

mptsd_nit.conf

 [Global]
 network_name = "Unixsol DVB-C network"
 
-[Transponder1]
-transport_stream_id = 1
-frequency           = 0658,0000
-modulation          = 64-QAM
-symbol_rate         = 006,8750
-
 [Transponder2]
 transport_stream_id = 2
 frequency           = 0666,0000

output_psi.c

 
 static void output_psi_init_pat(CONFIG *conf, OUTPUT *o) {
 	LNODE *lc, *lctmp;
+
 	o->pat = ts_pat_alloc_init(conf->transport_stream_id);
 	list_lock(conf->channels);
 	list_for_each(conf->channels, lc, lctmp) {
 
 	ts_nit_add_network_name_descriptor(nit, conf->network_name);
 
+	int num;
+	LNODE *lc, *lctmp;
+
+	uint32_t *svc_services = malloc(conf->channels->items * sizeof(uint32_t));
+	uint32_t *lcn_services = malloc(conf->channels->items * sizeof(uint32_t));
+
+	num = 0;
+
+	list_lock(conf->channels);
+
+	list_for_each(conf->channels, lc, lctmp) {
+			CHANNEL *c = lc->data;
+			uint32_t srv = 0;
+			srv  = (c->service_id &~ 0x00ff) << 24;
+			srv |= (c->service_id &~ 0xff00) << 16;
+			srv |= (c->lcn_visible ? 0x01 : 0x00 &~ 0xf0 ) << 15;
+			srv |= (0X00 &~ 0xf0 ) << 14;
+			srv |= (c->lcn &~ 0xc0ff);
+			srv |= (c->lcn &~ 0xff00);
+			lcn_services[num++] = srv;
+	}
+
+	list_unlock(conf->channels);
+
+	num = 0;
+
+	list_lock(conf->channels);
+    list_for_each(conf->channels, lc, lctmp) {
+             CHANNEL *c = lc->data;
+             uint32_t srv = 0;
+             srv  = (c->service_id &~ 0x00ff) << 16;
+             srv |= (c->service_id &~ 0xff00) << 8;
+             srv |= c->radio ? 0x02 : 0x01;
+             svc_services[num++] = srv;
+    }
+
+	list_unlock(conf->channels);
+
+    NIT *ts_ndata = nit_new(conf->transport_stream_id, conf->frequency, conf->modulation, conf->symbol_rate);
+
+	ts_nit_add_stream_descriptors(nit, ts_ndata->ts_id, conf->network_id, ts_ndata->_freq, ts_ndata->_modulation, ts_ndata->_symbol_rate, lcn_services, svc_services, num);
+
 	if (conf->nit->items < 64) {
-		int num;
-		LNODE *lc, *lctmp;
-		uint32_t *freqs = malloc(conf->nit->items * sizeof(uint32_t));
-		uint32_t *services = malloc(conf->channels->items * sizeof(uint32_t));
-		num = 0;
 		list_lock(conf->nit);
-		list_for_each(conf->nit, lc, lctmp) {
-			NIT *ndata = lc->data;
-			freqs[num++] = ndata->_freq;
-		}
-		ts_nit_add_frequency_list_descriptor_cable(nit, conf->transport_stream_id, conf->network_id, freqs, num);
-		list_for_each(conf->nit, lc, lctmp) {
+			list_for_each(conf->nit, lc, lctmp) {
 			NIT *ndata = lc->data;
 			ts_nit_add_cable_delivery_descriptor(nit, ndata->ts_id, conf->network_id, ndata->_freq, ndata->_modulation, ndata->_symbol_rate);
 		}
+
 		list_unlock(conf->nit);
-		num = 0;
-		list_lock(conf->channels);
-		list_for_each(conf->channels, lc, lctmp) {
-			CHANNEL *c = lc->data;
-			uint32_t srv = 0;
-			srv  = (c->service_id &~ 0x00ff) << 16;
-			srv |= (c->service_id &~ 0xff00) << 8;
-			srv |= c->radio ? 0x02 : 0x01;
-			services[num++] = srv;
-		}
-		list_unlock(conf->channels);
-		ts_nit_add_service_list_descriptor(nit, conf->transport_stream_id, conf->network_id, services, num);
-		free(freqs);
-		free(services);
+
+		free(lcn_services);
+		free(svc_services);
+
 	} else {
 		LOG("CONF  : Too much items in the NIT, maximum is 64! NIT not generated.\n");
 	}
 		o->pid_eit_cont += eit->section_header->num_packets;
 		cbuf_fill(o->psibuf, eit->section_header->packet_data, eit->section_header->num_packets * TS_PACKET_SIZE);
 	}
-//	ts_eit_dump(eit);
+	ts_eit_dump(eit);
 }
 
 static void output_add_eit(CONFIG *conf, OUTPUT *o) {

udp_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 "libfuncs/io.h"
+#include "libfuncs/log.h"
+
+#include "libtsfuncs/tsfuncs.h"
+
+#include "data.h"
+#include "config.h"
+#include "network.h"
+
+#include "udp_server.h"
+
+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 BUFSIZE 1316
+
+void *udp_server_thread(void *data) {
+	CONFIG *conf = data;
+
+	struct sockaddr_in client;					/* remote address */
+	socklen_t clientlen = sizeof(client);		/* length of addresses */
+	int clientsock; 							/* #bytes received */
+	char buf[FRAME_PACKET_SIZE];				/* receive buffer */
+
+	while (keep_going) {
+
+
+		clientsock = recvfrom(conf->udp_server_socket,(char*)buf, FRAME_PACKET_SIZE, 0, (struct sockaddr *)&client, &clientlen);
+
+		if (clientsock < 0) {
+			if (conf->udp_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)
+				break;
+		} else {
+
+		//	LOGf("received %d bytes from %s with port %d \n", clientsock, inet_ntoa(client.sin_addr), ntohs( client.sin_port ) );
+
+		// TODO  Process buffer and add to output_mix
+
+		}
+
+	}
+
+	pthread_exit(0);
+
+
+}
+
+void udp_server_start(CONFIG *conf) {
+	if (conf->udp_server_port)
+		udp_server_init(conf->udp_server_addr, conf->udp_server_port, &conf->udp_server, &conf->udp_server_socket);
+
+	if (conf->udp_server_socket > -1) {
+		LOG("UDP_SERVER: Started \n");
+		pthread_create(&conf->udp_server_thread, NULL, &udp_server_thread, conf);
+		}
+}
+
+void udp_server_stop(CONFIG *conf) {
+	if (conf->udp_server_socket > -1) {
+		shutdown_fd(&conf->udp_server_socket);
+		pthread_join(conf->udp_server_thread, NULL);
+	}
+}
+
+
+void udp_server_init(char *bind_addr, int bind_port, struct sockaddr_in *server, int *server_socket) {
+
+	LOG("UDP_SERVER: Init.\n");
+
+	char *binded;
+
+	struct hostent *host_ptr;
+	*server_socket = socket(PF_INET, SOCK_DGRAM, 0);
+
+	if (*server_socket == -1) {
+		perror("socket(server_socket)");
+		exit(1);
+	}
+
+	int j = 1;
+	if (setsockopt(*server_socket, SOL_SOCKET, SO_REUSEADDR,(const char *) &j, sizeof(j))<0) {
+		perror("setsockopt(SO_REUSEADDR)");
+		exit(1);
+	}
+
+	memset(server, 0, sizeof(struct sockaddr_in));
+	if (!bind_addr) {
+		binded = "*";
+		server->sin_addr.s_addr = htonl(INADDR_ANY);
+	} else {
+		host_ptr = gethostbyname(bind_addr);
+		if (!host_ptr) {
+			fprintf(stderr,"Error can't resolve bind address: %s\n", bind_addr);
+			exit(1);
+		}
+		memcpy(&server->sin_addr, host_ptr->h_addr, sizeof(server->sin_addr));
+		binded = inet_ntoa(server->sin_addr);
+	}
+
+	/* Bind to server socket */
+	LOGf ("UDP_SERVER: Bind to : %s:%i\n", binded, bind_port);
+
+	server->sin_family = AF_INET;
+	server->sin_port   = htons(bind_port);
+
+	if (bind(*server_socket, (struct sockaddr *)server, sizeof(struct sockaddr_in)) < 0) {
+		perror("bind(server_socket)");
+		exit(1);
+	}
+
+	LOG("UDP_SERVER: UDP server Initialized.\n");
+
+}

udp_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 UDP_SERVER_H
+#define UDP_SERVER_H
+
+#include "config.h"
+
+void udp_server_start(CONFIG *conf);
+void udp_server_init(char *bind_addr, int bind_port, struct sockaddr_in *server, int *server_socket);
+void udp_server_stop(CONFIG *conf);
+
+
+
+
+
+
+#endif