--- /dev/null
+Index: src/ozmod/ozmod_ss7_boost/sigboost.h
+===================================================================
+--- src/ozmod/ozmod_ss7_boost/sigboost.h (revision 717)
++++ src/ozmod/ozmod_ss7_boost/sigboost.h (working copy)
+@@ -1,5 +1,5 @@
+ /****************************************************************************
+- * sigboost.h $Revision: 1.5 $
++ * sigboost.h $Revision: 1.13 $
+ *
+ * Definitions for the sigboost interface.
+ *
+@@ -14,6 +14,8 @@
+ #ifndef _SIGBOOST_H_
+ #define _SIGBOOST_H_
+
++#define SIGBOOST_VERSION 100
++
+ #include <stdint.h>
+ #include <sys/time.h>
+
+@@ -48,16 +50,24 @@
+
+ enum e_sigboost_call_setup_ack_nack_cause_values
+ {
+- SIGBOOST_CALL_SETUP_NACK_ALL_CKTS_BUSY = 117, /* unused Q.850 value */
+- SIGBOOST_CALL_SETUP_NACK_TEST_CKT_BUSY = 118, /* unused Q.850 value */
+- SIGBOOST_CALL_SETUP_NACK_INVALID_NUMBER = 28,
+- /* probable elimination */
+- //SIGBOOST_CALL_SETUP_RESERVED = 0x00,
+- //SIGBOOST_CALL_SETUP_CIRCUIT_RESET = 0x10,
+- //SIGBOOST_CALL_SETUP_NACK_CKT_START_TIMEOUT = 0x11,
+- //SIGBOOST_CALL_SETUP_NACK_AUTO_CALL_GAP = 0x17,
++ //SIGBOOST_CALL_SETUP_NACK_ALL_CKTS_BUSY = 34, /* Q.850 value - don't use */
++ SIGBOOST_CALL_SETUP_NACK_ALL_CKTS_BUSY = 117, /* non Q.850 value indicates local all ckt busy
++ causing sangoma_mgd to perform automatic call
++ gapping*/
++ SIGBOOST_CALL_SETUP_NACK_TEST_CKT_BUSY = 17, /* Q.850 value */
++ SIGBOOST_CALL_SETUP_NACK_INVALID_NUMBER = 28, /* Q.850 value */
++ SIGBOOST_CALL_SETUP_CSUPID_DBL_USE = 200, /* unused Q.850 value */
+ };
+
++
++enum e_sigboost_huntgroup_values
++{
++ SIGBOOST_HUNTGRP_SEQ_ASC = 0x00, /* sequential with lowest available first */
++ SIGBOOST_HUNTGRP_SEQ_DESC = 0x01, /* sequential with highest available first */
++ SIGBOOST_HUNTGRP_RR_ASC = 0x02, /* round-robin with lowest available first */
++ SIGBOOST_HUNTGRP_RR_DESC = 0x03, /* round-robin with highest available first */
++};
++
+ #define MAX_DIALED_DIGITS 31
+
+ /* Next two defines are used to create the range of values for call_setup_id
+@@ -67,63 +77,73 @@
+ #define CORE_MAX_CHAN_PER_SPAN 30
+ #define MAX_PENDING_CALLS CORE_MAX_SPANS * CORE_MAX_CHAN_PER_SPAN
+ /* 0..(MAX_PENDING_CALLS-1) is range of call_setup_id below */
+-#define SIZE_RDNIS 128
++#define SIZE_RDNIS 900
+
++
+ #pragma pack(1)
++
+ typedef struct
+ {
+- uint32_t event_id;
++ uint8_t capability;
++ uint8_t uil1p;
++}t_sigboost_bearer;
++
++typedef struct
++{
++ uint16_t version;
++ uint32_t event_id;
+ /* delete sequence numbers - SCTP does not need them */
+- uint32_t fseqno;
+- uint32_t bseqno;
+- uint16_t call_setup_id;
+- uint32_t trunk_group;
+- uint8_t span;
+- uint8_t chan;
+- struct timeval tv;
+- uint8_t called_number_digits_count;
+- char called_number_digits [MAX_DIALED_DIGITS + 1]; /* it's a null terminated string */
+- uint8_t calling_number_digits_count; /* it's an array */
+- char calling_number_digits [MAX_DIALED_DIGITS + 1]; /* it's a null terminated string */
++ uint32_t fseqno;
++ uint32_t bseqno;
++ uint16_t call_setup_id;
++ uint32_t trunk_group;
++ uint8_t span;
++ uint8_t chan;
++ struct timeval tv;
++ uint8_t called_number_digits_count;
++ char called_number_digits [MAX_DIALED_DIGITS + 1]; /* it's a null terminated string */
++ uint8_t calling_number_digits_count; /* it's an array */
++ char calling_number_digits [MAX_DIALED_DIGITS + 1]; /* it's a null terminated string */
+ /* ref. Q.931 Table 4-11 and Q.951 Section 3 */
+- uint8_t calling_number_screening_ind;
+- uint8_t calling_number_presentation;
+- char calling_name[MAX_DIALED_DIGITS + 1];
+- uint16_t redirection_string_size;
+- char redirection_string [SIZE_RDNIS]; /* it's a null terminated string */
+- /* redir string format:
+- * http://www.ss7box.com/wiki/tiki-index.php?page=Call+Redirection
+- * */
++ uint8_t calling_number_screening_ind;
++ uint8_t calling_number_presentation;
++ char calling_name[MAX_DIALED_DIGITS + 1];
++ t_sigboost_bearer bearer;
++ uint8_t hunt_group;
++ uint16_t isup_in_rdnis_size;
++ char isup_in_rdnis [SIZE_RDNIS]; /* it's a null terminated string */
+ } t_sigboost_callstart;
+
+-#define MIN_SIZE_CALLSTART_MSG (sizeof(t_sigboost_callstart) - SIZE_RDNIS)
++#define MIN_SIZE_CALLSTART_MSG sizeof(t_sigboost_callstart) - SIZE_RDNIS
+
+ typedef struct
+ {
+- uint32_t event_id;
++ uint16_t version;
++ uint32_t event_id;
+ /* delete sequence numbers - SCTP does not need them */
+- uint32_t fseqno;
+- uint32_t bseqno;
+- uint16_t call_setup_id;
+- uint32_t trunk_group;
+- uint8_t span;
+- uint8_t chan;
+- struct timeval tv;
+- uint8_t release_cause;
++ uint32_t fseqno;
++ uint32_t bseqno;
++ uint16_t call_setup_id;
++ uint32_t trunk_group;
++ uint8_t span;
++ uint8_t chan;
++ struct timeval tv;
++ uint8_t release_cause;
+ } t_sigboost_short;
+ #pragma pack()
+
+ static inline int boost_full_event(int event_id)
+ {
+- switch (event_id) {
+- case SIGBOOST_EVENT_CALL_START:
+- case SIGBOOST_EVENT_DIGIT_IN:
+- return 1;
+- default:
+- return 0;
+- }
++ switch (event_id) {
++ case SIGBOOST_EVENT_CALL_START:
++ case SIGBOOST_EVENT_DIGIT_IN:
++ return 1;
++ default:
++ return 0;
++ }
+
+- return 0;
++ return 0;
+ }
+
++
+ #endif
+Index: src/ozmod/ozmod_ss7_boost/ss7_boost_client.c
+===================================================================
+--- src/ozmod/ozmod_ss7_boost/ss7_boost_client.c (revision 717)
++++ src/ozmod/ozmod_ss7_boost/ss7_boost_client.c (working copy)
+@@ -73,7 +73,7 @@
+ {
+ if (event->event_id == SIGBOOST_EVENT_HEARTBEAT)
+ return;
+- zap_log(file, func, line, ZAP_LOG_LEVEL_DEBUG, "%s EVENT: %s:(%X) [w%dg%d] CSid=%i Seq=%i Cn=[%s] Cd=[%s] Ci=[%s]\n",
++ zap_log(file, func, line, ZAP_LOG_LEVEL_WARNING, "%s EVENT: %s:(%X) [w%dg%d] CSid=%i Seq=%i Cn=[%s] Cd=[%s] Ci=[%s]\n",
+ dir ? "TX":"RX",
+ ss7bc_event_id_name(event->event_id),
+ event->event_id,
+@@ -91,7 +91,7 @@
+ {
+ if (event->event_id == SIGBOOST_EVENT_HEARTBEAT)
+ return;
+- zap_log(file, func, line, ZAP_LOG_LEVEL_DEBUG, "%s EVENT (%s): %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i \n",
++ zap_log(file, func, line, ZAP_LOG_LEVEL_WARNING, "%s EVENT (%s): %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i \n",
+ dir ? "TX":"RX",
+ priority ? "P":"N",
+ ss7bc_event_id_name(event->event_id),
+@@ -261,6 +261,10 @@
+ bytes = recvfrom(mcon->socket, &mcon->event, sizeof(mcon->event), MSG_DONTWAIT,
+ (struct sockaddr *) &mcon->local_addr, &fromlen);
+
++ if (mcon->event.version != SIGBOOST_VERSION) {
++ zap_log(ZAP_LOG_CRIT, "Invalid Boost Version %i Expecting %i\n",mcon->event.version, SIGBOOST_VERSION);
++ }
++
+ /* Must check for < 0 cannot rely on bytes > MIN_SIZE_... compiler issue */
+ if (bytes < 0) {
+ msg_ok=0;
+@@ -293,7 +297,7 @@
+ ss7bc_print_event_short(mcon, (ss7bc_short_event_t*)&mcon->event, 0, 0, file, func, line);
+ }
+
+-#if 1
++#if 0
+ /* NC: NOT USED ANY MORE */
+ if (mcon->rxseq_reset) {
+ //if (mcon->event.event_id == SIGBOOST_EVENT_SYSTEM_RESTART_ACK) {
+@@ -310,15 +314,17 @@
+ mcon->txwindow = mcon->txseq - mcon->event.bseqno;
+ mcon->rxseq++;
+
++#if 0
+ if (mcon->rxseq != mcon->event.fseqno) {
+ zap_log(ZAP_LOG_CRIT, "Invalid Sequence Number Expect=%i Rx=%i\n", mcon->rxseq, mcon->event.fseqno);
+ return NULL;
+ }
++#endif
+
+ return &mcon->event;
+ } else {
+ if (iteration == 0) {
+- zap_log(ZAP_LOG_CRIT, "Invalid Event length from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event));
++ zap_log(ZAP_LOG_CRIT, "NC - Invalid Event length from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event));
+ return NULL;
+ }
+ }
+@@ -332,6 +338,10 @@
+ int bytes = 0;
+
+ bytes = recvfrom(mcon->socket, &mcon->event, sizeof(mcon->event), MSG_DONTWAIT, (struct sockaddr *) &mcon->local_addr, &fromlen);
++
++ if (mcon->event.version != SIGBOOST_VERSION) {
++ zap_log(ZAP_LOG_CRIT, "Invalid Boost Version %i Expecting %i\n",mcon->event.version, SIGBOOST_VERSION);
++ }
+
+ if (bytes == sizeof(ss7bc_short_event_t)) {
+
+@@ -356,7 +366,7 @@
+ int __ss7bc_connection_write(ss7bc_connection_t *mcon, ss7bc_event_t *event, const char *file, const char *func, int line)
+ {
+ int err;
+- int event_size=sizeof(ss7bc_event_t);
++ int event_size=MIN_SIZE_CALLSTART_MSG+event->isup_in_rdnis_size;
+
+ if (!event || mcon->socket < 0 || !mcon->mutex) {
+ zap_log(file, func, line, ZAP_LOG_LEVEL_CRIT, "Critical Error: No Event Device\n");
+@@ -395,6 +405,7 @@
+ event->fseqno = mcon->txseq++;
+ }
+ event->bseqno = mcon->rxseq;
++ event->version = SIGBOOST_VERSION;
+ err = sendto(mcon->socket, event, event_size, 0, (struct sockaddr *) &mcon->remote_addr, sizeof(mcon->remote_addr));
+
+ zap_mutex_unlock(mcon->mutex);
+@@ -432,6 +443,7 @@
+ gettimeofday(&event->tv, NULL);
+
+ zap_mutex_lock(mcon->mutex);
++ event->version = SIGBOOST_VERSION;
+ err = sendto(mcon->socket, event, event_size, 0, (struct sockaddr *) &mcon->remote_addr, sizeof(mcon->remote_addr));
+ zap_mutex_unlock(mcon->mutex);
+
+Index: src/ozmod/ozmod_ss7_boost/ozmod_ss7_boost.c
+===================================================================
+--- src/ozmod/ozmod_ss7_boost/ozmod_ss7_boost.c (revision 717)
++++ src/ozmod/ozmod_ss7_boost/ozmod_ss7_boost.c (working copy)
+@@ -215,7 +215,11 @@
+
+ ss7bc_call_init(&event, caller_data->cid_num.digits, caller_data->ani.digits, r);
+ zap_set_string(event.calling_name, caller_data->cid_name);
+- zap_set_string(event.redirection_string, caller_data->rdnis.digits);
++ zap_set_string(event.isup_in_rdnis, caller_data->rdnis.digits);
++ if (strlen(caller_data->rdnis.digits)) {
++ event.isup_in_rdnis_size = strlen(caller_data->rdnis.digits)+1;
++ }
++
+ event.calling_number_screening_ind = caller_data->screen;
+ event.calling_number_presentation = caller_data->pres;
+
+@@ -483,7 +487,7 @@
+ }
+ zap_set_string(zchan->caller_data.ani.digits, (char *)event->calling_number_digits);
+ zap_set_string(zchan->caller_data.dnis.digits, (char *)event->called_number_digits);
+- zap_set_string(zchan->caller_data.rdnis.digits, (char *)event->redirection_string);
++ zap_set_string(zchan->caller_data.rdnis.digits, (char *)event->isup_in_rdnis);
+ zchan->caller_data.screen = event->calling_number_screening_ind;
+ zchan->caller_data.pres = event->calling_number_presentation;
+ zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RING);
+@@ -851,7 +855,7 @@
+ zap_span_t *span = (zap_span_t *) obj;
+ zap_ss7_boost_data_t *ss7_boost_data = span->signal_data;
+ ss7bc_connection_t *mcon, *pcon;
+- uint32_t ms = 10, too_long = 20000;
++ uint32_t ms = 10; //, too_long = 20000;
+
+
+ ss7_boost_data->pcon = ss7_boost_data->mcon;
+@@ -942,6 +946,8 @@
+ pcon->hb_elapsed = 0;
+ }
+
++
++#if 0
+ if (pcon->hb_elapsed >= too_long) {
+ zap_log(ZAP_LOG_CRIT, "Lost Heartbeat!\n");
+ zap_set_flag_locked(span, ZAP_SPAN_SUSPENDED);
+@@ -953,6 +959,7 @@
+ SIGBOOST_EVENT_SYSTEM_RESTART,
+ 0);
+ }
++#endif
+
+ if (zap_running()) {
+ check_state(span);
+@@ -1094,7 +1101,7 @@
+ {
+ zap_ss7_boost_data_t *ss7_boost_data = NULL;
+ const char *local_ip = "127.0.0.65", *remote_ip = "127.0.0.66";
+- int local_port = 5300, remote_port = 5300;
++ int local_port = 53000, remote_port = 53000;
+ char *var, *val;
+ int *intval;
+
+Index: src/ozmod/ozmod_wanpipe/ozmod_wanpipe.c
+===================================================================
+--- src/ozmod/ozmod_wanpipe/ozmod_wanpipe.c (revision 717)
++++ src/ozmod/ozmod_wanpipe/ozmod_wanpipe.c (working copy)
+@@ -38,7 +38,7 @@
+ #include "openzap.h"
+ #include <poll.h>
+ #include <sys/socket.h>
+-#include "wanpipe_tdm_api_iface.h"
++#include "libsangoma.h"
+
+ typedef enum {
+ WP_RINGING = (1 << 0)
+@@ -57,196 +57,28 @@
+ ZIO_SPAN_POLL_EVENT_FUNCTION(wanpipe_poll_event);
+ ZIO_SPAN_NEXT_EVENT_FUNCTION(wanpipe_next_event);
+
+-#define WP_INVALID_SOCKET -1
+-/* on windows right now, there is no way to specify if we want to read events here or not, we allways get them here */
+-/* we need some what to select if we are reading regular tdm msgs or events */
+-/* need to either have 2 functions, 1 for events, 1 for regural read, or a flag on this function to choose */
+-/* 2 functions preferred. Need implementation for the event function for both nix and windows that is threadsafe */
+-static __inline__ int tdmv_api_readmsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, int datalen)
+-{
+- /* What do we need to do here to avoid having to do all */
+- /* the memcpy's on windows and still maintain api compat with nix */
+- uint32_t rx_len=0;
+-#if defined(__WINDOWS__)
+- static RX_DATA_STRUCT rx_data;
+- api_header_t *pri;
+- wp_tdm_api_rx_hdr_t *tdm_api_rx_hdr;
+- wp_tdm_api_rx_hdr_t *user_buf = (wp_tdm_api_rx_hdr_t*)hdrbuf;
+- DWORD ln;
++#define WP_INVALID_SOCKET -1
+
+- if (hdrlen != sizeof(wp_tdm_api_rx_hdr_t)){
+- return -1;
+- }
+-
+- if (!DeviceIoControl(
+- fd,
+- IoctlReadCommand,
+- (LPVOID)NULL,
+- 0L,
+- (LPVOID)&rx_data,
+- sizeof(RX_DATA_STRUCT),
+- (LPDWORD)(&ln),
+- (LPOVERLAPPED)NULL
+- )){
+- return -1;
+- }
+-
+- pri = &rx_data.api_header;
+- tdm_api_rx_hdr = (wp_tdm_api_rx_hdr_t*)rx_data.data;
+-
+- user_buf->wp_tdm_api_event_type = pri->operation_status;
+-
+- switch(pri->operation_status)
+- {
+- case SANG_STATUS_RX_DATA_AVAILABLE:
+- if (pri->data_length > datalen){
+- break;
+- }
+- memcpy(databuf, rx_data.data, pri->data_length);
+- rx_len = pri->data_length;
+- break;
+-
+- default:
+- break;
+- }
+-
+-#else
+- struct msghdr msg;
+- struct iovec iov[2];
+-
+- memset(&msg,0,sizeof(struct msghdr));
+-
+- iov[0].iov_len=hdrlen;
+- iov[0].iov_base=hdrbuf;
+-
+- iov[1].iov_len=datalen;
+- iov[1].iov_base=databuf;
+-
+- msg.msg_iovlen=2;
+- msg.msg_iov=iov;
+-
+- rx_len = read(fd,&msg,datalen+hdrlen);
+-
+- if (rx_len <= sizeof(wp_tdm_api_rx_hdr_t)){
+- return -EINVAL;
+- }
+-
+- rx_len-=sizeof(wp_tdm_api_rx_hdr_t);
+-#endif
+- return rx_len;
+-}
+-
+-static __inline__ int tdmv_api_writemsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, unsigned short datalen)
+-{
+- /* What do we need to do here to avoid having to do all */
+- /* the memcpy's on windows and still maintain api compat with nix */
+- int bsent = 0;
+-#if defined(__WINDOWS__)
+- static TX_DATA_STRUCT local_tx_data;
+- api_header_t *pri;
+- DWORD ln;
+-
+- /* Are these really not needed or used??? What about for nix?? */
+- (void)hdrbuf;
+- (void)hdrlen;
+-
+- pri = &local_tx_data.api_header;
+-
+- pri->data_length = datalen;
+- memcpy(local_tx_data.data, databuf, pri->data_length);
+-
+- if (!DeviceIoControl(
+- fd,
+- IoctlWriteCommand,
+- (LPVOID)&local_tx_data,
+- (ULONG)sizeof(TX_DATA_STRUCT),
+- (LPVOID)&local_tx_data,
+- sizeof(TX_DATA_STRUCT),
+- (LPDWORD)(&ln),
+- (LPOVERLAPPED)NULL
+- )){
+- return -1;
+- }
+-
+- if (local_tx_data.api_header.operation_status == SANG_STATUS_SUCCESS) {
+- bsent = datalen;
+- }
+-#else
+- struct msghdr msg;
+- struct iovec iov[2];
+-
+- memset(&msg,0,sizeof(struct msghdr));
+-
+- iov[0].iov_len = hdrlen;
+- iov[0].iov_base = hdrbuf;
+-
+- iov[1].iov_len = datalen;
+- iov[1].iov_base = databuf;
+-
+- msg.msg_iovlen = 2;
+- msg.msg_iov = iov;
+-
+- bsent = write(fd, &msg, datalen + hdrlen);
+- if (bsent > 0){
+- bsent -= sizeof(wp_tdm_api_tx_hdr_t);
+- }
+-#endif
+- return bsent;
+-}
+-
+ /* a cross platform way to poll on an actual pollset (span and/or list of spans) will probably also be needed for analog */
+ /* so we can have one analong handler thread that will deal with all the idle analog channels for events */
+ /* the alternative would be for the driver to provide one socket for all of the oob events for all analog channels */
+ static __inline__ int tdmv_api_wait_socket(sng_fd_t fd, int timeout, int *flags)
+ {
+-#if defined(__WINDOWS__)
+- DWORD ln;
+- API_POLL_STRUCT api_poll;
+-
+- memset(&api_poll, 0x00, sizeof(API_POLL_STRUCT));
+
+- api_poll.user_flags_bitmap = *flags;
+- api_poll.timeout = timeout;
++#ifdef LIBSANGOMA_VERSION
++ int err;
++ sangoma_wait_obj_t sangoma_wait_obj;
+
+- if (!DeviceIoControl(
+- fd,
+- IoctlApiPoll,
+- (LPVOID)NULL,
+- 0L,
+- (LPVOID)&api_poll,
+- sizeof(API_POLL_STRUCT),
+- (LPDWORD)(&ln),
+- (LPOVERLAPPED)NULL)) {
+- return -1;
+- }
++ sangoma_init_wait_obj(&sangoma_wait_obj, fd, 1, 1, *flags, SANGOMA_WAIT_OBJ);
+
+- *flags = 0;
+-
+- switch(api_poll.operation_status)
+- {
+- case SANG_STATUS_RX_DATA_AVAILABLE:
+- break;
+-
+- case SANG_STATUS_RX_DATA_TIMEOUT:
+- return 0;
+-
+- default:
+- return -1;
+- }
+-
+- if (api_poll.poll_events_bitmap == 0){
+- return -1;
++ err=sangoma_socket_waitfor_many(&sangoma_wait_obj,1 , timeout);
++ if (err > 0) {
++ *flags=sangoma_wait_obj.flags_out;
+ }
++ return err;
+
+- if (api_poll.poll_events_bitmap & POLL_EVENT_TIMEOUT) {
+- return 0;
+- }
+-
+- *flags = api_poll.poll_events_bitmap;
+-
+- return 1;
+ #else
+- struct pollfd pfds[1];
++ struct pollfd pfds[1];
+ int res;
+
+ memset(&pfds[0], 0, sizeof(pfds[0]));
+@@ -265,87 +97,18 @@
+
+ return res;
+ #endif
++
+ }
+
+-#define FNAME_LEN 128
+ static __inline__ sng_fd_t tdmv_api_open_span_chan(int span, int chan)
+ {
+- char fname[FNAME_LEN];
+- sng_fd_t fd = WP_INVALID_SOCKET;
+-#if defined(__WINDOWS__)
+- DWORD ln;
+- wan_udp_hdr_t wan_udp;
+-
+- /* NOTE: under Windows Interfaces are zero based but 'chan' is 1 based. */
+- /* Subtract 1 from 'chan'. */
+- _snprintf(fname , FNAME_LEN, "\\\\.\\WANPIPE%d_IF%d", span, chan - 1);
+-
+- fd = CreateFile( fname,
+- GENERIC_READ | GENERIC_WRITE,
+- FILE_SHARE_READ | FILE_SHARE_WRITE,
+- (LPSECURITY_ATTRIBUTES)NULL,
+- OPEN_EXISTING,
+- FILE_FLAG_NO_BUFFERING | FILE_FLAG_WRITE_THROUGH,
+- (HANDLE)NULL
+- );
+-
+- /* make sure that we are the only ones who have this chan open */
+- /* is this a threadsafe way to make sure that we are ok and will */
+- /* never return a valid handle to more than one thread for the same channel? */
+-
+- wan_udp.wan_udphdr_command = GET_OPEN_HANDLES_COUNTER;
+- wan_udp.wan_udphdr_data_len = 0;
+-
+- DeviceIoControl(
+- fd,
+- IoctlManagementCommand,
+- (LPVOID)&wan_udp,
+- sizeof(wan_udp_hdr_t),
+- (LPVOID)&wan_udp,
+- sizeof(wan_udp_hdr_t),
+- (LPDWORD)(&ln),
+- (LPOVERLAPPED)NULL
+- );
+-
+- if ((wan_udp.wan_udphdr_return_code) || (*(int*)&wan_udp.wan_udphdr_data[0] != 1)){
+- /* somone already has this channel, or somthing else is not right. */
+- tdmv_api_close_socket(&fd);
+- }
+-
+-#else
+- /* Does this fail if another thread already has this chan open? */
+- /* if not, we need to add some code to make sure it does */
+- snprintf(fname, FNAME_LEN, "/dev/wptdm_s%dc%d",span,chan);
+-
+- fd = open(fname, O_RDWR);
+-
+- if (fd < 0) {
+- fd = WP_INVALID_SOCKET;
+- }
+-
+-#endif
+- return fd;
++ return sangoma_open_tdmapi_span_chan(span, chan);
+ }
+
+
+
+ static zap_io_interface_t wanpipe_interface;
+
+-static zap_status_t wp_tdm_cmd_exec(zap_channel_t *zchan, wanpipe_tdm_api_t *tdm_api)
+-{
+- int err;
+-
+- /* I'm told the 2nd arg is ignored but i send it as the cmd anyway for good measure */
+- err = ioctl(zchan->sockfd, tdm_api->wp_tdm_cmd.cmd, &tdm_api->wp_tdm_cmd);
+-
+- if (err) {
+- snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno));
+- return ZAP_FAIL;
+- }
+-
+- return ZAP_SUCCESS;
+-}
+-
+ static unsigned char wanpipe_swap_bits(unsigned char cas_bits)
+ {
+ unsigned char swapped_bits = 0x0;
+@@ -379,43 +142,17 @@
+
+ if (sockfd != WP_INVALID_SOCKET && zap_span_add_channel(span, sockfd, type, &chan) == ZAP_SUCCESS) {
+ wanpipe_tdm_api_t tdm_api;
++ memset(&tdm_api,0,sizeof(tdm_api));
+ zap_log(ZAP_LOG_INFO, "configuring device s%dc%d as OpenZAP device %d:%d fd:%d\n", spanno, x, chan->span_id, chan->chan_id, sockfd);
+ chan->physical_span_id = spanno;
+ chan->physical_chan_id = x;
+ chan->rate = 8000;
+
+- if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO) {
+-
+-
+-#if 1
+- if (type == ZAP_CHAN_TYPE_FXO) {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_ONHOOK;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- wp_tdm_cmd_exec(chan, &tdm_api);
+- }
+-#endif
+-
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_RING_DETECT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- wp_tdm_cmd_exec(chan, &tdm_api);
+-#if 1
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_RING_TRIP_DETECT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- wp_tdm_cmd_exec(chan, &tdm_api);
+-#endif
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_RXHOOK;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- wp_tdm_cmd_exec(chan, &tdm_api);
+-
+- }
+-
+ if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO || type == ZAP_CHAN_TYPE_B) {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_HW_CODING;
+- wp_tdm_cmd_exec(chan, &tdm_api);
++ int err;
++
++ /* FIXME: Handle Error Conditino Check for return code */
++ err= sangoma_tdm_get_hw_coding(chan->sockfd, &tdm_api);
+ if (tdm_api.wp_tdm_cmd.hw_tdm_coding) {
+ chan->native_codec = chan->effective_codec = ZAP_CODEC_ALAW;
+ } else {
+@@ -423,10 +160,24 @@
+ }
+ }
+
++#if 0
++ if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO) {
++ /* Enable FLASH/Wink Events */
++ int err=sangoma_set_rm_rxflashtime(chan->sockfd, &tdm_api, wp_globals.flash_ms);
++ if (err == 0) {
++ zap_log(ZAP_LOG_ERROR, "flash enabled s%dc%d\n", spanno, x);
++ } else {
++ zap_log(ZAP_LOG_ERROR, "flash disabled s%dc%d\n", spanno, x);
++ }
++ }
++#endif
++
+ if (type == ZAP_CHAN_TYPE_CAS) {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_WRITE_RBS_BITS;
+- tdm_api.wp_tdm_cmd.rbs_tx_bits = wanpipe_swap_bits(cas_bits);
+- wp_tdm_cmd_exec(chan, &tdm_api);
++#ifdef LIBSANGOMA_VERSION
++ sangoma_tdm_write_rbs(chan->sockfd,&tdm_api,chan->physical_chan_id,wanpipe_swap_bits(cas_bits));
++#else
++ sangoma_tdm_write_rbs(chan->sockfd,&tdm_api,wanpipe_swap_bits(cas_bits));
++#endif
+ }
+
+ if (!zap_strlen_zero(name)) {
+@@ -550,18 +301,31 @@
+ static ZIO_OPEN_FUNCTION(wanpipe_open)
+ {
+
++ int err;
+ wanpipe_tdm_api_t tdm_api;
+
++ memset(&tdm_api,0,sizeof(tdm_api));
++
+ if (zchan->type == ZAP_CHAN_TYPE_DQ921 || zchan->type == ZAP_CHAN_TYPE_DQ931) {
+ zchan->native_codec = zchan->effective_codec = ZAP_CODEC_NONE;
+ } else {
+ zchan->effective_codec = zchan->native_codec;
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_CODEC;
+- tdm_api.wp_tdm_cmd.tdm_codec = 0;
+- wp_tdm_cmd_exec(zchan, &tdm_api);
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_USR_PERIOD;
+- tdm_api.wp_tdm_cmd.usr_period = wp_globals.codec_ms;
+- wp_tdm_cmd_exec(zchan, &tdm_api);
++
++ sangoma_tdm_set_usr_period(zchan->sockfd, &tdm_api, wp_globals.codec_ms);
++
++ err=sangoma_tdm_get_hw_dtmf(zchan->sockfd, &tdm_api);
++ if (err > 0) {
++ err=sangoma_tdm_enable_dtmf_events(zchan->sockfd, &tdm_api);
++ if (err == 0) {
++ //zap_log(ZAP_LOG_DEBUG, "Enabling HW DTMF FEATURE\n");
++ zap_channel_set_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_DETECT);
++ } else {
++ //zap_log(ZAP_LOG_DEBUG, "NO HW DTMF FEATURE\n");
++ }
++ } else {
++ //zap_log(ZAP_LOG_DEBUG, "NO HW DTMF FEATURE\n");
++ }
++
+ zap_channel_set_feature(zchan, ZAP_CHANNEL_FEATURE_INTERVAL);
+ zchan->effective_interval = zchan->native_interval = wp_globals.codec_ms;
+ zchan->packet_len = zchan->native_interval * 8;
+@@ -585,10 +349,8 @@
+ switch(command) {
+ case ZAP_COMMAND_OFFHOOK:
+ {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_OFFHOOK;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- if ((err = wp_tdm_cmd_exec(zchan, &tdm_api))) {
++ err=sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api);
++ if (err) {
+ snprintf(zchan->last_error, sizeof(zchan->last_error), "OFFHOOK Failed");
+ return ZAP_FAIL;
+ }
+@@ -597,10 +359,8 @@
+ break;
+ case ZAP_COMMAND_ONHOOK:
+ {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_ONHOOK;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- if ((err = wp_tdm_cmd_exec(zchan, &tdm_api))) {
++ err=sangoma_tdm_txsig_onhook(zchan->sockfd,&tdm_api);
++ if (err) {
+ snprintf(zchan->last_error, sizeof(zchan->last_error), "ONHOOK Failed");
+ return ZAP_FAIL;
+ }
+@@ -609,9 +369,8 @@
+ break;
+ case ZAP_COMMAND_GENERATE_RING_ON:
+ {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_START;
+- if ((err = wp_tdm_cmd_exec(zchan, &tdm_api))) {
++ err=sangoma_tdm_txsig_start(zchan->sockfd,&tdm_api);
++ if (err) {
+ snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring Failed");
+ return ZAP_FAIL;
+ }
+@@ -622,9 +381,8 @@
+ break;
+ case ZAP_COMMAND_GENERATE_RING_OFF:
+ {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_OFFHOOK;
+- if ((err = wp_tdm_cmd_exec(zchan, &tdm_api))) {
++ err=sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api);
++ if (err) {
+ snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring-off Failed");
+ return ZAP_FAIL;
+ }
+@@ -634,27 +392,26 @@
+ break;
+ case ZAP_COMMAND_GET_INTERVAL:
+ {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_USR_PERIOD;
+-
+- if (!(err = wp_tdm_cmd_exec(zchan, &tdm_api))) {
+- ZAP_COMMAND_OBJ_INT = tdm_api.wp_tdm_cmd.usr_period;
++ err=sangoma_tdm_get_usr_period(zchan->sockfd, &tdm_api);
++ if (err > 0 ) {
++ ZAP_COMMAND_OBJ_INT = err;
++ err=0;
+ }
+-
+ }
+ break;
+ case ZAP_COMMAND_SET_INTERVAL:
+ {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_USR_PERIOD;
+- tdm_api.wp_tdm_cmd.usr_period = ZAP_COMMAND_OBJ_INT;
+- err = wp_tdm_cmd_exec(zchan, &tdm_api);
++ err=sangoma_tdm_set_usr_period(zchan->sockfd, &tdm_api, ZAP_COMMAND_OBJ_INT);
+ zchan->packet_len = zchan->native_interval * (zchan->effective_codec == ZAP_CODEC_SLIN ? 16 : 8);
+ }
+ break;
+ case ZAP_COMMAND_SET_CAS_BITS:
+ {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_WRITE_RBS_BITS;
+- tdm_api.wp_tdm_cmd.rbs_tx_bits = wanpipe_swap_bits(ZAP_COMMAND_OBJ_INT);
+- err = wp_tdm_cmd_exec(zchan, &tdm_api);
++#ifdef LIBSANGOMA_VERSION
++ err=sangoma_tdm_write_rbs(zchan->sockfd,&tdm_api,zchan->physical_chan_id,wanpipe_swap_bits(ZAP_COMMAND_OBJ_INT));
++#else
++ err=sangoma_tdm_write_rbs(zchan->sockfd,&tdm_api,wanpipe_swap_bits(ZAP_COMMAND_OBJ_INT));
++#endif
+ }
+ break;
+ case ZAP_COMMAND_GET_CAS_BITS:
+@@ -683,7 +440,7 @@
+
+ memset(&hdrframe, 0, sizeof(hdrframe));
+
+- rx_len = tdmv_api_readmsg_tdm(zchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (int)*datalen);
++ rx_len = sangoma_readmsg_tdm(zchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (int)*datalen,0);
+
+ *datalen = rx_len;
+
+@@ -702,7 +459,7 @@
+
+ /* Do we even need the headerframe here? on windows, we don't even pass it to the driver */
+ memset(&hdrframe, 0, sizeof(hdrframe));
+- bsent = tdmv_api_writemsg_tdm(zchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (unsigned short)(*datalen));
++ bsent = sangoma_writemsg_tdm(zchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (unsigned short)(*datalen),0);
+
+ /* should we be checking if bsent == *datalen here? */
+ if (bsent > 0) {
+@@ -759,19 +516,29 @@
+ return ZAP_SUCCESS;
+ }
+
+-#ifndef WIN32
+ ZIO_SPAN_POLL_EVENT_FUNCTION(wanpipe_poll_event)
+ {
++#ifdef LIBSANGOMA_VERSION
++ sangoma_wait_obj_t pfds[ZAP_MAX_CHANNELS_SPAN];
++#else
+ struct pollfd pfds[ZAP_MAX_CHANNELS_SPAN];
++#endif
++
+ uint32_t i, j = 0, k = 0, l = 0;
++ int objects=0;
+ int r;
+
+ for(i = 1; i <= span->chan_count; i++) {
+ zap_channel_t *zchan = span->channels[i];
++
++#ifdef LIBSANGOMA_VERSION
++ sangoma_init_wait_obj(&pfds[j], zchan->sockfd , 1, 1, POLLPRI, SANGOMA_WAIT_OBJ);
++#else
+ memset(&pfds[j], 0, sizeof(pfds[j]));
+ pfds[j].fd = span->channels[i]->sockfd;
+ pfds[j].events = POLLPRI;
+-
++#endif
++ objects++;
+ /* The driver probably should be able to do this wink/flash/ringing by itself this is sort of a hack to make it work! */
+
+ if (zap_test_flag(zchan, ZAP_CHANNEL_WINK) || zap_test_flag(zchan, ZAP_CHANNEL_FLASH)) {
+@@ -789,20 +556,16 @@
+ int err;
+ memset(&tdm_api, 0, sizeof(tdm_api));
+ if (zap_test_pflag(zchan, WP_RINGING)) {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_OFFHOOK;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_DISABLE;
+- if ((err = wp_tdm_cmd_exec(zchan, &tdm_api))) {
++ err=sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api);
++ if (err) {
+ snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring-off Failed");
+ return ZAP_FAIL;
+ }
+ zap_clear_pflag_locked(zchan, WP_RINGING);
+ zchan->ring_time = zap_current_time_in_ms() + wp_globals.ring_off_ms;
+ } else {
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_START;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- if ((err = wp_tdm_cmd_exec(zchan, &tdm_api))) {
++ err=sangoma_tdm_txsig_start(zchan->sockfd,&tdm_api);
++ if (err) {
+ snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring Failed");
+ return ZAP_FAIL;
+ }
+@@ -815,9 +578,12 @@
+ if (l) {
+ ms = l;
+ }
++#ifdef LIBSANGOMA_VERSION
++ r = sangoma_socket_waitfor_many(pfds,objects,ms);
++#else
++ r = poll(pfds, j, ms);
++#endif
+
+- r = poll(pfds, j, ms);
+-
+ if (r == 0) {
+ return l ? ZAP_SUCCESS : ZAP_TIMEOUT;
+ } else if (r < 0) {
+@@ -828,7 +594,11 @@
+ for(i = 1; i <= span->chan_count; i++) {
+ zap_channel_t *zchan = span->channels[i];
+
++#ifdef LIBSANGOMA_VERSION
++ if (pfds[i-1].flags_out & POLLPRI) {
++#else
+ if (pfds[i-1].revents & POLLPRI) {
++#endif
+ zap_set_flag(zchan, ZAP_CHANNEL_EVENT);
+ zchan->last_event_time = zap_current_time_in_ms();
+ k++;
+@@ -836,15 +606,43 @@
+ }
+
+
+-
+ return k ? ZAP_SUCCESS : ZAP_FAIL;
+ }
+
++
++static ZIO_GET_ALARMS_FUNCTION(wanpipe_get_alarms)
++{
++ wanpipe_tdm_api_t tdm_api;
++ unsigned int alarms = 0;
++ int err;
++
++ memset(&tdm_api,0,sizeof(tdm_api));
++
++#ifdef LIBSANGOMA_VERSION
++ if ((err = sangoma_tdm_get_fe_alarms(zchan->sockfd, &tdm_api, &alarms))) {
++ snprintf(zchan->last_error, sizeof(zchan->last_error), "ioctl failed (%s)", strerror(errno));
++ snprintf(zchan->span->last_error, sizeof(zchan->span->last_error), "ioctl failed (%s)", strerror(errno));
++ return ZAP_FAIL;
++ }
++#else
++ if ((err = sangoma_tdm_get_fe_alarms(zchan->sockfd, &tdm_api)) < 0){
++ snprintf(zchan->last_error, sizeof(zchan->last_error), "ioctl failed (%s)", strerror(errno));
++ snprintf(zchan->span->last_error, sizeof(zchan->span->last_error), "ioctl failed (%s)", strerror(errno));
++ return ZAP_FAIL;
++ }
++ alarms = tdm_api.wp_tdm_cmd.fe_alarms;
+ #endif
+
++
++ zchan->alarm_flags = alarms ? ZAP_ALARM_RED : ZAP_ALARM_NONE;
++
++ return ZAP_SUCCESS;
++}
++
++
+ ZIO_SPAN_NEXT_EVENT_FUNCTION(wanpipe_next_event)
+ {
+- uint32_t i;
++ uint32_t i,err;
+ zap_oob_event_t event_id;
+
+ for(i = 1; i <= span->chan_count; i++) {
+@@ -869,29 +667,43 @@
+ event_id = ZAP_OOB_ONHOOK;
+
+ if (span->channels[i]->type == ZAP_CHAN_TYPE_FXO) {
++ zap_channel_t *zchan = span->channels[i];
+ wanpipe_tdm_api_t tdm_api;
+ memset(&tdm_api, 0, sizeof(tdm_api));
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_ONHOOK;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- wp_tdm_cmd_exec(span->channels[i], &tdm_api);
++
++ sangoma_tdm_txsig_onhook(zchan->sockfd,&tdm_api);
+ }
+ goto event;
+ }
+ }
+- }
++ }
+ if (zap_test_flag(span->channels[i], ZAP_CHANNEL_EVENT)) {
+ wanpipe_tdm_api_t tdm_api;
++ zap_channel_t *zchan = span->channels[i];
+ memset(&tdm_api, 0, sizeof(tdm_api));
+ zap_clear_flag(span->channels[i], ZAP_CHANNEL_EVENT);
+
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_READ_EVENT;
+- if (wp_tdm_cmd_exec(span->channels[i], &tdm_api) != ZAP_SUCCESS) {
++ err=sangoma_tdm_read_event(zchan->sockfd,&tdm_api);
++ if (err != ZAP_SUCCESS) {
+ snprintf(span->last_error, sizeof(span->last_error), "%s", strerror(errno));
+ return ZAP_FAIL;
+ }
+
+ switch(tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type) {
++
++ case WP_TDMAPI_EVENT_LINK_STATUS:
++ {
++ switch(tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_link_status) {
++ case WP_TDMAPI_EVENT_LINK_STATUS_CONNECTED:
++ event_id = ZAP_OOB_ALARM_CLEAR;
++ break;
++ default:
++ event_id = ZAP_OOB_ALARM_TRAP;
++ break;
++ };
++ }
++ break;
++
+ case WP_TDMAPI_EVENT_RXHOOK:
+ {
+ if (span->channels[i]->type == ZAP_CHAN_TYPE_FXS) {
+@@ -918,11 +730,9 @@
+ continue;
+ } else {
+ int err;
+-
+- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_EVENT;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_TXSIG_ONHOOK;
+- tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
+- if ((err = wp_tdm_cmd_exec(span->channels[i], &tdm_api))) {
++ zap_channel_t *zchan = span->channels[i];
++ err=sangoma_tdm_txsig_onhook(zchan->sockfd,&tdm_api);
++ if (err) {
+ snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "ONHOOK Failed");
+ return ZAP_FAIL;
+ }
+@@ -948,6 +758,17 @@
+ span->channels[i]->cas_bits = wanpipe_swap_bits(tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_rbs_bits);
+ }
+ break;
++ case WP_TDMAPI_EVENT_DTMF:
++ {
++ char tmp_dtmf[2] = { tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_dtmf_digit, 0 };
++ event_id = ZAP_OOB_NOOP;
++
++ //zap_log(ZAP_LOG_DEBUG, "%d:%d queue hardware dtmf %s\n", zchan->span_id, zchan->chan_id, tmp_dtmf);
++ if (tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_dtmf_type == WAN_EC_TONE_STOP) {
++ zap_channel_queue_dtmf(zchan, tmp_dtmf);
++ }
++ }
++ break;
+ default:
+ {
+ zap_log(ZAP_LOG_WARNING, "Unhandled event %d\n", tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type);
+@@ -1005,6 +826,7 @@
+ #endif
+ wanpipe_interface.next_event = wanpipe_next_event;
+ wanpipe_interface.channel_destroy = wanpipe_channel_destroy;
++ wanpipe_interface.get_alarms = wanpipe_get_alarms;
+ *zio = &wanpipe_interface;
+
+ return ZAP_SUCCESS;
+Index: configure.ac
+===================================================================
+--- configure.ac (revision 717)
++++ configure.ac (working copy)
+@@ -155,6 +155,9 @@
+ [AS_HELP_STRING([--with-libpri], [Install ozmod_libpri])], [enable_libpri="yes"], [enable_libpri="no"])
+ AC_SUBST(enable_libpri)
+
++AC_CHECK_LIB([sangoma], [sangoma_span_chan_toif], [have_libsangoma="yes"])
++AM_CONDITIONAL([LIBSANGOMA],[test "${have_libsangoma}" = "yes"])
++
+ AM_CONDITIONAL([LIBPRI],[test "${enable_libpri}" = "yes"])
+
+ COMP_VENDOR_CFLAGS="$COMP_VENDOR_CFLAGS"
+Index: Makefile.am
+===================================================================
+--- Makefile.am (revision 717)
++++ Makefile.am (working copy)
+@@ -154,10 +154,12 @@
+ ozmod_skel_la_LDFLAGS = -module -avoid-version
+ ozmod_skel_la_LIBADD = $(MYLIB)
+
++if LIBSANGOMA
+ ozmod_wanpipe_la_SOURCES = $(SRC)/ozmod/ozmod_wanpipe/ozmod_wanpipe.c
+-ozmod_wanpipe_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS)
+-ozmod_wanpipe_la_LDFLAGS = -module -avoid-version
++ozmod_wanpipe_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -D__LINUX__ -I/usr/include/wanpipe
++ozmod_wanpipe_la_LDFLAGS = -module -avoid-version -lsangoma
+ ozmod_wanpipe_la_LIBADD = $(MYLIB)
++endif
+
+ ozmod_isdn_la_SOURCES = \
+ $(SRC)/isdn/EuroISDNStateNT.c \
projects / thirdparty / freeswitch.git / commitdiff
