/*  
    (C) 2012-15 Digital Devices GmbH. 

    This file is part of the octoserve SAT>IP server.

    Octoserve is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    Octoserve 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 octoserve.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "octoserve.h"

#include <getopt.h>

uint32_t debug;
uint32_t flags;
uint32_t conform = 0;
#define FLAGS_TRANSPORT 1

static uint32_t session_is_playing(struct ossess *sess);

uint64_t mtime_nano(void)
{
	struct timespec ts;

	if (clock_gettime(CLOCK_MONOTONIC_RAW, &ts))
		return 0;
	return ts.tv_sec * 1000000000 + ts.tv_nsec;
}

void dump(const uint8_t *b, int l)
{
	int i, j;
	
	for (j = 0; j < l; j += 16, b += 16) { 
		for (i = 0; i < 16; i++)
			if (i + j < l)
				printf("%02x ", b[i]);
			else
				printf("   ");
		printf(" | ");
		for (i = 0; i < 16; i++)
			if (i + j < l)
				putchar((b[i] > 31 && b[i] < 127) ? b[i] : '.');
		printf("\n");
	}
}

static void update_switch_vec(struct ossess *sess)
{
	struct osmcc *mcc;
	uint32_t vec = 0;
	struct ossess *ownsess = sess->stream->session;

	if (!sess->os->has_switch)
		return;
	for (mcc = sess->mccs.lh_first; mcc; mcc = mcc->mcc.le_next)
		vec |= mcc->port_vec;
	//if (conform && ownsess->trans.mcast && (ownsess->playing & 2))
	if (conform && ownsess->trans.mcast && session_is_playing(ownsess))
		vec |= 0x1f;
	if (vec != sess->mcc_port_vec_set || sess->port_vec != sess->port_vec_set) {
		sess->mcc_port_vec_set = vec;
		sess->port_vec_set = sess->port_vec;
		switch_set_multicast(sess->trans.mcmac,
				     sess->mcc_port_vec_set | sess->port_vec_set);
	}
}

struct rtsp_error rtsp_errors[] = {
	{100, "Continue"},
	{200, "OK"},
	{400, "Bad Request"},
	{403, "Forbidden"},
	{404, "Not Found"},
	{405, "Method Not Allowed"},
	{406, "Not Acceptable"},
	{408, "Request Timeout"},
	{414, "Request-URI Too Long"},
	{453, "Not Enough Bandwidth"},
	{454, "Session Not Found"},
	{455, "Method Not Valid in This State"},
	{461, "Unsupported Transport"},
	{500, "Internal Server Error"},
	{501, "Not Implemented"},
	{503, "Service Unavailable"},
	{505, "Version Not Supported"},
	{551, "Option Not Supported"},
	{0, ""},
}; 

static int adrtoip(struct sockaddr *sa, uint8_t *ip)
{
	unsigned short af = sa->sa_family;
	void *adr;
	
	if (af == AF_INET) 
		adr = &((struct sockaddr_in *) sa)->sin_addr;
	else if (af == AF_INET6)
		adr = &((struct sockaddr_in6 *) sa)->sin6_addr;
	else 
		return -1;
	memcpy(ip, adr,  af == AF_INET ? 4 : 16);
	return 0;
}

static int check_self(struct sockaddr *sadr, uint8_t *mac)
{
	uint8_t ip[16];

	if (adrtoip(sadr, ip) < 0)
		return -1;
}

static int get_mac(char *ifname, struct sockaddr *sadr, uint8_t *mac)
{
	struct arpreq arpreq;
	int s;

	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (s < 0)
		return -1;
	memset(&arpreq, 0, sizeof(struct arpreq));
	memcpy(&arpreq.arp_pa, sadr, sizeof(struct sockaddr));

	arpreq.arp_ha.sa_family = ARPHRD_ETHER;
	strcpy(arpreq.arp_dev, ifname);
	if (ioctl(s, SIOCGARP, &arpreq) < 0) {
		perror("get_mac socket error on");
		dump((uint8_t *)sadr, sizeof(struct sockaddr));
		close(s);
		return -1;
	}
	close(s);
	memcpy(mac, arpreq.arp_ha.sa_data, 6);
	dbgprintf(DEBUG_NET, "%s=%02x:%02x:%02x:%02x:%02x:%02x\n", ifname,  
	       mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	return 0;
}

static int ip2mac(uint8_t *ip, uint8_t *mac)
{
	struct arpreq arpreq;
	struct sockaddr_in *sin = (struct sockaddr_in *) &arpreq.arp_pa;
	int s;

	s = socket(AF_INET, SOCK_DGRAM, 0);
	if (s < 0)
		return -1;
	memset(&arpreq, 0, sizeof(struct arpreq));
	sin->sin_family = AF_INET;
	memcpy(&sin->sin_addr.s_addr, ip, 4);

	if (ioctl(s, SIOCGARP, &arpreq) < 0) {
		perror("ip2mac socket error");
		close(s);
		return -1;
	}
	close(s);
	memcpy(mac, arpreq.arp_ha.sa_data, 6);
	dbgprintf(DEBUG_NET, "%u.%u.%u.%u=%02x:%02x:%02x:%02x:%02x:%02x\n", 
		  ip[0], ip[1], ip[2], ip[3], 
		  mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
	return 0;
}

static void add_fd(int fd, int *mfd, fd_set *fds)
{
	FD_SET(fd, fds);
	if (fd > *mfd)
		*mfd = fd;
}

int readmii(int id, int reg)
{
	int fd;
	struct ifreq ifr;
	struct mii_ioctl_data *mii = (struct mii_ioctl_data *) &ifr.ifr_data;
	
	strcpy(ifr.ifr_name, "eth0");
	mii->phy_id = id;
	mii->reg_num = reg;
	mii->val_in = 0;
	mii->val_out = 0;
	fd = socket(AF_INET, SOCK_DGRAM, 0);
	ioctl(fd, SIOCGMIIREG, &ifr);
	dbgprintf(DEBUG_NET, "mii %02x.%02x = %02x\n", id, reg, mii->val_out);
}

/******************************************************************************/
/******************************************************************************/
/******************************************************************************/

void send_error(struct oscon *con, int err)
{
	uint8_t buf[256];
	int len;
	char *err_str;
	struct rtsp_error *rerr;

	for (rerr = rtsp_errors; rerr->number; rerr++)
		if (rerr->number == err)
			break;
	if (!rerr->number) {
		printf("Internal Error: invalid error number %d\n", err);
		return;
	}
	len=sprintf(buf, 
		    "RTSP/1.0 %d %s\r\n"
		    "CSeq: %d\r\n"
		    "\r\n", err, rerr->name, con->seq);
	sendlen(con->sock, buf, len);
	dbgprintf(DEBUG_RTSP, "Send Error:\n%s\n", buf);
}

static void release_session(struct ossess *oss);

static void release_ca(struct dvbca *ca)
{
	dbgprintf(DEBUG_SYS, "release ca %d\n", ca->nr);
	pthread_mutex_lock(&ca->os->lock);
	ca->stream->ca = NULL;
	ca->state = 0;
	pthread_mutex_unlock(&ca->os->lock);
}

static struct dvbca *alloc_ca_num(struct osstrm *str, int num)
{
	struct octoserve *os = str->os;
	struct dvbca *ca;

	if (num >= os->dvbca_num)
		return NULL;
	pthread_mutex_lock(&os->lock);
	ca = &os->dvbca[num];
	if (ca->state == 0) {
		printf("alloced ca %d\n", num);
		pthread_mutex_lock(&ca->mutex);
		memset(ca->pmt, 0, sizeof(ca->pmt));
		ca->state = 1;
		ca->stream = str;
		ca->input = str->fe->nr - 1;
		pthread_mutex_unlock(&ca->mutex);
		pthread_mutex_unlock(&os->lock);
		return ca;
	}
	pthread_mutex_unlock(&os->lock);
	return NULL;
}

static struct dvbca *alloc_ca(struct osstrm *str)
{
	struct octoserve *os = str->os;
	struct dvbca *ca;
	uint32_t i;

	printf("alloc ca\n");
	pthread_mutex_lock(&os->lock);
	for (i = 0; i < os->dvbca_num; i++) {
		ca = &os->dvbca[i];
		if (ca->state == 0) {
			printf("alloced ca %d\n", i);
			pthread_mutex_lock(&ca->mutex);
			memset(ca->pmt, 0, sizeof(ca->pmt));
			ca->state = 1;
			ca->stream = str;
			ca->input = str->fe->nr - 1;
			pthread_mutex_unlock(&ca->mutex);
			pthread_mutex_unlock(&os->lock);
			return ca;
			
		}
	}
	pthread_mutex_unlock(&os->lock);
	return NULL;
}

static void release_fe(struct octoserve *os, struct dvbfe *fe)
{
	if (!fe)
		return;
	dbgprintf(DEBUG_SYS, "release fe %d\n", fe->nr);
	fe->state = 2;
	pthread_join(fe->pt, NULL);
}

static struct dvbfe *alloc_fe_num(struct octoserve *os, int i, int type)
{
	struct dvbfe *fe;

	if (i > os->dvbfe_num)
		return NULL;
	dbgprintf(DEBUG_SYS, "alloc_fe_num %d\n", i);
	pthread_mutex_lock(&os->lock);
	fe = &os->dvbfe[i];
	if (fe->state || !(fe->type & (1UL << type))) {
		pthread_mutex_unlock(&os->lock);
		return NULL;
	}
	fe->n_tune = 0;
	fe->state = 1;
	pthread_create(&fe->pt, NULL, (void *) handle_fe, fe); 
	pthread_mutex_unlock(&os->lock);
	dbgprintf(DEBUG_SYS, "Allocated fe %d = %d/%d, fd=%d\n",
		  fe->nr, fe->anum, fe->fnum, fe->fd);
	return fe;
}

static struct dvbfe *alloc_fe(struct octoserve *os, int type)
{
	int i;
	struct dvbfe *fe;

	pthread_mutex_lock(&os->lock);
	for (i = 0; i < os->dvbfe_num; i++) {
		fe = &os->dvbfe[i];
		if (fe->state == 0 && 
		    (fe->type & (1UL << type))) {
			pthread_mutex_unlock(&os->lock);
			return alloc_fe_num(os, i, type);
		}
	}
	pthread_mutex_unlock(&os->lock);
	return NULL;
}

static void release_con(struct oscon *con)
{
	close(con->sock);
	con->state = 0;
	dbgprintf(DEBUG_SYS, "releasing con %d\n", con->nr);
}

static void shutdown_con(struct oscon *con)
{
	con->session = 0;
	con->state = 3;
	con->timeout = mtime(NULL) + 10;
	dbgprintf(DEBUG_SYS, "shutdown con %u at %u\n", con->nr, con->timeout);
}

static void _release_session(struct ossess *oss)
{
	struct octoserve *os = oss->os;
	int i;

	dbgprintf(DEBUG_SYS, "releasing session %d\n", oss->nr);
	for (i = 0; i < MAX_CONNECT; i++) {
		if (os->con[i].state &&
		    (os->con[i].session == oss))
			shutdown_con(&os->con[i]);
	}
	if (oss->nsfd >= 0) {
		dbgprintf(DEBUG_SYS, "closing netstream of session %d\n", oss->nr);
		close(oss->nsfd);
	}
	oss->playing = 0;
	oss->state = 0;
	if (oss->trans.mcast && conform) {
		dbgprintf(DEBUG_SYS, "check mc owner\n");
		if (!session_is_playing(oss))
			ioctl(oss->stream->session->nsfd, NS_STOP);			
	}
}

