freeswitch/libs/freetdm/src/ftmod/ftmod_misdn/ftmod_misdn.c

/**
 * mISDN HW interface
 *
 * Copyright (c) 2011, Stefan Knoblich <stkn@openisdn.net>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * NOTE: This is intended as a Layer 1 interface only, signaling
 *       is handled by other modules (e.g. ftmod_libpri or ftmod_isdn).
 */

#include <errno.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <poll.h>
#include <pthread.h>

#include <sys/timerfd.h>

/* this is how it should have been...
#ifdef HAVE_FREETDM_FREETDM_H
#include <freetdm/freetdm.h>
#else
#include <freetdm.h>
#endif
*/
/* ... and this is how it is */
#include <private/ftdm_core.h>

#include <mISDN/mISDNif.h>

/*
 * mISDNcompat.h replaces these with references to an extern int,
 * which is exported by libmisdn... unset them and use the official
 * AF ID "34"
 */
#undef PF_ISDN
#undef AF_ISDN
#define AF_ISDN         34
#define PF_ISDN         AF_ISDN

//#define MISDN_DEBUG_EVENTS
//#define MISDN_DEBUG_IO

#ifndef MIN
#define MIN(x,y)	(((x) < (y)) ? (x) : (y))
#endif

typedef enum {
	MISDN_CAPS_NONE = 0,

	/* D-Channel */
	MISDN_CAPS_PRI = (1 << 0),
	MISDN_CAPS_BRI = (1 << 1),
	MISDN_CAPS_UP0 = (1 << 2),
	MISDN_CAPS_NT  = (1 << 3),
	MISDN_CAPS_TE  = (1 << 4),

	/* B-Channel */
	MISDN_CAPS_RAW  = (1 << 10),
	MISDN_CAPS_HDLC = (1 << 11),
} misdn_capability_flags_t;

#define MISDN_IS_BRI(x)	(x & MISDN_CAPS_BRI)
#define MISDN_IS_PRI(x)	(x & MISDN_CAPS_PRI)

#define MISDN_IS_TE(x)	(x & MISDN_CAPS_TE)
#define MISDN_IS_NT(x)	(x & MISDN_CAPS_NT)

#define MISDN_IS_RAW(x)  (x & MISDN_CAPS_RAW)
#define MISDN_IS_HDLC(x) (x & MISDN_CAPS_HDLC)


const static struct {
	const int	id;
	const char	*name;
} misdn_event_types[] = {
	{ PH_DATA_REQ,       "PH_DATA_REQ"       },
	{ PH_DATA_IND,       "PH_DATA_IND"       },
	{ PH_DATA_CNF,       "PH_DATA_CNF"       },
	{ PH_CONTROL_REQ,    "PH_CONTROL_REQ"    },
	{ PH_CONTROL_IND,    "PH_CONTROL_IND"    },
	{ PH_CONTROL_CNF,    "PH_CONTROL_CNF"    },
	{ PH_ACTIVATE_REQ,   "PH_ACTIVATE_REQ"   },
	{ PH_ACTIVATE_IND,   "PH_ACTIVATE_IND"   },
	{ PH_ACTIVATE_CNF,   "PH_ACTIVATE_CNF"   },
	{ PH_DEACTIVATE_REQ, "PH_DEACTIVATE_REQ" },
	{ PH_DEACTIVATE_IND, "PH_DEACTIVATE_IND" },
	{ PH_DEACTIVATE_CNF, "PH_DEACTIVATE_CNF" },
};

static const char *misdn_event2str(const int event)
{
	int x;

	for (x = 0; x < ftdm_array_len(misdn_event_types); x++) {
		if (event == misdn_event_types[x].id)
			return misdn_event_types[x].name;
	}
	return "unknown";
}


const static struct {
	const int	id;
	const char	*name;
} misdn_control_types[] = {
#define MISDN_CONTROL_TYPE(x)	{ x, #x }
	MISDN_CONTROL_TYPE(DTMF_HFC_COEF),
};

#if 0 /* unused for now */
static const char *misdn_control2str(const int ctrl)
{
	int x;

	for (x = 0; x < ftdm_array_len(misdn_control_types); x++) {
		if (ctrl == misdn_control_types[x].id)
			return misdn_control_types[x].name;
	}
	return "unknown";
}
#endif

/***********************************************************************************
 * mISDN <-> FreeTDM data structures
 ***********************************************************************************/

enum {
	MISDN_SPAN_NONE    = 0,
	MISDN_SPAN_RUNNING = (1 << 0),
	MISDN_SPAN_STOPPED = (1 << 1)
};

struct misdn_span_private {
	int flags;

	/* event conditional */
	pthread_mutex_t event_cond_mutex;
	pthread_cond_t  event_cond;
};

#define MISDN_CHAN_STATE_CLOSED 0
#define MISDN_CHAN_STATE_OPEN   1

struct misdn_event_queue;

struct misdn_chan_private {
	/* */
	int state;
	int debugfd;
	int timerfd;

	/* hw addr of channel */
	struct sockaddr_mISDN addr;

	/* counters */
	unsigned long tx_cnt;
	unsigned long tx_ack_cnt;
	unsigned long rx_cnt;
	unsigned long slip_rx_cnt;
	unsigned long slip_tx_cnt;

	struct misdn_event_queue *events;
};

#define ftdm_chan_io_private(x) ((x)->io_data)
#define ftdm_span_io_private(x) ((x)->io_data)

static ftdm_status_t misdn_handle_incoming(ftdm_channel_t *ftdmchan, const char *rbuf, const int size);

/***********************************************************************************
 * mISDN interface functions
 ***********************************************************************************/

/*
 * Event Queue
 */
#define MISDN_EVENTS_MAX 8

struct misdn_event {
	int id;
};

struct misdn_event_queue {
	int read_pos;
	int write_pos;
	pthread_mutex_t mutex;

	struct misdn_event events[MISDN_EVENTS_MAX];
};

/**
 * Initialize event queue
 */
static ftdm_status_t misdn_event_queue_create(struct misdn_event_queue **queue)
{
	struct misdn_event_queue *tmp = NULL;

	if (!queue)
		return FTDM_FAIL;

	tmp = calloc(1, sizeof(*tmp));
	if (!tmp)
		return FTDM_FAIL;

	pthread_mutex_init(&tmp->mutex, NULL);

	*queue = tmp;
	return FTDM_SUCCESS;
}

/**
 * Destroy event queue
 */
static ftdm_status_t misdn_event_queue_destroy(struct misdn_event_queue **queue)
{
	if (!queue || !*queue)
		return FTDM_FAIL;

	pthread_mutex_destroy(&(*queue)->mutex);
	ftdm_safe_free(*queue);
	*queue = NULL;

	return FTDM_SUCCESS;
}

static ftdm_status_t misdn_event_queue_reset(struct misdn_event_queue *queue)
{
	if (!queue)
		return FTDM_FAIL;
	pthread_mutex_lock(&queue->mutex);

	memset(queue->events, 0, sizeof(queue->events));
	queue->read_pos = queue->write_pos = 0;

	pthread_mutex_unlock(&queue->mutex);
	return FTDM_SUCCESS;
}

static ftdm_status_t misdn_event_queue_has_data(const struct misdn_event_queue *queue)
{
	if (!queue)
		return FTDM_FALSE;

	return (queue->read_pos == queue->write_pos) ? FTDM_FALSE : FTDM_TRUE;
}

static struct misdn_event *misdn_event_queue_pop(struct misdn_event_queue *queue)
{
	struct misdn_event *evt = NULL;
	int next_idx = 0;

	if (!queue)
		return NULL;

	pthread_mutex_lock(&queue->mutex);

	next_idx = (queue->read_pos + 1) % MISDN_EVENTS_MAX;

	if (queue->read_pos == queue->write_pos) {
#ifdef MISDN_DEBUG_EVENTS
		ftdm_log(FTDM_LOG_DEBUG, "mISDN queue %p: empty\n", queue);
#endif
		pthread_mutex_unlock(&queue->mutex);
		return NULL;
	}

#ifdef MISDN_DEBUG_EVENTS
	ftdm_log(FTDM_LOG_DEBUG, "mISDN queue %p: read event (read_pos: %d, write_pos: %d, next_write_pos: %d)\n",
		queue, queue->read_pos, queue->write_pos, next_idx);
#endif
	/* update read pos */
	evt = &queue->events[queue->read_pos];
	queue->read_pos = next_idx;

