/*
 * Asterisk -- A telephony toolkit for Linux.
 *
 * Tormenta T1 Card (via Zapata library) support 
 * 
 * Copyright (C) 1999, Mark Spencer
 *
 * Mark Spencer <markster@linux-support.net>
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License
 */

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <asterisk/channel.h>
#include <asterisk/channel_pvt.h>
#include <asterisk/config.h>
#include <asterisk/logger.h>
#include <asterisk/module.h>
#include <asterisk/pbx.h>
#include <asterisk/options.h>
#include <asterisk/file.h>
#include <asterisk/ulaw.h>
#include <asterisk/callerid.h>
#include <sys/signal.h>
#include <sys/select.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/tor.h>
#include <zap.h>
#include <math.h>
#include <tonezone.h>

static char *desc = "Tormenta (Zapata) Channelized T1 Driver";
static char *type = "Tor";
static char *tdesc = "Tormenta T1 Driver";
static char *config = "tormenta.conf";

#define SIG_EM		0x1
#define SIG_EMWINK 	0x11
#define SIG_FEATD	0X21
#define SIG_FXSLS	0x2
#define SIG_FXSGS	0x3
#define SIG_FXSKS	0x4
#define SIG_FXOLS	0x5
#define SIG_FXOGS	0x6
#define SIG_FXOKS	0x7

#define tor_STATE_DOWN 0

static char context[AST_MAX_EXTENSION] = "default";
static char callerid[256] = "";

/* Keep certain dial patterns from turning off dialtone */
#define AST_MAX_DIAL_PAT 32

static char keepdialpat[AST_MAX_DIAL_PAT][10];
static int dialpats = 0;

static char language[MAX_LANGUAGE] = "";

static int use_callerid = 1;

static int cur_signalling = -1;

static int cur_group = 0;

static int immediate = 0;

static int stripmsd = 0;

/* Wait up to 16 seconds for first digit (FXO logic) */
static int firstdigittimeout = 16000;

/* How long to wait for following digits (FXO logic) */
static int gendigittimeout = 8000;

static int usecnt =0;
static pthread_mutex_t usecnt_lock = PTHREAD_MUTEX_INITIALIZER;

/* Protect the interface list (of tor_pvt's) */
static pthread_mutex_t iflock = PTHREAD_MUTEX_INITIALIZER;

/* Protect the monitoring thread, so only one process can kill or start it, and not
   when it's doing something critical. */
static pthread_mutex_t monlock = PTHREAD_MUTEX_INITIALIZER;

/* This is the thread for the monitor which checks for input on the channels
   which are not currently in use.  */
static pthread_t monitor_thread = 0;

static int restart_monitor(void);

static inline int tor_get_event(int fd)
{
	/* Avoid the silly tor_getevent which ignores a bunch of events */
	int j;
	if (ioctl(fd, TOR_GETEVENT, &j) == -1) return -1;
	return j;
}

static inline int tor_wait_event(int fd)
{
	/* Avoid the silly tor_waitevent which ignores a bunch of events */
	int i,j=0;
	i = TOR_IOMUX_SIGEVENT;
	if (ioctl(fd, TOR_IOMUX, &i) == -1) return -1;
	if (ioctl(fd, TOR_GETEVENT, &j) == -1) return -1;
	return j;
}

/* Chunk size to read -- we use the same size as the chunks that the zapata library uses.  */   
#define READ_SIZE 204

static struct tor_pvt {
	ZAP *z;
	struct ast_channel *owner;	/* Our owner (if applicable) */
	int sig;					/* Signalling style */
	struct tor_pvt *next;			/* Next channel in list */
	char context[AST_MAX_EXTENSION];
	char language[MAX_LANGUAGE];
	char callerid[AST_MAX_EXTENSION];
	char dtmfq[AST_MAX_EXTENSION];
	struct ast_frame f;
	short buffer[AST_FRIENDLY_OFFSET/2 + READ_SIZE];
	int group;
	int state;						/* Perhaps useful state info */
	int immediate;				/* Answer before getting digits? */
	int channel;				/* Channel Number */
	int ringgothangup;				/* Have we received exactly one hangup after a ring */
	int dialing;
	int use_callerid;			/* Whether or not to use caller id on this channel */
	unsigned char *cidspill;
	int cidpos;
	int cidlen;
	int stripmsd;
	DIAL_OPERATION dop;
} *iflist = NULL;

static int tor_digit(struct ast_channel *ast, char digit)
{
	DIAL_OPERATION zo;
	struct tor_pvt *p;
	int res;
	zo.op = TOR_DIAL_OP_APPEND;
	zo.dialstr[0] = 'T';
	zo.dialstr[1] = digit;
	zo.dialstr[2] = 0;
	p = ast->pvt->pvt;
	if ((res = ioctl(zap_fd(p->z), TOR_DIAL, &zo)))
		ast_log(LOG_WARNING, "Couldn't dial digit %c\n", digit);
	else
		p->dialing = 1;
	
	return res;
}

static char *events[] = {
        "No event",
        "On hook",
        "Ring/Answered",
        "Wink/Flash",
        "Alarm",
        "No more alarm",
		"HDLC Abort",
		"HDLC Overrun",
		"HDLC Bad FCS",
		"Dial Complete",
		"Ringer On",
		"Ringer Off",
		"Hook Transition Complete"
};
 
static char *event2str(int event)
{
        static char buf[256];
        if ((event < 13) && (event > -1))
                return events[event];
        sprintf(buf, "Event %d", event);
        return buf;
}

static char *sig2str(int sig)
{
	static char buf[256];
	switch(sig) {
	case SIG_EM:
		return "E & M Immediate";
	case SIG_EMWINK:
		return "E & M Wink";
	case SIG_FEATD:
		return "Feature Group D";
	case SIG_FXSLS:
		return "FXS Loopstart";
	case SIG_FXSGS:
		return "FXS Groundstart";
	case SIG_FXSKS:
		return "FXS Kewlstart";
	case SIG_FXOLS:
		return "FXO Loopstart";
	case SIG_FXOGS:
		return "FXO Groundstart";
	case SIG_FXOKS:
		return "FXO Kewlstart";
	default:
		snprintf(buf, sizeof(buf), "Unknown signalling %d\n", sig);
		return buf;
	}
}

static int set_actual_gain(int fd, int chan, float rxgain, float txgain)
{
	struct	tor_gains g;
	float ltxgain;
	float lrxgain;
	int j,k;
	g.chan = chan;
	  /* caluculate linear value of tx gain */
	ltxgain = pow(10.0,txgain / 20.0);
	  /* caluculate linear value of rx gain */
	lrxgain = pow(10.0,rxgain / 20.0);
	for (j=0;j<256;j++) {
		k = (int)(((float)ast_mulaw[j]) * lrxgain);
		if (k > 32767) k = 32767;
		if (k < -32767) k = -32767;
		g.rxgain[j] = ast_lin2mu[k + 32768];
		k = (int)(((float)ast_mulaw[j]) * ltxgain);
		if (k > 32767) k = 32767;
		if (k < -32767) k = -32767;
		g.txgain[j] = ast_lin2mu[k + 32768];
	}
		
	  /* set 'em */
	return(ioctl(fd,TOR_SETGAINS,&g));
}
static inline int tor_set_hook(int fd, int hs)
{
	int x, res;
	x = hs;
	res = ioctl(fd, TOR_HOOK, &x);
	if (res < 0) 
		ast_log(LOG_WARNING, "tor hook failed: %s\n", strerror(errno));
	return res;
}