static void release_stream(struct osstrm *str)
{
	struct octoserve *os = str->os;
	int i;
	dbgprintf(DEBUG_SYS, "release stream %d\n", str->nr);

	for (i = 0; i < MAX_SESSION; i++) {
		if (os->session[i].state && 
		    (os->session[i].stream == str))
			_release_session(&os->session[i]);
	}
	str->state = 0;
	release_fe(os, str->fe);
	if (str->ca)
		release_ca(str->ca);
}

static struct osstrm *alloc_stream(struct octoserve *os)
{
	int i;
	struct osstrm *str;

	pthread_mutex_lock(&os->lock);
	for (i = 0; i < MAX_STREAM; i++) {
		str = &os->stream[i];
		if (str->state == 0) {
			memset(str, 0, sizeof(struct osstrm));
			str->os = os;
			str->nr = i + 1;
			str->state = 1;
			str->sport = 8000 + 2 * i;
			str->sport2 = 8000 + 2 * i + 1;
			pthread_mutex_unlock(&os->lock);
			dbgprintf(DEBUG_SYS, "Allocated stream %d\n", str->nr);
			return str;}
	}
	pthread_mutex_unlock(&os->lock);
	return NULL;
}

static struct osstrm *get_stream(struct octoserve *os, int id)
{
	int i;
	struct osstrm *str, *r = NULL;

	pthread_mutex_lock(&os->lock);
	for (i = 0; i < MAX_STREAM; i++) {
		str = &os->stream[i];
		if (str->state && (str->nr == id)) {
			r = str;
			break;
		}
	}
	pthread_mutex_unlock(&os->lock);
	return r;
}

static void release_session(struct ossess *oss)
{
	struct octoserve *os = oss->os;
	int i;
	
	dbgprintf(DEBUG_SYS, "release session nr %d id %010d\n", oss->nr, oss->id);
	pthread_mutex_lock(&os->lock);
	mc_del(oss);
	if (oss->stream && (oss->stream->session == oss)) // stream owner?
		release_stream(oss->stream);
	else 
		_release_session(oss);
	pthread_mutex_unlock(&os->lock);
}

static void release_no_sessions(struct ossess *oss)
{
	struct octoserve *os = oss->os;
	struct osstrm *str = oss->stream;
	int i;
	
	dbgprintf(DEBUG_SYS, "release session nr %d id %010d\n", oss->nr, oss->id);
	pthread_mutex_lock(&os->lock);
	mc_del(oss);
	for (i = 0; i < MAX_SESSION; i++) {
		if (os->session[i].state && 
		    (os->session[i].stream == str) &&
		    (&os->session[i] != oss) &&
		    os->session[i].trans.mcast)
			_release_session(&os->session[i]);
	}
	pthread_mutex_unlock(&os->lock);
}

static uint32_t session_is_playing(struct ossess *sess)
{
	struct osstrm *str = sess->stream;
	struct octoserve *os = sess->os;
	int i;
	uint32_t playing = 0;

	if (!(sess->trans.mcast && conform))
		return sess->playing;
	pthread_mutex_lock(&os->lock);
	for (i = 0; i < MAX_SESSION; i++)
		if (os->session[i].state &&
		    os->session[i].trans.mcast &&
		    (os->session[i].stream == str)) {
			playing |= os->session[i].playing;
			dbgprintf(DEBUG_DEBUG, "playing[%u] = %u\n",
				  i, os->session[i].playing);
		}
	pthread_mutex_unlock(&os->lock);
	dbgprintf(DEBUG_DEBUG, "playing = %u\n", playing);
	
	return playing;
}

static struct ossess *get_session(struct octoserve *os, uint32_t id)
{
	int i;
	struct ossess *oss;
	
	pthread_mutex_lock(&os->lock);
	for (i = 0; i < MAX_SESSION; i++) {
		oss = &os->session[i];
		if (oss->state && (oss->id == id)) {
			pthread_mutex_unlock(&os->lock);
			return oss;
		}
	}
	pthread_mutex_unlock(&os->lock);
	return NULL;
}

static void check_mccs(struct ossess *sess)
{
	time_t tdiff, t;
	int update = 0;
	
	if (!sess->trans.mcast)
		return;

	tdiff = mtime(&t) - sess->mcc_time;
	switch (sess->mcc_state) {
	case 1:
		if (tdiff >= 1) {
			sess->mcc_state = 2;
			/* all replying clients get new tag */ 
			sess->mcc_tag++;
			send_igmp_query(sess->os, sess->trans.mcip, 10);
			sess->mcc_time = t;
			printf("%u: mcc_state 1 done, tag = %d\n", t, sess->mcc_tag);
		}
		break;
	case 2:
		if (tdiff >= 1) {
			sess->mcc_state = 3;
			send_igmp_query(sess->os, sess->trans.mcip, 10);
			printf("%u: mcc_state 2 done, tag = %d\n", t, sess->mcc_tag);
		}
		break;
	case 3:
		if (tdiff >= 2) {
			sess->mcc_state = 0;
			sess->mcc_time = t;
			printf("%u: mcc_state 3 done, tag = %d\n", t, sess->mcc_tag);
			update = 1;
		}
		break;
	case 0:
		update = 1;
		break;
	}
	mc_check(sess, update);
}

void session_timeout(struct ossess *sess)
{
	mtime(&sess->timeout);	
	sess->timeout += sess->timeout_len;
	dbgprintf(DEBUG_RTSP, "new timeout %d\n", sess->timeout);
}

void session_mc_timeout(struct ossess *sess)
{
	mtime(&sess->mc_timeout);	
	sess->mc_timeout += 260;
	dbgprintf(DEBUG_IGMP, "new mc timeout %d\n", sess->mc_timeout);
}

void check_session_timeouts(struct octoserve *os)
{
	time_t t;
	int i;
	struct ossess *sess;

	mtime(&t);
	pthread_mutex_lock(&os->lock);
	for (i = 0; i < MAX_SESSION; i++) {
		sess = &os->session[i];
		check_mccs(sess);

		if (sess->state &&
		    (sess->timeout < t)) {
			struct oscon *con;
			int j;
	
			/* also count open connections referencing this session, 
			   for VLC, mplayer, ... which do not send keep alives */
			for (j = 0; j < MAX_CONNECT; j++) {
				con = &os->con[j];
				if (con->state && con->session && 
				    (con->session == sess)) {
					session_timeout(sess);
					break;
				}
			}
			if (j == MAX_CONNECT)
				release_session(&os->session[i]);
		}
	}
	pthread_mutex_unlock(&os->lock);
}

static uint32_t get_id(struct octoserve *os)
{
	uint32_t id, i;
	struct ossess *oss;

	while (1) {
		id = random();
		for (i = 0; i < MAX_SESSION; i++) {
			oss = &os->session[i];
			if (oss->state && (oss->id == id))
				break;
		}
		if (i == MAX_SESSION)
			return id;
	}
}

static struct ossess *alloc_session(struct octoserve *os)
{
	int i;
	struct ossess *oss;

	pthread_mutex_lock(&os->lock);
	for (i = 0; i < MAX_SESSION; i++) {
		oss = &os->session[i];
		if (oss->state == 0) {
			memset(oss, 0, sizeof(struct ossess));
			oss->os = os;
			oss->nr = i;
			oss->id = get_id(os);
			os->sessionid++;
			oss->state = 1;
			oss->nsfd = -1;
			oss->timeout_len = 60;
			session_timeout(oss);
			session_mc_timeout(oss);
			LIST_INIT(&oss->mccs);
			mtime(&oss->mcc_time);
			dbgprintf(DEBUG_SYS,
				  "Allocated session nr=%d id=%d\n",
				  oss->nr, oss->id);
			pthread_mutex_unlock(&os->lock);
			return oss;
		}
	}
	pthread_mutex_unlock(&os->lock);
	return NULL;
}

static struct oscon *alloc_con(struct octoserve *os)
{
	int i;
	struct oscon *con;

	for (i = 0; i < MAX_CONNECT; i++) {
		con = &os->con[i];
		if (con->state == 0) {
			memset(con, 0, sizeof(struct oscon));
			con->os = os;
			con->nr = i;
			con->state = 1;
			return con;
		}
	}
	return NULL;
}

int die(char *msg)
{
	printf("%s\n", msg);
	exit(-1);
}

void sigchld_handler(int s)
{
	while (wait(NULL) > 0);
}

static void send_option(struct oscon *con)
{
	uint8_t buf[256], opt[256] ={ 0 };
	int len;

	if (con->session) 
		snprintf(opt, sizeof(opt), "Session: %010d\r\n", con->session->id);
	
	len = snprintf(buf, sizeof(buf),
		       "RTSP/1.0 200 OK\r\n" 
		       "CSeq: %d\r\n"
		       "Public: OPTIONS, DESCRIBE, SETUP, PLAY, TEARDOWN\r\n"
		       "%s"
		       "\r\n", 
		       con->seq, opt);
	if ((len > 0) && (len < sizeof(buf))) {
		sendlen(con->sock, buf, len);
		dbgprintf(DEBUG_RTSP, "Send: %s\n", buf);
	}
}

#define PAR2STR(par) ((p->set & (1UL << PARAM_##par)) ? par##2str[p->param[PARAM_POL]] : "")

char *pol2str[] = {"", "v", "h", "r", "l", NULL};
char *msys2str [] = {"", "undef", "dvbc", "dvbcb", "dvbt", "dss", "dvbs", "dvbs2", "dvbh",
		      "isdbt", "isdbs", "isdbc", "atsc", "atscmh", "dtmb", "cmmb", "dab",
		      "dvbt2", "turbo", "dvbcc", "dvbc2", NULL};
char *mtype2str [] = {"", "qpsk", "16qam", "32qam",
		      "64qam", "128qam", "256qam", 
		      "autoqam", "8vsb", "16vsb", "8psk",
		      "16apsk", "32apsk", "dqpsk", "4qamnr", NULL};