	pthread_mutex_unlock(&queue->mutex);
	return evt;
}

static ftdm_status_t misdn_event_queue_push(struct misdn_event_queue *queue, struct misdn_event *evt)
{
	int next_idx = 0;

	if (!queue || !evt)
		return FTDM_FAIL;

	pthread_mutex_lock(&queue->mutex);

	next_idx = (queue->write_pos + 1) % MISDN_EVENTS_MAX;

	if (next_idx == queue->read_pos) {
#ifdef MISDN_DEBUG_EVENTS
		ftdm_log(FTDM_LOG_DEBUG, "mISDN queue %p: full\n", queue);
#endif
		pthread_mutex_unlock(&queue->mutex);
		return FTDM_FAIL;
	}

#ifdef MISDN_DEBUG_EVENTS
	ftdm_log(FTDM_LOG_DEBUG, "mISDN queue %p: wrote event (read_pos: %d, write_pos: %d, next_write_pos: %d)\n",
		queue, queue->read_pos, queue->write_pos, next_idx);
#endif
	memcpy(&queue->events[queue->write_pos], evt, sizeof(*evt));
	queue->write_pos = next_idx;

	pthread_mutex_unlock(&queue->mutex);
	return FTDM_SUCCESS;
}

#if 0 /* unused for now */
static void misdn_event_queue_print_info(const struct misdn_event_queue *queue)
{
	ftdm_log(FTDM_LOG_DEBUG, "Queue %p\n\tread idx: %d\n\twrite idx: %d\n", queue,
			queue->read_pos, queue->write_pos);
}
#endif

/***********************************************************************************
 * mISDN helper functions
 ***********************************************************************************/

#define MISDN_PH_ACTIVATE_TIMEOUT_MS		10000
#define MISDN_MPH_INFORMATION_TIMEOUT_MS	3000

static inline void ts_add_msec(struct timespec *a, int msec)
{
	a->tv_sec  += (msec / 1000);
	a->tv_nsec += (msec % 1000) * 1000000;
	if (a->tv_nsec >= 1000000000) {
		a->tv_sec++;
		a->tv_nsec -= 1000000000;
	}
}

static inline int ts_sub_msec(struct timespec *a, struct timespec *b)
{
	int msec = 0;
	msec += (a->tv_sec  - b->tv_sec)  * 1000;
	msec += (a->tv_nsec - b->tv_nsec) / 1000000;
	return msec;
}

static inline int ts_after(struct timespec *a, struct timespec *b)
{
	if (a->tv_sec > b->tv_sec) return 1;
	if (a->tv_sec == b->tv_sec && a->tv_nsec > b->tv_nsec) return 1;
	return 0;
}

static inline int ts_before(struct timespec *a, struct timespec *b)
{
	if (a->tv_sec < b->tv_sec) return 1;
	if (a->tv_sec == b->tv_sec && a->tv_nsec < b->tv_nsec) return 1;
	return 0;
}

static ftdm_status_t misdn_activate_channel(ftdm_channel_t *chan, int activate)
{
	char buf[MAX_DATA_MEM] = { 0 };
	struct mISDNhead *hh = (struct mISDNhead *) buf;
	struct timespec abstimeout;
	int req = 0, resp = 0, ms_left = MISDN_PH_ACTIVATE_TIMEOUT_MS;
	int retval;

	ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN sending %s request\n",
		(activate) ? "activation" : "deactivation");

	/* prepare + send request primitive */
	req = (activate) ? PH_ACTIVATE_REQ : PH_DEACTIVATE_REQ;
	hh->prim = req;
	hh->id   = MISDN_ID_ANY;

	if ((retval = sendto(chan->sockfd, hh, sizeof(*hh), 0, NULL, 0)) < sizeof(*hh)) {
		ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN failed to send activation request: %s\n",
			strerror(errno));
		return FTDM_FAIL;
	}

	clock_gettime(CLOCK_MONOTONIC, &abstimeout);
	ts_add_msec(&abstimeout, ms_left);

	/* wait for answer */
	while (1) {
		struct timespec now;
		struct pollfd pfd;

		pfd.fd = chan->sockfd;
		pfd.events  = POLLIN /* | POLLPRI */;
		pfd.revents = 0;

		switch ((retval = poll(&pfd, 1, ms_left))) {
		case  0:	/* timeout */
			goto out;
		case -1:	/* error */
			if (!(retval == EAGAIN || retval == EINTR)) {
				ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN polling for activation confirmation failed: %s\n",
					strerror(errno));
				return FTDM_FAIL;
			}
			break;
		default:	/* read data */
			break;
		}

		if (pfd.revents & (POLLIN | POLLPRI)) {
			/* handle incoming message */
			if ((retval = recvfrom(chan->sockfd, buf, sizeof(buf), 0, NULL, NULL)) <= 0) {
				ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN failed to receive possible answer for %s request: %s\n",
					(activate) ? "activation" : "deactivation", strerror(errno));
				return FTDM_FAIL;
			}
//#ifdef MISDN_DEBUG_EVENTS
			ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN got event '%s' while waiting for %s confirmation\n",
				misdn_event2str(hh->prim), (activate) ? "activation" : "deactivation");
//#endif
			switch (hh->prim) {
			case PH_ACTIVATE_IND:	/* success (or not): save last response, */
			case PH_DEACTIVATE_IND:	/* stop looping if it's the one we've been waiting for */
				resp = hh->prim;
				if (hh->prim == (activate) ? PH_ACTIVATE_IND : PH_DEACTIVATE_IND) goto out;
				break;
			case PH_ACTIVATE_CNF:
			case PH_DEACTIVATE_CNF:
				resp = hh->prim;
				if (hh->prim == (activate) ? PH_ACTIVATE_CNF : PH_DEACTIVATE_CNF) goto out;
				break;
			case PH_ACTIVATE_REQ:	/* REQ echo, ignore */
			case PH_DEACTIVATE_REQ:
				ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN got '%s' echo while waiting for %s confirmation (id: %#x)\n",
					misdn_event2str(hh->prim), (activate) ? "activation" : "deactivation", hh->id);
				break;
			default:		/* other messages, ignore */
				ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN ignoring event '%s' while waiting for %s confirmation\n",
					misdn_event2str(hh->prim), (activate) ? "activation" : "deactivation");
				break;
			}
		}

		/* check timeout */
		clock_gettime(CLOCK_MONOTONIC, &now);

		if (ts_after(&now, &abstimeout) || (ms_left = ts_sub_msec(&abstimeout, &now)) <= 0)
			goto out;
	}
out:
	if (resp == 0) {
		ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN timeout waiting for %s confirmation\n",
			(activate) ? "activation" : "deactivation");
		return FTDM_TIMEOUT;
	}
	if ((req == PH_ACTIVATE_IND   && !(resp == PH_ACTIVATE_CNF   || resp == PH_ACTIVATE_IND)) ||
	    (req == PH_DEACTIVATE_IND && !(resp == PH_DEACTIVATE_CNF || resp == PH_DEACTIVATE_CNF))) {
		ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN received '%s' while waiting for %s\n",
			misdn_event2str(resp), (activate) ? "activation" : "deactivation");
		return FTDM_FAIL;
	}

	ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN received %s confirmation\n",
		(activate) ? "activation" : "deactivation");
	return FTDM_SUCCESS;
}