static int send_callerid(struct tor_pvt *p)
{
	/* Assumes spill in p->cidspill, p->cidlen in length and we're p->cidpos into it */
	int res;
	while(p->cidpos < p->cidlen) {
		res = write(zap_fd(p->z), p->cidspill + p->cidpos, p->cidlen - p->cidpos);
		if (res < 0) {
			if (errno == EAGAIN)
				return 0;
			else {
				ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
				return -1;
			}
		}
		if (!res)
			return 0;
		p->cidpos += res;
	}
	free(p->cidspill);
	p->cidspill = 0;
	return 0;
}
                                                                                
static int tor_call(struct ast_channel *ast, char *dest, int timeout)
{
	struct tor_pvt *p = ast->pvt->pvt;
	int x, res;
	char *c, *n, *l;
	char callerid[256];
	if ((ast->state != AST_STATE_DOWN) && (ast->state != AST_STATE_RESERVED)) {
		ast_log(LOG_WARNING, "tor_call called on %s, neither down nor reserved\n", ast->name);
		return -1;
	}
	switch(p->sig) {
	case SIG_FXOLS:
	case SIG_FXOGS:
	case SIG_FXOKS:
		if (p->use_callerid) {
			/* Generate the Caller-ID spill if desired */
			if (p->cidspill) {
				ast_log(LOG_WARNING, "cidspill already exists??\n");
				free(p->cidspill);
			}
			p->cidspill = malloc(MAX_CALLERID_SIZE);
			if (p->cidspill) {
				p->cidlen = ast_callerid_generate(p->cidspill, ast->callerid);
				p->cidpos = 0;
				send_callerid(p);
			} else
				ast_log(LOG_WARNING, "Unable to generate CallerID spill\n");
		}
		x = TOR_RING;
		if (ioctl(zap_fd(p->z), TOR_HOOK, &x) && (errno != EINPROGRESS)) {
			ast_log(LOG_WARNING, "Unable to ring phone: %s\n", strerror(errno));
			return -1;
		}
		ast->state = AST_STATE_RINGING;
		break;
	case SIG_FXSLS:
	case SIG_FXSGS:
	case SIG_FXSKS:
	case SIG_EMWINK:
	case SIG_EM:
	case SIG_FEATD:
		c = strchr(dest, '/');
		if (c)
			c++;
		else
			c = dest;
		if (strlen(c) < p->stripmsd) {
			ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
			return -1;
		}
		x = TOR_START;
		/* Start the trunk */
		res = ioctl(zap_fd(p->z), TOR_HOOK, &x);
		if (res < 0) {
			if (errno != EINPROGRESS) {
				ast_log(LOG_WARNING, "Unable to start channel: %s\n", strerror(errno));
				return -1;
			}
		}
		ast_log(LOG_DEBUG, "Dialing '%s'\n", c);
		p->dop.op = TOR_DIAL_OP_REPLACE;
		if (p->sig == SIG_FEATD) {
			if (ast->callerid) {
				strncpy(callerid, ast->callerid, sizeof(callerid));
				ast_callerid_parse(callerid, &n, &l);
				printf("Name: %s, number: %s\n", n, l);
				if (l) {
					ast_shrink_phone_number(l);
					if (!ast_isphonenumber(l))
						l = NULL;
				}
			} else
				l = NULL;
			if (l) 
				snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T*%s*%s*", l, c + p->stripmsd);
			else
				snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T**%s*", c + p->stripmsd);
		} else 
			snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%s", c + p->stripmsd);
		if (!res) {
			if (ioctl(zap_fd(p->z), TOR_DIAL, &p->dop)) {
				x = TOR_ONHOOK;
				ioctl(zap_fd(p->z), TOR_HOOK, &x);
				ast_log(LOG_WARNING, "Dialing failed on channel %d: %s\n", p->channel, strerror(errno));
				return -1;
			}
		} else
			ast_log(LOG_DEBUG, "Deferring dialing...\n");
		p->dialing = 1;
		ast->state = AST_STATE_DIALING;
		break;
	default:
		ast_log(LOG_DEBUG, "not yet implemented\n");
		return -1;
	}
	return 0;
}

static int tor_hangup(struct ast_channel *ast)
{
	int res;
	struct tor_pvt *p = ast->pvt->pvt;
	TOR_PARAMS par;
	if (option_debug)
		ast_log(LOG_DEBUG, "tor_hangup(%s)\n", ast->name);
	if (!ast->pvt->pvt) {
		ast_log(LOG_WARNING, "Asked to hangup channel not connected\n");
		return 0;
	}
	res = tor_set_hook(zap_fd(p->z), TOR_ONHOOK);
	if (res < 0) {
		ast_log(LOG_WARNING, "Unable to hangup line %s\n", ast->name);
		return -1;
	}
	switch(p->sig) {
	case SIG_FXOGS:
	case SIG_FXOLS:
	case SIG_FXOKS:
		res = ioctl(zap_fd(p->z), TOR_GET_PARAMS, &par);
		if (!res) {
			/* If they're off hook, try playing congestion */
			if (par.rxisoffhook)
				tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
		}
		break;
	default:
	}
	ast->state = AST_STATE_DOWN;
	p->owner = NULL;
	p->ringgothangup = 0;
	if (p->cidspill)
		free(p->cidspill);
	p->cidspill = NULL;
	pthread_mutex_lock(&usecnt_lock);
	usecnt--;
	if (usecnt < 0) 
		ast_log(LOG_WARNING, "Usecnt < 0???\n");
	pthread_mutex_unlock(&usecnt_lock);
	ast_update_use_count();
	if (option_verbose > 2) 
		ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", ast->name);
	ast->pvt->pvt = NULL;
	ast->state = AST_STATE_DOWN;
	restart_monitor();
	return 0;
}

static int tor_answer(struct ast_channel *ast)
{
	struct tor_pvt *p = ast->pvt->pvt;
	ast->state = AST_STATE_UP;
	switch(p->sig) {
	case SIG_FXSLS:
	case SIG_FXSGS:
	case SIG_FXSKS:
	case SIG_EM:
	case SIG_EMWINK:
	case SIG_FEATD:
	case SIG_FXOLS:
	case SIG_FXOGS:
	case SIG_FXOKS:
		/* Pick up the line */
		ast_log(LOG_DEBUG, "Took %s off hook\n", ast->name);
		return tor_set_hook(zap_fd(p->z), TOR_OFFHOOK);
		break;
		/* Nothing */
		break;
	default:
		ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel);
		return -1;
	}
	return 0;
}

static int bridge_cleanup(struct tor_pvt *p0, struct tor_pvt *p1)
{
	struct tor_confinfo c;
	int res;
	c.chan = 0;
	c.confno = 0;
	c.confmode = TOR_CONF_NORMAL;
	res = ioctl(zap_fd(p0->z), TOR_SETCONF, &c);
	if (res) {
		ast_log(LOG_WARNING, "ioctl(TOR_SETCONF) failed on channel %d: %s\n", p0->channel, strerror(errno));
		return -1;
	}
	c.chan = 0;
	c.confno = 0;
	c.confmode = TOR_CONF_NORMAL;
	res = ioctl(zap_fd(p1->z), TOR_SETCONF, &c);
	if (res) {
		ast_log(LOG_WARNING, "ioctl(TOR_SETCONF) failed on channel %d: %s\n", p1->channel, strerror(errno));
		return -1;
	}
	return 0;
}