char *pilot2str [] = {"", "on", "off", "auto", NULL};
char *roll2str [] = {"", "0.35", "0.20", "0.25", NULL};
char *fec2str [] = {"", "none", "12", "23", "34", "56", "78", "89", "35", "45", "910", "25", NULL};
char *bw2str [] = {"", "8", "7", "6", "auto", "5", "10", "1.712", NULL };
char *tmode2str [] = { "", "2k", "8k", "auto", "4k", "1k", "16k", "32k", "c1", "c3780", NULL};
char *gi2str [] = { "", "132", "116", "18", "14", "auto", "1128", "19128", "19256", "pn420", "pn595", "pn945", NULL};
char *num2str [] = {"", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", NULL};

#define ARRAY_SIZE(x) (sizeof(x)/sizeof((x)[0]))

static int session_string(struct ossess *sess, char *msg, int mlen)
{
	struct dvbfe *fe;
	char pids[512];
	struct dvb_params *p;
	int pid, len, len2, plen;
	int level = 0, lock = 0, quality = 0, tuner = 0;
	int all;
	struct osstrm *str = sess->stream;
	
	if (!sess->state || !str)
		return -1;
	if (str->fe){
		level = str->fe->level;
		lock = str->fe->lock;
		quality = (str->fe->quality * 3) / 20;
		tuner = str->fe->nr;
	}
	p = &sess->p;

	for (pid = 0, all = 1; pid < 1024; pid++) {
		if (p->pid[pid] != 0xff) {
			all = 0;
			break;
		}
	}
	if (all) 
		snprintf(pids, sizeof(pids), "=all");
	else {
		for (pid = 0, plen = 0; pid < 8192; pid++) {
			if (p->pid[pid >> 3] & (1 << (pid & 7))) {
				len2 = snprintf(pids + plen, sizeof(pids) - plen,
						",%u", pid);
				if (len2 < 0) 
					return -1;
				if (plen + len2 >= 200)
					break;
				plen += len2;
			}
		}
		pids[0] = '=';
		if (!plen) 
			snprintf(pids, sizeof(pids), "=none");
	}
	
	switch(p->param[PARAM_MSYS] - 1) {
	case SYS_DVBS:
	case SYS_DVBS2:
		len = snprintf(msg, mlen, 
			       "ver=1.0;src=%u;tuner=%u,%u,%u,%u,%u,%s,%s,%s,%s,%s,%u,%s;pids%s", 
			       p->param[PARAM_SRC], tuner, 
			       level, lock, quality,
			       p->param[PARAM_FREQ] / 1000,
			       pol2str[p->param[PARAM_POL]],
			       msys2str[p->param[PARAM_MSYS]],
			       mtype2str[p->param[PARAM_MTYPE]],
			       pilot2str[p->param[PARAM_PLTS]],
			       roll2str[p->param[PARAM_RO]],
			       p->param[PARAM_SR],
			       fec2str[p->param[PARAM_FEC]],
			       pids);
		break;
	case SYS_DVBT:
	case SYS_DVBT2:
		len = snprintf(msg, mlen, 
			       "ver=1.1;tuner=%u,%u,%u,%u,%u.%03u,%s,%s,%s,%s,%s,%s,%u,%u,%u;pids%s", 
			       tuner, level, lock, quality,
			       p->param[PARAM_FREQ] / 1000,
			       p->param[PARAM_FREQ] % 1000,
			       bw2str[p->param[PARAM_BW]],
			       msys2str[p->param[PARAM_MSYS]],
			       tmode2str[p->param[PARAM_TMODE]],
			       mtype2str[p->param[PARAM_MTYPE]],
			       gi2str[p->param[PARAM_GI]],
			       fec2str[p->param[PARAM_FEC]],
			       p->param[PARAM_PLP],
			       p->param[PARAM_T2ID],
			       p->param[PARAM_SM],
			       pids);
		break;
	case SYS_DVBC_ANNEX_A:
	case (SYS_DVBC_ANNEX_C + 1):
#if 0
		len = snprintf(msg, mlen, 
			       "ver=0.9;tuner=%u,%u,%u,%u,%u.%03u,%u,%s,%s;pids%s", 
			       tuner, level, lock, quality,
			       p->param[PARAM_FREQ] / 1000,
			       p->param[PARAM_FREQ] % 1000,
			       p->param[PARAM_SR],
			       msys2str[p->param[PARAM_MSYS]],
			       mtype2str[p->param[PARAM_MTYPE]],
			       pids);
#else
		len = snprintf(msg, mlen, 
			       "ver=1.2;tuner=%u,%u,%u,%u,%u.%03u,%u,%s,%s,%u,%u,%u,%u;pids%s", 
			       tuner, level, lock, quality,
			       p->param[PARAM_FREQ] / 1000,
			       p->param[PARAM_FREQ] % 1000,
			       p->param[PARAM_BW_HZ] / 1000000,
			       msys2str[p->param[PARAM_MSYS]],
			       mtype2str[p->param[PARAM_MTYPE]],
			       p->param[PARAM_SR],
			       p->param[PARAM_C2TFT],
			       p->param[PARAM_DS],
			       p->param[PARAM_PLP],
			       pids);
#endif
		break;
	}

	if (len >= mlen)
		return -1;
	return len;
}

static int send_describe(struct oscon *con, int only)
{
	struct osstrm *str;
	struct ostrans *t;
	uint8_t buf[4096], buf2[4096 + 1024], buf3[1024]; 
	int len, len2, i;
	int start = 0, end = MAX_STREAM;
	char *p;

	p = con->url;
	while (*p && *p != ' ')
		p++;
	*p = 0;

#if 1
	for (i = 0; i < MAX_STREAM; i++) {
		str = &con->os->stream[i];
		if (str->state)
			break;
	}
	if (i == MAX_STREAM) 
		return -404;
#endif
	if (only >= 0) {
		if (only >= MAX_STREAM)
			return -404;
		start = only - 1;
		end = only;
		str = &con->os->stream[start];
		if (!str->state)
			return -404;
	}
	if (con->os->dvbtnum + con->os->dvbt2num + con->os->dvbcnum + con->os->dvbc2num)
		len = snprintf(buf, sizeof(buf),
			       "v=0\r\n"
			       "o=- 5678901234 7890123456 IN %s %s\r\n"
			       "s=SatIPServer:1 %d,%d,%d\r\n"
			       "t=0 0\r\n",
			       con->trans.family == AF_INET ? "IP4" : "IP6", 
			       con->sadr_ip, 
			       con->os->dvbs2num,
			       con->os->dvbtnum + con->os->dvbt2num,
			       con->os->dvbcnum + con->os->dvbc2num		
			);
	else
		len = snprintf(buf, sizeof(buf),
			       "v=0\r\n"
			       "o=- 5678901234 7890123456 IN %s %s\r\n"
			       "s=SatIPServer:1 %d\r\n"
			       "t=0 0\r\n",
			       con->trans.family == AF_INET ? "IP4" : "IP6", 
			       con->sadr_ip, 
			       con->os->dvbs2num		
			);
		
	if (len <= 0 || len >= sizeof(buf))
		return -500;
	for (i = start; i < end; i++) {
		char *adr = "0.0.0.0", abuf[32];
		int j, sendonly = 0;
		int alen;

		str = &con->os->stream[i];
		if (!str->state)
			continue;
		t = &str->session->trans;

		for (j = sendonly = 0; j < MAX_SESSION; j++) {
			if (con->os->session[j].state && 
			    con->os->session[j].stream == str &&
			    con->os->session[j].playing)
				sendonly = 1;
		}
		session_string(str->session, buf3, sizeof(buf3));
		
		if (t->mcast) {
			alen = snprintf(abuf, sizeof(abuf), 
					"%d.%d.%d.%d/%u",
					t->mcip[0],
					t->mcip[1],
					t->mcip[2],
					t->mcip[3],
					t->ttl);
			if (alen < 0)
				return -500;
			adr = abuf;
		}
		
		len2 = snprintf(buf + len, sizeof(buf) - len,
				"m=video %d %s 33\r\n"
				"c=IN %s %s\r\n"
				"a=control:stream=%d\r\n"
				"a=fmtp:33 %s\r\n"
				"a=%s\r\n",
				t->mcast ? t->cport : 0,
				t->rtp ? "RTP/AVP" : "UDP",
				t->family == AF_INET ? "IP4" : "IP6",
				adr,
				str->nr,
				buf3,
				sendonly ? "sendonly" : "inactive"
			);
		if (len2 <= 0 || len2 >= sizeof(buf) - len)
			return -500;
		len += len2;
	}
	len2 = sprintf(buf2, "RTSP/1.0 200 OK\r\nCSeq: %d\r\n"
		       "Content-Type: application/sdp\r\n"
		       "Content-Base: rtsp://%s/\r\n"
		       "Content-Length: %d\r\n"
		       "\r\n", 
		       con->seq, con->sadr_ip, len);

	/* URGH, some receivers (cough Kathr** cough) cannot handle
           split RTSP messages */
#if 0
	sendlen(con->sock, buf2, len2);
	sendlen(con->sock, buf, len);
#else
	memcpy(buf2 + len2, buf, len);
	sendlen(con->sock, buf2, len + len2);
	//dump(buf2, len + len2);
#endif
	dbgprintf(DEBUG_RTSP, "Send:\n%s", buf2);
	dbgprintf(DEBUG_RTSP, "%s\n", buf);
	return 0;
}

static void send_describe2(struct oscon *con, char *url)
{
	uint8_t buf[1024], buf2[1024], *p;
	int len, len2;

	//while (*url && *url != '?')
	//url++;
	p = url;
	while (*p && *p != ' ')
		p++;
	*p = 0;

	len = snprintf(buf, sizeof(buf),
		       "v=0\r\n"
		       "o=- 9876543210 1 IN IP4 %s\r\n"
		       "s=MPEG TS\r\n"
		       "t=0 0\r\n"
		       "m=video 0 RTP/AVP 33\r\n"
		       "c=IN IP4 0.0.0.0\r\n"
		       "a=control:%s\r\n", 
		       con->sadr_ip,
		       url
		);
	if (len <= 0 || len >= sizeof(buf))
		return;
	len2=sprintf(buf2, "RTSP/1.0 200 OK\r\nCSeq: %d\r\nContent-Type: application/sdp\r\n"
		     "Content-Length: %d\r\n\r\n", con->seq, len);

	sendlen(con->sock, buf2, len2);
	sendlen(con->sock, buf, len);
	dbgprintf(DEBUG_RTSP, "Send:\n%s", buf2);
	dbgprintf(DEBUG_RTSP, "%s\n", buf);
}

#define MAX_PID 32

static int getsparam(char *b, char *name, char *q[], struct dvb_params *p, int type)
{
	int s, l = strlen(name), m;

	if (strncasecmp(b, name, l))
		return 0;
	b += l;
	if (b[0] == '&' || b[0] == ' ' || !b[m])
		return l;
	for (s = 1; q[s]; s++) {
		m = strlen(q[s]);
		if (!strncasecmp(b, q[s], m) &&
		    (b[m] == '&' || b[m] == ' ' || !b[m])) {
			p->param[type] = s; 
			p->set |= (1UL << type);
			dbgprintf(DEBUG_SYS, "%s%d(%s), ", name, p->param[type], q[s]);
			return l + m;
		}
	}
	return -1;
}

static int parse_url(struct oscon *con, int streamonly)
{
	struct dvb_params *p = &con->p;
	char *url, *end;
	struct ossess *oss;
	uint32_t pid;
	int s, l;
	
	dbgprintf(DEBUG_SYS, "parsing URL : %s\n", con->url);
	memset(p, 0, sizeof(struct dvb_params));

	for (url = con->url; *url == ' '; url++);
	if (strncasecmp(url, "rtsp://", 7))
		return -1;
	for (url += 7; *url != '/'; url++)
		if (*url == '\0')
			return 0;
	url++;
	if (*url == '\0' || *url == ' ')
		return 0;
	if (*url != '?') {
		if (strncasecmp(url, "stream=", 7))
			return -1;
		url += 7;
		errno = 0;
		p->param[PARAM_STREAMID] = strtoul(url, &end, 10);
		if (errno)
			return -1;
		p->set |= (1UL << PARAM_STREAMID);
		dbgprintf(DEBUG_SYS, "streamid = %d, ", p->param[PARAM_STREAMID]);
		url = end;
	} 
	if (*url != '\0' && *url != ' ' && *url != '?')
		return -1;
	if (!streamonly && *url == '?') {
		do {
			url++;	
			if (!strncasecmp(url, "src=", 4)) {
				url += 4;
				errno = 0;
				p->param[PARAM_SRC] = strtoul(url, &end, 10);
				if (url == end)
					return -1;
				p->set |= (1UL << PARAM_SRC);
				dbgprintf(DEBUG_SYS, "src=%d, ", p->param[PARAM_SRC]);
			} else if (!strncasecmp(url, "fe=", 3)) {
				url += 3;
				p->param[PARAM_FE] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_FE);
				dbgprintf(DEBUG_SYS, "fe=%d, ", p->param[PARAM_FE]);
			} else if (!strncasecmp(url, "c2tft=", 6)) {
				url += 6;
				p->param[PARAM_C2TFT] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_C2TFT);
				dbgprintf(DEBUG_SYS, "c2tft=%d, ", p->param[PARAM_C2TFT]);
			} else if (!strncasecmp(url, "ds=", 3)) {
				url += 3;
				p->param[PARAM_DS] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_DS);
				dbgprintf(DEBUG_SYS, "ds=%d, ", p->param[PARAM_C2TFT]);
			} else if (!strncasecmp(url, "plp=", 4)) {
				url += 4;
				p->param[PARAM_PLP] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_PLP);
				dbgprintf(DEBUG_SYS, "plp=%d, ", p->param[PARAM_PLP]);
			} else if (!strncasecmp(url, "specinv=", 8)) {
				url += 8;
				p->param[PARAM_SPECINV] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_SPECINV);
				dbgprintf(DEBUG_SYS, "plp=%d, ", p->param[PARAM_PLP]);
			} else if (!strncasecmp(url, "sm=", 3)) {
				url += 3;
				p->param[PARAM_SM] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_SM);
				dbgprintf(DEBUG_SYS, "sm=%d, ", p->param[PARAM_SM]);
			} else if (!strncasecmp(url, "t2id=", 5)) {
				url += 5;
				p->param[PARAM_T2ID] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_T2ID);
				dbgprintf(DEBUG_SYS, "t2id=%d, ", p->param[PARAM_T2ID]);
			} else if (!strncasecmp(url, "x_isi=", 6)) {
				url += 6;
				p->param[PARAM_ISI] = strtoul(url, &end, 10);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_ISI);
				dbgprintf(DEBUG_SYS, "x_isi=%d, ", p->param[PARAM_ISI]);
			} else if (!strncasecmp(url, "x_pls=", 6)) {
				url += 6;
				p->param[PARAM_PLS] = strtoul(url, &end, 0);
				if (end == url)
					break;
				p->set |= (1UL << PARAM_PLS);
				dbgprintf(DEBUG_SYS, "x_pls=%d, ", p->param[PARAM_PLS]);
			} else if (!strncasecmp(url, "freq=", 5)) {
				float f;

				url += 5;
				f = strtof(url, &end);
				p->param[PARAM_FREQ] = f * 1000.0;
				if (url == end)
					return -1;
				p->set |= (1UL << PARAM_FREQ);
				dbgprintf(DEBUG_SYS, "freq=%u.%03u, ", 
					  p->param[PARAM_FREQ] / 1000,
					  p->param[PARAM_FREQ] % 1000);
			} else if ((l = getsparam(url, "pol=", pol2str, p, PARAM_POL))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if ((l = getsparam(url, "msys=", msys2str, p, PARAM_MSYS))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if ((l = getsparam(url, "ro=", roll2str, p, PARAM_RO))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if ((l = getsparam(url, "mtype=", mtype2str, p, PARAM_MTYPE))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if ((l = getsparam(url, "gi=", gi2str, p, PARAM_GI))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if ((l = getsparam(url, "tmode=", tmode2str, p, PARAM_TMODE))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if ((l = getsparam(url, "plts=", pilot2str, p, PARAM_PLTS))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if (!strncasecmp(url, "sr=", 3)) {
				url += 3;
				p->param[PARAM_SR] = strtoul(url, &end, 10);
				p->set |= (1UL << PARAM_SR);
				dbgprintf(DEBUG_SYS, "sr=%d, ", p->param[PARAM_SR]);
#if 0 
			} else if ((l = getsparam(url, "bw=", bw2str, p, PARAM_BW))) {
				if (l < 0)
					return l;
				end = url + l;
#else
			} else if (!strncasecmp(url, "bw=", 3)) {
				float f;

				url += 3;
				f = strtof(url, &end);
				p->param[PARAM_BW_HZ] = f * 1000000.0;
				if (f == 5.0)
					p->param[PARAM_BW] = BANDWIDTH_5_MHZ;
				else if (f == 6.0)
					p->param[PARAM_BW] = BANDWIDTH_6_MHZ;
				else if (f == 7.0)
					p->param[PARAM_BW] = BANDWIDTH_7_MHZ;
				else if (f == 8.0)
					p->param[PARAM_BW] = BANDWIDTH_8_MHZ;
				else if (f == 10.0)
					p->param[PARAM_BW] = BANDWIDTH_10_MHZ;
				else if (f == 1.712)
					p->param[PARAM_BW] = BANDWIDTH_1_712_MHZ;
				else
					return -1;
				p->param[PARAM_BW]++;
				if (url == end)
					return -1;
				p->set |= (1UL << PARAM_BW);
				p->set |= (1UL << PARAM_BW_HZ);
#endif
			} else if ((l = getsparam(url, "fec=", fec2str, p, PARAM_FEC))) {
				if (l < 0)
					return l;
				end = url + l;
			} else if (!strncasecmp(url, "pids=", 5)) {
				if (p->set & ((1UL << PARAM_APID) | (1UL << PARAM_DPID)))
					return -1;
				url += 5;
				memset(p->pid, 0, 0x400);
				do {
					pid = strtoul(url, &end, 10);
					if (url == end) {
						if (!strncasecmp(url, "all", 3)) {
							memset(p->pid, 0xff, 0x400);
							end = url + 3;
						} else if (!strncasecmp(url, "none", 4)) {
							memset(p->pid, 0x00, 0x400);
							end = url + 4;
						} else
							return -1;
					} else {
						if (pid > 8191)
							return -1;
						p->pid[pid >> 3] |= (1 << (pid & 7));
					}
					url = end;
				} while (*(url++) == ',');
				p->set |= (1UL << PARAM_PID);
			} else if (!strncasecmp(url, "addpids=", 8)) {
				if (p->set & (1UL << PARAM_PID))
					return -1;
				url += 8;
				do {
					pid = strtoul(url, &end, 10);
					if (url == end)
						return -1;
					url = end;
					p->pid[pid >> 3] |= (1 << (pid & 7));
					dbgprintf(DEBUG_SYS, "add PID=%d, ", pid);
				} while (*(url++) == ',');
				p->set |= (1UL << PARAM_APID);
			} else if (!strncasecmp(url, "delpids=", 8)) {
				if (p->set & (1UL << PARAM_PID))
					return -1;
				url += 8;
				do {
					pid = strtoul(url, &end, 10);
					if (url == end)
						return -1;
					url = end;
					p->dpid[pid >> 3] |= (1 << (pid & 7));
					dbgprintf(DEBUG_SYS, "del PID=%d, ", pid);
				} while (*(url++) == ',');
				p->set |= (1UL << PARAM_DPID);
			} else if (!strncasecmp(url, "x_pmt=", 6)) {
				uint32_t pmt, sid, num = 0;
				
				url += 6;
				do {
					pmt = strtoul(url, &end, 10);
					if (url == end || pmt >= 8192) 
						return -1;
					if (*end == '.') {
						url = end + 1;
						sid = strtoul(url, &end, 10);
						if (url == end) 
							return -1;
						pmt |= (sid << 16);
					}
					if (num < MAX_PMT)
						p->pmt[num++] = pmt;
					dbgprintf(DEBUG_SYS, "+PMT=%08x, ", pmt);
					url = end;
				} while (*(url++) == ',');
				p->set |= (1UL << PARAM_PMT);
			} else if (!strncasecmp(url, "x_ci=", 5)) {
				url += 5;
				p->param[PARAM_CI] = strtoul(url, &end, 10);
				if (url == end)
					return -1;
				p->set |= (1UL << PARAM_CI);
				dbgprintf(DEBUG_SYS, "ci=%d, ", p->param[PARAM_CI]);
			} else {
				dbgprintf(DEBUG_SYS, "unknown parameter %s\n", url);
				while (*url != '&' && *url && *url != ' ')
					url++;
				end = url;
				/* ignore unknown parameters: return -1; */
			}
			url = end;
		} while (*url == '&');
	}
	while (*url == '/')
		url++;
	if (*url != ' ') 
		return -1;
	while (*url == ' ')
		url++;
	if (strncasecmp(url, "RTSP/1.0", 8))
		return -1;
	dbgprintf(DEBUG_SYS, "\n");
	return 0;
}

static int set_rtcp_msg(struct ossess *sess)
{
	char rtcp[512 - 96 - 102];
	int len;
	struct dvb_ns_rtcp rtcpm = { .msg = rtcp};

	if (!sess->state)
		return -1;
	len = session_string(sess, rtcp, sizeof(rtcp));
	if (len <= 0)
		return -1;
	rtcpm.len = len;
	dbgprintf(DEBUG_RTSP, "%s\n", rtcp);
	if (sess->nsfd < 0)
		return -1;
	return ioctl(sess->nsfd, NS_SET_RTCP_MSG, &rtcpm);
}

static int set_rtcp_msgs(struct osstrm *str)
{
	char rtcp[512 - 96 - 102];
	int len;
	struct dvb_ns_rtcp rtcpm = { .msg = rtcp};
	int i;
	struct ossess *sess;
	
	if (!str->state)
		return -1;
	for (i = 0; i < MAX_SESSION; i++) {
		sess = &str->os->session[i];
		if (!sess->state)
			continue;
		len = session_string(sess, rtcp, sizeof(rtcp));
		if (len <= 0)
			continue;
		rtcpm.len = len;
		dbgprintf(DEBUG_RTSP, "%s\n", rtcp);
		
		if (sess->stream && (sess->stream == str) && (sess->nsfd > 0))
			ioctl(sess->nsfd, NS_SET_RTCP_MSG, &rtcpm);
	}
	return 0;
}

static int set_ns(struct ossess *sess, struct dvb_ns_params *nsp)
{
	struct osstrm *str = sess->stream; 
	int fd = sess->nsfd;
	uint8_t *pids = sess->p.pid;
	
	if (fd < 0)
		return 0;
	dbgprintf(DEBUG_SYS, "%s\n", __FUNCTION__);
	ioctl(fd, NS_SET_NET, nsp);
	set_rtcp_msg(sess);
	ioctl(fd, NS_SET_PIDS, &pids);
	return 0;
}

static int get_ns(struct ossess *sess)
{
	struct dvbfe *fe = sess->stream->fe;
	char fname[80];

	sprintf(fname, "/dev/dvb/adapter%d/ns%d", fe->anum, fe->fnum); 
	sess->nsfd = open(fname, O_RDWR);
	if (sess->nsfd < 0 && errno != 2) {
		dbgprintf(DEBUG_SYS, "no ns free\n");
		return -1;
	}
	dbgprintf(DEBUG_SYS, "got fd %d, for %s\n", sess->nsfd, fname);
	return 0;
}

static int setup_nsp(struct ostrans *trans, struct dvb_ns_params *nsp)
{
	void *adr;
	
	memset(nsp, 0, sizeof(struct dvb_ns_params));
	memcpy(nsp->dmac, trans->cmac, 6);
	memcpy(nsp->smac, trans->smac, 6);
	nsp->smac[5] |= 1;
	nsp->sport = trans->sport;
	nsp->sport2 = trans->sport2;
	nsp->dport = trans->cport;
	nsp->dport2 = trans->cport2;
	if (trans->rtp) {
		nsp->flags = DVB_NS_RTP | DVB_NS_RTCP;
		if (!(trans->flags & TRANS_NO_RTP_TO))
			nsp->flags |= DVB_NS_RTP_TO;
	}
	nsp->qos = 5;
	nsp->vlan = 0;
	nsp->ttl = 64;
	dbgprintf(DEBUG_SYS, "ports: %d-%d %d-%d\n", 
		  nsp->sport, nsp->sport2, nsp->dport, nsp->dport2);

	memcpy(nsp->sip, trans->sip, 16);
	memcpy(nsp->dip, trans->cip, 16);

	if (trans->mcast) {
		uint8_t *mac = adr;

		memcpy(nsp->dmac, trans->mcmac, 6);
		memcpy(nsp->dip, trans->mcip, 16);

		nsp->ttl = trans->ttl ? trans->ttl : 2;

		//dump(nsp->dmac, 6);
		//dump(nsp->dip, 16);
		dbgprintf(DEBUG_SYS, "MC STREAM\n");
	}
	memcpy(nsp->ssrc, trans->ssrc, 4);
	return 0;
}

static int merge_pids(struct dvb_params *op, struct dvb_params *p)
{
	int i, r = 0;

	if (p->set & (1UL << PARAM_PID)) 
		for (i = 0 ; i < 1024 ; i++)
			if (op->pid[i] != p->pid[i]) {
				r |= 1;
				op->pid[i] = p->pid[i];
			}
	if (p->set & (1UL << PARAM_APID))
		for (i = 0 ; i < 1024 ; i++)
			if (!(op->pid[i] & p->pid[i])) {
				r |= 2;
				op->pid[i] |= p->pid[i];
			}
	if (p->set & (1UL << PARAM_DPID)) 
		for (i = 0 ; i < 1024 ; i++)
			if (op->pid[i] & p->dpid[i]) {
				r |= 4;
				op->pid[i] &= ~p->dpid[i];
			}
	return r;
}

static int merge_params(struct dvb_params *op, struct dvb_params *p)
{
	int i;

	if (p->set & 0xfff8) { 
		for (i = PARAM_FE ; i < PARAM_PID ; i++)
			if (p->set & (1UL << i)) {
				op->param[i] = p->param[i];
				dbgprintf(DEBUG_SYS, "para %d = %d\n", i, p->param[i]);
				op->set |= (1UL << i);
			}
	}
}

static void copy_params(struct ossess *s, struct ossess *t)
{
	memcpy(&s->p, &t->p, sizeof(struct dvb_params));
}

static void adjust_no_sessions(struct ossess *oss)
{
	struct octoserve *os = oss->os;
	struct osstrm *str = oss->stream;
	int i;
	
	dbgprintf(DEBUG_SYS, "adjust session nr %d id %010d\n", oss->nr, oss->id);
	for (i = 0; i < MAX_SESSION; i++) {
		struct ossess *nso = &os->session[i];

		if (nso->state && (nso->stream == str) && (nso != oss)) {
			uint8_t *pids = nso->p.pid;

			memcpy(&nso->p, &oss->p, sizeof(struct dvb_params));
			if (nso->nsfd >= 0)
				ioctl(nso->nsfd, NS_SET_PIDS, &pids);
		}
	}
}

static int setup_session(struct oscon *con, int newtrans)
{
	struct dvbfe *fe;
	struct dvb_ns_params nsp;
	struct ossess *sess = con->session;
	struct dvb_params *p = &con->p;
	struct dvb_params *sp = &sess->p;
	struct ostrans *trans = &con->trans;
	struct osstrm *str = sess->stream;
	struct ossess *ownsess = str->session;
	int pidchange;
	int owner = 0, tuned = 0;
	
	if (sess == ownsess)
		owner = 1;
	if (!str)
		return -500;
	pidchange = merge_pids(sp, p);
	
	dbgprintf(DEBUG_DEBUG, "stream setup newtrans=%u pidchange=%u\n",
		  newtrans, pidchange);
	if (owner) { /* stream owner */
		dbgprintf(DEBUG_DEBUG, "stream owner setup\n");
		merge_params(sp, p);
		
		if (str->fe && (sp->set & (1UL << PARAM_FE)) &&
		    (sp->param[PARAM_FE] != str->fe->nr)) {
			release_fe(con->os, str->fe);
			if (sess->nsfd >= 0)
				close(sess->nsfd);
		}
		if (!str->fe) {
			if (!(sp->set & (1UL << PARAM_MSYS)))
				return 0;
			if (sp->set & (1UL << PARAM_FE))
				fe = alloc_fe_num(sess->os, 
						  sp->param[PARAM_FE] - 1,
						  sp->param[PARAM_MSYS] - 1);
			else
				fe = alloc_fe(sess->os, 
					      sp->param[PARAM_MSYS] - 1);
			if (!fe) {
				dbgprintf(DEBUG_SYS, "no fe\n");
				return -404;
			}
			str->fe = fe;
			dvb_tune(str->fe, sp);
			tuned = 1;
		} else if (p->set & 0xffff8) { 
			dvb_tune(str->fe, sp);
			tuned = 1;
		}
	} else {
		dbgprintf(DEBUG_DEBUG, "non stream owner setup\n");
		if (pidchange && conform) {
                        /* non-owner tried to change pids,
			   copy back owner pids and return error */
			copy_params(sess, ownsess);
			return -455;
		}
	}
	if (sess->nsfd < 0) {
		dbgprintf(DEBUG_DEBUG, "no fd, conform=%u owner=%u mc=%u\n",
			  conform, owner, sess->trans.mcast);
		if (conform && !owner && sess->trans.mcast) {
			dbgprintf(DEBUG_DEBUG, "conform non-owner MCAST owner MC=%u\n",
				ownsess->trans.mcast);
			if (!ownsess->trans.mcast)
				return -455;
		} else {
			dbgprintf(DEBUG_DEBUG, "owner or unicast get fd\n");
#ifndef IGNORE_NS
			if (get_ns(sess) < 0)
				return -455;
#endif
			newtrans |= 256;
		}
	} 
 	if (newtrans) {
		if (sess->trans.mcast && conform) {
			if (owner && (newtrans & ~1UL))
				release_no_sessions(sess);
			else {
				memcpy(&sess->trans, &str->session->trans, sizeof(struct ostrans));
				dbgprintf(DEBUG_RTSP, "non-owner tried to change transport parameters\n");
			}
		}
		if (setup_nsp(&sess->trans, &nsp) < 0)
			return -1;
		if (set_ns(sess, &nsp) < 0)
			return -1;
	} else if (pidchange) {
		uint8_t *pids = (sp->pid);
		
		if (sess->nsfd >= 0)
			ioctl(sess->nsfd, NS_SET_PIDS, &pids);
	}
	if (conform && owner && (pidchange || tuned)) 
		adjust_no_sessions(sess);
	
	if (p->set & ((1UL << PARAM_CI))) {
		if (p->param[PARAM_CI] == 0 && str->ca)
			release_ca(str->ca);
		if (!str->ca) {
			if (sess->playing)
				return -455;
			str->ca = alloc_ca_num(str, p->param[PARAM_CI] - 1);
		}
		if (!str->ca)
			return -455;
	}
	if (p->set & ((1UL << PARAM_PMT))) {
		if (!str->ca) {
			if (sess->playing)
				return -455;
			str->ca = alloc_ca(str);
		}
		if (!str->ca)
			return -455;
		if (str->ca)
			set_pmt(str->ca, p->pmt);
	}
	if (con->session->trans.mcast) {
		update_switch_vec(sess);
	}
	return 0;
}

static int stop_session(struct ossess *sess)
{
	if (!session_is_playing(sess))
		return 0;
	sess->playing &= ~1;
	if (!session_is_playing(sess)) {
		printf("stopping session %d\n", sess->nr);
		if (sess->nsfd >= 0)
			ioctl(sess->nsfd, NS_STOP);
	}
	update_switch_vec(sess);
	return 0;
}

static int start_session(struct ossess *sess)
{
	if (!session_is_playing(sess)) {
		dbgprintf(DEBUG_SYS, "start session %d\n", sess->nr);
		if (sess->stream->ca) {
			uint8_t canum = sess->stream->ca->nr - 1;
			if (sess->nsfd >= 0)
				ioctl(sess->nsfd, NS_SET_CI, &canum);
		}
		if (sess->nsfd >= 0)
			ioctl(sess->nsfd, NS_START);
	}
	sess->playing |= 1;
	update_switch_vec(sess);
	return 0;
}

static int play_session(struct oscon *con)
{
	int res;
	struct ossess *sess = con->session;
	struct dvb_params *p = &con->p;
	struct ostrans *trans = &con->trans;
	struct octoserve *os = sess->os;
	struct osstrm *str = sess->stream;

	if (p) { 
		res = setup_session(con, 0);
		if (res < 0)
			return res;
	}
	dbgprintf(DEBUG_SYS, "%s fd %d\n", __FUNCTION__, sess->nsfd);
	pthread_mutex_lock(&os->lock);
	/* for strict multicast there is only the stream owners stream */
	if (sess->trans.mcast && conform) {
#ifndef IGNORE_NS
		if (str->session->nsfd < 0) 
			return -455;
#endif
		start_session(str->session);
	} else {
#ifndef IGNORE_NS
		if (sess->nsfd < 0) 
			return -455;
#endif
		start_session(sess);
	}
	dbgprintf(DEBUG_SYS, "%s set playing =2\n", __FUNCTION__);
	sess->playing |= 2;
	pthread_mutex_unlock(&os->lock);
	update_switch_vec(sess);
	return 0;
}

static struct ossess *match_session(struct octoserve *os, uint8_t *group)
{
	struct ossess *sess;
	int i;

	for (i = 0; i < MAX_SESSION; i++) {
		sess = &os->session[i];
		if (!sess->state || !sess->trans.mcast)
			continue;
		if (conform && sess->stream->session != sess)
			continue;
		if (!memcmp(sess->trans.mcip, group, 4))
			return sess;
	}
	return NULL;
}

void mc_check(struct ossess *sess, int update)
{
	struct osmcc *mcc, *next;
	struct octoserve *os = sess->os;

	if (sess->mcc_state && (os->igmp_mode & 1))
		return;
	pthread_mutex_lock(&os->lock);
	for (mcc = sess->mccs.lh_first; mcc; mcc = next) {
		next = mcc->mcc.le_next;
		if (((sess->mcc_state == 0) && (sess->mcc_tag != mcc->tag)) ||
		    (((os->igmp_mode & 1) == 0) && (os->igmp_tag - mcc->gtag) > 1)) {
			printf("removed client at %u.%u.%u.%u\n", 
			       mcc->ip[0], mcc->ip[1], mcc->ip[2], mcc->ip[3]);
			printf("mcc_tags: %d %d\n", sess->mcc_tag, mcc->tag);
			printf("gtags: %d %d\n", os->igmp_tag, mcc->gtag);
			LIST_REMOVE(mcc, mcc);
			free(mcc);
		}
	}
	if (update) {
		update_switch_vec(sess);
		if (!sess->mccs.lh_first)
			//if (mtime() > sess->mc_timeout)
			stop_session(sess);
	}
	pthread_mutex_unlock(&os->lock);
}

void mc_del(struct ossess *sess)
{
	struct osmcc *mcc, *next;
	struct octoserve *os = sess->os;

	pthread_mutex_lock(&os->lock);
	for (mcc = sess->mccs.lh_first; mcc; mcc = next) {
		next = mcc->mcc.le_next;
		LIST_REMOVE(mcc, mcc);
		free(mcc);
	}
	update_switch_vec(sess);
	pthread_mutex_unlock(&os->lock);
}

static void killall_sessions(struct octoserve *os)
{
	struct ossess *sess;
	int i;

	for (i = 0; i < MAX_SESSION; i++) {
		sess = &os->session[i];
		if (!sess->state)
			continue;
		release_session(sess);
	}
}

void mc_join(struct octoserve *os, uint8_t *ip, uint8_t *mac, uint8_t *group)
{
	struct ossess *sess;
	struct osmcc *mcc, *newmcc;

	pthread_mutex_lock(&os->lock);
	if ((sess = match_session(os, group)) == NULL)
		goto out;

	session_mc_timeout(sess);
	printf("matched session %d to join %u.%u.%u.%u\n", 
	       sess->nr, ip[0], ip[1], ip[2], ip[3]);
	for (mcc = sess->mccs.lh_first; mcc; mcc = mcc->mcc.le_next) 
		if (!memcmp(ip, mcc->ip, 4)) {
			mcc->tag = sess->mcc_tag;
			mcc->gtag = os->igmp_tag;
			printf("already in list, tag = %08x, gtag = %08x\n", mcc->tag, mcc->gtag);
			goto out;
		}
	newmcc = malloc(sizeof(struct osmcc));
	if (!newmcc) {
		printf("Could not allocate new multicast client entry\n");
		goto out;
	}
	memset(newmcc, 0, sizeof(struct osmcc));
	LIST_INSERT_HEAD(&sess->mccs, newmcc, mcc);
	memcpy(newmcc->ip, ip, 4);
	newmcc->tag = sess->mcc_tag;
	newmcc->gtag = os->igmp_tag;
	if (mac) {
		int port;

		memcpy(newmcc->mac, mac, 6);
		if (os->has_switch)
			port = switch_get_port(newmcc->mac);
		else 
			port = 0;
		printf("New client at port %02x\n", port);
		if (port >= 0) {
			newmcc->port_vec = port;
			sess->mcc_port_vec |= port;
		}
		update_switch_vec(sess);
	}
	start_session(sess);
out:
	pthread_mutex_unlock(&os->lock);
}

void mc_query(struct ossess *sess)
{
	/* query in group if anybody still there */
	if (!sess->mcc_state) {
		mtime(&sess->mcc_time);
		sess->mcc_state = 1;
	}
}

void mc_leave(struct octoserve *os, uint8_t *ip, uint8_t *group)
{
	struct ossess *sess;
	struct osmcc *mcc, *next;
	
	pthread_mutex_lock(&os->lock);
	if ((sess = match_session(os, group)) == NULL)	
		goto out;
	
	printf("matched session %d to leave %u.%u.%u.%u\n", 
	       sess->nr, ip[0], ip[1], ip[2], ip[3]);
	mc_query(sess);

	for (mcc = sess->mccs.lh_first; mcc; mcc = next) {
		next = mcc->mcc.le_next;
		if (!memcmp(ip, mcc->ip, 4)) {
			LIST_REMOVE(mcc, mcc);
			free(mcc);
#if 0
			if (!sess->mccs.lh_first)
				stop_session(sess);
			mc_query(sess);
#endif
			break;
		}
	}
	update_switch_vec(sess);
out:
	pthread_mutex_unlock(&os->lock);
}

static void send_play(struct oscon *con)
{
	uint8_t buf[1024];
	int len;

	len = sprintf(buf, 
		      "RTSP/1.0 200 OK\r\n"
		      "CSeq: %d\r\n"
		      "Session: %010d\r\n"
		      "RTP-Info: url=%s\r\n"
		      "\r\n", con->seq, con->session->id, con->url);
	sendlen(con->sock, buf, len);
	dbgprintf(DEBUG_RTSP, "Send: %s\n", buf);
}

static void send_teardown(struct oscon *con)
{
	uint8_t buf[256];
	int len;

	len=sprintf(buf, 
		    "RTSP/1.0 200 OK\r\n"
		    "CSeq: %d\r\n"
		    "Session: %010d\r\n"
		    "\r\n", con->seq, con->session->id);
	sendlen(con->sock, buf, len);
	dbgprintf(DEBUG_RTSP, "Send: %s\n", buf);
}

static int parse_transport(struct oscon *con, char *line)
{
	char *end, *arg;
	struct ostrans *t = &con->trans;
	int ttlset = 0;
	
	dbgprintf(DEBUG_RTSP, "parse: %s\n", line);

	for (arg = line; *arg == ' '; arg++);

	do {
		printf("arg:%s\n", arg);
		if (!strncasecmp(arg, "RTP/AVP/UDP", 11)) {
			t->rtp = 1;
			end = arg + 11;
		} else if (!strncasecmp(arg, "RTP/AVP", 7)) {
			t->rtp = 1;
			end = arg + 7;
		} else if (!strncasecmp(arg, "UDP", 3)) {
			t->rtp = 0;
			end = arg + 3;
		} else if (!strncasecmp(arg, "unicast", 7)) {
			t->mcast = 0;
			end = arg + 7;
		} else if (!strncasecmp(arg, "multicast", 9)) {
			t->mcast = 1;
			end = arg + 9;
		} else if (!strncasecmp(arg, "client_port=", 12)) {
			arg += 12;
			t->cport = strtoul(arg, &end, 10);
			if (*end == '-')
				t->cport2 = strtoul(end + 1, &end, 10);
			else
				t->cport2 = 0;
		} else if (!strncasecmp(arg, "port=", 5)) {
			arg += 5;
			t->cport = strtoul(arg, &end, 10);
			if (*end == '-')
				t->cport2 = strtoul(end + 1, &end, 10);
			else
				t->cport2 = 0;
		} else if (!strncasecmp(arg, "interleaved=", 12)) {
			return -461;
			arg += 12;
			strtoul(arg, &end, 10);
			strtoul(end + 1, &end, 10);
		} else if (!strncasecmp(arg, "ttl=", 4)) {
			arg += 4;
			t->ttl = strtoul(arg, &end, 10);
			ttlset = 1;
		} else if (!strncasecmp(arg, "destination=", 12)) {
			char c;
			
			arg += 12;
			end = arg;
			while (*end && *end != ';' && *end != ' ')
				end++;
			c = *end;
			*end = 0;
			inet_pton(AF_INET, arg, &t->mcip);
			t->mcmac[0] = 0x01;
			t->mcmac[1] = 0x00;
			t->mcmac[2] = 0x5e;
			t->mcmac[3] = t->mcip[1] & 0x7f;
			t->mcmac[4] = t->mcip[2];
			t->mcmac[5] = t->mcip[3];
			*end = c;
			t->flags |= TRANS_ALT_DEST;
		} else
			return -461;
		arg = end;
		if (*arg != ';' && *arg != ' ' && *arg != 0)
			return -461;
	} while (*(arg++) == ';');

	if (t->flags & TRANS_ALT_DEST && !t->mcast) {
		ip2mac(t->mcip, t->mcmac);		

	}
	if (!t->ttl && !ttlset)
		t->ttl = 2;
	dbgprintf(DEBUG_RTSP, "parsed\n");
	return 0;
}

static int parse_x_octonet(struct oscon *con, char *line)
{
	char *end, *arg;

	dbgprintf(DEBUG_RTSP, "parse: %s\n", line);

	for (arg = line; *arg == ' '; arg++);

	do {
		if (!strncasecmp(arg, "switch=", 7)) {
			uint32_t port;

			arg += 7;
			do {
				port = strtoul(arg, &end, 10);
				if (arg == end) 
					return -1;
				arg = end;
				if (port < 7)
					con->x_ports |= 1 << (port - 1);
			} while (*(arg++) == ',');
			printf("x_ports = %02x\n", con->x_ports);
		} else
			return -1;
		arg = end;
	} while (*(arg++) == ';');
	dbgprintf(DEBUG_RTSP, "parsed\n");
	return 0;
}

void send_setup(struct oscon *con)
{
	uint8_t buf[256];
	int len;
	struct ostrans *t = &con->session->trans;

	if (t->mcast) 
		len = sprintf(buf, 
			      "RTSP/1.0 200 OK\r\n"
			      "CSeq: %d\r\nSession: %010d;timeout=%u\r\n"
			      "Transport: %s;multicast;destination=%d.%d.%d.%d;"
			      "port=%d-%d;ttl=%d;source=%s\r\n"
			      "com.ses.streamID: %d\r\n\r\n", 
			      con->seq, con->session->id, con->session->timeout_len,
			      t->rtp ? "RTP/AVP" : "UDP",
			      t->mcip[0], t->mcip[1], t->mcip[2], t->mcip[3],
			      t->cport, t->cport2, t->ttl,
			      con->sadr_ip, con->session->stream->nr
			);
	else
		len = sprintf(buf, 
			      "RTSP/1.0 200 OK\r\n"
			      "CSeq: %d\r\nSession: %010d;timeout=%u\r\n"
			      "Transport: %s;unicast;client_port=%d-%d;server_port=%d-%d\r\n"
			      "com.ses.streamID: %d\r\n\r\n", 
			      con->seq, con->session->id, con->session->timeout_len,
			      t->rtp ? "RTP/AVP" : "UDP",
			      t->cport, t->cport2, 
			      con->session->stream->sport,
			      con->session->stream->sport2,
			      con->session->stream->nr
			);
	sendlen(con->sock, buf, len);
	dbgprintf(DEBUG_RTSP, "Send: %s\n", buf);
}

static void cpyarg(char *d, char *s)
{
	while (*s == ' ')
		s++;
	strcpy(d, s);
}


static int cmp_trans(struct ostrans *t,  struct ostrans *u)
{
	uint32_t ret = 0;
	
	if (t->ttl != u->ttl)
		ret |= 1;
	if (t->mcast != u->mcast)
		ret |= 2;
	if (t->cport != u->cport)
		ret |= 4;
	if (t->cport2 != u->cport2)
		ret |= 8;
	if (t->flags != u->flags)
		ret |= 16;
	return ret;
}

static int proc_setup(struct oscon *con)
{
	struct osstrm *str = 0;
	uint32_t newtrans = 0;
	int res;
	
	if (!con->transport_parsed) {
		/* no proper transport params given */
		send_error(con, 400);
		return -1;
	}
	if (con->session_parsed && !con->session) {
		/* no session with given ID found */
		send_error(con, 454);
		return -1;
	}
	if (parse_url(con, 0) < 0) {
		/* invalid params in URL */
		send_error(con, 400);
		return -1;
	} 
	if (con->p.set & (1UL << PARAM_STREAMID)) {
		dbgprintf(DEBUG_SYS, "existing stream %d\n",
			  con->p.param[PARAM_STREAMID]);
		str = get_stream(con->os, con->p.param[PARAM_STREAMID]);
		if (!str) {
			/* no stream with given ID  */
			send_error(con, 400);
			return -1;
		}
		
#if 0
		if (con->session && con->session != str->session) {
			/* if we already have a session ID we
			   have to be stream owner  */
			send_error(con, 400);
			return -1;
		}
#endif
	}
	if (!con->session) {
		/* alloc new session */
		con->session = alloc_session(con->os);
		if (!con->session) {
			send_error(con, 400);
			return -1;
		}
		con->state = 2;
		if (!con->session->stream) {
			if (str) {
				/* use existing stream and stream params*/
				con->session->stream = str;
				if (con->session->stream->session) {
					memcpy(&con->session->p,
					       &con->session->stream->session->p,
					       sizeof(struct dvb_params));
				}
			} else {
				con->session->stream = alloc_stream(con->os);
				if (!con->session->stream) {
					send_error(con, 400);
					return -1;
				}
				con->session->stream->session = con->session;
			}
		}
		newtrans = 256;
	}
	newtrans |= cmp_trans(&con->session->trans, &con->trans);
	if (newtrans) {
		con->trans.sport = con->session->stream->sport;
		con->trans.sport2 = con->session->stream->sport2;
		
		/* set transport struct according to session
		   and transport parameters */
		if (con->trans.mcast && con->trans.cport == 0) {
			con->trans.cport = con->trans.sport;
			con->trans.cport2 = con->trans.sport2;
		}
		
		if (con->trans.mcast &&
		    !(con->trans.flags & TRANS_ALT_DEST)) {
			uint8_t mac[6] = { 0x01, 0x00, 0x5e, 
					   con->os->ssdp.devid & 0x7f, 1,
					   con->session->stream->nr };
			uint8_t ip[4]  = { 239, con->os->ssdp.devid, 1,
					   con->session->stream->nr };
			
			memcpy(con->trans.mcmac, mac, 6);
			memcpy(con->trans.mcip, ip, 4);
		}
		con->session->trans = con->trans;
	}
	res = setup_session(con, newtrans);
	if (res < 0) {
		release_session(con->session);
		send_error(con, -res);
	} else
		send_setup(con);
	return 0;
}


static int proc_line(struct oscon *con)
{
	char *line = con->buf;
	int res;

	if (con->ln == 0) {
		if (!strncasecmp(line, "OPTIONS", 7)) {
			cpyarg(con->url, line + 7); 
			con->cmd = M_OPTIONS;
		} else if (!strncasecmp(line, "DESCRIBE", 8)) {
			cpyarg(con->url, line + 8); 
			con->cmd = M_DESCRIBE;
		} else if (!strncasecmp(line, "SETUP", 5)) {
			cpyarg(con->url, line + 5); 
			con->cmd = M_SETUP;
		} else if (!strncasecmp(line, "PLAY", 4)) {
			cpyarg(con->url, line + 4); 
			con->cmd = M_PLAY;
		} else if (!strncasecmp(line, "TEARDOWN", 8)) {
			cpyarg(con->url, line + 8); 
			con->cmd = M_TEARDOWN;
		} else {
			con->cmd = M_UNKNOWN;
			return -1;
		}
		return 0;
	}

	if (line[0] == '\0') { /* last line */
		if (con->error) {
			send_error(con, con->error);
		} else {
			switch (con->cmd) {
			case M_OPTIONS:
				if (con->session_parsed && !con->session)
					send_error(con, 404);
				else
					send_option(con);
				break;
			case M_DESCRIBE:
			{
				int only = -1;
				
				if (parse_url(con, 0) < 0) {
					send_error(con, 400);
					break;
				} 
				if (con->p.set & ~(1UL << PARAM_STREAMID)) {
					send_describe2(con, con->url);
					break;
				}
				if (con->p.set & (1UL << PARAM_STREAMID)) 
					only = con->p.param[PARAM_STREAMID];
				res = send_describe(con, only);
				if (res < 0)
					send_error(con, -res);
				break;
			}
			
			case M_SETUP:
				proc_setup(con);
				break;

			case M_PLAY:
				if (!con->session || !con->session->stream) {
					send_error(con, 400);
					break;
				}
				if (parse_url(con, 0) < 0) {
					send_error(con, 400);
					break;
				} 
				if (con->x_octonet_parsed) {
					con->session->port_vec = con->x_ports;
					printf("port_vec = %02x\n", con->session->port_vec);
				}
				res = play_session(con);
				if (res < 0) 
					send_error(con, -res);
				else
					send_play(con);
				break;
			case M_TEARDOWN:
				if (parse_url(con, 0) < 0) {
					send_error(con, 400);
					break;
				} 
				if (!con->session) {
					send_error(con, 404);
					break;
				}
				send_teardown(con);
				release_session(con->session);
				break;
			default:
				send_error(con, 501);
				break;
			}
		}
		con->cmd = M_NONE;
		con->transport_parsed = 0;
		con->session_parsed = 0;
		con->error = 0;
		con->ln = -1;
		return 0;
	} 
	
	if (!strncasecmp(line, "CSeq:", 5)) {
		con->seq = strtoul(line + 5, NULL, 10);
		//printf("CSeq = %d\n", con->seq);
	} else if (!strncasecmp(line, "Transport:", 10)) {
		res = parse_transport(con, line + 10);
		if (res < 0) {
			con->error = -res;
		} else
			con->transport_parsed = 1;
	} else if (!strncasecmp(line, "Session:", 8)) {
		uint32_t sid = strtoul(line + 8, NULL, 10);
		
		con->session = get_session(con->os, sid);
		if (con->session)
			session_timeout(con->session);
		con->state = 2;
		con->session_parsed = 1;
	} else if (!strncasecmp(line, "User-Agent:", 11)) {
		char *p = line + 11;
		
		while (*p == ' ')
			p++;
		if (!strncasecmp(p, "libvlc", 6))
			con->trans.flags |= TRANS_NO_RTP_TO;
	} else if (!strncasecmp(line, "x_octonet:", 10)) {
		char *p = line + 10;
		
		while (*p == ' ')
			p++;
		parse_x_octonet(con, p);
		con->x_octonet_parsed = 1;
	} else 
		;//con->error = 551;
	return 0;
}

static const char *intop(int af, struct sockaddr *sa, char *dst, socklen_t size, uint8_t *ip)
{
       void *adr;

       if (af == AF_INET) 
		adr = &((struct sockaddr_in *) sa)->sin_addr;
       else if (af == AF_INET6)
	       adr = &((struct sockaddr_in6 *) sa)->sin6_addr;
       else 
	       return NULL;

       memcpy(ip, adr,  af == AF_INET ? 4 : 16);
       return inet_ntop(af, adr, dst, size);
}

static void get_ips(struct oscon *con)
{
	con->slen = sizeof(con->sadr);
	con->clen = sizeof(con->cadr);
	getsockname(con->sock, (struct sockaddr *) &con->sadr, &con->slen);
	intop(con->trans.family, &con->sadr, con->sadr_ip, INET6_ADDRSTRLEN, con->trans.sip);
	getpeername(con->sock, (struct sockaddr *) &con->cadr, &con->clen);
	intop(con->trans.family, &con->cadr, con->cadr_ip, INET6_ADDRSTRLEN, con->trans.cip);
}

static int same_ip(struct sockaddr *sa, struct sockaddr *sa2)
{
	unsigned short af = sa->sa_family;
	
	if (af != sa2->sa_family)
		return -1;
	if (af == AF_INET) 
		return memcmp(&((struct sockaddr_in *) sa)->sin_addr,
			      &((struct sockaddr_in *) sa2)->sin_addr, 4);
	else if (af == AF_INET6)
		return memcmp(&((struct sockaddr_in6 *) sa)->sin6_addr,
			      &((struct sockaddr_in6 *) sa2)->sin6_addr, 16);
	else
		return -1;
}

static void init_con(struct oscon *con)
{
	int one = 1, idle = 20, intvl = 20, cnt = 3;

	get_ips(con);
	if (!same_ip(&con->sadr, &con->cadr))
		memcpy(con->trans.cmac, con->os->mac, 6);
	else
		get_mac(con->os->ifname, &con->cadr, con->trans.cmac);
	memcpy(con->trans.smac, con->os->mac, 6);
	con->bufp = 0;
	con->ln = 0;
	con->session = 0;
	setsockopt(con->sock, SOL_SOCKET, SO_KEEPALIVE, &one, sizeof(one));
#if 1
	setsockopt(con->sock, SOL_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
	setsockopt(con->sock, SOL_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl));
	setsockopt(con->sock, SOL_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt));
#else
	setsockopt(con->sock, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof(idle));
	setsockopt(con->sock, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof(intvl));
	setsockopt(con->sock, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof(cnt));
	
#endif
}


static void con_check(struct octoserve *os)
{
	int i;
	time_t t = mtime(NULL);

	for (i = 0; i < MAX_CONNECT; i++) {
		if (os->con[i].state == 3 &&
		    t > os->con[i].timeout)
			release_con(&os->con[i]);
	}
}

int con_loop(struct oscon *con)
{
	uint8_t buf[1024];
	int len, i, res;

	len = recv(con->sock, buf, 1024, 0);
	if (len == 0) 
		goto release;
	if (len < 0) {
		if (errno != EAGAIN) 
			goto release;
		return 0;
	}
	if (debug & DEBUG_RTSP)
		dump(buf, len);
	//printf("received %d bytes\n", len);
	for (i = 0; i < len; i++) {
		// FIXME send URI too long
		if (con->bufp >= 8192) {
			goto release;
		}
		con->buf[con->bufp++] = buf[i];
		if (buf[i] == '\n') {
			if (con->bufp < 2 || 
			    con->buf[con->bufp - 2] != '\r') {
				goto release;
			}
			con->buf[con->bufp - 2] = 0;
			if (con->buf[0])
				dbgprintf(DEBUG_SYS, "%d:%d:%d: %s\n", 
					  con->nr, con->ln, 
					  con->bufp, con->buf);
			res = proc_line(con);
			con->ln++;
			con->bufp = 0;
		}
	}
	return 0;
release:
	dbgprintf(DEBUG_SYS, "release\n");
	release_con(con);
	return -1;
}

void handle_con(struct oscon *con)
{
	while (con_loop(con) >= 0);
}

int set_nonblock(int fd)
{
	int fl = fcntl(fd, F_GETFL);
	
	if (fl < 0)
		return fl;
	return fcntl(fd, F_SETFL, fl | O_NONBLOCK);
}

int set_block(int fd)
{
	int fl = fcntl(fd, F_GETFL);
	
	if (fl < 0)
		return fl;
	return fcntl(fd, F_SETFL, fl & ~O_NONBLOCK);
}

void check_frontends(struct octoserve *os)
{
	int i;
	struct dvbfe *fe;
	uint16_t sig, snr;
	fe_status_t stat;

	for (i = 0; i < os->dvbfe_num; i++) {
		fe = &os->dvbfe[i];
		if (fe->state != 1)
			continue;
		if (ioctl(fe->fd, FE_READ_STATUS, &stat) < 0)
			continue;
		if (ioctl(fe->fd, FE_READ_SIGNAL_STRENGTH, &sig) < 0)
			continue;
		if (ioctl(fe->fd, FE_READ_SNR, &snr) < 0)
			continue;
		fe->stat = stat;
		fe->lock = (stat == 0x1f) ? 1 : 0;
		fe->level = sig >> 8;
		fe->quality = snr >> 12;
		dbgprintf(DEBUG_DVB, "fe%d: stat=%02x str=%04x snr=%04x\n", fe->nr, stat, sig, snr);
	}
}

static int check_streams(struct octoserve *os)
{
	int i;
	struct osstrm *str;
	
	for (i = 0; i < MAX_STREAM; i++) {
		str = &os->stream[i];
		if (!str->state)
			continue;
		set_rtcp_msgs(str);
	}
	return 0;
}


static int alloc_igmp_socket(struct octoserve *os)
{
	struct ip_mreq imr;
	struct sockaddr_in sadr;
	uint8_t one = 1;
	
	os->igmp_sock = socket(AF_INET, SOCK_RAW, IPPROTO_IGMP); 

	set_nonblock(os->igmp_sock);
	get_ifa(os->ifname, AF_INET, (struct sockaddr *) &sadr);
	imr.imr_interface.s_addr = sadr.sin_addr.s_addr;
	imr.imr_multiaddr.s_addr = inet_addr("224.0.0.22");
	setsockopt(os->igmp_sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
		   &imr, sizeof(imr));
	setsockopt(os->igmp_sock, IPPROTO_IP, IP_MULTICAST_TTL, 
		   &one, sizeof(one));
	setsockopt(os->igmp_sock, IPPROTO_IP, IP_ROUTER_ALERT, 
		   &one, sizeof(one));
	mtime(&os->igmp_time);
	/* first query after 125-94=31 seconds */
	os->igmp_mode = 0;
	os->igmp_time -= 94;
	os->igmp_robust = 1;
	return 0;
}

static int alloc_igmp_raw_socket(struct octoserve *os)
{
	struct ifreq ifr;
	int s, n, i;
	struct sockaddr cadr;
	socklen_t len = sizeof(cadr);
	uint8_t buf[4096];
	struct sock_filter bpf_igmp[] = {
		{ 0x28, 0, 0, 0x0000000c },
		{ 0x15, 0, 3, 0x00000800 },
		{ 0x30, 0, 0, 0x00000017 },
		{ 0x15, 0, 1, 0x00000002 },
		//{ 0x6, 0, 0, 0x0000ffff },
		{ 0x6, 0, 0, 0x00040000 },
		{ 0x6, 0, 0, 0x00000000 },
	};
	struct sock_fprog sfprog;
	
	sfprog.len = ARRAY_SIZE(bpf_igmp);
	sfprog.filter = bpf_igmp;
	
	s = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_IP));
	set_nonblock(s);

	memset (&ifr, 0, sizeof(struct ifreq));
	strncpy(ifr.ifr_name, os->ifname, IFNAMSIZ);
	ioctl(s, SIOCGIFFLAGS, &ifr);
	ifr.ifr_flags |= IFF_PROMISC;
	ioctl(s, SIOCSIFFLAGS, &ifr);

	n  = setsockopt(s, SOL_SOCKET, SO_ATTACH_FILTER, &sfprog, sizeof(sfprog));
	if (n < 0) {
		printf("could not set filter\n");
	}
	
#if 0
	printf("raw = %d\n", s);
	for (i = 0; i < 5; i++) {
		n = recvfrom(s, buf, sizeof(buf), 0, NULL, NULL);
		printf("raw = %d, n = %d, errno = %d\n", s, n, errno);
		dump(buf, n);
	}
	close (s);
#endif
	os->igmp_rsock = s;
	return 0;
}

static void os_serve(struct octoserve *os)
{
	struct sigaction sa;
	fd_set fds;
	int mfd, i;
	struct timeval timeout;
	time_t t, u;

	signal(SIGPIPE, SIG_IGN);
	signal(SIGHUP, SIG_IGN);
	sa.sa_handler = sigchld_handler; 
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = SA_RESTART;

	if (sigaction(SIGCHLD, &sa, NULL) == -1) 
		die("Error in sigaction");

	os->rtsp_sock = streamsock("554", AF_INET, &os->rtsp_sadr);
	sockname((struct sockaddr *) &os->rtsp_sadr, os->rtsp_ip);
	dbgprintf(DEBUG_SYS, "rtsp_ip: %s, %d\n", os->rtsp_ip, os->rtsp_sock);
	if (listen(os->rtsp_sock, 20) < 0) {
		dbgprintf(DEBUG_SYS, "listen error");
		return;
	}
	set_nonblock(os->rtsp_sock);
	
	alloc_igmp_raw_socket(os);
	alloc_igmp_socket(os);

#if 0
	{
		struct ipv6_mreq imr;

		memset(&imr, 0, sizeof(imr));
		imr.ipv6mr_interface = if_nametoindex(os->ifname);
		inet_pton(AF_INET6, "FF02::16", &imr.ipv6mr_multiaddr);
		setsockopt(os->mld_sock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
			   &imr, sizeof(imr));
	}
#endif
	mtime(&t);
	while (!os->exit) {
		int csock, ncon;
		struct sockaddr cadr;
		socklen_t clen = sizeof(cadr);
		uint8_t buf[2048];
		int num, n;

		mtime(&u);
		if (u > t) {
			t = u;
			check_session_timeouts(os);
			//check_frontends(os);
			check_streams(os);
			check_igmp(os);
		}

		timeout.tv_sec = 0;
		timeout.tv_usec = 500000;

		FD_ZERO(&fds);
		mfd = 0;
		add_fd(os->rtsp_sock, &mfd, &fds);
		//add_fd(os->igmp_sock, &mfd, &fds);
		add_fd(os->igmp_rsock, &mfd, &fds);
		//add_fd(os->mld_sock, &mfd, &fds);
		for (i = 0, ncon = 0; i < MAX_CONNECT; i++) {
			if (os->con[i].state) {
				ncon++;
				add_fd(os->con[i].sock, &mfd, &fds);
			}
		}
		//printf("serve_loop: %d cons, mfd=%d\n", ncon, mfd);
		num = select(mfd + 1, &fds, NULL, NULL, &timeout);
		if (num < 0)
			break;
#if 0
		if (FD_ISSET(os->igmp_sock, &fds)) {
			n = recvfrom(os->igmp_sock, buf, sizeof(buf), 0, &cadr, &clen);
			if (n > 0)
				proc_igmp(os, buf, n, NULL);
		}
#endif
		if (FD_ISSET(os->igmp_rsock, &fds)) {
			n = recvfrom(os->igmp_rsock, buf, sizeof(buf), 0, &cadr, &clen);
			if (n > 14)
				proc_igmp(os, buf + 14, n - 14, buf);
		}
		if (FD_ISSET(os->mld_sock, &fds)) {
			n = recvfrom(os->mld_sock, buf, sizeof(buf), 0, &cadr, &clen);
			printf("n = %d\n", n);
			if (n > 0)
				;//dump(buf, n);
		}
#ifndef MULTI_THREADED
		for (i = 0; i < MAX_CONNECT; i++) 
			if (os->con[i].state && 
			    FD_ISSET(os->con[i].sock, &fds))
				con_loop(&os->con[i]);
#endif
		con_check(os);

		
		if (FD_ISSET(os->rtsp_sock, &fds)) {
			struct oscon *con;

			csock = accept(os->rtsp_sock, &cadr, &clen);
			if (csock < 0) {
				dbgprintf(DEBUG_SYS, "Could not accept\n");
				continue;
			}
			con = alloc_con(os);
			if (!con) {
				dbgprintf(DEBUG_SYS, "Could not alloc new connection\n");
				continue;
			}
			con->sock = csock;
			con->trans.family = AF_INET;
			init_con(con);
			dbgprintf(DEBUG_SYS, "sock %d  con  %d on %s\n", 
				  con->sock, con->nr, con->cadr_ip);
#ifdef MULTI_THREADED
			pthread_create(&con->pt, NULL, (void *) handle_con, con); 
			set_block(csock);
#else
			set_nonblock(csock);
#endif
		}
	}
	killall_sessions(os);
}

static struct octoserve *os_init(char *ifname, int nossdp, int nodms, int nodvbt, int msmode)
{
	struct octoserve *os;
	struct os_ssdp *ss;
	struct ifreq ifr;
	int s;
	pthread_mutexattr_t mta;

	os = malloc(sizeof(*os));
	if (!os)
		return NULL;
	dbgprintf(DEBUG_SYS, "allocated octoserve struct, %d bytes\n", sizeof(*os));
	memset(os, 0, sizeof(struct octoserve));

	pthread_mutexattr_init(&mta);
	pthread_mutexattr_settype(&mta, PTHREAD_MUTEX_RECURSIVE);
	pthread_mutex_init(&os->lock, &mta);

	os->ifname = ifname;
	os->sessionid = random();

	if (get_ifa(ifname, AF_INET, (struct sockaddr *) &os->ssdp.sadr) < 0) {
		perror("no such interface:");
		free(os);
		return NULL;
	}
	get_ifa(ifname, AF_INET6, (struct sockaddr *) &os->ssdp.sadr6);
	sockname((struct sockaddr *) &os->ssdp.sadr, os->ssdp.ip);
	sockname((struct sockaddr *) &os->ssdp.sadr6, os->ssdp.ip6);

	strcpy(ifr.ifr_name, os->ifname);
	s = socket(AF_INET, SOCK_DGRAM, 0);
	ioctl(s, SIOCGIFHWADDR, &ifr);
	close(s);
	memcpy(os->mac, ifr.ifr_hwaddr.sa_data, 6);
	dbgprintf(DEBUG_NET, "MAC %s=%02x:%02x:%02x:%02x:%02x:%02x\n", 
		  os->ifname,
		  os->mac[0], os->mac[1], os->mac[2], 
		  os->mac[3], os->mac[4], os->mac[5]);
	if (os->has_switch)
		switch_get_port(os->mac);

	init_dvb(os, nodvbt, msmode);

	ss = &os->ssdp;
	if (init_ssdp(os, &os->ssdp, debug, nossdp, nodms) < 0) {
		release_dvb(os);
		free(os);
		return NULL;
	}
#if 0
	if (init_httpos, debug) < 0) {
		release_dvb(os);
		free(os);
		return NULL;
	}
#endif
	return os;
}