#if 0 /* unused for now */
static ftdm_status_t misdn_get_ph_info(ftdm_channel_t *chan, struct ph_info *info)
{
	char buf[MAX_DATA_MEM] = { 0 };
	struct mISDNhead *hh;
	struct timespec abstimeout;
	int req = 0, resp = 0, ms_left = MISDN_MPH_INFORMATION_TIMEOUT_MS;
	int retval;

	/* prepare + send request primitive */
	req = MPH_INFORMATION_REQ;
	hh = (struct mISDNhead *)buf;
	hh->prim = req;
	hh->id   = MISDN_ID_ANY;

	ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN sending %s request\n",
		misdn_event2str(req));

	if ((retval = sendto(chan->sockfd, &hh, sizeof(hh), 0, NULL, 0)) < sizeof(hh)) {
		ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN failed to send %s request: %s\n",
			misdn_event2str(req), strerror(errno));
		return FTDM_FAIL;
	}

	clock_gettime(CLOCK_MONOTONIC, &abstimeout);
	ts_add_msec(&abstimeout, ms_left);

	/* wait for answer */
	while (1) {
		struct timespec now;
		struct pollfd pfd;

		pfd.fd = chan->sockfd;
		pfd.events  = POLLIN /* | POLLPRI */;
		pfd.revents = 0;

		switch ((retval = poll(&pfd, 1, ms_left))) {
		case  0:	/* timeout */
			goto out;
		case -1:	/* error */
			if (!(retval == EAGAIN || retval == EINTR)) {
				ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN polling for %s answer failed: %s\n",
					misdn_event2str(req), strerror(errno));
				return FTDM_FAIL;
			}
			break;
		default:	/* read data */
			break;
		}

		if (pfd.revents & (POLLIN | POLLPRI)) {
			/* handle incoming message */
			if ((retval = recvfrom(chan->sockfd, buf, sizeof(buf), 0, NULL, NULL)) <= 0) {
				ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN failed to receive possible answer for %s request: %s\n",
					misdn_event2str(req), strerror(errno));
				return FTDM_FAIL;
			}
//#ifdef MISDN_DEBUG_EVENTS
			ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN got event '%s' while waiting for %s answer\n",
				misdn_event2str(hh->prim), misdn_event2str(req));
//#endif
			switch (hh->prim) {
			case MPH_INFORMATION_IND:	/* success */
				if (retval < MISDN_HEADER_LEN + sizeof(*info)) {
					ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN answer for %s is too short\n",
						misdn_event2str(req));
					return FTDM_FAIL;
				}
				resp = hh->prim;
				/* TODO */
				goto out;
			case MPH_INFORMATION_REQ:	/* REQ echo, ignore */
				ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN got '%s' echo while waiting for %s answer\n",
					misdn_event2str(hh->prim), misdn_event2str(req));
				break;
			default:		/* other messages, ignore */
				ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN ignoring event '%s' while waiting for %s answer\n",
					misdn_event2str(hh->prim), misdn_event2str(req));
				break;
			}
		}

		/* check timeout */
		clock_gettime(CLOCK_MONOTONIC, &now);

		if (ts_after(&now, &abstimeout) || (ms_left = ts_sub_msec(&abstimeout, &now)) <= 0)
			goto out;
	}
out:
	if (resp == 0) {
		ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN timeout waiting for %s answer\n",
			misdn_event2str(req));
		return FTDM_TIMEOUT;
	}

	return FTDM_SUCCESS;
}
#endif

static int misdn_handle_ph_control_ind(ftdm_channel_t *chan, const struct mISDNhead *hh, const void *data, const int data_len)
{
#ifdef MISDN_DEBUG_EVENTS
	ftdm_log_chan(chan, FTDM_LOG_DEBUG,
		"PH_CONTROL_IND:\n"
		"\tMessage:\t%s\n"
		"\tPayload:\t%d\n",
		misdn_control2str(hh->id), data_len);
#endif

	switch (hh->id) {
	case DTMF_HFC_COEF:
		break;
	default:
		break;
	}

	return FTDM_SUCCESS;
}

static int misdn_handle_mph_information_ind(ftdm_channel_t *chan, const struct mISDNhead *hh, const void *data, const int data_len)
{
	struct misdn_chan_private *priv = ftdm_chan_io_private(chan);
	int alarm_flags, value;

	if (data_len < sizeof(value)) {
		ftdm_log_chan_msg(chan, FTDM_LOG_ERROR, "mISDN MPH_INFORMATION_IND message is too short\n");
		return FTDM_FAIL;
	}
	value = *(int *)data;
	alarm_flags = chan->alarm_flags;

	switch (value) {
	case L1_SIGNAL_LOS_ON:
		alarm_flags |= FTDM_ALARM_RED;
		break;
	case L1_SIGNAL_LOS_OFF:
		alarm_flags &= ~FTDM_ALARM_RED;
		break;
	case L1_SIGNAL_AIS_ON:
		alarm_flags |= FTDM_ALARM_AIS;
		break;
	case L1_SIGNAL_AIS_OFF:
		alarm_flags &= ~FTDM_ALARM_AIS;
		break;
	case L1_SIGNAL_RDI_ON:
		alarm_flags |= FTDM_ALARM_YELLOW;
		break;
	case L1_SIGNAL_RDI_OFF:
		alarm_flags &= ~FTDM_ALARM_YELLOW;
		break;
	case L1_SIGNAL_SLIP_RX:
		priv->slip_rx_cnt++;
		break;
	case L1_SIGNAL_SLIP_TX:
		priv->slip_tx_cnt++;
		break;
	default:
		ftdm_log_chan(chan, FTDM_LOG_ERROR, "mISDN unknown MPH_INFORMATION_IND message: %d\n",
			value);
		return FTDM_FAIL;
	}
	if ((value = (alarm_flags ^ chan->alarm_flags))) {
		ftdm_log_chan(chan, FTDM_LOG_DEBUG, "mISDN alarm flags have changed %#x -> %#x\n",
			chan->alarm_flags, alarm_flags);
		chan->alarm_flags ^= value;
	}
	return FTDM_SUCCESS;
}

/***********************************************************************************
 * mISDN <-> FreeTDM interface functions
 ***********************************************************************************/

struct misdn_globals {
	int sockfd;
} globals;

/**
 * \brief	Open channel
 * \param	ftdmchan	FreeTDM channel to open
 */
static FIO_OPEN_FUNCTION(misdn_open)
{
	struct misdn_chan_private *chan_priv = ftdm_chan_io_private(ftdmchan);
	ftdm_span_t *span = ftdm_channel_get_span(ftdmchan);
	struct misdn_span_private *span_priv = ftdm_span_io_private(span);
	ftdm_status_t ret = 0;

	assert(chan_priv);
	assert(span_priv);

	if (chan_priv->state == MISDN_CHAN_STATE_OPEN) {
		ftdm_log_chan_msg(ftdmchan, FTDM_LOG_INFO, "mISDN channel is already open, skipping activation\n");
		return FTDM_SUCCESS;
	}

	/* flush all events */
	misdn_event_queue_reset(chan_priv->events);

	/*
	 * Send activation request
	 */
	ret = misdn_activate_channel(ftdmchan, 1);
	if (ret != FTDM_SUCCESS) {
		ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "Failed to activate channel (socket: %d)\n",
			ftdmchan->sockfd);
		return FTDM_FAIL;
	}

	ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "mISDN channel activation request sent\n");

	switch (ftdmchan->type) {
	case FTDM_CHAN_TYPE_B: {
			struct itimerspec its = {
				.it_interval = { 0, 0 },
				.it_value    = { 0, 0 },
			};

			its.it_interval.tv_nsec = (ftdmchan->effective_interval * 1000000);
			its.it_value.tv_nsec    = (ftdmchan->effective_interval * 1000000);

			/* create tx timerfd */
			chan_priv->timerfd = timerfd_create(CLOCK_MONOTONIC, O_NONBLOCK);
			if (chan_priv->timerfd < 0) {
				ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "mISDN failed to create b-channel tx interval timer: %s\n",
					strerror(errno));
				return FTDM_FAIL;
			}

			/* start tx timerfd */
			ret = timerfd_settime(chan_priv->timerfd, 0, &its, NULL);
			if (ret < 0) {
				ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "mISDN failed to start b-channel tx interval timer: %s\n",
					strerror(errno));
				return FTDM_FAIL;
			}

			ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "mISDN created tx interval (%d ms) timer\n",
				ftdmchan->effective_interval);
		}
	case FTDM_CHAN_TYPE_DQ921:
		chan_priv->state = MISDN_CHAN_STATE_OPEN;
		break;
	default:
		ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "mISDN invalid channel type '%s'\n",
			ftdm_channel_get_type(ftdmchan));
		break;
	}
	return FTDM_SUCCESS;
}

/**
 * \brief	Close channel
 * \param	ftdmchan	FreeTDM channel to close
 */