static int tor_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
{
	/* Do a quickie conference between the two channels and wait for something to happen */
	struct tor_pvt *p0 = c0->pvt->pvt;
	struct tor_pvt *p1 = c1->pvt->pvt;
	struct ast_channel *who, *cs[3];
	struct ast_frame *f;
	struct tor_confinfo c;
	int res;
	int to = -1;
	/* Put the first channel in a unique conference */
	c.chan = 0;
	c.confno = p1->channel;
	c.confmode = TOR_CONF_MONITOR;
	
	/* Stop any playing */
	tone_zone_play_tone(zap_fd(p0->z), 	-1);
	res = ioctl(zap_fd(p0->z), TOR_SETCONF, &c);
	if (res) {
		ast_log(LOG_WARNING, "ioctl(TOR_SETCONF) failed on channel %s: %s\n", c0->name, strerror(errno));
		bridge_cleanup(p0, p1);
		return -1;
	}
	if (option_debug)
		ast_log(LOG_DEBUG, "Channel %d got put on conference %d\n", c.chan, c.confno);

	/* Put the other channel on the same conference */
	c.chan = 0;
	c.confno = p0->channel;
	res = ioctl(zap_fd(p1->z), TOR_SETCONF, &c);
	if (res) {
		ast_log(LOG_WARNING, "ioctl(TOR_SETCONF) failed on channel %s: %s\n", c0->name, strerror(errno));
		bridge_cleanup(p0, p1);
		return -1;
	}
	if (option_debug)
		ast_log(LOG_DEBUG, "Channel %d got put on conference %d\n", c.chan, c.confno);

	for (;;) {
		cs[0] = c0;
		cs[1] = c1;
		who = ast_waitfor_n(cs, 2, &to);
		if (!who) {
			ast_log(LOG_WARNING, "Nobody there??\n");
			continue;
		}
		f = ast_read(who);
		if (!f) {
			*fo = NULL;
			*rc = who;
			bridge_cleanup(p0, p1);
			return 0;
		}
		if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
			*fo = f;
			*rc = who;
			bridge_cleanup(p0, p1);
			return 0;
		}
		if ((f->frametype == AST_FRAME_VOICE) ||
			(f->frametype == AST_FRAME_TEXT) ||
			(f->frametype == AST_FRAME_VIDEO) || 
			(f->frametype == AST_FRAME_IMAGE) ||
			(f->frametype == AST_FRAME_DTMF)) {
			if ((f->frametype == AST_FRAME_DTMF) && (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))) {
				if ((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) {
					*rc = c0;
					*fo = f;
					bridge_cleanup(p0, p1);
					return 0;
				} else
				if ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1)) {
					*rc = c1;
					*fo = f;
					bridge_cleanup(p0, p1);
					return 0;
				}
			}
			ast_frfree(f);
		} else
			ast_frfree(f);
		/* Swap who gets priority */
		cs[2] = cs[0];
		cs[0] = cs[1];
		cs[1] = cs[2];
	}
		
	return 0;
}

struct ast_frame *tor_handle_event(struct ast_channel *ast)
{
	int res;
	struct tor_pvt *p = ast->pvt->pvt;
	p->f.frametype = AST_FRAME_NULL;
	p->f.datalen = 0;
	p->f.timelen = 0;
	p->f.mallocd = 0;
	p->f.offset = 0;
	p->f.src = "tor_handle_event";
	p->f.data = NULL;
	res = tor_get_event(zap_fd(p->z));
	ast_log(LOG_DEBUG, "Got event %s(%d) on channel %d\n", event2str(res), res, p->channel);
	switch(res) {
		case TOR_EVENT_DIALCOMPLETE:
			p->dialing = 0;
			if (ast->state == AST_STATE_DIALING) {
#if 0
				ast->state = AST_STATE_RINGING;
#else
				ast->state = AST_STATE_UP;
				p->f.frametype = AST_FRAME_CONTROL;
				p->f.subclass = AST_CONTROL_ANSWER;
#endif				
			}
			break;
		case TOR_EVENT_ONHOOK:
			return NULL;
		case TOR_EVENT_RINGOFFHOOK:
			switch(p->sig) {
			case SIG_FXOLS:
			case SIG_FXOGS:
			case SIG_FXOKS:
				switch(ast->state) {
				case AST_STATE_RINGING:
					ast->state = AST_STATE_UP;
					p->f.frametype = AST_FRAME_CONTROL;
					p->f.subclass = AST_CONTROL_ANSWER;
					/* Make sure it stops ringing */
					tor_set_hook(zap_fd(p->z), TOR_OFFHOOK);
					ast_log(LOG_DEBUG, "channel %d answered\n", p->channel);
					if (p->cidspill) {
						/* Cancel any running CallerID spill */
						free(p->cidspill);
						p->cidspill = NULL;
					}
					return &p->f;
				case AST_STATE_DOWN:
					ast->state = AST_STATE_RING;
					ast->rings = 1;
					p->f.frametype = AST_FRAME_CONTROL;
					p->f.subclass = AST_CONTROL_OFFHOOK;
					ast_log(LOG_DEBUG, "channel %d picked up\n", p->channel);
					return &p->f;
				default:
					ast_log(LOG_WARNING, "FXO phone off hook in weird state %d??\n", ast->state);
				}
				break;
			case SIG_EM:
			case SIG_EMWINK:
			case SIG_FEATD:
			case SIG_FXSLS:
			case SIG_FXSGS:
			case SIG_FXSKS:
				if (ast->state == AST_STATE_DOWN) {
					if (option_debug)
						ast_log(LOG_DEBUG, "Ring detected\n");
					p->f.frametype = AST_FRAME_CONTROL;
					p->f.subclass = AST_CONTROL_RING;
				} else if (ast->state == AST_STATE_RINGING) {
					if (option_debug)
						ast_log(LOG_DEBUG, "Line answered\n");
					p->f.frametype = AST_FRAME_CONTROL;
					p->f.subclass = AST_CONTROL_ANSWER;
					ast->state = AST_STATE_UP;
				} else 
					ast_log(LOG_WARNING, "Ring/Off-hook in strange state %d on channel %d\n", ast->state, p->channel);
				break;
			default:
				ast_log(LOG_WARNING, "Don't know how to handle ring/off hoook for signalling %d\n", p->sig);
			}
			break;
		case TOR_EVENT_RINGEROFF:
			ast->rings++;
			if ((ast->rings > 1) && (p->cidspill)) {
				ast_log(LOG_WARNING, "Didn't finish Caller-ID spill.  Cancelling.\n");
				free(p->cidspill);
				p->cidspill = NULL;
			}
			p->f.frametype = AST_FRAME_CONTROL;
			p->f.subclass = AST_CONTROL_RINGING;
			break;
		case TOR_EVENT_RINGERON:
		case TOR_EVENT_NOALARM:
			break;
		case TOR_EVENT_WINKFLASH:
			switch(p->sig) {
			case SIG_FXOLS:
			case SIG_FXOGS:
			case SIG_FXOKS:
				/* XXX For now, treat as a hang up */
				return NULL;
			case SIG_EM:
			case SIG_EMWINK:
			case SIG_FEATD:
			case SIG_FXSLS:
			case SIG_FXSGS:
				if (p->dialing)
					ast_log(LOG_DEBUG, "Ignoring wink on channel %d\n", p->channel);
				else
					ast_log(LOG_DEBUG, "Got wink in weird state %d on channel %d\n", ast->state, p->channel);
				break;
			default:
				ast_log(LOG_WARNING, "Don't know how to handle ring/off hoook for signalling %d\n", p->sig);
			}
			break;
		case TOR_EVENT_HOOKCOMPLETE:
			res = ioctl(zap_fd(p->z), TOR_DIAL, &p->dop);
			if (res < 0) {
				ast_log(LOG_WARNING, "Unable to initiate dialing on trunk channel %d\n", p->channel);
				p->dop.dialstr[0] = '\0';
				return NULL;
			} else 
				ast_log(LOG_DEBUG, "Sent deferred digit string: %s\n", p->dop.dialstr);
			p->dop.dialstr[0] = '\0';
			break;
		default:
			ast_log(LOG_DEBUG, "Dunno what to do with event %d on channel %d\n", res, p->channel);
	}
	return &p->f;
 }

struct ast_frame *tor_exception(struct ast_channel *ast)
{
	return tor_handle_event(ast);
}

struct ast_frame  *tor_read(struct ast_channel *ast)
{
	struct tor_pvt *p = ast->pvt->pvt;
	int res,x;
	unsigned char ireadbuf[READ_SIZE];
	unsigned char *readbuf;
	