struct octoserve *os;

void term_action(int sig)
{
	printf("EXIT\n");
	os->exit = 1;
}

static int set_termaction(void)
{
	struct sigaction term;

	memset(&term, 0, sizeof(term));
	term.sa_handler = term_action;
	sigemptyset(&term.sa_mask);
	term.sa_flags = 0;
	sigaction(SIGINT, &term, NULL);

	memset(&term, 0, sizeof(term));
	term.sa_handler = term_action;
	sigemptyset(&term.sa_mask);
	term.sa_flags = 0;
	sigaction(SIGTERM, &term, NULL);
}

static int fexists(char *fn)
{
	struct stat b;

	return (!stat(fn, &b));
}

static int read_msmode(char *fn)
{
	int fd, len;
	char mode[80];
		
	fd = open(fn, O_RDONLY);
	if (fd < 0) {
		if (fexists("/config/noswitch.enabled"))
			return 0;
		else
			return 1;
	}
	len = read(fd, mode, 7);
	if (len < 0)
		return 0;
	close (fd);
	if (len == 4 && !strncasecmp(mode, "none", 4))
		return 0;
	if (len == 4 && !strncasecmp(mode, "quad", 4))
		return 1;
	if (len == 7 && !strncasecmp(mode, "quattro", 7))
		return 2;
	return 0;
}