static FIO_CLOSE_FUNCTION(misdn_close)
{
	struct misdn_chan_private *chan_priv = ftdm_chan_io_private(ftdmchan);
	ftdm_status_t ret = 0;

	assert(chan_priv);

	/* deactivate b-channels on close */
	if (ftdm_channel_get_type(ftdmchan) == FTDM_CHAN_TYPE_B) {
		/*
		 * Stop tx timerfd
		 */
		if (chan_priv->timerfd >= 0) {
			close(chan_priv->timerfd);
			chan_priv->timerfd = -1;
		}

		/*
		 * Send deactivation request (don't wait for answer)
		 */
		ret = misdn_activate_channel(ftdmchan, 0);
		if (ret != FTDM_SUCCESS) {
			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "Failed to deactivate channel\n");
			return FTDM_FAIL;
		}

		ftdm_log_chan_msg(ftdmchan, FTDM_LOG_INFO, "mISDN channel deactivated\n");
		chan_priv->state = MISDN_CHAN_STATE_CLOSED;
	}

	return FTDM_SUCCESS;
}

/**
 * \brief	Execute command
 * \param	ftdmchan	FreeTDM channel
 * \param	command	Command to execute
 * \param	obj	Additional command data
 */
static FIO_COMMAND_FUNCTION(misdn_command)
{
	switch (command) {
	case FTDM_COMMAND_NOOP:
		break;
	case FTDM_COMMAND_SET_INTERVAL:
//	case FTDM_COMMAND_GET_INTERVAL:
	case FTDM_COMMAND_SET_CODEC:
	case FTDM_COMMAND_GET_CODEC:
	case FTDM_COMMAND_SET_NATIVE_CODEC:
	case FTDM_COMMAND_GET_NATIVE_CODEC:
	case FTDM_COMMAND_ENABLE_DTMF_DETECT:
	case FTDM_COMMAND_DISABLE_DTMF_DETECT:
	case FTDM_COMMAND_SEND_DTMF:
	case FTDM_COMMAND_SET_DTMF_ON_PERIOD:
	case FTDM_COMMAND_GET_DTMF_ON_PERIOD:
	case FTDM_COMMAND_SET_DTMF_OFF_PERIOD:
	case FTDM_COMMAND_GET_DTMF_OFF_PERIOD:
	case FTDM_COMMAND_SET_RX_GAIN:	/* DSP_VOL_CHANGE_RX / HFC_VOL_CHANGE_RX */
	case FTDM_COMMAND_GET_RX_GAIN:
	case FTDM_COMMAND_SET_TX_GAIN:	/* DSP_VOL_CHANGE_TX / HFC_VOL_CHANGE_TX */
	case FTDM_COMMAND_GET_TX_GAIN:
	case FTDM_COMMAND_FLUSH_TX_BUFFERS:
	case FTDM_COMMAND_FLUSH_RX_BUFFERS:
	case FTDM_COMMAND_FLUSH_BUFFERS:
	case FTDM_COMMAND_FLUSH_IOSTATS:
	case FTDM_COMMAND_SET_PRE_BUFFER_SIZE:
	case FTDM_COMMAND_SET_LINK_STATUS:
	case FTDM_COMMAND_GET_LINK_STATUS:
	case FTDM_COMMAND_SET_RX_QUEUE_SIZE:
	case FTDM_COMMAND_SET_TX_QUEUE_SIZE:
	case FTDM_COMMAND_START_MF_PLAYBACK:
	case FTDM_COMMAND_STOP_MF_PLAYBACK:
	case FTDM_COMMAND_GET_IOSTATS:
	case FTDM_COMMAND_SWITCH_IOSTATS:
	/* Supported by mISDN */
	case FTDM_COMMAND_ENABLE_ECHOCANCEL:	/* DSP_ECHO_ON */
	case FTDM_COMMAND_DISABLE_ECHOCANCEL:	/* DSP_ECHO_OFF */
	case FTDM_COMMAND_ENABLE_LOOP:
	case FTDM_COMMAND_DISABLE_LOOP:
		ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Received unimplemented command: %d\n",
			command);
		break;

	case FTDM_COMMAND_GET_INTERVAL:
		FTDM_COMMAND_OBJ_INT = ftdm_channel_get_io_interval(ftdmchan);
		ftdm_log(FTDM_LOG_NOTICE, "Interval %d ms [%d:%d]\n",
			ftdm_channel_get_io_interval(ftdmchan), ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan));
		break;

	default:
		ftdm_log(FTDM_LOG_ERROR, "Unknown command %d\n", command);
	}
	return FTDM_SUCCESS;
}


/**
 * \brief	Wait for new data
 * \param	ftdmchan	FreeTDM channel to wait on
 * \param	flags	Wait flags
 * \param	to	Timeout
 */
static FIO_WAIT_FUNCTION(misdn_wait)
{
	struct misdn_chan_private *chan_priv = ftdm_chan_io_private(ftdmchan);
	struct pollfd pfds[2];
	int nr_fds = 0;
	int retval;

	memset(pfds, 0, sizeof(pfds));

	switch (ftdm_channel_get_type(ftdmchan)) {
	case FTDM_CHAN_TYPE_B:
		if (*flags & FTDM_WRITE) {
			pfds[nr_fds].fd = chan_priv->timerfd;
			pfds[nr_fds].events = POLLIN;
			nr_fds++;
		}
		if (*flags & (FTDM_READ | FTDM_EVENTS)) {
			pfds[nr_fds].fd = ftdmchan->sockfd;
			pfds[nr_fds].events |= (*flags & FTDM_READ)   ? POLLIN  : 0;
			pfds[nr_fds].events |= (*flags & FTDM_EVENTS) ? POLLPRI : 0;
			nr_fds++;
		}
		break;
	default:
		if (*flags & FTDM_READ)
			pfds[0].events |= POLLIN;
		if (*flags & FTDM_WRITE)
			pfds[0].events |= POLLOUT;
		if (*flags & FTDM_EVENTS)
			pfds[0].events |= POLLPRI;
		pfds[0].fd = ftdmchan->sockfd;
		nr_fds++;
		break;
	}

	*flags = FTDM_NO_FLAGS;

	if (!(pfds[0].events || pfds[1].events))
		return FTDM_SUCCESS;
	if ((retval = poll(pfds, nr_fds, to)) < 0) {
		ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "mISDN poll() failed: %s\n",
			strerror(errno));
		return FTDM_FAIL;
	}
	if (retval == 0)
		return FTDM_TIMEOUT;

	switch (ftdm_channel_get_type(ftdmchan)) {
	case FTDM_CHAN_TYPE_B:
		if (pfds[0].fd == chan_priv->timerfd) {
			if (pfds[0].revents & POLLIN) {
				uint64_t tmp = 0;	/* clear pending events on timerfd */
				retval = read(pfds[0].fd, &tmp, sizeof(tmp));
				*flags |= FTDM_WRITE;
			}
			if (pfds[1].revents & POLLIN)
				*flags |= FTDM_READ;
			if (pfds[1].revents & POLLPRI)
				*flags |= FTDM_EVENTS;
			break;
		}
	default:
		if (pfds[0].revents & POLLIN)
			*flags |= FTDM_READ;
		if (pfds[0].revents & POLLOUT)
			*flags |= FTDM_WRITE;
		if (pfds[0].revents & POLLPRI)
			*flags |= FTDM_EVENTS;
		break;
	}
	return FTDM_SUCCESS;
}

/**
 * \brief	Read data
 * \param	ftdmchan	FreeTDM channel
 * \param	data	Buffer for data
 * \param	datalen	Number of bytes to read (contains bytes read after return)
 */