	p->f.frametype = AST_FRAME_DTMF;
	p->f.datalen = 0;
	p->f.timelen = 0;
	p->f.mallocd = 0;
	p->f.offset = 0;
	p->f.src = "tor_read";
	p->f.data = NULL;
	
	/* Check first for any outstanding DTMF characters */
	if (strlen(p->dtmfq)) {
		p->f.subclass = p->dtmfq[0];
		memmove(p->dtmfq, p->dtmfq + 1, sizeof(p->dtmfq) - 1);
		return &p->f;
	}
	
	if (ast->pvt->rawreadformat == AST_FORMAT_SLINEAR) {
		/* Read into temporary buffer */
		readbuf = ireadbuf;
	} else if (ast->pvt->rawreadformat == AST_FORMAT_ULAW) {
		/* Read ulaw directly into frame */
		readbuf = ((unsigned char *)p->buffer) + AST_FRIENDLY_OFFSET;
	} else {
		ast_log(LOG_WARNING, "Don't know how to read frames in format %d\n", ast->pvt->rawreadformat);
		return NULL;
	}
	CHECK_BLOCKING(ast);
	res = zap_recchunk(p->z, readbuf, READ_SIZE, ZAP_DTMFINT);
	ast->blocking = 0;
	/* Check for hangup */
	if (res < 0) {
		if (res == -1) 
			ast_log(LOG_WARNING, "tor_rec: %s\n", strerror(errno));
		return NULL;
	}
	if (res != READ_SIZE) {
		if (option_debug)
			ast_log(LOG_DEBUG, "Short read, must be DTMF or something...\n");
		/* XXX UGLY!!  Zapata's DTMF handling is a bit ugly XXX */
		if (zap_dtmfwaiting(p->z) && !strlen(zap_dtmfbuf(p->z))) {
			zap_getdtmf(p->z, 1, NULL, 0, 1, 1, 0);
		}
		if (strlen(zap_dtmfbuf(p->z))) {
			ast_log(LOG_DEBUG, "Got some dtmf ('%s')... on channel %s\n", zap_dtmfbuf(p->z), ast->name);
			/* DTMF tone detected.  Queue and erturn */
			strncpy(p->dtmfq + strlen(p->dtmfq), zap_dtmfbuf(p->z), sizeof(p->dtmfq) - strlen(p->dtmfq));
			zap_clrdtmfn(p->z);
		} else {
			return tor_handle_event(ast);
		}
		return &p->f;
	}
	if (ast->pvt->rawreadformat == AST_FORMAT_SLINEAR) {
		for (x=0;x<READ_SIZE;x++) {
			p->buffer[x + AST_FRIENDLY_OFFSET/2] = ast_mulaw[readbuf[x]];
		}
		p->f.datalen = READ_SIZE * 2;
	} else 
		p->f.datalen = READ_SIZE;

	/* Handle CallerID Transmission */
	if ((ast->rings == 1) && (p->cidspill))
		send_callerid(p);

	p->f.frametype = AST_FRAME_VOICE;
	p->f.subclass = ast->pvt->rawreadformat;
	p->f.timelen = READ_SIZE/8;
	p->f.mallocd = 0;
	p->f.offset = AST_FRIENDLY_OFFSET;
	p->f.data = p->buffer + AST_FRIENDLY_OFFSET/2;
#if 0
	ast_log(LOG_DEBUG, "Read %d of voice on %s\n", p->f.datalen, ast->name);
#endif	
	return &p->f;
}

static int my_tor_write(struct tor_pvt *p, unsigned char *buf, int len)
{
	int sent=0;
	int size;
	int res;
	while(len) {
		size = len;
		if (size > READ_SIZE)
			size = READ_SIZE;
		res = write(zap_fd(p->z), buf, size);
		if (res != size) {
			ast_log(LOG_DEBUG, "Write returned %d (%s) on channel %d\n", res, strerror(errno), p->channel);
			return sent;
		}
		len -= size;
		buf += size;
	}
	return sent;
}

static int tor_write(struct ast_channel *ast, struct ast_frame *frame)
{
	struct tor_pvt *p = ast->pvt->pvt;
	int x;
	int res;
	unsigned char outbuf[4096];
	short *inbuf;
	/* Write a frame of (presumably voice) data */
	if (frame->frametype != AST_FRAME_VOICE) {
		ast_log(LOG_WARNING, "Don't know what to do with frame type '%d'\n", frame->frametype);
		return -1;
	}
	if ((frame->subclass != AST_FORMAT_SLINEAR) && (frame->subclass != AST_FORMAT_ULAW)) {
		ast_log(LOG_WARNING, "Cannot handle frames in %d format\n", frame->subclass);
		return -1;
	}
	if (p->dialing) {
		ast_log(LOG_DEBUG, "Dropping frame since I'm still dialing...\n");
		return 0;
	}
	if (p->cidspill) {
		ast_log(LOG_DEBUG, "Dropping frame since I've still got a callerid spill\n");
		return 0;
	}
	/* Return if it's not valid data */
	if (!frame->data || !frame->datalen)
		return 0;
	if (frame->datalen > sizeof(outbuf) * 2) {
		ast_log(LOG_WARNING, "Frame too large\n");
		return 0;
	}
	if (frame->subclass == AST_FORMAT_SLINEAR) {
		inbuf = frame->data;
		for (x=0;x<frame->datalen/2;x++)
			outbuf[x] = ast_lin2mu[inbuf[x]+32768];
		res = my_tor_write(p, outbuf, frame->datalen/2);
	} else {
		/* uLaw already */
		res = my_tor_write(p, (unsigned char *)frame->data, frame->datalen);
	}
	if (res < 0) {
		ast_log(LOG_WARNING, "write failed: %s\n", strerror(errno));
		return -1;
	} else if (res != frame->datalen/2) {
		/* Some sort of an event */
		return 0;
	}
	return 0;
}

static struct ast_channel *tor_new(struct tor_pvt *i, int state, int startpbx)
{
	struct ast_channel *tmp;
	tmp = ast_channel_alloc();
	if (tmp) {
		snprintf(tmp->name, sizeof(tmp->name), "Tor/%d", i->channel);
		tmp->type = type;
		tmp->fd = zap_fd(i->z);
		tmp->nativeformats = AST_FORMAT_SLINEAR | AST_FORMAT_ULAW;
		/* Start out assuming ulaw since it's smaller :) */
		tmp->pvt->rawreadformat = AST_FORMAT_ULAW;
		tmp->readformat = AST_FORMAT_ULAW;
		tmp->pvt->rawwriteformat = AST_FORMAT_ULAW;
		tmp->writeformat = AST_FORMAT_ULAW;
		
		tmp->state = state;
		if (state == AST_STATE_RING)
			tmp->rings = 1;
		tmp->pvt->pvt = i;
		tmp->pvt->send_digit = tor_digit;
		tmp->pvt->call = tor_call;
		tmp->pvt->hangup = tor_hangup;
		tmp->pvt->answer = tor_answer;
		tmp->pvt->read = tor_read;
		tmp->pvt->write = tor_write;
		tmp->pvt->bridge = tor_bridge;
		tmp->pvt->exception = tor_exception;
		if (strlen(i->language))
			strncpy(tmp->language, i->language, sizeof(tmp->language));
		i->owner = tmp;
		pthread_mutex_lock(&usecnt_lock);
		usecnt++;
		pthread_mutex_unlock(&usecnt_lock);
		ast_update_use_count();
		strncpy(tmp->context, i->context, sizeof(tmp->context));
		if (startpbx) {
			if (ast_pbx_start(tmp)) {
				ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
				ast_hangup(tmp);
				tmp = NULL;
			}
		}
	} else
		ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
	return tmp;
}


