Skip to content

F
freeswitch
提交 b06e0aee authored 作者: Anthony Minessale's avatar Anthony Minessale
浏览文件
操作

update 

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@159 a93c3328-9c30-0410-af19-c9cd2b2d52af
上级 219ac87d
隐藏空白字符变更
内嵌 并排
正在显示 包含 667 行增加 和 5 行删除
libs/openzap/Makefile
浏览文件 @ b06e0aee
...@@ -65,7 +65,9 @@ PWD=$(shell pwd) ...@@ -65,7 +65,9 @@ PWD=$(shell pwd)
INCS=-I$(PWD)/$(SRC)//include -I$(PWD)/$(SRC)//isdn/include INCS=-I$(PWD)/$(SRC)//include -I$(PWD)/$(SRC)//isdn/include
CFLAGS=$(ZAP_CFLAGS) $(INCS) CFLAGS=$(ZAP_CFLAGS) $(INCS)
MYLIB=libopenzap.a 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) include general.makefile $(ZAP_MODS)
...@@ -84,14 +86,17 @@ testisdn: $(SRC)/testisdn.c $(MYLIB) ...@@ -84,14 +86,17 @@ testisdn: $(SRC)/testisdn.c $(MYLIB)
testanalog: $(SRC)/testanalog.c $(MYLIB) testanalog: $(SRC)/testanalog.c $(MYLIB)
$(CC) $(INCS) -L. $(SRC)/testanalog.c -o testanalog -lopenzap -lm -lpthread $(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 $(CC) $(INCS) $(TMP) -c $(SRC)/priserver.c -o $(SRC)/priserver.o
$(SRC)/sangoma_pri.o: $(SRC)/sangoma_pri.c $(SRC)/sangoma_pri.o: $(SRC)/sangoma_pri.c
$(CC) $(INCS) $(TMP) -c $(SRC)/sangoma_pri.c -o $(SRC)/sangoma_pri.o $(CC) $(INCS) $(TMP) -c $(SRC)/sangoma_pri.c -o $(SRC)/sangoma_pri.o
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-1.2.4/libpri.a 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 $(SRC)/zap_io.o: $(SRC)/zap_io.c
$(CC) $(MOD_CFLAGS) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@ $(CC) $(MOD_CFLAGS) $(CC_CFLAGS) $(CFLAGS) -c $< -o $@
...@@ -117,8 +122,9 @@ mod_openzap-install: mod_openzap ...@@ -117,8 +122,9 @@ mod_openzap-install: mod_openzap
cd mod_openzap && make install cd mod_openzap && make install
mod_openzap-clean: 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 clean: mod_openzap-clean
rm -f $(SRC)/*.o $(SRC)/isdn/*.o $(MYLIB) *~ \#* testapp priserver testisdn testanalog rm -f $(SRC)/*.o $(SRC)/isdn/*.o $(MYLIB) *~ \#* testapp priserver testisdn testanalog
@if [ -f $(LIBPRI)/$(LIBPRIA) ] ; then cd $(LIBPRI) && make clean ; fi
libs/openzap/src/priserver.c 0 → 100644
浏览文件 @ b06e0aee
/*****************************************************************************
* 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;
}
libs/openzap/src/sangoma_pri.c 0 → 100644
浏览文件 @ b06e0aee
/*****************************************************************************
* 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;
}
libs/openzap/src/sangoma_pri.h 0 → 100644
浏览文件 @ b06e0aee
/*****************************************************************************
* 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
Markdown 格式
0% 或
您添加了 0 人 到此讨论。请谨慎行事。
请先完成此评论的编辑！
请 注册 或者 后发表评论