static FIO_READ_FUNCTION(misdn_read)
{
	struct misdn_chan_private *priv = ftdm_chan_io_private(ftdmchan);
	char rbuf[MAX_DATA_MEM] = { 0 };
	struct mISDNhead *hh = (struct mISDNhead *)rbuf;
	int bytes = *datalen;
	int retval;

	if (priv->state == MISDN_CHAN_STATE_CLOSED) {
		/* ignore */
		*datalen = 0;
		return FTDM_SUCCESS;
	}

	/*
	 * try to read all messages, as long as we haven't received a PH_DATA_IND one
	 * we'll get a lot of "mISDN_send: error -12" message in dmesg otherwise
	 * (= b-channel receive queue overflowing)
	 */
	while (1) {
		if ((retval = recvfrom(ftdmchan->sockfd, rbuf, sizeof(rbuf), 0, NULL, NULL)) < 0) {
			if (errno == EWOULDBLOCK) break;
			if (errno == EAGAIN) continue;
			ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "mISDN failed to receive incoming message: %s\n",
				strerror(errno));
			return FTDM_FAIL;
		}

		if (retval < MISDN_HEADER_LEN) {
			ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "mISDN received message too small\n");
			return FTDM_FAIL;
		}

		if (hh->prim == PH_DATA_IND) {
			*datalen = MIN(bytes, retval - MISDN_HEADER_LEN);
			memcpy(data, rbuf + MISDN_HEADER_LEN, *datalen);
#ifdef MISDN_DEBUG_IO
			if (*datalen > 0) {
				char hbuf[MAX_DATA_MEM] = { 0 };
				print_hex_bytes(data, *datalen, hbuf, sizeof(hbuf));
				ftdm_log(FTDM_LOG_DEBUG, "mISDN read data: %s\n", hbuf);
			}
#endif
			return FTDM_SUCCESS;
		} else {
			*datalen = 0;
			/* event */
			misdn_handle_incoming(ftdmchan, rbuf, retval);
		}
	}
	return FTDM_SUCCESS;
}

/**
 * \brief	Write data
 * \param	ftdmchan	FreeTDM channel
 * \param	data	Buffer for data
 * \param	datalen	Number of bytes to write (contains bytes written after return)
 */
static FIO_WRITE_FUNCTION(misdn_write)
{
	struct misdn_chan_private *priv = ftdm_chan_io_private(ftdmchan);
	char wbuf[MAX_DATA_MEM];
	struct mISDNhead *hh = (struct mISDNhead *)wbuf;
	int size = *datalen;
	int retval = 0;

	assert(priv);

	/* ignore empty writes */
	if (*datalen <= 0)
		return FTDM_SUCCESS;

#ifdef MISDN_DEBUG_IO
	{
		char hbuf[MAX_DATA_MEM] = { 0 };
		print_hex_bytes(data, *datalen, hbuf, sizeof(hbuf));
		ftdm_log(FTDM_LOG_DEBUG, "mISDN write data: %s\n", hbuf);
	}
#endif
	hh->prim = PH_DATA_REQ;
	hh->id   = MISDN_ID_ANY;

	/* avoid buffer overflow */
	size = MIN(size, MAX_DATA_MEM);

	memcpy(wbuf + MISDN_HEADER_LEN, data, size);
	size += MISDN_HEADER_LEN;

#ifdef MISDN_DEBUG_IO
	ftdm_log(FTDM_LOG_DEBUG, "mISDN writing %d bytes to channel %d:%d socket %d\n",
		size, ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan), ftdmchan->sockfd);
#endif
	if ((retval = sendto(ftdmchan->sockfd, wbuf, size, 0, NULL, 0)) != size) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN channel %d:%d socket write error: %s\n",
			ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan),
			strerror(errno));
		return FTDM_FAIL;
	}
	*datalen = retval;

//	if (priv->debugfd >= 0) {
//		write(priv->debugfd, wbuf + MISDN_HEADER_LEN, size  - MISDN_HEADER_LEN);
//	}

	priv->tx_cnt++;
	return FTDM_SUCCESS;
}