static int ignore_pat(char *s)
{
	int x;
	for (x=0;x<dialpats;x++)
		if (!strcmp(s, keepdialpat[x]))
			return 1;
	return 0;
}

static int bump_gains(struct tor_pvt *p)
{
	int res;
	/* Bump receive gain by 9.0db */
	res = set_actual_gain(zap_fd(p->z), 0, 9, 0);
	if (res) {
		ast_log(LOG_WARNING, "Unable to bump gain\n");
		return -1;
	}
	return 0;
}

static int restore_gains(struct tor_pvt *p)
{
	int res;
	/* Bump receive gain by 9.0db */
	res = set_actual_gain(zap_fd(p->z), 0, 0, 0);
	if (res) {
		ast_log(LOG_WARNING, "Unable to restore gain\n");
		return -1;
	}
	return 0;
}

static void *ss_thread(void *data)
{
	struct ast_channel *chan = data;
	struct tor_pvt *p = chan->pvt->pvt;
	char exten[AST_MAX_EXTENSION];
	char exten2[AST_MAX_EXTENSION];
	unsigned char buf[256];
	char cid[256];
	struct callerid_state *cs;
	char *name, *number;
	int flags;
	int i;
	char *s1, *s2;
	int len = 0;
	int res;
	if (option_verbose > 2) 
		ast_verbose( VERBOSE_PREFIX_3 "Starting simple switch on '%s'\n", chan->name);
	zap_clrdtmf(p->z);
	switch(p->sig) {
	case SIG_FEATD:
	case SIG_EMWINK:
		zap_wink(p->z);
		/* Fall through */
	case SIG_EM:
		res = tone_zone_play_tone(zap_fd(p->z), -1);
		zap_clrdtmf(p->z);
		/* Wait for the first digit (up to 1 second). */
		res = zap_getdtmf(p->z, 1, NULL, 0, 1000, 1000, ZAP_TIMEOUTOK | ZAP_HOOKEXIT);

		if (res == 1) {
			/* If we got it, get the rest */
			res = zap_getdtmf(p->z, 50, NULL, 0, 250, 15000, ZAP_TIMEOUTOK | ZAP_HOOKEXIT);
		}
		if (res == -1) {
			ast_log(LOG_WARNING, "getdtmf on channel %d: %s\n", p->channel, strerror(errno));
			ast_hangup(chan);
			return NULL;
		} else if (res < 0) {
			ast_log(LOG_DEBUG, "Got hung up before digits finished\n");
			ast_hangup(chan);
			return NULL;
		}
		strncpy(exten, zap_dtmfbuf(p->z), sizeof(exten));
		if (!strlen(exten))
			strncpy(exten, "s", sizeof(exten));
		if (p->sig == SIG_FEATD) {
			if (exten[0] == '*') {
				strncpy(exten2, exten, sizeof(exten2));
				/* Parse out extension and callerid */
				s1 = strtok(exten2 + 1, "*");
				s2 = strtok(NULL, "*");
				if (s2) {
					if (strlen(p->callerid))
						chan->callerid = strdup(p->callerid);
					else
						chan->callerid = strdup(s1);
					strncpy(exten, s2, sizeof(exten));
				} else
					strncpy(exten, s1, sizeof(exten));
			} else
				ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d.  Assuming E&M Wink instead\n", p->channel);
		}
		res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_RINGTONE);
		if (res < 0)
			ast_log(LOG_WARNING, "Unable to start ringback tone on channel %d\n", p->channel);
		if (ast_exists_extension(chan, chan->context, exten, 1)) {
			strncpy(chan->exten, exten, sizeof(chan->exten));
			zap_clrdtmf(p->z);
			res = ast_pbx_run(chan);
			if (res) 
				ast_log(LOG_WARNING, "PBX exited non-zero\n");
			res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
			return NULL;
		} else {
			if (option_verbose > 2)
				ast_verbose(VERBOSE_PREFIX_2 "Unknown extension '%s' in context '%s' requested\n", exten, chan->context);
			sleep(2);
			res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_INFO);
			if (res < 0)
				ast_log(LOG_WARNING, "Unable to start special tone on %d\n", p->channel);
			else
				sleep(1);
			res = ast_streamfile(chan, "ss-noservice", chan->language);
			if (res >= 0)
				ast_waitstream(chan, "");
			res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
			ast_hangup(chan);
			return NULL;
		}
		break;
	case SIG_FXOLS:
	case SIG_FXOGS:
	case SIG_FXOKS:
		/* Read the first digit */
		res = zap_getdtmf(p->z, 1, NULL, 0, firstdigittimeout, firstdigittimeout, ZAP_HOOKEXIT | ZAP_TIMEOUTOK);
		if (res < 0) {
			if (option_debug)
				ast_log(LOG_DEBUG, "getdtmf returned %d (%s)...\n", res, strerror(errno));
			/* Got hung up on apparently.  Stop any playing tones.  We're done */
			res = tone_zone_play_tone(zap_fd(p->z), -1);
			ast_hangup(chan);
			return NULL;
		}
		if (res) {
			strncpy(exten + len, zap_dtmfbuf(p->z), sizeof(exten) - len);
			len++;
			if (ast_exists_extension(chan, chan->context, exten, 1)) {
				if (!ignore_pat(exten)) {
					res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_RINGTONE);
					if (res < 0)
						ast_log(LOG_WARNING, "Unable to start ringback tone on channel %d\n", p->channel);
				}
				/* Check for a single digit extension */
				strncpy(chan->exten, exten, sizeof(chan->exten));
				zap_clrdtmf(p->z);
				res = ast_pbx_run(chan);
				if (res) 
					ast_log(LOG_WARNING, "PBX exited non-zero\n");
				res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
				return NULL;
			}
			
			if (!ignore_pat(exten))
				tone_zone_play_tone(zap_fd(p->z), -1);
			while(len < AST_MAX_EXTENSION-1) {
				zap_clrdtmf(p->z);
				res = zap_getdtmf(p->z, 1, NULL, 0, gendigittimeout, gendigittimeout, ZAP_HOOKEXIT | ZAP_TIMEOUTOK);
				if (res < 0) {
					ast_log(LOG_DEBUG, "getdtmf returned < 0...\n");
					res = tone_zone_play_tone(zap_fd(p->z), -1);
					ast_hangup(chan);
					return NULL;
				} else if (res == 0) {
					ast_log(LOG_DEBUG, "not enough digits...\n");
					res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
					tor_wait_event(zap_fd(p->z));
					ast_hangup(chan);
					return NULL;
				} else {
					strncpy(exten + len, zap_dtmfbuf(p->z), sizeof(exten) - len);
					len++;
					if (!ignore_pat(exten))
						tone_zone_play_tone(zap_fd(p->z), -1);
					if (ast_exists_extension(chan, chan->context, exten, 1)) {
						res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_RINGTONE);
						if (res < 0)
							ast_log(LOG_WARNING, "Unable to start ringback tone on channel %d\n", p->channel);
						strncpy(chan->exten, exten, sizeof(chan->exten));
						if (strlen(p->callerid))
							chan->callerid = strdup(p->callerid);
						zap_clrdtmf(p->z);
						res = ast_pbx_run(chan);
						if (res) 
							ast_log(LOG_WARNING, "PBX exited non-zero\n");
						res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
						return NULL;
					} else if (!ast_canmatch_extension(chan, chan->context, exten, 1)) {
						printf("Can't match %s is context %s\n", exten, chan->context);
						break;
					}
				}
			}
		}
		break;
	case SIG_FXSLS:
	case SIG_FXSGS:
	case SIG_FXSKS:
		if (p->use_callerid) {
			cs = callerid_new();
			if (cs) {
#if 1
				bump_gains(p);
#endif				
				len = 0;
				for(;;) {	
					i = TOR_IOMUX_READ | TOR_IOMUX_SIGEVENT;
					if ((res = ioctl(zap_fd(p->z), TOR_IOMUX, &i)))	{
						ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
						callerid_free(cs);
						ast_hangup(chan);
						return NULL;
					}
					if (i & TOR_IOMUX_SIGEVENT) {
						res = tor_get_event(zap_fd(p->z));
						ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
						res = 0;
						break;
					} else if (i & TOR_IOMUX_READ) {
						res = read(zap_fd(p->z), buf + len, sizeof(buf) - len);
						if (res < 0) {
							if (errno != ELAST) {
								ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
								callerid_free(cs);
								ast_hangup(chan);
								return NULL;
							}
							break;
						}
						res = callerid_feed(cs, buf, res);
						if (res < 0) {
							ast_log(LOG_WARNING, "CallerID feed failed: %s\n", strerror(errno));
							break;
						} else if (res)
							break;
					}
				}
				if (res == 1) {
					callerid_get(cs, &number, &name, &flags);
					if (option_debug)
						ast_log(LOG_DEBUG, "CallerID number: %s, name: %s, flags=%d\n", number, name, flags);
				}
#if 1
				restore_gains(p);
#endif				
				if (res < 0) {
					ast_log(LOG_WARNING, "CallerID returned with error on channel '%s'\n", chan->name);
				}
			} else
				ast_log(LOG_WARNING, "Unable to get caller ID space\n");
		}
		if (name && number) {
			snprintf(cid, sizeof(cid), "\"%s\" <%s>", name, number);
		} else if (name) {
			snprintf(cid, sizeof(cid), "\"%s\"", name);
		} else if (number) {
			snprintf(cid, sizeof(cid), "%s", number);
		} else {
			strcpy(cid, "");
		}
		if (strlen(cid))
			chan->callerid = strdup(cid);
		chan->state = AST_STATE_RING;
		chan->rings = 1;
		res = ast_pbx_run(chan);
		if (res) {
			ast_hangup(chan);
			ast_log(LOG_WARNING, "PBX exited non-zero\n");
		}
		return NULL;
	default:
		ast_log(LOG_WARNING, "Don't know how to handle simple switch with signalling %s on channel %d\n", sig2str(p->sig), p->channel);
		res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
		if (res < 0)
				ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel);
	}
	res = tone_zone_play_tone(zap_fd(p->z), TOR_TONE_CONGESTION);
	if (res < 0)
			ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel);
	ast_hangup(chan);
	return NULL;
}

