$(SRC)/zap_analog.o \
$(SRC)/zap_config.o \
$(SRC)/zap_callerid.o \
-$(SRC)/dsp/fsk.o \
-$(SRC)/dsp/uart.o \
+$(SRC)/fsk.o \
+$(SRC)/uart.o \
$(SRC)/g711.o \
$(SRC)/libteletone_detect.o \
$(SRC)/libteletone_generate.o \
$(SRC)/isdn/nationalmes.o \
$(SRC)/isdn/nationalStateNT.o \
$(SRC)/isdn/nationalStateTE.o \
-$(SRC)/isdn/Q932mes.o
+$(SRC)/isdn/Q932mes.o \
+$(SRC)/zap_zt.o \
+$(SRC)/zap_wanpipe.o
+
HEADERS=$(SRC)/isdn/include/Q931.h \
$(SRC)/include/openzap.h
PWD=$(shell pwd)
-INCS=-I$(PWD)/$(SRC)//include -I$(PWD)/$(SRC)//isdn/include -I$(PWD)/src/dsp
+INCS=-I$(PWD)/$(SRC)//include -I$(PWD)/$(SRC)//isdn/include
CFLAGS=$(ZAP_CFLAGS) $(INCS)
MYLIB=libopenzap.a
LIBPRIA=libpri.a
LIBPRI=./libpri
TMP=-I$(LIBPRI) -I$(SRC)/include -I./src -w
-include general.makefile $(ZAP_MODS)
+include general.makefile
all: $(MYLIB)
$(SRC)/zap_io.o: $(SRC)/zap_io.c
$(CC) $(MOD_CFLAGS) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@
-$(SRC)/zap_wanpipe.o: $(SRC)/zap_wanpipe.c
- $(CC) $(CFLAGS) $(ZAP_CFLAGS) $(WP_CFLAGS) -c $< -o $@
-
-$(SRC)/zap_zt.o: $(SRC)/zap_zt.c
- $(CC) $(CFLAGS) $(ZAP_CFLAGS) $(ZT_CFLAGS) -c $< -o $@
-
%.o: %.c
$(CC) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@
+++ /dev/null
-I have only tested the library with samples at 8kHz. It *should* work with arbitrary sample rates; the "optr" variable in the code samples below is the sampling rate in Hz.\r
-\r
-The first thing you need to do is initialize a context structure:\r
-\r
- dsp_fsk_attr_t fsk1200_attr; // attributes structure for FSK 1200 baud modem\r
- dsp_fsk_handle_t *fsk1200_handle; // context structure for FSK 1200 baud modem\r
-\r
- // initialize:\r
- dsp_fsk_attr_init (&fsk1200_attr); // clear attributes structure\r
- dsp_fsk_attr_set_samplerate (&fsk1200_attr, optr); // set sample rate\r
- dsp_fsk_attr_set_bytehandler (&fsk1200_attr, clid_byte_handler, ch); // bind byte handler\r
-\r
- // create context:\r
- fsk1200_handle = dsp_fsk_create (&fsk1200_attr);\r
-\r
- // error check:\r
- if (fsk1200_handle == NULL) {\r
- fprintf (stderr, "%s: can't dsp_fsk_create, errno %d (%s)\n", progname, errno, strerror (errno));\r
- exit (EXIT_FAILURE);\r
- }\r
-\r
-If you are decoding multiple channels, you will need multiple context structures; one per channel.\r
-The attributes ("dsp_fsk_attr_t") do not have to be persistent, but the handle does.\r
-There's even a "dsp_fsk_destroy()" function call to remove the context structure; I don't believe I've ever used it, my stuff hangs around forever.\r
-\r
-Then, you need to feed samples into the software modem:\r
- dsp_fsk_sample (fsk1200_handle, (double) sample / 32767.);\r
-\r
-It assumes the samples are between -1 and 1 as a double.\r
-\r
-It will outcall to your provided "clid_byte_handler()" function, which needs to have a prototype as follows:\r
-\r
- void clid_byte_handler (void *x, int data);\r
-\r
-The "x" is a context "void *" that you can associate in the fsk1200_handle (great for multiple channels).\r
-\r
-This will dribble bytes out to you at 1200 baud.\r
-\r
-From there, you are on your own. Canadian caller ID streams are different format than US caller ID streams IIRC. Both are trivial to figure out, as they have lots of ASCII data. I can supply some more code later on the Canadian one if you need it.\r
-\r
-Here's a sample of a Canadian caller ID stream from when you called:\r
-\r
-00000000: 55 55 55 55 55 55 55 55-55 55 55 55 55 55 55 55 UUUUUUUUUUUUUUUU\r
-00000010: 55 55 D5 80 1D 01 08 30-36 30 31 31 36 31 36 08 UU.....06011616.\r
-00000020: 01 4F 03 0B 31 32 34 38-35 35 35 31 32 31 32 06 .O..12485551212.\r
-00000030: 01 4C D1 85 00 02 54 00-02 C5 60 28 10 0A 80 30 .L....T...`(...0\r
-\r
-The "UUUUU" is an alternating series of ones and zeros (which, when combined with the start and stop bits, creates the 0x55 character "U") used to train analog modems.\r
-06011616 is the date and time (JUN 01 16:16), the "O" at 0x21 is an "Out of area"\r
-qualifier for why your name didn't appear, and "1248..." is your DN. The "L" at 0x31 is a long distance qualifier.\r
#define FNAME_LEN 50
-/* what should the returns from this function be?? */
-/* I dont think they are currently consistant between windows and *nix */
-#ifdef __WINDOWS__
-static __inline__ int tdmv_api_ioctl(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api_cmd)
-{
- /* can we make the structure passed for this on nix and windows the same */
- /* so we don't have to do the extra 2 memcpy's on windows for this ? */
- wan_udp_hdr_t wan_udp;
- DWORD ln;
- unsigned char id = 0;
-
- wan_udp.wan_udphdr_request_reply = 0x01;
- wan_udp.wan_udphdr_id = id;
- wan_udp.wan_udphdr_return_code = WAN_UDP_TIMEOUT_CMD;
-
- wan_udp.wan_udphdr_command = WAN_TDMV_API_IOCTL;
- wan_udp.wan_udphdr_data_len = sizeof(wanpipe_tdm_api_cmd_t);
-
- memcpy( wan_udp.wan_udphdr_data, (void*)tdm_api_cmd, sizeof(wanpipe_tdm_api_cmd_t));
-
- if (DeviceIoControl(
- fd,
- IoctlManagementCommand,
- (LPVOID)&wan_udp,
- sizeof(wan_udp_hdr_t),
- (LPVOID)&wan_udp,
- sizeof(wan_udp_hdr_t),
- (LPDWORD)(&ln),
- (LPOVERLAPPED)NULL
- ) == FALSE){
- return 1;
- }
-
- if (wan_udp.wan_udphdr_return_code != WAN_CMD_OK){
- return 2;
- }
-
- memcpy( (void*)tdm_api_cmd, wan_udp.wan_udphdr_data, sizeof(wanpipe_tdm_api_cmd_t));
- return 0;
-}
-
-#else
-static __inline__ int tdmv_api_ioctl(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api_cmd)
-{
- return ioctl(fd, SIOC_WANPIPE_TDM_API, tdm_api_cmd);
-}
-#endif
-
-void __inline__ tdmv_api_close_socket(sng_fd_t *sp)
-{
- if ( *sp != WP_INVALID_SOCKET){
-#if defined(__WINDOWS__)
- CloseHandle(*sp);
-#else
- close(*sp);
-#endif
- *sp = WP_INVALID_SOCKET;
- }
-}
-
-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;
-}
#if defined(__WINDOWS__)
/* This might be broken on windows, as POLL_EVENT_TELEPHONY seems to be commented out in sang_api.h.. it should be added to POLLPRI */
--- /dev/null
+/*****************************************************************************
+* wanpipe_tdm_api.h
+*
+* WANPIPE(tm) AFT TE1 Hardware Support
+*
+* Authors: Nenad Corbic <ncorbic@sangoma.com>
+*
+* Copyright (c) 2007, Sangoma Technologies
+* All rights reserved.
+*
+* Redistribution and use in source and binary forms, with or without
+* modification, are permitted provided that the following conditions are met:
+* * Redistributions of source code must retain the above copyright
+* notice, this list of conditions and the following disclaimer.
+* * Redistributions in binary form must reproduce the above copyright
+* notice, this list of conditions and the following disclaimer in the
+* documentation and/or other materials provided with the distribution.
+* * Neither the name of the <organization> nor the
+* names of its contributors may be used to endorse or promote products
+* derived from this software without specific prior written permission.
+*
+* THIS SOFTWARE IS PROVIDED BY <copyright holder> ``AS IS'' AND ANY
+* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
+* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+* ============================================================================
+* Oct 04, 2005 Nenad Corbic Initial version.
+*
+* Jul 25, 2006 David Rokhvarg <davidr@sangoma.com> Ported to Windows.
+*****************************************************************************/
+
+#ifndef __WANPIPE_TDM_API_IFACE_H_
+#define __WANPIPE_TDM_API_IFACE_H_
+
+
+#if defined(__WINDOWS__)
+typedef HANDLE sng_fd_t;
+#else
+typedef int sng_fd_t;
+#endif
+
+enum wanpipe_tdm_api_cmds {
+
+ SIOC_WP_TDM_GET_USR_MTU_MRU, /* 0x00 */
+
+ SIOC_WP_TDM_SET_USR_PERIOD, /* 0x01 */
+ SIOC_WP_TDM_GET_USR_PERIOD, /* 0x02 */
+
+ SIOC_WP_TDM_SET_HW_MTU_MRU, /* 0x03 */
+ SIOC_WP_TDM_GET_HW_MTU_MRU, /* 0x04 */
+
+ SIOC_WP_TDM_SET_CODEC, /* 0x05 */
+ SIOC_WP_TDM_GET_CODEC, /* 0x06 */
+
+ SIOC_WP_TDM_SET_POWER_LEVEL, /* 0x07 */
+ SIOC_WP_TDM_GET_POWER_LEVEL, /* 0x08 */
+
+ SIOC_WP_TDM_TOGGLE_RX, /* 0x09 */
+ SIOC_WP_TDM_TOGGLE_TX, /* 0x0A */
+
+ SIOC_WP_TDM_GET_HW_CODING, /* 0x0B */
+ SIOC_WP_TDM_SET_HW_CODING, /* 0x0C */
+
+ SIOC_WP_TDM_GET_FULL_CFG, /* 0x0D */
+
+ SIOC_WP_TDM_SET_EC_TAP, /* 0x0E */
+ SIOC_WP_TDM_GET_EC_TAP, /* 0x0F */
+
+ SIOC_WP_TDM_ENABLE_RBS_EVENTS, /* 0x10 */
+ SIOC_WP_TDM_DISABLE_RBS_EVENTS, /* 0x11 */
+ SIOC_WP_TDM_WRITE_RBS_BITS, /* 0x12 */
+
+ SIOC_WP_TDM_GET_STATS, /* 0x13 */
+ SIOC_WP_TDM_FLUSH_BUFFERS, /* 0x14 */
+
+ SIOC_WP_TDM_READ_EVENT, /* 0x15 */
+
+ SIOC_WP_TDM_SET_EVENT,
+
+ SIOC_WP_TDM_SET_RX_GAINS,
+ SIOC_WP_TDM_SET_TX_GAINS,
+ SIOC_WP_TDM_CLEAR_RX_GAINS,
+ SIOC_WP_TDM_CLEAR_TX_GAINS,
+
+ SIOC_WP_TDM_GET_FE_ALARMS,
+
+ SIOC_WP_TDM_ENABLE_HWEC,
+ SIOC_WP_TDM_DISABLE_HWEC,
+
+ SIOC_WP_TDM_NOTSUPP /* */
+
+
+};
+
+enum wanpipe_tdm_api_events {
+ WP_TDMAPI_EVENT_NONE,
+ WP_TDMAPI_EVENT_RBS,
+ WP_TDMAPI_EVENT_ALARM,
+ WP_TDMAPI_EVENT_DTMF,
+ WP_TDMAPI_EVENT_RM_DTMF,
+ WP_TDMAPI_EVENT_RXHOOK,
+ WP_TDMAPI_EVENT_RING,
+ WP_TDMAPI_EVENT_RING_DETECT,
+ WP_TDMAPI_EVENT_RING_TRIP_DETECT,
+ WP_TDMAPI_EVENT_TONE,
+ WP_TDMAPI_EVENT_TXSIG_KEWL,
+ WP_TDMAPI_EVENT_TXSIG_START,
+ WP_TDMAPI_EVENT_TXSIG_OFFHOOK,
+ WP_TDMAPI_EVENT_TXSIG_ONHOOK,
+ WP_TDMAPI_EVENT_ONHOOKTRANSFER,
+ WP_TDMAPI_EVENT_SETPOLARITY
+};
+
+#define WP_TDMAPI_EVENT_ENABLE 0x01
+#define WP_TDMAPI_EVENT_DISABLE 0x02
+#define WP_TDMAPI_EVENT_MODE_DECODE(mode) \
+ ((mode) == WP_TDMAPI_EVENT_ENABLE) ? "Enable" : \
+ ((mode) == WP_TDMAPI_EVENT_DISABLE) ? "Disable" : \
+ "(Unknown mode)"
+
+#define WPTDM_A_BIT WAN_RBS_SIG_A
+#define WPTDM_B_BIT WAN_RBS_SIG_B
+#define WPTDM_C_BIT WAN_RBS_SIG_C
+#define WPTDM_D_BIT WAN_RBS_SIG_D
+
+#define WP_TDMAPI_EVENT_RXHOOK_OFF 0x01
+#define WP_TDMAPI_EVENT_RXHOOK_ON 0x02
+#define WP_TDMAPI_EVENT_RXHOOK_DECODE(state) \
+ ((state) == WP_TDMAPI_EVENT_RXHOOK_OFF) ? "Off-hook" : \
+ ((state) == WP_TDMAPI_EVENT_RXHOOK_ON) ? "On-hook" : \
+ "(Unknown state)"
+
+#define WP_TDMAPI_EVENT_RING_PRESENT 0x01
+#define WP_TDMAPI_EVENT_RING_STOP 0x02
+#define WP_TDMAPI_EVENT_RING_DECODE(state) \
+ ((state) == WP_TDMAPI_EVENT_RING_PRESENT) ? "Ring Present" : \
+ ((state) == WP_TDMAPI_EVENT_RING_STOP) ? "Ring Stop" : \
+ "(Unknown state)"
+
+#define WP_TDMAPI_EVENT_RING_TRIP_PRESENT 0x01
+#define WP_TDMAPI_EVENT_RING_TRIP_STOP 0x02
+#define WP_TDMAPI_EVENT_RING_TRIP_DECODE(state) \
+ ((state) == WP_TDMAPI_EVENT_RING_TRIP_PRESENT) ? "Ring Present" : \
+ ((state) == WP_TDMAPI_EVENT_RING_TRIP_STOP) ? "Ring Stop" : \
+ "(Unknown state)"
+
+#define WP_TDMAPI_EVENT_TONE_DIAL 0x01
+#define WP_TDMAPI_EVENT_TONE_BUSY 0x02
+#define WP_TDMAPI_EVENT_TONE_RING 0x03
+#define WP_TDMAPI_EVENT_TONE_CONGESTION 0x04
+
+
+typedef struct {
+
+ u_int8_t type;
+ u_int8_t mode;
+ u_int32_t time_stamp;
+ u_int16_t channel;
+ u_int32_t chan_map;
+ union {
+ struct {
+ u_int8_t alarm;
+ } te1_alarm;
+ struct {
+ u_int8_t rbs_bits;
+ } te1_rbs;
+ struct {
+ u_int8_t state;
+ u_int8_t sig;
+ } rm_hook;
+ struct {
+ u_int8_t state;
+ } rm_ring;
+ struct {
+ u_int8_t type;
+ } rm_tone;
+ struct {
+ u_int8_t digit; /* DTMF: digit */
+ u_int8_t port; /* DTMF: SOUT/ROUT */
+ u_int8_t type; /* DTMF: PRESET/STOP */
+ } dtmf;
+ struct {
+ u_int16_t polarity;
+ u_int16_t ohttimer;
+ } rm_common;
+ } wp_tdm_api_event_u;
+#define wp_tdm_api_event_type type
+#define wp_tdm_api_event_mode mode
+#define wp_tdm_api_event_alarm wp_tdm_api_event_u.te1_alarm.alarm
+#define wp_tdm_api_event_alarm wp_tdm_api_event_u.te1_alarm.alarm
+#define wp_tdm_api_event_rbs_bits wp_tdm_api_event_u.te1_rbs.rbs_bits
+#define wp_tdm_api_event_hook_state wp_tdm_api_event_u.rm_hook.state
+#define wp_tdm_api_event_hook_sig wp_tdm_api_event_u.rm_hook.sig
+#define wp_tdm_api_event_ring_state wp_tdm_api_event_u.rm_ring.state
+#define wp_tdm_api_event_tone_type wp_tdm_api_event_u.rm_tone.type
+#define wp_tdm_api_event_dtmf_digit wp_tdm_api_event_u.dtmf.digit
+#define wp_tdm_api_event_dtmf_type wp_tdm_api_event_u.dtmf.type
+#define wp_tdm_api_event_dtmf_port wp_tdm_api_event_u.dtmf.port
+#define wp_tdm_api_event_ohttimer wp_tdm_api_event_u.rm_common.ohttimer
+#define wp_tdm_api_event_polarity wp_tdm_api_event_u.rm_common.polarity
+} wp_tdm_api_event_t;
+
+typedef struct {
+ union {
+ unsigned char reserved[16];
+ }wp_rx_hdr_u;
+} wp_tdm_api_rx_hdr_t;
+
+typedef struct {
+ wp_tdm_api_rx_hdr_t hdr;
+ unsigned char data[1];
+} wp_tdm_api_rx_element_t;
+
+typedef struct {
+ union {
+ struct {
+ unsigned char _rbs_rx_bits;
+ unsigned int _time_stamp;
+ }wp_tx;
+ unsigned char reserved[16];
+ }wp_tx_hdr_u;
+#define wp_api_time_stamp wp_tx_hdr_u.wp_tx._time_stamp
+} wp_tdm_api_tx_hdr_t;
+
+typedef struct {
+ wp_tdm_api_tx_hdr_t hdr;
+ unsigned char data[1];
+} wp_tdm_api_tx_element_t;
+
+
+
+typedef struct wp_tdm_chan_stats
+{
+ unsigned int rx_packets; /* total packets received */
+ unsigned int tx_packets; /* total packets transmitted */
+ unsigned int rx_bytes; /* total bytes received */
+ unsigned int tx_bytes; /* total bytes transmitted */
+ unsigned int rx_errors; /* bad packets received */
+ unsigned int tx_errors; /* packet transmit problems */
+ unsigned int rx_dropped; /* no space in linux buffers */
+ unsigned int tx_dropped; /* no space available in linux */
+ unsigned int multicast; /* multicast packets received */
+#if !defined(__WINDOWS__)
+ unsigned int collisions;
+#endif
+ /* detailed rx_errors: */
+ unsigned int rx_length_errors;
+ unsigned int rx_over_errors; /* receiver ring buff overflow */
+ unsigned int rx_crc_errors; /* recved pkt with crc error */
+ unsigned int rx_frame_errors; /* recv'd frame alignment error */
+#if !defined(__WINDOWS__)
+ unsigned int rx_fifo_errors; /* recv'r fifo overrun */
+#endif
+ unsigned int rx_missed_errors; /* receiver missed packet */
+
+ /* detailed tx_errors */
+#if !defined(__WINDOWS__)
+ unsigned int tx_aborted_errors;
+ unsigned int tx_carrier_errors;
+#endif
+ unsigned int tx_fifo_errors;
+ unsigned int tx_heartbeat_errors;
+ unsigned int tx_window_errors;
+
+}wp_tdm_chan_stats_t;
+
+
+
+typedef struct wanpipe_tdm_api_cmd{
+ unsigned int cmd;
+ unsigned int hw_tdm_coding; /* Set/Get HW TDM coding: uLaw muLaw */
+ unsigned int hw_mtu_mru; /* Set/Get HW TDM MTU/MRU */
+ unsigned int usr_period; /* Set/Get User Period in ms */
+ unsigned int tdm_codec; /* Set/Get TDM Codec: SLinear */
+ unsigned int power_level; /* Set/Get Power level treshold */
+ unsigned int rx_disable; /* Enable/Disable Rx */
+ unsigned int tx_disable; /* Enable/Disable Tx */
+ unsigned int usr_mtu_mru; /* Set/Get User TDM MTU/MRU */
+ unsigned int ec_tap; /* Echo Cancellation Tap */
+ unsigned int rbs_poll; /* Enable/Disable RBS Polling */
+ unsigned int rbs_rx_bits; /* Rx RBS Bits */
+ unsigned int rbs_tx_bits; /* Tx RBS Bits */
+ unsigned int hdlc; /* HDLC based device */
+ unsigned int idle_flag; /* IDLE flag to Tx */
+ unsigned int fe_alarms; /* FE Alarms detected */
+ wp_tdm_chan_stats_t stats; /* TDM Statistics */
+ wp_tdm_api_event_t event; /* TDM Event */
+ unsigned int data_len;
+ void *data;
+}wanpipe_tdm_api_cmd_t;
+
+typedef struct wanpipe_tdm_api_event{
+ int (*wp_rbs_event)(sng_fd_t fd, unsigned char rbs_bits);
+ int (*wp_dtmf_event)(sng_fd_t fd, unsigned char dtmf, unsigned char type, unsigned char port);
+ int (*wp_rxhook_event)(sng_fd_t fd, unsigned char hook_state);
+ int (*wp_ring_detect_event)(sng_fd_t fd, unsigned char ring_state);
+ int (*wp_ring_trip_detect_event)(sng_fd_t fd, unsigned char ring_state);
+ int (*wp_fe_alarm_event)(sng_fd_t fd, unsigned char fe_alarm_event);
+}wanpipe_tdm_api_event_t;
+
+typedef struct wanpipe_tdm_api{
+ wanpipe_tdm_api_cmd_t wp_tdm_cmd;
+ wanpipe_tdm_api_event_t wp_tdm_event;
+}wanpipe_tdm_api_t;
+
+
+#endif
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+#define ZAP_ZT_SUPPORT
+#define ZAP_WANPIPE_SUPPORT
#include "openzap.h"
#include "zap_isdn.h"
#include <stdarg.h>
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
-#define WANPIPE_TDM_API 1
-
#include "openzap.h"
#include "zap_wanpipe.h"
+#include <stropts.h>
+#include <poll.h>
+#include <sys/socket.h>
+
+#define WP_INVALID_SOCKET -1
-/*#include <sangoma_tdm_api.h>*/
-#include <wanpipe_tdm_api.h>
+#include <wanpipe_tdm_api_iface.h>
static struct {
uint32_t codec_ms;
uint32_t flash_ms;
} wp_globals;
+#define SIOC_WANPIPE_TDM_API 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;
+
+ 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;
+
+ if (!DeviceIoControl(
+ fd,
+ IoctlApiPoll,
+ (LPVOID)NULL,
+ 0L,
+ (LPVOID)&api_poll,
+ sizeof(API_POLL_STRUCT),
+ (LPDWORD)(&ln),
+ (LPOVERLAPPED)NULL)) {
+ return -1;
+ }
+
+ *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;
+ }
+
+ if (api_poll.poll_events_bitmap & POLL_EVENT_TIMEOUT) {
+ return 0;
+ }
+
+ *flags = api_poll.poll_events_bitmap;
+
+ return 1;
+#else
+ struct pollfd pfds[1];
+ int res;
+
+ memset(&pfds[0], 0, sizeof(pfds[0]));
+ pfds[0].fd = fd;
+ pfds[0].events = *flags;
+ res = poll(pfds, 1, timeout);
+ *flags = 0;
+
+ if (pfds[0].revents & POLLERR) {
+ res = -1;
+ }
+
+ if (res > 0) {
+ *flags = pfds[0].revents;
+ }
+
+ 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;
+}
+
+
+
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;
- err = tdmv_api_ioctl(zchan->sockfd, tdm_api);
-
+ /* 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;
if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO) {
wanpipe_tdm_api_t tdm_api;
- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_ENABLE_RXHOOK_EVENTS;
+ 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) {
- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_ENABLE_RING_DETECT_EVENTS;
+ tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type = WP_TDMAPI_EVENT_RING;
+ tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_mode = WP_TDMAPI_EVENT_ENABLE;
wp_tdm_cmd_exec(chan, &tdm_api);
}
zchan->native_codec = zchan->effective_codec = ZAP_CODEC_NONE;
} else {
tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_CODEC;
- tdm_api.wp_tdm_cmd.tdm_codec = WP_NONE;
+ 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;
ZIO_SPAN_POLL_EVENT_FUNCTION(wanpipe_poll_event)
{
struct pollfd pfds[ZAP_MAX_CHANNELS_SPAN];
- int i, j = 0, k = 0, l = 0, r;
+ uint32_t i, j = 0, k = 0, l = 0;
+ int r;
for(i = 1; i <= span->chan_count; i++) {
memset(&pfds[j], 0, sizeof(pfds[j]));
}
switch(tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type) {
- case WP_TDM_EVENT_RXHOOK:
+ case WP_TDMAPI_EVENT_RXHOOK:
{
- event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_rxhook_state & WP_TDMAPI_EVENT_RXHOOK_OFF ? ZAP_OOB_OFFHOOK : ZAP_OOB_ONHOOK;
+ event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_hook_state & WP_TDMAPI_EVENT_RXHOOK_OFF ? ZAP_OOB_OFFHOOK : ZAP_OOB_ONHOOK;
if (event_id == ZAP_OOB_OFFHOOK) {
if (zap_test_flag((&span->channels[i]), ZAP_CHANNEL_FLASH)) {
continue;
}
break;
- case WP_TDM_EVENT_RING_DETECT:
+ case WP_TDMAPI_EVENT_RING_DETECT:
{
event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_ring_state & WP_TDMAPI_EVENT_RING_PRESENT ? ZAP_OOB_RING_START : ZAP_OOB_RING_STOP;
- tdm_api.wp_tdm_cmd.cmd = SIOC_WP_TDM_DISABLE_RING_DETECT_EVENTS;
- wp_tdm_cmd_exec(&span->channels[i], &tdm_api);
+
}
break;
default:
static ZIO_DESTROY_CHANNEL_FUNCTION(wanpipe_destroy_channel)
{
- tdmv_api_close_socket(&zchan->sockfd);
- zchan->sockfd = WP_INVALID_SOCKET;
+ if (zchan->sockfd > -1) {
+ close(zchan->sockfd);
+ zchan->sockfd = WP_INVALID_SOCKET;
+ }
return ZAP_SUCCESS;
}
{
unsigned configured = 0, x;
char path[128] = "";
- zt_params_t ztp = {0};
+ zt_params_t ztp;
+
+ memset(&ztp, 0, sizeof(ztp));
for(x = start; x < end; x++) {
zap_channel_t *chan;
static ZIO_COMMAND_FUNCTION(zt_command)
{
- zt_params_t ztp = {0};
+ zt_params_t ztp;
int err = 0;
+ memset(&ztp, 0, sizeof(ztp));
+
switch(command) {
case ZAP_COMMAND_OFFHOOK:
{
ZIO_SPAN_POLL_EVENT_FUNCTION(zt_poll_event)
{
struct pollfd pfds[ZAP_MAX_CHANNELS_SPAN];
- int i, j = 0, k = 0, r, e;
+ uint32_t i, j = 0, k = 0;
+ int r;
for(i = 1; i <= span->chan_count; i++) {
memset(&pfds[j], 0, sizeof(pfds[j]));
break;
}
- event:
span->channels[i].last_event_time = 0;
span->event_header.e_type = ZAP_EVENT_OOB;
span->event_header.enum_id = event_id;
+++ /dev/null
-MOD_CFLAGS +=-DZAP_WANPIPE_SUPPORT
-OBJS += $(SRC)/zap_wanpipe.o
-WANPIPE_INCLUDE=/usr/include/wanpipe
-
-WP_CFLAGS =-Wall -Werror -I$(WANPIPE_INCLUDE) -I/usr/local/include -I/usr/src/linux/include -I. -I/usr/include
-WP_CFLAGS +=-D__LINUX__ -D_REENTRANT -D_GNU_SOURCE -DAFT_A104 -DWANPIPE_TDM_API -D_GNUC_ -DWANPIPE_TDM_API
-
-
-
-
+++ /dev/null
-MOD_CFLAGS +=-DZAP_ZT_SUPPORT
-OBJS += $(SRC)/zap_zt.o
projects / thirdparty / freeswitch.git / commitdiff
