INCS=-I$(PWD)/$(SRC)//include -I$(PWD)/$(SRC)//isdn/include
CFLAGS=$(ZAP_CFLAGS) $(INCS)
MYLIB=libopenzap.a
-TMP=-I../libpri-1.2.4 -I$(SRC)/include -I./src -w
+LIBPRIA=libpri.a
+LIBPRI=./libpri
+TMP=-I$(LIBPRI) -I$(SRC)/include -I./src -w
include general.makefile $(ZAP_MODS)
testanalog: $(SRC)/testanalog.c $(MYLIB)
$(CC) $(INCS) -L. $(SRC)/testanalog.c -o testanalog -lopenzap -lm -lpthread
-priserver.o: $(SRC)/priserver.c
+$(SRC)/priserver.o: $(SRC)/priserver.c
$(CC) $(INCS) $(TMP) -c $(SRC)/priserver.c -o $(SRC)/priserver.o
$(SRC)/sangoma_pri.o: $(SRC)/sangoma_pri.c
$(CC) $(INCS) $(TMP) -c $(SRC)/sangoma_pri.c -o $(SRC)/sangoma_pri.o
-priserver: $(MYLIB) $(SRC)/priserver.o $(SRC)/sangoma_pri.o
- $(CC) $(SRC)/sangoma_pri.o $(SRC)/priserver.o -L. -o priserver -lopenzap -lm -lpthread ../../libpri-1.2.4/libpri.a
+$(LIBPRI)/$(LIBPRIA):
+ cd libpri && make
+
+priserver: $(MYLIB) $(SRC)/priserver.o $(SRC)/sangoma_pri.o $(LIBPRI)/$(LIBPRIA)
+ $(CC) $(SRC)/sangoma_pri.o $(SRC)/priserver.o -L. -o priserver -lopenzap -lm -lpthread $(LIBPRI)/$(LIBPRIA)
$(SRC)/zap_io.o: $(SRC)/zap_io.c
$(CC) $(MOD_CFLAGS) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@
cd mod_openzap && make install
mod_openzap-clean:
- cd mod_openzap && make clean
+ @if [ -f mod_openzap/mod_openzap.so ] ; then cd mod_openzap && make clean ; fi
clean: mod_openzap-clean
rm -f $(SRC)/*.o $(SRC)/isdn/*.o $(MYLIB) *~ \#* testapp priserver testisdn testanalog
+ @if [ -f $(LIBPRI)/$(LIBPRIA) ] ; then cd $(LIBPRI) && make clean ; fi
--- /dev/null
+/*****************************************************************************
+ * priserver.c Refactoring of pritest.c
+ *
+ * Author(s): Anthony Minessale II <anthmct@yahoo.com>
+ * Nenad Corbic <ncorbic@sangoma.com>
+ *
+ * Copyright: (c) 2005 Anthony Minessale II
+ *
+ * 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 "openzap.h"
+#include <sangoma_pri.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/wait.h>
+
+typedef struct {
+ int pid;
+ q931_call call;
+ void *pri;
+ int ready;
+}call_info_t;
+
+
+#define SANGOMA_MAX_CHAN_PER_SPAN 32
+
+static call_info_t pidmap[SANGOMA_MAX_CHAN_PER_SPAN];
+
+ZIO_EVENT_CB_FUNCTION(my_zap_event_handler)
+{
+ if (event->e_type = ZAP_EVENT_DTMF) {
+ char *dtmf = event->data;
+ printf("DTMF %s\n", dtmf);
+ }
+}
+
+/* Stupid runtime process to play a file to a b channel*/
+#define BYTES 320
+#define MAX_BYTES 1000
+
+static int ready = 1;
+
+static void handle_SIGINT(int sig)
+{
+ if (sig) {
+ ready = 0;
+ }
+
+ return;
+}
+
+static void launch_channel(struct sangoma_pri *spri, int channo)
+{
+ pid_t pid;
+ int fd = 0, file = 0, inlen = 0, outlen = 0;
+ unsigned char inframe[MAX_BYTES], outframe[MAX_BYTES];
+ fd_set readfds;
+ int mtu_mru=BYTES / 2;
+ int err;
+ zap_channel_t *chan;
+ zap_codec_t codec = ZAP_CODEC_SLIN;
+ unsigned ms = 20;
+ unsigned int lead = 50;
+ int ifd = -1;
+ zap_tone_type_t tt = ZAP_TONE_DTMF;
+ char dtmf[] = "1234567890";
+ int loops = 0;
+
+ pid = fork();
+
+ if (pid) {
+ pidmap[channo-1].pid = pid;
+ printf("-- Launching process %d to handle channel %d\n", pid, channo);
+ return;
+ }
+
+ signal(SIGINT, handle_SIGINT);
+
+ //ifd = open("/nfs/sounds/ptest.raw", O_WRONLY|O_CREAT|O_TRUNC, 777);
+
+ memset(inframe, 0, MAX_BYTES);
+ memset(outframe, 0, MAX_BYTES);
+
+ if (zap_channel_open("wanpipe", spri->span, channo, &chan) != ZAP_SUCCESS) {
+ printf("DEBUG cant open fd!\n");
+ }
+
+
+
+#if 1
+ if (zap_channel_command(chan, ZAP_COMMAND_SET_CODEC, &codec) != ZAP_SUCCESS) {
+ printf("Critical Error: Failed to set driver codec!\n");
+ zap_channel_close(&chan);
+ exit(-1);
+ }
+#endif
+
+#if 1
+ if (zap_channel_command(chan, ZAP_COMMAND_ENABLE_TONE_DETECT, &tt) != ZAP_SUCCESS) {
+ printf("Critical Error: Failed to set dtmf detect!\n");
+ zap_channel_close(&chan);
+ exit(-1);
+ }
+ zap_channel_set_event_callback(chan, my_zap_event_handler);
+#endif
+
+
+ if (zap_channel_command(chan, ZAP_COMMAND_SET_INTERVAL, &ms) != ZAP_SUCCESS) {
+ printf("Critical Error: Failed to set codec interval!\n");
+ zap_channel_close(&chan);
+ exit(-1);
+ }
+
+ file = open("sound.raw", O_RDONLY);
+ if (file < 0){
+ printf("Critical Error: Failed to open sound file!\n");
+ zap_channel_close(&chan);
+ exit(-1);
+ }
+
+
+ while(ready) {
+ zap_wait_flag_t flags = ZAP_READ;
+ zap_size_t len;
+ loops++;
+
+ if (lead) {
+ lead--;
+ }
+
+ if (!lead && loops == 300) {
+#if 1
+ if (zap_channel_command(chan, ZAP_COMMAND_SEND_DTMF, dtmf) != ZAP_SUCCESS) {
+ printf("Critical Error: Failed to send dtmf\n");
+ zap_channel_close(&chan);
+ exit(-1);
+ }
+#endif
+
+ }
+
+ if (zap_channel_wait(chan, &flags, 2000) != ZAP_SUCCESS) {
+ printf("wait FAIL! [%s]\n", chan->last_error);
+ break;
+ }
+
+ if (flags & ZAP_READ) {
+ len = MAX_BYTES;
+ if (zap_channel_read(chan, inframe, &len) == ZAP_SUCCESS) {
+ //printf("READ: %d\n", len);
+ //write(ifd, inframe, len);
+ if(!lead && (outlen = read(file, outframe, len)) <= 0) {
+ break;
+ }
+
+ } else {
+ printf("READ FAIL! %d [%s]\n", len, chan->last_error);
+ break;
+ }
+ if (lead) {
+ continue;
+ }
+ zap_channel_write(chan, outframe, &len);
+ } else {
+ printf("BREAK");
+ break;
+ }
+ }
+
+ printf("loop done\n");
+
+ //sangoma_get_full_cfg(fd, &tdm_api);
+ close(file);
+ //close(ifd);
+
+
+ if (zap_channel_close(&chan) != ZAP_SUCCESS) {
+ printf("Critical Error: Failed to close channel [%s]\n", chan->last_error);
+ }
+
+ printf("Call Handler: Process Finished\n");
+ exit(0);
+}
+
+
+/* Event Handlers */
+
+static int on_info(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *event)
+{
+ printf( "number is: %s\n", event->ring.callednum);
+ if(strlen(event->ring.callednum) > 3) {
+ printf( "final number is: %s\n", event->ring.callednum);
+ pri_answer(spri->pri, event->ring.call, 0, 1);
+ }
+ return 0;
+}
+
+static int on_hangup(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *event)
+{
+ //pri_hangup(spri->pri, event->hangup.call, event->hangup.cause);
+ printf("-- Hanging up channel %d\n", event->hangup.channel);
+ if(pidmap[event->hangup.channel-1].pid) {
+ pri_hangup(spri->pri, event->hangup.call, 16);
+ pri_destroycall(spri->pri, event->hangup.call);
+ kill(pidmap[event->hangup.channel-1].pid, SIGINT);
+ pidmap[event->hangup.channel-1].pid = 0;
+ }
+ return 0;
+}
+
+static int on_ring(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *event)
+{
+ printf("-- Ring on channel %d (from %s to %s), answering...\n", event->ring.channel, event->ring.callingnum, event->ring.callednum);
+ pri_answer(spri->pri, event->ring.call, event->ring.channel, 1);
+ memcpy(&pidmap[event->ring.channel-1].call, event->ring.call, sizeof(q931_call));
+ pidmap[event->ring.channel-1].pri=spri->pri;
+ pidmap[event->ring.channel-1].call = *event->ring.call;
+ launch_channel(spri, event->ring.channel);
+ return 0;
+}
+
+static int on_restart(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *event)
+{
+ printf("-- Restarting channel %d\n", event->restart.channel);
+ return 0;
+}
+
+static int on_anything(struct sangoma_pri *spri, sangoma_pri_event_t event_type, pri_event *event)
+{
+ printf("%s: Caught Event %d (%s)\n", __FUNCTION__, event_type, sangoma_pri_event_str(event_type));
+ return 0;
+}
+
+/* Generic Reaper */
+static void chan_ended(int sig)
+{
+ int status;
+ int x;
+ struct rusage rusage;
+ pid_t pid;
+ pid = wait4(-1, &status, WNOHANG, &rusage);
+
+ printf("-- PID %d ended\n", pid);
+
+ for (x=0;x<SANGOMA_MAX_CHAN_PER_SPAN;x++) {
+ if (pid == pidmap[x].pid) {
+ pidmap[x].pid = 0;
+ if (pidmap[x].pri){
+ int err=pri_hangup(pidmap[x].pri, &pidmap[x].call, 16);
+ //pri_destroycall(pidmap[x].pri, &pidmap[x].call);
+ printf("Hanging up on PID %i Err=%i\n",pid,err);
+ }
+
+ pidmap[x].pri=NULL;
+ signal(SIGCHLD, chan_ended);
+ return;
+ }
+ }
+
+ if (pid > -1) {
+ fprintf(stderr, "--!! Unknown PID %d exited\n", pid);
+ signal(SIGCHLD, chan_ended);
+ return;
+ }
+}
+
+/* Our Program */
+int main(int argc, char *argv[])
+{
+ struct sangoma_pri spri;
+ int debug = 0;
+ if (argv[1]) {
+ debug = atoi(argv[1]);
+ }
+
+ zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG);
+ if (zap_global_init() != ZAP_SUCCESS) {
+ fprintf(stderr, "Error loading OpenZAP\n");
+ exit(-1);
+ }
+
+ printf("OpenZAP loaded\n");
+
+
+
+ if (sangoma_init_pri(&spri,
+ 1, // span
+ 24, // dchan
+ SANGOMA_PRI_SWITCH_DMS100,
+ SANGOMA_PRI_CPE,
+ debug) < 0) {
+ return -1;
+ }
+ //spri.pri->debug = (PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW | PRI_DEBUG_Q921_STATE);
+
+ //pri_set_debug(&spri.pri, (PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q921_DUMP | PRI_DEBUG_Q921_RAW | PRI_DEBUG_Q921_STATE));
+
+ SANGOMA_MAP_PRI_EVENT(spri, SANGOMA_PRI_EVENT_ANY, on_anything);
+ SANGOMA_MAP_PRI_EVENT(spri, SANGOMA_PRI_EVENT_RING, on_ring);
+ SANGOMA_MAP_PRI_EVENT(spri, SANGOMA_PRI_EVENT_HANGUP, on_hangup);
+ SANGOMA_MAP_PRI_EVENT(spri, SANGOMA_PRI_EVENT_HANGUP_REQ, on_hangup);
+ SANGOMA_MAP_PRI_EVENT(spri, SANGOMA_PRI_EVENT_INFO_RECEIVED, on_info);
+ SANGOMA_MAP_PRI_EVENT(spri, SANGOMA_PRI_EVENT_RESTART, on_restart);
+
+ signal(SIGCHLD, chan_ended);
+ sangoma_run_pri(&spri);
+ return 0;
+}
+
--- /dev/null
+/*****************************************************************************
+ * sangoma_pri.c libpri Sangoma integration
+ *
+ * Author(s): Anthony Minessale II <anthmct@yahoo.com>
+ * Nenad Corbic <ncorbic@sangoma.com>
+ *
+ * Copyright: (c) 2005 Anthony Minessale II
+ *
+ * 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 "openzap.h"
+#include <sangoma_pri.h>
+#ifndef HAVE_GETTIMEOFDAY
+
+#ifdef WIN32
+#include <mmsystem.h>
+
+static __inline int gettimeofday(struct timeval *tp, void *nothing)
+{
+#ifdef WITHOUT_MM_LIB
+ SYSTEMTIME st;
+ time_t tt;
+ struct tm tmtm;
+ /* mktime converts local to UTC */
+ GetLocalTime (&st);
+ tmtm.tm_sec = st.wSecond;
+ tmtm.tm_min = st.wMinute;
+ tmtm.tm_hour = st.wHour;
+ tmtm.tm_mday = st.wDay;
+ tmtm.tm_mon = st.wMonth - 1;
+ tmtm.tm_year = st.wYear - 1900; tmtm.tm_isdst = -1;
+ tt = mktime (&tmtm);
+ tp->tv_sec = tt;
+ tp->tv_usec = st.wMilliseconds * 1000;
+#else
+ /**
+ ** The earlier time calculations using GetLocalTime
+ ** had a time resolution of 10ms.The timeGetTime, part
+ ** of multimedia apis offer a better time resolution
+ ** of 1ms.Need to link against winmm.lib for this
+ **/
+ unsigned long Ticks = 0;
+ unsigned long Sec =0;
+ unsigned long Usec = 0;
+ Ticks = timeGetTime();
+
+ Sec = Ticks/1000;
+ Usec = (Ticks - (Sec*1000))*1000;
+ tp->tv_sec = Sec;
+ tp->tv_usec = Usec;
+#endif /* WITHOUT_MM_LIB */
+ (void)nothing;
+ return 0;
+}
+#endif /* WIN32 */
+#endif /* HAVE_GETTIMEOFDAY */
+
+static struct sangoma_pri_event_list SANGOMA_PRI_EVENT_LIST[] = {
+ {0, SANGOMA_PRI_EVENT_ANY, "ANY"},
+ {1, SANGOMA_PRI_EVENT_DCHAN_UP, "DCHAN_UP"},
+ {2, SANGOMA_PRI_EVENT_DCHAN_DOWN, "DCHAN_DOWN"},
+ {3, SANGOMA_PRI_EVENT_RESTART, "RESTART"},
+ {4, SANGOMA_PRI_EVENT_CONFIG_ERR, "CONFIG_ERR"},
+ {5, SANGOMA_PRI_EVENT_RING, "RING"},
+ {6, SANGOMA_PRI_EVENT_HANGUP, "HANGUP"},
+ {7, SANGOMA_PRI_EVENT_RINGING, "RINGING"},
+ {8, SANGOMA_PRI_EVENT_ANSWER, "ANSWER"},
+ {9, SANGOMA_PRI_EVENT_HANGUP_ACK, "HANGUP_ACK"},
+ {10, SANGOMA_PRI_EVENT_RESTART_ACK, "RESTART_ACK"},
+ {11, SANGOMA_PRI_EVENT_FACNAME, "FACNAME"},
+ {12, SANGOMA_PRI_EVENT_INFO_RECEIVED, "INFO_RECEIVED"},
+ {13, SANGOMA_PRI_EVENT_PROCEEDING, "PROCEEDING"},
+ {14, SANGOMA_PRI_EVENT_SETUP_ACK, "SETUP_ACK"},
+ {15, SANGOMA_PRI_EVENT_HANGUP_REQ, "HANGUP_REQ"},
+ {16, SANGOMA_PRI_EVENT_NOTIFY, "NOTIFY"},
+ {17, SANGOMA_PRI_EVENT_PROGRESS, "PROGRESS"},
+ {18, SANGOMA_PRI_EVENT_KEYPAD_DIGIT, "KEYPAD_DIGIT"}
+};
+
+#define LINE "--------------------------------------------------------------------------------"
+
+char *sangoma_pri_event_str(sangoma_pri_event_t event_id)
+{
+ return SANGOMA_PRI_EVENT_LIST[event_id].name;
+}
+
+static int __pri_sangoma_read(struct pri *pri, void *buf, int buflen)
+{
+ struct sangoma_pri *spri = (struct sangoma_pri *) pri->userdata;
+ zap_size_t len = buflen;
+ int res;
+ char bb[4096] = "";
+
+
+ if (zap_channel_read(spri->zdchan, buf, &len) != ZAP_SUCCESS) {
+ printf("D-READ FAIL! [%s]\n", spri->zdchan->last_error);
+ return 0;
+ }
+ res = (int)len;
+ memset(&((unsigned char*)buf)[res],0,2);
+ res+=2;
+
+ print_bits(buf, res-2, bb, sizeof(bb), 1);
+ zap_log(ZAP_LOG_DEBUG, "READ %d\n%s\n%s\n\n", res-2, LINE, bb);
+
+ return res;
+}
+
+static int __pri_sangoma_write(struct pri *pri, void *buf, int buflen)
+{
+ struct sangoma_pri *spri = (struct sangoma_pri *) pri->userdata;
+ int res;
+ zap_size_t len = buflen -2;
+ char bb[4096] = "";
+
+ if (zap_channel_write(spri->zdchan, buf, &len) != ZAP_SUCCESS) {
+ printf("D-WRITE FAIL! [%s]\n", spri->zdchan->last_error);
+ return 0;
+ }
+
+ print_bits(buf, (int)buflen-2, bb, sizeof(bb), 1);
+ zap_log(ZAP_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)buflen-2, LINE, bb);
+
+ return (int) buflen;
+}
+
+int sangoma_init_pri(struct sangoma_pri *spri, int span, int dchan, int swtype, int node, int debug)
+{
+ int ret = -1;
+ zap_socket_t dfd = 0;
+
+ memset(spri, 0, sizeof(struct sangoma_pri));
+
+ if (zap_channel_open("wanpipe", span, dchan, &spri->zdchan) != ZAP_SUCCESS) {
+ fprintf(stderr, "Unable to open DCHAN %d for span %d (%s)\n", dchan, span, strerror(errno));
+ } else {
+ if ((spri->pri = pri_new_cb(spri->zdchan->sockfd, node, swtype, __pri_sangoma_read, __pri_sangoma_write, spri))){
+ spri->span = span;
+ pri_set_debug(spri->pri, debug);
+ ret = 0;
+ } else {
+ fprintf(stderr, "Unable to create PRI\n");
+ }
+ }
+ return ret;
+}
+
+
+int sangoma_one_loop(struct sangoma_pri *spri)
+{
+ fd_set rfds, efds;
+ struct timeval now = {0,0}, *next;
+ pri_event *event;
+ int sel;
+
+ if (spri->on_loop) {
+ spri->on_loop(spri);
+ }
+
+ FD_ZERO(&rfds);
+ FD_ZERO(&efds);
+
+#ifdef _MSC_VER
+//Windows macro for FD_SET includes a warning C4127: conditional expression is constant
+#pragma warning(push)
+#pragma warning(disable:4127)
+#endif
+
+ FD_SET(spri->pri->fd, &rfds);
+ FD_SET(spri->pri->fd, &efds);
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+ if ((next = pri_schedule_next(spri->pri))) {
+ gettimeofday(&now, NULL);
+ now.tv_sec = next->tv_sec - now.tv_sec;
+ now.tv_usec = next->tv_usec - now.tv_usec;
+ if (now.tv_usec < 0) {
+ now.tv_usec += 1000000;
+ now.tv_sec -= 1;
+ }
+ if (now.tv_sec < 0) {
+ now.tv_sec = 0;
+ now.tv_usec = 0;
+ }
+ }
+
+ sel = select(spri->pri->fd + 1, &rfds, NULL, &efds, next ? &now : NULL);
+ event = NULL;
+
+ if (!sel) {
+ event = pri_schedule_run(spri->pri);
+ } else if (sel > 0) {
+ event = pri_check_event(spri->pri);
+ }
+
+ if (event) {
+ event_handler handler;
+ /* 0 is catchall event handler */
+ if ((handler = spri->eventmap[event->e] ? spri->eventmap[event->e] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) {
+ handler(spri, event->e, event);
+ } else {
+ fprintf(stderr,"No event handler found for event %d.\n", event->e);
+ }
+ }
+
+ return sel;
+}
+
+int sangoma_run_pri(struct sangoma_pri *spri)
+{
+ int ret = 0;
+
+ for (;;){
+ ret=sangoma_one_loop(spri);
+ if (ret < 0){
+
+#ifndef WIN32 //This needs to be adressed fror WIN32 still
+ if (errno == EINTR){
+ /* Igonore an interrupted system call */
+ continue;
+ }
+#endif
+ printf("Error = %i\n",ret);
+ perror("Sangoma Run Pri: ");
+ break;
+ }
+ }
+
+ return ret;
+
+}
+
--- /dev/null
+/*****************************************************************************
+ * libsangoma.c AFT T1/E1: HDLC API Code Library
+ *
+ * Author(s): Anthony Minessale II <anthmct@yahoo.com>
+ * Nenad Corbic <ncorbic@sangoma.com>
+ *
+ * Copyright: (c) 2005 Anthony Minessale II
+ *
+ * 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.
+ * ============================================================================
+ */
+
+#ifndef _SANGOMA_PRI_H
+#define _SANGOMA_PRI_H
+#include <libpri.h>
+#include <pri_internal.h>
+
+
+#define SANGOMA_MAX_CHAN_PER_SPAN 32
+
+typedef enum {
+ SANGOMA_PRI_EVENT_ANY = 0,
+ SANGOMA_PRI_EVENT_DCHAN_UP = PRI_EVENT_DCHAN_UP,
+ SANGOMA_PRI_EVENT_DCHAN_DOWN = PRI_EVENT_DCHAN_DOWN,
+ SANGOMA_PRI_EVENT_RESTART = PRI_EVENT_RESTART,
+ SANGOMA_PRI_EVENT_CONFIG_ERR = PRI_EVENT_CONFIG_ERR,
+ SANGOMA_PRI_EVENT_RING = PRI_EVENT_RING,
+ SANGOMA_PRI_EVENT_HANGUP = PRI_EVENT_HANGUP,
+ SANGOMA_PRI_EVENT_RINGING = PRI_EVENT_RINGING,
+ SANGOMA_PRI_EVENT_ANSWER = PRI_EVENT_ANSWER,
+ SANGOMA_PRI_EVENT_HANGUP_ACK = PRI_EVENT_HANGUP_ACK,
+ SANGOMA_PRI_EVENT_RESTART_ACK = PRI_EVENT_RESTART_ACK,
+ SANGOMA_PRI_EVENT_FACNAME = PRI_EVENT_FACNAME,
+ SANGOMA_PRI_EVENT_INFO_RECEIVED = PRI_EVENT_INFO_RECEIVED,
+ SANGOMA_PRI_EVENT_PROCEEDING = PRI_EVENT_PROCEEDING,
+ SANGOMA_PRI_EVENT_SETUP_ACK = PRI_EVENT_SETUP_ACK,
+ SANGOMA_PRI_EVENT_HANGUP_REQ = PRI_EVENT_HANGUP_REQ,
+ SANGOMA_PRI_EVENT_NOTIFY = PRI_EVENT_NOTIFY,
+ SANGOMA_PRI_EVENT_PROGRESS = PRI_EVENT_PROGRESS,
+ SANGOMA_PRI_EVENT_KEYPAD_DIGIT = PRI_EVENT_KEYPAD_DIGIT
+} sangoma_pri_event_t;
+
+typedef enum {
+ SANGOMA_PRI_NETWORK = PRI_NETWORK,
+ SANGOMA_PRI_CPE = PRI_CPE
+} sangoma_pri_node_t;
+
+typedef enum {
+ SANGOMA_PRI_SWITCH_UNKNOWN = PRI_SWITCH_UNKNOWN,
+ SANGOMA_PRI_SWITCH_NI2 = PRI_SWITCH_NI2,
+ SANGOMA_PRI_SWITCH_DMS100 = PRI_SWITCH_DMS100,
+ SANGOMA_PRI_SWITCH_LUCENT5E = PRI_SWITCH_LUCENT5E,
+ SANGOMA_PRI_SWITCH_ATT4ESS = PRI_SWITCH_ATT4ESS,
+ SANGOMA_PRI_SWITCH_EUROISDN_E1 = PRI_SWITCH_EUROISDN_E1,
+ SANGOMA_PRI_SWITCH_EUROISDN_T1 = PRI_SWITCH_EUROISDN_T1,
+ SANGOMA_PRI_SWITCH_NI1 = PRI_SWITCH_NI1,
+ SANGOMA_PRI_SWITCH_GR303_EOC = PRI_SWITCH_GR303_EOC,
+ SANGOMA_PRI_SWITCH_GR303_TMC = PRI_SWITCH_GR303_TMC,
+ SANGOMA_PRI_SWITCH_QSIG = PRI_SWITCH_QSIG
+} sangoma_pri_switch_t;
+
+typedef enum {
+ SANGOMA_PRI_READY = (1 << 0)
+} sangoma_pri_flag_t;
+
+struct sangoma_pri;
+typedef int (*event_handler)(struct sangoma_pri *, sangoma_pri_event_t, pri_event *);
+typedef int (*loop_handler)(struct sangoma_pri *);
+#define MAX_EVENT 18
+
+struct sangoma_pri {
+ struct pri *pri;
+ int span;
+ int dchan;
+ unsigned int flags;
+ void *private_info;
+ event_handler eventmap[MAX_EVENT+1];
+ loop_handler on_loop;
+ zap_channel_t *zdchan;
+};
+
+struct sangoma_pri_event_list {
+ int event_id;
+ int pri_event;
+ char *name;
+};
+
+
+
+#define SANGOMA_MAP_PRI_EVENT(spri, event, func) spri.eventmap[event] = func;
+
+char *sangoma_pri_event_str(sangoma_pri_event_t event_id);
+int sangoma_one_loop(struct sangoma_pri *spri);
+int sangoma_init_pri(struct sangoma_pri *spri, int span, int dchan, int swtype, int node, int debug);
+int sangoma_run_pri(struct sangoma_pri *spri);
+
+#endif
projects / thirdparty / freeswitch.git / commitdiff