static int handle_init_event(struct tor_pvt *i, int event)
{
	int res;
	pthread_t threadid;
	struct ast_channel *chan;
	/* Handle an event on a given channel for the monitor thread. */
	switch(event) {
	case TOR_EVENT_RINGOFFHOOK:
		/* Got a ring/answer.  What kind of channel are we? */
		switch(i->sig) {
		case SIG_FXOLS:
		case SIG_FXOGS:
		case SIG_FXOKS:
			if (i->immediate) {
				/* The channel is immediately up.  Start right away */
				chan = tor_new(i, AST_STATE_UP, 1);
				if (!chan)  {
					ast_log(LOG_WARNING, "Unable to start PBX on channel %d\n", i->channel);
					res = tone_zone_play_tone(zap_fd(i->z), TOR_TONE_CONGESTION);
					if (res < 0)
						ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel);
				}
			} else {
				res = tone_zone_play_tone(zap_fd(i->z), TOR_TONE_DIALTONE);
				if (res < 0) 
					ast_log(LOG_WARNING, "Unable to play dialtone on channel %d\n", i->channel);
				/* Check for callerid, digits, etc */
				chan = tor_new(i, AST_STATE_DOWN, 0);
				if (pthread_create(&threadid, NULL, ss_thread, chan)) {
					ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel);
					res = tone_zone_play_tone(zap_fd(i->z), TOR_TONE_CONGESTION);
					if (res < 0)
						ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel);
					ast_hangup(chan);
				}
			}
			break;
		case SIG_EMWINK:
		case SIG_FEATD:
		case SIG_EM:
		case SIG_FXSLS:
		case SIG_FXSGS:
		case SIG_FXSKS:
				/* Check for callerid, digits, etc */
				chan = tor_new(i, AST_STATE_RING, 0);
				if (pthread_create(&threadid, NULL, ss_thread, chan)) {
					ast_log(LOG_WARNING, "Unable to start simple switch thread on channel %d\n", i->channel);
					res = tone_zone_play_tone(zap_fd(i->z), TOR_TONE_CONGESTION);
					if (res < 0)
						ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel);
					ast_hangup(chan);
				}
				break;
		default:
			ast_log(LOG_WARNING, "Don't know how to handle ring/answer with signalling %s on channel %d\n", sig2str(i->sig), i->channel);
			res = tone_zone_play_tone(zap_fd(i->z), TOR_TONE_CONGESTION);
			if (res < 0)
					ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", i->channel);
			return -1;
		}
		break;
	case TOR_EVENT_WINKFLASH:
	case TOR_EVENT_ONHOOK:
		/* Back on hook.  Hang up. */
		switch(i->sig) {
		case SIG_FXOLS:
		case SIG_FXOGS:
		case SIG_FXOKS:
		case SIG_FEATD:
		case SIG_EM:
		case SIG_EMWINK:
		case SIG_FXSLS:
		case SIG_FXSGS:
		case SIG_FXSKS:
			res = tone_zone_play_tone(zap_fd(i->z), -1);
			tor_set_hook(zap_fd(i->z), TOR_ONHOOK);
			break;
		default:
			ast_log(LOG_WARNING, "Don't know hwo to handle on hook with signalling %s on channel %d\n", sig2str(i->sig), i->channel);
			res = tone_zone_play_tone(zap_fd(i->z), -1);
			return -1;
		}
		break;
	}
	return 0;
}

static void *do_monitor(void *data)
{
	fd_set rfds;
	fd_set efds;
	int n, res;
	struct tor_pvt *i;
	/* This thread monitors all the frame relay interfaces which are not yet in use
	   (and thus do not have a separate thread) indefinitely */
	/* From here on out, we die whenever asked */
#if 0
	if (pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL)) {
		ast_log(LOG_WARNING, "Unable to set cancel type to asynchronous\n");
		return NULL;
	}
	ast_log(LOG_DEBUG, "Monitor starting...\n");
#endif
	for(;;) {
		/* Don't let anybody kill us right away.  Nobody should lock the interface list
		   and wait for the monitor list, but the other way around is okay. */
		if (pthread_mutex_lock(&monlock)) {
			ast_log(LOG_ERROR, "Unable to grab monitor lock\n");
			return NULL;
		}
		/* Lock the interface list */
		if (pthread_mutex_lock(&iflock)) {
			ast_log(LOG_ERROR, "Unable to grab interface lock\n");
			pthread_mutex_unlock(&monlock);
			return NULL;
		}
		/* Build the stuff we're going to select on, that is the socket of every
		   tor_pvt that does not have an associated owner channel */
		n = -1;
		FD_ZERO(&efds);
		i = iflist;
		while(i) {
			if (FD_ISSET(zap_fd(i->z), &efds)) 
				ast_log(LOG_WARNING, "Descriptor %d appears twice?\n", zap_fd(i->z));
			if (!i->owner) {
				/* This needs to be watched, as it lacks an owner */
				FD_SET(zap_fd(i->z), &efds);
				if (zap_fd(i->z) > n)
					n = zap_fd(i->z);
			}
			i = i->next;
		}
		/* Okay, now that we know what to do, release the interface lock */
		pthread_mutex_unlock(&iflock);
		
		/* And from now on, we're okay to be killed, so release the monitor lock as well */
		pthread_mutex_unlock(&monlock);
		pthread_testcancel();
		/* Wait indefinitely for something to happen */
		res = select(n + 1, &rfds, NULL, &efds, NULL);
		pthread_testcancel();
		/* Okay, select has finished.  Let's see what happened.  */
		if (res < 0) {
			if ((errno != EAGAIN) && (errno != EINTR))
				ast_log(LOG_WARNING, "select return %d: %s\n", res, strerror(errno));
			continue;
		}
		/* Alright, lock the interface list again, and let's look and see what has
		   happened */
		if (pthread_mutex_lock(&iflock)) {
			ast_log(LOG_WARNING, "Unable to lock the interface list\n");
			continue;
		}
		i = iflist;
		while(i) {
			if (FD_ISSET(zap_fd(i->z), &efds)) {
				if (i->owner) {
					ast_log(LOG_WARNING, "Whoa....  I'm owned but found (%d)...\n", zap_fd(i->z));
					i = i->next;
					continue;
				}
				res = tor_get_event(zap_fd(i->z));
				ast_log(LOG_DEBUG, "Monitor doohicky got event %s on channel %d\n", event2str(res), i->channel);
				handle_init_event(i, res);
			}
			i=i->next;
		}
		pthread_mutex_unlock(&iflock);
	}
	/* Never reached */
	return NULL;
	
}

