LIBPRI=libpri-1.2.4
LIBPRI_FILE=$(LIBPRI).tar.gz
LIBPRI_DIR=$(BASE)/libs/$(LIBPRI)
-WANPIPE=wanpipe-3.1.0.p13
+WANPIPE=wanpipe-3.1.0.p15
WANPIPE_HOST=ftp://ftp.sangoma.com/linux/custom/3.1
WANPIPE_FILE=$(WANPIPE).tgz
WANPIPE_DIR=$(BASE)/libs/$(WANPIPE)
WANPIPE_INCLUDE=$(WANPIPE_DIR)/patches/kdrivers/include
WANPIPE_KO=$(WANPIPE_DIR)/patches/kdrivers/src/net/wanpipe.ko
WANPIPE_INSTALLED_KO=$(shell echo "/lib/modules/`uname -r`/kernel/drivers/net/wan/wanpipe.ko")
-LIBSANGOMA_DIR=$(WANPIPE_DIR)/api/libsangoma
+LIBSANGOMA_DIR=./libsangoma
LOCAL_CFLAGS =-w -I$(WANPIPE_INCLUDE) -I$(LIBSANGOMA_DIR) -I/usr/local/include -I$(LIBPRI_DIR) -I/usr/src/linux/include -I. -I/usr/include
LOCAL_CFLAGS +=-D__LINUX__ -D_REENTRANT -D_GNU_SOURCE -DAFT_A104 -DWANPIPE_TDM_API -I$(switch_srcdir)/libs/libteletone/src -D_GNUC_ -DWANPIPE_TDM_API
LOCAL_OBJS = ss7boost_client.o $(LIBPRI_DIR)/copy_string.o $(LIBPRI_DIR)/pri.o $(LIBPRI_DIR)/q921.o $(LIBPRI_DIR)/prisched.o $(LIBPRI_DIR)/q931.o $(LIBPRI_DIR)/pri_facility.o $(LIBSANGOMA_DIR)/libsangoma.o $(LIBSANGOMA_DIR)/sangoma_pri.o
include $(BASE)/build/modmake.rules
+testapp: testapp.c $(LIBSANGOMA_DIR)/libsangoma.o
+ $(CC) -I$(WANPIPE_DIR)/api/lib $(CFLAGS) $(LOCAL_CFLAGS) lib_api.c testapp.c $(LIBSANGOMA_DIR)/libsangoma.o -o testapp
+
$(LIBPRI_DIR):
$(GETLIB) $(LIBPRI_HOST) $(LIBPRI_FILE)
--- /dev/null
+/*****************************************************************************
+* lib_api.c Common API library
+*
+* Author(s): Nenad Corbic <ncorbic@sangoma.com>
+*
+* Copyright: (c) 2003 Sangoma Technologies Inc.
+*
+* This program is free software; you can redistribute it and/or
+* modify it under the terms of the GNU General Public License
+* as published by the Free Software Foundation; either version
+* 2 of the License, or (at your option) any later version.
+* ============================================================================
+*/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <linux/if_wanpipe.h>
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <linux/if.h>
+
+#include <linux/wanpipe_defines.h>
+#include <linux/wanpipe_cfg.h>
+#include <linux/wanpipe.h>
+
+#include "lib_api.h"
+
+#define SINGLE_CHANNEL 0x2
+#define RANGE_CHANNEL 0x1
+
+
+char read_enable=0;
+char write_enable=0;
+char primary_enable=0;
+int tx_cnt=1;
+int rx_cnt=0;
+int tx_size=10;
+int tx_delay=0;
+int tx_data=-1;
+int tx_ss7_type=0;
+int rx_ss7_timer=0;
+
+unsigned char card_name[WAN_IFNAME_SZ];
+unsigned char if_name[WAN_IFNAME_SZ];
+
+unsigned char sw_if_name[WAN_IFNAME_SZ];
+unsigned char sw_card_name[WAN_IFNAME_SZ];
+
+unsigned char tx_file[WAN_IFNAME_SZ];
+unsigned char rx_file[WAN_IFNAME_SZ];
+
+unsigned char daddr[TX_ADDR_STR_SZ];
+unsigned char saddr[TX_ADDR_STR_SZ];
+unsigned char udata[TX_ADDR_STR_SZ];
+
+int files_used=0;
+int verbose=0;
+
+int tx_connections;
+
+int ds_prot=0;
+int ds_prot_opt=0;
+int ds_max_mult_cnt=0;
+unsigned int ds_active_ch=0;
+int ds_7bit_hdlc=0;
+int direction=-1;
+
+int tx_channels=1;
+int cause=0;
+int diagn=0;
+
+int card_cnt=0;
+int i_cnt=0;
+
+unsigned long parse_active_channel(char* val);
+
+int init_args(int argc, char *argv[])
+{
+ int i;
+ int c_cnt=0;
+
+ sprintf(daddr,"111");
+ sprintf(saddr,"222");
+ sprintf(udata,"C9");
+
+ for (i = 0; i < argc; i++){
+
+ if (!strcmp(argv[i],"-i")){
+
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid Interface Name!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(if_name, argv[i+1],WAN_IFNAME_SZ);
+ i_cnt=1;
+
+ }else if (!strcmp(argv[i],"-si")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid Switch Interface Name!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(sw_if_name, argv[i+1], WAN_IFNAME_SZ);
+
+ }else if (!strcmp(argv[i],"-c")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid Card Name!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(card_name, argv[i+1], WAN_IFNAME_SZ);
+ card_cnt=1;
+
+ }else if (!strcmp(argv[i],"-sc")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid Switch Card Name!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(sw_card_name, argv[i+1], WAN_IFNAME_SZ);
+
+ }else if (!strcmp(argv[i],"-r")){
+ read_enable=1;
+ c_cnt=1;
+
+ }else if (!strcmp(argv[i],"-w")){
+ write_enable=1;
+ c_cnt=1;
+
+ }else if (!strcmp(argv[i],"-pri")){
+ primary_enable=1;
+
+ }else if (!strcmp(argv[i],"-txcnt")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid tx cnt!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ tx_cnt = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid tx cnt!\n");
+ return WAN_FALSE;
+ }
+
+ }else if (!strcmp(argv[i],"-rxcnt")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid rx cnt!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ rx_cnt = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid rx cnt!\n");
+ return WAN_FALSE;
+ }
+
+ }else if (!strcmp(argv[i],"-txsize")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid tx size!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ tx_size = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid tx size, must be a digit!\n");
+ return WAN_FALSE;
+ }
+ }else if (!strcmp(argv[i],"-txdelay")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid tx delay!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ tx_delay = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid tx delay, must be a digit!\n");
+ return WAN_FALSE;
+ }
+ }else if (!strcmp(argv[i],"-txdata")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid tx data!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ tx_data = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid tx data, must be a digit!\n");
+ return WAN_FALSE;
+ }
+ }else if (!strcmp(argv[i],"-tx_ss7_type")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid tx ss7 type!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ tx_ss7_type = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid tx ss7 type, must be a digit!\n");
+ return WAN_FALSE;
+ }
+
+ }else if (!strcmp(argv[i],"-rx_ss7_timer")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid rx ss7 timer!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ rx_ss7_timer = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid tx ss7 type, must be a digit!\n");
+ return WAN_FALSE;
+ }
+
+
+ }else if (!strcmp(argv[i],"-txfile")){
+
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid Tx File Name!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(tx_file, argv[i+1],WAN_IFNAME_SZ);
+ files_used |= TX_FILE_USED;
+
+ }else if (!strcmp(argv[i],"-rxfile")){
+
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid Rx File Name!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(rx_file, argv[i+1],WAN_IFNAME_SZ);
+ files_used |= RX_FILE_USED;
+
+ }else if (!strcmp(argv[i],"-daddr")){
+
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid daddr str!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(daddr, argv[i+1],TX_ADDR_STR_SZ);
+
+ }else if (!strcmp(argv[i],"-saddr")){
+
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid saddr str!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(saddr, argv[i+1],TX_ADDR_STR_SZ);
+
+ }else if (!strcmp(argv[i],"-udata")){
+
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid udata str!\n");
+ return WAN_FALSE;
+ }
+
+ strncpy(udata, argv[i+1],TX_ADDR_STR_SZ);
+
+ }else if (!strcmp(argv[i],"-verbose")){
+ verbose=1;
+
+ }else if (!strcmp(argv[i],"-prot")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid prot!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ ds_prot = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid prot, must be a digit!\n");
+ return WAN_FALSE;
+ }
+
+
+ }else if (!strcmp(argv[i],"-prot_opt")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid prot_opt!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ ds_prot_opt = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid prot_opt, must be a digit!\n");
+ return WAN_FALSE;
+ }
+ }else if (!strcmp(argv[i],"-max_mult_cnt")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid max_mult_cnt!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ ds_max_mult_cnt = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid max_mult_cnt, must be a digit!\n");
+ return WAN_FALSE;
+ }
+ }else if (!strcmp(argv[i],"-active_ch")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid active ch!\n");
+ return WAN_FALSE;
+ }
+
+ ds_active_ch = parse_active_channel(argv[i+1]);
+ }else if (!strcmp(argv[i],"-txchan")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid channels!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ tx_channels = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid channels, must be a digit!\n");
+ return WAN_FALSE;
+ }
+ }else if (!strcmp(argv[i],"-diagn")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid diagn!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ diagn = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid diagn, must be a digit!\n");
+ return WAN_FALSE;
+ }
+
+ }else if (!strcmp(argv[i],"-cause")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid cause!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ cause = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid cause, must be a digit!\n");
+ return WAN_FALSE;
+ }
+
+ }else if (!strcmp(argv[i],"-7bit_hdlc")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid 7bit hdlc value!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ ds_7bit_hdlc = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid 7bit hdlc, must be a digit!\n");
+ return WAN_FALSE;
+ }
+
+ }else if (!strcmp(argv[i],"-dir")){
+ if (i+1 > argc-1){
+ printf("ERROR: Invalid direction value!\n");
+ return WAN_FALSE;
+ }
+
+ if(isdigit(argv[i+1][0])){
+ direction = atoi(argv[i+1]);
+ }else{
+ printf("ERROR: Invalid direction, must be a digit!\n");
+ return WAN_FALSE;
+ }
+ }
+ }
+
+ if (!i_cnt){
+ printf("ERROR: No Interface Name!\n");
+ return WAN_FALSE;
+ }
+ if (!card_cnt){
+ printf("ERROR: No Card name!\n");
+ return WAN_FALSE;
+ }
+ if (!c_cnt){
+ printf("ERROR: No Read or Write Command!\n");
+ return WAN_FALSE;
+ }
+
+ return WAN_TRUE;
+}
+
+static unsigned char api_usage[]="\n"
+"\n"
+"<options>:\n"
+" -i <ifname> #interface name\n"
+" -c <card name> #card name\n"
+" -r #read enable\n"
+" -w #write eable\n"
+"\n"
+"<extra options>\n"
+" -txcnt <digit> #number of tx packets (Dflt: 1)\n"
+" -txsize <digit> #tx packet size (Dflt: 10)\n"
+" -txdelay <digit> #delay in sec after each tx packet (Dflt: 0)\n"
+" -txdata <digit> #data to tx <1-255>\n"
+"\n"
+" -txfile <file> #Use file to tx instead\n"
+" -rxfile <file> #Save all rx data to a file\n"
+" \n"
+"\n"
+" -tx_ss7_type <digit> # 1=FISU 2=LSSU (repeating)\n"
+" -rx_ss7_timer <digit> #Force receive timeout value \n"
+"\n"
+" -rxcnt <digit> #number of rx packets before exit\n"
+" #this number overwrites the txcnt\n"
+" #Thus, app will only exit after it\n"
+" #receives the rxcnt number of packets.\n"
+" \n"
+" -verbose #Enable verbose mode\n"
+"\n"
+"<datascope options>\n"
+"\n"
+" -prot <digit> #Protocol Bit map: \n"
+" #1=FISU, 2=LSSU, 4=MSU, 8=RAW HDLC\n"
+" \n"
+" -prot_opt <digit> #Protocol bit map\n"
+" #0=None, 1=Delta, 2=Max Multiple\n"
+"\n"
+" -active_ch <digit> #Active channel\n"
+" #ALL = all channels \n"
+" #1 24 = 1 to 24 \n"
+" #1.24 = 1 and 24 \n"
+" #1-4.7-15 = 1 to 4 and 7 to 15\n"
+" \n"
+" -max_mult_cnt <digit> #If Prot_opt == 2 \n"
+" #max_mult_cnt is the number of \n"
+" #consecutive duplicate frames \n"
+" #received before pass up the stack.\n"
+" \n"
+" -7bit_hdlc <digit> #Enable 7 Bit Hdlc Engine\n"
+" #1=Enable 0=Disable\n"
+" \n"
+" -dir <digit> #Direction 0: Rx 1: Tx none: All\n"
+"\n"
+"<x25 protocol options>\n"
+"\n"
+" -txchan <digit> #Number of channels (dflt=1)\n"
+" -cause <digit> #disconnect cause (dflt=0)\n"
+" -diagn <digit> #disconnect diagnostic (dflt=0)\n"
+"\n";
+
+void usage(unsigned char *api_name)
+{
+printf ("\n\nAPI %s USAGE:\n\n%s <options> <extra options>\n\n%s\n",
+ api_name,api_name,api_usage);
+}
+
+
+/*============================================================================
+ * TE1
+ */
+unsigned long get_active_channels(int channel_flag, int start_channel, int stop_channel)
+{
+ int i = 0;
+ unsigned long tmp = 0, mask = 0;
+
+ if ((channel_flag & (SINGLE_CHANNEL | RANGE_CHANNEL)) == 0)
+ return tmp;
+ if (channel_flag & RANGE_CHANNEL) { /* Range of channels */
+ for(i = start_channel; i <= stop_channel; i++) {
+ mask = 1 << (i - 1);
+ tmp |=mask;
+ }
+ } else { /* Single channel */
+ mask = 1 << (stop_channel - 1);
+ tmp |= mask;
+ }
+ return tmp;
+}
+
+
+unsigned long parse_active_channel(char* val)
+{
+ int channel_flag = 0;
+ char* ptr = val;
+ int channel = 0, start_channel = 0;
+ unsigned long tmp = 0;
+
+ if (strcmp(val,"ALL") == 0)
+ return ENABLE_ALL_CHANNELS;
+
+ while(*ptr != '\0') {
+ if (isdigit(*ptr)) {
+ channel = strtoul(ptr, &ptr, 10);
+ channel_flag |= SINGLE_CHANNEL;
+ } else {
+ if (*ptr == '-') {
+ channel_flag |= RANGE_CHANNEL;
+ start_channel = channel;
+ } else {
+ tmp |= get_active_channels(channel_flag, start_channel, channel);
+ channel_flag = 0;
+ }
+ ptr++;
+ }
+ }
+ if (channel_flag){
+ tmp |= get_active_channels(channel_flag, start_channel, channel);
+ }
+ return tmp;
+}
+
+void u_delay(int usec)
+{
+ struct timeval tv;
+ tv.tv_usec = usec;
+ tv.tv_sec=0;
+
+ select(0,NULL,NULL, NULL, &tv);
+}
#define DFT_CARD "wanpipe1"
#if defined(WIN32)
-//extern int verbose;
+//extern int verbose;
#define DEV_NAME_LEN 100
char device_name[DEV_NAME_LEN];
/* IOCTL management structures and variables*/
-wan_udp_hdr_t wan_udp;
+wan_udp_hdr_t wan_udp;
#include "win_api_common.h"
static wan_cmd_api_t api_cmd;
-static api_tx_hdr_t *tx_hdr = (api_tx_hdr_t *) api_cmd.data;
+static api_tx_hdr_t *tx_hdr = (api_tx_hdr_t *)api_cmd.data;
/* keeps the LAST (and single) event received */
static wp_tdm_api_rx_hdr_t last_tdm_api_event_buffer;
-#endif /* WIN32 */
+#endif /* WIN32 */
-void sangoma_socket_close(sng_fd_t * sp)
+void sangoma_socket_close(sng_fd_t *sp)
{
#if defined(WIN32)
- if (*sp != INVALID_HANDLE_VALUE) {
+ if( *sp != INVALID_HANDLE_VALUE){
CloseHandle(*sp);
*sp = INVALID_HANDLE_VALUE;
}
#else
- if (*sp > -1) {
- close(*sp);
- *sp = -1;
- }
+ if (*sp > -1) {
+ close(*sp);
+ *sp = -1;
+ }
#endif
}
int sangoma_socket_waitfor(sng_fd_t fd, int timeout, int flags)
{
#if defined(WIN32)
- API_POLL_STRUCT api_poll;
+ API_POLL_STRUCT api_poll;
memset(&api_poll, 0x00, sizeof(API_POLL_STRUCT));
-
+
api_poll.user_flags_bitmap = flags;
- if (DoApiPollCommand(fd, &api_poll)) {
+ if(DoApiPollCommand(fd, &api_poll)){
//failed
return 0;
}
- switch (api_poll.operation_status) {
- case SANG_STATUS_RX_DATA_AVAILABLE:
- break;
+ switch(api_poll.operation_status)
+ {
+ case SANG_STATUS_RX_DATA_AVAILABLE:
+ break;
- default:
- prn(1, "Error: sangoma_socket_waitfor(): Unknown Operation Status: %d\n", api_poll.operation_status);
- return 0;
- } //switch()
+ default:
+ prn(1, "Error: sangoma_socket_waitfor(): Unknown Operation Status: %d\n",
+ api_poll.operation_status);
+ return 0;
+ }//switch()
- if (api_poll.poll_events_bitmap == 0) {
- prn(1, "Error: invalid Poll Events bitmap: 0x%X\n", api_poll.poll_events_bitmap);
+ if(api_poll.poll_events_bitmap == 0){
+ prn(1, "Error: invalid Poll Events bitmap: 0x%X\n",
+ api_poll.poll_events_bitmap);
}
return api_poll.poll_events_bitmap;
#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);
- if (res > 0) {
- if ((pfds[0].revents & POLLERR)) {
- res = -1;
- } else if ((pfds[0].revents)) {
- res = 1;
- }
- }
-
- return res;
+ 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);
+ if (res > 0) {
+ if ((pfds[0].revents & POLLERR)) {
+ res = -1;
+ } else if((pfds[0].revents)) {
+ res = 1;
+ }
+ }
+
+ return res;
#endif
}
int sangoma_span_chan_toif(int span, int chan, char *interface_name)
{
- sprintf(interface_name, "s%ic%i", span, chan);
+ sprintf(interface_name,"s%ic%i",span,chan);
return 0;
}
int sangoma_interface_toi(char *interface_name, int *span, int *chan)
{
- char *p = NULL, *sp = NULL, *ch = NULL;
+ char *p=NULL, *sp = NULL, *ch = NULL;
int ret = 0;
char data[FNAME_LEN];
}
}
- if (ch && sp) {
+ if(ch && sp) {
*span = atoi(sp);
*chan = atoi(ch);
ret = 1;
}
}
- if (ch && sp) {
+ if(ch && sp) {
*span = atoi(sp);
*chan = atoi(ch);
ret = 1;
return ret;
}
-sng_fd_t sangoma_open_tdmapi_span_chan(int span, int chan)
+sng_fd_t sangoma_open_tdmapi_span_chan(int span, int chan)
{
- char fname[FNAME_LEN];
+ char fname[FNAME_LEN];
#if defined(WIN32)
//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);
+ // Subtract 1 from 'chan'.
+ _snprintf(fname , FNAME_LEN, "\\\\.\\WANPIPE%d_IF%d", span, chan - 1);
//prn(verbose, "Opening device: %s...\n", fname);
- return 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);
+ return 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
+ );
#else
- int fd = -1;
+ int fd=-1;
- sprintf(fname, "/dev/wptdm_s%dc%d", span, chan);
+ sprintf(fname,"/dev/wptdm_s%dc%d",span,chan);
fd = open(fname, O_RDWR);
- return fd;
+ return fd;
#endif
-}
+}
-sng_fd_t sangoma_create_socket_by_name(char *device, char *card)
+sng_fd_t sangoma_create_socket_by_name(char *device, char *card)
{
- int span, chan;
- sangoma_interface_toi(device, &span, &chan);
-
- return sangoma_open_tdmapi_span_chan(span, chan);
+ int span,chan;
+ sangoma_interface_toi(device,&span,&chan);
+
+ return sangoma_open_tdmapi_span_chan(span,chan);
}
-
-sng_fd_t sangoma_open_tdmapi_span(int span)
+
+sng_fd_t sangoma_open_tdmapi_span(int span)
{
- int i = 0;
+ int i=0;
#if defined(WIN32)
sng_fd_t fd = INVALID_HANDLE_VALUE;
- for (i = 1; i < 32; i++) {
- if ((fd = sangoma_open_tdmapi_span_chan(span, i)) == INVALID_HANDLE_VALUE) {
+ for(i = 1; i < 32; i++){
+ if((fd = sangoma_open_tdmapi_span_chan(span, i)) == INVALID_HANDLE_VALUE){
//prn(verbose, "Span: %d, chan: %d: is not running, consider 'busy'\n",
- // span, i);
+ // span, i);
continue;
}
+
//get the open handle counter
- wan_udp.wan_udphdr_command = GET_OPEN_HANDLES_COUNTER;
+ wan_udp.wan_udphdr_command = GET_OPEN_HANDLES_COUNTER;
wan_udp.wan_udphdr_data_len = 0;
DoManagementCommand(fd, &wan_udp);
- if (wan_udp.wan_udphdr_return_code) {
- prn(1, "Error: command GET_OPEN_HANDLES_COUNTER failed! Span: %d, chan: %d\n", span, i);
+ if(wan_udp.wan_udphdr_return_code){
+ prn(1, "Error: command GET_OPEN_HANDLES_COUNTER failed! Span: %d, chan: %d\n",
+ span, i);
//don't forget to close!! otherwize counter will stay incremented.
sangoma_socket_close(&fd);
continue;
}
+
//prn(verbose, "open handles counter: %d\n", *(int*)&wan_udp.wan_udphdr_data[0]);
- if (*(int *) &wan_udp.wan_udphdr_data[0] == 1) {
+ if(*(int*)&wan_udp.wan_udphdr_data[0] == 1){
//this is the only process using this chan/span, so it is 'free'
//prn(verbose, "Found 'free' Span: %d, chan: %d\n",span, i);
break;
}
//don't forget to close!! otherwize counter will stay incremented.
sangoma_socket_close(&fd);
- } //for()
+ }//for()
#else
- unsigned char fname[FNAME_LEN];
- int fd = 0;
- for (i = 1; i < 32; i++) {
- sprintf(fname, "/dev/wptdm_s%dc%d", span, i);
+ unsigned char fname[FNAME_LEN];
+ int fd=0;
+ for (i=1;i<32;i++){
+ sprintf(fname,"/dev/wptdm_s%dc%d",span,i);
fd = open(fname, O_RDWR);
- if (fd < 0) {
- continue;
+ if (fd < 0){
+ continue;
}
break;
}
-#endif
- return fd;
-}
+#endif
+ return fd;
+}
int sangoma_readmsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, int datalen, int flag)
{
- int rx_len = 0;
+ int rx_len=0;
#if defined(WIN32)
- 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;
+ 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;
- if (hdrlen != sizeof(wp_tdm_api_rx_hdr_t)) {
+ if(hdrlen != sizeof(wp_tdm_api_rx_hdr_t)){
//error
prn(1, "Error: sangoma_readmsg_tdm(): invalid size of user's 'header buffer'.\
Should be 'sizeof(wp_tdm_api_rx_hdr_t)'.\n");
return -1;
}
- if (DoReadCommand(fd, &rx_data)) {
+ if(DoReadCommand(fd, &rx_data) ){
//error
prn(1, "Error: DoReadCommand() failed! Check messages log.\n");
return -1;
}
+
//use our special buffer at rxdata to hold received data
pri = &rx_data.api_header;
- tdm_api_rx_hdr = (wp_tdm_api_rx_hdr_t *) rx_data.data;
+ 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) {
+ switch(pri->operation_status)
+ {
case SANG_STATUS_RX_DATA_AVAILABLE:
//prn(verbose, "SANG_STATUS_RX_DATA_AVAILABLE\n");
- if (pri->data_length > datalen) {
- rx_len = 0;
+ if(pri->data_length > datalen){
+ rx_len=0;
break;
}
memcpy(databuf, rx_data.data, pri->data_length);
rx_len = pri->data_length;
//make copy for use with sangoma_tdm_read_event() - indirect access.
- memcpy(&last_tdm_api_event_buffer, tdm_api_rx_hdr, sizeof(wp_tdm_api_rx_hdr_t));
+ memcpy( &last_tdm_api_event_buffer, tdm_api_rx_hdr, sizeof(wp_tdm_api_rx_hdr_t));
break;
default:
- switch (pri->operation_status) {
+ switch(pri->operation_status)
+ {
case SANG_STATUS_RX_DATA_TIMEOUT:
//no data in READ_CMD_TIMEOUT, try again.
prn(1, "Error: Timeout on read.\n");
default:
prn(1, "Rx:Unknown Operation Status: %d\n", pri->operation_status);
break;
- } //switch()
+ }//switch()
return 0;
- } //switch()
+ }//switch()
#else
struct msghdr msg;
struct iovec iov[2];
- memset(&msg, 0, sizeof(struct msghdr));
+ memset(&msg,0,sizeof(struct msghdr));
- iov[0].iov_len = hdrlen;
- iov[0].iov_base = hdrbuf;
+ iov[0].iov_len=hdrlen;
+ iov[0].iov_base=hdrbuf;
- iov[1].iov_len = datalen;
- iov[1].iov_base = databuf;
+ iov[1].iov_len=datalen;
+ iov[1].iov_base=databuf;
- msg.msg_iovlen = 2;
- msg.msg_iov = iov;
+ msg.msg_iovlen=2;
+ msg.msg_iov=iov;
- rx_len = read(fd, &msg, datalen + hdrlen);
+ rx_len = read(fd,&msg,datalen+hdrlen);
- if (rx_len <= sizeof(wp_tdm_api_rx_hdr_t)) {
+ if (rx_len <= sizeof(wp_tdm_api_rx_hdr_t)){
return -EINVAL;
}
- rx_len -= sizeof(wp_tdm_api_rx_hdr_t);
+ rx_len-=sizeof(wp_tdm_api_rx_hdr_t);
#endif
- return rx_len;
-}
+ return rx_len;
+}
int sangoma_writemsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, unsigned short datalen, int flag)
{
int bsent;
#if defined(WIN32)
- static TX_DATA_STRUCT local_tx_data;
- api_header_t *pri;
+ static TX_DATA_STRUCT local_tx_data;
+ api_header_t *pri;
pri = &local_tx_data.api_header;
memcpy(local_tx_data.data, databuf, pri->data_length);
//queue data for transmission
- if (DoWriteCommand(fd, &local_tx_data)) {
+ if( DoWriteCommand(fd, &local_tx_data)){
//error
prn(1, "Error: DoWriteCommand() failed!! Check messages log.\n");
return -1;
}
- bsent = 0;
+ bsent=0;
//check that frame was transmitted
- switch (local_tx_data.api_header.operation_status) {
+ switch(local_tx_data.api_header.operation_status)
+ {
case SANG_STATUS_SUCCESS:
bsent = datalen;
break;
-
+
case SANG_STATUS_TX_TIMEOUT:
//error
prn(1, "****** Error: SANG_STATUS_TX_TIMEOUT ******\n");
//Check messages log or look at statistics.
break;
-
+
case SANG_STATUS_TX_DATA_TOO_LONG:
//Attempt to transmit data longer than the pre-configured maximum.
//Maximum length is set in 'Interface Properties',
//in the 'Device Manager'.
prn(1, "****** SANG_STATUS_TX_DATA_TOO_LONG ******\n");
break;
-
+
case SANG_STATUS_TX_DATA_TOO_SHORT:
//Minimum is 1 byte for Primary port,
- // 2 bytes for Secondary port
+ // 2 bytes for Secondary port
prn(1, "****** SANG_STATUS_TX_DATA_TOO_SHORT ******\n");
break;
break;
default:
- prn(1, "Unknown return code (0x%X) on transmission!\n", local_tx_data.api_header.operation_status);
+ prn(1, "Unknown return code (0x%X) on transmission!\n",
+ local_tx_data.api_header.operation_status);
break;
- } //switch()
+ }//switch()
#else
struct msghdr msg;
struct iovec iov[2];
- memset(&msg, 0, sizeof(struct msghdr));
+ memset(&msg,0,sizeof(struct msghdr));
- iov[0].iov_len = hdrlen;
- iov[0].iov_base = hdrbuf;
+ iov[0].iov_len=hdrlen;
+ iov[0].iov_base=hdrbuf;
- iov[1].iov_len = datalen;
- iov[1].iov_base = databuf;
+ iov[1].iov_len=datalen;
+ iov[1].iov_base=databuf;
- msg.msg_iovlen = 2;
- msg.msg_iov = iov;
+ 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);
+ bsent = write(fd,&msg,datalen+hdrlen);
+ if (bsent > 0){
+ bsent-=sizeof(wp_tdm_api_tx_hdr_t);
}
#endif
return bsent;
* Execute TDM command
*
*/
-static int sangoma_tdm_cmd_exec(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+static int sangoma_tdm_cmd_exec(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
#if defined(WIN32)
err = tdmv_api_ioctl(fd, &tdm_api->wp_tdm_cmd);
#else
- err = ioctl(fd, SIOC_WANPIPE_TDM_API, &tdm_api->wp_tdm_cmd);
- if (err < 0) {
+ err = ioctl(fd,SIOC_WANPIPE_TDM_API,&tdm_api->wp_tdm_cmd);
+ if (err < 0){
char tmp[50];
- sprintf(tmp, "TDM API: CMD: %i\n", tdm_api->wp_tdm_cmd.cmd);
+ sprintf(tmp,"TDM API: CMD: %i\n",tdm_api->wp_tdm_cmd.cmd);
perror(tmp);
return -1;
}
* Get Full TDM API configuration per channel
*
*/
-int sangoma_get_full_cfg(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_get_full_cfg(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_FULL_CFG;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
printf("TDM API CFG:\n");
- printf("\thw_tdm_coding:\t%d\n", tdm_api->wp_tdm_cmd.hw_tdm_coding);
- printf("\tusr_mtu_mru:\t%d\n", tdm_api->wp_tdm_cmd.hw_mtu_mru);
- printf("\tusr_period:\t%d\n", tdm_api->wp_tdm_cmd.usr_period);
- printf("\ttdm_codec:\t%d\n", tdm_api->wp_tdm_cmd.tdm_codec);
- printf("\tpower_level:\t%d\n", tdm_api->wp_tdm_cmd.power_level);
- printf("\trx_disable:\t%d\n", tdm_api->wp_tdm_cmd.rx_disable);
- printf("\ttx_disable:\t%d\n", tdm_api->wp_tdm_cmd.tx_disable);
- printf("\tusr_mtu_mru:\t%d\n", tdm_api->wp_tdm_cmd.usr_mtu_mru);
- printf("\tidle flag:\t0x%02X\n", tdm_api->wp_tdm_cmd.idle_flag);
- printf("\tfe alarms:\t0x%02X\n", tdm_api->wp_tdm_cmd.fe_alarms);
-
- printf("\trx pkt\t%d\ttx pkt\t%d\n", tdm_api->wp_tdm_cmd.stats.rx_packets, tdm_api->wp_tdm_cmd.stats.tx_packets);
- printf("\trx err\t%d\ttx err\t%d\n", tdm_api->wp_tdm_cmd.stats.rx_errors, tdm_api->wp_tdm_cmd.stats.tx_errors);
+ printf("\thw_tdm_coding:\t%d\n",tdm_api->wp_tdm_cmd.hw_tdm_coding);
+ printf("\tusr_mtu_mru:\t%d\n",tdm_api->wp_tdm_cmd.hw_mtu_mru);
+ printf("\tusr_period:\t%d\n",tdm_api->wp_tdm_cmd.usr_period);
+ printf("\ttdm_codec:\t%d\n",tdm_api->wp_tdm_cmd.tdm_codec);
+ printf("\tpower_level:\t%d\n",tdm_api->wp_tdm_cmd.power_level);
+ printf("\trx_disable:\t%d\n",tdm_api->wp_tdm_cmd.rx_disable);
+ printf("\ttx_disable:\t%d\n",tdm_api->wp_tdm_cmd.tx_disable);
+ printf("\tusr_mtu_mru:\t%d\n",tdm_api->wp_tdm_cmd.usr_mtu_mru);
+ printf("\tidle flag:\t0x%02X\n",tdm_api->wp_tdm_cmd.idle_flag);
+ printf("\tfe alarms:\t0x%02X\n",tdm_api->wp_tdm_cmd.fe_alarms);
+
+ printf("\trx pkt\t%d\ttx pkt\t%d\n",tdm_api->wp_tdm_cmd.stats.rx_packets,
+ tdm_api->wp_tdm_cmd.stats.tx_packets);
+ printf("\trx err\t%d\ttx err\t%d\n",
+ tdm_api->wp_tdm_cmd.stats.rx_errors,
+ tdm_api->wp_tdm_cmd.stats.tx_errors);
#ifndef __WINDOWS__
- printf("\trx ovr\t%d\ttx idl\t%d\n", tdm_api->wp_tdm_cmd.stats.rx_fifo_errors, tdm_api->wp_tdm_cmd.stats.tx_carrier_errors);
-#endif
-
+ printf("\trx ovr\t%d\ttx idl\t%d\n",
+ tdm_api->wp_tdm_cmd.stats.rx_fifo_errors,
+ tdm_api->wp_tdm_cmd.stats.tx_carrier_errors);
+#endif
+
return 0;
}
* }
*
*/
-int sangoma_tdm_set_codec(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int codec)
+int sangoma_tdm_set_codec(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int codec)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_CODEC;
tdm_api->wp_tdm_cmd.tdm_codec = codec;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
return err;
}
* }
*
*/
-int sangoma_tdm_get_codec(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_get_codec(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_CODEC;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
- return tdm_api->wp_tdm_cmd.tdm_codec;
+ return tdm_api->wp_tdm_cmd.tdm_codec;
}
* 10,20,30,40,50 ms
*
*/
-int sangoma_tdm_set_usr_period(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int period)
+int sangoma_tdm_set_usr_period(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int period)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_USR_PERIOD;
tdm_api->wp_tdm_cmd.usr_period = period;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
return err;
}
* 10,20,30,40,50 ms
*
*/
-int sangoma_tdm_get_usr_period(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_get_usr_period(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_USR_PERIOD;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
* Coding Format will be ULAW/ALAW based on T1/E1
*/
-int sangoma_tdm_get_hw_coding(int fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_get_hw_coding(int fd, wanpipe_tdm_api_t *tdm_api)
{
- int err;
- tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_HW_CODING;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
- return err;
- }
- return tdm_api->wp_tdm_cmd.hw_tdm_coding;
+ int err;
+ tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_HW_CODING;
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
+ return err;
+ }
+ return tdm_api->wp_tdm_cmd.hw_tdm_coding;
}
* The USER MTU/MRU values will change each time a PERIOD
* or CODEC is adjusted.
*/
-int sangoma_tdm_get_usr_mtu_mru(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_get_usr_mtu_mru(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_USR_MTU_MRU;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
* This option is not implemented yet
*
*/
-int sangoma_tdm_set_power_level(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int power)
+int sangoma_tdm_set_power_level(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int power)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_SET_POWER_LEVEL;
tdm_api->wp_tdm_cmd.power_level = power;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
return err;
}
* This option is not implemented yet
*
*/
-int sangoma_tdm_get_power_level(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_get_power_level(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_POWER_LEVEL;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return tdm_api->wp_tdm_cmd.power_level;
}
-int sangoma_tdm_flush_bufs(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_flush_bufs(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
#if 0
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_FLUSH_BUFFERS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
#endif
return 0;
}
-int sangoma_tdm_enable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int poll_in_sec)
-{
-
+int sangoma_tdm_enable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int poll_in_sec) {
+
int err;
-
+
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_ENABLE_RBS_EVENTS;
- tdm_api->wp_tdm_cmd.rbs_poll = poll_in_sec;
-
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ tdm_api->wp_tdm_cmd.rbs_poll=poll_in_sec;
+
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
}
-int sangoma_tdm_disable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
-{
+int sangoma_tdm_disable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api) {
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_DISABLE_RBS_EVENTS;
-
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return 0;
}
-int sangoma_tdm_write_rbs(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, unsigned char rbs)
+int sangoma_tdm_write_rbs(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, unsigned char rbs)
{
-
+
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_WRITE_RBS_BITS;
- tdm_api->wp_tdm_cmd.rbs_tx_bits = rbs;
-
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ tdm_api->wp_tdm_cmd.rbs_tx_bits=rbs;
+
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return 0;
-}
+}
-int sangoma_tdm_read_event(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_read_event(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
wp_tdm_api_rx_hdr_t *rx_event;
-#if defined(WIN32)
+#if defined(WIN32)
rx_event = &last_tdm_api_event_buffer;
#else
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_READ_EVENT;
-
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
rx_event = &tdm_api->wp_tdm_cmd.event;
#endif
- switch (rx_event->wp_tdm_api_event_type) {
-
+ switch (rx_event->wp_tdm_api_event_type){
+
case WP_TDM_EVENT_RBS:
- printf("%d: GOT RBS EVENT %p\n", (int) fd, tdm_api->wp_tdm_event.wp_rbs_event);
+ printf("%d: GOT RBS EVENT %p\n",(int)fd,tdm_api->wp_tdm_event.wp_rbs_event);
if (tdm_api->wp_tdm_event.wp_rbs_event) {
- tdm_api->wp_tdm_event.wp_rbs_event(fd, rx_event->wp_tdm_api_event_rbs_rx_bits);
+ tdm_api->wp_tdm_event.wp_rbs_event(fd,rx_event->wp_tdm_api_event_rbs_rx_bits);
}
-
+
break;
-
+
case WP_TDM_EVENT_DTMF:
- printf("%d: GOT DTMF EVENT\n", (int) fd);
+ printf("%d: GOT DTMF EVENT\n",(int)fd);
if (tdm_api->wp_tdm_event.wp_dtmf_event) {
tdm_api->wp_tdm_event.wp_dtmf_event(fd,
- rx_event->wp_tdm_api_event_dtmf_digit,
- rx_event->wp_tdm_api_event_dtmf_type, rx_event->wp_tdm_api_event_dtmf_port);
+ rx_event->wp_tdm_api_event_dtmf_digit,
+ rx_event->wp_tdm_api_event_dtmf_type,
+ rx_event->wp_tdm_api_event_dtmf_port);
}
break;
-
+
case WP_TDM_EVENT_RXHOOK:
- printf("%d: GOT RXHOOK EVENT\n", (int) fd);
+ printf("%d: GOT RXHOOK EVENT\n",(int)fd);
if (tdm_api->wp_tdm_event.wp_rxhook_event) {
- tdm_api->wp_tdm_event.wp_rxhook_event(fd, rx_event->wp_tdm_api_event_rxhook_state);
+ tdm_api->wp_tdm_event.wp_rxhook_event(fd,
+ rx_event->wp_tdm_api_event_rxhook_state);
}
break;
case WP_TDM_EVENT_RING_DETECT:
- printf("%d: GOT RXRING EVENT\n", (int) fd);
+ printf("%d: GOT RXRING EVENT\n",(int)fd);
if (tdm_api->wp_tdm_event.wp_rxring_event) {
- tdm_api->wp_tdm_event.wp_rxring_event(fd, rx_event->wp_tdm_api_event_ring_state);
+ tdm_api->wp_tdm_event.wp_rxring_event(fd,
+ rx_event->wp_tdm_api_event_ring_state);
}
break;
case WP_TDM_EVENT_RING_TRIP:
- printf("%d: GOT RING TRIP EVENT\n", (int) fd);
+ printf("%d: GOT RING TRIP EVENT\n",(int)fd);
if (tdm_api->wp_tdm_event.wp_ringtrip_event) {
- tdm_api->wp_tdm_event.wp_ringtrip_event(fd, rx_event->wp_tdm_api_event_ring_state);
+ tdm_api->wp_tdm_event.wp_ringtrip_event(fd,
+ rx_event->wp_tdm_api_event_ring_state);
}
break;
case WP_TDM_EVENT_FE_ALARM:
- printf("%d: GOT FE ALARMS EVENT %i\n", (int) fd, rx_event->wp_tdm_api_event_fe_alarm);
+ printf("%d: GOT FE ALARMS EVENT %i\n",(int)fd,
+ rx_event->wp_tdm_api_event_fe_alarm);
if (tdm_api->wp_tdm_event.wp_fe_alarm_event) {
- tdm_api->wp_tdm_event.wp_fe_alarm_event(fd, rx_event->wp_tdm_api_event_fe_alarm);
- }
-
+ tdm_api->wp_tdm_event.wp_fe_alarm_event(fd,
+ rx_event->wp_tdm_api_event_fe_alarm);
+ }
+
default:
- printf("%d: Unknown TDM event!", (int) fd);
+ printf("%d: Unknown TDM event!", (int)fd);
break;
}
-
+
return 0;
-}
+}
-int sangoma_tdm_enable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_enable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
-
+
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_ENABLE_DTMF_EVENTS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return 0;
}
-int sangoma_tdm_disable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_disable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_DISABLE_DTMF_EVENTS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return 0;
}
-int sangoma_tdm_enable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_enable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
-
+
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_ENABLE_RM_DTMF_EVENTS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return 0;
}
-int sangoma_tdm_disable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_disable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_DISABLE_RM_DTMF_EVENTS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return 0;
}
-int sangoma_tdm_enable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_enable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_ENABLE_RXHOOK_EVENTS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return 0;
}
-int sangoma_tdm_disable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_disable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_DISABLE_RXHOOK_EVENTS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
* GET Front End Alarms
*
*/
-int sangoma_tdm_get_fe_alarms(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api)
+int sangoma_tdm_get_fe_alarms(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api)
{
int err;
tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_GET_FE_ALARMS;
- err = sangoma_tdm_cmd_exec(fd, tdm_api);
- if (err) {
+ err=sangoma_tdm_cmd_exec(fd,tdm_api);
+ if (err){
return err;
}
return tdm_api->wp_tdm_cmd.fe_alarms;
-}
+}
#endif /* WANPIPE_TDM_API */
#ifdef WANPIPE_TDM_API
#include <wanpipe_tdm_api.h> //for TDMV API
#endif
-#include <sang_status_defines.h> //return codes
+#include <sang_status_defines.h>//return codes
#include <sang_api.h> //for IOCTL codes
#include <sdla_te1_pmc.h> //RBS definitions
#include <sdla_te1.h> //TE1 macros
/* Open Span/Chan devices
* open_tdmapi_span_chan: open device based on span chan values
* sangoma_open_tdmapi_span: open first available device on span
- */
+ */
sng_fd_t sangoma_open_tdmapi_span_chan(int span, int chan);
sng_fd_t sangoma_open_tdmapi_span(int span);
/* Device Rx/Tx functions
* writemsg_tdm: tx header + data from separate buffers
* readmsg_tdm: rx header + data to separate buffers
- */
-int sangoma_writemsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, unsigned short datalen, int flag);
-int sangoma_readmsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen, void *databuf, int datalen, int flag);
+ */
+int sangoma_writemsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen,
+ void *databuf, unsigned short datalen, int flag);
+int sangoma_readmsg_tdm(sng_fd_t fd, void *hdrbuf, int hdrlen,
+ void *databuf, int datalen, int flag);
#define sangoma_readmsg_socket sangoma_readmsg_tdm
#define sangoma_sendmsg_socket sangoma_writemsg_tdm
#ifdef WANPIPE_TDM_API
-void sangoma_socket_close(sng_fd_t * sp);
+void sangoma_socket_close(sng_fd_t *sp);
int sangoma_socket_waitfor(sng_fd_t fd, int timeout, int flags);
/* Get Full TDM API configuration per chan */
-int sangoma_get_full_cfg(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_get_full_cfg(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* Get/Set TDM Codec per chan */
-int sangoma_tdm_set_codec(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int codec);
-int sangoma_tdm_get_codec(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_set_codec(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int codec);
+int sangoma_tdm_get_codec(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* Get/Set USR Tx/Rx Period in milliseconds */
-int sangoma_tdm_set_usr_period(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int period);
-int sangoma_tdm_get_usr_period(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_set_usr_period(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int period);
+int sangoma_tdm_get_usr_period(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* Get user MTU/MRU values in bytes */
-int sangoma_tdm_get_usr_mtu_mru(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_get_usr_mtu_mru(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* Not supported yet */
-int sangoma_tdm_set_power_level(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int power);
-int sangoma_tdm_get_power_level(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_set_power_level(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int power);
+int sangoma_tdm_get_power_level(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* Flush buffers from current channel */
-int sangoma_tdm_flush_bufs(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_flush_bufs(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
-int sangoma_tdm_enable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, int poll_in_sec);
-int sangoma_tdm_disable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_enable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, int poll_in_sec);
+int sangoma_tdm_disable_rbs_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
-int sangoma_tdm_write_rbs(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api, unsigned char rbs);
+int sangoma_tdm_write_rbs(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api, unsigned char rbs);
-int sangoma_tdm_read_event(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_read_event(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* DTMF Detection on Octasic chip */
-int sangoma_tdm_enable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
-int sangoma_tdm_disable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_enable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
+int sangoma_tdm_disable_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* DTMF Detection on A200 (SLIC) chip */
-int sangoma_tdm_enable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
-int sangoma_tdm_disable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_enable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
+int sangoma_tdm_disable_rm_dtmf_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
/* On/Off hook events on A200 (Analog) card */
-int sangoma_tdm_enable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
-int sangoma_tdm_disable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_enable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
+int sangoma_tdm_disable_rxhook_events(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
-int sangoma_tdm_get_fe_alarms(sng_fd_t fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_get_fe_alarms(sng_fd_t fd, wanpipe_tdm_api_t *tdm_api);
#ifndef LIBSANGOMA_GET_HWCODING
#define LIBSANGOMA_GET_HWCODING 1
#endif
-int sangoma_tdm_get_hw_coding(int fd, wanpipe_tdm_api_t * tdm_api);
+int sangoma_tdm_get_hw_coding(int fd, wanpipe_tdm_api_t *tdm_api);
-#endif /* WANPIPE_TDM_API */
+#endif /* WANPIPE_TDM_API */
#endif
char map[SANGOMA_MAX_CHAN_PER_SPAN][SWITCH_UUID_FORMATTED_LENGTH + 1];
};
-unsigned int txseq = 0;
-unsigned int rxseq = 0;
+unsigned int txseq=0;
+unsigned int rxseq=0;
#define SETUP_LEN CORE_MAX_CHAN_PER_SPAN*CORE_MAX_SPANS+1
typedef struct ss7boost_handle ss7boost_handle_t;
-static int isup_exec_command(ss7boost_handle_t * ss7boost_handle, int span, int chan, int id, int cmd, int cause);
+static int isup_exec_command(ss7boost_handle_t *ss7boost_handle, int span, int chan, int id, int cmd, int cause);
static struct {
int debug;
-static int local_sangoma_tdm_read_event(sng_fd_t fd, wp_tdm_api_rx_hdr_t * rx_event)
+static int local_sangoma_tdm_read_event(sng_fd_t fd, wp_tdm_api_rx_hdr_t *rx_event)
{
wanpipe_tdm_api_t tdm_api[1];
-
+
#if defined(WIN32)
- rx_event = &last_tdm_api_event_buffer;
+ rx_event = &last_tdm_api_event_buffer;
#else
- int err;
+ int err;
- tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_READ_EVENT;
+ tdm_api->wp_tdm_cmd.cmd = SIOC_WP_TDM_READ_EVENT;
- if ((err = sangoma_tdm_cmd_exec(fd, tdm_api))) {
- return err;
- }
+ if ((err = sangoma_tdm_cmd_exec(fd, tdm_api))) {
+ return err;
+ }
- rx_event = &tdm_api->wp_tdm_cmd.event;
+ rx_event = &tdm_api->wp_tdm_cmd.event;
#endif
return 0;
}
-static int analog_set_state(analog_channel_t * alc, analog_state_t state)
+static int analog_set_state(analog_channel_t *alc, analog_state_t state)
{
alc->state = state;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Changing State to %d\n", state);
}
-static void analog_check_state(analog_channel_t * alc)
+static void analog_check_state(analog_channel_t *alc)
{
wanpipe_tdm_api_t tdm_api;
- switch (alc->state) {
+ switch(alc->state) {
case ANALOG_STATE_DOWN:
sangoma_tdm_enable_rxhook_events(alc->sock->fd, &tdm_api);
analog_set_state(alc, ANALOG_STATE_ONHOOK);
}
}
-static void analog_parse_event(analog_channel_t * alc)
+static void analog_parse_event(analog_channel_t *alc)
{
wp_tdm_api_rx_hdr_t rx_event;
int err = local_sangoma_tdm_read_event(alc->sock->fd, &rx_event);
-
+
if (err < 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error reading event!\n");
return;
}
-static void *SWITCH_THREAD_FUNC fxs_thread_run(switch_thread_t * thread, void *obj)
+static void *SWITCH_THREAD_FUNC fxs_thread_run(switch_thread_t *thread, void *obj)
{
- for (;;) {
+ for(;;) {
int i = 0, sel_on = -1;
fd_set oob;
FD_ZERO(&oob);
-
- for (i = 0; i < globals.fxs_index; i++) {
+
+ for(i = 0; i < globals.fxs_index; i++) {
int fd;
assert(FXS_ANALOG_CHANNELS[i]);
assert(FXS_ANALOG_CHANNELS[i]->sock);
fd = FXS_ANALOG_CHANNELS[i]->sock->fd;
-
+
analog_check_state(FXS_ANALOG_CHANNELS[i]);
FD_SET(fd, &oob);
if (sel_on > -1) {
if (select(++sel_on, NULL, NULL, &oob, NULL)) {
- for (i = 0; i < globals.fxs_index; i++) {
+ for(i = 0; i < globals.fxs_index; i++) {
int fd = FXS_ANALOG_CHANNELS[i]->sock->fd;
if (FD_ISSET(fd, &oob)) {
analog_parse_event(FXS_ANALOG_CHANNELS[i]);
}
-static int wp_close(private_object_t * tech_pvt)
+static int wp_close(private_object_t *tech_pvt)
{
int ret = 0;
ret = 1;
}
switch_mutex_unlock(globals.hash_mutex);
-
+
return ret;
}
-static wpsock_t *wp_open(private_object_t * tech_pvt, int span, int chan)
+static wpsock_t *wp_open(private_object_t *tech_pvt, int span, int chan)
{
sng_fd_t fd;
wpsock_t *sock;
char name[25];
-
+
snprintf(name, sizeof(name), "s%dc%d", span, chan);
switch_mutex_lock(globals.hash_mutex);
wpsock_t *sock;
sng_fd_t fd;
char name[25];
-
+
snprintf(name, sizeof(name), "s%dc%d", span, chan);
switch_mutex_lock(globals.hash_mutex);
sangoma_socket_close(&fd);
return 0;
}
-
+
return -1;
}
if (!strcasecmp(dp, "local"))
return PRI_LOCAL_ISDN;
if (!strcasecmp(dp, "private"))
- return PRI_PRIVATE;
+ return PRI_PRIVATE;
if (!strcasecmp(dp, "unknown"))
return PRI_UNKNOWN;
static switch_status_t wanpipe_on_hangup(switch_core_session_t *session);
static switch_status_t wanpipe_on_loopback(switch_core_session_t *session);
static switch_status_t wanpipe_on_transmit(switch_core_session_t *session);
-static switch_call_cause_t wanpipe_outgoing_channel(switch_core_session_t *session,
- switch_caller_profile_t *outbound_profile,
+static switch_call_cause_t wanpipe_outgoing_channel(switch_core_session_t *session, switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool);
-static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id);
-static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id);
-static int on_info(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent);
-static int on_hangup(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent);
-static int on_ring(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent);
+static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout,
+ switch_io_flag_t flags, int stream_id);
+static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout,
+ switch_io_flag_t flags, int stream_id);
+static int on_info(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent);
+static int on_hangup(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent);
+static int on_ring(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent);
static int check_flags(struct sangoma_pri *spri);
-static int on_restart(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent);
-static int on_anything(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent);
-static void *SWITCH_THREAD_FUNC pri_thread_run(switch_thread_t * thread, void *obj);
+static int on_restart(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent);
+static int on_anything(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent);
+static void *SWITCH_THREAD_FUNC pri_thread_run(switch_thread_t *thread, void *obj);
static switch_status_t config_wanpipe(int reload);
-static switch_status_t wanpipe_codec_init(private_object_t * tech_pvt)
+static switch_status_t wanpipe_codec_init(private_object_t *tech_pvt)
{
int err = 0;
- wanpipe_tdm_api_t tdm_api = { {0} };
+ wanpipe_tdm_api_t tdm_api = {{0}};
unsigned int rate = 8000;
switch_channel_t *channel = NULL;
assert(channel != NULL);
err = sangoma_tdm_set_codec(tech_pvt->wpsock->fd, &tdm_api, WP_SLINEAR);
-
+
sangoma_tdm_set_usr_period(tech_pvt->wpsock->fd, &tdm_api, globals.samples_per_frame / 8);
tech_pvt->frame_size = sangoma_tdm_get_usr_mtu_mru(tech_pvt->wpsock->fd, &tdm_api);
if (switch_core_codec_init
- (&tech_pvt->read_codec, "L16", NULL, rate, globals.samples_per_frame / 8, 1,
- SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
+ (&tech_pvt->read_codec, "L16", NULL, rate, globals.samples_per_frame / 8, 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
+ switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s Cannot set read codec\n", switch_channel_get_name(channel));
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
}
if (switch_core_codec_init
- (&tech_pvt->write_codec, "L16", NULL, rate, globals.samples_per_frame / 8, 1,
- SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL, switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
+ (&tech_pvt->write_codec, "L16", NULL, rate, globals.samples_per_frame / 8, 1, SWITCH_CODEC_FLAG_ENCODE | SWITCH_CODEC_FLAG_DECODE, NULL,
+ switch_core_session_get_pool(tech_pvt->session)) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s Cannot set read codec\n", switch_channel_get_name(channel));
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return SWITCH_STATUS_FALSE;
switch_core_session_set_read_codec(tech_pvt->session, &tech_pvt->read_codec);
switch_core_session_set_write_codec(tech_pvt->session, &tech_pvt->write_codec);
-#ifdef DOTRACE
- tech_pvt->fd = open("/tmp/wp-in.raw", O_WRONLY | O_TRUNC | O_CREAT);
- tech_pvt->fd2 = open("/tmp/wp-out.raw", O_WRONLY | O_TRUNC | O_CREAT);
+#ifdef DOTRACE
+ tech_pvt->fd = open("/tmp/wp-in.raw", O_WRONLY | O_TRUNC | O_CREAT);
+ tech_pvt->fd2 = open("/tmp/wp-out.raw", O_WRONLY | O_TRUNC | O_CREAT);
#endif
/* Setup artificial DTMF stuff */
memset(&tech_pvt->tone_session, 0, sizeof(tech_pvt->tone_session));
teletone_init_session(&tech_pvt->tone_session, 1024, NULL, NULL);
-
+
if (globals.debug) {
tech_pvt->tone_session.debug = globals.debug;
tech_pvt->tone_session.debug_stream = stdout;
}
-
+
tech_pvt->tone_session.rate = rate;
tech_pvt->tone_session.duration = globals.dtmf_on * (tech_pvt->tone_session.rate / 1000);
tech_pvt->tone_session.wait = globals.dtmf_off * (tech_pvt->tone_session.rate / 1000);
-
- teletone_dtmf_detect_init(&tech_pvt->dtmf_detect, rate);
+
+ teletone_dtmf_detect_init (&tech_pvt->dtmf_detect, rate);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Audio init %s\n", switch_channel_get_name(channel));
switch_set_flag(tech_pvt, TFLAG_CODEC);
tech_pvt->read_frame.data = tech_pvt->databuf;
- if (tech_pvt->ss7boost_handle) {
+ if (tech_pvt->ss7boost_handle) {
if (switch_channel_test_flag(channel, CF_OUTBOUND)) {
ss7boost_client_event_t event;
event.calling_number_presentation = tech_pvt->boost_pres;
event.trunk_group = tech_pvt->boost_trunk_group;
-
+
switch_mutex_lock(tech_pvt->ss7boost_handle->mutex);
tech_pvt->setup_index = ++tech_pvt->ss7boost_handle->setup_index;
if (tech_pvt->ss7boost_handle->setup_index == SETUP_LEN - 1) {
tech_pvt->ss7boost_handle->setup_index = 0;
}
switch_mutex_unlock(tech_pvt->ss7boost_handle->mutex);
-
+
switch_copy_string(tech_pvt->ss7boost_handle->setup_array[tech_pvt->setup_index],
- switch_core_session_get_uuid(session), sizeof(tech_pvt->ss7boost_handle->setup_array[tech_pvt->setup_index]));
-
-
- ss7boost_client_call_init(&event, tech_pvt->caller_profile->caller_id_number, tech_pvt->caller_profile->destination_number,
- tech_pvt->setup_index);
-
+ switch_core_session_get_uuid(session),
+ sizeof(tech_pvt->ss7boost_handle->setup_array[tech_pvt->setup_index]));
+
+
+ ss7boost_client_call_init(&event, tech_pvt->caller_profile->caller_id_number, tech_pvt->caller_profile->destination_number, tech_pvt->setup_index);
+
if (ss7boost_client_connection_write(&tech_pvt->ss7boost_handle->mcon, &event) <= 0) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Critical System Error: Failed to tx on ISUP socket [%s]\n", strerror(errno));
}
-
+
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Call Called Event TG=%d\n", tech_pvt->boost_trunk_group);
goto done;
}
- }
+ }
if ((status = wanpipe_codec_init(tech_pvt)) != SWITCH_STATUS_SUCCESS) {
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return status;
}
-
+
if (switch_test_flag(tech_pvt, TFLAG_NOSIG)) {
switch_channel_mark_answered(channel);
}
- done:
+ done:
/* Move Channel's State Machine to RING */
switch_channel_set_state(channel, CS_RING);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "WANPIPE RING\n");
-
+
return SWITCH_STATUS_SUCCESS;
}
switch_channel_t *channel = NULL;
struct channel_map *chanmap = NULL;
-
+
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
switch_mutex_unlock(tech_pvt->ss7boost_handle->mutex);
if (!switch_test_flag(tech_pvt, TFLAG_BYE)) {
isup_exec_command(tech_pvt->ss7boost_handle,
- tech_pvt->boost_span_number, tech_pvt->boost_chan_number, -1, SIGBOOST_EVENT_CALL_STOPPED, SIGBOOST_RELEASE_CAUSE_NORMAL);
+ tech_pvt->boost_span_number,
+ tech_pvt->boost_chan_number,
+ -1,
+ SIGBOOST_EVENT_CALL_STOPPED,
+ SIGBOOST_RELEASE_CAUSE_NORMAL);
}
} else if (tech_pvt->spri) {
chanmap = tech_pvt->spri->private_info;
switch_mutex_lock(globals.channel_mutex);
*chanmap->map[tech_pvt->callno] = '\0';
switch_mutex_unlock(globals.channel_mutex);
-
+
}
switch_set_flag_locked(tech_pvt, TFLAG_BYE);
teletone_destroy_session(&tech_pvt->tone_session);
switch_buffer_destroy(&tech_pvt->dtmf_buffer);
-
+
return SWITCH_STATUS_SUCCESS;
}
pri_answer(tech_pvt->spri->pri, tech_pvt->call, 0, 1);
}
} else if (tech_pvt->ss7boost_handle) {
- isup_exec_command(tech_pvt->ss7boost_handle, tech_pvt->boost_span_number, tech_pvt->boost_chan_number, -1, SIGBOOST_EVENT_CALL_ANSWERED, 0);
+ isup_exec_command(tech_pvt->ss7boost_handle,
+ tech_pvt->boost_span_number,
+ tech_pvt->boost_chan_number,
+ -1,
+ SIGBOOST_EVENT_CALL_ANSWERED,
+ 0);
}
return SWITCH_STATUS_SUCCESS;
-static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t wanpipe_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout,
+ switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt;
switch_channel_t *channel = NULL;
}
if ((bread = sangoma_readmsg_socket(tech_pvt->wpsock->fd,
- &tech_pvt->hdrframe, sizeof(tech_pvt->hdrframe), bp, sizeof(tech_pvt->databuf) - bytes, 0)) < 0) {
+ &tech_pvt->hdrframe,
+ sizeof(tech_pvt->hdrframe), bp, sizeof(tech_pvt->databuf) - bytes, 0)) < 0) {
if (errno == EBUSY) {
continue;
} else {
tech_pvt->read_frame.datalen = bytes;
tech_pvt->read_frame.samples = bytes / 2;
- teletone_dtmf_detect(&tech_pvt->dtmf_detect, tech_pvt->read_frame.data, tech_pvt->read_frame.samples);
+ teletone_dtmf_detect (&tech_pvt->dtmf_detect, tech_pvt->read_frame.data, tech_pvt->read_frame.samples);
teletone_dtmf_get(&tech_pvt->dtmf_detect, digit_str, sizeof(digit_str));
-
- if (digit_str[0]) {
+
+ if(digit_str[0]) {
switch_channel_queue_dtmf(channel, digit_str);
if (globals.debug) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "DTMF DETECTED: [%s]\n", digit_str);
memset(tech_pvt->read_frame.data, 0, tech_pvt->read_frame.datalen);
tech_pvt->skip_read_frames--;
}
-#ifdef DOTRACE
+
+#ifdef DOTRACE
write(tech_pvt->fd2, tech_pvt->read_frame.data, (int) tech_pvt->read_frame.datalen);
#endif
//printf("read %d\n", tech_pvt->read_frame.datalen);
return SWITCH_STATUS_SUCCESS;
}
-static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
+static switch_status_t wanpipe_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout,
+ switch_io_flag_t flags, int stream_id)
{
private_object_t *tech_pvt;
uint32_t dtmf_blen;
if (tech_pvt->dtmf_buffer && (dtmf_blen = switch_buffer_inuse(tech_pvt->dtmf_buffer))) {
uint32_t len = dtmf_blen > frame->datalen ? frame->datalen : dtmf_blen;
- switch_buffer_read(tech_pvt->dtmf_buffer, tech_pvt->auxbuf, len);
+ switch_buffer_read(tech_pvt->dtmf_buffer, tech_pvt->auxbuf, len);
if (len < frame->datalen) {
uint8_t *data = frame->data;
memcpy(data + len, tech_pvt->auxbuf + len, frame->datalen - len);
}
- data = tech_pvt->auxbuf;
- }
-
+ data= tech_pvt->auxbuf;
+ }
+
if (tech_pvt->skip_write_frames) {
tech_pvt->skip_write_frames--;
return SWITCH_STATUS_SUCCESS;
}
+
#ifdef DOTRACE
write(tech_pvt->fd, data, frame->datalen);
#endif
result = sangoma_sendmsg_socket(tech_pvt->wpsock->fd, &tech_pvt->hdrframe, sizeof(tech_pvt->hdrframe), data, frame->datalen, 0);
-
+
if (result < 0 && errno != EBUSY) {
return SWITCH_STATUS_GENERR;
}
}
}
for (cur = digits; *cur; cur++) {
- if ((wrote = teletone_mux_tones(&tech_pvt->tone_session, &tech_pvt->tone_session.TONES[(int) *cur]))) {
+ if ((wrote = teletone_mux_tones(&tech_pvt->tone_session, &tech_pvt->tone_session.TONES[(int)*cur]))) {
switch_buffer_write(tech_pvt->dtmf_buffer, tech_pvt->tone_session.buffer, wrote * 2);
}
}
tech_pvt->skip_read_frames = 200;
-
+
return status;
}
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
-
+
tech_pvt = (private_object_t *) switch_core_session_get_private(session);
assert(tech_pvt != NULL);
tech_pvt = switch_core_session_get_private(session);
assert(tech_pvt != NULL);
- switch (sig) {
+ switch(sig) {
case SWITCH_SIG_KILL:
switch_clear_flag_locked(tech_pvt, TFLAG_MEDIA);
break;
/*.kill_channel */ wanpipe_kill_channel,
/*.waitfor_read */ NULL,
/*.waitfor_read */ NULL,
- /*.send_dtmf */ wanpipe_send_dtmf,
- /*.receive_message */ wanpipe_receive_message
+ /*.send_dtmf*/ wanpipe_send_dtmf,
+ /*.receive_message*/ wanpipe_receive_message
};
static const switch_state_handler_table_t wanpipe_state_handlers = {
};
-static switch_call_cause_t wanpipe_outgoing_channel(switch_core_session_t *session,
- switch_caller_profile_t *outbound_profile,
+static switch_call_cause_t wanpipe_outgoing_channel(switch_core_session_t *session, switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session, switch_memory_pool_t **pool)
{
char *bchan = NULL;
char *dest;
int ready = 0, is_pri = 0, is_boost = 0, is_raw = 0;
switch_call_cause_t cause = SWITCH_CAUSE_SUCCESS;
-
+
if (!outbound_profile) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Doh! no caller profile\n");
cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
goto error;
}
-
+
*dest++ = '\0';
if (!strcasecmp(protocol, "raw")) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error No SS7BOOST Spans Configured.\n");
}
}
-
+
if (!ready) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot Continue!\n");
cause = SWITCH_CAUSE_NETWORK_OUT_OF_ORDER;
goto error;
}
-
+
caller_profile = switch_caller_profile_clone(*new_session, outbound_profile);
if (is_pri) {
}
switch_set_flag_locked(tech_pvt, TFLAG_NOSIG);
snprintf(name, sizeof(name), "wanpipe/%s/nosig", bchan);
- switch_channel_set_name(channel, name);
+ switch_channel_set_name(channel, name);
switch_channel_set_caller_profile(channel, caller_profile);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid address\n");
if (SPANS[span] && (spri = &SPANS[span]->spri) && switch_test_flag(spri, SANGOMA_PRI_READY)) {
chanmap = spri->private_info;
-
+
if (autochan > 0) {
- for (callno = 1; callno < SANGOMA_MAX_CHAN_PER_SPAN; callno++) {
- if ((SPANS[span]->bchans & (1 << callno)) && !*chanmap->map[callno]) {
+ for(callno = 1; callno < SANGOMA_MAX_CHAN_PER_SPAN; callno++) {
+ if ((SPANS[span]->bchans & (1 << callno)) && ! *chanmap->map[callno]) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Choosing channel s%dc%d\n", span, callno);
goto done;
}
}
callno = 0;
} else if (autochan < 0) {
- for (callno = SANGOMA_MAX_CHAN_PER_SPAN; callno > 0; callno--) {
- if ((SPANS[span]->bchans & (1 << callno)) && !*chanmap->map[callno]) {
+ for(callno = SANGOMA_MAX_CHAN_PER_SPAN; callno > 0; callno--) {
+ if ((SPANS[span]->bchans & (1 << callno)) && ! *chanmap->map[callno]) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Choosing channel s%dc%d\n", span, callno);
goto done;
}
span--;
}
}
- done:
+ done:
switch_mutex_unlock(globals.channel_mutex);
if (!spri || callno == 0 || callno == (SANGOMA_MAX_CHAN_PER_SPAN)) {
cause = SWITCH_CAUSE_SWITCH_CONGESTION;
goto error;
}
-
+
tech_pvt->callno = callno;
-
+
if (spri && (tech_pvt->call = pri_new_call(spri->pri))) {
struct pri_sr *sr;
-
+
snprintf(name, sizeof(name), "wanpipe/pri/s%dc%d/%s", spri->span, callno, caller_profile->destination_number);
- switch_channel_set_name(channel, name);
+ switch_channel_set_name(channel, name);
switch_channel_set_caller_profile(channel, caller_profile);
sr = pri_sr_new();
pri_sr_set_channel(sr, callno, 0, 0);
pri_sr_set_bearer(sr, 0, SPANS[span]->l1);
pri_sr_set_called(sr, caller_profile->destination_number, SPANS[span]->dp, 1);
pri_sr_set_caller(sr,
- caller_profile->caller_id_number, caller_profile->caller_id_name, SPANS[span]->dp,
+ caller_profile->caller_id_number,
+ caller_profile->caller_id_name,
+ SPANS[span]->dp,
PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN);
- pri_sr_set_redirecting(sr, caller_profile->caller_id_number, SPANS[span]->dp, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN,
+ pri_sr_set_redirecting(sr,
+ caller_profile->caller_id_number,
+ SPANS[span]->dp,
+ PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN,
PRI_REDIR_UNCONDITIONAL);
-
- if (pri_setup(spri->pri, tech_pvt->call, sr)) {
+
+ if (pri_setup(spri->pri, tech_pvt->call , sr)) {
switch_core_session_destroy(new_session);
pri_sr_free(sr);
cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER;
goto error;
}
pri_sr_free(sr);
- switch_copy_string(chanmap->map[callno], switch_core_session_get_uuid(*new_session), sizeof(chanmap->map[callno]));
+ switch_copy_string(chanmap->map[callno],
+ switch_core_session_get_uuid(*new_session),
+ sizeof(chanmap->map[callno]));
tech_pvt->spri = spri;
}
} else if (is_boost) {
if ((p = strchr(caller_profile->destination_number, '/'))) {
char *grp = caller_profile->destination_number;
*p = '\0';
- caller_profile->destination_number = p + 1;
- tech_pvt->boost_trunk_group = atoi(grp + 1) - 1;
+ caller_profile->destination_number = p+1;
+ tech_pvt->boost_trunk_group = atoi(grp+1) - 1;
if (tech_pvt->boost_trunk_group < 0) {
tech_pvt->boost_trunk_group = 0;
}
cause = SWITCH_CAUSE_SUCCESS;
}
- error:
+ error:
switch_safe_free(protocol);
return cause;
}
/*event Handlers */
-static int on_info(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_info(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "number is: %s\n", pevent->ring.callednum);
if (strlen(pevent->ring.callednum) > 3) {
return 0;
}
-static int on_hangup(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_hangup(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
struct channel_map *chanmap;
switch_core_session_t *session;
tech_pvt->cause = pevent->hangup.cause;
switch_set_flag_locked(tech_pvt, TFLAG_BYE);
switch_channel_hangup(channel, tech_pvt->cause);
-
+
switch_mutex_lock(globals.channel_mutex);
*chanmap->map[pevent->hangup.channel] = '\0';
switch_mutex_unlock(globals.channel_mutex);
return 0;
}
-static int on_answer(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_answer(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
switch_core_session_t *session;
switch_channel_t *channel;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "-- Answer on channel s%dc%d but it's not in use?\n", spri->span, pevent->answer.channel);
}
-
+
return 0;
}
-static int on_proceed(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_proceed(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
switch_core_session_t *session;
switch_channel_t *channel;
switch_core_session_message_t *msg;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "-- Proceeding on channel s%dc%d\n", spri->span, pevent->proceeding.channel);
-
+
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
-
+
if ((msg = malloc(sizeof(*msg)))) {
memset(msg, 0, sizeof(*msg));
msg->message_id = SWITCH_MESSAGE_INDICATE_PROGRESS;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Memory Error!\n");
}
-
+
switch_core_session_rwunlock(session);
} else {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE,
- "-- Proceeding on channel s%dc%d but it's not in use?\n", spri->span, pevent->proceeding.channel);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "-- Proceeding on channel s%dc%d but it's not in use?\n",
+ spri->span, pevent->proceeding.channel);
}
return 0;
}
-static int on_ringing(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_ringing(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
switch_core_session_t *session;
switch_channel_t *channel;
switch_core_session_rwunlock(session);
} else {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
- "-- Ringing on channel s%dc%d %s but it's not in use?\n", spri->span, pevent->ringing.channel,
- chanmap->map[pevent->ringing.channel]);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "-- Ringing on channel s%dc%d %s but it's not in use?\n", spri->span, pevent->ringing.channel, chanmap->map[pevent->ringing.channel]);
}
return 0;
}
-static int on_ring(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_ring(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
char name[128];
switch_core_session_t *session;
switch_channel_t *channel;
struct channel_map *chanmap;
int ret = 0;
-
+
switch_mutex_lock(globals.channel_mutex);
chanmap = spri->private_info;
if (switch_core_session_locate(chanmap->map[pevent->ring.channel])) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "--Duplicate Ring on channel s%dc%d (ignored)\n", spri->span, pevent->ring.channel);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "--Duplicate Ring on channel s%dc%d (ignored)\n",
+ spri->span, pevent->ring.channel);
switch_core_session_rwunlock(session);
ret = 0;
goto done;
}
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "-- Ring on channel s%dc%d (from %s to %s)\n", spri->span,
- pevent->ring.channel, pevent->ring.callingnum, pevent->ring.callednum);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_NOTICE, "-- Ring on channel s%dc%d (from %s to %s)\n", spri->span, pevent->ring.channel,
+ pevent->ring.callingnum, pevent->ring.callednum);
pri_proceeding(spri->pri, pevent->ring.call, pevent->ring.channel, 0);
}
if ((tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
- NULL, globals.dialplan, "FreeSWITCH", pevent->ring.callingnum,
+ NULL,
+ globals.dialplan,
+ "FreeSWITCH",
+ pevent->ring.callingnum,
#ifdef WIN32
NULL,
#else
pevent->ring.callingani,
#endif
switch_strlen_zero(ani2str) ? NULL : ani2str,
- NULL, NULL, (char *) modname, NULL, pevent->ring.callednum))) {
+ NULL,
+ NULL,
+ (char *)modname,
+ NULL,
+ pevent->ring.callednum))) {
switch_channel_set_caller_profile(channel, tech_pvt->caller_profile);
}
if (!tech_pvt->call) {
tech_pvt->call = pevent->ring.call;
}
-
+
tech_pvt->callno = pevent->ring.channel;
tech_pvt->span = spri->span;
}
switch_copy_string(chanmap->map[pevent->ring.channel], switch_core_session_get_uuid(session), sizeof(chanmap->map[pevent->ring.channel]));
-
+
switch_channel_set_state(channel, CS_INIT);
switch_core_session_thread_launch(session);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot Create new Inbound Channel!\n");
}
- done:
+ done:
switch_mutex_unlock(globals.channel_mutex);
-
+
return ret;
}
return 0;
}
-static int on_restart(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_restart(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
switch_core_session_t *session;
struct channel_map *chanmap;
chanmap = spri->private_info;
-
+
if ((session = switch_core_session_locate(chanmap->map[pevent->restart.channel]))) {
switch_channel_t *channel;
channel = switch_core_session_get_channel(session);
switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING);
switch_core_session_rwunlock(session);
}
-
+
wp_restart(spri->span, pevent->restart.channel);
return 0;
}
-static int on_dchan_up(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_dchan_up(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
if (!switch_test_flag(spri, SANGOMA_PRI_READY)) {
return 0;
}
-static int on_dchan_down(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_dchan_down(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
if (switch_test_flag(spri, SANGOMA_PRI_READY)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Span %d D-Chan DOWN!\n", spri->span);
switch_clear_flag(spri, SANGOMA_PRI_READY);
}
-
+
return 0;
}
-static int on_anything(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event * pevent)
+static int on_anything(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *pevent)
{
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Caught Event span %d %u (%s)\n", spri->span, event_type, sangoma_pri_event_str(event_type));
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Caught Event span %d %u (%s)\n", spri->span, event_type,
+ sangoma_pri_event_str(event_type));
return 0;
}
-static void *SWITCH_THREAD_FUNC pri_thread_run(switch_thread_t * thread, void *obj)
+static void *SWITCH_THREAD_FUNC pri_thread_run(switch_thread_t *thread, void *obj)
{
struct sangoma_pri *spri = obj;
struct channel_map chanmap;
{
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
-
+
switch_threadattr_create(&thd_attr, module_pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
}
-static int isup_exec_command(ss7boost_handle_t * ss7boost_handle, int span, int chan, int id, int cmd, int cause)
+static int isup_exec_command(ss7boost_handle_t *ss7boost_handle, int span, int chan, int id, int cmd, int cause)
{
ss7boost_client_event_t oevent;
int r = 0;
switch_mutex_lock(ss7boost_handle->mutex);
ss7boost_client_event_init(&oevent, cmd, chan, span);
oevent.release_cause = cause;
-
+
if (id >= 0) {
oevent.call_setup_id = id;
}
-
- if (ss7boost_client_connection_write(&ss7boost_handle->mcon, &oevent) <= 0) {
+
+ if (ss7boost_client_connection_write(&ss7boost_handle->mcon, &oevent) <= 0){
r = -1;
}
#ifdef USE_WAITFOR_SOCKET
static int waitfor_socket(int fd, int timeout, int flags)
{
- 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);
-
- if (res > 0) {
- if (pfds[0].revents & POLLIN) {
- res = 1;
- } else if ((pfds[0].revents & POLLERR)) {
- res = -1;
- } else {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "System Error: Poll Event Error no event!\n");
- res = -1;
- }
- }
-
- return res;
+ 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);
+
+ if (res > 0) {
+ if(pfds[0].revents & POLLIN) {
+ res = 1;
+ } else if ((pfds[0].revents & POLLERR)) {
+ res = -1;
+ } else {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR,"System Error: Poll Event Error no event!\n");
+ res = -1;
+ }
+ }
+
+ return res;
}
#endif
}
-static void handle_call_stop(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_call_stop(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
char *uuid = ss7boost_handle->span_chanmap[event->span].map[event->chan];
if ((session = switch_core_session_locate(uuid))) {
private_object_t *tech_pvt;
switch_channel_t *channel;
-
+
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
}
*uuid = '\0';
- }
+ }
- isup_exec_command(ss7boost_handle, event->span, event->chan, -1, SIGBOOST_EVENT_CALL_STOPPED_ACK, 0);
+ isup_exec_command(ss7boost_handle,
+ event->span,
+ event->chan,
+ -1,
+ SIGBOOST_EVENT_CALL_STOPPED_ACK,
+ 0);
}
-static void handle_call_start(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_call_start(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
switch_core_session_t *session = NULL;
switch_channel_t *channel = NULL;
char name[128];
if (*ss7boost_handle->span_chanmap[event->span].map[event->chan]) {
- isup_exec_command(ss7boost_handle, event->span, event->chan, -1, SIGBOOST_EVENT_CALL_START_NACK, SIGBOOST_RELEASE_CAUSE_BUSY);
+ isup_exec_command(ss7boost_handle,
+ event->span,
+ event->chan,
+ -1,
+ SIGBOOST_EVENT_CALL_START_NACK,
+ SIGBOOST_RELEASE_CAUSE_BUSY);
return;
}
-
+
if ((session = switch_core_session_request(&wanpipe_endpoint_interface, NULL))) {
private_object_t *tech_pvt;
switch_mutex_init(&tech_pvt->flag_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(session));
channel = switch_core_session_get_channel(session);
switch_core_session_set_private(session, tech_pvt);
- sprintf(name, "wanpipe/ss7boost/s%dc%d", event->span + 1, event->chan + 1);
+ sprintf(name, "wanpipe/ss7boost/s%dc%d", event->span+1, event->chan+1);
switch_channel_set_name(channel, name);
tech_pvt->session = session;
} else {
if ((tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session),
- NULL, globals.dialplan, "FreeSWITCH(boost)", (char *) event->calling_number_digits,
+ NULL,
+ globals.dialplan,
+ "FreeSWITCH(boost)",
+ (char *)event->calling_number_digits,
#ifdef WIN32
NULL,
#else
- (char *) event->calling_number_digits,
+ (char *)event->calling_number_digits,
#endif
- NULL, NULL, NULL, (char *) modname, NULL, (char *) event->called_number_digits))) {
+ NULL,
+ NULL,
+ NULL,
+ (char *)modname,
+ NULL,
+ (char *)event->called_number_digits))) {
switch_channel_set_caller_profile(channel, tech_pvt->caller_profile);
}
tech_pvt->boost_span_number = event->span;
tech_pvt->boost_chan_number = event->chan;
tech_pvt->boost_pres = event->calling_number_presentation;
-
- if (!wp_open(tech_pvt, event->span + 1, event->chan + 1)) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open channel %d:%d\n", event->span + 1, event->chan + 1);
+
+ if (!wp_open(tech_pvt, event->span+1, event->chan+1)) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open channel %d:%d\n", event->span+1, event->chan+1);
goto fail;
}
- switch_copy_string(ss7boost_handle->span_chanmap[event->span].map[event->chan],
- switch_core_session_get_uuid(session), sizeof(ss7boost_handle->span_chanmap[event->span].map[event->chan]));
-
+ switch_copy_string(ss7boost_handle->span_chanmap[event->span].map[event->chan], switch_core_session_get_uuid(session),
+ sizeof(ss7boost_handle->span_chanmap[event->span].map[event->chan]));
+
switch_channel_set_state(channel, CS_INIT);
- isup_exec_command(ss7boost_handle, event->span, event->chan, -1, SIGBOOST_EVENT_CALL_START_ACK, 0);
+ isup_exec_command(ss7boost_handle,
+ event->span,
+ event->chan,
+ -1,
+ SIGBOOST_EVENT_CALL_START_ACK,
+ 0);
switch_core_session_thread_launch(session);
return;
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot Create new Inbound Channel!\n");
}
-
- fail:
+
+ fail:
if (session) {
switch_core_session_destroy(&session);
}
- isup_exec_command(ss7boost_handle, event->span, event->chan, -1, SIGBOOST_EVENT_CALL_STOPPED, SIGBOOST_RELEASE_CAUSE_BUSY);
+ isup_exec_command(ss7boost_handle,
+ event->span,
+ event->chan,
+ -1,
+ SIGBOOST_EVENT_CALL_STOPPED,
+ SIGBOOST_RELEASE_CAUSE_BUSY);
}
-static void handle_heartbeat(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_heartbeat(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Heartbeat!\n");
- isup_exec_command(ss7boost_handle, event->span, event->chan, -1, SIGBOOST_EVENT_HEARTBEAT, 0);
+ isup_exec_command(ss7boost_handle,
+ event->span,
+ event->chan,
+ -1,
+ SIGBOOST_EVENT_HEARTBEAT,
+ 0);
}
-static void handle_call_start_ack(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_call_start_ack(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
char *uuid = ss7boost_handle->setup_array[event->call_setup_id];
-
+
if (*uuid) {
switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid))) {
private_object_t *tech_pvt;
switch_channel_t *channel;
-
+
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
-
+
tech_pvt = switch_core_session_get_private(session);
assert(tech_pvt != NULL);
-
+
tech_pvt->ss7boost_handle = ss7boost_handle;
tech_pvt->boost_span_number = event->span;
tech_pvt->boost_chan_number = event->chan;
-
- switch_copy_string(ss7boost_handle->span_chanmap[event->span].map[event->chan],
- switch_core_session_get_uuid(session), sizeof(ss7boost_handle->span_chanmap[event->span].map[event->chan]));
+
+ switch_copy_string(ss7boost_handle->span_chanmap[event->span].map[event->chan], switch_core_session_get_uuid(session),
+ sizeof(ss7boost_handle->span_chanmap[event->span].map[event->chan]));
if (!tech_pvt->wpsock) {
- if (!wp_open(tech_pvt, tech_pvt->boost_span_number + 1, tech_pvt->boost_chan_number + 1)) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open fd for s%dc%d! [%s]\n",
- tech_pvt->boost_span_number + 1, tech_pvt->boost_chan_number + 1, strerror(errno));
+ if (!wp_open(tech_pvt, tech_pvt->boost_span_number+1, tech_pvt->boost_chan_number+1)) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open fd for s%dc%d! [%s]\n",
+ tech_pvt->boost_span_number+1, tech_pvt->boost_chan_number+1, strerror(errno));
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return;
}
}
switch_channel_mark_pre_answered(channel);
-
+
switch_core_session_rwunlock(session);
}
*uuid = '\0';
}
}
-static void handle_call_start_nack_ack(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_call_start_nack_ack(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
// WTF IS THIS! ?
}
-static void handle_call_answer(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_call_answer(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
char *uuid = ss7boost_handle->span_chanmap[event->span].map[event->chan];
if (*uuid) {
switch_core_session_t *session;
-
+
if ((session = switch_core_session_locate(uuid))) {
private_object_t *tech_pvt;
switch_channel_t *channel;
-
+
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
assert(tech_pvt != NULL);
if (!tech_pvt->wpsock) {
- if (!wp_open(tech_pvt, tech_pvt->boost_span_number + 1, tech_pvt->boost_chan_number + 1)) {
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open fd for s%dc%d! [%s]\n",
- tech_pvt->boost_span_number + 1, tech_pvt->boost_chan_number + 1, strerror(errno));
+ if (!wp_open(tech_pvt, tech_pvt->boost_span_number+1, tech_pvt->boost_chan_number+1)) {
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Can't open fd for s%dc%d! [%s]\n",
+ tech_pvt->boost_span_number+1, tech_pvt->boost_chan_number+1, strerror(errno));
switch_channel_hangup(channel, SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER);
return;
}
return;
}
}
-
+
switch_channel_mark_answered(channel);
switch_core_session_rwunlock(session);
} else {
}
}
-static void handle_call_stop_ack(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_call_stop_ack(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
// TODO anything here?
}
-static void handle_call_start_nack(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static void handle_call_start_nack(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
char *uuid = ss7boost_handle->setup_array[event->call_setup_id];
-
+
if (*uuid) {
switch_core_session_t *session;
if ((session = switch_core_session_locate(uuid))) {
private_object_t *tech_pvt;
switch_channel_t *channel;
-
+
channel = switch_core_session_get_channel(session);
assert(channel != NULL);
-
+
tech_pvt = switch_core_session_get_private(session);
assert(tech_pvt != NULL);
-
+
tech_pvt->ss7boost_handle = ss7boost_handle;
tech_pvt->boost_span_number = event->span;
tech_pvt->boost_chan_number = event->chan;
-
+
switch_channel_hangup(channel, event->release_cause);
-
- isup_exec_command(ss7boost_handle, event->span, event->chan, event->call_setup_id, SIGBOOST_EVENT_CALL_START_NACK_ACK, 0);
+
+ isup_exec_command(ss7boost_handle,
+ event->span,
+ event->chan,
+ event->call_setup_id,
+ SIGBOOST_EVENT_CALL_START_NACK_ACK,
+ 0);
switch_core_session_rwunlock(session);
} else {
}
}
-static int parse_ss7_event(ss7boost_handle_t * ss7boost_handle, ss7boost_client_event_t * event)
+static int parse_ss7_event(ss7boost_handle_t *ss7boost_handle, ss7boost_client_event_t *event)
{
int ret = 0;
switch_mutex_lock(ss7boost_handle->mutex);
-
- validate_number((unsigned char *) event->called_number_digits);
- validate_number((unsigned char *) event->calling_number_digits);
+
+ validate_number((unsigned char*)event->called_number_digits);
+ validate_number((unsigned char*)event->calling_number_digits);
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG,
"\nRX EVENT\n"
"\n",
ss7boost_client_event_id_name(event->event_id),
event->event_id,
- event->span + 1,
- event->chan + 1,
+ event->span+1,
+ event->chan+1,
(event->called_number_digits_count ? (char *) event->called_number_digits : "N/A"),
(event->calling_number_digits_count ? (char *) event->calling_number_digits : "N/A"),
- switch_channel_cause2str(event->release_cause), event->span + 1, event->chan + 1, event->event_id, event->call_setup_id,
- event->seqno);
-
-
- switch (event->event_id) {
+ switch_channel_cause2str(event->release_cause),
+ event->span+1,
+ event->chan+1,
+ event->event_id,
+ event->call_setup_id,
+ event->seqno
+ );
+
+ switch(event->event_id) {
+
case SIGBOOST_EVENT_CALL_START:
handle_call_start(ss7boost_handle, event);
break;
handle_call_stop_ack(ss7boost_handle, event);
break;
default:
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Warning no handler implemented for [%s]\n",
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Warning no handler implemented for [%s]\n",
ss7boost_client_event_id_name(event->event_id));
break;
}
return ret;
}
-static void *SWITCH_THREAD_FUNC boost_thread_run(switch_thread_t * thread, void *obj)
+static void *SWITCH_THREAD_FUNC boost_thread_run(switch_thread_t *thread, void *obj)
{
ss7boost_handle_t *ss7boost_handle = (ss7boost_handle_t *) obj;
ss7boost_client_event_t *event;
if (ss7boost_client_connection_open(&ss7boost_handle->mcon,
- ss7boost_handle->local_ip,
- ss7boost_handle->local_port,
- ss7boost_handle->remote_ip, ss7boost_handle->remote_port, module_pool) != SWITCH_STATUS_SUCCESS) {
+ ss7boost_handle->local_ip,
+ ss7boost_handle->local_port,
+ ss7boost_handle->remote_ip,
+ ss7boost_handle->remote_port,
+ module_pool) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "FATAL ERROR CREATING CLIENT CONNECTION\n");
return NULL;
}
-
- isup_exec_command(ss7boost_handle, 0, 0, -1, SIGBOOST_EVENT_SYSTEM_RESTART, 0);
-
-
+
+ isup_exec_command(ss7boost_handle,
+ 0,
+ 0,
+ -1,
+ SIGBOOST_EVENT_SYSTEM_RESTART,
+ 0);
+
+
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Monitor Thread Started\n");
-
+
switch_mutex_lock(globals.hash_mutex);
globals.configured_boost_spans++;
switch_mutex_unlock(globals.hash_mutex);
globals.ss7boost_handle = ss7boost_handle;
-
- for (;;) {
+
+ for(;;) {
if (ss7boost_client_connection_read(&ss7boost_handle->mcon, &event) == SWITCH_STATUS_SUCCESS) {
- struct timeval current;
- struct timeval difftime;
- gettimeofday(¤t, NULL);
- timersub(¤t, &event->tv, &difftime);
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Socket Event [%s] T=%d:%d\n",
- ss7boost_client_event_id_name(event->event_id), (int) difftime.tv_sec, (int) difftime.tv_usec);
-
- parse_ss7_event(ss7boost_handle, event);
+ struct timeval current;
+ struct timeval difftime;
+ gettimeofday(¤t,NULL);
+ timersub (¤t, &event->tv, &difftime);
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Socket Event [%s] T=%d:%d\n",
+ ss7boost_client_event_id_name(event->event_id),
+ (int)difftime.tv_sec, (int)difftime.tv_usec);
+
+ parse_ss7_event(ss7boost_handle, event);
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: Reading from Boost Socket! %s\n", strerror(errno));
break;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Close udp socket\n");
ss7boost_client_connection_close(&ss7boost_handle->mcon);
- switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Monitor Thread Ended\n");
-
+ switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Monitor Thread Ended\n");
+
return NULL;
}
-static void launch_ss7boost_handle(ss7boost_handle_t * ss7boost_handle)
+static void launch_ss7boost_handle(ss7boost_handle_t *ss7boost_handle)
{
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
-
+
switch_threadattr_create(&thd_attr, module_pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
for (param = switch_xml_child(span, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
-
+
if (!strcasecmp(var, "local-ip")) {
local_ip = val;
} else if (!strcasecmp(var, "local-port")) {
}
analog_channels = switch_xml_child(cfg, "analog_channels");
- for (channel = switch_xml_child(analog_channels, "channel"); channel; channel = channel->next) {
+ for(channel = switch_xml_child(analog_channels, "channel"); channel; channel = channel->next) {
char *c_type = (char *) switch_xml_attr(channel, "type");
char *c_dev = (char *) switch_xml_attr(channel, "device");
char *user = NULL;
analog_type_t a_type = ANALOG_TYPE_UNKNOWN;
wpsock_t *sock;
int chan, span;
-
+
if (!c_type) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing required attribute 'type'\n");
continue;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid device name '%s'\n", c_dev);
continue;
}
-
+
if (!(sock = wp_open(NULL, span, chan))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Cannot open device '%s' (%s)\n", c_dev, strerror(errno));
continue;
}
for (param = switch_xml_child(channel, "param"); param; param = param->next) {
- char *var = (char *) switch_xml_attr_soft(param, "name");
- char *val = (char *) switch_xml_attr_soft(param, "value");
-
+ char *var = (char *) switch_xml_attr_soft(param, "name");
+ char *val = (char *) switch_xml_attr_soft(param, "value");
+
if (!strcasecmp(var, "user")) {
user = var;
} else if (!strcasecmp(var, "domain")) {
if (cid_num) {
alc->cid_name = strdup(cid_num);
}
-
+
alc->a_type = a_type;
alc->sock = sock;
alc->chan = chan;
if (globals.fxs_index) {
switch_thread_t *thread;
switch_threadattr_t *thd_attr = NULL;
-
+
switch_threadattr_create(&thd_attr, module_pool);
switch_threadattr_detach_set(thd_attr, 1);
switch_threadattr_stacksize_set(thd_attr, SWITCH_THREAD_STACKSIZE);
int32_t i = 0;
current_span = 0;
-
+
if (id) {
char *p;
-
+
min_span = atoi(id);
if ((p = strchr(id, '-'))) {
p++;
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Missing SPAN ID!\n");
continue;
}
-
+
for (i = min_span; i <= max_span; i++) {
current_span = i;
-
+
if (current_span <= 0 || current_span > MAX_SPANS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Invalid SPAN %d!\n", current_span);
current_span = 0;
continue;
}
-
+
if (!SPANS[current_span]) {
if (!(SPANS[current_span] = switch_core_alloc(module_pool, sizeof(*SPANS[current_span])))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "MEMORY ERROR\n");
}
SPANS[current_span]->span = current_span;
}
-
+
for (param = switch_xml_child(span, "param"); param; param = param->next) {
char *var = (char *) switch_xml_attr_soft(param, "name");
char *val = (char *) switch_xml_attr_soft(param, "value");
-
+
if (!strcmp(var, "dchan")) {
SPANS[current_span]->dchan = atoi(val);
} else if (!strcmp(var, "bchan")) {
fromi = atoi(from);
toi = atoi(to);
if (fromi > 0 && toi > 0 && fromi < toi && fromi < MAX_SPANS && toi < MAX_SPANS) {
- for (x = fromi; x <= toi; x++) {
+ for(x = fromi; x <= toi; x++) {
SPANS[current_span]->bchans |= (1 << x);
}
} else {
globals.configured_spans = 0;
- for (current_span = 1; current_span < MAX_SPANS; current_span++) {
+ for(current_span = 1; current_span < MAX_SPANS; current_span++) {
if (SPANS[current_span]) {
if (!SPANS[current_span]->l1) {
SPANS[current_span]->l1 = PRI_LAYER_1_ULAW;
}
if (sangoma_init_pri(&SPANS[current_span]->spri,
- current_span, SPANS[current_span]->dchan, SPANS[current_span]->pswitch, SPANS[current_span]->node, globals.debug)) {
+ current_span,
+ SPANS[current_span]->dchan,
+ SPANS[current_span]->pswitch,
+ SPANS[current_span]->node,
+ globals.debug)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Cannot launch span %d\n", current_span);
continue;
}
return SWITCH_STATUS_SUCCESS;
}
+
+
+
--- /dev/null
+/*****************************************************************************\r
+* aft_api.c AFT T1/E1: HDLC API Sample Code\r
+*\r
+* Author(s): Nenad Corbic <ncorbic@sangoma.com>\r
+*\r
+* Copyright: (c) 2003-2004 Sangoma Technologies Inc.\r
+*\r
+* This program is free software; you can redistribute it and/or\r
+* modify it under the terms of the GNU General Public License\r
+* as published by the Free Software Foundation; either version\r
+* 2 of the License, or (at your option) any later version.\r
+* ============================================================================\r
+*/\r
+\r
+\r
+#include <stdlib.h>\r
+#include <stdio.h>\r
+#include <ctype.h>\r
+#include <unistd.h>\r
+#include <sys/time.h>\r
+#include <sys/socket.h>\r
+#include <netinet/in.h>\r
+#include <linux/if_wanpipe.h>\r
+#include <string.h>\r
+#include <errno.h>\r
+#include <fcntl.h>\r
+#include <sys/ioctl.h>\r
+#include <sys/types.h>\r
+#include <signal.h>\r
+#include <linux/if.h>\r
+#include <linux/wanpipe_defines.h>\r
+#include <linux/wanpipe_cfg.h>\r
+#include <linux/wanpipe.h>\r
+#include <libsangoma.h>\r
+#include "lib_api.h"\r
+\r
+#define MAX_TX_DATA 5000 /* Size of tx data */ \r
+#define MAX_FRAMES 5000 /* Number of frames to transmit */ \r
+\r
+#define MAX_RX_DATA 5000\r
+\r
+unsigned short Rx_lgth;\r
+\r
+unsigned char Rx_data[MAX_RX_DATA];\r
+unsigned char Tx_data[MAX_TX_DATA + sizeof(wp_tdm_api_rx_hdr_t)];\r
+\r
+/* Prototypes */\r
+int MakeConnection(void);\r
+void handle_span_chan( void);\r
+void sig_end(int sigid);\r
+\r
+int dev_fd;\r
+FILE *tx_fd=NULL,*rx_fd=NULL; \r
+wanpipe_tdm_api_t tdm_api; \r
+\r
+\r
+/***************************************************\r
+* HANDLE SOCKET \r
+*\r
+* o Read a socket \r
+* o Cast data received to api_rx_element_t data type \r
+* o The received packet contains 16 bytes header \r
+*\r
+* ------------------------------------------\r
+* | 16 bytes | X bytes ...\r
+* ------------------------------------------\r
+* Header Data\r
+*\r
+* o Data structures:\r
+* ------------------\r
+* typedef struct {\r
+* union {\r
+* struct {\r
+* unsigned char _event_type;\r
+* unsigned char _rbs_rx_bits;\r
+* unsigned int _time_stamp;\r
+* }wp_event;\r
+* struct {\r
+* unsigned char _rbs_rx_bits;\r
+* unsigned int _time_stamp;\r
+* }wp_rx;\r
+* unsigned char reserved[16];\r
+* }wp_rx_hdr_u;\r
+* #define wp_api_event_type wp_rx_hdr_u.wp_event._event_type\r
+* #define wp_api_event_rbs_rx_bits wp_rx_hdr_u.wp_event._rbs_rx_bits\r
+* #define wp_api_event_time_stamp wp_rx_hdr_u.wp_event._time_stamp\r
+* } wp_tdm_api_rx_hdr_t;\r
+* \r
+* typedef struct {\r
+* wp_tdm_api_rx_hdr_t hdr;\r
+* unsigned char data[1];\r
+* } wp_tdm_api_rx_element_t;\r
+* \r
+* typedef struct {\r
+* union {\r
+* struct {\r
+* unsigned char _rbs_rx_bits;\r
+* unsigned int _time_stamp;\r
+* }wp_tx;\r
+* unsigned char reserved[16];\r
+* }wp_tx_hdr_u;\r
+* #define wp_api_time_stamp wp_tx_hdr_u.wp_tx._time_stamp\r
+* } wp_tdm_api_tx_hdr_t;\r
+* \r
+* typedef struct {\r
+* wp_tdm_api_tx_hdr_t hdr;\r
+* unsigned char data[1];\r
+* } wp_tdm_api_tx_element_t;\r
+* \r
+* #define WPTDM_A_BIT 0x08\r
+* #define WPTDM_B_BIT 0x04\r
+* #define WPTDM_C_BIT 0x02\r
+* #define WPTDM_D_BIT 0x01\r
+*\r
+*/\r
+\r
+void handle_span_chan(void) \r
+{\r
+ unsigned int Rx_count,Tx_count,Tx_length;\r
+ wp_tdm_api_rx_element_t* api_rx_el;\r
+ wp_tdm_api_tx_element_t * api_tx_el;\r
+ fd_set ready,write,oob;\r
+ int err,i;\r
+ \r
+#if 0\r
+ int rlen;\r
+ int stream_sync=0;\r
+#endif\r
+ \r
+ Rx_count = 0;\r
+ Tx_count = 0;\r
+\r
+ if (tdm_api.wp_tdm_cmd.hdlc) {\r
+ Tx_length = tx_size;\r
+ } else {\r
+ Tx_length = tdm_api.wp_tdm_cmd.usr_mtu_mru;\r
+ }\r
+ \r
+ printf("\n\nSocket Handler: Rx=%d Tx=%i TxCnt=%i TxLen=%i TxDelay=%i\n",\r
+ read_enable,write_enable,tx_cnt,tx_size,tx_delay); \r
+\r
+ /* Initialize the Tx Data buffer */\r
+ memset(&Tx_data[0],0,MAX_TX_DATA + sizeof(wp_tdm_api_rx_hdr_t));\r
+\r
+ /* Cast the Tx data packet with the tx element\r
+ * structure. We must insert a 16 byte\r
+ * driver header, which driver will remove \r
+ * before passing packet out the physical port */\r
+ api_tx_el = (wp_tdm_api_tx_element_t*)&Tx_data[0];\r
+ \r
+\r
+ /* Create a Tx packet based on user info, or\r
+ * by deafult incrementing number starting from 0 */\r
+ for (i=0;i<Tx_length;i++){\r
+ if (tx_data == -1){\r
+ api_tx_el->data[i] = (unsigned char)i;\r
+ }else{\r
+#if 0\r
+ api_tx_el->data[i] = (unsigned char)tx_data+(i%4);\r
+#else\r
+ api_tx_el->data[i] = (unsigned char)tx_data;\r
+#endif\r
+ }\r
+ }\r
+\r
+ sangoma_tdm_enable_rxhook_events(dev_fd, &tdm_api);\r
+\r
+ /* Main Rx Tx OOB routine */\r
+ for(;;) { \r
+\r
+ /* Initialize all select() descriptors */\r
+ FD_ZERO(&ready);\r
+ FD_ZERO(&write);\r
+ FD_ZERO(&oob);\r
+ FD_SET(dev_fd,&oob);\r
+ FD_SET(dev_fd,&ready);\r
+\r
+ if (write_enable){\r
+ FD_SET(dev_fd,&write);\r
+ }\r
+\r
+ /* Select will block, until:\r
+ * 1: OOB event, link level change\r
+ * 2: Rx data available\r
+ * 3: Interface able to Tx */\r
+ \r
+ if(select(dev_fd + 1,&ready, &write, &oob, NULL)){\r
+\r
+ fflush(stdout); \r
+ if (FD_ISSET(dev_fd,&oob)){\r
+ \r
+ /* An OOB event is pending, usually indicating\r
+ * a link level change */\r
+ \r
+ err=sangoma_tdm_read_event(dev_fd,&tdm_api);\r
+\r
+ if(err < 0 ) {\r
+ printf("Failed to receive OOB %i , %i\n", Rx_count, err);\r
+ err = ioctl(dev_fd,SIOC_WANPIPE_SOCK_STATE,0);\r
+ printf("Sock state is %s\n",\r
+ (err == 0) ? "CONNECTED" : \r
+ (err == 1) ? "DISCONNECTED" :\r
+ "CONNECTING");\r
+ break;\r
+ }\r
+ \r
+ printf("GOT OOB EXCEPTION CMD Exiting\n");\r
+ }\r
+ \r
+ \r
+ if (FD_ISSET(dev_fd,&ready)){\r
+\r
+ /* An Rx packet is pending\r
+ * 1: Read the rx packet into the Rx_data\r
+ * buffer. Confirm len > 0\r
+ *\r
+ * 2: Cast Rx_data to the api_rx_element.\r
+ * Thus, removing a 16 byte header\r
+ * attached by the driver.\r
+ *\r
+ * 3. Check error_flag:\r
+ * CRC,Abort..etc \r
+ */\r
+\r
+ memset(Rx_data, 0, sizeof(Rx_data));\r
+\r
+ err = sangoma_readmsg_tdm(dev_fd,\r
+ Rx_data, \r
+ sizeof(wp_tdm_api_rx_hdr_t),\r
+ &Rx_data[sizeof(wp_tdm_api_rx_hdr_t)],\r
+ MAX_RX_DATA, 0); \r
+\r
+\r
+ if (!read_enable){\r
+ goto bitstrm_skip_read;\r
+ }\r
+\r
+ /* err indicates bytes received */\r
+ if(err <= 0) {\r
+ printf("\nError receiving data\n");\r
+ break;\r
+ }\r
+\r
+ api_rx_el = (wp_tdm_api_rx_element_t*)&Rx_data[0];\r
+\r
+ /* Check the packet length */\r
+ Rx_lgth = err;\r
+ if(Rx_lgth<=0) {\r
+ printf("\nShort frame received (%d)\n",\r
+ Rx_lgth);\r
+ return;\r
+ }\r
+\r
+#if 0\r
+ if (api_rx_el->data[0] == tx_data && api_rx_el->data[1] == (tx_data+1)){\r
+ if (!stream_sync){\r
+ printf("GOT SYNC %x\n",api_rx_el->data[0]);\r
+ }\r
+ stream_sync=1;\r
+ }else{\r
+ if (stream_sync){\r
+ printf("OUT OF SYNC: %x\n",api_rx_el->data[0]);\r
+ }\r
+ }\r
+#endif \r
+\r
+ ++Rx_count;\r
+\r
+ if (verbose){\r
+#if 0\r
+ printf("Received %i Length = %i\n", \r
+ Rx_count,Rx_lgth);\r
+\r
+ printf("Data: ");\r
+ for(i=0;i<Rx_lgth; i ++) {\r
+ printf("0x%02X ", api_rx_el->data[i]);\r
+ }\r
+ printf("\n");\r
+#endif\r
+ }else{\r
+ //putchar('R');\r
+ }\r
+\r
+\r
+#if 0\r
+ switch(api_rx_el->hdr.wp_api_event_type){\r
+ case WP_TDM_EVENT_DTMF:\r
+ printf("DTMV Event: %c (%s:%s)!\n",\r
+ api_rx_el->hdr.wp_api_event_dtmf_digit,\r
+ (api_rx_el->hdr.wp_api_event_dtmf_type&WP_TDM_EVENT_DTMF_ROUT)?"ROUT":"SOUT",\r
+ (api_rx_el->hdr.wp_api_event_dtmf_type&WP_TDM_EVENT_DTMF_PRESET)?"PRESET":"STOP"); \r
+ break;\r
+ case WP_TDM_EVENT_RXHOOK:\r
+ printf("RXHOOK Event: %s!\n",\r
+ (api_rx_el->hdr.wp_api_event_rxhook_state&WP_TDM_EVENT_RXHOOK_OFF)?"OFF-HOOK":"ON-HOOK");\r
+ break;\r
+ case WP_TDM_EVENT_RING:\r
+ printf("RING Event: %s!\n",\r
+ (api_rx_el->hdr.wp_api_event_ring_state&WP_TDM_EVENT_RING_PRESENT)?"PRESENT":"STOP");\r
+ break;\r
+ }\r
+#endif\r
+\r
+ if (rx_cnt > 0 && Rx_count >= rx_cnt){\r
+ break;\r
+ }\r
+bitstrm_skip_read:\r
+;\r
+ }\r
+ \r
+ if (FD_ISSET(dev_fd,&write)){\r
+\r
+\r
+ err = sangoma_writemsg_tdm(dev_fd,\r
+ Tx_data,16, \r
+ &Tx_data[16], Tx_length, \r
+ 0);\r
+ if (err <= 0){\r
+ if (errno == EBUSY){\r
+ if (verbose){\r
+ printf("Sock busy try again!\n");\r
+ }\r
+ /* Socket busy try sending again !*/\r
+ }else{\r
+ printf("Faild to send %i \n",errno);\r
+ perror("Send: ");\r
+ break;\r
+ }\r
+ }else{\r
+\r
+ ++Tx_count;\r
+ \r
+ if (verbose){\r
+ //printf("Packet sent: Sent %i : %i\n",\r
+ // err,Tx_count);\r
+ }else{\r
+ //putchar('T');\r
+ }\r
+ }\r
+ }\r
+\r
+ if (tx_delay){\r
+ usleep(tx_delay);\r
+ }\r
+\r
+ if (tx_cnt && tx_size && Tx_count >= tx_cnt && !(files_used & TX_FILE_USED)){\r
+ \r
+ write_enable=0;\r
+ if (rx_cnt > 0){\r
+ /* Dont break let rx finish */\r
+ }else{\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ sangoma_tdm_disable_rxhook_events(dev_fd, &tdm_api);\r
+ if (tx_fd){\r
+ fclose(tx_fd);\r
+ }\r
+ if (rx_fd){\r
+ fclose(rx_fd);\r
+ }\r
+ close (dev_fd);\r
+ return;\r
+\r
+} \r
+\r
+int rxhook_event (int fd, unsigned char state)\r
+{\r
+ printf("%d: RXHOOK Event: %s!\n",\r
+ fd, (state & WAN_EVENT_RXHOOK_OFF)?"OFF-HOOK":"ON-HOOK");\r
+ return 0;\r
+}\r
+\r
+/***************************************************************\r
+ * Main:\r
+ *\r
+ * o Make a socket connection to the driver.\r
+ * o Call handle_span_chan() to read the socket \r
+ *\r
+ **************************************************************/\r
+\r
+\r
+int main(int argc, char* argv[])\r
+{\r
+ int proceed;\r
+\r
+ proceed=init_args(argc,argv);\r
+ if (proceed != WAN_TRUE){\r
+ usage(argv[0]);\r
+ return -1;\r
+ }\r
+\r
+ signal(SIGINT,&sig_end);\r
+ memset(&tdm_api,0,sizeof(tdm_api));\r
+ tdm_api.wp_tdm_event.wp_rxhook_event = &rxhook_event;\r
+ \r
+ printf("TDM RXHOOK PTR = %p\n",tdm_api.wp_tdm_event.wp_rxhook_event);\r
+ \r
+ dev_fd =-1;\r
+ \r
+ dev_fd = sangoma_open_tdmapi_span_chan(atoi(card_name),atoi(if_name));\r
+ if( dev_fd < 0){\r
+ printf("Failed to open span chan (%s:%s:%d:%d)\n",\r
+ card_name, if_name,\r
+ atoi(card_name),atoi(if_name));\r
+ exit (1);\r
+ }\r
+ printf("HANDLING SPAN %i CHAN %i FD=%i\n",\r
+ atoi(card_name),atoi(if_name),dev_fd);\r
+ \r
+ sangoma_tdm_set_codec(dev_fd,&tdm_api,WP_NONE);\r
+ sangoma_get_full_cfg(dev_fd, &tdm_api);\r
+ \r
+ handle_span_chan();\r
+ close(dev_fd);\r
+ return 0;\r
+\r
+ return 0;\r
+};\r
+\r
+\r
+void sig_end(int sigid)\r
+{\r
+\r
+ printf("Got Signal %i\n",sigid);\r
+ \r
+ sangoma_tdm_disable_rxhook_events(dev_fd, &tdm_api);\r
+\r
+ if (tx_fd){\r
+ fclose(tx_fd);\r
+ }\r
+ if (rx_fd){\r
+ fclose(rx_fd);\r
+ }\r
+\r
+ if (dev_fd){\r
+ close (dev_fd);\r
+ }\r
+ \r
+\r
+ exit(1);\r
+}\r
+\r
+\r
+\r
projects / thirdparty / freeswitch.git / commitdiff