static ftdm_status_t misdn_open_range(ftdm_span_t *span, ftdm_chan_type_t type, struct mISDN_devinfo *devinfo, int start, int end)
{
	int num_configured = 0;
	int d_protocol, d_channel;
	int x;

	ftdm_log(FTDM_LOG_DEBUG, "mISDN configuring card:range %d:%d->%d\n",
		devinfo->id, start, end);

	switch (ftdm_span_get_trunk_type(span)) {
	case FTDM_TRUNK_E1:
		d_protocol = ISDN_P_TE_E1;
		d_channel  = 16;
		break;
	case FTDM_TRUNK_BRI:
	case FTDM_TRUNK_BRI_PTMP:
		d_protocol = ISDN_P_TE_S0;
		d_channel  = 0;
		break;
	default:
		ftdm_log(FTDM_LOG_ERROR, "Unsupported span type %s\n",
			ftdm_span_get_trunk_type_str(span));
		return FTDM_FAIL;
	}

	for (x = start; x <= end; x++) {
		struct misdn_chan_private *priv;
		struct sockaddr_mISDN addr;
		ftdm_channel_t *ftdmchan = NULL;
		ftdm_socket_t sockfd = -1;

		ftdm_log(FTDM_LOG_DEBUG, "mISDN configuring card:channel => %d:%d\n",
			devinfo->id, x);

		memset(&addr, 0, sizeof(addr));
		addr.family = AF_ISDN;
		addr.dev    = devinfo->id;

		switch (type) {
		case FTDM_CHAN_TYPE_DQ931:	/* unsupported */
			ftdm_log(FTDM_LOG_ERROR, "Unsupported channel type '%s'\n",
				ftdm_chan_type2str(type));
			return FTDM_FAIL;

		case FTDM_CHAN_TYPE_DQ921:
			/* No NT-mode support, since we have no idea which mode we should run in at this point */
			sockfd = socket(PF_ISDN, SOCK_DGRAM, d_protocol);
			addr.channel = d_channel;	/* 0 for S0 and 16 for E1 */
			break;

		case FTDM_CHAN_TYPE_B:
			if (!test_channelmap(x, devinfo->channelmap)) {
				ftdm_log(FTDM_LOG_ERROR, "Invalid B-Channel specified: %d\n", x);
				return FTDM_FAIL;
			}
			sockfd = socket(PF_ISDN, SOCK_DGRAM, ISDN_P_B_RAW);
			addr.channel = x;
			break;

		default:
			ftdm_log(FTDM_LOG_ERROR, "Invalid/unsupported channel type '%s' (%d)\n",
				ftdm_chan_type2str(type), type);
			return FTDM_FAIL;
		}

		if (sockfd < 0) {
			ftdm_log(FTDM_LOG_ERROR, "Failed to open socket: %s\n", strerror(errno));
			return FTDM_FAIL;
		}

		ftdm_log(FTDM_LOG_DEBUG, "mISDN opened socket (on chan:dev => %d:%d): %d\n",
			addr.dev, addr.channel, sockfd);

		/* set non-blocking */
		if (fcntl(sockfd, F_SETFL, O_NONBLOCK) < 0) {
			ftdm_log(FTDM_LOG_ERROR, "mISDN Failed to set socket fd to non-blocking: %s\n", strerror(errno));
			return FTDM_FAIL;
		}

		/*
		 * Bind socket to card:channel
		 */
		if (bind(sockfd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
			ftdm_log(FTDM_LOG_ERROR, "Failed to bind mISDN socket [%d:%d]: %s\n",
				addr.dev, x, strerror(errno));
			close(sockfd);
			return FTDM_FAIL;
		}

		/*
		 * Add channel to span
		 */
		if (ftdm_span_add_channel(span, sockfd, type, &ftdmchan) != FTDM_SUCCESS) {
			ftdm_log(FTDM_LOG_ERROR, "Failed to add mISDN ftdmchan to span\n");
			close(sockfd);
			return FTDM_FAIL;
		}

		priv = calloc(1, sizeof(*priv));
		if (!priv) {
			ftdm_log(FTDM_LOG_ERROR, "mISDN failed to allocate channel private data\n");
			close(sockfd);
			return FTDM_FAIL;
		}
		ftdm_chan_io_private(ftdmchan) = priv;

		priv->addr    = addr;
		priv->debugfd = -1;
		priv->timerfd = -1;

		/*
		 * Create event queue
		 */
		misdn_event_queue_create(&priv->events);

		ftdmchan->rate = 8000;
		ftdmchan->physical_span_id = devinfo->id;
		ftdmchan->physical_chan_id = x;

		if (ftdmchan->type == FTDM_CHAN_TYPE_B) {
			ftdmchan->packet_len         = 10 /* ms */ * (ftdmchan->rate / 1000);
			ftdmchan->effective_interval = ftdmchan->native_interval = ftdmchan->packet_len / 8;
			ftdmchan->native_codec       = ftdmchan->effective_codec = FTDM_CODEC_ALAW;

			ftdm_channel_set_feature(ftdmchan, FTDM_CHANNEL_FEATURE_INTERVAL);
		} else {
			ftdmchan->native_codec = ftdmchan->effective_codec = FTDM_CODEC_NONE;
		}
		num_configured++;
	}

	return num_configured;
}

static int misdn_find_device(const char *name, int nr_devices, struct mISDN_devinfo *info)
{
	struct mISDN_devinfo devinfo;
	char *endp = NULL;
	int port_id = -1;
	int i;

	port_id = strtoul(name, &endp, 10);
	if (endp == name || errno == EINVAL)
		port_id = -1;
	if (port_id < 0 || port_id >= nr_devices)
		port_id = -1;

	for (i = 0; i < nr_devices; i++) {
		memset(&devinfo, 0, sizeof(devinfo));
		devinfo.id = i;

		if (ioctl(globals.sockfd, IMGETDEVINFO, &devinfo) < 0) {
			ftdm_log(FTDM_LOG_ERROR, "mISDN unable to get device %d info: %s\n",
				devinfo.id, strerror(errno));
			return FTDM_FAIL;
		}
		if (devinfo.id == port_id)
			break;
		if (strlen(devinfo.name) <= 0)
			continue;
		if (!strcasecmp(devinfo.name, name))
			break;
	}
	if (i == nr_devices)
		return FTDM_FAIL;

	if (info) *info = devinfo;
	return FTDM_SUCCESS;
}

#define MISDN_PH_TE_PROTOCOLS(x)	\
	((x) & ((1 << ISDN_P_TE_S0) | (1 << ISDN_P_TE_E1) | (1 << ISDN_P_TE_UP0)))
#define MISDN_PH_NT_PROTOCOLS(x)	\
	((x) & ((1 << ISDN_P_NT_S0) | (1 << ISDN_P_NT_E1) | (1 << ISDN_P_NT_UP0)))

/**
 * \brief	Configure/open span ftmod_misdn settings
 */
static FIO_CONFIGURE_SPAN_FUNCTION(misdn_configure_span)
{
	struct misdn_span_private *span_priv = ftdm_span_io_private(span);
	struct mISDN_devinfo devinfo;
	int range_start = 0, range_end = 0;
	int nr_ports = 0, nr_items = 0;
	int res = 0, i;
	char *chan_str, *ptr;
	char *data = strdup(str);
	char *item_list[10];

	/* only these are supported */
	switch (ftdm_span_get_trunk_type(span)) {
	case FTDM_TRUNK_E1:
	case FTDM_TRUNK_BRI:
	case FTDM_TRUNK_BRI_PTMP:
		break;
	default:
		ftdm_log(FTDM_LOG_ERROR, "Unsupported span type %s\n",
			ftdm_span_get_trunk_type_str(span));
		return FTDM_FAIL;
	}

	/* get port count */
	if (ioctl(globals.sockfd, IMGETCOUNT, &nr_ports) < 0) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN unable to get port count: %s\n",
			strerror(errno));
		goto error;
	}
	if (nr_ports <= 0) {
		ftdm_log(FTDM_LOG_ERROR, "No mISDN devices found\n");
		goto error;
	}

	/* split configuration string into port ID and channel list */
	if (!(chan_str = strchr(data, ':'))) {
		ftdm_log(FTDM_LOG_ERROR, "Invalid configuration string: %s\nExpected format <card_id>:<channel_1>[-<channel_N>]\n", str);
		goto error;
	}
	*chan_str++ = '\0';

	/* lookup port id, by number first, then by name */
	if (misdn_find_device(data, nr_ports, &devinfo) != FTDM_SUCCESS) {
		ftdm_log(FTDM_LOG_ERROR, "No such mISDN device/port: %s\n",
			data);
		goto error;
	}
	if (devinfo.nrbchan == 0 || devinfo.channelmap == 0) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN device '%s' has no b-channels\n",
			data);
		goto error;
	}
	if (!MISDN_PH_TE_PROTOCOLS(devinfo.Dprotocols)) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN device '%s' does not support any ISDN TE modes\n",
			data);
		goto error;
	}

	/* allocate span private */
	if (!span_priv) {
		/*
		 * Not perfect, there should be something like span_create too
		 */
		span_priv = calloc(1, sizeof(*span_priv));
		if (!span_priv) {
			ftdm_log(FTDM_LOG_ERROR, "mISDN failed to allocate span private data\n");
			return FTDM_FAIL;
		}
		ftdm_span_io_private(span) = span_priv;

		/* init event condition */
		pthread_cond_init(&span_priv->event_cond, NULL);
		pthread_mutex_init(&span_priv->event_cond_mutex, NULL);
	}

	/* split channel list by ',' */
	nr_items = ftdm_separate_string(chan_str, ',', item_list, ftdm_array_len(item_list));

	for (i = 0; i < nr_items; i++) {
		/* */
		if (!(ptr = strchr(item_list[i], '-'))) {
			/* single channel */
			range_start = atoi(item_list[i]);
			range_end   = range_start;
		} else {
			*ptr++ = '\0';
			/* channel range */
			range_start = atoi(item_list[i]);
			range_end   = atoi(ptr);
		}

		/* check if channel range/id is valid */
		if (range_start <= 0 || range_end <= 0 || range_end < range_start) {
			ftdm_log(FTDM_LOG_ERROR, "Invalid configuration string: %s\n",
				item_list[i]);
			goto error;
		}

		/* add range to span */
		res = misdn_open_range(span, type, &devinfo, range_start, range_end);
		if (res <= 0) {
			ftdm_log(FTDM_LOG_ERROR, "mISDN failed to configure channel(s)\n");
			goto error;
		}
	}

	ftdm_safe_free(data);
	return res;
error:
	ftdm_span_io_private(span) = NULL;
	ftdm_safe_free(span_priv);
	ftdm_safe_free(data);
	return res;
}

/**
 * \brief	Configure global ftmod_misdn settings
 */
static FIO_CONFIGURE_FUNCTION(misdn_configure)
{
	return FTDM_SUCCESS;
}

/**
 * \brief	Retrieve alarm event information (if any)
 * \param	ftdmchan	FreeTDM channel
 */
static FIO_GET_ALARMS_FUNCTION(misdn_get_alarms)
{
#if 0
/*
	Nope, this won't work...

	There's no way to create a separate "control" socket for a device
	that can be used to send / receive MPH_INFORMATION_REQ/_IND without
	having to care about PH_* messages in between...

	... well, unless we use our own event loop (= thread) and
	add event queues and data fifos, so we can sift all the
	messages we get to forward them to the right receiver
*/
	ftdm_span_t *span = ftdm_channel_get_span(ftdmchan);
	struct misdn_span_private *span_priv = ftdm_span_io_private(span);
	char buf[MAX_DATA_MEM] = { 0 };
	struct sockaddr_mISDN addr;
	struct mISDNhead *hh;
	struct ph_info *phi = NULL;
	struct pollfd pfd;
	socklen_t addrlen = sizeof(addr);
	int retval;

	/* use the global socket to query alarms */
	ftdm_log(FTDM_LOG_DEBUG, "mISDN getting alarms for channel %d:%d [%d:%d]\n",
		ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan),
		ftdm_channel_get_ph_span_id(ftdmchan), ftdm_channel_get_ph_id(ftdmchan));

	memset(&addr, 0, sizeof(addr));
	addr.family  = AF_ISDN;
	addr.dev     = ftdm_channel_get_ph_span_id(ftdmchan) - 1;
	addr.channel = ftdm_channel_get_ph_id(ftdmchan)      - 1;

	hh = (struct mISDNhead *)buf;
	hh->prim = MPH_INFORMATION_REQ;
	hh->id   = MISDN_ID_ANY;

	/* */
	if ((retval = sendto(span_priv->ctrlsock, hh, sizeof(*hh), 0, (struct sockaddr *)&addr, addrlen)) <= 0) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN failed to send '%s' to channel %d:%d: %s\n",
			misdn_event2str(hh->prim), ftdm_channel_get_span_id(ftdmchan),
			ftdm_channel_get_id(ftdmchan), strerror(errno));
		return FTDM_FAIL;
	}

	pfd.fd = span_priv->ctrlsock;
	pfd.events  = POLLIN /*| POLLPRI*/;
	pfd.revents = 0;

	if ((retval = poll(&pfd, 1, -1)) <= 0) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN failed to poll for '%s' answer on channel %d:%d: %s\n",
			misdn_event2str(hh->prim), ftdm_channel_get_span_id(ftdmchan),
			ftdm_channel_get_id(ftdmchan), strerror(errno));
		return FTDM_FAIL;
	}

	if (!(pfd.revents & (POLLIN | POLLPRI))) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN failed to poll for '%s' answer on channel %d:%d: %s\n",
			misdn_event2str(hh->prim), ftdm_channel_get_span_id(ftdmchan),
			ftdm_channel_get_id(ftdmchan), "No read/pri flag");
		return FTDM_FAIL;
	}

	if ((retval = recvfrom(span_priv->ctrlsock, buf, sizeof(buf), 0, (struct sockaddr *)&addr, &addrlen)) < 0) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN failed to receive answer for '%s' on channel %d:%d: %s\n",
			misdn_event2str(hh->prim), ftdm_channel_get_span_id(ftdmchan),
			ftdm_channel_get_id(ftdmchan), strerror(errno));
		return FTDM_FAIL;
	}
	if (retval < MISDN_HEADER_LEN) {
		ftdm_log(FTDM_LOG_ERROR, "mISDN short read on channel %d:%d\n",
			ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan));
		return FTDM_FAIL;
	}

	switch (hh->prim) {
	case MPH_INFORMATION_IND:
		ftdm_log(FTDM_LOG_DEBUG, "mISDN received '%s' on channel %d:%d, size %d bytes\n",
			misdn_event2str(hh->prim), ftdm_channel_get_span_id(ftdmchan),
			ftdm_channel_get_id(ftdmchan), retval);
		break;
	default:
		ftdm_log(FTDM_LOG_ERROR, "mISDN received unexpected answer '%s' on channel %d:%d: %s\n",
			misdn_event2str(hh->prim), ftdm_channel_get_span_id(ftdmchan),
			ftdm_channel_get_id(ftdmchan), strerror(errno));
		return FTDM_FAIL;
	}