static int restart_monitor(void)
{
	/* If we're supposed to be stopped -- stay stopped */
	if (monitor_thread == -2)
		return 0;
	if (pthread_mutex_lock(&monlock)) {
		ast_log(LOG_WARNING, "Unable to lock monitor\n");
		return -1;
	}
	if (monitor_thread == pthread_self()) {
		pthread_mutex_unlock(&monlock);
		ast_log(LOG_WARNING, "Cannot kill myself\n");
		return -1;
	}
	if (monitor_thread) {
#if 1
		pthread_cancel(monitor_thread);
#endif
		pthread_kill(monitor_thread, SIGURG);
#if 0
		pthread_join(monitor_thread, NULL);
#endif
	}
	/* Start a new monitor */
	if (pthread_create(&monitor_thread, NULL, do_monitor, NULL) < 0) {
		pthread_mutex_unlock(&monlock);
		ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
		return -1;
	}
	pthread_mutex_unlock(&monlock);
	return 0;
}

static struct tor_pvt *mkif(int channel, int signalling)
{
	/* Make a tor_pvt structure for this interface */
	struct tor_pvt *tmp;
	char fn[80];
#if 1
	struct tor_bufferinfo bi;
#endif	
	int res;
	TOR_PARAMS p;

	tmp = malloc(sizeof(struct tor_pvt));
	if (tmp) {
		memset(tmp, 0, sizeof(struct tor_pvt));
		snprintf(fn, sizeof(fn), "/dev/tor/%d", channel);
		/* Open non-blocking */
		tmp->z = zap_open(fn, 1);
		/* Allocate a zapata structure */
		if (!tmp->z) {
			ast_log(LOG_ERROR, "Unable to open channel %d: %s\n", channel, strerror(errno));
			free(tmp);
			return NULL;
		}
		res = ioctl(zap_fd(tmp->z), TOR_GET_PARAMS, &p);
		if (res < 0) {
			ast_log(LOG_ERROR, "Unable to get parameters\n");
			free(tmp);
			return NULL;
		}
		if (p.sigtype != (signalling & 0xf)) {
			ast_log(LOG_ERROR, "Signalling requested is %s but line is in %s signalling\n", sig2str(signalling), sig2str(p.sigtype));
			return NULL;
		}
		/* Adjust starttime on loopstart and kewlstart trunks to reasonable values */
		if ((signalling == SIG_FXSKS) || (signalling == SIG_FXSLS)) {
			p.starttime = 250;
			res = ioctl(zap_fd(tmp->z), TOR_SET_PARAMS, &p);
			if (res < 0) {
				ast_log(LOG_ERROR, "Unable to set parameters\n");
				free(tmp);
				return NULL;
			}
		}
#if 0
		res = fcntl(zap_fd(tmp->z), F_GETFL);
		if (res >= 0) {
			res |= O_NONBLOCK;
			if (fcntl(zap_fd(tmp->z), F_SETFL, res))
				ast_log(LOG_WARNING, "Unable to set non-blocking mode on channel %d\n", channel);
		} else
			ast_log(LOG_WARNING, "Unable to read flags on channel %d\n", channel);
#endif			
#if 1
		res = ioctl(zap_fd(tmp->z), TOR_GET_BUFINFO, &bi);
		if (!res) {
			bi.txbufpolicy = POLICY_IMMEDIATE;
			bi.rxbufpolicy = POLICY_IMMEDIATE;
			bi.numbufs = 4;
			res = ioctl(zap_fd(tmp->z), TOR_SET_BUFINFO, &bi);
			if (res < 0) {
				ast_log(LOG_WARNING, "Unable to set buffer policy on channel %d\n", channel);
			}
		} else
			ast_log(LOG_WARNING, "Unable to check buffer policy on channel %d\n", channel);
#endif
		tmp->immediate = immediate;
		tmp->state = tor_STATE_DOWN;
		tmp->sig = signalling;
		tmp->use_callerid = use_callerid;
		tmp->channel = channel;
		tmp->stripmsd = stripmsd;
		strncpy(tmp->language, language, sizeof(tmp->language));
		strncpy(tmp->context, context, sizeof(tmp->context));
		strncpy(tmp->callerid, callerid, sizeof(tmp->callerid));
		tmp->group = cur_group;
		tmp->next = NULL;
		tmp->ringgothangup = 0;
		/* Hang it up to be sure it's good */
		tor_set_hook(zap_fd(tmp->z), TOR_ONHOOK);
		
	}
	return tmp;
}

static struct ast_channel *tor_request(char *type, int format, void *data)
{
	int oldformat;
	int groupmatch = 0;
	int channelmatch = -1;
	struct tor_pvt *p;
	struct ast_channel *tmp = NULL;
	char *dest=NULL;
	int x;
	char *s;
	
	/* We do signed linear */
	oldformat = format;
	format &= (AST_FORMAT_SLINEAR | AST_FORMAT_ULAW);
	if (!format) {
		ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format '%d'\n", oldformat);
		return NULL;
	}
	if (data) {
		dest = strdup((char *)data);
	} else {
		ast_log(LOG_WARNING, "Channel requested with no data\n");
		return NULL;
	}
	if (dest[0] == 'g') {
		/* Retrieve the group number */
		s = strtok(dest  + 1, "/");
		if (sscanf(s, "%d", &x) != 1) {
			ast_log(LOG_WARNING, "Unable to determine group for data %s\n", (char *)data);
			free(dest);
			return NULL;
		}
		groupmatch = 1 << x;
	} else {
		s = strtok(dest, "/");
		if (sscanf(s, "%d", &x) != 1) {
			ast_log(LOG_WARNING, "Unable to determine channel for data %s\n", (char *)data);
			free(dest);
			return NULL;
		}
		channelmatch = x;
	}
	/* Search for an unowned channel */
	if (pthread_mutex_lock(&iflock)) {
		ast_log(LOG_ERROR, "Unable to lock interface list???\n");
		return NULL;
	}
	p = iflist;
	while(p && !tmp) {
		if (!p->owner &&	/* No current owner */
		    ((channelmatch < 0) || (p->channel == channelmatch)) && /* Right channel */
			(((p->group & groupmatch) == groupmatch))				/* Right group */
		) {
			if (option_debug)
				ast_log(LOG_DEBUG, "Using channel %d\n", p->channel);
			tmp = tor_new(p, AST_STATE_RESERVED, 0);
			break;
		}
		p = p->next;
	}
	pthread_mutex_unlock(&iflock);
	restart_monitor();
	return tmp;
}