static void awrite(char *fn, char *txt)
{
	FILE *f = fopen(fn, "w");

	if (f)
		fprintf(f, "%s", txt);
}

int main(int argc, char **argv)
{
	int nodms = 0, nossdp = 0, nodvbt = 0, vlan = 0, msmode = 1;
		
	printf("Octoserve " OCTOSERVE_VERSION
	       ", Copyright (C) 2012-15 Digital Devices GmbH\n"); 
	debug = 0;
	flags = 0;
	while (1) {
                int option_index = 0;
		int c;
                static struct option long_options[] = {
			{"debug", required_argument, 0, 'd'},
			{"flags", required_argument, 0, 'f'},
			{"nossdp", no_argument, 0, 'n'},
			{"nodms", no_argument, 0, 'm'},
			{"nodvbt", no_argument, 0, 't'},
			{"conform", no_argument, 0, 'c'},
			{"help", no_argument , 0, 'h'},
			{0, 0, 0, 0}
		};
                c = getopt_long(argc, argv, 
				"d:f:nmtsch",
				long_options, &option_index);
		if (c==-1)
 			break;

		switch (c) {
		case 'd':
			debug = strtoul(optarg, NULL, 16);
			break;
		case 'f':
			flags = strtoul(optarg, NULL, 16);
			break;
		case 'n':
			nossdp = 1;
			break;
		case 'm':
			nodms = 1;
			break;
		case 't':
			nodvbt = 1;
			break;
		case 'c':
			conform = 1;
			break;
		case 'h':
		default:
			break;
			
		}
	}
	if (optind < argc) {
		printf("Warning: unused arguments\n");
	}
	if (fexists("/config/nodms.enabled"))
		nodms = 1;
	msmode = read_msmode("/config/msmode");
	if (fexists("/config/nodvbt.enabled"))
		nodvbt = 1;
	if (fexists("/config/vlan.enabled")) {
		awrite("/sys/class/ddbridge/ddbridge0/vlan", "1");
		vlan = 1;
	} else
		awrite("/sys/class/ddbridge/ddbridge0/vlan", "0");
	printf("nodms = %d, nodvbt = %d, vlan = %d\n", nodms, nodvbt, vlan);
	
	os = os_init("eth0", nossdp, nodms, nodvbt, msmode);
	if (!os)
		return -1;
	set_termaction();

	os->has_switch = switch_test();
	if (os->has_switch)
		printf("Switch detected\n");
	else
		printf("No switch detected\n");
	
	os_serve(os);
	if (!nossdp)
		pthread_join(os->ssdp.pt, NULL);
	release_dvb(os);
	free(os);
}