#endif
	return FTDM_SUCCESS;
}


/**
 * \brief	Poll for new events
 * \param	span	FreeTDM span
 * \param	ms	Timeout (in ms)
 */
static FIO_SPAN_POLL_EVENT_FUNCTION(misdn_poll_event)
{
	struct misdn_span_private *span_priv = ftdm_span_io_private(span);
	struct timespec ts;
	int retval = 0, nr_events = 0;
	int i;

	clock_gettime(CLOCK_REALTIME, &ts);
	ts_add_msec(&ts, ms);

	for (i = 1; i <= ftdm_span_get_chan_count(span); i++) {
		ftdm_channel_t *chan = ftdm_span_get_channel(span, i);
		struct misdn_chan_private *chan_priv = ftdm_chan_io_private(chan);

		if (misdn_event_queue_has_data(chan_priv->events)) {
#ifdef MISDN_DEBUG_EVENTS
			ftdm_log(FTDM_LOG_DEBUG, "mISDN channel %d:%d has event(s)\n",
				ftdm_channel_get_span_id(chan), ftdm_channel_get_id(chan));
#endif
			ftdm_set_flag(chan, FTDM_CHANNEL_IO_EVENT);
			chan->last_event_time = ftdm_current_time_in_ms();
			nr_events++;
		}
	}
	if (nr_events)
		return FTDM_SUCCESS;

	if ((retval = pthread_cond_timedwait(&span_priv->event_cond, &span_priv->event_cond_mutex, &ts))) {
		switch (retval) {
		case ETIMEDOUT:
//			ftdm_log(FTDM_LOG_DEBUG, "mISDN span %d: No events within %d ms\n",
//				ftdm_span_get_id(span), ms);
			return FTDM_TIMEOUT;
		default:
			ftdm_log(FTDM_LOG_DEBUG, "mISDN failed to poll for events on span %d: %s\n",
				ftdm_span_get_id(span), strerror(retval));
			return FTDM_FAIL;
		}
	}

	for (i = 1; i <= ftdm_span_get_chan_count(span); i++) {
		ftdm_channel_t *chan = ftdm_span_get_channel(span, i);
		struct misdn_chan_private *chan_priv = ftdm_chan_io_private(chan);

		if (misdn_event_queue_has_data(chan_priv->events)) {
			ftdm_set_flag(chan, FTDM_CHANNEL_IO_EVENT);
			chan->last_event_time = ftdm_current_time_in_ms();
			nr_events++;
		}
	}
	return (nr_events) ? FTDM_SUCCESS : FTDM_TIMEOUT;	/* no events? => timeout */
}

/**
 * \brief	Retrieve event
 * \param	span	FreeTDM span
 * \param	event	FreeTDM event
 */
static FIO_SPAN_NEXT_EVENT_FUNCTION(misdn_next_event)
{
	int32_t event_id = FTDM_OOB_INVALID;
	int i;

	ftdm_log(FTDM_LOG_DEBUG, "Reading next event from span %d\n",
		ftdm_span_get_id(span));

	for (i = 1; i <= ftdm_span_get_chan_count(span); i++) {
		ftdm_channel_t *chan = ftdm_span_get_channel(span, i);
		struct misdn_chan_private *chan_priv = ftdm_chan_io_private(chan);
		struct misdn_event *evt = NULL;

		if (!(evt = misdn_event_queue_pop(chan_priv->events))) {
#ifdef MISDN_DEBUG_EVENTS
			ftdm_log_chan_msg(chan, FTDM_LOG_DEBUG, "mISDN channel event queue has no events\n");
#endif
                        ftdm_clear_io_flag(chan, FTDM_CHANNEL_IO_EVENT);
			continue;
		}

#ifdef MISDN_DEBUG_EVENTS
		ftdm_log_chan(chan, FTDM_LOG_DEBUG, "Got event '%s' from channel event queue\n",
			misdn_event2str(evt->id));
#endif
		switch (evt->id) {
		case PH_DEACTIVATE_IND:
			event_id = FTDM_OOB_ALARM_TRAP;
			chan->alarm_flags |= FTDM_ALARM_RED;
			break;
		case PH_ACTIVATE_IND:
			event_id = FTDM_OOB_ALARM_CLEAR;
			chan->alarm_flags &= ~FTDM_ALARM_RED;
			break;
		default:
			ftdm_log(FTDM_LOG_ERROR, "Unhandled event id %d (0x%x) %s\n",
				evt->id, evt->id, misdn_event2str(evt->id));
			continue;
		}

		chan->last_event_time = 0;
		span->event_header.e_type = FTDM_EVENT_OOB;
		span->event_header.enum_id = event_id;
		span->event_header.channel = chan;
		*event = &span->event_header;
		return FTDM_SUCCESS;
	}
	return FTDM_FAIL;
}

/**
 * \brief	Shutdown ftmod_misdn channel
 * \param	ftdmchan	FreeTDM channel
 */
static FIO_CHANNEL_DESTROY_FUNCTION(misdn_channel_destroy)
{
	struct misdn_chan_private *chan_priv = ftdm_chan_io_private(ftdmchan);
	assert(chan_priv);

	ftdm_log(FTDM_LOG_DEBUG, "Destroying channel %d:%d\n",
		ftdm_channel_get_span_id(ftdmchan),
		ftdm_channel_get_id(ftdmchan));

	if (ftdmchan->sockfd >= 0) {
		close(ftdmchan->sockfd);
		ftdmchan->sockfd = -1;
	}

	/*
	 * Destroy fifo + event queue
	 */
	if (chan_priv->events)
		misdn_event_queue_destroy(&chan_priv->events);

	ftdm_chan_io_private(ftdmchan) = NULL;
	ftdm_safe_free(chan_priv);

	ftdm_log(FTDM_LOG_DEBUG, "mISDN channel %d:%d destroyed\n",
		ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan));
	return FTDM_SUCCESS;
}

/**
 * \brief	Shutdown ftmod_misdn span
 * \param	span	FreeTDM span
 */
static FIO_SPAN_DESTROY_FUNCTION(misdn_span_destroy)
{
	struct misdn_span_private *span_priv = ftdm_span_io_private(span);

	ftdm_span_io_private(span) = NULL;
	ftdm_safe_free(span_priv);

	ftdm_log(FTDM_LOG_DEBUG, "mISDN span %d (%s) destroyed\n",
		ftdm_span_get_id(span), ftdm_span_get_name(span));
	return FTDM_SUCCESS;
}