static int get_group(char *s)
{
	char *copy;
	char *piece;
	int start, finish,x;
	int group = 0;
	copy = strdup(s);
	if (!copy) {
		ast_log(LOG_ERROR, "Out of memory\n");
		return 0;
	}
	piece = strtok(copy, ",");
	while(piece) {
		if (sscanf(piece, "%d-%d", &start, &finish) == 2) {
			/* Range */
		} else if (sscanf(piece, "%d", &start)) {
			/* Just one */
			finish = start;
		} else {
			ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'.  Using '0'\n", s,piece);
			return 0;
		}
		piece = strtok(NULL, ",");
		for (x=start;x<=finish;x++) {
			if ((x > 31) || (x < 0)) {
				ast_log(LOG_WARNING, "Ignoring invalid group %d\n", x);
			} else
				group |= (1 << x);
		}
	}
	free(copy);
	return group;
}

int load_module()
{
	struct ast_config *cfg;
	struct ast_variable *v;
	struct tor_pvt *tmp;
	char *chan;
	int start, finish,x;
	cfg = ast_load(config);

	/* We *must* have a config file otherwise stop immediately */
	if (!cfg) {
		ast_log(LOG_ERROR, "Unable to load config %s\n", config);
		return -1;
	}
	

	if (pthread_mutex_lock(&iflock)) {
		/* It's a little silly to lock it, but we mind as well just to be sure */
		ast_log(LOG_ERROR, "Unable to lock interface list???\n");
		return -1;
	}
	v = ast_variable_browse(cfg, "channels");
	while(v) {
		/* Create the interface list */
		if (!strcasecmp(v->name, "channel")) {
			if (cur_signalling < 0) {
				ast_log(LOG_ERROR, "Signalling must be specified before any channels are.\n");
				ast_destroy(cfg);
				pthread_mutex_unlock(&iflock);
				unload_module();
				return -1;
			}
			chan = strtok(v->value, ",");
			while(chan) {
				if (sscanf(chan, "%d-%d", &start, &finish) == 2) {
					/* Range */
				} else if (sscanf(chan, "%d", &start)) {
					/* Just one */
					finish = start;
				} else {
					ast_log(LOG_ERROR, "Syntax error parsing '%s' at '%s'\n", v->value, chan);
					ast_destroy(cfg);
					pthread_mutex_unlock(&iflock);
					unload_module();
					return -1;
				}
				if (finish < start) {
					ast_log(LOG_WARNING, "Sillyness: %d < %d\n", start, finish);
					x = finish;
					finish = start;
					start = x;
				}
				for (x=start;x<=finish;x++) {
					tmp = mkif(x, cur_signalling);
					if (tmp) {
						tmp->next = iflist;
						iflist = tmp;
						if (option_verbose > 2)
							ast_verbose(VERBOSE_PREFIX_3 "Registered channel %d, %s signalling\n", x, sig2str(tmp->sig));
					} else {
						ast_log(LOG_ERROR, "Unable to register channel '%s'\n", v->value);
						ast_destroy(cfg);
						pthread_mutex_unlock(&iflock);
						unload_module();
						return -1;
					}
				}
				chan = strtok(NULL, ",");
			}
		} else if (!strcasecmp(v->name, "context")) {
			strncpy(context, v->value, sizeof(context));
		} else if (!strcasecmp(v->name, "language")) {
			strncpy(language, v->value, sizeof(language));
		} else if (!strcasecmp(v->name, "stripmsd")) {
			stripmsd = atoi(v->value);
		} else if (!strcasecmp(v->name, "group")) {
			cur_group = get_group(v->value);
		} else if (!strcasecmp(v->name, "immediate")) {
			immediate = ast_true(v->value);
		} else if (!strcasecmp(v->name, "callerid")) {
			if (!strcasecmp(v->value, "asreceived"))
				strcpy(callerid,"");
			else
				strncpy(callerid, v->value, sizeof(callerid));
		} else if (!strcasecmp(v->name, "ignorepat")) {
			if (dialpats < AST_MAX_DIAL_PAT - 1) {
				strncpy(keepdialpat[dialpats], v->value, sizeof(keepdialpat[dialpats]));
				dialpats++;
			} else
				ast_log(LOG_WARNING, "Too many dial patterns, ignoring '%s'\n", v->value);
		} else if (!strcasecmp(v->name, "signalling")) {
			if (!strcasecmp(v->value, "em")) {
				cur_signalling = SIG_EM;
			} else if (!strcasecmp(v->value, "em_w")) {
				cur_signalling = SIG_EMWINK;
			} else if (!strcasecmp(v->value, "fxs_ls")) {
				cur_signalling = SIG_FXSLS;
			} else if (!strcasecmp(v->value, "fxs_gs")) {
				cur_signalling = SIG_FXSGS;
			} else if (!strcasecmp(v->value, "fxs_ks")) {
				cur_signalling = SIG_FXSKS;
			} else if (!strcasecmp(v->value, "fxo_ls")) {
				cur_signalling = SIG_FXOLS;
			} else if (!strcasecmp(v->value, "fxo_gs")) {
				cur_signalling = SIG_FXOGS;
			} else if (!strcasecmp(v->value, "fxo_ks")) {
				cur_signalling = SIG_FXOKS;
			} else if (!strcasecmp(v->value, "featd")) {
				cur_signalling = SIG_FEATD;
			} else {
				ast_log(LOG_ERROR, "Unknown signalling method '%s'\n", v->value);
				ast_destroy(cfg);
				pthread_mutex_unlock(&iflock);
				unload_module();
				return -1;
			}
		} else
			ast_log(LOG_DEBUG, "Ignoring %s\n", v->name);
		v = v->next;
	}
	pthread_mutex_unlock(&iflock);
	/* Make sure we can register our Tor channel type */
	if (ast_channel_register(type, tdesc, AST_FORMAT_SLINEAR |  AST_FORMAT_ULAW, tor_request)) {
		ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
		ast_destroy(cfg);
		unload_module();
		return -1;
	}
	ast_destroy(cfg);
	/* And start the monitor for the first time */
	restart_monitor();
	return 0;
}

int unload_module()
{
	struct tor_pvt *p, *pl;
	/* First, take us out of the channel loop */
	ast_channel_unregister(type);
	if (!pthread_mutex_lock(&iflock)) {
		/* Hangup all interfaces if they have an owner */
		p = iflist;
		while(p) {
			if (p->owner)
				ast_softhangup(p->owner);
			p = p->next;
		}
		iflist = NULL;
		pthread_mutex_unlock(&iflock);
	} else {
		ast_log(LOG_WARNING, "Unable to lock the monitor\n");
		return -1;
	}
	if (!pthread_mutex_lock(&monlock)) {
		if (monitor_thread) {
			pthread_cancel(monitor_thread);
			pthread_kill(monitor_thread, SIGURG);
			pthread_join(monitor_thread, NULL);
		}
		monitor_thread = -2;
		pthread_mutex_unlock(&monlock);
	} else {
		ast_log(LOG_WARNING, "Unable to lock the monitor\n");
		return -1;
	}

	if (!pthread_mutex_lock(&iflock)) {
		/* Destroy all the interfaces and free their memory */
		p = iflist;
		while(p) {
			/* Free any callerid */
			if (p->cidspill)
				free(p->cidspill);
			/* Close the zapata thingy */
			if (p->z)
				zap_close(p->z);
			pl = p;
			p = p->next;
			/* Free associated memory */
			free(pl);
		}
		iflist = NULL;
		pthread_mutex_unlock(&iflock);
	} else {
		ast_log(LOG_WARNING, "Unable to lock the monitor\n");
		return -1;
	}
		
	return 0;
}
int usecount()
{
	int res;
	pthread_mutex_lock(&usecnt_lock);
	res = usecnt;
	pthread_mutex_unlock(&usecnt_lock);
	return res;
}

char *description()
{
	return desc;
}

char *key()
{
	return ASTERISK_GPL_KEY;
}