static ftdm_status_t misdn_handle_incoming(ftdm_channel_t *ftdmchan, const char *rbuf, const int size)
{
	struct mISDNhead *hh = (struct mISDNhead *)rbuf;
	struct misdn_chan_private *priv = ftdm_chan_io_private(ftdmchan);
	const char *data = rbuf + sizeof(*hh);
	int data_len = size - sizeof(*hh);

	assert(priv);

#ifdef MISDN_DEBUG_EVENTS
	ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "mISDN channel received '%s' message (additional data: %d bytes)\n",
		misdn_event2str(hh->prim), data_len);
#endif

	switch (hh->prim) {
	/* data events */
	case PH_DATA_CNF:	/* TX ack */
		priv->tx_ack_cnt++;
		break;
	case PH_DATA_REQ:	/* request echo? */
		break;
	case PH_DATA_E_IND:	/* TX/RX ERR(?) */
		break;

	/* control events */
	case PH_ACTIVATE_REQ:
	case PH_DEACTIVATE_REQ:
		/*
		 * Echoed(?) L2->L1 requests, ignore...
		 * (something broken in mISDN or the way we setup the channel?)
		 */
		break;
	case PH_CONTROL_IND:
		return misdn_handle_ph_control_ind(ftdmchan, hh, data, data_len);
	case PH_CONTROL_REQ:
	case PH_CONTROL_CNF:
		break;

	case MPH_INFORMATION_IND:
		return misdn_handle_mph_information_ind(ftdmchan, hh, data, data_len);

	case PH_ACTIVATE_IND:
	case PH_DEACTIVATE_IND:
		{
			/* other events, enqueue and let misdn_event_next handle it */
			struct misdn_span_private *span_priv = ftdm_span_io_private(ftdmchan->span);
			struct misdn_event evt = { 0 };
			evt.id = hh->prim;

			misdn_event_queue_push(priv->events, &evt);

			/* wake possible readers */
			pthread_cond_signal(&span_priv->event_cond);
		}
		break;

	default:	/* error? */
		ftdm_log(FTDM_LOG_DEBUG, "mISDN channel %d:%d received unknown event %d\n",
			ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan), hh->prim);
		break;
	}
	return FTDM_SUCCESS;
}


/**
 * \brief	ftmod_misdn interface
 */
//static const ftdm_io_interface_t misdn_interface = {
static const ftdm_io_interface_t misdn_interface = {
	.name       = "misdn",

	.open       = misdn_open,
	.close      = misdn_close,
	.wait       = misdn_wait,
	.read       = misdn_read,
	.write      = misdn_write,

	.poll_event = misdn_poll_event,
	.next_event = misdn_next_event,

	.command         = misdn_command,
	.get_alarms      = misdn_get_alarms,
	.configure       = misdn_configure,		/* configure global parameters */
	.configure_span  = misdn_configure_span,	/* assign channels to span */
	.channel_destroy = misdn_channel_destroy,	/* clean up channel */
	.span_destroy    = misdn_span_destroy,		/* clean up span */
};


/**
 * \brief	ftmod_misdn module init function
 */
static FIO_IO_LOAD_FUNCTION(misdn_load)
{
	struct mISDNversion ver;
	struct mISDN_devinfo devinfo;
	int devcnt, usecnt;
	int i;

	/* */
	globals.sockfd = socket(PF_ISDN, SOCK_RAW, ISDN_P_BASE);
	if (globals.sockfd < 0) {
		ftdm_log(FTDM_LOG_CRIT, "Unable to create mISDN base socket (are you sure this kernel has mISDN support?)\n");
		return FTDM_FAIL;
	}

	if (ioctl(globals.sockfd, IMGETVERSION, &ver) < 0) {
		ftdm_log(FTDM_LOG_CRIT, "Unable to retrieve mISDN version\n");
		goto error;
	}

	ftdm_log(FTDM_LOG_INFO, "mISDN Interface version %hhd.%hhd.%hd\n", ver.major, ver.minor, ver.release);

	devcnt = 0;
	if (ioctl(globals.sockfd, IMGETCOUNT, &devcnt) < 0) {
		ftdm_log(FTDM_LOG_CRIT, "Unable to retrieve number of mISDN devices\n");
		goto error;

	}

	if (!devcnt) {
		ftdm_log(FTDM_LOG_CRIT, "No mISDN devices found\n");
		goto error;
	}
	usecnt = devcnt;

	ftdm_log(FTDM_LOG_INFO, "Found %d mISDN devices:\n", devcnt);

	/* Output most important device information */
	for (i = 0; i < devcnt; i++) {
		int caps = MISDN_CAPS_NONE;

		devinfo.id = i;
		if (ioctl(globals.sockfd, IMGETDEVINFO, &devinfo) < 0) {
			ftdm_log(FTDM_LOG_ERROR, "Failed to retrieve information for device %d\n", i);
			continue;
		}

		/* print */
		ftdm_log(FTDM_LOG_INFO, "<%d> Name: %s, B-Channels: %d\n",
					devinfo.id,
					ftdm_strlen_zero_buf(devinfo.name) ? "Unknown" : devinfo.name,
					devinfo.nrbchan);

		/* D-Channels capabilities */
		if (devinfo.Dprotocols & (1 << ISDN_P_TE_E1))
			caps |= MISDN_CAPS_TE | MISDN_CAPS_PRI;
		if (devinfo.Dprotocols & (1 << ISDN_P_NT_E1))
			caps |= MISDN_CAPS_NT | MISDN_CAPS_PRI;
		if (devinfo.Dprotocols & (1 << ISDN_P_TE_S0))
			caps |= MISDN_CAPS_TE | MISDN_CAPS_BRI;
		if (devinfo.Dprotocols & (1 << ISDN_P_NT_S0))
			caps |= MISDN_CAPS_NT | MISDN_CAPS_BRI;
#ifdef ISDN_P_TE_UP0
		if (devinfo.Dprotocols & (1 << ISDN_P_TE_UP0))
			caps |= MISDN_CAPS_TE | MISDN_CAPS_UP0 | MISDN_CAPS_BRI;
#endif
#ifdef ISDN_P_NT_UP0
		if (devinfo.Dprotocols & (1 << ISDN_P_NT_UP0))
			caps |= MISDN_CAPS_NT | MISDN_CAPS_UP0 | MISDN_CAPS_BRI;
#endif
		/* B-Channel capabilities */
		if (devinfo.Bprotocols & (1 << (ISDN_P_B_RAW & ISDN_P_B_MASK)))
			caps |= MISDN_CAPS_RAW;
		if (devinfo.Bprotocols & (1 << (ISDN_P_B_HDLC & ISDN_P_B_MASK)))
			caps |= MISDN_CAPS_HDLC;

		ftdm_log(FTDM_LOG_INFO, "    Type: %s, Modes: %s %s\n",
					MISDN_IS_PRI(caps) ? "PRI" : "BRI",
					MISDN_IS_NT(caps)  ? "NT" : "",
					MISDN_IS_TE(caps)  ? "TE" : "");

		ftdm_log(FTDM_LOG_INFO, "    B-Channel modes: %s %s\n",
					MISDN_IS_RAW(caps) ? "RAW" : "",
					MISDN_IS_HDLC(caps) ? "HDLC" : "");

		if (!(MISDN_IS_NT(caps) || MISDN_IS_TE(caps)) && !MISDN_IS_RAW(caps)) {
			ftdm_log(FTDM_LOG_ERROR, "   This device is unusable!\n");
			usecnt--;
		}
	}
	if (!usecnt) {
		ftdm_log(FTDM_LOG_CRIT, "No useable devices found!\n");
		goto error;
	}

	ftdm_log(FTDM_LOG_INFO, "Found %d useable mISDN devices\n", usecnt);

	/* assign interface struct */
	*fio = (ftdm_io_interface_t *)&misdn_interface;
	return FTDM_SUCCESS;
error:
	if (globals.sockfd >= 0)
		close(globals.sockfd);
	return FTDM_FAIL;
}

/**
 * \brief	ftmod_misdn module shutdown
 */
static FIO_IO_UNLOAD_FUNCTION(misdn_unload)
{
	if (globals.sockfd >= 0)
		close(globals.sockfd);
	return FTDM_SUCCESS;
}

/**
 * \brief	ftmod_misdn module
 */
ftdm_module_t ftdm_module = {
	.name      = "misdn",
	.io_load   = misdn_load,
	.io_unload = misdn_unload
};