From 900f1ed2efdeb162116319a0281923cc8756c2e7 Mon Sep 17 00:00:00 2001 From: Moises Silva Date: Fri, 15 Jan 2010 19:22:49 +0000 Subject: [PATCH] Linux renaming from openzap to freetdm git-svn-id: http://svn.openzap.org/svn/openzap/branches/sangoma_boost@967 a93c3328-9c30-0410-af19-c9cd2b2d52af --- libs/freetdm/Makefile.am | 180 +- libs/freetdm/configure.ac | 24 +- libs/freetdm/{openzap.pc.in => freetdm.pc.in} | 0 libs/freetdm/mod_freetdm/Makefile.in | 23 + .../mod_freetdm.c} | 852 ++-- .../mod_openzap.2005.vcproj | 0 .../mod_openzap.2008.vcproj | 0 libs/freetdm/mod_openzap/Makefile.in | 23 - libs/freetdm/ozrename.sh | 54 +- libs/freetdm/src/detect_dtmf.c | 2 +- libs/freetdm/src/detect_tones.c | 2 +- libs/freetdm/src/fsk.c | 14 +- .../src/{zap_buffer.c => ftdm_buffer.c} | 86 +- .../src/{zap_callerid.c => ftdm_callerid.c} | 106 +- .../src/{zap_config.c => ftdm_config.c} | 38 +- libs/freetdm/src/{zap_dso.c => ftdm_dso.c} | 26 +- libs/freetdm/src/ftdm_io.c | 3754 +++++++++++++++++ libs/freetdm/src/{zap_m3ua.c => ftdm_m3ua.c} | 284 +- .../freetdm/src/{zap_queue.c => ftdm_queue.c} | 130 +- .../{zap_threadmutex.c => ftdm_threadmutex.c} | 162 +- .../ftmod_analog/ftdm_analog.h} | 22 +- .../src/ftmod/ftmod_analog/ftmod_analog.c | 977 +++++ .../ftmod_analog}/ozmod_analog.2005.vcproj | 0 .../ftmod_analog}/ozmod_analog.2008.vcproj | 0 .../ftmod_analog_em/ftdm_analog_em.h} | 16 +- .../ftmod/ftmod_analog_em/ftmod_analog_em.c | 709 ++++ .../ozmod_analog_em.2005.vcproj | 0 .../ozmod_analog_em.2008.vcproj | 0 .../ftmod_isdn/ftdm_isdn.h} | 48 +- .../ftmod_isdn/ftmod_isdn.c} | 1120 ++--- .../ftmod_isdn}/ozmod_isdn.2005.vcproj | 0 .../ftmod_isdn}/ozmod_isdn.2008.vcproj | 0 .../ftmod_libpri/ftmod_libpri.c} | 662 +-- .../ftmod_libpri/ftmod_libpri.h} | 38 +- .../ftmod_libpri}/lpwrap_pri.c | 40 +- .../ftmod_libpri}/lpwrap_pri.h | 8 +- .../ftmod_pika/ftdm_pika.h} | 6 +- .../ftmod_pika/ftmod_pika.c} | 620 +-- .../ftmod_pika}/ozmod_pika.2005.vcproj | 0 .../ftmod_pika}/ozmod_pika.2008.vcproj | 0 libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c | 1367 ++++++ .../ftmod_sangoma_boost}/BOOST.limitations | 0 .../ftmod_sangoma_boost/ftdm_sangoma_boost.h} | 28 +- .../ftmod_sangoma_boost.c} | 1088 ++--- .../ozmod_sangoma_boost.2008.vcproj | 0 .../sangoma_boost_client.c | 84 +- .../sangoma_boost_client.h | 10 +- .../sangoma_boost_interface.h | 102 +- .../ftmod_sangoma_boost}/sigboost.h | 6 +- .../ftmod_skel/ftmod_skel.c} | 38 +- .../ftmod_wanpipe/ftmod_wanpipe.c} | 500 +-- .../ftmod_wanpipe}/ozmod_wanpipe.2005.vcproj | 0 .../ftmod_wanpipe}/ozmod_wanpipe.2008.vcproj | 0 .../ftmod_wanpipe}/wanpipe_tdm_api_iface.h | 0 .../ozmod_zt.c => ftmod/ftmod_zt/ftmod_zt.c} | 588 +-- .../ozmod_zt.h => ftmod/ftmod_zt/ftmod_zt.h} | 14 +- libs/freetdm/src/hashtable.c | 40 +- libs/freetdm/src/hashtable_itr.c | 6 +- libs/freetdm/src/include/hashtable.h | 20 +- libs/freetdm/src/include/libteletone.h | 8 +- libs/freetdm/src/include/libteletone_detect.h | 4 +- libs/freetdm/src/include/openzap.h | 932 ---- libs/freetdm/src/include/zap_buffer.h | 154 - libs/freetdm/src/include/zap_config.h | 145 - libs/freetdm/src/include/zap_dso.h | 51 - libs/freetdm/src/include/zap_m3ua.h | 134 - libs/freetdm/src/include/zap_threadmutex.h | 67 - libs/freetdm/src/include/zap_types.h | 703 --- libs/freetdm/src/isdn/Q921.c | 4 +- libs/freetdm/src/libteletone_generate.c | 10 +- libs/freetdm/src/m3ua_client.c | 40 +- libs/freetdm/src/m3ua_client.h | 6 +- .../src/ozmod/ozmod_analog/ozmod_analog.c | 977 ----- .../ozmod/ozmod_analog_em/ozmod_analog_em.c | 709 ---- libs/freetdm/src/ozmod/ozmod_r2/ozmod_r2.c | 1367 ------ libs/freetdm/src/priserver.c | 56 +- libs/freetdm/src/sangoma_pri.c | 18 +- libs/freetdm/src/sangoma_pri.h | 2 +- libs/freetdm/src/testanalog.c | 76 +- libs/freetdm/src/testapp.c | 40 +- libs/freetdm/src/testboost.c | 34 +- libs/freetdm/src/testcid.c | 50 +- libs/freetdm/src/testisdn.c | 28 +- libs/freetdm/src/testm3ua.c | 32 +- libs/freetdm/src/testpri.c | 70 +- libs/freetdm/src/testr2.c | 42 +- libs/freetdm/src/testsangomaboost.c | 34 +- libs/freetdm/src/testtones.c | 2 +- libs/freetdm/src/uart.c | 6 +- libs/freetdm/src/zap_io.c | 3754 ----------------- 90 files changed, 10653 insertions(+), 12819 deletions(-) rename libs/freetdm/{openzap.pc.in => freetdm.pc.in} (100%) create mode 100644 libs/freetdm/mod_freetdm/Makefile.in rename libs/freetdm/{mod_openzap/mod_openzap.c => mod_freetdm/mod_freetdm.c} (74%) rename libs/freetdm/{mod_openzap => mod_freetdm}/mod_openzap.2005.vcproj (100%) rename libs/freetdm/{mod_openzap => mod_freetdm}/mod_openzap.2008.vcproj (100%) delete mode 100644 libs/freetdm/mod_openzap/Makefile.in rename libs/freetdm/src/{zap_buffer.c => ftdm_buffer.c} (71%) rename libs/freetdm/src/{zap_callerid.c => ftdm_callerid.c} (61%) rename libs/freetdm/src/{zap_config.c => ftdm_config.c} (77%) rename libs/freetdm/src/{zap_dso.c => ftdm_dso.c} (80%) create mode 100644 libs/freetdm/src/ftdm_io.c rename libs/freetdm/src/{zap_m3ua.c => ftdm_m3ua.c} (62%) rename libs/freetdm/src/{zap_queue.c => ftdm_queue.c} (50%) rename libs/freetdm/src/{zap_threadmutex.c => ftdm_threadmutex.c} (59%) rename libs/freetdm/src/{ozmod/ozmod_analog/zap_analog.h => ftmod/ftmod_analog/ftdm_analog.h} (84%) create mode 100644 libs/freetdm/src/ftmod/ftmod_analog/ftmod_analog.c rename libs/freetdm/src/{ozmod/ozmod_analog => ftmod/ftmod_analog}/ozmod_analog.2005.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_analog => ftmod/ftmod_analog}/ozmod_analog.2008.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_analog_em/zap_analog_em.h => ftmod/ftmod_analog_em/ftdm_analog_em.h} (87%) create mode 100644 libs/freetdm/src/ftmod/ftmod_analog_em/ftmod_analog_em.c rename libs/freetdm/src/{ozmod/ozmod_analog_em => ftmod/ftmod_analog_em}/ozmod_analog_em.2005.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_analog_em => ftmod/ftmod_analog_em}/ozmod_analog_em.2008.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_isdn/zap_isdn.h => ftmod/ftmod_isdn/ftdm_isdn.h} (69%) rename libs/freetdm/src/{ozmod/ozmod_isdn/ozmod_isdn.c => ftmod/ftmod_isdn/ftmod_isdn.c} (55%) rename libs/freetdm/src/{ozmod/ozmod_isdn => ftmod/ftmod_isdn}/ozmod_isdn.2005.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_isdn => ftmod/ftmod_isdn}/ozmod_isdn.2008.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_libpri/ozmod_libpri.c => ftmod/ftmod_libpri/ftmod_libpri.c} (51%) rename libs/freetdm/src/{ozmod/ozmod_libpri/ozmod_libpri.h => ftmod/ftmod_libpri/ftmod_libpri.h} (76%) rename libs/freetdm/src/{ozmod/ozmod_libpri => ftmod/ftmod_libpri}/lpwrap_pri.c (85%) rename libs/freetdm/src/{ozmod/ozmod_libpri => ftmod/ftmod_libpri}/lpwrap_pri.h (95%) rename libs/freetdm/src/{ozmod/ozmod_pika/zap_pika.h => ftmod/ftmod_pika/ftdm_pika.h} (98%) rename libs/freetdm/src/{ozmod/ozmod_pika/ozmod_pika.c => ftmod/ftmod_pika/ftmod_pika.c} (67%) rename libs/freetdm/src/{ozmod/ozmod_pika => ftmod/ftmod_pika}/ozmod_pika.2005.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_pika => ftmod/ftmod_pika}/ozmod_pika.2008.vcproj (100%) create mode 100644 libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost => ftmod/ftmod_sangoma_boost}/BOOST.limitations (100%) rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost/zap_sangoma_boost.h => ftmod/ftmod_sangoma_boost/ftdm_sangoma_boost.h} (81%) rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.c => ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c} (51%) rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost => ftmod/ftmod_sangoma_boost}/ozmod_sangoma_boost.2008.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost => ftmod/ftmod_sangoma_boost}/sangoma_boost_client.c (82%) rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost => ftmod/ftmod_sangoma_boost}/sangoma_boost_client.h (98%) rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost => ftmod/ftmod_sangoma_boost}/sangoma_boost_interface.h (66%) rename libs/freetdm/src/{ozmod/ozmod_sangoma_boost => ftmod/ftmod_sangoma_boost}/sigboost.h (97%) rename libs/freetdm/src/{ozmod/ozmod_skel/ozmod_skel.c => ftmod/ftmod_skel/ftmod_skel.c} (88%) rename libs/freetdm/src/{ozmod/ozmod_wanpipe/ozmod_wanpipe.c => ftmod/ftmod_wanpipe/ftmod_wanpipe.c} (58%) rename libs/freetdm/src/{ozmod/ozmod_wanpipe => ftmod/ftmod_wanpipe}/ozmod_wanpipe.2005.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_wanpipe => ftmod/ftmod_wanpipe}/ozmod_wanpipe.2008.vcproj (100%) rename libs/freetdm/src/{ozmod/ozmod_wanpipe => ftmod/ftmod_wanpipe}/wanpipe_tdm_api_iface.h (100%) rename libs/freetdm/src/{ozmod/ozmod_zt/ozmod_zt.c => ftmod/ftmod_zt/ftmod_zt.c} (52%) rename libs/freetdm/src/{ozmod/ozmod_zt/ozmod_zt.h => ftmod/ftmod_zt/ftmod_zt.h} (97%) delete mode 100644 libs/freetdm/src/include/openzap.h delete mode 100644 libs/freetdm/src/include/zap_buffer.h delete mode 100644 libs/freetdm/src/include/zap_config.h delete mode 100644 libs/freetdm/src/include/zap_dso.h delete mode 100644 libs/freetdm/src/include/zap_m3ua.h delete mode 100644 libs/freetdm/src/include/zap_threadmutex.h delete mode 100644 libs/freetdm/src/include/zap_types.h delete mode 100644 libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.c delete mode 100644 libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.c delete mode 100644 libs/freetdm/src/ozmod/ozmod_r2/ozmod_r2.c delete mode 100644 libs/freetdm/src/zap_io.c diff --git a/libs/freetdm/Makefile.am b/libs/freetdm/Makefile.am index 770291e461..5f829b6614 100644 --- a/libs/freetdm/Makefile.am +++ b/libs/freetdm/Makefile.am @@ -36,11 +36,11 @@ moddir = @modinstdir@ libdir = @libdir@ library_includedir = $(PREFIX)/include -INCS = -I$(OZ_SRCDIR)/$(SRC)/include -I$(OZ_SRCDIR)/$(SRC)/isdn/include +INCS = -I$(FT_SRCDIR)/$(SRC)/include -I$(FT_SRCDIR)/$(SRC)/isdn/include if HAVE_SCTP -INCS += -I$(OZ_SRCDIR)/$(SRC)/ozmod/ozmod_sangoma_boost +INCS += -I$(FT_SRCDIR)/$(SRC)/ftmod/ftmod_sangoma_boost endif -MY_CFLAGS = $(INCS) $(ZAP_CFLAGS) -DZAP_CONFIG_DIR=\"@confdir@\" -DZAP_MOD_DIR=\"$(moddir)\" @COMP_VENDOR_CFLAGS@ @DEFS@ +MY_CFLAGS = $(INCS) $(FTDM_CFLAGS) -DFTDM_CONFIG_DIR=\"@confdir@\" -DFTDM_MOD_DIR=\"$(moddir)\" @COMP_VENDOR_CFLAGS@ @DEFS@ COMPILE = $(CC) $(MY_CFLAGS) $(INCS) LTCOMPILE = $(LIBTOOL) --mode=compile --tag=CC $(COMPILE) LINK = $(LIBTOOL) --mode=link --tag=CC $(CC) $(MY_CFLAGS) $(LDFLAGS) -o $@ @@ -49,30 +49,30 @@ LINK = $(LIBTOOL) --mode=link --tag=CC $(CC) $(MY_CFLAGS) $(LDFLAGS) -o $@ # # GNU pkgconfig file # -EXTRA_DIST = openzap.pc.in +EXTRA_DIST = freetdm.pc.in pkgconfigdir = $(libdir)/pkgconfig -pkgconfig_DATA = openzap.pc +pkgconfig_DATA = freetdm.pc # -# libopenzap +# libfreetdm # -libopenzap_la_SOURCES = \ +libfreetdm_la_SOURCES = \ $(SRC)/hashtable.c \ $(SRC)/hashtable_itr.c \ -$(SRC)/zap_io.c \ -$(SRC)/zap_queue.c \ -$(SRC)/zap_config.c \ -$(SRC)/zap_callerid.c \ +$(SRC)/ftdm_io.c \ +$(SRC)/ftdm_queue.c \ +$(SRC)/ftdm_config.c \ +$(SRC)/ftdm_callerid.c \ $(SRC)/fsk.c \ $(SRC)/uart.c \ $(SRC)/g711.c \ $(SRC)/libteletone_detect.c \ $(SRC)/libteletone_generate.c \ -$(SRC)/zap_buffer.c \ -$(SRC)/zap_threadmutex.c \ -$(SRC)/zap_dso.c +$(SRC)/ftdm_buffer.c \ +$(SRC)/ftdm_threadmutex.c \ +$(SRC)/ftdm_dso.c library_include_HEADERS = \ $(SRC)/include/fsk.h \ @@ -83,23 +83,23 @@ $(SRC)/include/hashtable_private.h \ $(SRC)/include/libteletone_detect.h \ $(SRC)/include/libteletone_generate.h \ $(SRC)/include/libteletone.h \ -$(SRC)/include/openzap.h \ +$(SRC)/include/freetdm.h \ $(SRC)/include/sangoma_tdm_api.h \ $(SRC)/include/uart.h \ -$(SRC)/include/zap_buffer.h \ -$(SRC)/include/zap_config.h \ -$(SRC)/include/zap_threadmutex.h \ -$(SRC)/include/zap_dso.h \ -$(SRC)/include/zap_types.h +$(SRC)/include/ftdm_buffer.h \ +$(SRC)/include/ftdm_config.h \ +$(SRC)/include/ftdm_threadmutex.h \ +$(SRC)/include/ftdm_dso.h \ +$(SRC)/include/ftdm_types.h -lib_LTLIBRARIES = libopenzap.la -libopenzap_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -libopenzap_la_LDFLAGS = -version-info 1:0:0 $(AM_LDFLAGS) -libopenzap_la_LIBADD = $(LIBS) +lib_LTLIBRARIES = libfreetdm.la +libfreetdm_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +libfreetdm_la_LDFLAGS = -version-info 1:0:0 $(AM_LDFLAGS) +libfreetdm_la_LIBADD = $(LIBS) -MYLIB = libopenzap.la +MYLIB = libfreetdm.la -core: libopenzap.la +core: libfreetdm.la core-install: install-libLTLIBRARIES # @@ -112,91 +112,91 @@ endif noinst_PROGRAMS += testsangomaboost testapp_SOURCES = $(SRC)/testapp.c -testapp_LDADD = libopenzap.la +testapp_LDADD = libfreetdm.la testapp_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) testcid_SOURCES = $(SRC)/testcid.c -testcid_LDADD = libopenzap.la +testcid_LDADD = libfreetdm.la testcid_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) testtones_SOURCES = $(SRC)/testtones.c -testtones_LDADD = libopenzap.la +testtones_LDADD = libfreetdm.la testtones_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) detect_tones_SOURCES = $(SRC)/detect_tones.c -detect_tones_LDADD = libopenzap.la +detect_tones_LDADD = libfreetdm.la detect_tones_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) detect_dtmf_SOURCES = $(SRC)/detect_dtmf.c -detect_dtmf_LDADD = libopenzap.la +detect_dtmf_LDADD = libfreetdm.la detect_dtmf_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) testisdn_SOURCES = $(SRC)/testisdn.c -testisdn_LDADD = libopenzap.la +testisdn_LDADD = libfreetdm.la testisdn_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) testpri_SOURCES = $(SRC)/testpri.c -testpri_LDADD = libopenzap.la +testpri_LDADD = libfreetdm.la testpri_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) testr2_SOURCES = $(SRC)/testr2.c -testr2_LDADD = libopenzap.la +testr2_LDADD = libfreetdm.la testr2_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) if HAVE_SCTP testboost_SOURCES = $(SRC)/testboost.c -testboost_LDADD = libopenzap.la +testboost_LDADD = libfreetdm.la testboost_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) endif testsangomaboost_SOURCES = $(SRC)/testsangomaboost.c -testsangomaboost_LDADD = libopenzap.la +testsangomaboost_LDADD = libfreetdm.la testsangomaboost_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) testanalog_SOURCES = $(SRC)/testanalog.c -testanalog_LDADD = libopenzap.la +testanalog_LDADD = libfreetdm.la testanalog_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) # -# ozmod modules +# ftmod modules # -mod_LTLIBRARIES = ozmod_zt.la ozmod_skel.la ozmod_isdn.la ozmod_analog.la ozmod_analog_em.la +mod_LTLIBRARIES = ftmod_zt.la ftmod_skel.la ftmod_isdn.la ftmod_analog.la ftmod_analog_em.la if HAVE_SCTP -mod_LTLIBRARIES += ozmod_sangoma_boost.la +mod_LTLIBRARIES += ftmod_sangoma_boost.la endif if LIBSANGOMA -mod_LTLIBRARIES += ozmod_wanpipe.la +mod_LTLIBRARIES += ftmod_wanpipe.la endif if LIBPRI -mod_LTLIBRARIES += ozmod_libpri.la +mod_LTLIBRARIES += ftmod_libpri.la endif if OPENR2 -mod_LTLIBRARIES += ozmod_r2.la +mod_LTLIBRARIES += ftmod_r2.la endif -ozmod_zt_la_SOURCES = $(SRC)/ozmod/ozmod_zt/ozmod_zt.c -ozmod_zt_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -ozmod_zt_la_LDFLAGS = -module -avoid-version -ozmod_zt_la_LIBADD = $(MYLIB) +ftmod_zt_la_SOURCES = $(SRC)/ftmod/ftmod_zt/ftmod_zt.c +ftmod_zt_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +ftmod_zt_la_LDFLAGS = -module -avoid-version +ftmod_zt_la_LIBADD = $(MYLIB) -ozmod_skel_la_SOURCES = $(SRC)/ozmod/ozmod_skel/ozmod_skel.c -ozmod_skel_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -ozmod_skel_la_LDFLAGS = -module -avoid-version -ozmod_skel_la_LIBADD = $(MYLIB) +ftmod_skel_la_SOURCES = $(SRC)/ftmod/ftmod_skel/ftmod_skel.c +ftmod_skel_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +ftmod_skel_la_LDFLAGS = -module -avoid-version +ftmod_skel_la_LIBADD = $(MYLIB) if LIBSANGOMA -ozmod_wanpipe_la_SOURCES = $(SRC)/ozmod/ozmod_wanpipe/ozmod_wanpipe.c -ozmod_wanpipe_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -D__LINUX__ -I/usr/include/wanpipe -ozmod_wanpipe_la_LDFLAGS = -module -avoid-version -lsangoma -ozmod_wanpipe_la_LIBADD = $(MYLIB) +ftmod_wanpipe_la_SOURCES = $(SRC)/ftmod/ftmod_wanpipe/ftmod_wanpipe.c +ftmod_wanpipe_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -D__LINUX__ -I/usr/include/wanpipe +ftmod_wanpipe_la_LDFLAGS = -module -avoid-version -lsangoma +ftmod_wanpipe_la_LIBADD = $(MYLIB) endif -ozmod_isdn_la_SOURCES = \ +ftmod_isdn_la_SOURCES = \ $(SRC)/isdn/EuroISDNStateNT.c \ $(SRC)/isdn/EuroISDNStateTE.c \ $(SRC)/isdn/mfifo.c \ @@ -217,60 +217,60 @@ $(SRC)/isdn/5ESSmes.c \ $(SRC)/isdn/5ESSStateNT.c \ $(SRC)/isdn/5ESSStateTE.c \ $(SRC)/isdn/Q932mes.c \ -$(SRC)/ozmod/ozmod_isdn/ozmod_isdn.c +$(SRC)/ftmod/ftmod_isdn/ftmod_isdn.c -ozmod_isdn_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -D_GNU_SOURCE -ozmod_isdn_la_LDFLAGS = $(PCAP_LIB_FLAGS) -module -avoid-version -ozmod_isdn_la_LIBADD = $(MYLIB) +ftmod_isdn_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -D_GNU_SOURCE +ftmod_isdn_la_LDFLAGS = $(PCAP_LIB_FLAGS) -module -avoid-version +ftmod_isdn_la_LIBADD = $(MYLIB) -ozmod_analog_la_SOURCES = $(SRC)/ozmod/ozmod_analog/ozmod_analog.c -ozmod_analog_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -ozmod_analog_la_LDFLAGS = -module -avoid-version -ozmod_analog_la_LIBADD = $(MYLIB) +ftmod_analog_la_SOURCES = $(SRC)/ftmod/ftmod_analog/ftmod_analog.c +ftmod_analog_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +ftmod_analog_la_LDFLAGS = -module -avoid-version +ftmod_analog_la_LIBADD = $(MYLIB) -ozmod_analog_em_la_SOURCES = $(SRC)/ozmod/ozmod_analog_em/ozmod_analog_em.c -ozmod_analog_em_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -ozmod_analog_em_la_LDFLAGS = -module -avoid-version -ozmod_analog_em_la_LIBADD = $(MYLIB) +ftmod_analog_em_la_SOURCES = $(SRC)/ftmod/ftmod_analog_em/ftmod_analog_em.c +ftmod_analog_em_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +ftmod_analog_em_la_LDFLAGS = -module -avoid-version +ftmod_analog_em_la_LIBADD = $(MYLIB) if HAVE_SCTP -ozmod_sangoma_boost_la_SOURCES = $(SRC)/ozmod/ozmod_sangoma_boost/sangoma_boost_client.c $(SRC)/ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.c -ozmod_sangoma_boost_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -ozmod_sangoma_boost_la_LDFLAGS = -module -avoid-version -ozmod_sangoma_boost_la_LIBADD = $(MYLIB) +ftmod_sangoma_boost_la_SOURCES = $(SRC)/ftmod/ftmod_sangoma_boost/sangoma_boost_client.c $(SRC)/ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c +ftmod_sangoma_boost_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +ftmod_sangoma_boost_la_LDFLAGS = -module -avoid-version +ftmod_sangoma_boost_la_LIBADD = $(MYLIB) endif if LIBPRI -ozmod_libpri_la_SOURCES = $(SRC)/ozmod/ozmod_libpri/ozmod_libpri.c $(SRC)/ozmod/ozmod_libpri/lpwrap_pri.c -ozmod_libpri_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -ozmod_libpri_la_LDFLAGS = -module -avoid-version -lpri -ozmod_libpri_la_LIBADD = $(MYLIB) +ftmod_libpri_la_SOURCES = $(SRC)/ftmod/ftmod_libpri/ftmod_libpri.c $(SRC)/ftmod/ftmod_libpri/lpwrap_pri.c +ftmod_libpri_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +ftmod_libpri_la_LDFLAGS = -module -avoid-version -lpri +ftmod_libpri_la_LIBADD = $(MYLIB) endif if OPENR2 -ozmod_r2_la_SOURCES = $(SRC)/ozmod/ozmod_r2/ozmod_r2.c -ozmod_r2_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) -ozmod_r2_la_LDFLAGS = -module -avoid-version -lopenr2 -ozmod_r2_la_LIBADD = $(MYLIB) +ftmod_r2_la_SOURCES = $(SRC)/ftmod/ftmod_r2/ftmod_r2.c +ftmod_r2_la_CFLAGS = $(AM_CFLAGS) $(MY_CFLAGS) +ftmod_r2_la_LDFLAGS = -module -avoid-version -lopenr2 +ftmod_r2_la_LIBADD = $(MYLIB) endif dox doxygen: - cd docs && doxygen $(OZ_SRCDIR)/docs/Doxygen.conf + cd docs && doxygen $(FT_SRCDIR)/docs/Doxygen.conf -mod_openzap/mod_openzap.$(DYNAMIC_LIB_EXTEN): $(MYLIB) mod_openzap/mod_openzap.c - cd mod_openzap && make +mod_freetdm/mod_freetdm.$(DYNAMIC_LIB_EXTEN): $(MYLIB) mod_freetdm/mod_freetdm.c + cd mod_freetdm && make -mod_openzap: mod_openzap/mod_openzap.$(DYNAMIC_LIB_EXTEN) +mod_freetdm: mod_freetdm/mod_freetdm.$(DYNAMIC_LIB_EXTEN) -mod_openzap-install: mod_openzap - cd mod_openzap && make install +mod_freetdm-install: mod_freetdm + cd mod_freetdm && make install -mod_openzap-clean: - @if [ -f mod_openzap/mod_openzap.$(DYNAMIC_LIB_EXTEN) ] ; then cd mod_openzap && make clean ; fi +mod_freetdm-clean: + @if [ -f mod_freetdm/mod_freetdm.$(DYNAMIC_LIB_EXTEN) ] ; then cd mod_freetdm && make clean ; fi install-data-local: $(mkinstalldirs) $(DESTDIR)$(PREFIX) $(mkinstalldirs) $(DESTDIR)@confdir@ - @[ -f "$(DESTDIR)@confdir@/openzap.conf" ] || ( cp conf/*.conf $(DESTDIR)@confdir@) - @echo OpenZAP Installed + @[ -f "$(DESTDIR)@confdir@/freetdm.conf" ] || ( cp conf/*.conf $(DESTDIR)@confdir@) + @echo OpenFTDM Installed diff --git a/libs/freetdm/configure.ac b/libs/freetdm/configure.ac index f1bba93f1e..fc141e888e 100644 --- a/libs/freetdm/configure.ac +++ b/libs/freetdm/configure.ac @@ -2,28 +2,28 @@ # Process this file with autoconf to produce a configure script. AC_PREREQ(2.59) -AC_INIT([openzap],[pre-alpha],[bugs@freeswitch.org]) -AC_CONFIG_SRCDIR([src/zap_io.c]) +AC_INIT([freetdm],[pre-alpha],[bugs@freeswitch.org]) +AC_CONFIG_SRCDIR([src/ftdm_io.c]) AC_CONFIG_AUX_DIR(build) -AM_INIT_AUTOMAKE(libopenzap,0.1) +AM_INIT_AUTOMAKE(libfreetdm,0.1) # Checks for programs. AC_PROG_CC AC_PROG_MAKE_SET AM_PROG_CC_C_O -AC_PREFIX_DEFAULT(/usr/local/openzap) +AC_PREFIX_DEFAULT(/usr/local/freetdm) # AC_PREFIX_DEFAULT does not get expanded until too late so we need to do this to use prefix in this script if test "x$prefix" = "xNONE" ; then - prefix='/usr/local/openzap' + prefix='/usr/local/freetdm' fi # Absolute source/build directory -OZ_SRCDIR=`(cd $srcdir && pwd)` -oz_builddir=`pwd` -AC_SUBST(OZ_SRCDIR) -AC_SUBST(oz_builddir) +FT_SRCDIR=`(cd $srcdir && pwd)` +ft_builddir=`pwd` +AC_SUBST(FT_SRCDIR) +AC_SUBST(ft_builddir) if test "$sysconfdir" = "\${prefix}/etc" ; then confdir="$prefix/conf" @@ -162,7 +162,7 @@ AC_SUBST(modinstdir) # libpri? AC_ARG_WITH([libpri], - [AS_HELP_STRING([--with-libpri], [Install ozmod_libpri])], [enable_libpri="yes"], [enable_libpri="no"]) + [AS_HELP_STRING([--with-libpri], [Install ftmod_libpri])], [enable_libpri="yes"], [enable_libpri="no"]) AC_SUBST(enable_libpri) AC_CHECK_LIB([sangoma], [sangoma_span_chan_toif], [have_libsangoma="yes"]) @@ -176,6 +176,6 @@ AM_CONDITIONAL([OPENR2],[test "${have_openr2}" = "yes"]) COMP_VENDOR_CFLAGS="$COMP_VENDOR_CFLAGS" AC_SUBST(COMP_VENDOR_CFLAGS) AC_CONFIG_FILES([Makefile - openzap.pc - mod_openzap/Makefile]) + freetdm.pc + mod_freetdm/Makefile]) AC_OUTPUT diff --git a/libs/freetdm/openzap.pc.in b/libs/freetdm/freetdm.pc.in similarity index 100% rename from libs/freetdm/openzap.pc.in rename to libs/freetdm/freetdm.pc.in diff --git a/libs/freetdm/mod_freetdm/Makefile.in b/libs/freetdm/mod_freetdm/Makefile.in new file mode 100644 index 0000000000..ceea0dfbba --- /dev/null +++ b/libs/freetdm/mod_freetdm/Makefile.in @@ -0,0 +1,23 @@ +FT_CFLAGS=@CFLAGS@ @COMP_VENDOR_CFLAGS@ @DEFS@ + +BASE=../../.. +FT_DIR=.. +VERBOSE=1 +FTLA=$(FT_DIR)/libfreetdm.la +LOCAL_CFLAGS=-I$(FT_DIR)/src/include -I$(FT_DIR)/src/isdn/include $(FT_CFLAGS) +LOCAL_LDFLAGS=-L$(FT_DIR) -lfreetdm +include $(BASE)/build/modmake.rules + +local_depend: $(FTLA) + +$(FTLA): $(FT_DIR)/.update + cd $(FT_DIR) && $(MAKE) + +local_install: + cd $(FT_DIR) && $(MAKE) install + [ -f $(DESTDIR)@confdir@/autoload_configs/freetdm.conf.xml ] || cp -f $(FT_DIR)/conf/freetdm.conf.xml $(DESTDIR)@confdir@/autoload_configs + +local_clean: + cd $(FT_DIR) && $(MAKE) clean + + diff --git a/libs/freetdm/mod_openzap/mod_openzap.c b/libs/freetdm/mod_freetdm/mod_freetdm.c similarity index 74% rename from libs/freetdm/mod_openzap/mod_openzap.c rename to libs/freetdm/mod_freetdm/mod_freetdm.c index 6d283eaf3f..f2676ef6c7 100644 --- a/libs/freetdm/mod_openzap/mod_openzap.c +++ b/libs/freetdm/mod_freetdm/mod_freetdm.c @@ -4,10 +4,10 @@ * * Version: MPL 1.1 * - * The contents of this file are subject to the Mozilla Public License Version + * The contents of this file are subject to the Mftilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ + * http://www.mftilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License @@ -27,24 +27,24 @@ * Moises Silva * * - * mod_openzap.c -- OPENZAP Endpoint Module + * mod_freetdm.c -- OPENFTDM Endpoint Module * */ #include -#include "openzap.h" +#include "freetdm.h" #ifndef __FUNCTION__ #define __FUNCTION__ __SWITCH_FUNC__ #endif -#define OPENZAP_VAR_PREFIX "openzap_" -#define OPENZAP_VAR_PREFIX_LEN 8 +#define OPENFTDM_VAR_PREFIX "freetdm_" +#define OPENFTDM_VAR_PREFIX_LEN 8 -SWITCH_MODULE_LOAD_FUNCTION(mod_openzap_load); -SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_openzap_shutdown); -SWITCH_MODULE_DEFINITION(mod_openzap, mod_openzap_load, mod_openzap_shutdown, NULL); +SWITCH_MODULE_LOAD_FUNCTION(mod_freetdm_load); +SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_freetdm_shutdown); +SWITCH_MODULE_DEFINITION(mod_freetdm, mod_freetdm_load, mod_freetdm_shutdown, NULL); -switch_endpoint_interface_t *openzap_endpoint_interface; +switch_endpoint_interface_t *freetdm_endpoint_interface; static switch_memory_pool_t *module_pool = NULL; @@ -55,7 +55,7 @@ typedef enum { } analog_option_t; struct span_config { - zap_span_t *span; + ftdm_span_t *span; char dialplan[80]; char context[80]; char dial_regex[256]; @@ -65,7 +65,7 @@ struct span_config { analog_option_t analog_options; }; -static struct span_config SPAN_CONFIG[ZAP_MAX_SPANS_INTERFACE] = {{0}}; +static struct span_config SPAN_CONFIG[FTDM_MAX_SPANS_INTERFACE] = {{0}}; typedef enum { TFLAG_IO = (1 << 0), @@ -108,7 +108,7 @@ struct private_object { unsigned short samprate; switch_mutex_t *mutex; switch_mutex_t *flag_mutex; - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; uint32_t wr_error; }; @@ -129,31 +129,31 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi static switch_status_t channel_read_frame(switch_core_session_t *session, switch_frame_t **frame, switch_io_flag_t flags, int stream_id); static switch_status_t channel_write_frame(switch_core_session_t *session, switch_frame_t *frame, switch_io_flag_t flags, int stream_id); static switch_status_t channel_kill_channel(switch_core_session_t *session, int sig); -zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t **sp); -void dump_chan(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream); -void dump_chan_xml(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream); +ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session_t **sp); +void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream); +void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream); -static switch_core_session_t *zap_channel_get_session(zap_channel_t *channel, int32_t id) +static switch_core_session_t *ftdm_channel_get_session(ftdm_channel_t *channel, int32_t id) { switch_core_session_t *session = NULL; - if (id > ZAP_MAX_TOKENS) { + if (id > FTDM_MAX_TOKENS) { return NULL; } if (!zstr(channel->tokens[id])) { if (!(session = switch_core_session_locate(channel->tokens[id]))) { - zap_channel_clear_token(channel, channel->tokens[id]); + ftdm_channel_clear_token(channel, channel->tokens[id]); } } return session; } -static const char *zap_channel_get_uuid(zap_channel_t *channel, int32_t id) +static const char *ftdm_channel_get_uuid(ftdm_channel_t *channel, int32_t id) { - if (id > ZAP_MAX_TOKENS) { + if (id > FTDM_MAX_TOKENS) { return NULL; } @@ -190,7 +190,7 @@ static void stop_hold(switch_core_session_t *session_a, const char *uuid) } } -static void start_hold(zap_channel_t *zchan, switch_core_session_t *session_a, const char *uuid, const char *stream) +static void start_hold(ftdm_channel_t *ftdmchan, switch_core_session_t *session_a, const char *uuid, const char *stream) { switch_core_session_t *session; switch_channel_t *channel, *channel_a; @@ -206,7 +206,7 @@ static void start_hold(zap_channel_t *zchan, switch_core_session_t *session_a, c if (!strcasecmp(globals.hold_music, "indicate_hold")) { stream = "indicate_hold"; } - if (!strcasecmp(SPAN_CONFIG[zchan->span->span_id].hold_music, "indicate_hold")) { + if (!strcasecmp(SPAN_CONFIG[ftdmchan->span->span_id].hold_music, "indicate_hold")) { stream = "indicate_hold"; } } @@ -216,7 +216,7 @@ static void start_hold(zap_channel_t *zchan, switch_core_session_t *session_a, c } if (zstr(stream)) { - stream = SPAN_CONFIG[zchan->span->span_id].hold_music; + stream = SPAN_CONFIG[ftdmchan->span->span_id].hold_music; } if (zstr(stream)) { @@ -244,31 +244,31 @@ static void start_hold(zap_channel_t *zchan, switch_core_session_t *session_a, c } -static void cycle_foreground(zap_channel_t *zchan, int flash, const char *bcast) { +static void cycle_foreground(ftdm_channel_t *ftdmchan, int flash, const char *bcast) { uint32_t i = 0; switch_core_session_t *session; switch_channel_t *channel; private_t *tech_pvt; - for (i = 0; i < zchan->token_count; i++) { - if ((session = zap_channel_get_session(zchan, i))) { + for (i = 0; i < ftdmchan->token_count; i++) { + if ((session = ftdm_channel_get_session(ftdmchan, i))) { const char *buuid; tech_pvt = switch_core_session_get_private(session); channel = switch_core_session_get_channel(session); buuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE); - if (zchan->token_count == 1 && flash) { + if (ftdmchan->token_count == 1 && flash) { if (switch_test_flag(tech_pvt, TFLAG_HOLD)) { stop_hold(session, buuid); switch_clear_flag_locked(tech_pvt, TFLAG_HOLD); } else { - start_hold(zchan, session, buuid, bcast); + start_hold(ftdmchan, session, buuid, bcast); switch_set_flag_locked(tech_pvt, TFLAG_HOLD); } } else if (i) { - start_hold(zchan, session, buuid, bcast); + start_hold(ftdmchan, session, buuid, bcast); switch_set_flag_locked(tech_pvt, TFLAG_HOLD); } else { stop_hold(session, buuid); @@ -285,13 +285,13 @@ static void cycle_foreground(zap_channel_t *zchan, int flash, const char *bcast) -static switch_status_t tech_init(private_t *tech_pvt, switch_core_session_t *session, zap_channel_t *zchan) +static switch_status_t tech_init(private_t *tech_pvt, switch_core_session_t *session, ftdm_channel_t *ftdmchan) { const char *dname = NULL; uint32_t interval = 0, srate = 8000; - zap_codec_t codec; + ftdm_codec_t codec; - tech_pvt->zchan = zchan; + tech_pvt->ftdmchan = ftdmchan; tech_pvt->read_frame.data = tech_pvt->databuf; tech_pvt->read_frame.buflen = sizeof(tech_pvt->databuf); tech_pvt->cng_frame.data = tech_pvt->cng_databuf; @@ -304,28 +304,28 @@ static switch_status_t tech_init(private_t *tech_pvt, switch_core_session_t *ses switch_core_session_set_private(session, tech_pvt); tech_pvt->session = session; - if (ZAP_SUCCESS != zap_channel_command(zchan, ZAP_COMMAND_GET_INTERVAL, &interval)) { + if (FTDM_SUCCESS != ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_INTERVAL, &interval)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to retrieve channel interval.\n"); return SWITCH_STATUS_GENERR; } - if (ZAP_SUCCESS != zap_channel_command(zchan, ZAP_COMMAND_GET_CODEC, &codec)) { + if (FTDM_SUCCESS != ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_CODEC, &codec)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Failed to retrieve channel codec.\n"); return SWITCH_STATUS_GENERR; } switch(codec) { - case ZAP_CODEC_ULAW: + case FTDM_CODEC_ULAW: { dname = "PCMU"; } break; - case ZAP_CODEC_ALAW: + case FTDM_CODEC_ALAW: { dname = "PCMA"; } break; - case ZAP_CODEC_SLIN: + case FTDM_CODEC_SLIN: { dname = "L16"; } @@ -392,7 +392,7 @@ static switch_status_t channel_on_init(switch_core_session_t *session) globals.calls++; switch_mutex_unlock(globals.mutex); - zap_channel_init(tech_pvt->zchan); + ftdm_channel_init(tech_pvt->ftdmchan); //switch_channel_set_flag(channel, CF_ACCEPT_CNG); @@ -463,43 +463,43 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session) assert(tech_pvt != NULL); - zap_channel_clear_token(tech_pvt->zchan, switch_core_session_get_uuid(session)); + ftdm_channel_clear_token(tech_pvt->ftdmchan, switch_core_session_get_uuid(session)); - switch (tech_pvt->zchan->type) { - case ZAP_CHAN_TYPE_FXO: - case ZAP_CHAN_TYPE_EM: - case ZAP_CHAN_TYPE_CAS: + switch (tech_pvt->ftdmchan->type) { + case FTDM_CHAN_TYPE_FXO: + case FTDM_CHAN_TYPE_EM: + case FTDM_CHAN_TYPE_CAS: { - zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_HANGUP); + ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } break; - case ZAP_CHAN_TYPE_FXS: + case FTDM_CHAN_TYPE_FXS: { - if (tech_pvt->zchan->state != ZAP_CHANNEL_STATE_BUSY && tech_pvt->zchan->state != ZAP_CHANNEL_STATE_DOWN) { - if (tech_pvt->zchan->token_count) { - cycle_foreground(tech_pvt->zchan, 0, NULL); + if (tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_BUSY && tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_DOWN) { + if (tech_pvt->ftdmchan->token_count) { + cycle_foreground(tech_pvt->ftdmchan, 0, NULL); } else { - zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_HANGUP); + ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } } break; - case ZAP_CHAN_TYPE_B: + case FTDM_CHAN_TYPE_B: { - if (tech_pvt->zchan->state != ZAP_CHANNEL_STATE_DOWN) { - if (tech_pvt->zchan->state != ZAP_CHANNEL_STATE_TERMINATING) { - tech_pvt->zchan->caller_data.hangup_cause = switch_channel_get_cause_q850(channel); - if (tech_pvt->zchan->caller_data.hangup_cause < 1 || tech_pvt->zchan->caller_data.hangup_cause > 127) { - tech_pvt->zchan->caller_data.hangup_cause = ZAP_CAUSE_DESTINATION_OUT_OF_ORDER; + if (tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_DOWN) { + if (tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_TERMINATING) { + tech_pvt->ftdmchan->caller_data.hangup_cause = switch_channel_get_cause_q850(channel); + if (tech_pvt->ftdmchan->caller_data.hangup_cause < 1 || tech_pvt->ftdmchan->caller_data.hangup_cause > 127) { + tech_pvt->ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_DESTINATION_OUT_OF_ORDER; } } - zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_HANGUP); + ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } break; default: { - switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Unhandled channel type %d for channel %s\n", tech_pvt->zchan->type, + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Unhandled channel type %d for channel %s\n", tech_pvt->ftdmchan->type, switch_channel_get_name(channel)); } break; @@ -565,7 +565,7 @@ static switch_status_t channel_send_dtmf(switch_core_session_t *session, const s assert(tech_pvt != NULL); tmp[0] = dtmf->digit; - zap_channel_command(tech_pvt->zchan, ZAP_COMMAND_SEND_DTMF, tmp); + ftdm_channel_command(tech_pvt->ftdmchan, FTDM_COMMAND_SEND_DTMF, tmp); return SWITCH_STATUS_SUCCESS; } @@ -574,10 +574,10 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch { switch_channel_t *channel = NULL; private_t *tech_pvt = NULL; - zap_size_t len; - zap_wait_flag_t wflags = ZAP_READ; + ftdm_size_t len; + ftdm_wait_flag_t wflags = FTDM_READ; char dtmf[128] = ""; - zap_status_t status; + ftdm_status_t status; int total_to; int chunk, do_break = 0; @@ -589,12 +589,12 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch tech_pvt = switch_core_session_get_private(session); assert(tech_pvt != NULL); - assert(tech_pvt->zchan != NULL); + assert(tech_pvt->ftdmchan != NULL); /* Digium Cards sometimes timeout several times in a row here. Yes, we support digium cards, ain't we nice....... 6 double length intervals should compensate */ - chunk = tech_pvt->zchan->effective_interval * 2; + chunk = tech_pvt->ftdmchan->effective_interval * 2; total_to = chunk * 6; if (switch_test_flag(tech_pvt, TFLAG_DEAD)) { @@ -613,12 +613,12 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch } if (switch_test_flag(tech_pvt, TFLAG_HOLD) || do_break) { - switch_yield(tech_pvt->zchan->effective_interval * 1000); - tech_pvt->cng_frame.datalen = tech_pvt->zchan->packet_len; + switch_yield(tech_pvt->ftdmchan->effective_interval * 1000); + tech_pvt->cng_frame.datalen = tech_pvt->ftdmchan->packet_len; tech_pvt->cng_frame.samples = tech_pvt->cng_frame.datalen; tech_pvt->cng_frame.flags = SFF_CNG; *frame = &tech_pvt->cng_frame; - if (tech_pvt->zchan->effective_codec == ZAP_CODEC_SLIN) { + if (tech_pvt->ftdmchan->effective_codec == FTDM_CODEC_SLIN) { tech_pvt->cng_frame.samples /= 2; } return SWITCH_STATUS_SUCCESS; @@ -628,14 +628,14 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch goto fail; } - wflags = ZAP_READ; - status = zap_channel_wait(tech_pvt->zchan, &wflags, chunk); + wflags = FTDM_READ; + status = ftdm_channel_wait(tech_pvt->ftdmchan, &wflags, chunk); - if (status == ZAP_FAIL) { + if (status == FTDM_FAIL) { goto fail; } - if (status == ZAP_TIMEOUT) { + if (status == FTDM_TIMEOUT) { if (!switch_test_flag(tech_pvt, TFLAG_HOLD)) { total_to -= chunk; if (total_to <= 0) { @@ -646,12 +646,12 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch goto top; } - if (!(wflags & ZAP_READ)) { + if (!(wflags & FTDM_READ)) { goto fail; } len = tech_pvt->read_frame.buflen; - if (zap_channel_read(tech_pvt->zchan, tech_pvt->read_frame.data, &len) != ZAP_SUCCESS) { + if (ftdm_channel_read(tech_pvt->ftdmchan, tech_pvt->read_frame.data, &len) != FTDM_SUCCESS) { goto fail; } @@ -659,17 +659,17 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch tech_pvt->read_frame.datalen = (uint32_t)len; tech_pvt->read_frame.samples = tech_pvt->read_frame.datalen; - if (tech_pvt->zchan->effective_codec == ZAP_CODEC_SLIN) { + if (tech_pvt->ftdmchan->effective_codec == FTDM_CODEC_SLIN) { tech_pvt->read_frame.samples /= 2; } - if (zap_channel_dequeue_dtmf(tech_pvt->zchan, dtmf, sizeof(dtmf))) { + if (ftdm_channel_dequeue_dtmf(tech_pvt->ftdmchan, dtmf, sizeof(dtmf))) { switch_dtmf_t _dtmf = { 0, SWITCH_DEFAULT_DTMF_DURATION }; char *p; for (p = dtmf; p && *p; p++) { if (is_dtmf(*p)) { _dtmf.digit = *p; - zap_log(ZAP_LOG_DEBUG, "queue DTMF [%c]\n", *p); + ftdm_log(FTDM_LOG_DEBUG, "queue DTMF [%c]\n", *p); switch_channel_queue_dtmf(channel, &_dtmf); } } @@ -687,10 +687,10 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc { switch_channel_t *channel = NULL; private_t *tech_pvt = NULL; - zap_size_t len; + ftdm_size_t len; unsigned char data[SWITCH_RECOMMENDED_BUFFER_SIZE] = {0}; - zap_wait_flag_t wflags = ZAP_WRITE; - zap_status_t status; + ftdm_wait_flag_t wflags = FTDM_WRITE; + ftdm_status_t status; channel = switch_core_session_get_channel(session); assert(channel != NULL); @@ -698,7 +698,7 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc tech_pvt = switch_core_session_get_private(session); assert(tech_pvt != NULL); - assert(tech_pvt->zchan != NULL); + assert(tech_pvt->ftdmchan != NULL); if (switch_test_flag(tech_pvt, TFLAG_DEAD)) { return SWITCH_STATUS_FALSE; @@ -722,15 +722,15 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc } - wflags = ZAP_WRITE; - status = zap_channel_wait(tech_pvt->zchan, &wflags, tech_pvt->zchan->effective_interval * 4); + wflags = FTDM_WRITE; + status = ftdm_channel_wait(tech_pvt->ftdmchan, &wflags, tech_pvt->ftdmchan->effective_interval * 4); - if (!(wflags & ZAP_WRITE)) { + if (!(wflags & FTDM_WRITE)) { goto fail; } len = frame->datalen; - if (zap_channel_write(tech_pvt->zchan, frame->data, frame->buflen, &len) != ZAP_SUCCESS) { + if (ftdm_channel_write(tech_pvt->ftdmchan, frame->data, frame->buflen, &len) != FTDM_SUCCESS) { if (++tech_pvt->wr_error > 10) { goto fail; } @@ -758,45 +758,45 @@ static switch_status_t channel_receive_message_cas(switch_core_session_t *sessio tech_pvt = (private_t *) switch_core_session_get_private(session); assert(tech_pvt != NULL); - zap_log(ZAP_LOG_DEBUG, "Got Freeswitch message in R2 channel %d [%d]\n", tech_pvt->zchan->physical_chan_id, + ftdm_log(FTDM_LOG_DEBUG, "Got Freeswitch message in R2 channel %d [%d]\n", tech_pvt->ftdmchan->physical_chan_id, msg->message_id); switch (msg->message_id) { case SWITCH_MESSAGE_INDICATE_RINGING: { if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); } else { - zap_set_state_locked_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS); + ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } } break; case SWITCH_MESSAGE_INDICATE_PROGRESS: { if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS); - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_MEDIA); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_MEDIA); } else { - zap_set_state_locked_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS); - zap_set_state_locked_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS_MEDIA); + ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); + ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } } break; case SWITCH_MESSAGE_INDICATE_ANSWER: { if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_ANSWERED); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); } else { - /* lets make the ozmod_r2 module life easier by moving thru each + /* lets make the ftmod_r2 module life easier by moving thru each * state waiting for completion, clumsy, but does the job */ - if (tech_pvt->zchan->state < ZAP_CHANNEL_STATE_PROGRESS) { - zap_set_state_locked_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS); + if (tech_pvt->ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) { + ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } - if (tech_pvt->zchan->state < ZAP_CHANNEL_STATE_PROGRESS_MEDIA) { - zap_set_state_locked_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS_MEDIA); + if (tech_pvt->ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS_MEDIA) { + ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } - zap_set_state_locked_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_UP); + ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); } } break; @@ -817,11 +817,11 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session, tech_pvt = (private_t *) switch_core_session_get_private(session); assert(tech_pvt != NULL); - assert(tech_pvt->zchan != NULL); + assert(tech_pvt->ftdmchan != NULL); - zap_mutex_lock(tech_pvt->zchan->mutex); - if (tech_pvt->zchan->state == ZAP_CHANNEL_STATE_TERMINATING) { - zap_mutex_unlock(tech_pvt->zchan->mutex); + ftdm_mutex_lock(tech_pvt->ftdmchan->mutex); + if (tech_pvt->ftdmchan->state == FTDM_CHANNEL_STATE_TERMINATING) { + ftdm_mutex_unlock(tech_pvt->ftdmchan->mutex); return SWITCH_STATUS_SUCCESS; } @@ -829,45 +829,45 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session, case SWITCH_MESSAGE_INDICATE_RINGING: { if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS); + ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); } else { - zap_set_state_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS); + ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } } break; case SWITCH_MESSAGE_INDICATE_PROGRESS: { if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS); - zap_set_flag(tech_pvt->zchan, ZAP_CHANNEL_MEDIA); + ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_MEDIA); } else { /* Don't skip messages in the ISDN call setup * TODO: make the isdn stack smart enough to handle that itself * until then, this is here for safety... */ - if (tech_pvt->zchan->state < ZAP_CHANNEL_STATE_PROGRESS) { - zap_set_state_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS); + if (tech_pvt->ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) { + ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } - zap_set_state_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS_MEDIA); + ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } } break; case SWITCH_MESSAGE_INDICATE_ANSWER: { if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag(tech_pvt->zchan, ZAP_CHANNEL_ANSWERED); + ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); } else { /* Don't skip messages in the ISDN call setup * TODO: make the isdn stack smart enough to handle that itself * until then, this is here for safety... */ - if (tech_pvt->zchan->state < ZAP_CHANNEL_STATE_PROGRESS) { - zap_set_state_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS); + if (tech_pvt->ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) { + ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } - if (tech_pvt->zchan->state < ZAP_CHANNEL_STATE_PROGRESS_MEDIA) { - zap_set_state_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_PROGRESS_MEDIA); + if (tech_pvt->ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS_MEDIA) { + ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } - zap_set_state_wait(tech_pvt->zchan, ZAP_CHANNEL_STATE_UP); + ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); } } break; @@ -875,7 +875,7 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session, break; } - zap_mutex_unlock(tech_pvt->zchan->mutex); + ftdm_mutex_unlock(tech_pvt->ftdmchan->mutex); return SWITCH_STATUS_SUCCESS; } @@ -894,11 +894,11 @@ static switch_status_t channel_receive_message_fxo(switch_core_session_t *sessio case SWITCH_MESSAGE_INDICATE_PROGRESS: case SWITCH_MESSAGE_INDICATE_ANSWER: if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_ANSWERED); - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS); - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_MEDIA); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_MEDIA); } else { - zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_UP); + ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); } break; default: @@ -923,10 +923,10 @@ static switch_status_t channel_receive_message_fxs(switch_core_session_t *sessio case SWITCH_MESSAGE_INDICATE_PROGRESS: case SWITCH_MESSAGE_INDICATE_ANSWER: if (!switch_channel_test_flag(channel, CF_OUTBOUND)) { - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_ANSWERED); - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_PROGRESS); - zap_set_flag_locked(tech_pvt->zchan, ZAP_CHANNEL_MEDIA); - zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_UP); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_MEDIA); + ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); switch_channel_mark_answered(channel); } break; @@ -937,7 +937,7 @@ static switch_status_t channel_receive_message_fxs(switch_core_session_t *sessio !switch_channel_test_flag(channel, CF_EARLY_MEDIA) && !switch_channel_test_flag(channel, CF_RING_READY) ) { - zap_set_state_locked(tech_pvt->zchan, ZAP_CHANNEL_STATE_RING); + ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_RING); switch_channel_mark_ring_ready(channel); } } @@ -965,35 +965,35 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s case SWITCH_MESSAGE_INDICATE_PROGRESS: case SWITCH_MESSAGE_INDICATE_ANSWER: if (!switch_channel_test_flag(channel, CF_OUTBOUND)) { - if ((var = switch_channel_get_variable(channel, "openzap_pre_buffer_size"))) { + if ((var = switch_channel_get_variable(channel, "freetdm_pre_buffer_size"))) { int tmp = atoi(var); if (tmp > -1) { - zap_channel_command(tech_pvt->zchan, ZAP_COMMAND_SET_PRE_BUFFER_SIZE, &tmp); + ftdm_channel_command(tech_pvt->ftdmchan, FTDM_COMMAND_SET_PRE_BUFFER_SIZE, &tmp); } } } break; case SWITCH_MESSAGE_INDICATE_UUID_CHANGE: { - zap_channel_replace_token(tech_pvt->zchan, msg->string_array_arg[0], msg->string_array_arg[1]); + ftdm_channel_replace_token(tech_pvt->ftdmchan, msg->string_array_arg[0], msg->string_array_arg[1]); } break; default: break; } - switch (tech_pvt->zchan->type) { - case ZAP_CHAN_TYPE_FXS: - case ZAP_CHAN_TYPE_EM: + switch (tech_pvt->ftdmchan->type) { + case FTDM_CHAN_TYPE_FXS: + case FTDM_CHAN_TYPE_EM: status = channel_receive_message_fxs(session, msg); break; - case ZAP_CHAN_TYPE_FXO: + case FTDM_CHAN_TYPE_FXO: status = channel_receive_message_fxo(session, msg); break; - case ZAP_CHAN_TYPE_B: + case FTDM_CHAN_TYPE_B: status = channel_receive_message_b(session, msg); break; - case ZAP_CHAN_TYPE_CAS: + case FTDM_CHAN_TYPE_CAS: status = channel_receive_message_cas(session, msg); break; default: @@ -1005,7 +1005,7 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s } -switch_state_handler_table_t openzap_state_handlers = { +switch_state_handler_table_t freetdm_state_handlers = { /*.on_init */ channel_on_init, /*.on_routing */ channel_on_routing, /*.on_execute */ channel_on_execute, @@ -1021,7 +1021,7 @@ switch_state_handler_table_t openzap_state_handlers = { }; -switch_io_routines_t openzap_io_routines = { +switch_io_routines_t freetdm_io_routines = { /*.outgoing_channel */ channel_outgoing_channel, /*.read_frame */ channel_read_frame, /*.write_frame */ channel_write_frame, @@ -1042,12 +1042,12 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi const char *dest = NULL; char *data = NULL; int span_id = -1, group_id = -1,chan_id = 0; - zap_channel_t *zchan = NULL; + ftdm_channel_t *ftdmchan = NULL; switch_call_cause_t cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; char name[128]; - zap_status_t status; - int direction = ZAP_TOP_DOWN; - zap_caller_data_t caller_data = {{ 0 }}; + ftdm_status_t status; + int direction = FTDM_TOP_DOWN; + ftdm_caller_data_t caller_data = {{ 0 }}; char *span_name = NULL; switch_event_header_t *h; char *argv[3]; @@ -1080,9 +1080,9 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi } if (*argv[1] == 'A') { - direction = ZAP_BOTTOM_UP; + direction = FTDM_BOTTOM_UP; } else if (*argv[1] == 'a') { - direction = ZAP_TOP_DOWN; + direction = FTDM_TOP_DOWN; } else { chan_id = atoi(argv[1]); } @@ -1097,27 +1097,27 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi } if (span_id == -1 && !zstr(span_name)) { - zap_span_t *span; - zap_status_t zstatus = zap_span_find_by_name(span_name, &span); - if (zstatus == ZAP_SUCCESS && span) { + ftdm_span_t *span; + ftdm_status_t zstatus = ftdm_span_find_by_name(span_name, &span); + if (zstatus == FTDM_SUCCESS && span) { span_id = span->span_id; } } if (span_id == -1) { //Look for a group - zap_group_t *group; - zap_status_t zstatus = zap_group_find_by_name(span_name, &group); - if (zstatus == ZAP_SUCCESS && group) { + ftdm_group_t *group; + ftdm_status_t zstatus = ftdm_group_find_by_name(span_name, &group); + if (zstatus == FTDM_SUCCESS && group) { group_id = group->group_id; } else { - switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing zap span or group: %s\n", span_name); + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing ftdm span or group: %s\n", span_name); return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; } } if (group_id < 0 && chan_id < 0) { - direction = ZAP_BOTTOM_UP; + direction = FTDM_BOTTOM_UP; chan_id = 0; } @@ -1130,18 +1130,18 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi } if (!zstr(dest)) { - zap_set_string(caller_data.ani.digits, dest); + ftdm_set_string(caller_data.ani.digits, dest); } - if ((var = switch_event_get_header(var_event, "openzap_outbound_ton")) || (var = switch_core_get_variable("openzap_outbound_ton"))) { + if ((var = switch_event_get_header(var_event, "freetdm_outbound_ton")) || (var = switch_core_get_variable("freetdm_outbound_ton"))) { if (!strcasecmp(var, "national")) { - caller_data.ani.type = ZAP_TON_NATIONAL; + caller_data.ani.type = FTDM_TON_NATIONAL; } else if (!strcasecmp(var, "international")) { - caller_data.ani.type = ZAP_TON_INTERNATIONAL; + caller_data.ani.type = FTDM_TON_INTERNATIONAL; } else if (!strcasecmp(var, "local")) { - caller_data.ani.type = ZAP_TON_SUBSCRIBER_NUMBER; + caller_data.ani.type = FTDM_TON_SUBSCRIBER_NUMBER; } else if (!strcasecmp(var, "unknown")) { - caller_data.ani.type = ZAP_TON_UNKNOWN; + caller_data.ani.type = FTDM_TON_UNKNOWN; } } else { caller_data.ani.type = outbound_profile->destination_number_ton; @@ -1152,51 +1152,51 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi #if 0 if (!zstr(outbound_profile->rdnis)) { - zap_set_string(caller_data.rdnis.digits, outbound_profile->rdnis); + ftdm_set_string(caller_data.rdnis.digits, outbound_profile->rdnis); } #endif - zap_set_string(caller_data.cid_name, outbound_profile->caller_id_name); - zap_set_string(caller_data.cid_num.digits, outbound_profile->caller_id_number); + ftdm_set_string(caller_data.cid_name, outbound_profile->caller_id_name); + ftdm_set_string(caller_data.cid_num.digits, outbound_profile->caller_id_number); if (group_id >= 0) { - status = zap_channel_open_by_group(group_id, direction, &caller_data, &zchan); + status = ftdm_channel_open_by_group(group_id, direction, &caller_data, &ftdmchan); } else if (chan_id) { - status = zap_channel_open(span_id, chan_id, &zchan); + status = ftdm_channel_open(span_id, chan_id, &ftdmchan); } else { - status = zap_channel_open_by_span(span_id, direction, &caller_data, &zchan); + status = ftdm_channel_open_by_span(span_id, direction, &caller_data, &ftdmchan); } - if (status != ZAP_SUCCESS) { + if (status != FTDM_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "No channels available\n"); return SWITCH_CAUSE_NORMAL_CIRCUIT_CONGESTION; } - if ((var = switch_event_get_header(var_event, "openzap_pre_buffer_size"))) { + if ((var = switch_event_get_header(var_event, "freetdm_pre_buffer_size"))) { int tmp = atoi(var); if (tmp > -1) { - zap_channel_command(zchan, ZAP_COMMAND_SET_PRE_BUFFER_SIZE, &tmp); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_SET_PRE_BUFFER_SIZE, &tmp); } } - zap_channel_clear_vars(zchan); + ftdm_channel_clear_vars(ftdmchan); for (h = var_event->headers; h; h = h->next) { - if (!strncasecmp(h->name, OPENZAP_VAR_PREFIX, OPENZAP_VAR_PREFIX_LEN)) { - char *v = h->name + OPENZAP_VAR_PREFIX_LEN; + if (!strncasecmp(h->name, OPENFTDM_VAR_PREFIX, OPENFTDM_VAR_PREFIX_LEN)) { + char *v = h->name + OPENFTDM_VAR_PREFIX_LEN; if (!zstr(v)) { - zap_channel_add_var(zchan, v, h->value); + ftdm_channel_add_var(ftdmchan, v, h->value); } } } - if ((*new_session = switch_core_session_request(openzap_endpoint_interface, SWITCH_CALL_DIRECTION_OUTBOUND, pool)) != 0) { + if ((*new_session = switch_core_session_request(freetdm_endpoint_interface, SWITCH_CALL_DIRECTION_OUTBOUND, pool)) != 0) { private_t *tech_pvt; switch_caller_profile_t *caller_profile; switch_channel_t *channel = switch_core_session_get_channel(*new_session); switch_core_session_add_stream(*new_session, NULL); if ((tech_pvt = (private_t *) switch_core_session_alloc(*new_session, sizeof(private_t))) != 0) { - tech_init(tech_pvt, *new_session, zchan); + tech_init(tech_pvt, *new_session, ftdmchan); } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Hey where is my memory pool?\n"); switch_core_session_destroy(new_session); @@ -1204,13 +1204,13 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi goto fail; } - snprintf(name, sizeof(name), "OpenZAP/%u:%u/%s", zchan->span_id, zchan->chan_id, dest); + snprintf(name, sizeof(name), "OpenFTDM/%u:%u/%s", ftdmchan->span_id, ftdmchan->chan_id, dest); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Connect outbound channel %s\n", name); switch_channel_set_name(channel, name); - switch_channel_set_variable(channel, "openzap_span_name", zchan->span->name); - switch_channel_set_variable_printf(channel, "openzap_span_number", "%d", zchan->span_id); - switch_channel_set_variable_printf(channel, "openzap_chan_number", "%d", zchan->chan_id); - zchan->caller_data = caller_data; + switch_channel_set_variable(channel, "freetdm_span_name", ftdmchan->span->name); + switch_channel_set_variable_printf(channel, "freetdm_span_number", "%d", ftdmchan->span_id); + switch_channel_set_variable_printf(channel, "freetdm_chan_number", "%d", ftdmchan->chan_id); + ftdmchan->caller_data = caller_data; caller_profile = switch_caller_profile_clone(*new_session, outbound_profile); switch_channel_set_caller_profile(channel, caller_profile); tech_pvt->caller_profile = caller_profile; @@ -1218,14 +1218,14 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi switch_channel_set_flag(channel, CF_OUTBOUND); switch_channel_set_state(channel, CS_INIT); - if (zap_channel_add_token(zchan, switch_core_session_get_uuid(*new_session), zchan->token_count) != ZAP_SUCCESS) { + if (ftdm_channel_add_token(ftdmchan, switch_core_session_get_uuid(*new_session), ftdmchan->token_count) != FTDM_SUCCESS) { switch_core_session_destroy(new_session); cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; goto fail; } - if (zap_channel_outgoing_call(zchan) != ZAP_SUCCESS) { + if (ftdm_channel_outgoing_call(ftdmchan) != FTDM_SUCCESS) { if (tech_pvt->read_codec.implementation) { switch_core_codec_destroy(&tech_pvt->read_codec); } @@ -1238,22 +1238,22 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi goto fail; } - zap_channel_init(zchan); + ftdm_channel_init(ftdmchan); return SWITCH_CAUSE_SUCCESS; } fail: - if (zchan) { - zap_channel_done(zchan); + if (ftdmchan) { + ftdm_channel_done(ftdmchan); } return cause; } -zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t **sp) +ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session_t **sp) { switch_core_session_t *session = NULL; private_t *tech_pvt = NULL; @@ -1262,9 +1262,9 @@ zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t *sp = NULL; - if (!(session = switch_core_session_request(openzap_endpoint_interface, SWITCH_CALL_DIRECTION_INBOUND, NULL))) { + if (!(session = switch_core_session_request(freetdm_endpoint_interface, SWITCH_CALL_DIRECTION_INBOUND, NULL))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Initilization Error!\n"); - return ZAP_FAIL; + return FTDM_FAIL; } switch_core_session_add_stream(session, NULL); @@ -1275,7 +1275,7 @@ zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t if (tech_init(tech_pvt, session, sigmsg->channel) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Initilization Error!\n"); switch_core_session_destroy(&session); - return ZAP_FAIL; + return FTDM_FAIL; } *sigmsg->channel->caller_data.collected = '\0'; @@ -1293,7 +1293,7 @@ zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t } tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session), - "OpenZAP", + "OpenFTDM", SPAN_CONFIG[sigmsg->channel->span_id].dialplan, sigmsg->channel->caller_data.cid_name, sigmsg->channel->caller_data.cid_num.digits, @@ -1315,30 +1315,30 @@ zap_status_t zap_channel_from_event(zap_sigmsg_t *sigmsg, switch_core_session_t switch_set_flag(tech_pvt->caller_profile, SWITCH_CPF_HIDE_NAME | SWITCH_CPF_HIDE_NUMBER); } - snprintf(name, sizeof(name), "OpenZAP/%u:%u/%s", sigmsg->channel->span_id, sigmsg->channel->chan_id, tech_pvt->caller_profile->destination_number); + snprintf(name, sizeof(name), "OpenFTDM/%u:%u/%s", sigmsg->channel->span_id, sigmsg->channel->chan_id, tech_pvt->caller_profile->destination_number); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Connect inbound channel %s\n", name); switch_channel_set_name(channel, name); switch_channel_set_caller_profile(channel, tech_pvt->caller_profile); - switch_channel_set_variable(channel, "openzap_span_name", sigmsg->channel->span->name); - switch_channel_set_variable_printf(channel, "openzap_span_number", "%d", sigmsg->channel->span_id); - switch_channel_set_variable_printf(channel, "openzap_chan_number", "%d", sigmsg->channel->chan_id); + switch_channel_set_variable(channel, "freetdm_span_name", sigmsg->channel->span->name); + switch_channel_set_variable_printf(channel, "freetdm_span_number", "%d", sigmsg->channel->span_id); + switch_channel_set_variable_printf(channel, "freetdm_chan_number", "%d", sigmsg->channel->chan_id); switch_channel_set_state(channel, CS_INIT); if (switch_core_session_thread_launch(session) != SWITCH_STATUS_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error spawning thread\n"); switch_core_session_destroy(&session); - return ZAP_FAIL; + return FTDM_FAIL; } - if (zap_channel_add_token(sigmsg->channel, switch_core_session_get_uuid(session), 0) != ZAP_SUCCESS) { + if (ftdm_channel_add_token(sigmsg->channel, switch_core_session_get_uuid(session), 0) != FTDM_SUCCESS) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error adding token\n"); switch_core_session_destroy(&session); - return ZAP_FAIL; + return FTDM_FAIL; } *sp = session; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } @@ -1346,46 +1346,46 @@ static ZIO_SIGNAL_CB_FUNCTION(on_fxo_signal) { switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; - zap_status_t status; + ftdm_status_t status; - zap_log(ZAP_LOG_DEBUG, "got FXO sig %d:%d [%s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, zap_signal_event2str(sigmsg->event_id)); + ftdm_log(FTDM_LOG_DEBUG, "got FXO sig %d:%d [%s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, ftdm_signal_event2str(sigmsg->event_id)); switch(sigmsg->event_id) { - case ZAP_SIGEVENT_PROGRESS_MEDIA: + case FTDM_SIGEVENT_PROGRESS_MEDIA: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_mark_pre_answered(channel); switch_core_session_rwunlock(session); } } break; - case ZAP_SIGEVENT_STOP: + case FTDM_SIGEVENT_STOP: { - while((session = zap_channel_get_session(sigmsg->channel, 0))) { - zap_channel_clear_token(sigmsg->channel, 0); + while((session = ftdm_channel_get_session(sigmsg->channel, 0))) { + ftdm_channel_clear_token(sigmsg->channel, 0); channel = switch_core_session_get_channel(session); switch_channel_hangup(channel, sigmsg->channel->caller_data.hangup_cause); - zap_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); + ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } } break; - case ZAP_SIGEVENT_UP: + case FTDM_SIGEVENT_UP: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_mark_answered(channel); switch_core_session_rwunlock(session); } } break; - case ZAP_SIGEVENT_START: + case FTDM_SIGEVENT_START: { - status = zap_channel_from_event(sigmsg, &session); - if (status != ZAP_SUCCESS) { - zap_set_state_locked(sigmsg->channel, ZAP_CHANNEL_STATE_DOWN); + status = ftdm_channel_from_event(sigmsg, &session); + if (status != FTDM_SUCCESS) { + ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_DOWN); } } break; @@ -1399,46 +1399,46 @@ static ZIO_SIGNAL_CB_FUNCTION(on_fxo_signal) } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } static ZIO_SIGNAL_CB_FUNCTION(on_fxs_signal) { switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; - zap_status_t status = ZAP_SUCCESS; + ftdm_status_t status = FTDM_SUCCESS; - zap_log(ZAP_LOG_DEBUG, "got FXS sig [%s]\n", zap_signal_event2str(sigmsg->event_id)); + ftdm_log(FTDM_LOG_DEBUG, "got FXS sig [%s]\n", ftdm_signal_event2str(sigmsg->event_id)); switch(sigmsg->event_id) { - case ZAP_SIGEVENT_UP: + case FTDM_SIGEVENT_UP: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_mark_answered(channel); switch_core_session_rwunlock(session); } } break; - case ZAP_SIGEVENT_PROGRESS: + case FTDM_SIGEVENT_PROGRESS: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_mark_ring_ready(channel); switch_core_session_rwunlock(session); } } break; - case ZAP_SIGEVENT_START: + case FTDM_SIGEVENT_START: { - zap_clear_flag_locked(sigmsg->channel, ZAP_CHANNEL_HOLD); - status = zap_channel_from_event(sigmsg, &session); - if (status != ZAP_SUCCESS) { - zap_set_state_locked(sigmsg->channel, ZAP_CHANNEL_STATE_BUSY); + ftdm_clear_flag_locked(sigmsg->channel, FTDM_CHANNEL_HOLD); + status = ftdm_channel_from_event(sigmsg, &session); + if (status != FTDM_SUCCESS) { + ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_BUSY); } } break; - case ZAP_SIGEVENT_STOP: + case FTDM_SIGEVENT_STOP: { switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING; if (sigmsg->channel->token_count) { @@ -1494,28 +1494,28 @@ static ZIO_SIGNAL_CB_FUNCTION(on_fxs_signal) } - while((session = zap_channel_get_session(sigmsg->channel, 0))) { + while((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_hangup(channel, cause); - zap_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); + ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } - zap_channel_clear_token(sigmsg->channel, NULL); + ftdm_channel_clear_token(sigmsg->channel, NULL); } break; - case ZAP_SIGEVENT_ADD_CALL: + case FTDM_SIGEVENT_ADD_CALL: { cycle_foreground(sigmsg->channel, 1, NULL); } break; - case ZAP_SIGEVENT_FLASH: + case FTDM_SIGEVENT_FLASH: { - if (zap_test_flag(sigmsg->channel, ZAP_CHANNEL_HOLD) && sigmsg->channel->token_count == 1) { + if (ftdm_test_flag(sigmsg->channel, FTDM_CHANNEL_HOLD) && sigmsg->channel->token_count == 1) { switch_core_session_t *session; - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { const char *buuid; switch_channel_t *channel; private_t *tech_pvt; @@ -1523,25 +1523,25 @@ static ZIO_SIGNAL_CB_FUNCTION(on_fxs_signal) tech_pvt = switch_core_session_get_private(session); channel = switch_core_session_get_channel(session); buuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE); - zap_set_state_locked(sigmsg->channel, ZAP_CHANNEL_STATE_UP); + ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_UP); stop_hold(session, buuid); switch_clear_flag_locked(tech_pvt, TFLAG_HOLD); switch_core_session_rwunlock(session); } } else if (sigmsg->channel->token_count == 2 && (SPAN_CONFIG[sigmsg->span_id].analog_options & ANALOG_OPTION_3WAY)) { - if (zap_test_flag(sigmsg->channel, ZAP_CHANNEL_3WAY)) { - zap_clear_flag(sigmsg->channel, ZAP_CHANNEL_3WAY); - if ((session = zap_channel_get_session(sigmsg->channel, 1))) { + if (ftdm_test_flag(sigmsg->channel, FTDM_CHANNEL_3WAY)) { + ftdm_clear_flag(sigmsg->channel, FTDM_CHANNEL_3WAY); + if ((session = ftdm_channel_get_session(sigmsg->channel, 1))) { channel = switch_core_session_get_channel(session); switch_channel_hangup(channel, SWITCH_CAUSE_NORMAL_CLEARING); - zap_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); + ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } cycle_foreground(sigmsg->channel, 1, NULL); } else { char *cmd; cmd = switch_mprintf("three_way::%s", sigmsg->channel->tokens[0]); - zap_set_flag(sigmsg->channel, ZAP_CHANNEL_3WAY); + ftdm_set_flag(sigmsg->channel, FTDM_CHANNEL_3WAY); cycle_foreground(sigmsg->channel, 1, cmd); free(cmd); } @@ -1550,15 +1550,15 @@ static ZIO_SIGNAL_CB_FUNCTION(on_fxs_signal) ) { cycle_foreground(sigmsg->channel, 1, NULL); if (sigmsg->channel->token_count == 1) { - zap_set_flag_locked(sigmsg->channel, ZAP_CHANNEL_HOLD); - zap_set_state_locked(sigmsg->channel, ZAP_CHANNEL_STATE_DIALTONE); + ftdm_set_flag_locked(sigmsg->channel, FTDM_CHANNEL_HOLD); + ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_DIALTONE); } } } break; - case ZAP_SIGEVENT_COLLECTED_DIGIT: + case FTDM_SIGEVENT_COLLECTED_DIGIT: { char *dtmf = sigmsg->raw_data; char *regex = SPAN_CONFIG[sigmsg->channel->span->span_id].dial_regex; @@ -1572,7 +1572,7 @@ static ZIO_SIGNAL_CB_FUNCTION(on_fxs_signal) fail_regex = NULL; } - zap_log(ZAP_LOG_DEBUG, "got DTMF sig [%s]\n", dtmf); + ftdm_log(FTDM_LOG_DEBUG, "got DTMF sig [%s]\n", dtmf); switch_set_string(sigmsg->channel->caller_data.collected, dtmf); if ((regex || fail_regex) && !zstr(dtmf)) { @@ -1582,13 +1582,13 @@ static ZIO_SIGNAL_CB_FUNCTION(on_fxs_signal) if (fail_regex) { match = switch_regex_perform(dtmf, fail_regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0])); - status = match ? ZAP_SUCCESS : ZAP_BREAK; + status = match ? FTDM_SUCCESS : FTDM_BREAK; switch_regex_safe_free(re); } - if (status == ZAP_SUCCESS && regex) { + if (status == FTDM_SUCCESS && regex) { match = switch_regex_perform(dtmf, regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0])); - status = match ? ZAP_BREAK : ZAP_SUCCESS; + status = match ? FTDM_BREAK : FTDM_SUCCESS; } switch_regex_safe_free(re); @@ -1613,32 +1613,32 @@ static ZIO_SIGNAL_CB_FUNCTION(on_r2_signal) { switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; - zap_status_t status = ZAP_SUCCESS; + ftdm_status_t status = FTDM_SUCCESS; - zap_log(ZAP_LOG_DEBUG, "Got R2 channel sig [%s] in channel %d\n", zap_signal_event2str(sigmsg->event_id), sigmsg->channel->physical_chan_id); + ftdm_log(FTDM_LOG_DEBUG, "Got R2 channel sig [%s] in channel %d\n", ftdm_signal_event2str(sigmsg->event_id), sigmsg->channel->physical_chan_id); switch(sigmsg->event_id) { /* on_call_disconnect from the R2 side */ - case ZAP_SIGEVENT_STOP: + case FTDM_SIGEVENT_STOP: { - while((session = zap_channel_get_session(sigmsg->channel, 0))) { + while((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_hangup(channel, sigmsg->channel->caller_data.hangup_cause); - zap_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); + ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } } break; /* on_call_offered from the R2 side */ - case ZAP_SIGEVENT_START: + case FTDM_SIGEVENT_START: { - status = zap_channel_from_event(sigmsg, &session); + status = ftdm_channel_from_event(sigmsg, &session); } break; - /* on DNIS received from the R2 forward side, return status == ZAP_BREAK to stop requesting DNIS */ - case ZAP_SIGEVENT_COLLECTED_DIGIT: + /* on DNIS received from the R2 forward side, return status == FTDM_BREAK to stop requesting DNIS */ + case FTDM_SIGEVENT_COLLECTED_DIGIT: { char *regex = SPAN_CONFIG[sigmsg->channel->span->span_id].dial_regex; char *fail_regex = SPAN_CONFIG[sigmsg->channel->span->span_id].fail_dial_regex; @@ -1651,7 +1651,7 @@ static ZIO_SIGNAL_CB_FUNCTION(on_r2_signal) fail_regex = NULL; } - zap_log(ZAP_LOG_DEBUG, "R2 DNIS so far [%s]\n", sigmsg->channel->caller_data.dnis.digits); + ftdm_log(FTDM_LOG_DEBUG, "R2 DNIS so far [%s]\n", sigmsg->channel->caller_data.dnis.digits); if ((regex || fail_regex) && !zstr(sigmsg->channel->caller_data.dnis.digits)) { switch_regex_t *re = NULL; @@ -1660,13 +1660,13 @@ static ZIO_SIGNAL_CB_FUNCTION(on_r2_signal) if (fail_regex) { match = switch_regex_perform(sigmsg->channel->caller_data.dnis.digits, fail_regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0])); - status = match ? ZAP_SUCCESS : ZAP_BREAK; + status = match ? FTDM_SUCCESS : FTDM_BREAK; switch_regex_safe_free(re); } - if (status == ZAP_SUCCESS && regex) { + if (status == FTDM_SUCCESS && regex) { match = switch_regex_perform(sigmsg->channel->caller_data.dnis.digits, regex, &re, ovector, sizeof(ovector) / sizeof(ovector[0])); - status = match ? ZAP_BREAK : ZAP_SUCCESS; + status = match ? FTDM_BREAK : FTDM_SUCCESS; } switch_regex_safe_free(re); @@ -1674,9 +1674,9 @@ static ZIO_SIGNAL_CB_FUNCTION(on_r2_signal) } break; - case ZAP_SIGEVENT_PROGRESS: + case FTDM_SIGEVENT_PROGRESS: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_mark_ring_ready(channel); switch_core_session_rwunlock(session); @@ -1684,14 +1684,14 @@ static ZIO_SIGNAL_CB_FUNCTION(on_r2_signal) } break; - case ZAP_SIGEVENT_UP: + case FTDM_SIGEVENT_UP: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { - zap_tone_type_t tt = ZAP_TONE_DTMF; + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { + ftdm_tone_type_t tt = FTDM_TONE_DTMF; channel = switch_core_session_get_channel(session); switch_channel_mark_answered(channel); - if (zap_channel_command(sigmsg->channel, ZAP_COMMAND_ENABLE_DTMF_DETECT, &tt) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Failed to enable DTMF detection in R2 channel %d:%d\n", sigmsg->channel->span_id, sigmsg->channel->chan_id); + if (ftdm_channel_command(sigmsg->channel, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Failed to enable DTMF detection in R2 channel %d:%d\n", sigmsg->channel->span_id, sigmsg->channel->chan_id); } switch_core_session_rwunlock(session); } @@ -1714,70 +1714,70 @@ static ZIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; - zap_log(ZAP_LOG_DEBUG, "got clear channel sig [%s]\n", zap_signal_event2str(sigmsg->event_id)); + ftdm_log(FTDM_LOG_DEBUG, "got clear channel sig [%s]\n", ftdm_signal_event2str(sigmsg->event_id)); switch(sigmsg->event_id) { - case ZAP_SIGEVENT_START: + case FTDM_SIGEVENT_START: { - zap_tone_type_t tt = ZAP_TONE_DTMF; + ftdm_tone_type_t tt = FTDM_TONE_DTMF; - if (zap_channel_command(sigmsg->channel, ZAP_COMMAND_ENABLE_DTMF_DETECT, &tt) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "TONE ERROR\n"); + if (ftdm_channel_command(sigmsg->channel, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "TONE ERROR\n"); } - return zap_channel_from_event(sigmsg, &session); + return ftdm_channel_from_event(sigmsg, &session); } break; - case ZAP_SIGEVENT_STOP: - case ZAP_SIGEVENT_RESTART: + case FTDM_SIGEVENT_STOP: + case FTDM_SIGEVENT_RESTART: { - while((session = zap_channel_get_session(sigmsg->channel, 0))) { + while((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_hangup(channel, sigmsg->channel->caller_data.hangup_cause); - zap_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); + ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } } break; - case ZAP_SIGEVENT_UP: + case FTDM_SIGEVENT_UP: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { - zap_tone_type_t tt = ZAP_TONE_DTMF; + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { + ftdm_tone_type_t tt = FTDM_TONE_DTMF; channel = switch_core_session_get_channel(session); switch_channel_mark_answered(channel); - if (zap_channel_command(sigmsg->channel, ZAP_COMMAND_ENABLE_DTMF_DETECT, &tt) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "TONE ERROR\n"); + if (ftdm_channel_command(sigmsg->channel, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "TONE ERROR\n"); } switch_core_session_rwunlock(session); } else { - const char *uuid = zap_channel_get_uuid(sigmsg->channel, 0); + const char *uuid = ftdm_channel_get_uuid(sigmsg->channel, 0); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Session for channel %d:%d not found [UUID: %s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, (uuid) ? uuid : "N/A"); } } - case ZAP_SIGEVENT_PROGRESS_MEDIA: + case FTDM_SIGEVENT_PROGRESS_MEDIA: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_mark_pre_answered(channel); switch_core_session_rwunlock(session); } else { - const char *uuid = zap_channel_get_uuid(sigmsg->channel, 0); + const char *uuid = ftdm_channel_get_uuid(sigmsg->channel, 0); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Session for channel %d:%d not found [UUID: %s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, (uuid) ? uuid : "N/A"); } } break; - case ZAP_SIGEVENT_PROGRESS: + case FTDM_SIGEVENT_PROGRESS: { - if ((session = zap_channel_get_session(sigmsg->channel, 0))) { + if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { channel = switch_core_session_get_channel(session); switch_channel_mark_ring_ready(channel); switch_core_session_rwunlock(session); } else { - const char *uuid = zap_channel_get_uuid(sigmsg->channel, 0); + const char *uuid = ftdm_channel_get_uuid(sigmsg->channel, 0); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Session for channel %d:%d not found [UUID: %s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, (uuid) ? uuid : "N/A"); @@ -1791,7 +1791,7 @@ static ZIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) break; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } @@ -1800,13 +1800,13 @@ static ZIO_SIGNAL_CB_FUNCTION(on_analog_signal) switch_status_t status = SWITCH_STATUS_FALSE; switch (sigmsg->channel->type) { - case ZAP_CHAN_TYPE_FXO: - case ZAP_CHAN_TYPE_EM: + case FTDM_CHAN_TYPE_FXO: + case FTDM_CHAN_TYPE_EM: { status = on_fxo_signal(sigmsg); } break; - case ZAP_CHAN_TYPE_FXS: + case FTDM_CHAN_TYPE_FXS: { status = on_fxs_signal(sigmsg); } @@ -1822,7 +1822,7 @@ static ZIO_SIGNAL_CB_FUNCTION(on_analog_signal) return status; } -static void zap_logger(const char *file, const char *func, int line, int level, const char *fmt, ...) +static void ftdm_logger(const char *file, const char *func, int line, int level, const char *fmt, ...) { char *data = NULL; va_list ap; @@ -1854,10 +1854,10 @@ static uint32_t enable_analog_option(const char *str, uint32_t current_options) static switch_status_t load_config(void) { - const char *cf = "openzap.conf"; + const char *cf = "freetdm.conf"; switch_xml_t cfg, xml, settings, param, spans, myspan; - zap_span_t *boost_spans[ZAP_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN]; - zap_span_t *boost_span = NULL; + ftdm_span_t *boost_spans[FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN]; + ftdm_span_t *boost_span = NULL; unsigned boosti = 0; unsigned int i = 0; @@ -1888,7 +1888,7 @@ static switch_status_t load_config(void) for (myspan = switch_xml_child(spans, "span"); myspan; myspan = myspan->next) { char *id = (char *) switch_xml_attr(myspan, "id"); char *name = (char *) switch_xml_attr(myspan, "name"); - zap_status_t zstatus = ZAP_FAIL; + ftdm_status_t zstatus = FTDM_FAIL; const char *context = "default"; const char *dialplan = "XML"; const char *tonegroup = NULL; @@ -1901,7 +1901,7 @@ static switch_status_t load_config(void) const char *enable_callerid = "true"; uint32_t span_id = 0, to = 0, max = 0; - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; analog_option_t analog_options = ANALOG_OPTION_NONE; for (param = switch_xml_child(myspan, "param"); param; param = param->next) { @@ -1953,20 +1953,20 @@ static switch_status_t load_config(void) } if (name) { - zstatus = zap_span_find_by_name(name, &span); + zstatus = ftdm_span_find_by_name(name, &span); } else { if (switch_is_number(id)) { span_id = atoi(id); - zstatus = zap_span_find(span_id, &span); + zstatus = ftdm_span_find(span_id, &span); } - if (zstatus != ZAP_SUCCESS) { - zstatus = zap_span_find_by_name(id, &span); + if (zstatus != FTDM_SUCCESS) { + zstatus = ftdm_span_find_by_name(id, &span); } } - if (zstatus != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); + if (zstatus != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error finding OpenFTDM span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); continue; } @@ -1974,14 +1974,14 @@ static switch_status_t load_config(void) span_id = span->span_id; } - if (zap_configure_span("analog", span, on_analog_signal, + if (ftdm_configure_span("analog", span, on_analog_signal, "tonemap", tonegroup, "digit_timeout", &to, "max_dialstr", &max, "hotline", hotline, "enable_callerid", enable_callerid, - TAG_END) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error starting OpenZAP span %d\n", span_id); + TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error starting OpenFTDM span %d\n", span_id); continue; } @@ -2002,7 +2002,7 @@ static switch_status_t load_config(void) switch_set_string(SPAN_CONFIG[span->span_id].hold_music, hold_music); } switch_copy_string(SPAN_CONFIG[span->span_id].type, "analog", sizeof(SPAN_CONFIG[span->span_id].type)); - zap_span_start(span); + ftdm_span_start(span); } } @@ -2010,7 +2010,7 @@ static switch_status_t load_config(void) for (myspan = switch_xml_child(spans, "span"); myspan; myspan = myspan->next) { char *id = (char *) switch_xml_attr(myspan, "id"); char *name = (char *) switch_xml_attr(myspan, "name"); - zap_status_t zstatus = ZAP_FAIL; + ftdm_status_t zstatus = FTDM_FAIL; const char *context = "default"; const char *dialplan = "XML"; const char *tonegroup = NULL; @@ -2020,7 +2020,7 @@ static switch_status_t load_config(void) char *hold_music = NULL; char *fail_dial_regex = NULL; uint32_t span_id = 0, to = 0, max = 0; - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; analog_option_t analog_options = ANALOG_OPTION_NONE; for (param = switch_xml_child(myspan, "param"); param; param = param->next) { @@ -2068,20 +2068,20 @@ static switch_status_t load_config(void) if (name) { - zstatus = zap_span_find_by_name(name, &span); + zstatus = ftdm_span_find_by_name(name, &span); } else { if (switch_is_number(id)) { span_id = atoi(id); - zstatus = zap_span_find(span_id, &span); + zstatus = ftdm_span_find(span_id, &span); } - if (zstatus != ZAP_SUCCESS) { - zstatus = zap_span_find_by_name(id, &span); + if (zstatus != FTDM_SUCCESS) { + zstatus = ftdm_span_find_by_name(id, &span); } } - if (zstatus != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); + if (zstatus != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error finding OpenFTDM span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); continue; } @@ -2090,12 +2090,12 @@ static switch_status_t load_config(void) } - if (zap_configure_span("analog_em", span, on_analog_signal, + if (ftdm_configure_span("analog_em", span, on_analog_signal, "tonemap", tonegroup, "digit_timeout", &to, "max_dialstr", &max, - TAG_END) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error starting OpenZAP span %d\n", span_id); + TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error starting OpenFTDM span %d\n", span_id); continue; } @@ -2116,7 +2116,7 @@ static switch_status_t load_config(void) switch_set_string(SPAN_CONFIG[span->span_id].hold_music, hold_music); } switch_copy_string(SPAN_CONFIG[span->span_id].type, "analog_em", sizeof(SPAN_CONFIG[span->span_id].type)); - zap_span_start(span); + ftdm_span_start(span); } } @@ -2124,7 +2124,7 @@ static switch_status_t load_config(void) for (myspan = switch_xml_child(spans, "span"); myspan; myspan = myspan->next) { char *id = (char *) switch_xml_attr(myspan, "id"); char *name = (char *) switch_xml_attr(myspan, "name"); - zap_status_t zstatus = ZAP_FAIL; + ftdm_status_t zstatus = FTDM_FAIL; const char *context = "default"; const char *dialplan = "XML"; //Q921NetUser_t mode = Q931_TE; @@ -2132,7 +2132,7 @@ static switch_status_t load_config(void) char *mode = NULL; char *dialect = NULL; uint32_t span_id = 0; - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; const char *tonegroup = NULL; char *digit_timeout = NULL; const char *opts = "none"; @@ -2177,15 +2177,15 @@ static switch_status_t load_config(void) } if (name) { - zstatus = zap_span_find_by_name(name, &span); + zstatus = ftdm_span_find_by_name(name, &span); } else { if (switch_is_number(id)) { span_id = atoi(id); - zstatus = zap_span_find(span_id, &span); + zstatus = ftdm_span_find(span_id, &span); } - if (zstatus != ZAP_SUCCESS) { - zstatus = zap_span_find_by_name(id, &span); + if (zstatus != FTDM_SUCCESS) { + zstatus = ftdm_span_find_by_name(id, &span); } } @@ -2193,8 +2193,8 @@ static switch_status_t load_config(void) to = atoi(digit_timeout); } - if (zstatus != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); + if (zstatus != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error finding OpenFTDM span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); continue; } @@ -2206,7 +2206,7 @@ static switch_status_t load_config(void) tonegroup = "us"; } - if (zap_configure_span("isdn", span, on_clear_channel_signal, + if (ftdm_configure_span("isdn", span, on_clear_channel_signal, "mode", mode, "dialect", dialect, "digit_timeout", &to, @@ -2214,8 +2214,8 @@ static switch_status_t load_config(void) "tonemap", tonegroup, "q921loglevel", q921loglevel, "q931loglevel", q931loglevel, - TAG_END) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error starting OpenZAP span %d mode: %s dialect: %s error: %s\n", span_id, mode, dialect, span->last_error); + TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error starting OpenFTDM span %d mode: %s dialect: %s error: %s\n", span_id, mode, dialect, span->last_error); continue; } @@ -2224,7 +2224,7 @@ static switch_status_t load_config(void) switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); switch_copy_string(SPAN_CONFIG[span->span_id].type, "isdn", sizeof(SPAN_CONFIG[span->span_id].type)); - zap_span_start(span); + ftdm_span_start(span); } } @@ -2234,7 +2234,7 @@ static switch_status_t load_config(void) for (myspan = switch_xml_child(spans, "span"); myspan; myspan = myspan->next) { char *id = (char *) switch_xml_attr(myspan, "id"); char *name = (char *) switch_xml_attr(myspan, "name"); - zap_status_t zstatus = ZAP_FAIL; + ftdm_status_t zstatus = FTDM_FAIL; const char *context = "default"; const char *dialplan = "XML"; @@ -2246,7 +2246,7 @@ static switch_status_t load_config(void) const char* opts = "none"; uint32_t span_id = 0; - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; for (param = switch_xml_child(myspan, "param"); param; param = param->next) { @@ -2278,20 +2278,20 @@ static switch_status_t load_config(void) } if (name) { - zstatus = zap_span_find_by_name(name, &span); + zstatus = ftdm_span_find_by_name(name, &span); } else { if (switch_is_number(id)) { span_id = atoi(id); - zstatus = zap_span_find(span_id, &span); + zstatus = ftdm_span_find(span_id, &span); } - if (zstatus != ZAP_SUCCESS) { - zstatus = zap_span_find_by_name(id, &span); + if (zstatus != FTDM_SUCCESS) { + zstatus = ftdm_span_find_by_name(id, &span); } } - if (zstatus != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); + if (zstatus != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error finding OpenFTDM span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); continue; } @@ -2300,15 +2300,15 @@ static switch_status_t load_config(void) } - if (zap_configure_span("libpri", span, on_clear_channel_signal, + if (ftdm_configure_span("libpri", span, on_clear_channel_signal, "node", o_node, "switch", o_switch, "dp", o_dp, "l1", o_l1, "debug", o_debug, "opts", opts, - TAG_END) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error starting OpenZAP span %d node: %s switch: %s dp: %s l1: %s debug: %s error: %s\n", + TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error starting OpenFTDM span %d node: %s switch: %s dp: %s l1: %s debug: %s error: %s\n", span_id, switch_str_nil(o_node), switch_str_nil(o_switch), switch_str_nil(o_dp), switch_str_nil(o_l1), switch_str_nil(o_debug), span->last_error); continue; @@ -2319,7 +2319,7 @@ static switch_status_t load_config(void) switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); switch_copy_string(SPAN_CONFIG[span->span_id].type, "isdn", sizeof(SPAN_CONFIG[span->span_id].type)); - zap_span_start(span); + ftdm_span_start(span); } } @@ -2328,17 +2328,17 @@ static switch_status_t load_config(void) char *id = (char *) switch_xml_attr(myspan, "id"); char *name = (char *) switch_xml_attr(myspan, "name"); char *sigmod = (char *) switch_xml_attr(myspan, "sigmod"); - zap_status_t zstatus = ZAP_FAIL; + ftdm_status_t zstatus = FTDM_FAIL; const char *context = "default"; const char *dialplan = "XML"; uint32_t span_id = 0; - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; const char *tonegroup = NULL; - zap_conf_parameter_t spanparameters[30]; + ftdm_conf_parameter_t spanparameters[30]; unsigned paramindex = 0; if (!id && !name) { - switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "boost span requires an id or name as attribute: \n"); + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "boost span requires an id or name as attribute: \n"); continue; } memset(spanparameters, 0, sizeof(spanparameters)); @@ -2373,20 +2373,20 @@ static switch_status_t load_config(void) } if (name) { - zstatus = zap_span_find_by_name(name, &span); + zstatus = ftdm_span_find_by_name(name, &span); } else { if (switch_is_number(id)) { span_id = atoi(id); - zstatus = zap_span_find(span_id, &span); + zstatus = ftdm_span_find(span_id, &span); } - if (zstatus != ZAP_SUCCESS) { - zstatus = zap_span_find_by_name(id, &span); + if (zstatus != FTDM_SUCCESS) { + zstatus = ftdm_span_find_by_name(id, &span); } } - if (zstatus != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); + if (zstatus != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error finding OpenFTDM span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); continue; } @@ -2394,8 +2394,8 @@ static switch_status_t load_config(void) span_id = span->span_id; } - if (zap_configure_span_signaling("sangoma_boost", span, on_clear_channel_signal, spanparameters) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error starting OpenZAP span %d error: %s\n", span_id, span->last_error); + if (ftdm_configure_span_signaling("sangoma_boost", span, on_clear_channel_signal, spanparameters) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error starting OpenFTDM span %d error: %s\n", span_id, span->last_error); continue; } @@ -2412,7 +2412,7 @@ static switch_status_t load_config(void) for (myspan = switch_xml_child(spans, "span"); myspan; myspan = myspan->next) { char *id = (char *) switch_xml_attr(myspan, "id"); char *name = (char *) switch_xml_attr(myspan, "name"); - zap_status_t zstatus = ZAP_FAIL; + ftdm_status_t zstatus = FTDM_FAIL; /* strings */ const char *variant = "itu"; @@ -2443,7 +2443,7 @@ static switch_status_t load_config(void) char *dial_regex = NULL; char *fail_dial_regex = NULL; uint32_t span_id = 0; - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; for (param = switch_xml_child(myspan, "param"); param; param = param->next) { @@ -2508,20 +2508,20 @@ static switch_status_t load_config(void) } if (name) { - zstatus = zap_span_find_by_name(name, &span); + zstatus = ftdm_span_find_by_name(name, &span); } else { if (switch_is_number(id)) { span_id = atoi(id); - zstatus = zap_span_find(span_id, &span); + zstatus = ftdm_span_find(span_id, &span); } - if (zstatus != ZAP_SUCCESS) { - zstatus = zap_span_find_by_name(id, &span); + if (zstatus != FTDM_SUCCESS) { + zstatus = ftdm_span_find_by_name(id, &span); } } - if (zstatus != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); + if (zstatus != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error finding OpenFTDM span id:%s name:%s\n", switch_str_nil(id), switch_str_nil(name)); continue; } @@ -2529,7 +2529,7 @@ static switch_status_t load_config(void) span_id = span->span_id; } - if (zap_configure_span("r2", span, on_r2_signal, + if (ftdm_configure_span("r2", span, on_r2_signal, "variant", variant, "max_ani", max_ani, "max_dnis", max_dnis, @@ -2547,8 +2547,8 @@ static switch_status_t load_config(void) "call_files", call_files, "mfback_timeout", mfback_timeout, "metering_pulse_timeout", metering_pulse_timeout, - TAG_END) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error configuring R2 OpenZAP span %d, error: %s\n", + TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error configuring R2 OpenFTDM span %d, error: %s\n", span_id, span->last_error); continue; } @@ -2566,8 +2566,8 @@ static switch_status_t load_config(void) switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); switch_copy_string(SPAN_CONFIG[span->span_id].type, "r2", sizeof(SPAN_CONFIG[span->span_id].type)); - if (zap_span_start(span) == ZAP_FAIL) { - zap_log(ZAP_LOG_ERROR, "Error starting R2 OpenZAP span %d, error: %s\n", span_id, span->last_error); + if (ftdm_span_start(span) == FTDM_FAIL) { + ftdm_log(FTDM_LOG_ERROR, "Error starting R2 OpenFTDM span %d, error: %s\n", span_id, span->last_error); continue; } } @@ -2577,9 +2577,9 @@ static switch_status_t load_config(void) * of needing all spans to be configured before starting them */ for ( ; i < boosti; i++) { boost_span = boost_spans[i]; - zap_log(ZAP_LOG_DEBUG, "Starting boost span %d\n", boost_span->span_id); - if (zap_span_start(boost_span) == ZAP_FAIL) { - zap_log(ZAP_LOG_ERROR, "Error starting boost OpenZAP span %d, error: %s\n", boost_span->span_id, boost_span->last_error); + ftdm_log(FTDM_LOG_DEBUG, "Starting boost span %d\n", boost_span->span_id); + if (ftdm_span_start(boost_span) == FTDM_FAIL) { + ftdm_log(FTDM_LOG_ERROR, "Error starting boost OpenFTDM span %d, error: %s\n", boost_span->span_id, boost_span->last_error); continue; } } @@ -2591,7 +2591,7 @@ static switch_status_t load_config(void) } -void dump_chan(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream) +void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream) { if (chan_id > span->chan_count) { return; @@ -2617,9 +2617,9 @@ void dump_chan(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *strea span->channels[chan_id]->chan_id, span->channels[chan_id]->physical_span_id, span->channels[chan_id]->physical_chan_id, - zap_chan_type2str(span->channels[chan_id]->type), - zap_channel_state2str(span->channels[chan_id]->state), - zap_channel_state2str(span->channels[chan_id]->last_state), + ftdm_chan_type2str(span->channels[chan_id]->type), + ftdm_channel_state2str(span->channels[chan_id]->state), + ftdm_channel_state2str(span->channels[chan_id]->last_state), span->channels[chan_id]->caller_data.cid_date, span->channels[chan_id]->caller_data.cid_name, span->channels[chan_id]->caller_data.cid_num.digits, @@ -2631,7 +2631,7 @@ void dump_chan(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *strea ); } -void dump_chan_xml(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream) +void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream) { if (chan_id > span->chan_count) { return; @@ -2659,9 +2659,9 @@ void dump_chan_xml(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *s span->channels[chan_id]->chan_id, span->channels[chan_id]->physical_span_id, span->channels[chan_id]->physical_chan_id, - zap_chan_type2str(span->channels[chan_id]->type), - zap_channel_state2str(span->channels[chan_id]->state), - zap_channel_state2str(span->channels[chan_id]->last_state), + ftdm_chan_type2str(span->channels[chan_id]->type), + ftdm_channel_state2str(span->channels[chan_id]->state), + ftdm_channel_state2str(span->channels[chan_id]->last_state), span->channels[chan_id]->caller_data.cid_date, span->channels[chan_id]->caller_data.cid_name, span->channels[chan_id]->caller_data.cid_num.digits, @@ -2673,8 +2673,8 @@ void dump_chan_xml(zap_span_t *span, uint32_t chan_id, switch_stream_handle_t *s ); } -#define OZ_SYNTAX "list || dump [] || q931_pcap on|off [pcapfilename without suffix] || gains " -SWITCH_STANDARD_API(oz_function) +#define FT_SYNTAX "list || dump [] || q931_pcap on|off [pcapfilename without suffix] || gains " +SWITCH_STANDARD_API(ft_function) { char *mycmd = NULL, *argv[10] = { 0 }; int argc = 0; @@ -2684,20 +2684,20 @@ SWITCH_STANDARD_API(oz_function) } if (!argc) { - stream->write_function(stream, "%s", OZ_SYNTAX); + stream->write_function(stream, "%s", FT_SYNTAX); goto end; } if (!strcasecmp(argv[0], "dump")) { if (argc < 2) { - stream->write_function(stream, "-ERR Usage: oz dump []\n"); + stream->write_function(stream, "-ERR Usage: ft dump []\n"); goto end; } else { uint32_t chan_id = 0; - zap_span_t *span; + ftdm_span_t *span; char *as = NULL; - zap_span_find_by_name(argv[1], &span); + ftdm_span_find_by_name(argv[1], &span); if (argc > 2) { if (argv[3] && !strcasecmp(argv[2], "as")) { @@ -2755,10 +2755,10 @@ SWITCH_STANDARD_API(oz_function) } } else if (!strcasecmp(argv[0], "list")) { int j; - for (j = 0 ; j < ZAP_MAX_SPANS_INTERFACE; j++) { + for (j = 0 ; j < FTDM_MAX_SPANS_INTERFACE; j++) { if (SPAN_CONFIG[j].span) { const char *flags = "none"; - zap_signaling_status_t sigstatus; + ftdm_signaling_status_t sigstatus; if (SPAN_CONFIG[j].analog_options & ANALOG_OPTION_3WAY) { flags = "3way"; @@ -2766,7 +2766,7 @@ SWITCH_STANDARD_API(oz_function) flags = "call swap"; } - if ((ZAP_SUCCESS == zap_span_get_sig_status(SPAN_CONFIG[j].span, &sigstatus))) { + if ((FTDM_SUCCESS == ftdm_span_get_sig_status(SPAN_CONFIG[j].span, &sigstatus))) { stream->write_function(stream, "+OK\n" "span: %u (%s)\n" @@ -2782,7 +2782,7 @@ SWITCH_STANDARD_API(oz_function) j, SPAN_CONFIG[j].span->name, SPAN_CONFIG[j].type, - zap_signaling_status2str(sigstatus), + ftdm_signaling_status2str(sigstatus), SPAN_CONFIG[j].span->chan_count, SPAN_CONFIG[j].dialplan, SPAN_CONFIG[j].context, @@ -2819,11 +2819,11 @@ SWITCH_STANDARD_API(oz_function) } } else if (!strcasecmp(argv[0], "stop") || !strcasecmp(argv[0], "start")) { char *span_name = argv[1]; - zap_span_t *span = NULL; - zap_status_t status; + ftdm_span_t *span = NULL; + ftdm_status_t status; if (span_name) { - zap_span_find_by_name(span_name, &span); + ftdm_span_find_by_name(span_name, &span); } if (!span) { @@ -2832,24 +2832,24 @@ SWITCH_STANDARD_API(oz_function) } if (!strcasecmp(argv[0], "stop")) { - status = zap_span_stop(span); + status = ftdm_span_stop(span); } else { - status = zap_span_start(span); + status = ftdm_span_start(span); } - stream->write_function(stream, status == ZAP_SUCCESS ? "+OK\n" : "-ERR failure\n"); + stream->write_function(stream, status == FTDM_SUCCESS ? "+OK\n" : "-ERR failure\n"); goto end; /*Q931ToPcap enhancement*/ } else if (!strcasecmp(argv[0], "q931_pcap")) { int32_t span_id = 0; - zap_span_t *span; + ftdm_span_t *span; const char *pcapfn = NULL; char *tmp_path = NULL; if (argc < 3) { - stream->write_function(stream, "-ERR Usage: oz q931_pcap on|off [pcapfilename without suffix]\n"); + stream->write_function(stream, "-ERR Usage: ft q931_pcap on|off [pcapfilename without suffix]\n"); goto end; } span_id = atoi(argv[1]); @@ -2872,21 +2872,21 @@ SWITCH_STANDARD_API(oz_function) tmp_path=switch_mprintf("%s%s%s.pcap", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, pcapfn); if(!strcasecmp(argv[2], "on")) { - if (zap_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 1, "pcapfilename", tmp_path, TAG_END) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_WARNING, "Error couldn't (re-)enable Q931-To-Pcap!\n"); + if (ftdm_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 1, "pcapfilename", tmp_path, TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_WARNING, "Error couldn't (re-)enable Q931-To-Pcap!\n"); goto end; } else { stream->write_function(stream, "+OK\n"); } } else if(!strcasecmp(argv[2], "off")) { - if (zap_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 0, TAG_END) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error couldn't enable Q931-To-Pcap!\n"); + if (ftdm_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 0, TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error couldn't enable Q931-To-Pcap!\n"); goto end; } else { stream->write_function(stream, "+OK\n"); } } else { - stream->write_function(stream, "-ERR Usage: oz q931_pcap on|off [pcapfilename without suffix]\n"); + stream->write_function(stream, "-ERR Usage: ft q931_pcap on|off [pcapfilename without suffix]\n"); goto end; } @@ -2895,12 +2895,12 @@ SWITCH_STANDARD_API(oz_function) float txgain = 0.0; float rxgain = 0.0; uint32_t chan_id = 0; - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; if (argc < 4) { - stream->write_function(stream, "-ERR Usage: oz gains []\n"); + stream->write_function(stream, "-ERR Usage: ft gains []\n"); goto end; } - zap_span_find_by_name(argv[3], &span); + ftdm_span_find_by_name(argv[3], &span); if (!span) { stream->write_function(stream, "-ERR invalid span\n"); goto end; @@ -2919,23 +2919,23 @@ SWITCH_STANDARD_API(oz_function) goto end; } if (chan_id) { - zap_channel_command(span->channels[chan_id], ZAP_COMMAND_SET_RX_GAIN, &rxgain); - zap_channel_command(span->channels[chan_id], ZAP_COMMAND_SET_TX_GAIN, &txgain); + ftdm_channel_command(span->channels[chan_id], FTDM_COMMAND_SET_RX_GAIN, &rxgain); + ftdm_channel_command(span->channels[chan_id], FTDM_COMMAND_SET_TX_GAIN, &txgain); } else { for (i = 1; i < span->chan_count; i++) { - zap_channel_command(span->channels[i], ZAP_COMMAND_SET_RX_GAIN, &rxgain); - zap_channel_command(span->channels[i], ZAP_COMMAND_SET_TX_GAIN, &txgain); + ftdm_channel_command(span->channels[i], FTDM_COMMAND_SET_RX_GAIN, &rxgain); + ftdm_channel_command(span->channels[i], FTDM_COMMAND_SET_TX_GAIN, &txgain); } } stream->write_function(stream, "+OK gains set to Rx %f and Tx %f\n", rxgain, txgain); } else { - char *rply = zap_api_execute(cmd, NULL); + char *rply = ftdm_api_execute(cmd, NULL); if (rply) { stream->write_function(stream, "%s", rply); free(rply); } else { - stream->write_function(stream, "-ERR Usage: %s\n", OZ_SYNTAX); + stream->write_function(stream, "-ERR Usage: %s\n", FT_SYNTAX); } } /*Q931ToPcap enhancement done*/ @@ -2953,19 +2953,19 @@ SWITCH_STANDARD_APP(disable_ec_function) private_t *tech_pvt; int x = 0; - if (!switch_core_session_check_interface(session, openzap_endpoint_interface)) { - zap_log(ZAP_LOG_ERROR, "This application is only for OpenZAP channels.\n"); + if (!switch_core_session_check_interface(session, freetdm_endpoint_interface)) { + ftdm_log(FTDM_LOG_ERROR, "This application is only for OpenFTDM channels.\n"); return; } tech_pvt = switch_core_session_get_private(session); - zap_channel_command(tech_pvt->zchan, ZAP_COMMAND_DISABLE_ECHOCANCEL, &x); - zap_channel_command(tech_pvt->zchan, ZAP_COMMAND_DISABLE_ECHOTRAIN, &x); - zap_log(ZAP_LOG_INFO, "Echo Canceller Disabled\n"); + ftdm_channel_command(tech_pvt->ftdmchan, FTDM_COMMAND_DISABLE_ECHOCANCEL, &x); + ftdm_channel_command(tech_pvt->ftdmchan, FTDM_COMMAND_DISABLE_ECHOTRAIN, &x); + ftdm_log(FTDM_LOG_INFO, "Echo Canceller Disabled\n"); } -SWITCH_MODULE_LOAD_FUNCTION(mod_openzap_load) +SWITCH_MODULE_LOAD_FUNCTION(mod_freetdm_load) { switch_api_interface_t *commands_api_interface; @@ -2973,30 +2973,30 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_openzap_load) module_pool = pool; - zap_global_set_logger(zap_logger); + ftdm_global_set_logger(ftdm_logger); - if (zap_global_init() != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error loading OpenFTDM\n"); return SWITCH_STATUS_TERM; } - if (zap_global_configuration() != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error configuring OpenZAP\n"); + if (ftdm_global_configuration() != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error configuring OpenFTDM\n"); return SWITCH_STATUS_TERM; } if (load_config() != SWITCH_STATUS_SUCCESS) { - zap_global_destroy(); + ftdm_global_destroy(); return SWITCH_STATUS_TERM; } *module_interface = switch_loadable_module_create_module_interface(pool, modname); - openzap_endpoint_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE); - openzap_endpoint_interface->interface_name = "openzap"; - openzap_endpoint_interface->io_routines = &openzap_io_routines; - openzap_endpoint_interface->state_handler = &openzap_state_handlers; + freetdm_endpoint_interface = switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE); + freetdm_endpoint_interface->interface_name = "freetdm"; + freetdm_endpoint_interface->io_routines = &freetdm_io_routines; + freetdm_endpoint_interface->state_handler = &freetdm_state_handlers; - SWITCH_ADD_API(commands_api_interface, "oz", "OpenZAP commands", oz_function, OZ_SYNTAX); + SWITCH_ADD_API(commands_api_interface, "ft", "OpenFTDM commands", ft_function, FT_SYNTAX); SWITCH_ADD_APP(app_interface, "disable_ec", "Disable Echo Canceller", "Disable Echo Canceller", disable_ec_function, "", SAF_NONE); @@ -3004,9 +3004,9 @@ SWITCH_MODULE_LOAD_FUNCTION(mod_openzap_load) return SWITCH_STATUS_SUCCESS; } -SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_openzap_shutdown) +SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_freetdm_shutdown) { - zap_global_destroy(); + ftdm_global_destroy(); // this breaks pika but they are MIA so *shrug* //return SWITCH_STATUS_NOUNLOAD; diff --git a/libs/freetdm/mod_openzap/mod_openzap.2005.vcproj b/libs/freetdm/mod_freetdm/mod_openzap.2005.vcproj similarity index 100% rename from libs/freetdm/mod_openzap/mod_openzap.2005.vcproj rename to libs/freetdm/mod_freetdm/mod_openzap.2005.vcproj diff --git a/libs/freetdm/mod_openzap/mod_openzap.2008.vcproj b/libs/freetdm/mod_freetdm/mod_openzap.2008.vcproj similarity index 100% rename from libs/freetdm/mod_openzap/mod_openzap.2008.vcproj rename to libs/freetdm/mod_freetdm/mod_openzap.2008.vcproj diff --git a/libs/freetdm/mod_openzap/Makefile.in b/libs/freetdm/mod_openzap/Makefile.in deleted file mode 100644 index 85275d1d8d..0000000000 --- a/libs/freetdm/mod_openzap/Makefile.in +++ /dev/null @@ -1,23 +0,0 @@ -OZ_CFLAGS=@CFLAGS@ @COMP_VENDOR_CFLAGS@ @DEFS@ - -BASE=../../.. -OZ_DIR=.. -VERBOSE=1 -OZLA=$(OZ_DIR)/libopenzap.la -LOCAL_CFLAGS=-I$(OZ_DIR)/src/include -I$(OZ_DIR)/src/isdn/include $(OZ_CFLAGS) -LOCAL_LDFLAGS=-L$(OZ_DIR) -lopenzap -include $(BASE)/build/modmake.rules - -local_depend: $(OZLA) - -$(OZLA): $(OZ_DIR)/.update - cd $(OZ_DIR) && $(MAKE) - -local_install: - cd $(OZ_DIR) && $(MAKE) install - [ -f $(DESTDIR)@confdir@/autoload_configs/openzap.conf.xml ] || cp -f $(OZ_DIR)/conf/openzap.conf.xml $(DESTDIR)@confdir@/autoload_configs - -local_clean: - cd $(OZ_DIR) && $(MAKE) clean - - diff --git a/libs/freetdm/ozrename.sh b/libs/freetdm/ozrename.sh index 575e6b0cba..369be1c3a1 100755 --- a/libs/freetdm/ozrename.sh +++ b/libs/freetdm/ozrename.sh @@ -1,40 +1,57 @@ # renaming main header and build file -move="mv" -$move src/include/openzap.h src/include/freetdm.h -$move openzap.pc.in freetdm.pc.in -$move mod_openzap/mod_openzap.c mod_openzap/mod_freetdm.c -$move mod_openzap mod_freetdm +copy="cp -r" +$copy src/include/openzap.h src/include/freetdm.h +svn delete src/include/openzap.h +$copy openzap.pc.in freetdm.pc.in +svn delete openzap.pc.in + +# create mod_freetdm +mkdir mod_freetdm +cp mod_openzap/* mod_freetdm/ +mv mod_freetdm/mod_openzap.c mod_freetdm/mod_freetdm.c +svn delete --force mod_openzap + + +##### ozmod stuff #### # rename anything ozmod to ftmod, including directories first -$move src/ozmod src/ftmod -for file in `find ./ -name *ozmod_* -type d` +mkdir ./src/ftmod +for file in `find ./src/ozmod -name *ozmod_* -type d` do - $move $file ${file//ozmod/ftmod} + $copy ${file} ${file//ozmod/ftmod} done -# move ozmod c files -for file in `find ./ -name *ozmod_*.c` +#remove .svn directories in the copied ozmod dirs +find ./src/ftmod -name *.svn -exec rm -rf {} \; + +# copy ozmod c files +for file in `find ./src/ftmod -name *ozmod_*.c` do - $move $file ${file//ozmod/ftmod} + mv $file ${file//ozmod/ftmod} done -# move ozmod h files -for file in `find ./ -name *ozmod_*.h` +# copy ozmod h files +for file in `find ./src/ftmod -name *ozmod_*.h` do - $move $file ${file//ozmod/ftmod} + mv $file ${file//ozmod/ftmod} done -# renaming other files +#### end ozmod stuff #### + +# renaming other zap files for file in `find ./ -name *zap_*.c` do - $move $file ${file//zap_/ftdm_} + mv $file ${file//zap_/ftdm_} done for file in `find ./ -name *zap_*.h` do - $move $file ${file//zap_/ftdm_} + mv $file ${file//zap_/ftdm_} done +svn revert -R src/ozmod +svn delete --force src/ozmod + # replace full openzap occurences first (handles openzap.h, libopenzap etc) find ./ -name *.c -exec sed -i 's,openzap,freetdm,g' {} \; @@ -77,3 +94,6 @@ sed -i 's,zap,ftdm,g' mod_freetdm/Makefile.in sed -i 's,ZAP,FTDM,g' mod_freetdm/Makefile.in sed -i 's,zchan,ftdmchan,g' mod_freetdm/Makefile.in +svn add src/ftmod/ +svn add mod_freetdm/ + diff --git a/libs/freetdm/src/detect_dtmf.c b/libs/freetdm/src/detect_dtmf.c index f73586adcb..e7d9648192 100644 --- a/libs/freetdm/src/detect_dtmf.c +++ b/libs/freetdm/src/detect_dtmf.c @@ -1,4 +1,4 @@ -//#include "openzap.h" +//#include "freetdm.h" #include "libteletone_detect.h" int main(int argc, char *argv[]) diff --git a/libs/freetdm/src/detect_tones.c b/libs/freetdm/src/detect_tones.c index 580f6a9d17..5cd52d4d99 100644 --- a/libs/freetdm/src/detect_tones.c +++ b/libs/freetdm/src/detect_tones.c @@ -1,4 +1,4 @@ -//#include "openzap.h" +//#include "freetdm.h" #include "libteletone_detect.h" int main(int argc, char *argv[]) diff --git a/libs/freetdm/src/fsk.c b/libs/freetdm/src/fsk.c index 16a1bcb7d4..60a4722a4c 100644 --- a/libs/freetdm/src/fsk.c +++ b/libs/freetdm/src/fsk.c @@ -32,7 +32,7 @@ * * 2005 03 20 R. Krten created */ -#include +#include #include #include #include @@ -134,7 +134,7 @@ dsp_fsk_handle_t *dsp_fsk_create(dsp_fsk_attr_t *attr) double phi_mark, phi_space; dsp_fsk_handle_t *handle; - handle = zap_malloc(sizeof(*handle)); + handle = ftdm_malloc(sizeof(*handle)); if (!handle) { return NULL; } @@ -157,7 +157,7 @@ dsp_fsk_handle_t *dsp_fsk_create(dsp_fsk_attr_t *attr) /* allocate the correlation sin/cos arrays and initialize */ for (i = 0; i < 4; i++) { - handle->correlates[i] = zap_malloc(sizeof(double) * handle->corrsize); + handle->correlates[i] = ftdm_malloc(sizeof(double) * handle->corrsize); if (handle->correlates[i] == NULL) { /* some failed, back out memory allocations */ dsp_fsk_destroy(&handle); @@ -177,7 +177,7 @@ dsp_fsk_handle_t *dsp_fsk_create(dsp_fsk_attr_t *attr) } /* initialize the ring buffer */ - handle->buffer = zap_malloc(sizeof(double) * handle->corrsize); + handle->buffer = ftdm_malloc(sizeof(double) * handle->corrsize); if (!handle->buffer) { /* failed; back out memory allocations */ dsp_fsk_destroy(&handle); return NULL; @@ -226,13 +226,13 @@ void dsp_fsk_destroy(dsp_fsk_handle_t **handle) for (i = 0; i < 4; i++) { if ((*handle)->correlates[i] != NULL) { - zap_safe_free((*handle)->correlates[i]); + ftdm_safe_free((*handle)->correlates[i]); (*handle)->correlates[i] = NULL; } } if ((*handle)->buffer != NULL) { - zap_safe_free((*handle)->buffer); + ftdm_safe_free((*handle)->buffer); (*handle)->buffer = NULL; } @@ -241,7 +241,7 @@ void dsp_fsk_destroy(dsp_fsk_handle_t **handle) dsp_uart_destroy(dhandle); } - zap_safe_free(*handle); + ftdm_safe_free(*handle); *handle = NULL; } diff --git a/libs/freetdm/src/zap_buffer.c b/libs/freetdm/src/ftdm_buffer.c similarity index 71% rename from libs/freetdm/src/zap_buffer.c rename to libs/freetdm/src/ftdm_buffer.c index 11a7c03d29..2f08e7bbee 100644 --- a/libs/freetdm/src/zap_buffer.c +++ b/libs/freetdm/src/ftdm_buffer.c @@ -31,37 +31,37 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "openzap.h" -#include "zap_buffer.h" +#include "freetdm.h" +#include "ftdm_buffer.h" static unsigned buffer_id = 0; -struct zap_buffer { +struct ftdm_buffer { unsigned char *data; unsigned char *head; - zap_size_t used; - zap_size_t actually_used; - zap_size_t datalen; - zap_size_t max_len; - zap_size_t blocksize; + ftdm_size_t used; + ftdm_size_t actually_used; + ftdm_size_t datalen; + ftdm_size_t max_len; + ftdm_size_t blocksize; unsigned id; int loops; }; -OZ_DECLARE(zap_status_t) zap_buffer_create(zap_buffer_t **buffer, zap_size_t blocksize, zap_size_t start_len, zap_size_t max_len) +FT_DECLARE(ftdm_status_t) ftdm_buffer_create(ftdm_buffer_t **buffer, ftdm_size_t blocksize, ftdm_size_t start_len, ftdm_size_t max_len) { - zap_buffer_t *new_buffer; + ftdm_buffer_t *new_buffer; - new_buffer = zap_malloc(sizeof(*new_buffer)); + new_buffer = ftdm_malloc(sizeof(*new_buffer)); if (new_buffer) { memset(new_buffer, 0, sizeof(*new_buffer)); if (start_len) { - new_buffer->data = zap_malloc(start_len); + new_buffer->data = ftdm_malloc(start_len); if (!new_buffer->data) { - zap_safe_free(new_buffer); - return ZAP_MEMERR; + ftdm_safe_free(new_buffer); + return FTDM_MEMERR; } memset(new_buffer->data, 0, start_len); } @@ -73,13 +73,13 @@ OZ_DECLARE(zap_status_t) zap_buffer_create(zap_buffer_t **buffer, zap_size_t blo new_buffer->head = new_buffer->data; *buffer = new_buffer; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_MEMERR; + return FTDM_MEMERR; } -OZ_DECLARE(zap_size_t) zap_buffer_len(zap_buffer_t *buffer) +FT_DECLARE(ftdm_size_t) ftdm_buffer_len(ftdm_buffer_t *buffer) { assert(buffer != NULL); @@ -89,28 +89,28 @@ OZ_DECLARE(zap_size_t) zap_buffer_len(zap_buffer_t *buffer) } -OZ_DECLARE(zap_size_t) zap_buffer_freespace(zap_buffer_t *buffer) +FT_DECLARE(ftdm_size_t) ftdm_buffer_freespace(ftdm_buffer_t *buffer) { assert(buffer != NULL); if (buffer->max_len) { - return (zap_size_t) (buffer->max_len - buffer->used); + return (ftdm_size_t) (buffer->max_len - buffer->used); } return 1000000; } -OZ_DECLARE(zap_size_t) zap_buffer_inuse(zap_buffer_t *buffer) +FT_DECLARE(ftdm_size_t) ftdm_buffer_inuse(ftdm_buffer_t *buffer) { assert(buffer != NULL); return buffer->used; } -OZ_DECLARE(zap_size_t) zap_buffer_seek(zap_buffer_t *buffer, zap_size_t datalen) +FT_DECLARE(ftdm_size_t) ftdm_buffer_seek(ftdm_buffer_t *buffer, ftdm_size_t datalen) { - zap_size_t reading = 0; + ftdm_size_t reading = 0; assert(buffer != NULL); @@ -129,9 +129,9 @@ OZ_DECLARE(zap_size_t) zap_buffer_seek(zap_buffer_t *buffer, zap_size_t datalen) return reading; } -OZ_DECLARE(zap_size_t) zap_buffer_toss(zap_buffer_t *buffer, zap_size_t datalen) +FT_DECLARE(ftdm_size_t) ftdm_buffer_toss(ftdm_buffer_t *buffer, ftdm_size_t datalen) { - zap_size_t reading = 0; + ftdm_size_t reading = 0; assert(buffer != NULL); @@ -150,29 +150,29 @@ OZ_DECLARE(zap_size_t) zap_buffer_toss(zap_buffer_t *buffer, zap_size_t datalen) return buffer->used; } -OZ_DECLARE(void) zap_buffer_set_loops(zap_buffer_t *buffer, int loops) +FT_DECLARE(void) ftdm_buffer_set_loops(ftdm_buffer_t *buffer, int loops) { buffer->loops = loops; } -OZ_DECLARE(zap_size_t) zap_buffer_read_loop(zap_buffer_t *buffer, void *data, zap_size_t datalen) +FT_DECLARE(ftdm_size_t) ftdm_buffer_read_loop(ftdm_buffer_t *buffer, void *data, ftdm_size_t datalen) { - zap_size_t len; - if ((len = zap_buffer_read(buffer, data, datalen)) < datalen) { + ftdm_size_t len; + if ((len = ftdm_buffer_read(buffer, data, datalen)) < datalen) { if (buffer->loops == 0) { return len; } buffer->head = buffer->data; buffer->used = buffer->actually_used; - len = zap_buffer_read(buffer, (char*)data + len, datalen - len); + len = ftdm_buffer_read(buffer, (char*)data + len, datalen - len); buffer->loops--; } return len; } -OZ_DECLARE(zap_size_t) zap_buffer_read(zap_buffer_t *buffer, void *data, zap_size_t datalen) +FT_DECLARE(ftdm_size_t) ftdm_buffer_read(ftdm_buffer_t *buffer, void *data, ftdm_size_t datalen) { - zap_size_t reading = 0; + ftdm_size_t reading = 0; assert(buffer != NULL); assert(data != NULL); @@ -195,9 +195,9 @@ OZ_DECLARE(zap_size_t) zap_buffer_read(zap_buffer_t *buffer, void *data, zap_siz return reading; } -OZ_DECLARE(zap_size_t) zap_buffer_write(zap_buffer_t *buffer, const void *data, zap_size_t datalen) +FT_DECLARE(ftdm_size_t) ftdm_buffer_write(ftdm_buffer_t *buffer, const void *data, ftdm_size_t datalen) { - zap_size_t freespace, actual_freespace; + ftdm_size_t freespace, actual_freespace; assert(buffer != NULL); assert(data != NULL); @@ -224,7 +224,7 @@ OZ_DECLARE(zap_size_t) zap_buffer_write(zap_buffer_t *buffer, const void *data, */ if (freespace < datalen) { - zap_size_t new_size, new_block_size; + ftdm_size_t new_size, new_block_size; void *data; new_size = buffer->datalen + datalen; @@ -258,7 +258,7 @@ OZ_DECLARE(zap_size_t) zap_buffer_write(zap_buffer_t *buffer, const void *data, return buffer->used; } -OZ_DECLARE(void) zap_buffer_zero(zap_buffer_t *buffer) +FT_DECLARE(void) ftdm_buffer_zero(ftdm_buffer_t *buffer) { assert(buffer != NULL); assert(buffer->data != NULL); @@ -268,23 +268,23 @@ OZ_DECLARE(void) zap_buffer_zero(zap_buffer_t *buffer) buffer->head = buffer->data; } -OZ_DECLARE(zap_size_t) zap_buffer_zwrite(zap_buffer_t *buffer, const void *data, zap_size_t datalen) +FT_DECLARE(ftdm_size_t) ftdm_buffer_zwrite(ftdm_buffer_t *buffer, const void *data, ftdm_size_t datalen) { - zap_size_t w; + ftdm_size_t w; - if (!(w = zap_buffer_write(buffer, data, datalen))) { - zap_buffer_zero(buffer); - return zap_buffer_write(buffer, data, datalen); + if (!(w = ftdm_buffer_write(buffer, data, datalen))) { + ftdm_buffer_zero(buffer); + return ftdm_buffer_write(buffer, data, datalen); } return w; } -OZ_DECLARE(void) zap_buffer_destroy(zap_buffer_t **buffer) +FT_DECLARE(void) ftdm_buffer_destroy(ftdm_buffer_t **buffer) { if (*buffer) { - zap_safe_free((*buffer)->data); - zap_safe_free(*buffer); + ftdm_safe_free((*buffer)->data); + ftdm_safe_free(*buffer); } *buffer = NULL; diff --git a/libs/freetdm/src/zap_callerid.c b/libs/freetdm/src/ftdm_callerid.c similarity index 61% rename from libs/freetdm/src/zap_callerid.c rename to libs/freetdm/src/ftdm_callerid.c index 7a6e658261..16dd5c8ed7 100644 --- a/libs/freetdm/src/zap_callerid.c +++ b/libs/freetdm/src/ftdm_callerid.c @@ -1,4 +1,4 @@ -#include "openzap.h" +#include "freetdm.h" #include "fsk.h" #include "uart.h" @@ -6,7 +6,7 @@ static void fsk_byte_handler (void *x, int data) { - zap_fsk_data_state_t *state = (zap_fsk_data_state_t *) x; + ftdm_fsk_data_state_t *state = (ftdm_fsk_data_state_t *) x; uint8_t byte = (uint8_t)data; top: @@ -37,42 +37,42 @@ static void fsk_byte_handler (void *x, int data) } } -OZ_DECLARE(zap_status_t) zap_fsk_data_init(zap_fsk_data_state_t *state, uint8_t *data, uint32_t datalen) +FT_DECLARE(ftdm_status_t) ftdm_fsk_data_init(ftdm_fsk_data_state_t *state, uint8_t *data, uint32_t datalen) { memset(state, 0, sizeof(*state)); state->buf = data; state->bufsize = datalen; state->bpos = 2; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) zap_fsk_data_add_sdmf(zap_fsk_data_state_t *state, const char *date, char *number) +FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number) { size_t dlen = strlen(date); size_t nlen = strlen(number); - state->buf[0] = ZAP_CID_TYPE_SDMF; + state->buf[0] = FTDM_CID_TYPE_SDMF; memcpy(&state->buf[state->bpos], date, dlen); state->bpos += dlen; memcpy(&state->buf[state->bpos], number, nlen); state->bpos += nlen; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) zap_fsk_data_add_mdmf(zap_fsk_data_state_t *state, zap_mdmf_type_t type, const uint8_t *data, uint32_t datalen) +FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_mdmf(ftdm_fsk_data_state_t *state, ftdm_mdmf_type_t type, const uint8_t *data, uint32_t datalen) { - state->buf[0] = ZAP_CID_TYPE_MDMF; + state->buf[0] = FTDM_CID_TYPE_MDMF; state->buf[state->bpos++] = type; state->buf[state->bpos++] = (uint8_t)datalen; memcpy(&state->buf[state->bpos], data, datalen); state->bpos += datalen; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) zap_fsk_data_add_checksum(zap_fsk_data_state_t *state) +FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *state) { uint32_t i; uint8_t check = 0; @@ -89,20 +89,20 @@ OZ_DECLARE(zap_status_t) zap_fsk_data_add_checksum(zap_fsk_data_state_t *state) state->dlen = state->bpos; state->blen = state->buf[1]; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) zap_fsk_data_parse(zap_fsk_data_state_t *state, zap_size_t *type, char **data, zap_size_t *len) +FT_DECLARE(ftdm_status_t) ftdm_fsk_data_parse(ftdm_fsk_data_state_t *state, ftdm_size_t *type, char **data, ftdm_size_t *len) { - zap_size_t i; + ftdm_size_t i; int sum = 0; top: if (state->checksum != 0 || state->ppos >= state->dlen - 1) { - return ZAP_FAIL; + return FTDM_FAIL; } if (!state->ppos) { @@ -112,13 +112,13 @@ OZ_DECLARE(zap_status_t) zap_fsk_data_parse(zap_fsk_data_state_t *state, zap_siz state->checksum = sum % 256; state->ppos = 2; - if (state->buf[0] != ZAP_CID_TYPE_MDMF && state->buf[0] != ZAP_CID_TYPE_SDMF) { + if (state->buf[0] != FTDM_CID_TYPE_MDMF && state->buf[0] != FTDM_CID_TYPE_SDMF) { state->checksum = -1; } goto top; } - if (state->buf[0] == ZAP_CID_TYPE_SDMF) { + if (state->buf[0] == FTDM_CID_TYPE_SDMF) { /* convert sdmf to mdmf so we don't need 2 parsers */ if (state->ppos == 2) { *type = MDMF_DATETIME; @@ -134,46 +134,46 @@ OZ_DECLARE(zap_status_t) zap_fsk_data_parse(zap_fsk_data_state_t *state, zap_siz } *data = (char *)&state->buf[state->ppos]; state->ppos += *len; - return ZAP_SUCCESS; - } else if (state->buf[0] == ZAP_CID_TYPE_MDMF) { + return FTDM_SUCCESS; + } else if (state->buf[0] == FTDM_CID_TYPE_MDMF) { *type = state->buf[state->ppos++]; *len = state->buf[state->ppos++]; *data = (char *)&state->buf[state->ppos]; state->ppos += *len; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_FAIL; + return FTDM_FAIL; } -OZ_DECLARE(zap_status_t) zap_fsk_demod_feed(zap_fsk_data_state_t *state, int16_t *data, zap_size_t samples) +FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_feed(ftdm_fsk_data_state_t *state, int16_t *data, ftdm_size_t samples) { uint32_t x; int16_t *sp = data; if (state->init == 3) { - return ZAP_FAIL; + return FTDM_FAIL; } for (x = 0; x < samples; x++) { dsp_fsk_sample (state->fsk1200_handle, (double) *sp++ / 32767.0); if (state->dlen && state->bpos >= state->dlen) { state->init = 3; - return ZAP_FAIL; + return FTDM_FAIL; } } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) zap_fsk_demod_destroy(zap_fsk_data_state_t *state) +FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_destroy(ftdm_fsk_data_state_t *state) { dsp_fsk_destroy(&state->fsk1200_handle); memset(state, 0, sizeof(*state)); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(int) zap_fsk_demod_init(zap_fsk_data_state_t *state, int rate, uint8_t *buf, zap_size_t bufsize) +FT_DECLARE(int) ftdm_fsk_demod_init(ftdm_fsk_data_state_t *state, int rate, uint8_t *buf, ftdm_size_t bufsize) { dsp_fsk_attr_t fsk1200_attr; @@ -193,20 +193,20 @@ OZ_DECLARE(int) zap_fsk_demod_init(zap_fsk_data_state_t *state, int rate, uint8_ state->fsk1200_handle = dsp_fsk_create (&fsk1200_attr); if (state->fsk1200_handle == NULL) { - return ZAP_FAIL; + return FTDM_FAIL; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_size_t) zap_fsk_modulator_generate_bit(zap_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, zap_size_t buflen) +FT_DECLARE(ftdm_size_t) ftdm_fsk_modulator_generate_bit(ftdm_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, ftdm_size_t buflen) { - zap_size_t i; + ftdm_size_t i; for(i = 0 ; i < buflen; i++) { fsk_trans->bit_accum += fsk_trans->bit_factor; - if (fsk_trans->bit_accum >= ZAP_FSK_MOD_FACTOR) { - fsk_trans->bit_accum -= (ZAP_FSK_MOD_FACTOR + fsk_trans->bit_factor); + if (fsk_trans->bit_accum >= FTDM_FSK_MOD_FACTOR) { + fsk_trans->bit_accum -= (FTDM_FSK_MOD_FACTOR + fsk_trans->bit_factor); break; } @@ -217,15 +217,15 @@ OZ_DECLARE(zap_size_t) zap_fsk_modulator_generate_bit(zap_fsk_modulator_t *fsk_t } -OZ_DECLARE(int32_t) zap_fsk_modulator_generate_carrier_bits(zap_fsk_modulator_t *fsk_trans, uint32_t bits) +FT_DECLARE(int32_t) ftdm_fsk_modulator_generate_carrier_bits(ftdm_fsk_modulator_t *fsk_trans, uint32_t bits) { uint32_t i = 0; - zap_size_t r = 0; + ftdm_size_t r = 0; int8_t bit = 1; for (i = 0; i < bits; i++) { - if ((r = zap_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) { - if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != ZAP_SUCCESS) { + if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) { + if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) { break; } } else { @@ -237,15 +237,15 @@ OZ_DECLARE(int32_t) zap_fsk_modulator_generate_carrier_bits(zap_fsk_modulator_t } -OZ_DECLARE(void) zap_fsk_modulator_generate_chan_sieze(zap_fsk_modulator_t *fsk_trans) +FT_DECLARE(void) ftdm_fsk_modulator_generate_chan_sieze(ftdm_fsk_modulator_t *fsk_trans) { uint32_t i = 0; - zap_size_t r = 0; + ftdm_size_t r = 0; int8_t bit = 0; for (i = 0; i < fsk_trans->chan_sieze_bits; i++) { - if ((r = zap_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) { - if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != ZAP_SUCCESS) { + if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) { + if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) { break; } } else { @@ -258,14 +258,14 @@ OZ_DECLARE(void) zap_fsk_modulator_generate_chan_sieze(zap_fsk_modulator_t *fsk_ } -OZ_DECLARE(void) zap_fsk_modulator_send_data(zap_fsk_modulator_t *fsk_trans) +FT_DECLARE(void) ftdm_fsk_modulator_send_data(ftdm_fsk_modulator_t *fsk_trans) { - zap_size_t r = 0; + ftdm_size_t r = 0; int8_t bit = 0; - while((bit = zap_bitstream_get_bit(&fsk_trans->bs)) > -1) { - if ((r = zap_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) { - if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != ZAP_SUCCESS) { + while((bit = ftdm_bitstream_get_bit(&fsk_trans->bs)) > -1) { + if ((r = ftdm_fsk_modulator_generate_bit(fsk_trans, bit, fsk_trans->sample_buffer, sizeof(fsk_trans->sample_buffer) / 2))) { + if (fsk_trans->write_sample_callback(fsk_trans->sample_buffer, r, fsk_trans->user_data) != FTDM_SUCCESS) { break; } } else { @@ -275,33 +275,33 @@ OZ_DECLARE(void) zap_fsk_modulator_send_data(zap_fsk_modulator_t *fsk_trans) } -OZ_DECLARE(zap_status_t) zap_fsk_modulator_init(zap_fsk_modulator_t *fsk_trans, +FT_DECLARE(ftdm_status_t) ftdm_fsk_modulator_init(ftdm_fsk_modulator_t *fsk_trans, fsk_modem_types_t modem_type, uint32_t sample_rate, - zap_fsk_data_state_t *fsk_data, + ftdm_fsk_data_state_t *fsk_data, float db_level, uint32_t carrier_bits_start, uint32_t carrier_bits_stop, uint32_t chan_sieze_bits, - zap_fsk_write_sample_t write_sample_callback, + ftdm_fsk_write_sample_t write_sample_callback, void *user_data) { memset(fsk_trans, 0, sizeof(*fsk_trans)); fsk_trans->modem_type = modem_type; teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_space, sample_rate, 0); teletone_dds_state_set_tone(&fsk_trans->dds, fsk_modem_definitions[fsk_trans->modem_type].freq_mark, sample_rate, 1); - fsk_trans->bit_factor = (uint32_t)((fsk_modem_definitions[fsk_trans->modem_type].baud_rate * ZAP_FSK_MOD_FACTOR) / (float)sample_rate); + fsk_trans->bit_factor = (uint32_t)((fsk_modem_definitions[fsk_trans->modem_type].baud_rate * FTDM_FSK_MOD_FACTOR) / (float)sample_rate); fsk_trans->samples_per_bit = (uint32_t) (sample_rate / fsk_modem_definitions[fsk_trans->modem_type].baud_rate); fsk_trans->est_bytes = (int32_t)(((fsk_data->dlen * 10) + carrier_bits_start + carrier_bits_stop + chan_sieze_bits) * ((fsk_trans->samples_per_bit + 1) * 2)); fsk_trans->bit_accum = 0; fsk_trans->fsk_data = fsk_data; teletone_dds_state_set_tx_level(&fsk_trans->dds, db_level); - zap_bitstream_init(&fsk_trans->bs, fsk_trans->fsk_data->buf, (uint32_t)fsk_trans->fsk_data->dlen, ZAP_ENDIAN_BIG, 1); + ftdm_bitstream_init(&fsk_trans->bs, fsk_trans->fsk_data->buf, (uint32_t)fsk_trans->fsk_data->dlen, FTDM_ENDIAN_BIG, 1); fsk_trans->carrier_bits_start = carrier_bits_start; fsk_trans->carrier_bits_stop = carrier_bits_stop; fsk_trans->chan_sieze_bits = chan_sieze_bits; fsk_trans->write_sample_callback = write_sample_callback; fsk_trans->user_data = user_data; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } diff --git a/libs/freetdm/src/zap_config.c b/libs/freetdm/src/ftdm_config.c similarity index 77% rename from libs/freetdm/src/zap_config.c rename to libs/freetdm/src/ftdm_config.c index ca0315594b..a7a8f041b1 100644 --- a/libs/freetdm/src/zap_config.c +++ b/libs/freetdm/src/ftdm_config.c @@ -31,10 +31,10 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "openzap.h" -#include "zap_config.h" +#include "freetdm.h" +#include "ftdm_config.h" -int zap_config_open_file(zap_config_t *cfg, const char *file_path) +int ftdm_config_open_file(ftdm_config_t *cfg, const char *file_path) { FILE *f; const char *path = NULL; @@ -43,7 +43,7 @@ int zap_config_open_file(zap_config_t *cfg, const char *file_path) if (file_path[0] == '/') { path = file_path; } else { - snprintf(path_buf, sizeof(path_buf), "%s%s%s", ZAP_CONFIG_DIR, ZAP_PATH_SEPARATOR, file_path); + snprintf(path_buf, sizeof(path_buf), "%s%s%s", FTDM_CONFIG_DIR, FTDM_PATH_SEPARATOR, file_path); path = path_buf; } @@ -53,7 +53,7 @@ int zap_config_open_file(zap_config_t *cfg, const char *file_path) memset(cfg, 0, sizeof(*cfg)); cfg->lockto = -1; - zap_log(ZAP_LOG_DEBUG, "Configuration file is %s.\n", path); + ftdm_log(FTDM_LOG_DEBUG, "Configuration file is %s.\n", path); f = fopen(path, "r"); if (!f) { @@ -61,7 +61,7 @@ int zap_config_open_file(zap_config_t *cfg, const char *file_path) int last = -1; char *var, *val; - snprintf(path_buf, sizeof(path_buf), "%s%sopenzap.conf", ZAP_CONFIG_DIR, ZAP_PATH_SEPARATOR); + snprintf(path_buf, sizeof(path_buf), "%s%sfreetdm.conf", FTDM_CONFIG_DIR, FTDM_PATH_SEPARATOR); path = path_buf; if ((f = fopen(path, "r")) == 0) { @@ -69,16 +69,16 @@ int zap_config_open_file(zap_config_t *cfg, const char *file_path) } cfg->file = f; - zap_set_string(cfg->path, path); + ftdm_set_string(cfg->path, path); - while (zap_config_next_pair(cfg, &var, &val)) { + while (ftdm_config_next_pair(cfg, &var, &val)) { if ((cfg->sectno != last) && !strcmp(cfg->section, file_path)) { cfg->lockto = cfg->sectno; return 1; } } - zap_config_close_file(cfg); + ftdm_config_close_file(cfg); memset(cfg, 0, sizeof(*cfg)); return 0; } @@ -86,12 +86,12 @@ int zap_config_open_file(zap_config_t *cfg, const char *file_path) return 0; } else { cfg->file = f; - zap_set_string(cfg->path, path); + ftdm_set_string(cfg->path, path); return 1; } } -void zap_config_close_file(zap_config_t *cfg) +void ftdm_config_close_file(ftdm_config_t *cfg) { if (cfg->file) { @@ -103,7 +103,7 @@ void zap_config_close_file(zap_config_t *cfg) -int zap_config_next_pair(zap_config_t *cfg, char **var, char **val) +int ftdm_config_next_pair(ftdm_config_t *cfg, char **var, char **val) { int ret = 0; char *p, *end; @@ -128,7 +128,7 @@ int zap_config_next_pair(zap_config_t *cfg, char **var, char **val) (*var)++; if (**var == '+') { (*var)++; - zap_copy_string(cfg->section, *var, sizeof(cfg->section)); + ftdm_copy_string(cfg->section, *var, sizeof(cfg->section)); cfg->sectno++; if (cfg->lockto > -1 && cfg->sectno != cfg->lockto) { @@ -140,7 +140,7 @@ int zap_config_next_pair(zap_config_t *cfg, char **var, char **val) *val = (char *) ""; return 1; } else { - zap_copy_string(cfg->category, *var, sizeof(cfg->category)); + ftdm_copy_string(cfg->category, *var, sizeof(cfg->category)); cfg->catno++; } continue; @@ -209,29 +209,29 @@ int zap_config_next_pair(zap_config_t *cfg, char **var, char **val) } -OZ_DECLARE (int) zap_config_get_cas_bits(char *strvalue, unsigned char *outbits) +FT_DECLARE (int) ftdm_config_get_cas_bits(char *strvalue, unsigned char *outbits) { char cas_bits[5]; unsigned char bit = 0x8; int x = 0; char *double_colon = strchr(strvalue, ':'); if (!double_colon) { - zap_log(ZAP_LOG_ERROR, "No CAS bits specified: %s, :xxxx definition expected, where x is 1 or 0\n", strvalue); + ftdm_log(FTDM_LOG_ERROR, "No CAS bits specified: %s, :xxxx definition expected, where x is 1 or 0\n", strvalue); return -1; } double_colon++; *outbits = 0; cas_bits[4] = 0; if (sscanf(double_colon, "%c%c%c%c", &cas_bits[0], &cas_bits[1], &cas_bits[2], &cas_bits[3]) != 4) { - zap_log(ZAP_LOG_ERROR, "Invalid CAS bits specified: '%s', :xxxx definition expected, where x is 1 or 0\n", double_colon); + ftdm_log(FTDM_LOG_ERROR, "Invalid CAS bits specified: '%s', :xxxx definition expected, where x is 1 or 0\n", double_colon); return -1; } - zap_log(ZAP_LOG_DEBUG, "CAS bits specification found: %s\n", cas_bits); + ftdm_log(FTDM_LOG_DEBUG, "CAS bits specification found: %s\n", cas_bits); for (; cas_bits[x]; x++) { if ('1' == cas_bits[x]) { *outbits |= bit; } else if ('0' != cas_bits[x]) { - zap_log(ZAP_LOG_ERROR, "Invalid CAS pattern specified: %s, just 0 or 1 allowed for each bit\n"); + ftdm_log(FTDM_LOG_ERROR, "Invalid CAS pattern specified: %s, just 0 or 1 allowed for each bit\n"); return -1; } bit >>= 1; diff --git a/libs/freetdm/src/zap_dso.c b/libs/freetdm/src/ftdm_dso.c similarity index 80% rename from libs/freetdm/src/zap_dso.c rename to libs/freetdm/src/ftdm_dso.c index b222e24231..a0981ebdd9 100644 --- a/libs/freetdm/src/zap_dso.c +++ b/libs/freetdm/src/ftdm_dso.c @@ -17,8 +17,8 @@ * */ -#include "openzap.h" -#include "zap_dso.h" +#include "freetdm.h" +#include "ftdm_dso.h" #include #include @@ -27,14 +27,14 @@ #include -OZ_DECLARE(void) zap_dso_destroy(zap_dso_lib_t *lib) { +FT_DECLARE(void) ftdm_dso_destroy(ftdm_dso_lib_t *lib) { if (lib && *lib) { FreeLibrary(*lib); *lib = NULL; } } -OZ_DECLARE(zap_dso_lib_t) zap_dso_open(const char *path, char **err) { +FT_DECLARE(ftdm_dso_lib_t) ftdm_dso_open(const char *path, char **err) { HINSTANCE lib; lib = LoadLibraryEx(path, NULL, 0); @@ -47,21 +47,21 @@ OZ_DECLARE(zap_dso_lib_t) zap_dso_open(const char *path, char **err) { DWORD error = GetLastError(); char tmp[80]; sprintf(tmp, "dll open error [%ul]\n", error); - *err = zap_strdup(tmp); + *err = ftdm_strdup(tmp); } return lib; } -OZ_DECLARE(void*) zap_dso_func_sym(zap_dso_lib_t lib, const char *sym, char **err) { +FT_DECLARE(void*) ftdm_dso_func_sym(ftdm_dso_lib_t lib, const char *sym, char **err) { FARPROC func = GetProcAddress(lib, sym); if (!func) { DWORD error = GetLastError(); char tmp[80]; sprintf(tmp, "dll sym error [%ul]\n", error); - *err = zap_strdup(tmp); + *err = ftdm_strdup(tmp); } - return (void *)(intptr_t)func; // this should really be addr - zap_dso_func_data + return (void *)(intptr_t)func; // this should really be addr - ftdm_dso_func_data } #else @@ -78,25 +78,25 @@ OZ_DECLARE(void*) zap_dso_func_sym(zap_dso_lib_t lib, const char *sym, char **er #include -OZ_DECLARE(void) zap_dso_destroy(zap_dso_lib_t *lib) { +FT_DECLARE(void) ftdm_dso_destroy(ftdm_dso_lib_t *lib) { if (lib && *lib) { dlclose(*lib); *lib = NULL; } } -OZ_DECLARE(zap_dso_lib_t) zap_dso_open(const char *path, char **err) { +FT_DECLARE(ftdm_dso_lib_t) ftdm_dso_open(const char *path, char **err) { void *lib = dlopen(path, RTLD_NOW | RTLD_LOCAL); if (lib == NULL) { - *err = zap_strdup(dlerror()); + *err = ftdm_strdup(dlerror()); } return lib; } -OZ_DECLARE(void*) zap_dso_func_sym(zap_dso_lib_t lib, const char *sym, char **err) { +FT_DECLARE(void*) ftdm_dso_func_sym(ftdm_dso_lib_t lib, const char *sym, char **err) { void *func = dlsym(lib, sym); if (!func) { - *err = zap_strdup(dlerror()); + *err = ftdm_strdup(dlerror()); } return func; } diff --git a/libs/freetdm/src/ftdm_io.c b/libs/freetdm/src/ftdm_io.c new file mode 100644 index 0000000000..fc2c450288 --- /dev/null +++ b/libs/freetdm/src/ftdm_io.c @@ -0,0 +1,3754 @@ +/* + * Copyright (c) 2007, Anthony Minessale II + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of the original author; nor the names of any contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributors: + * + * Moises Silva + * David Yat Sin + * + */ + +#define _GNU_SOURCE +#ifndef WIN32 +#endif +#include "freetdm.h" +#include +#ifdef WIN32 +#include +#endif +#ifdef FTDM_PIKA_SUPPORT +#include "ftdm_pika.h" +#endif + +static int time_is_init = 0; + +static void time_init(void) +{ +#ifdef WIN32 + timeBeginPeriod(1); +#endif + time_is_init = 1; +} + +static void time_end(void) +{ +#ifdef WIN32 + timeEndPeriod(1); +#endif + time_is_init = 0; +} + +FT_DECLARE(ftdm_time_t) ftdm_current_time_in_ms(void) +{ +#ifdef WIN32 + return timeGetTime(); +#else + struct timeval tv; + gettimeofday(&tv, NULL); + return ((tv.tv_sec * 1000) + (tv.tv_usec / 1000)); +#endif +} + +static struct { + ftdm_hash_t *interface_hash; + ftdm_hash_t *module_hash; + ftdm_hash_t *span_hash; + ftdm_hash_t *group_hash; + ftdm_mutex_t *mutex; + ftdm_mutex_t *span_mutex; + ftdm_mutex_t *group_mutex; + uint32_t span_index; + uint32_t group_index; + uint32_t running; + ftdm_span_t *spans; + ftdm_group_t *groups; +} globals; + + +/* enum lookup funcs */ +FTDM_ENUM_NAMES(TONEMAP_NAMES, TONEMAP_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_tonemap, ftdm_tonemap2str, ftdm_tonemap_t, TONEMAP_NAMES, FTDM_TONEMAP_INVALID) + +FTDM_ENUM_NAMES(OOB_NAMES, OOB_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_oob_event, ftdm_oob_event2str, ftdm_oob_event_t, OOB_NAMES, FTDM_OOB_INVALID) + +FTDM_ENUM_NAMES(TRUNK_TYPE_NAMES, TRUNK_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_trunk_type, ftdm_trunk_type2str, ftdm_trunk_type_t, TRUNK_TYPE_NAMES, FTDM_TRUNK_NONE) + +FTDM_ENUM_NAMES(START_TYPE_NAMES, START_TYPE_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_analog_start_type, ftdm_analog_start_type2str, ftdm_analog_start_type_t, START_TYPE_NAMES, FTDM_ANALOG_START_NA) + +FTDM_ENUM_NAMES(SIGNAL_NAMES, SIGNAL_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_signal_event, ftdm_signal_event2str, ftdm_signal_event_t, SIGNAL_NAMES, FTDM_SIGEVENT_INVALID) + +FTDM_ENUM_NAMES(CHANNEL_STATE_NAMES, CHANNEL_STATE_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_channel_state, ftdm_channel_state2str, ftdm_channel_state_t, CHANNEL_STATE_NAMES, FTDM_CHANNEL_STATE_INVALID) + +FTDM_ENUM_NAMES(MDMF_TYPE_NAMES, MDMF_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_mdmf_type, ftdm_mdmf_type2str, ftdm_mdmf_type_t, MDMF_TYPE_NAMES, MDMF_INVALID) + +FTDM_ENUM_NAMES(CHAN_TYPE_NAMES, CHAN_TYPE_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_chan_type, ftdm_chan_type2str, ftdm_chan_type_t, CHAN_TYPE_NAMES, FTDM_CHAN_TYPE_COUNT) + +FTDM_ENUM_NAMES(SIGNALING_STATUS_NAMES, SIGSTATUS_STRINGS) +FTDM_STR2ENUM(ftdm_str2ftdm_signaling_status, ftdm_signaling_status2str, ftdm_signaling_status_t, SIGNALING_STATUS_NAMES, FTDM_SIG_STATE_INVALID) + +static const char *cut_path(const char *in) +{ + const char *p, *ret = in; + char delims[] = "/\\"; + char *i; + + for (i = delims; *i; i++) { + p = in; + while ((p = strchr(p, *i)) != 0) { + ret = ++p; + } + } + return ret; +} + +static void null_logger(const char *file, const char *func, int line, int level, const char *fmt, ...) +{ + if (file && func && line && level && fmt) { + return; + } + return; +} + + +static const char *LEVEL_NAMES[] = { + "EMERG", + "ALERT", + "CRIT", + "ERROR", + "WARNING", + "NOTICE", + "INFO", + "DEBUG", + NULL +}; + +static int ftdm_log_level = 7; + +static void default_logger(const char *file, const char *func, int line, int level, const char *fmt, ...) +{ + const char *fp; + char data[1024]; + va_list ap; + + if (level < 0 || level > 7) { + level = 7; + } + if (level > ftdm_log_level) { + return; + } + + fp = cut_path(file); + + va_start(ap, fmt); + + vsnprintf(data, sizeof(data), fmt, ap); + + + fprintf(stderr, "[%s] %s:%d %s() %s", LEVEL_NAMES[level], file, line, func, data); + + va_end(ap); + +} + +static __inline__ void *ftdm_std_malloc(void *pool, ftdm_size_t size) +{ + void *ptr = malloc(size); + pool = NULL; /* fix warning */ + ftdm_assert_return(ptr != NULL, NULL, "Out of memory"); + return ptr; +} + +static __inline__ void *ftdm_std_calloc(void *pool, ftdm_size_t elements, ftdm_size_t size) +{ + void *ptr = calloc(elements, size); + pool = NULL; + ftdm_assert_return(ptr != NULL, NULL, "Out of memory"); + return ptr; +} + +static __inline__ void ftdm_std_free(void *pool, void *ptr) +{ + pool = NULL; + ftdm_assert_return(ptr != NULL, , "Attempted to free null pointer"); + free(ptr); +} + +FT_DECLARE_DATA ftdm_memory_handler_t g_ftdm_mem_handler = +{ + /*.pool =*/ NULL, + /*.malloc =*/ ftdm_std_malloc, + /*.calloc =*/ ftdm_std_calloc, + /*.free =*/ ftdm_std_free +}; + +FT_DECLARE_DATA ftdm_crash_policy_t g_ftdm_crash_policy = FTDM_CRASH_NEVER; + +FT_DECLARE_DATA ftdm_logger_t ftdm_log = null_logger; + +FT_DECLARE(void) ftdm_global_set_crash_policy(ftdm_crash_policy_t policy) +{ + g_ftdm_crash_policy |= policy; +} + +FT_DECLARE(ftdm_status_t) ftdm_global_set_memory_handler(ftdm_memory_handler_t *handler) +{ + if (!handler) { + return FTDM_FAIL; + } + if (!handler->malloc) { + return FTDM_FAIL; + } + if (!handler->calloc) { + return FTDM_FAIL; + } + if (!handler->free) { + return FTDM_FAIL; + } + memcpy(&g_ftdm_mem_handler, handler, sizeof(*handler)); + return FTDM_SUCCESS; +} + +FT_DECLARE(void) ftdm_global_set_logger(ftdm_logger_t logger) +{ + if (logger) { + ftdm_log = logger; + } else { + ftdm_log = null_logger; + } +} + +FT_DECLARE(void) ftdm_global_set_default_logger(int level) +{ + if (level < 0 || level > 7) { + level = 7; + } + + ftdm_log = default_logger; + ftdm_log_level = level; +} + +FT_DECLARE_NONSTD(int) ftdm_hash_equalkeys(void *k1, void *k2) +{ + return strcmp((char *) k1, (char *) k2) ? 0 : 1; +} + +FT_DECLARE_NONSTD(uint32_t) ftdm_hash_hashfromstring(void *ky) +{ + unsigned char *str = (unsigned char *) ky; + uint32_t hash = 0; + int c; + + while ((c = *str++)) { + hash = c + (hash << 6) + (hash << 16) - hash; + } + + return hash; +} + +static ftdm_status_t ftdm_channel_destroy(ftdm_channel_t *ftdmchan) +{ + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_CONFIGURED)) { + + while (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_log(FTDM_LOG_INFO, "Waiting for thread to exit on channel %u:%u\n", ftdmchan->span_id, ftdmchan->chan_id); + ftdm_sleep(500); + } + + ftdm_mutex_lock(ftdmchan->pre_buffer_mutex); + ftdm_buffer_destroy(&ftdmchan->pre_buffer); + ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex); + + ftdm_buffer_destroy(&ftdmchan->digit_buffer); + ftdm_buffer_destroy(&ftdmchan->gen_dtmf_buffer); + ftdm_buffer_destroy(&ftdmchan->dtmf_buffer); + ftdm_buffer_destroy(&ftdmchan->fsk_buffer); + ftdmchan->pre_buffer_size = 0; + + hashtable_destroy(ftdmchan->variable_hash); + + ftdm_safe_free(ftdmchan->dtmf_hangup_buf); + + if (ftdmchan->tone_session.buffer) { + teletone_destroy_session(&ftdmchan->tone_session); + memset(&ftdmchan->tone_session, 0, sizeof(ftdmchan->tone_session)); + } + + + if (ftdmchan->span->zio->channel_destroy) { + ftdm_log(FTDM_LOG_INFO, "Closing channel %s:%u:%u fd:%d\n", ftdmchan->span->type, ftdmchan->span_id, ftdmchan->chan_id, ftdmchan->sockfd); + if (ftdmchan->span->zio->channel_destroy(ftdmchan) == FTDM_SUCCESS) { + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_CONFIGURED); + } else { + ftdm_log(FTDM_LOG_ERROR, "Error Closing channel %u:%u fd:%d\n", ftdmchan->span_id, ftdmchan->chan_id, ftdmchan->sockfd); + } + } + + ftdm_mutex_destroy(&ftdmchan->mutex); + ftdm_mutex_destroy(&ftdmchan->pre_buffer_mutex); + } + + return FTDM_SUCCESS; +} + +static ftdm_status_t ftdm_span_destroy(ftdm_span_t *span) +{ + ftdm_status_t status = FTDM_SUCCESS; + unsigned j; + + ftdm_mutex_lock(span->mutex); + + /* stop the signaling */ + if (span->stop) { + status = span->stop(span); + } + + /* destroy the channels */ + ftdm_clear_flag(span, FTDM_SPAN_CONFIGURED); + for(j = 1; j <= span->chan_count && span->channels[j]; j++) { + ftdm_channel_t *cur_chan = span->channels[j]; + if (cur_chan) { + if (ftdm_test_flag(cur_chan, FTDM_CHANNEL_CONFIGURED)) { + ftdm_channel_destroy(cur_chan); + } + ftdm_safe_free(cur_chan); + cur_chan = NULL; + } + } + + /* destroy the I/O for the span */ + if (span->zio && span->zio->span_destroy) { + ftdm_log(FTDM_LOG_INFO, "Destroying span %u type (%s)\n", span->span_id, span->type); + if (span->zio->span_destroy(span) != FTDM_SUCCESS) { + status = FTDM_FAIL; + } + ftdm_safe_free(span->type); + ftdm_safe_free(span->dtmf_hangup); + } + + /* destroy final basic resources of the span data structure */ + ftdm_mutex_unlock(span->mutex); + ftdm_mutex_destroy(&span->mutex); + ftdm_safe_free(span->signal_data); + + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(ftdm_channel_t *ftdmchan) +{ + ftdm_status_t status = FTDM_FAIL; + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_CONFIGURED)) { + if (ftdmchan->span->zio->get_alarms) { + if ((status = ftdmchan->span->zio->get_alarms(ftdmchan)) == FTDM_SUCCESS) { + *ftdmchan->last_error = '\0'; + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_RED)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "RED/"); + } + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_YELLOW)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "YELLOW/"); + } + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_BLUE)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "BLUE/"); + } + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_LOOPBACK)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "LOOP/"); + } + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_RECOVER)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "RECOVER/"); + } + *(ftdmchan->last_error + strlen(ftdmchan->last_error) - 1) = '\0'; + + } + } else { + status = FTDM_NOTIMPL; + } + } + + return status; +} + +static void ftdm_span_add(ftdm_span_t *span) +{ + ftdm_span_t *sp; + ftdm_mutex_lock(globals.span_mutex); + for (sp = globals.spans; sp && sp->next; sp = sp->next); + if (sp) { + sp->next = span; + } else { + globals.spans = span; + } + hashtable_insert(globals.span_hash, (void *)span->name, span, HASHTABLE_FLAG_NONE); + ftdm_mutex_unlock(globals.span_mutex); +} + +#if 0 +static void ftdm_span_del(ftdm_span_t *span) +{ + ftdm_span_t *last = NULL, *sp; + + ftdm_mutex_lock(globals.span_mutex); + for (sp = globals.spans; sp; sp = sp->next) { + + if (sp == span) { + if (last) { + last->next = sp->next; + } else { + globals.spans = sp->next; + } + hashtable_remove(globals.span_hash, (void *)sp->name); + break; + } + + last = sp; + } + ftdm_mutex_unlock(globals.span_mutex); +} +#endif + +FT_DECLARE(ftdm_status_t) ftdm_span_stop(ftdm_span_t *span) +{ + if (span->stop) { + span->stop(span); + return FTDM_SUCCESS; + } + + return FTDM_FAIL; +} + +FT_DECLARE(ftdm_status_t) ftdm_span_create(ftdm_io_interface_t *zio, ftdm_span_t **span, const char *name) +{ + ftdm_span_t *new_span = NULL; + ftdm_status_t status = FTDM_FAIL; + + assert(zio != NULL); + + ftdm_mutex_lock(globals.mutex); + + if (globals.span_index < FTDM_MAX_SPANS_INTERFACE) { + new_span = ftdm_malloc(sizeof(*new_span)); + assert(new_span); + memset(new_span, 0, sizeof(*new_span)); + status = ftdm_mutex_create(&new_span->mutex); + assert(status == FTDM_SUCCESS); + + ftdm_set_flag(new_span, FTDM_SPAN_CONFIGURED); + new_span->span_id = ++globals.span_index; + new_span->zio = zio; + ftdm_copy_string(new_span->tone_map[FTDM_TONEMAP_DIAL], "%(1000,0,350,440)", FTDM_TONEMAP_LEN); + ftdm_copy_string(new_span->tone_map[FTDM_TONEMAP_RING], "%(2000,4000,440,480)", FTDM_TONEMAP_LEN); + ftdm_copy_string(new_span->tone_map[FTDM_TONEMAP_BUSY], "%(500,500,480,620)", FTDM_TONEMAP_LEN); + ftdm_copy_string(new_span->tone_map[FTDM_TONEMAP_ATTN], "%(100,100,1400,2060,2450,2600)", FTDM_TONEMAP_LEN); + new_span->trunk_type = FTDM_TRUNK_NONE; + new_span->data_type = FTDM_TYPE_SPAN; + + ftdm_mutex_lock(globals.span_mutex); + if (!ftdm_strlen_zero(name) && hashtable_search(globals.span_hash, (void *)name)) { + ftdm_log(FTDM_LOG_WARNING, "name %s is already used, substituting 'span%d' as the name\n", name, new_span->span_id); + name = NULL; + } + ftdm_mutex_unlock(globals.span_mutex); + + if (!name) { + char buf[128] = ""; + snprintf(buf, sizeof(buf), "span%d", new_span->span_id); + name = buf; + } + new_span->name = ftdm_strdup(name); + ftdm_span_add(new_span); + *span = new_span; + status = FTDM_SUCCESS; + } + ftdm_mutex_unlock(globals.mutex); + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void) +{ + ftdm_span_t *span; + uint32_t i = 0, j; + + ftdm_mutex_lock(globals.span_mutex); + for (span = globals.spans; span; span = span->next) { + if (ftdm_test_flag(span, FTDM_SPAN_CONFIGURED)) { + for(j = 1; j <= span->chan_count && span->channels[j]; j++) { + ftdm_channel_t *toclose = span->channels[j]; + if (ftdm_test_flag(toclose, FTDM_CHANNEL_INUSE)) { + ftdm_channel_close(&toclose); + } + i++; + } + } + } + ftdm_mutex_unlock(globals.span_mutex); + + return i ? FTDM_SUCCESS : FTDM_FAIL; +} + +FT_DECLARE(ftdm_status_t) ftdm_span_load_tones(ftdm_span_t *span, const char *mapname) +{ + ftdm_config_t cfg; + char *var, *val; + int x = 0; + + if (!ftdm_config_open_file(&cfg, "tones.conf")) { + snprintf(span->last_error, sizeof(span->last_error), "error loading tones."); + return FTDM_FAIL; + } + + while (ftdm_config_next_pair(&cfg, &var, &val)) { + int detect = 0; + + if (!strcasecmp(cfg.category, mapname) && var && val) { + uint32_t index; + char *name = NULL; + + if (!strncasecmp(var, "detect-", 7)) { + name = var + 7; + detect = 1; + } else if (!strncasecmp(var, "generate-", 9)) { + name = var + 9; + } else { + ftdm_log(FTDM_LOG_WARNING, "Unknown tone name %s\n", var); + continue; + } + + index = ftdm_str2ftdm_tonemap(name); + + if (index >= FTDM_TONEMAP_INVALID || index == FTDM_TONEMAP_NONE) { + ftdm_log(FTDM_LOG_WARNING, "Unknown tone name %s\n", name); + } else { + if (detect) { + char *p = val, *next; + int i = 0; + do { + teletone_process_t this; + next = strchr(p, ','); + this = (teletone_process_t)atof(p); + span->tone_detect_map[index].freqs[i++] = this; + if (next) { + p = next + 1; + } + } while (next); + ftdm_log(FTDM_LOG_DEBUG, "added tone detect [%s] = [%s]\n", name, val); + } else { + ftdm_log(FTDM_LOG_DEBUG, "added tone generation [%s] = [%s]\n", name, val); + ftdm_copy_string(span->tone_map[index], val, sizeof(span->tone_map[index])); + } + x++; + } + } + } + + ftdm_config_close_file(&cfg); + + if (!x) { + snprintf(span->last_error, sizeof(span->last_error), "error loading tones."); + return FTDM_FAIL; + } + + return FTDM_SUCCESS; + +} + +#define FTDM_SLINEAR_MAX_VALUE 32767 +#define FTDM_SLINEAR_MIN_VALUE -32767 +static void reset_gain_table(unsigned char *gain_table, float new_gain, ftdm_codec_t codec_gain) +{ + /* sample value */ + unsigned sv = 0; + /* linear gain factor */ + float lingain = 0; + /* linear value for each table sample */ + float linvalue = 0; + /* amplified (or attenuated in case of negative amplification) sample value */ + int ampvalue = 0; + + /* gain tables are only for alaw and ulaw */ + if (codec_gain != FTDM_CODEC_ALAW && codec_gain != FTDM_CODEC_ULAW) { + ftdm_log(FTDM_LOG_WARNING, "Not resetting gain table because codec is not ALAW or ULAW but %d\n", codec_gain); + return; + } + + if (!new_gain) { + /* for a 0.0db gain table, each alaw/ulaw sample value is left untouched (0 ==0, 1 == 1, 2 == 2 etc)*/ + for (sv = 0; sv < FTDM_GAINS_TABLE_SIZE; sv++) { + gain_table[sv] = sv; + } + return; + } + + /* use the 20log rule to increase the gain: http://en.wikipedia.org/wiki/Gain, http:/en.wipedia.org/wiki/20_log_rule#Definitions */ + lingain = pow(10.0, new_gain/ 20.0); + for (sv = 0; sv < FTDM_GAINS_TABLE_SIZE; sv++) { + /* get the linear value for this alaw/ulaw sample value */ + linvalue = codec_gain == FTDM_CODEC_ALAW ? alaw_to_linear(sv) : ulaw_to_linear(sv); + + /* multiply the linear value and the previously calculated linear gain */ + ampvalue = (int)(linvalue * lingain); + + /* chop it if goes beyond the limits */ + if (ampvalue > FTDM_SLINEAR_MAX_VALUE) { + ampvalue = FTDM_SLINEAR_MAX_VALUE; + } + + if (ampvalue < FTDM_SLINEAR_MIN_VALUE) { + ampvalue = FTDM_SLINEAR_MIN_VALUE; + } + gain_table[sv] = codec_gain == FTDM_CODEC_ALAW ? linear_to_alaw(ampvalue) : linear_to_ulaw(ampvalue); + } +} + +FT_DECLARE(ftdm_status_t) ftdm_span_add_channel(ftdm_span_t *span, ftdm_socket_t sockfd, ftdm_chan_type_t type, ftdm_channel_t **chan) +{ + unsigned i = 0; + if (span->chan_count < FTDM_MAX_CHANNELS_SPAN) { + ftdm_channel_t *new_chan = span->channels[++span->chan_count]; + + if (!new_chan) { + if (!(new_chan = ftdm_calloc(1, sizeof(*new_chan)))) { + return FTDM_FAIL; + } + span->channels[span->chan_count] = new_chan; + } + + new_chan->type = type; + new_chan->sockfd = sockfd; + new_chan->zio = span->zio; + new_chan->span_id = span->span_id; + new_chan->chan_id = span->chan_count; + new_chan->span = span; + new_chan->fds[0] = -1; + new_chan->fds[1] = -1; + new_chan->data_type = FTDM_TYPE_CHANNEL; + if (!new_chan->dtmf_on) { + new_chan->dtmf_on = FTDM_DEFAULT_DTMF_ON; + } + + if (!new_chan->dtmf_off) { + new_chan->dtmf_off = FTDM_DEFAULT_DTMF_OFF; + } + + ftdm_mutex_create(&new_chan->mutex); + ftdm_mutex_create(&new_chan->pre_buffer_mutex); + + ftdm_buffer_create(&new_chan->digit_buffer, 128, 128, 0); + ftdm_buffer_create(&new_chan->gen_dtmf_buffer, 128, 128, 0); + new_chan->variable_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + + new_chan->dtmf_hangup_buf = ftdm_calloc (span->dtmf_hangup_len + 1, sizeof (char)); + + /* set 0.0db gain table */ + for (i = 0; i < sizeof(new_chan->txgain_table); i++) { + new_chan->txgain_table[i] = i; + new_chan->rxgain_table[i] = i; + } + + ftdm_set_flag(new_chan, FTDM_CHANNEL_CONFIGURED | FTDM_CHANNEL_READY); + *chan = new_chan; + return FTDM_SUCCESS; + } + + return FTDM_FAIL; +} + +FT_DECLARE(ftdm_status_t) ftdm_span_find_by_name(const char *name, ftdm_span_t **span) +{ + ftdm_status_t status = FTDM_FAIL; + + ftdm_mutex_lock(globals.span_mutex); + if (!ftdm_strlen_zero(name)) { + if ((*span = hashtable_search(globals.span_hash, (void *)name))) { + status = FTDM_SUCCESS; + } else { + int span_id = atoi(name); + + ftdm_span_find(span_id, span); + if (*span) { + status = FTDM_SUCCESS; + } + } + } + ftdm_mutex_unlock(globals.span_mutex); + + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_span_find(uint32_t id, ftdm_span_t **span) +{ + ftdm_span_t *fspan = NULL, *sp; + + if (id > FTDM_MAX_SPANS_INTERFACE) { + return FTDM_FAIL; + } + + ftdm_mutex_lock(globals.span_mutex); + for (sp = globals.spans; sp; sp = sp->next) { + if (sp->span_id == id) { + fspan = sp; + break; + } + } + ftdm_mutex_unlock(globals.span_mutex); + + if (!fspan || !ftdm_test_flag(fspan, FTDM_SPAN_CONFIGURED)) { + return FTDM_FAIL; + } + + *span = fspan; + + return FTDM_SUCCESS; + +} + +FT_DECLARE(ftdm_status_t) ftdm_span_set_event_callback(ftdm_span_t *span, zio_event_cb_t event_callback) +{ + ftdm_mutex_lock(span->mutex); + span->event_callback = event_callback; + ftdm_mutex_unlock(span->mutex); + return FTDM_SUCCESS; +} + + +FT_DECLARE(ftdm_status_t) ftdm_span_poll_event(ftdm_span_t *span, uint32_t ms) +{ + assert(span->zio != NULL); + + if (span->zio->poll_event) { + return span->zio->poll_event(span, ms); + } else { + ftdm_log(FTDM_LOG_ERROR, "poll_event method not implemented in module %s!", span->zio->name); + } + + return FTDM_NOTIMPL; +} + +FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event) +{ + assert(span->zio != NULL); + + if (span->zio->next_event) { + return span->zio->next_event(span, event); + } else { + ftdm_log(FTDM_LOG_ERROR, "next_event method not implemented in module %s!", span->zio->name); + } + + return FTDM_NOTIMPL; +} + +static ftdm_status_t ftdmchan_fsk_write_sample(int16_t *buf, ftdm_size_t buflen, void *user_data) +{ + ftdm_channel_t *ftdmchan = (ftdm_channel_t *) user_data; + ftdm_buffer_write(ftdmchan->fsk_buffer, buf, buflen * 2); + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_send_fsk_data(ftdm_channel_t *ftdmchan, ftdm_fsk_data_state_t *fsk_data, float db_level) +{ + struct ftdm_fsk_modulator fsk_trans; + + if (!ftdmchan->fsk_buffer) { + ftdm_buffer_create(&ftdmchan->fsk_buffer, 128, 128, 0); + } else { + ftdm_buffer_zero(ftdmchan->fsk_buffer); + } + + if (ftdmchan->token_count > 1) { + ftdm_fsk_modulator_init(&fsk_trans, FSK_BELL202, ftdmchan->rate, fsk_data, db_level, 80, 5, 0, ftdmchan_fsk_write_sample, ftdmchan); + ftdm_fsk_modulator_send_all((&fsk_trans)); + } else { + ftdm_fsk_modulator_init(&fsk_trans, FSK_BELL202, ftdmchan->rate, fsk_data, db_level, 180, 5, 300, ftdmchan_fsk_write_sample, ftdmchan); + ftdm_fsk_modulator_send_all((&fsk_trans)); + ftdmchan->buffer_delay = 3500 / ftdmchan->effective_interval; + } + + return FTDM_SUCCESS; +} + + +FT_DECLARE(ftdm_status_t) ftdm_channel_set_event_callback(ftdm_channel_t *ftdmchan, zio_event_cb_t event_callback) +{ + ftdm_mutex_lock(ftdmchan->mutex); + ftdmchan->event_callback = event_callback; + ftdm_mutex_unlock(ftdmchan->mutex); + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_clear_token(ftdm_channel_t *ftdmchan, const char *token) +{ + ftdm_status_t status = FTDM_FAIL; + + ftdm_mutex_lock(ftdmchan->mutex); + if (token == NULL) { + memset(ftdmchan->tokens, 0, sizeof(ftdmchan->tokens)); + ftdmchan->token_count = 0; + } else if (*token != '\0') { + char tokens[FTDM_MAX_TOKENS][FTDM_TOKEN_STRLEN]; + int32_t i, count = ftdmchan->token_count; + memcpy(tokens, ftdmchan->tokens, sizeof(tokens)); + memset(ftdmchan->tokens, 0, sizeof(ftdmchan->tokens)); + ftdmchan->token_count = 0; + + for (i = 0; i < count; i++) { + if (strcmp(tokens[i], token)) { + ftdm_copy_string(ftdmchan->tokens[ftdmchan->token_count], tokens[i], sizeof(ftdmchan->tokens[ftdmchan->token_count])); + ftdmchan->token_count++; + } + } + + status = FTDM_SUCCESS; + } + ftdm_mutex_unlock(ftdmchan->mutex); + + return status; +} + +FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan) +{ + if (ftdmchan->token_count) { + memmove(ftdmchan->tokens[1], ftdmchan->tokens[0], ftdmchan->token_count * FTDM_TOKEN_STRLEN); + ftdm_copy_string(ftdmchan->tokens[0], ftdmchan->tokens[ftdmchan->token_count], FTDM_TOKEN_STRLEN); + *ftdmchan->tokens[ftdmchan->token_count] = '\0'; + } +} + +FT_DECLARE(void) ftdm_channel_replace_token(ftdm_channel_t *ftdmchan, const char *old_token, const char *new_token) +{ + unsigned int i; + + if (ftdmchan->token_count) { + for(i = 0; i < ftdmchan->token_count; i++) { + if (!strcmp(ftdmchan->tokens[i], old_token)) { + ftdm_copy_string(ftdmchan->tokens[i], new_token, FTDM_TOKEN_STRLEN); + break; + } + } + } +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_add_token(ftdm_channel_t *ftdmchan, char *token, int end) +{ + ftdm_status_t status = FTDM_FAIL; + + ftdm_mutex_lock(ftdmchan->mutex); + if (ftdmchan->token_count < FTDM_MAX_TOKENS) { + if (end) { + ftdm_copy_string(ftdmchan->tokens[ftdmchan->token_count++], token, FTDM_TOKEN_STRLEN); + } else { + memmove(ftdmchan->tokens[1], ftdmchan->tokens[0], ftdmchan->token_count * FTDM_TOKEN_STRLEN); + ftdm_copy_string(ftdmchan->tokens[0], token, FTDM_TOKEN_STRLEN); + ftdmchan->token_count++; + } + status = FTDM_SUCCESS; + } + ftdm_mutex_unlock(ftdmchan->mutex); + + return status; +} + + +FT_DECLARE(ftdm_status_t) ftdm_channel_complete_state(ftdm_channel_t *ftdmchan) +{ + ftdm_channel_state_t state = ftdmchan->state; + + if (state == FTDM_CHANNEL_STATE_PROGRESS) { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_PROGRESS); + } else if (state == FTDM_CHANNEL_STATE_UP) { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_MEDIA); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_ANSWERED); + } else if (state == FTDM_CHANNEL_STATE_PROGRESS_MEDIA) { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_MEDIA); + } + + return FTDM_SUCCESS; +} + +static int ftdm_parse_state_map(ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, ftdm_state_map_t *state_map) +{ + int x = 0, ok = 0; + ftdm_state_direction_t direction = ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) ? ZSD_OUTBOUND : ZSD_INBOUND; + + for(x = 0; x < FTDM_MAP_NODE_SIZE; x++) { + int i = 0, proceed = 0; + if (!state_map->nodes[x].type) { + break; + } + + if (state_map->nodes[x].direction != direction) { + continue; + } + + if (state_map->nodes[x].check_states[0] == FTDM_ANY_STATE) { + proceed = 1; + } else { + for(i = 0; i < FTDM_MAP_MAX; i++) { + if (state_map->nodes[x].check_states[i] == ftdmchan->state) { + proceed = 1; + break; + } + } + } + + if (!proceed) { + continue; + } + + for(i = 0; i < FTDM_MAP_MAX; i++) { + ok = (state_map->nodes[x].type == ZSM_ACCEPTABLE); + if (state_map->nodes[x].states[i] == FTDM_END) { + break; + } + if (state_map->nodes[x].states[i] == state) { + ok = !ok; + goto end; + } + } + } + end: + + return ok; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int lock) +{ + int ok = 1; + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_READY)) { + return FTDM_FAIL; + } + + if (ftdm_test_flag(ftdmchan->span, FTDM_SPAN_SUSPENDED)) { + if (state != FTDM_CHANNEL_STATE_RESTART && state != FTDM_CHANNEL_STATE_DOWN) { + return FTDM_FAIL; + } + } + + if (lock) { + ftdm_mutex_lock(ftdmchan->mutex); + } + + if (ftdmchan->span->state_map) { + ok = ftdm_parse_state_map(ftdmchan, state, ftdmchan->span->state_map); + goto end; + } + + switch(ftdmchan->state) { + case FTDM_CHANNEL_STATE_HANGUP: + case FTDM_CHANNEL_STATE_TERMINATING: + { + ok = 0; + switch(state) { + case FTDM_CHANNEL_STATE_DOWN: + case FTDM_CHANNEL_STATE_BUSY: + case FTDM_CHANNEL_STATE_RESTART: + ok = 1; + break; + default: + break; + } + } + break; + case FTDM_CHANNEL_STATE_UP: + { + ok = 1; + switch(state) { + case FTDM_CHANNEL_STATE_PROGRESS: + case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: + case FTDM_CHANNEL_STATE_RING: + ok = 0; + break; + default: + break; + } + } + break; + case FTDM_CHANNEL_STATE_DOWN: + { + ok = 0; + + switch(state) { + case FTDM_CHANNEL_STATE_DIALTONE: + case FTDM_CHANNEL_STATE_COLLECT: + case FTDM_CHANNEL_STATE_DIALING: + case FTDM_CHANNEL_STATE_RING: + case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: + case FTDM_CHANNEL_STATE_PROGRESS: + case FTDM_CHANNEL_STATE_GET_CALLERID: + case FTDM_CHANNEL_STATE_GENRING: + ok = 1; + break; + default: + break; + } + } + break; + case FTDM_CHANNEL_STATE_BUSY: + { + switch(state) { + case FTDM_CHANNEL_STATE_UP: + ok = 0; + break; + default: + break; + } + } + break; + case FTDM_CHANNEL_STATE_RING: + { + switch(state) { + case FTDM_CHANNEL_STATE_UP: + ok = 1; + break; + default: + break; + } + } + break; + default: + break; + } + + end: + + if (state == ftdmchan->state) { + ok = 0; + } + + + if (ok) { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + ftdm_set_flag_locked(ftdmchan->span, FTDM_SPAN_STATE_CHANGE); + ftdmchan->last_state = ftdmchan->state; + ftdmchan->state = state; + } + + if (lock) { + ftdm_mutex_unlock(ftdmchan->mutex); + } + + return ok ? FTDM_SUCCESS : FTDM_FAIL; +} + + +FT_DECLARE(ftdm_status_t) ftdm_group_channel_use_count(ftdm_group_t *group, uint32_t *count) +{ + uint32_t j; + + *count = 0; + + if (!group) { + return FTDM_FAIL; + } + + for(j = 0; j < group->chan_count && group->channels[j]; j++) { + if (group->channels[j]) { + if (ftdm_test_flag(group->channels[j], FTDM_CHANNEL_INUSE)) { + (*count)++; + } + } + } + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_group(uint32_t group_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan) +{ + ftdm_status_t status = FTDM_FAIL; + ftdm_channel_t *check; + uint32_t i, count; + ftdm_group_t *group = NULL; + + if (group_id) { + ftdm_group_find(group_id, &group); + } + + if (!group ) { + ftdm_log(FTDM_LOG_CRIT, "GROUP NOT DEFINED!\n"); + *ftdmchan = NULL; + return FTDM_FAIL; + } + + ftdm_group_channel_use_count(group, &count); + + if (count >= group->chan_count) { + ftdm_log(FTDM_LOG_CRIT, "All circuits are busy.\n"); + *ftdmchan = NULL; + return FTDM_FAIL; + } + + + if (direction == FTDM_TOP_DOWN) { + i = 0; + } else { + i = group->chan_count-1; + } + + ftdm_mutex_lock(group->mutex); + for (;;) { + if (direction == FTDM_TOP_DOWN) { + if (i >= group->chan_count) { + break; + } + } else { + if (i < 0) { + break; + } + } + + if (!(check = group->channels[i])) { + status = FTDM_FAIL; + break; + } + + if (ftdm_test_flag(check, FTDM_CHANNEL_READY) && + !ftdm_test_flag(check, FTDM_CHANNEL_INUSE) && + !ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) && + check->state == FTDM_CHANNEL_STATE_DOWN && + check->type != FTDM_CHAN_TYPE_DQ921 && + check->type != FTDM_CHAN_TYPE_DQ931 + + ) { + ftdm_span_t* span = NULL; + ftdm_span_find(check->span_id, &span); + if (span && span->channel_request) { + status = span->channel_request(span, check->chan_id, direction, caller_data, ftdmchan); + break; + } + + status = check->zio->open(check); + + if (status == FTDM_SUCCESS) { + ftdm_set_flag(check, FTDM_CHANNEL_INUSE); + ftdm_channel_open_chan(check); + *ftdmchan = check; + break; + } + } + + if (direction == FTDM_TOP_DOWN) { + i++; + } else { + i--; + } + } + ftdm_mutex_unlock(group->mutex); + return status; +} + + +FT_DECLARE(ftdm_status_t) ftdm_span_channel_use_count(ftdm_span_t *span, uint32_t *count) +{ + uint32_t j; + + *count = 0; + + if (!span || !ftdm_test_flag(span, FTDM_SPAN_CONFIGURED)) { + return FTDM_FAIL; + } + + for(j = 1; j <= span->chan_count && span->channels[j]; j++) { + if (span->channels[j]) { + if (ftdm_test_flag(span->channels[j], FTDM_CHANNEL_INUSE)) { + (*count)++; + } + } + } + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_span(uint32_t span_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan) +{ + ftdm_status_t status = FTDM_FAIL; + ftdm_channel_t *check; + uint32_t i, j, count; + ftdm_span_t *span = NULL; + uint32_t span_max; + + if (span_id) { + ftdm_span_find(span_id, &span); + + if (!span || !ftdm_test_flag(span, FTDM_SPAN_CONFIGURED)) { + ftdm_log(FTDM_LOG_CRIT, "SPAN NOT DEFINED!\n"); + *ftdmchan = NULL; + return FTDM_FAIL; + } + + ftdm_span_channel_use_count(span, &count); + + if (count >= span->chan_count) { + ftdm_log(FTDM_LOG_CRIT, "All circuits are busy.\n"); + *ftdmchan = NULL; + return FTDM_FAIL; + } + + if (span->channel_request && !span->suggest_chan_id) { + return span->channel_request(span, 0, direction, caller_data, ftdmchan); + } + + span_max = span_id; + j = span_id; + } else { + ftdm_log(FTDM_LOG_CRIT, "No span supplied\n"); + *ftdmchan = NULL; + return FTDM_FAIL; + } + + ftdm_mutex_lock(span->mutex); + + if (direction == FTDM_TOP_DOWN) { + i = 1; + } else { + i = span->chan_count; + } + + for(;;) { + + if (direction == FTDM_TOP_DOWN) { + if (i > span->chan_count) { + break; + } + } else { + if (i == 0) { + break; + } + } + + if (!(check = span->channels[i])) { + status = FTDM_FAIL; + break; + } + + if (ftdm_test_flag(check, FTDM_CHANNEL_READY) && + !ftdm_test_flag(check, FTDM_CHANNEL_INUSE) && + !ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) && + check->state == FTDM_CHANNEL_STATE_DOWN && + check->type != FTDM_CHAN_TYPE_DQ921 && + check->type != FTDM_CHAN_TYPE_DQ931 + + ) { + + if (span && span->channel_request) { + status = span->channel_request(span, i, direction, caller_data, ftdmchan); + break; + } + + status = check->zio->open(check); + + if (status == FTDM_SUCCESS) { + ftdm_set_flag(check, FTDM_CHANNEL_INUSE); + ftdm_channel_open_chan(check); + *ftdmchan = check; + break; + } + } + + if (direction == FTDM_TOP_DOWN) { + i++; + } else { + i--; + } + } + + ftdm_mutex_unlock(span->mutex); + + return status; +} + +static ftdm_status_t ftdm_channel_reset(ftdm_channel_t *ftdmchan) +{ + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_OPEN); + ftdmchan->event_callback = NULL; + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_DTMF_DETECT); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_SUPRESS_DTMF); + ftdm_channel_done(ftdmchan); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_HOLD); + + memset(ftdmchan->tokens, 0, sizeof(ftdmchan->tokens)); + ftdmchan->token_count = 0; + + if (ftdmchan->dtmf_buffer) { + ftdm_buffer_zero(ftdmchan->dtmf_buffer); + } + + if (ftdmchan->gen_dtmf_buffer) { + ftdm_buffer_zero(ftdmchan->gen_dtmf_buffer); + } + + if (ftdmchan->digit_buffer) { + ftdm_buffer_zero(ftdmchan->digit_buffer); + } + + if (!ftdmchan->dtmf_on) { + ftdmchan->dtmf_on = FTDM_DEFAULT_DTMF_ON; + } + + if (!ftdmchan->dtmf_off) { + ftdmchan->dtmf_off = FTDM_DEFAULT_DTMF_OFF; + } + + memset(ftdmchan->dtmf_hangup_buf, '\0', ftdmchan->span->dtmf_hangup_len); + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_TRANSCODE)) { + ftdmchan->effective_codec = ftdmchan->native_codec; + ftdmchan->packet_len = ftdmchan->native_interval * (ftdmchan->effective_codec == FTDM_CODEC_SLIN ? 16 : 8); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_TRANSCODE); + } + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_init(ftdm_channel_t *ftdmchan) +{ + if (ftdmchan->init_state != FTDM_CHANNEL_STATE_DOWN) { + ftdm_set_state_locked(ftdmchan, ftdmchan->init_state); + ftdmchan->init_state = FTDM_CHANNEL_STATE_DOWN; + } + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan) +{ + ftdm_status_t status = FTDM_FAIL; + + assert(ftdmchan != NULL); + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_SUSPENDED)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", "Channel is suspended"); + return FTDM_FAIL; + } + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_READY) || (status = ftdm_mutex_trylock(ftdmchan->mutex)) != FTDM_SUCCESS) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Channel is not ready or is in use %d %d", ftdm_test_flag(ftdmchan, FTDM_CHANNEL_READY), status); + return status; + } + + status = FTDM_FAIL; + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_READY)) { + status = ftdmchan->span->zio->open(ftdmchan); + if (status == FTDM_SUCCESS) { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OPEN | FTDM_CHANNEL_INUSE); + } + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", "Channel is not ready"); + } + + ftdm_mutex_unlock(ftdmchan->mutex); + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_open(uint32_t span_id, uint32_t chan_id, ftdm_channel_t **ftdmchan) +{ + ftdm_channel_t *check; + ftdm_status_t status = FTDM_FAIL; + ftdm_span_t *span = NULL; + + ftdm_mutex_unlock(globals.mutex); + ftdm_span_find(span_id, &span); + + if (!span || !ftdm_test_flag(span, FTDM_SPAN_CONFIGURED) || chan_id >= FTDM_MAX_CHANNELS_SPAN) { + ftdm_log(FTDM_LOG_CRIT, "SPAN NOT DEFINED!\n"); + *ftdmchan = NULL; + goto done; + } + + if (span->channel_request) { + ftdm_log(FTDM_LOG_ERROR, "Individual channel selection not implemented on this span.\n"); + *ftdmchan = NULL; + goto done; + } + + if (!(check = span->channels[chan_id])) { + ftdm_log(FTDM_LOG_ERROR, "Invalid Channel %d\n", chan_id); + *ftdmchan = NULL; + goto done; + } + + if (ftdm_test_flag(check, FTDM_CHANNEL_SUSPENDED) || + !ftdm_test_flag(check, FTDM_CHANNEL_READY) || (status = ftdm_mutex_trylock(check->mutex)) != FTDM_SUCCESS) { + *ftdmchan = NULL; + goto done; + } + + status = FTDM_FAIL; + + if (ftdm_test_flag(check, FTDM_CHANNEL_READY) && (!ftdm_test_flag(check, FTDM_CHANNEL_INUSE) || + (check->type == FTDM_CHAN_TYPE_FXS && check->token_count == 1))) { + if (!ftdm_test_flag(check, FTDM_CHANNEL_OPEN)) { + status = check->zio->open(check); + if (status == FTDM_SUCCESS) { + ftdm_set_flag(check, FTDM_CHANNEL_OPEN); + } + } else { + status = FTDM_SUCCESS; + } + ftdm_set_flag(check, FTDM_CHANNEL_INUSE); + *ftdmchan = check; + } + ftdm_mutex_unlock(check->mutex); + + done: + ftdm_mutex_unlock(globals.mutex); + + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_outgoing_call(ftdm_channel_t *ftdmchan) +{ + ftdm_status_t status; + + assert(ftdmchan != NULL); + + if (ftdmchan->span->outgoing_call) { + if ((status = ftdmchan->span->outgoing_call(ftdmchan)) == FTDM_SUCCESS) { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + } + return status; + } else { + ftdm_log(FTDM_LOG_ERROR, "outgoing_call method not implemented!\n"); + } + + return FTDM_FAIL; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_set_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t sigstatus) +{ + ftdm_assert_return(ftdmchan != NULL, FTDM_FAIL, "Null channel\n"); + ftdm_assert_return(ftdmchan->span != NULL, FTDM_FAIL, "Null span\n"); + + if (ftdmchan->span->set_channel_sig_status) { + return ftdmchan->span->set_channel_sig_status(ftdmchan, sigstatus); + } else { + ftdm_log(FTDM_LOG_ERROR, "set_channel_sig_status method not implemented!\n"); + return FTDM_FAIL; + } +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_get_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *sigstatus) +{ + ftdm_assert_return(ftdmchan != NULL, FTDM_FAIL, "Null channel\n"); + ftdm_assert_return(ftdmchan->span != NULL, FTDM_FAIL, "Null span\n"); + ftdm_assert_return(sigstatus != NULL, FTDM_FAIL, "Null sig status parameter\n"); + + if (ftdmchan->span->get_channel_sig_status) { + return ftdmchan->span->get_channel_sig_status(ftdmchan, sigstatus); + } else { + ftdm_log(FTDM_LOG_ERROR, "get_channel_sig_status method not implemented!\n"); + return FTDM_FAIL; + } +} + +FT_DECLARE(ftdm_status_t) ftdm_span_set_sig_status(ftdm_span_t *span, ftdm_signaling_status_t sigstatus) +{ + ftdm_assert_return(span != NULL, FTDM_FAIL, "Null span\n"); + + if (span->set_span_sig_status) { + return span->set_span_sig_status(span, sigstatus); + } else { + ftdm_log(FTDM_LOG_ERROR, "set_span_sig_status method not implemented!\n"); + return FTDM_FAIL; + } +} + +FT_DECLARE(ftdm_status_t) ftdm_span_get_sig_status(ftdm_span_t *span, ftdm_signaling_status_t *sigstatus) +{ + ftdm_assert_return(span != NULL, FTDM_FAIL, "Null span\n"); + ftdm_assert_return(sigstatus != NULL, FTDM_FAIL, "Null sig status parameter\n"); + + if (span->get_span_sig_status) { + return span->get_span_sig_status(span, sigstatus); + } else { + ftdm_log(FTDM_LOG_ERROR, "get_span_sig_status method not implemented!\n"); + return FTDM_FAIL; + } +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_done(ftdm_channel_t *ftdmchan) +{ + assert(ftdmchan != NULL); + + ftdm_mutex_lock(ftdmchan->mutex); + + memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data)); + + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_INUSE); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_WINK); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_FLASH); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_HOLD); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_RINGING); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_PROGRESS_DETECT); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_CALLERID_DETECT); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_3WAY); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_MEDIA); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_ANSWERED); + ftdm_mutex_lock(ftdmchan->pre_buffer_mutex); + ftdm_buffer_destroy(&ftdmchan->pre_buffer); + ftdmchan->pre_buffer_size = 0; + ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex); + + ftdmchan->init_state = FTDM_CHANNEL_STATE_DOWN; + ftdmchan->state = FTDM_CHANNEL_STATE_DOWN; + + ftdm_log(FTDM_LOG_DEBUG, "channel done %u:%u\n", ftdmchan->span_id, ftdmchan->chan_id); + + ftdm_mutex_unlock(ftdmchan->mutex); + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_use(ftdm_channel_t *ftdmchan) +{ + + assert(ftdmchan != NULL); + + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INUSE); + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_close(ftdm_channel_t **ftdmchan) +{ + ftdm_channel_t *check; + ftdm_status_t status = FTDM_FAIL; + + assert(ftdmchan != NULL); + check = *ftdmchan; + *ftdmchan = NULL; + + if (!check) { + return FTDM_FAIL; + } + + if (!ftdm_test_flag(check, FTDM_CHANNEL_INUSE)) { + ftdm_log(FTDM_LOG_WARNING, "Called ftdm_channel_close but never ftdm_channel_open in chan %d:%d??\n", check->span_id, check->chan_id); + return FTDM_FAIL; + } + + if (ftdm_test_flag(check, FTDM_CHANNEL_CONFIGURED)) { + ftdm_mutex_lock(check->mutex); + if (ftdm_test_flag(check, FTDM_CHANNEL_OPEN)) { + status = check->zio->close(check); + if (status == FTDM_SUCCESS) { + ftdm_clear_flag(check, FTDM_CHANNEL_INUSE); + ftdm_channel_reset(check); + *ftdmchan = NULL; + } + } + check->ring_count = 0; + ftdm_mutex_unlock(check->mutex); + } + + return status; +} + + +static ftdm_status_t ftdmchan_activate_dtmf_buffer(ftdm_channel_t *ftdmchan) +{ + + if (!ftdmchan->dtmf_buffer) { + if (ftdm_buffer_create(&ftdmchan->dtmf_buffer, 1024, 3192, 0) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Failed to allocate DTMF Buffer!\n"); + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "buffer error"); + return FTDM_FAIL; + } else { + ftdm_log(FTDM_LOG_DEBUG, "Created DTMF Buffer!\n"); + } + } + + + if (!ftdmchan->tone_session.buffer) { + memset(&ftdmchan->tone_session, 0, sizeof(ftdmchan->tone_session)); + teletone_init_session(&ftdmchan->tone_session, 0, NULL, NULL); + } + + ftdmchan->tone_session.rate = ftdmchan->rate; + ftdmchan->tone_session.duration = ftdmchan->dtmf_on * (ftdmchan->tone_session.rate / 1000); + ftdmchan->tone_session.wait = ftdmchan->dtmf_off * (ftdmchan->tone_session.rate / 1000); + ftdmchan->tone_session.volume = -7; + + /* + ftdmchan->tone_session.debug = 1; + ftdmchan->tone_session.debug_stream = stdout; + */ + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_command(ftdm_channel_t *ftdmchan, ftdm_command_t command, void *obj) +{ + ftdm_status_t status = FTDM_FAIL; + + assert(ftdmchan != NULL); + assert(ftdmchan->zio != NULL); + + ftdm_mutex_lock(ftdmchan->mutex); + + switch(command) { + + case FTDM_COMMAND_ENABLE_CALLERID_DETECT: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_CALLERID)) { + if (ftdm_fsk_demod_init(&ftdmchan->fsk, ftdmchan->rate, ftdmchan->fsk_buf, sizeof(ftdmchan->fsk_buf)) != FTDM_SUCCESS) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + GOTO_STATUS(done, FTDM_FAIL); + } + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_CALLERID_DETECT); + } + } + break; + case FTDM_COMMAND_DISABLE_CALLERID_DETECT: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_CALLERID)) { + ftdm_fsk_demod_destroy(&ftdmchan->fsk); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_CALLERID_DETECT); + } + } + break; + case FTDM_COMMAND_TRACE_INPUT: + { + char *path = (char *) obj; + if (ftdmchan->fds[0] > 0) { + close(ftdmchan->fds[0]); + ftdmchan->fds[0] = -1; + } + if ((ftdmchan->fds[0] = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) > -1) { + ftdm_log(FTDM_LOG_DEBUG, "Tracing channel %u:%u to [%s]\n", ftdmchan->span_id, ftdmchan->chan_id, path); + GOTO_STATUS(done, FTDM_SUCCESS); + } + + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + GOTO_STATUS(done, FTDM_FAIL); + } + break; + case FTDM_COMMAND_TRACE_OUTPUT: + { + char *path = (char *) obj; + if (ftdmchan->fds[1] > 0) { + close(ftdmchan->fds[1]); + ftdmchan->fds[1] = -1; + } + if ((ftdmchan->fds[1] = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) > -1) { + ftdm_log(FTDM_LOG_DEBUG, "Tracing channel %u:%u to [%s]\n", ftdmchan->span_id, ftdmchan->chan_id, path); + GOTO_STATUS(done, FTDM_SUCCESS); + } + + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + GOTO_STATUS(done, FTDM_FAIL); + } + break; + case FTDM_COMMAND_SET_INTERVAL: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_INTERVAL)) { + ftdmchan->effective_interval = FTDM_COMMAND_OBJ_INT; + if (ftdmchan->effective_interval == ftdmchan->native_interval) { + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_BUFFER); + } else { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_BUFFER); + } + ftdmchan->packet_len = ftdmchan->native_interval * (ftdmchan->effective_codec == FTDM_CODEC_SLIN ? 16 : 8); + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_GET_INTERVAL: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_INTERVAL)) { + FTDM_COMMAND_OBJ_INT = ftdmchan->effective_interval; + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_SET_CODEC: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_CODECS)) { + ftdmchan->effective_codec = FTDM_COMMAND_OBJ_INT; + + if (ftdmchan->effective_codec == ftdmchan->native_codec) { + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_TRANSCODE); + } else { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_TRANSCODE); + } + ftdmchan->packet_len = ftdmchan->native_interval * (ftdmchan->effective_codec == FTDM_CODEC_SLIN ? 16 : 8); + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + + case FTDM_COMMAND_SET_NATIVE_CODEC: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_CODECS)) { + ftdmchan->effective_codec = ftdmchan->native_codec; + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_TRANSCODE); + ftdmchan->packet_len = ftdmchan->native_interval * (ftdmchan->effective_codec == FTDM_CODEC_SLIN ? 16 : 8); + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + + case FTDM_COMMAND_GET_CODEC: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_CODECS)) { + FTDM_COMMAND_OBJ_INT = ftdmchan->effective_codec; + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_GET_NATIVE_CODEC: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_CODECS)) { + FTDM_COMMAND_OBJ_INT = ftdmchan->native_codec; + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_ENABLE_PROGRESS_DETECT: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_PROGRESS)) { + /* if they don't have thier own, use ours */ + ftdm_channel_clear_detected_tones(ftdmchan); + ftdm_channel_clear_needed_tones(ftdmchan); + teletone_multi_tone_init(&ftdmchan->span->tone_finder[FTDM_TONEMAP_DIAL], &ftdmchan->span->tone_detect_map[FTDM_TONEMAP_DIAL]); + teletone_multi_tone_init(&ftdmchan->span->tone_finder[FTDM_TONEMAP_RING], &ftdmchan->span->tone_detect_map[FTDM_TONEMAP_RING]); + teletone_multi_tone_init(&ftdmchan->span->tone_finder[FTDM_TONEMAP_BUSY], &ftdmchan->span->tone_detect_map[FTDM_TONEMAP_BUSY]); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_PROGRESS_DETECT); + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_DISABLE_PROGRESS_DETECT: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_PROGRESS)) { + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_PROGRESS_DETECT); + ftdm_channel_clear_detected_tones(ftdmchan); + ftdm_channel_clear_needed_tones(ftdmchan); + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_ENABLE_DTMF_DETECT: + { + /* if they don't have thier own, use ours */ + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_DETECT)) { + ftdm_tone_type_t tt = FTDM_COMMAND_OBJ_INT; + if (tt == FTDM_TONE_DTMF) { + teletone_dtmf_detect_init (&ftdmchan->dtmf_detect, ftdmchan->rate); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_DTMF_DETECT); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_SUPRESS_DTMF); + GOTO_STATUS(done, FTDM_SUCCESS); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "invalid command"); + GOTO_STATUS(done, FTDM_FAIL); + } + } + } + break; + case FTDM_COMMAND_DISABLE_DTMF_DETECT: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_DETECT)) { + ftdm_tone_type_t tt = FTDM_COMMAND_OBJ_INT; + if (tt == FTDM_TONE_DTMF) { + teletone_dtmf_detect_init (&ftdmchan->dtmf_detect, ftdmchan->rate); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_DTMF_DETECT); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_SUPRESS_DTMF); + GOTO_STATUS(done, FTDM_SUCCESS); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "invalid command"); + GOTO_STATUS(done, FTDM_FAIL); + } + } + } + + case FTDM_COMMAND_SET_PRE_BUFFER_SIZE: + { + int val = FTDM_COMMAND_OBJ_INT; + + if (val < 0) { + val = 0; + } + + ftdmchan->pre_buffer_size = val * 8; + + ftdm_mutex_lock(ftdmchan->pre_buffer_mutex); + if (!ftdmchan->pre_buffer_size) { + ftdm_buffer_destroy(&ftdmchan->pre_buffer); + } else if (!ftdmchan->pre_buffer) { + ftdm_buffer_create(&ftdmchan->pre_buffer, 1024, ftdmchan->pre_buffer_size, 0); + } + ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex); + + GOTO_STATUS(done, FTDM_SUCCESS); + + } + break; + case FTDM_COMMAND_GET_DTMF_ON_PERIOD: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_GENERATE)) { + FTDM_COMMAND_OBJ_INT = ftdmchan->dtmf_on; + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_GET_DTMF_OFF_PERIOD: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_GENERATE)) { + FTDM_COMMAND_OBJ_INT = ftdmchan->dtmf_on; + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + case FTDM_COMMAND_SET_DTMF_ON_PERIOD: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_GENERATE)) { + int val = FTDM_COMMAND_OBJ_INT; + if (val > 10 && val < 1000) { + ftdmchan->dtmf_on = val; + GOTO_STATUS(done, FTDM_SUCCESS); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "invalid value %d range 10-1000", val); + GOTO_STATUS(done, FTDM_FAIL); + } + } + } + break; + case FTDM_COMMAND_SET_DTMF_OFF_PERIOD: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_GENERATE)) { + int val = FTDM_COMMAND_OBJ_INT; + if (val > 10 && val < 1000) { + ftdmchan->dtmf_off = val; + GOTO_STATUS(done, FTDM_SUCCESS); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "invalid value %d range 10-1000", val); + GOTO_STATUS(done, FTDM_FAIL); + } + } + } + break; + case FTDM_COMMAND_SEND_DTMF: + { + if (!ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_GENERATE)) { + char *digits = FTDM_COMMAND_OBJ_CHAR_P; + + if ((status = ftdmchan_activate_dtmf_buffer(ftdmchan)) != FTDM_SUCCESS) { + GOTO_STATUS(done, status); + } + + ftdm_buffer_write(ftdmchan->gen_dtmf_buffer, digits, strlen(digits)); + + GOTO_STATUS(done, FTDM_SUCCESS); + } + } + break; + + case FTDM_COMMAND_DISABLE_ECHOCANCEL: + { + ftdm_mutex_lock(ftdmchan->pre_buffer_mutex); + ftdm_buffer_destroy(&ftdmchan->pre_buffer); + ftdmchan->pre_buffer_size = 0; + ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex); + } + break; + + /* FIXME: validate user gain values */ + case FTDM_COMMAND_SET_RX_GAIN: + { + ftdmchan->rxgain = FTDM_COMMAND_OBJ_FLOAT; + reset_gain_table(ftdmchan->rxgain_table, ftdmchan->rxgain, ftdmchan->native_codec); + if (ftdmchan->rxgain == 0.0) { + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_USE_RX_GAIN); + } else { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_USE_RX_GAIN); + } + } + break; + case FTDM_COMMAND_GET_RX_GAIN: + { + FTDM_COMMAND_OBJ_FLOAT = ftdmchan->rxgain; + } + break; + case FTDM_COMMAND_SET_TX_GAIN: + { + ftdmchan->txgain = FTDM_COMMAND_OBJ_FLOAT; + reset_gain_table(ftdmchan->txgain_table, ftdmchan->txgain, ftdmchan->native_codec); + if (ftdmchan->txgain == 0.0) { + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_USE_TX_GAIN); + } else { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_USE_TX_GAIN); + } + } + break; + case FTDM_COMMAND_GET_TX_GAIN: + { + FTDM_COMMAND_OBJ_FLOAT = ftdmchan->txgain; + } + break; + default: + break; + } + + if (!ftdmchan->zio->command) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "method not implemented"); + ftdm_log(FTDM_LOG_ERROR, "no command function defined by the I/O freetdm module!\n"); + GOTO_STATUS(done, FTDM_FAIL); + } + + status = ftdmchan->zio->command(ftdmchan, command, obj); + + if (status == FTDM_NOTIMPL) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "I/O command %d not implemented in backend", command); + ftdm_log(FTDM_LOG_ERROR, "I/O backend does not support command %d!\n", command); + } +done: + ftdm_mutex_unlock(ftdmchan->mutex); + return status; + +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_wait(ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t to) +{ + assert(ftdmchan != NULL); + assert(ftdmchan->zio != NULL); + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "channel not open"); + return FTDM_FAIL; + } + + if (!ftdmchan->zio->wait) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "method not implemented"); + return FTDM_FAIL; + } + + return ftdmchan->zio->wait(ftdmchan, flags, to); + +} + +/*******************************/ +ZIO_CODEC_FUNCTION(zio_slin2ulaw) +{ + int16_t sln_buf[512] = {0}, *sln = sln_buf; + uint8_t *lp = data; + uint32_t i; + ftdm_size_t len = *datalen; + + if (max > len) { + max = len; + } + + memcpy(sln, data, max); + + for(i = 0; i < max; i++) { + *lp++ = linear_to_ulaw(*sln++); + } + + *datalen = max / 2; + + return FTDM_SUCCESS; + +} + + +ZIO_CODEC_FUNCTION(zio_ulaw2slin) +{ + int16_t *sln = data; + uint8_t law[1024] = {0}, *lp = law; + uint32_t i; + ftdm_size_t len = *datalen; + + if (max > len) { + max = len; + } + + memcpy(law, data, max); + + for(i = 0; i < max; i++) { + *sln++ = ulaw_to_linear(*lp++); + } + + *datalen = max * 2; + + return FTDM_SUCCESS; +} + +ZIO_CODEC_FUNCTION(zio_slin2alaw) +{ + int16_t sln_buf[512] = {0}, *sln = sln_buf; + uint8_t *lp = data; + uint32_t i; + ftdm_size_t len = *datalen; + + if (max > len) { + max = len; + } + + memcpy(sln, data, max); + + for(i = 0; i < max; i++) { + *lp++ = linear_to_alaw(*sln++); + } + + *datalen = max / 2; + + return FTDM_SUCCESS; + +} + + +ZIO_CODEC_FUNCTION(zio_alaw2slin) +{ + int16_t *sln = data; + uint8_t law[1024] = {0}, *lp = law; + uint32_t i; + ftdm_size_t len = *datalen; + + if (max > len) { + max = len; + } + + memcpy(law, data, max); + + for(i = 0; i < max; i++) { + *sln++ = alaw_to_linear(*lp++); + } + + *datalen = max * 2; + + return FTDM_SUCCESS; +} + +ZIO_CODEC_FUNCTION(zio_ulaw2alaw) +{ + ftdm_size_t len = *datalen; + uint32_t i; + uint8_t *lp = data; + + if (max > len) { + max = len; + } + + for(i = 0; i < max; i++) { + *lp = ulaw_to_alaw(*lp); + lp++; + } + + return FTDM_SUCCESS; +} + +ZIO_CODEC_FUNCTION(zio_alaw2ulaw) +{ + ftdm_size_t len = *datalen; + uint32_t i; + uint8_t *lp = data; + + if (max > len) { + max = len; + } + + for(i = 0; i < max; i++) { + *lp = alaw_to_ulaw(*lp); + lp++; + } + + return FTDM_SUCCESS; +} + +/******************************/ + +FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan) +{ + uint32_t i; + + memset(ftdmchan->detected_tones, 0, sizeof(ftdmchan->detected_tones[0]) * FTDM_TONEMAP_INVALID); + + for (i = 1; i < FTDM_TONEMAP_INVALID; i++) { + ftdmchan->span->tone_finder[i].tone_count = 0; + } +} + +FT_DECLARE(void) ftdm_channel_clear_needed_tones(ftdm_channel_t *ftdmchan) +{ + memset(ftdmchan->needed_tones, 0, sizeof(ftdmchan->needed_tones[0]) * FTDM_TONEMAP_INVALID); +} + +FT_DECLARE(ftdm_size_t) ftdm_channel_dequeue_dtmf(ftdm_channel_t *ftdmchan, char *dtmf, ftdm_size_t len) +{ + ftdm_size_t bytes = 0; + + assert(ftdmchan != NULL); + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_READY)) { + return FTDM_FAIL; + } + + if (ftdmchan->digit_buffer && ftdm_buffer_inuse(ftdmchan->digit_buffer)) { + ftdm_mutex_lock(ftdmchan->mutex); + if ((bytes = ftdm_buffer_read(ftdmchan->digit_buffer, dtmf, len)) > 0) { + *(dtmf + bytes) = '\0'; + } + ftdm_mutex_unlock(ftdmchan->mutex); + } + + return bytes; +} + +FT_DECLARE(void) ftdm_channel_flush_dtmf(ftdm_channel_t *ftdmchan) +{ + if (ftdmchan->digit_buffer && ftdm_buffer_inuse(ftdmchan->digit_buffer)) { + ftdm_mutex_lock(ftdmchan->mutex); + ftdm_buffer_zero(ftdmchan->digit_buffer); + ftdm_mutex_unlock(ftdmchan->mutex); + } +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf) +{ + ftdm_status_t status; + register ftdm_size_t len, inuse; + ftdm_size_t wr = 0; + const char *p; + + assert(ftdmchan != NULL); + + if (ftdmchan->pre_buffer) { + ftdm_buffer_zero(ftdmchan->pre_buffer); + } + + ftdm_mutex_lock(ftdmchan->mutex); + + inuse = ftdm_buffer_inuse(ftdmchan->digit_buffer); + len = strlen(dtmf); + + if (len + inuse > ftdm_buffer_len(ftdmchan->digit_buffer)) { + ftdm_buffer_toss(ftdmchan->digit_buffer, strlen(dtmf)); + } + + if (ftdmchan->span->dtmf_hangup_len) { + for (p = dtmf; ftdm_is_dtmf(*p); p++) { + memmove (ftdmchan->dtmf_hangup_buf, ftdmchan->dtmf_hangup_buf + 1, ftdmchan->span->dtmf_hangup_len - 1); + ftdmchan->dtmf_hangup_buf[ftdmchan->span->dtmf_hangup_len - 1] = *p; + if (!strcmp(ftdmchan->dtmf_hangup_buf, ftdmchan->span->dtmf_hangup)) { + ftdm_log(FTDM_LOG_DEBUG, "DTMF hangup detected.\n"); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + break; + } + } + } + + p = dtmf; + while (wr < len && p) { + if (ftdm_is_dtmf(*p)) { + wr++; + } else { + break; + } + p++; + } + + status = ftdm_buffer_write(ftdmchan->digit_buffer, dtmf, wr) ? FTDM_SUCCESS : FTDM_FAIL; + ftdm_mutex_unlock(ftdmchan->mutex); + + return status; +} + + +static ftdm_status_t handle_dtmf(ftdm_channel_t *ftdmchan, ftdm_size_t datalen) +{ + ftdm_buffer_t *buffer = NULL; + ftdm_size_t dblen = 0; + int wrote = 0; + + if (ftdmchan->gen_dtmf_buffer && (dblen = ftdm_buffer_inuse(ftdmchan->gen_dtmf_buffer))) { + char digits[128] = ""; + char *cur; + int x = 0; + + if (dblen > sizeof(digits) - 1) { + dblen = sizeof(digits) - 1; + } + + if (ftdm_buffer_read(ftdmchan->gen_dtmf_buffer, digits, dblen) && !ftdm_strlen_zero_buf(digits)) { + ftdm_log(FTDM_LOG_DEBUG, "%d:%d GENERATE DTMF [%s]\n", ftdmchan->span_id, ftdmchan->chan_id, digits); + + cur = digits; + + if (*cur == 'F') { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_FLASH, NULL); + cur++; + } + + for (; *cur; cur++) { + if ((wrote = teletone_mux_tones(&ftdmchan->tone_session, &ftdmchan->tone_session.TONES[(int)*cur]))) { + ftdm_buffer_write(ftdmchan->dtmf_buffer, ftdmchan->tone_session.buffer, wrote * 2); + x++; + } else { + ftdm_log(FTDM_LOG_ERROR, "%d:%d Problem Adding DTMF SEQ [%s]\n", ftdmchan->span_id, ftdmchan->chan_id, digits); + return FTDM_FAIL; + } + } + + if (x) { + ftdmchan->skip_read_frames = (wrote / (ftdmchan->effective_interval * 8)) + 4; + } + } + } + + + if (!ftdmchan->buffer_delay || --ftdmchan->buffer_delay == 0) { + if (ftdmchan->dtmf_buffer && (dblen = ftdm_buffer_inuse(ftdmchan->dtmf_buffer))) { + buffer = ftdmchan->dtmf_buffer; + } else if (ftdmchan->fsk_buffer && (dblen = ftdm_buffer_inuse(ftdmchan->fsk_buffer))) { + buffer = ftdmchan->fsk_buffer; + } + } + + if (buffer) { + ftdm_size_t dlen = datalen; + uint8_t auxbuf[1024]; + ftdm_size_t len, br, max = sizeof(auxbuf); + + if (ftdmchan->native_codec != FTDM_CODEC_SLIN) { + dlen *= 2; + } + + len = dblen > dlen ? dlen : dblen; + + br = ftdm_buffer_read(buffer, auxbuf, len); + if (br < dlen) { + memset(auxbuf + br, 0, dlen - br); + } + + if (ftdmchan->native_codec != FTDM_CODEC_SLIN) { + if (ftdmchan->native_codec == FTDM_CODEC_ULAW) { + zio_slin2ulaw(auxbuf, max, &dlen); + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW) { + zio_slin2alaw(auxbuf, max, &dlen); + } + } + + return ftdmchan->zio->write(ftdmchan, auxbuf, &dlen); + } + + return FTDM_SUCCESS; + +} + + +FT_DECLARE(void) ftdm_generate_sln_silence(int16_t *data, uint32_t samples, uint32_t divisor) +{ + int16_t x; + uint32_t i; + int sum_rnd = 0; + int16_t rnd2 = (int16_t) ftdm_current_time_in_ms() * (int16_t) (intptr_t) data; + + assert(divisor); + + for (i = 0; i < samples; i++, sum_rnd = 0) { + for (x = 0; x < 6; x++) { + rnd2 = rnd2 * 31821U + 13849U; + sum_rnd += rnd2 ; + } + //switch_normalize_to_16bit(sum_rnd); + *data = (int16_t) ((int16_t) sum_rnd / (int) divisor); + + data++; + } +} + + + +FT_DECLARE(ftdm_status_t) ftdm_channel_read(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen) +{ + ftdm_status_t status = FTDM_FAIL; + zio_codec_t codec_func = NULL; + ftdm_size_t max = *datalen; + unsigned i = 0; + + assert(ftdmchan != NULL); + assert(ftdmchan->zio != NULL); + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "channel not open"); + return FTDM_FAIL; + } + + if (!ftdmchan->zio->read) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "method not implemented"); + return FTDM_FAIL; + } + + status = ftdmchan->zio->read(ftdmchan, data, datalen); + if (ftdmchan->fds[0] > -1) { + int dlen = (int) *datalen; + if (write(ftdmchan->fds[0], data, dlen) != dlen) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "file write error!"); + return FTDM_FAIL; + } + } + + if (status == FTDM_SUCCESS) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_USE_RX_GAIN) + && (ftdmchan->native_codec == FTDM_CODEC_ALAW || ftdmchan->native_codec == FTDM_CODEC_ULAW)) { + unsigned char *rdata = data; + for (i = 0; i < *datalen; i++) { + rdata[i] = ftdmchan->rxgain_table[rdata[i]]; + } + } + handle_dtmf(ftdmchan, *datalen); + } + + if (status == FTDM_SUCCESS && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_TRANSCODE) && ftdmchan->effective_codec != ftdmchan->native_codec) { + if (ftdmchan->native_codec == FTDM_CODEC_ULAW && ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + codec_func = zio_ulaw2slin; + } else if (ftdmchan->native_codec == FTDM_CODEC_ULAW && ftdmchan->effective_codec == FTDM_CODEC_ALAW) { + codec_func = zio_ulaw2alaw; + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW && ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + codec_func = zio_alaw2slin; + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW && ftdmchan->effective_codec == FTDM_CODEC_ULAW) { + codec_func = zio_alaw2ulaw; + } + + if (codec_func) { + status = codec_func(data, max, datalen); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!"); + status = FTDM_FAIL; + } + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_DTMF_DETECT) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS_DETECT) || + ftdm_test_flag(ftdmchan, FTDM_CHANNEL_CALLERID_DETECT)) { + uint8_t sln_buf[1024] = {0}; + int16_t *sln; + ftdm_size_t slen = 0; + char digit_str[80] = ""; + + if (ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + sln = data; + slen = *datalen / 2; + } else { + ftdm_size_t len = *datalen; + uint32_t i; + uint8_t *lp = data; + + slen = sizeof(sln_buf) / 2; + if (len > slen) { + len = slen; + } + + sln = (int16_t *) sln_buf; + for(i = 0; i < len; i++) { + if (ftdmchan->effective_codec == FTDM_CODEC_ULAW) { + *sln++ = ulaw_to_linear(*lp++); + } else if (ftdmchan->effective_codec == FTDM_CODEC_ALAW) { + *sln++ = alaw_to_linear(*lp++); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!"); + return FTDM_FAIL; + } + } + sln = (int16_t *) sln_buf; + slen = len; + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_CALLERID_DETECT)) { + if (ftdm_fsk_demod_feed(&ftdmchan->fsk, sln, slen) != FTDM_SUCCESS) { + ftdm_size_t type, mlen; + char str[128], *sp; + + while(ftdm_fsk_data_parse(&ftdmchan->fsk, &type, &sp, &mlen) == FTDM_SUCCESS) { + *(str+mlen) = '\0'; + ftdm_copy_string(str, sp, ++mlen); + ftdm_clean_string(str); + ftdm_log(FTDM_LOG_DEBUG, "FSK: TYPE %s LEN %d VAL [%s]\n", ftdm_mdmf_type2str(type), mlen-1, str); + + switch(type) { + case MDMF_DDN: + case MDMF_PHONE_NUM: + { + if (mlen > sizeof(ftdmchan->caller_data.ani)) { + mlen = sizeof(ftdmchan->caller_data.ani); + } + ftdm_set_string(ftdmchan->caller_data.ani.digits, str); + ftdm_set_string(ftdmchan->caller_data.cid_num.digits, ftdmchan->caller_data.ani.digits); + } + break; + case MDMF_NO_NUM: + { + ftdm_set_string(ftdmchan->caller_data.ani.digits, *str == 'P' ? "private" : "unknown"); + ftdm_set_string(ftdmchan->caller_data.cid_name, ftdmchan->caller_data.ani.digits); + } + break; + case MDMF_PHONE_NAME: + { + if (mlen > sizeof(ftdmchan->caller_data.cid_name)) { + mlen = sizeof(ftdmchan->caller_data.cid_name); + } + ftdm_set_string(ftdmchan->caller_data.cid_name, str); + } + break; + case MDMF_NO_NAME: + { + ftdm_set_string(ftdmchan->caller_data.cid_name, *str == 'P' ? "private" : "unknown"); + } + case MDMF_DATETIME: + { + if (mlen > sizeof(ftdmchan->caller_data.cid_date)) { + mlen = sizeof(ftdmchan->caller_data.cid_date); + } + ftdm_set_string(ftdmchan->caller_data.cid_date, str); + } + break; + } + } + ftdm_channel_command(ftdmchan, FTDM_COMMAND_DISABLE_CALLERID_DETECT, NULL); + } + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS_DETECT) && !ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_PROGRESS)) { + uint32_t i; + + for (i = 1; i < FTDM_TONEMAP_INVALID; i++) { + if (ftdmchan->span->tone_finder[i].tone_count) { + if (ftdmchan->needed_tones[i] && teletone_multi_tone_detect(&ftdmchan->span->tone_finder[i], sln, (int)slen)) { + if (++ftdmchan->detected_tones[i]) { + ftdmchan->needed_tones[i] = 0; + ftdmchan->detected_tones[0]++; + } + } + } + } + } + + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_DTMF_DETECT) && !ftdm_channel_test_feature(ftdmchan, FTDM_CHANNEL_FEATURE_DTMF_DETECT)) { + teletone_dtmf_detect(&ftdmchan->dtmf_detect, sln, (int)slen); + teletone_dtmf_get(&ftdmchan->dtmf_detect, digit_str, sizeof(digit_str)); + + if(*digit_str) { + zio_event_cb_t event_callback = NULL; + + if (ftdmchan->state == FTDM_CHANNEL_STATE_CALLWAITING && (*digit_str == 'D' || *digit_str == 'A')) { + ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]++; + } else { + ftdm_channel_queue_dtmf(ftdmchan, digit_str); + + if (ftdmchan->span->event_callback) { + event_callback = ftdmchan->span->event_callback; + } else if (ftdmchan->event_callback) { + event_callback = ftdmchan->event_callback; + } + + if (event_callback) { + ftdmchan->event_header.channel = ftdmchan; + ftdmchan->event_header.e_type = FTDM_EVENT_DTMF; + ftdmchan->event_header.data = digit_str; + event_callback(ftdmchan, &ftdmchan->event_header); + ftdmchan->event_header.e_type = FTDM_EVENT_NONE; + ftdmchan->event_header.data = NULL; + } + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_SUPRESS_DTMF)) { + ftdmchan->skip_read_frames = 20; + } + } + } + } + } + + if (ftdmchan->skip_read_frames > 0 || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_MUTE)) { + + ftdm_mutex_lock(ftdmchan->pre_buffer_mutex); + if (ftdmchan->pre_buffer && ftdm_buffer_inuse(ftdmchan->pre_buffer)) { + ftdm_buffer_zero(ftdmchan->pre_buffer); + } + ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex); + + + memset(data, 255, *datalen); + + if (ftdmchan->skip_read_frames > 0) { + ftdmchan->skip_read_frames--; + } + } else { + ftdm_mutex_lock(ftdmchan->pre_buffer_mutex); + if (ftdmchan->pre_buffer_size && ftdmchan->pre_buffer) { + ftdm_buffer_write(ftdmchan->pre_buffer, data, *datalen); + if (ftdm_buffer_inuse(ftdmchan->pre_buffer) >= ftdmchan->pre_buffer_size) { + ftdm_buffer_read(ftdmchan->pre_buffer, data, *datalen); + } else { + memset(data, 255, *datalen); + } + } + ftdm_mutex_unlock(ftdmchan->pre_buffer_mutex); + } + + + return status; +} + + +FT_DECLARE(ftdm_status_t) ftdm_channel_write(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t datasize, ftdm_size_t *datalen) +{ + ftdm_status_t status = FTDM_FAIL; + zio_codec_t codec_func = NULL; + ftdm_size_t max = datasize; + unsigned int i = 0; + + assert(ftdmchan != NULL); + assert(ftdmchan->zio != NULL); + + if (!ftdmchan->buffer_delay && + ((ftdmchan->dtmf_buffer && ftdm_buffer_inuse(ftdmchan->dtmf_buffer)) || + (ftdmchan->fsk_buffer && ftdm_buffer_inuse(ftdmchan->fsk_buffer)))) { + /* read size writing DTMF ATM */ + return FTDM_SUCCESS; + } + + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "channel not open"); + return FTDM_FAIL; + } + + if (!ftdmchan->zio->write) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "method not implemented"); + return FTDM_FAIL; + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_TRANSCODE) && ftdmchan->effective_codec != ftdmchan->native_codec) { + if (ftdmchan->native_codec == FTDM_CODEC_ULAW && ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + codec_func = zio_slin2ulaw; + } else if (ftdmchan->native_codec == FTDM_CODEC_ULAW && ftdmchan->effective_codec == FTDM_CODEC_ALAW) { + codec_func = zio_alaw2ulaw; + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW && ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + codec_func = zio_slin2alaw; + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW && ftdmchan->effective_codec == FTDM_CODEC_ULAW) { + codec_func = zio_ulaw2alaw; + } + + if (codec_func) { + status = codec_func(data, max, datalen); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!"); + status = FTDM_FAIL; + } + } + + if (ftdmchan->fds[1] > -1) { + int dlen = (int) *datalen; + if ((write(ftdmchan->fds[1], data, dlen)) != dlen) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "file write error!"); + return FTDM_FAIL; + } + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_USE_TX_GAIN) + && (ftdmchan->native_codec == FTDM_CODEC_ALAW || ftdmchan->native_codec == FTDM_CODEC_ULAW)) { + unsigned char *wdata = data; + for (i = 0; i < *datalen; i++) { + wdata[i] = ftdmchan->txgain_table[wdata[i]]; + } + } + status = ftdmchan->zio->write(ftdmchan, data, datalen); + + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_clear_vars(ftdm_channel_t *ftdmchan) +{ + if(ftdmchan->variable_hash) { + hashtable_destroy(ftdmchan->variable_hash); + } + ftdmchan->variable_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + + if(!ftdmchan->variable_hash) + return FTDM_FAIL; + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_add_var(ftdm_channel_t *ftdmchan, const char *var_name, const char *value) +{ + char *t_name = 0, *t_val = 0; + + if(!ftdmchan->variable_hash || !var_name || !value) + { + return FTDM_FAIL; + } + + t_name = ftdm_strdup(var_name); + t_val = ftdm_strdup(value); + + if(hashtable_insert(ftdmchan->variable_hash, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE)) { + return FTDM_SUCCESS; + } + return FTDM_FAIL; +} + +FT_DECLARE(const char *) ftdm_channel_get_var(ftdm_channel_t *ftdmchan, const char *var_name) +{ + if(!ftdmchan->variable_hash || !var_name) + { + return NULL; + } + return (const char *) hashtable_search(ftdmchan->variable_hash, (void *)var_name); +} + +static struct { + ftdm_io_interface_t *pika_interface; +} interfaces; + + +FT_DECLARE(char *) ftdm_api_execute(const char *type, const char *cmd) +{ + ftdm_io_interface_t *zio = NULL; + char *dup = NULL, *p; + char *rval = NULL; + + if (type && !cmd) { + dup = ftdm_strdup(type); + if ((p = strchr(dup, ' '))) { + *p++ = '\0'; + cmd = p; + } + + type = dup; + } + + ftdm_mutex_lock(globals.mutex); + if (!(zio = (ftdm_io_interface_t *) hashtable_search(globals.interface_hash, (void *)type))) { + ftdm_load_module_assume(type); + if ((zio = (ftdm_io_interface_t *) hashtable_search(globals.interface_hash, (void *)type))) { + ftdm_log(FTDM_LOG_INFO, "auto-loaded '%s'\n", type); + } + } + ftdm_mutex_unlock(globals.mutex); + + if (zio && zio->api) { + ftdm_stream_handle_t stream = { 0 }; + ftdm_status_t status; + FTDM_STANDARD_STREAM(stream); + status = zio->api(&stream, cmd); + + if (status != FTDM_SUCCESS) { + ftdm_safe_free(stream.data); + } else { + rval = (char *) stream.data; + } + } + + ftdm_safe_free(dup); + + return rval; +} + + +static ftdm_status_t load_config(void) +{ + char cfg_name[] = "freetdm.conf"; + ftdm_config_t cfg; + char *var, *val; + int catno = -1; + ftdm_span_t *span = NULL; + unsigned configured = 0, d = 0; + char name[80] = ""; + char number[25] = ""; + char group_name[80] = "default"; + ftdm_io_interface_t *zio = NULL; + ftdm_analog_start_type_t tmp; + ftdm_size_t len = 0; + + if (!ftdm_config_open_file(&cfg, cfg_name)) { + return FTDM_FAIL; + } + + while (ftdm_config_next_pair(&cfg, &var, &val)) { + if (*cfg.category == '#') { + if (cfg.catno != catno) { + ftdm_log(FTDM_LOG_DEBUG, "Skipping %s\n", cfg.category); + catno = cfg.catno; + } + } else if (!strncasecmp(cfg.category, "span", 4)) { + if (cfg.catno != catno) { + char *type = cfg.category + 4; + char *name; + + if (*type == ' ') { + type++; + } + + ftdm_log(FTDM_LOG_DEBUG, "found config for span\n"); + catno = cfg.catno; + + if (ftdm_strlen_zero(type)) { + ftdm_log(FTDM_LOG_CRIT, "failure creating span, no type specified.\n"); + span = NULL; + continue; + } + + if ((name = strchr(type, ' '))) { + *name++ = '\0'; + } + + ftdm_mutex_lock(globals.mutex); + if (!(zio = (ftdm_io_interface_t *) hashtable_search(globals.interface_hash, type))) { + ftdm_load_module_assume(type); + if ((zio = (ftdm_io_interface_t *) hashtable_search(globals.interface_hash, type))) { + ftdm_log(FTDM_LOG_INFO, "auto-loaded '%s'\n", type); + } + } + ftdm_mutex_unlock(globals.mutex); + + if (!zio) { + ftdm_log(FTDM_LOG_CRIT, "failure creating span, no such type '%s'\n", type); + span = NULL; + continue; + } + + if (!zio->configure_span) { + ftdm_log(FTDM_LOG_CRIT, "failure creating span, no configure_span method for '%s'\n", type); + span = NULL; + continue; + } + + if (ftdm_span_create(zio, &span, name) == FTDM_SUCCESS) { + span->type = ftdm_strdup(type); + d = 0; + + ftdm_log(FTDM_LOG_DEBUG, "created span %d (%s) of type %s\n", span->span_id, span->name, type); + + } else { + ftdm_log(FTDM_LOG_CRIT, "failure creating span of type %s\n", type); + span = NULL; + continue; + } + } + + if (!span) { + continue; + } + + ftdm_log(FTDM_LOG_DEBUG, "span %d [%s]=[%s]\n", span->span_id, var, val); + + if (!strcasecmp(var, "trunk_type")) { + span->trunk_type = ftdm_str2ftdm_trunk_type(val); + ftdm_log(FTDM_LOG_DEBUG, "setting trunk type to '%s'\n", ftdm_trunk_type2str(span->trunk_type)); + } else if (!strcasecmp(var, "name")) { + if (!strcasecmp(val, "undef")) { + *name = '\0'; + } else { + ftdm_copy_string(name, val, sizeof(name)); + } + } else if (!strcasecmp(var, "number")) { + if (!strcasecmp(val, "undef")) { + *number = '\0'; + } else { + ftdm_copy_string(number, val, sizeof(number)); + } + } else if (!strcasecmp(var, "analog-start-type")) { + if (span->trunk_type == FTDM_TRUNK_FXS || span->trunk_type == FTDM_TRUNK_FXO || span->trunk_type == FTDM_TRUNK_EM) { + if ((tmp = ftdm_str2ftdm_analog_start_type(val)) != FTDM_ANALOG_START_NA) { + span->start_type = tmp; + ftdm_log(FTDM_LOG_DEBUG, "changing start type to '%s'\n", ftdm_analog_start_type2str(span->start_type)); + } + } else { + ftdm_log(FTDM_LOG_ERROR, "This option is only valid on analog trunks!\n"); + } + } else if (!strcasecmp(var, "fxo-channel")) { + if (span->trunk_type == FTDM_TRUNK_NONE) { + span->trunk_type = FTDM_TRUNK_FXO; + ftdm_log(FTDM_LOG_DEBUG, "setting trunk type to '%s' start(%s)\n", ftdm_trunk_type2str(span->trunk_type), + ftdm_analog_start_type2str(span->start_type)); + } + if (span->trunk_type == FTDM_TRUNK_FXO) { + configured += zio->configure_span(span, val, FTDM_CHAN_TYPE_FXO, name, number); + } else { + ftdm_log(FTDM_LOG_WARNING, "Cannot add FXO channels to an FXS trunk!\n"); + } + } else if (!strcasecmp(var, "fxs-channel")) { + if (span->trunk_type == FTDM_TRUNK_NONE) { + span->trunk_type = FTDM_TRUNK_FXS; + ftdm_log(FTDM_LOG_DEBUG, "setting trunk type to '%s' start(%s)\n", ftdm_trunk_type2str(span->trunk_type), + ftdm_analog_start_type2str(span->start_type)); + } + if (span->trunk_type == FTDM_TRUNK_FXS) { + configured += zio->configure_span(span, val, FTDM_CHAN_TYPE_FXS, name, number); + } else { + ftdm_log(FTDM_LOG_WARNING, "Cannot add FXS channels to an FXO trunk!\n"); + } + } else if (!strcasecmp(var, "em-channel")) { + if (span->trunk_type == FTDM_TRUNK_NONE) { + span->trunk_type = FTDM_TRUNK_EM; + ftdm_log(FTDM_LOG_DEBUG, "setting trunk type to '%s' start(%s)\n", ftdm_trunk_type2str(span->trunk_type), + ftdm_analog_start_type2str(span->start_type)); + } + if (span->trunk_type == FTDM_TRUNK_EM) { + configured += zio->configure_span(span, val, FTDM_CHAN_TYPE_EM, name, number); + } else { + ftdm_log(FTDM_LOG_WARNING, "Cannot add EM channels to a non-EM trunk!\n"); + } + } else if (!strcasecmp(var, "b-channel")) { + configured += zio->configure_span(span, val, FTDM_CHAN_TYPE_B, name, number); + ftdm_group_add_channels(group_name, span, val); + } else if (!strcasecmp(var, "d-channel")) { + if (d) { + ftdm_log(FTDM_LOG_WARNING, "ignoring extra d-channel\n"); + } else { + ftdm_chan_type_t qtype; + if (!strncasecmp(val, "lapd:", 5)) { + qtype = FTDM_CHAN_TYPE_DQ931; + val += 5; + } else { + qtype = FTDM_CHAN_TYPE_DQ921; + } + configured += zio->configure_span(span, val, qtype, name, number); + d++; + } + } else if (!strcasecmp(var, "cas-channel")) { + configured += zio->configure_span(span, val, FTDM_CHAN_TYPE_CAS, name, number); + } else if (!strcasecmp(var, "dtmf_hangup")) { + span->dtmf_hangup = ftdm_strdup(val); + span->dtmf_hangup_len = strlen(val); + } else if (!strcasecmp(var, "group")) { + len = strlen(val); + if (len >= sizeof(group_name)) { + len = sizeof(group_name) - 1; + ftdm_log(FTDM_LOG_WARNING, "Truncating group name %s to %zd length\n", val, len); + } + memcpy(group_name, val, len); + group_name[len] = '\0'; + } else { + ftdm_log(FTDM_LOG_ERROR, "unknown span variable '%s'\n", var); + } + } else { + ftdm_log(FTDM_LOG_ERROR, "unknown param [%s] '%s' / '%s'\n", cfg.category, var, val); + } + } + ftdm_config_close_file(&cfg); + + ftdm_log(FTDM_LOG_INFO, "Configured %u channel(s)\n", configured); + + return configured ? FTDM_SUCCESS : FTDM_FAIL; +} + +static ftdm_status_t process_module_config(ftdm_io_interface_t *zio) +{ + ftdm_config_t cfg; + char *var, *val; + char filename[256] = ""; + + ftdm_assert_return(zio != NULL, FTDM_FAIL, "zio argument is null\n"); + + snprintf(filename, sizeof(filename), "%s.conf", zio->name); + + if (!zio->configure) { + ftdm_log(FTDM_LOG_DEBUG, "Module %s does not support configuration.\n", zio->name); + return FTDM_FAIL; + } + + if (!ftdm_config_open_file(&cfg, filename)) { + ftdm_log(FTDM_LOG_ERROR, "Cannot open %s\n", filename); + return FTDM_FAIL; + } + + while (ftdm_config_next_pair(&cfg, &var, &val)) { + zio->configure(cfg.category, var, val, cfg.lineno); + } + + ftdm_config_close_file(&cfg); + + return FTDM_SUCCESS; +} + +FT_DECLARE(char *) ftdm_build_dso_path(const char *name, char *path, ftdm_size_t len) +{ +#ifdef WIN32 + const char *ext = ".dll"; + //const char *EXT = ".DLL"; +#define FTDM_MOD_DIR "." //todo +#elif defined (MACOSX) || defined (DARWIN) + const char *ext = ".dylib"; + //const char *EXT = ".DYLIB"; +#else + const char *ext = ".so"; + //const char *EXT = ".SO"; +#endif + if (*name == *FTDM_PATH_SEPARATOR) { + snprintf(path, len, "%s%s", name, ext); + } else { + snprintf(path, len, "%s%s%s%s", FTDM_MOD_DIR, FTDM_PATH_SEPARATOR, name, ext); + } + return path; +} + +FT_DECLARE(ftdm_status_t) ftdm_global_add_io_interface(ftdm_io_interface_t *interface1) +{ + ftdm_status_t ret = FTDM_SUCCESS; + ftdm_mutex_lock(globals.mutex); + if (hashtable_search(globals.interface_hash, (void *)interface1->name)) { + ftdm_log(FTDM_LOG_ERROR, "Interface %s already loaded!\n", interface1->name); + } else { + hashtable_insert(globals.interface_hash, (void *)interface1->name, interface1, HASHTABLE_FLAG_NONE); + } + ftdm_mutex_unlock(globals.mutex); + return ret; +} + +FT_DECLARE(int) ftdm_load_module(const char *name) +{ + ftdm_dso_lib_t lib; + int count = 0, x = 0; + char path[128] = ""; + char *err; + ftdm_module_t *mod; + + ftdm_build_dso_path(name, path, sizeof(path)); + + if (!(lib = ftdm_dso_open(path, &err))) { + ftdm_log(FTDM_LOG_ERROR, "Error loading %s [%s]\n", path, err); + ftdm_safe_free(err); + return 0; + } + + if (!(mod = (ftdm_module_t *) ftdm_dso_func_sym(lib, "ftdm_module", &err))) { + ftdm_log(FTDM_LOG_ERROR, "Error loading %s [%s]\n", path, err); + ftdm_safe_free(err); + return 0; + } + + if (mod->io_load) { + ftdm_io_interface_t *interface1 = NULL; /* name conflict w/windows here */ + + if (mod->io_load(&interface1) != FTDM_SUCCESS || !interface1 || !interface1->name) { + ftdm_log(FTDM_LOG_ERROR, "Error loading %s\n", path); + } else { + ftdm_log(FTDM_LOG_INFO, "Loading IO from %s [%s]\n", path, interface1->name); + if (ftdm_global_add_io_interface(interface1) == FTDM_SUCCESS) { + process_module_config(interface1); + x++; + } + } + } + + if (mod->sig_load) { + if (mod->sig_load() != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error loading %s\n", path); + } else { + ftdm_log(FTDM_LOG_INFO, "Loading SIG from %s\n", path); + x++; + } + } + + if (x) { + char *p; + mod->lib = lib; + ftdm_set_string(mod->path, path); + if (mod->name[0] == '\0') { + if (!(p = strrchr(path, *FTDM_PATH_SEPARATOR))) { + p = path; + } + ftdm_set_string(mod->name, p); + } + + ftdm_mutex_lock(globals.mutex); + if (hashtable_search(globals.module_hash, (void *)mod->name)) { + ftdm_log(FTDM_LOG_ERROR, "Module %s already loaded!\n", mod->name); + ftdm_dso_destroy(&lib); + } else { + hashtable_insert(globals.module_hash, (void *)mod->name, mod, HASHTABLE_FLAG_NONE); + count++; + } + ftdm_mutex_unlock(globals.mutex); + } else { + ftdm_log(FTDM_LOG_ERROR, "Unloading %s\n", path); + ftdm_dso_destroy(&lib); + } + + return count; +} + +FT_DECLARE(int) ftdm_load_module_assume(const char *name) +{ + char buf[256] = ""; + + snprintf(buf, sizeof(buf), "ftmod_%s", name); + return ftdm_load_module(buf); +} + +FT_DECLARE(int) ftdm_load_modules(void) +{ + char cfg_name[] = "modules.conf"; + ftdm_config_t cfg; + char *var, *val; + int count = 0; + + if (!ftdm_config_open_file(&cfg, cfg_name)) { + return FTDM_FAIL; + } + + while (ftdm_config_next_pair(&cfg, &var, &val)) { + if (!strcasecmp(cfg.category, "modules")) { + if (!strcasecmp(var, "load")) { + count += ftdm_load_module(val); + } + } + } + + return count; +} + +FT_DECLARE(ftdm_status_t) ftdm_unload_modules(void) +{ + ftdm_hash_iterator_t *i; + ftdm_dso_lib_t lib; + + for (i = hashtable_first(globals.module_hash); i; i = hashtable_next(i)) { + const void *key; + void *val; + + hashtable_this(i, &key, NULL, &val); + + if (key && val) { + ftdm_module_t *mod = (ftdm_module_t *) val; + + if (!mod) { + continue; + } + + if (mod->io_unload) { + if (mod->io_unload() == FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_INFO, "Unloading IO %s\n", mod->name); + } else { + ftdm_log(FTDM_LOG_ERROR, "Error unloading IO %s\n", mod->name); + } + } + + if (mod->sig_unload) { + if (mod->sig_unload() == FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_INFO, "Unloading SIG %s\n", mod->name); + } else { + ftdm_log(FTDM_LOG_ERROR, "Error unloading SIG %s\n", mod->name); + } + } + + + ftdm_log(FTDM_LOG_INFO, "Unloading %s\n", mod->path); + lib = mod->lib; + ftdm_dso_destroy(&lib); + + } + } + + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_configure_span(const char *type, ftdm_span_t *span, zio_signal_cb_t sig_cb, ...) +{ + ftdm_module_t *mod = (ftdm_module_t *) hashtable_search(globals.module_hash, (void *)type); + ftdm_status_t status = FTDM_FAIL; + + if (!mod) { + ftdm_load_module_assume(type); + if ((mod = (ftdm_module_t *) hashtable_search(globals.module_hash, (void *)type))) { + ftdm_log(FTDM_LOG_INFO, "auto-loaded '%s'\n", type); + } + } + + if (mod && mod->sig_configure) { + va_list ap; + va_start(ap, sig_cb); + status = mod->sig_configure(span, sig_cb, ap); + va_end(ap); + } else { + ftdm_log(FTDM_LOG_ERROR, "can't find '%s'\n", type); + status = FTDM_FAIL; + } + + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_configure_span_signaling(const char *type, ftdm_span_t *span, zio_signal_cb_t sig_cb, ftdm_conf_parameter_t *parameters) +{ + ftdm_module_t *mod = (ftdm_module_t *) hashtable_search(globals.module_hash, (void *)type); + ftdm_status_t status = FTDM_FAIL; + + ftdm_assert_return(type != NULL, FTDM_FAIL, "No signaling type"); + ftdm_assert_return(span != NULL, FTDM_FAIL, "No span"); + ftdm_assert_return(sig_cb != NULL, FTDM_FAIL, "No signaling callback"); + ftdm_assert_return(parameters != NULL, FTDM_FAIL, "No parameters"); + + if (!mod) { + ftdm_load_module_assume(type); + if ((mod = (ftdm_module_t *) hashtable_search(globals.module_hash, (void *)type))) { + ftdm_log(FTDM_LOG_INFO, "auto-loaded '%s'\n", type); + } + } + + if (!mod) { + ftdm_log(FTDM_LOG_ERROR, "Failed to load module type: %s\n", type); + return FTDM_FAIL; + } + + if (mod->configure_span_signaling) { + status = mod->configure_span_signaling(span, sig_cb, parameters); + } else { + ftdm_log(FTDM_LOG_ERROR, "Module %s did not implement the signaling configuration method\n", type); + } + + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_span_start(ftdm_span_t *span) +{ + if (span->start) { + return span->start(span); + } + + return FTDM_FAIL; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_add_to_group(const char* name, ftdm_channel_t* ftdmchan) +{ + int i; + ftdm_group_t* group = NULL; + + ftdm_mutex_lock(globals.group_mutex); + + if (ftdm_group_find_by_name(name, &group) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_DEBUG, "Creating new group:%s\n", name); + ftdm_group_create(&group, name); + } + + /*verify that group does not already include this channel first */ + for(i=0; i < group->chan_count; i++) { + if (group->channels[i]->physical_span_id == ftdmchan->physical_span_id && + group->channels[i]->physical_chan_id == ftdmchan->physical_chan_id) { + + ftdm_mutex_unlock(globals.group_mutex); + return FTDM_SUCCESS; + } + } + + if (group->chan_count >= FTDM_MAX_CHANNELS_GROUP) { + ftdm_log(FTDM_LOG_CRIT, "Max number of channels exceeded (max:%d)\n", FTDM_MAX_CHANNELS_GROUP); + ftdm_mutex_unlock(globals.group_mutex); + return FTDM_FAIL; + } + + group->channels[group->chan_count++] = ftdmchan; + ftdm_mutex_unlock(globals.group_mutex); + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_remove_from_group(ftdm_group_t* group, ftdm_channel_t* ftdmchan) +{ + //Need to test this function + ftdm_mutex_lock(globals.group_mutex); + int i, j; + + for (i=0; i < group->chan_count; i++) { + if (group->channels[i]->physical_span_id == ftdmchan->physical_span_id && + group->channels[i]->physical_chan_id == ftdmchan->physical_chan_id) { + + j=i; + while(j < group->chan_count-1) { + group->channels[j] = group->channels[j+1]; + j++; + } + group->channels[group->chan_count--] = NULL; + if (group->chan_count <=0) { + /* Delete group if it is empty */ + hashtable_remove(globals.group_hash, (void *)group->name); + } + ftdm_mutex_unlock(globals.group_mutex); + return FTDM_SUCCESS; + } + } + + ftdm_mutex_unlock(globals.group_mutex); + //Group does not contain this channel + return FTDM_FAIL; +} + +FT_DECLARE(ftdm_status_t) ftdm_group_add_channels(const char* name, ftdm_span_t* span, const char* val) +{ + char *p, *mydata, *item_list[10]; + int items, i; + + assert(strlen(name) > 0); + + p = strchr(val, ':'); + mydata = ftdm_strdup(++p); + + ftdm_assert_return(mydata != NULL, FTDM_FAIL, "ftdm_strdup failed when adding channels\n"); + + items = ftdm_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); + + for(i=0; i < items; i++) { + if (!strchr(item_list[i], '-')) { + int chan_no; + + chan_no = atoi (item_list[i]); + ftdm_assert(chan_no > 0, "Channel number is not bigger than zero, expect a nasty failure!\n"); + + if (ftdm_channel_add_to_group(name, span->channels[chan_no]) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_CRIT, "Failed to add chan:%d to group:%s\n", chan_no, name); + } + } else { + int chan_no_start, chan_no_end; + if (sscanf(item_list[i], "%d-%d", &chan_no_start, &chan_no_end) == 2) { + while (chan_no_start <= chan_no_end) { + if (ftdm_channel_add_to_group(name, span->channels[chan_no_start++])) { + ftdm_log(FTDM_LOG_CRIT, "Failed to add chan:%d to group:%s\n", chan_no_start-1, name); + } + } + } + } + } + ftdm_safe_free(mydata); + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_group_find(uint32_t id, ftdm_group_t **group) +{ + ftdm_group_t *fgroup = NULL, *grp; + + if (id > FTDM_MAX_GROUPS_INTERFACE) { + return FTDM_FAIL; + } + + + ftdm_mutex_lock(globals.group_mutex); + for (grp = globals.groups; grp; grp = grp->next) { + if (grp->group_id == id) { + fgroup = grp; + break; + } + } + ftdm_mutex_unlock(globals.group_mutex); + + if (!fgroup) { + return FTDM_FAIL; + } + + *group = fgroup; + + return FTDM_SUCCESS; + +} + +FT_DECLARE(ftdm_status_t) ftdm_group_find_by_name(const char *name, ftdm_group_t **group) +{ + ftdm_status_t status = FTDM_FAIL; + *group = NULL; + ftdm_mutex_lock(globals.group_mutex); + if (!ftdm_strlen_zero(name)) { + if ((*group = hashtable_search(globals.group_hash, (void *) name))) { + status = FTDM_SUCCESS; + } + } + ftdm_mutex_unlock(globals.group_mutex); + return status; +} + +static void ftdm_group_add(ftdm_group_t *group) +{ + ftdm_group_t *grp; + ftdm_mutex_lock(globals.group_mutex); + + for (grp = globals.groups; grp && grp->next; grp = grp->next); + + if (grp) { + grp->next = group; + } else { + globals.groups = group; + } + hashtable_insert(globals.group_hash, (void *)group->name, group, HASHTABLE_FLAG_NONE); + + ftdm_mutex_unlock(globals.group_mutex); +} + + +FT_DECLARE(ftdm_status_t) ftdm_group_create(ftdm_group_t **group, const char *name) +{ + ftdm_group_t *new_group = NULL; + ftdm_status_t status = FTDM_FAIL; + + ftdm_mutex_lock(globals.mutex); + if (globals.group_index < FTDM_MAX_GROUPS_INTERFACE) { + new_group = ftdm_calloc(1, sizeof(*new_group)); + + ftdm_assert(new_group != NULL, "Failed to create new ftdm group, expect a crash\n"); + + status = ftdm_mutex_create(&new_group->mutex); + + ftdm_assert(status == FTDM_SUCCESS, "Failed to create group mutex, expect a crash\n"); + + new_group->group_id = ++globals.group_index; + new_group->name = ftdm_strdup(name); + ftdm_group_add(new_group); + *group = new_group; + status = FTDM_SUCCESS; + } else { + ftdm_log(FTDM_LOG_CRIT, "Group %s was not added, we exceeded the max number of groups\n", name); + } + ftdm_mutex_unlock(globals.mutex); + return status; +} + +FT_DECLARE(ftdm_status_t) ftdm_global_init(void) +{ + memset(&globals, 0, sizeof(globals)); + + time_init(); + + ftdm_thread_override_default_stacksize(FTDM_THREAD_STACKSIZE); + + memset(&interfaces, 0, sizeof(interfaces)); + globals.interface_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + globals.module_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + globals.span_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + globals.group_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + ftdm_mutex_create(&globals.mutex); + ftdm_mutex_create(&globals.span_mutex); + ftdm_mutex_create(&globals.group_mutex); + globals.running = 1; + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_global_configuration(void) +{ + int modcount = ftdm_load_modules(); + ftdm_log(FTDM_LOG_NOTICE, "Modules configured: %d \n", modcount); + + if (load_config() != FTDM_SUCCESS) { + globals.running = 0; + ftdm_log(FTDM_LOG_ERROR, "OpenZap global configuration failed!\n"); + return FTDM_FAIL; + } + return FTDM_SUCCESS; +} + +FT_DECLARE(uint32_t) ftdm_running(void) +{ + return globals.running; +} + + +FT_DECLARE(ftdm_status_t) ftdm_global_destroy(void) +{ + ftdm_span_t *sp; + + time_end(); + + globals.running = 0; + ftdm_span_close_all(); + ftdm_sleep(1000); + + ftdm_mutex_lock(globals.span_mutex); + for (sp = globals.spans; sp;) { + ftdm_span_t *cur_span = sp; + sp = sp->next; + + if (cur_span) { + if (ftdm_test_flag(cur_span, FTDM_SPAN_CONFIGURED)) { + ftdm_span_destroy(cur_span); + } + + hashtable_remove(globals.span_hash, (void *)cur_span->name); + ftdm_safe_free(cur_span->type); + ftdm_safe_free(cur_span->name); + ftdm_safe_free(cur_span); + cur_span = NULL; + } + } + globals.spans = NULL; + ftdm_mutex_unlock(globals.span_mutex); + + globals.span_index = 0; + + ftdm_unload_modules(); + + ftdm_mutex_lock(globals.mutex); + hashtable_destroy(globals.interface_hash); + hashtable_destroy(globals.module_hash); + hashtable_destroy(globals.span_hash); + ftdm_mutex_unlock(globals.mutex); + ftdm_mutex_destroy(&globals.mutex); + ftdm_mutex_destroy(&globals.span_mutex); + + memset(&globals, 0, sizeof(globals)); + return FTDM_SUCCESS; +} + + +FT_DECLARE(uint32_t) ftdm_separate_string(char *buf, char delim, char **array, int arraylen) +{ + int argc; + char *ptr; + int quot = 0; + char qc = '\''; + int x; + + if (!buf || !array || !arraylen) { + return 0; + } + + memset(array, 0, arraylen * sizeof(*array)); + + ptr = buf; + + for (argc = 0; *ptr && (argc < arraylen - 1); argc++) { + array[argc] = ptr; + for (; *ptr; ptr++) { + if (*ptr == qc) { + if (quot) { + quot--; + } else { + quot++; + } + } else if ((*ptr == delim) && !quot) { + *ptr++ = '\0'; + break; + } + } + } + + if (*ptr) { + array[argc++] = ptr; + } + + /* strip quotes and leading / trailing spaces */ + for (x = 0; x < argc; x++) { + char *p; + + while(*(array[x]) == ' ') { + (array[x])++; + } + p = array[x]; + while((p = strchr(array[x], qc))) { + memmove(p, p+1, strlen(p)); + p++; + } + p = array[x] + (strlen(array[x]) - 1); + while(*p == ' ') { + *p-- = '\0'; + } + } + + return argc; +} + +FT_DECLARE(void) ftdm_bitstream_init(ftdm_bitstream_t *bsp, uint8_t *data, uint32_t datalen, ftdm_endian_t endian, uint8_t ss) +{ + memset(bsp, 0, sizeof(*bsp)); + bsp->data = data; + bsp->datalen = datalen; + bsp->endian = endian; + bsp->ss = ss; + + if (endian < 0) { + bsp->top = bsp->bit_index = 7; + bsp->bot = 0; + } else { + bsp->top = bsp->bit_index = 0; + bsp->bot = 7; + } + +} + +FT_DECLARE(int8_t) ftdm_bitstream_get_bit(ftdm_bitstream_t *bsp) +{ + int8_t bit = -1; + + + if (bsp->byte_index >= bsp->datalen) { + goto done; + } + + if (bsp->ss) { + if (!bsp->ssv) { + bsp->ssv = 1; + return 0; + } else if (bsp->ssv == 2) { + bsp->byte_index++; + bsp->ssv = 0; + return 1; + } + } + + + + + bit = (bsp->data[bsp->byte_index] >> (bsp->bit_index)) & 1; + + if (bsp->bit_index == bsp->bot) { + bsp->bit_index = bsp->top; + if (bsp->ss) { + bsp->ssv = 2; + goto done; + } + + if (++bsp->byte_index > bsp->datalen) { + bit = -1; + goto done; + } + + } else { + bsp->bit_index = bsp->bit_index + bsp->endian; + } + + + done: + return bit; +} + +FT_DECLARE(void) print_hex_bytes(uint8_t *data, ftdm_size_t dlen, char *buf, ftdm_size_t blen) +{ + char *bp = buf; + uint8_t *byte = data; + uint32_t i, j = 0; + + if (blen < (dlen * 3) + 2) { + return; + } + + *bp++ = '['; + j++; + + for(i = 0; i < dlen; i++) { + snprintf(bp, blen-j, "%02x ", *byte++); + bp += 3; + j += 3; + } + + *--bp = ']'; + +} + +FT_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, ftdm_endian_t e, uint8_t ss) +{ + ftdm_bitstream_t bs; + int j = 0, c = 0; + int8_t bit; + uint32_t last; + + if (blen < (bl * 10) + 2) { + return; + } + + ftdm_bitstream_init(&bs, b, bl, e, ss); + last = bs.byte_index; + while((bit = ftdm_bitstream_get_bit(&bs)) > -1) { + buf[j++] = bit ? '1' : '0'; + if (bs.byte_index != last) { + buf[j++] = ' '; + last = bs.byte_index; + if (++c == 8) { + buf[j++] = '\n'; + c = 0; + } + } + } + +} + + + +FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_raw_write(ftdm_stream_handle_t *handle, uint8_t *data, ftdm_size_t datalen) +{ + ftdm_size_t need = handle->data_len + datalen; + + if (need >= handle->data_size) { + void *new_data; + need += handle->alloc_chunk; + + if (!(new_data = realloc(handle->data, need))) { + return FTDM_MEMERR; + } + + handle->data = new_data; + handle->data_size = need; + } + + memcpy((uint8_t *) (handle->data) + handle->data_len, data, datalen); + handle->data_len += datalen; + handle->end = (uint8_t *) (handle->data) + handle->data_len; + *(uint8_t *)handle->end = '\0'; + + return FTDM_SUCCESS; +} + +FT_DECLARE(int) ftdm_vasprintf(char **ret, const char *fmt, va_list ap) /* code from switch_apr.c */ +{ +#ifdef HAVE_VASPRINTF + return vasprintf(ret, fmt, ap); +#else + char *buf; + int len; + size_t buflen; + va_list ap2; + char *tmp = NULL; + +#ifdef _MSC_VER +#if _MSC_VER >= 1500 + /* hack for incorrect assumption in msvc header files for code analysis */ + __analysis_assume(tmp); +#endif + ap2 = ap; +#else + va_copy(ap2, ap); +#endif + + len = vsnprintf(tmp, 0, fmt, ap2); + + if (len > 0 && (buf = ftdm_malloc((buflen = (size_t) (len + 1)))) != NULL) { + len = vsnprintf(buf, buflen, fmt, ap); + *ret = buf; + } else { + *ret = NULL; + len = -1; + } + + va_end(ap2); + return len; +#endif +} + +FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_write(ftdm_stream_handle_t *handle, const char *fmt, ...) +{ + va_list ap; + char *buf = handle->data; + char *end = handle->end; + int ret = 0; + char *data = NULL; + + if (handle->data_len >= handle->data_size) { + return FTDM_FAIL; + } + + va_start(ap, fmt); + ret = ftdm_vasprintf(&data, fmt, ap); + va_end(ap); + + if (data) { + ftdm_size_t remaining = handle->data_size - handle->data_len; + ftdm_size_t need = strlen(data) + 1; + + if ((remaining < need) && handle->alloc_len) { + ftdm_size_t new_len; + void *new_data; + + new_len = handle->data_size + need + handle->alloc_chunk; + if ((new_data = realloc(handle->data, new_len))) { + handle->data_size = handle->alloc_len = new_len; + handle->data = new_data; + buf = handle->data; + remaining = handle->data_size - handle->data_len; + handle->end = (uint8_t *) (handle->data) + handle->data_len; + end = handle->end; + } else { + ftdm_log(FTDM_LOG_CRIT, "Memory Error!\n"); + ftdm_safe_free(data); + return FTDM_FAIL; + } + } + + if (remaining < need) { + ret = -1; + } else { + ret = 0; + snprintf(end, remaining, "%s", data); + handle->data_len = strlen(buf); + handle->end = (uint8_t *) (handle->data) + handle->data_len; + } + ftdm_safe_free(data); + } + + return ret ? FTDM_FAIL : FTDM_SUCCESS; +} + +FT_DECLARE(char *) ftdm_strdup(const char *str) +{ + ftdm_size_t len = strlen(str) + 1; + void *new = ftdm_malloc(len); + + if (!new) { + return NULL; + } + + return (char *)memcpy(new, str, len); +} + +FT_DECLARE(char *) ftdm_strndup(const char *str, ftdm_size_t inlen) +{ + char *new = NULL; + ftdm_size_t len = strlen(str) + 1; + if (len > (inlen+1)) { + len = inlen+1; + } + new = (char *)ftdm_malloc(len); + + if (!new) { + return NULL; + } + + memcpy(new, str, len-1); + new[len-1] = 0; + return new; +} + + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4: + */ diff --git a/libs/freetdm/src/zap_m3ua.c b/libs/freetdm/src/ftdm_m3ua.c similarity index 62% rename from libs/freetdm/src/zap_m3ua.c rename to libs/freetdm/src/ftdm_m3ua.c index bcc0e0559d..bb1f06b5e0 100644 --- a/libs/freetdm/src/zap_m3ua.c +++ b/libs/freetdm/src/ftdm_m3ua.c @@ -1,6 +1,6 @@ /* - * zap_m3ua.c - * openzap + * ftdm_m3ua.c + * freetdm * * Created by Shane Burrell on 4/3/08. * Copyright 2008 Shane Burrell. All rights reserved. @@ -38,9 +38,9 @@ */ -#include "openzap.h" +#include "freetdm.h" #include "m3ua_client.h" -#include "zap_m3ua.h" +#include "ftdm_m3ua.h" #define MAX_REQ_ID MAX_PENDING_CALLS typedef uint16_t m3ua_request_id_t; @@ -55,8 +55,8 @@ typedef enum { typedef struct { m3ua_request_status_t status; m3uac_event_t event; - zap_span_t *span; - zap_channel_t *zchan; + ftdm_span_t *span; + ftdm_channel_t *ftdmchan; } m3ua_request_t; @@ -80,7 +80,7 @@ struct m3ua_channel_profile { typedef struct m3ua_channel_profile m3ua_channel_profile_t; static struct { - zap_hash_t *profile_hash; + ftdm_hash_t *profile_hash; general_config_t general_config; } globals; @@ -91,24 +91,24 @@ struct m3ua_span_data { typedef struct m3ua_span_data m3ua_span_data_t; struct m3ua_chan_data { - zap_buffer_t *digit_buffer; - zap_mutex_t *digit_mutex; - zap_size_t dtmf_len; + ftdm_buffer_t *digit_buffer; + ftdm_mutex_t *digit_mutex; + ftdm_size_t dtmf_len; uint32_t flags; uint32_t hdlc_bytes; }; typedef struct m3ua_chan_data m3ua_chan_data_t; -static zap_mutex_t *request_mutex = NULL; -static zap_mutex_t *signal_mutex = NULL; +static ftdm_mutex_t *request_mutex = NULL; +static ftdm_mutex_t *signal_mutex = NULL; static uint8_t req_map[MAX_REQ_ID+1] = { 0 }; static void release_request_id(m3ua_request_id_t r) { - zap_mutex_lock(request_mutex); + ftdm_mutex_lock(request_mutex); req_map[r] = 0; - zap_mutex_unlock(request_mutex); + ftdm_mutex_unlock(request_mutex); } /*static m3ua_request_id_t next_request_id(void) @@ -117,7 +117,7 @@ static void release_request_id(m3ua_request_id_t r) int ok = 0; while(!ok) { - zap_mutex_lock(request_mutex); + ftdm_mutex_lock(request_mutex); for (r = 1; r <= MAX_REQ_ID; r++) { if (!req_map[r]) { ok = 1; @@ -125,153 +125,153 @@ static void release_request_id(m3ua_request_id_t r) break; } } - zap_mutex_unlock(request_mutex); + ftdm_mutex_unlock(request_mutex); if (!ok) { - zap_sleep(5); + ftdm_sleep(5); } } return r; } */ -static __inline__ void state_advance(zap_channel_t *zchan) +static __inline__ void state_advance(ftdm_channel_t *ftdmchan) { - m3ua_data_t *m3ua_data = zchan->span->signal_data; + m3ua_data_t *m3ua_data = ftdmchan->span->signal_data; m3uac_connection_t *mcon = &m3ua_data->mcon; - zap_sigmsg_t sig; - zap_status_t status; + ftdm_sigmsg_t sig; + ftdm_status_t status; - zap_log(ZAP_LOG_DEBUG, "%d:%d STATE [%s]\n", zchan->span_id, zchan->chan_id, zap_channel_state2str(zchan->state)); + ftdm_log(FTDM_LOG_DEBUG, "%d:%d STATE [%s]\n", ftdmchan->span_id, ftdmchan->chan_id, ftdm_channel_state2str(ftdmchan->state)); memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; - switch (zchan->state) { - case ZAP_CHANNEL_STATE_DOWN: + switch (ftdmchan->state) { + case FTDM_CHANNEL_STATE_DOWN: { - if (zchan->extra_id) { - release_request_id((m3ua_request_id_t)zchan->extra_id); - zchan->extra_id = 0; + if (ftdmchan->extra_id) { + release_request_id((m3ua_request_id_t)ftdmchan->extra_id); + ftdmchan->extra_id = 0; } - zap_channel_done(zchan); + ftdm_channel_done(ftdmchan); } break; - case ZAP_CHANNEL_STATE_PROGRESS_MEDIA: - case ZAP_CHANNEL_STATE_PROGRESS: + case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: + case FTDM_CHANNEL_STATE_PROGRESS: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_PROGRESS_MEDIA; - if ((status = m3ua_data->signal_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA; + if ((status = m3ua_data->signal_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { m3uac_exec_command(mcon, - zchan->physical_span_id-1, - zchan->physical_chan_id-1, + ftdmchan->physical_span_id-1, + ftdmchan->physical_chan_id-1, 0, SIGBOOST_EVENT_CALL_START_ACK, 0); } } break; - case ZAP_CHANNEL_STATE_RING: + case FTDM_CHANNEL_STATE_RING: { - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_START; - if ((status = m3ua_data->signal_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_START; + if ((status = m3ua_data->signal_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } } break; - case ZAP_CHANNEL_STATE_RESTART: + case FTDM_CHANNEL_STATE_RESTART: { - if (zchan->last_state != ZAP_CHANNEL_STATE_HANGUP && zchan->last_state != ZAP_CHANNEL_STATE_DOWN) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdmchan->last_state != FTDM_CHANNEL_STATE_HANGUP && ftdmchan->last_state != FTDM_CHANNEL_STATE_DOWN) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } } break; - case ZAP_CHANNEL_STATE_UP: + case FTDM_CHANNEL_STATE_UP: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_UP; - if ((status = m3ua_data->signal_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_UP; + if ((status = m3ua_data->signal_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { - if (!(zap_test_flag(zchan, ZAP_CHANNEL_PROGRESS) || zap_test_flag(zchan, ZAP_CHANNEL_MEDIA))) { + if (!(ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_MEDIA))) { m3uac_exec_command(mcon, - zchan->physical_span_id-1, - zchan->physical_chan_id-1, + ftdmchan->physical_span_id-1, + ftdmchan->physical_chan_id-1, 0, SIGBOOST_EVENT_CALL_START_ACK, 0); } m3uac_exec_command(mcon, - zchan->physical_span_id-1, - zchan->physical_chan_id-1, + ftdmchan->physical_span_id-1, + ftdmchan->physical_chan_id-1, 0, SIGBOOST_EVENT_CALL_ANSWERED, 0); } } break; - case ZAP_CHANNEL_STATE_DIALING: + case FTDM_CHANNEL_STATE_DIALING: { } break; - case ZAP_CHANNEL_STATE_HANGUP_COMPLETE: + case FTDM_CHANNEL_STATE_HANGUP_COMPLETE: { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; - case ZAP_CHANNEL_STATE_HANGUP: + case FTDM_CHANNEL_STATE_HANGUP: { - if (zap_test_flag(zchan, ZAP_CHANNEL_ANSWERED) || zap_test_flag(zchan, ZAP_CHANNEL_PROGRESS) || zap_test_flag(zchan, ZAP_CHANNEL_MEDIA)) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_ANSWERED) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_MEDIA)) { m3uac_exec_command(mcon, - zchan->physical_span_id-1, - zchan->physical_chan_id-1, + ftdmchan->physical_span_id-1, + ftdmchan->physical_chan_id-1, 0, SIGBOOST_EVENT_CALL_STOPPED, - zchan->caller_data.hangup_cause); + ftdmchan->caller_data.hangup_cause); } else { m3uac_exec_command(mcon, - zchan->physical_span_id-1, - zchan->physical_chan_id-1, + ftdmchan->physical_span_id-1, + ftdmchan->physical_chan_id-1, 0, SIGBOOST_EVENT_CALL_START_NACK, - zchan->caller_data.hangup_cause); + ftdmchan->caller_data.hangup_cause); } } break; - case ZAP_CHANNEL_STATE_CANCEL: + case FTDM_CHANNEL_STATE_CANCEL: { - sig.event_id = ZAP_SIGEVENT_STOP; + sig.event_id = FTDM_SIGEVENT_STOP; status = m3ua_data->signal_cb(&sig); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); m3uac_exec_command(mcon, - zchan->physical_span_id-1, - zchan->physical_chan_id-1, + ftdmchan->physical_span_id-1, + ftdmchan->physical_chan_id-1, 0, SIGBOOST_EVENT_CALL_START_NACK_ACK, 0); } break; - case ZAP_CHANNEL_STATE_TERMINATING: + case FTDM_CHANNEL_STATE_TERMINATING: { - sig.event_id = ZAP_SIGEVENT_STOP; + sig.event_id = FTDM_SIGEVENT_STOP; status = m3ua_data->signal_cb(&sig); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); m3uac_exec_command(mcon, - zchan->physical_span_id-1, - zchan->physical_chan_id-1, + ftdmchan->physical_span_id-1, + ftdmchan->physical_chan_id-1, 0, SIGBOOST_EVENT_CALL_STOPPED_ACK, 0); @@ -283,36 +283,36 @@ static __inline__ void state_advance(zap_channel_t *zchan) } -static __inline__ void check_state(zap_span_t *span) +static __inline__ void check_state(ftdm_span_t *span) { - if (zap_test_flag(span, ZAP_SPAN_STATE_CHANGE)) { + if (ftdm_test_flag(span, FTDM_SPAN_STATE_CHANGE)) { uint32_t j; - zap_clear_flag_locked(span, ZAP_SPAN_STATE_CHANGE); + ftdm_clear_flag_locked(span, FTDM_SPAN_STATE_CHANGE); for(j = 1; j <= span->chan_count; j++) { - if (zap_test_flag((&span->channels[j]), ZAP_CHANNEL_STATE_CHANGE)) { - zap_clear_flag_locked((&span->channels[j]), ZAP_CHANNEL_STATE_CHANGE); + if (ftdm_test_flag((&span->channels[j]), FTDM_CHANNEL_STATE_CHANGE)) { + ftdm_clear_flag_locked((&span->channels[j]), FTDM_CHANNEL_STATE_CHANGE); state_advance(&span->channels[j]); - zap_channel_complete_state(&span->channels[j]); + ftdm_channel_complete_state(&span->channels[j]); } } } } -static int parse_ss7_event(zap_span_t *span, m3uac_connection_t *mcon, m3uac_event_t *event) +static int parse_ss7_event(ftdm_span_t *span, m3uac_connection_t *mcon, m3uac_event_t *event) { - zap_mutex_lock(signal_mutex); + ftdm_mutex_lock(signal_mutex); - if (!zap_running()) { - zap_log(ZAP_LOG_WARNING, "System is shutting down.\n"); + if (!ftdm_running()) { + ftdm_log(FTDM_LOG_WARNING, "System is shutting down.\n"); goto end; } - if (zap_test_flag(span, ZAP_SPAN_SUSPENDED) && + if (ftdm_test_flag(span, FTDM_SPAN_SUSPENDED) && event->event_id != SIGBOOST_EVENT_SYSTEM_RESTART_ACK && event->event_id != SIGBOOST_EVENT_HEARTBEAT) { - zap_log(ZAP_LOG_WARNING, + ftdm_log(FTDM_LOG_WARNING, "INVALID EVENT: %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i Cd=[%s] Ci=[%s]\n", m3uac_event_id_name(event->event_id), event->event_id, @@ -329,7 +329,7 @@ static int parse_ss7_event(zap_span_t *span, m3uac_connection_t *mcon, m3uac_eve } - zap_log(ZAP_LOG_DEBUG, + ftdm_log(FTDM_LOG_DEBUG, "RX EVENT: %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i Cd=[%s] Ci=[%s]\n", m3uac_event_id_name(event->event_id), event->event_id, @@ -381,13 +381,13 @@ static int parse_ss7_event(zap_span_t *span, m3uac_connection_t *mcon, m3uac_eve //handle_gap_abate(event); break; default: - zap_log(ZAP_LOG_WARNING, "No handler implemented for [%s]\n", m3uac_event_id_name(event->event_id)); + ftdm_log(FTDM_LOG_WARNING, "No handler implemented for [%s]\n", m3uac_event_id_name(event->event_id)); break; } end: - zap_mutex_unlock(signal_mutex); + ftdm_mutex_unlock(signal_mutex); return 0; } @@ -399,14 +399,14 @@ static ZIO_CONFIGURE_FUNCTION(m3ua_configure) int ok = 1; if (!(profile = (m3ua_channel_profile_t *) hashtable_search(globals.profile_hash, (char *)category))) { - profile = zap_malloc(sizeof(*profile)); + profile = ftdm_malloc(sizeof(*profile)); memset(profile, 0, sizeof(*profile)); - zap_set_string(profile->name, category); + ftdm_set_string(profile->name, category); hashtable_insert(globals.profile_hash, (void *)profile->name, profile); - zap_log(ZAP_LOG_INFO, "creating profile [%s]\n", category); + ftdm_log(FTDM_LOG_INFO, "creating profile [%s]\n", category); } -// zap_set_string(m3ua_data->mcon. cfg.local_ip, local_ip); +// ftdm_set_string(m3ua_data->mcon. cfg.local_ip, local_ip); if (!strcasecmp(var, "local_sctp_port")) { profile->local_port = 30000 ; profile->remote_port = 30000; @@ -416,30 +416,30 @@ static ZIO_CONFIGURE_FUNCTION(m3ua_configure) if (ok) { - zap_log(ZAP_LOG_INFO, "setting param [%s]=[%s] for profile [%s]\n", var, val, category); + ftdm_log(FTDM_LOG_INFO, "setting param [%s]=[%s] for profile [%s]\n", var, val, category); } else { - zap_log(ZAP_LOG_ERROR, "unknown param [%s]\n", var); + ftdm_log(FTDM_LOG_ERROR, "unknown param [%s]\n", var); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } static ZIO_CONFIGURE_SPAN_FUNCTION(m3ua_configure_span) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_OPEN_FUNCTION(m3ua_open) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_CLOSE_FUNCTION(m3ua_close) { - return ZAP_FAIL; + return FTDM_FAIL; } /*static ZIO_SET_INTERVAL_FUNCTION(m3ua_set_interval) @@ -451,34 +451,34 @@ static ZIO_CLOSE_FUNCTION(m3ua_close) static ZIO_WAIT_FUNCTION(m3ua_wait) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_READ_FUNCTION(m3ua_read) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_WRITE_FUNCTION(m3ua_write) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_COMMAND_FUNCTION(m3ua_command) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_SPAN_POLL_EVENT_FUNCTION(m3ua_poll_event) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_SPAN_NEXT_EVENT_FUNCTION(m3ua_next_event) { - return ZAP_FAIL; + return FTDM_FAIL; } @@ -487,18 +487,18 @@ static ZIO_SPAN_DESTROY_FUNCTION(m3ua_span_destroy) m3ua_span_data_t *span_data = (m3ua_span_data_t *) span->mod_data; if (span_data) { - zap_safe_free(span_data); + ftdm_safe_free(span_data); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } static ZIO_CHANNEL_DESTROY_FUNCTION(m3ua_channel_destroy) { - m3ua_chan_data_t *chan_data = (m3ua_chan_data_t *) zchan->mod_data; - m3ua_span_data_t *span_data = (m3ua_span_data_t *) zchan->span->mod_data; + m3ua_chan_data_t *chan_data = (m3ua_chan_data_t *) ftdmchan->mod_data; + m3ua_span_data_t *span_data = (m3ua_span_data_t *) ftdmchan->span->mod_data; if (!chan_data) { - return ZAP_FAIL; + return FTDM_FAIL; } @@ -506,30 +506,30 @@ static ZIO_CHANNEL_DESTROY_FUNCTION(m3ua_channel_destroy) - zap_mutex_destroy(&chan_data->digit_mutex); - zap_buffer_destroy(&chan_data->digit_buffer); + ftdm_mutex_destroy(&chan_data->digit_mutex); + ftdm_buffer_destroy(&chan_data->digit_buffer); - zap_safe_free(chan_data); + ftdm_safe_free(chan_data); if (span_data) { - zap_safe_free(span_data); + ftdm_safe_free(span_data); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } static ZIO_GET_ALARMS_FUNCTION(m3ua_get_alarms) { - return ZAP_FAIL; + return FTDM_FAIL; } -static zap_io_interface_t m3ua_interface; +static ftdm_io_interface_t m3ua_interface; -zap_status_t m3ua_init(zap_io_interface_t **zint) +ftdm_status_t m3ua_init(ftdm_io_interface_t **zint) { assert(zint != NULL); memset(&m3ua_interface, 0, sizeof(m3ua_interface)); @@ -550,18 +550,18 @@ zap_status_t m3ua_init(zap_io_interface_t **zint) m3ua_interface.get_alarms = m3ua_get_alarms; *zint = &m3ua_interface; - return ZAP_FAIL; + return FTDM_FAIL; } -zap_status_t m3ua_destroy(void) +ftdm_status_t m3ua_destroy(void) { - return ZAP_FAIL; + return FTDM_FAIL; } -static void *m3ua_run(zap_thread_t *me, void *obj) +static void *m3ua_run(ftdm_thread_t *me, void *obj) { - zap_span_t *span = (zap_span_t *) obj; + ftdm_span_t *span = (ftdm_span_t *) obj; m3ua_data_t *m3ua_data = span->signal_data; m3uac_connection_t *mcon, *pcon; uint32_t ms = 10, too_long = 60000; @@ -574,7 +574,7 @@ static void *m3ua_run(zap_thread_t *me, void *obj) m3ua_data->mcon.cfg.local_port, m3ua_data->mcon.cfg.remote_ip, m3ua_data->mcon.cfg.remote_port) < 0) { - zap_log(ZAP_LOG_DEBUG, "Error: Opening MCON Socket [%d] %s\n", m3ua_data->mcon.socket, strerror(errno)); + ftdm_log(FTDM_LOG_DEBUG, "Error: Opening MCON Socket [%d] %s\n", m3ua_data->mcon.socket, strerror(errno)); goto end; } @@ -583,7 +583,7 @@ static void *m3ua_run(zap_thread_t *me, void *obj) ++m3ua_data->pcon.cfg.local_port, m3ua_data->pcon.cfg.remote_ip, m3ua_data->pcon.cfg.remote_port) < 0) { - zap_log(ZAP_LOG_DEBUG, "Error: Opening PCON Socket [%d] %s\n", m3ua_data->pcon.socket, strerror(errno)); + ftdm_log(FTDM_LOG_DEBUG, "Error: Opening PCON Socket [%d] %s\n", m3ua_data->pcon.socket, strerror(errno)); goto end; } @@ -601,13 +601,13 @@ static void *m3ua_run(zap_thread_t *me, void *obj) SIGBOOST_EVENT_SYSTEM_RESTART, 0); - while (zap_test_flag(m3ua_data, ZAP_M3UA_RUNNING)) { + while (ftdm_test_flag(m3ua_data, FTDM_M3UA_RUNNING)) { fd_set rfds, efds; struct timeval tv = { 0, ms * 1000 }; int max, activity, i = 0; m3uac_event_t *event = NULL; - if (!zap_running()) { + if (!ftdm_running()) { m3uac_exec_command(mcon, 0, 0, @@ -651,11 +651,11 @@ static void *m3ua_run(zap_thread_t *me, void *obj) check_state(span); mcon->hb_elapsed += ms; - if (mcon->hb_elapsed >= too_long && (mcon->up || !zap_test_flag(span, ZAP_SPAN_SUSPENDED))) { - zap_set_state_all(span, ZAP_CHANNEL_STATE_RESTART); - zap_set_flag_locked(span, ZAP_SPAN_SUSPENDED); + if (mcon->hb_elapsed >= too_long && (mcon->up || !ftdm_test_flag(span, FTDM_SPAN_SUSPENDED))) { + ftdm_set_state_all(span, FTDM_CHANNEL_STATE_RESTART); + ftdm_set_flag_locked(span, FTDM_SPAN_SUSPENDED); mcon->up = 0; - zap_log(ZAP_LOG_CRIT, "Lost Heartbeat!\n"); + ftdm_log(FTDM_LOG_CRIT, "Lost Heartbeat!\n"); } } @@ -663,23 +663,23 @@ static void *m3ua_run(zap_thread_t *me, void *obj) goto end; error: - zap_log(ZAP_LOG_CRIT, "Socket Error!\n"); + ftdm_log(FTDM_LOG_CRIT, "Socket Error!\n"); end: m3uac_connection_close(&m3ua_data->mcon); m3uac_connection_close(&m3ua_data->pcon); - zap_clear_flag(m3ua_data, ZAP_M3UA_RUNNING); + ftdm_clear_flag(m3ua_data, FTDM_M3UA_RUNNING); - zap_log(ZAP_LOG_DEBUG, "M3UA thread ended.\n"); + ftdm_log(FTDM_LOG_DEBUG, "M3UA thread ended.\n"); return NULL; } -zap_status_t m3ua_start(zap_span_t *span) +ftdm_status_t m3ua_start(ftdm_span_t *span) { m3ua_data_t *m3ua_data = span->signal_data; - zap_set_flag(m3ua_data, ZAP_M3UA_RUNNING); - return zap_thread_create_detached(m3ua_run, span); + ftdm_set_flag(m3ua_data, FTDM_M3UA_RUNNING); + return ftdm_thread_create_detached(m3ua_run, span); } /* For Emacs: diff --git a/libs/freetdm/src/zap_queue.c b/libs/freetdm/src/ftdm_queue.c similarity index 50% rename from libs/freetdm/src/zap_queue.c rename to libs/freetdm/src/ftdm_queue.c index a714af340c..92ea75c57a 100644 --- a/libs/freetdm/src/zap_queue.c +++ b/libs/freetdm/src/ftdm_queue.c @@ -32,34 +32,34 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "openzap.h" +#include "freetdm.h" -static zap_status_t zap_std_queue_create(zap_queue_t **outqueue, zap_size_t capacity); -static zap_status_t zap_std_queue_enqueue(zap_queue_t *queue, void *obj); -static void *zap_std_queue_dequeue(zap_queue_t *queue); -static zap_status_t zap_std_queue_wait(zap_queue_t *queue, int ms); -static zap_status_t zap_std_queue_destroy(zap_queue_t **inqueue); +static ftdm_status_t ftdm_std_queue_create(ftdm_queue_t **outqueue, ftdm_size_t capacity); +static ftdm_status_t ftdm_std_queue_enqueue(ftdm_queue_t *queue, void *obj); +static void *ftdm_std_queue_dequeue(ftdm_queue_t *queue); +static ftdm_status_t ftdm_std_queue_wait(ftdm_queue_t *queue, int ms); +static ftdm_status_t ftdm_std_queue_destroy(ftdm_queue_t **inqueue); -struct zap_queue { - zap_mutex_t *mutex; - zap_condition_t *condition; - zap_size_t capacity; - zap_size_t size; +struct ftdm_queue { + ftdm_mutex_t *mutex; + ftdm_condition_t *condition; + ftdm_size_t capacity; + ftdm_size_t size; unsigned rindex; unsigned windex; void **elements; }; -OZ_DECLARE_DATA zap_queue_handler_t g_zap_queue_handler = +FT_DECLARE_DATA ftdm_queue_handler_t g_ftdm_queue_handler = { - /*.create = */ zap_std_queue_create, - /*.enqueue = */ zap_std_queue_enqueue, - /*.dequeue = */ zap_std_queue_dequeue, - /*.wait = */ zap_std_queue_wait, - /*.destroy = */ zap_std_queue_destroy + /*.create = */ ftdm_std_queue_create, + /*.enqueue = */ ftdm_std_queue_enqueue, + /*.dequeue = */ ftdm_std_queue_dequeue, + /*.wait = */ ftdm_std_queue_wait, + /*.destroy = */ ftdm_std_queue_destroy }; -OZ_DECLARE(zap_status_t) zap_global_set_queue_handler(zap_queue_handler_t *handler) +FT_DECLARE(ftdm_status_t) ftdm_global_set_queue_handler(ftdm_queue_handler_t *handler) { if (!handler || !handler->create || @@ -67,62 +67,62 @@ OZ_DECLARE(zap_status_t) zap_global_set_queue_handler(zap_queue_handler_t *handl !handler->dequeue || !handler->wait || !handler->destroy) { - return ZAP_FAIL; + return FTDM_FAIL; } - memcpy(&g_zap_queue_handler, handler, sizeof(*handler)); - return ZAP_SUCCESS; + memcpy(&g_ftdm_queue_handler, handler, sizeof(*handler)); + return FTDM_SUCCESS; } -static zap_status_t zap_std_queue_create(zap_queue_t **outqueue, zap_size_t capacity) +static ftdm_status_t ftdm_std_queue_create(ftdm_queue_t **outqueue, ftdm_size_t capacity) { - zap_queue_t *queue = NULL; - zap_assert_return(outqueue, ZAP_FAIL, "Queue double pointer is null\n"); - zap_assert_return(capacity > 0, ZAP_FAIL, "Queue capacity is not bigger than 0\n"); + ftdm_queue_t *queue = NULL; + ftdm_assert_return(outqueue, FTDM_FAIL, "Queue double pointer is null\n"); + ftdm_assert_return(capacity > 0, FTDM_FAIL, "Queue capacity is not bigger than 0\n"); *outqueue = NULL; - queue = zap_calloc(1, sizeof(*queue)); + queue = ftdm_calloc(1, sizeof(*queue)); if (!queue) { - return ZAP_FAIL; + return FTDM_FAIL; } - queue->elements = zap_calloc(1, (sizeof(void*)*capacity)); + queue->elements = ftdm_calloc(1, (sizeof(void*)*capacity)); if (!queue->elements) { goto failed; } queue->capacity = capacity; - if (zap_mutex_create(&queue->mutex) != ZAP_SUCCESS) { + if (ftdm_mutex_create(&queue->mutex) != FTDM_SUCCESS) { goto failed; } - if (zap_condition_create(&queue->condition, queue->mutex) != ZAP_SUCCESS) { + if (ftdm_condition_create(&queue->condition, queue->mutex) != FTDM_SUCCESS) { goto failed; } *outqueue = queue; - return ZAP_SUCCESS; + return FTDM_SUCCESS; failed: if (queue) { if (queue->condition) { - zap_condition_destroy(&queue->condition); + ftdm_condition_destroy(&queue->condition); } if (queue->mutex) { - zap_mutex_destroy(&queue->mutex); + ftdm_mutex_destroy(&queue->mutex); } - zap_safe_free(queue->elements); - zap_safe_free(queue); + ftdm_safe_free(queue->elements); + ftdm_safe_free(queue); } - return ZAP_FAIL; + return FTDM_FAIL; } -static zap_status_t zap_std_queue_enqueue(zap_queue_t *queue, void *obj) +static ftdm_status_t ftdm_std_queue_enqueue(ftdm_queue_t *queue, void *obj) { - zap_status_t status = ZAP_FAIL; + ftdm_status_t status = FTDM_FAIL; - zap_assert_return(queue != NULL, ZAP_FAIL, "Queue is null!"); + ftdm_assert_return(queue != NULL, FTDM_FAIL, "Queue is null!"); - zap_mutex_lock(queue->mutex); + ftdm_mutex_lock(queue->mutex); if (queue->windex == queue->capacity) { /* try to see if we can wrap around */ @@ -130,31 +130,31 @@ static zap_status_t zap_std_queue_enqueue(zap_queue_t *queue, void *obj) } if (queue->size != 0 && queue->windex == queue->rindex) { - zap_log(ZAP_LOG_ERROR, "Failed to enqueue obj %p in queue %p, no more room! windex == rindex == %d!\n", obj, queue, queue->windex); + ftdm_log(FTDM_LOG_ERROR, "Failed to enqueue obj %p in queue %p, no more room! windex == rindex == %d!\n", obj, queue, queue->windex); goto done; } queue->elements[queue->windex++] = obj; queue->size++; - status = ZAP_SUCCESS; + status = FTDM_SUCCESS; /* wake up queue reader */ - zap_condition_signal(queue->condition); + ftdm_condition_signal(queue->condition); done: - zap_mutex_unlock(queue->mutex); + ftdm_mutex_unlock(queue->mutex); return status; } -static void *zap_std_queue_dequeue(zap_queue_t *queue) +static void *ftdm_std_queue_dequeue(ftdm_queue_t *queue) { void *obj = NULL; - zap_assert_return(queue != NULL, NULL, "Queue is null!"); + ftdm_assert_return(queue != NULL, NULL, "Queue is null!"); - zap_mutex_lock(queue->mutex); + ftdm_mutex_lock(queue->mutex); if (queue->size == 0) { goto done; @@ -169,46 +169,46 @@ static void *zap_std_queue_dequeue(zap_queue_t *queue) done: - zap_mutex_unlock(queue->mutex); + ftdm_mutex_unlock(queue->mutex); return obj; } -static zap_status_t zap_std_queue_wait(zap_queue_t *queue, int ms) +static ftdm_status_t ftdm_std_queue_wait(ftdm_queue_t *queue, int ms) { - zap_status_t ret; - zap_assert_return(queue != NULL, ZAP_FAIL, "Queue is null!"); + ftdm_status_t ret; + ftdm_assert_return(queue != NULL, FTDM_FAIL, "Queue is null!"); - zap_mutex_lock(queue->mutex); + ftdm_mutex_lock(queue->mutex); /* if there is elements in the queue, no need to wait */ if (queue->size != 0) { - zap_mutex_unlock(queue->mutex); - return ZAP_SUCCESS; + ftdm_mutex_unlock(queue->mutex); + return FTDM_SUCCESS; } /* no elements on the queue, wait for someone to write an element */ - ret = zap_condition_wait(queue->condition, ms); + ret = ftdm_condition_wait(queue->condition, ms); /* got an element or timeout, bail out */ - zap_mutex_unlock(queue->mutex); + ftdm_mutex_unlock(queue->mutex); return ret; } -static zap_status_t zap_std_queue_destroy(zap_queue_t **inqueue) +static ftdm_status_t ftdm_std_queue_destroy(ftdm_queue_t **inqueue) { - zap_queue_t *queue = NULL; - zap_assert_return(inqueue != NULL, ZAP_FAIL, "Queue is null!"); - zap_assert_return(*inqueue != NULL, ZAP_FAIL, "Queue is null!"); + ftdm_queue_t *queue = NULL; + ftdm_assert_return(inqueue != NULL, FTDM_FAIL, "Queue is null!"); + ftdm_assert_return(*inqueue != NULL, FTDM_FAIL, "Queue is null!"); queue = *inqueue; - zap_condition_destroy(&queue->condition); - zap_mutex_destroy(&queue->mutex); - zap_safe_free(queue->elements); - zap_safe_free(queue); + ftdm_condition_destroy(&queue->condition); + ftdm_mutex_destroy(&queue->mutex); + ftdm_safe_free(queue->elements); + ftdm_safe_free(queue); *inqueue = NULL; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /* For Emacs: diff --git a/libs/freetdm/src/zap_threadmutex.c b/libs/freetdm/src/ftdm_threadmutex.c similarity index 59% rename from libs/freetdm/src/zap_threadmutex.c rename to libs/freetdm/src/ftdm_threadmutex.c index bae288c561..7446896dcd 100644 --- a/libs/freetdm/src/zap_threadmutex.c +++ b/libs/freetdm/src/ftdm_threadmutex.c @@ -26,84 +26,84 @@ #define _WIN32_WINNT 0x0400 #endif -#include "openzap.h" -#include "zap_threadmutex.h" +#include "freetdm.h" +#include "ftdm_threadmutex.h" #ifdef WIN32 #include -#define ZAP_THREAD_CALLING_CONVENTION __stdcall +#define FTDM_THREAD_CALLING_CONVENTION __stdcall -struct zap_mutex { +struct ftdm_mutex { CRITICAL_SECTION mutex; }; #else #include -#define ZAP_THREAD_CALLING_CONVENTION +#define FTDM_THREAD_CALLING_CONVENTION -struct zap_mutex { +struct ftdm_mutex { pthread_mutex_t mutex; }; #endif -struct zap_condition { +struct ftdm_condition { #ifdef WIN32 HANDLE condition; #else pthread_cond_t condition; #endif - zap_mutex_t *mutex; + ftdm_mutex_t *mutex; }; -struct zap_thread { +struct ftdm_thread { #ifdef WIN32 void *handle; #else pthread_t handle; #endif void *private_data; - zap_thread_function_t function; - zap_size_t stack_size; + ftdm_thread_function_t function; + ftdm_size_t stack_size; #ifndef WIN32 pthread_attr_t attribute; #endif }; -zap_size_t thread_default_stacksize = 0; +ftdm_size_t thread_default_stacksize = 0; -OZ_DECLARE(void) zap_thread_override_default_stacksize(zap_size_t size) +FT_DECLARE(void) ftdm_thread_override_default_stacksize(ftdm_size_t size) { thread_default_stacksize = size; } -static void * ZAP_THREAD_CALLING_CONVENTION thread_launch(void *args) +static void * FTDM_THREAD_CALLING_CONVENTION thread_launch(void *args) { void *exit_val; - zap_thread_t *thread = (zap_thread_t *)args; + ftdm_thread_t *thread = (ftdm_thread_t *)args; exit_val = thread->function(thread, thread->private_data); #ifndef WIN32 pthread_attr_destroy(&thread->attribute); #endif - zap_safe_free(thread); + ftdm_safe_free(thread); return exit_val; } -OZ_DECLARE(zap_status_t) zap_thread_create_detached(zap_thread_function_t func, void *data) +FT_DECLARE(ftdm_status_t) ftdm_thread_create_detached(ftdm_thread_function_t func, void *data) { - return zap_thread_create_detached_ex(func, data, thread_default_stacksize); + return ftdm_thread_create_detached_ex(func, data, thread_default_stacksize); } -OZ_DECLARE(zap_status_t) zap_thread_create_detached_ex(zap_thread_function_t func, void *data, zap_size_t stack_size) +FT_DECLARE(ftdm_status_t) ftdm_thread_create_detached_ex(ftdm_thread_function_t func, void *data, ftdm_size_t stack_size) { - zap_thread_t *thread = NULL; - zap_status_t status = ZAP_FAIL; + ftdm_thread_t *thread = NULL; + ftdm_status_t status = FTDM_FAIL; - if (!func || !(thread = (zap_thread_t *)zap_malloc(sizeof(zap_thread_t)))) { + if (!func || !(thread = (ftdm_thread_t *)ftdm_malloc(sizeof(ftdm_thread_t)))) { goto done; } @@ -118,7 +118,7 @@ OZ_DECLARE(zap_status_t) zap_thread_create_detached_ex(zap_thread_function_t fun } CloseHandle(thread->handle); - status = ZAP_SUCCESS; + status = FTDM_SUCCESS; goto done; #else @@ -130,7 +130,7 @@ OZ_DECLARE(zap_status_t) zap_thread_create_detached_ex(zap_thread_function_t fun if (pthread_create(&thread->handle, &thread->attribute, thread_launch, thread) != 0) goto failpthread; - status = ZAP_SUCCESS; + status = FTDM_SUCCESS; goto done; failpthread: pthread_attr_destroy(&thread->attribute); @@ -138,22 +138,22 @@ OZ_DECLARE(zap_status_t) zap_thread_create_detached_ex(zap_thread_function_t fun fail: if (thread) { - zap_safe_free(thread); + ftdm_safe_free(thread); } done: return status; } -OZ_DECLARE(zap_status_t) zap_mutex_create(zap_mutex_t **mutex) +FT_DECLARE(ftdm_status_t) ftdm_mutex_create(ftdm_mutex_t **mutex) { - zap_status_t status = ZAP_FAIL; + ftdm_status_t status = FTDM_FAIL; #ifndef WIN32 pthread_mutexattr_t attr; #endif - zap_mutex_t *check = NULL; + ftdm_mutex_t *check = NULL; - check = (zap_mutex_t *)zap_malloc(sizeof(**mutex)); + check = (ftdm_mutex_t *)ftdm_malloc(sizeof(**mutex)); if (!check) goto done; #ifdef WIN32 @@ -177,77 +177,77 @@ OZ_DECLARE(zap_status_t) zap_mutex_create(zap_mutex_t **mutex) success: #endif *mutex = check; - status = ZAP_SUCCESS; + status = FTDM_SUCCESS; done: return status; } -OZ_DECLARE(zap_status_t) zap_mutex_destroy(zap_mutex_t **mutex) +FT_DECLARE(ftdm_status_t) ftdm_mutex_destroy(ftdm_mutex_t **mutex) { - zap_mutex_t *mp = *mutex; + ftdm_mutex_t *mp = *mutex; *mutex = NULL; if (!mp) { - return ZAP_FAIL; + return FTDM_FAIL; } #ifdef WIN32 DeleteCriticalSection(&mp->mutex); #else if (pthread_mutex_destroy(&mp->mutex)) - return ZAP_FAIL; + return FTDM_FAIL; #endif - zap_safe_free(mp); - return ZAP_SUCCESS; + ftdm_safe_free(mp); + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) _zap_mutex_lock(zap_mutex_t *mutex) +FT_DECLARE(ftdm_status_t) _ftdm_mutex_lock(ftdm_mutex_t *mutex) { #ifdef WIN32 EnterCriticalSection(&mutex->mutex); #else int err; if ((err = pthread_mutex_lock(&mutex->mutex))) { - zap_log(ZAP_LOG_ERROR, "Failed to lock mutex %d:%s\n", err, strerror(err)); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Failed to lock mutex %d:%s\n", err, strerror(err)); + return FTDM_FAIL; } #endif - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) _zap_mutex_trylock(zap_mutex_t *mutex) +FT_DECLARE(ftdm_status_t) _ftdm_mutex_trylock(ftdm_mutex_t *mutex) { #ifdef WIN32 if (!TryEnterCriticalSection(&mutex->mutex)) - return ZAP_FAIL; + return FTDM_FAIL; #else if (pthread_mutex_trylock(&mutex->mutex)) - return ZAP_FAIL; + return FTDM_FAIL; #endif - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) _zap_mutex_unlock(zap_mutex_t *mutex) +FT_DECLARE(ftdm_status_t) _ftdm_mutex_unlock(ftdm_mutex_t *mutex) { #ifdef WIN32 LeaveCriticalSection(&mutex->mutex); #else if (pthread_mutex_unlock(&mutex->mutex)) - return ZAP_FAIL; + return FTDM_FAIL; #endif - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) zap_condition_create(zap_condition_t **incondition, zap_mutex_t *mutex) +FT_DECLARE(ftdm_status_t) ftdm_condition_create(ftdm_condition_t **incondition, ftdm_mutex_t *mutex) { - zap_condition_t *condition = NULL; + ftdm_condition_t *condition = NULL; - zap_assert_return(incondition != NULL, ZAP_FAIL, "Condition double pointer is null!\n"); - zap_assert_return(mutex != NULL, ZAP_FAIL, "Mutex for condition must not be null!\n"); + ftdm_assert_return(incondition != NULL, FTDM_FAIL, "Condition double pointer is null!\n"); + ftdm_assert_return(mutex != NULL, FTDM_FAIL, "Mutex for condition must not be null!\n"); - condition = zap_calloc(1, sizeof(*condition)); + condition = ftdm_calloc(1, sizeof(*condition)); if (!condition) { - return ZAP_FAIL; + return FTDM_FAIL; } condition->mutex = mutex; @@ -263,38 +263,38 @@ OZ_DECLARE(zap_status_t) zap_condition_create(zap_condition_t **incondition, zap #endif *incondition = condition; - return ZAP_SUCCESS; + return FTDM_SUCCESS; failed: if (condition) { - zap_safe_free(condition); + ftdm_safe_free(condition); } - return ZAP_FAIL; + return FTDM_FAIL; } #define ONE_BILLION 1000000000 -OZ_DECLARE(zap_status_t) zap_condition_wait(zap_condition_t *condition, int ms) +FT_DECLARE(ftdm_status_t) ftdm_condition_wait(ftdm_condition_t *condition, int ms) { #ifdef WIN32 DWORD res = 0; #endif - zap_assert_return(condition != NULL, ZAP_FAIL, "Condition is null!\n"); + ftdm_assert_return(condition != NULL, FTDM_FAIL, "Condition is null!\n"); #ifdef WIN32 - zap_mutex_unlock(condition->mutex); + ftdm_mutex_unlock(condition->mutex); res = WaitForSingleObject(condition->condition, ms > 0 ? ms : INFINITE); - zap_mutex_lock(condition->mutex); + ftdm_mutex_lock(condition->mutex); switch (res) { case WAIT_ABANDONED: case WAIT_TIMEOUT: - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; case WAIT_FAILED: - return ZAP_FAIL; + return FTDM_FAIL; case WAIT_OBJECT_0: - return ZAP_SUCCESS; + return FTDM_SUCCESS; default: - zap_log(ZAP_LOG_ERROR, "Error waiting for openzap condition event (WaitForSingleObject returned %d)\n", res); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Error waiting for freetdm condition event (WaitForSingleObject returned %d)\n", res); + return FTDM_FAIL; } #else int res = 0; @@ -314,48 +314,48 @@ OZ_DECLARE(zap_status_t) zap_condition_wait(zap_condition_t *condition, int ms) } if (res != 0) { if (res == ETIMEDOUT) { - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; } - zap_log(ZAP_LOG_CRIT,"pthread_cond_timedwait failed (%d)\n", res); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_CRIT,"pthread_cond_timedwait failed (%d)\n", res); + return FTDM_FAIL; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; #endif } -OZ_DECLARE(zap_status_t) zap_condition_signal(zap_condition_t *condition) +FT_DECLARE(ftdm_status_t) ftdm_condition_signal(ftdm_condition_t *condition) { - zap_assert_return(condition != NULL, ZAP_FAIL, "Condition is null!\n"); + ftdm_assert_return(condition != NULL, FTDM_FAIL, "Condition is null!\n"); #ifdef WIN32 if (!SetEvent(condition->condition)) { - return ZAP_FAIL; + return FTDM_FAIL; } #else int err; if ((err = pthread_cond_signal(&condition->condition))) { - zap_log(ZAP_LOG_ERROR, "Failed to signal condition %d:%s\n", err, strerror(err)); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Failed to signal condition %d:%s\n", err, strerror(err)); + return FTDM_FAIL; } #endif - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -OZ_DECLARE(zap_status_t) zap_condition_destroy(zap_condition_t **incondition) +FT_DECLARE(ftdm_status_t) ftdm_condition_destroy(ftdm_condition_t **incondition) { - zap_condition_t *condition = NULL; - zap_assert_return(incondition != NULL, ZAP_FAIL, "Condition null when destroying!\n"); + ftdm_condition_t *condition = NULL; + ftdm_assert_return(incondition != NULL, FTDM_FAIL, "Condition null when destroying!\n"); condition = *incondition; #ifdef WIN32 CloseHandle(condition->condition); #else if (pthread_cond_destroy(&condition->condition)) { - return ZAP_FAIL; + return FTDM_FAIL; } #endif - zap_safe_free(condition); + ftdm_safe_free(condition); *incondition = NULL; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /* For Emacs: diff --git a/libs/freetdm/src/ozmod/ozmod_analog/zap_analog.h b/libs/freetdm/src/ftmod/ftmod_analog/ftdm_analog.h similarity index 84% rename from libs/freetdm/src/ozmod/ozmod_analog/zap_analog.h rename to libs/freetdm/src/ftmod/ftmod_analog/ftdm_analog.h index 563285eb2c..8e1fa7a721 100644 --- a/libs/freetdm/src/ozmod/ozmod_analog/zap_analog.h +++ b/libs/freetdm/src/ftmod/ftmod_analog/ftdm_analog.h @@ -31,30 +31,30 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ZAP_ANALOG_H -#define ZAP_ANALOG_H -#include "openzap.h" +#ifndef FTDM_ANALOG_H +#define FTDM_ANALOG_H +#include "freetdm.h" typedef enum { - ZAP_ANALOG_RUNNING = (1 << 0), - ZAP_ANALOG_CALLERID = (1 << 1) -} zap_analog_flag_t; + FTDM_ANALOG_RUNNING = (1 << 0), + FTDM_ANALOG_CALLERID = (1 << 1) +} ftdm_analog_flag_t; -#define ZAP_MAX_HOTLINE_STR 20 +#define FTDM_MAX_HOTLINE_STR 20 #define MAX_DTMF 256 -struct zap_analog_data { +struct ftdm_analog_data { uint32_t flags; uint32_t max_dialstr; uint32_t digit_timeout; - char hotline[ZAP_MAX_HOTLINE_STR]; + char hotline[FTDM_MAX_HOTLINE_STR]; zio_signal_cb_t sig_cb; }; -static void *zap_analog_run(zap_thread_t *me, void *obj); -typedef struct zap_analog_data zap_analog_data_t; +static void *ftdm_analog_run(ftdm_thread_t *me, void *obj); +typedef struct ftdm_analog_data ftdm_analog_data_t; #endif diff --git a/libs/freetdm/src/ftmod/ftmod_analog/ftmod_analog.c b/libs/freetdm/src/ftmod/ftmod_analog/ftmod_analog.c new file mode 100644 index 0000000000..66192108cd --- /dev/null +++ b/libs/freetdm/src/ftmod/ftmod_analog/ftmod_analog.c @@ -0,0 +1,977 @@ +/* + * Copyright (c) 2007, Anthony Minessale II + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of the original author; nor the names of any contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "freetdm.h" +#include "ftdm_analog.h" + +#ifndef localtime_r +struct tm * localtime_r(const time_t *clock, struct tm *result); +#endif + +static void *ftdm_analog_channel_run(ftdm_thread_t *me, void *obj); + +/** + * \brief Starts an FXO channel thread (outgoing call) + * \param ftdmchan Channel to initiate call on + * \return Success or failure + * + * Initialises state, starts tone progress detection and runs the channel in a new a thread. + */ +static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxo_outgoing_call) +{ + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_channel_clear_needed_tones(ftdmchan); + ftdm_channel_clear_detected_tones(ftdmchan); + + ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_PROGRESS_DETECT, NULL); + ftdmchan->needed_tones[FTDM_TONEMAP_DIAL] = 1; + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALING); + ftdm_thread_create_detached(ftdm_analog_channel_run, ftdmchan); + return FTDM_SUCCESS; + } + + return FTDM_FAIL; +} + +/** + * \brief Starts an FXS channel thread (outgoing call) + * \param ftdmchan Channel to initiate call on + * \return Success or failure + * + * Indicates call waiting if channel is already in use, otherwise runs the channel in a new thread. + */ +static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxs_outgoing_call) +{ + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_CALLWAITING); + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_GENRING); + ftdm_thread_create_detached(ftdm_analog_channel_run, ftdmchan); + } + + return FTDM_SUCCESS; +} + +/** + * \brief Starts an analog span thread (monitor) + * \param span Span to monitor + * \return Success or failure + */ +static ftdm_status_t ftdm_analog_start(ftdm_span_t *span) +{ + ftdm_analog_data_t *analog_data = span->signal_data; + ftdm_set_flag(analog_data, FTDM_ANALOG_RUNNING); + return ftdm_thread_create_detached(ftdm_analog_run, span); +} + +/** + * \brief Initialises an analog span from configuration variables + * \param span Span to configure + * \param sig_cb Callback function for event signals + * \param ap List of configuration variables + * \return Success or failure + */ +static ZIO_SIG_CONFIGURE_FUNCTION(ftdm_analog_configure_span) +//ftdm_status_t ftdm_analog_configure_span(ftdm_span_t *span, char *tonemap, uint32_t digit_timeout, uint32_t max_dialstr, zio_signal_cb_t sig_cb) +{ + ftdm_analog_data_t *analog_data; + const char *tonemap = "us"; + const char *hotline = ""; + uint32_t digit_timeout = 10; + uint32_t max_dialstr = MAX_DTMF; + const char *var, *val; + int *intval; + uint32_t flags = FTDM_ANALOG_CALLERID; + + assert(sig_cb != NULL); + + if (span->signal_type) { + snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling."); + return FTDM_FAIL; + } + + analog_data = ftdm_malloc(sizeof(*analog_data)); + assert(analog_data != NULL); + memset(analog_data, 0, sizeof(*analog_data)); + + while ((var = va_arg(ap, char *))) { + if (!strcasecmp(var, "tonemap")) { + if (!(val = va_arg(ap, char *))) { + break; + } + tonemap = val; + } else if (!strcasecmp(var, "digit_timeout")) { + if (!(intval = va_arg(ap, int *))) { + break; + } + digit_timeout = *intval; + } else if (!strcasecmp(var, "enable_callerid")) { + if (!(val = va_arg(ap, char *))) { + break; + } + + if (ftdm_true(val)) { + flags |= FTDM_ANALOG_CALLERID; + } else { + flags &= ~FTDM_ANALOG_CALLERID; + } + } else if (!strcasecmp(var, "max_dialstr")) { + if (!(intval = va_arg(ap, int *))) { + break; + } + max_dialstr = *intval; + } else if (!strcasecmp(var, "hotline")) { + if (!(val = va_arg(ap, char *))) { + break; + } + hotline = val; + } else { + snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); + return FTDM_FAIL; + } + } + + + if (digit_timeout < 2000 || digit_timeout > 10000) { + digit_timeout = 2000; + } + + if ((max_dialstr < 1 && !strlen(hotline)) || max_dialstr > MAX_DTMF) { + max_dialstr = MAX_DTMF; + } + + span->start = ftdm_analog_start; + analog_data->flags = flags; + analog_data->digit_timeout = digit_timeout; + analog_data->max_dialstr = max_dialstr; + analog_data->sig_cb = sig_cb; + strncpy(analog_data->hotline, hotline, sizeof(analog_data->hotline)); + span->signal_type = FTDM_SIGTYPE_ANALOG; + span->signal_data = analog_data; + span->outgoing_call = span->trunk_type == FTDM_TRUNK_FXS ? analog_fxs_outgoing_call : analog_fxo_outgoing_call; + ftdm_span_load_tones(span, tonemap); + + return FTDM_SUCCESS; + +} + +/** + * \brief Retrieves tone generation output to be sent + * \param ts Teletone generator + * \param map Tone map + * \return -1 on error, 0 on success + */ +static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map) +{ + ftdm_buffer_t *dt_buffer = ts->user_data; + int wrote; + + if (!dt_buffer) { + return -1; + } + wrote = teletone_mux_tones(ts, map); + ftdm_buffer_write(dt_buffer, ts->buffer, wrote * 2); + return 0; +} + +/** + * \brief Sends caller id on an analog channel (FSK coded) + * \param ftdmchan Channel to send caller id on + */ +static void send_caller_id(ftdm_channel_t *ftdmchan) +{ + ftdm_fsk_data_state_t fsk_data; + uint8_t databuf[1024] = ""; + char time_str[9]; + struct tm tm; + time_t now; + ftdm_mdmf_type_t mt = MDMF_INVALID; + + time(&now); +#ifdef WIN32 + _tzset(); + _localtime64_s(&tm, &now); +#else + localtime_r(&now, &tm); +#endif + strftime(time_str, sizeof(time_str), "%m%d%H%M", &tm); + + ftdm_fsk_data_init(&fsk_data, databuf, sizeof(databuf)); + ftdm_fsk_data_add_mdmf(&fsk_data, MDMF_DATETIME, (uint8_t *) time_str, 8); + + if (ftdm_strlen_zero(ftdmchan->caller_data.cid_num.digits)) { + mt = MDMF_NO_NUM; + ftdm_set_string(ftdmchan->caller_data.cid_num.digits, "O"); + } else if (!strcasecmp(ftdmchan->caller_data.cid_num.digits, "P") || !strcasecmp(ftdmchan->caller_data.cid_num.digits, "O")) { + mt = MDMF_NO_NUM; + } else { + mt = MDMF_PHONE_NUM; + } + ftdm_fsk_data_add_mdmf(&fsk_data, mt, (uint8_t *) ftdmchan->caller_data.cid_num.digits, (uint8_t)strlen(ftdmchan->caller_data.cid_num.digits)); + + if (ftdm_strlen_zero(ftdmchan->caller_data.cid_name)) { + mt = MDMF_NO_NAME; + ftdm_set_string(ftdmchan->caller_data.cid_name, "O"); + } else if (!strcasecmp(ftdmchan->caller_data.cid_name, "P") || !strcasecmp(ftdmchan->caller_data.cid_name, "O")) { + mt = MDMF_NO_NAME; + } else { + mt = MDMF_PHONE_NAME; + } + ftdm_fsk_data_add_mdmf(&fsk_data, mt, (uint8_t *) ftdmchan->caller_data.cid_name, (uint8_t)strlen(ftdmchan->caller_data.cid_name)); + + ftdm_fsk_data_add_checksum(&fsk_data); + ftdm_channel_send_fsk_data(ftdmchan, &fsk_data, -14); +} + +/** + * \brief Main thread function for analog channel (outgoing call) + * \param me Current thread + * \param obj Channel to run in this thread + */ +static void *ftdm_analog_channel_run(ftdm_thread_t *me, void *obj) +{ + ftdm_channel_t *ftdmchan = (ftdm_channel_t *) obj; + ftdm_buffer_t *dt_buffer = NULL; + teletone_generation_session_t ts; + uint8_t frame[1024]; + ftdm_size_t len, rlen; + ftdm_tone_type_t tt = FTDM_TONE_DTMF; + char dtmf[MAX_DTMF+1] = ""; + ftdm_size_t dtmf_offset = 0; + ftdm_analog_data_t *analog_data = ftdmchan->span->signal_data; + ftdm_channel_t *closed_chan; + uint32_t state_counter = 0, elapsed = 0, collecting = 0, interval = 0, last_digit = 0, indicate = 0, dial_timeout = 30000; + ftdm_sigmsg_t sig; + ftdm_status_t status; + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG CHANNEL thread starting.\n"); + + ts.buffer = NULL; + + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error); + goto done; + } + + if (ftdm_buffer_create(&dt_buffer, 1024, 3192, 0) != FTDM_SUCCESS) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "memory error!"); + ftdm_log(FTDM_LOG_ERROR, "MEM ERROR\n"); + goto done; + } + + if (ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "error initilizing tone detector!"); + ftdm_log(FTDM_LOG_ERROR, "TONE ERROR\n"); + goto done; + } + + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INTHREAD); + teletone_init_session(&ts, 0, teletone_handler, dt_buffer); + ts.rate = 8000; +#if 0 + ts.debug = 1; + ts.debug_stream = stdout; +#endif + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_INTERVAL, &interval); + ftdm_buffer_set_loops(dt_buffer, -1); + + memset(&sig, 0, sizeof(sig)); + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; + + assert(interval != 0); + + while (ftdm_running() && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_wait_flag_t flags = FTDM_READ; + ftdm_size_t dlen = 0; + + len = sizeof(frame); + + elapsed += interval; + state_counter += interval; + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) { + switch(ftdmchan->state) { + case FTDM_CHANNEL_STATE_GET_CALLERID: + { + if (state_counter > 5000 || !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_CALLERID_DETECT)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_DISABLE_CALLERID_DETECT, NULL); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE); + } + } + break; + case FTDM_CHANNEL_STATE_DIALING: + { + if (state_counter > dial_timeout) { + if (ftdmchan->needed_tones[FTDM_TONEMAP_DIAL]) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); + } + } + } + break; + case FTDM_CHANNEL_STATE_GENRING: + { + if (state_counter > 60000) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } else if (!ftdmchan->fsk_buffer || !ftdm_buffer_inuse(ftdmchan->fsk_buffer)) { + ftdm_sleep(interval); + continue; + } + } + break; + case FTDM_CHANNEL_STATE_DIALTONE: + { + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_HOLD) && state_counter > 10000) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } + } + break; + case FTDM_CHANNEL_STATE_BUSY: + { + if (state_counter > 20000) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_ATTN); + } + } + break; + case FTDM_CHANNEL_STATE_ATTN: + { + if (state_counter > 20000) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + break; + case FTDM_CHANNEL_STATE_HANGUP: + { + if (state_counter > 500) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_OFF, NULL); + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && + (ftdmchan->last_state == FTDM_CHANNEL_STATE_RING || ftdmchan->last_state == FTDM_CHANNEL_STATE_DIALTONE + || ftdmchan->last_state >= FTDM_CHANNEL_STATE_IDLE)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CLEARING; + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + } + break; + case FTDM_CHANNEL_STATE_CALLWAITING: + { + int done = 0; + + if (ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] == 1) { + send_caller_id(ftdmchan); + ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]++; + } else if (state_counter > 600 && !ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]) { + send_caller_id(ftdmchan); + ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]++; + } else if (state_counter > 1000 && !ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]) { + done = 1; + } else if (state_counter > 10000) { + if (ftdmchan->fsk_buffer) { + ftdm_buffer_zero(ftdmchan->fsk_buffer); + } else { + ftdm_buffer_create(&ftdmchan->fsk_buffer, 128, 128, 0); + } + + ts.user_data = ftdmchan->fsk_buffer; + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_CALLWAITING_SAS]); + ts.user_data = dt_buffer; + done = 1; + } + + if (done) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + ftdm_clear_flag_locked(ftdmchan->span, FTDM_SPAN_STATE_CHANGE); + ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] = 0; + } + } + case FTDM_CHANNEL_STATE_UP: + case FTDM_CHANNEL_STATE_IDLE: + { + ftdm_sleep(interval); + continue; + } + break; + case FTDM_CHANNEL_STATE_DOWN: + { + goto done; + } + break; + default: + break; + } + } else { + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + ftdm_clear_flag_locked(ftdmchan->span, FTDM_SPAN_STATE_CHANGE); + ftdm_channel_complete_state(ftdmchan); + indicate = 0; + state_counter = 0; + + ftdm_log(FTDM_LOG_DEBUG, "Executing state handler on %d:%d for %s\n", + ftdmchan->span_id, ftdmchan->chan_id, + ftdm_channel_state2str(ftdmchan->state)); + switch(ftdmchan->state) { + case FTDM_CHANNEL_STATE_UP: + { + ftdm_channel_use(ftdmchan); + ftdm_channel_clear_needed_tones(ftdmchan); + ftdm_channel_flush_dtmf(ftdmchan); + + if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL); + } + + if (ftdmchan->fsk_buffer && ftdm_buffer_inuse(ftdmchan->fsk_buffer)) { + ftdm_log(FTDM_LOG_DEBUG, "Cancel FSK transmit due to early answer.\n"); + ftdm_buffer_zero(ftdmchan->fsk_buffer); + } + + if (ftdmchan->type == FTDM_CHAN_TYPE_FXS && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_OFF, NULL); + } + + if (ftdmchan->token_count == 1) { + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_HOLD); + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_HOLD)) { + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_HOLD); + sig.event_id = FTDM_SIGEVENT_ADD_CALL; + } else { + sig.event_id = FTDM_SIGEVENT_UP; + } + + analog_data->sig_cb(&sig); + continue; + } + break; + case FTDM_CHANNEL_STATE_DIALING: + { + ftdm_channel_use(ftdmchan); + } + break; + case FTDM_CHANNEL_STATE_IDLE: + { + ftdm_channel_use(ftdmchan); + sig.event_id = FTDM_SIGEVENT_START; + + if (ftdmchan->type == FTDM_CHAN_TYPE_FXO) { + ftdm_set_string(ftdmchan->caller_data.dnis.digits, ftdmchan->chan_number); + } else { + ftdm_set_string(ftdmchan->caller_data.dnis.digits, dtmf); + } + + analog_data->sig_cb(&sig); + continue; + } + break; + case FTDM_CHANNEL_STATE_DOWN: + { + sig.event_id = FTDM_SIGEVENT_STOP; + analog_data->sig_cb(&sig); + goto done; + } + break; + case FTDM_CHANNEL_STATE_DIALTONE: + { + memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data)); + *dtmf = '\0'; + dtmf_offset = 0; + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_DIAL]); + indicate = 1; + } + break; + case FTDM_CHANNEL_STATE_CALLWAITING: + { + ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] = 0; + if (ftdmchan->fsk_buffer) { + ftdm_buffer_zero(ftdmchan->fsk_buffer); + } else { + ftdm_buffer_create(&ftdmchan->fsk_buffer, 128, 128, 0); + } + + ts.user_data = ftdmchan->fsk_buffer; + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_CALLWAITING_SAS]); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_CALLWAITING_CAS]); + ts.user_data = dt_buffer; + } + break; + case FTDM_CHANNEL_STATE_GENRING: + { + ftdm_sigmsg_t sig; + + send_caller_id(ftdmchan); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_ON, NULL); + + memset(&sig, 0, sizeof(sig)); + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; + sig.event_id = FTDM_SIGEVENT_PROGRESS; + analog_data->sig_cb(&sig); + + } + break; + case FTDM_CHANNEL_STATE_GET_CALLERID: + { + memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data)); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_CALLERID_DETECT, NULL); + continue; + } + break; + case FTDM_CHANNEL_STATE_RING: + { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_RING]); + indicate = 1; + + } + break; + case FTDM_CHANNEL_STATE_BUSY: + { + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION; + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_BUSY]); + indicate = 1; + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + break; + case FTDM_CHANNEL_STATE_ATTN: + { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_ATTN]); + indicate = 1; + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + break; + default: + break; + } + } + + + if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALTONE || ftdmchan->state == FTDM_CHANNEL_STATE_COLLECT) { + if ((dlen = ftdm_channel_dequeue_dtmf(ftdmchan, dtmf + dtmf_offset, sizeof(dtmf) - strlen(dtmf)))) { + + if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALTONE) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_COLLECT); + collecting = 1; + } + dtmf_offset = strlen(dtmf); + last_digit = elapsed; + sig.event_id = FTDM_SIGEVENT_COLLECTED_DIGIT; + sig.raw_data = dtmf; + if (analog_data->sig_cb(&sig) == FTDM_BREAK) { + collecting = 0; + } + } + else if(!analog_data->max_dialstr) + { + last_digit = elapsed; + collecting = 0; + strcpy(dtmf, analog_data->hotline); + } + } + + + if (last_digit && (!collecting || ((elapsed - last_digit > analog_data->digit_timeout) || strlen(dtmf) >= analog_data->max_dialstr))) { + ftdm_log(FTDM_LOG_DEBUG, "Number obtained [%s]\n", dtmf); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE); + last_digit = 0; + collecting = 0; + } + + if (ftdm_channel_wait(ftdmchan, &flags, interval * 2) != FTDM_SUCCESS) { + continue; + } + + if (!(flags & FTDM_READ)) { + continue; + } + + if (ftdm_channel_read(ftdmchan, frame, &len) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "READ ERROR [%s]\n", ftdmchan->last_error); + goto done; + } + + if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && ftdmchan->detected_tones[0]) { + ftdm_sigmsg_t sig; + int i; + memset(&sig, 0, sizeof(sig)); + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; + sig.event_id = FTDM_SIGEVENT_TONE_DETECTED; + + for (i = 1; i < FTDM_TONEMAP_INVALID; i++) { + if (ftdmchan->detected_tones[i]) { + ftdm_log(FTDM_LOG_DEBUG, "Detected tone %s on %d:%d\n", ftdm_tonemap2str(i), ftdmchan->span_id, ftdmchan->chan_id); + sig.raw_data = &i; + if (analog_data->sig_cb) { + analog_data->sig_cb(&sig); + } + } + } + + if (ftdmchan->detected_tones[FTDM_TONEMAP_BUSY] || + ftdmchan->detected_tones[FTDM_TONEMAP_FAIL1] || + ftdmchan->detected_tones[FTDM_TONEMAP_FAIL2] || + ftdmchan->detected_tones[FTDM_TONEMAP_FAIL3] || + ftdmchan->detected_tones[FTDM_TONEMAP_ATTN] + ) { + ftdm_log(FTDM_LOG_ERROR, "Failure indication detected!\n"); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else if (ftdmchan->detected_tones[FTDM_TONEMAP_DIAL]) { + if (ftdm_strlen_zero(ftdmchan->caller_data.ani.digits)) { + ftdm_log(FTDM_LOG_ERROR, "No Digits to send!\n"); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + if (ftdm_channel_command(ftdmchan, FTDM_COMMAND_SEND_DTMF, ftdmchan->caller_data.ani.digits) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Send Digits Failed [%s]\n", ftdmchan->last_error); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + state_counter = 0; + ftdmchan->needed_tones[FTDM_TONEMAP_RING] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_BUSY] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_FAIL1] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_FAIL2] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_FAIL3] = 1; + dial_timeout = ((ftdmchan->dtmf_on + ftdmchan->dtmf_off) * strlen(ftdmchan->caller_data.ani.digits)) + 2000; + } + } + } else if (ftdmchan->detected_tones[FTDM_TONEMAP_RING]) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); + } + + ftdm_channel_clear_detected_tones(ftdmchan); + } + + if ((ftdmchan->dtmf_buffer && ftdm_buffer_inuse(ftdmchan->dtmf_buffer)) || (ftdmchan->fsk_buffer && ftdm_buffer_inuse(ftdmchan->fsk_buffer))) { + //rlen = len; + //memset(frame, 0, len); + //ftdm_channel_write(ftdmchan, frame, sizeof(frame), &rlen); + continue; + } + + if (!indicate) { + continue; + } + + if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL); + } + + if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) { + len *= 2; + } + + rlen = ftdm_buffer_read_loop(dt_buffer, frame, len); + + if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) { + zio_codec_t codec_func = NULL; + + if (ftdmchan->native_codec == FTDM_CODEC_ULAW) { + codec_func = zio_slin2ulaw; + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW) { + codec_func = zio_slin2alaw; + } + + if (codec_func) { + status = codec_func(frame, sizeof(frame), &rlen); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!"); + goto done; + } + } + + ftdm_channel_write(ftdmchan, frame, sizeof(frame), &rlen); + } + + done: + + + if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_ONHOOK, NULL); + } + + if (ftdmchan->type == FTDM_CHAN_TYPE_FXS && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_OFF, NULL); + } + + + closed_chan = ftdmchan; + ftdm_channel_close(&ftdmchan); + + ftdm_channel_command(closed_chan, FTDM_COMMAND_SET_NATIVE_CODEC, NULL); + + if (ts.buffer) { + teletone_destroy_session(&ts); + } + + if (dt_buffer) { + ftdm_buffer_destroy(&dt_buffer); + } + + if (closed_chan->state != FTDM_CHANNEL_STATE_DOWN) { + ftdm_set_state_locked(closed_chan, FTDM_CHANNEL_STATE_DOWN); + } + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG CHANNEL %d:%d thread ended.\n", closed_chan->span_id, closed_chan->chan_id); + ftdm_clear_flag(closed_chan, FTDM_CHANNEL_INTHREAD); + + return NULL; +} + +/** + * \brief Processes freetdm event + * \param span Span on which the event was fired + * \param event Event to be treated + * \return Success or failure + */ +static __inline__ ftdm_status_t process_event(ftdm_span_t *span, ftdm_event_t *event) +{ + ftdm_sigmsg_t sig; + ftdm_analog_data_t *analog_data = event->channel->span->signal_data; + int locked = 0; + + memset(&sig, 0, sizeof(sig)); + sig.chan_id = event->channel->chan_id; + sig.span_id = event->channel->span_id; + sig.channel = event->channel; + + + ftdm_log(FTDM_LOG_DEBUG, "EVENT [%s][%d:%d] STATE [%s]\n", + ftdm_oob_event2str(event->enum_id), event->channel->span_id, event->channel->chan_id, ftdm_channel_state2str(event->channel->state)); + + ftdm_mutex_lock(event->channel->mutex); + locked++; + + switch(event->enum_id) { + case FTDM_OOB_RING_START: + { + if (event->channel->type != FTDM_CHAN_TYPE_FXO) { + ftdm_log(FTDM_LOG_ERROR, "Cannot get a RING_START event on a non-fxo channel, please check your config.\n"); + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_DOWN); + goto end; + } + if (!event->channel->ring_count && (event->channel->state == FTDM_CHANNEL_STATE_DOWN && !ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD))) { + if (ftdm_test_flag(analog_data, FTDM_ANALOG_CALLERID)) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_GET_CALLERID); + } else { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_IDLE); + } + event->channel->ring_count = 1; + ftdm_mutex_unlock(event->channel->mutex); + locked = 0; + ftdm_thread_create_detached(ftdm_analog_channel_run, event->channel); + } else { + event->channel->ring_count++; + } + } + break; + case FTDM_OOB_ONHOOK: + { + if (ftdm_test_flag(event->channel, FTDM_CHANNEL_RINGING)) { + ftdm_channel_command(event->channel, FTDM_COMMAND_GENERATE_RING_OFF, NULL); + } + + if (event->channel->state != FTDM_CHANNEL_STATE_DOWN) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_DOWN); + } + + } + break; + case FTDM_OOB_FLASH: + { + if (event->channel->state == FTDM_CHANNEL_STATE_CALLWAITING) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_UP); + ftdm_clear_flag_locked(event->channel, FTDM_CHANNEL_STATE_CHANGE); + ftdm_clear_flag_locked(event->channel->span, FTDM_SPAN_STATE_CHANGE); + event->channel->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] = 0; + } + + ftdm_channel_rotate_tokens(event->channel); + + if (ftdm_test_flag(event->channel, FTDM_CHANNEL_HOLD) && event->channel->token_count != 1) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_UP); + } else { + sig.event_id = FTDM_SIGEVENT_FLASH; + analog_data->sig_cb(&sig); + } + } + break; + case FTDM_OOB_OFFHOOK: + { + if (event->channel->type == FTDM_CHAN_TYPE_FXS) { + if (ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD)) { + if (ftdm_test_flag(event->channel, FTDM_CHANNEL_RINGING)) { + ftdm_channel_command(event->channel, FTDM_COMMAND_GENERATE_RING_OFF, NULL); + } + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_UP); + } else { + if(!analog_data->max_dialstr) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_COLLECT); + } else { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_DIALTONE); + } + ftdm_mutex_unlock(event->channel->mutex); + locked = 0; + ftdm_thread_create_detached(ftdm_analog_channel_run, event->channel); + } + } else { + if (!ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD)) { + if (ftdm_test_flag(event->channel, FTDM_CHANNEL_OFFHOOK)) { + ftdm_channel_command(event->channel, FTDM_COMMAND_ONHOOK, NULL); + } + } + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_DOWN); + } + } + } + + end: + + if (locked) { + ftdm_mutex_unlock(event->channel->mutex); + } + return FTDM_SUCCESS; +} + +/** + * \brief Main thread function for analog span (monitor) + * \param me Current thread + * \param obj Span to run in this thread + */ +static void *ftdm_analog_run(ftdm_thread_t *me, void *obj) +{ + ftdm_span_t *span = (ftdm_span_t *) obj; + ftdm_analog_data_t *analog_data = span->signal_data; + int errs = 0; + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG thread starting.\n"); + + while(ftdm_running() && ftdm_test_flag(analog_data, FTDM_ANALOG_RUNNING)) { + int waitms = 1000; + ftdm_status_t status; + + if ((status = ftdm_span_poll_event(span, waitms)) != FTDM_FAIL) { + errs = 0; + } + + switch(status) { + case FTDM_SUCCESS: + { + ftdm_event_t *event; + while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) { + if (event->enum_id == FTDM_OOB_NOOP) { + continue; + } + if (process_event(span, event) != FTDM_SUCCESS) { + goto end; + } + } + } + break; + case FTDM_FAIL: + { + ftdm_log(FTDM_LOG_ERROR, "Failure Polling event! [%s]\n", span->last_error); + if (++errs > 300) { + ftdm_log(FTDM_LOG_CRIT, "Too Many Errors!\n"); + goto end; + } + } + break; + default: + break; + } + + } + + end: + + ftdm_clear_flag(analog_data, FTDM_ANALOG_RUNNING); + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG thread ending.\n"); + + return NULL; +} + +/** + * \brief Openftdm analog signaling module initialisation + * \return Success + */ +static ZIO_SIG_LOAD_FUNCTION(ftdm_analog_init) +{ + return FTDM_SUCCESS; +} + +/** + * \brief Openftdm analog signaling module definition + */ +EX_DECLARE_DATA ftdm_module_t ftdm_module = { + "analog", + NULL, + NULL, + ftdm_analog_init, + ftdm_analog_configure_span, + NULL +}; + + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4: + */ diff --git a/libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.2005.vcproj b/libs/freetdm/src/ftmod/ftmod_analog/ozmod_analog.2005.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.2005.vcproj rename to libs/freetdm/src/ftmod/ftmod_analog/ozmod_analog.2005.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.2008.vcproj b/libs/freetdm/src/ftmod/ftmod_analog/ozmod_analog.2008.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.2008.vcproj rename to libs/freetdm/src/ftmod/ftmod_analog/ozmod_analog.2008.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_analog_em/zap_analog_em.h b/libs/freetdm/src/ftmod/ftmod_analog_em/ftdm_analog_em.h similarity index 87% rename from libs/freetdm/src/ozmod/ozmod_analog_em/zap_analog_em.h rename to libs/freetdm/src/ftmod/ftmod_analog_em/ftdm_analog_em.h index 5f0f726063..fbb268ae1d 100644 --- a/libs/freetdm/src/ozmod/ozmod_analog_em/zap_analog_em.h +++ b/libs/freetdm/src/ftmod/ftmod_analog_em/ftdm_analog_em.h @@ -36,26 +36,26 @@ * */ -#ifndef ZAP_ANALOG_EM_H -#define ZAP_ANALOG_EM_H -#include "openzap.h" +#ifndef FTDM_ANALOG_EM_H +#define FTDM_ANALOG_EM_H +#include "freetdm.h" #define MAX_DIALSTRING 256 typedef enum { - ZAP_ANALOG_EM_RUNNING = (1 << 0) -} zap_analog_em_flag_t; + FTDM_ANALOG_EM_RUNNING = (1 << 0) +} ftdm_analog_em_flag_t; -struct zap_analog_data { +struct ftdm_analog_data { uint32_t flags; uint32_t max_dialstr; uint32_t digit_timeout; zio_signal_cb_t sig_cb; }; -static void *zap_analog_em_run(zap_thread_t *me, void *obj); -typedef struct zap_analog_data zap_analog_em_data_t; +static void *ftdm_analog_em_run(ftdm_thread_t *me, void *obj); +typedef struct ftdm_analog_data ftdm_analog_em_data_t; #endif diff --git a/libs/freetdm/src/ftmod/ftmod_analog_em/ftmod_analog_em.c b/libs/freetdm/src/ftmod/ftmod_analog_em/ftmod_analog_em.c new file mode 100644 index 0000000000..2ff3db0990 --- /dev/null +++ b/libs/freetdm/src/ftmod/ftmod_analog_em/ftmod_analog_em.c @@ -0,0 +1,709 @@ +/* + * Copyright (c) 2008, Anthony Minessale II + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of the original author; nor the names of any contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * Contributor(s): + * + * John Wehle (john@feith.com) + * + */ + +#include "freetdm.h" +#include "ftdm_analog_em.h" + +#ifndef localtime_r +struct tm * localtime_r(const time_t *clock, struct tm *result); +#endif + +static void *ftdm_analog_em_channel_run(ftdm_thread_t *me, void *obj); + +/** + * \brief Starts an EM channel thread (outgoing call) + * \param ftdmchan Channel to initiate call on + * \return Success or failure + * + * Initialises state, starts tone progress detection and runs the channel in a new a thread. + */ +static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_em_outgoing_call) +{ + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_channel_clear_needed_tones(ftdmchan); + ftdm_channel_clear_detected_tones(ftdmchan); + + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + + ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_PROGRESS_DETECT, NULL); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALING); + ftdm_thread_create_detached(ftdm_analog_em_channel_run, ftdmchan); + return FTDM_SUCCESS; + } + + return FTDM_FAIL; +} + +/** + * \brief Starts an EM span thread (monitor) + * \param span Span to monitor + * \return Success or failure + */ +static ftdm_status_t ftdm_analog_em_start(ftdm_span_t *span) +{ + ftdm_analog_em_data_t *analog_data = span->signal_data; + ftdm_set_flag(analog_data, FTDM_ANALOG_EM_RUNNING); + return ftdm_thread_create_detached(ftdm_analog_em_run, span); +} + +/** + * \brief Initialises an EM span from configuration variables + * \param span Span to configure + * \param sig_cb Callback function for event signals + * \param ap List of configuration variables + * \return Success or failure + */ +static ZIO_SIG_CONFIGURE_FUNCTION(ftdm_analog_em_configure_span) +//ftdm_status_t ftdm_analog_em_configure_span(ftdm_span_t *span, char *tonemap, uint32_t digit_timeout, uint32_t max_dialstr, zio_signal_cb_t sig_cb) +{ + ftdm_analog_em_data_t *analog_data; + const char *tonemap = "us"; + uint32_t digit_timeout = 10; + uint32_t max_dialstr = 11; + const char *var, *val; + int *intval; + + assert(sig_cb != NULL); + + if (span->signal_type) { + snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling."); + return FTDM_FAIL; + } + + analog_data = ftdm_malloc(sizeof(*analog_data)); + assert(analog_data != NULL); + memset(analog_data, 0, sizeof(*analog_data)); + + while((var = va_arg(ap, char *))) { + if (!strcasecmp(var, "tonemap")) { + if (!(val = va_arg(ap, char *))) { + break; + } + tonemap = val; + } else if (!strcasecmp(var, "digit_timeout")) { + if (!(intval = va_arg(ap, int *))) { + break; + } + digit_timeout = *intval; + } else if (!strcasecmp(var, "max_dialstr")) { + if (!(intval = va_arg(ap, int *))) { + break; + } + max_dialstr = *intval; + } else { + snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); + return FTDM_FAIL; + } + } + + + if (digit_timeout < 2000 || digit_timeout > 10000) { + digit_timeout = 2000; + } + + if (max_dialstr < 2 || max_dialstr > MAX_DIALSTRING) { + ftdm_log(FTDM_LOG_ERROR, "Invalid max_dialstr, setting to %d\n", MAX_DIALSTRING); + max_dialstr = MAX_DIALSTRING; + } + + span->start = ftdm_analog_em_start; + analog_data->digit_timeout = digit_timeout; + analog_data->max_dialstr = max_dialstr; + analog_data->sig_cb = sig_cb; + span->signal_type = FTDM_SIGTYPE_ANALOG; + span->signal_data = analog_data; + span->outgoing_call = analog_em_outgoing_call; + ftdm_span_load_tones(span, tonemap); + + return FTDM_SUCCESS; + +} + +/** + * \brief Retrieves tone generation output to be sent + * \param ts Teletone generator + * \param map Tone map + * \return -1 on error, 0 on success + */ +static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map) +{ + ftdm_buffer_t *dt_buffer = ts->user_data; + int wrote; + + if (!dt_buffer) { + return -1; + } + wrote = teletone_mux_tones(ts, map); + ftdm_buffer_write(dt_buffer, ts->buffer, wrote * 2); + return 0; +} + +/** + * \brief Main thread function for EM channel (outgoing call) + * \param me Current thread + * \param obj Channel to run in this thread + */ +static void *ftdm_analog_em_channel_run(ftdm_thread_t *me, void *obj) +{ + ftdm_channel_t *ftdmchan = (ftdm_channel_t *) obj; + ftdm_buffer_t *dt_buffer = NULL; + teletone_generation_session_t ts; + uint8_t frame[1024]; + ftdm_size_t len, rlen; + ftdm_tone_type_t tt = FTDM_TONE_DTMF; + char dtmf[128] = ""; + ftdm_size_t dtmf_offset = 0; + ftdm_analog_em_data_t *analog_data = ftdmchan->span->signal_data; + ftdm_channel_t *closed_chan; + uint32_t state_counter = 0, elapsed = 0, collecting = 0, interval = 0, last_digit = 0, indicate = 0, dial_timeout = 30000; + ftdm_sigmsg_t sig; + ftdm_status_t status; + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG EM CHANNEL thread starting.\n"); + + ts.buffer = NULL; + + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error); + goto done; + } + + if (ftdm_buffer_create(&dt_buffer, 1024, 3192, 0) != FTDM_SUCCESS) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "memory error!"); + ftdm_log(FTDM_LOG_ERROR, "MEM ERROR\n"); + goto done; + } + + if (ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "error initilizing tone detector!"); + ftdm_log(FTDM_LOG_ERROR, "TONE ERROR\n"); + goto done; + } + + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INTHREAD); + teletone_init_session(&ts, 0, teletone_handler, dt_buffer); + ts.rate = 8000; +#if 0 + ts.debug = 1; + ts.debug_stream = stdout; +#endif + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_INTERVAL, &interval); + ftdm_buffer_set_loops(dt_buffer, -1); + + memset(&sig, 0, sizeof(sig)); + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; + + assert(interval != 0); + + while (ftdm_running() && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_wait_flag_t flags = FTDM_READ; + ftdm_size_t dlen = 0; + + len = sizeof(frame); + + elapsed += interval; + state_counter += interval; + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) { + switch(ftdmchan->state) { + case FTDM_CHANNEL_STATE_DIALING: + { + if (! ftdmchan->needed_tones[FTDM_TONEMAP_RING] + && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_WINK)) { + if (ftdm_strlen_zero(ftdmchan->caller_data.ani.digits)) { + ftdm_log(FTDM_LOG_ERROR, "No Digits to send!\n"); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + if (ftdm_channel_command(ftdmchan, FTDM_COMMAND_SEND_DTMF, ftdmchan->caller_data.ani.digits) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Send Digits Failed [%s]\n", ftdmchan->last_error); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + state_counter = 0; + ftdmchan->needed_tones[FTDM_TONEMAP_RING] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_BUSY] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_FAIL1] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_FAIL2] = 1; + ftdmchan->needed_tones[FTDM_TONEMAP_FAIL3] = 1; + dial_timeout = ((ftdmchan->dtmf_on + ftdmchan->dtmf_off) * strlen(ftdmchan->caller_data.ani.digits)) + 2000; + } + } + break; + } + if (state_counter > dial_timeout) { + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_WINK)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); + } + } + } + break; + case FTDM_CHANNEL_STATE_DIALTONE: + { + if (state_counter > 10000) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } + } + break; + case FTDM_CHANNEL_STATE_BUSY: + { + if (state_counter > 20000) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_ATTN); + } + } + break; + case FTDM_CHANNEL_STATE_ATTN: + { + if (state_counter > 20000) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + break; + case FTDM_CHANNEL_STATE_HANGUP: + { + if (state_counter > 500) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && + (ftdmchan->last_state == FTDM_CHANNEL_STATE_RING || ftdmchan->last_state == FTDM_CHANNEL_STATE_DIALTONE + || ftdmchan->last_state >= FTDM_CHANNEL_STATE_IDLE)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else { + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CLEARING; + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + } + break; + case FTDM_CHANNEL_STATE_UP: + case FTDM_CHANNEL_STATE_IDLE: + { + ftdm_sleep(interval); + continue; + } + break; + case FTDM_CHANNEL_STATE_DOWN: + { + goto done; + } + break; + default: + break; + } + } else { + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + ftdm_clear_flag_locked(ftdmchan->span, FTDM_SPAN_STATE_CHANGE); + ftdm_channel_complete_state(ftdmchan); + indicate = 0; + state_counter = 0; + + ftdm_log(FTDM_LOG_DEBUG, "Executing state handler on %d:%d for %s\n", + ftdmchan->span_id, ftdmchan->chan_id, + ftdm_channel_state2str(ftdmchan->state)); + switch(ftdmchan->state) { + case FTDM_CHANNEL_STATE_UP: + { + ftdm_channel_use(ftdmchan); + ftdm_channel_clear_needed_tones(ftdmchan); + ftdm_channel_flush_dtmf(ftdmchan); + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) { + ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL); + } + + sig.event_id = FTDM_SIGEVENT_UP; + + analog_data->sig_cb(&sig); + continue; + } + break; + case FTDM_CHANNEL_STATE_DIALING: + { + ftdm_channel_use(ftdmchan); + } + break; + case FTDM_CHANNEL_STATE_IDLE: + { + ftdm_channel_use(ftdmchan); + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_set_string(ftdmchan->caller_data.dnis.digits, ftdmchan->chan_number); + } else { + ftdm_set_string(ftdmchan->caller_data.dnis.digits, dtmf); + } + + sig.event_id = FTDM_SIGEVENT_START; + + analog_data->sig_cb(&sig); + continue; + } + break; + case FTDM_CHANNEL_STATE_DOWN: + { + sig.event_id = FTDM_SIGEVENT_STOP; + analog_data->sig_cb(&sig); + goto done; + } + break; + case FTDM_CHANNEL_STATE_DIALTONE: + { + memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data)); + *dtmf = '\0'; + dtmf_offset = 0; + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_DIAL]); + indicate = 1; + + ftdm_channel_command(ftdmchan, FTDM_COMMAND_WINK, NULL); + } + break; + case FTDM_CHANNEL_STATE_RING: + { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_RING]); + indicate = 1; + } + break; + case FTDM_CHANNEL_STATE_BUSY: + { + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION; + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_BUSY]); + indicate = 1; + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + break; + case FTDM_CHANNEL_STATE_ATTN: + { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_ATTN]); + indicate = 1; + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + break; + default: + break; + } + } + + + if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALTONE || ftdmchan->state == FTDM_CHANNEL_STATE_COLLECT) { + if ((dlen = ftdm_channel_dequeue_dtmf(ftdmchan, dtmf + dtmf_offset, sizeof(dtmf) - strlen(dtmf)))) { + + if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALTONE) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_COLLECT); + collecting = 1; + } + dtmf_offset = strlen(dtmf); + last_digit = elapsed; + sig.event_id = FTDM_SIGEVENT_COLLECTED_DIGIT; + sig.raw_data = dtmf; + if (analog_data->sig_cb(&sig) == FTDM_BREAK) { + collecting = 0; + } + } + } + + + if (last_digit && (!collecting || ((elapsed - last_digit > analog_data->digit_timeout) || strlen(dtmf) > analog_data->max_dialstr))) { + ftdm_log(FTDM_LOG_DEBUG, "Number obtained [%s]\n", dtmf); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE); + last_digit = 0; + collecting = 0; + } + + if (ftdm_channel_wait(ftdmchan, &flags, interval * 2) != FTDM_SUCCESS) { + continue; + } + + if (!(flags & FTDM_READ)) { + continue; + } + + if (ftdm_channel_read(ftdmchan, frame, &len) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "READ ERROR [%s]\n", ftdmchan->last_error); + goto done; + } + + if (ftdmchan->detected_tones[0]) { + ftdm_sigmsg_t sig; + int i; + memset(&sig, 0, sizeof(sig)); + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; + sig.event_id = FTDM_SIGEVENT_TONE_DETECTED; + + for (i = 1; i < FTDM_TONEMAP_INVALID; i++) { + if (ftdmchan->detected_tones[i]) { + ftdm_log(FTDM_LOG_DEBUG, "Detected tone %s on %d:%d\n", ftdm_tonemap2str(i), ftdmchan->span_id, ftdmchan->chan_id); + sig.raw_data = &i; + if (analog_data->sig_cb) { + analog_data->sig_cb(&sig); + } + } + } + + if (ftdmchan->detected_tones[FTDM_TONEMAP_BUSY] || + ftdmchan->detected_tones[FTDM_TONEMAP_FAIL1] || + ftdmchan->detected_tones[FTDM_TONEMAP_FAIL2] || + ftdmchan->detected_tones[FTDM_TONEMAP_FAIL3] || + ftdmchan->detected_tones[FTDM_TONEMAP_ATTN] + ) { + ftdm_log(FTDM_LOG_ERROR, "Failure indication detected!\n"); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + } else if (ftdmchan->detected_tones[FTDM_TONEMAP_RING]) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); + } + + ftdm_channel_clear_detected_tones(ftdmchan); + } + + if ((ftdmchan->dtmf_buffer && ftdm_buffer_inuse(ftdmchan->dtmf_buffer))) { + rlen = len; + memset(frame, 0, len); + ftdm_channel_write(ftdmchan, frame, sizeof(frame), &rlen); + continue; + } + + if (!indicate) { + continue; + } + + if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) { + len *= 2; + } + + rlen = ftdm_buffer_read_loop(dt_buffer, frame, len); + + if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) { + zio_codec_t codec_func = NULL; + + if (ftdmchan->native_codec == FTDM_CODEC_ULAW) { + codec_func = zio_slin2ulaw; + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW) { + codec_func = zio_slin2alaw; + } + + if (codec_func) { + status = codec_func(frame, sizeof(frame), &rlen); + } else { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!"); + goto done; + } + } + + ftdm_channel_write(ftdmchan, frame, sizeof(frame), &rlen); + } + + done: + + ftdm_channel_command(ftdmchan, FTDM_COMMAND_ONHOOK, NULL); + + closed_chan = ftdmchan; + ftdm_channel_close(&ftdmchan); + + ftdm_channel_command(closed_chan, FTDM_COMMAND_SET_NATIVE_CODEC, NULL); + + if (ts.buffer) { + teletone_destroy_session(&ts); + } + + if (dt_buffer) { + ftdm_buffer_destroy(&dt_buffer); + } + + ftdm_clear_flag(closed_chan, FTDM_CHANNEL_INTHREAD); + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG EM CHANNEL thread ended.\n"); + + return NULL; +} + +/** + * \brief Processes EM events coming from ftdmtel/dahdi + * \param span Span on which the event was fired + * \param event Event to be treated + * \return Success or failure + */ +static __inline__ ftdm_status_t process_event(ftdm_span_t *span, ftdm_event_t *event) +{ + ftdm_sigmsg_t sig; + int locked = 0; + + memset(&sig, 0, sizeof(sig)); + sig.chan_id = event->channel->chan_id; + sig.span_id = event->channel->span_id; + sig.channel = event->channel; + + + ftdm_log(FTDM_LOG_DEBUG, "EVENT [%s][%d:%d] STATE [%s]\n", + ftdm_oob_event2str(event->enum_id), event->channel->span_id, event->channel->chan_id, ftdm_channel_state2str(event->channel->state)); + + ftdm_mutex_lock(event->channel->mutex); + locked++; + + switch(event->enum_id) { + case FTDM_OOB_ONHOOK: + { + if (event->channel->state != FTDM_CHANNEL_STATE_DOWN) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_DOWN); + } + + } + break; + case FTDM_OOB_OFFHOOK: + { + if (ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD)) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_UP); + } else { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_DIALTONE); + ftdm_mutex_unlock(event->channel->mutex); + locked = 0; + ftdm_thread_create_detached(ftdm_analog_em_channel_run, event->channel); + } + break; + } + case FTDM_OOB_WINK: + { + if (event->channel->state != FTDM_CHANNEL_STATE_DIALING) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_DOWN); + } else { + ftdm_set_flag_locked(event->channel, FTDM_CHANNEL_WINK); + } + + } + break; + } + if (locked) { + ftdm_mutex_unlock(event->channel->mutex); + } + return FTDM_SUCCESS; +} + +/** + * \brief Main thread function for EM span (monitor) + * \param me Current thread + * \param obj Span to run in this thread + */ +static void *ftdm_analog_em_run(ftdm_thread_t *me, void *obj) +{ + ftdm_span_t *span = (ftdm_span_t *) obj; + ftdm_analog_em_data_t *analog_data = span->signal_data; + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG EM thread starting.\n"); + + while(ftdm_running() && ftdm_test_flag(analog_data, FTDM_ANALOG_EM_RUNNING)) { + int waitms = 10; + ftdm_status_t status; + + status = ftdm_span_poll_event(span, waitms); + + switch(status) { + case FTDM_SUCCESS: + { + ftdm_event_t *event; + while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) { + if (event->enum_id == FTDM_OOB_NOOP) { + continue; + } + if (process_event(span, event) != FTDM_SUCCESS) { + goto end; + } + } + } + break; + case FTDM_FAIL: + { + ftdm_log(FTDM_LOG_ERROR, "Failure Polling event! [%s]\n", span->last_error); + } + break; + default: + break; + } + + } + + end: + + ftdm_clear_flag(analog_data, FTDM_ANALOG_EM_RUNNING); + + ftdm_log(FTDM_LOG_DEBUG, "ANALOG EM thread ending.\n"); + + return NULL; +} + +/** + * \brief Openftdm analog EM module initialisation + * \return Success + */ +static ZIO_SIG_LOAD_FUNCTION(ftdm_analog_em_init) +{ + return FTDM_SUCCESS; +} + +/** + * \brief Openftdm analog EM module definition + */ +EX_DECLARE_DATA ftdm_module_t ftdm_module = { + "analog_em", + NULL, + NULL, + ftdm_analog_em_init, + ftdm_analog_em_configure_span, + NULL +}; + + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4: + */ diff --git a/libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.2005.vcproj b/libs/freetdm/src/ftmod/ftmod_analog_em/ozmod_analog_em.2005.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.2005.vcproj rename to libs/freetdm/src/ftmod/ftmod_analog_em/ozmod_analog_em.2005.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.2008.vcproj b/libs/freetdm/src/ftmod/ftmod_analog_em/ozmod_analog_em.2008.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.2008.vcproj rename to libs/freetdm/src/ftmod/ftmod_analog_em/ozmod_analog_em.2008.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_isdn/zap_isdn.h b/libs/freetdm/src/ftmod/ftmod_isdn/ftdm_isdn.h similarity index 69% rename from libs/freetdm/src/ozmod/ozmod_isdn/zap_isdn.h rename to libs/freetdm/src/ftmod/ftmod_isdn/ftdm_isdn.h index b16b004a9d..c3b44bec5a 100644 --- a/libs/freetdm/src/ozmod/ozmod_isdn/zap_isdn.h +++ b/libs/freetdm/src/ftmod/ftmod_isdn/ftdm_isdn.h @@ -31,55 +31,55 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ZAP_ISDN_H -#define ZAP_ISDN_H -#include "openzap.h" +#ifndef FTDM_ISDN_H +#define FTDM_ISDN_H +#include "freetdm.h" #define DEFAULT_DIGIT_TIMEOUT 10000 /* default overlap timeout: 10 seconds */ typedef enum { - ZAP_ISDN_OPT_NONE = 0, - ZAP_ISDN_OPT_SUGGEST_CHANNEL = (1 << 0), - ZAP_ISDN_OPT_OMIT_DISPLAY_IE = (1 << 1), /*!< Do not send Caller name in outgoing SETUP message (= Display IE) */ - ZAP_ISDN_OPT_DISABLE_TONES = (1 << 2), /*!< Disable tone generating thread (NT mode) */ + FTDM_ISDN_OPT_NONE = 0, + FTDM_ISDN_OPT_SUGGEST_CHANNEL = (1 << 0), + FTDM_ISDN_OPT_OMIT_DISPLAY_IE = (1 << 1), /*!< Do not send Caller name in outgoing SETUP message (= Display IE) */ + FTDM_ISDN_OPT_DISABLE_TONES = (1 << 2), /*!< Disable tone generating thread (NT mode) */ - ZAP_ISDN_OPT_MAX = (2 << 0) -} zap_isdn_opts_t; + FTDM_ISDN_OPT_MAX = (2 << 0) +} ftdm_isdn_opts_t; typedef enum { - ZAP_ISDN_RUNNING = (1 << 0), - ZAP_ISDN_TONES_RUNNING = (1 << 1), - ZAP_ISDN_STOP = (1 << 2) -} zap_isdn_flag_t; + FTDM_ISDN_RUNNING = (1 << 0), + FTDM_ISDN_TONES_RUNNING = (1 << 1), + FTDM_ISDN_STOP = (1 << 2) +} ftdm_isdn_flag_t; -struct zap_isdn_data { +struct ftdm_isdn_data { Q921Data_t q921; Q931_TrunkInfo_t q931; - zap_channel_t *dchan; - zap_channel_t *dchans[2]; - struct zap_sigmsg sigmsg; + ftdm_channel_t *dchan; + ftdm_channel_t *dchans[2]; + struct ftdm_sigmsg sigmsg; zio_signal_cb_t sig_cb; uint32_t flags; int32_t mode; int32_t digit_timeout; - zap_isdn_opts_t opts; - zap_caller_data_t *outbound_crv[32768]; - zap_channel_t *channels_local_crv[32768]; - zap_channel_t *channels_remote_crv[32768]; + ftdm_isdn_opts_t opts; + ftdm_caller_data_t *outbound_crv[32768]; + ftdm_channel_t *channels_local_crv[32768]; + ftdm_channel_t *channels_remote_crv[32768]; }; -typedef struct zap_isdn_data zap_isdn_data_t; +typedef struct ftdm_isdn_data ftdm_isdn_data_t; /* b-channel private data */ -struct zap_isdn_bchan_data +struct ftdm_isdn_bchan_data { L2ULONG digit_timeout; }; -typedef struct zap_isdn_bchan_data zap_isdn_bchan_data_t; +typedef struct ftdm_isdn_bchan_data ftdm_isdn_bchan_data_t; #endif diff --git a/libs/freetdm/src/ozmod/ozmod_isdn/ozmod_isdn.c b/libs/freetdm/src/ftmod/ftmod_isdn/ftmod_isdn.c similarity index 55% rename from libs/freetdm/src/ozmod/ozmod_isdn/ozmod_isdn.c rename to libs/freetdm/src/ftmod/ftmod_isdn/ftmod_isdn.c index d927610668..898d606beb 100644 --- a/libs/freetdm/src/ozmod/ozmod_isdn/ozmod_isdn.c +++ b/libs/freetdm/src/ftmod/ftmod_isdn/ftmod_isdn.c @@ -38,7 +38,7 @@ #define __EXTENSIONS__ #endif -#include "openzap.h" +#include "freetdm.h" #include "Q931.h" #include "Q921.h" #ifdef WIN32 @@ -47,14 +47,14 @@ #include #endif -#include "zap_isdn.h" +#include "ftdm_isdn.h" #define LINE "--------------------------------------------------------------------------------" //#define IODEBUG /* helper macros */ -#define ZAP_SPAN_IS_BRI(x) ((x)->trunk_type == ZAP_TRUNK_BRI || (x)->trunk_type == ZAP_TRUNK_BRI_PTMP) -#define ZAP_SPAN_IS_NT(x) (((zap_isdn_data_t *)(x)->signal_data)->mode == Q921_NT) +#define FTDM_SPAN_IS_BRI(x) ((x)->trunk_type == FTDM_TRUNK_BRI || (x)->trunk_type == FTDM_TRUNK_BRI_PTMP) +#define FTDM_SPAN_IS_NT(x) (((ftdm_isdn_data_t *)(x)->signal_data)->mode == Q921_NT) #ifdef HAVE_LIBPCAP @@ -117,31 +117,31 @@ L3UCHAR sendFrame[SNAPLEN]= { * \brief Opens a pcap file for capture * \return Success or failure */ -static zap_status_t openPcapFile(void) +static ftdm_status_t openPcapFile(void) { if(!pcaphandle) { pcaphandle = pcap_open_dead(DLT_EN10MB, SNAPLEN); if (!pcaphandle) { - zap_log(ZAP_LOG_ERROR, "Can't open pcap session: (%s)\n", pcap_geterr(pcaphandle)); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Can't open pcap session: (%s)\n", pcap_geterr(pcaphandle)); + return FTDM_FAIL; } } if(!pcapfile){ /* Open the dump file */ if(!(pcapfile=pcap_dump_open(pcaphandle, pcapfn))){ - zap_log(ZAP_LOG_ERROR, "Error opening output file (%s)\n", pcap_geterr(pcaphandle)); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Error opening output file (%s)\n", pcap_geterr(pcaphandle)); + return FTDM_FAIL; } } else{ - zap_log(ZAP_LOG_WARNING, "Pcap file is already open!\n"); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_WARNING, "Pcap file is already open!\n"); + return FTDM_FAIL; } - zap_log(ZAP_LOG_DEBUG, "Pcap file '%s' successfully opened!\n", pcapfn); + ftdm_log(FTDM_LOG_DEBUG, "Pcap file '%s' successfully opened!\n", pcapfn); pcaphdr.ts.tv_sec = 0; pcaphdr.ts.tv_usec = 0; @@ -149,20 +149,20 @@ static zap_status_t openPcapFile(void) tcp_next_seq_no_send = 0; tcp_next_seq_no_rec = 0; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Closes a pcap file * \return Success */ -static zap_status_t closePcapFile(void) +static ftdm_status_t closePcapFile(void) { if (pcapfile) { pcap_dump_close(pcapfile); if (pcaphandle) pcap_close(pcaphandle); - zap_log(ZAP_LOG_DEBUG, "Pcap file closed! File size is %lu bytes.\n", pcapfilesize); + ftdm_log(FTDM_LOG_DEBUG, "Pcap file closed! File size is %lu bytes.\n", pcapfilesize); pcaphdr.ts.tv_sec = 0; pcaphdr.ts.tv_usec = 0; @@ -174,14 +174,14 @@ static zap_status_t closePcapFile(void) } /*We have allways success with this? I think so*/ - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Writes a Q931 packet to a pcap file * \return Success or failure */ -static zap_status_t writeQ931PacketToPcap(L3UCHAR* q931buf, L3USHORT q931size, L3ULONG span_id, L3USHORT direction) +static ftdm_status_t writeQ931PacketToPcap(L3UCHAR* q931buf, L3USHORT q931size, L3ULONG span_id, L3USHORT direction) { L3UCHAR *frame = NULL; struct timeval ts; @@ -212,8 +212,8 @@ static zap_status_t writeQ931PacketToPcap(L3UCHAR* q931buf, L3USHORT q931size, L if(q931size > MAX_Q931_SIZE) { /*WARNING*/ - zap_log(ZAP_LOG_WARNING, "Q931 packet size is too big (%u)! Ignoring it!\n", q931size); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_WARNING, "Q931 packet size is too big (%u)! Ignoring it!\n", q931size); + return FTDM_FAIL; } /*Copy q931 buffer into frame*/ @@ -255,9 +255,9 @@ static zap_status_t writeQ931PacketToPcap(L3UCHAR* q931buf, L3USHORT q931size, L pcapfilesize+=pcaphdr.caplen; pcapfilesize+=sizeof(struct pcap_pkthdr); - zap_log(ZAP_LOG_DEBUG, "Added %u bytes to pcap file. File size is now %lu, \n", q931size, pcapfilesize); + ftdm_log(FTDM_LOG_DEBUG, "Added %u bytes to pcap file. File size is now %lu, \n", q931size, pcapfilesize); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } #endif @@ -271,7 +271,7 @@ static ZIO_IO_UNLOAD_FUNCTION(close_pcap) #ifdef HAVE_LIBPCAP return closePcapFile(); #else - return ZAP_SUCCESS; + return FTDM_SUCCESS; #endif } @@ -282,21 +282,21 @@ static ZIO_IO_UNLOAD_FUNCTION(close_pcap) * \brief Gets current time * \return Current time (in ms) */ -static L2ULONG zap_time_now(void) +static L2ULONG ftdm_time_now(void) { - return (L2ULONG)zap_current_time_in_ms(); + return (L2ULONG)ftdm_current_time_in_ms(); } /** * \brief Initialises an ISDN channel (outgoing call) - * \param zchan Channel to initiate call on + * \param ftdmchan Channel to initiate call on * \return Success or failure */ static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call) { - zap_status_t status = ZAP_SUCCESS; - zap_set_flag(zchan, ZAP_CHANNEL_OUTBOUND); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DIALING); + ftdm_status_t status = FTDM_SUCCESS; + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALING); return status; } @@ -306,7 +306,7 @@ static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call) * \param chan_id Specific channel to get (0 for any) * \param direction Call direction (inbound, outbound) * \param caller_data Caller information - * \param zchan Channel to initialise + * \param ftdmchan Channel to initialise * \return Success or failure */ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) @@ -321,15 +321,15 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) Q931ie_Display Display, *ptrDisplay; Q931ie_HLComp HLComp; /* High-Layer Compatibility IE */ Q931ie_ProgInd Progress; /* Progress Indicator IE */ - zap_status_t status = ZAP_FAIL; - zap_isdn_data_t *isdn_data = span->signal_data; + ftdm_status_t status = FTDM_FAIL; + ftdm_isdn_data_t *isdn_data = span->signal_data; int sanity = 60000; int codec = 0; /* * get codec type */ - zap_channel_command(span->channels[chan_id], ZAP_COMMAND_GET_NATIVE_CODEC, &codec); + ftdm_channel_command(span->channels[chan_id], FTDM_COMMAND_GET_NATIVE_CODEC, &codec); /* * Q.931 Setup Message @@ -347,17 +347,17 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) BearerCap.TransMode = 0; /* Circuit = 0, Packet = 1 */ BearerCap.ITR = Q931_ITR_64K; /* 64k */ BearerCap.Layer1Ident = 1; - BearerCap.UIL1Prot = (codec == ZAP_CODEC_ALAW) ? Q931_UIL1P_G711A : Q931_UIL1P_G711U; /* U-law = 2, A-law = 3 */ + BearerCap.UIL1Prot = (codec == FTDM_CODEC_ALAW) ? Q931_UIL1P_G711A : Q931_UIL1P_G711U; /* U-law = 2, A-law = 3 */ gen->BearerCap = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &BearerCap); /* * Channel ID IE */ Q931InitIEChanID(&ChanID); - ChanID.IntType = ZAP_SPAN_IS_BRI(span) ? 0 : 1; /* PRI = 1, BRI = 0 */ + ChanID.IntType = FTDM_SPAN_IS_BRI(span) ? 0 : 1; /* PRI = 1, BRI = 0 */ - if(!ZAP_SPAN_IS_NT(span)) { - ChanID.PrefExcl = (isdn_data->opts & ZAP_ISDN_OPT_SUGGEST_CHANNEL) ? 0 : 1; /* 0 = preferred, 1 exclusive */ + if(!FTDM_SPAN_IS_NT(span)) { + ChanID.PrefExcl = (isdn_data->opts & FTDM_ISDN_OPT_SUGGEST_CHANNEL) ? 0 : 1; /* 0 = preferred, 1 exclusive */ } else { ChanID.PrefExcl = 1; /* always exclusive in NT-mode */ } @@ -383,12 +383,12 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) /* * Display IE */ - if (!(isdn_data->opts & ZAP_ISDN_OPT_OMIT_DISPLAY_IE)) { + if (!(isdn_data->opts & FTDM_ISDN_OPT_OMIT_DISPLAY_IE)) { Q931InitIEDisplay(&Display); Display.Size = Display.Size + (unsigned char)strlen(caller_data->cid_name); gen->Display = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &Display); ptrDisplay = Q931GetIEPtr(gen->Display, gen->buf); - zap_copy_string((char *)ptrDisplay->Display, caller_data->cid_name, strlen(caller_data->cid_name)+1); + ftdm_copy_string((char *)ptrDisplay->Display, caller_data->cid_name, strlen(caller_data->cid_name)+1); } /* @@ -402,7 +402,7 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) CallingNum.Size = CallingNum.Size + (unsigned char)strlen(caller_data->cid_num.digits); gen->CallingNum = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &CallingNum); ptrCallingNum = Q931GetIEPtr(gen->CallingNum, gen->buf); - zap_copy_string((char *)ptrCallingNum->Digit, caller_data->cid_num.digits, strlen(caller_data->cid_num.digits)+1); + ftdm_copy_string((char *)ptrCallingNum->Digit, caller_data->cid_num.digits, strlen(caller_data->cid_num.digits)+1); /* @@ -414,7 +414,7 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) CalledNum.Size = CalledNum.Size + (unsigned char)strlen(caller_data->ani.digits); gen->CalledNum = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &CalledNum); ptrCalledNum = Q931GetIEPtr(gen->CalledNum, gen->buf); - zap_copy_string((char *)ptrCalledNum->Digit, caller_data->ani.digits, strlen(caller_data->ani.digits)+1); + ftdm_copy_string((char *)ptrCalledNum->Digit, caller_data->ani.digits, strlen(caller_data->ani.digits)+1); /* * High-Layer Compatibility IE (Note: Required for AVM FritzBox) @@ -426,46 +426,46 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) HLComp.HLCharID = 1; /* Telephony = 1, Fax G2+3 = 4, Fax G4 = 65 (Class I)/ 68 (Class II or III) */ gen->HLComp = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &HLComp); - caller_data->call_state = ZAP_CALLER_STATE_DIALING; + caller_data->call_state = FTDM_CALLER_STATE_DIALING; Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); isdn_data->outbound_crv[gen->CRV] = caller_data; - //isdn_data->channels_local_crv[gen->CRV] = zchan; + //isdn_data->channels_local_crv[gen->CRV] = ftdmchan; - while(zap_running() && caller_data->call_state == ZAP_CALLER_STATE_DIALING) { - zap_sleep(1); + while(ftdm_running() && caller_data->call_state == FTDM_CALLER_STATE_DIALING) { + ftdm_sleep(1); if (!--sanity) { - caller_data->call_state = ZAP_CALLER_STATE_FAIL; + caller_data->call_state = FTDM_CALLER_STATE_FAIL; break; } } isdn_data->outbound_crv[gen->CRV] = NULL; - if (caller_data->call_state == ZAP_CALLER_STATE_SUCCESS) { - zap_channel_t *new_chan = NULL; + if (caller_data->call_state == FTDM_CALLER_STATE_SUCCESS) { + ftdm_channel_t *new_chan = NULL; int fail = 1; new_chan = NULL; - if (caller_data->chan_id < ZAP_MAX_CHANNELS_SPAN && caller_data->chan_id <= span->chan_count) { + if (caller_data->chan_id < FTDM_MAX_CHANNELS_SPAN && caller_data->chan_id <= span->chan_count) { new_chan = span->channels[caller_data->chan_id]; } - if (new_chan && (status = zap_channel_open_chan(new_chan) == ZAP_SUCCESS)) { - if (zap_test_flag(new_chan, ZAP_CHANNEL_INUSE) || new_chan->state != ZAP_CHANNEL_STATE_DOWN) { - if (new_chan->state == ZAP_CHANNEL_STATE_DOWN || new_chan->state >= ZAP_CHANNEL_STATE_TERMINATING) { + if (new_chan && (status = ftdm_channel_open_chan(new_chan) == FTDM_SUCCESS)) { + if (ftdm_test_flag(new_chan, FTDM_CHANNEL_INUSE) || new_chan->state != FTDM_CHANNEL_STATE_DOWN) { + if (new_chan->state == FTDM_CHANNEL_STATE_DOWN || new_chan->state >= FTDM_CHANNEL_STATE_TERMINATING) { int x = 0; - zap_log(ZAP_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use waiting for it to become available.\n"); + ftdm_log(FTDM_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use waiting for it to become available.\n"); for (x = 0; x < 200; x++) { - if (!zap_test_flag(new_chan, ZAP_CHANNEL_INUSE)) { + if (!ftdm_test_flag(new_chan, FTDM_CHANNEL_INUSE)) { break; } - zap_sleep(5); + ftdm_sleep(5); } } - if (zap_test_flag(new_chan, ZAP_CHANNEL_INUSE)) { - zap_log(ZAP_LOG_ERROR, "Channel %d:%d ~ %d:%d is already in use.\n", + if (ftdm_test_flag(new_chan, FTDM_CHANNEL_INUSE)) { + ftdm_log(FTDM_LOG_ERROR, "Channel %d:%d ~ %d:%d is already in use.\n", new_chan->span_id, new_chan->chan_id, new_chan->physical_span_id, @@ -475,20 +475,20 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) } } - if (new_chan && new_chan->state == ZAP_CHANNEL_STATE_DOWN) { + if (new_chan && new_chan->state == FTDM_CHANNEL_STATE_DOWN) { isdn_data->channels_local_crv[gen->CRV] = new_chan; memset(&new_chan->caller_data, 0, sizeof(new_chan->caller_data)); - zap_set_flag(new_chan, ZAP_CHANNEL_OUTBOUND); - zap_set_state_locked(new_chan, ZAP_CHANNEL_STATE_DIALING); + ftdm_set_flag(new_chan, FTDM_CHANNEL_OUTBOUND); + ftdm_set_state_locked(new_chan, FTDM_CHANNEL_STATE_DIALING); switch(gen->MesType) { case Q931mes_ALERTING: - new_chan->init_state = ZAP_CHANNEL_STATE_PROGRESS_MEDIA; + new_chan->init_state = FTDM_CHANNEL_STATE_PROGRESS_MEDIA; break; case Q931mes_CONNECT: - new_chan->init_state = ZAP_CHANNEL_STATE_UP; + new_chan->init_state = FTDM_CHANNEL_STATE_UP; break; default: - new_chan->init_state = ZAP_CHANNEL_STATE_PROGRESS; + new_chan->init_state = FTDM_CHANNEL_STATE_PROGRESS; break; } @@ -497,8 +497,8 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) } if (!fail) { - *zchan = new_chan; - return ZAP_SUCCESS; + *ftdmchan = new_chan; + return FTDM_SUCCESS; } else { Q931ie_Cause cause; gen->MesType = Q931mes_DISCONNECT; @@ -508,7 +508,7 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) cause.Location = 1; cause.Recom = 1; //should we be casting here.. or do we need to translate value? - cause.Value = (unsigned char) ZAP_CAUSE_WRONG_CALL_STATE; + cause.Value = (unsigned char) FTDM_CAUSE_WRONG_CALL_STATE; *cause.Diag = '\0'; gen->Cause = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); @@ -518,15 +518,15 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) } if (new_chan) { - zap_log(ZAP_LOG_CRIT, "Channel is busy\n"); + ftdm_log(FTDM_LOG_CRIT, "Channel is busy\n"); } else { - zap_log(ZAP_LOG_CRIT, "Failed to open channel for new setup message\n"); + ftdm_log(FTDM_LOG_CRIT, "Failed to open channel for new setup message\n"); } } } - *zchan = NULL; - return ZAP_FAIL; + *ftdmchan = NULL; + return FTDM_FAIL; } @@ -538,9 +538,9 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) * \param p2 ?? * \return 0 */ -static L3INT zap_isdn_931_err(void *pvt, L3INT id, L3INT p1, L3INT p2) +static L3INT ftdm_isdn_931_err(void *pvt, L3INT id, L3INT p1, L3INT p2) { - zap_log(ZAP_LOG_ERROR, "ERROR: [%s] [%d] [%d]\n", q931_error_to_name(id), p1, p2); + ftdm_log(FTDM_LOG_ERROR, "ERROR: [%s] [%d] [%d]\n", q931_error_to_name(id), p1, p2); return 0; } @@ -551,15 +551,15 @@ static L3INT zap_isdn_931_err(void *pvt, L3INT id, L3INT p1, L3INT p2) * \param mlen Message string length * \return 0 */ -static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) +static L3INT ftdm_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) { - zap_span_t *span = (zap_span_t *) pvt; - zap_isdn_data_t *isdn_data = span->signal_data; + ftdm_span_t *span = (ftdm_span_t *) pvt; + ftdm_isdn_data_t *isdn_data = span->signal_data; Q931mes_Generic *gen = (Q931mes_Generic *) msg; uint32_t chan_id = 0; int chan_hunt = 0; - zap_channel_t *zchan = NULL; - zap_caller_data_t *caller_data = NULL; + ftdm_channel_t *ftdmchan = NULL; + ftdm_caller_data_t *caller_data = NULL; if (Q931IsIEPresent(gen->ChanID)) { Q931ie_ChanID *chanid = Q931GetIEPtr(gen->ChanID, gen->buf); @@ -573,7 +573,7 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) if(chanid->InfoChanSel == 3) { chan_hunt++; } - } else if (ZAP_SPAN_IS_NT(span)) { + } else if (FTDM_SPAN_IS_NT(span)) { /* no channel ie */ chan_hunt++; } @@ -581,7 +581,7 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) assert(span != NULL); assert(isdn_data != NULL); - zap_log(ZAP_LOG_DEBUG, "Yay I got an event! Type:[%02x] Size:[%d] CRV: %d (%#hx, CTX: %s)\n", gen->MesType, gen->Size, gen->CRV, gen->CRV, gen->CRVFlag ? "Terminator" : "Originator"); + ftdm_log(FTDM_LOG_DEBUG, "Yay I got an event! Type:[%02x] Size:[%d] CRV: %d (%#hx, CTX: %s)\n", gen->MesType, gen->Size, gen->CRV, gen->CRV, gen->CRVFlag ? "Terminator" : "Originator"); if (gen->CRVFlag && (caller_data = isdn_data->outbound_crv[gen->CRV])) { if (chan_id) { @@ -596,11 +596,11 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) case Q931mes_PROGRESS: case Q931mes_CONNECT: { - caller_data->call_state = ZAP_CALLER_STATE_SUCCESS; + caller_data->call_state = FTDM_CALLER_STATE_SUCCESS; } break; default: - caller_data->call_state = ZAP_CALLER_STATE_FAIL; + caller_data->call_state = FTDM_CALLER_STATE_FAIL; break; } @@ -608,12 +608,12 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) } if (gen->CRVFlag) { - zchan = isdn_data->channels_local_crv[gen->CRV]; + ftdmchan = isdn_data->channels_local_crv[gen->CRV]; } else { - zchan = isdn_data->channels_remote_crv[gen->CRV]; + ftdmchan = isdn_data->channels_remote_crv[gen->CRV]; } - zap_log(ZAP_LOG_DEBUG, "zchan %x (%d:%d) source isdn_data->channels_%s_crv[%#hx]\n", zchan, zchan ? zchan->span_id : -1, zchan ? zchan->chan_id : -1, gen->CRVFlag ? "local" : "remote", gen->CRV); + ftdm_log(FTDM_LOG_DEBUG, "ftdmchan %x (%d:%d) source isdn_data->channels_%s_crv[%#hx]\n", ftdmchan, ftdmchan ? ftdmchan->span_id : -1, ftdmchan ? ftdmchan->chan_id : -1, gen->CRVFlag ? "local" : "remote", gen->CRV); if (gen->ProtDisc == 3) { @@ -621,25 +621,25 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) case Q931mes_SERVICE: { Q931ie_ChangeStatus *changestatus = Q931GetIEPtr(gen->ChangeStatus, gen->buf); - if (zchan) { + if (ftdmchan) { switch (changestatus->NewStatus) { case 0: /* change status to "in service" */ { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_SUSPENDED); - zap_log(ZAP_LOG_DEBUG, "Channel %d:%d in service\n", zchan->span_id, zchan->chan_id); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_SUSPENDED); + ftdm_log(FTDM_LOG_DEBUG, "Channel %d:%d in service\n", ftdmchan->span_id, ftdmchan->chan_id); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } break; case 1: { /* change status to "maintenance" */ - zap_set_flag_locked(zchan, ZAP_CHANNEL_SUSPENDED); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_SUSPENDED); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_SUSPENDED); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED); } break; case 2: { /* change status to "out of service" */ - zap_set_flag_locked(zchan, ZAP_CHANNEL_SUSPENDED); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_SUSPENDED); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_SUSPENDED); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED); } break; default: /* unknown */ @@ -658,14 +658,14 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) case Q931mes_RESTART: { if (chan_id) { - zchan = span->channels[chan_id]; + ftdmchan = span->channels[chan_id]; } - if (zchan) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + if (ftdmchan) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } else { uint32_t i; for (i = 1; i < span->chan_count; i++) { - zap_set_state_locked((span->channels[i]), ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked((span->channels[i]), FTDM_CHANNEL_STATE_RESTART); } } } @@ -674,82 +674,82 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) case Q931mes_RELEASE_COMPLETE: { const char *what = gen->MesType == Q931mes_RELEASE ? "Release" : "Release Complete"; - if (zchan) { - if (zchan->state == ZAP_CHANNEL_STATE_TERMINATING || zchan->state == ZAP_CHANNEL_STATE_HANGUP) { + if (ftdmchan) { + if (ftdmchan->state == FTDM_CHANNEL_STATE_TERMINATING || ftdmchan->state == FTDM_CHANNEL_STATE_HANGUP) { if (gen->MesType == Q931mes_RELEASE) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP_COMPLETE); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } } - else if((gen->MesType == Q931mes_RELEASE && zchan->state <= ZAP_CHANNEL_STATE_UP) || - (gen->MesType == Q931mes_RELEASE_COMPLETE && zchan->state == ZAP_CHANNEL_STATE_DIALING)) { + else if((gen->MesType == Q931mes_RELEASE && ftdmchan->state <= FTDM_CHANNEL_STATE_UP) || + (gen->MesType == Q931mes_RELEASE_COMPLETE && ftdmchan->state == FTDM_CHANNEL_STATE_DIALING)) { /* * Don't keep inbound channels open if the remote side hangs up before we answered */ Q931ie_Cause *cause = Q931GetIEPtr(gen->Cause, gen->buf); - zap_sigmsg_t sig; - zap_status_t status; + ftdm_sigmsg_t sig; + ftdm_status_t status; memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; - sig.channel->caller_data.hangup_cause = (cause) ? cause->Value : ZAP_CAUSE_NORMAL_UNSPECIFIED; + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; + sig.channel->caller_data.hangup_cause = (cause) ? cause->Value : FTDM_CAUSE_NORMAL_UNSPECIFIED; - sig.event_id = ZAP_SIGEVENT_STOP; + sig.event_id = FTDM_SIGEVENT_STOP; status = isdn_data->sig_cb(&sig); - zap_log(ZAP_LOG_DEBUG, "Received %s in state %s, requested hangup for channel %d:%d\n", what, zap_channel_state2str(zchan->state), zchan->span_id, chan_id); + ftdm_log(FTDM_LOG_DEBUG, "Received %s in state %s, requested hangup for channel %d:%d\n", what, ftdm_channel_state2str(ftdmchan->state), ftdmchan->span_id, chan_id); } else { - zap_log(ZAP_LOG_DEBUG, "Ignoring %s on channel %d\n", what, chan_id); + ftdm_log(FTDM_LOG_DEBUG, "Ignoring %s on channel %d\n", what, chan_id); } } else { - zap_log(ZAP_LOG_CRIT, "Received %s with no matching channel %d\n", what, chan_id); + ftdm_log(FTDM_LOG_CRIT, "Received %s with no matching channel %d\n", what, chan_id); } } break; case Q931mes_DISCONNECT: { - if (zchan) { + if (ftdmchan) { Q931ie_Cause *cause = Q931GetIEPtr(gen->Cause, gen->buf); - zchan->caller_data.hangup_cause = cause->Value; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_TERMINATING); + ftdmchan->caller_data.hangup_cause = cause->Value; + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING); } else { - zap_log(ZAP_LOG_CRIT, "Received Disconnect with no matching channel %d\n", chan_id); + ftdm_log(FTDM_LOG_CRIT, "Received Disconnect with no matching channel %d\n", chan_id); } } break; case Q931mes_ALERTING: { - if (zchan) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_PROGRESS_MEDIA); + if (ftdmchan) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } else { - zap_log(ZAP_LOG_CRIT, "Received Alerting with no matching channel %d\n", chan_id); + ftdm_log(FTDM_LOG_CRIT, "Received Alerting with no matching channel %d\n", chan_id); } } break; case Q931mes_PROGRESS: { - if (zchan) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_PROGRESS); + if (ftdmchan) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } else { - zap_log(ZAP_LOG_CRIT, "Received Progress with no matching channel %d\n", chan_id); + ftdm_log(FTDM_LOG_CRIT, "Received Progress with no matching channel %d\n", chan_id); } } break; case Q931mes_CONNECT: { - if (zchan) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); + if (ftdmchan) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); gen->MesType = Q931mes_CONNECT_ACKNOWLEDGE; gen->CRVFlag = 0; /* outbound */ Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); } else { - zap_log(ZAP_LOG_CRIT, "Received Connect with no matching channel %d\n", chan_id); + ftdm_log(FTDM_LOG_CRIT, "Received Connect with no matching channel %d\n", chan_id); } } break; @@ -762,21 +762,21 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) int overlap_dial = 0; uint32_t cplen = mlen; - if(zchan && zchan == isdn_data->channels_remote_crv[gen->CRV]) { - zap_log(ZAP_LOG_INFO, "Duplicate SETUP message(?) for Channel %d:%d ~ %d:%d in state %s [ignoring]\n", - zchan->span_id, - zchan->chan_id, - zchan->physical_span_id, - zchan->physical_chan_id, - zap_channel_state2str(zchan->state)); + if(ftdmchan && ftdmchan == isdn_data->channels_remote_crv[gen->CRV]) { + ftdm_log(FTDM_LOG_INFO, "Duplicate SETUP message(?) for Channel %d:%d ~ %d:%d in state %s [ignoring]\n", + ftdmchan->span_id, + ftdmchan->chan_id, + ftdmchan->physical_span_id, + ftdmchan->physical_chan_id, + ftdm_channel_state2str(ftdmchan->state)); break; } - zchan = NULL; + ftdmchan = NULL; /* * Channel selection for incoming calls: */ - if (ZAP_SPAN_IS_NT(span) && chan_hunt) { + if (FTDM_SPAN_IS_NT(span) && chan_hunt) { uint32_t x; /* @@ -784,21 +784,21 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) * try to find a free channel */ for (x = 1; x <= span->chan_count; x++) { - zap_channel_t *zc = span->channels[x]; + ftdm_channel_t *zc = span->channels[x]; - if (!zap_test_flag(zc, ZAP_CHANNEL_INUSE) && zc->state == ZAP_CHANNEL_STATE_DOWN) { - zchan = zc; + if (!ftdm_test_flag(zc, FTDM_CHANNEL_INUSE) && zc->state == FTDM_CHANNEL_STATE_DOWN) { + ftdmchan = zc; break; } } } - else if (!ZAP_SPAN_IS_NT(span) && chan_hunt) { + else if (!FTDM_SPAN_IS_NT(span) && chan_hunt) { /* * In TE-mode this ("any") is invalid */ - fail_cause = ZAP_CAUSE_CHANNEL_UNACCEPTABLE; + fail_cause = FTDM_CAUSE_CHANNEL_UNACCEPTABLE; - zap_log(ZAP_LOG_ERROR, "Invalid channel selection in incoming call (network side didn't specify a channel)\n"); + ftdm_log(FTDM_LOG_ERROR, "Invalid channel selection in incoming call (network side didn't specify a channel)\n"); } else { /* @@ -807,78 +807,78 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) * TODO: NT mode is abled to select a different channel if the one chosen * by the TE side is already in use */ - if (chan_id > 0 && chan_id < ZAP_MAX_CHANNELS_SPAN && chan_id <= span->chan_count) { - zchan = span->channels[chan_id]; + if (chan_id > 0 && chan_id < FTDM_MAX_CHANNELS_SPAN && chan_id <= span->chan_count) { + ftdmchan = span->channels[chan_id]; } else { /* invalid channel id */ - fail_cause = ZAP_CAUSE_CHANNEL_UNACCEPTABLE; + fail_cause = FTDM_CAUSE_CHANNEL_UNACCEPTABLE; - zap_log(ZAP_LOG_ERROR, "Invalid channel selection in incoming call (none selected or out of bounds)\n"); + ftdm_log(FTDM_LOG_ERROR, "Invalid channel selection in incoming call (none selected or out of bounds)\n"); } } if (!callednum || !strlen((char *)callednum->Digit)) { - if (ZAP_SPAN_IS_NT(span)) { - zap_log(ZAP_LOG_NOTICE, "No destination number found, assuming overlap dial\n"); + if (FTDM_SPAN_IS_NT(span)) { + ftdm_log(FTDM_LOG_NOTICE, "No destination number found, assuming overlap dial\n"); overlap_dial++; } else { - zap_log(ZAP_LOG_ERROR, "No destination number found\n"); - zchan = NULL; + ftdm_log(FTDM_LOG_ERROR, "No destination number found\n"); + ftdmchan = NULL; } } - if (zchan) { - if (zap_test_flag(zchan, ZAP_CHANNEL_INUSE) || zchan->state != ZAP_CHANNEL_STATE_DOWN) { - if (zchan->state == ZAP_CHANNEL_STATE_DOWN || zchan->state >= ZAP_CHANNEL_STATE_TERMINATING) { + if (ftdmchan) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE) || ftdmchan->state != FTDM_CHANNEL_STATE_DOWN) { + if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN || ftdmchan->state >= FTDM_CHANNEL_STATE_TERMINATING) { int x = 0; - zap_log(ZAP_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use waiting for it to become available.\n", - zchan->span_id, - zchan->chan_id, - zchan->physical_span_id, - zchan->physical_chan_id); + ftdm_log(FTDM_LOG_WARNING, "Channel %d:%d ~ %d:%d is already in use waiting for it to become available.\n", + ftdmchan->span_id, + ftdmchan->chan_id, + ftdmchan->physical_span_id, + ftdmchan->physical_chan_id); for (x = 0; x < 200; x++) { - if (!zap_test_flag(zchan, ZAP_CHANNEL_INUSE)) { + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE)) { break; } - zap_sleep(5); + ftdm_sleep(5); } } - if (zap_test_flag(zchan, ZAP_CHANNEL_INUSE)) { - zap_log(ZAP_LOG_ERROR, "Channel %d:%d ~ %d:%d is already in use.\n", - zchan->span_id, - zchan->chan_id, - zchan->physical_span_id, - zchan->physical_chan_id + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE)) { + ftdm_log(FTDM_LOG_ERROR, "Channel %d:%d ~ %d:%d is already in use.\n", + ftdmchan->span_id, + ftdmchan->chan_id, + ftdmchan->physical_span_id, + ftdmchan->physical_chan_id ); - zchan = NULL; + ftdmchan = NULL; } } - if (zchan && zchan->state == ZAP_CHANNEL_STATE_DOWN) { - isdn_data->channels_remote_crv[gen->CRV] = zchan; - memset(&zchan->caller_data, 0, sizeof(zchan->caller_data)); + if (ftdmchan && ftdmchan->state == FTDM_CHANNEL_STATE_DOWN) { + isdn_data->channels_remote_crv[gen->CRV] = ftdmchan; + memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data)); - if (zchan->mod_data) { - memset(zchan->mod_data, 0, sizeof(zap_isdn_bchan_data_t)); + if (ftdmchan->mod_data) { + memset(ftdmchan->mod_data, 0, sizeof(ftdm_isdn_bchan_data_t)); } - zap_set_string(zchan->caller_data.cid_num.digits, (char *)callingnum->Digit); - zap_set_string(zchan->caller_data.cid_name, (char *)callingnum->Digit); - zap_set_string(zchan->caller_data.ani.digits, (char *)callingnum->Digit); + ftdm_set_string(ftdmchan->caller_data.cid_num.digits, (char *)callingnum->Digit); + ftdm_set_string(ftdmchan->caller_data.cid_name, (char *)callingnum->Digit); + ftdm_set_string(ftdmchan->caller_data.ani.digits, (char *)callingnum->Digit); if (!overlap_dial) { - zap_set_string(zchan->caller_data.dnis.digits, (char *)callednum->Digit); + ftdm_set_string(ftdmchan->caller_data.dnis.digits, (char *)callednum->Digit); } - zchan->caller_data.CRV = gen->CRV; - if (cplen > sizeof(zchan->caller_data.raw_data)) { - cplen = sizeof(zchan->caller_data.raw_data); + ftdmchan->caller_data.CRV = gen->CRV; + if (cplen > sizeof(ftdmchan->caller_data.raw_data)) { + cplen = sizeof(ftdmchan->caller_data.raw_data); } gen->CRVFlag = !(gen->CRVFlag); - memcpy(zchan->caller_data.raw_data, msg, cplen); - zchan->caller_data.raw_data_len = cplen; + memcpy(ftdmchan->caller_data.raw_data, msg, cplen); + ftdmchan->caller_data.raw_data_len = cplen; fail = 0; } } @@ -893,7 +893,7 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) cause.Location = 1; cause.Recom = 1; //should we be casting here.. or do we need to translate value? - cause.Value = (unsigned char)((fail_cause) ? fail_cause : ZAP_CAUSE_WRONG_CALL_STATE); + cause.Value = (unsigned char)((fail_cause) ? fail_cause : FTDM_CAUSE_WRONG_CALL_STATE); *cause.Diag = '\0'; gen->Cause = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); @@ -902,10 +902,10 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) Q931ReleaseCRV(&isdn_data->q931, gen->CRV); } - if (zchan) { - zap_log(ZAP_LOG_CRIT, "Channel is busy\n"); + if (ftdmchan) { + ftdm_log(FTDM_LOG_CRIT, "Channel is busy\n"); } else { - zap_log(ZAP_LOG_CRIT, "Failed to open channel for new setup message\n"); + ftdm_log(FTDM_LOG_CRIT, "Failed to open channel for new setup message\n"); } } else { @@ -915,14 +915,14 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) * Update Channel ID IE */ Q931InitIEChanID(&ChanID); - ChanID.IntType = ZAP_SPAN_IS_BRI(zchan->span) ? 0 : 1; /* PRI = 1, BRI = 0 */ - ChanID.PrefExcl = ZAP_SPAN_IS_NT(zchan->span) ? 1 : 0; /* Exclusive in NT-mode = 1, Preferred otherwise = 0 */ + ChanID.IntType = FTDM_SPAN_IS_BRI(ftdmchan->span) ? 0 : 1; /* PRI = 1, BRI = 0 */ + ChanID.PrefExcl = FTDM_SPAN_IS_NT(ftdmchan->span) ? 1 : 0; /* Exclusive in NT-mode = 1, Preferred otherwise = 0 */ if(ChanID.IntType) { ChanID.InfoChanSel = 1; /* None = 0, See Slot = 1, Any = 3 */ ChanID.ChanMapType = 3; /* B-Chan */ - ChanID.ChanSlot = (unsigned char)zchan->chan_id; + ChanID.ChanSlot = (unsigned char)ftdmchan->chan_id; } else { - ChanID.InfoChanSel = (unsigned char)zchan->chan_id & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ + ChanID.InfoChanSel = (unsigned char)ftdmchan->chan_id & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ } gen->ChanID = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &ChanID); @@ -946,12 +946,12 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) gen->CRVFlag = 1; /* inbound call */ Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DIALTONE); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALTONE); } else { /* * Advance to RING state */ - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RING); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING); } } } @@ -959,37 +959,37 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) case Q931mes_CALL_PROCEEDING: { - if (zchan) { - zap_log(ZAP_LOG_CRIT, "Received CALL PROCEEDING message for channel %d\n", chan_id); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_PROGRESS); + if (ftdmchan) { + ftdm_log(FTDM_LOG_CRIT, "Received CALL PROCEEDING message for channel %d\n", chan_id); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } else { - zap_log(ZAP_LOG_CRIT, "Received CALL PROCEEDING with no matching channel %d\n", chan_id); + ftdm_log(FTDM_LOG_CRIT, "Received CALL PROCEEDING with no matching channel %d\n", chan_id); } } break; case Q931mes_CONNECT_ACKNOWLEDGE: { - if (zchan) { - zap_log(ZAP_LOG_DEBUG, "Received CONNECT_ACK message for channel %d\n", chan_id); + if (ftdmchan) { + ftdm_log(FTDM_LOG_DEBUG, "Received CONNECT_ACK message for channel %d\n", chan_id); } else { - zap_log(ZAP_LOG_DEBUG, "Received CONNECT_ACK with no matching channel %d\n", chan_id); + ftdm_log(FTDM_LOG_DEBUG, "Received CONNECT_ACK with no matching channel %d\n", chan_id); } } break; case Q931mes_INFORMATION: { - if (zchan) { - zap_log(ZAP_LOG_CRIT, "Received INFORMATION message for channel %d\n", zchan->chan_id); + if (ftdmchan) { + ftdm_log(FTDM_LOG_CRIT, "Received INFORMATION message for channel %d\n", ftdmchan->chan_id); - if (zchan->state == ZAP_CHANNEL_STATE_DIALTONE) { + if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALTONE) { char digit = '\0'; /* * overlap dial digit indication */ if (Q931IsIEPresent(gen->CalledNum)) { - zap_isdn_bchan_data_t *data = (zap_isdn_bchan_data_t *)zchan->mod_data; + ftdm_isdn_bchan_data_t *data = (ftdm_isdn_bchan_data_t *)ftdmchan->mod_data; Q931ie_CalledNum *callednum = Q931GetIEPtr(gen->CalledNum, gen->buf); int pos; @@ -999,23 +999,23 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) } /* TODO: make this more safe with strncat() */ - pos = (int)strlen(zchan->caller_data.dnis.digits); - strcat(&zchan->caller_data.dnis.digits[pos], (char *)callednum->Digit); + pos = (int)strlen(ftdmchan->caller_data.dnis.digits); + strcat(&ftdmchan->caller_data.dnis.digits[pos], (char *)callednum->Digit); /* update timer */ - data->digit_timeout = zap_time_now() + isdn_data->digit_timeout; + data->digit_timeout = ftdm_time_now() + isdn_data->digit_timeout; - zap_log(ZAP_LOG_DEBUG, "Received new overlap digit (%s), destination number: %s\n", callednum->Digit, zchan->caller_data.dnis.digits); + ftdm_log(FTDM_LOG_DEBUG, "Received new overlap digit (%s), destination number: %s\n", callednum->Digit, ftdmchan->caller_data.dnis.digits); } if (Q931IsIEPresent(gen->SendComplete) || digit == '#') { - zap_log(ZAP_LOG_DEBUG, "Leaving overlap dial mode\n"); + ftdm_log(FTDM_LOG_DEBUG, "Leaving overlap dial mode\n"); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RING); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING); } } } else { - zap_log(ZAP_LOG_CRIT, "Received INFORMATION message with no matching channel\n"); + ftdm_log(FTDM_LOG_CRIT, "Received INFORMATION message with no matching channel\n"); } } break; @@ -1025,7 +1025,7 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) /* * !! HACK ALERT !! * - * Map OpenZAP channel states to Q.931 states + * Map OpenFTDM channel states to Q.931 states */ Q931ie_CallState state; Q931ie_Cause cause; @@ -1043,18 +1043,18 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) cause.Recom = 1; /* */ *cause.Diag = '\0'; - if(zchan) { - switch(zchan->state) { - case ZAP_CHANNEL_STATE_UP: + if(ftdmchan) { + switch(ftdmchan->state) { + case FTDM_CHANNEL_STATE_UP: state.CallState = Q931_U10; /* Active */ break; - case ZAP_CHANNEL_STATE_RING: + case FTDM_CHANNEL_STATE_RING: state.CallState = Q931_U6; /* Call present */ break; - case ZAP_CHANNEL_STATE_DIALING: + case FTDM_CHANNEL_STATE_DIALING: state.CallState = Q931_U1; /* Call initiated */ break; - case ZAP_CHANNEL_STATE_DIALTONE: + case FTDM_CHANNEL_STATE_DIALTONE: state.CallState = Q931_U25; /* Overlap receiving */ break; @@ -1076,7 +1076,7 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) break; default: - zap_log(ZAP_LOG_CRIT, "Received unhandled message %d (%#x)\n", (int)gen->MesType, (int)gen->MesType); + ftdm_log(FTDM_LOG_CRIT, "Received unhandled message %d (%#x)\n", (int)gen->MesType, (int)gen->MesType); break; } } @@ -1093,7 +1093,7 @@ static L3INT zap_isdn_931_34(void *pvt, L2UCHAR *msg, L2INT mlen) * \param mlen Message string length * \return 0 on success, 1 on failure */ -static int zap_isdn_921_23(void *pvt, Q921DLMsg_t ind, L2UCHAR tei, L2UCHAR *msg, L2INT mlen) +static int ftdm_isdn_921_23(void *pvt, Q921DLMsg_t ind, L2UCHAR tei, L2UCHAR *msg, L2INT mlen) { int ret, offset = (ind == Q921_DL_DATA) ? 4 : 3; char bb[4096] = ""; @@ -1105,19 +1105,19 @@ static int zap_isdn_921_23(void *pvt, Q921DLMsg_t ind, L2UCHAR tei, L2UCHAR *msg #ifdef HAVE_LIBPCAP /*Q931ToPcap*/ if(do_q931ToPcap==1){ - zap_span_t *span = (zap_span_t *) pvt; - if(writeQ931PacketToPcap(msg + offset, mlen - offset, span->span_id, 1) != ZAP_SUCCESS){ - zap_log(ZAP_LOG_WARNING, "Couldn't write Q931 buffer to pcap file!\n"); + ftdm_span_t *span = (ftdm_span_t *) pvt; + if(writeQ931PacketToPcap(msg + offset, mlen - offset, span->span_id, 1) != FTDM_SUCCESS){ + ftdm_log(FTDM_LOG_WARNING, "Couldn't write Q931 buffer to pcap file!\n"); } } /*Q931ToPcap done*/ #endif - zap_log(ZAP_LOG_DEBUG, "READ %d\n%s\n%s\n\n\n", (int)mlen - offset, LINE, bb); + ftdm_log(FTDM_LOG_DEBUG, "READ %d\n%s\n%s\n\n\n", (int)mlen - offset, LINE, bb); default: ret = Q931Rx23(pvt, ind, tei, msg, mlen); if (ret != 0) - zap_log(ZAP_LOG_DEBUG, "931 parse error [%d] [%s]\n", ret, q931_error_to_name(ret)); + ftdm_log(FTDM_LOG_DEBUG, "931 parse error [%d] [%s]\n", ret, q931_error_to_name(ret)); break; } @@ -1131,84 +1131,84 @@ static int zap_isdn_921_23(void *pvt, Q921DLMsg_t ind, L2UCHAR tei, L2UCHAR *msg * \param mlen Message string length * \return 0 on success, -1 on failure */ -static int zap_isdn_921_21(void *pvt, L2UCHAR *msg, L2INT mlen) +static int ftdm_isdn_921_21(void *pvt, L2UCHAR *msg, L2INT mlen) { - zap_span_t *span = (zap_span_t *) pvt; - zap_size_t len = (zap_size_t) mlen; - zap_isdn_data_t *isdn_data = span->signal_data; + ftdm_span_t *span = (ftdm_span_t *) pvt; + ftdm_size_t len = (ftdm_size_t) mlen; + ftdm_isdn_data_t *isdn_data = span->signal_data; #ifdef IODEBUG char bb[4096] = ""; print_hex_bytes(msg, len, bb, sizeof(bb)); - print_bits(msg, (int)len, bb, sizeof(bb), ZAP_ENDIAN_LITTLE, 0); - zap_log(ZAP_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)len, LINE, bb); + print_bits(msg, (int)len, bb, sizeof(bb), FTDM_ENDIAN_LITTLE, 0); + ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)len, LINE, bb); #endif assert(span != NULL); - return zap_channel_write(isdn_data->dchan, msg, len, &len) == ZAP_SUCCESS ? 0 : -1; + return ftdm_channel_write(isdn_data->dchan, msg, len, &len) == FTDM_SUCCESS ? 0 : -1; } /** * \brief Handler for channel state change - * \param zchan Channel to handle + * \param ftdmchan Channel to handle */ -static __inline__ void state_advance(zap_channel_t *zchan) +static __inline__ void state_advance(ftdm_channel_t *ftdmchan) { - Q931mes_Generic *gen = (Q931mes_Generic *) zchan->caller_data.raw_data; - zap_isdn_data_t *isdn_data = zchan->span->signal_data; - zap_sigmsg_t sig; - zap_status_t status; + Q931mes_Generic *gen = (Q931mes_Generic *) ftdmchan->caller_data.raw_data; + ftdm_isdn_data_t *isdn_data = ftdmchan->span->signal_data; + ftdm_sigmsg_t sig; + ftdm_status_t status; - zap_log(ZAP_LOG_DEBUG, "%d:%d STATE [%s]\n", - zchan->span_id, zchan->chan_id, zap_channel_state2str(zchan->state)); + ftdm_log(FTDM_LOG_DEBUG, "%d:%d STATE [%s]\n", + ftdmchan->span_id, ftdmchan->chan_id, ftdm_channel_state2str(ftdmchan->state)); memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; - switch (zchan->state) { - case ZAP_CHANNEL_STATE_DOWN: + switch (ftdmchan->state) { + case FTDM_CHANNEL_STATE_DOWN: { if (gen->CRV) { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { isdn_data->channels_local_crv[gen->CRV] = NULL; } else { isdn_data->channels_remote_crv[gen->CRV] = NULL; } Q931ReleaseCRV(&isdn_data->q931, gen->CRV); } - zap_channel_done(zchan); + ftdm_channel_done(ftdmchan); } break; - case ZAP_CHANNEL_STATE_PROGRESS: + case FTDM_CHANNEL_STATE_PROGRESS: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_PROGRESS; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_PROGRESS; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { gen->MesType = Q931mes_CALL_PROCEEDING; gen->CRVFlag = 1; /* inbound */ - if (ZAP_SPAN_IS_NT(zchan->span)) { + if (FTDM_SPAN_IS_NT(ftdmchan->span)) { Q931ie_ChanID ChanID; /* * Set new Channel ID */ Q931InitIEChanID(&ChanID); - ChanID.IntType = ZAP_SPAN_IS_BRI(zchan->span) ? 0 : 1; /* PRI = 1, BRI = 0 */ + ChanID.IntType = FTDM_SPAN_IS_BRI(ftdmchan->span) ? 0 : 1; /* PRI = 1, BRI = 0 */ ChanID.PrefExcl = 1; /* always exclusive in NT-mode */ if(ChanID.IntType) { ChanID.InfoChanSel = 1; /* None = 0, See Slot = 1, Any = 3 */ ChanID.ChanMapType = 3; /* B-Chan */ - ChanID.ChanSlot = (unsigned char)zchan->chan_id; + ChanID.ChanSlot = (unsigned char)ftdmchan->chan_id; } else { - ChanID.InfoChanSel = (unsigned char)zchan->chan_id & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ + ChanID.InfoChanSel = (unsigned char)ftdmchan->chan_id & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ } gen->ChanID = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &ChanID); } @@ -1217,44 +1217,44 @@ static __inline__ void state_advance(zap_channel_t *zchan) } } break; - case ZAP_CHANNEL_STATE_DIALTONE: + case FTDM_CHANNEL_STATE_DIALTONE: { - zap_isdn_bchan_data_t *data = (zap_isdn_bchan_data_t *)zchan->mod_data; + ftdm_isdn_bchan_data_t *data = (ftdm_isdn_bchan_data_t *)ftdmchan->mod_data; if (data) { - data->digit_timeout = zap_time_now() + isdn_data->digit_timeout; + data->digit_timeout = ftdm_time_now() + isdn_data->digit_timeout; } } break; - case ZAP_CHANNEL_STATE_RING: + case FTDM_CHANNEL_STATE_RING: { - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_START; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_START; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } } break; - case ZAP_CHANNEL_STATE_RESTART: + case FTDM_CHANNEL_STATE_RESTART: { - zchan->caller_data.hangup_cause = ZAP_CAUSE_NORMAL_UNSPECIFIED; - sig.event_id = ZAP_SIGEVENT_RESTART; + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_UNSPECIFIED; + sig.event_id = FTDM_SIGEVENT_RESTART; status = isdn_data->sig_cb(&sig); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; - case ZAP_CHANNEL_STATE_PROGRESS_MEDIA: + case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_PROGRESS_MEDIA; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { - if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) { - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); return; } } @@ -1264,29 +1264,29 @@ static __inline__ void state_advance(zap_channel_t *zchan) } } break; - case ZAP_CHANNEL_STATE_UP: + case FTDM_CHANNEL_STATE_UP: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_UP; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_UP; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { - if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) { - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); return; } } gen->MesType = Q931mes_CONNECT; gen->BearerCap = 0; gen->CRVFlag = 1; /* inbound call */ - Q931Rx43(&isdn_data->q931, (void *)gen, zchan->caller_data.raw_data_len); + Q931Rx43(&isdn_data->q931, (void *)gen, ftdmchan->caller_data.raw_data_len); } } break; - case ZAP_CHANNEL_STATE_DIALING: - if (!(isdn_data->opts & ZAP_ISDN_OPT_SUGGEST_CHANNEL)) { + case FTDM_CHANNEL_STATE_DIALING: + if (!(isdn_data->opts & FTDM_ISDN_OPT_SUGGEST_CHANNEL)) { Q931ie_BearerCap BearerCap; Q931ie_ChanID ChanID; Q931ie_CallingNum CallingNum; @@ -1301,7 +1301,7 @@ static __inline__ void state_advance(zap_channel_t *zchan) /* * get codec type */ - zap_channel_command(zchan->span->channels[zchan->chan_id], ZAP_COMMAND_GET_NATIVE_CODEC, &codec); + ftdm_channel_command(ftdmchan->span->channels[ftdmchan->chan_id], FTDM_COMMAND_GET_NATIVE_CODEC, &codec); /* * Q.931 Setup Message @@ -1319,21 +1319,21 @@ static __inline__ void state_advance(zap_channel_t *zchan) BearerCap.TransMode = 0; /* Circuit = 0, Packet = 1 */ BearerCap.ITR = Q931_ITR_64K; /* 64k = 16, Packet mode = 0 */ BearerCap.Layer1Ident = 1; - BearerCap.UIL1Prot = (codec == ZAP_CODEC_ALAW) ? 3 : 2; /* U-law = 2, A-law = 3 */ + BearerCap.UIL1Prot = (codec == FTDM_CODEC_ALAW) ? 3 : 2; /* U-law = 2, A-law = 3 */ gen->BearerCap = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &BearerCap); /* * ChannelID IE */ Q931InitIEChanID(&ChanID); - ChanID.IntType = ZAP_SPAN_IS_BRI(zchan->span) ? 0 : 1; /* PRI = 1, BRI = 0 */ - ChanID.PrefExcl = ZAP_SPAN_IS_NT(zchan->span) ? 1 : 0; /* Exclusive in NT-mode = 1, Preferred otherwise = 0 */ + ChanID.IntType = FTDM_SPAN_IS_BRI(ftdmchan->span) ? 0 : 1; /* PRI = 1, BRI = 0 */ + ChanID.PrefExcl = FTDM_SPAN_IS_NT(ftdmchan->span) ? 1 : 0; /* Exclusive in NT-mode = 1, Preferred otherwise = 0 */ if(ChanID.IntType) { ChanID.InfoChanSel = 1; /* None = 0, See Slot = 1, Any = 3 */ ChanID.ChanMapType = 3; /* B-Chan */ - ChanID.ChanSlot = (unsigned char)zchan->chan_id; + ChanID.ChanSlot = (unsigned char)ftdmchan->chan_id; } else { - ChanID.InfoChanSel = (unsigned char)zchan->chan_id & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ + ChanID.InfoChanSel = (unsigned char)ftdmchan->chan_id & 0x03; /* None = 0, B1 = 1, B2 = 2, Any = 3 */ } gen->ChanID = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &ChanID); @@ -1349,26 +1349,26 @@ static __inline__ void state_advance(zap_channel_t *zchan) /* * Display IE */ - if (!(isdn_data->opts & ZAP_ISDN_OPT_OMIT_DISPLAY_IE)) { + if (!(isdn_data->opts & FTDM_ISDN_OPT_OMIT_DISPLAY_IE)) { Q931InitIEDisplay(&Display); - Display.Size = Display.Size + (unsigned char)strlen(zchan->caller_data.cid_name); + Display.Size = Display.Size + (unsigned char)strlen(ftdmchan->caller_data.cid_name); gen->Display = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &Display); ptrDisplay = Q931GetIEPtr(gen->Display, gen->buf); - zap_copy_string((char *)ptrDisplay->Display, zchan->caller_data.cid_name, strlen(zchan->caller_data.cid_name)+1); + ftdm_copy_string((char *)ptrDisplay->Display, ftdmchan->caller_data.cid_name, strlen(ftdmchan->caller_data.cid_name)+1); } /* * CallingNum IE */ Q931InitIECallingNum(&CallingNum); - CallingNum.TypNum = zchan->caller_data.ani.type; + CallingNum.TypNum = ftdmchan->caller_data.ani.type; CallingNum.NumPlanID = Q931_NUMPLAN_E164; CallingNum.PresInd = Q931_PRES_ALLOWED; CallingNum.ScreenInd = Q931_SCREEN_USER_NOT_SCREENED; - CallingNum.Size = CallingNum.Size + (unsigned char)strlen(zchan->caller_data.cid_num.digits); + CallingNum.Size = CallingNum.Size + (unsigned char)strlen(ftdmchan->caller_data.cid_num.digits); gen->CallingNum = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &CallingNum); ptrCallingNum = Q931GetIEPtr(gen->CallingNum, gen->buf); - zap_copy_string((char *)ptrCallingNum->Digit, zchan->caller_data.cid_num.digits, strlen(zchan->caller_data.cid_num.digits)+1); + ftdm_copy_string((char *)ptrCallingNum->Digit, ftdmchan->caller_data.cid_num.digits, strlen(ftdmchan->caller_data.cid_num.digits)+1); /* * CalledNum IE @@ -1376,10 +1376,10 @@ static __inline__ void state_advance(zap_channel_t *zchan) Q931InitIECalledNum(&CalledNum); CalledNum.TypNum = Q931_TON_UNKNOWN; CalledNum.NumPlanID = Q931_NUMPLAN_E164; - CalledNum.Size = CalledNum.Size + (unsigned char)strlen(zchan->caller_data.ani.digits); + CalledNum.Size = CalledNum.Size + (unsigned char)strlen(ftdmchan->caller_data.ani.digits); gen->CalledNum = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &CalledNum); ptrCalledNum = Q931GetIEPtr(gen->CalledNum, gen->buf); - zap_copy_string((char *)ptrCalledNum->Digit, zchan->caller_data.ani.digits, strlen(zchan->caller_data.ani.digits)+1); + ftdm_copy_string((char *)ptrCalledNum->Digit, ftdmchan->caller_data.ani.digits, strlen(ftdmchan->caller_data.ani.digits)+1); /* * High-Layer Compatibility IE (Note: Required for AVM FritzBox) @@ -1392,27 +1392,27 @@ static __inline__ void state_advance(zap_channel_t *zchan) gen->HLComp = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &HLComp); Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); - isdn_data->channels_local_crv[gen->CRV] = zchan; + isdn_data->channels_local_crv[gen->CRV] = ftdmchan; } break; - case ZAP_CHANNEL_STATE_HANGUP_COMPLETE: + case FTDM_CHANNEL_STATE_HANGUP_COMPLETE: { /* reply RELEASE with RELEASE_COMPLETE message */ - if(zchan->last_state == ZAP_CHANNEL_STATE_HANGUP) { + if(ftdmchan->last_state == FTDM_CHANNEL_STATE_HANGUP) { gen->MesType = Q931mes_RELEASE_COMPLETE; Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); } - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; - case ZAP_CHANNEL_STATE_HANGUP: + case FTDM_CHANNEL_STATE_HANGUP: { Q931ie_Cause cause; - zap_log(ZAP_LOG_DEBUG, "Hangup: Direction %s\n", zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) ? "Outbound" : "Inbound"); + ftdm_log(FTDM_LOG_DEBUG, "Hangup: Direction %s\n", ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) ? "Outbound" : "Inbound"); - gen->CRVFlag = zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) ? 0 : 1; + gen->CRVFlag = ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) ? 0 : 1; cause.IEId = Q931ie_CAUSE; cause.Size = sizeof(Q931ie_Cause); @@ -1424,36 +1424,36 @@ static __inline__ void state_advance(zap_channel_t *zchan) * BRI PTMP needs special handling here... * TODO: cleanup / refine (see above) */ - if (zchan->last_state == ZAP_CHANNEL_STATE_RING) { + if (ftdmchan->last_state == FTDM_CHANNEL_STATE_RING) { /* * inbound call [was: number unknown (= not found in routing state)] * (in Q.931 spec terms: Reject request) */ gen->MesType = Q931mes_RELEASE_COMPLETE; - //cause.Value = (unsigned char) ZAP_CAUSE_UNALLOCATED; - cause.Value = (unsigned char) zchan->caller_data.hangup_cause; + //cause.Value = (unsigned char) FTDM_CAUSE_UNALLOCATED; + cause.Value = (unsigned char) ftdmchan->caller_data.hangup_cause; *cause.Diag = '\0'; gen->Cause = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); /* we're done, release channel */ - //zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP_COMPLETE); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + //ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } - else if (zchan->last_state <= ZAP_CHANNEL_STATE_PROGRESS) { + else if (ftdmchan->last_state <= FTDM_CHANNEL_STATE_PROGRESS) { /* * just release all unanswered calls [was: inbound call, remote side hung up before we answered] */ gen->MesType = Q931mes_RELEASE; - cause.Value = (unsigned char) zchan->caller_data.hangup_cause; + cause.Value = (unsigned char) ftdmchan->caller_data.hangup_cause; *cause.Diag = '\0'; gen->Cause = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, (void *)gen, gen->Size); /* this will be triggered by the RELEASE_COMPLETE reply */ - /* zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP_COMPLETE); */ + /* ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); */ } else { /* @@ -1461,21 +1461,21 @@ static __inline__ void state_advance(zap_channel_t *zchan) */ gen->MesType = Q931mes_DISCONNECT; - cause.Value = (unsigned char) zchan->caller_data.hangup_cause; + cause.Value = (unsigned char) ftdmchan->caller_data.hangup_cause; *cause.Diag = '\0'; gen->Cause = Q931AppendIE((L3UCHAR *) gen, (L3UCHAR *) &cause); Q931Rx43(&isdn_data->q931, (L3UCHAR *) gen, gen->Size); } } break; - case ZAP_CHANNEL_STATE_TERMINATING: + case FTDM_CHANNEL_STATE_TERMINATING: { - zap_log(ZAP_LOG_DEBUG, "Terminating: Direction %s\n", zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) ? "Outbound" : "Inbound"); + ftdm_log(FTDM_LOG_DEBUG, "Terminating: Direction %s\n", ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) ? "Outbound" : "Inbound"); - sig.event_id = ZAP_SIGEVENT_STOP; + sig.event_id = FTDM_SIGEVENT_STOP; status = isdn_data->sig_cb(&sig); gen->MesType = Q931mes_RELEASE; - gen->CRVFlag = zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) ? 0 : 1; + gen->CRVFlag = ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) ? 0 : 1; Q931Rx43(&isdn_data->q931, (void *)gen, gen->Size); } default: @@ -1487,110 +1487,110 @@ static __inline__ void state_advance(zap_channel_t *zchan) * \brief Checks current state on a span * \param span Span to check status on */ -static __inline__ void check_state(zap_span_t *span) +static __inline__ void check_state(ftdm_span_t *span) { - if (zap_test_flag(span, ZAP_SPAN_STATE_CHANGE)) { + if (ftdm_test_flag(span, FTDM_SPAN_STATE_CHANGE)) { uint32_t j; - zap_clear_flag_locked(span, ZAP_SPAN_STATE_CHANGE); + ftdm_clear_flag_locked(span, FTDM_SPAN_STATE_CHANGE); for(j = 1; j <= span->chan_count; j++) { - if (zap_test_flag((span->channels[j]), ZAP_CHANNEL_STATE_CHANGE)) { - zap_mutex_lock(span->channels[j]->mutex); - zap_clear_flag((span->channels[j]), ZAP_CHANNEL_STATE_CHANGE); + if (ftdm_test_flag((span->channels[j]), FTDM_CHANNEL_STATE_CHANGE)) { + ftdm_mutex_lock(span->channels[j]->mutex); + ftdm_clear_flag((span->channels[j]), FTDM_CHANNEL_STATE_CHANGE); state_advance(span->channels[j]); - zap_channel_complete_state(span->channels[j]); - zap_mutex_unlock(span->channels[j]->mutex); + ftdm_channel_complete_state(span->channels[j]); + ftdm_mutex_unlock(span->channels[j]->mutex); } } } } /** - * \brief Processes Openzap event on a span + * \brief Processes Openftdm event on a span * \param span Span to process event on * \param event Event to process * \return Success or failure */ -static __inline__ zap_status_t process_event(zap_span_t *span, zap_event_t *event) +static __inline__ ftdm_status_t process_event(ftdm_span_t *span, ftdm_event_t *event) { - zap_sigmsg_t sig; - zap_isdn_data_t *isdn_data = span->signal_data; + ftdm_sigmsg_t sig; + ftdm_isdn_data_t *isdn_data = span->signal_data; memset(&sig, 0, sizeof(sig)); sig.chan_id = event->channel->chan_id; sig.span_id = event->channel->span_id; sig.channel = event->channel; - zap_log(ZAP_LOG_DEBUG, "EVENT [%s][%d:%d] STATE [%s]\n", - zap_oob_event2str(event->enum_id), event->channel->span_id, event->channel->chan_id, zap_channel_state2str(event->channel->state)); + ftdm_log(FTDM_LOG_DEBUG, "EVENT [%s][%d:%d] STATE [%s]\n", + ftdm_oob_event2str(event->enum_id), event->channel->span_id, event->channel->chan_id, ftdm_channel_state2str(event->channel->state)); switch(event->enum_id) { - case ZAP_OOB_ALARM_TRAP: + case FTDM_OOB_ALARM_TRAP: { - sig.event_id = ZAP_SIGEVENT_HWSTATUS_CHANGED; - sig.raw_data = (void *)ZAP_HW_LINK_DISCONNECTED; - if (event->channel->state != ZAP_CHANNEL_STATE_DOWN) { - if (event->channel->type == ZAP_CHAN_TYPE_B) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_RESTART); + sig.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED; + sig.raw_data = (void *)FTDM_HW_LINK_DISCONNECTED; + if (event->channel->state != FTDM_CHANNEL_STATE_DOWN) { + if (event->channel->type == FTDM_CHAN_TYPE_B) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_RESTART); } } - zap_set_flag(event->channel, ZAP_CHANNEL_SUSPENDED); + ftdm_set_flag(event->channel, FTDM_CHANNEL_SUSPENDED); - zap_channel_get_alarms(event->channel); + ftdm_channel_get_alarms(event->channel); isdn_data->sig_cb(&sig); - zap_log(ZAP_LOG_WARNING, "channel %d:%d (%d:%d) has alarms! [%s]\n", + ftdm_log(FTDM_LOG_WARNING, "channel %d:%d (%d:%d) has alarms! [%s]\n", event->channel->span_id, event->channel->chan_id, event->channel->physical_span_id, event->channel->physical_chan_id, event->channel->last_error); } break; - case ZAP_OOB_ALARM_CLEAR: + case FTDM_OOB_ALARM_CLEAR: { - zap_log(ZAP_LOG_WARNING, "channel %d:%d (%d:%d) alarms Cleared!\n", event->channel->span_id, event->channel->chan_id, + ftdm_log(FTDM_LOG_WARNING, "channel %d:%d (%d:%d) alarms Cleared!\n", event->channel->span_id, event->channel->chan_id, event->channel->physical_span_id, event->channel->physical_chan_id); - sig.event_id = ZAP_SIGEVENT_HWSTATUS_CHANGED; - sig.raw_data = (void *)ZAP_HW_LINK_CONNECTED; - zap_clear_flag(event->channel, ZAP_CHANNEL_SUSPENDED); - zap_channel_get_alarms(event->channel); + sig.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED; + sig.raw_data = (void *)FTDM_HW_LINK_CONNECTED; + ftdm_clear_flag(event->channel, FTDM_CHANNEL_SUSPENDED); + ftdm_channel_get_alarms(event->channel); isdn_data->sig_cb(&sig); } break; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Checks for events on a span * \param span Span to check for events */ -static __inline__ void check_events(zap_span_t *span) +static __inline__ void check_events(ftdm_span_t *span) { - zap_status_t status; + ftdm_status_t status; - status = zap_span_poll_event(span, 5); + status = ftdm_span_poll_event(span, 5); switch(status) { - case ZAP_SUCCESS: + case FTDM_SUCCESS: { - zap_event_t *event; - while (zap_span_next_event(span, &event) == ZAP_SUCCESS) { - if (event->enum_id == ZAP_OOB_NOOP) { + ftdm_event_t *event; + while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) { + if (event->enum_id == FTDM_OOB_NOOP) { continue; } - if (process_event(span, event) != ZAP_SUCCESS) { + if (process_event(span, event) != FTDM_SUCCESS) { break; } } } break; - case ZAP_FAIL: + case FTDM_FAIL: { - zap_log(ZAP_LOG_DEBUG, "Event Failure! %d\n", zap_running()); + ftdm_log(FTDM_LOG_DEBUG, "Event Failure! %d\n", ftdm_running()); } break; default: @@ -1606,14 +1606,14 @@ static __inline__ void check_events(zap_span_t *span) */ static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map) { - zap_buffer_t *dt_buffer = ts->user_data; + ftdm_buffer_t *dt_buffer = ts->user_data; int wrote; if (!dt_buffer) { return -1; } wrote = teletone_mux_tones(ts, map); - zap_buffer_write(dt_buffer, ts->buffer, wrote * 2); + ftdm_buffer_write(dt_buffer, ts->buffer, wrote * 2); return 0; } @@ -1622,38 +1622,38 @@ static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map * \param me Current thread * \param obj Span to generate tones on */ -static void *zap_isdn_tones_run(zap_thread_t *me, void *obj) +static void *ftdm_isdn_tones_run(ftdm_thread_t *me, void *obj) { - zap_span_t *span = (zap_span_t *) obj; - zap_isdn_data_t *isdn_data = span->signal_data; - zap_buffer_t *dt_buffer = NULL; + ftdm_span_t *span = (ftdm_span_t *) obj; + ftdm_isdn_data_t *isdn_data = span->signal_data; + ftdm_buffer_t *dt_buffer = NULL; teletone_generation_session_t ts = {{{{0}}}}; unsigned char frame[1024]; uint32_t x; int interval = 0; int offset = 0; - zap_log(ZAP_LOG_DEBUG, "ISDN tones thread starting.\n"); - zap_set_flag(isdn_data, ZAP_ISDN_TONES_RUNNING); + ftdm_log(FTDM_LOG_DEBUG, "ISDN tones thread starting.\n"); + ftdm_set_flag(isdn_data, FTDM_ISDN_TONES_RUNNING); - if (zap_buffer_create(&dt_buffer, 1024, 1024, 0) != ZAP_SUCCESS) { + if (ftdm_buffer_create(&dt_buffer, 1024, 1024, 0) != FTDM_SUCCESS) { snprintf(isdn_data->dchan->last_error, sizeof(isdn_data->dchan->last_error), "memory error!"); - zap_log(ZAP_LOG_ERROR, "MEM ERROR\n"); + ftdm_log(FTDM_LOG_ERROR, "MEM ERROR\n"); goto done; } - zap_buffer_set_loops(dt_buffer, -1); + ftdm_buffer_set_loops(dt_buffer, -1); /* get a tone generation friendly interval to avoid distortions */ for (x = 1; x <= span->chan_count; x++) { - if (span->channels[x]->type != ZAP_CHAN_TYPE_DQ921) { - zap_channel_command(span->channels[x], ZAP_COMMAND_GET_INTERVAL, &interval); + if (span->channels[x]->type != FTDM_CHAN_TYPE_DQ921) { + ftdm_channel_command(span->channels[x], FTDM_COMMAND_GET_INTERVAL, &interval); break; } } if (!interval) { interval = 20; } - zap_log(ZAP_LOG_NOTICE, "Tone generating interval %d\n", interval); + ftdm_log(FTDM_LOG_NOTICE, "Tone generating interval %d\n", interval); /* init teletone */ teletone_init_session(&ts, 0, teletone_handler, dt_buffer); @@ -1661,21 +1661,21 @@ static void *zap_isdn_tones_run(zap_thread_t *me, void *obj) ts.duration = ts.rate; /* main loop */ - while(zap_running() && zap_test_flag(isdn_data, ZAP_ISDN_TONES_RUNNING) && !zap_test_flag(isdn_data, ZAP_ISDN_STOP)) { - zap_wait_flag_t flags; - zap_status_t status; + while(ftdm_running() && ftdm_test_flag(isdn_data, FTDM_ISDN_TONES_RUNNING) && !ftdm_test_flag(isdn_data, FTDM_ISDN_STOP)) { + ftdm_wait_flag_t flags; + ftdm_status_t status; int last_chan_state = 0; int gated = 0; - L2ULONG now = zap_time_now(); + L2ULONG now = ftdm_time_now(); /* * check b-channel states and generate & send tones if neccessary */ for (x = 1; x <= span->chan_count; x++) { - zap_channel_t *zchan = span->channels[x]; - zap_size_t len = sizeof(frame), rlen; + ftdm_channel_t *ftdmchan = span->channels[x]; + ftdm_size_t len = sizeof(frame), rlen; - if (zchan->type == ZAP_CHAN_TYPE_DQ921) { + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921) { continue; } @@ -1684,40 +1684,40 @@ static void *zap_isdn_tones_run(zap_thread_t *me, void *obj) * (Recycle buffer content if succeeding channels share the * same state, this saves some cpu cycles) */ - switch (zchan->state) { - case ZAP_CHANNEL_STATE_DIALTONE: + switch (ftdmchan->state) { + case FTDM_CHANNEL_STATE_DIALTONE: { - zap_isdn_bchan_data_t *data = (zap_isdn_bchan_data_t *)zchan->mod_data; + ftdm_isdn_bchan_data_t *data = (ftdm_isdn_bchan_data_t *)ftdmchan->mod_data; /* check overlap dial timeout first before generating tone */ if (data && data->digit_timeout && data->digit_timeout <= now) { - if (strlen(zchan->caller_data.dnis.digits) > 0) { - zap_log(ZAP_LOG_DEBUG, "Overlap dial timeout, advancing to RING state\n"); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RING); + if (strlen(ftdmchan->caller_data.dnis.digits) > 0) { + ftdm_log(FTDM_LOG_DEBUG, "Overlap dial timeout, advancing to RING state\n"); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING); } else { /* no digits received, hangup */ - zap_log(ZAP_LOG_DEBUG, "Overlap dial timeout, no digits received, going to HANGUP state\n"); - zchan->caller_data.hangup_cause = ZAP_CAUSE_RECOVERY_ON_TIMER_EXPIRE; /* TODO: probably wrong cause value */ - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + ftdm_log(FTDM_LOG_DEBUG, "Overlap dial timeout, no digits received, going to HANGUP state\n"); + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE; /* TODO: probably wrong cause value */ + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } data->digit_timeout = 0; continue; } - if (last_chan_state != zchan->state) { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_DIAL]); - last_chan_state = zchan->state; + if (last_chan_state != ftdmchan->state) { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_DIAL]); + last_chan_state = ftdmchan->state; } } break; - case ZAP_CHANNEL_STATE_RING: + case FTDM_CHANNEL_STATE_RING: { - if (last_chan_state != zchan->state) { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_RING]); - last_chan_state = zchan->state; + if (last_chan_state != ftdmchan->state) { + ftdm_buffer_zero(dt_buffer); + teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_RING]); + last_chan_state = ftdmchan->state; } } break; @@ -1726,70 +1726,70 @@ static void *zap_isdn_tones_run(zap_thread_t *me, void *obj) continue; } - if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) { - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) { + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); continue; } - zap_log(ZAP_LOG_NOTICE, "Successfully opened channel %d:%d\n", zchan->span_id, zchan->chan_id); + ftdm_log(FTDM_LOG_NOTICE, "Successfully opened channel %d:%d\n", ftdmchan->span_id, ftdmchan->chan_id); } - flags = ZAP_READ; + flags = FTDM_READ; - status = zap_channel_wait(zchan, &flags, (gated) ? 0 : interval); + status = ftdm_channel_wait(ftdmchan, &flags, (gated) ? 0 : interval); switch(status) { - case ZAP_FAIL: + case FTDM_FAIL: continue; - case ZAP_TIMEOUT: + case FTDM_TIMEOUT: gated = 1; continue; default: - if (!(flags & ZAP_READ)) { + if (!(flags & FTDM_READ)) { continue; } } gated = 1; - status = zap_channel_read(zchan, frame, &len); - if (status != ZAP_SUCCESS || len <= 0) { + status = ftdm_channel_read(ftdmchan, frame, &len); + if (status != FTDM_SUCCESS || len <= 0) { continue; } - if (zchan->effective_codec != ZAP_CODEC_SLIN) { + if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) { len *= 2; } /* seek to current offset */ - zap_buffer_seek(dt_buffer, offset); + ftdm_buffer_seek(dt_buffer, offset); - rlen = zap_buffer_read_loop(dt_buffer, frame, len); + rlen = ftdm_buffer_read_loop(dt_buffer, frame, len); - if (zchan->effective_codec != ZAP_CODEC_SLIN) { + if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) { zio_codec_t codec_func = NULL; - if (zchan->native_codec == ZAP_CODEC_ULAW) { + if (ftdmchan->native_codec == FTDM_CODEC_ULAW) { codec_func = zio_slin2ulaw; - } else if (zchan->native_codec == ZAP_CODEC_ALAW) { + } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW) { codec_func = zio_slin2alaw; } if (codec_func) { status = codec_func(frame, sizeof(frame), &rlen); } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "codec error!"); + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!"); goto done; } } - zap_channel_write(zchan, frame, sizeof(frame), &rlen); + ftdm_channel_write(ftdmchan, frame, sizeof(frame), &rlen); } /* * sleep a bit if there was nothing to do */ if (!gated) { - zap_sleep(interval); + ftdm_sleep(interval); } offset += (ts.rate / (1000 / interval)) << 1; @@ -1804,11 +1804,11 @@ done: } if (dt_buffer) { - zap_buffer_destroy(&dt_buffer); + ftdm_buffer_destroy(&dt_buffer); } - zap_log(ZAP_LOG_DEBUG, "ISDN tone thread ended.\n"); - zap_clear_flag(isdn_data, ZAP_ISDN_TONES_RUNNING); + ftdm_log(FTDM_LOG_DEBUG, "ISDN tone thread ended.\n"); + ftdm_clear_flag(isdn_data, FTDM_ISDN_TONES_RUNNING); return NULL; } @@ -1818,26 +1818,26 @@ done: * \param me Current thread * \param obj Span to monitor */ -static void *zap_isdn_run(zap_thread_t *me, void *obj) +static void *ftdm_isdn_run(ftdm_thread_t *me, void *obj) { - zap_span_t *span = (zap_span_t *) obj; - zap_isdn_data_t *isdn_data = span->signal_data; + ftdm_span_t *span = (ftdm_span_t *) obj; + ftdm_isdn_data_t *isdn_data = span->signal_data; unsigned char frame[1024]; - zap_size_t len = sizeof(frame); + ftdm_size_t len = sizeof(frame); int errs = 0; #ifdef WIN32 timeBeginPeriod(1); #endif - zap_log(ZAP_LOG_DEBUG, "ISDN thread starting.\n"); - zap_set_flag(isdn_data, ZAP_ISDN_RUNNING); + ftdm_log(FTDM_LOG_DEBUG, "ISDN thread starting.\n"); + ftdm_set_flag(isdn_data, FTDM_ISDN_RUNNING); Q921Start(&isdn_data->q921); - while(zap_running() && zap_test_flag(isdn_data, ZAP_ISDN_RUNNING) && !zap_test_flag(isdn_data, ZAP_ISDN_STOP)) { - zap_wait_flag_t flags = ZAP_READ; - zap_status_t status = zap_channel_wait(isdn_data->dchan, &flags, 100); + while(ftdm_running() && ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING) && !ftdm_test_flag(isdn_data, FTDM_ISDN_STOP)) { + ftdm_wait_flag_t flags = FTDM_READ; + ftdm_status_t status = ftdm_channel_wait(isdn_data->dchan, &flags, 100); Q921TimerTick(&isdn_data->q921); Q931TimerTick(&isdn_data->q931); @@ -1848,17 +1848,17 @@ static void *zap_isdn_run(zap_thread_t *me, void *obj) * */ switch(status) { - case ZAP_FAIL: + case FTDM_FAIL: { - zap_log(ZAP_LOG_ERROR, "D-Chan Read Error!\n"); + ftdm_log(FTDM_LOG_ERROR, "D-Chan Read Error!\n"); snprintf(span->last_error, sizeof(span->last_error), "D-Chan Read Error!"); if (++errs == 10) { - isdn_data->dchan->state = ZAP_CHANNEL_STATE_UP; + isdn_data->dchan->state = FTDM_CHANNEL_STATE_UP; goto done; } } break; - case ZAP_TIMEOUT: + case FTDM_TIMEOUT: { errs = 0; } @@ -1866,26 +1866,26 @@ static void *zap_isdn_run(zap_thread_t *me, void *obj) default: { errs = 0; - if (flags & ZAP_READ) { + if (flags & FTDM_READ) { - if (zap_test_flag(isdn_data->dchan, ZAP_CHANNEL_SUSPENDED)) { - zap_clear_flag_all(span, ZAP_CHANNEL_SUSPENDED); + if (ftdm_test_flag(isdn_data->dchan, FTDM_CHANNEL_SUSPENDED)) { + ftdm_clear_flag_all(span, FTDM_CHANNEL_SUSPENDED); } len = sizeof(frame); - if (zap_channel_read(isdn_data->dchan, frame, &len) == ZAP_SUCCESS) { + if (ftdm_channel_read(isdn_data->dchan, frame, &len) == FTDM_SUCCESS) { #ifdef IODEBUG char bb[4096] = ""; print_hex_bytes(frame, len, bb, sizeof(bb)); - print_bits(frame, (int)len, bb, sizeof(bb), ZAP_ENDIAN_LITTLE, 0); - zap_log(ZAP_LOG_DEBUG, "READ %d\n%s\n%s\n\n", (int)len, LINE, bb); + print_bits(frame, (int)len, bb, sizeof(bb), FTDM_ENDIAN_LITTLE, 0); + ftdm_log(FTDM_LOG_DEBUG, "READ %d\n%s\n%s\n\n", (int)len, LINE, bb); #endif Q921QueueHDLCFrame(&isdn_data->q921, frame, (int)len); Q921Rx12(&isdn_data->q921); } } else { - zap_log(ZAP_LOG_DEBUG, "No Read FLAG!\n"); + ftdm_log(FTDM_LOG_DEBUG, "No Read FLAG!\n"); } } break; @@ -1893,30 +1893,30 @@ static void *zap_isdn_run(zap_thread_t *me, void *obj) } done: - zap_channel_close(&isdn_data->dchans[0]); - zap_channel_close(&isdn_data->dchans[1]); - zap_clear_flag(isdn_data, ZAP_ISDN_RUNNING); + ftdm_channel_close(&isdn_data->dchans[0]); + ftdm_channel_close(&isdn_data->dchans[1]); + ftdm_clear_flag(isdn_data, FTDM_ISDN_RUNNING); #ifdef WIN32 timeEndPeriod(1); #endif - zap_log(ZAP_LOG_DEBUG, "ISDN thread ended.\n"); + ftdm_log(FTDM_LOG_DEBUG, "ISDN thread ended.\n"); return NULL; } /** - * \brief Openzap ISDN signaling module initialisation + * \brief Openftdm ISDN signaling module initialisation * \return Success */ -static ZIO_SIG_LOAD_FUNCTION(zap_isdn_init) +static ZIO_SIG_LOAD_FUNCTION(ftdm_isdn_init) { Q931Initialize(); - Q921SetGetTimeCB(zap_time_now); - Q931SetGetTimeCB(zap_time_now); + Q921SetGetTimeCB(ftdm_time_now); + Q931SetGetTimeCB(ftdm_time_now); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** @@ -1942,14 +1942,14 @@ static int q931_rx_32(void *pvt, Q921DLMsg_t ind, L3UCHAR tei, L3UCHAR *msg, L3I #ifdef HAVE_LIBPCAP /*Q931ToPcap*/ if(do_q931ToPcap==1){ - zap_span_t *span = (zap_span_t *) pvt; - if(writeQ931PacketToPcap(msg + offset, mlen - offset, span->span_id, 0) != ZAP_SUCCESS){ - zap_log(ZAP_LOG_WARNING, "Couldn't write Q931 buffer to pcap file!\n"); + ftdm_span_t *span = (ftdm_span_t *) pvt; + if(writeQ931PacketToPcap(msg + offset, mlen - offset, span->span_id, 0) != FTDM_SUCCESS){ + ftdm_log(FTDM_LOG_WARNING, "Couldn't write Q931 buffer to pcap file!\n"); } } /*Q931ToPcap done*/ #endif - zap_log(ZAP_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)mlen - offset, LINE, bb); + ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)mlen - offset, LINE, bb); break; default: @@ -1967,11 +1967,11 @@ static int q931_rx_32(void *pvt, Q921DLMsg_t ind, L3UCHAR tei, L3UCHAR *msg, L3I * \param size Message string length * \return 0 */ -static int zap_isdn_q921_log(void *pvt, Q921LogLevel_t level, char *msg, L2INT size) +static int ftdm_isdn_q921_log(void *pvt, Q921LogLevel_t level, char *msg, L2INT size) { - zap_span_t *span = (zap_span_t *) pvt; + ftdm_span_t *span = (ftdm_span_t *) pvt; - zap_log("Span", "Q.921", span->span_id, (int)level, "%s", msg); + ftdm_log("Span", "Q.921", span->span_id, (int)level, "%s", msg); return 0; } @@ -1983,122 +1983,122 @@ static int zap_isdn_q921_log(void *pvt, Q921LogLevel_t level, char *msg, L2INT s * \param size Message string length * \return 0 */ -static L3INT zap_isdn_q931_log(void *pvt, Q931LogLevel_t level, char *msg, L3INT size) +static L3INT ftdm_isdn_q931_log(void *pvt, Q931LogLevel_t level, char *msg, L3INT size) { - zap_span_t *span = (zap_span_t *) pvt; + ftdm_span_t *span = (ftdm_span_t *) pvt; - zap_log("Span", "Q.931", span->span_id, (int)level, "%s", msg); + ftdm_log("Span", "Q.931", span->span_id, (int)level, "%s", msg); return 0; } /** * \brief ISDN state map */ -static zap_state_map_t isdn_state_map = { +static ftdm_state_map_t isdn_state_map = { { { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_ANY_STATE}, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END} + {FTDM_ANY_STATE}, + {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, - {ZAP_CHANNEL_STATE_DIALING, ZAP_END} + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, + {FTDM_CHANNEL_STATE_DIALING, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DIALING, ZAP_END}, - {ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_UP, ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END} + {FTDM_CHANNEL_STATE_DIALING, FTDM_END}, + {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_UP, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_PROGRESS, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_UP, ZAP_END} + {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_UP, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END} + {FTDM_CHANNEL_STATE_UP, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, /****************************************/ { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_ANY_STATE}, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END} + {FTDM_ANY_STATE}, + {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, - {ZAP_CHANNEL_STATE_DIALTONE, ZAP_CHANNEL_STATE_RING, ZAP_END} + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, + {FTDM_CHANNEL_STATE_DIALTONE, FTDM_CHANNEL_STATE_RING, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DIALTONE, ZAP_END}, - {ZAP_CHANNEL_STATE_RING, ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END} + {FTDM_CHANNEL_STATE_DIALTONE, FTDM_END}, + {FTDM_CHANNEL_STATE_RING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_UP, ZAP_END} + {FTDM_CHANNEL_STATE_RING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, - ZAP_CHANNEL_STATE_CANCEL, ZAP_CHANNEL_STATE_UP, ZAP_END}, + {FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, + FTDM_CHANNEL_STATE_CANCEL, FTDM_CHANNEL_STATE_UP, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_UP, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, + {FTDM_CHANNEL_STATE_UP, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, }, @@ -2112,25 +2112,25 @@ static zap_state_map_t isdn_state_map = { * * Sets a stop flag and waits for the threads to end */ -static zap_status_t zap_isdn_stop(zap_span_t *span) +static ftdm_status_t ftdm_isdn_stop(ftdm_span_t *span) { - zap_isdn_data_t *isdn_data = span->signal_data; + ftdm_isdn_data_t *isdn_data = span->signal_data; - if (!zap_test_flag(isdn_data, ZAP_ISDN_RUNNING)) { - return ZAP_FAIL; + if (!ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { + return FTDM_FAIL; } - zap_set_flag(isdn_data, ZAP_ISDN_STOP); + ftdm_set_flag(isdn_data, FTDM_ISDN_STOP); - while(zap_test_flag(isdn_data, ZAP_ISDN_RUNNING)) { - zap_sleep(100); + while(ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { + ftdm_sleep(100); } - while(zap_test_flag(isdn_data, ZAP_ISDN_TONES_RUNNING)) { - zap_sleep(100); + while(ftdm_test_flag(isdn_data, FTDM_ISDN_TONES_RUNNING)) { + ftdm_sleep(100); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } @@ -2141,24 +2141,24 @@ static zap_status_t zap_isdn_stop(zap_span_t *span) * * Launches a thread to monitor the span and a thread to generate tones on the span */ -static zap_status_t zap_isdn_start(zap_span_t *span) +static ftdm_status_t ftdm_isdn_start(ftdm_span_t *span) { - zap_status_t ret; - zap_isdn_data_t *isdn_data = span->signal_data; + ftdm_status_t ret; + ftdm_isdn_data_t *isdn_data = span->signal_data; - if (zap_test_flag(isdn_data, ZAP_ISDN_RUNNING)) { - return ZAP_FAIL; + if (ftdm_test_flag(isdn_data, FTDM_ISDN_RUNNING)) { + return FTDM_FAIL; } - zap_clear_flag(isdn_data, ZAP_ISDN_STOP); - ret = zap_thread_create_detached(zap_isdn_run, span); + ftdm_clear_flag(isdn_data, FTDM_ISDN_STOP); + ret = ftdm_thread_create_detached(ftdm_isdn_run, span); - if (ret != ZAP_SUCCESS) { + if (ret != FTDM_SUCCESS) { return ret; } - if (ZAP_SPAN_IS_NT(span) && !(isdn_data->opts & ZAP_ISDN_OPT_DISABLE_TONES)) { - ret = zap_thread_create_detached(zap_isdn_tones_run, span); + if (FTDM_SPAN_IS_NT(span) && !(isdn_data->opts & FTDM_ISDN_OPT_DISABLE_TONES)) { + ret = ftdm_thread_create_detached(ftdm_isdn_tones_run, span); } return ret; } @@ -2177,15 +2177,15 @@ static uint32_t parse_opts(const char *in) } if (strstr(in, "suggest_channel")) { - flags |= ZAP_ISDN_OPT_SUGGEST_CHANNEL; + flags |= FTDM_ISDN_OPT_SUGGEST_CHANNEL; } if (strstr(in, "omit_display")) { - flags |= ZAP_ISDN_OPT_OMIT_DISPLAY_IE; + flags |= FTDM_ISDN_OPT_OMIT_DISPLAY_IE; } if (strstr(in, "disable_tones")) { - flags |= ZAP_ISDN_OPT_DISABLE_TONES; + flags |= FTDM_ISDN_OPT_DISABLE_TONES; } return flags; @@ -2198,11 +2198,11 @@ static uint32_t parse_opts(const char *in) * \param ap List of configuration variables * \return Success or failure */ -static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) +static ZIO_SIG_CONFIGURE_FUNCTION(ftdm_isdn_configure_span) { uint32_t i, x = 0; - zap_channel_t *dchans[2] = {0}; - zap_isdn_data_t *isdn_data; + ftdm_channel_t *dchans[2] = {0}; + ftdm_isdn_data_t *isdn_data; const char *tonemap = "us"; char *var, *val; Q931Dialect_t dialect = Q931_Dialect_National; @@ -2216,7 +2216,7 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) if (span->signal_type) { #ifdef HAVE_LIBPCAP - /*Q931ToPcap: Get the content of the q931topcap and pcapfilename args given by mod_openzap */ + /*Q931ToPcap: Get the content of the q931topcap and pcapfilename args given by mod_freetdm */ while((var = va_arg(ap, char *))) { if (!strcasecmp(var, "q931topcap")) { q931topcap = va_arg(ap, int); @@ -2225,9 +2225,9 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) openPcap=1; } else if (q931topcap==0) { /*PCAP off*/ - if (closePcapFile() != ZAP_SUCCESS) return ZAP_FAIL; + if (closePcapFile() != FTDM_SUCCESS) return FTDM_FAIL; do_q931ToPcap=0; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } } if (!strcasecmp(var, "pcapfilename")) { @@ -2237,30 +2237,30 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) } /*We know now, that user wants to enable Q931ToPcap and what file name he wants, so open it please*/ if(openPcap==1){ - if(openPcapFile() != ZAP_SUCCESS) return ZAP_FAIL; + if(openPcapFile() != FTDM_SUCCESS) return FTDM_FAIL; do_q931ToPcap=1; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /*Q931ToPcap done*/ #endif snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling [%d].", span->signal_type); - return ZAP_FAIL; + return FTDM_FAIL; } - if (span->trunk_type >= ZAP_TRUNK_NONE) { - zap_log(ZAP_LOG_WARNING, "Invalid trunk type '%s' defaulting to T1.\n", zap_trunk_type2str(span->trunk_type)); - span->trunk_type = ZAP_TRUNK_T1; + if (span->trunk_type >= FTDM_TRUNK_NONE) { + ftdm_log(FTDM_LOG_WARNING, "Invalid trunk type '%s' defaulting to T1.\n", ftdm_trunk_type2str(span->trunk_type)); + span->trunk_type = FTDM_TRUNK_T1; } for(i = 1; i <= span->chan_count; i++) { - if (span->channels[i]->type == ZAP_CHAN_TYPE_DQ921) { + if (span->channels[i]->type == FTDM_CHAN_TYPE_DQ921) { if (x > 1) { snprintf(span->last_error, sizeof(span->last_error), "Span has more than 2 D-Channels!"); - return ZAP_FAIL; + return FTDM_FAIL; } else { - if (zap_channel_open(span->span_id, i, &dchans[x]) == ZAP_SUCCESS) { - zap_log(ZAP_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, dchans[x]->span_id, dchans[x]->chan_id); - dchans[x]->state = ZAP_CHANNEL_STATE_UP; + if (ftdm_channel_open(span->span_id, i, &dchans[x]) == FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, dchans[x]->span_id, dchans[x]->chan_id); + dchans[x]->state = FTDM_CHANNEL_STATE_UP; x++; } } @@ -2269,10 +2269,10 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) if (!x) { snprintf(span->last_error, sizeof(span->last_error), "Span has no D-Channels!"); - return ZAP_FAIL; + return FTDM_FAIL; } - isdn_data = zap_malloc(sizeof(*isdn_data)); + isdn_data = ftdm_malloc(sizeof(*isdn_data)); assert(isdn_data != NULL); memset(isdn_data, 0, sizeof(*isdn_data)); @@ -2291,7 +2291,7 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) } dialect = q931_str2Q931Dialect_type(val); if (dialect == Q931_Dialect_Count) { - return ZAP_FAIL; + return FTDM_FAIL; } } else if (!strcasecmp(var, "opts")) { if (!(val = va_arg(ap, char *))) { @@ -2325,7 +2325,7 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) } } else { snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); - return ZAP_FAIL; + return FTDM_FAIL; } } @@ -2334,29 +2334,29 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) digit_timeout = DEFAULT_DIGIT_TIMEOUT; } else if (digit_timeout < 3000 || digit_timeout > 30000) { - zap_log(ZAP_LOG_WARNING, "Digit timeout %d ms outside of range (3000 - 30000 ms), using default (10000 ms)\n", digit_timeout); + ftdm_log(FTDM_LOG_WARNING, "Digit timeout %d ms outside of range (3000 - 30000 ms), using default (10000 ms)\n", digit_timeout); digit_timeout = DEFAULT_DIGIT_TIMEOUT; } /* allocate per b-chan data */ if (isdn_data->mode == Q931_NT) { - zap_isdn_bchan_data_t *data; + ftdm_isdn_bchan_data_t *data; - data = zap_malloc((span->chan_count - 1) * sizeof(zap_isdn_bchan_data_t)); + data = ftdm_malloc((span->chan_count - 1) * sizeof(ftdm_isdn_bchan_data_t)); if (!data) { - return ZAP_FAIL; + return FTDM_FAIL; } for (i = 1; i <= span->chan_count; i++, data++) { - if (span->channels[i]->type == ZAP_CHAN_TYPE_B) { + if (span->channels[i]->type == FTDM_CHAN_TYPE_B) { span->channels[i]->mod_data = data; - memset(data, 0, sizeof(zap_isdn_bchan_data_t)); + memset(data, 0, sizeof(ftdm_isdn_bchan_data_t)); } } } - span->start = zap_isdn_start; - span->stop = zap_isdn_stop; + span->start = ftdm_isdn_start; + span->stop = ftdm_isdn_stop; isdn_data->sig_cb = sig_cb; isdn_data->dchans[0] = dchans[0]; isdn_data->dchans[1] = dchans[1]; @@ -2367,56 +2367,56 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_isdn_configure_span) 0, 0, isdn_data->mode, - span->trunk_type == ZAP_TRUNK_BRI_PTMP ? Q921_PTMP : Q921_PTP, + span->trunk_type == FTDM_TRUNK_BRI_PTMP ? Q921_PTMP : Q921_PTP, 0, - zap_isdn_921_21, - (Q921Tx23CB_t)zap_isdn_921_23, + ftdm_isdn_921_21, + (Q921Tx23CB_t)ftdm_isdn_921_23, span, &isdn_data->q931); - Q921SetLogCB(&isdn_data->q921, &zap_isdn_q921_log, isdn_data); + Q921SetLogCB(&isdn_data->q921, &ftdm_isdn_q921_log, isdn_data); Q921SetLogLevel(&isdn_data->q921, (Q921LogLevel_t)q921loglevel); Q931Api_InitTrunk(&isdn_data->q931, dialect, isdn_data->mode, span->trunk_type, - zap_isdn_931_34, + ftdm_isdn_931_34, (Q931Tx32CB_t)q931_rx_32, - zap_isdn_931_err, + ftdm_isdn_931_err, &isdn_data->q921, span); - Q931SetLogCB(&isdn_data->q931, &zap_isdn_q931_log, isdn_data); + Q931SetLogCB(&isdn_data->q931, &ftdm_isdn_q931_log, isdn_data); Q931SetLogLevel(&isdn_data->q931, (Q931LogLevel_t)q931loglevel); isdn_data->q931.autoRestartAck = 1; isdn_data->q931.autoConnectAck = 0; isdn_data->q931.autoServiceAck = 1; span->signal_data = isdn_data; - span->signal_type = ZAP_SIGTYPE_ISDN; + span->signal_type = FTDM_SIGTYPE_ISDN; span->outgoing_call = isdn_outgoing_call; - if ((isdn_data->opts & ZAP_ISDN_OPT_SUGGEST_CHANNEL)) { + if ((isdn_data->opts & FTDM_ISDN_OPT_SUGGEST_CHANNEL)) { span->channel_request = isdn_channel_request; span->suggest_chan_id = 1; } span->state_map = &isdn_state_map; - zap_span_load_tones(span, tonemap); + ftdm_span_load_tones(span, tonemap); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Openzap ISDN signaling module definition + * \brief Openftdm ISDN signaling module definition */ -EX_DECLARE_DATA zap_module_t zap_module = { +EX_DECLARE_DATA ftdm_module_t ftdm_module = { "isdn", NULL, close_pcap, - zap_isdn_init, - zap_isdn_configure_span, + ftdm_isdn_init, + ftdm_isdn_configure_span, NULL }; diff --git a/libs/freetdm/src/ozmod/ozmod_isdn/ozmod_isdn.2005.vcproj b/libs/freetdm/src/ftmod/ftmod_isdn/ozmod_isdn.2005.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_isdn/ozmod_isdn.2005.vcproj rename to libs/freetdm/src/ftmod/ftmod_isdn/ozmod_isdn.2005.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_isdn/ozmod_isdn.2008.vcproj b/libs/freetdm/src/ftmod/ftmod_isdn/ozmod_isdn.2008.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_isdn/ozmod_isdn.2008.vcproj rename to libs/freetdm/src/ftmod/ftmod_isdn/ozmod_isdn.2008.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.c b/libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c similarity index 51% rename from libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.c rename to libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c index af34e000f7..9f6769aca0 100644 --- a/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.c +++ b/libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.c @@ -31,28 +31,28 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "openzap.h" -#include "ozmod_libpri.h" +#include "freetdm.h" +#include "ftmod_libpri.h" /** * \brief Unloads libpri IO module * \return Success */ -static ZIO_IO_UNLOAD_FUNCTION(zap_libpri_unload) +static ZIO_IO_UNLOAD_FUNCTION(ftdm_libpri_unload) { - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Starts a libpri channel (outgoing call) - * \param zchan Channel to initiate call on + * \param ftdmchan Channel to initiate call on * \return Success or failure */ static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call) { - zap_status_t status = ZAP_SUCCESS; - zap_set_flag(zchan, ZAP_CHANNEL_OUTBOUND); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DIALING); + ftdm_status_t status = FTDM_SUCCESS; + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALING); return status; } @@ -62,12 +62,12 @@ static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(isdn_outgoing_call) * \param chan_id Specific channel to get (0 for any) (unused) * \param direction Call direction (unused) * \param caller_data Caller information (unused) - * \param zchan Channel to initialise (unused) + * \param ftdmchan Channel to initialise (unused) * \return Failure */ static ZIO_CHANNEL_REQUEST_FUNCTION(isdn_channel_request) { - return ZAP_FAIL; + return FTDM_FAIL; } #ifdef WIN32 @@ -85,7 +85,7 @@ static void s_pri_error(char *s) static void s_pri_error(struct pri *pri, char *s) #endif { - zap_log(ZAP_LOG_ERROR, "%s", s); + ftdm_log(FTDM_LOG_ERROR, "%s", s); } #ifdef WIN32 @@ -103,7 +103,7 @@ static void s_pri_message(char *s) static void s_pri_message(struct pri *pri, char *s) #endif { - zap_log(ZAP_LOG_DEBUG, "%s", s); + ftdm_log(FTDM_LOG_DEBUG, "%s", s); } /** @@ -120,15 +120,15 @@ static uint32_t parse_opts(const char *in) } if (strstr(in, "suggest_channel")) { - flags |= OZMOD_LIBPRI_OPT_SUGGEST_CHANNEL; + flags |= FTMOD_LIBPRI_OPT_SUGGEST_CHANNEL; } if (strstr(in, "omit_display")) { - flags |= OZMOD_LIBPRI_OPT_OMIT_DISPLAY_IE; + flags |= FTMOD_LIBPRI_OPT_OMIT_DISPLAY_IE; } if (strstr(in, "omit_redirecting_number")) { - flags |= OZMOD_LIBPRI_OPT_OMIT_REDIRECTING_NUMBER_IE; + flags |= FTMOD_LIBPRI_OPT_OMIT_REDIRECTING_NUMBER_IE; } return flags; @@ -194,9 +194,9 @@ static int parse_debug(const char *in) return flags; } -static zap_io_interface_t zap_libpri_interface; +static ftdm_io_interface_t ftdm_libpri_interface; -static zap_status_t zap_libpri_start(zap_span_t *span); +static ftdm_status_t ftdm_libpri_start(ftdm_span_t *span); /** * \brief API function to kill or debug a libpri span @@ -204,30 +204,30 @@ static zap_status_t zap_libpri_start(zap_span_t *span); * \param data String containing argurments * \return Flags */ -static ZIO_API_FUNCTION(zap_libpri_api) +static ZIO_API_FUNCTION(ftdm_libpri_api) { char *mycmd = NULL, *argv[10] = { 0 }; int argc = 0; if (data) { - mycmd = zap_strdup(data); - argc = zap_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); + mycmd = ftdm_strdup(data); + argc = ftdm_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); } if (argc == 2) { if (!strcasecmp(argv[0], "kill")) { int span_id = atoi(argv[1]); - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; - if (zap_span_find_by_name(argv[1], &span) == ZAP_SUCCESS || zap_span_find(span_id, &span) == ZAP_SUCCESS) { - zap_libpri_data_t *isdn_data = span->signal_data; + if (ftdm_span_find_by_name(argv[1], &span) == FTDM_SUCCESS || ftdm_span_find(span_id, &span) == FTDM_SUCCESS) { + ftdm_libpri_data_t *isdn_data = span->signal_data; - if (span->start != zap_libpri_start) { + if (span->start != ftdm_libpri_start) { stream->write_function(stream, "%s: -ERR invalid span.\n", __FILE__); goto done; } - zap_clear_flag((&isdn_data->spri), LPWRAP_PRI_READY); + ftdm_clear_flag((&isdn_data->spri), LPWRAP_PRI_READY); stream->write_function(stream, "%s: +OK killed.\n", __FILE__); goto done; } else { @@ -239,11 +239,11 @@ static ZIO_API_FUNCTION(zap_libpri_api) if (argc > 2) { if (!strcasecmp(argv[0], "debug")) { - zap_span_t *span = NULL; + ftdm_span_t *span = NULL; - if (zap_span_find_by_name(argv[1], &span) == ZAP_SUCCESS) { - zap_libpri_data_t *isdn_data = span->signal_data; - if (span->start != zap_libpri_start) { + if (ftdm_span_find_by_name(argv[1], &span) == FTDM_SUCCESS) { + ftdm_libpri_data_t *isdn_data = span->signal_data; + if (span->start != ftdm_libpri_start) { stream->write_function(stream, "%s: -ERR invalid span.\n", __FILE__); goto done; } @@ -263,150 +263,150 @@ static ZIO_API_FUNCTION(zap_libpri_api) done: - zap_safe_free(mycmd); + ftdm_safe_free(mycmd); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Loads libpri IO module - * \param zio Openzap IO interface + * \param zio Openftdm IO interface * \return Success */ -static ZIO_IO_LOAD_FUNCTION(zap_libpri_io_init) +static ZIO_IO_LOAD_FUNCTION(ftdm_libpri_io_init) { assert(zio != NULL); - memset(&zap_libpri_interface, 0, sizeof(zap_libpri_interface)); + memset(&ftdm_libpri_interface, 0, sizeof(ftdm_libpri_interface)); - zap_libpri_interface.name = "libpri"; - zap_libpri_interface.api = zap_libpri_api; + ftdm_libpri_interface.name = "libpri"; + ftdm_libpri_interface.api = ftdm_libpri_api; - *zio = &zap_libpri_interface; + *zio = &ftdm_libpri_interface; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Loads libpri signaling module - * \param zio Openzap IO interface + * \param zio Openftdm IO interface * \return Success */ -static ZIO_SIG_LOAD_FUNCTION(zap_libpri_init) +static ZIO_SIG_LOAD_FUNCTION(ftdm_libpri_init) { pri_set_error(s_pri_error); pri_set_message(s_pri_message); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief libpri state map */ -static zap_state_map_t isdn_state_map = { +static ftdm_state_map_t isdn_state_map = { { { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_ANY_STATE}, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END} + {FTDM_ANY_STATE}, + {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, - {ZAP_CHANNEL_STATE_DIALING, ZAP_END} + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, + {FTDM_CHANNEL_STATE_DIALING, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DIALING, ZAP_END}, - {ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_UP, ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END} + {FTDM_CHANNEL_STATE_DIALING, FTDM_END}, + {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_UP, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_PROGRESS, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_UP, ZAP_END} + {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_UP, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END} + {FTDM_CHANNEL_STATE_UP, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, /****************************************/ { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_ANY_STATE}, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END} + {FTDM_ANY_STATE}, + {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, - {ZAP_CHANNEL_STATE_DIALTONE, ZAP_CHANNEL_STATE_RING, ZAP_END} + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, + {FTDM_CHANNEL_STATE_DIALTONE, FTDM_CHANNEL_STATE_RING, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DIALTONE, ZAP_END}, - {ZAP_CHANNEL_STATE_RING, ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END} + {FTDM_CHANNEL_STATE_DIALTONE, FTDM_END}, + {FTDM_CHANNEL_STATE_RING, FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_UP, ZAP_END} + {FTDM_CHANNEL_STATE_RING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_UP, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, - ZAP_CHANNEL_STATE_CANCEL, ZAP_CHANNEL_STATE_UP, ZAP_END}, + {FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, + FTDM_CHANNEL_STATE_CANCEL, FTDM_CHANNEL_STATE_UP, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_UP, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, + {FTDM_CHANNEL_STATE_UP, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, }, @@ -415,172 +415,172 @@ static zap_state_map_t isdn_state_map = { /** * \brief Handler for channel state change - * \param zchan Channel to handle + * \param ftdmchan Channel to handle */ -static __inline__ void state_advance(zap_channel_t *zchan) +static __inline__ void state_advance(ftdm_channel_t *ftdmchan) { - //Q931mes_Generic *gen = (Q931mes_Generic *) zchan->caller_data.raw_data; - zap_libpri_data_t *isdn_data = zchan->span->signal_data; - zap_status_t status; - zap_sigmsg_t sig; - q931_call *call = (q931_call *) zchan->call_data; + //Q931mes_Generic *gen = (Q931mes_Generic *) ftdmchan->caller_data.raw_data; + ftdm_libpri_data_t *isdn_data = ftdmchan->span->signal_data; + ftdm_status_t status; + ftdm_sigmsg_t sig; + q931_call *call = (q931_call *) ftdmchan->call_data; - zap_log(ZAP_LOG_DEBUG, "%d:%d STATE [%s]\n", - zchan->span_id, zchan->chan_id, zap_channel_state2str(zchan->state)); + ftdm_log(FTDM_LOG_DEBUG, "%d:%d STATE [%s]\n", + ftdmchan->span_id, ftdmchan->chan_id, ftdm_channel_state2str(ftdmchan->state)); #if 0 - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) && !call) { - zap_log(ZAP_LOG_WARNING, "NO CALL!!!!\n"); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) && !call) { + ftdm_log(FTDM_LOG_WARNING, "NO CALL!!!!\n"); } #endif memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; - switch (zchan->state) { - case ZAP_CHANNEL_STATE_DOWN: + switch (ftdmchan->state) { + case FTDM_CHANNEL_STATE_DOWN: { - zchan->call_data = NULL; - zap_channel_done(zchan); + ftdmchan->call_data = NULL; + ftdm_channel_done(ftdmchan); } break; - case ZAP_CHANNEL_STATE_PROGRESS: + case FTDM_CHANNEL_STATE_PROGRESS: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_PROGRESS; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_PROGRESS; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else if (call) { - pri_progress(isdn_data->spri.pri, call, zchan->chan_id, 1); + pri_progress(isdn_data->spri.pri, call, ftdmchan->chan_id, 1); } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } } break; - case ZAP_CHANNEL_STATE_PROGRESS_MEDIA: + case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_PROGRESS_MEDIA; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else if (call) { - pri_proceeding(isdn_data->spri.pri, call, zchan->chan_id, 1); + pri_proceeding(isdn_data->spri.pri, call, ftdmchan->chan_id, 1); } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } } break; - case ZAP_CHANNEL_STATE_RING: + case FTDM_CHANNEL_STATE_RING: { - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { if (call) { - pri_acknowledge(isdn_data->spri.pri, call, zchan->chan_id, 0); - sig.event_id = ZAP_SIGEVENT_START; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + pri_acknowledge(isdn_data->spri.pri, call, ftdmchan->chan_id, 0); + sig.event_id = FTDM_SIGEVENT_START; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } } } break; - case ZAP_CHANNEL_STATE_RESTART: + case FTDM_CHANNEL_STATE_RESTART: { - zchan->caller_data.hangup_cause = ZAP_CAUSE_NORMAL_UNSPECIFIED; - sig.event_id = ZAP_SIGEVENT_RESTART; + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_UNSPECIFIED; + sig.event_id = FTDM_SIGEVENT_RESTART; status = isdn_data->sig_cb(&sig); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; - case ZAP_CHANNEL_STATE_UP: + case FTDM_CHANNEL_STATE_UP: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_UP; - if ((status = isdn_data->sig_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_UP; + if ((status = isdn_data->sig_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else if (call) { pri_answer(isdn_data->spri.pri, call, 0, 1); } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } } break; - case ZAP_CHANNEL_STATE_DIALING: + case FTDM_CHANNEL_STATE_DIALING: if (isdn_data) { struct pri_sr *sr; int dp; if (!(call = pri_new_call(isdn_data->spri.pri))) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); return; } - dp = zchan->caller_data.ani.type; + dp = ftdmchan->caller_data.ani.type; switch(dp) { - case ZAP_TON_NATIONAL: + case FTDM_TON_NATIONAL: dp = PRI_NATIONAL_ISDN; break; - case ZAP_TON_INTERNATIONAL: + case FTDM_TON_INTERNATIONAL: dp = PRI_INTERNATIONAL_ISDN; break; - case ZAP_TON_SUBSCRIBER_NUMBER: + case FTDM_TON_SUBSCRIBER_NUMBER: dp = PRI_LOCAL_ISDN; break; default: dp = isdn_data->dp; } - zchan->call_data = call; + ftdmchan->call_data = call; sr = pri_sr_new(); assert(sr); - pri_sr_set_channel(sr, zchan->chan_id, 0, 0); + pri_sr_set_channel(sr, ftdmchan->chan_id, 0, 0); pri_sr_set_bearer(sr, 0, isdn_data->l1); - pri_sr_set_called(sr, zchan->caller_data.ani.digits, dp, 1); - pri_sr_set_caller(sr, zchan->caller_data.cid_num.digits, (isdn_data->opts & OZMOD_LIBPRI_OPT_OMIT_DISPLAY_IE ? NULL : zchan->caller_data.cid_name), - dp, (zchan->caller_data.pres != 1 ? PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN : PRES_PROHIB_USER_NUMBER_NOT_SCREENED)); + pri_sr_set_called(sr, ftdmchan->caller_data.ani.digits, dp, 1); + pri_sr_set_caller(sr, ftdmchan->caller_data.cid_num.digits, (isdn_data->opts & FTMOD_LIBPRI_OPT_OMIT_DISPLAY_IE ? NULL : ftdmchan->caller_data.cid_name), + dp, (ftdmchan->caller_data.pres != 1 ? PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN : PRES_PROHIB_USER_NUMBER_NOT_SCREENED)); - if (!(isdn_data->opts & OZMOD_LIBPRI_OPT_OMIT_REDIRECTING_NUMBER_IE)) { - pri_sr_set_redirecting(sr, zchan->caller_data.cid_num.digits, dp, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, PRI_REDIR_UNCONDITIONAL); + if (!(isdn_data->opts & FTMOD_LIBPRI_OPT_OMIT_REDIRECTING_NUMBER_IE)) { + pri_sr_set_redirecting(sr, ftdmchan->caller_data.cid_num.digits, dp, PRES_ALLOWED_USER_NUMBER_PASSED_SCREEN, PRI_REDIR_UNCONDITIONAL); } if (pri_setup(isdn_data->spri.pri, call, sr)) { - zchan->caller_data.hangup_cause = ZAP_CAUSE_DESTINATION_OUT_OF_ORDER; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_DESTINATION_OUT_OF_ORDER; + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } pri_sr_free(sr); } break; - case ZAP_CHANNEL_STATE_HANGUP: + case FTDM_CHANNEL_STATE_HANGUP: { if (call) { - pri_hangup(isdn_data->spri.pri, call, zchan->caller_data.hangup_cause); + pri_hangup(isdn_data->spri.pri, call, ftdmchan->caller_data.hangup_cause); pri_destroycall(isdn_data->spri.pri, call); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } } break; - case ZAP_CHANNEL_STATE_HANGUP_COMPLETE: + case FTDM_CHANNEL_STATE_HANGUP_COMPLETE: break; - case ZAP_CHANNEL_STATE_TERMINATING: + case FTDM_CHANNEL_STATE_TERMINATING: { - sig.event_id = ZAP_SIGEVENT_STOP; + sig.event_id = FTDM_SIGEVENT_STOP; status = isdn_data->sig_cb(&sig); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } default: @@ -596,18 +596,18 @@ static __inline__ void state_advance(zap_channel_t *zchan) * \brief Checks current state on a span * \param span Span to check status on */ -static __inline__ void check_state(zap_span_t *span) +static __inline__ void check_state(ftdm_span_t *span) { - if (zap_test_flag(span, ZAP_SPAN_STATE_CHANGE)) { + if (ftdm_test_flag(span, FTDM_SPAN_STATE_CHANGE)) { uint32_t j; - zap_clear_flag_locked(span, ZAP_SPAN_STATE_CHANGE); + ftdm_clear_flag_locked(span, FTDM_SPAN_STATE_CHANGE); for(j = 1; j <= span->chan_count; j++) { - if (zap_test_flag((span->channels[j]), ZAP_CHANNEL_STATE_CHANGE)) { - zap_mutex_lock(span->channels[j]->mutex); - zap_clear_flag((span->channels[j]), ZAP_CHANNEL_STATE_CHANGE); + if (ftdm_test_flag((span->channels[j]), FTDM_CHANNEL_STATE_CHANGE)) { + ftdm_mutex_lock(span->channels[j]->mutex); + ftdm_clear_flag((span->channels[j]), FTDM_CHANNEL_STATE_CHANGE); state_advance(span->channels[j]); - zap_channel_complete_state(span->channels[j]); - zap_mutex_unlock(span->channels[j]->mutex); + ftdm_channel_complete_state(span->channels[j]); + ftdm_mutex_unlock(span->channels[j]->mutex); } } } @@ -623,9 +623,9 @@ static __inline__ void check_state(zap_span_t *span) static int on_info(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_log(ZAP_LOG_DEBUG, "number is: %s\n", pevent->ring.callednum); + ftdm_log(FTDM_LOG_DEBUG, "number is: %s\n", pevent->ring.callednum); if (strlen(pevent->ring.callednum) > 3) { - zap_log(ZAP_LOG_DEBUG, "final number is: %s\n", pevent->ring.callednum); + ftdm_log(FTDM_LOG_DEBUG, "final number is: %s\n", pevent->ring.callednum); pri_answer(spri->pri, pevent->ring.call, 0, 1); } return 0; @@ -640,21 +640,21 @@ static int on_info(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event */ static int on_hangup(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_span_t *span = spri->private_info; - zap_channel_t *zchan = NULL; + ftdm_span_t *span = spri->private_info; + ftdm_channel_t *ftdmchan = NULL; q931_call *call = NULL; - zchan = span->channels[pevent->hangup.channel]; + ftdmchan = span->channels[pevent->hangup.channel]; - if (zchan) { - call = (q931_call *) zchan->call_data; - zap_log(ZAP_LOG_DEBUG, "-- Hangup on channel %d:%d\n", spri->span->span_id, pevent->hangup.channel); - zchan->caller_data.hangup_cause = pevent->hangup.cause; + if (ftdmchan) { + call = (q931_call *) ftdmchan->call_data; + ftdm_log(FTDM_LOG_DEBUG, "-- Hangup on channel %d:%d\n", spri->span->span_id, pevent->hangup.channel); + ftdmchan->caller_data.hangup_cause = pevent->hangup.cause; pri_release(spri->pri, call, 0); pri_destroycall(spri->pri, call); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_TERMINATING); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING); } else { - zap_log(ZAP_LOG_DEBUG, "-- Hangup on channel %d:%d %s but it's not in use?\n", spri->span->span_id, - pevent->hangup.channel, zchan->chan_id); + ftdm_log(FTDM_LOG_DEBUG, "-- Hangup on channel %d:%d %s but it's not in use?\n", spri->span->span_id, + pevent->hangup.channel, ftdmchan->chan_id); } return 0; @@ -669,16 +669,16 @@ static int on_hangup(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_even */ static int on_answer(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_span_t *span = spri->private_info; - zap_channel_t *zchan = NULL; + ftdm_span_t *span = spri->private_info; + ftdm_channel_t *ftdmchan = NULL; - zchan = span->channels[pevent->answer.channel]; + ftdmchan = span->channels[pevent->answer.channel]; - if (zchan) { - zap_log(ZAP_LOG_DEBUG, "-- Answer on channel %d:%d\n", spri->span->span_id, pevent->answer.channel); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); + if (ftdmchan) { + ftdm_log(FTDM_LOG_DEBUG, "-- Answer on channel %d:%d\n", spri->span->span_id, pevent->answer.channel); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); } else { - zap_log(ZAP_LOG_DEBUG, "-- Answer on channel %d:%d %s but it's not in use?\n", spri->span->span_id, pevent->answer.channel, zchan->chan_id); + ftdm_log(FTDM_LOG_DEBUG, "-- Answer on channel %d:%d %s but it's not in use?\n", spri->span->span_id, pevent->answer.channel, ftdmchan->chan_id); } @@ -694,17 +694,17 @@ static int on_answer(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_even */ static int on_proceed(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_span_t *span = spri->private_info; - zap_channel_t *zchan = NULL; + ftdm_span_t *span = spri->private_info; + ftdm_channel_t *ftdmchan = NULL; - zchan = span->channels[pevent->proceeding.channel]; + ftdmchan = span->channels[pevent->proceeding.channel]; - if (zchan) { - zap_log(ZAP_LOG_DEBUG, "-- Proceeding on channel %d:%d\n", spri->span->span_id, pevent->proceeding.channel); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_PROGRESS_MEDIA); + if (ftdmchan) { + ftdm_log(FTDM_LOG_DEBUG, "-- Proceeding on channel %d:%d\n", spri->span->span_id, pevent->proceeding.channel); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } else { - zap_log(ZAP_LOG_DEBUG, "-- Proceeding on channel %d:%d %s but it's not in use?\n", spri->span->span_id, - pevent->proceeding.channel, zchan->chan_id); + ftdm_log(FTDM_LOG_DEBUG, "-- Proceeding on channel %d:%d %s but it's not in use?\n", spri->span->span_id, + pevent->proceeding.channel, ftdmchan->chan_id); } return 0; @@ -719,22 +719,22 @@ static int on_proceed(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_eve */ static int on_ringing(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_span_t *span = spri->private_info; - zap_channel_t *zchan = NULL; + ftdm_span_t *span = spri->private_info; + ftdm_channel_t *ftdmchan = NULL; - zchan = span->channels[pevent->ringing.channel]; + ftdmchan = span->channels[pevent->ringing.channel]; - if (zchan) { - zap_log(ZAP_LOG_DEBUG, "-- Ringing on channel %d:%d\n", spri->span->span_id, pevent->ringing.channel); - /* we may get on_ringing even when we're already in ZAP_CHANNEL_STATE_PROGRESS_MEDIA */ - if (zchan->state == ZAP_CHANNEL_STATE_PROGRESS_MEDIA) { + if (ftdmchan) { + ftdm_log(FTDM_LOG_DEBUG, "-- Ringing on channel %d:%d\n", spri->span->span_id, pevent->ringing.channel); + /* we may get on_ringing even when we're already in FTDM_CHANNEL_STATE_PROGRESS_MEDIA */ + if (ftdmchan->state == FTDM_CHANNEL_STATE_PROGRESS_MEDIA) { /* dont try to move to STATE_PROGRESS to avoid annoying veto warning */ return 0; } - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_PROGRESS); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } else { - zap_log(ZAP_LOG_DEBUG, "-- Ringing on channel %d:%d %s but it's not in use?\n", spri->span->span_id, - pevent->ringing.channel, zchan->chan_id); + ftdm_log(FTDM_LOG_DEBUG, "-- Ringing on channel %d:%d %s but it's not in use?\n", spri->span->span_id, + pevent->ringing.channel, ftdmchan->chan_id); } return 0; @@ -749,48 +749,48 @@ static int on_ringing(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_eve */ static int on_ring(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_span_t *span = spri->private_info; - zap_channel_t *zchan = NULL; + ftdm_span_t *span = spri->private_info; + ftdm_channel_t *ftdmchan = NULL; int ret = 0; //switch_mutex_lock(globals.channel_mutex); - zchan = span->channels[pevent->ring.channel]; - if (!zchan || zchan->state != ZAP_CHANNEL_STATE_DOWN || zap_test_flag(zchan, ZAP_CHANNEL_INUSE)) { - zap_log(ZAP_LOG_WARNING, "--Duplicate Ring on channel %d:%d (ignored)\n", spri->span->span_id, pevent->ring.channel); + ftdmchan = span->channels[pevent->ring.channel]; + if (!ftdmchan || ftdmchan->state != FTDM_CHANNEL_STATE_DOWN || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE)) { + ftdm_log(FTDM_LOG_WARNING, "--Duplicate Ring on channel %d:%d (ignored)\n", spri->span->span_id, pevent->ring.channel); ret = 0; goto done; } - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_WARNING, "--Failure opening channel %d:%d (ignored)\n", spri->span->span_id, pevent->ring.channel); + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_WARNING, "--Failure opening channel %d:%d (ignored)\n", spri->span->span_id, pevent->ring.channel); ret = 0; goto done; } - zap_log(ZAP_LOG_NOTICE, "-- Ring on channel %d:%d (from %s to %s)\n", spri->span->span_id, pevent->ring.channel, + ftdm_log(FTDM_LOG_NOTICE, "-- Ring on channel %d:%d (from %s to %s)\n", spri->span->span_id, pevent->ring.channel, pevent->ring.callingnum, pevent->ring.callednum); - memset(&zchan->caller_data, 0, sizeof(zchan->caller_data)); + memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data)); - zap_set_string(zchan->caller_data.cid_num.digits, (char *)pevent->ring.callingnum); - if (!zap_strlen_zero((char *)pevent->ring.callingname)) { - zap_set_string(zchan->caller_data.cid_name, (char *)pevent->ring.callingname); + ftdm_set_string(ftdmchan->caller_data.cid_num.digits, (char *)pevent->ring.callingnum); + if (!ftdm_strlen_zero((char *)pevent->ring.callingname)) { + ftdm_set_string(ftdmchan->caller_data.cid_name, (char *)pevent->ring.callingname); } else { - zap_set_string(zchan->caller_data.cid_name, (char *)pevent->ring.callingnum); + ftdm_set_string(ftdmchan->caller_data.cid_name, (char *)pevent->ring.callingnum); } - zap_set_string(zchan->caller_data.ani.digits, (char *)pevent->ring.callingani); - zap_set_string(zchan->caller_data.dnis.digits, (char *)pevent->ring.callednum); + ftdm_set_string(ftdmchan->caller_data.ani.digits, (char *)pevent->ring.callingani); + ftdm_set_string(ftdmchan->caller_data.dnis.digits, (char *)pevent->ring.callednum); if (pevent->ring.ani2 >= 0) { - snprintf(zchan->caller_data.aniII, 5, "%.2d", pevent->ring.ani2); + snprintf(ftdmchan->caller_data.aniII, 5, "%.2d", pevent->ring.ani2); } // scary to trust this pointer, you'd think they would give you a copy of the call data so you own it...... - zchan->call_data = pevent->ring.call; + ftdmchan->call_data = pevent->ring.call; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RING); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING); done: //switch_mutex_unlock(globals.channel_mutex); @@ -799,93 +799,93 @@ static int on_ring(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event } /** - * \brief Processes openzap event + * \brief Processes freetdm event * \param span Span on which the event was fired * \param event Event to be treated * \return Success or failure */ -static __inline__ zap_status_t process_event(zap_span_t *span, zap_event_t *event) +static __inline__ ftdm_status_t process_event(ftdm_span_t *span, ftdm_event_t *event) { - zap_sigmsg_t sig; - zap_libpri_data_t *isdn_data = span->signal_data; + ftdm_sigmsg_t sig; + ftdm_libpri_data_t *isdn_data = span->signal_data; memset(&sig, 0, sizeof(sig)); sig.chan_id = event->channel->chan_id; sig.span_id = event->channel->span_id; sig.channel = event->channel; - zap_log(ZAP_LOG_DEBUG, "EVENT [%s][%d][%d:%d] STATE [%s]\n", - zap_oob_event2str(event->enum_id), event->enum_id, event->channel->span_id, event->channel->chan_id, zap_channel_state2str(event->channel->state)); + ftdm_log(FTDM_LOG_DEBUG, "EVENT [%s][%d][%d:%d] STATE [%s]\n", + ftdm_oob_event2str(event->enum_id), event->enum_id, event->channel->span_id, event->channel->chan_id, ftdm_channel_state2str(event->channel->state)); switch(event->enum_id) { - case ZAP_OOB_ALARM_TRAP: + case FTDM_OOB_ALARM_TRAP: { - sig.event_id = ZAP_SIGEVENT_HWSTATUS_CHANGED; - sig.raw_data = (void *)ZAP_HW_LINK_CONNECTED; - if (event->channel->state != ZAP_CHANNEL_STATE_DOWN) { - if (event->channel->type == ZAP_CHAN_TYPE_B) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_RESTART); + sig.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED; + sig.raw_data = (void *)FTDM_HW_LINK_CONNECTED; + if (event->channel->state != FTDM_CHANNEL_STATE_DOWN) { + if (event->channel->type == FTDM_CHAN_TYPE_B) { + ftdm_set_state_locked(event->channel, FTDM_CHANNEL_STATE_RESTART); } } - zap_set_flag(event->channel, ZAP_CHANNEL_SUSPENDED); + ftdm_set_flag(event->channel, FTDM_CHANNEL_SUSPENDED); - zap_channel_get_alarms(event->channel); + ftdm_channel_get_alarms(event->channel); isdn_data->sig_cb(&sig); - zap_log(ZAP_LOG_WARNING, "channel %d:%d (%d:%d) has alarms! [%s]\n", + ftdm_log(FTDM_LOG_WARNING, "channel %d:%d (%d:%d) has alarms! [%s]\n", event->channel->span_id, event->channel->chan_id, event->channel->physical_span_id, event->channel->physical_chan_id, event->channel->last_error); } break; - case ZAP_OOB_ALARM_CLEAR: + case FTDM_OOB_ALARM_CLEAR: { - zap_log(ZAP_LOG_WARNING, "channel %d:%d (%d:%d) alarms Cleared!\n", event->channel->span_id, event->channel->chan_id, + ftdm_log(FTDM_LOG_WARNING, "channel %d:%d (%d:%d) alarms Cleared!\n", event->channel->span_id, event->channel->chan_id, event->channel->physical_span_id, event->channel->physical_chan_id); - sig.event_id = ZAP_SIGEVENT_HWSTATUS_CHANGED; - sig.raw_data = (void *)ZAP_HW_LINK_CONNECTED; - zap_clear_flag(event->channel, ZAP_CHANNEL_SUSPENDED); - zap_channel_get_alarms(event->channel); + sig.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED; + sig.raw_data = (void *)FTDM_HW_LINK_CONNECTED; + ftdm_clear_flag(event->channel, FTDM_CHANNEL_SUSPENDED); + ftdm_channel_get_alarms(event->channel); isdn_data->sig_cb(&sig); } break; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Checks for events on a span * \param span Span to check for events */ -static __inline__ void check_events(zap_span_t *span) +static __inline__ void check_events(ftdm_span_t *span) { - zap_status_t status; + ftdm_status_t status; - status = zap_span_poll_event(span, 5); + status = ftdm_span_poll_event(span, 5); switch(status) { - case ZAP_SUCCESS: + case FTDM_SUCCESS: { - zap_event_t *event; - while (zap_span_next_event(span, &event) == ZAP_SUCCESS) { - if (event->enum_id == ZAP_OOB_NOOP) { + ftdm_event_t *event; + while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) { + if (event->enum_id == FTDM_OOB_NOOP) { continue; } - if (process_event(span, event) != ZAP_SUCCESS) { + if (process_event(span, event) != FTDM_SUCCESS) { break; } } } break; - case ZAP_FAIL: + case FTDM_FAIL: { - zap_log(ZAP_LOG_DEBUG, "Event Failure! %d\n", zap_running()); - zap_sleep(2000); + ftdm_log(FTDM_LOG_DEBUG, "Event Failure! %d\n", ftdm_running()); + ftdm_sleep(2000); } break; default: @@ -900,9 +900,9 @@ static __inline__ void check_events(zap_span_t *span) */ static int check_flags(lpwrap_pri_t *spri) { - zap_span_t *span = spri->private_info; + ftdm_span_t *span = spri->private_info; - if (!zap_running() || zap_test_flag(span, ZAP_SPAN_STOP_THREAD)) { + if (!ftdm_running() || ftdm_test_flag(span, FTDM_SPAN_STOP_THREAD)) { return -1; } @@ -922,21 +922,21 @@ static int check_flags(lpwrap_pri_t *spri) */ static int on_restart(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_span_t *span = spri->private_info; - zap_channel_t *zchan; + ftdm_span_t *span = spri->private_info; + ftdm_channel_t *ftdmchan; - zap_log(ZAP_LOG_NOTICE, "-- Restarting %d:%d\n", spri->span->span_id, pevent->restart.channel); + ftdm_log(FTDM_LOG_NOTICE, "-- Restarting %d:%d\n", spri->span->span_id, pevent->restart.channel); - zchan = span->channels[pevent->restart.channel]; + ftdmchan = span->channels[pevent->restart.channel]; - if (!zchan) { + if (!ftdmchan) { return 0; } if (pevent->restart.channel < 1) { - zap_set_state_all(zchan->span, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_all(ftdmchan->span, FTDM_CHANNEL_STATE_RESTART); } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART); } return 0; @@ -952,10 +952,10 @@ static int on_restart(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_eve static int on_dchan_up(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - if (!zap_test_flag(spri, LPWRAP_PRI_READY)) { - zap_log(ZAP_LOG_INFO, "Span %d D-Chan UP!\n", spri->span->span_id); - zap_set_flag(spri, LPWRAP_PRI_READY); - zap_set_state_all(spri->span, ZAP_CHANNEL_STATE_RESTART); + if (!ftdm_test_flag(spri, LPWRAP_PRI_READY)) { + ftdm_log(FTDM_LOG_INFO, "Span %d D-Chan UP!\n", spri->span->span_id); + ftdm_set_flag(spri, LPWRAP_PRI_READY); + ftdm_set_state_all(spri->span, FTDM_CHANNEL_STATE_RESTART); } return 0; @@ -971,10 +971,10 @@ static int on_dchan_up(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_ev static int on_dchan_down(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - if (zap_test_flag(spri, LPWRAP_PRI_READY)) { - zap_log(ZAP_LOG_INFO, "Span %d D-Chan DOWN!\n", spri->span->span_id); - zap_clear_flag(spri, LPWRAP_PRI_READY); - zap_set_state_all(spri->span, ZAP_CHANNEL_STATE_RESTART); + if (ftdm_test_flag(spri, LPWRAP_PRI_READY)) { + ftdm_log(FTDM_LOG_INFO, "Span %d D-Chan DOWN!\n", spri->span->span_id); + ftdm_clear_flag(spri, LPWRAP_PRI_READY); + ftdm_set_state_all(spri->span, FTDM_CHANNEL_STATE_RESTART); } @@ -991,7 +991,7 @@ static int on_dchan_down(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_ static int on_anything(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_log(ZAP_LOG_DEBUG, "Caught Event span %d %u (%s)\n", spri->span->span_id, event_type, lpwrap_pri_event_str(event_type)); + ftdm_log(FTDM_LOG_DEBUG, "Caught Event span %d %u (%s)\n", spri->span->span_id, event_type, lpwrap_pri_event_str(event_type)); return 0; } @@ -1005,7 +1005,7 @@ static int on_anything(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_ev static int on_io_fail(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent) { - zap_log(ZAP_LOG_DEBUG, "Caught Event span %d %u (%s)\n", spri->span->span_id, event_type, lpwrap_pri_event_str(event_type)); + ftdm_log(FTDM_LOG_DEBUG, "Caught Event span %d %u (%s)\n", spri->span->span_id, event_type, lpwrap_pri_event_str(event_type)); return 0; } @@ -1014,23 +1014,23 @@ static int on_io_fail(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_eve * \param me Current thread * \param obj Span to run in this thread */ -static void *zap_libpri_run(zap_thread_t *me, void *obj) +static void *ftdm_libpri_run(ftdm_thread_t *me, void *obj) { - zap_span_t *span = (zap_span_t *) obj; - zap_libpri_data_t *isdn_data = span->signal_data; + ftdm_span_t *span = (ftdm_span_t *) obj; + ftdm_libpri_data_t *isdn_data = span->signal_data; int i, x = 0; int down = 0; int got_d = 0; - zap_set_flag(span, ZAP_SPAN_IN_THREAD); + ftdm_set_flag(span, FTDM_SPAN_IN_THREAD); - while(zap_running() && !zap_test_flag(span, ZAP_SPAN_STOP_THREAD)) { + while(ftdm_running() && !ftdm_test_flag(span, FTDM_SPAN_STOP_THREAD)) { if (!got_d) { for(i = 1; i <= span->chan_count; i++) { - if (span->channels[i]->type == ZAP_CHAN_TYPE_DQ921) { - if (zap_channel_open(span->span_id, i, &isdn_data->dchan) == ZAP_SUCCESS) { - zap_log(ZAP_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, isdn_data->dchan->span_id, isdn_data->dchan->chan_id); - isdn_data->dchan->state = ZAP_CHANNEL_STATE_UP; + if (span->channels[i]->type == FTDM_CHAN_TYPE_DQ921) { + if (ftdm_channel_open(span->span_id, i, &isdn_data->dchan) == FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, isdn_data->dchan->span_id, isdn_data->dchan->chan_id); + isdn_data->dchan->state = FTDM_CHANNEL_STATE_UP; got_d = 1; x++; break; @@ -1064,8 +1064,8 @@ static void *zap_libpri_run(zap_thread_t *me, void *obj) LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_IO_FAIL, on_io_fail); if (down) { - zap_log(ZAP_LOG_INFO, "PRI back up on span %d\n", isdn_data->spri.span->span_id); - zap_set_state_all(span, ZAP_CHANNEL_STATE_RESTART); + ftdm_log(FTDM_LOG_INFO, "PRI back up on span %d\n", isdn_data->spri.span->span_id); + ftdm_set_state_all(span, FTDM_CHANNEL_STATE_RESTART); down = 0; } @@ -1075,14 +1075,14 @@ static void *zap_libpri_run(zap_thread_t *me, void *obj) } - if (!zap_running() || zap_test_flag(span, ZAP_SPAN_STOP_THREAD)) { + if (!ftdm_running() || ftdm_test_flag(span, FTDM_SPAN_STOP_THREAD)) { break; } - zap_log(ZAP_LOG_CRIT, "PRI down on span %d\n", isdn_data->spri.span->span_id); + ftdm_log(FTDM_LOG_CRIT, "PRI down on span %d\n", isdn_data->spri.span->span_id); if (!down) { - zap_set_state_all(span, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_all(span, FTDM_CHANNEL_STATE_RESTART); check_state(span); } @@ -1090,13 +1090,13 @@ static void *zap_libpri_run(zap_thread_t *me, void *obj) check_events(span); down++; - zap_sleep(5000); + ftdm_sleep(5000); } - zap_log(ZAP_LOG_DEBUG, "PRI thread ended on span %d\n", isdn_data->spri.span->span_id); + ftdm_log(FTDM_LOG_DEBUG, "PRI thread ended on span %d\n", isdn_data->spri.span->span_id); - zap_clear_flag(span, ZAP_SPAN_IN_THREAD); - zap_clear_flag(isdn_data, OZMOD_LIBPRI_RUNNING); + ftdm_clear_flag(span, FTDM_SPAN_IN_THREAD); + ftdm_clear_flag(isdn_data, FTMOD_LIBPRI_RUNNING); return NULL; } @@ -1108,23 +1108,23 @@ static void *zap_libpri_run(zap_thread_t *me, void *obj) * * Sets a stop flag and waits for the thread to end */ -static zap_status_t zap_libpri_stop(zap_span_t *span) +static ftdm_status_t ftdm_libpri_stop(ftdm_span_t *span) { - zap_libpri_data_t *isdn_data = span->signal_data; + ftdm_libpri_data_t *isdn_data = span->signal_data; - if (!zap_test_flag(isdn_data, OZMOD_LIBPRI_RUNNING)) { - return ZAP_FAIL; + if (!ftdm_test_flag(isdn_data, FTMOD_LIBPRI_RUNNING)) { + return FTDM_FAIL; } - zap_set_state_all(span, ZAP_CHANNEL_STATE_RESTART); + ftdm_set_state_all(span, FTDM_CHANNEL_STATE_RESTART); check_state(span); - zap_set_flag(span, ZAP_SPAN_STOP_THREAD); - while(zap_test_flag(span, ZAP_SPAN_IN_THREAD)) { - zap_sleep(100); + ftdm_set_flag(span, FTDM_SPAN_STOP_THREAD); + while(ftdm_test_flag(span, FTDM_SPAN_IN_THREAD)) { + ftdm_sleep(100); } check_state(span); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** @@ -1134,22 +1134,22 @@ static zap_status_t zap_libpri_stop(zap_span_t *span) * * Launches a thread to monitor the span */ -static zap_status_t zap_libpri_start(zap_span_t *span) +static ftdm_status_t ftdm_libpri_start(ftdm_span_t *span) { - zap_status_t ret; - zap_libpri_data_t *isdn_data = span->signal_data; + ftdm_status_t ret; + ftdm_libpri_data_t *isdn_data = span->signal_data; - if (zap_test_flag(isdn_data, OZMOD_LIBPRI_RUNNING)) { - return ZAP_FAIL; + if (ftdm_test_flag(isdn_data, FTMOD_LIBPRI_RUNNING)) { + return FTDM_FAIL; } - zap_clear_flag(span, ZAP_SPAN_STOP_THREAD); - zap_clear_flag(span, ZAP_SPAN_IN_THREAD); + ftdm_clear_flag(span, FTDM_SPAN_STOP_THREAD); + ftdm_clear_flag(span, FTDM_SPAN_IN_THREAD); - zap_set_flag(isdn_data, OZMOD_LIBPRI_RUNNING); - ret = zap_thread_create_detached(zap_libpri_run, span); + ftdm_set_flag(isdn_data, FTMOD_LIBPRI_RUNNING); + ret = ftdm_thread_create_detached(ftdm_libpri_run, span); - if (ret != ZAP_SUCCESS) { + if (ret != FTDM_SUCCESS) { return ret; } @@ -1237,29 +1237,29 @@ static int str2dp(char *dp) * \param ap List of configuration variables * \return Success or failure */ -static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span) +static ZIO_SIG_CONFIGURE_FUNCTION(ftdm_libpri_configure_span) { uint32_t i, x = 0; - //zap_channel_t *dchans[2] = {0}; - zap_libpri_data_t *isdn_data; + //ftdm_channel_t *dchans[2] = {0}; + ftdm_libpri_data_t *isdn_data; char *var, *val; char *debug = NULL; - if (span->trunk_type >= ZAP_TRUNK_NONE) { - zap_log(ZAP_LOG_WARNING, "Invalid trunk type '%s' defaulting to T1.\n", zap_trunk_type2str(span->trunk_type)); - span->trunk_type = ZAP_TRUNK_T1; + if (span->trunk_type >= FTDM_TRUNK_NONE) { + ftdm_log(FTDM_LOG_WARNING, "Invalid trunk type '%s' defaulting to T1.\n", ftdm_trunk_type2str(span->trunk_type)); + span->trunk_type = FTDM_TRUNK_T1; } for(i = 1; i <= span->chan_count; i++) { - if (span->channels[i]->type == ZAP_CHAN_TYPE_DQ921) { + if (span->channels[i]->type == FTDM_CHAN_TYPE_DQ921) { if (x > 1) { snprintf(span->last_error, sizeof(span->last_error), "Span has more than 2 D-Channels!"); - return ZAP_FAIL; + return FTDM_FAIL; } else { #if 0 - if (zap_channel_open(span->span_id, i, &dchans[x]) == ZAP_SUCCESS) { - zap_log(ZAP_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, dchans[x]->span_id, dchans[x]->chan_id); - dchans[x]->state = ZAP_CHANNEL_STATE_UP; + if (ftdm_channel_open(span->span_id, i, &dchans[x]) == FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_DEBUG, "opening d-channel #%d %d:%d\n", x, dchans[x]->span_id, dchans[x]->chan_id); + dchans[x]->state = FTDM_CHANNEL_STATE_UP; x++; } #endif @@ -1270,19 +1270,19 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span) #if 0 if (!x) { snprintf(span->last_error, sizeof(span->last_error), "Span has no D-Channels!"); - return ZAP_FAIL; + return FTDM_FAIL; } #endif - isdn_data = zap_malloc(sizeof(*isdn_data)); + isdn_data = ftdm_malloc(sizeof(*isdn_data)); assert(isdn_data != NULL); memset(isdn_data, 0, sizeof(*isdn_data)); - if (span->trunk_type == ZAP_TRUNK_E1) { - zap_log(ZAP_LOG_NOTICE, "Setting default Layer 1 to ALAW since this is an E1 trunk\n"); + if (span->trunk_type == FTDM_TRUNK_E1) { + ftdm_log(FTDM_LOG_NOTICE, "Setting default Layer 1 to ALAW since this is an E1 trunk\n"); isdn_data->l1 = PRI_LAYER_1_ALAW; - } else if (span->trunk_type == ZAP_TRUNK_T1) { - zap_log(ZAP_LOG_NOTICE, "Setting default Layer 1 to ULAW since this is a T1 trunk\n"); + } else if (span->trunk_type == FTDM_TRUNK_T1) { + ftdm_log(FTDM_LOG_NOTICE, "Setting default Layer 1 to ULAW since this is a T1 trunk\n"); isdn_data->l1 = PRI_LAYER_1_ULAW; } @@ -1294,7 +1294,7 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span) } node = str2node(val); if (-1 == node) { - zap_log(ZAP_LOG_ERROR, "Unknown node type %s, defaulting to CPE mode\n", val); + ftdm_log(FTDM_LOG_ERROR, "Unknown node type %s, defaulting to CPE mode\n", val); node = PRI_CPE; } isdn_data->node = node; @@ -1325,12 +1325,12 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span) debug = val; } else { snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); - return ZAP_FAIL; + return FTDM_FAIL; } } - span->start = zap_libpri_start; - span->stop = zap_libpri_stop; + span->start = ftdm_libpri_start; + span->stop = ftdm_libpri_stop; isdn_data->sig_cb = sig_cb; //isdn_data->dchans[0] = dchans[0]; //isdn_data->dchans[1] = dchans[1]; @@ -1340,28 +1340,28 @@ static ZIO_SIG_CONFIGURE_FUNCTION(zap_libpri_configure_span) span->signal_data = isdn_data; - span->signal_type = ZAP_SIGTYPE_ISDN; + span->signal_type = FTDM_SIGTYPE_ISDN; span->outgoing_call = isdn_outgoing_call; - if ((isdn_data->opts & OZMOD_LIBPRI_OPT_SUGGEST_CHANNEL)) { + if ((isdn_data->opts & FTMOD_LIBPRI_OPT_SUGGEST_CHANNEL)) { span->channel_request = isdn_channel_request; span->suggest_chan_id = 1; } span->state_map = &isdn_state_map; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Openzap libpri signaling and IO module definition + * \brief Openftdm libpri signaling and IO module definition */ -zap_module_t zap_module = { +ftdm_module_t ftdm_module = { "libpri", - zap_libpri_io_init, - zap_libpri_unload, - zap_libpri_init, - zap_libpri_configure_span, + ftdm_libpri_io_init, + ftdm_libpri_unload, + ftdm_libpri_init, + ftdm_libpri_configure_span, NULL }; diff --git a/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.h b/libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.h similarity index 76% rename from libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.h rename to libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.h index 4e33aba17d..3038624481 100644 --- a/libs/freetdm/src/ozmod/ozmod_libpri/ozmod_libpri.h +++ b/libs/freetdm/src/ftmod/ftmod_libpri/ftmod_libpri.h @@ -32,33 +32,33 @@ */ -#ifndef OZMOD_LIBPRI_H -#define OZMOD_LIBPRI_H -#include "openzap.h" +#ifndef FTMOD_LIBPRI_H +#define FTMOD_LIBPRI_H +#include "freetdm.h" #include "lpwrap_pri.h" typedef enum { - OZMOD_LIBPRI_OPT_NONE = 0, - OZMOD_LIBPRI_OPT_SUGGEST_CHANNEL = (1 << 0), - OZMOD_LIBPRI_OPT_OMIT_DISPLAY_IE = (1 << 1), - OZMOD_LIBPRI_OPT_OMIT_REDIRECTING_NUMBER_IE = (1 << 2), + FTMOD_LIBPRI_OPT_NONE = 0, + FTMOD_LIBPRI_OPT_SUGGEST_CHANNEL = (1 << 0), + FTMOD_LIBPRI_OPT_OMIT_DISPLAY_IE = (1 << 1), + FTMOD_LIBPRI_OPT_OMIT_REDIRECTING_NUMBER_IE = (1 << 2), - OZMOD_LIBPRI_OPT_MAX = (1 << 3) -} zap_isdn_opts_t; + FTMOD_LIBPRI_OPT_MAX = (1 << 3) +} ftdm_isdn_opts_t; typedef enum { - OZMOD_LIBPRI_RUNNING = (1 << 0) -} zap_isdn_flag_t; + FTMOD_LIBPRI_RUNNING = (1 << 0) +} ftdm_isdn_flag_t; -struct zap_libpri_data { - zap_channel_t *dchan; - zap_channel_t *dchans[2]; - struct zap_sigmsg sigmsg; +struct ftdm_libpri_data { + ftdm_channel_t *dchan; + ftdm_channel_t *dchans[2]; + struct ftdm_sigmsg sigmsg; zio_signal_cb_t sig_cb; uint32_t flags; int32_t mode; - zap_isdn_opts_t opts; + ftdm_isdn_opts_t opts; int node; int pswitch; @@ -71,16 +71,16 @@ struct zap_libpri_data { lpwrap_pri_t spri; }; -typedef struct zap_libpri_data zap_libpri_data_t; +typedef struct ftdm_libpri_data ftdm_libpri_data_t; /* b-channel private data */ -struct zap_isdn_bchan_data +struct ftdm_isdn_bchan_data { int32_t digit_timeout; }; -typedef struct zap_isdn_bchan_data zap_isdn_bchan_data_t; +typedef struct ftdm_isdn_bchan_data ftdm_isdn_bchan_data_t; #endif diff --git a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.c b/libs/freetdm/src/ftmod/ftmod_libpri/lpwrap_pri.c similarity index 85% rename from libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.c rename to libs/freetdm/src/ftmod/ftmod_libpri/lpwrap_pri.c index 3df1d54d89..de6a311ef9 100644 --- a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.c +++ b/libs/freetdm/src/ftmod/ftmod_libpri/lpwrap_pri.c @@ -33,7 +33,7 @@ //#define IODEBUG -#include "openzap.h" +#include "freetdm.h" #include "lpwrap_pri.h" #ifndef HAVE_GETTIMEOFDAY @@ -113,19 +113,19 @@ const char *lpwrap_pri_event_str(lpwrap_pri_event_t event_id) static int __pri_lpwrap_read(struct pri *pri, void *buf, int buflen) { struct lpwrap_pri *spri = (struct lpwrap_pri *) pri_get_userdata(pri); - zap_size_t len = buflen; + ftdm_size_t len = buflen; int res; - zap_status_t zst; + ftdm_status_t zst; - if ((zst = zap_channel_read(spri->dchan, buf, &len)) != ZAP_SUCCESS) { - if (zst == ZAP_FAIL) { - zap_log(ZAP_LOG_CRIT, "span %d D-READ FAIL! [%s]\n", spri->span->span_id, spri->dchan->last_error); + if ((zst = ftdm_channel_read(spri->dchan, buf, &len)) != FTDM_SUCCESS) { + if (zst == FTDM_FAIL) { + ftdm_log(FTDM_LOG_CRIT, "span %d D-READ FAIL! [%s]\n", spri->span->span_id, spri->dchan->last_error); spri->errs++; } else { - zap_log(ZAP_LOG_CRIT, "span %d D-READ TIMEOUT\n", spri->span->span_id); + ftdm_log(FTDM_LOG_CRIT, "span %d D-READ TIMEOUT\n", spri->span->span_id); } - zap_clear_flag(spri, LPWRAP_PRI_READY); + ftdm_clear_flag(spri, LPWRAP_PRI_READY); return -1; } spri->errs = 0; @@ -138,7 +138,7 @@ static int __pri_lpwrap_read(struct pri *pri, void *buf, int buflen) char bb[2048] = { 0 }; print_hex_bytes(buf, res - 2, bb, sizeof(bb)); - zap_log(ZAP_LOG_DEBUG, "READ %d\n", res-2); + ftdm_log(FTDM_LOG_DEBUG, "READ %d\n", res-2); } #endif @@ -148,11 +148,11 @@ static int __pri_lpwrap_read(struct pri *pri, void *buf, int buflen) static int __pri_lpwrap_write(struct pri *pri, void *buf, int buflen) { struct lpwrap_pri *spri = (struct lpwrap_pri *) pri_get_userdata(pri); - zap_size_t len = buflen -2; + ftdm_size_t len = buflen -2; - if (zap_channel_write(spri->dchan, buf, buflen, &len) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_CRIT, "span %d D-WRITE FAIL! [%s]\n", spri->span->span_id, spri->dchan->last_error); - zap_clear_flag(spri, LPWRAP_PRI_READY); + if (ftdm_channel_write(spri->dchan, buf, buflen, &len) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_CRIT, "span %d D-WRITE FAIL! [%s]\n", spri->span->span_id, spri->dchan->last_error); + ftdm_clear_flag(spri, LPWRAP_PRI_READY); return -1; } @@ -161,14 +161,14 @@ static int __pri_lpwrap_write(struct pri *pri, void *buf, int buflen) char bb[2048] = { 0 }; print_hex_bytes(buf, buflen - 2, bb, sizeof(bb)); - zap_log(ZAP_LOG_DEBUG, "WRITE %d\n", (int)buflen-2); + ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n", (int)buflen-2); } #endif return (int) buflen; } -int lpwrap_init_pri(struct lpwrap_pri *spri, zap_span_t *span, zap_channel_t *dchan, int swtype, int node, int debug) +int lpwrap_init_pri(struct lpwrap_pri *spri, ftdm_span_t *span, ftdm_channel_t *dchan, int swtype, int node, int debug) { int ret = -1; @@ -182,8 +182,8 @@ int lpwrap_init_pri(struct lpwrap_pri *spri, zap_span_t *span, zap_channel_t *dc size_t buflen = sizeof(buf), len = 0; pri_set_debug(spri->pri, debug); ret = 0; - zap_set_flag(spri, LPWRAP_PRI_READY); - zap_channel_write(spri->dchan, buf, buflen, &len); + ftdm_set_flag(spri, LPWRAP_PRI_READY); + ftdm_channel_write(spri->dchan, buf, buflen, &len); } else { fprintf(stderr, "Unable to create PRI\n"); } @@ -238,7 +238,7 @@ int lpwrap_one_loop(struct lpwrap_pri *spri) if ((next = pri_schedule_next(spri->pri))) { gettimeofday(&now, NULL); if (now.tv_sec >= next->tv_sec && (now.tv_usec >= next->tv_usec || next->tv_usec <= 100000)) { - //zap_log(ZAP_LOG_DEBUG, "Check event\n"); + //ftdm_log(FTDM_LOG_DEBUG, "Check event\n"); event = pri_schedule_run(spri->pri); } } @@ -251,7 +251,7 @@ int lpwrap_one_loop(struct lpwrap_pri *spri) if ((handler = spri->eventmap[event->e] ? spri->eventmap[event->e] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) { handler(spri, event->e, event); } else { - zap_log(ZAP_LOG_CRIT, "No event handler found for event %d.\n", event->e); + ftdm_log(FTDM_LOG_CRIT, "No event handler found for event %d.\n", event->e); } } @@ -281,7 +281,7 @@ int lpwrap_run_pri(struct lpwrap_pri *spri) continue; } #endif - zap_log(ZAP_LOG_CRIT, "Error = %i [%s]\n", ret, strerror(errno)); + ftdm_log(FTDM_LOG_CRIT, "Error = %i [%s]\n", ret, strerror(errno)); break; } } diff --git a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.h b/libs/freetdm/src/ftmod/ftmod_libpri/lpwrap_pri.h similarity index 95% rename from libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.h rename to libs/freetdm/src/ftmod/ftmod_libpri/lpwrap_pri.h index 4c79526b9e..f92c5bbafa 100644 --- a/libs/freetdm/src/ozmod/ozmod_libpri/lpwrap_pri.h +++ b/libs/freetdm/src/ftmod/ftmod_libpri/lpwrap_pri.h @@ -34,7 +34,7 @@ #ifndef _LPWRAP_PRI_H #define _LPWRAP_PRI_H #include -#include +#include #define LPWRAP_MAX_CHAN_PER_SPAN 32 @@ -97,8 +97,8 @@ typedef int (*loop_handler)(struct lpwrap_pri *); struct lpwrap_pri { struct pri *pri; - zap_span_t *span; - zap_channel_t *dchan; + ftdm_span_t *span; + ftdm_channel_t *dchan; unsigned int flags; void *private_info; event_handler eventmap[LPWRAP_PRI_EVENT_MAX]; @@ -120,7 +120,7 @@ struct lpwrap_pri_event_list { const char *lpwrap_pri_event_str(lpwrap_pri_event_t event_id); int lpwrap_one_loop(struct lpwrap_pri *spri); -int lpwrap_init_pri(struct lpwrap_pri *spri, zap_span_t *span, zap_channel_t *dchan, int swtype, int node, int debug); +int lpwrap_init_pri(struct lpwrap_pri *spri, ftdm_span_t *span, ftdm_channel_t *dchan, int swtype, int node, int debug); int lpwrap_run_pri(struct lpwrap_pri *spri); #endif diff --git a/libs/freetdm/src/ozmod/ozmod_pika/zap_pika.h b/libs/freetdm/src/ftmod/ftmod_pika/ftdm_pika.h similarity index 98% rename from libs/freetdm/src/ozmod/ozmod_pika/zap_pika.h rename to libs/freetdm/src/ftmod/ftmod_pika/ftdm_pika.h index 27c455a429..882eaba411 100644 --- a/libs/freetdm/src/ozmod/ozmod_pika/zap_pika.h +++ b/libs/freetdm/src/ftmod/ftmod_pika/ftdm_pika.h @@ -31,9 +31,9 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ZAP_PIKA_H -#define ZAP_PIKA_H -#include "openzap.h" +#ifndef FTDM_PIKA_H +#define FTDM_PIKA_H +#include "freetdm.h" #include "pikahmpapi.h" diff --git a/libs/freetdm/src/ozmod/ozmod_pika/ozmod_pika.c b/libs/freetdm/src/ftmod/ftmod_pika/ftmod_pika.c similarity index 67% rename from libs/freetdm/src/ozmod/ozmod_pika/ozmod_pika.c rename to libs/freetdm/src/ftmod/ftmod_pika/ftmod_pika.c index 2932a342e7..06ea9f1353 100644 --- a/libs/freetdm/src/ozmod/ozmod_pika/ozmod_pika.c +++ b/libs/freetdm/src/ftmod/ftmod_pika/ftmod_pika.c @@ -32,8 +32,8 @@ */ -#include "openzap.h" -#include "zap_pika.h" +#include "freetdm.h" +#include "ftdm_pika.h" #define MAX_NUMBER_OF_TRUNKS 64 @@ -45,19 +45,19 @@ PK_VOID PK_CALLBACK media_out_callback(PKH_TPikaEvent *event); -ZAP_ENUM_NAMES(PIKA_SPAN_NAMES, PIKA_SPAN_STRINGS) +FTDM_ENUM_NAMES(PIKA_SPAN_NAMES, PIKA_SPAN_STRINGS) PIKA_STR2ENUM(pika_str2span, pika_span2str, PIKA_TSpanFraming, PIKA_SPAN_NAMES, PIKA_SPAN_INVALID) -ZAP_ENUM_NAMES(PIKA_SPAN_ENCODING_NAMES, PIKA_SPAN_ENCODING_STRINGS) +FTDM_ENUM_NAMES(PIKA_SPAN_ENCODING_NAMES, PIKA_SPAN_ENCODING_STRINGS) PIKA_STR2ENUM(pika_str2span_encoding, pika_span_encoding2str, PIKA_TSpanEncoding, PIKA_SPAN_ENCODING_NAMES, PIKA_SPAN_ENCODING_INVALID) -ZAP_ENUM_NAMES(PIKA_LL_NAMES, PIKA_LL_STRINGS) +FTDM_ENUM_NAMES(PIKA_LL_NAMES, PIKA_LL_STRINGS) PIKA_STR2ENUM(pika_str2loop_length, pika_loop_length2str, PIKA_TSpanLoopLength, PIKA_LL_NAMES, PIKA_SPAN_LOOP_INVALID) -ZAP_ENUM_NAMES(PIKA_LBO_NAMES, PIKA_LBO_STRINGS) +FTDM_ENUM_NAMES(PIKA_LBO_NAMES, PIKA_LBO_STRINGS) PIKA_STR2ENUM(pika_str2lbo, pika_lbo2str, PIKA_TSpanBuildOut, PIKA_LBO_NAMES, PIKA_SPAN_LBO_INVALID) -ZAP_ENUM_NAMES(PIKA_SPAN_COMPAND_MODE_NAMES, PIKA_SPAN_COMPAND_MODE_STRINGS) +FTDM_ENUM_NAMES(PIKA_SPAN_COMPAND_MODE_NAMES, PIKA_SPAN_COMPAND_MODE_STRINGS) PIKA_STR2ENUM(pika_str2compand_mode, pika_compand_mode2str, PIKA_TSpanCompandMode, PIKA_SPAN_COMPAND_MODE_NAMES, PIKA_SPAN_COMPAND_MODE_INVALID) @@ -93,7 +93,7 @@ static struct { PKH_TECConfig ec_config; PKH_TSpanConfig t1_span_config; PKH_TSpanConfig e1_span_config; - zap_hash_t *profile_hash; + ftdm_hash_t *profile_hash; general_config_t general_config; } globals; @@ -121,9 +121,9 @@ struct pika_chan_data { int ec_enabled; PKH_TECConfig ec_config; PKH_THDLCConfig hdlc_config; - zap_buffer_t *digit_buffer; - zap_mutex_t *digit_mutex; - zap_size_t dtmf_len; + ftdm_buffer_t *digit_buffer; + ftdm_mutex_t *digit_mutex; + ftdm_size_t dtmf_len; uint32_t flags; uint32_t hdlc_bytes; }; @@ -156,20 +156,20 @@ static ZIO_CONFIGURE_FUNCTION(pika_configure) int ok = 1; if (!(profile = (pika_channel_profile_t *) hashtable_search(globals.profile_hash, (char *)category))) { - profile = zap_malloc(sizeof(*profile)); + profile = ftdm_malloc(sizeof(*profile)); memset(profile, 0, sizeof(*profile)); - zap_set_string(profile->name, category); + ftdm_set_string(profile->name, category); profile->ec_config = globals.ec_config; profile->record_config = globals.record_config; profile->play_config = globals.play_config; hashtable_insert(globals.profile_hash, (void *)profile->name, profile, HASHTABLE_FLAG_NONE); - zap_log(ZAP_LOG_INFO, "creating profile [%s]\n", category); + ftdm_log(FTDM_LOG_INFO, "creating profile [%s]\n", category); } if (!strcasecmp(var, "rx-gain")) { profile->record_config.gain = pk_atof(val); } else if (!strcasecmp(var, "rx-agc-enabled")) { - profile->record_config.AGC.enabled = zap_true(val); + profile->record_config.AGC.enabled = ftdm_true(val); } else if (!strcasecmp(var, "rx-agc-targetPower")) { profile->record_config.AGC.targetPower = pk_atof(val); } else if (!strcasecmp(var, "rx-agc-minGain")) { @@ -183,7 +183,7 @@ static ZIO_CONFIGURE_FUNCTION(pika_configure) } else if (!strcasecmp(var, "rx-agc-speechThreshold")) { profile->record_config.AGC.speechThreshold = pk_atof(val); } else if (!strcasecmp(var, "rx-vad-enabled")) { - profile->record_config.VAD.enabled = zap_true(val); + profile->record_config.VAD.enabled = ftdm_true(val); } else if (!strcasecmp(var, "rx-vad-activationThreshold")) { profile->record_config.VAD.activationThreshold = pk_atof(val); } else if (!strcasecmp(var, "rx-vad-activationDebounceTime")) { @@ -197,7 +197,7 @@ static ZIO_CONFIGURE_FUNCTION(pika_configure) } else if (!strcasecmp(var, "tx-gain")) { profile->play_config.gain = pk_atof(val); } else if (!strcasecmp(var, "tx-agc-enabled")) { - profile->play_config.AGC.enabled = zap_true(val); + profile->play_config.AGC.enabled = ftdm_true(val); } else if (!strcasecmp(var, "tx-agc-targetPower")) { profile->play_config.AGC.targetPower = pk_atof(val); } else if (!strcasecmp(var, "tx-agc-minGain")) { @@ -211,7 +211,7 @@ static ZIO_CONFIGURE_FUNCTION(pika_configure) } else if (!strcasecmp(var, "tx-agc-speechThreshold")) { profile->play_config.AGC.speechThreshold = pk_atof(val); } else if (!strcasecmp(var, "ec-enabled")) { - profile->ec_enabled = zap_true(val); + profile->ec_enabled = ftdm_true(val); } else if (!strcasecmp(var, "ec-doubleTalkerThreshold")) { profile->ec_config.doubleTalkerThreshold = pk_atof(val); } else if (!strcasecmp(var, "ec-speechPresentThreshold")) { @@ -219,11 +219,11 @@ static ZIO_CONFIGURE_FUNCTION(pika_configure) } else if (!strcasecmp(var, "ec-echoSuppressionThreshold")) { profile->ec_config.echoSuppressionThreshold = pk_atof(val); } else if (!strcasecmp(var, "ec-echoSuppressionEnabled")) { - profile->ec_config.echoSuppressionEnabled = zap_true(val); + profile->ec_config.echoSuppressionEnabled = ftdm_true(val); } else if (!strcasecmp(var, "ec-comfortNoiseEnabled")) { - profile->ec_config.comfortNoiseEnabled = zap_true(val); + profile->ec_config.comfortNoiseEnabled = ftdm_true(val); } else if (!strcasecmp(var, "ec-adaptationModeEnabled")) { - profile->ec_config.adaptationModeEnabled = zap_true(val); + profile->ec_config.adaptationModeEnabled = ftdm_true(val); } else if (!strcasecmp(var, "framing")) { profile->span_config.framing = pika_str2span(val); profile->cust_span++; @@ -250,12 +250,12 @@ static ZIO_CONFIGURE_FUNCTION(pika_configure) } if (ok) { - zap_log(ZAP_LOG_INFO, "setting param [%s]=[%s] for profile [%s]\n", var, val, category); + ftdm_log(FTDM_LOG_INFO, "setting param [%s]=[%s] for profile [%s]\n", var, val, category); } else { - zap_log(ZAP_LOG_ERROR, "unknown param [%s]\n", var); + ftdm_log(FTDM_LOG_ERROR, "unknown param [%s]\n", var); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** @@ -265,22 +265,22 @@ static ZIO_CONFIGURE_FUNCTION(pika_configure) PK_VOID PK_CALLBACK media_out_callback(PKH_TPikaEvent *event) { PK_STATUS pk_status; - zap_channel_t *zchan = event->userData; - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; + ftdm_channel_t *ftdmchan = event->userData; + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; //PK_CHAR event_text[PKH_EVENT_MAX_NAME_LENGTH]; //PKH_EVENT_GetText(event->id, event_text, sizeof(event_text)); - //zap_log(ZAP_LOG_DEBUG, "Event: %s\n", event_text); + //ftdm_log(FTDM_LOG_DEBUG, "Event: %s\n", event_text); switch (event->id) { case PKH_EVENT_PLAY_IDLE: { - while (zap_buffer_inuse(chan_data->digit_buffer)) { + while (ftdm_buffer_inuse(chan_data->digit_buffer)) { char dtmf[128] = ""; - zap_mutex_lock(chan_data->digit_mutex); - chan_data->dtmf_len = zap_buffer_read(chan_data->digit_buffer, dtmf, sizeof(dtmf)); + ftdm_mutex_lock(chan_data->digit_mutex); + chan_data->dtmf_len = ftdm_buffer_read(chan_data->digit_buffer, dtmf, sizeof(dtmf)); pk_status = PKH_TG_PlayDTMF(chan_data->media_out, dtmf); - zap_mutex_unlock(chan_data->digit_mutex); + ftdm_mutex_unlock(chan_data->digit_mutex); } } break; @@ -288,10 +288,10 @@ PK_VOID PK_CALLBACK media_out_callback(PKH_TPikaEvent *event) { if (!event->p1) { - zap_mutex_lock(chan_data->digit_mutex); + ftdm_mutex_lock(chan_data->digit_mutex); PKH_PLAY_Start(chan_data->media_out); chan_data->dtmf_len = 0; - zap_mutex_unlock(chan_data->digit_mutex); + ftdm_mutex_unlock(chan_data->digit_mutex); } @@ -305,19 +305,19 @@ PK_VOID PK_CALLBACK media_out_callback(PKH_TPikaEvent *event) /** * \brief Initialises a range of pika channels - * \param span Openzap span + * \param span Openftdm span * \param boardno Pika board number * \param spanno Pika span number * \param start Initial pika channel number * \param end Final pika channel number - * \param type Openzap channel type - * \param name Openzap span name - * \param number Openzap span number + * \param type Openftdm channel type + * \param name Openftdm span name + * \param number Openftdm span number * \param profile Pika channel profile * \return number of spans configured */ -static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spanno, unsigned start, unsigned end, - zap_chan_type_t type, char *name, char *number, pika_channel_profile_t *profile) +static unsigned pika_open_range(ftdm_span_t *span, unsigned boardno, unsigned spanno, unsigned start, unsigned end, + ftdm_chan_type_t type, char *name, char *number, pika_channel_profile_t *profile) { unsigned configured = 0, x; PK_STATUS status; @@ -325,7 +325,7 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa pika_span_data_t *span_data; if (boardno >= globals.board_list.numberOfBoards) { - zap_log(ZAP_LOG_ERROR, "Board %u is not present!\n", boardno); + ftdm_log(FTDM_LOG_ERROR, "Board %u is not present!\n", boardno); return 0; } @@ -334,12 +334,12 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa NULL, &globals.open_boards[boardno]); if(status != PK_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error: PKH_BOARD_Open %d failed(%s)!\n", boardno, + ftdm_log(FTDM_LOG_ERROR, "Error: PKH_BOARD_Open %d failed(%s)!\n", boardno, PKH_ERROR_GetText(status, error_text, sizeof(error_text))); return 0; } - zap_log(ZAP_LOG_DEBUG, "Open board %u\n", boardno); + ftdm_log(FTDM_LOG_DEBUG, "Open board %u\n", boardno); //PKH_BOARD_SetDebugTrace(globals.open_boards[boardno], 1, 0); @@ -348,7 +348,7 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa if (span->mod_data) { span_data = span->mod_data; } else { - span_data = zap_malloc(sizeof(*span_data)); + span_data = ftdm_malloc(sizeof(*span_data)); assert(span_data != NULL); memset(span_data, 0, sizeof(*span_data)); span_data->boardno = boardno; @@ -356,9 +356,9 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa status = PKH_QUEUE_Create(PKH_QUEUE_TYPE_NORMAL, &span_data->event_queue); if (status != PK_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error: PKH_QUEUE_Create failed(%s)!\n", + ftdm_log(FTDM_LOG_ERROR, "Error: PKH_QUEUE_Create failed(%s)!\n", PKH_ERROR_GetText(status, error_text, sizeof(error_text))); - zap_safe_free(span_data); + ftdm_safe_free(span_data); return 0; } @@ -367,43 +367,43 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa span->mod_data = span_data; } - if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO) { + if (type == FTDM_CHAN_TYPE_FXS || type == FTDM_CHAN_TYPE_FXO) { start--; end--; } for(x = start; x < end; x++) { - zap_channel_t *chan; + ftdm_channel_t *chan; pika_chan_data_t *chan_data = NULL; - chan_data = zap_malloc(sizeof *chan_data); + chan_data = ftdm_malloc(sizeof *chan_data); assert(chan_data); memset(chan_data, 0, sizeof(*chan_data)); - zap_span_add_channel(span, 0, type, &chan); + ftdm_span_add_channel(span, 0, type, &chan); chan->mod_data = chan_data; - if ((type == ZAP_CHAN_TYPE_B || type == ZAP_CHAN_TYPE_DQ921) && !span_data->handle) { + if ((type == FTDM_CHAN_TYPE_B || type == FTDM_CHAN_TYPE_DQ921) && !span_data->handle) { PKH_TBoardConfig boardConfig; TRY_OR_DIE(PKH_BOARD_GetConfig(globals.open_boards[boardno], &boardConfig), PK_SUCCESS, error); - if ((profile && profile->general_config.region == PKH_TRUNK_EU) || zap_test_flag(span_data, PK_FLAG_LOCKED)) { - if (span->trunk_type == ZAP_TRUNK_T1) { - zap_log(ZAP_LOG_WARNING, "Changing trunk type to E1 based on previous config.\n"); + if ((profile && profile->general_config.region == PKH_TRUNK_EU) || ftdm_test_flag(span_data, PK_FLAG_LOCKED)) { + if (span->trunk_type == FTDM_TRUNK_T1) { + ftdm_log(FTDM_LOG_WARNING, "Changing trunk type to E1 based on previous config.\n"); } - span->trunk_type = ZAP_TRUNK_E1; + span->trunk_type = FTDM_TRUNK_E1; } - if (span->trunk_type == ZAP_TRUNK_T1) { - if (zap_test_flag(span_data, PK_FLAG_LOCKED)) { - zap_log(ZAP_LOG_WARNING, "Already locked into E1 mode!\n"); + if (span->trunk_type == FTDM_TRUNK_T1) { + if (ftdm_test_flag(span_data, PK_FLAG_LOCKED)) { + ftdm_log(FTDM_LOG_WARNING, "Already locked into E1 mode!\n"); } - } else if (span->trunk_type == ZAP_TRUNK_E1) { + } else if (span->trunk_type == FTDM_TRUNK_E1) { boardConfig.specific.DigitalGateway.interfaceType = PKH_BOARD_INTERFACE_TYPE_E1; if ((status = PKH_BOARD_SetConfig(globals.open_boards[boardno], &boardConfig)) != PK_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error: [%s]\n", + ftdm_log(FTDM_LOG_ERROR, "Error: [%s]\n", PKH_ERROR_GetText(status, error_text, sizeof(error_text))); } - zap_set_flag(span_data, PK_FLAG_LOCKED); + ftdm_set_flag(span_data, PK_FLAG_LOCKED); } TRY_OR_DIE(PKH_SPAN_Open(globals.open_boards[boardno], spanno, NULL, &span_data->handle), PK_SUCCESS, error); @@ -411,7 +411,7 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa TRY_OR_DIE(PKH_QUEUE_Attach(span_data->event_queue, span_data->handle, (PK_VOID*) span), PK_SUCCESS, error); } - if (type == ZAP_CHAN_TYPE_FXO) { + if (type == FTDM_CHAN_TYPE_FXO) { PKH_TTrunkConfig trunkConfig; TRY_OR_DIE(PKH_TRUNK_Open(globals.open_boards[boardno], x, &chan_data->handle), PK_SUCCESS, error); @@ -422,10 +422,10 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa trunkConfig.internationalControl = PKH_PHONE_INTERNATIONAL_CONTROL_EU; trunkConfig.audioFormat = PKH_AUDIO_ALAW; trunkConfig.compandMode = PKH_PHONE_AUDIO_ALAW; - chan->native_codec = chan->effective_codec = ZAP_CODEC_ALAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ALAW; TRY_OR_DIE(PKH_TRUNK_SetConfig(chan_data->handle, &trunkConfig), PK_SUCCESS, error); } else { - chan->native_codec = chan->effective_codec = ZAP_CODEC_ULAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ULAW; } @@ -437,17 +437,17 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa TRY_OR_DIE(PKH_QUEUE_SetEventHandler(chan_data->media_out_queue, media_out_callback), PK_SUCCESS, error); TRY_OR_DIE(PKH_QUEUE_Attach(chan_data->media_out_queue, chan_data->media_out, (PK_VOID*) chan), PK_SUCCESS, error); TRY_OR_DIE(PKH_TRUNK_Start(chan_data->handle), PK_SUCCESS, error); - } else if (type == ZAP_CHAN_TYPE_FXS) { + } else if (type == FTDM_CHAN_TYPE_FXS) { PKH_TPhoneConfig phoneConfig; if (profile && profile->general_config.region == PKH_TRUNK_EU) { TRY_OR_DIE(PKH_PHONE_GetConfig(chan_data->handle, &phoneConfig), PK_SUCCESS, error); phoneConfig.internationalControl = PKH_PHONE_INTERNATIONAL_CONTROL_EU; phoneConfig.compandMode = PKH_PHONE_AUDIO_ALAW; - chan->native_codec = chan->effective_codec = ZAP_CODEC_ALAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ALAW; TRY_OR_DIE(PKH_PHONE_SetConfig(chan_data->handle, &phoneConfig), PK_SUCCESS, error); } else { - chan->native_codec = chan->effective_codec = ZAP_CODEC_ULAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ULAW; } TRY_OR_DIE(PKH_PHONE_Open(globals.open_boards[boardno], x, &chan_data->handle), PK_SUCCESS, error); @@ -460,7 +460,7 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa TRY_OR_DIE(PKH_QUEUE_SetEventHandler(chan_data->media_out_queue, media_out_callback), PK_SUCCESS, error); TRY_OR_DIE(PKH_QUEUE_Attach(chan_data->media_out_queue, chan_data->media_out, (PK_VOID*) chan), PK_SUCCESS, error); TRY_OR_DIE(PKH_PHONE_Start(chan_data->handle), PK_SUCCESS, error); - } else if (type == ZAP_CHAN_TYPE_B) { + } else if (type == FTDM_CHAN_TYPE_B) { TRY_OR_DIE(PKH_SPAN_SeizeChannel(span_data->handle, x), PK_SUCCESS, error); TRY_OR_DIE(PKH_SPAN_GetMediaStreams(span_data->handle, x, &chan_data->media_in, &chan_data->media_out), PK_SUCCESS, error); TRY_OR_DIE(PKH_QUEUE_Create(PKH_QUEUE_TYPE_NORMAL, &chan_data->media_in_queue), PK_SUCCESS, error); @@ -468,7 +468,7 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa TRY_OR_DIE(PKH_QUEUE_Create(PKH_QUEUE_TYPE_CALLBACK, &chan_data->media_out_queue), PK_SUCCESS, error); TRY_OR_DIE(PKH_QUEUE_SetEventHandler(chan_data->media_out_queue, media_out_callback), PK_SUCCESS, error); TRY_OR_DIE(PKH_QUEUE_Attach(chan_data->media_out_queue, chan_data->media_out, (PK_VOID*) chan), PK_SUCCESS, error); - } else if (type == ZAP_CHAN_TYPE_DQ921) { + } else if (type == FTDM_CHAN_TYPE_DQ921) { TRY_OR_DIE(PKH_SPAN_HDLC_Open(span_data->handle, PKH_SPAN_HDLC_MODE_NORMAL, &chan_data->handle), PK_SUCCESS, error); TRY_OR_DIE(PKH_SPAN_HDLC_GetConfig(chan_data->handle, &chan_data->hdlc_config), PK_SUCCESS, error); chan_data->hdlc_config.channelId = x; @@ -492,7 +492,7 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa } } } else { - if (span->trunk_type == ZAP_TRUNK_E1) { + if (span->trunk_type == FTDM_TRUNK_E1) { span_data->span_config = globals.e1_span_config; } else { span_data->span_config = globals.t1_span_config; @@ -507,10 +507,10 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa error: PKH_ERROR_GetText(status, error_text, sizeof(error_text)); - zap_log(ZAP_LOG_ERROR, "failure configuring device b%ds%dc%d [%s]\n", boardno, spanno, x, error_text); + ftdm_log(FTDM_LOG_ERROR, "failure configuring device b%ds%dc%d [%s]\n", boardno, spanno, x, error_text); continue; ok: - zap_set_flag(chan_data, PK_FLAG_READY); + ftdm_set_flag(chan_data, PK_FLAG_READY); status = PKH_RECORD_GetConfig(chan_data->media_in, &chan_data->record_config); chan_data->record_config.encoding = PKH_RECORD_ENCODING_MU_LAW; chan_data->record_config.samplingRate = PKH_RECORD_SAMPLING_RATE_8KHZ; @@ -524,10 +524,10 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa chan_data->play_config.encoding = PKH_RECORD_ENCODING_MU_LAW; chan_data->play_config.samplingRate = PKH_RECORD_SAMPLING_RATE_8KHZ; chan_data->play_config.AGC.enabled = PK_FALSE; - zap_log(ZAP_LOG_INFO, "configuring device b%ds%dc%d as OpenZAP device %d:%d\n", boardno, spanno, x, chan->span_id, chan->chan_id); + ftdm_log(FTDM_LOG_INFO, "configuring device b%ds%dc%d as OpenFTDM device %d:%d\n", boardno, spanno, x, chan->span_id, chan->chan_id); if (profile) { - zap_log(ZAP_LOG_INFO, "applying config profile %s to device %d:%d\n", profile->name, chan->span_id, chan->chan_id); + ftdm_log(FTDM_LOG_INFO, "applying config profile %s to device %d:%d\n", profile->name, chan->span_id, chan->chan_id); chan_data->record_config.gain = profile->record_config.gain; chan_data->record_config.AGC = profile->record_config.AGC; chan_data->record_config.VAD = profile->record_config.VAD; @@ -537,11 +537,11 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa chan_data->ec_config = profile->ec_config; } - if (type == ZAP_CHAN_TYPE_B) { + if (type == FTDM_CHAN_TYPE_B) { if (span_data->span_config.compandMode == PKH_SPAN_COMPAND_MODE_A_LAW) { - chan->native_codec = chan->effective_codec = ZAP_CODEC_ALAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ALAW; } else { - chan->native_codec = chan->effective_codec = ZAP_CODEC_ULAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ULAW; } } @@ -562,17 +562,17 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa PKH_EC_Start(chan_data->media_in, chan_data->media_in, chan_data->media_out); } - if (!zap_strlen_zero(name)) { - zap_copy_string(chan->chan_name, name, sizeof(chan->chan_name)); + if (!ftdm_strlen_zero(name)) { + ftdm_copy_string(chan->chan_name, name, sizeof(chan->chan_name)); } - if (!zap_strlen_zero(number)) { - zap_copy_string(chan->chan_number, number, sizeof(chan->chan_number)); + if (!ftdm_strlen_zero(number)) { + ftdm_copy_string(chan->chan_number, number, sizeof(chan->chan_number)); } - zap_channel_set_feature(chan, ZAP_CHANNEL_FEATURE_DTMF_GENERATE); - zap_buffer_create(&chan_data->digit_buffer, 128, 128, 0); - zap_mutex_create(&chan_data->digit_mutex); + ftdm_channel_set_feature(chan, FTDM_CHANNEL_FEATURE_DTMF_GENERATE); + ftdm_buffer_create(&chan_data->digit_buffer, 128, 128, 0); + ftdm_mutex_create(&chan_data->digit_mutex); configured++; } @@ -582,12 +582,12 @@ static unsigned pika_open_range(zap_span_t *span, unsigned boardno, unsigned spa } /** - * \brief Initialises an openzap pika span from a configuration string - * \param span Openzap span + * \brief Initialises an freetdm pika span from a configuration string + * \param span Openftdm span * \param str Configuration string - * \param type Openzap span type - * \param name Openzap span name - * \param number Openzap span number + * \param type Openftdm span type + * \param name Openftdm span name + * \param number Openftdm span number * \return Success or failure */ static ZIO_CONFIGURE_SPAN_FUNCTION(pika_configure_span) @@ -605,17 +605,17 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(pika_configure_span) assert(str != NULL); - mydata = zap_strdup(str); + mydata = ftdm_strdup(str); assert(mydata != NULL); if ((profile_name = strchr(mydata, '@'))) { *profile_name++ = '\0'; - if (!zap_strlen_zero(profile_name)) { + if (!ftdm_strlen_zero(profile_name)) { profile = (pika_channel_profile_t *) hashtable_search(globals.profile_hash, (char *)profile_name); } } - items = zap_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); + items = ftdm_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); for(i = 0; i < items; i++) { bd = item_list[i]; @@ -627,7 +627,7 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(pika_configure_span) } if (!(bd && sp && ch)) { - zap_log(ZAP_LOG_ERROR, "Invalid input\n"); + ftdm_log(FTDM_LOG_ERROR, "Invalid input\n"); continue; } @@ -637,17 +637,17 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(pika_configure_span) if (boardno < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid board number %d\n", boardno); + ftdm_log(FTDM_LOG_ERROR, "Invalid board number %d\n", boardno); continue; } if (channo < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid channel number %d\n", channo); + ftdm_log(FTDM_LOG_ERROR, "Invalid channel number %d\n", channo); continue; } if (spanno < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid span number %d\n", channo); + ftdm_log(FTDM_LOG_ERROR, "Invalid span number %d\n", channo); continue; } @@ -660,7 +660,7 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(pika_configure_span) if (top < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid range number %d\n", top); + ftdm_log(FTDM_LOG_ERROR, "Invalid range number %d\n", top); continue; } @@ -668,108 +668,108 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(pika_configure_span) } - zap_safe_free(mydata); + ftdm_safe_free(mydata); return configured; } /** * \brief Opens Pika channel - * \param zchan Channel to open + * \param ftdmchan Channel to open * \return Success or failure */ static ZIO_OPEN_FUNCTION(pika_open) { - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; - if (!chan_data && !zap_test_flag(chan_data, PK_FLAG_READY)) { - return ZAP_FAIL; + if (!chan_data && !ftdm_test_flag(chan_data, PK_FLAG_READY)) { + return FTDM_FAIL; } if (chan_data->media_in_queue) { PKH_QUEUE_Flush(chan_data->media_in_queue); } - if (zchan->type == ZAP_CHAN_TYPE_FXS || zchan->type == ZAP_CHAN_TYPE_FXO || zchan->type == ZAP_CHAN_TYPE_B) { + if (ftdmchan->type == FTDM_CHAN_TYPE_FXS || ftdmchan->type == FTDM_CHAN_TYPE_FXO || ftdmchan->type == FTDM_CHAN_TYPE_B) { PKH_PLAY_Start(chan_data->media_out); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Closes Pika channel - * \param zchan Channel to close + * \param ftdmchan Channel to close * \return Success */ static ZIO_CLOSE_FUNCTION(pika_close) { - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Waits for an event on a Pika channel - * \param zchan Channel to open + * \param ftdmchan Channel to open * \param flags Type of event to wait for * \param to Time to wait (in ms) * \return Success, failure or timeout */ static ZIO_WAIT_FUNCTION(pika_wait) { - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; PK_STATUS status; - zap_wait_flag_t myflags = *flags; + ftdm_wait_flag_t myflags = *flags; PK_CHAR event_text[PKH_EVENT_MAX_NAME_LENGTH]; - *flags = ZAP_NO_FLAGS; + *flags = FTDM_NO_FLAGS; - if (myflags & ZAP_READ) { + if (myflags & FTDM_READ) { if (chan_data->hdlc_bytes) { - *flags |= ZAP_READ; - return ZAP_SUCCESS; + *flags |= FTDM_READ; + return FTDM_SUCCESS; } status = PKH_QUEUE_WaitOnEvent(chan_data->media_in_queue, to, &chan_data->last_media_event); if (status == PK_SUCCESS) { if (chan_data->last_media_event.id == PKH_EVENT_QUEUE_TIMEOUT || chan_data->last_media_event.id == PKH_EVENT_RECORD_BUFFER_OVERFLOW) { - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; } - *flags |= ZAP_READ; - return ZAP_SUCCESS; + *flags |= FTDM_READ; + return FTDM_SUCCESS; } PKH_EVENT_GetText(chan_data->last_media_event.id, event_text, sizeof(event_text)); - zap_log(ZAP_LOG_DEBUG, "Event: %s\n", event_text); + ftdm_log(FTDM_LOG_DEBUG, "Event: %s\n", event_text); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Reads data from a Pika channel - * \param zchan Channel to read from + * \param ftdmchan Channel to read from * \param data Data buffer * \param datalen Size of data buffer * \return Success or failure */ static ZIO_READ_FUNCTION(pika_read) { - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; PK_STATUS status; PK_CHAR event_text[PKH_EVENT_MAX_NAME_LENGTH]; uint32_t len; - if (zchan->type == ZAP_CHAN_TYPE_DQ921) { + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921) { if ((status = PKH_SPAN_HDLC_GetMessage(chan_data->handle, data, *datalen)) == PK_SUCCESS) { *datalen = chan_data->hdlc_bytes; chan_data->hdlc_bytes = 0; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_FAIL; + return FTDM_FAIL; } if (!(len = chan_data->last_media_event.p0)) { - len = zchan->packet_len; + len = ftdmchan->packet_len; } if (len < *datalen) { @@ -777,167 +777,167 @@ static ZIO_READ_FUNCTION(pika_read) } if ((status = PKH_RECORD_GetData(chan_data->media_in, data, *datalen)) == PK_SUCCESS) { - return ZAP_SUCCESS; + return FTDM_SUCCESS; } PKH_ERROR_GetText(status, event_text, sizeof(event_text)); - zap_log(ZAP_LOG_DEBUG, "ERR: %s\n", event_text); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_DEBUG, "ERR: %s\n", event_text); + return FTDM_FAIL; } /** * \brief Writes data to a Pika channel - * \param zchan Channel to write to + * \param ftdmchan Channel to write to * \param data Data buffer * \param datalen Size of data buffer * \return Success or failure */ static ZIO_WRITE_FUNCTION(pika_write) { - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; PK_STATUS status; - if (zchan->type == ZAP_CHAN_TYPE_DQ921) { + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921) { if ((status = PKH_SPAN_HDLC_SendMessage(chan_data->handle, data, *datalen)) == PK_SUCCESS) { - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_FAIL; + return FTDM_FAIL; } if (PKH_PLAY_AddData(chan_data->media_out, 0, data, *datalen) == PK_SUCCESS) { - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_FAIL; + return FTDM_FAIL; } /** - * \brief Executes an Openzap command on a Pika channel - * \param zchan Channel to execute command on - * \param command Openzap command to execute + * \brief Executes an Openftdm command on a Pika channel + * \param ftdmchan Channel to execute command on + * \param command Openftdm command to execute * \param obj Object (unused) * \return Success or failure */ static ZIO_COMMAND_FUNCTION(pika_command) { - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; - //pika_span_data_t *span_data = (pika_span_data_t *) zchan->span->mod_data; + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; + //pika_span_data_t *span_data = (pika_span_data_t *) ftdmchan->span->mod_data; PK_STATUS pk_status; - zap_status_t status = ZAP_SUCCESS; + ftdm_status_t status = FTDM_SUCCESS; switch(command) { - case ZAP_COMMAND_OFFHOOK: + case FTDM_COMMAND_OFFHOOK: { if ((pk_status = PKH_TRUNK_SetHookSwitch(chan_data->handle, PKH_TRUNK_OFFHOOK)) != PK_SUCCESS) { - PKH_ERROR_GetText(pk_status, zchan->last_error, sizeof(zchan->last_error)); - GOTO_STATUS(done, ZAP_FAIL); + PKH_ERROR_GetText(pk_status, ftdmchan->last_error, sizeof(ftdmchan->last_error)); + GOTO_STATUS(done, FTDM_FAIL); } else { - zap_set_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK); } } break; - case ZAP_COMMAND_ONHOOK: + case FTDM_COMMAND_ONHOOK: { if ((pk_status = PKH_TRUNK_SetHookSwitch(chan_data->handle, PKH_TRUNK_ONHOOK)) != PK_SUCCESS) { - PKH_ERROR_GetText(pk_status, zchan->last_error, sizeof(zchan->last_error)); - GOTO_STATUS(done, ZAP_FAIL); + PKH_ERROR_GetText(pk_status, ftdmchan->last_error, sizeof(ftdmchan->last_error)); + GOTO_STATUS(done, FTDM_FAIL); } else { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK); } } break; - case ZAP_COMMAND_GENERATE_RING_ON: + case FTDM_COMMAND_GENERATE_RING_ON: { if ((pk_status = PKH_PHONE_RingStart(chan_data->handle, 0, 0)) != PK_SUCCESS) { - PKH_ERROR_GetText(pk_status, zchan->last_error, sizeof(zchan->last_error)); - GOTO_STATUS(done, ZAP_FAIL); + PKH_ERROR_GetText(pk_status, ftdmchan->last_error, sizeof(ftdmchan->last_error)); + GOTO_STATUS(done, FTDM_FAIL); } else { - zap_set_flag_locked(zchan, ZAP_CHANNEL_RINGING); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING); } } break; - case ZAP_COMMAND_GENERATE_RING_OFF: + case FTDM_COMMAND_GENERATE_RING_OFF: { if ((pk_status = PKH_PHONE_RingStop(chan_data->handle)) != PK_SUCCESS) { - PKH_ERROR_GetText(pk_status, zchan->last_error, sizeof(zchan->last_error)); - GOTO_STATUS(done, ZAP_FAIL); + PKH_ERROR_GetText(pk_status, ftdmchan->last_error, sizeof(ftdmchan->last_error)); + GOTO_STATUS(done, FTDM_FAIL); } else { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_RINGING); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING); } } break; - case ZAP_COMMAND_GET_INTERVAL: + case FTDM_COMMAND_GET_INTERVAL: { - ZAP_COMMAND_OBJ_INT = zchan->native_interval; + FTDM_COMMAND_OBJ_INT = ftdmchan->native_interval; } break; - case ZAP_COMMAND_SET_INTERVAL: + case FTDM_COMMAND_SET_INTERVAL: { - int interval = ZAP_COMMAND_OBJ_INT; + int interval = FTDM_COMMAND_OBJ_INT; int len = interval * 8; chan_data->record_config.bufferSize = len; chan_data->record_config.numberOfBuffers = (PK_UINT)chan_data->record_config.bufferSize; - zchan->packet_len = (uint32_t)chan_data->record_config.bufferSize; - zchan->effective_interval = zchan->native_interval = zchan->packet_len / 8; + ftdmchan->packet_len = (uint32_t)chan_data->record_config.bufferSize; + ftdmchan->effective_interval = ftdmchan->native_interval = ftdmchan->packet_len / 8; PKH_RECORD_SetConfig(chan_data->media_in, &chan_data->record_config); - GOTO_STATUS(done, ZAP_SUCCESS); + GOTO_STATUS(done, FTDM_SUCCESS); } break; - case ZAP_COMMAND_GET_DTMF_ON_PERIOD: + case FTDM_COMMAND_GET_DTMF_ON_PERIOD: { - ZAP_COMMAND_OBJ_INT = zchan->dtmf_on; - GOTO_STATUS(done, ZAP_SUCCESS); + FTDM_COMMAND_OBJ_INT = ftdmchan->dtmf_on; + GOTO_STATUS(done, FTDM_SUCCESS); } break; - case ZAP_COMMAND_GET_DTMF_OFF_PERIOD: + case FTDM_COMMAND_GET_DTMF_OFF_PERIOD: { - ZAP_COMMAND_OBJ_INT = zchan->dtmf_on; - GOTO_STATUS(done, ZAP_SUCCESS); + FTDM_COMMAND_OBJ_INT = ftdmchan->dtmf_on; + GOTO_STATUS(done, FTDM_SUCCESS); } break; - case ZAP_COMMAND_SET_DTMF_ON_PERIOD: + case FTDM_COMMAND_SET_DTMF_ON_PERIOD: { - int val = ZAP_COMMAND_OBJ_INT; + int val = FTDM_COMMAND_OBJ_INT; if (val > 10 && val < 1000) { - zchan->dtmf_on = val; - GOTO_STATUS(done, ZAP_SUCCESS); + ftdmchan->dtmf_on = val; + GOTO_STATUS(done, FTDM_SUCCESS); } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "invalid value %d range 10-1000", val); - GOTO_STATUS(done, ZAP_FAIL); + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "invalid value %d range 10-1000", val); + GOTO_STATUS(done, FTDM_FAIL); } } break; - case ZAP_COMMAND_SET_DTMF_OFF_PERIOD: + case FTDM_COMMAND_SET_DTMF_OFF_PERIOD: { - int val = ZAP_COMMAND_OBJ_INT; + int val = FTDM_COMMAND_OBJ_INT; if (val > 10 && val < 1000) { - zchan->dtmf_off = val; - GOTO_STATUS(done, ZAP_SUCCESS); + ftdmchan->dtmf_off = val; + GOTO_STATUS(done, FTDM_SUCCESS); } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "invalid value %d range 10-1000", val); - GOTO_STATUS(done, ZAP_FAIL); + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "invalid value %d range 10-1000", val); + GOTO_STATUS(done, FTDM_FAIL); } } break; - case ZAP_COMMAND_SEND_DTMF: + case FTDM_COMMAND_SEND_DTMF: { - char *digits = ZAP_COMMAND_OBJ_CHAR_P; - zap_log(ZAP_LOG_DEBUG, "Adding DTMF SEQ [%s]\n", digits); - zap_mutex_lock(chan_data->digit_mutex); - zap_buffer_write(chan_data->digit_buffer, digits, strlen(digits)); - zap_mutex_unlock(chan_data->digit_mutex); + char *digits = FTDM_COMMAND_OBJ_CHAR_P; + ftdm_log(FTDM_LOG_DEBUG, "Adding DTMF SEQ [%s]\n", digits); + ftdm_mutex_lock(chan_data->digit_mutex); + ftdm_buffer_write(chan_data->digit_buffer, digits, strlen(digits)); + ftdm_mutex_unlock(chan_data->digit_mutex); pk_status = PKH_PLAY_Stop(chan_data->media_out); if (pk_status != PK_SUCCESS) { - PKH_ERROR_GetText(pk_status, zchan->last_error, sizeof(zchan->last_error)); - GOTO_STATUS(done, ZAP_FAIL); + PKH_ERROR_GetText(pk_status, ftdmchan->last_error, sizeof(ftdmchan->last_error)); + GOTO_STATUS(done, FTDM_FAIL); } - GOTO_STATUS(done, ZAP_SUCCESS); + GOTO_STATUS(done, FTDM_SUCCESS); } break; default: @@ -963,22 +963,22 @@ static ZIO_SPAN_POLL_EVENT_FUNCTION(pika_poll_event) status = PKH_QUEUE_WaitOnEvent(span_data->event_queue, ms, &span_data->last_oob_event); if (status == PK_SUCCESS) { - zap_channel_t *zchan = NULL; + ftdm_channel_t *ftdmchan = NULL; uint32_t *data = (uint32_t *) span_data->last_oob_event.userData; - zap_data_type_t data_type = ZAP_TYPE_NONE; + ftdm_data_type_t data_type = FTDM_TYPE_NONE; if (span_data->last_oob_event.id == PKH_EVENT_QUEUE_TIMEOUT) { - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; } if (data) { data_type = *data; } - if (data_type == ZAP_TYPE_CHANNEL) { - zchan = span_data->last_oob_event.userData; - } else if (data_type == ZAP_TYPE_SPAN) { - zap_time_t last_event_time = zap_current_time_in_ms(); + if (data_type == FTDM_TYPE_CHANNEL) { + ftdmchan = span_data->last_oob_event.userData; + } else if (data_type == FTDM_TYPE_SPAN) { + ftdm_time_t last_event_time = ftdm_current_time_in_ms(); uint32_t event_id = 0; switch (span_data->last_oob_event.id) { @@ -996,7 +996,7 @@ static ZIO_SPAN_POLL_EVENT_FUNCTION(pika_poll_event) case PKH_EVENT_SPAN_LOSS_OF_SIGNAL: case PKH_EVENT_SPAN_OUT_OF_CRC_MF_SYNC: case PKH_EVENT_SPAN_OUT_OF_CAS_MF_SYNC: - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_T1_RED_CLEAR: case PKH_EVENT_SPAN_ALARM_T1_YELLOW_CLEAR: @@ -1011,7 +1011,7 @@ static ZIO_SPAN_POLL_EVENT_FUNCTION(pika_poll_event) case PKH_EVENT_SPAN_LOSS_OF_SIGNAL_CLEAR: case PKH_EVENT_SPAN_IN_CRC_MF_SYNC: case PKH_EVENT_SPAN_IN_CAS_MF_SYNC: - event_id = ZAP_OOB_ALARM_CLEAR; + event_id = FTDM_OOB_ALARM_CLEAR; break; case PKH_EVENT_SPAN_MESSAGE: case PKH_EVENT_SPAN_ABCD_SIGNAL_CHANGE: @@ -1020,17 +1020,17 @@ static ZIO_SPAN_POLL_EVENT_FUNCTION(pika_poll_event) if (event_id) { uint32_t x = 0; - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; pika_chan_data_t *chan_data; for(x = 1; x <= span->chan_count; x++) { - zchan = span->channels[x]; - assert(zchan != NULL); - chan_data = (pika_chan_data_t *) zchan->mod_data; + ftdmchan = span->channels[x]; + assert(ftdmchan != NULL); + chan_data = (pika_chan_data_t *) ftdmchan->mod_data; assert(chan_data != NULL); - zap_set_flag(zchan, ZAP_CHANNEL_EVENT); - zchan->last_event_time = last_event_time; + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_EVENT); + ftdmchan->last_event_time = last_event_time; chan_data->last_oob_event = span_data->last_oob_event; } @@ -1039,27 +1039,27 @@ static ZIO_SPAN_POLL_EVENT_FUNCTION(pika_poll_event) } PKH_EVENT_GetText(span_data->last_oob_event.id, event_text, sizeof(event_text)); - //zap_log(ZAP_LOG_DEBUG, "Event: %s\n", event_text); + //ftdm_log(FTDM_LOG_DEBUG, "Event: %s\n", event_text); - if (zchan) { - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; + if (ftdmchan) { + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; assert(chan_data != NULL); - zap_set_flag(zchan, ZAP_CHANNEL_EVENT); - zchan->last_event_time = zap_current_time_in_ms(); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_EVENT); + ftdmchan->last_event_time = ftdm_current_time_in_ms(); chan_data->last_oob_event = span_data->last_oob_event; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_FAIL; + return FTDM_FAIL; } /** * \brief Retrieves an event from a Pika span * \param span Span to retrieve event from - * \param event Openzap event to return + * \param event Openftdm event to return * \return Success or failure */ static ZIO_SPAN_NEXT_EVENT_FUNCTION(pika_next_event) @@ -1067,11 +1067,11 @@ static ZIO_SPAN_NEXT_EVENT_FUNCTION(pika_next_event) uint32_t i, event_id = 0; for(i = 1; i <= span->chan_count; i++) { - if (zap_test_flag(span->channels[i], ZAP_CHANNEL_EVENT)) { + if (ftdm_test_flag(span->channels[i], FTDM_CHANNEL_EVENT)) { pika_chan_data_t *chan_data = (pika_chan_data_t *) span->channels[i]->mod_data; PK_CHAR event_text[PKH_EVENT_MAX_NAME_LENGTH]; - zap_clear_flag(span->channels[i], ZAP_CHANNEL_EVENT); + ftdm_clear_flag(span->channels[i], FTDM_CHANNEL_EVENT); PKH_EVENT_GetText(chan_data->last_oob_event.id, event_text, sizeof(event_text)); @@ -1080,58 +1080,58 @@ static ZIO_SPAN_NEXT_EVENT_FUNCTION(pika_next_event) chan_data->hdlc_bytes = chan_data->last_oob_event.p2; continue; case PKH_EVENT_TRUNK_HOOKFLASH: - event_id = ZAP_OOB_FLASH; + event_id = FTDM_OOB_FLASH; break; case PKH_EVENT_TRUNK_RING_OFF: - event_id = ZAP_OOB_RING_STOP; + event_id = FTDM_OOB_RING_STOP; break; case PKH_EVENT_TRUNK_RING_ON: - event_id = ZAP_OOB_RING_START; + event_id = FTDM_OOB_RING_START; break; case PKH_EVENT_PHONE_OFFHOOK: - zap_set_flag_locked(span->channels[i], ZAP_CHANNEL_OFFHOOK); - event_id = ZAP_OOB_OFFHOOK; + ftdm_set_flag_locked(span->channels[i], FTDM_CHANNEL_OFFHOOK); + event_id = FTDM_OOB_OFFHOOK; break; case PKH_EVENT_TRUNK_BELOW_THRESHOLD: case PKH_EVENT_TRUNK_ABOVE_THRESHOLD: case PKH_EVENT_PHONE_ONHOOK: - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_OFFHOOK); - event_id = ZAP_OOB_ONHOOK; + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_OFFHOOK); + event_id = FTDM_OOB_ONHOOK; break; case PKH_EVENT_SPAN_ALARM_T1_RED: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_RED); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_RED); snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "RED ALARM"); - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_T1_YELLOW: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_YELLOW); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_YELLOW); snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "YELLOW ALARM"); - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_T1_AIS: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_AIS); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_AIS); snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "AIS ALARM"); - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_E1_RED: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_RED); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_RED); snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "RED ALARM"); - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_E1_RAI: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_RAI); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_RAI); snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "RAI ALARM"); - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_E1_AIS: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_AIS); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_AIS); snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "AIS ALARM"); - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_E1_RMAI: case PKH_EVENT_SPAN_ALARM_E1_TS16AIS: @@ -1141,22 +1141,22 @@ static ZIO_SPAN_NEXT_EVENT_FUNCTION(pika_next_event) case PKH_EVENT_SPAN_LOSS_OF_SIGNAL: case PKH_EVENT_SPAN_OUT_OF_CRC_MF_SYNC: case PKH_EVENT_SPAN_OUT_OF_CAS_MF_SYNC: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_GENERAL); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_GENERAL); snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "GENERAL ALARM"); - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; case PKH_EVENT_SPAN_ALARM_T1_RED_CLEAR: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_RED); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_RED); case PKH_EVENT_SPAN_ALARM_T1_YELLOW_CLEAR: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_YELLOW); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_YELLOW); case PKH_EVENT_SPAN_ALARM_T1_AIS_CLEAR: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_AIS); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_AIS); case PKH_EVENT_SPAN_ALARM_E1_RED_CLEAR: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_RED); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_RED); case PKH_EVENT_SPAN_ALARM_E1_RAI_CLEAR: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_RAI); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_RAI); case PKH_EVENT_SPAN_ALARM_E1_AIS_CLEAR: - zap_set_alarm_flag(span->channels[i], ZAP_ALARM_AIS); + ftdm_set_alarm_flag(span->channels[i], FTDM_ALARM_AIS); case PKH_EVENT_SPAN_ALARM_E1_RMAI_CLEAR: case PKH_EVENT_SPAN_ALARM_E1_TS16AIS_CLEAR: case PKH_EVENT_SPAN_ALARM_E1_TS16LOS_CLEAR: @@ -1164,8 +1164,8 @@ static ZIO_SPAN_NEXT_EVENT_FUNCTION(pika_next_event) case PKH_EVENT_SPAN_LOSS_OF_SIGNAL_CLEAR: case PKH_EVENT_SPAN_IN_CRC_MF_SYNC: case PKH_EVENT_SPAN_IN_CAS_MF_SYNC: - zap_clear_alarm_flag(span->channels[i], ZAP_ALARM_GENERAL); - event_id = ZAP_OOB_ALARM_CLEAR; + ftdm_clear_alarm_flag(span->channels[i], FTDM_ALARM_GENERAL); + event_id = FTDM_OOB_ALARM_CLEAR; break; case PKH_EVENT_SPAN_MESSAGE: case PKH_EVENT_SPAN_ABCD_SIGNAL_CHANGE: @@ -1183,21 +1183,21 @@ static ZIO_SPAN_NEXT_EVENT_FUNCTION(pika_next_event) case PKH_EVENT_TRUNK_LOF: case PKH_EVENT_TRUNK_RX_OVERLOAD: default: - zap_log(ZAP_LOG_DEBUG, "Unhandled event %d on channel %d [%s]\n", chan_data->last_oob_event.id, i, event_text); - event_id = ZAP_OOB_INVALID; + ftdm_log(FTDM_LOG_DEBUG, "Unhandled event %d on channel %d [%s]\n", chan_data->last_oob_event.id, i, event_text); + event_id = FTDM_OOB_INVALID; break; } span->channels[i]->last_event_time = 0; - span->event_header.e_type = ZAP_EVENT_OOB; + span->event_header.e_type = FTDM_EVENT_OOB; span->event_header.enum_id = event_id; span->event_header.channel = span->channels[i]; *event = &span->event_header; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } } - return ZAP_FAIL; + return FTDM_FAIL; } /** @@ -1211,27 +1211,27 @@ static ZIO_SPAN_DESTROY_FUNCTION(pika_span_destroy) if (span_data) { PKH_QUEUE_Destroy(span_data->event_queue); - zap_safe_free(span_data); + ftdm_safe_free(span_data); } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Destroys a Pika Channel - * \param zchan Channel to destroy + * \param ftdmchan Channel to destroy * \return Success or failure */ static ZIO_CHANNEL_DESTROY_FUNCTION(pika_channel_destroy) { - pika_chan_data_t *chan_data = (pika_chan_data_t *) zchan->mod_data; - pika_span_data_t *span_data = (pika_span_data_t *) zchan->span->mod_data; + pika_chan_data_t *chan_data = (pika_chan_data_t *) ftdmchan->mod_data; + pika_span_data_t *span_data = (pika_span_data_t *) ftdmchan->span->mod_data; if (!chan_data) { - return ZAP_FAIL; + return FTDM_FAIL; } - if (!zap_test_flag(chan_data, PK_FLAG_READY)) { + if (!ftdm_test_flag(chan_data, PK_FLAG_READY)) { goto end; } @@ -1240,16 +1240,16 @@ static ZIO_CHANNEL_DESTROY_FUNCTION(pika_channel_destroy) PKH_QUEUE_Destroy(chan_data->media_in_queue); PKH_QUEUE_Destroy(chan_data->media_out_queue); - switch(zchan->type) { - case ZAP_CHAN_TYPE_FXS: + switch(ftdmchan->type) { + case FTDM_CHAN_TYPE_FXS: PKH_QUEUE_Detach(span_data->event_queue, chan_data->handle); PKH_PHONE_Close(chan_data->handle); break; - case ZAP_CHAN_TYPE_FXO: + case FTDM_CHAN_TYPE_FXO: PKH_QUEUE_Detach(span_data->event_queue, chan_data->handle); PKH_TRUNK_Close(chan_data->handle); break; - case ZAP_CHAN_TYPE_DQ921: + case FTDM_CHAN_TYPE_DQ921: PKH_SPAN_Stop(span_data->handle); break; default: @@ -1257,30 +1257,30 @@ static ZIO_CHANNEL_DESTROY_FUNCTION(pika_channel_destroy) } - zap_mutex_destroy(&chan_data->digit_mutex); - zap_buffer_destroy(&chan_data->digit_buffer); + ftdm_mutex_destroy(&chan_data->digit_mutex); + ftdm_buffer_destroy(&chan_data->digit_buffer); end: - zap_safe_free(chan_data); + ftdm_safe_free(chan_data); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Gets alarms from a Pika Channel (does nothing) - * \param zchan Channel to get alarms from + * \param ftdmchan Channel to get alarms from * \return Failure */ static ZIO_GET_ALARMS_FUNCTION(pika_get_alarms) { - return ZAP_FAIL; + return FTDM_FAIL; } -static zap_io_interface_t pika_interface; +static ftdm_io_interface_t pika_interface; /** * \brief Loads Pika IO module - * \param zio Openzap IO interface + * \param zio Openftdm IO interface * \return Success or failure */ static ZIO_IO_LOAD_FUNCTION(pika_init) @@ -1298,21 +1298,21 @@ static ZIO_IO_LOAD_FUNCTION(pika_init) memset(&globals, 0, sizeof(globals)); globals.general_config.region = PKH_TRUNK_NA; - globals.profile_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys); + globals.profile_hash = create_hashtable(16, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); // Open the system object, to enumerate boards configured for this system if ((status = PKH_SYSTEM_Open(&globals.system_handle)) != PK_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error: PKH_SYSTEM_Open failed(%s)!\n", + ftdm_log(FTDM_LOG_ERROR, "Error: PKH_SYSTEM_Open failed(%s)!\n", PKH_ERROR_GetText(status, error_text, sizeof(error_text))); - return ZAP_FAIL; + return FTDM_FAIL; } // Retrieves a list of all boards in this system, existing, // or listed in pika.cfg if ((status = PKH_SYSTEM_Detect(globals.system_handle, &globals.board_list)) != PK_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error: PKH_SYSTEM_Detect failed(%s)!\n", + ftdm_log(FTDM_LOG_ERROR, "Error: PKH_SYSTEM_Detect failed(%s)!\n", PKH_ERROR_GetText(status, error_text, sizeof(error_text))); - return ZAP_FAIL; + return FTDM_FAIL; } PKH_SYSTEM_GetConfig(globals.system_handle, &globals.system_config); @@ -1330,9 +1330,9 @@ static ZIO_IO_LOAD_FUNCTION(pika_init) - zap_log(ZAP_LOG_DEBUG, "Found %u board%s\n", globals.board_list.numberOfBoards, globals.board_list.numberOfBoards == 1 ? "" : "s"); + ftdm_log(FTDM_LOG_DEBUG, "Found %u board%s\n", globals.board_list.numberOfBoards, globals.board_list.numberOfBoards == 1 ? "" : "s"); for(i = 0; i < globals.board_list.numberOfBoards; ++i) { - zap_log(ZAP_LOG_INFO, "Found PIKA board type:[%s] id:[%u] serno:[%u]\n", + ftdm_log(FTDM_LOG_INFO, "Found PIKA board type:[%s] id:[%u] serno:[%u]\n", pika_board_type_string(globals.board_list.board[i].type), globals.board_list.board[i].id, (uint32_t) globals.board_list.board[i].serialNumber); @@ -1358,7 +1358,7 @@ static ZIO_IO_LOAD_FUNCTION(pika_init) } if (!ok) { - return ZAP_FAIL; + return FTDM_FAIL; } pika_interface.name = "pika"; @@ -1378,35 +1378,35 @@ static ZIO_IO_LOAD_FUNCTION(pika_init) *zio = &pika_interface; - zap_log(ZAP_LOG_INFO, "Dumping Default configs:\n"); - zap_log(ZAP_LOG_INFO, "rx-gain => %0.2f\n", (float)globals.record_config.gain); - zap_log(ZAP_LOG_INFO, "rx-agc-enabled => %s\n", globals.record_config.AGC.enabled ? "true" : "false"); - zap_log(ZAP_LOG_INFO, "rx-agc-targetPower => %0.2f\n", (float)globals.record_config.AGC.targetPower); - zap_log(ZAP_LOG_INFO, "rx-agc-minGain => %0.2f\n", (float)globals.record_config.AGC.minGain); - zap_log(ZAP_LOG_INFO, "rx-agc-maxGain => %0.2f\n", (float)globals.record_config.AGC.maxGain); - zap_log(ZAP_LOG_INFO, "rx-agc-attackRate => %d\n", (int)globals.record_config.AGC.attackRate); - zap_log(ZAP_LOG_INFO, "rx-agc-decayRate => %d\n", (int)globals.record_config.AGC.decayRate); - zap_log(ZAP_LOG_INFO, "rx-agc-speechThreshold => %0.2f\n", (float)globals.record_config.AGC.speechThreshold); - zap_log(ZAP_LOG_INFO, "rx-vad-enabled => %s\n", globals.record_config.VAD.enabled ? "true" : "false"); - zap_log(ZAP_LOG_INFO, "rx-vad-activationThreshold => %0.2f\n", (float)globals.record_config.VAD.activationThreshold); - zap_log(ZAP_LOG_INFO, "rx-vad-activationDebounceTime => %d\n", (int)globals.record_config.VAD.activationDebounceTime); - zap_log(ZAP_LOG_INFO, "rx-vad-deactivationThreshold => %0.2f\n", (float)globals.record_config.VAD.deactivationThreshold); - zap_log(ZAP_LOG_INFO, "rx-vad-deactivationDebounceTime => %d\n", (int)globals.record_config.VAD.deactivationDebounceTime); - zap_log(ZAP_LOG_INFO, "rx-vad-preSpeechBufferSize => %d\n", (int)globals.record_config.VAD.preSpeechBufferSize); - zap_log(ZAP_LOG_INFO, "tx-gain => %0.2f\n", (float)globals.play_config.gain); - zap_log(ZAP_LOG_INFO, "tx-agc-enabled => %s\n", globals.play_config.AGC.enabled ? "true" : "false"); - zap_log(ZAP_LOG_INFO, "tx-agc-targetPower => %0.2f\n", (float)globals.play_config.AGC.targetPower); - zap_log(ZAP_LOG_INFO, "tx-agc-minGain => %0.2f\n", (float)globals.play_config.AGC.minGain); - zap_log(ZAP_LOG_INFO, "tx-agc-maxGain => %0.2f\n", (float)globals.play_config.AGC.maxGain); - zap_log(ZAP_LOG_INFO, "tx-agc-attackRate => %d\n", (int)globals.play_config.AGC.attackRate); - zap_log(ZAP_LOG_INFO, "tx-agc-decayRate => %d\n", (int)globals.play_config.AGC.decayRate); - zap_log(ZAP_LOG_INFO, "tx-agc-speechThreshold => %0.2f\n", (float)globals.play_config.AGC.speechThreshold); - zap_log(ZAP_LOG_INFO, "ec-doubleTalkerThreshold => %0.2f\n", (float)globals.ec_config.doubleTalkerThreshold); - zap_log(ZAP_LOG_INFO, "ec-speechPresentThreshold => %0.2f\n", (float)globals.ec_config.speechPresentThreshold); - zap_log(ZAP_LOG_INFO, "ec-echoSuppressionThreshold => %0.2f\n", (float)globals.ec_config.echoSuppressionThreshold); - zap_log(ZAP_LOG_INFO, "ec-echoSuppressionEnabled => %s\n", globals.ec_config.echoSuppressionEnabled ? "true" : "false"); - zap_log(ZAP_LOG_INFO, "ec-comfortNoiseEnabled => %s\n", globals.ec_config.comfortNoiseEnabled ? "true" : "false"); - zap_log(ZAP_LOG_INFO, "ec-adaptationModeEnabled => %s\n", globals.ec_config.adaptationModeEnabled ? "true" : "false"); + ftdm_log(FTDM_LOG_INFO, "Dumping Default configs:\n"); + ftdm_log(FTDM_LOG_INFO, "rx-gain => %0.2f\n", (float)globals.record_config.gain); + ftdm_log(FTDM_LOG_INFO, "rx-agc-enabled => %s\n", globals.record_config.AGC.enabled ? "true" : "false"); + ftdm_log(FTDM_LOG_INFO, "rx-agc-targetPower => %0.2f\n", (float)globals.record_config.AGC.targetPower); + ftdm_log(FTDM_LOG_INFO, "rx-agc-minGain => %0.2f\n", (float)globals.record_config.AGC.minGain); + ftdm_log(FTDM_LOG_INFO, "rx-agc-maxGain => %0.2f\n", (float)globals.record_config.AGC.maxGain); + ftdm_log(FTDM_LOG_INFO, "rx-agc-attackRate => %d\n", (int)globals.record_config.AGC.attackRate); + ftdm_log(FTDM_LOG_INFO, "rx-agc-decayRate => %d\n", (int)globals.record_config.AGC.decayRate); + ftdm_log(FTDM_LOG_INFO, "rx-agc-speechThreshold => %0.2f\n", (float)globals.record_config.AGC.speechThreshold); + ftdm_log(FTDM_LOG_INFO, "rx-vad-enabled => %s\n", globals.record_config.VAD.enabled ? "true" : "false"); + ftdm_log(FTDM_LOG_INFO, "rx-vad-activationThreshold => %0.2f\n", (float)globals.record_config.VAD.activationThreshold); + ftdm_log(FTDM_LOG_INFO, "rx-vad-activationDebounceTime => %d\n", (int)globals.record_config.VAD.activationDebounceTime); + ftdm_log(FTDM_LOG_INFO, "rx-vad-deactivationThreshold => %0.2f\n", (float)globals.record_config.VAD.deactivationThreshold); + ftdm_log(FTDM_LOG_INFO, "rx-vad-deactivationDebounceTime => %d\n", (int)globals.record_config.VAD.deactivationDebounceTime); + ftdm_log(FTDM_LOG_INFO, "rx-vad-preSpeechBufferSize => %d\n", (int)globals.record_config.VAD.preSpeechBufferSize); + ftdm_log(FTDM_LOG_INFO, "tx-gain => %0.2f\n", (float)globals.play_config.gain); + ftdm_log(FTDM_LOG_INFO, "tx-agc-enabled => %s\n", globals.play_config.AGC.enabled ? "true" : "false"); + ftdm_log(FTDM_LOG_INFO, "tx-agc-targetPower => %0.2f\n", (float)globals.play_config.AGC.targetPower); + ftdm_log(FTDM_LOG_INFO, "tx-agc-minGain => %0.2f\n", (float)globals.play_config.AGC.minGain); + ftdm_log(FTDM_LOG_INFO, "tx-agc-maxGain => %0.2f\n", (float)globals.play_config.AGC.maxGain); + ftdm_log(FTDM_LOG_INFO, "tx-agc-attackRate => %d\n", (int)globals.play_config.AGC.attackRate); + ftdm_log(FTDM_LOG_INFO, "tx-agc-decayRate => %d\n", (int)globals.play_config.AGC.decayRate); + ftdm_log(FTDM_LOG_INFO, "tx-agc-speechThreshold => %0.2f\n", (float)globals.play_config.AGC.speechThreshold); + ftdm_log(FTDM_LOG_INFO, "ec-doubleTalkerThreshold => %0.2f\n", (float)globals.ec_config.doubleTalkerThreshold); + ftdm_log(FTDM_LOG_INFO, "ec-speechPresentThreshold => %0.2f\n", (float)globals.ec_config.speechPresentThreshold); + ftdm_log(FTDM_LOG_INFO, "ec-echoSuppressionThreshold => %0.2f\n", (float)globals.ec_config.echoSuppressionThreshold); + ftdm_log(FTDM_LOG_INFO, "ec-echoSuppressionEnabled => %s\n", globals.ec_config.echoSuppressionEnabled ? "true" : "false"); + ftdm_log(FTDM_LOG_INFO, "ec-comfortNoiseEnabled => %s\n", globals.ec_config.comfortNoiseEnabled ? "true" : "false"); + ftdm_log(FTDM_LOG_INFO, "ec-adaptationModeEnabled => %s\n", globals.ec_config.adaptationModeEnabled ? "true" : "false"); @@ -1414,7 +1414,7 @@ static ZIO_IO_LOAD_FUNCTION(pika_init) //m.apiMask = 0xffffffff; //PKH_LOG_SetMasks(&m); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** @@ -1429,28 +1429,28 @@ static ZIO_IO_UNLOAD_FUNCTION(pika_destroy) for (x = 0; x < MAX_NUMBER_OF_TRUNKS; x++) { if (globals.open_boards[x]) { - zap_log(ZAP_LOG_INFO, "Closing board %u\n", x); + ftdm_log(FTDM_LOG_INFO, "Closing board %u\n", x); PKH_BOARD_Close(globals.open_boards[x]); } } // The system can now be closed. if ((status = PKH_SYSTEM_Close(globals.system_handle)) != PK_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error: PKH_SYSTEM_Close failed(%s)!\n", + ftdm_log(FTDM_LOG_ERROR, "Error: PKH_SYSTEM_Close failed(%s)!\n", PKH_ERROR_GetText(status, error_text, sizeof(error_text))); } else { - zap_log(ZAP_LOG_INFO, "Closing system handle\n"); + ftdm_log(FTDM_LOG_INFO, "Closing system handle\n"); } hashtable_destroy(globals.profile_hash); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Pika IO module definition */ -EX_DECLARE_DATA zap_module_t zap_module = { +EX_DECLARE_DATA ftdm_module_t ftdm_module = { "pika", pika_init, pika_destroy, diff --git a/libs/freetdm/src/ozmod/ozmod_pika/ozmod_pika.2005.vcproj b/libs/freetdm/src/ftmod/ftmod_pika/ozmod_pika.2005.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_pika/ozmod_pika.2005.vcproj rename to libs/freetdm/src/ftmod/ftmod_pika/ozmod_pika.2005.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_pika/ozmod_pika.2008.vcproj b/libs/freetdm/src/ftmod/ftmod_pika/ozmod_pika.2008.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_pika/ozmod_pika.2008.vcproj rename to libs/freetdm/src/ftmod/ftmod_pika/ozmod_pika.2008.vcproj diff --git a/libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c b/libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c new file mode 100644 index 0000000000..3dee603f1a --- /dev/null +++ b/libs/freetdm/src/ftmod/ftmod_r2/ftmod_r2.c @@ -0,0 +1,1367 @@ +/* + * Copyright (c) 2009, Moises Silva + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of the original author; nor the names of any contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER + * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include "freetdm.h" + +/* debug thread count for r2 legs */ +static ftdm_mutex_t* g_thread_count_mutex; +static int32_t g_thread_count = 0; + +/* when the users kills a span we clear this flag to kill the signaling thread */ +/* FIXME: what about the calls that are already up-and-running? */ +typedef enum { + FTDM_R2_RUNNING = (1 << 0), +} ftdm_r2_flag_t; + +/* private call information stored in ftdmchan->call_data void* ptr */ +#define R2CALL(ftdmchan) ((ftdm_r2_call_t*)((ftdmchan)->call_data)) +typedef struct ftdm_r2_call_t { + openr2_chan_t *r2chan; + int accepted:1; + int answer_pending:1; + int state_ack_pending:1; + int disconnect_rcvd:1; + int ftdm_started:1; + ftdm_channel_state_t chanstate; + ftdm_size_t dnis_index; + ftdm_size_t ani_index; + char name[10]; +} ftdm_r2_call_t; + +/* this is just used as place holder in the stack when configuring the span to avoid using bunch of locals */ +typedef struct ft_r2_conf_s { + /* openr2 types */ + openr2_variant_t variant; + openr2_calling_party_category_t category; + openr2_log_level_t loglevel; + + /* strings */ + char *logdir; + char *advanced_protocol_file; + + /* ints */ + int32_t max_ani; + int32_t max_dnis; + int32_t mfback_timeout; + int32_t metering_pulse_timeout; + + /* booleans */ + int immediate_accept; + int skip_category; + int get_ani_first; + int call_files; + int double_answer; + int charge_calls; + int forced_release; + int allow_collect_calls; +} ft_r2_conf_t; + +/* r2 configuration stored in span->signal_data */ +typedef struct ftdm_r2_data_s { + /* signaling callback */ + zio_signal_cb_t sig_cb; + /* span flags */ + ftdm_r2_flag_t flags; + /* openr2 handle for the R2 variant context */ + openr2_context_t *r2context; + /* category to use when making calls */ + openr2_calling_party_category_t category; + /* whether to use OR2_CALL_WITH_CHARGE or OR2_CALL_NO_CHARGE when accepting a call */ + int charge_calls:1; + /* allow or reject collect calls */ + int allow_collect_calls:1; + /* whether to use forced release when hanging up */ + int forced_release:1; + /* whether accept the call when offered, or wait until the user decides to accept */ + int accept_on_offer:1; +} ftdm_r2_data_t; + +/* one element per span will be stored in g_mod_data_hash global var to keep track of them + and destroy them on module unload */ +typedef struct ftdm_r2_span_pvt_s { + openr2_context_t *r2context; /* r2 context allocated for this span */ + ftdm_hash_t *r2calls; /* hash table of allocated call data per channel for this span */ +} ftdm_r2_span_pvt_t; + +/* span monitor thread */ +static void *ftdm_r2_run(ftdm_thread_t *me, void *obj); + +/* channel monitor thread */ +static void *ftdm_r2_channel_run(ftdm_thread_t *me, void *obj); + +/* hash of all the private span allocations + we need to keep track of them to destroy them when unloading the module + since freetdm does not notify signaling modules when destroying a span + span -> ftdm_r2_mod_allocs_t */ +static ftdm_hash_t *g_mod_data_hash; + +/* IO interface for the command API */ +static ftdm_io_interface_t g_ftdm_r2_interface; + +static void ft_r2_clean_call(ftdm_r2_call_t *call) +{ + openr2_chan_t *r2chan = call->r2chan; + memset(call, 0, sizeof(*call)); + call->r2chan = r2chan; +} + +static void ft_r2_accept_call(ftdm_channel_t *ftdmchan) +{ + openr2_chan_t *r2chan = R2CALL(ftdmchan)->r2chan; + // FIXME: not always accept as no charge, let the user decide that + // also we should check the return code from openr2_chan_accept_call and handle error condition + // hanging up the call with protocol error as the reason, this openr2 API will fail only when there something + // wrong at the I/O layer or the library itself + openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE); + R2CALL(ftdmchan)->accepted = 1; +} + +static void ft_r2_answer_call(ftdm_channel_t *ftdmchan) +{ + openr2_chan_t *r2chan = R2CALL(ftdmchan)->r2chan; + // FIXME + // 1. check openr2_chan_answer_call return code + // 2. The openr2_chan_answer_call_with_mode should be used depending on user settings + // openr2_chan_answer_call_with_mode(r2chan, OR2_ANSWER_SIMPLE); + openr2_chan_answer_call(r2chan); + R2CALL(ftdmchan)->answer_pending = 0; +} + +static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(r2_outgoing_call) +{ + ftdm_status_t status; + ftdm_mutex_lock(ftdmchan->mutex); + + /* the channel may be down but the thread not quite done */ + ftdm_wait_for_flag_cleared(ftdmchan, FTDM_CHANNEL_INTHREAD, 200); + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_log(FTDM_LOG_ERROR, "%d:%d Yay! R2 outgoing call in channel that is already in thread.\n", + ftdmchan->span_id, ftdmchan->chan_id); + ftdm_mutex_unlock(ftdmchan->mutex); + return FTDM_FAIL; + } + + ft_r2_clean_call(ftdmchan->call_data); + R2CALL(ftdmchan)->chanstate = FTDM_CHANNEL_STATE_DOWN; + ftdm_channel_set_state(ftdmchan, FTDM_CHANNEL_STATE_DIALING, 0); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + R2CALL(ftdmchan)->ftdm_started = 1; + ftdm_mutex_unlock(ftdmchan->mutex); + + status = ftdm_thread_create_detached(ftdm_r2_channel_run, ftdmchan); + if (status == FTDM_FAIL) { + ftdm_log(FTDM_LOG_ERROR, "%d:%d Cannot handle request to start call in channel, failed to create thread!\n", + ftdmchan->span_id, ftdmchan->chan_id); + ftdm_channel_done(ftdmchan); + return FTDM_FAIL; + } + + return FTDM_SUCCESS; +} + +static ftdm_status_t ftdm_r2_start(ftdm_span_t *span) +{ + ftdm_r2_data_t *r2_data = span->signal_data; + ftdm_set_flag(r2_data, FTDM_R2_RUNNING); + return ftdm_thread_create_detached(ftdm_r2_run, span); +} + +/* always called from the monitor thread */ +static void ftdm_r2_on_call_init(openr2_chan_t *r2chan) +{ + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_status_t status; + ftdm_log(FTDM_LOG_NOTICE, "Received request to start call on chan %d\n", openr2_chan_get_number(r2chan)); + + ftdm_mutex_lock(ftdmchan->mutex); + + if (ftdmchan->state != FTDM_CHANNEL_STATE_DOWN) { + ftdm_log(FTDM_LOG_ERROR, "Cannot handle request to start call in channel %d, invalid state (%d)\n", + openr2_chan_get_number(r2chan), ftdmchan->state); + ftdm_mutex_unlock(ftdmchan->mutex); + return; + } + + /* the channel may be down but the thread not quite done */ + ftdm_wait_for_flag_cleared(ftdmchan, FTDM_CHANNEL_INTHREAD, 200); + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) { + ftdm_log(FTDM_LOG_ERROR, "Cannot handle request to start call in channel %d, already in thread!\n", + openr2_chan_get_number(r2chan)); + ftdm_mutex_unlock(ftdmchan->mutex); + return; + } + ft_r2_clean_call(ftdmchan->call_data); + R2CALL(ftdmchan)->chanstate = FTDM_CHANNEL_STATE_DOWN; + ftdm_channel_set_state(ftdmchan, FTDM_CHANNEL_STATE_COLLECT, 0); + ftdm_mutex_unlock(ftdmchan->mutex); + + status = ftdm_thread_create_detached(ftdm_r2_channel_run, ftdmchan); + if (status == FTDM_FAIL) { + ftdm_log(FTDM_LOG_ERROR, "Cannot handle request to start call in channel %d, failed to create thread!\n", + openr2_chan_get_number(r2chan)); + } +} + +/* only called for incoming calls when the ANI, DNIS etc is complete and the user has to decide either to accept or reject the call */ +static void ftdm_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, const char *dnis, openr2_calling_party_category_t category) +{ + ftdm_sigmsg_t sigev; + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_r2_data_t *r2data = ftdmchan->span->signal_data; + + ftdm_log(FTDM_LOG_NOTICE, "Call offered on chan %d, ANI = %s, DNIS = %s, Category = %s\n", openr2_chan_get_number(r2chan), + ani, dnis, openr2_proto_get_category_string(category)); + + /* notify the user about the new call */ + memset(&sigev, 0, sizeof(sigev)); + sigev.chan_id = ftdmchan->chan_id; + sigev.span_id = ftdmchan->span_id; + sigev.channel = ftdmchan; + sigev.event_id = FTDM_SIGEVENT_START; + + if (r2data->sig_cb(&sigev) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_NOTICE, "Failed to handle call offered on chan %d\n", openr2_chan_get_number(r2chan)); + openr2_chan_disconnect_call(r2chan, OR2_CAUSE_OUT_OF_ORDER); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_CANCEL); + return; + } + ftdm_channel_use(ftdmchan); + R2CALL(ftdmchan)->ftdm_started = 1; +} + +static void ftdm_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode) +{ + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_log(FTDM_LOG_NOTICE, "Call accepted on chan %d\n", openr2_chan_get_number(r2chan)); + /* at this point the MF signaling has ended and there is no point on keep reading */ + openr2_chan_disable_read(r2chan); + if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) { + R2CALL(ftdmchan)->state_ack_pending = 1; + if (R2CALL(ftdmchan)->answer_pending) { + ftdm_log(FTDM_LOG_DEBUG, "Answer was pending on chan %d, answering now.\n", openr2_chan_get_number(r2chan)); + ft_r2_answer_call(ftdmchan); + return; + } + } else { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); + } +} + +static void ftdm_r2_on_call_answered(openr2_chan_t *r2chan) +{ + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_log(FTDM_LOG_NOTICE, "Call answered on chan %d\n", openr2_chan_get_number(r2chan)); + /* notify the upper layer of progress in the outbound call */ + if (OR2_DIR_FORWARD == openr2_chan_get_direction(r2chan)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP); + } +} + +/* may be called in the signaling or media thread depending on whether the hangup is product of MF or CAS signaling */ +static void ftdm_r2_on_call_disconnect(openr2_chan_t *r2chan, openr2_call_disconnect_cause_t cause) +{ + ftdm_sigmsg_t sigev; + ftdm_r2_data_t *r2data; + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_log(FTDM_LOG_NOTICE, "Call disconnected on chan %d\n", openr2_chan_get_number(r2chan)); + + ftdm_log(FTDM_LOG_DEBUG, "Got openr2 disconnection, clearing call on channel %d\n", ftdmchan->physical_chan_id); + + R2CALL(ftdmchan)->disconnect_rcvd = 1; + + /* acknowledge the hangup, cause will be ignored. From here to -> HANGUP once the freetdm side hangs up as well */ + openr2_chan_disconnect_call(r2chan, OR2_CAUSE_NORMAL_CLEARING); + + /* if the call has not been started yet we must go to HANGUP right here */ + if (!R2CALL(ftdmchan)->ftdm_started) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + return; + } + + /* FIXME: use the cause received from openr2 and map it to ftdm cause */ + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CLEARING; + + /* notify the user of the call terminating */ + memset(&sigev, 0, sizeof(sigev)); + sigev.chan_id = ftdmchan->chan_id; + sigev.span_id = ftdmchan->span_id; + sigev.channel = ftdmchan; + sigev.event_id = FTDM_SIGEVENT_STOP; + r2data = ftdmchan->span->signal_data; + + r2data->sig_cb(&sigev); +} + +static void ftdm_r2_on_call_end(openr2_chan_t *r2chan) +{ + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_log(FTDM_LOG_NOTICE, "Call finished on chan %d\n", openr2_chan_get_number(r2chan)); + /* this means the freetdm side disconnected the call, therefore we must move to DOWN here */ + if (!R2CALL(ftdmchan)->disconnect_rcvd) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + return; + } +} + +static void ftdm_r2_on_call_read(openr2_chan_t *r2chan, const unsigned char *buf, int buflen) +{ + ftdm_log(FTDM_LOG_NOTICE, "Call read data on chan %d\n", openr2_chan_get_number(r2chan)); +} + +static void ftdm_r2_on_hardware_alarm(openr2_chan_t *r2chan, int alarm) +{ + ftdm_log(FTDM_LOG_NOTICE, "Alarm on chan %d (%d)\n", openr2_chan_get_number(r2chan), alarm); +} + +static void ftdm_r2_on_os_error(openr2_chan_t *r2chan, int errorcode) +{ + ftdm_log(FTDM_LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode)); +} + +static void ftdm_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason) +{ + ftdm_sigmsg_t sigev; + ftdm_r2_data_t *r2data; + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + + ftdm_log(FTDM_LOG_ERROR, "Protocol error on chan %d\n", openr2_chan_get_number(r2chan)); + + R2CALL(ftdmchan)->disconnect_rcvd = 1; + + if (!R2CALL(ftdmchan)->ftdm_started) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + return; + } + + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_PROTOCOL_ERROR; + + /* notify the user of the call terminating */ + memset(&sigev, 0, sizeof(sigev)); + sigev.chan_id = ftdmchan->chan_id; + sigev.span_id = ftdmchan->span_id; + sigev.channel = ftdmchan; + sigev.event_id = FTDM_SIGEVENT_STOP; + r2data = ftdmchan->span->signal_data; + + r2data->sig_cb(&sigev); +} + +static void ftdm_r2_on_line_blocked(openr2_chan_t *r2chan) +{ + ftdm_log(FTDM_LOG_NOTICE, "Far end blocked on chan %d\n", openr2_chan_get_number(r2chan)); +} + +static void ftdm_r2_on_line_idle(openr2_chan_t *r2chan) +{ + ftdm_log(FTDM_LOG_NOTICE, "Far end unblocked on chan %d\n", openr2_chan_get_number(r2chan)); +} + +static void ftdm_r2_write_log(openr2_log_level_t level, const char *message) +{ + switch (level) { + case OR2_LOG_NOTICE: + ftdm_log(FTDM_LOG_NOTICE, "%s", message); + break; + case OR2_LOG_WARNING: + ftdm_log(FTDM_LOG_WARNING, "%s", message); + break; + case OR2_LOG_ERROR: + ftdm_log(FTDM_LOG_ERROR, "%s", message); + break; + case OR2_LOG_STACK_TRACE: + case OR2_LOG_MF_TRACE: + case OR2_LOG_CAS_TRACE: + case OR2_LOG_DEBUG: + case OR2_LOG_EX_DEBUG: + ftdm_log(FTDM_LOG_DEBUG, "%s", message); + break; + default: + ftdm_log(FTDM_LOG_WARNING, "We should handle logging level %d here.\n", level); + ftdm_log(FTDM_LOG_DEBUG, "%s", message); + break; + } +} + +static void ftdm_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level, const char *fmt, va_list ap) +{ +#define CONTEXT_TAG "Context -" + char logmsg[256]; + char completemsg[sizeof(logmsg) + sizeof(CONTEXT_TAG) - 1]; + vsnprintf(logmsg, sizeof(logmsg), fmt, ap); + snprintf(completemsg, sizeof(completemsg), CONTEXT_TAG "%s", logmsg); + ftdm_r2_write_log(level, completemsg); +#undef CONTEXT_TAG +} + +static void ftdm_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level, const char *fmt, va_list ap) +{ +#define CHAN_TAG "Chan " + char logmsg[256]; + char completemsg[sizeof(logmsg) + sizeof(CHAN_TAG) - 1]; + vsnprintf(logmsg, sizeof(logmsg), fmt, ap); + snprintf(completemsg, sizeof(completemsg), CHAN_TAG "%d: %s", openr2_chan_get_number(r2chan), logmsg); + ftdm_r2_write_log(level, completemsg); +#undef CHAN_TAG +} + +static int ftdm_r2_on_dnis_digit_received(openr2_chan_t *r2chan, char digit) +{ + ftdm_sigmsg_t sigev; + ftdm_r2_data_t *r2data; + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_size_t collected_len = R2CALL(ftdmchan)->dnis_index; + + ftdm_log(FTDM_LOG_DEBUG, "DNIS digit %d received chan %d\n", digit, openr2_chan_get_number(r2chan)); + + /* save the digit we just received */ + ftdmchan->caller_data.dnis.digits[collected_len] = digit; + collected_len++; + ftdmchan->caller_data.dnis.digits[collected_len] = '\0'; + R2CALL(ftdmchan)->dnis_index = collected_len; + + /* notify the user about the new digit and check if we should stop requesting more DNIS */ + memset(&sigev, 0, sizeof(sigev)); + sigev.chan_id = ftdmchan->chan_id; + sigev.span_id = ftdmchan->span_id; + sigev.channel = ftdmchan; + sigev.event_id = FTDM_SIGEVENT_COLLECTED_DIGIT; + r2data = ftdmchan->span->signal_data; + if (r2data->sig_cb(&sigev) == FTDM_BREAK) { + ftdm_log(FTDM_LOG_NOTICE, "Requested to stop getting DNIS. Current DNIS = %s on chan %d\n", ftdmchan->caller_data.dnis.digits, openr2_chan_get_number(r2chan)); + return OR2_STOP_DNIS_REQUEST; + } + + /* the only other reason to stop requesting DNIS is that there is no more room to save it */ + if (collected_len == (sizeof(ftdmchan->caller_data.dnis.digits) - 1)) { + ftdm_log(FTDM_LOG_NOTICE, "No more room for DNIS. Current DNIS = %s on chan %d\n", ftdmchan->caller_data.dnis.digits, openr2_chan_get_number(r2chan)); + return OR2_STOP_DNIS_REQUEST; + } + + return OR2_CONTINUE_DNIS_REQUEST; +} + +static void ftdm_r2_on_ani_digit_received(openr2_chan_t *r2chan, char digit) +{ + ftdm_channel_t *ftdmchan = openr2_chan_get_client_data(r2chan); + ftdm_size_t collected_len = R2CALL(ftdmchan)->ani_index; + + /* check if we should drop ANI */ + if (collected_len == (sizeof(ftdmchan->caller_data.ani.digits) - 1)) { + ftdm_log(FTDM_LOG_NOTICE, "No more room for ANI %c on chan %d, digit dropped.\n", digit, openr2_chan_get_number(r2chan)); + return; + } + ftdm_log(FTDM_LOG_DEBUG, "ANI digit %c received chan %d\n", digit, openr2_chan_get_number(r2chan)); + + /* save the digit we just received */ + ftdmchan->caller_data.ani.digits[collected_len++] = digit; + ftdmchan->caller_data.ani.digits[collected_len] = '\0'; +} + +static openr2_event_interface_t ftdm_r2_event_iface = { + .on_call_init = ftdm_r2_on_call_init, + .on_call_offered = ftdm_r2_on_call_offered, + .on_call_accepted = ftdm_r2_on_call_accepted, + .on_call_answered = ftdm_r2_on_call_answered, + .on_call_disconnect = ftdm_r2_on_call_disconnect, + .on_call_end = ftdm_r2_on_call_end, + .on_call_read = ftdm_r2_on_call_read, + .on_hardware_alarm = ftdm_r2_on_hardware_alarm, + .on_os_error = ftdm_r2_on_os_error, + .on_protocol_error = ftdm_r2_on_protocol_error, + .on_line_blocked = ftdm_r2_on_line_blocked, + .on_line_idle = ftdm_r2_on_line_idle, + /* cast seems to be needed to get rid of the annoying warning regarding format attribute */ + .on_context_log = (openr2_handle_context_logging_func)ftdm_r2_on_context_log, + .on_dnis_digit_received = ftdm_r2_on_dnis_digit_received, + .on_ani_digit_received = ftdm_r2_on_ani_digit_received, + /* so far we do nothing with billing pulses */ + .on_billing_pulse_received = NULL +}; + +static int ftdm_r2_io_set_cas(openr2_chan_t *r2chan, int cas) +{ + ftdm_channel_t *ftdm_chan = openr2_chan_get_fd(r2chan); + ftdm_status_t status = ftdm_channel_command(ftdm_chan, FTDM_COMMAND_SET_CAS_BITS, &cas); + if (FTDM_FAIL == status) { + return -1; + } + return 0; +} + +static int ftdm_r2_io_get_cas(openr2_chan_t *r2chan, int *cas) +{ + ftdm_channel_t *ftdm_chan = openr2_chan_get_fd(r2chan); + ftdm_status_t status = ftdm_channel_command(ftdm_chan, FTDM_COMMAND_GET_CAS_BITS, cas); + if (FTDM_FAIL == status) { + return -1; + } + return 0; +} + +static int ftdm_r2_io_flush_write_buffers(openr2_chan_t *r2chan) +{ + ftdm_channel_t *ftdm_chan = openr2_chan_get_fd(r2chan); + ftdm_status_t status = ftdm_channel_command(ftdm_chan, FTDM_COMMAND_FLUSH_TX_BUFFERS, NULL); + if (FTDM_FAIL == status) { + return -1; + } + return 0; +} + +static int ftdm_r2_io_write(openr2_chan_t *r2chan, const void *buf, int size) +{ + ftdm_channel_t *ftdm_chan = openr2_chan_get_fd(r2chan); + ftdm_size_t outsize = size; + ftdm_status_t status = ftdm_channel_write(ftdm_chan, (void *)buf, size, &outsize); + if (FTDM_FAIL == status) { + return -1; + } + return outsize; +} + +static int ftdm_r2_io_read(openr2_chan_t *r2chan, const void *buf, int size) +{ + ftdm_channel_t *ftdm_chan = openr2_chan_get_fd(r2chan); + ftdm_size_t outsize = size; + ftdm_status_t status = ftdm_channel_read(ftdm_chan, (void *)buf, &outsize); + if (FTDM_FAIL == status) { + return -1; + } + return outsize; +} + +static int ftdm_r2_io_wait(openr2_chan_t *r2chan, int *flags, int block) +{ + ftdm_status_t status; + ftdm_wait_flag_t ftdmflags = 0; + + ftdm_channel_t *ftdm_chan = openr2_chan_get_fd(r2chan); + int32_t timeout = block ? -1 : 0; + + if (*flags & OR2_IO_READ) { + ftdmflags |= FTDM_READ; + } + if (*flags & OR2_IO_WRITE) { + ftdmflags |= FTDM_WRITE; + } + if (*flags & OR2_IO_OOB_EVENT) { + ftdmflags |= FTDM_EVENTS; + } + + status = ftdm_channel_wait(ftdm_chan, &ftdmflags, timeout); + + if (FTDM_SUCCESS != status) { + return -1; + } + + *flags = 0; + if (ftdmflags & FTDM_READ) { + *flags |= OR2_IO_READ; + } + if (ftdmflags & FTDM_WRITE) { + *flags |= OR2_IO_WRITE; + } + if (ftdmflags & FTDM_EVENTS) { + *flags |= OR2_IO_OOB_EVENT; + } + + return 0; +} + +/* The following openr2 hooks never get called, read on for reasoning ... */ +/* since freetdm takes care of opening the file descriptor and using openr2_chan_new_from_fd, openr2 should never call this hook */ +static openr2_io_fd_t ftdm_r2_io_open(openr2_context_t *r2context, int channo) +{ + ftdm_log(FTDM_LOG_ERROR, "I should not be called (I/O open)!!\n"); + return NULL; +} + +/* since freetdm takes care of closing the file descriptor and uses openr2_chan_new_from_fd, openr2 should never call this hook */ +static int ftdm_r2_io_close(openr2_chan_t *r2chan) +{ + ftdm_log(FTDM_LOG_ERROR, "I should not be called (I/O close)!!\n"); + return 0; +} + +/* since freetdm takes care of opening the file descriptor and using openr2_chan_new_from_fd, openr2 should never call this hook */ +static int ftdm_r2_io_setup(openr2_chan_t *r2chan) +{ + ftdm_log(FTDM_LOG_ERROR, "I should not be called (I/O Setup)!!\n"); + return 0; +} + +/* since the signaling thread calls openr2_chan_process_cas_signaling directly, openr2 should never call this hook */ +static int ftdm_r2_io_get_oob_event(openr2_chan_t *r2chan, openr2_oob_event_t *event) +{ + *event = 0; + ftdm_log(FTDM_LOG_ERROR, "I should not be called (I/O get oob event)!!\n"); + return 0; +} + +static openr2_io_interface_t ftdm_r2_io_iface = { + .open = ftdm_r2_io_open, /* never called */ + .close = ftdm_r2_io_close, /* never called */ + .set_cas = ftdm_r2_io_set_cas, + .get_cas = ftdm_r2_io_get_cas, + .flush_write_buffers = ftdm_r2_io_flush_write_buffers, + .write = ftdm_r2_io_write, + .read = ftdm_r2_io_read, + .setup = ftdm_r2_io_setup, /* never called */ + .wait = ftdm_r2_io_wait, + .get_oob_event = ftdm_r2_io_get_oob_event /* never called */ +}; + +static ZIO_SIG_CONFIGURE_FUNCTION(ftdm_r2_configure_span) + //ftdm_status_t (ftdm_span_t *span, zio_signal_cb_t sig_cb, va_list ap) +{ + int i = 0; + int conf_failure = 0; + char *var = NULL; + char *val = NULL; + ftdm_r2_data_t *r2data = NULL; + ftdm_r2_span_pvt_t *spanpvt = NULL; + ftdm_r2_call_t *r2call = NULL; + openr2_chan_t *r2chan = NULL; + + assert(sig_cb != NULL); + + ft_r2_conf_t r2conf = + { + .variant = OR2_VAR_ITU, + .category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER, + .loglevel = OR2_LOG_ERROR | OR2_LOG_WARNING, + .max_ani = 10, + .max_dnis = 4, + .mfback_timeout = -1, + .metering_pulse_timeout = -1, + .allow_collect_calls = -1, + .immediate_accept = -1, + .skip_category = -1, + .forced_release = -1, + .charge_calls = -1, + .get_ani_first = -1, + .call_files = -1, + .logdir = NULL, + .advanced_protocol_file = NULL + }; + + + if (span->signal_type) { + snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling."); + return FTDM_FAIL; + } + + while ((var = va_arg(ap, char *))) { + ftdm_log(FTDM_LOG_DEBUG, "Reading R2 parameter %s for span %d\n", var, span->span_id); + if (!strcasecmp(var, "variant")) { + if (!(val = va_arg(ap, char *))) { + break; + } + if (ftdm_strlen_zero_buf(val)) { + ftdm_log(FTDM_LOG_NOTICE, "Ignoring empty R2 variant parameter\n"); + continue; + } + r2conf.variant = openr2_proto_get_variant(val); + if (r2conf.variant == OR2_VAR_UNKNOWN) { + ftdm_log(FTDM_LOG_ERROR, "Unknown R2 variant %s\n", val); + conf_failure = 1; + break; + } + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d for variant %s\n", span->span_id, val); + } else if (!strcasecmp(var, "category")) { + if (!(val = va_arg(ap, char *))) { + break; + } + if (ftdm_strlen_zero_buf(val)) { + ftdm_log(FTDM_LOG_NOTICE, "Ignoring empty R2 category parameter\n"); + continue; + } + r2conf.category = openr2_proto_get_category(val); + if (r2conf.category == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) { + ftdm_log(FTDM_LOG_ERROR, "Unknown R2 caller category %s\n", val); + conf_failure = 1; + break; + } + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with default category %s\n", span->span_id, val); + } else if (!strcasecmp(var, "logdir")) { + if (!(val = va_arg(ap, char *))) { + break; + } + if (ftdm_strlen_zero_buf(val)) { + ftdm_log(FTDM_LOG_NOTICE, "Ignoring empty R2 logdir parameter\n"); + continue; + } + r2conf.logdir = val; + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with logdir %s\n", span->span_id, val); + } else if (!strcasecmp(var, "logging")) { + if (!(val = va_arg(ap, char *))) { + break; + } + if (ftdm_strlen_zero_buf(val)) { + ftdm_log(FTDM_LOG_NOTICE, "Ignoring empty R2 logging parameter\n"); + continue; + } + openr2_log_level_t tmplevel; + char *clevel; + char *logval = ftdm_malloc(strlen(val)+1); /* alloca man page scared me, so better to use good ol' malloc */ + if (!logval) { + ftdm_log(FTDM_LOG_WARNING, "Ignoring R2 logging parameter: '%s', failed to alloc memory\n", val); + continue; + } + strcpy(logval, val); + while (logval) { + clevel = strsep(&logval, ","); + if (-1 == (tmplevel = openr2_log_get_level(clevel))) { + ftdm_log(FTDM_LOG_WARNING, "Ignoring invalid R2 logging level: '%s'\n", clevel); + continue; + } + r2conf.loglevel |= tmplevel; + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with loglevel %s\n", span->span_id, clevel); + } + ftdm_safe_free(logval); + } else if (!strcasecmp(var, "advanced_protocol_file")) { + if (!(val = va_arg(ap, char *))) { + break; + } + if (ftdm_strlen_zero_buf(val)) { + ftdm_log(FTDM_LOG_NOTICE, "Ignoring empty R2 advanced_protocol_file parameter\n"); + continue; + } + r2conf.advanced_protocol_file = val; + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with advanced protocol file %s\n", span->span_id, val); + } else if (!strcasecmp(var, "allow_collect_calls")) { + r2conf.allow_collect_calls = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with allow collect calls max ani = %d\n", span->span_id, r2conf.allow_collect_calls); + } else if (!strcasecmp(var, "double_answer")) { + r2conf.double_answer = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with double answer = %d\n", span->span_id, r2conf.double_answer); + } else if (!strcasecmp(var, "immediate_accept")) { + r2conf.immediate_accept = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with immediate accept = %d\n", span->span_id, r2conf.immediate_accept); + } else if (!strcasecmp(var, "skip_category")) { + r2conf.skip_category = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with skip category = %d\n", span->span_id, r2conf.skip_category); + } else if (!strcasecmp(var, "forced_release")) { + r2conf.forced_release = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with forced release = %d\n", span->span_id, r2conf.forced_release); + } else if (!strcasecmp(var, "charge_calls")) { + r2conf.charge_calls = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with charge calls = %d\n", span->span_id, r2conf.charge_calls); + } else if (!strcasecmp(var, "get_ani_first")) { + r2conf.get_ani_first = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with get ani first = %d\n", span->span_id, r2conf.get_ani_first); + } else if (!strcasecmp(var, "call_files")) { + r2conf.call_files = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with call files = %d\n", span->span_id, r2conf.call_files); + } else if (!strcasecmp(var, "mfback_timeout")) { + r2conf.mfback_timeout = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with MF backward timeout = %dms\n", span->span_id, r2conf.mfback_timeout); + } else if (!strcasecmp(var, "metering_pulse_timeout")) { + r2conf.metering_pulse_timeout = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with metering pulse timeout = %dms\n", span->span_id, r2conf.metering_pulse_timeout); + } else if (!strcasecmp(var, "max_ani")) { + r2conf.max_ani = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with max ani = %d\n", span->span_id, r2conf.max_ani); + } else if (!strcasecmp(var, "max_dnis")) { + r2conf.max_dnis = va_arg(ap, int); + ftdm_log(FTDM_LOG_DEBUG, "Configuring R2 span %d with max dnis = %d\n", span->span_id, r2conf.max_dnis); + } else { + snprintf(span->last_error, sizeof(span->last_error), "Unknown R2 parameter [%s]", var); + return FTDM_FAIL; + } + } + + if (conf_failure) { + snprintf(span->last_error, sizeof(span->last_error), "R2 configuration error"); + return FTDM_FAIL; + } + + r2data = ftdm_malloc(sizeof(*r2data)); + if (!r2data) { + snprintf(span->last_error, sizeof(span->last_error), "Failed to allocate R2 data."); + return FTDM_FAIL; + } + memset(r2data, 0, sizeof(*r2data)); + + spanpvt = ftdm_malloc(sizeof(*spanpvt)); + if (!spanpvt) { + snprintf(span->last_error, sizeof(span->last_error), "Failed to allocate private span data container."); + goto fail; + } + memset(spanpvt, 0, sizeof(*spanpvt)); + + r2data->r2context = openr2_context_new(r2conf.variant, &ftdm_r2_event_iface, r2conf.max_ani, r2conf.max_dnis); + if (!r2data->r2context) { + snprintf(span->last_error, sizeof(span->last_error), "Cannot create openr2 context for span."); + goto fail; + } + openr2_context_set_io_type(r2data->r2context, OR2_IO_CUSTOM, &ftdm_r2_io_iface); + openr2_context_set_log_level(r2data->r2context, r2conf.loglevel); + openr2_context_set_ani_first(r2data->r2context, r2conf.get_ani_first); + openr2_context_set_skip_category_request(r2data->r2context, r2conf.skip_category); + openr2_context_set_mf_back_timeout(r2data->r2context, r2conf.mfback_timeout); + openr2_context_set_metering_pulse_timeout(r2data->r2context, r2conf.metering_pulse_timeout); + openr2_context_set_double_answer(r2data->r2context, r2conf.double_answer); + openr2_context_set_immediate_accept(r2data->r2context, r2conf.immediate_accept); + if (r2conf.logdir) { + openr2_context_set_log_directory(r2data->r2context, r2conf.logdir); + } + if (r2conf.advanced_protocol_file) { + openr2_context_configure_from_advanced_file(r2data->r2context, r2conf.advanced_protocol_file); + } + + spanpvt->r2calls = create_hashtable(FTDM_MAX_CHANNELS_SPAN, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + if (!spanpvt->r2calls) { + snprintf(span->last_error, sizeof(span->last_error), "Cannot create channel calls hash for span."); + goto fail; + } + + for (i = 1; (i <= span->chan_count) && (i <= FTDM_MAX_CHANNELS_SPAN); i++) { + r2chan = openr2_chan_new_from_fd(r2data->r2context, span->channels[i], span->channels[i]->physical_chan_id); + if (!r2chan) { + snprintf(span->last_error, sizeof(span->last_error), "Cannot create all openr2 channels for span."); + goto fail; + } + if (r2conf.call_files) { + openr2_chan_enable_call_files(r2chan); + openr2_chan_set_log_level(r2chan, r2conf.loglevel); + } + + r2call = ftdm_malloc(sizeof(*r2call)); + if (!r2call) { + snprintf(span->last_error, sizeof(span->last_error), "Cannot create all R2 call data structures for the span."); + ftdm_safe_free(r2chan); + goto fail; + } + memset(r2call, 0, sizeof(*r2call)); + openr2_chan_set_logging_func(r2chan, ftdm_r2_on_chan_log); + openr2_chan_set_client_data(r2chan, span->channels[i]); + r2call->r2chan = r2chan; + span->channels[i]->call_data = r2call; + /* value and key are the same so just free one of them */ + snprintf(r2call->name, sizeof(r2call->name), "chancall%d", i); + hashtable_insert(spanpvt->r2calls, (void *)r2call->name, r2call, HASHTABLE_FLAG_FREE_VALUE); + + } + spanpvt->r2context = r2data->r2context; + + /* just the value must be freed by the hash */ + hashtable_insert(g_mod_data_hash, (void *)span->name, spanpvt, HASHTABLE_FLAG_FREE_VALUE); + + span->start = ftdm_r2_start; + r2data->flags = 0; + r2data->sig_cb = sig_cb; + span->signal_type = FTDM_SIGTYPE_R2; + span->signal_data = r2data; + span->outgoing_call = r2_outgoing_call; + + return FTDM_SUCCESS; + +fail: + + if (r2data && r2data->r2context) { + openr2_context_delete(r2data->r2context); + } + if (spanpvt && spanpvt->r2calls) { + hashtable_destroy(spanpvt->r2calls); + } + ftdm_safe_free(r2data); + ftdm_safe_free(spanpvt); + return FTDM_FAIL; + +} + +static void *ftdm_r2_channel_run(ftdm_thread_t *me, void *obj) +{ + ftdm_channel_t *closed_chan; + uint32_t interval = 0; + ftdm_sigmsg_t sigev; + ftdm_channel_t *ftdmchan = (ftdm_channel_t *)obj; + openr2_chan_t *r2chan = R2CALL(ftdmchan)->r2chan; + ftdm_r2_data_t *r2data = ftdmchan->span->signal_data; + + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INTHREAD); + + ftdm_mutex_lock(g_thread_count_mutex); + g_thread_count++; + ftdm_mutex_unlock(g_thread_count_mutex); + + ftdm_log(FTDM_LOG_DEBUG, "R2 CHANNEL thread starting on %d in state %s.\n", + ftdmchan->physical_chan_id, + ftdm_channel_state2str(ftdmchan->state)); + + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error); + goto endthread; + } + + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_INTERVAL, &interval); + + assert(interval != 0); + ftdm_log(FTDM_LOG_DEBUG, "Got %d interval for chan %d\n", interval, ftdmchan->physical_chan_id); + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + /* FIXME: is this needed? */ + memset(ftdmchan->caller_data.dnis.digits, 0, sizeof(ftdmchan->caller_data.collected)); + memset(ftdmchan->caller_data.ani.digits, 0, sizeof(ftdmchan->caller_data.collected)); + } + + memset(&sigev, 0, sizeof(sigev)); + sigev.chan_id = ftdmchan->chan_id; + sigev.span_id = ftdmchan->span_id; + sigev.channel = ftdmchan; + + while (ftdm_running()) { + int32_t read_enabled = openr2_chan_get_read_enabled(r2chan); + ftdm_wait_flag_t flags = read_enabled ? ( FTDM_READ | FTDM_WRITE ) : 0; + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE) && (R2CALL(ftdmchan)->chanstate != ftdmchan->state)) { + + ftdm_log(FTDM_LOG_DEBUG, "Executing state handler on %d:%d for %s\n", ftdmchan->span_id, ftdmchan->chan_id, ftdm_channel_state2str(ftdmchan->state)); + R2CALL(ftdmchan)->chanstate = ftdmchan->state; + + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) && !R2CALL(ftdmchan)->accepted && + (ftdmchan->state == FTDM_CHANNEL_STATE_PROGRESS || + ftdmchan->state == FTDM_CHANNEL_STATE_PROGRESS_MEDIA || + ftdmchan->state == FTDM_CHANNEL_STATE_UP) ) { + /* if an accept ack will be required we should not acknowledge the state change just yet, + it will be done below after processing the MF signals, otherwise we have a race condition between freetdm calling + openr2_chan_answer_call and openr2 accepting the call first, if freetdm calls openr2_chan_answer_call before the accept cycle + completes, openr2 will fail to answer the call */ + ftdm_log(FTDM_LOG_DEBUG, "State ack in chan %d:%d for state %s will have to wait a bit\n", ftdmchan->span_id, ftdmchan->chan_id, ftdm_channel_state2str(ftdmchan->state)); + } else if (ftdmchan->state != FTDM_CHANNEL_STATE_DOWN){ + /* the down state will be completed in ftdm_channel_done below */ + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + ftdm_channel_complete_state(ftdmchan); + } + + switch (ftdmchan->state) { + + /* starting an incoming call */ + case FTDM_CHANNEL_STATE_COLLECT: + { + ftdm_log(FTDM_LOG_DEBUG, "COLLECT: Starting processing of incoming call in channel %d with interval %d\n", ftdmchan->physical_chan_id, interval); + } + break; + + /* starting an outgoing call */ + case FTDM_CHANNEL_STATE_DIALING: + { + // FIXME: use user defined calling party + ftdm_channel_use(ftdmchan); + ftdm_log(FTDM_LOG_DEBUG, "DIALING: Starting processing of outgoing call in channel %d with interval %d\n", ftdmchan->physical_chan_id, interval); + if (openr2_chan_make_call(r2chan, ftdmchan->caller_data.cid_num.digits, ftdmchan->caller_data.ani.digits, OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER)) { + ftdm_log(FTDM_LOG_ERROR, "%d:%d Failed to make call in R2 channel, openr2_chan_make_call failed\n", ftdmchan->span_id, ftdmchan->chan_id); + ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_DESTINATION_OUT_OF_ORDER; + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + } + } + break; + + /* the call is ringing */ + case FTDM_CHANNEL_STATE_PROGRESS: + case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: + { + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + if (!R2CALL(ftdmchan)->accepted) { + ftdm_log(FTDM_LOG_DEBUG, "PROGRESS: Accepting call on channel %d\n", ftdmchan->physical_chan_id); + ft_r2_accept_call(ftdmchan); + } + } else { + ftdm_log(FTDM_LOG_DEBUG, "PROGRESS: Notifying progress in channel %d\n", ftdmchan->physical_chan_id); + sigev.event_id = FTDM_SIGEVENT_PROGRESS; + if (r2data->sig_cb(&sigev) != FTDM_SUCCESS) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + } + } + } + break; + + /* the call was answered */ + case FTDM_CHANNEL_STATE_UP: + { + ftdm_log(FTDM_LOG_DEBUG, "UP: Call was answered on channel %d\n", ftdmchan->physical_chan_id); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + if (!R2CALL(ftdmchan)->accepted) { + ftdm_log(FTDM_LOG_DEBUG, "UP: Call has not been accepted, need to accept first\n"); + // the answering will be done in the on_call_accepted handler + ft_r2_accept_call(ftdmchan); + R2CALL(ftdmchan)->answer_pending = 1; + } else { + ft_r2_answer_call(ftdmchan); + } + } else { + ftdm_log(FTDM_LOG_DEBUG, "UP: Notifying of call answered in channel %d\n", ftdmchan->physical_chan_id); + sigev.event_id = FTDM_SIGEVENT_UP; + if (r2data->sig_cb(&sigev) != FTDM_SUCCESS) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + } + } + } + break; + + /* just got hangup */ + case FTDM_CHANNEL_STATE_HANGUP: + { + /* FIXME: the cause should be retrieved from ftdmchan->caller_data.hangup_cause and translated from Q931 to R2 cause */ + ftdm_log(FTDM_LOG_DEBUG, "HANGUP: Clearing call on channel %d\n", ftdmchan->physical_chan_id); + if (!R2CALL(ftdmchan)->disconnect_rcvd) { + /* this will disconnect the call, but need to wait for the call end before moving to DOWN */ + openr2_chan_disconnect_call(r2chan, OR2_CAUSE_NORMAL_CLEARING); + } else { + /* at this point on_call_end possibly was already called, + * but we needed to wait for the freetdm confirmation before moving to DOWN */ + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); + } + } + break; + + /* just got hangup from the freetdm side due to abnormal failure */ + case FTDM_CHANNEL_STATE_CANCEL: + { + ftdm_log(FTDM_LOG_DEBUG, "CANCEL: Unable to receive call on channel %d\n", ftdmchan->physical_chan_id); + openr2_chan_disconnect_call(r2chan, OR2_CAUSE_OUT_OF_ORDER); + } + break; + + /* finished call for good */ + case FTDM_CHANNEL_STATE_DOWN: + { + ftdm_log(FTDM_LOG_DEBUG, "DOWN: Placing channel %d back to the pool of available channels\n", ftdmchan->physical_chan_id); + ftdm_channel_done(ftdmchan); + goto endthread; + } + break; + + default: + { + ftdm_log(FTDM_LOG_ERROR, "%s: Unhandled channel state change in channel %d\n", ftdm_channel_state2str(ftdmchan->state), ftdmchan->physical_chan_id); + } + break; + + } + } + + if (flags) { + if (ftdm_channel_wait(ftdmchan, &flags, interval * 2) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_DEBUG, "ftdm_channel_wait did not return FTDM_SUCCESS\n"); + continue; + } + + /* handle timeout events first if any */ + openr2_chan_run_schedule(r2chan); + + /* openr2 will now try to detect MF tones, make sense out of them, reply if necessary with another tone and trigger + * telephony events via the call event interface we provided when creating the R2 context. + * openr2 will also call our I/O callbacks to retrieve audio from the channel and call our wait poll I/O registered callback + * and will not return from this function until the I/O poll callback returns no pending events + * */ + openr2_chan_process_mf_signaling(r2chan); + if (R2CALL(ftdmchan)->state_ack_pending) { + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + ftdm_channel_complete_state(ftdmchan); + R2CALL(ftdmchan)->state_ack_pending = 0; + } + } else { + /* once the MF signaling has end we just loop here waiting for state changes */ + ftdm_sleep(interval); + } + + } + +endthread: + + closed_chan = ftdmchan; + ftdm_channel_close(&closed_chan); + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_INTHREAD); + ftdm_log(FTDM_LOG_DEBUG, "R2 channel %d thread ended.\n", ftdmchan->physical_chan_id); + + ftdm_mutex_lock(g_thread_count_mutex); + g_thread_count--; + ftdm_mutex_unlock(g_thread_count_mutex); + + return NULL; +} + +static void *ftdm_r2_run(ftdm_thread_t *me, void *obj) +{ + openr2_chan_t *r2chan; + ftdm_status_t status; + ftdm_span_t *span = (ftdm_span_t *) obj; + ftdm_r2_data_t *r2data = span->signal_data; + int waitms = 1000; + int i; + + ftdm_log(FTDM_LOG_DEBUG, "OpenR2 monitor thread started.\n"); + r2chan = NULL; + for (i = 1; i <= span->chan_count; i++) { + r2chan = R2CALL(span->channels[i])->r2chan; + openr2_chan_set_idle(r2chan); + openr2_chan_process_cas_signaling(r2chan); + } + + while (ftdm_running() && ftdm_test_flag(r2data, FTDM_R2_RUNNING)) { + status = ftdm_span_poll_event(span, waitms); + if (FTDM_FAIL == status) { + ftdm_log(FTDM_LOG_ERROR, "Failure Polling event! [%s]\n", span->last_error); + continue; + } + if (FTDM_SUCCESS == status) { + ftdm_event_t *event; + while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) { + if (event->enum_id == FTDM_OOB_CAS_BITS_CHANGE) { + r2chan = R2CALL(event->channel)->r2chan; + ftdm_log(FTDM_LOG_DEBUG, "Handling CAS on channel %d.\n", openr2_chan_get_number(r2chan)); + // we only expect CAS and other OOB events on this thread/loop, once a call is started + // the MF events (in-band signaling) are handled in the call thread + openr2_chan_process_cas_signaling(r2chan); + } else { + ftdm_log(FTDM_LOG_DEBUG, "Ignoring event %d on channel %d.\n", event->enum_id, openr2_chan_get_number(r2chan)); + // XXX TODO: handle alarms here XXX + } + } + } else if (status != FTDM_TIMEOUT) { + ftdm_log(FTDM_LOG_ERROR, "ftdm_span_poll_event returned %d.\n", status); + } else { + //ftdm_log(FTDM_LOG_DEBUG, "timed out waiting for event on span %d\n", span->span_id); + } + } + + /* + FIXME: we should set BLOCKED but at this point I/O routines of freetdm caused segfault + for (i = 1; i <= span->chan_count; i++) { + r2chan = R2CALL(span->channels[i])->r2chan; + openr2_chan_set_blocked(r2chan); + } + */ + + ftdm_clear_flag(r2data, FTDM_R2_RUNNING); + ftdm_log(FTDM_LOG_DEBUG, "R2 thread ending.\n"); + + return NULL; + +} + +static ZIO_API_FUNCTION(ftdm_r2_api) +{ + char *mycmd = NULL, *argv[10] = { 0 }; + int argc = 0; + + if (data) { + mycmd = ftdm_strdup(data); + argc = ftdm_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); + } + + if (argc == 2) { + if (!strcasecmp(argv[0], "kill")) { + int span_id = atoi(argv[1]); + ftdm_span_t *span = NULL; + + if (ftdm_span_find_by_name(argv[1], &span) == FTDM_SUCCESS || ftdm_span_find(span_id, &span) == FTDM_SUCCESS) { + ftdm_r2_data_t *r2data = span->signal_data; + + if (span->start != ftdm_r2_start) { + stream->write_function(stream, "-ERR invalid span.\n"); + goto done; + } + + ftdm_clear_flag(r2data, FTDM_R2_RUNNING); + stream->write_function(stream, "+OK killed.\n"); + goto done; + } else { + stream->write_function(stream, "-ERR invalid span.\n"); + goto done; + } + } + + if (!strcasecmp(argv[0], "status")) { + int span_id = atoi(argv[1]); + ftdm_r2_data_t *r2data = NULL; + ftdm_span_t *span = NULL; + openr2_chan_t *r2chan = NULL; + openr2_context_t *r2context = NULL; + int i = 0; + + if (ftdm_span_find_by_name(argv[1], &span) == FTDM_SUCCESS || ftdm_span_find(span_id, &span) == FTDM_SUCCESS) { + if (span->start != ftdm_r2_start) { + stream->write_function(stream, "-ERR not an R2 span.\n"); + goto done; + } + if (!(r2data = span->signal_data)) { + stream->write_function(stream, "-ERR invalid span. No R2 singal data in span.\n"); + goto done; + } + r2context = r2data->r2context; + openr2_variant_t r2variant = openr2_context_get_variant(r2context); + stream->write_function(stream, + "Variant: %s\n" + "Max ANI: %d\n" + "Max DNIS: %d\n" + "ANI First: %s\n" + "Immediate Accept: %s\n", + openr2_proto_get_variant_string(r2variant), + openr2_context_get_max_ani(r2context), + openr2_context_get_max_dnis(r2context), + openr2_context_get_ani_first(r2context) ? "Yes" : "No", + openr2_context_get_immediate_accept(r2context) ? "Yes" : "No"); + stream->write_function(stream, "\n"); + stream->write_function(stream, "%4s %-12.12s %-12.12s\n", "Channel", "Tx CAS", "Rx CAS"); + for (i = 1; i <= span->chan_count; i++) { + if (i == 16) continue; + r2chan = R2CALL(span->channels[i])->r2chan; + stream->write_function(stream, "%4d %-12.12s %-12.12s\n", + span->channels[i]->physical_chan_id, + openr2_chan_get_tx_cas_string(r2chan), + openr2_chan_get_rx_cas_string(r2chan)); + } + stream->write_function(stream, "\n"); + stream->write_function(stream, "+OK.\n"); + goto done; + } else { + stream->write_function(stream, "-ERR invalid span.\n"); + goto done; + } + } + + } + + if (argc == 1) { + if (!strcasecmp(argv[0], "threads")) { + ftdm_mutex_lock(g_thread_count_mutex); + stream->write_function(stream, "%d R2 channel threads up\n", g_thread_count); + ftdm_mutex_unlock(g_thread_count_mutex); + stream->write_function(stream, "+OK.\n"); + goto done; + } + + if (!strcasecmp(argv[0], "version")) { + stream->write_function(stream, "OpenR2 version: %s, revision: %s\n", openr2_get_version(), openr2_get_revision()); + stream->write_function(stream, "+OK.\n"); + goto done; + } + + if (!strcasecmp(argv[0], "variants")) { + int32_t numvariants = 0; + const openr2_variant_entry_t *variants = openr2_proto_get_variant_list(&numvariants); + if (!variants) { + stream->write_function(stream, "-ERR failed to retrieve openr2 variant list.\n"); + goto done; + } +#define VARIANT_FORMAT "%4s %40s\n" + stream->write_function(stream, VARIANT_FORMAT, "Variant Code", "Country"); + numvariants--; + for (; numvariants; numvariants--) { + stream->write_function(stream, VARIANT_FORMAT, variants[numvariants].name, variants[numvariants].country); + } + stream->write_function(stream, "+OK.\n"); +#undef VARIANT_FORMAT + goto done; + } + } + + stream->write_function(stream, "-ERR invalid command.\n"); + +done: + + ftdm_safe_free(mycmd); + + return FTDM_SUCCESS; + +} + +static ZIO_IO_LOAD_FUNCTION(ftdm_r2_io_init) +{ + assert(zio != NULL); + memset(&g_ftdm_r2_interface, 0, sizeof(g_ftdm_r2_interface)); + + g_ftdm_r2_interface.name = "r2"; + g_ftdm_r2_interface.api = ftdm_r2_api; + + *zio = &g_ftdm_r2_interface; + + return FTDM_SUCCESS; +} + +static ZIO_SIG_LOAD_FUNCTION(ftdm_r2_init) +{ + g_mod_data_hash = create_hashtable(10, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); + if (!g_mod_data_hash) { + return FTDM_FAIL; + } + ftdm_mutex_create(&g_thread_count_mutex); + return FTDM_SUCCESS; +} + +static ZIO_SIG_UNLOAD_FUNCTION(ftdm_r2_destroy) +{ + ftdm_hash_iterator_t *i = NULL; + ftdm_r2_span_pvt_t *spanpvt = NULL; + const void *key = NULL; + void *val = NULL; + for (i = hashtable_first(g_mod_data_hash); i; i = hashtable_next(i)) { + hashtable_this(i, &key, NULL, &val); + if (key && val) { + spanpvt = val; + openr2_context_delete(spanpvt->r2context); + hashtable_destroy(spanpvt->r2calls); + } + } + hashtable_destroy(g_mod_data_hash); + ftdm_mutex_destroy(&g_thread_count_mutex); + return FTDM_SUCCESS; +} + +ftdm_module_t ftdm_module = { + "r2", + ftdm_r2_io_init, + NULL, + ftdm_r2_init, + ftdm_r2_configure_span, + ftdm_r2_destroy +}; + + +/* For Emacs: + * Local Variables: + * mode:c + * indent-tabs-mode:t + * tab-width:4 + * c-basic-offset:4 + * End: + * For VIM: + * vim:set softtabstop=4 shiftwidth=4 tabstop=4 + */ diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/BOOST.limitations b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/BOOST.limitations similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/BOOST.limitations rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/BOOST.limitations diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/zap_sangoma_boost.h b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftdm_sangoma_boost.h similarity index 81% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/zap_sangoma_boost.h rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftdm_sangoma_boost.h index 91f54f930b..c3eb739f84 100644 --- a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/zap_sangoma_boost.h +++ b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftdm_sangoma_boost.h @@ -31,19 +31,19 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ZAP_SANGOMA_BOOST_H -#define ZAP_SANGOMA_BOOST_H +#ifndef FTDM_SANGOMA_BOOST_H +#define FTDM_SANGOMA_BOOST_H #include "sangoma_boost_client.h" -#include "openzap.h" +#include "freetdm.h" #define MAX_CHANS_PER_TRUNKGROUP 1024 typedef enum { - ZAP_SANGOMA_BOOST_RUNNING = (1 << 0), - ZAP_SANGOMA_BOOST_RESTARTING = (1 << 1) -} zap_sangoma_boost_flag_t; + FTDM_SANGOMA_BOOST_RUNNING = (1 << 0), + FTDM_SANGOMA_BOOST_RESTARTING = (1 << 1) +} ftdm_sangoma_boost_flag_t; -typedef struct zap_sangoma_boost_data { +typedef struct ftdm_sangoma_boost_data { sangomabc_connection_t mcon; sangomabc_connection_t pcon; fd_set rfds; @@ -52,16 +52,16 @@ typedef struct zap_sangoma_boost_data { zio_signal_cb_t signal_cb; uint32_t flags; boost_sigmod_interface_t *sigmod; - zap_queue_t *boost_queue; -} zap_sangoma_boost_data_t; + ftdm_queue_t *boost_queue; +} ftdm_sangoma_boost_data_t; -typedef struct zap_sangoma_boost_trunkgroup { - zap_mutex_t *mutex; - zap_size_t size; /* Number of b-channels in group */ +typedef struct ftdm_sangoma_boost_trunkgroup { + ftdm_mutex_t *mutex; + ftdm_size_t size; /* Number of b-channels in group */ unsigned int last_used_index; /* index of last b-channel used */ - zap_channel_t* zchans[MAX_CHANS_PER_TRUNKGROUP]; + ftdm_channel_t* ftdmchans[MAX_CHANS_PER_TRUNKGROUP]; //DAVIDY need to merge congestion timeouts to this struct -} zap_sangoma_boost_trunkgroup_t; +} ftdm_sangoma_boost_trunkgroup_t; #endif /* For Emacs: diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.c b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c similarity index 51% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.c rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c index cc85b0bfee..5641086b4d 100644 --- a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.c +++ b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/ftmod_sangoma_boost.c @@ -43,28 +43,28 @@ On WIN32 platform this code works with sigmod ONLY, don't try to make sense of a I basically ifdef out everything that the compiler complained about */ -#include "openzap.h" +#include "freetdm.h" #include "sangoma_boost_client.h" -#include "zap_sangoma_boost.h" +#include "ftdm_sangoma_boost.h" #ifdef HAVE_SYS_SELECT_H #include #endif /* Boost signaling modules global hash and its mutex */ -zap_mutex_t *g_boost_modules_mutex = NULL; -zap_hash_t *g_boost_modules_hash = NULL; +ftdm_mutex_t *g_boost_modules_mutex = NULL; +ftdm_hash_t *g_boost_modules_hash = NULL; #define MAX_TRUNK_GROUPS 64 -//DAVIDY need to merge congestion_timeouts with zap_sangoma_boost_trunkgroups +//DAVIDY need to merge congestion_timeouts with ftdm_sangoma_boost_trunkgroups static time_t congestion_timeouts[MAX_TRUNK_GROUPS]; -static zap_sangoma_boost_trunkgroup_t *g_trunkgroups[MAX_TRUNK_GROUPS]; +static ftdm_sangoma_boost_trunkgroup_t *g_trunkgroups[MAX_TRUNK_GROUPS]; #define BOOST_QUEUE_SIZE 500 -/* get openzap span and chan depending on the span mode */ -#define BOOST_SPAN(zchan) ((zap_sangoma_boost_data_t*)(zchan)->span->signal_data)->sigmod ? zchan->physical_span_id : zchan->physical_span_id-1 -#define BOOST_CHAN(zchan) ((zap_sangoma_boost_data_t*)(zchan)->span->signal_data)->sigmod ? zchan->physical_chan_id : zchan->physical_chan_id-1 +/* get freetdm span and chan depending on the span mode */ +#define BOOST_SPAN(ftdmchan) ((ftdm_sangoma_boost_data_t*)(ftdmchan)->span->signal_data)->sigmod ? ftdmchan->physical_span_id : ftdmchan->physical_span_id-1 +#define BOOST_CHAN(ftdmchan) ((ftdm_sangoma_boost_data_t*)(ftdmchan)->span->signal_data)->sigmod ? ftdmchan->physical_chan_id : ftdmchan->physical_chan_id-1 /** * \brief Strange flag @@ -94,19 +94,19 @@ typedef enum { typedef struct { sangoma_boost_request_status_t status; sangomabc_short_event_t event; - zap_span_t *span; - zap_channel_t *zchan; + ftdm_span_t *span; + ftdm_channel_t *ftdmchan; } sangoma_boost_request_t; -//#define MAX_REQ_ID ZAP_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN * ZAP_MAX_CHANNELS_PHYSICAL_SPAN +//#define MAX_REQ_ID FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN * FTDM_MAX_CHANNELS_PHYSICAL_SPAN #define MAX_REQ_ID 6000 -static uint16_t SETUP_GRID[ZAP_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN+1][ZAP_MAX_CHANNELS_PHYSICAL_SPAN+1] = {{ 0 }}; +static uint16_t SETUP_GRID[FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN+1][FTDM_MAX_CHANNELS_PHYSICAL_SPAN+1] = {{ 0 }}; static sangoma_boost_request_t OUTBOUND_REQUESTS[MAX_REQ_ID+1] = {{ 0 }}; -static zap_mutex_t *request_mutex = NULL; -static zap_mutex_t *signal_mutex = NULL; +static ftdm_mutex_t *request_mutex = NULL; +static ftdm_mutex_t *signal_mutex = NULL; static uint8_t req_map[MAX_REQ_ID+1] = { 0 }; static uint8_t nack_map[MAX_REQ_ID+1] = { 0 }; @@ -123,13 +123,13 @@ static void __release_request_id_span_chan(int span, int chan, const char *func, { int id; - zap_mutex_lock(request_mutex); + ftdm_mutex_lock(request_mutex); if ((id = SETUP_GRID[span][chan])) { assert(id <= MAX_REQ_ID); req_map[id] = 0; SETUP_GRID[span][chan] = 0; } - zap_mutex_unlock(request_mutex); + ftdm_mutex_unlock(request_mutex); } #define release_request_id_span_chan(s, c) __release_request_id_span_chan(s, c, __FUNCTION__, __LINE__) @@ -142,9 +142,9 @@ static void __release_request_id_span_chan(int span, int chan, const char *func, static void __release_request_id(sangoma_boost_request_id_t r, const char *func, int line) { assert(r <= MAX_REQ_ID); - zap_mutex_lock(request_mutex); + ftdm_mutex_lock(request_mutex); req_map[r] = 0; - zap_mutex_unlock(request_mutex); + ftdm_mutex_unlock(request_mutex); } #define release_request_id(r) __release_request_id(r, __FUNCTION__, __LINE__) @@ -161,7 +161,7 @@ static sangoma_boost_request_id_t __next_request_id(const char *func, int line) sangoma_boost_request_id_t r = 0, i = 0; int found=0; - zap_mutex_lock(request_mutex); + ftdm_mutex_lock(request_mutex); //r = ++last_req; //while(!r || req_map[r]) { @@ -184,7 +184,7 @@ static sangoma_boost_request_id_t __next_request_id(const char *func, int line) } - zap_mutex_unlock(request_mutex); + ftdm_mutex_unlock(request_mutex); if (!found) { return 0; @@ -201,11 +201,11 @@ static sangoma_boost_request_id_t __next_request_id(const char *func, int line) * \param force Do not wait for the channel to be available if in use * \return NULL if not found, channel otherwise */ -static zap_channel_t *find_zchan(zap_span_t *span, sangomabc_short_event_t *event, int force) +static ftdm_channel_t *find_ftdmchan(ftdm_span_t *span, sangomabc_short_event_t *event, int force) { uint32_t i; - zap_channel_t *zchan = NULL; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_channel_t *ftdmchan = NULL; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; uint32_t targetspan = event->span+1; uint32_t targetchan = event->chan+1; if (sangoma_boost_data->sigmod) { @@ -214,15 +214,15 @@ static zap_channel_t *find_zchan(zap_span_t *span, sangomabc_short_event_t *even targetchan = event->chan; } - zap_mutex_lock(signal_mutex); + ftdm_mutex_lock(signal_mutex); for(i = 1; i <= span->chan_count; i++) { if (span->channels[i]->physical_span_id == targetspan && span->channels[i]->physical_chan_id == targetchan) { - zchan = span->channels[i]; - if (force || (zchan->state == ZAP_CHANNEL_STATE_DOWN && !zap_test_flag(zchan, ZAP_CHANNEL_INUSE))) { + ftdmchan = span->channels[i]; + if (force || (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE))) { break; } else { - zchan = NULL; - zap_log(ZAP_LOG_DEBUG, "Channel %d:%d ~ %d:%d is already in use.\n", + ftdmchan = NULL; + ftdm_log(FTDM_LOG_DEBUG, "Channel %d:%d ~ %d:%d is already in use.\n", span->channels[i]->span_id, span->channels[i]->chan_id, span->channels[i]->physical_span_id, @@ -232,9 +232,9 @@ static zap_channel_t *find_zchan(zap_span_t *span, sangomabc_short_event_t *even } } } - zap_mutex_unlock(signal_mutex); + ftdm_mutex_unlock(signal_mutex); - return zchan; + return ftdmchan; } static int check_congestion(int trunk_group) @@ -271,7 +271,7 @@ static int boost_media_ready(sangomabc_event_t *event) } else { } } else { - zap_log(ZAP_LOG_ERROR, "Invalid boost isup_rdnis MEDIA format %s\n", p); + ftdm_log(FTDM_LOG_ERROR, "Invalid boost isup_rdnis MEDIA format %s\n", p); } } return 0; @@ -283,13 +283,13 @@ static int boost_media_ready(sangomabc_event_t *event) * \param chan_id Specific channel to get (0 for any) * \param direction Call direction * \param caller_data Caller information - * \param zchan Channel to initialise + * \param ftdmchan Channel to initialise * \return Success or failure */ static ZIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request) { - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; - zap_status_t status = ZAP_FAIL; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_status_t status = FTDM_FAIL; sangoma_boost_request_id_t r; sangomabc_event_t event = {0}; int boost_request_timeout = 5000; @@ -298,32 +298,32 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request) char *gr = NULL; uint32_t count = 0; int tg=0; - if (zap_test_flag(span, ZAP_SPAN_SUSPENDED)) { - zap_log(ZAP_LOG_CRIT, "SPAN is not online.\n"); - *zchan = NULL; - return ZAP_FAIL; + if (ftdm_test_flag(span, FTDM_SPAN_SUSPENDED)) { + ftdm_log(FTDM_LOG_CRIT, "SPAN is not online.\n"); + *ftdmchan = NULL; + return FTDM_FAIL; } - zap_set_string(ani, caller_data->ani.digits); + ftdm_set_string(ani, caller_data->ani.digits); r = next_request_id(); if (r == 0) { - zap_log(ZAP_LOG_CRIT, "All tanks ids are busy.\n"); - *zchan = NULL; - return ZAP_FAIL; + ftdm_log(FTDM_LOG_CRIT, "All tanks ids are busy.\n"); + *ftdmchan = NULL; + return FTDM_FAIL; } sangomabc_call_init(&event, caller_data->cid_num.digits, ani, r); if (sangoma_boost_data->sigmod) { - *zchan = span->channels[chan_id]; + *ftdmchan = span->channels[chan_id]; - event.span = (uint8_t) (*zchan)->physical_span_id; - event.chan = (uint8_t) (*zchan)->physical_chan_id; + event.span = (uint8_t) (*ftdmchan)->physical_span_id; + event.chan = (uint8_t) (*ftdmchan)->physical_chan_id; - zap_set_flag((*zchan), ZAP_CHANNEL_OUTBOUND); - zap_set_flag_locked((*zchan), ZAP_CHANNEL_INUSE); + ftdm_set_flag((*ftdmchan), FTDM_CHANNEL_OUTBOUND); + ftdm_set_flag_locked((*ftdmchan), FTDM_CHANNEL_INUSE); - OUTBOUND_REQUESTS[r].zchan = *zchan; + OUTBOUND_REQUESTS[r].ftdmchan = *ftdmchan; } else { if ((gr = strchr(ani, '@'))) { *gr++ = '\0'; @@ -338,17 +338,17 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request) event.trunk_group = tg; if (check_congestion(tg)) { - zap_log(ZAP_LOG_CRIT, "All circuits are busy. Trunk Group=%i (BOOST REQUESTED BACK OFF)\n",tg+1); - *zchan = NULL; - return ZAP_FAIL; + ftdm_log(FTDM_LOG_CRIT, "All circuits are busy. Trunk Group=%i (BOOST REQUESTED BACK OFF)\n",tg+1); + *ftdmchan = NULL; + return FTDM_FAIL; } - zap_span_channel_use_count(span, &count); + ftdm_span_channel_use_count(span, &count); if (count >= span->chan_count) { - zap_log(ZAP_LOG_CRIT, "All circuits are busy.\n"); - *zchan = NULL; - return ZAP_FAIL; + ftdm_log(FTDM_LOG_CRIT, "All circuits are busy.\n"); + *ftdmchan = NULL; + return FTDM_FAIL; } if (gr && *(gr+1)) { @@ -366,14 +366,14 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request) event.hunt_group = SIGBOOST_HUNTGRP_RR_DESC; break; default: - zap_log(ZAP_LOG_WARNING, "Failed to determine huntgroup (%s)\n", gr); + ftdm_log(FTDM_LOG_WARNING, "Failed to determine huntgroup (%s)\n", gr); event.hunt_group = SIGBOOST_HUNTGRP_SEQ_ASC; } } } - zap_set_string(event.calling_name, caller_data->cid_name); - zap_set_string(event.isup_in_rdnis, caller_data->rdnis.digits); + ftdm_set_string(event.calling_name, caller_data->cid_name); + ftdm_set_string(event.isup_in_rdnis, caller_data->rdnis.digits); if (strlen(caller_data->rdnis.digits)) { event.isup_in_rdnis_size = (uint16_t)strlen(caller_data->rdnis.digits)+1; } @@ -385,57 +385,57 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request) OUTBOUND_REQUESTS[r].span = span; if (sangomabc_connection_write(&sangoma_boost_data->mcon, &event) <= 0) { - zap_log(ZAP_LOG_CRIT, "Failed to tx boost event [%s]\n", strerror(errno)); - status = ZAP_FAIL; + ftdm_log(FTDM_LOG_CRIT, "Failed to tx boost event [%s]\n", strerror(errno)); + status = FTDM_FAIL; if (!sangoma_boost_data->sigmod) { - *zchan = NULL; + *ftdmchan = NULL; } goto done; } - while(zap_running() && OUTBOUND_REQUESTS[r].status == BST_WAITING) { - zap_sleep(1); + while(ftdm_running() && OUTBOUND_REQUESTS[r].status == BST_WAITING) { + ftdm_sleep(1); if (--boost_request_timeout <= 0) { - status = ZAP_FAIL; + status = FTDM_FAIL; if (!sangoma_boost_data->sigmod) { - *zchan = NULL; + *ftdmchan = NULL; } - zap_log(ZAP_LOG_CRIT, "Timed out waiting for boost channel request response, current status: BST_WAITING\n"); - zap_log(ZAP_LOG_CRIT, "s%dc%d: Csid:%d Timed out waiting for boost channel request response, current status: BST_WAITING\n", (*zchan)->physical_span_id, (*zchan)->physical_chan_id, r); + ftdm_log(FTDM_LOG_CRIT, "Timed out waiting for boost channel request response, current status: BST_WAITING\n"); + ftdm_log(FTDM_LOG_CRIT, "s%dc%d: Csid:%d Timed out waiting for boost channel request response, current status: BST_WAITING\n", (*ftdmchan)->physical_span_id, (*ftdmchan)->physical_chan_id, r); goto done; } } - if (OUTBOUND_REQUESTS[r].status == BST_ACK && OUTBOUND_REQUESTS[r].zchan) { - *zchan = OUTBOUND_REQUESTS[r].zchan; - status = ZAP_SUCCESS; - (*zchan)->init_state = ZAP_CHANNEL_STATE_PROGRESS; - zap_log(ZAP_LOG_DEBUG, "Channel state changed to PROGRESS [Csid:%d]\n", r); + if (OUTBOUND_REQUESTS[r].status == BST_ACK && OUTBOUND_REQUESTS[r].ftdmchan) { + *ftdmchan = OUTBOUND_REQUESTS[r].ftdmchan; + status = FTDM_SUCCESS; + (*ftdmchan)->init_state = FTDM_CHANNEL_STATE_PROGRESS; + ftdm_log(FTDM_LOG_DEBUG, "Channel state changed to PROGRESS [Csid:%d]\n", r); } boost_request_timeout = 5000; - while(zap_running() && OUTBOUND_REQUESTS[r].status == BST_ACK) { - zap_sleep(1); + while(ftdm_running() && OUTBOUND_REQUESTS[r].status == BST_ACK) { + ftdm_sleep(1); if (--boost_request_timeout <= 0) { - status = ZAP_FAIL; + status = FTDM_FAIL; if (!sangoma_boost_data->sigmod) { - *zchan = NULL; + *ftdmchan = NULL; } - zap_log(ZAP_LOG_CRIT, "Timed out waiting for boost channel request response, current status: BST_ACK\n"); + ftdm_log(FTDM_LOG_CRIT, "Timed out waiting for boost channel request response, current status: BST_ACK\n"); goto done; } //printf("WTF %d\n", sanity); } - if (OUTBOUND_REQUESTS[r].status == BST_READY && OUTBOUND_REQUESTS[r].zchan) { - *zchan = OUTBOUND_REQUESTS[r].zchan; - status = ZAP_SUCCESS; - (*zchan)->init_state = ZAP_CHANNEL_STATE_PROGRESS_MEDIA; - zap_log(ZAP_LOG_DEBUG, "Channel state changed to PROGRESS_MEDIA [Csid:%d]\n", r); + if (OUTBOUND_REQUESTS[r].status == BST_READY && OUTBOUND_REQUESTS[r].ftdmchan) { + *ftdmchan = OUTBOUND_REQUESTS[r].ftdmchan; + status = FTDM_SUCCESS; + (*ftdmchan)->init_state = FTDM_CHANNEL_STATE_PROGRESS_MEDIA; + ftdm_log(FTDM_LOG_DEBUG, "Channel state changed to PROGRESS_MEDIA [Csid:%d]\n", r); } else { - status = ZAP_FAIL; + status = FTDM_FAIL; if (!sangoma_boost_data->sigmod) { - *zchan = NULL; + *ftdmchan = NULL; } } @@ -451,8 +451,8 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request) nack_map[r] = 1; if (sangoma_boost_data->sigmod) { sangomabc_exec_command(&sangoma_boost_data->mcon, - BOOST_SPAN((*zchan)), - BOOST_CHAN((*zchan)), + BOOST_SPAN((*ftdmchan)), + BOOST_CHAN((*ftdmchan)), r, SIGBOOST_EVENT_CALL_START_NACK, 0); @@ -471,12 +471,12 @@ static ZIO_CHANNEL_REQUEST_FUNCTION(sangoma_boost_channel_request) /** * \brief Starts an sangoma boost channel (outgoing call) - * \param zchan Channel to initiate call on + * \param ftdmchan Channel to initiate call on * \return Success */ static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(sangoma_boost_outgoing_call) { - zap_status_t status = ZAP_SUCCESS; + ftdm_status_t status = FTDM_SUCCESS; return status; } @@ -488,7 +488,7 @@ static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(sangoma_boost_outgoing_call) */ static void handle_call_progress(sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; if (nack_map[event->call_setup_id]) { return; @@ -498,7 +498,7 @@ static void handle_call_progress(sangomabc_connection_t *mcon, sangomabc_short_e if (OUTBOUND_REQUESTS[event->call_setup_id].status == BST_ACK) { if (boost_media_ready((sangomabc_event_t*) event)) { OUTBOUND_REQUESTS[event->call_setup_id].status = BST_READY; - zap_log(ZAP_LOG_DEBUG, "chan media ready %d:%d CSid:%d\n", event->span+1, event->chan+1, event->call_setup_id); + ftdm_log(FTDM_LOG_DEBUG, "chan media ready %d:%d CSid:%d\n", event->span+1, event->chan+1, event->call_setup_id); } return; } @@ -506,16 +506,16 @@ static void handle_call_progress(sangomabc_connection_t *mcon, sangomabc_short_e OUTBOUND_REQUESTS[event->call_setup_id].event = *event; SETUP_GRID[event->span][event->chan] = event->call_setup_id; - if ((zchan = find_zchan(OUTBOUND_REQUESTS[event->call_setup_id].span, (sangomabc_short_event_t*) event, 0))) { - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "OPEN ERROR [%s]\n", zchan->last_error); + if ((ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, (sangomabc_short_event_t*) event, 0))) { + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error); } else { - zap_set_flag(zchan, ZAP_CHANNEL_OUTBOUND); - zap_set_flag_locked(zchan, ZAP_CHANNEL_INUSE); - zchan->extra_id = event->call_setup_id; - zap_log(ZAP_LOG_DEBUG, "Assign chan %d:%d (%d:%d) CSid=%d\n", zchan->span_id, zchan->chan_id, event->span+1,event->chan+1, event->call_setup_id); - zchan->sflags = 0; - OUTBOUND_REQUESTS[event->call_setup_id].zchan = zchan; + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INUSE); + ftdmchan->extra_id = event->call_setup_id; + ftdm_log(FTDM_LOG_DEBUG, "Assign chan %d:%d (%d:%d) CSid=%d\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id); + ftdmchan->sflags = 0; + OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan = ftdmchan; if (boost_media_ready((sangomabc_event_t*)event)) { OUTBOUND_REQUESTS[event->call_setup_id].status = BST_READY; } else { @@ -526,21 +526,21 @@ static void handle_call_progress(sangomabc_connection_t *mcon, sangomabc_short_e } //printf("WTF BAD ACK CSid=%d span=%d chan=%d\n", event->call_setup_id, event->span+1,event->chan+1); - if ((zchan = find_zchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 1))) { - //printf("WTF BAD ACK2 %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", zchan->span_id, zchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, zchan->extra_id, zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND), zap_channel_state2str(zchan->state)); + if ((ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 1))) { + //printf("WTF BAD ACK2 %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, ftdmchan->extra_id, ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND), ftdm_channel_state2str(ftdmchan->state)); } - zap_log(ZAP_LOG_CRIT, "START PROGRESS CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); - if (zchan) { - zap_set_sflag(zchan, SFLAG_SENT_FINAL_MSG); + ftdm_log(FTDM_LOG_CRIT, "START PROGRESS CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); + if (ftdmchan) { + ftdm_set_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG); } sangomabc_exec_command(mcon, event->span, event->chan, event->call_setup_id, SIGBOOST_EVENT_CALL_STOPPED, - ZAP_CAUSE_DESTINATION_OUT_OF_ORDER); + FTDM_CAUSE_DESTINATION_OUT_OF_ORDER); OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL; } @@ -552,7 +552,7 @@ static void handle_call_progress(sangomabc_connection_t *mcon, sangomabc_short_e static void handle_call_start_ack(sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; uint32_t event_span = event->span+1; uint32_t event_chan = event->chan+1; @@ -569,40 +569,40 @@ static void handle_call_start_ack(sangomabc_connection_t *mcon, sangomabc_short_ SETUP_GRID[event->span][event->chan] = event->call_setup_id; if (mcon->sigmod) { - zchan = OUTBOUND_REQUESTS[event->call_setup_id].zchan; - zap_set_flag(zchan, ZAP_CHANNEL_OUTBOUND); - zap_set_flag_locked(zchan, ZAP_CHANNEL_INUSE); + ftdmchan = OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan; + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INUSE); } else { - zchan = find_zchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 0); + ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 0); } - if (zchan) { - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "OPEN ERROR [%s]\n", zchan->last_error); + if (ftdmchan) { + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error); } else { - zchan->extra_id = event->call_setup_id; - zap_log(ZAP_LOG_DEBUG, "Assign chan %d:%d (%d:%d) CSid=%d\n", zchan->span_id, zchan->chan_id, event_span, event_chan, event->call_setup_id); - zchan->sflags = 0; - OUTBOUND_REQUESTS[event->call_setup_id].zchan = zchan; + ftdmchan->extra_id = event->call_setup_id; + ftdm_log(FTDM_LOG_DEBUG, "Assign chan %d:%d (%d:%d) CSid=%d\n", ftdmchan->span_id, ftdmchan->chan_id, event_span, event_chan, event->call_setup_id); + ftdmchan->sflags = 0; + OUTBOUND_REQUESTS[event->call_setup_id].ftdmchan = ftdmchan; OUTBOUND_REQUESTS[event->call_setup_id].status = BST_READY; return; } } //printf("WTF BAD ACK CSid=%d span=%d chan=%d\n", event->call_setup_id, event->span+1,event->chan+1); - if ((zchan = find_zchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 1))) { - //printf("WTF BAD ACK2 %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", zchan->span_id, zchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, zchan->extra_id, zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND), zap_channel_state2str(zchan->state)); + if ((ftdmchan = find_ftdmchan(OUTBOUND_REQUESTS[event->call_setup_id].span, event, 1))) { + //printf("WTF BAD ACK2 %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, ftdmchan->extra_id, ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND), ftdm_channel_state2str(ftdmchan->state)); } - zap_set_sflag(zchan, SFLAG_SENT_FINAL_MSG); - zap_log(ZAP_LOG_CRIT, "START ACK CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); + ftdm_set_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG); + ftdm_log(FTDM_LOG_CRIT, "START ACK CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); sangomabc_exec_command(mcon, event->span, event->chan, event->call_setup_id, SIGBOOST_EVENT_CALL_STOPPED, - ZAP_CAUSE_DESTINATION_OUT_OF_ORDER); + FTDM_CAUSE_DESTINATION_OUT_OF_ORDER); OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL; } @@ -612,42 +612,42 @@ static void handle_call_start_ack(sangomabc_connection_t *mcon, sangomabc_short_ * \param mcon sangoma boost connection * \param event Event to handle */ -static void handle_call_done(zap_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) +static void handle_call_done(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; int r = 0; - if ((zchan = find_zchan(span, event, 1))) { - zap_sangoma_boost_data_t *sangoma_boost_data = zchan->span->signal_data; - zap_mutex_lock(zchan->mutex); + if ((ftdmchan = find_ftdmchan(span, event, 1))) { + ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data; + ftdm_mutex_lock(ftdmchan->mutex); if (sangoma_boost_data->sigmod) { /* not really completely done, but if we ever get an incoming call before moving to HANGUP_COMPLETE * handle_incoming_call() will take care of moving the state machine to release the channel */ sangomabc_exec_command(&sangoma_boost_data->mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_RELEASED, 0); } - if (zchan->state == ZAP_CHANNEL_STATE_DOWN || zchan->state == ZAP_CHANNEL_STATE_HANGUP_COMPLETE) { + if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN || ftdmchan->state == FTDM_CHANNEL_STATE_HANGUP_COMPLETE) { goto done; } - zap_set_state_r(zchan, ZAP_CHANNEL_STATE_HANGUP_COMPLETE, 0, r); + ftdm_set_state_r(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE, 0, r); if (r) { - zap_set_sflag(zchan, SFLAG_FREE_REQ_ID); - zap_mutex_unlock(zchan->mutex); + ftdm_set_sflag(ftdmchan, SFLAG_FREE_REQ_ID); + ftdm_mutex_unlock(ftdmchan->mutex); return; } } done: - if (zchan) { - zap_mutex_unlock(zchan->mutex); + if (ftdmchan) { + ftdm_mutex_unlock(ftdmchan->mutex); } if (event->call_setup_id) { @@ -663,17 +663,17 @@ static void handle_call_done(zap_span_t *span, sangomabc_connection_t *mcon, san * \param mcon sangoma boost connection * \param event Event to handle */ -static void handle_call_start_nack(zap_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) +static void handle_call_start_nack(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_channel_t *zchan; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_channel_t *ftdmchan; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; if (event->release_cause == SIGBOOST_CALL_SETUP_NACK_ALL_CKTS_BUSY) { uint32_t count = 0; int delay = 0; int tg=event->trunk_group; - zap_span_channel_use_count(span, &count); + ftdm_span_channel_use_count(span, &count); delay = (int) (count / 100) * 2; @@ -684,7 +684,7 @@ static void handle_call_start_nack(zap_span_t *span, sangomabc_connection_t *mco } if (tg < 0 || tg >= MAX_TRUNK_GROUPS) { - zap_log(ZAP_LOG_CRIT, "Invalid All Ckt Busy trunk group number %i\n", tg); + ftdm_log(FTDM_LOG_CRIT, "Invalid All Ckt Busy trunk group number %i\n", tg); tg=0; } @@ -695,7 +695,7 @@ static void handle_call_start_nack(zap_span_t *span, sangomabc_connection_t *mco event->release_cause = 17; } - zap_log(ZAP_LOG_DEBUG, "setting event->call_setup_id:%d to BST_FAIL\n", event->call_setup_id); + ftdm_log(FTDM_LOG_DEBUG, "setting event->call_setup_id:%d to BST_FAIL\n", event->call_setup_id); OUTBOUND_REQUESTS[event->call_setup_id].event = *event; OUTBOUND_REQUESTS[event->call_setup_id].status = BST_FAIL; if (!sangoma_boost_data->sigmod) { @@ -708,18 +708,18 @@ static void handle_call_start_nack(zap_span_t *span, sangomabc_connection_t *mco return; } else { - if ((zchan = find_zchan(span, event, 1))) { + if ((ftdmchan = find_ftdmchan(span, event, 1))) { int r = 0; - assert(!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)); + assert(!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)); - zchan->call_data = (void*)(intptr_t)event->event_id; + ftdmchan->call_data = (void*)(intptr_t)event->event_id; - zap_mutex_lock(zchan->mutex); - zap_set_state_r(zchan, ZAP_CHANNEL_STATE_TERMINATING, 0, r); - if (r == ZAP_STATE_CHANGE_SUCCESS) { - zchan->caller_data.hangup_cause = event->release_cause; + ftdm_mutex_lock(ftdmchan->mutex); + ftdm_set_state_r(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING, 0, r); + if (r == FTDM_STATE_CHANGE_SUCCESS) { + ftdmchan->caller_data.hangup_cause = event->release_cause; } - zap_mutex_unlock(zchan->mutex); + ftdm_mutex_unlock(ftdmchan->mutex); if (r) { return; } @@ -727,8 +727,8 @@ static void handle_call_start_nack(zap_span_t *span, sangomabc_connection_t *mco } #if 0 - if (zchan) { - zap_set_sflag_locked(zchan, SFLAG_SENT_FINAL_MSG); + if (ftdmchan) { + ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG); } /* nobody else will do it so we have to do it ourselves */ @@ -741,15 +741,15 @@ static void handle_call_start_nack(zap_span_t *span, sangomabc_connection_t *mco #endif } -static void handle_call_released(zap_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) +static void handle_call_released(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; - if ((zchan = find_zchan(span, event, 1))) { - zap_log(ZAP_LOG_DEBUG, "Releasing completely chan s%dc%d\n", event->span, event->chan); - zap_channel_done(zchan); + if ((ftdmchan = find_ftdmchan(span, event, 1))) { + ftdm_log(FTDM_LOG_DEBUG, "Releasing completely chan s%dc%d\n", event->span, event->chan); + ftdm_channel_done(ftdmchan); } else { - zap_log(ZAP_LOG_ERROR, "Odd, We could not find chan: s%dc%d to release the call completely!!\n", event->span, event->chan); + ftdm_log(FTDM_LOG_ERROR, "Odd, We could not find chan: s%dc%d to release the call completely!!\n", event->span, event->chan); } } @@ -759,46 +759,46 @@ static void handle_call_released(zap_span_t *span, sangomabc_connection_t *mcon, * \param mcon sangoma boost connection * \param event Event to handle */ -static void handle_call_stop(zap_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) +static void handle_call_stop(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; - if ((zchan = find_zchan(span, event, 1))) { + if ((ftdmchan = find_ftdmchan(span, event, 1))) { int r = 0; - zap_mutex_lock(zchan->mutex); + ftdm_mutex_lock(ftdmchan->mutex); - if (zchan->state == ZAP_CHANNEL_STATE_HANGUP) { + if (ftdmchan->state == FTDM_CHANNEL_STATE_HANGUP) { /* racing condition where both sides initiated a hangup * Do not change current state as channel is already clearing * itself through local initiated hangup */ sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_STOPPED_ACK, 0); - zap_mutex_unlock(zchan->mutex); + ftdm_mutex_unlock(ftdmchan->mutex); return; } else { - zap_set_state_r(zchan, ZAP_CHANNEL_STATE_TERMINATING, 0, r); + ftdm_set_state_r(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING, 0, r); } - if (r == ZAP_STATE_CHANGE_SUCCESS) { - zchan->caller_data.hangup_cause = event->release_cause; + if (r == FTDM_STATE_CHANGE_SUCCESS) { + ftdmchan->caller_data.hangup_cause = event->release_cause; } if (r) { - zap_set_sflag(zchan, SFLAG_FREE_REQ_ID); + ftdm_set_sflag(ftdmchan, SFLAG_FREE_REQ_ID); } - zap_mutex_unlock(zchan->mutex); + ftdm_mutex_unlock(ftdmchan->mutex); if (r) { return; } } else { /* we have to do it ourselves.... */ - zap_log(ZAP_LOG_ERROR, "Odd, We could not find chan: s%dc%d\n", event->span, event->chan); + ftdm_log(FTDM_LOG_ERROR, "Odd, We could not find chan: s%dc%d\n", event->span, event->chan); release_request_id_span_chan(event->span, event->chan); } } @@ -809,34 +809,34 @@ static void handle_call_stop(zap_span_t *span, sangomabc_connection_t *mcon, san * \param mcon sangoma boost connection * \param event Event to handle */ -static void handle_call_answer(zap_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) +static void handle_call_answer(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; - if ((zchan = find_zchan(span, event, 1))) { + if ((ftdmchan = find_ftdmchan(span, event, 1))) { int r = 0; - if (zchan->extra_id == event->call_setup_id && zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - zap_mutex_lock(zchan->mutex); - if (zchan->state == ZAP_CHANNEL_STATE_DOWN && zchan->init_state != ZAP_CHANNEL_STATE_UP) { - zchan->init_state = ZAP_CHANNEL_STATE_UP; + if (ftdmchan->extra_id == event->call_setup_id && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_mutex_lock(ftdmchan->mutex); + if (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN && ftdmchan->init_state != FTDM_CHANNEL_STATE_UP) { + ftdmchan->init_state = FTDM_CHANNEL_STATE_UP; r = 1; } else { - zap_set_state_r(zchan, ZAP_CHANNEL_STATE_UP, 0, r); + ftdm_set_state_r(ftdmchan, FTDM_CHANNEL_STATE_UP, 0, r); } - zap_mutex_unlock(zchan->mutex); + ftdm_mutex_unlock(ftdmchan->mutex); } #if 0 if (!r) { - printf("WTF BAD ANSWER %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", zchan->span_id, zchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, zchan->extra_id, zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND), zap_channel_state2str(zchan->state)); + printf("WTF BAD ANSWER %d:%d (%d:%d) CSid=%d xtra_id=%d out=%d state=%s\n", ftdmchan->span_id, ftdmchan->chan_id, event->span+1,event->chan+1, event->call_setup_id, ftdmchan->extra_id, ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND), ftdm_channel_state2str(ftdmchan->state)); } #endif } else { - zap_log(ZAP_LOG_CRIT, "ANSWER CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); + ftdm_log(FTDM_LOG_CRIT, "ANSWER CANT FIND A CHAN %d:%d\n", event->span+1,event->chan+1); } } -static __inline__ void advance_chan_states(zap_channel_t *zchan); +static __inline__ void advance_chan_states(ftdm_channel_t *ftdmchan); /** * \brief Handler for call start event @@ -844,66 +844,66 @@ static __inline__ void advance_chan_states(zap_channel_t *zchan); * \param mcon sangoma boost connection * \param event Event to handle */ -static void handle_call_start(zap_span_t *span, sangomabc_connection_t *mcon, sangomabc_event_t *event) +static void handle_call_start(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_event_t *event) { - zap_channel_t *zchan; + ftdm_channel_t *ftdmchan; - if (!(zchan = find_zchan(span, (sangomabc_short_event_t*)event, 0))) { - if (!(zchan = find_zchan(span, (sangomabc_short_event_t*)event, 1))) { - zap_log(ZAP_LOG_CRIT, "START CANT FIND CHAN %d:%d AT ALL\n", event->span+1,event->chan+1); + if (!(ftdmchan = find_ftdmchan(span, (sangomabc_short_event_t*)event, 0))) { + if (!(ftdmchan = find_ftdmchan(span, (sangomabc_short_event_t*)event, 1))) { + ftdm_log(FTDM_LOG_CRIT, "START CANT FIND CHAN %d:%d AT ALL\n", event->span+1,event->chan+1); goto error; } /* this handles race conditions where state handlers are still pending to be executed for finished calls but an incoming call arrives first, we must complete the channel states and then try again to get the - zap channel */ - advance_chan_states(zchan); - if (!(zchan = find_zchan(span, (sangomabc_short_event_t*)event, 0))) { - zap_log(ZAP_LOG_CRIT, "START CANT FIND CHAN %d:%d EVEN AFTER STATE ADVANCE\n", event->span+1,event->chan+1); + ftdm channel */ + advance_chan_states(ftdmchan); + if (!(ftdmchan = find_ftdmchan(span, (sangomabc_short_event_t*)event, 0))) { + ftdm_log(FTDM_LOG_CRIT, "START CANT FIND CHAN %d:%d EVEN AFTER STATE ADVANCE\n", event->span+1,event->chan+1); goto error; } } - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_CRIT, "START CANT OPEN CHAN %d:%d\n", event->span+1,event->chan+1); + if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_CRIT, "START CANT OPEN CHAN %d:%d\n", event->span+1,event->chan+1); goto error; } - zap_log(ZAP_LOG_DEBUG, "Got call start from s%dc%d mapped to openzap logical s%dc%d, physical s%dc%d\n", + ftdm_log(FTDM_LOG_DEBUG, "Got call start from s%dc%d mapped to freetdm logical s%dc%d, physical s%dc%d\n", event->span, event->chan, - zchan->span_id, zchan->chan_id, - zchan->physical_span_id, zchan->physical_chan_id); + ftdmchan->span_id, ftdmchan->chan_id, + ftdmchan->physical_span_id, ftdmchan->physical_chan_id); - zchan->sflags = 0; - zap_set_string(zchan->caller_data.cid_num.digits, (char *)event->calling_number_digits); - zap_set_string(zchan->caller_data.cid_name, (char *)event->calling_number_digits); + ftdmchan->sflags = 0; + ftdm_set_string(ftdmchan->caller_data.cid_num.digits, (char *)event->calling_number_digits); + ftdm_set_string(ftdmchan->caller_data.cid_name, (char *)event->calling_number_digits); if (strlen(event->calling_name)) { - zap_set_string(zchan->caller_data.cid_name, (char *)event->calling_name); + ftdm_set_string(ftdmchan->caller_data.cid_name, (char *)event->calling_name); } - zap_set_string(zchan->caller_data.ani.digits, (char *)event->calling_number_digits); - zap_set_string(zchan->caller_data.dnis.digits, (char *)event->called_number_digits); + ftdm_set_string(ftdmchan->caller_data.ani.digits, (char *)event->calling_number_digits); + ftdm_set_string(ftdmchan->caller_data.dnis.digits, (char *)event->called_number_digits); if (event->isup_in_rdnis_size) { char* p; //Set value of rdnis.digis in case prot daemon is still using older style RDNIS if (atoi((char *)event->isup_in_rdnis) > 0) { - zap_set_string(zchan->caller_data.rdnis.digits, (char *)event->isup_in_rdnis); + ftdm_set_string(ftdmchan->caller_data.rdnis.digits, (char *)event->isup_in_rdnis); } p = strstr((char*)event->isup_in_rdnis,"PRI001-ANI2-"); if (p!=NULL) { int ani2 = 0; sscanf(p, "PRI001-ANI2-%d", &ani2); - snprintf(zchan->caller_data.aniII, 5, "%.2d", ani2); + snprintf(ftdmchan->caller_data.aniII, 5, "%.2d", ani2); } p = strstr((char*)event->isup_in_rdnis,"RDNIS-"); if (p!=NULL) { - sscanf(p, "RDNIS-%s", &zchan->caller_data.rdnis.digits[0]); + sscanf(p, "RDNIS-%s", &ftdmchan->caller_data.rdnis.digits[0]); } } - zchan->caller_data.screen = event->calling_number_screening_ind; - zchan->caller_data.pres = event->calling_number_presentation; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_RING); + ftdmchan->caller_data.screen = event->calling_number_screening_ind; + ftdmchan->caller_data.pres = event->calling_number_presentation; + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING); return; error: @@ -928,7 +928,7 @@ static void handle_heartbeat(sangomabc_connection_t *mcon, sangomabc_short_event err = sangomabc_connection_writep(mcon, (sangomabc_event_t*)event); if (err <= 0) { - zap_log(ZAP_LOG_CRIT, "Failed to tx on ISUP socket [%s]: %s\n", strerror(errno)); + ftdm_log(FTDM_LOG_CRIT, "Failed to tx on ISUP socket [%s]: %s\n", strerror(errno)); } mcon->hb_elapsed = 0; @@ -942,9 +942,9 @@ static void handle_heartbeat(sangomabc_connection_t *mcon, sangomabc_short_event * \param span Span where event was fired * \param event Event to handle */ -static void handle_restart_ack(sangomabc_connection_t *mcon, zap_span_t *span, sangomabc_short_event_t *event) +static void handle_restart_ack(sangomabc_connection_t *mcon, ftdm_span_t *span, sangomabc_short_event_t *event) { - zap_log(ZAP_LOG_DEBUG, "RECV RESTART ACK\n"); + ftdm_log(FTDM_LOG_DEBUG, "RECV RESTART ACK\n"); } /** @@ -953,14 +953,14 @@ static void handle_restart_ack(sangomabc_connection_t *mcon, zap_span_t *span, s * \param span Span where event was fired * \param event Event to handle */ -static void handle_restart(sangomabc_connection_t *mcon, zap_span_t *span, sangomabc_short_event_t *event) +static void handle_restart(sangomabc_connection_t *mcon, ftdm_span_t *span, sangomabc_short_event_t *event) { - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; mcon->rxseq_reset = 0; - zap_set_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN); - zap_set_flag_locked(span, ZAP_SPAN_SUSPENDED); - zap_set_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RESTARTING); + ftdm_set_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN); + ftdm_set_flag_locked(span, FTDM_SPAN_SUSPENDED); + ftdm_set_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RESTARTING); mcon->hb_elapsed = 0; } @@ -971,31 +971,31 @@ static void handle_restart(sangomabc_connection_t *mcon, zap_span_t *span, sango * \param span Span where event was fired * \param event Event to handle */ -static void handle_incoming_digit(sangomabc_connection_t *mcon, zap_span_t *span, sangomabc_event_t *event) +static void handle_incoming_digit(sangomabc_connection_t *mcon, ftdm_span_t *span, sangomabc_event_t *event) { - zap_channel_t *zchan = NULL; + ftdm_channel_t *ftdmchan = NULL; char digits[MAX_DIALED_DIGITS + 2] = ""; - if (!(zchan = find_zchan(span, (sangomabc_short_event_t *)event, 1))) { - zap_log(ZAP_LOG_ERROR, "Invalid channel\n"); + if (!(ftdmchan = find_ftdmchan(span, (sangomabc_short_event_t *)event, 1))) { + ftdm_log(FTDM_LOG_ERROR, "Invalid channel\n"); return; } if (event->called_number_digits_count == 0) { - zap_log(ZAP_LOG_WARNING, "Error Incoming digit with len %s %d [w%dg%d]\n", + ftdm_log(FTDM_LOG_WARNING, "Error Incoming digit with len %s %d [w%dg%d]\n", event->called_number_digits, event->called_number_digits_count, event->span+1, event->chan+1); return; } - zap_log(ZAP_LOG_WARNING, "Incoming digit with len %s %d [w%dg%d]\n", + ftdm_log(FTDM_LOG_WARNING, "Incoming digit with len %s %d [w%dg%d]\n", event->called_number_digits, event->called_number_digits_count, event->span+1, event->chan+1); memcpy(digits, event->called_number_digits, event->called_number_digits_count); - zap_channel_queue_dtmf(zchan, digits); + ftdm_channel_queue_dtmf(ftdmchan, digits); return; } @@ -1006,12 +1006,12 @@ static void handle_incoming_digit(sangomabc_connection_t *mcon, zap_span_t *span * \param mcon sangoma boost connection * \param event Event to handle */ -static int parse_sangoma_event(zap_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) +static int parse_sangoma_event(ftdm_span_t *span, sangomabc_connection_t *mcon, sangomabc_short_event_t *event) { - zap_mutex_lock(signal_mutex); + ftdm_mutex_lock(signal_mutex); - if (!zap_running()) { - zap_log(ZAP_LOG_WARNING, "System is shutting down.\n"); + if (!ftdm_running()) { + ftdm_log(FTDM_LOG_WARNING, "System is shutting down.\n"); goto end; } @@ -1067,56 +1067,56 @@ static int parse_sangoma_event(zap_span_t *span, sangomabc_connection_t *mcon, s handle_incoming_digit(mcon, span, (sangomabc_event_t*)event); break; default: - zap_log(ZAP_LOG_WARNING, "No handler implemented for [%s]\n", sangomabc_event_id_name(event->event_id)); + ftdm_log(FTDM_LOG_WARNING, "No handler implemented for [%s]\n", sangomabc_event_id_name(event->event_id)); break; } end: - zap_mutex_unlock(signal_mutex); + ftdm_mutex_unlock(signal_mutex); return 0; } /** * \brief Handler for channel state change - * \param zchan Channel to handle + * \param ftdmchan Channel to handle */ -static __inline__ void state_advance(zap_channel_t *zchan) +static __inline__ void state_advance(ftdm_channel_t *ftdmchan) { - zap_sangoma_boost_data_t *sangoma_boost_data = zchan->span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data; sangomabc_connection_t *mcon = &sangoma_boost_data->mcon; - zap_sigmsg_t sig; - zap_status_t status; + ftdm_sigmsg_t sig; + ftdm_status_t status; - zap_log(ZAP_LOG_DEBUG, "%d:%d STATE [%s]\n", zchan->span_id, zchan->chan_id, zap_channel_state2str(zchan->state)); + ftdm_log(FTDM_LOG_DEBUG, "%d:%d STATE [%s]\n", ftdmchan->span_id, ftdmchan->chan_id, ftdm_channel_state2str(ftdmchan->state)); memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; - switch (zchan->state) { - case ZAP_CHANNEL_STATE_DOWN: + switch (ftdmchan->state) { + case FTDM_CHANNEL_STATE_DOWN: { int call_stopped_ack_sent = 0; - zap_sangoma_boost_data_t *sangoma_boost_data = zchan->span->signal_data; - if (zchan->extra_id) { - zchan->extra_id = 0; + ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data; + if (ftdmchan->extra_id) { + ftdmchan->extra_id = 0; } - if (zap_test_sflag(zchan, SFLAG_FREE_REQ_ID)) { - release_request_id_span_chan(zchan->physical_span_id-1, zchan->physical_chan_id-1); + if (ftdm_test_sflag(ftdmchan, SFLAG_FREE_REQ_ID)) { + release_request_id_span_chan(ftdmchan->physical_span_id-1, ftdmchan->physical_chan_id-1); } - if (!zap_test_sflag(zchan, SFLAG_SENT_FINAL_MSG)) { - zap_set_sflag_locked(zchan, SFLAG_SENT_FINAL_MSG); + if (!ftdm_test_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG)) { + ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG); - if (zchan->call_data && ((uint32_t)(intptr_t)zchan->call_data == SIGBOOST_EVENT_CALL_START_NACK)) { + if (ftdmchan->call_data && ((uint32_t)(intptr_t)ftdmchan->call_data == SIGBOOST_EVENT_CALL_START_NACK)) { sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_START_NACK_ACK, 0); @@ -1124,39 +1124,39 @@ static __inline__ void state_advance(zap_channel_t *zchan) } else { /* we got a call stop msg, time to reply with call stopped ack */ sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_STOPPED_ACK, 0); call_stopped_ack_sent = 1; } } - zchan->sflags = 0; - zchan->call_data = NULL; + ftdmchan->sflags = 0; + ftdmchan->call_data = NULL; if (sangoma_boost_data->sigmod && call_stopped_ack_sent) { - /* we dont want to call zap_channel_done just yet until call released is received */ - zap_log(ZAP_LOG_DEBUG, "Waiting for call release confirmation before declaring chan %d:%d as available \n", - zchan->span_id, zchan->chan_id); + /* we dont want to call ftdm_channel_done just yet until call released is received */ + ftdm_log(FTDM_LOG_DEBUG, "Waiting for call release confirmation before declaring chan %d:%d as available \n", + ftdmchan->span_id, ftdmchan->chan_id); } else { - zap_channel_done(zchan); + ftdm_channel_done(ftdmchan); } } break; - case ZAP_CHANNEL_STATE_PROGRESS_MEDIA: - case ZAP_CHANNEL_STATE_PROGRESS: + case FTDM_CHANNEL_STATE_PROGRESS_MEDIA: + case FTDM_CHANNEL_STATE_PROGRESS: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_PROGRESS_MEDIA; - if ((status = sangoma_boost_data->signal_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_PROGRESS_MEDIA; + if ((status = sangoma_boost_data->signal_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { - if (!zap_test_sflag(zchan, SFLAG_SENT_ACK)) { - zap_set_sflag(zchan, SFLAG_SENT_ACK); + if (!ftdm_test_sflag(ftdmchan, SFLAG_SENT_ACK)) { + ftdm_set_sflag(ftdmchan, SFLAG_SENT_ACK); sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_START_ACK, 0); @@ -1164,88 +1164,88 @@ static __inline__ void state_advance(zap_channel_t *zchan) } } break; - case ZAP_CHANNEL_STATE_RING: + case FTDM_CHANNEL_STATE_RING: { - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_START; - if ((status = sangoma_boost_data->signal_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_START; + if ((status = sangoma_boost_data->signal_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } } break; - case ZAP_CHANNEL_STATE_RESTART: + case FTDM_CHANNEL_STATE_RESTART: { - sig.event_id = ZAP_SIGEVENT_RESTART; + sig.event_id = FTDM_SIGEVENT_RESTART; status = sangoma_boost_data->signal_cb(&sig); - zap_set_sflag_locked(zchan, SFLAG_SENT_FINAL_MSG); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; - case ZAP_CHANNEL_STATE_UP: + case FTDM_CHANNEL_STATE_UP: { - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - sig.event_id = ZAP_SIGEVENT_UP; - if ((status = sangoma_boost_data->signal_cb(&sig) != ZAP_SUCCESS)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + sig.event_id = FTDM_SIGEVENT_UP; + if ((status = sangoma_boost_data->signal_cb(&sig) != FTDM_SUCCESS)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } } else { - if (!(zap_test_flag(zchan, ZAP_CHANNEL_PROGRESS) || zap_test_flag(zchan, ZAP_CHANNEL_MEDIA))) { + if (!(ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_MEDIA))) { sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_START_ACK, 0); } sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_ANSWERED, 0); } } break; - case ZAP_CHANNEL_STATE_DIALING: + case FTDM_CHANNEL_STATE_DIALING: { } break; - case ZAP_CHANNEL_STATE_HANGUP_COMPLETE: + case FTDM_CHANNEL_STATE_HANGUP_COMPLETE: { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN); } break; - case ZAP_CHANNEL_STATE_HANGUP: + case FTDM_CHANNEL_STATE_HANGUP: { - if (zchan->last_state == ZAP_CHANNEL_STATE_TERMINATING || - zap_test_sflag(zchan, SFLAG_SENT_FINAL_MSG)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP_COMPLETE); + if (ftdmchan->last_state == FTDM_CHANNEL_STATE_TERMINATING || + ftdm_test_sflag(ftdmchan, SFLAG_SENT_FINAL_MSG)) { + ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP_COMPLETE); } else { - zap_set_sflag_locked(zchan, SFLAG_SENT_FINAL_MSG); - if (zap_test_flag(zchan, ZAP_CHANNEL_ANSWERED) || zap_test_flag(zchan, ZAP_CHANNEL_PROGRESS) || zap_test_flag(zchan, ZAP_CHANNEL_MEDIA)) { + ftdm_set_sflag_locked(ftdmchan, SFLAG_SENT_FINAL_MSG); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_ANSWERED) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_PROGRESS) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_MEDIA)) { sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_STOPPED, - zchan->caller_data.hangup_cause); + ftdmchan->caller_data.hangup_cause); } else { sangomabc_exec_command(mcon, - BOOST_SPAN(zchan), - BOOST_CHAN(zchan), + BOOST_SPAN(ftdmchan), + BOOST_CHAN(ftdmchan), 0, SIGBOOST_EVENT_CALL_START_NACK, - zchan->caller_data.hangup_cause); + ftdmchan->caller_data.hangup_cause); } } } break; - case ZAP_CHANNEL_STATE_TERMINATING: + case FTDM_CHANNEL_STATE_TERMINATING: { - sig.event_id = ZAP_SIGEVENT_STOP; + sig.event_id = FTDM_SIGEVENT_STOP; status = sangoma_boost_data->signal_cb(&sig); } break; @@ -1254,15 +1254,15 @@ static __inline__ void state_advance(zap_channel_t *zchan) } } -static __inline__ void advance_chan_states(zap_channel_t *zchan) +static __inline__ void advance_chan_states(ftdm_channel_t *ftdmchan) { - zap_mutex_lock(zchan->mutex); - while (zap_test_flag(zchan, ZAP_CHANNEL_STATE_CHANGE)) { - zap_clear_flag(zchan, ZAP_CHANNEL_STATE_CHANGE); - state_advance(zchan); - zap_channel_complete_state(zchan); + ftdm_mutex_lock(ftdmchan->mutex); + while (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) { + ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE); + state_advance(ftdmchan); + ftdm_channel_complete_state(ftdmchan); } - zap_mutex_unlock(zchan->mutex); + ftdm_mutex_unlock(ftdmchan->mutex); } /** @@ -1278,43 +1278,43 @@ static __inline__ void init_outgoing_array(void) * \brief Checks current state on a span * \param span Span to check status on */ -static __inline__ void check_state(zap_span_t *span) +static __inline__ void check_state(ftdm_span_t *span) { - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; - int susp = zap_test_flag(span, ZAP_SPAN_SUSPENDED); + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + int susp = ftdm_test_flag(span, FTDM_SPAN_SUSPENDED); - if (susp && zap_check_state_all(span, ZAP_CHANNEL_STATE_DOWN)) { + if (susp && ftdm_check_state_all(span, FTDM_CHANNEL_STATE_DOWN)) { susp = 0; } - if (zap_test_flag(span, ZAP_SPAN_STATE_CHANGE) || susp) { + if (ftdm_test_flag(span, FTDM_SPAN_STATE_CHANGE) || susp) { uint32_t j; - zap_clear_flag_locked(span, ZAP_SPAN_STATE_CHANGE); + ftdm_clear_flag_locked(span, FTDM_SPAN_STATE_CHANGE); for(j = 1; j <= span->chan_count; j++) { - if (zap_test_flag((span->channels[j]), ZAP_CHANNEL_STATE_CHANGE) || susp) { - zap_mutex_lock(span->channels[j]->mutex); - zap_clear_flag((span->channels[j]), ZAP_CHANNEL_STATE_CHANGE); - if (susp && span->channels[j]->state != ZAP_CHANNEL_STATE_DOWN) { - zap_channel_set_state(span->channels[j], ZAP_CHANNEL_STATE_RESTART, 0); + if (ftdm_test_flag((span->channels[j]), FTDM_CHANNEL_STATE_CHANGE) || susp) { + ftdm_mutex_lock(span->channels[j]->mutex); + ftdm_clear_flag((span->channels[j]), FTDM_CHANNEL_STATE_CHANGE); + if (susp && span->channels[j]->state != FTDM_CHANNEL_STATE_DOWN) { + ftdm_channel_set_state(span->channels[j], FTDM_CHANNEL_STATE_RESTART, 0); } state_advance(span->channels[j]); - zap_channel_complete_state(span->channels[j]); - zap_mutex_unlock(span->channels[j]->mutex); + ftdm_channel_complete_state(span->channels[j]); + ftdm_mutex_unlock(span->channels[j]->mutex); } } } - if (zap_test_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RESTARTING)) { - if (zap_check_state_all(span, ZAP_CHANNEL_STATE_DOWN)) { + if (ftdm_test_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RESTARTING)) { + if (ftdm_check_state_all(span, FTDM_CHANNEL_STATE_DOWN)) { sangomabc_exec_command(&sangoma_boost_data->mcon, 0, 0, -1, SIGBOOST_EVENT_SYSTEM_RESTART_ACK, 0); - zap_clear_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RESTARTING); - zap_clear_flag_locked(span, ZAP_SPAN_SUSPENDED); - zap_clear_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN); + ftdm_clear_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RESTARTING); + ftdm_clear_flag_locked(span, FTDM_SPAN_SUSPENDED); + ftdm_clear_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN); sangoma_boost_data->mcon.hb_elapsed = 0; init_outgoing_array(); } @@ -1326,38 +1326,38 @@ static __inline__ void check_state(zap_span_t *span) * \brief Checks for events on a span * \param span Span to check for events */ -static __inline__ zap_status_t check_events(zap_span_t *span, int ms_timeout) +static __inline__ ftdm_status_t check_events(ftdm_span_t *span, int ms_timeout) { - zap_status_t status; - zap_sigmsg_t sigmsg; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_status_t status; + ftdm_sigmsg_t sigmsg; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; memset(&sigmsg, 0, sizeof(sigmsg)); - status = zap_span_poll_event(span, ms_timeout); + status = ftdm_span_poll_event(span, ms_timeout); switch(status) { - case ZAP_SUCCESS: + case FTDM_SUCCESS: { - zap_event_t *event; - while (zap_span_next_event(span, &event) == ZAP_SUCCESS) { + ftdm_event_t *event; + while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) { sigmsg.span_id = event->channel->span_id; sigmsg.chan_id = event->channel->chan_id; sigmsg.channel = event->channel; switch (event->enum_id) { - case ZAP_OOB_ALARM_TRAP: - sigmsg.event_id = ZAP_SIGEVENT_HWSTATUS_CHANGED; - sigmsg.raw_data = (void *)ZAP_HW_LINK_DISCONNECTED; + case FTDM_OOB_ALARM_TRAP: + sigmsg.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED; + sigmsg.raw_data = (void *)FTDM_HW_LINK_DISCONNECTED; if (sangoma_boost_data->sigmod) { - sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, ZAP_HW_LINK_DISCONNECTED); + sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, FTDM_HW_LINK_DISCONNECTED); } sangoma_boost_data->signal_cb(&sigmsg); break; - case ZAP_OOB_ALARM_CLEAR: - sigmsg.event_id = ZAP_SIGEVENT_HWSTATUS_CHANGED; - sigmsg.raw_data = (void *)ZAP_HW_LINK_CONNECTED; + case FTDM_OOB_ALARM_CLEAR: + sigmsg.event_id = FTDM_SIGEVENT_HWSTATUS_CHANGED; + sigmsg.raw_data = (void *)FTDM_HW_LINK_CONNECTED; if (sangoma_boost_data->sigmod) { - sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, ZAP_HW_LINK_CONNECTED); + sangoma_boost_data->sigmod->on_hw_link_status_change(event->channel, FTDM_HW_LINK_CONNECTED); } sangoma_boost_data->signal_cb(&sigmsg); break; @@ -1365,20 +1365,20 @@ static __inline__ zap_status_t check_events(zap_span_t *span, int ms_timeout) } } break; - case ZAP_FAIL: + case FTDM_FAIL: { - if (!zap_running()) { + if (!ftdm_running()) { break; } - zap_log(ZAP_LOG_ERROR, "Boost Check Event Failure Failure: %s\n", span->last_error); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Boost Check Event Failure Failure: %s\n", span->last_error); + return FTDM_FAIL; } break; default: break; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** @@ -1386,16 +1386,16 @@ static __inline__ zap_status_t check_events(zap_span_t *span, int ms_timeout) * \param me Current thread * \param obj Span to run in this thread */ -static void *zap_sangoma_events_run(zap_thread_t *me, void *obj) +static void *ftdm_sangoma_events_run(ftdm_thread_t *me, void *obj) { - zap_span_t *span = (zap_span_t *) obj; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_span_t *span = (ftdm_span_t *) obj; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; unsigned errs = 0; - while (zap_test_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING) && zap_running()) { - if (check_events(span,100) != ZAP_SUCCESS) { + while (ftdm_test_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING) && ftdm_running()) { + if (check_events(span,100) != FTDM_SUCCESS) { if (errs++ > 50) { - zap_log(ZAP_LOG_ERROR, "Too many event errors, quitting sangoma events thread\n"); + ftdm_log(FTDM_LOG_ERROR, "Too many event errors, quitting sangoma events thread\n"); return NULL; } } @@ -1404,16 +1404,16 @@ static void *zap_sangoma_events_run(zap_thread_t *me, void *obj) return NULL; } -static zap_status_t zap_boost_connection_open(zap_span_t *span) +static ftdm_status_t ftdm_boost_connection_open(ftdm_span_t *span) { - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; if (sangoma_boost_data->sigmod) { - if (sangoma_boost_data->sigmod->start_span(span) != ZAP_SUCCESS) { - return ZAP_FAIL; + if (sangoma_boost_data->sigmod->start_span(span) != FTDM_SUCCESS) { + return FTDM_FAIL; } - zap_clear_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RESTARTING); - zap_clear_flag_locked(span, ZAP_SPAN_SUSPENDED); - zap_clear_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN); + ftdm_clear_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RESTARTING); + ftdm_clear_flag_locked(span, FTDM_SPAN_SUSPENDED); + ftdm_clear_flag((&sangoma_boost_data->mcon), MSU_FLAG_DOWN); } sangoma_boost_data->pcon = sangoma_boost_data->mcon; @@ -1424,8 +1424,8 @@ static zap_status_t zap_boost_connection_open(zap_span_t *span) sangoma_boost_data->mcon.cfg.local_port, sangoma_boost_data->mcon.cfg.remote_ip, sangoma_boost_data->mcon.cfg.remote_port) < 0) { - zap_log(ZAP_LOG_ERROR, "Error: Opening MCON Socket [%d] %s\n", sangoma_boost_data->mcon.socket, strerror(errno)); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Error: Opening MCON Socket [%d] %s\n", sangoma_boost_data->mcon.socket, strerror(errno)); + return FTDM_FAIL; } if (sangomabc_connection_open(&sangoma_boost_data->pcon, @@ -1433,32 +1433,32 @@ static zap_status_t zap_boost_connection_open(zap_span_t *span) ++sangoma_boost_data->pcon.cfg.local_port, sangoma_boost_data->pcon.cfg.remote_ip, ++sangoma_boost_data->pcon.cfg.remote_port) < 0) { - zap_log(ZAP_LOG_ERROR, "Error: Opening PCON Socket [%d] %s\n", sangoma_boost_data->pcon.socket, strerror(errno)); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Error: Opening PCON Socket [%d] %s\n", sangoma_boost_data->pcon.socket, strerror(errno)); + return FTDM_FAIL; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /*! \brief wait for a boost event \return -1 on error, 0 on timeout, 1 when there are events */ -static int zap_boost_wait_event(zap_span_t *span, int ms) +static int ftdm_boost_wait_event(ftdm_span_t *span, int ms) { #ifndef WIN32 struct timeval tv = { 0, ms * 1000 }; sangomabc_connection_t *mcon, *pcon; int max, activity; #endif - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; if (sangoma_boost_data->sigmod) { - zap_status_t res; - res = zap_queue_wait(sangoma_boost_data->boost_queue, ms); - if (ZAP_TIMEOUT == res) { + ftdm_status_t res; + res = ftdm_queue_wait(sangoma_boost_data->boost_queue, ms); + if (FTDM_TIMEOUT == res) { return 0; } - if (ZAP_SUCCESS != res) { + if (FTDM_SUCCESS != res) { return -1; } return 1; @@ -1490,11 +1490,11 @@ static int zap_boost_wait_event(zap_span_t *span, int ms) } -static sangomabc_event_t *zap_boost_read_event(zap_span_t *span) +static sangomabc_event_t *ftdm_boost_read_event(ftdm_span_t *span) { sangomabc_event_t *event = NULL; sangomabc_connection_t *mcon, *pcon; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; mcon = &sangoma_boost_data->mcon; pcon = &sangoma_boost_data->pcon; @@ -1520,12 +1520,12 @@ static sangomabc_event_t *zap_boost_read_event(zap_span_t *span) * \param me Current thread * \param obj Span to run in this thread */ -static void *zap_sangoma_boost_run(zap_thread_t *me, void *obj) +static void *ftdm_sangoma_boost_run(ftdm_thread_t *me, void *obj) { - zap_span_t *span = (zap_span_t *) obj; + ftdm_span_t *span = (ftdm_span_t *) obj; sangomabc_connection_t *mcon, *pcon; uint32_t ms = 10; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; mcon = &sangoma_boost_data->mcon; pcon = &sangoma_boost_data->pcon; @@ -1541,8 +1541,8 @@ static void *zap_sangoma_boost_run(zap_thread_t *me, void *obj) pcon->boost_queue = sangoma_boost_data->boost_queue; } - if (zap_boost_connection_open(span) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "zap_boost_connection_open failed\n"); + if (ftdm_boost_connection_open(span) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "ftdm_boost_connection_open failed\n"); goto end; } @@ -1554,14 +1554,14 @@ static void *zap_sangoma_boost_run(zap_thread_t *me, void *obj) -1, SIGBOOST_EVENT_SYSTEM_RESTART, 0); - zap_set_flag(mcon, MSU_FLAG_DOWN); + ftdm_set_flag(mcon, MSU_FLAG_DOWN); } - while (zap_test_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING)) { + while (ftdm_test_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING)) { sangomabc_event_t *event = NULL; int activity = 0; - if (!zap_running()) { + if (!ftdm_running()) { if (!sangoma_boost_data->sigmod) { sangomabc_exec_commandp(pcon, 0, @@ -1569,19 +1569,19 @@ static void *zap_sangoma_boost_run(zap_thread_t *me, void *obj) -1, SIGBOOST_EVENT_SYSTEM_RESTART, 0); - zap_set_flag(mcon, MSU_FLAG_DOWN); + ftdm_set_flag(mcon, MSU_FLAG_DOWN); } - zap_log(ZAP_LOG_DEBUG, "zap is no longer running\n"); + ftdm_log(FTDM_LOG_DEBUG, "ftdm is no longer running\n"); break; } - if ((activity = zap_boost_wait_event(span, ms)) < 0) { - zap_log(ZAP_LOG_ERROR, "zap_boost_wait_event failed\n"); + if ((activity = ftdm_boost_wait_event(span, ms)) < 0) { + ftdm_log(FTDM_LOG_ERROR, "ftdm_boost_wait_event failed\n"); goto error; } if (activity) { - while ((event = zap_boost_read_event(span))) { + while ((event = ftdm_boost_read_event(span))) { parse_sangoma_event(span, pcon, (sangomabc_short_event_t*)event); sangoma_boost_data->iteration++; } @@ -1589,11 +1589,11 @@ static void *zap_sangoma_boost_run(zap_thread_t *me, void *obj) pcon->hb_elapsed += ms; - if (zap_test_flag(span, ZAP_SPAN_SUSPENDED) || zap_test_flag(mcon, MSU_FLAG_DOWN)) { + if (ftdm_test_flag(span, FTDM_SPAN_SUSPENDED) || ftdm_test_flag(mcon, MSU_FLAG_DOWN)) { pcon->hb_elapsed = 0; } - if (zap_running()) { + if (ftdm_running()) { check_state(span); } } @@ -1601,7 +1601,7 @@ static void *zap_sangoma_boost_run(zap_thread_t *me, void *obj) goto end; error: - zap_log(ZAP_LOG_CRIT, "Boost event processing Error!\n"); + ftdm_log(FTDM_LOG_CRIT, "Boost event processing Error!\n"); end: if (!sangoma_boost_data->sigmod) { @@ -1609,231 +1609,231 @@ end: sangomabc_connection_close(&sangoma_boost_data->pcon); } - zap_clear_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING); + ftdm_clear_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING); - zap_log(ZAP_LOG_DEBUG, "Sangoma Boost thread ended.\n"); + ftdm_log(FTDM_LOG_DEBUG, "Sangoma Boost thread ended.\n"); return NULL; } /** * \brief Loads sangoma boost signaling module - * \param zio Openzap IO interface + * \param zio Openftdm IO interface * \return Success */ -static ZIO_SIG_LOAD_FUNCTION(zap_sangoma_boost_init) +static ZIO_SIG_LOAD_FUNCTION(ftdm_sangoma_boost_init) { - g_boost_modules_hash = create_hashtable(10, zap_hash_hashfromstring, zap_hash_equalkeys); + g_boost_modules_hash = create_hashtable(10, ftdm_hash_hashfromstring, ftdm_hash_equalkeys); if (!g_boost_modules_hash) { - return ZAP_FAIL; + return FTDM_FAIL; } - zap_mutex_create(&request_mutex); - zap_mutex_create(&signal_mutex); - zap_mutex_create(&g_boost_modules_mutex); + ftdm_mutex_create(&request_mutex); + ftdm_mutex_create(&signal_mutex); + ftdm_mutex_create(&g_boost_modules_mutex); memset(&g_trunkgroups[0], 0, sizeof(g_trunkgroups)); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -static ZIO_SIG_UNLOAD_FUNCTION(zap_sangoma_boost_destroy) +static ZIO_SIG_UNLOAD_FUNCTION(ftdm_sangoma_boost_destroy) { - zap_hash_iterator_t *i = NULL; + ftdm_hash_iterator_t *i = NULL; boost_sigmod_interface_t *sigmod = NULL; const void *key = NULL; void *val = NULL; - zap_dso_lib_t lib; + ftdm_dso_lib_t lib; for (i = hashtable_first(g_boost_modules_hash); i; i = hashtable_next(i)) { hashtable_this(i, &key, NULL, &val); if (key && val) { sigmod = val; lib = sigmod->pvt; - zap_dso_destroy(&lib); + ftdm_dso_destroy(&lib); } } hashtable_destroy(g_boost_modules_hash); - zap_mutex_destroy(&request_mutex); - zap_mutex_destroy(&signal_mutex); - zap_mutex_destroy(&g_boost_modules_mutex); - return ZAP_SUCCESS; + ftdm_mutex_destroy(&request_mutex); + ftdm_mutex_destroy(&signal_mutex); + ftdm_mutex_destroy(&g_boost_modules_mutex); + return FTDM_SUCCESS; } -static zap_status_t zap_sangoma_boost_start(zap_span_t *span) +static ftdm_status_t ftdm_sangoma_boost_start(ftdm_span_t *span) { int err; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; - zap_set_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING); - err=zap_thread_create_detached(zap_sangoma_boost_run, span); + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_set_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING); + err=ftdm_thread_create_detached(ftdm_sangoma_boost_run, span); if (err) { - zap_clear_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING); + ftdm_clear_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING); return err; } // launch the events thread to handle HW DTMF and possibly // other events in the future - err=zap_thread_create_detached(zap_sangoma_events_run, span); + err=ftdm_thread_create_detached(ftdm_sangoma_events_run, span); if (err) { - zap_clear_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING); + ftdm_clear_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING); } return err; } -static zap_status_t zap_sangoma_boost_stop(zap_span_t *span) +static ftdm_status_t ftdm_sangoma_boost_stop(ftdm_span_t *span) { int cnt = 10; - zap_status_t status = ZAP_SUCCESS; - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_status_t status = FTDM_SUCCESS; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; if (sangoma_boost_data->sigmod) { - /* FIXME: we should make sure the span thread is stopped (use pthread_kill or openzap thread kill function) */ + /* FIXME: we should make sure the span thread is stopped (use pthread_kill or freetdm thread kill function) */ /* I think stopping the span before destroying the queue makes sense otherwise may be boost events would still arrive when the queue is already destroyed! */ status = sangoma_boost_data->sigmod->stop_span(span); - zap_queue_enqueue(sangoma_boost_data->boost_queue, NULL); - while(zap_test_flag(sangoma_boost_data, ZAP_SANGOMA_BOOST_RUNNING) && cnt-- > 0) { - zap_log(ZAP_LOG_DEBUG, "Waiting for boost thread\n"); - zap_sleep(500); + ftdm_queue_enqueue(sangoma_boost_data->boost_queue, NULL); + while(ftdm_test_flag(sangoma_boost_data, FTDM_SANGOMA_BOOST_RUNNING) && cnt-- > 0) { + ftdm_log(FTDM_LOG_DEBUG, "Waiting for boost thread\n"); + ftdm_sleep(500); } - zap_queue_destroy(&sangoma_boost_data->boost_queue); + ftdm_queue_destroy(&sangoma_boost_data->boost_queue); return status; } return status; } -static zap_state_map_t boost_state_map = { +static ftdm_state_map_t boost_state_map = { { { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_ANY_STATE}, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END} + {FTDM_ANY_STATE}, + {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, - {ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_PROGRESS, ZAP_END} + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, + {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_CHANNEL_STATE_PROGRESS, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_UP, ZAP_END} + {FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_CHANNEL_STATE_PROGRESS, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_CHANNEL_STATE_HANGUP, ZAP_END} + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_HANGUP, FTDM_END} }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_OUTBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_UP, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END} + {FTDM_CHANNEL_STATE_UP, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END} }, /****************************************/ { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_ANY_STATE}, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END} + {FTDM_ANY_STATE}, + {FTDM_CHANNEL_STATE_RESTART, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RESTART, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END} + {FTDM_CHANNEL_STATE_RESTART, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, - {ZAP_CHANNEL_STATE_RING, ZAP_END} + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, + {FTDM_CHANNEL_STATE_RING, FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_RING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_PROGRESS_MEDIA,ZAP_END} + {FTDM_CHANNEL_STATE_RING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA,FTDM_END} }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_CHANNEL_STATE_HANGUP, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_HANGUP, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_HANGUP_COMPLETE, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, - {ZAP_CHANNEL_STATE_DOWN, ZAP_END}, + {FTDM_CHANNEL_STATE_HANGUP_COMPLETE, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, + {FTDM_CHANNEL_STATE_DOWN, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_PROGRESS, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_CHANNEL_STATE_UP, ZAP_CHANNEL_STATE_PROGRESS_MEDIA, ZAP_END}, + {FTDM_CHANNEL_STATE_PROGRESS, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_CHANNEL_STATE_UP, FTDM_CHANNEL_STATE_PROGRESS_MEDIA, FTDM_END}, }, { ZSD_INBOUND, ZSM_UNACCEPTABLE, - {ZAP_CHANNEL_STATE_UP, ZAP_END}, - {ZAP_CHANNEL_STATE_HANGUP, ZAP_CHANNEL_STATE_TERMINATING, ZAP_END}, + {FTDM_CHANNEL_STATE_UP, FTDM_END}, + {FTDM_CHANNEL_STATE_HANGUP, FTDM_CHANNEL_STATE_TERMINATING, FTDM_END}, }, } }; -static BOOST_WRITE_MSG_FUNCTION(zap_boost_write_msg) +static BOOST_WRITE_MSG_FUNCTION(ftdm_boost_write_msg) { sangomabc_short_event_t *shortmsg = NULL; - zap_sangoma_boost_data_t *sangoma_boost_data = NULL; + ftdm_sangoma_boost_data_t *sangoma_boost_data = NULL; sangomabc_queue_element_t *element = NULL; - zap_assert_return(msg != NULL, ZAP_FAIL, "Boost message to write was null"); + ftdm_assert_return(msg != NULL, FTDM_FAIL, "Boost message to write was null"); if (!span) { shortmsg = msg; - zap_log(ZAP_LOG_ERROR, "Unexpected boost message %d\n", shortmsg->event_id); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Unexpected boost message %d\n", shortmsg->event_id); + return FTDM_FAIL; } /* duplicate the event and enqueue it */ - element = zap_calloc(1, sizeof(*element)); + element = ftdm_calloc(1, sizeof(*element)); if (!element) { - return ZAP_FAIL; + return FTDM_FAIL; } memcpy(element->boostmsg, msg, msglen); element->size = msglen; sangoma_boost_data = span->signal_data; - return zap_queue_enqueue(sangoma_boost_data->boost_queue, element); + return ftdm_queue_enqueue(sangoma_boost_data->boost_queue, element); } -static BOOST_SIG_STATUS_CB_FUNCTION(zap_boost_sig_status_change) +static BOOST_SIG_STATUS_CB_FUNCTION(ftdm_boost_sig_status_change) { - zap_sigmsg_t sig; - zap_sangoma_boost_data_t *sangoma_boost_data = zchan->span->signal_data; - zap_log(ZAP_LOG_NOTICE, "%d:%d Signaling link status changed to %s\n", zchan->span_id, zchan->chan_id, zap_signaling_status2str(status)); + ftdm_sigmsg_t sig; + ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data; + ftdm_log(FTDM_LOG_NOTICE, "%d:%d Signaling link status changed to %s\n", ftdmchan->span_id, ftdmchan->chan_id, ftdm_signaling_status2str(status)); memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; - sig.event_id = ZAP_SIGEVENT_SIGSTATUS_CHANGED; + sig.chan_id = ftdmchan->chan_id; + sig.span_id = ftdmchan->span_id; + sig.channel = ftdmchan; + sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED; sig.raw_data = &status; sangoma_boost_data->signal_cb(&sig); return; @@ -1841,56 +1841,56 @@ static BOOST_SIG_STATUS_CB_FUNCTION(zap_boost_sig_status_change) static ZIO_CHANNEL_SET_SIG_STATUS_FUNCTION(sangoma_boost_set_channel_sig_status) { - zap_sangoma_boost_data_t *sangoma_boost_data = zchan->span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data; if (!sangoma_boost_data->sigmod) { - zap_log(ZAP_LOG_ERROR, "Cannot set signaling status in boost channel with no signaling module configured\n"); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Cannot set signaling status in boost channel with no signaling module configured\n"); + return FTDM_FAIL; } if (!sangoma_boost_data->sigmod->set_channel_sig_status) { - zap_log(ZAP_LOG_ERROR, "Cannot set signaling status in boost channel: method not implemented\n"); - return ZAP_NOTIMPL; + ftdm_log(FTDM_LOG_ERROR, "Cannot set signaling status in boost channel: method not implemented\n"); + return FTDM_NOTIMPL; } - return sangoma_boost_data->sigmod->set_channel_sig_status(zchan, status); + return sangoma_boost_data->sigmod->set_channel_sig_status(ftdmchan, status); } static ZIO_CHANNEL_GET_SIG_STATUS_FUNCTION(sangoma_boost_get_channel_sig_status) { - zap_sangoma_boost_data_t *sangoma_boost_data = zchan->span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = ftdmchan->span->signal_data; if (!sangoma_boost_data->sigmod) { - zap_log(ZAP_LOG_ERROR, "Cannot get signaling status in boost channel with no signaling module configured\n"); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Cannot get signaling status in boost channel with no signaling module configured\n"); + return FTDM_FAIL; } if (!sangoma_boost_data->sigmod->get_channel_sig_status) { - zap_log(ZAP_LOG_ERROR, "Cannot get signaling status in boost channel: method not implemented\n"); - return ZAP_NOTIMPL; + ftdm_log(FTDM_LOG_ERROR, "Cannot get signaling status in boost channel: method not implemented\n"); + return FTDM_NOTIMPL; } - return sangoma_boost_data->sigmod->get_channel_sig_status(zchan, status); + return sangoma_boost_data->sigmod->get_channel_sig_status(ftdmchan, status); } static ZIO_SPAN_SET_SIG_STATUS_FUNCTION(sangoma_boost_set_span_sig_status) { - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; if (!sangoma_boost_data->sigmod) { - zap_log(ZAP_LOG_ERROR, "Cannot set signaling status in boost span with no signaling module configured\n"); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Cannot set signaling status in boost span with no signaling module configured\n"); + return FTDM_FAIL; } if (!sangoma_boost_data->sigmod->set_span_sig_status) { - zap_log(ZAP_LOG_ERROR, "Cannot set signaling status in boost span: method not implemented\n"); - return ZAP_NOTIMPL; + ftdm_log(FTDM_LOG_ERROR, "Cannot set signaling status in boost span: method not implemented\n"); + return FTDM_NOTIMPL; } return sangoma_boost_data->sigmod->set_span_sig_status(span, status); } static ZIO_SPAN_GET_SIG_STATUS_FUNCTION(sangoma_boost_get_span_sig_status) { - zap_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; + ftdm_sangoma_boost_data_t *sangoma_boost_data = span->signal_data; if (!sangoma_boost_data->sigmod) { - zap_log(ZAP_LOG_ERROR, "Cannot get signaling status in boost span with no signaling module configured\n"); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Cannot get signaling status in boost span with no signaling module configured\n"); + return FTDM_FAIL; } if (!sangoma_boost_data->sigmod->get_span_sig_status) { - zap_log(ZAP_LOG_ERROR, "Cannot get signaling status in boost span: method not implemented\n"); - return ZAP_NOTIMPL; + ftdm_log(FTDM_LOG_ERROR, "Cannot get signaling status in boost span: method not implemented\n"); + return FTDM_NOTIMPL; } return sangoma_boost_data->sigmod->get_span_sig_status(span, status); } @@ -1902,35 +1902,35 @@ static ZIO_SPAN_GET_SIG_STATUS_FUNCTION(sangoma_boost_get_span_sig_status) * \param ap List of configuration variables * \return Success or failure */ -static ZIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(zap_sangoma_boost_configure_span) +static ZIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(ftdm_sangoma_boost_configure_span) { #define FAIL_CONFIG_RETURN(retstatus) \ if (sangoma_boost_data) \ - zap_safe_free(sangoma_boost_data); \ + ftdm_safe_free(sangoma_boost_data); \ if (err) \ - zap_safe_free(err) \ + ftdm_safe_free(err) \ if (hash_locked) \ - zap_mutex_unlock(g_boost_modules_mutex); \ + ftdm_mutex_unlock(g_boost_modules_mutex); \ if (lib) \ - zap_dso_destroy(&lib); \ + ftdm_dso_destroy(&lib); \ return retstatus; boost_sigmod_interface_t *sigmod_iface = NULL; - zap_sangoma_boost_data_t *sangoma_boost_data = NULL; + ftdm_sangoma_boost_data_t *sangoma_boost_data = NULL; const char *local_ip = "127.0.0.65", *remote_ip = "127.0.0.66"; const char *sigmod = NULL; int local_port = 53000, remote_port = 53000; const char *var = NULL, *val = NULL; int hash_locked = 0; - zap_dso_lib_t lib = NULL; + ftdm_dso_lib_t lib = NULL; char path[255] = ""; char *err = NULL; unsigned paramindex = 0; - zap_status_t rc = ZAP_SUCCESS; + ftdm_status_t rc = FTDM_SUCCESS; - for (; zap_parameters[paramindex].var; paramindex++) { - var = zap_parameters[paramindex].var; - val = zap_parameters[paramindex].val; + for (; ftdm_parameters[paramindex].var; paramindex++) { + var = ftdm_parameters[paramindex].var; + val = ftdm_parameters[paramindex].val; if (!strcasecmp(var, "sigmod")) { sigmod = val; } else if (!strcasecmp(var, "local_ip")) { @@ -1943,74 +1943,74 @@ static ZIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(zap_sangoma_boost_configure_span) remote_port = atoi(val); } else if (!sigmod) { snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); - FAIL_CONFIG_RETURN(ZAP_FAIL); + FAIL_CONFIG_RETURN(FTDM_FAIL); } } if (!sigmod) { if (!local_ip && local_port && remote_ip && remote_port && sig_cb) { - zap_set_string(span->last_error, "missing Sangoma boost IP parameters"); - FAIL_CONFIG_RETURN(ZAP_FAIL); + ftdm_set_string(span->last_error, "missing Sangoma boost IP parameters"); + FAIL_CONFIG_RETURN(FTDM_FAIL); } } - sangoma_boost_data = zap_calloc(1, sizeof(*sangoma_boost_data)); + sangoma_boost_data = ftdm_calloc(1, sizeof(*sangoma_boost_data)); if (!sangoma_boost_data) { - FAIL_CONFIG_RETURN(ZAP_FAIL); + FAIL_CONFIG_RETURN(FTDM_FAIL); } /* WARNING: be sure to release this mutex on errors inside this if() */ - zap_mutex_lock(g_boost_modules_mutex); + ftdm_mutex_lock(g_boost_modules_mutex); hash_locked = 1; if (sigmod && !(sigmod_iface = hashtable_search(g_boost_modules_hash, (void *)sigmod))) { - zap_build_dso_path(sigmod, path, sizeof(path)); - lib = zap_dso_open(path, &err); + ftdm_build_dso_path(sigmod, path, sizeof(path)); + lib = ftdm_dso_open(path, &err); if (!lib) { - zap_log(ZAP_LOG_ERROR, "Error loading Sangoma boost signaling module '%s': %s\n", path, err); + ftdm_log(FTDM_LOG_ERROR, "Error loading Sangoma boost signaling module '%s': %s\n", path, err); snprintf(span->last_error, sizeof(span->last_error), "Failed to load sangoma boost signaling module %s", path); - FAIL_CONFIG_RETURN(ZAP_FAIL); + FAIL_CONFIG_RETURN(FTDM_FAIL); } - if (!(sigmod_iface = (boost_sigmod_interface_t *)zap_dso_func_sym(lib, BOOST_INTERFACE_NAME_STR, &err))) { - zap_log(ZAP_LOG_ERROR, "Failed to read Sangoma boost signaling module interface '%s': %s\n", path, err); + if (!(sigmod_iface = (boost_sigmod_interface_t *)ftdm_dso_func_sym(lib, BOOST_INTERFACE_NAME_STR, &err))) { + ftdm_log(FTDM_LOG_ERROR, "Failed to read Sangoma boost signaling module interface '%s': %s\n", path, err); snprintf(span->last_error, sizeof(span->last_error), "Failed to read Sangoma boost signaling module interface '%s': %s", path, err); - FAIL_CONFIG_RETURN(ZAP_FAIL); + FAIL_CONFIG_RETURN(FTDM_FAIL); } rc = sigmod_iface->on_load(); - if (rc != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Failed to load Sangoma boost signaling module interface '%s': on_load method failed (%d)\n", path, rc); - FAIL_CONFIG_RETURN(ZAP_FAIL); + if (rc != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Failed to load Sangoma boost signaling module interface '%s': on_load method failed (%d)\n", path, rc); + FAIL_CONFIG_RETURN(FTDM_FAIL); } sigmod_iface->pvt = lib; - sigmod_iface->set_write_msg_cb(zap_boost_write_msg); - sigmod_iface->set_sig_status_cb(zap_boost_sig_status_change); + sigmod_iface->set_write_msg_cb(ftdm_boost_write_msg); + sigmod_iface->set_sig_status_cb(ftdm_boost_sig_status_change); hashtable_insert(g_boost_modules_hash, (void *)sigmod_iface->name, sigmod_iface, HASHTABLE_FLAG_NONE); lib = NULL; /* destroying the lib will be done when going down and NOT on FAIL_CONFIG_RETURN */ } - zap_mutex_unlock(g_boost_modules_mutex); + ftdm_mutex_unlock(g_boost_modules_mutex); hash_locked = 0; if (sigmod_iface) { /* try to create the boost queue */ - if (zap_queue_create(&sangoma_boost_data->boost_queue, BOOST_QUEUE_SIZE) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Span %s could not create its boost queue!\n", span->name); - FAIL_CONFIG_RETURN(ZAP_FAIL); + if (ftdm_queue_create(&sangoma_boost_data->boost_queue, BOOST_QUEUE_SIZE) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Span %s could not create its boost queue!\n", span->name); + FAIL_CONFIG_RETURN(FTDM_FAIL); } - zap_log(ZAP_LOG_NOTICE, "Span %s will use Sangoma Boost Signaling Module %s\n", span->name, sigmod_iface->name); + ftdm_log(FTDM_LOG_NOTICE, "Span %s will use Sangoma Boost Signaling Module %s\n", span->name, sigmod_iface->name); sangoma_boost_data->sigmod = sigmod_iface; - sigmod_iface->configure_span(span, zap_parameters); + sigmod_iface->configure_span(span, ftdm_parameters); } else { - zap_set_string(sangoma_boost_data->mcon.cfg.local_ip, local_ip); + ftdm_set_string(sangoma_boost_data->mcon.cfg.local_ip, local_ip); sangoma_boost_data->mcon.cfg.local_port = local_port; - zap_set_string(sangoma_boost_data->mcon.cfg.remote_ip, remote_ip); + ftdm_set_string(sangoma_boost_data->mcon.cfg.remote_ip, remote_ip); sangoma_boost_data->mcon.cfg.remote_port = remote_port; } sangoma_boost_data->signal_cb = sig_cb; - span->start = zap_sangoma_boost_start; - span->stop = zap_sangoma_boost_stop; + span->start = ftdm_sangoma_boost_start; + span->stop = ftdm_sangoma_boost_stop; span->signal_data = sangoma_boost_data; - span->signal_type = ZAP_SIGTYPE_SANGOMABOOST; + span->signal_type = FTDM_SIGTYPE_SANGOMABOOST; span->outgoing_call = sangoma_boost_outgoing_call; span->channel_request = sangoma_boost_channel_request; span->get_channel_sig_status = sangoma_boost_get_channel_sig_status; @@ -2019,21 +2019,21 @@ static ZIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(zap_sangoma_boost_configure_span) span->set_span_sig_status = sangoma_boost_set_span_sig_status; span->state_map = &boost_state_map; span->suggest_chan_id = 1; - zap_set_flag_locked(span, ZAP_SPAN_SUSPENDED); - return ZAP_SUCCESS; + ftdm_set_flag_locked(span, FTDM_SPAN_SUSPENDED); + return FTDM_SUCCESS; } /** - * \brief Openzap sangoma boost signaling module definition + * \brief Openftdm sangoma boost signaling module definition */ -EX_DECLARE_DATA zap_module_t zap_module = { +EX_DECLARE_DATA ftdm_module_t ftdm_module = { /*.name =*/ "sangoma_boost", /*.io_load =*/ NULL, /*.io_unload =*/ NULL, - /*.sig_load = */ zap_sangoma_boost_init, + /*.sig_load = */ ftdm_sangoma_boost_init, /*.sig_configure =*/ NULL, - /*.sig_unload = */zap_sangoma_boost_destroy, - /*.configure_span_signaling = */ zap_sangoma_boost_configure_span + /*.sig_unload = */ftdm_sangoma_boost_destroy, + /*.configure_span_signaling = */ ftdm_sangoma_boost_configure_span }; /* For Emacs: diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.2008.vcproj b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/ozmod_sangoma_boost.2008.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/ozmod_sangoma_boost.2008.vcproj rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/ozmod_sangoma_boost.2008.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_client.c b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.c similarity index 82% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_client.c rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.c index ebd27cccac..1d026f1bf4 100644 --- a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_client.c +++ b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.c @@ -35,7 +35,7 @@ #include #endif -#include "openzap.h" +#include "freetdm.h" #include "sangoma_boost_client.h" #ifndef HAVE_GETHOSTBYNAME_R @@ -77,7 +77,7 @@ static void sangomabc_print_event_call(sangomabc_connection_t *mcon, sangomabc_e if (event->event_id == SIGBOOST_EVENT_HEARTBEAT) return; - zap_log(file, func, line, ZAP_LOG_LEVEL_DEBUG, "%s EVENT (%s): %s:(%X) [w%dg%d] CSid=%i Seq=%i Cn=[%s] Cd=[%s] Ci=[%s] Rdnis=[%s]\n", + ftdm_log(file, func, line, FTDM_LOG_LEVEL_DEBUG, "%s EVENT (%s): %s:(%X) [w%dg%d] CSid=%i Seq=%i Cn=[%s] Cd=[%s] Ci=[%s] Rdnis=[%s]\n", dir ? "TX":"RX", priority ? "P":"N", sangomabc_event_id_name(event->event_id), @@ -96,7 +96,7 @@ static void sangomabc_print_event_short(sangomabc_connection_t *mcon, sangomabc_ { if (event->event_id == SIGBOOST_EVENT_HEARTBEAT) return; - zap_log(file, func, line, ZAP_LOG_LEVEL_DEBUG, "%s EVENT (%s): %s:(%X) [s%dc%d] Rc=%i CSid=%i Seq=%i \n", + ftdm_log(file, func, line, FTDM_LOG_LEVEL_DEBUG, "%s EVENT (%s): %s:(%X) [s%dc%d] Rc=%i CSid=%i Seq=%i \n", dir ? "TX":"RX", priority ? "P":"N", sangomabc_event_id_name(event->event_id), @@ -118,18 +118,18 @@ static int create_conn_socket(sangomabc_connection_t *mcon, char *local_ip, int int err = 0, local_err = 0; if (mcon->sigmod) { - zap_log(ZAP_LOG_WARNING, "I should not be called on a sigmod-managed connection!\n"); + ftdm_log(FTDM_LOG_WARNING, "I should not be called on a sigmod-managed connection!\n"); return 0; } memset(&mcon->remote_hp, 0, sizeof(mcon->remote_hp)); memset(&mcon->local_hp, 0, sizeof(mcon->local_hp)); #ifdef HAVE_NETINET_SCTP_H - zap_log(ZAP_LOG_DEBUG, "Creating SCTP socket L=%s:%d R=%s:%d\n", + ftdm_log(FTDM_LOG_DEBUG, "Creating SCTP socket L=%s:%d R=%s:%d\n", local_ip, local_port, ip, port); mcon->socket = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP); #else - zap_log(ZAP_LOG_DEBUG, "Creating UDP socket L=%s:%d R=%s:%d\n", + ftdm_log(FTDM_LOG_DEBUG, "Creating UDP socket L=%s:%d R=%s:%d\n", local_ip, local_port, ip, port); mcon->socket = socket(AF_INET, SOCK_DGRAM, 0); #endif @@ -187,7 +187,7 @@ int sangomabc_connection_close(sangomabc_connection_t *mcon) { #ifndef WIN32 if (mcon->sigmod) { - zap_log(ZAP_LOG_WARNING, "I should not be called on a sigmod-managed connection!\n"); + ftdm_log(FTDM_LOG_WARNING, "I should not be called on a sigmod-managed connection!\n"); return 0; } if (mcon->socket > -1) { @@ -195,9 +195,9 @@ int sangomabc_connection_close(sangomabc_connection_t *mcon) } if (mcon->mutex) { - zap_mutex_lock(mcon->mutex); - zap_mutex_unlock(mcon->mutex); - zap_mutex_destroy(&mcon->mutex); + ftdm_mutex_lock(mcon->mutex); + ftdm_mutex_unlock(mcon->mutex); + ftdm_mutex_destroy(&mcon->mutex); } memset(mcon, 0, sizeof(*mcon)); mcon->socket = -1; @@ -207,7 +207,7 @@ int sangomabc_connection_close(sangomabc_connection_t *mcon) int sangomabc_connection_open(sangomabc_connection_t *mcon, char *local_ip, int local_port, char *ip, int port) { - zap_mutex_create(&mcon->mutex); + ftdm_mutex_create(&mcon->mutex); if (mcon->sigmod) { /*value of mcon->socket will be ignored in sigmod mode */ return 0; @@ -242,11 +242,11 @@ int sangomabc_exec_command(sangomabc_connection_t *mcon, int span, int chan, int while (sangomabc_connection_write(mcon, (sangomabc_event_t*)&oevent) <= 0) { if (--retry <= 0) { - zap_log(ZAP_LOG_CRIT, "Failed to tx on boost socket: %s\n", strerror(errno)); + ftdm_log(FTDM_LOG_CRIT, "Failed to tx on boost socket: %s\n", strerror(errno)); return -1; } else { - zap_log(ZAP_LOG_WARNING, "Failed to tx on boost socket: %s :retry %i\n", strerror(errno), retry); - zap_sleep(1); + ftdm_log(FTDM_LOG_WARNING, "Failed to tx on boost socket: %s :retry %i\n", strerror(errno), retry); + ftdm_sleep(1); } } @@ -268,11 +268,11 @@ int sangomabc_exec_commandp(sangomabc_connection_t *pcon, int span, int chan, in while (sangomabc_connection_writep(pcon, (sangomabc_event_t*)&oevent) <= 0) { if (--retry <= 0) { - zap_log(ZAP_LOG_CRIT, "Failed to tx on boost socket: %s\n", strerror(errno)); + ftdm_log(FTDM_LOG_CRIT, "Failed to tx on boost socket: %s\n", strerror(errno)); return -1; } else { - zap_log(ZAP_LOG_WARNING, "Failed to tx on boost socket: %s :retry %i\n", strerror(errno), retry); - zap_sleep(1); + ftdm_log(FTDM_LOG_WARNING, "Failed to tx on boost socket: %s :retry %i\n", strerror(errno), retry); + ftdm_sleep(1); } } @@ -289,11 +289,11 @@ sangomabc_event_t *__sangomabc_connection_read(sangomabc_connection_t *mcon, int sangomabc_queue_element_t *e = NULL; if (mcon->sigmod) { - e = zap_queue_dequeue(mcon->boost_queue); + e = ftdm_queue_dequeue(mcon->boost_queue); if (e) { bytes = e->size; memcpy(&mcon->event, e->boostmsg, bytes); - zap_safe_free(e); + ftdm_safe_free(e); } } #ifndef WIN32 @@ -307,7 +307,7 @@ sangomabc_event_t *__sangomabc_connection_read(sangomabc_connection_t *mcon, int } if (mcon->event.version != SIGBOOST_VERSION) { - zap_log(ZAP_LOG_CRIT, "Invalid Boost Version %i Expecting %i\n",mcon->event.version, SIGBOOST_VERSION); + ftdm_log(FTDM_LOG_CRIT, "Invalid Boost Version %i Expecting %i\n",mcon->event.version, SIGBOOST_VERSION); } /* Must check for < 0 cannot rely on bytes > MIN_SIZE_... compiler issue */ @@ -329,7 +329,7 @@ sangomabc_event_t *__sangomabc_connection_read(sangomabc_connection_t *mcon, int if (mcon->event.event_id != SIGBOOST_EVENT_SYSTEM_RESTART && mcon->event.event_id != SIGBOOST_EVENT_SYSTEM_RESTART_ACK && mcon->event.event_id != SIGBOOST_EVENT_HEARTBEAT) { - zap_log(file, func, line, ZAP_LOG_LEVEL_WARNING, "Not reading packets when connection is down. [%s]\n", + ftdm_log(file, func, line, FTDM_LOG_LEVEL_WARNING, "Not reading packets when connection is down. [%s]\n", sangomabc_event_id_name(mcon->event.event_id)); return NULL; } @@ -345,12 +345,12 @@ sangomabc_event_t *__sangomabc_connection_read(sangomabc_connection_t *mcon, int /* NC: NOT USED ANY MORE */ if (mcon->rxseq_reset) { //if (mcon->event.event_id == SIGBOOST_EVENT_SYSTEM_RESTART_ACK) { - zap_log(ZAP_LOG_DEBUG, "Rx sync ok\n"); + ftdm_log(FTDM_LOG_DEBUG, "Rx sync ok\n"); mcon->rxseq = mcon->event.fseqno; return &mcon->event; //} errno=EAGAIN; - zap_log(ZAP_LOG_DEBUG, "Waiting for rx sync...\n"); + ftdm_log(FTDM_LOG_DEBUG, "Waiting for rx sync...\n"); return NULL; } #endif @@ -360,7 +360,7 @@ sangomabc_event_t *__sangomabc_connection_read(sangomabc_connection_t *mcon, int #if 0 if (mcon->rxseq != mcon->event.fseqno) { - zap_log(ZAP_LOG_CRIT, "Invalid Sequence Number Expect=%i Rx=%i\n", mcon->rxseq, mcon->event.fseqno); + ftdm_log(FTDM_LOG_CRIT, "Invalid Sequence Number Expect=%i Rx=%i\n", mcon->rxseq, mcon->event.fseqno); return NULL; } #endif @@ -368,7 +368,7 @@ sangomabc_event_t *__sangomabc_connection_read(sangomabc_connection_t *mcon, int return &mcon->event; } else { if (iteration == 0) { - zap_log(ZAP_LOG_CRIT, "NC - Invalid Event length from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); + ftdm_log(FTDM_LOG_CRIT, "NC - Invalid Event length from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); return NULL; } } @@ -397,7 +397,7 @@ sangomabc_event_t *__sangomabc_connection_readp(sangomabc_connection_t *mcon, in } if (mcon->event.version != SIGBOOST_VERSION) { - zap_log(ZAP_LOG_CRIT, "Invalid Boost Version %i Expecting %i\n",mcon->event.version, SIGBOOST_VERSION); + ftdm_log(FTDM_LOG_CRIT, "Invalid Boost Version %i Expecting %i\n",mcon->event.version, SIGBOOST_VERSION); } if (bytes == sizeof(sangomabc_short_event_t)) { @@ -411,7 +411,7 @@ sangomabc_event_t *__sangomabc_connection_readp(sangomabc_connection_t *mcon, in return &mcon->event; } else { if (iteration == 0) { - zap_log(ZAP_LOG_CRIT, "Critical Error: PQ Invalid Event lenght from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); + ftdm_log(FTDM_LOG_CRIT, "Critical Error: PQ Invalid Event lenght from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); return NULL; } } @@ -425,12 +425,12 @@ int __sangomabc_connection_write(sangomabc_connection_t *mcon, sangomabc_event_t int err = 0; int event_size=MIN_SIZE_CALLSTART_MSG+event->isup_in_rdnis_size; - zap_assert_return(event != NULL, -1, "No event!"); - zap_assert_return(mcon->socket >= 0, -1, "No mcon->socket!"); - zap_assert_return(mcon->mutex != NULL, -1, "No mcon->mutex!"); + ftdm_assert_return(event != NULL, -1, "No event!"); + ftdm_assert_return(mcon->socket >= 0, -1, "No mcon->socket!"); + ftdm_assert_return(mcon->mutex != NULL, -1, "No mcon->mutex!"); - if (event->span >= ZAP_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN || event->chan >= ZAP_MAX_CHANNELS_PHYSICAL_SPAN ) { - zap_log(file, func, line, ZAP_LOG_LEVEL_CRIT, "Critical Error: TX Cmd=%s Invalid Span=%i Chan=%i\n", sangomabc_event_id_name(event->event_id), event->span, event->chan); + if (event->span >= FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN || event->chan >= FTDM_MAX_CHANNELS_PHYSICAL_SPAN ) { + ftdm_log(file, func, line, FTDM_LOG_LEVEL_CRIT, "Critical Error: TX Cmd=%s Invalid Span=%i Chan=%i\n", sangomabc_event_id_name(event->event_id), event->span, event->chan); abort(); return -1; } @@ -443,13 +443,13 @@ int __sangomabc_connection_write(sangomabc_connection_t *mcon, sangomabc_event_t if (event->event_id != SIGBOOST_EVENT_SYSTEM_RESTART && event->event_id != SIGBOOST_EVENT_SYSTEM_RESTART_ACK && event->event_id != SIGBOOST_EVENT_HEARTBEAT) { - zap_log(file, func, line, ZAP_LOG_LEVEL_WARNING, "Not writing packets when connection is down. [%s]\n", + ftdm_log(file, func, line, FTDM_LOG_LEVEL_WARNING, "Not writing packets when connection is down. [%s]\n", sangomabc_event_id_name(event->event_id)); return 0; } } - zap_mutex_lock(mcon->mutex); + ftdm_mutex_lock(mcon->mutex); if (event->event_id == SIGBOOST_EVENT_SYSTEM_RESTART_ACK) { mcon->txseq=0; mcon->rxseq=0; @@ -476,9 +476,9 @@ int __sangomabc_connection_write(sangomabc_connection_t *mcon, sangomabc_event_t } #endif - zap_mutex_unlock(mcon->mutex); + ftdm_mutex_unlock(mcon->mutex); - zap_assert_return(err == event_size, -1, "Failed to send the boost message completely!"); + ftdm_assert_return(err == event_size, -1, "Failed to send the boost message completely!"); return err; } @@ -490,16 +490,16 @@ int __sangomabc_connection_writep(sangomabc_connection_t *mcon, sangomabc_event_ int event_size=sizeof(sangomabc_event_t); if (!mcon->sigmod) { - zap_assert_return(event != NULL, -1, "No event!"); - zap_assert_return(mcon->socket >= 0, -1, "No mcon->socket!"); - zap_assert_return(mcon->mutex != NULL, -1, "No mcon->mutex!"); + ftdm_assert_return(event != NULL, -1, "No event!"); + ftdm_assert_return(mcon->socket >= 0, -1, "No mcon->socket!"); + ftdm_assert_return(mcon->mutex != NULL, -1, "No mcon->mutex!"); } if (!boost_full_event(event->event_id)) { event_size=sizeof(sangomabc_short_event_t); } - zap_mutex_lock(mcon->mutex); + ftdm_mutex_lock(mcon->mutex); event->version = SIGBOOST_VERSION; if (mcon->sigmod) { mcon->sigmod->write_msg(mcon->span, event, event_size); @@ -511,9 +511,9 @@ int __sangomabc_connection_writep(sangomabc_connection_t *mcon, sangomabc_event_ err = sendto(mcon->socket, event, event_size, 0, (struct sockaddr *) &mcon->remote_addr, sizeof(mcon->remote_addr)); } #endif - zap_mutex_unlock(mcon->mutex); + ftdm_mutex_unlock(mcon->mutex); - zap_assert_return(err == event_size, -1, "Failed to send boost message completely!"); + ftdm_assert_return(err == event_size, -1, "Failed to send boost message completely!"); if (boost_full_event(event->event_id)) { sangomabc_print_event_call(mcon, event, 1, 1, file, func, line); diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_client.h b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.h similarity index 98% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_client.h rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.h index 24a0a5c600..9fe2145b94 100644 --- a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_client.h +++ b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_client.h @@ -91,14 +91,14 @@ typedef enum { struct sangomabc_connection { - zap_socket_t socket; + ftdm_socket_t socket; struct sockaddr_in local_addr; struct sockaddr_in remote_addr; sangomabc_event_t event; struct hostent remote_hp; struct hostent local_hp; unsigned int flags; - zap_mutex_t *mutex; + ftdm_mutex_t *mutex; FILE *log; unsigned int txseq; unsigned int rxseq; @@ -108,15 +108,15 @@ struct sangomabc_connection { uint32_t hb_elapsed; /* boost signaling mod interface pointer (if not working in TCP mode) */ boost_sigmod_interface_t *sigmod; - zap_queue_t *boost_queue; - zap_span_t *span; + ftdm_queue_t *boost_queue; + ftdm_span_t *span; }; typedef struct sangomabc_connection sangomabc_connection_t; typedef struct sangomabc_queue_element { unsigned char boostmsg[sizeof(sangomabc_event_t)]; - zap_size_t size; + ftdm_size_t size; } sangomabc_queue_element_t; /* disable nagle's algorythm */ diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_interface.h b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_interface.h similarity index 66% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_interface.h rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_interface.h index 5faa474727..b555e24338 100644 --- a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sangoma_boost_interface.h +++ b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sangoma_boost_interface.h @@ -35,7 +35,7 @@ #ifndef SANGOMA_BOOST_INTERFACE_H #define SANGOMA_BOOST_INTERFACE_H -#include "openzap.h" +#include "freetdm.h" #ifdef __cplusplus @@ -44,28 +44,28 @@ extern "C" { /*! \brief Callback used to notify signaling status changes on a channel - \param zchan The openzap channel where the signaling status just changed + \param ftdmchan The freetdm channel where the signaling status just changed \param status The new signaling status */ -#define BOOST_SIG_STATUS_CB_ARGS (zap_channel_t *zchan, zap_signaling_status_t status) +#define BOOST_SIG_STATUS_CB_ARGS (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status) typedef void (*boost_sig_status_cb_func_t) BOOST_SIG_STATUS_CB_ARGS; #define BOOST_SIG_STATUS_CB_FUNCTION(name) void name BOOST_SIG_STATUS_CB_ARGS /*! \brief Write a boost msg to a boost endpoint - \param span The openzap span where this msg was generated + \param span The freetdm span where this msg was generated \param msg The generic message pointer, owned by the caller \param msglen The length of the provided structure pointed by msg - \return ZAP_SUCCESS or ZAP_FAIL + \return FTDM_SUCCESS or FTDM_FAIL The msg buffer is owned by the caller and it should be either t_sigboost_callstart or t_sigboost_short the endpoint receiving the msg will first cast to t_sigboost_short, check the event type, and if needed. */ -#define BOOST_WRITE_MSG_ARGS (zap_span_t *span, void *msg, zap_size_t msglen) -typedef zap_status_t (*boost_write_msg_func_t) BOOST_WRITE_MSG_ARGS; -#define BOOST_WRITE_MSG_FUNCTION(name) zap_status_t name BOOST_WRITE_MSG_ARGS +#define BOOST_WRITE_MSG_ARGS (ftdm_span_t *span, void *msg, ftdm_size_t msglen) +typedef ftdm_status_t (*boost_write_msg_func_t) BOOST_WRITE_MSG_ARGS; +#define BOOST_WRITE_MSG_FUNCTION(name) ftdm_status_t name BOOST_WRITE_MSG_ARGS /*! \brief Set the callback to be used by a signaling module to write boost messages @@ -80,11 +80,11 @@ typedef void (*boost_set_write_msg_cb_func_t) BOOST_SET_WRITE_MSG_CB_ARGS; /*! \brief Notify hardware status change - \param zchan The openzap channel + \param ftdmchan The freetdm channel \param status The hw status - \return ZAP_SUCCESS or ZAP_FAIL + \return FTDM_SUCCESS or FTDM_FAIL */ -#define BOOST_ON_HW_LINK_STATUS_CHANGE_ARGS (zap_channel_t *zchan, zap_channel_hw_link_status_t status) +#define BOOST_ON_HW_LINK_STATUS_CHANGE_ARGS (ftdm_channel_t *ftdmchan, ftdm_channel_hw_link_status_t status) typedef void (*boost_on_hw_link_status_change_func_t) BOOST_ON_HW_LINK_STATUS_CHANGE_ARGS; #define BOOST_ON_HW_LINK_STATUS_CHANGE_FUNCTION(name) void name BOOST_ON_HW_LINK_STATUS_CHANGE_ARGS @@ -101,84 +101,84 @@ typedef void (*boost_set_sig_status_cb_func_t) BOOST_SET_SIG_STATUS_CB_ARGS; /*! \brief Get the signaling status on the given channel. - \param zchan The openzap channel + \param ftdmchan The freetdm channel \param status The status pointer where the current signaling status will be set */ -#define BOOST_GET_CHANNEL_SIG_STATUS_ARGS (zap_channel_t *zchan, zap_signaling_status_t *status) -typedef zap_status_t (*boost_get_channel_sig_status_func_t) BOOST_GET_CHANNEL_SIG_STATUS_ARGS; -#define BOOST_GET_CHANNEL_SIG_STATUS_FUNCTION(name) zap_status_t name BOOST_GET_CHANNEL_SIG_STATUS_ARGS +#define BOOST_GET_CHANNEL_SIG_STATUS_ARGS (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status) +typedef ftdm_status_t (*boost_get_channel_sig_status_func_t) BOOST_GET_CHANNEL_SIG_STATUS_ARGS; +#define BOOST_GET_CHANNEL_SIG_STATUS_FUNCTION(name) ftdm_status_t name BOOST_GET_CHANNEL_SIG_STATUS_ARGS /*! \brief Set the signaling status on the given channel. - \param zchan The openzap channel + \param ftdmchan The freetdm channel \param status The new status for the channel - \return ZAP_SUCCESS or ZAP_FAIL + \return FTDM_SUCCESS or FTDM_FAIL */ -#define BOOST_SET_CHANNEL_SIG_STATUS_ARGS (zap_channel_t *zchan, zap_signaling_status_t status) -typedef zap_status_t (*boost_set_channel_sig_status_func_t) BOOST_SET_CHANNEL_SIG_STATUS_ARGS; -#define BOOST_SET_CHANNEL_SIG_STATUS_FUNCTION(name) zap_status_t name BOOST_SET_CHANNEL_SIG_STATUS_ARGS +#define BOOST_SET_CHANNEL_SIG_STATUS_ARGS (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status) +typedef ftdm_status_t (*boost_set_channel_sig_status_func_t) BOOST_SET_CHANNEL_SIG_STATUS_ARGS; +#define BOOST_SET_CHANNEL_SIG_STATUS_FUNCTION(name) ftdm_status_t name BOOST_SET_CHANNEL_SIG_STATUS_ARGS /*! \brief Get the signaling status on the given span. - \param span The openzap span + \param span The freetdm span \param status The status pointer where the current signaling status will be set */ -#define BOOST_GET_SPAN_SIG_STATUS_ARGS (zap_span_t *span, zap_signaling_status_t *status) -typedef zap_status_t (*boost_get_span_sig_status_func_t) BOOST_GET_SPAN_SIG_STATUS_ARGS; -#define BOOST_GET_SPAN_SIG_STATUS_FUNCTION(name) zap_status_t name BOOST_GET_SPAN_SIG_STATUS_ARGS +#define BOOST_GET_SPAN_SIG_STATUS_ARGS (ftdm_span_t *span, ftdm_signaling_status_t *status) +typedef ftdm_status_t (*boost_get_span_sig_status_func_t) BOOST_GET_SPAN_SIG_STATUS_ARGS; +#define BOOST_GET_SPAN_SIG_STATUS_FUNCTION(name) ftdm_status_t name BOOST_GET_SPAN_SIG_STATUS_ARGS /*! \brief Set the signaling status on the given span. - \param zchan The openzap span + \param ftdmchan The freetdm span \param status The new status for the span - \return ZAP_SUCCESS or ZAP_FAIL + \return FTDM_SUCCESS or FTDM_FAIL */ -#define BOOST_SET_SPAN_SIG_STATUS_ARGS (zap_span_t *span, zap_signaling_status_t status) -typedef zap_status_t (*boost_set_span_sig_status_func_t) BOOST_SET_SPAN_SIG_STATUS_ARGS; -#define BOOST_SET_SPAN_SIG_STATUS_FUNCTION(name) zap_status_t name BOOST_SET_SPAN_SIG_STATUS_ARGS +#define BOOST_SET_SPAN_SIG_STATUS_ARGS (ftdm_span_t *span, ftdm_signaling_status_t status) +typedef ftdm_status_t (*boost_set_span_sig_status_func_t) BOOST_SET_SPAN_SIG_STATUS_ARGS; +#define BOOST_SET_SPAN_SIG_STATUS_FUNCTION(name) ftdm_status_t name BOOST_SET_SPAN_SIG_STATUS_ARGS /*! \brief Configure the given span signaling - \param span The openzap span + \param span The freetdm span \param parameters The array of configuration key,value pairs (must be null terminated) - \return ZAP_SUCCESS or ZAP_FAIL + \return FTDM_SUCCESS or FTDM_FAIL */ -#define BOOST_CONFIGURE_SPAN_ARGS (zap_span_t *span, zap_conf_parameter_t *parameters) -typedef zap_status_t (*boost_configure_span_func_t) BOOST_CONFIGURE_SPAN_ARGS; -#define BOOST_CONFIGURE_SPAN_FUNCTION(name) zap_status_t name BOOST_CONFIGURE_SPAN_ARGS +#define BOOST_CONFIGURE_SPAN_ARGS (ftdm_span_t *span, ftdm_conf_parameter_t *parameters) +typedef ftdm_status_t (*boost_configure_span_func_t) BOOST_CONFIGURE_SPAN_ARGS; +#define BOOST_CONFIGURE_SPAN_FUNCTION(name) ftdm_status_t name BOOST_CONFIGURE_SPAN_ARGS /*! \brief Start the given span - \param span The openzap span - \return ZAP_SUCCESS or ZAP_FAIL + \param span The freetdm span + \return FTDM_SUCCESS or FTDM_FAIL */ -#define BOOST_START_SPAN_ARGS (zap_span_t *span) -typedef zap_status_t (*boost_start_span_func_t) BOOST_START_SPAN_ARGS; -#define BOOST_START_SPAN_FUNCTION(name) zap_status_t name BOOST_START_SPAN_ARGS +#define BOOST_START_SPAN_ARGS (ftdm_span_t *span) +typedef ftdm_status_t (*boost_start_span_func_t) BOOST_START_SPAN_ARGS; +#define BOOST_START_SPAN_FUNCTION(name) ftdm_status_t name BOOST_START_SPAN_ARGS /*! \brief Stop the given span - \param span The openzap span - \return ZAP_SUCCESS or ZAP_FAIL + \param span The freetdm span + \return FTDM_SUCCESS or FTDM_FAIL */ -#define BOOST_STOP_SPAN_ARGS (zap_span_t *span) -typedef zap_status_t (*boost_stop_span_func_t) BOOST_START_SPAN_ARGS; -#define BOOST_STOP_SPAN_FUNCTION(name) zap_status_t name BOOST_STOP_SPAN_ARGS +#define BOOST_STOP_SPAN_ARGS (ftdm_span_t *span) +typedef ftdm_status_t (*boost_stop_span_func_t) BOOST_START_SPAN_ARGS; +#define BOOST_STOP_SPAN_FUNCTION(name) ftdm_status_t name BOOST_STOP_SPAN_ARGS /*! \brief Called when the module is being loaded BEFORE calling anything else - \return ZAP_SUCCESS or ZAP_FAIL + \return FTDM_SUCCESS or FTDM_FAIL */ #define BOOST_ON_LOAD_ARGS (void) -typedef zap_status_t (*boost_on_load_func_t) BOOST_ON_LOAD_ARGS; -#define BOOST_ON_LOAD_FUNCTION(name) zap_status_t name BOOST_ON_LOAD_ARGS +typedef ftdm_status_t (*boost_on_load_func_t) BOOST_ON_LOAD_ARGS; +#define BOOST_ON_LOAD_FUNCTION(name) ftdm_status_t name BOOST_ON_LOAD_ARGS /*! \brief Called when the module is being unloaded, last chance to stop everything! */ #define BOOST_ON_UNLOAD_ARGS (void) -typedef zap_status_t (*boost_on_unload_func_t) BOOST_ON_UNLOAD_ARGS; -#define BOOST_ON_UNLOAD_FUNCTION(name) zap_status_t name BOOST_ON_UNLOAD_ARGS +typedef ftdm_status_t (*boost_on_unload_func_t) BOOST_ON_UNLOAD_ARGS; +#define BOOST_ON_UNLOAD_FUNCTION(name) ftdm_status_t name BOOST_ON_UNLOAD_ARGS /*! \brief The boost signaling module interface @@ -204,9 +204,9 @@ typedef struct boost_sigmod_interface_s { boost_on_hw_link_status_change_func_t on_hw_link_status_change; /*! \brief configure span signaling */ boost_configure_span_func_t configure_span; - /*! \brief start openzap span */ + /*! \brief start freetdm span */ boost_start_span_func_t start_span; - /*! \brief stop openzap span */ + /*! \brief stop freetdm span */ boost_stop_span_func_t stop_span; /*! \brief the module was just loaded */ boost_on_load_func_t on_load; diff --git a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sigboost.h b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sigboost.h similarity index 97% rename from libs/freetdm/src/ozmod/ozmod_sangoma_boost/sigboost.h rename to libs/freetdm/src/ftmod/ftmod_sangoma_boost/sigboost.h index b9cbf110f6..37a3803faa 100644 --- a/libs/freetdm/src/ozmod/ozmod_sangoma_boost/sigboost.h +++ b/libs/freetdm/src/ftmod/ftmod_sangoma_boost/sigboost.h @@ -17,7 +17,7 @@ #define SIGBOOST_VERSION 100 // handy to define integer types that actually work on both Lin and Win -#include +#include enum e_sigboost_event_id_values { @@ -30,11 +30,11 @@ enum e_sigboost_event_id_values SIGBOOST_EVENT_CALL_STOPPED_ACK = 0x86, /*134*/ /* CALL_RELEASED is aimed to fix a race condition that became obvious * when the boost socket was replaced by direct function calls - * and the channel hunting was moved to openzap, the problem is + * and the channel hunting was moved to freetdm, the problem is * we can get CALL_STOPPED msg and reply with CALL_STOPPED_ACK * but the signaling module will still (in PRI) send RELEASE and * wait for RELEASE_COMPLETE from the isdn network before - * marking the channel as available, therefore openzap should + * marking the channel as available, therefore freetdm should * also not mark the channel as available until CALL_RELEASED * is received, for socket mode we can continue working as usual * with CALL_STOPPED being the last step because the hunting is diff --git a/libs/freetdm/src/ozmod/ozmod_skel/ozmod_skel.c b/libs/freetdm/src/ftmod/ftmod_skel/ftmod_skel.c similarity index 88% rename from libs/freetdm/src/ozmod/ozmod_skel/ozmod_skel.c rename to libs/freetdm/src/ftmod/ftmod_skel/ftmod_skel.c index 949e0fbf31..ca01ed1bcc 100644 --- a/libs/freetdm/src/ozmod/ozmod_skel/ozmod_skel.c +++ b/libs/freetdm/src/ftmod/ftmod_skel/ftmod_skel.c @@ -32,75 +32,75 @@ */ -#include "openzap.h" -//#include "zap_skel.h" +#include "freetdm.h" +//#include "ftdm_skel.h" static ZIO_CONFIGURE_FUNCTION(skel_configure) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_CONFIGURE_SPAN_FUNCTION(skel_configure_span) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_OPEN_FUNCTION(skel_open) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_CLOSE_FUNCTION(skel_close) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_WAIT_FUNCTION(skel_wait) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_READ_FUNCTION(skel_read) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_WRITE_FUNCTION(skel_write) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_COMMAND_FUNCTION(skel_command) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_SPAN_POLL_EVENT_FUNCTION(skel_poll_event) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_SPAN_NEXT_EVENT_FUNCTION(skel_next_event) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_CHANNEL_DESTROY_FUNCTION(skel_channel_destroy) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_SPAN_DESTROY_FUNCTION(skel_span_destroy) { - return ZAP_FAIL; + return FTDM_FAIL; } static ZIO_GET_ALARMS_FUNCTION(skel_get_alarms) { - return ZAP_FAIL; + return FTDM_FAIL; } -static zap_io_interface_t skel_interface; +static ftdm_io_interface_t skel_interface; static ZIO_IO_LOAD_FUNCTION(skel_init) { @@ -123,16 +123,16 @@ static ZIO_IO_LOAD_FUNCTION(skel_init) skel_interface.get_alarms = skel_get_alarms; *zio = &skel_interface; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } static ZIO_IO_UNLOAD_FUNCTION(skel_destroy) { - return ZAP_SUCCESS; + return FTDM_SUCCESS; } -zap_module_t zap_module = { +ftdm_module_t ftdm_module = { "skel", skel_init, skel_destroy, diff --git a/libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.c b/libs/freetdm/src/ftmod/ftmod_wanpipe/ftmod_wanpipe.c similarity index 58% rename from libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.c rename to libs/freetdm/src/ftmod/ftmod_wanpipe/ftmod_wanpipe.c index 713e72498b..aebf4735c9 100644 --- a/libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.c +++ b/libs/freetdm/src/ftmod/ftmod_wanpipe/ftmod_wanpipe.c @@ -42,7 +42,7 @@ #include #include #endif -#include "openzap.h" +#include "freetdm.h" #ifndef __WINDOWS__ #include #include @@ -114,14 +114,14 @@ ZIO_SPAN_NEXT_EVENT_FUNCTION(wanpipe_next_event); * so we can have one analong handler thread that will deal with all the idle analog channels for events * the alternative would be for the driver to provide one socket for all of the oob events for all analog channels */ -static __inline__ int tdmv_api_wait_socket(zap_channel_t *zchan, int timeout, int *flags) +static __inline__ int tdmv_api_wait_socket(ftdm_channel_t *ftdmchan, int timeout, int *flags) { #ifdef LIBSANGOMA_VERSION int err; uint32_t inflags = *flags; uint32_t outflags = 0; - sangoma_wait_obj_t *sangoma_wait_obj = zchan->mod_data; + sangoma_wait_obj_t *sangoma_wait_obj = ftdmchan->mod_data; err = sangoma_waitfor(sangoma_wait_obj, inflags, &outflags, timeout); *flags = 0; @@ -138,7 +138,7 @@ static __inline__ int tdmv_api_wait_socket(zap_channel_t *zchan, int timeout, in int res; memset(&pfds[0], 0, sizeof(pfds[0])); - pfds[0].fd = zchan->sockfd; + pfds[0].fd = ftdmchan->sockfd; pfds[0].events = *flags; res = poll(pfds, 1, timeout); *flags = 0; @@ -174,7 +174,7 @@ static __inline__ sng_fd_t __tdmv_api_open_span_chan(int span, int chan) } #endif -static zap_io_interface_t wanpipe_interface; +static ftdm_io_interface_t wanpipe_interface; /** * \brief Inverts bit string @@ -201,17 +201,17 @@ static unsigned char wanpipe_swap_bits(unsigned char cas_bits) /** * \brief Initialises a range of wanpipe channels - * \param span Openzap span + * \param span Openftdm span * \param spanno Wanpipe span number * \param start Initial wanpipe channel number * \param end Final wanpipe channel number - * \param type Openzap channel type - * \param name Openzap span name - * \param number Openzap span number + * \param type Openftdm channel type + * \param name Openftdm span name + * \param number Openftdm span number * \param cas_bits CAS bits * \return number of spans configured */ -static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start, unsigned end, zap_chan_type_t type, char *name, char *number, unsigned char cas_bits) +static unsigned wp_open_range(ftdm_span_t *span, unsigned spanno, unsigned start, unsigned end, ftdm_chan_type_t type, char *name, char *number, unsigned char cas_bits) { unsigned configured = 0, x; #ifdef LIBSANGOMA_VERSION @@ -219,39 +219,39 @@ static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start, sangoma_wait_obj_t *sangoma_wait_obj; #endif - if (type == ZAP_CHAN_TYPE_CAS) { - zap_log(ZAP_LOG_DEBUG, "Configuring Wanpipe CAS channels with abcd == 0x%X\n", cas_bits); + if (type == FTDM_CHAN_TYPE_CAS) { + ftdm_log(FTDM_LOG_DEBUG, "Configuring Wanpipe CAS channels with abcd == 0x%X\n", cas_bits); } for(x = start; x < end; x++) { - zap_channel_t *chan; - zap_socket_t sockfd = WP_INVALID_SOCKET; + ftdm_channel_t *chan; + ftdm_socket_t sockfd = WP_INVALID_SOCKET; const char *dtmf = "none"; - if (!strncasecmp(span->name, "smg_prid_nfas", 8) && span->trunk_type == ZAP_TRUNK_T1 && x == 24) { + if (!strncasecmp(span->name, "smg_prid_nfas", 8) && span->trunk_type == FTDM_TRUNK_T1 && x == 24) { #ifdef LIBSANGOMA_VERSION sockfd = __tdmv_api_open_span_chan(spanno, x); #else - zap_log(ZAP_LOG_ERROR, "span %d channel %d cannot be configured as smg_prid_nfas, you need to compile openzap with newer libsangoma\n", spanno, x); + ftdm_log(FTDM_LOG_ERROR, "span %d channel %d cannot be configured as smg_prid_nfas, you need to compile freetdm with newer libsangoma\n", spanno, x); #endif } else { sockfd = tdmv_api_open_span_chan(spanno, x); } if (sockfd == WP_INVALID_SOCKET) { - zap_log(ZAP_LOG_ERROR, "Failed to open wanpipe device span %d channel %d\n", spanno, x); + ftdm_log(FTDM_LOG_ERROR, "Failed to open wanpipe device span %d channel %d\n", spanno, x); continue; } - if (zap_span_add_channel(span, sockfd, type, &chan) == ZAP_SUCCESS) { + if (ftdm_span_add_channel(span, sockfd, type, &chan) == FTDM_SUCCESS) { wanpipe_tdm_api_t tdm_api; memset(&tdm_api, 0, sizeof(tdm_api)); #ifdef LIBSANGOMA_VERSION /* we need SANGOMA_DEVICE_WAIT_OBJ_SIG and not SANGOMA_DEVICE_WAIT_OBJ alone because we need to call - * sangoma_wait_obj_sig to wake up any I/O waiters when closing the channel (typically on zap shutdown) + * sangoma_wait_obj_sig to wake up any I/O waiters when closing the channel (typically on ftdm shutdown) * this adds an extra pair of file descriptors to the waitable object * */ sangstatus = sangoma_wait_obj_create(&sangoma_wait_obj, sockfd, SANGOMA_DEVICE_WAIT_OBJ_SIG); if (sangstatus != SANG_STATUS_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "failure create waitable object for s%dc%d\n", spanno, x); + ftdm_log(FTDM_LOG_ERROR, "failure create waitable object for s%dc%d\n", spanno, x); continue; } chan->mod_data = sangoma_wait_obj; @@ -261,7 +261,7 @@ static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start, chan->physical_chan_id = x; chan->rate = 8000; - if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO || type == ZAP_CHAN_TYPE_B) { + if (type == FTDM_CHAN_TYPE_FXS || type == FTDM_CHAN_TYPE_FXO || type == FTDM_CHAN_TYPE_B) { int err; dtmf = "software"; @@ -270,34 +270,34 @@ static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start, err = sangoma_tdm_get_hw_coding(chan->sockfd, &tdm_api); if (tdm_api.wp_tdm_cmd.hw_tdm_coding) { - chan->native_codec = chan->effective_codec = ZAP_CODEC_ALAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ALAW; } else { - chan->native_codec = chan->effective_codec = ZAP_CODEC_ULAW; + chan->native_codec = chan->effective_codec = FTDM_CODEC_ULAW; } //err = sangoma_tdm_get_hw_dtmf(chan->sockfd, &tdm_api); //if (err > 0) { err = sangoma_tdm_enable_dtmf_events(chan->sockfd, &tdm_api); if (err == 0) { - zap_channel_set_feature(chan, ZAP_CHANNEL_FEATURE_DTMF_DETECT); + ftdm_channel_set_feature(chan, FTDM_CHANNEL_FEATURE_DTMF_DETECT); dtmf = "hardware"; } //} } #if 0 - if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO) { + if (type == FTDM_CHAN_TYPE_FXS || type == FTDM_CHAN_TYPE_FXO) { /* Enable FLASH/Wink Events */ int err=sangoma_set_rm_rxflashtime(chan->sockfd, &tdm_api, wp_globals.flash_ms); if (err == 0) { - zap_log(ZAP_LOG_ERROR, "flash enabled s%dc%d\n", spanno, x); + ftdm_log(FTDM_LOG_ERROR, "flash enabled s%dc%d\n", spanno, x); } else { - zap_log(ZAP_LOG_ERROR, "flash disabled s%dc%d\n", spanno, x); + ftdm_log(FTDM_LOG_ERROR, "flash disabled s%dc%d\n", spanno, x); } } #endif - if (type == ZAP_CHAN_TYPE_CAS || type == ZAP_CHAN_TYPE_EM) { + if (type == FTDM_CHAN_TYPE_CAS || type == FTDM_CHAN_TYPE_EM) { #ifdef LIBSANGOMA_VERSION sangoma_tdm_write_rbs(chan->sockfd,&tdm_api,chan->physical_chan_id, wanpipe_swap_bits(cas_bits)); @@ -305,7 +305,7 @@ static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start, The poll rate is hard coded to 100 per second (done in the driver, is the max rate of polling allowed by wanpipe) */ if (sangoma_tdm_enable_rbs_events(chan->sockfd, &tdm_api, 100)) { - zap_log(ZAP_LOG_ERROR, "Failed to enable RBS/CAS events in device %d:%d fd:%d\n", chan->span_id, chan->chan_id, sockfd); + ftdm_log(FTDM_LOG_ERROR, "Failed to enable RBS/CAS events in device %d:%d fd:%d\n", chan->span_id, chan->chan_id, sockfd); continue; } /* probably done by the driver but lets write defensive code this time */ @@ -318,7 +318,7 @@ static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start, * may be we should not send an error until that is fixed in the driver */ if (sangoma_tdm_enable_rbs_events(chan->sockfd, &tdm_api, 100)) { - zap_log(ZAP_LOG_ERROR, "Failed to enable RBS/CAS events in device %d:%d fd:%d\n", chan->span_id, chan->chan_id, sockfd); + ftdm_log(FTDM_LOG_ERROR, "Failed to enable RBS/CAS events in device %d:%d fd:%d\n", chan->span_id, chan->chan_id, sockfd); } /* probably done by the driver but lets write defensive code this time */ sangoma_tdm_flush_bufs(chan->sockfd, &tdm_api); @@ -326,19 +326,19 @@ static unsigned wp_open_range(zap_span_t *span, unsigned spanno, unsigned start, #endif } - if (!zap_strlen_zero(name)) { - zap_copy_string(chan->chan_name, name, sizeof(chan->chan_name)); + if (!ftdm_strlen_zero(name)) { + ftdm_copy_string(chan->chan_name, name, sizeof(chan->chan_name)); } - if (!zap_strlen_zero(number)) { - zap_copy_string(chan->chan_number, number, sizeof(chan->chan_number)); + if (!ftdm_strlen_zero(number)) { + ftdm_copy_string(chan->chan_number, number, sizeof(chan->chan_number)); } configured++; - zap_log(ZAP_LOG_INFO, "configuring device s%dc%d as OpenZAP device %d:%d fd:%d DTMF: %s\n", + ftdm_log(FTDM_LOG_INFO, "configuring device s%dc%d as OpenFTDM device %d:%d fd:%d DTMF: %s\n", spanno, x, chan->span_id, chan->chan_id, sockfd, dtmf); } else { - zap_log(ZAP_LOG_ERROR, "zap_span_add_channel failed for wanpipe span %d channel %d\n", spanno, x); + ftdm_log(FTDM_LOG_ERROR, "ftdm_span_add_channel failed for wanpipe span %d channel %d\n", spanno, x); } } @@ -361,37 +361,37 @@ static ZIO_CONFIGURE_FUNCTION(wanpipe_configure) if (!strcasecmp(var, "codec_ms")) { num = atoi(val); if (num < 10 || num > 60) { - zap_log(ZAP_LOG_WARNING, "invalid codec ms at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid codec ms at line %d\n", lineno); } else { wp_globals.codec_ms = num; } } else if (!strcasecmp(var, "wink_ms")) { num = atoi(val); if (num < 50 || num > 3000) { - zap_log(ZAP_LOG_WARNING, "invalid wink ms at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid wink ms at line %d\n", lineno); } else { wp_globals.wink_ms = num; } } else if (!strcasecmp(var, "flash_ms")) { num = atoi(val); if (num < 50 || num > 3000) { - zap_log(ZAP_LOG_WARNING, "invalid flash ms at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid flash ms at line %d\n", lineno); } else { wp_globals.flash_ms = num; } } } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Initialises an openzap Wanpipe span from a configuration string - * \param span Openzap span + * \brief Initialises an freetdm Wanpipe span from a configuration string + * \param span Openftdm span * \param str Configuration string - * \param type Openzap span type - * \param name Openzap span name - * \param number Openzap span number + * \param type Openftdm span type + * \param name Openftdm span name + * \param number Openftdm span number * \return Success or failure */ static ZIO_CONFIGURE_SPAN_FUNCTION(wanpipe_configure_span) @@ -408,11 +408,11 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(wanpipe_configure_span) assert(str != NULL); - mydata = zap_strdup(str); + mydata = ftdm_strdup(str); assert(mydata != NULL); - items = zap_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); + items = ftdm_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); for(i = 0; i < items; i++) { sp = item_list[i]; @@ -421,7 +421,7 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(wanpipe_configure_span) } if (!(sp && ch)) { - zap_log(ZAP_LOG_ERROR, "No valid wanpipe span and channel was specified\n"); + ftdm_log(FTDM_LOG_ERROR, "No valid wanpipe span and channel was specified\n"); continue; } @@ -429,12 +429,12 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(wanpipe_configure_span) spanno = atoi(sp); if (channo < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid channel number %d\n", channo); + ftdm_log(FTDM_LOG_ERROR, "Invalid channel number %d\n", channo); continue; } if (spanno < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid span number %d\n", channo); + ftdm_log(FTDM_LOG_ERROR, "Invalid span number %d\n", channo); continue; } @@ -447,25 +447,25 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(wanpipe_configure_span) if (top < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid range number %d\n", top); + ftdm_log(FTDM_LOG_ERROR, "Invalid range number %d\n", top); continue; } - if (ZAP_CHAN_TYPE_CAS == type && zap_config_get_cas_bits(ch, &cas_bits)) { - zap_log(ZAP_LOG_ERROR, "Failed to get CAS bits in CAS channel\n"); + if (FTDM_CHAN_TYPE_CAS == type && ftdm_config_get_cas_bits(ch, &cas_bits)) { + ftdm_log(FTDM_LOG_ERROR, "Failed to get CAS bits in CAS channel\n"); continue; } configured += wp_open_range(span, spanno, channo, top, type, name, number, cas_bits); } - zap_safe_free(mydata); + ftdm_safe_free(mydata); return configured; } /** * \brief Opens Wanpipe channel - * \param zchan Channel to open + * \param ftdmchan Channel to open * \return Success or failure */ static ZIO_OPEN_FUNCTION(wanpipe_open) @@ -475,40 +475,40 @@ static ZIO_OPEN_FUNCTION(wanpipe_open) memset(&tdm_api,0,sizeof(tdm_api)); - if (zchan->type == ZAP_CHAN_TYPE_DQ921 || zchan->type == ZAP_CHAN_TYPE_DQ931) { - zchan->native_codec = zchan->effective_codec = ZAP_CODEC_NONE; + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921 || ftdmchan->type == FTDM_CHAN_TYPE_DQ931) { + ftdmchan->native_codec = ftdmchan->effective_codec = FTDM_CODEC_NONE; } else { - zchan->effective_codec = zchan->native_codec; + ftdmchan->effective_codec = ftdmchan->native_codec; - sangoma_tdm_set_usr_period(zchan->sockfd, &tdm_api, wp_globals.codec_ms); + sangoma_tdm_set_usr_period(ftdmchan->sockfd, &tdm_api, wp_globals.codec_ms); - zap_channel_set_feature(zchan, ZAP_CHANNEL_FEATURE_INTERVAL); - zchan->effective_interval = zchan->native_interval = wp_globals.codec_ms; - zchan->packet_len = zchan->native_interval * 8; + ftdm_channel_set_feature(ftdmchan, FTDM_CHANNEL_FEATURE_INTERVAL); + ftdmchan->effective_interval = ftdmchan->native_interval = wp_globals.codec_ms; + ftdmchan->packet_len = ftdmchan->native_interval * 8; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Closes Wanpipe channel - * \param zchan Channel to close + * \param ftdmchan Channel to close * \return Success */ static ZIO_CLOSE_FUNCTION(wanpipe_close) { #ifdef LIBSANGOMA_VERSION - sangoma_wait_obj_t *waitobj = zchan->mod_data; + sangoma_wait_obj_t *waitobj = ftdmchan->mod_data; /* kick any I/O waiters */ sangoma_wait_obj_signal(waitobj); #endif - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Executes an Openzap command on a Wanpipe channel - * \param zchan Channel to execute command on - * \param command Openzap command to execute + * \brief Executes an Openftdm command on a Wanpipe channel + * \param ftdmchan Channel to execute command on + * \param command Openftdm command to execute * \param obj Object (unused) * \return Success or failure */ @@ -520,110 +520,110 @@ static ZIO_COMMAND_FUNCTION(wanpipe_command) memset(&tdm_api, 0, sizeof(tdm_api)); switch(command) { - case ZAP_COMMAND_OFFHOOK: + case FTDM_COMMAND_OFFHOOK: { - err=sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api); + err=sangoma_tdm_txsig_offhook(ftdmchan->sockfd,&tdm_api); if (err) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "OFFHOOK Failed"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "OFFHOOK Failed"); + return FTDM_FAIL; } - zap_set_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK); } break; - case ZAP_COMMAND_ONHOOK: + case FTDM_COMMAND_ONHOOK: { - err=sangoma_tdm_txsig_onhook(zchan->sockfd,&tdm_api); + err=sangoma_tdm_txsig_onhook(ftdmchan->sockfd,&tdm_api); if (err) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "ONHOOK Failed"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "ONHOOK Failed"); + return FTDM_FAIL; } - zap_clear_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK); } break; - case ZAP_COMMAND_GENERATE_RING_ON: + case FTDM_COMMAND_GENERATE_RING_ON: { - err=sangoma_tdm_txsig_start(zchan->sockfd,&tdm_api); + err=sangoma_tdm_txsig_start(ftdmchan->sockfd,&tdm_api); if (err) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring Failed"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring Failed"); + return FTDM_FAIL; } - zap_set_flag_locked(zchan, ZAP_CHANNEL_RINGING); - zap_set_pflag_locked(zchan, WP_RINGING); - zchan->ring_time = zap_current_time_in_ms() + wp_globals.ring_on_ms; + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING); + ftdm_set_pflag_locked(ftdmchan, WP_RINGING); + ftdmchan->ring_time = ftdm_current_time_in_ms() + wp_globals.ring_on_ms; } break; - case ZAP_COMMAND_GENERATE_RING_OFF: + case FTDM_COMMAND_GENERATE_RING_OFF: { - err=sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api); + err=sangoma_tdm_txsig_offhook(ftdmchan->sockfd,&tdm_api); if (err) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring-off Failed"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring-off Failed"); + return FTDM_FAIL; } - zap_clear_pflag_locked(zchan, WP_RINGING); - zap_clear_flag_locked(zchan, ZAP_CHANNEL_RINGING); + ftdm_clear_pflag_locked(ftdmchan, WP_RINGING); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING); } break; - case ZAP_COMMAND_GET_INTERVAL: + case FTDM_COMMAND_GET_INTERVAL: { - err=sangoma_tdm_get_usr_period(zchan->sockfd, &tdm_api); + err=sangoma_tdm_get_usr_period(ftdmchan->sockfd, &tdm_api); if (err > 0 ) { - ZAP_COMMAND_OBJ_INT = err; + FTDM_COMMAND_OBJ_INT = err; err=0; } } break; - case ZAP_COMMAND_ENABLE_ECHOCANCEL: + case FTDM_COMMAND_ENABLE_ECHOCANCEL: { //code me } break; - case ZAP_COMMAND_DISABLE_ECHOCANCEL: + case FTDM_COMMAND_DISABLE_ECHOCANCEL: { //code me } break; - case ZAP_COMMAND_SET_INTERVAL: + case FTDM_COMMAND_SET_INTERVAL: { - err=sangoma_tdm_set_usr_period(zchan->sockfd, &tdm_api, ZAP_COMMAND_OBJ_INT); - zchan->packet_len = zchan->native_interval * (zchan->effective_codec == ZAP_CODEC_SLIN ? 16 : 8); + err=sangoma_tdm_set_usr_period(ftdmchan->sockfd, &tdm_api, FTDM_COMMAND_OBJ_INT); + ftdmchan->packet_len = ftdmchan->native_interval * (ftdmchan->effective_codec == FTDM_CODEC_SLIN ? 16 : 8); } break; - case ZAP_COMMAND_SET_CAS_BITS: + case FTDM_COMMAND_SET_CAS_BITS: { #ifdef LIBSANGOMA_VERSION - err = sangoma_tdm_write_rbs(zchan->sockfd,&tdm_api, zchan->physical_chan_id, wanpipe_swap_bits(ZAP_COMMAND_OBJ_INT)); + err = sangoma_tdm_write_rbs(ftdmchan->sockfd,&tdm_api, ftdmchan->physical_chan_id, wanpipe_swap_bits(FTDM_COMMAND_OBJ_INT)); #else - err = sangoma_tdm_write_rbs(zchan->sockfd, &tdm_api, wanpipe_swap_bits(ZAP_COMMAND_OBJ_INT)); + err = sangoma_tdm_write_rbs(ftdmchan->sockfd, &tdm_api, wanpipe_swap_bits(FTDM_COMMAND_OBJ_INT)); #endif } break; - case ZAP_COMMAND_GET_CAS_BITS: + case FTDM_COMMAND_GET_CAS_BITS: { #ifdef LIBSANGOMA_VERSION unsigned char rbsbits; - err = sangoma_tdm_read_rbs(zchan->sockfd, &tdm_api, zchan->physical_chan_id, &rbsbits); + err = sangoma_tdm_read_rbs(ftdmchan->sockfd, &tdm_api, ftdmchan->physical_chan_id, &rbsbits); if (!err) { - ZAP_COMMAND_OBJ_INT = wanpipe_swap_bits(rbsbits); + FTDM_COMMAND_OBJ_INT = wanpipe_swap_bits(rbsbits); } #else // does sangoma_tdm_read_rbs is available here? - ZAP_COMMAND_OBJ_INT = zchan->rx_cas_bits; + FTDM_COMMAND_OBJ_INT = ftdmchan->rx_cas_bits; #endif } break; - case ZAP_COMMAND_SET_LINK_STATUS: + case FTDM_COMMAND_SET_LINK_STATUS: { - zap_channel_hw_link_status_t status = ZAP_COMMAND_OBJ_INT; - char sangoma_status = status == ZAP_HW_LINK_CONNECTED ? FE_CONNECTED : FE_DISCONNECTED; - err = sangoma_tdm_set_fe_status(zchan->sockfd, &tdm_api, sangoma_status); + ftdm_channel_hw_link_status_t status = FTDM_COMMAND_OBJ_INT; + char sangoma_status = status == FTDM_HW_LINK_CONNECTED ? FE_CONNECTED : FE_DISCONNECTED; + err = sangoma_tdm_set_fe_status(ftdmchan->sockfd, &tdm_api, sangoma_status); } break; - case ZAP_COMMAND_GET_LINK_STATUS: + case FTDM_COMMAND_GET_LINK_STATUS: { unsigned char sangoma_status = 0; - err = sangoma_tdm_get_fe_status(zchan->sockfd, &tdm_api, &sangoma_status); + err = sangoma_tdm_get_fe_status(ftdmchan->sockfd, &tdm_api, &sangoma_status); if (!err) { - ZAP_COMMAND_OBJ_INT = sangoma_status == FE_CONNECTED ? ZAP_HW_LINK_CONNECTED : ZAP_HW_LINK_DISCONNECTED; + FTDM_COMMAND_OBJ_INT = sangoma_status == FE_CONNECTED ? FTDM_HW_LINK_CONNECTED : FTDM_HW_LINK_DISCONNECTED; } } break; @@ -632,17 +632,17 @@ static ZIO_COMMAND_FUNCTION(wanpipe_command) }; if (err) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + return FTDM_FAIL; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Reads data from a Wanpipe channel - * \param zchan Channel to read from + * \param ftdmchan Channel to read from * \param data Data buffer * \param datalen Size of data buffer * \return Success, failure or timeout @@ -654,25 +654,25 @@ static ZIO_READ_FUNCTION(wanpipe_read) memset(&hdrframe, 0, sizeof(hdrframe)); - rx_len = sangoma_readmsg_tdm(zchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (int)*datalen,0); + rx_len = sangoma_readmsg_tdm(ftdmchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (int)*datalen,0); *datalen = rx_len; if (rx_len == 0 || rx_len == -17) { - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; } if (rx_len < 0) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + return FTDM_FAIL; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Writes data to a Wanpipe channel - * \param zchan Channel to write to + * \param ftdmchan Channel to write to * \param data Data buffer * \param datalen Size of data buffer * \return Success or failure @@ -684,20 +684,20 @@ static ZIO_WRITE_FUNCTION(wanpipe_write) /* Do we even need the headerframe here? on windows, we don't even pass it to the driver */ memset(&hdrframe, 0, sizeof(hdrframe)); - bsent = sangoma_writemsg_tdm(zchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (unsigned short)(*datalen),0); + bsent = sangoma_writemsg_tdm(ftdmchan->sockfd, &hdrframe, (int)sizeof(hdrframe), data, (unsigned short)(*datalen),0); /* should we be checking if bsent == *datalen here? */ if (bsent > 0) { *datalen = bsent; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_FAIL; + return FTDM_FAIL; } /** * \brief Waits for an event on a Wanpipe channel - * \param zchan Channel to open + * \param ftdmchan Channel to open * \param flags Type of event to wait for * \param to Time to wait (in ms) * \return Success, failure or timeout @@ -708,44 +708,44 @@ static ZIO_WAIT_FUNCTION(wanpipe_wait) int32_t inflags = 0; int result; - if (*flags & ZAP_READ) { + if (*flags & FTDM_READ) { inflags |= POLLIN; } - if (*flags & ZAP_WRITE) { + if (*flags & FTDM_WRITE) { inflags |= POLLOUT; } - if (*flags & ZAP_EVENTS) { + if (*flags & FTDM_EVENTS) { inflags |= POLLPRI; } - result = tdmv_api_wait_socket(zchan, to, &inflags); + result = tdmv_api_wait_socket(ftdmchan, to, &inflags); - *flags = ZAP_NO_FLAGS; + *flags = FTDM_NO_FLAGS; if (result < 0){ - snprintf(zchan->last_error, sizeof(zchan->last_error), "Poll failed"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Poll failed"); + return FTDM_FAIL; } if (result == 0) { - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; } if (inflags & POLLIN) { - *flags |= ZAP_READ; + *flags |= FTDM_READ; } if (inflags & POLLOUT) { - *flags |= ZAP_WRITE; + *flags |= FTDM_WRITE; } if (inflags & POLLPRI) { - *flags |= ZAP_EVENTS; + *flags |= FTDM_EVENTS; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** @@ -758,22 +758,22 @@ ZIO_SPAN_POLL_EVENT_FUNCTION(wanpipe_poll_event) { #ifdef LIBSANGOMA_VERSION sangoma_status_t sangstatus; - sangoma_wait_obj_t *pfds[ZAP_MAX_CHANNELS_SPAN] = { 0 }; - uint32_t inflags[ZAP_MAX_CHANNELS_SPAN]; - uint32_t outflags[ZAP_MAX_CHANNELS_SPAN]; + sangoma_wait_obj_t *pfds[FTDM_MAX_CHANNELS_SPAN] = { 0 }; + uint32_t inflags[FTDM_MAX_CHANNELS_SPAN]; + uint32_t outflags[FTDM_MAX_CHANNELS_SPAN]; #else - struct pollfd pfds[ZAP_MAX_CHANNELS_SPAN]; + struct pollfd pfds[FTDM_MAX_CHANNELS_SPAN]; #endif uint32_t i, j = 0, k = 0, l = 0; int r; for(i = 1; i <= span->chan_count; i++) { - zap_channel_t *zchan = span->channels[i]; + ftdm_channel_t *ftdmchan = span->channels[i]; #ifdef LIBSANGOMA_VERSION - if (!zchan->mod_data) { + if (!ftdmchan->mod_data) { continue; /* should never happen but happens when shutting down */ } - pfds[j] = zchan->mod_data; + pfds[j] = ftdmchan->mod_data; inflags[j] = POLLPRI; #else memset(&pfds[j], 0, sizeof(pfds[j])); @@ -782,38 +782,38 @@ ZIO_SPAN_POLL_EVENT_FUNCTION(wanpipe_poll_event) #endif /* The driver probably should be able to do this wink/flash/ringing by itself this is sort of a hack to make it work! */ - if (zap_test_flag(zchan, ZAP_CHANNEL_WINK) || zap_test_flag(zchan, ZAP_CHANNEL_FLASH)) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_WINK) || ftdm_test_flag(ftdmchan, FTDM_CHANNEL_FLASH)) { l = 5; } j++; - if (zap_test_flag(zchan, ZAP_CHANNEL_RINGING)) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING)) { l = 5; } - if (zap_test_flag(zchan, ZAP_CHANNEL_RINGING) && zap_current_time_in_ms() >= zchan->ring_time) { + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING) && ftdm_current_time_in_ms() >= ftdmchan->ring_time) { wanpipe_tdm_api_t tdm_api; int err; memset(&tdm_api, 0, sizeof(tdm_api)); - if (zap_test_pflag(zchan, WP_RINGING)) { - err = sangoma_tdm_txsig_offhook(zchan->sockfd,&tdm_api); + if (ftdm_test_pflag(ftdmchan, WP_RINGING)) { + err = sangoma_tdm_txsig_offhook(ftdmchan->sockfd,&tdm_api); if (err) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring-off Failed"); - zap_log(ZAP_LOG_ERROR, "sangoma_tdm_txsig_offhook failed\n"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring-off Failed"); + ftdm_log(FTDM_LOG_ERROR, "sangoma_tdm_txsig_offhook failed\n"); + return FTDM_FAIL; } - zap_clear_pflag_locked(zchan, WP_RINGING); - zchan->ring_time = zap_current_time_in_ms() + wp_globals.ring_off_ms; + ftdm_clear_pflag_locked(ftdmchan, WP_RINGING); + ftdmchan->ring_time = ftdm_current_time_in_ms() + wp_globals.ring_off_ms; } else { - err=sangoma_tdm_txsig_start(zchan->sockfd,&tdm_api); + err=sangoma_tdm_txsig_start(ftdmchan->sockfd,&tdm_api); if (err) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring Failed"); - zap_log(ZAP_LOG_ERROR, "sangoma_tdm_txsig_start failed\n"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring Failed"); + ftdm_log(FTDM_LOG_ERROR, "sangoma_tdm_txsig_start failed\n"); + return FTDM_FAIL; } - zap_set_pflag_locked(zchan, WP_RINGING); - zchan->ring_time = zap_current_time_in_ms() + wp_globals.ring_on_ms; + ftdm_set_pflag_locked(ftdmchan, WP_RINGING); + ftdmchan->ring_time = ftdm_current_time_in_ms() + wp_globals.ring_on_ms; } } } @@ -828,7 +828,7 @@ ZIO_SPAN_POLL_EVENT_FUNCTION(wanpipe_poll_event) } else if (SANG_STATUS_SUCCESS == sangstatus) { r = 1; /* hopefully we never need how many changed -_- */ } else { - zap_log(ZAP_LOG_ERROR, "sangoma_waitfor_many failed: %d, %s\n", sangstatus, strerror(errno)); + ftdm_log(FTDM_LOG_ERROR, "sangoma_waitfor_many failed: %d, %s\n", sangstatus, strerror(errno)); r = -1; } #else @@ -836,32 +836,32 @@ ZIO_SPAN_POLL_EVENT_FUNCTION(wanpipe_poll_event) #endif if (r == 0) { - return l ? ZAP_SUCCESS : ZAP_TIMEOUT; + return l ? FTDM_SUCCESS : FTDM_TIMEOUT; } else if (r < 0) { snprintf(span->last_error, sizeof(span->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + return FTDM_FAIL; } for(i = 1; i <= span->chan_count; i++) { - zap_channel_t *zchan = span->channels[i]; + ftdm_channel_t *ftdmchan = span->channels[i]; #ifdef LIBSANGOMA_VERSION if (outflags[i-1] & POLLPRI) { #else if (pfds[i-1].revents & POLLPRI) { #endif - zap_set_flag(zchan, ZAP_CHANNEL_EVENT); - zchan->last_event_time = zap_current_time_in_ms(); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_EVENT); + ftdmchan->last_event_time = ftdm_current_time_in_ms(); k++; } } /* when k is 0 it might be that an async wanpipe device signal was delivered */ - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Gets alarms from a Wanpipe Channel - * \param zchan Channel to get alarms from + * \param ftdmchan Channel to get alarms from * \return Success or failure */ static ZIO_GET_ALARMS_FUNCTION(wanpipe_get_alarms) @@ -873,78 +873,78 @@ static ZIO_GET_ALARMS_FUNCTION(wanpipe_get_alarms) memset(&tdm_api,0,sizeof(tdm_api)); #ifdef LIBSANGOMA_VERSION - if ((err = sangoma_tdm_get_fe_alarms(zchan->sockfd, &tdm_api, &alarms))) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "ioctl failed (%s)", strerror(errno)); - snprintf(zchan->span->last_error, sizeof(zchan->span->last_error), "ioctl failed (%s)", strerror(errno)); - return ZAP_FAIL; + if ((err = sangoma_tdm_get_fe_alarms(ftdmchan->sockfd, &tdm_api, &alarms))) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "ioctl failed (%s)", strerror(errno)); + snprintf(ftdmchan->span->last_error, sizeof(ftdmchan->span->last_error), "ioctl failed (%s)", strerror(errno)); + return FTDM_FAIL; } #else - if ((err = sangoma_tdm_get_fe_alarms(zchan->sockfd, &tdm_api)) < 0){ - snprintf(zchan->last_error, sizeof(zchan->last_error), "ioctl failed (%s)", strerror(errno)); - snprintf(zchan->span->last_error, sizeof(zchan->span->last_error), "ioctl failed (%s)", strerror(errno)); - return ZAP_FAIL; + if ((err = sangoma_tdm_get_fe_alarms(ftdmchan->sockfd, &tdm_api)) < 0){ + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "ioctl failed (%s)", strerror(errno)); + snprintf(ftdmchan->span->last_error, sizeof(ftdmchan->span->last_error), "ioctl failed (%s)", strerror(errno)); + return FTDM_FAIL; } alarms = tdm_api.wp_tdm_cmd.fe_alarms; #endif - zchan->alarm_flags = alarms ? ZAP_ALARM_RED : ZAP_ALARM_NONE; + ftdmchan->alarm_flags = alarms ? FTDM_ALARM_RED : FTDM_ALARM_NONE; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Retrieves an event from a wanpipe span * \param span Span to retrieve event from - * \param event Openzap event to return + * \param event Openftdm event to return * \return Success or failure */ ZIO_SPAN_NEXT_EVENT_FUNCTION(wanpipe_next_event) { uint32_t i,err; - zap_oob_event_t event_id; + ftdm_oob_event_t event_id; for(i = 1; i <= span->chan_count; i++) { - if (span->channels[i]->last_event_time && !zap_test_flag(span->channels[i], ZAP_CHANNEL_EVENT)) { - uint32_t diff = (uint32_t)(zap_current_time_in_ms() - span->channels[i]->last_event_time); - /* XX printf("%u %u %u\n", diff, (unsigned)zap_current_time_in_ms(), (unsigned)span->channels[i]->last_event_time); */ - if (zap_test_flag(span->channels[i], ZAP_CHANNEL_WINK)) { + if (span->channels[i]->last_event_time && !ftdm_test_flag(span->channels[i], FTDM_CHANNEL_EVENT)) { + uint32_t diff = (uint32_t)(ftdm_current_time_in_ms() - span->channels[i]->last_event_time); + /* XX printf("%u %u %u\n", diff, (unsigned)ftdm_current_time_in_ms(), (unsigned)span->channels[i]->last_event_time); */ + if (ftdm_test_flag(span->channels[i], FTDM_CHANNEL_WINK)) { if (diff > wp_globals.wink_ms) { - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_WINK); - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_FLASH); - zap_set_flag_locked(span->channels[i], ZAP_CHANNEL_OFFHOOK); - event_id = ZAP_OOB_OFFHOOK; + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_WINK); + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_FLASH); + ftdm_set_flag_locked(span->channels[i], FTDM_CHANNEL_OFFHOOK); + event_id = FTDM_OOB_OFFHOOK; goto event; } } - if (zap_test_flag(span->channels[i], ZAP_CHANNEL_FLASH)) { + if (ftdm_test_flag(span->channels[i], FTDM_CHANNEL_FLASH)) { if (diff > wp_globals.flash_ms) { - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_FLASH); - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_WINK); - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_OFFHOOK); - event_id = ZAP_OOB_ONHOOK; + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_FLASH); + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_WINK); + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_OFFHOOK); + event_id = FTDM_OOB_ONHOOK; - if (span->channels[i]->type == ZAP_CHAN_TYPE_FXO) { - zap_channel_t *zchan = span->channels[i]; + if (span->channels[i]->type == FTDM_CHAN_TYPE_FXO) { + ftdm_channel_t *ftdmchan = span->channels[i]; wanpipe_tdm_api_t tdm_api; memset(&tdm_api, 0, sizeof(tdm_api)); - sangoma_tdm_txsig_onhook(zchan->sockfd,&tdm_api); + sangoma_tdm_txsig_onhook(ftdmchan->sockfd,&tdm_api); } goto event; } } } - if (zap_test_flag(span->channels[i], ZAP_CHANNEL_EVENT)) { + if (ftdm_test_flag(span->channels[i], FTDM_CHANNEL_EVENT)) { wanpipe_tdm_api_t tdm_api; - zap_channel_t *zchan = span->channels[i]; + ftdm_channel_t *ftdmchan = span->channels[i]; memset(&tdm_api, 0, sizeof(tdm_api)); - zap_clear_flag(span->channels[i], ZAP_CHANNEL_EVENT); + ftdm_clear_flag(span->channels[i], FTDM_CHANNEL_EVENT); - err = sangoma_tdm_read_event(zchan->sockfd, &tdm_api); - if (err != ZAP_SUCCESS) { + err = sangoma_tdm_read_event(ftdmchan->sockfd, &tdm_api); + if (err != FTDM_SUCCESS) { snprintf(span->last_error, sizeof(span->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + return FTDM_FAIL; } switch(tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type) { @@ -953,10 +953,10 @@ ZIO_SPAN_NEXT_EVENT_FUNCTION(wanpipe_next_event) { switch(tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_link_status) { case WP_TDMAPI_EVENT_LINK_STATUS_CONNECTED: - event_id = ZAP_OOB_ALARM_CLEAR; + event_id = FTDM_OOB_ALARM_CLEAR; break; default: - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; break; }; } @@ -964,80 +964,80 @@ ZIO_SPAN_NEXT_EVENT_FUNCTION(wanpipe_next_event) case WP_TDMAPI_EVENT_RXHOOK: { - if (span->channels[i]->type == ZAP_CHAN_TYPE_FXS) { - event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_hook_state & WP_TDMAPI_EVENT_RXHOOK_OFF ? ZAP_OOB_OFFHOOK : ZAP_OOB_ONHOOK; - if (event_id == ZAP_OOB_OFFHOOK) { - if (zap_test_flag(span->channels[i], ZAP_CHANNEL_FLASH)) { - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_FLASH); - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_WINK); - event_id = ZAP_OOB_FLASH; + if (span->channels[i]->type == FTDM_CHAN_TYPE_FXS) { + event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_hook_state & WP_TDMAPI_EVENT_RXHOOK_OFF ? FTDM_OOB_OFFHOOK : FTDM_OOB_ONHOOK; + if (event_id == FTDM_OOB_OFFHOOK) { + if (ftdm_test_flag(span->channels[i], FTDM_CHANNEL_FLASH)) { + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_FLASH); + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_WINK); + event_id = FTDM_OOB_FLASH; goto event; } else { - zap_set_flag_locked(span->channels[i], ZAP_CHANNEL_WINK); + ftdm_set_flag_locked(span->channels[i], FTDM_CHANNEL_WINK); } } else { - if (zap_test_flag(span->channels[i], ZAP_CHANNEL_WINK)) { - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_WINK); - zap_clear_flag_locked(span->channels[i], ZAP_CHANNEL_FLASH); - event_id = ZAP_OOB_WINK; + if (ftdm_test_flag(span->channels[i], FTDM_CHANNEL_WINK)) { + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_WINK); + ftdm_clear_flag_locked(span->channels[i], FTDM_CHANNEL_FLASH); + event_id = FTDM_OOB_WINK; goto event; } else { - zap_set_flag_locked(span->channels[i], ZAP_CHANNEL_FLASH); + ftdm_set_flag_locked(span->channels[i], FTDM_CHANNEL_FLASH); } } continue; } else { int err; - zap_channel_t *zchan = span->channels[i]; - err=sangoma_tdm_txsig_onhook(zchan->sockfd,&tdm_api); + ftdm_channel_t *ftdmchan = span->channels[i]; + err=sangoma_tdm_txsig_onhook(ftdmchan->sockfd,&tdm_api); if (err) { snprintf(span->channels[i]->last_error, sizeof(span->channels[i]->last_error), "ONHOOK Failed"); - return ZAP_FAIL; + return FTDM_FAIL; } - event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_hook_state & WP_TDMAPI_EVENT_RXHOOK_OFF ? ZAP_OOB_ONHOOK : ZAP_OOB_NOOP; + event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_hook_state & WP_TDMAPI_EVENT_RXHOOK_OFF ? FTDM_OOB_ONHOOK : FTDM_OOB_NOOP; } } break; case WP_TDMAPI_EVENT_RING_DETECT: { - event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_ring_state == WP_TDMAPI_EVENT_RING_PRESENT ? ZAP_OOB_RING_START : ZAP_OOB_RING_STOP; + event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_ring_state == WP_TDMAPI_EVENT_RING_PRESENT ? FTDM_OOB_RING_START : FTDM_OOB_RING_STOP; } break; case WP_TDMAPI_EVENT_RING_TRIP_DETECT: { - event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_ring_state == WP_TDMAPI_EVENT_RING_PRESENT ? ZAP_OOB_ONHOOK : ZAP_OOB_OFFHOOK; + event_id = tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_ring_state == WP_TDMAPI_EVENT_RING_PRESENT ? FTDM_OOB_ONHOOK : FTDM_OOB_OFFHOOK; } break; case WP_TDMAPI_EVENT_RBS: { - event_id = ZAP_OOB_CAS_BITS_CHANGE; + event_id = FTDM_OOB_CAS_BITS_CHANGE; span->channels[i]->rx_cas_bits = wanpipe_swap_bits(tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_rbs_bits); } break; case WP_TDMAPI_EVENT_DTMF: { char tmp_dtmf[2] = { tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_dtmf_digit, 0 }; - event_id = ZAP_OOB_NOOP; + event_id = FTDM_OOB_NOOP; if (tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_dtmf_type == WAN_EC_TONE_PRESENT) { - zap_set_flag_locked(zchan, ZAP_CHANNEL_MUTE); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_MUTE); } if (tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_dtmf_type == WAN_EC_TONE_STOP) { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_MUTE); - zap_channel_queue_dtmf(zchan, tmp_dtmf); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_MUTE); + ftdm_channel_queue_dtmf(ftdmchan, tmp_dtmf); } } break; case WP_TDMAPI_EVENT_ALARM: { - event_id = ZAP_OOB_NOOP; + event_id = FTDM_OOB_NOOP; } break; default: { - zap_log(ZAP_LOG_WARNING, "Unhandled event %d\n", tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type); - event_id = ZAP_OOB_INVALID; + ftdm_log(FTDM_LOG_WARNING, "Unhandled event %d\n", tdm_api.wp_tdm_cmd.event.wp_tdm_api_event_type); + event_id = FTDM_OOB_INVALID; } break; } @@ -1045,45 +1045,45 @@ ZIO_SPAN_NEXT_EVENT_FUNCTION(wanpipe_next_event) event: span->channels[i]->last_event_time = 0; - span->event_header.e_type = ZAP_EVENT_OOB; + span->event_header.e_type = FTDM_EVENT_OOB; span->event_header.enum_id = event_id; span->event_header.channel = span->channels[i]; *event = &span->event_header; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } } - return ZAP_FAIL; + return FTDM_FAIL; } /** * \brief Destroys a Wanpipe Channel - * \param zchan Channel to destroy + * \param ftdmchan Channel to destroy * \return Success */ static ZIO_CHANNEL_DESTROY_FUNCTION(wanpipe_channel_destroy) { #ifdef LIBSANGOMA_VERSION - if (zchan->mod_data) { + if (ftdmchan->mod_data) { sangoma_wait_obj_t *sangoma_wait_obj; - sangoma_wait_obj = zchan->mod_data; - zchan->mod_data = NULL; + sangoma_wait_obj = ftdmchan->mod_data; + ftdmchan->mod_data = NULL; sangoma_wait_obj_delete(&sangoma_wait_obj); } #endif - if (zchan->sockfd > -1) { - close(zchan->sockfd); - zchan->sockfd = WP_INVALID_SOCKET; + if (ftdmchan->sockfd > -1) { + close(ftdmchan->sockfd); + ftdmchan->sockfd = WP_INVALID_SOCKET; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** * \brief Loads wanpipe IO module - * \param zio Openzap IO interface + * \param zio Openftdm IO interface * \return Success */ static ZIO_IO_LOAD_FUNCTION(wanpipe_init) @@ -1111,7 +1111,7 @@ static ZIO_IO_LOAD_FUNCTION(wanpipe_init) wanpipe_interface.get_alarms = wanpipe_get_alarms; *zio = &wanpipe_interface; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** @@ -1121,13 +1121,13 @@ static ZIO_IO_LOAD_FUNCTION(wanpipe_init) static ZIO_IO_UNLOAD_FUNCTION(wanpipe_destroy) { memset(&wanpipe_interface, 0, sizeof(wanpipe_interface)); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Openzap wanpipe IO module definition + * \brief Openftdm wanpipe IO module definition */ -EX_DECLARE_DATA zap_module_t zap_module = { +EX_DECLARE_DATA ftdm_module_t ftdm_module = { "wanpipe", wanpipe_init, wanpipe_destroy, diff --git a/libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.2005.vcproj b/libs/freetdm/src/ftmod/ftmod_wanpipe/ozmod_wanpipe.2005.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.2005.vcproj rename to libs/freetdm/src/ftmod/ftmod_wanpipe/ozmod_wanpipe.2005.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.2008.vcproj b/libs/freetdm/src/ftmod/ftmod_wanpipe/ozmod_wanpipe.2008.vcproj similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_wanpipe/ozmod_wanpipe.2008.vcproj rename to libs/freetdm/src/ftmod/ftmod_wanpipe/ozmod_wanpipe.2008.vcproj diff --git a/libs/freetdm/src/ozmod/ozmod_wanpipe/wanpipe_tdm_api_iface.h b/libs/freetdm/src/ftmod/ftmod_wanpipe/wanpipe_tdm_api_iface.h similarity index 100% rename from libs/freetdm/src/ozmod/ozmod_wanpipe/wanpipe_tdm_api_iface.h rename to libs/freetdm/src/ftmod/ftmod_wanpipe/wanpipe_tdm_api_iface.h diff --git a/libs/freetdm/src/ozmod/ozmod_zt/ozmod_zt.c b/libs/freetdm/src/ftmod/ftmod_zt/ftmod_zt.c similarity index 52% rename from libs/freetdm/src/ozmod/ozmod_zt/ozmod_zt.c rename to libs/freetdm/src/ftmod/ftmod_zt/ftmod_zt.c index 4815fbec51..46881519cc 100644 --- a/libs/freetdm/src/ozmod/ozmod_zt/ozmod_zt.c +++ b/libs/freetdm/src/ftmod/ftmod_zt/ftmod_zt.c @@ -32,8 +32,8 @@ */ -#include "openzap.h" -#include "ozmod_zt.h" +#include "freetdm.h" +#include "ftmod_zt.h" /** * \brief Zaptel globals @@ -170,10 +170,10 @@ static const char *chanpath = NULL; static const char dahdi_ctlpath[] = "/dev/dahdi/ctl"; static const char dahdi_chanpath[] = "/dev/dahdi/channel"; -static const char zt_ctlpath[] = "/dev/zap/ctl"; -static const char zt_chanpath[] = "/dev/zap/channel"; +static const char zt_ctlpath[] = "/dev/ftdm/ctl"; +static const char zt_chanpath[] = "/dev/ftdm/channel"; -static zap_socket_t CONTROL_FD = ZT_INVALID_SOCKET; +static ftdm_socket_t CONTROL_FD = ZT_INVALID_SOCKET; ZIO_SPAN_NEXT_EVENT_FUNCTION(zt_next_event); ZIO_SPAN_POLL_EVENT_FUNCTION(zt_poll_event); @@ -193,7 +193,7 @@ static void zt_build_gains(struct zt_gains *g, float rxgain, float txgain, int c float linear_txgain = pow(10.0, txgain / 20.0); switch (codec) { - case ZAP_CODEC_ALAW: + case FTDM_CODEC_ALAW: for (j = 0; j < (sizeof(g->receive_gain) / sizeof(g->receive_gain[0])); j++) { if (rxgain) { k = (int) (((float) alaw_to_linear(j)) * linear_rxgain); @@ -213,7 +213,7 @@ static void zt_build_gains(struct zt_gains *g, float rxgain, float txgain, int c } } break; - case ZAP_CODEC_ULAW: + case FTDM_CODEC_ULAW: for (j = 0; j < (sizeof(g->receive_gain) / sizeof(g->receive_gain[0])); j++) { if (rxgain) { k = (int) (((float) ulaw_to_linear(j)) * linear_rxgain); @@ -237,41 +237,41 @@ static void zt_build_gains(struct zt_gains *g, float rxgain, float txgain, int c } /** - * \brief Initialises a range of zaptel channels - * \param span Openzap span + * \brief Initialises a range of ftdmtel channels + * \param span Openftdm span * \param start Initial wanpipe channel number * \param end Final wanpipe channel number - * \param type Openzap channel type - * \param name Openzap span name - * \param number Openzap span number + * \param type Openftdm channel type + * \param name Openftdm span name + * \param number Openftdm span number * \param cas_bits CAS bits * \return number of spans configured */ -static unsigned zt_open_range(zap_span_t *span, unsigned start, unsigned end, zap_chan_type_t type, char *name, char *number, unsigned char cas_bits) +static unsigned zt_open_range(ftdm_span_t *span, unsigned start, unsigned end, ftdm_chan_type_t type, char *name, char *number, unsigned char cas_bits) { unsigned configured = 0, x; zt_params_t ztp; memset(&ztp, 0, sizeof(ztp)); - if (type == ZAP_CHAN_TYPE_CAS) { - zap_log(ZAP_LOG_DEBUG, "Configuring CAS channels with abcd == 0x%X\n", cas_bits); + if (type == FTDM_CHAN_TYPE_CAS) { + ftdm_log(FTDM_LOG_DEBUG, "Configuring CAS channels with abcd == 0x%X\n", cas_bits); } for(x = start; x < end; x++) { - zap_channel_t *zchan; - zap_socket_t sockfd = ZT_INVALID_SOCKET; + ftdm_channel_t *ftdmchan; + ftdm_socket_t sockfd = ZT_INVALID_SOCKET; int len; sockfd = open(chanpath, O_RDWR); - if (sockfd != ZT_INVALID_SOCKET && zap_span_add_channel(span, sockfd, type, &zchan) == ZAP_SUCCESS) { + if (sockfd != ZT_INVALID_SOCKET && ftdm_span_add_channel(span, sockfd, type, &ftdmchan) == FTDM_SUCCESS) { if (ioctl(sockfd, codes.SPECIFY, &x)) { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s chan %d fd %d (%s)\n", chanpath, x, sockfd, strerror(errno)); + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s chan %d fd %d (%s)\n", chanpath, x, sockfd, strerror(errno)); close(sockfd); continue; } - if (zchan->type == ZAP_CHAN_TYPE_DQ921) { + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921) { struct zt_bufferinfo binfo; memset(&binfo, 0, sizeof(binfo)); binfo.txbufpolicy = 0; @@ -279,28 +279,28 @@ static unsigned zt_open_range(zap_span_t *span, unsigned start, unsigned end, za binfo.numbufs = 32; binfo.bufsize = 1024; if (ioctl(sockfd, codes.SET_BUFINFO, &binfo)) { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s as OpenZAP device %d:%d fd:%d\n", chanpath, zchan->span_id, zchan->chan_id, sockfd); + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s as OpenFTDM device %d:%d fd:%d\n", chanpath, ftdmchan->span_id, ftdmchan->chan_id, sockfd); close(sockfd); continue; } } - if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO) { + if (type == FTDM_CHAN_TYPE_FXS || type == FTDM_CHAN_TYPE_FXO) { struct zt_chanconfig cc; memset(&cc, 0, sizeof(cc)); cc.chan = cc.master = x; switch(type) { - case ZAP_CHAN_TYPE_FXS: + case FTDM_CHAN_TYPE_FXS: { switch(span->start_type) { - case ZAP_ANALOG_START_KEWL: + case FTDM_ANALOG_START_KEWL: cc.sigtype = ZT_SIG_FXOKS; break; - case ZAP_ANALOG_START_LOOP: + case FTDM_ANALOG_START_LOOP: cc.sigtype = ZT_SIG_FXOLS; break; - case ZAP_ANALOG_START_GROUND: + case FTDM_ANALOG_START_GROUND: cc.sigtype = ZT_SIG_FXOGS; break; default: @@ -308,16 +308,16 @@ static unsigned zt_open_range(zap_span_t *span, unsigned start, unsigned end, za } } break; - case ZAP_CHAN_TYPE_FXO: + case FTDM_CHAN_TYPE_FXO: { switch(span->start_type) { - case ZAP_ANALOG_START_KEWL: + case FTDM_ANALOG_START_KEWL: cc.sigtype = ZT_SIG_FXSKS; break; - case ZAP_ANALOG_START_LOOP: + case FTDM_ANALOG_START_LOOP: cc.sigtype = ZT_SIG_FXSLS; break; - case ZAP_ANALOG_START_GROUND: + case FTDM_ANALOG_START_GROUND: cc.sigtype = ZT_SIG_FXSGS; break; default: @@ -330,79 +330,79 @@ static unsigned zt_open_range(zap_span_t *span, unsigned start, unsigned end, za } if (ioctl(CONTROL_FD, codes.CHANCONFIG, &cc)) { - zap_log(ZAP_LOG_WARNING, "this ioctl fails on older zaptel but is harmless if you used ztcfg\n[device %s chan %d fd %d (%s)]\n", chanpath, x, CONTROL_FD, strerror(errno)); + ftdm_log(FTDM_LOG_WARNING, "this ioctl fails on older ftdmtel but is harmless if you used ztcfg\n[device %s chan %d fd %d (%s)]\n", chanpath, x, CONTROL_FD, strerror(errno)); } } - if (type == ZAP_CHAN_TYPE_CAS) { + if (type == FTDM_CHAN_TYPE_CAS) { struct zt_chanconfig cc; memset(&cc, 0, sizeof(cc)); cc.chan = cc.master = x; cc.sigtype = ZT_SIG_CAS; cc.idlebits = cas_bits; if (ioctl(CONTROL_FD, codes.CHANCONFIG, &cc)) { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s as OpenZAP device %d:%d fd:%d err:%s", chanpath, zchan->span_id, zchan->chan_id, sockfd, strerror(errno)); + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s as OpenFTDM device %d:%d fd:%d err:%s", chanpath, ftdmchan->span_id, ftdmchan->chan_id, sockfd, strerror(errno)); close(sockfd); continue; } } - if (zchan->type != ZAP_CHAN_TYPE_DQ921 && zchan->type != ZAP_CHAN_TYPE_DQ931) { + if (ftdmchan->type != FTDM_CHAN_TYPE_DQ921 && ftdmchan->type != FTDM_CHAN_TYPE_DQ931) { len = zt_globals.codec_ms * 8; - if (ioctl(zchan->sockfd, codes.SET_BLOCKSIZE, &len)) { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s as OpenZAP device %d:%d fd:%d err:%s\n", - chanpath, zchan->span_id, zchan->chan_id, sockfd, strerror(errno)); + if (ioctl(ftdmchan->sockfd, codes.SET_BLOCKSIZE, &len)) { + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s as OpenFTDM device %d:%d fd:%d err:%s\n", + chanpath, ftdmchan->span_id, ftdmchan->chan_id, sockfd, strerror(errno)); close(sockfd); continue; } - zchan->packet_len = len; - zchan->effective_interval = zchan->native_interval = zchan->packet_len / 8; + ftdmchan->packet_len = len; + ftdmchan->effective_interval = ftdmchan->native_interval = ftdmchan->packet_len / 8; - if (zchan->effective_codec == ZAP_CODEC_SLIN) { - zchan->packet_len *= 2; + if (ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + ftdmchan->packet_len *= 2; } } if (ioctl(sockfd, codes.GET_PARAMS, &ztp) < 0) { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s as OpenZAP device %d:%d fd:%d\n", chanpath, zchan->span_id, zchan->chan_id, sockfd); + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s as OpenFTDM device %d:%d fd:%d\n", chanpath, ftdmchan->span_id, ftdmchan->chan_id, sockfd); close(sockfd); continue; } - if (zchan->type == ZAP_CHAN_TYPE_DQ921) { + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921) { if ( (ztp.sig_type != ZT_SIG_HDLCRAW) && (ztp.sig_type != ZT_SIG_HDLCFCS) && (ztp.sig_type != ZT_SIG_HARDHDLC) ) { - zap_log(ZAP_LOG_ERROR, "Failure configuring device %s as OpenZAP device %d:%d fd:%d, hardware signaling is not HDLC, fix your Zap/DAHDI configuration!\n", chanpath, zchan->span_id, zchan->chan_id, sockfd); + ftdm_log(FTDM_LOG_ERROR, "Failure configuring device %s as OpenFTDM device %d:%d fd:%d, hardware signaling is not HDLC, fix your Zap/DAHDI configuration!\n", chanpath, ftdmchan->span_id, ftdmchan->chan_id, sockfd); close(sockfd); continue; } } - zap_log(ZAP_LOG_INFO, "configuring device %s channel %d as OpenZAP device %d:%d fd:%d\n", chanpath, x, zchan->span_id, zchan->chan_id, sockfd); + ftdm_log(FTDM_LOG_INFO, "configuring device %s channel %d as OpenFTDM device %d:%d fd:%d\n", chanpath, x, ftdmchan->span_id, ftdmchan->chan_id, sockfd); - zchan->rate = 8000; - zchan->physical_span_id = ztp.span_no; - zchan->physical_chan_id = ztp.chan_no; + ftdmchan->rate = 8000; + ftdmchan->physical_span_id = ztp.span_no; + ftdmchan->physical_chan_id = ztp.chan_no; - if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO || type == ZAP_CHAN_TYPE_EM || type == ZAP_CHAN_TYPE_B) { + if (type == FTDM_CHAN_TYPE_FXS || type == FTDM_CHAN_TYPE_FXO || type == FTDM_CHAN_TYPE_EM || type == FTDM_CHAN_TYPE_B) { if (ztp.g711_type == ZT_G711_ALAW) { - zchan->native_codec = zchan->effective_codec = ZAP_CODEC_ALAW; + ftdmchan->native_codec = ftdmchan->effective_codec = FTDM_CODEC_ALAW; } else if (ztp.g711_type == ZT_G711_MULAW) { - zchan->native_codec = zchan->effective_codec = ZAP_CODEC_ULAW; + ftdmchan->native_codec = ftdmchan->effective_codec = FTDM_CODEC_ULAW; } else { int type; - if (zchan->span->trunk_type == ZAP_TRUNK_E1) { - type = ZAP_CODEC_ALAW; + if (ftdmchan->span->trunk_type == FTDM_TRUNK_E1) { + type = FTDM_CODEC_ALAW; } else { - type = ZAP_CODEC_ULAW; + type = FTDM_CODEC_ULAW; } - zchan->native_codec = zchan->effective_codec = type; + ftdmchan->native_codec = ftdmchan->effective_codec = type; } } @@ -411,20 +411,20 @@ static unsigned zt_open_range(zap_span_t *span, unsigned start, unsigned end, za ztp.flash_time = zt_globals.flash_ms; if (ioctl(sockfd, codes.SET_PARAMS, &ztp) < 0) { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s as OpenZAP device %d:%d fd:%d\n", chanpath, zchan->span_id, zchan->chan_id, sockfd); + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s as OpenFTDM device %d:%d fd:%d\n", chanpath, ftdmchan->span_id, ftdmchan->chan_id, sockfd); close(sockfd); continue; } - if (!zap_strlen_zero(name)) { - zap_copy_string(zchan->chan_name, name, sizeof(zchan->chan_name)); + if (!ftdm_strlen_zero(name)) { + ftdm_copy_string(ftdmchan->chan_name, name, sizeof(ftdmchan->chan_name)); } - if (!zap_strlen_zero(number)) { - zap_copy_string(zchan->chan_number, number, sizeof(zchan->chan_number)); + if (!ftdm_strlen_zero(number)) { + ftdm_copy_string(ftdmchan->chan_number, number, sizeof(ftdmchan->chan_number)); } configured++; } else { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s\n", chanpath); + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s\n", chanpath); } } @@ -434,12 +434,12 @@ static unsigned zt_open_range(zap_span_t *span, unsigned start, unsigned end, za } /** - * \brief Initialises an openzap zaptel span from a configuration string - * \param span Openzap span + * \brief Initialises an freetdm ftdmtel span from a configuration string + * \param span Openftdm span * \param str Configuration string - * \param type Openzap span type - * \param name Openzap span name - * \param number Openzap span number + * \param type Openftdm span type + * \param name Openftdm span name + * \param number Openftdm span number * \return Success or failure */ static ZIO_CONFIGURE_SPAN_FUNCTION(zt_configure_span) @@ -456,24 +456,24 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(zt_configure_span) assert(str != NULL); - mydata = zap_strdup(str); + mydata = ftdm_strdup(str); assert(mydata != NULL); - items = zap_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); + items = ftdm_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); for(i = 0; i < items; i++) { ch = item_list[i]; if (!(ch)) { - zap_log(ZAP_LOG_ERROR, "Invalid input\n"); + ftdm_log(FTDM_LOG_ERROR, "Invalid input\n"); continue; } channo = atoi(ch); if (channo < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid channel number %d\n", channo); + ftdm_log(FTDM_LOG_ERROR, "Invalid channel number %d\n", channo); continue; } @@ -486,25 +486,25 @@ static ZIO_CONFIGURE_SPAN_FUNCTION(zt_configure_span) if (top < 0) { - zap_log(ZAP_LOG_ERROR, "Invalid range number %d\n", top); + ftdm_log(FTDM_LOG_ERROR, "Invalid range number %d\n", top); continue; } - if (ZAP_CHAN_TYPE_CAS == type && zap_config_get_cas_bits(ch, &cas_bits)) { - zap_log(ZAP_LOG_ERROR, "Failed to get CAS bits in CAS channel\n"); + if (FTDM_CHAN_TYPE_CAS == type && ftdm_config_get_cas_bits(ch, &cas_bits)) { + ftdm_log(FTDM_LOG_ERROR, "Failed to get CAS bits in CAS channel\n"); continue; } configured += zt_open_range(span, channo, top, type, name, number, cas_bits); } - zap_safe_free(mydata); + ftdm_safe_free(mydata); return configured; } /** - * \brief Process configuration variable for a zaptel profile + * \brief Process configuration variable for a ftdmtel profile * \param category Wanpipe profile name * \param var Variable name * \param val Variable value @@ -521,28 +521,28 @@ static ZIO_CONFIGURE_FUNCTION(zt_configure) if (!strcasecmp(var, "codec_ms")) { num = atoi(val); if (num < 10 || num > 60) { - zap_log(ZAP_LOG_WARNING, "invalid codec ms at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid codec ms at line %d\n", lineno); } else { zt_globals.codec_ms = num; } } else if (!strcasecmp(var, "wink_ms")) { num = atoi(val); if (num < 50 || num > 3000) { - zap_log(ZAP_LOG_WARNING, "invalid wink ms at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid wink ms at line %d\n", lineno); } else { zt_globals.wink_ms = num; } } else if (!strcasecmp(var, "flash_ms")) { num = atoi(val); if (num < 50 || num > 3000) { - zap_log(ZAP_LOG_WARNING, "invalid flash ms at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid flash ms at line %d\n", lineno); } else { zt_globals.flash_ms = num; } } else if (!strcasecmp(var, "echo_cancel_level")) { num = atoi(val); if (num < 0 || num > 256) { - zap_log(ZAP_LOG_WARNING, "invalid echo can val at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid echo can val at line %d\n", lineno); } else { zt_globals.eclevel = num; } @@ -550,71 +550,71 @@ static ZIO_CONFIGURE_FUNCTION(zt_configure) } else if (!strcasecmp(var, "rxgain")) { fnum = (float)atof(val); if (fnum < -100.0 || fnum > 100.0) { - zap_log(ZAP_LOG_WARNING, "invalid rxgain val at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid rxgain val at line %d\n", lineno); } else { zt_globals.rxgain = fnum; - zap_log(ZAP_LOG_INFO, "Setting rxgain val to %f\n", fnum); + ftdm_log(FTDM_LOG_INFO, "Setting rxgain val to %f\n", fnum); } } else if (!strcasecmp(var, "txgain")) { fnum = (float)atof(val); if (fnum < -100.0 || fnum > 100.0) { - zap_log(ZAP_LOG_WARNING, "invalid txgain val at line %d\n", lineno); + ftdm_log(FTDM_LOG_WARNING, "invalid txgain val at line %d\n", lineno); } else { zt_globals.txgain = fnum; - zap_log(ZAP_LOG_INFO, "Setting txgain val to %f\n", fnum); + ftdm_log(FTDM_LOG_INFO, "Setting txgain val to %f\n", fnum); } } } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Opens a zaptel channel - * \param zchan Channel to open + * \brief Opens a ftdmtel channel + * \param ftdmchan Channel to open * \return Success or failure */ static ZIO_OPEN_FUNCTION(zt_open) { - zap_channel_set_feature(zchan, ZAP_CHANNEL_FEATURE_INTERVAL); + ftdm_channel_set_feature(ftdmchan, FTDM_CHANNEL_FEATURE_INTERVAL); - if (zchan->type == ZAP_CHAN_TYPE_DQ921 || zchan->type == ZAP_CHAN_TYPE_DQ931) { - zchan->native_codec = zchan->effective_codec = ZAP_CODEC_NONE; + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921 || ftdmchan->type == FTDM_CHAN_TYPE_DQ931) { + ftdmchan->native_codec = ftdmchan->effective_codec = FTDM_CODEC_NONE; } else { - int blocksize = zt_globals.codec_ms * (zchan->rate / 1000); + int blocksize = zt_globals.codec_ms * (ftdmchan->rate / 1000); int err; - if ((err = ioctl(zchan->sockfd, codes.SET_BLOCKSIZE, &blocksize))) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + if ((err = ioctl(ftdmchan->sockfd, codes.SET_BLOCKSIZE, &blocksize))) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + return FTDM_FAIL; } else { - zchan->effective_interval = zchan->native_interval; - zchan->packet_len = blocksize; - zchan->native_codec = zchan->effective_codec; + ftdmchan->effective_interval = ftdmchan->native_interval; + ftdmchan->packet_len = blocksize; + ftdmchan->native_codec = ftdmchan->effective_codec; } - if (zchan->type == ZAP_CHAN_TYPE_B) { + if (ftdmchan->type == FTDM_CHAN_TYPE_B) { int one = 1; - if (ioctl(zchan->sockfd, codes.AUDIOMODE, &one)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - zap_log(ZAP_LOG_ERROR, "%s\n", zchan->last_error); - return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.AUDIOMODE, &one)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + ftdm_log(FTDM_LOG_ERROR, "%s\n", ftdmchan->last_error); + return FTDM_FAIL; } - } else if (zchan->type == ZAP_CHAN_TYPE_FXS || zchan->type == ZAP_CHAN_TYPE_FXO || zchan->type == ZAP_CHAN_TYPE_EM) { + } else if (ftdmchan->type == FTDM_CHAN_TYPE_FXS || ftdmchan->type == FTDM_CHAN_TYPE_FXO || ftdmchan->type == FTDM_CHAN_TYPE_EM) { int len = zt_globals.eclevel; - if (ioctl(zchan->sockfd, codes.ECHOCANCEL, &len)) { - zap_log(ZAP_LOG_WARNING, "Echo cancel not available for %d:%d\n", zchan->span_id, zchan->chan_id); - //snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - //zap_log(ZAP_LOG_ERROR, "%s\n", zchan->last_error); - //return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.ECHOCANCEL, &len)) { + ftdm_log(FTDM_LOG_WARNING, "Echo cancel not available for %d:%d\n", ftdmchan->span_id, ftdmchan->chan_id); + //snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + //ftdm_log(FTDM_LOG_ERROR, "%s\n", ftdmchan->last_error); + //return FTDM_FAIL; } else { len = zt_globals.etlevel; - if (ioctl(zchan->sockfd, codes.ECHOTRAIN, &len)) { - zap_log(ZAP_LOG_WARNING, "Echo training not available for %d:%d\n", zchan->span_id, zchan->chan_id); - //snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - //zap_log(ZAP_LOG_ERROR, "%s\n", zchan->last_error); - //return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.ECHOTRAIN, &len)) { + ftdm_log(FTDM_LOG_WARNING, "Echo training not available for %d:%d\n", ftdmchan->span_id, ftdmchan->chan_id); + //snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + //ftdm_log(FTDM_LOG_ERROR, "%s\n", ftdmchan->last_error); + //return FTDM_FAIL; } } } @@ -622,49 +622,49 @@ static ZIO_OPEN_FUNCTION(zt_open) struct zt_gains gains; memset(&gains, 0, sizeof(gains)); - gains.chan_no = zchan->physical_chan_id; - zt_build_gains(&gains, zt_globals.rxgain, zt_globals.txgain, zchan->native_codec); + gains.chan_no = ftdmchan->physical_chan_id; + zt_build_gains(&gains, zt_globals.rxgain, zt_globals.txgain, ftdmchan->native_codec); if(zt_globals.rxgain) - zap_log(ZAP_LOG_INFO, "Setting rxgain to %f on channel %d\n", zt_globals.rxgain, gains.chan_no); + ftdm_log(FTDM_LOG_INFO, "Setting rxgain to %f on channel %d\n", zt_globals.rxgain, gains.chan_no); if(zt_globals.txgain) - zap_log(ZAP_LOG_INFO, "Setting txgain to %f on channel %d\n", zt_globals.txgain, gains.chan_no); + ftdm_log(FTDM_LOG_INFO, "Setting txgain to %f on channel %d\n", zt_globals.txgain, gains.chan_no); - if (ioctl(zchan->sockfd, codes.SETGAINS, &gains) < 0) { - zap_log(ZAP_LOG_ERROR, "failure configuring device %s as OpenZAP device %d:%d fd:%d\n", chanpath, zchan->span_id, zchan->chan_id, zchan->sockfd); + if (ioctl(ftdmchan->sockfd, codes.SETGAINS, &gains) < 0) { + ftdm_log(FTDM_LOG_ERROR, "failure configuring device %s as OpenFTDM device %d:%d fd:%d\n", chanpath, ftdmchan->span_id, ftdmchan->chan_id, ftdmchan->sockfd); } } int len = zt_globals.eclevel; - zap_log(ZAP_LOG_INFO, "Setting echo cancel to %d taps for %d:%d\n", len, zchan->span_id, zchan->chan_id); - if (ioctl(zchan->sockfd, codes.ECHOCANCEL, &len)) { - zap_log(ZAP_LOG_WARNING, "Echo cancel not available for %d:%d\n", zchan->span_id, zchan->chan_id); + ftdm_log(FTDM_LOG_INFO, "Setting echo cancel to %d taps for %d:%d\n", len, ftdmchan->span_id, ftdmchan->chan_id); + if (ioctl(ftdmchan->sockfd, codes.ECHOCANCEL, &len)) { + ftdm_log(FTDM_LOG_WARNING, "Echo cancel not available for %d:%d\n", ftdmchan->span_id, ftdmchan->chan_id); } else { len = zt_globals.etlevel; - if (ioctl(zchan->sockfd, codes.ECHOTRAIN, &len)) { - zap_log(ZAP_LOG_WARNING, "Echo training not available for %d:%d\n", zchan->span_id, zchan->chan_id); + if (ioctl(ftdmchan->sockfd, codes.ECHOTRAIN, &len)) { + ftdm_log(FTDM_LOG_WARNING, "Echo training not available for %d:%d\n", ftdmchan->span_id, ftdmchan->chan_id); } } } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Closes zaptel channel - * \param zchan Channel to close + * \brief Closes ftdmtel channel + * \param ftdmchan Channel to close * \return Success */ static ZIO_CLOSE_FUNCTION(zt_close) { - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Executes an Openzap command on a zaptel channel - * \param zchan Channel to execute command on - * \param command Openzap command to execute + * \brief Executes an Openftdm command on a ftdmtel channel + * \param ftdmchan Channel to execute command on + * \param command Openftdm command to execute * \param obj Object (unused) * \return Success or failure */ @@ -676,166 +676,166 @@ static ZIO_COMMAND_FUNCTION(zt_command) memset(&ztp, 0, sizeof(ztp)); switch(command) { - case ZAP_COMMAND_ENABLE_ECHOCANCEL: + case FTDM_COMMAND_ENABLE_ECHOCANCEL: { - int level = ZAP_COMMAND_OBJ_INT; - err = ioctl(zchan->sockfd, codes.ECHOCANCEL, &level); - ZAP_COMMAND_OBJ_INT = level; + int level = FTDM_COMMAND_OBJ_INT; + err = ioctl(ftdmchan->sockfd, codes.ECHOCANCEL, &level); + FTDM_COMMAND_OBJ_INT = level; } - case ZAP_COMMAND_DISABLE_ECHOCANCEL: + case FTDM_COMMAND_DISABLE_ECHOCANCEL: { int level = 0; - err = ioctl(zchan->sockfd, codes.ECHOCANCEL, &level); - ZAP_COMMAND_OBJ_INT = level; + err = ioctl(ftdmchan->sockfd, codes.ECHOCANCEL, &level); + FTDM_COMMAND_OBJ_INT = level; } break; - case ZAP_COMMAND_ENABLE_ECHOTRAIN: + case FTDM_COMMAND_ENABLE_ECHOTRAIN: { - int level = ZAP_COMMAND_OBJ_INT; - err = ioctl(zchan->sockfd, codes.ECHOTRAIN, &level); - ZAP_COMMAND_OBJ_INT = level; + int level = FTDM_COMMAND_OBJ_INT; + err = ioctl(ftdmchan->sockfd, codes.ECHOTRAIN, &level); + FTDM_COMMAND_OBJ_INT = level; } - case ZAP_COMMAND_DISABLE_ECHOTRAIN: + case FTDM_COMMAND_DISABLE_ECHOTRAIN: { int level = 0; - err = ioctl(zchan->sockfd, codes.ECHOTRAIN, &level); - ZAP_COMMAND_OBJ_INT = level; + err = ioctl(ftdmchan->sockfd, codes.ECHOTRAIN, &level); + FTDM_COMMAND_OBJ_INT = level; } break; - case ZAP_COMMAND_OFFHOOK: + case FTDM_COMMAND_OFFHOOK: { int command = ZT_OFFHOOK; - if (ioctl(zchan->sockfd, codes.HOOK, &command)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "OFFHOOK Failed"); - return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "OFFHOOK Failed"); + return FTDM_FAIL; } - zap_set_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK); } break; - case ZAP_COMMAND_ONHOOK: + case FTDM_COMMAND_ONHOOK: { int command = ZT_ONHOOK; - if (ioctl(zchan->sockfd, codes.HOOK, &command)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "ONHOOK Failed"); - return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "ONHOOK Failed"); + return FTDM_FAIL; } - zap_clear_flag_locked(zchan, ZAP_CHANNEL_OFFHOOK); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_OFFHOOK); } break; - case ZAP_COMMAND_FLASH: + case FTDM_COMMAND_FLASH: { int command = ZT_FLASH; - if (ioctl(zchan->sockfd, codes.HOOK, &command)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "FLASH Failed"); - return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "FLASH Failed"); + return FTDM_FAIL; } } break; - case ZAP_COMMAND_WINK: + case FTDM_COMMAND_WINK: { int command = ZT_WINK; - if (ioctl(zchan->sockfd, codes.HOOK, &command)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "WINK Failed"); - return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "WINK Failed"); + return FTDM_FAIL; } } break; - case ZAP_COMMAND_GENERATE_RING_ON: + case FTDM_COMMAND_GENERATE_RING_ON: { int command = ZT_RING; - if (ioctl(zchan->sockfd, codes.HOOK, &command)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring Failed"); - return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring Failed"); + return FTDM_FAIL; } - zap_set_flag_locked(zchan, ZAP_CHANNEL_RINGING); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING); } break; - case ZAP_COMMAND_GENERATE_RING_OFF: + case FTDM_COMMAND_GENERATE_RING_OFF: { int command = ZT_RINGOFF; - if (ioctl(zchan->sockfd, codes.HOOK, &command)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "Ring-off failed"); - return ZAP_FAIL; + if (ioctl(ftdmchan->sockfd, codes.HOOK, &command)) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Ring-off failed"); + return FTDM_FAIL; } - zap_clear_flag_locked(zchan, ZAP_CHANNEL_RINGING); + ftdm_clear_flag_locked(ftdmchan, FTDM_CHANNEL_RINGING); } break; - case ZAP_COMMAND_GET_INTERVAL: + case FTDM_COMMAND_GET_INTERVAL: { - if (!(err = ioctl(zchan->sockfd, codes.GET_BLOCKSIZE, &zchan->packet_len))) { - zchan->native_interval = zchan->packet_len / 8; - if (zchan->effective_codec == ZAP_CODEC_SLIN) { - zchan->packet_len *= 2; + if (!(err = ioctl(ftdmchan->sockfd, codes.GET_BLOCKSIZE, &ftdmchan->packet_len))) { + ftdmchan->native_interval = ftdmchan->packet_len / 8; + if (ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + ftdmchan->packet_len *= 2; } - ZAP_COMMAND_OBJ_INT = zchan->native_interval; + FTDM_COMMAND_OBJ_INT = ftdmchan->native_interval; } } break; - case ZAP_COMMAND_SET_INTERVAL: + case FTDM_COMMAND_SET_INTERVAL: { - int interval = ZAP_COMMAND_OBJ_INT; + int interval = FTDM_COMMAND_OBJ_INT; int len = interval * 8; - if (!(err = ioctl(zchan->sockfd, codes.SET_BLOCKSIZE, &len))) { - zchan->packet_len = len; - zchan->effective_interval = zchan->native_interval = zchan->packet_len / 8; + if (!(err = ioctl(ftdmchan->sockfd, codes.SET_BLOCKSIZE, &len))) { + ftdmchan->packet_len = len; + ftdmchan->effective_interval = ftdmchan->native_interval = ftdmchan->packet_len / 8; - if (zchan->effective_codec == ZAP_CODEC_SLIN) { - zchan->packet_len *= 2; + if (ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + ftdmchan->packet_len *= 2; } } } break; - case ZAP_COMMAND_SET_CAS_BITS: + case FTDM_COMMAND_SET_CAS_BITS: { - int bits = ZAP_COMMAND_OBJ_INT; - err = ioctl(zchan->sockfd, codes.SETTXBITS, &bits); + int bits = FTDM_COMMAND_OBJ_INT; + err = ioctl(ftdmchan->sockfd, codes.SETTXBITS, &bits); } break; - case ZAP_COMMAND_GET_CAS_BITS: + case FTDM_COMMAND_GET_CAS_BITS: { - err = ioctl(zchan->sockfd, codes.GETRXBITS, &zchan->rx_cas_bits); + err = ioctl(ftdmchan->sockfd, codes.GETRXBITS, &ftdmchan->rx_cas_bits); if (!err) { - ZAP_COMMAND_OBJ_INT = zchan->rx_cas_bits; + FTDM_COMMAND_OBJ_INT = ftdmchan->rx_cas_bits; } } break; - case ZAP_COMMAND_FLUSH_TX_BUFFERS: + case FTDM_COMMAND_FLUSH_TX_BUFFERS: { int flushmode = ZT_FLUSH_WRITE; - err = ioctl(zchan->sockfd, codes.FLUSH, &flushmode); + err = ioctl(ftdmchan->sockfd, codes.FLUSH, &flushmode); } break; - case ZAP_COMMAND_FLUSH_RX_BUFFERS: + case FTDM_COMMAND_FLUSH_RX_BUFFERS: { int flushmode = ZT_FLUSH_READ; - err = ioctl(zchan->sockfd, codes.FLUSH, &flushmode); + err = ioctl(ftdmchan->sockfd, codes.FLUSH, &flushmode); } break; - case ZAP_COMMAND_FLUSH_BUFFERS: + case FTDM_COMMAND_FLUSH_BUFFERS: { int flushmode = ZT_FLUSH_BOTH; - err = ioctl(zchan->sockfd, codes.FLUSH, &flushmode); + err = ioctl(ftdmchan->sockfd, codes.FLUSH, &flushmode); } break; default: - err = ZAP_NOTIMPL; + err = FTDM_NOTIMPL; break; }; - if (err && err != ZAP_NOTIMPL) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + if (err && err != FTDM_NOTIMPL) { + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "%s", strerror(errno)); + return FTDM_FAIL; } - return err == 0 ? ZAP_SUCCESS : err; + return err == 0 ? FTDM_SUCCESS : err; } /** - * \brief Gets alarms from a zaptel Channel - * \param zchan Channel to get alarms from + * \brief Gets alarms from a ftdmtel Channel + * \param ftdmchan Channel to get alarms from * \return Success or failure */ static ZIO_GET_ALARMS_FUNCTION(zt_get_alarms) @@ -843,22 +843,22 @@ static ZIO_GET_ALARMS_FUNCTION(zt_get_alarms) struct zt_spaninfo info; memset(&info, 0, sizeof(info)); - info.span_no = zchan->physical_span_id; + info.span_no = ftdmchan->physical_span_id; if (ioctl(CONTROL_FD, codes.SPANSTAT, &info)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "ioctl failed (%s)", strerror(errno)); - snprintf(zchan->span->last_error, sizeof(zchan->span->last_error), "ioctl failed (%s)", strerror(errno)); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "ioctl failed (%s)", strerror(errno)); + snprintf(ftdmchan->span->last_error, sizeof(ftdmchan->span->last_error), "ioctl failed (%s)", strerror(errno)); + return FTDM_FAIL; } - zchan->alarm_flags = info.alarms; + ftdmchan->alarm_flags = info.alarms; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Waits for an event on a zaptel channel - * \param zchan Channel to open + * \brief Waits for an event on a ftdmtel channel + * \param ftdmchan Channel to open * \param flags Type of event to wait for * \param to Time to wait (in ms) * \return Success, failure or timeout @@ -869,21 +869,21 @@ static ZIO_WAIT_FUNCTION(zt_wait) int result; struct pollfd pfds[1]; - if (*flags & ZAP_READ) { + if (*flags & FTDM_READ) { inflags |= POLLIN; } - if (*flags & ZAP_WRITE) { + if (*flags & FTDM_WRITE) { inflags |= POLLOUT; } - if (*flags & ZAP_EVENTS) { + if (*flags & FTDM_EVENTS) { inflags |= POLLPRI; } memset(&pfds[0], 0, sizeof(pfds[0])); - pfds[0].fd = zchan->sockfd; + pfds[0].fd = ftdmchan->sockfd; pfds[0].events = inflags; result = poll(pfds, 1, to); *flags = 0; @@ -896,42 +896,42 @@ static ZIO_WAIT_FUNCTION(zt_wait) inflags = pfds[0].revents; } - *flags = ZAP_NO_FLAGS; + *flags = FTDM_NO_FLAGS; if (result < 0){ - snprintf(zchan->last_error, sizeof(zchan->last_error), "Poll failed"); - return ZAP_FAIL; + snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "Poll failed"); + return FTDM_FAIL; } if (result == 0) { - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; } if (inflags & POLLIN) { - *flags |= ZAP_READ; + *flags |= FTDM_READ; } if (inflags & POLLOUT) { - *flags |= ZAP_WRITE; + *flags |= FTDM_WRITE; } if (inflags & POLLPRI) { - *flags |= ZAP_EVENTS; + *flags |= FTDM_EVENTS; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Checks for events on a zaptel span + * \brief Checks for events on a ftdmtel span * \param span Span to check for events * \param ms Time to wait for event * \return Success if event is waiting or failure if not */ ZIO_SPAN_POLL_EVENT_FUNCTION(zt_poll_event) { - struct pollfd pfds[ZAP_MAX_CHANNELS_SPAN]; + struct pollfd pfds[FTDM_MAX_CHANNELS_SPAN]; uint32_t i, j = 0, k = 0; int r; @@ -945,16 +945,16 @@ ZIO_SPAN_POLL_EVENT_FUNCTION(zt_poll_event) r = poll(pfds, j, ms); if (r == 0) { - return ZAP_TIMEOUT; + return FTDM_TIMEOUT; } else if (r < 0 || (pfds[i-1].revents & POLLERR)) { snprintf(span->last_error, sizeof(span->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + return FTDM_FAIL; } for(i = 1; i <= span->chan_count; i++) { if (pfds[i-1].revents & POLLPRI) { - zap_set_flag(span->channels[i], ZAP_CHANNEL_EVENT); - span->channels[i]->last_event_time = zap_current_time_in_ms(); + ftdm_set_flag(span->channels[i], FTDM_CHANNEL_EVENT); + span->channels[i]->last_event_time = ftdm_current_time_in_ms(); k++; } } @@ -963,127 +963,127 @@ ZIO_SPAN_POLL_EVENT_FUNCTION(zt_poll_event) snprintf(span->last_error, sizeof(span->last_error), "no matching descriptor"); } - return k ? ZAP_SUCCESS : ZAP_FAIL; + return k ? FTDM_SUCCESS : FTDM_FAIL; } /** - * \brief Retrieves an event from a zaptel span + * \brief Retrieves an event from a ftdmtel span * \param span Span to retrieve event from - * \param event Openzap event to return + * \param event Openftdm event to return * \return Success or failure */ ZIO_SPAN_NEXT_EVENT_FUNCTION(zt_next_event) { uint32_t i, event_id = 0; - zap_oob_event_t zt_event_id = 0; + ftdm_oob_event_t zt_event_id = 0; for(i = 1; i <= span->chan_count; i++) { - if (zap_test_flag(span->channels[i], ZAP_CHANNEL_EVENT)) { - zap_clear_flag(span->channels[i], ZAP_CHANNEL_EVENT); + if (ftdm_test_flag(span->channels[i], FTDM_CHANNEL_EVENT)) { + ftdm_clear_flag(span->channels[i], FTDM_CHANNEL_EVENT); if (ioctl(span->channels[i]->sockfd, codes.GETEVENT, &zt_event_id) == -1) { snprintf(span->last_error, sizeof(span->last_error), "%s", strerror(errno)); - return ZAP_FAIL; + return FTDM_FAIL; } switch(zt_event_id) { case ZT_EVENT_RINGEROFF: { - return ZAP_FAIL; + return FTDM_FAIL; } break; case ZT_EVENT_RINGERON: { - return ZAP_FAIL; + return FTDM_FAIL; } break; case ZT_EVENT_RINGBEGIN: { - event_id = ZAP_OOB_RING_START; + event_id = FTDM_OOB_RING_START; } break; case ZT_EVENT_ONHOOK: { - event_id = ZAP_OOB_ONHOOK; + event_id = FTDM_OOB_ONHOOK; } break; case ZT_EVENT_WINKFLASH: { - if (span->channels[i]->state == ZAP_CHANNEL_STATE_DOWN || span->channels[i]->state == ZAP_CHANNEL_STATE_DIALING) { - event_id = ZAP_OOB_WINK; + if (span->channels[i]->state == FTDM_CHANNEL_STATE_DOWN || span->channels[i]->state == FTDM_CHANNEL_STATE_DIALING) { + event_id = FTDM_OOB_WINK; } else { - event_id = ZAP_OOB_FLASH; + event_id = FTDM_OOB_FLASH; } } break; case ZT_EVENT_RINGOFFHOOK: { - if (span->channels[i]->type == ZAP_CHAN_TYPE_FXS || (span->channels[i]->type == ZAP_CHAN_TYPE_EM && span->channels[i]->state != ZAP_CHANNEL_STATE_UP)) { - zap_set_flag_locked(span->channels[i], ZAP_CHANNEL_OFFHOOK); - event_id = ZAP_OOB_OFFHOOK; - } else if (span->channels[i]->type == ZAP_CHAN_TYPE_FXO) { - event_id = ZAP_OOB_RING_START; + if (span->channels[i]->type == FTDM_CHAN_TYPE_FXS || (span->channels[i]->type == FTDM_CHAN_TYPE_EM && span->channels[i]->state != FTDM_CHANNEL_STATE_UP)) { + ftdm_set_flag_locked(span->channels[i], FTDM_CHANNEL_OFFHOOK); + event_id = FTDM_OOB_OFFHOOK; + } else if (span->channels[i]->type == FTDM_CHAN_TYPE_FXO) { + event_id = FTDM_OOB_RING_START; } } break; case ZT_EVENT_ALARM: { - event_id = ZAP_OOB_ALARM_TRAP; + event_id = FTDM_OOB_ALARM_TRAP; } break; case ZT_EVENT_NOALARM: { - event_id = ZAP_OOB_ALARM_CLEAR; + event_id = FTDM_OOB_ALARM_CLEAR; } break; case ZT_EVENT_BITSCHANGED: { - event_id = ZAP_OOB_CAS_BITS_CHANGE; + event_id = FTDM_OOB_CAS_BITS_CHANGE; int bits = 0; int err = ioctl(span->channels[i]->sockfd, codes.GETRXBITS, &bits); if (err) { - return ZAP_FAIL; + return FTDM_FAIL; } span->channels[i]->rx_cas_bits = bits; } break; default: { - zap_log(ZAP_LOG_WARNING, "Unhandled event %d for %d:%d\n", zt_event_id, span->span_id, i); - event_id = ZAP_OOB_INVALID; + ftdm_log(FTDM_LOG_WARNING, "Unhandled event %d for %d:%d\n", zt_event_id, span->span_id, i); + event_id = FTDM_OOB_INVALID; } break; } span->channels[i]->last_event_time = 0; - span->event_header.e_type = ZAP_EVENT_OOB; + span->event_header.e_type = FTDM_EVENT_OOB; span->event_header.enum_id = event_id; span->event_header.channel = span->channels[i]; *event = &span->event_header; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } } - return ZAP_FAIL; + return FTDM_FAIL; } /** - * \brief Reads data from a zaptel channel - * \param zchan Channel to read from + * \brief Reads data from a ftdmtel channel + * \param ftdmchan Channel to read from * \param data Data buffer * \param datalen Size of data buffer * \return Success, failure or timeout */ static ZIO_READ_FUNCTION(zt_read) { - zap_ssize_t r = 0; + ftdm_ssize_t r = 0; int errs = 0; while (errs++ < 30) { - if ((r = read(zchan->sockfd, data, *datalen)) > 0) { + if ((r = read(ftdmchan->sockfd, data, *datalen)) > 0) { break; } - zap_sleep(10); + ftdm_sleep(10); if (r == 0) { errs--; } @@ -1091,63 +1091,63 @@ static ZIO_READ_FUNCTION(zt_read) if (r > 0) { *datalen = r; - if (zchan->type == ZAP_CHAN_TYPE_DQ921) { + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921) { *datalen -= 2; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return r == 0 ? ZAP_TIMEOUT : ZAP_FAIL; + return r == 0 ? FTDM_TIMEOUT : FTDM_FAIL; } /** - * \brief Writes data to a zaptel channel - * \param zchan Channel to write to + * \brief Writes data to a ftdmtel channel + * \param ftdmchan Channel to write to * \param data Data buffer * \param datalen Size of data buffer * \return Success or failure */ static ZIO_WRITE_FUNCTION(zt_write) { - zap_ssize_t w = 0; - zap_size_t bytes = *datalen; + ftdm_ssize_t w = 0; + ftdm_size_t bytes = *datalen; - if (zchan->type == ZAP_CHAN_TYPE_DQ921) { + if (ftdmchan->type == FTDM_CHAN_TYPE_DQ921) { memset(data+bytes, 0, 2); bytes += 2; } - w = write(zchan->sockfd, data, bytes); + w = write(ftdmchan->sockfd, data, bytes); if (w >= 0) { *datalen = w; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } - return ZAP_FAIL; + return FTDM_FAIL; } /** - * \brief Destroys a zaptel Channel - * \param zchan Channel to destroy + * \brief Destroys a ftdmtel Channel + * \param ftdmchan Channel to destroy * \return Success */ static ZIO_CHANNEL_DESTROY_FUNCTION(zt_channel_destroy) { - close(zchan->sockfd); - zchan->sockfd = ZT_INVALID_SOCKET; + close(ftdmchan->sockfd); + ftdmchan->sockfd = ZT_INVALID_SOCKET; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Global Openzap IO interface for zaptel + * \brief Global Openftdm IO interface for ftdmtel */ -static zap_io_interface_t zt_interface; +static ftdm_io_interface_t zt_interface; /** - * \brief Loads zaptel IO module - * \param zio Openzap IO interface + * \brief Loads ftdmtel IO module + * \param zio Openftdm IO interface * \return Success or failure */ static ZIO_IO_LOAD_FUNCTION(zt_init) @@ -1158,22 +1158,22 @@ static ZIO_IO_LOAD_FUNCTION(zt_init) memset(&zt_globals, 0, sizeof(zt_globals)); if (!stat(zt_ctlpath, &statbuf)) { - zap_log(ZAP_LOG_NOTICE, "Using Zaptel control device\n"); + ftdm_log(FTDM_LOG_NOTICE, "Using Zaptel control device\n"); ctlpath = zt_ctlpath; chanpath = zt_chanpath; memcpy(&codes, &zt_ioctl_codes, sizeof(codes)); } else if (!stat(dahdi_ctlpath, &statbuf)) { - zap_log(ZAP_LOG_NOTICE, "Using DAHDI control device\n"); + ftdm_log(FTDM_LOG_NOTICE, "Using DAHDI control device\n"); ctlpath = dahdi_ctlpath; chanpath = dahdi_chanpath; memcpy(&codes, &dahdi_ioctl_codes, sizeof(codes)); } else { - zap_log(ZAP_LOG_ERROR, "No DAHDI or Zap control device found in /dev/\n"); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "No DAHDI or Zap control device found in /dev/\n"); + return FTDM_FAIL; } if ((CONTROL_FD = open(ctlpath, O_RDWR)) < 0) { - zap_log(ZAP_LOG_ERROR, "Cannot open control device %s: %s\n", ctlpath, strerror(errno)); - return ZAP_FAIL; + ftdm_log(FTDM_LOG_ERROR, "Cannot open control device %s: %s\n", ctlpath, strerror(errno)); + return FTDM_FAIL; } zt_globals.codec_ms = 20; @@ -1197,24 +1197,24 @@ static ZIO_IO_LOAD_FUNCTION(zt_init) zt_interface.get_alarms = zt_get_alarms; *zio = &zt_interface; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Unloads zaptel IO module + * \brief Unloads ftdmtel IO module * \return Success */ static ZIO_IO_UNLOAD_FUNCTION(zt_destroy) { close(CONTROL_FD); memset(&zt_interface, 0, sizeof(zt_interface)); - return ZAP_SUCCESS; + return FTDM_SUCCESS; } /** - * \brief Openzap zaptel IO module definition + * \brief Openftdm ftdmtel IO module definition */ -zap_module_t zap_module = { +ftdm_module_t ftdm_module = { "zt", zt_init, zt_destroy, diff --git a/libs/freetdm/src/ozmod/ozmod_zt/ozmod_zt.h b/libs/freetdm/src/ftmod/ftmod_zt/ftmod_zt.h similarity index 97% rename from libs/freetdm/src/ozmod/ozmod_zt/ozmod_zt.h rename to libs/freetdm/src/ftmod/ftmod_zt/ftmod_zt.h index 687269a983..cf5479dba1 100644 --- a/libs/freetdm/src/ozmod/ozmod_zt/ozmod_zt.h +++ b/libs/freetdm/src/ftmod/ftmod_zt/ftmod_zt.h @@ -31,9 +31,9 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef ZAP_ZT_H -#define ZAP_ZT_H -#include "openzap.h" +#ifndef FTDM_ZT_H +#define FTDM_ZT_H +#include "freetdm.h" #include #include @@ -45,7 +45,7 @@ /* Hardware interface structures and defines */ /* Based on documentation of the structures required for the hardware interface */ -/* from http://wiki.freeswitch.org/wiki/Zapata_zaptel_interface */ +/* from http://wiki.freeswitch.org/wiki/Zapata_ftdmtel_interface */ /* Structures */ @@ -111,9 +111,9 @@ struct zt_spaninfo { int sync_src; /* Span # of sync source (0 = free run) */ int configured_chan_count; /* Count of channels configured on the span */ int channel_count; /* Total count of channels on the span */ - int span_count; /* Total count of zaptel spans on the system*/ + int span_count; /* Total count of ftdmtel spans on the system*/ /* end v1 of the struct */ - /* as long as we don't use the fields below we should be ok regardless of the zaptel/dahdi version */ + /* as long as we don't use the fields below we should be ok regardless of the ftdmtel/dahdi version */ int lbo; /* Line Build Out */ int lineconfig; /* framing/coding */ /* end of v2 of the struct */ @@ -290,7 +290,7 @@ ZT_ABIT = 8 #define ZT_HDLCRAWMODE _IOW (ZT_CODE, 36, int) /* Set a clear channel into HDLC w/out FCS checking/calculation mode */ #define ZT_HDLCFCSMODE _IOW (ZT_CODE, 37, int) /* Set a clear channel into HDLC w/ FCS mode */ -/* Specify a channel on /dev/zap/chan -- must be done before any other ioctl's and is only valid on /dev/zap/chan */ +/* Specify a channel on /dev/ftdm/chan -- must be done before any other ioctl's and is only valid on /dev/ftdm/chan */ #define ZT_SPECIFY _IOW (ZT_CODE, 38, int) /* Temporarily set the law on a channel to ZT_LAW_DEFAULT, ZT_LAW_ALAW, or ZT_LAW_MULAW. Is reset on close. */ diff --git a/libs/freetdm/src/hashtable.c b/libs/freetdm/src/hashtable.c index 15ec9014f4..1f08abc2b8 100644 --- a/libs/freetdm/src/hashtable.c +++ b/libs/freetdm/src/hashtable.c @@ -31,7 +31,7 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "openzap.h" +#include "freetdm.h" #include "hashtable.h" #include "hashtable_private.h" #include @@ -57,7 +57,7 @@ const unsigned int prime_table_length = sizeof(primes)/sizeof(primes[0]); const float max_load_factor = 0.65f; /*****************************************************************************/ -OZ_DECLARE(struct hashtable *) +FT_DECLARE(struct hashtable *) create_hashtable(unsigned int minsize, unsigned int (*hashf) (void*), int (*eqf) (void*,void*)) @@ -70,10 +70,10 @@ create_hashtable(unsigned int minsize, for (pindex=0; pindex < prime_table_length; pindex++) { if (primes[pindex] > minsize) { size = primes[pindex]; break; } } - h = (struct hashtable *)zap_malloc(sizeof(struct hashtable)); + h = (struct hashtable *)ftdm_malloc(sizeof(struct hashtable)); if (NULL == h) return NULL; /*oom*/ - h->table = (struct entry **)zap_malloc(sizeof(struct entry*) * size); - if (NULL == h->table) { zap_safe_free(h); return NULL; } /*oom*/ + h->table = (struct entry **)ftdm_malloc(sizeof(struct entry*) * size); + if (NULL == h->table) { ftdm_safe_free(h); return NULL; } /*oom*/ memset(h->table, 0, size * sizeof(struct entry *)); h->tablelength = size; h->primeindex = pindex; @@ -111,7 +111,7 @@ hashtable_expand(struct hashtable *h) if (h->primeindex == (prime_table_length - 1)) return 0; newsize = primes[++(h->primeindex)]; - newtable = (struct entry **)zap_malloc(sizeof(struct entry*) * newsize); + newtable = (struct entry **)ftdm_malloc(sizeof(struct entry*) * newsize); if (NULL != newtable) { memset(newtable, 0, newsize * sizeof(struct entry *)); @@ -125,7 +125,7 @@ hashtable_expand(struct hashtable *h) newtable[index] = e; } } - zap_safe_free(h->table); + ftdm_safe_free(h->table); h->table = newtable; } /* Plan B: realloc instead */ @@ -158,14 +158,14 @@ hashtable_expand(struct hashtable *h) } /*****************************************************************************/ -OZ_DECLARE(unsigned int) +FT_DECLARE(unsigned int) hashtable_count(struct hashtable *h) { return h->entrycount; } /*****************************************************************************/ -OZ_DECLARE(int) +FT_DECLARE(int) hashtable_insert(struct hashtable *h, void *k, void *v, hashtable_flag_t flags) { /* This method allows duplicate keys - but they shouldn't be used */ @@ -179,7 +179,7 @@ hashtable_insert(struct hashtable *h, void *k, void *v, hashtable_flag_t flags) * element may be ok. Next time we insert, we'll try expanding again.*/ hashtable_expand(h); } - e = (struct entry *)zap_malloc(sizeof(struct entry)); + e = (struct entry *)ftdm_malloc(sizeof(struct entry)); if (NULL == e) { --(h->entrycount); return 0; } /*oom*/ e->h = hash(h,k); index = indexFor(h->tablelength,e->h); @@ -192,7 +192,7 @@ hashtable_insert(struct hashtable *h, void *k, void *v, hashtable_flag_t flags) } /*****************************************************************************/ -OZ_DECLARE(void *) /* returns value associated with key */ +FT_DECLARE(void *) /* returns value associated with key */ hashtable_search(struct hashtable *h, void *k) { struct entry *e; @@ -210,7 +210,7 @@ hashtable_search(struct hashtable *h, void *k) } /*****************************************************************************/ -OZ_DECLARE(void *) /* returns value associated with key */ +FT_DECLARE(void *) /* returns value associated with key */ hashtable_remove(struct hashtable *h, void *k) { /* TODO: consider compacting the table when the load factor drops enough, @@ -236,7 +236,7 @@ hashtable_remove(struct hashtable *h, void *k) if (e->flags & HASHTABLE_FLAG_FREE_KEY) { freekey(e->k); } - zap_safe_free(e); + ftdm_safe_free(e); return v; } pE = &(e->next); @@ -247,7 +247,7 @@ hashtable_remove(struct hashtable *h, void *k) /*****************************************************************************/ /* destroy */ -OZ_DECLARE(void) +FT_DECLARE(void) hashtable_destroy(struct hashtable *h) { unsigned int i; @@ -258,14 +258,14 @@ hashtable_destroy(struct hashtable *h) { e = table[i]; while (NULL != e) - { f = e; e = e->next; if (f->flags & HASHTABLE_FLAG_FREE_KEY) freekey(f->k); if (f->flags & HASHTABLE_FLAG_FREE_VALUE) zap_safe_free(f->v); zap_safe_free(f); } + { f = e; e = e->next; if (f->flags & HASHTABLE_FLAG_FREE_KEY) freekey(f->k); if (f->flags & HASHTABLE_FLAG_FREE_VALUE) ftdm_safe_free(f->v); ftdm_safe_free(f); } } - zap_safe_free(h->table); - zap_safe_free(h); + ftdm_safe_free(h->table); + ftdm_safe_free(h); } -OZ_DECLARE(struct hashtable_iterator *) hashtable_next(struct hashtable_iterator *i) +FT_DECLARE(struct hashtable_iterator *) hashtable_next(struct hashtable_iterator *i) { if (i->e) { @@ -291,7 +291,7 @@ OZ_DECLARE(struct hashtable_iterator *) hashtable_next(struct hashtable_iterator return NULL; } -OZ_DECLARE(struct hashtable_iterator *) hashtable_first(struct hashtable *h) +FT_DECLARE(struct hashtable_iterator *) hashtable_first(struct hashtable *h) { h->iterator.pos = 0; h->iterator.e = NULL; @@ -301,7 +301,7 @@ OZ_DECLARE(struct hashtable_iterator *) hashtable_first(struct hashtable *h) -OZ_DECLARE(void) hashtable_this(struct hashtable_iterator *i, const void **key, int *klen, void **val) +FT_DECLARE(void) hashtable_this(struct hashtable_iterator *i, const void **key, int *klen, void **val) { if (i->e) { if (key) { diff --git a/libs/freetdm/src/hashtable_itr.c b/libs/freetdm/src/hashtable_itr.c index ab5e1ce0c8..a31f5b44c5 100644 --- a/libs/freetdm/src/hashtable_itr.c +++ b/libs/freetdm/src/hashtable_itr.c @@ -31,7 +31,7 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#include "openzap.h" +#include "freetdm.h" #include "hashtable.h" #include "hashtable_private.h" #include "hashtable_itr.h" @@ -44,7 +44,7 @@ struct hashtable_itr * hashtable_iterator(struct hashtable *h) { unsigned int i, tablelength; - struct hashtable_itr *itr = zap_malloc(sizeof(struct hashtable_itr)); + struct hashtable_itr *itr = ftdm_malloc(sizeof(struct hashtable_itr)); if (NULL == itr) return NULL; itr->h = h; itr->e = NULL; @@ -138,7 +138,7 @@ hashtable_iterator_remove(struct hashtable_itr *itr) remember_parent = itr->parent; ret = hashtable_iterator_advance(itr); if (itr->parent == remember_e) { itr->parent = remember_parent; } - zap_safe_free(remember_e); + ftdm_safe_free(remember_e); return ret; } diff --git a/libs/freetdm/src/include/hashtable.h b/libs/freetdm/src/include/hashtable.h index 7a94354d5d..f08ea817e2 100644 --- a/libs/freetdm/src/include/hashtable.h +++ b/libs/freetdm/src/include/hashtable.h @@ -7,7 +7,7 @@ #define __inline__ __inline #endif #endif -#include "openzap.h" +#include "freetdm.h" #ifdef __cplusplus extern "C" { @@ -81,7 +81,7 @@ struct hashtable_iterator; * @return newly created hashtable or NULL on failure */ -OZ_DECLARE(struct hashtable *) +FT_DECLARE(struct hashtable *) create_hashtable(unsigned int minsize, unsigned int (*hashfunction) (void*), int (*key_eq_fn) (void*,void*)); @@ -112,7 +112,7 @@ typedef enum { HASHTABLE_FLAG_FREE_VALUE = (1 << 1) } hashtable_flag_t; -OZ_DECLARE(int) +FT_DECLARE(int) hashtable_insert(struct hashtable *h, void *k, void *v, hashtable_flag_t flags); #define DEFINE_HASHTABLE_INSERT(fnname, keytype, valuetype) \ @@ -130,7 +130,7 @@ hashtable_insert(struct hashtable *h, void *k, void *v, hashtable_flag_t flags); * @return the value associated with the key, or NULL if none found */ -OZ_DECLARE(void *) +FT_DECLARE(void *) hashtable_search(struct hashtable *h, void *k); #define DEFINE_HASHTABLE_SEARCH(fnname, keytype, valuetype) \ @@ -148,7 +148,7 @@ hashtable_search(struct hashtable *h, void *k); * @return the value associated with the key, or NULL if none found */ -OZ_DECLARE(void *) /* returns value */ +FT_DECLARE(void *) /* returns value */ hashtable_remove(struct hashtable *h, void *k); #define DEFINE_HASHTABLE_REMOVE(fnname, keytype, valuetype) \ @@ -165,7 +165,7 @@ hashtable_remove(struct hashtable *h, void *k); * @param h the hashtable * @return the number of items stored in the hashtable */ -OZ_DECLARE(unsigned int) +FT_DECLARE(unsigned int) hashtable_count(struct hashtable *h); @@ -177,12 +177,12 @@ hashtable_count(struct hashtable *h); * @param free_values whether to call 'free' on the remaining values */ -OZ_DECLARE(void) +FT_DECLARE(void) hashtable_destroy(struct hashtable *h); -OZ_DECLARE(struct hashtable_iterator*) hashtable_first(struct hashtable *h); -OZ_DECLARE(struct hashtable_iterator*) hashtable_next(struct hashtable_iterator *i); -OZ_DECLARE(void) hashtable_this(struct hashtable_iterator *i, const void **key, int *klen, void **val); +FT_DECLARE(struct hashtable_iterator*) hashtable_first(struct hashtable *h); +FT_DECLARE(struct hashtable_iterator*) hashtable_next(struct hashtable_iterator *i); +FT_DECLARE(void) hashtable_this(struct hashtable_iterator *i, const void **key, int *klen, void **val); #ifdef __cplusplus } /* extern C */ diff --git a/libs/freetdm/src/include/libteletone.h b/libs/freetdm/src/include/libteletone.h index 6e806cec4f..18b95e7f3c 100644 --- a/libs/freetdm/src/include/libteletone.h +++ b/libs/freetdm/src/include/libteletone.h @@ -4,10 +4,10 @@ * * Version: MPL 1.1 * - * The contents of this file are subject to the Mozilla Public License Version + * The contents of this file are subject to the Mftilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at - * http://www.mozilla.org/MPL/ + * http://www.mftilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License @@ -33,8 +33,8 @@ * Exception: * The author hereby grants the use of this source code under the * following license if and only if the source code is distributed - * as part of the openzap library. Any use or distribution of this - * source code outside the scope of the openzap library will nullify the + * as part of the freetdm library. Any use or distribution of this + * source code outside the scope of the freetdm library will nullify the * following license and reinact the MPL 1.1 as stated above. * * Copyright (c) 2007, Anthony Minessale II diff --git a/libs/freetdm/src/include/libteletone_detect.h b/libs/freetdm/src/include/libteletone_detect.h index 3d0a5130ec..dc14356e3e 100644 --- a/libs/freetdm/src/include/libteletone_detect.h +++ b/libs/freetdm/src/include/libteletone_detect.h @@ -7,8 +7,8 @@ * Exception: * The author hereby grants the use of this source code under the * following license if and only if the source code is distributed - * as part of the openzap library. Any use or distribution of this - * source code outside the scope of the openzap library will nullify the + * as part of the freetdm library. Any use or distribution of this + * source code outside the scope of the freetdm library will nullify the * following license and reinact the MPL 1.1 as stated above. * * Copyright (c) 2007, Anthony Minessale II diff --git a/libs/freetdm/src/include/openzap.h b/libs/freetdm/src/include/openzap.h deleted file mode 100644 index 7281684afc..0000000000 --- a/libs/freetdm/src/include/openzap.h +++ /dev/null @@ -1,932 +0,0 @@ -/* - * Copyright (c) 2007, Anthony Minessale II - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * Contributors: - * - * Moises Silva - * - */ - -#ifndef OPENZAP_H -#define OPENZAP_H - - -#if !defined(_XOPEN_SOURCE) && !defined(__FreeBSD__) -#define _XOPEN_SOURCE 600 -#endif - -#ifndef HAVE_STRINGS_H -#define HAVE_STRINGS_H 1 -#endif -#ifndef HAVE_SYS_SOCKET_H -#define HAVE_SYS_SOCKET_H 1 -#endif - -#ifndef __WINDOWS__ -#if defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32) || defined(_WIN64) -#define __WINDOWS__ -#endif -#endif - -#ifdef _MSC_VER -#if defined(OZ_DECLARE_STATIC) -#define OZ_DECLARE(type) type __stdcall -#define OZ_DECLARE_NONSTD(type) type __cdecl -#define OZ_DECLARE_DATA -#elif defined(OPENZAP_EXPORTS) -#define OZ_DECLARE(type) __declspec(dllexport) type __stdcall -#define OZ_DECLARE_NONSTD(type) __declspec(dllexport) type __cdecl -#define OZ_DECLARE_DATA __declspec(dllexport) -#else -#define OZ_DECLARE(type) __declspec(dllimport) type __stdcall -#define OZ_DECLARE_NONSTD(type) __declspec(dllimport) type __cdecl -#define OZ_DECLARE_DATA __declspec(dllimport) -#endif -#define EX_DECLARE_DATA __declspec(dllexport) -#else -#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(HAVE_VISIBILITY) -#define OZ_DECLARE(type) __attribute__((visibility("default"))) type -#define OZ_DECLARE_NONSTD(type) __attribute__((visibility("default"))) type -#define OZ_DECLARE_DATA __attribute__((visibility("default"))) -#else -#define OZ_DECLARE(type) type -#define OZ_DECLARE_NONSTD(type) type -#define OZ_DECLARE_DATA -#endif -#define EX_DECLARE_DATA -#endif - -#ifdef _MSC_VER -#ifndef __inline__ -#define __inline__ __inline -#endif -#if (_MSC_VER >= 1400) /* VC8+ */ -#ifndef _CRT_SECURE_NO_DEPRECATE -#define _CRT_SECURE_NO_DEPRECATE -#endif -#ifndef _CRT_NONSTDC_NO_DEPRECATE -#define _CRT_NONSTDC_NO_DEPRECATE -#endif -#endif -#ifndef strcasecmp -#define strcasecmp(s1, s2) _stricmp(s1, s2) -#endif -#ifndef strncasecmp -#define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n) -#endif -#ifndef snprintf -#define snprintf _snprintf -#endif -#ifndef S_IRUSR -#define S_IRUSR _S_IREAD -#endif -#ifndef S_IWUSR -#define S_IWUSR _S_IWRITE -#endif -#undef HAVE_STRINGS_H -#undef HAVE_SYS_SOCKET_H -/* disable warning for zero length array in a struct */ -/* this will cause errors on c99 and ansi compliant compilers and will need to be fixed in the wanpipe header files */ -#pragma warning(disable:4706) -#pragma comment(lib, "Winmm") -#endif - -#define ZAP_THREAD_STACKSIZE 240 * 1024 -#define ZAP_ENUM_NAMES(_NAME, _STRINGS) static const char * _NAME [] = { _STRINGS , NULL }; -#define ZAP_STR2ENUM_P(_FUNC1, _FUNC2, _TYPE) OZ_DECLARE(_TYPE) _FUNC1 (const char *name); OZ_DECLARE(const char *) _FUNC2 (_TYPE type); -#define ZAP_STR2ENUM(_FUNC1, _FUNC2, _TYPE, _STRINGS, _MAX) \ - OZ_DECLARE(_TYPE) _FUNC1 (const char *name) \ - { \ - int i; \ - _TYPE t = _MAX ; \ - \ - for (i = 0; i < _MAX ; i++) { \ - if (!strcasecmp(name, _STRINGS[i])) { \ - t = (_TYPE) i; \ - break; \ - } \ - } \ - \ - return t; \ - } \ - OZ_DECLARE(const char *) _FUNC2 (_TYPE type) \ - { \ - if (type > _MAX) { \ - type = _MAX; \ - } \ - return _STRINGS[(int)type]; \ - } \ - -#define zap_true(expr) \ - (expr && ( !strcasecmp(expr, "yes") || \ - !strcasecmp(expr, "on") || \ - !strcasecmp(expr, "true") || \ - !strcasecmp(expr, "enabled") || \ - !strcasecmp(expr, "active") || \ - atoi(expr))) ? 1 : 0 - - -#include -#ifndef __WINDOWS__ -#include -#endif - -#include -#include -#include -#ifdef HAVE_STRINGS_H -#include -#endif -#include -#include "zap_types.h" -#include "hashtable.h" -#include "zap_config.h" -#include "g711.h" -#include "libteletone.h" -#include "zap_buffer.h" -#include "zap_threadmutex.h" - -#ifdef __cplusplus -extern "C" { -#endif - -#ifdef __WINDOWS__ -#define zap_sleep(x) Sleep(x) -#else -#define zap_sleep(x) usleep(x * 1000) -#endif - -#ifdef NDEBUG -#undef assert -#define assert(_Expression) ((void)(_Expression)) -#endif - -#define ZAP_MAX_CHANNELS_PHYSICAL_SPAN 32 -#define ZAP_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN 32 -#define ZAP_MAX_CHANNELS_SPAN ZAP_MAX_CHANNELS_PHYSICAL_SPAN * ZAP_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN -#define ZAP_MAX_SPANS_INTERFACE 128 - -#define ZAP_MAX_CHANNELS_GROUP 1024 -#define ZAP_MAX_GROUPS_INTERFACE ZAP_MAX_SPANS_INTERFACE - -#define GOTO_STATUS(label,st) status = st; goto label ; - -#define zap_copy_string(x,y,z) strncpy(x, y, z - 1) -#define zap_set_string(x,y) strncpy(x, y, sizeof(x)-1) -#define zap_strlen_zero(s) (!s || *s == '\0') -#define zap_strlen_zero_buf(s) (*s == '\0') - - -#define zap_channel_test_feature(obj, flag) ((obj)->features & flag) -#define zap_channel_set_feature(obj, flag) (obj)->features |= (flag) -#define zap_channel_clear_feature(obj, flag) (obj)->features &= ~(flag) -#define zap_channel_set_member_locked(obj, _m, _v) zap_mutex_lock(obj->mutex); obj->_m = _v; zap_mutex_unlock(obj->mutex) - -/*! - \brief Test for the existance of a flag on an arbitary object - \command obj the object to test - \command flag the or'd list of flags to test - \return true value if the object has the flags defined -*/ -#define zap_test_flag(obj, flag) ((obj)->flags & flag) -#define zap_test_pflag(obj, flag) ((obj)->pflags & flag) -#define zap_test_sflag(obj, flag) ((obj)->sflags & flag) - - -#define zap_set_alarm_flag(obj, flag) (obj)->alarm_flags |= (flag) -#define zap_clear_alarm_flag(obj, flag) (obj)->alarm_flags &= ~(flag) -#define zap_test_alarm_flag(obj, flag) ((obj)->alarm_flags & flag) - -/*! - \brief Set a flag on an arbitrary object - \command obj the object to set the flags on - \command flag the or'd list of flags to set -*/ -#define zap_set_flag(obj, flag) (obj)->flags |= (flag) -#define zap_set_flag_locked(obj, flag) assert(obj->mutex != NULL); \ - zap_mutex_lock(obj->mutex); \ - (obj)->flags |= (flag); \ - zap_mutex_unlock(obj->mutex); - -#define zap_set_pflag(obj, flag) (obj)->pflags |= (flag) -#define zap_set_pflag_locked(obj, flag) assert(obj->mutex != NULL); \ - zap_mutex_lock(obj->mutex); \ - (obj)->pflags |= (flag); \ - zap_mutex_unlock(obj->mutex); - -#define zap_set_sflag(obj, flag) (obj)->sflags |= (flag) -#define zap_set_sflag_locked(obj, flag) assert(obj->mutex != NULL); \ - zap_mutex_lock(obj->mutex); \ - (obj)->sflags |= (flag); \ - zap_mutex_unlock(obj->mutex); - -/*! - \brief Clear a flag on an arbitrary object while locked - \command obj the object to test - \command flag the or'd list of flags to clear -*/ -#define zap_clear_flag(obj, flag) (obj)->flags &= ~(flag) - -#define zap_clear_flag_locked(obj, flag) assert(obj->mutex != NULL); zap_mutex_lock(obj->mutex); (obj)->flags &= ~(flag); zap_mutex_unlock(obj->mutex); - -#define zap_clear_pflag(obj, flag) (obj)->pflags &= ~(flag) - -#define zap_clear_pflag_locked(obj, flag) assert(obj->mutex != NULL); zap_mutex_lock(obj->mutex); (obj)->pflags &= ~(flag); zap_mutex_unlock(obj->mutex); - -#define zap_clear_sflag(obj, flag) (obj)->sflags &= ~(flag) - -#define zap_clear_sflag_locked(obj, flag) assert(obj->mutex != NULL); zap_mutex_lock(obj->mutex); (obj)->sflags &= ~(flag); zap_mutex_unlock(obj->mutex); - - -#define zap_set_state_locked(obj, s) if ( obj->state == s ) { \ - zap_log(ZAP_LOG_WARNING, "Why bother changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(obj->state), zap_channel_state2str(s)); \ - } else if (zap_test_flag(obj, ZAP_CHANNEL_READY)) { \ - zap_channel_state_t st = obj->state; \ - zap_channel_set_state(obj, s, 1); \ - if (obj->state == s) zap_log(ZAP_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s)); \ - else zap_log(ZAP_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s)); \ - } - -#ifdef _MSC_VER -/* The while(0) below throws a conditional expression is constant warning */ -#pragma warning(disable:4127) -#endif - -#define zap_set_state_locked_wait(obj, s) \ - do { \ - int __safety = 100; \ - zap_set_state_locked(obj, s); \ - while(__safety-- && zap_test_flag(obj, ZAP_CHANNEL_STATE_CHANGE)) { \ - zap_sleep(10); \ - } \ - if(!__safety) { \ - zap_log(ZAP_LOG_CRIT, "State change not completed\n"); \ - } \ - } while(0); - -#define zap_wait_for_flag_cleared(obj, flag, time) \ - do { \ - int __safety = time; \ - while(__safety-- && zap_test_flag(obj, flag)) { \ - zap_mutex_unlock(obj->mutex); \ - zap_sleep(10); \ - zap_mutex_lock(obj->mutex); \ - } \ - if(!__safety) { \ - zap_log(ZAP_LOG_CRIT, "flag %d was never cleared\n", flag); \ - } \ - } while(0); - -#define zap_set_state_wait(obj, s) \ - do { \ - zap_channel_set_state(obj, s, 0); \ - zap_wait_for_flag_cleared(obj, ZAP_CHANNEL_STATE_CHANGE, 100); \ - } while(0); - - -typedef enum { - ZAP_STATE_CHANGE_FAIL, - ZAP_STATE_CHANGE_SUCCESS, - ZAP_STATE_CHANGE_SAME, -} zap_state_change_result_t; - -#define zap_set_state_r(obj, s, l, r) if ( obj->state == s ) { \ - zap_log(ZAP_LOG_WARNING, "Why bother changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(obj->state), zap_channel_state2str(s)); r = ZAP_STATE_CHANGE_SAME; \ - } else if (zap_test_flag(obj, ZAP_CHANNEL_READY)) { \ - int st = obj->state; \ - r = (zap_channel_set_state(obj, s, l) == ZAP_SUCCESS) ? ZAP_STATE_CHANGE_SUCCESS : ZAP_STATE_CHANGE_FAIL; \ - if (obj->state == s) {zap_log(ZAP_LOG_DEBUG, "Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s));} \ - else {zap_log(ZAP_LOG_WARNING, "VETO Changing state on %d:%d from %s to %s\n", obj->span_id, obj->chan_id, zap_channel_state2str(st), zap_channel_state2str(s)); } \ - } - - -#define zap_is_dtmf(key) ((key > 47 && key < 58) || (key > 64 && key < 69) || (key > 96 && key < 101) || key == 35 || key == 42 || key == 87 || key == 119) - -/*! - \brief Copy flags from one arbitrary object to another - \command dest the object to copy the flags to - \command src the object to copy the flags from - \command flags the flags to copy -*/ -#define zap_copy_flags(dest, src, flags) (dest)->flags &= ~(flags); (dest)->flags |= ((src)->flags & (flags)) - -struct zap_stream_handle { - zap_stream_handle_write_function_t write_function; - zap_stream_handle_raw_write_function_t raw_write_function; - void *data; - void *end; - zap_size_t data_size; - zap_size_t data_len; - zap_size_t alloc_len; - zap_size_t alloc_chunk; -}; - - -OZ_DECLARE_NONSTD(zap_status_t) zap_console_stream_raw_write(zap_stream_handle_t *handle, uint8_t *data, zap_size_t datalen); -OZ_DECLARE_NONSTD(zap_status_t) zap_console_stream_write(zap_stream_handle_t *handle, const char *fmt, ...); - -#define ZAP_CMD_CHUNK_LEN 1024 -#define ZAP_STANDARD_STREAM(s) memset(&s, 0, sizeof(s)); s.data = malloc(ZAP_CMD_CHUNK_LEN); \ - assert(s.data); \ - memset(s.data, 0, ZAP_CMD_CHUNK_LEN); \ - s.end = s.data; \ - s.data_size = ZAP_CMD_CHUNK_LEN; \ - s.write_function = zap_console_stream_write; \ - s.raw_write_function = zap_console_stream_raw_write; \ - s.alloc_len = ZAP_CMD_CHUNK_LEN; \ - s.alloc_chunk = ZAP_CMD_CHUNK_LEN - -struct zap_event { - zap_event_type_t e_type; - uint32_t enum_id; - zap_channel_t *channel; - void *data; -}; - -#define ZAP_TOKEN_STRLEN 128 -#define ZAP_MAX_TOKENS 10 - -static __inline__ char *zap_clean_string(char *s) -{ - char *p; - - for (p = s; p && *p; p++) { - uint8_t x = (uint8_t) *p; - if (x < 32 || x > 127) { - *p = ' '; - } - } - - return s; -} - -struct zap_bitstream { - uint8_t *data; - uint32_t datalen; - uint32_t byte_index; - uint8_t bit_index; - int8_t endian; - uint8_t top; - uint8_t bot; - uint8_t ss; - uint8_t ssv; -}; - -struct zap_fsk_data_state { - dsp_fsk_handle_t *fsk1200_handle; - uint8_t init; - uint8_t *buf; - size_t bufsize; - zap_size_t blen; - zap_size_t bpos; - zap_size_t dlen; - zap_size_t ppos; - int checksum; -}; - -struct zap_fsk_modulator { - teletone_dds_state_t dds; - zap_bitstream_t bs; - uint32_t carrier_bits_start; - uint32_t carrier_bits_stop; - uint32_t chan_sieze_bits; - uint32_t bit_factor; - uint32_t bit_accum; - uint32_t sample_counter; - int32_t samples_per_bit; - int32_t est_bytes; - fsk_modem_types_t modem_type; - zap_fsk_data_state_t *fsk_data; - zap_fsk_write_sample_t write_sample_callback; - void *user_data; - int16_t sample_buffer[64]; -}; - -/** - * Type Of Number (TON) - */ -typedef enum { - ZAP_TON_UNKNOWN = 0, - ZAP_TON_INTERNATIONAL, - ZAP_TON_NATIONAL, - ZAP_TON_NETWORK_SPECIFIC, - ZAP_TON_SUBSCRIBER_NUMBER, - ZAP_TON_ABBREVIATED_NUMBER, - ZAP_TON_RESERVED -} zap_ton_t; - -typedef struct { - char digits[25]; - uint8_t type; - uint8_t plan; -} zap_number_t; - -typedef enum { - ZAP_CALLER_STATE_DIALING, - ZAP_CALLER_STATE_SUCCESS, - ZAP_CALLER_STATE_FAIL -} zap_caller_state_t; - -struct zap_caller_data { - char cid_date[8]; - char cid_name[80]; - zap_number_t cid_num; - zap_number_t ani; - zap_number_t dnis; - zap_number_t rdnis; - char aniII[25]; - uint8_t screen; - uint8_t pres; - char collected[25]; - int CRV; - int hangup_cause; - uint8_t raw_data[1024]; - uint32_t raw_data_len; - uint32_t flags; - zap_caller_state_t call_state; - uint32_t chan_id; -}; - -typedef enum { - ZAP_TYPE_NONE, - ZAP_TYPE_SPAN = 0xFF, - ZAP_TYPE_CHANNEL -} zap_data_type_t; - -/* 2^8 table size, one for each byte value */ -#define ZAP_GAINS_TABLE_SIZE 256 -struct zap_channel { - zap_data_type_t data_type; - uint32_t span_id; - uint32_t chan_id; - uint32_t physical_span_id; - uint32_t physical_chan_id; - uint32_t rate; - uint32_t extra_id; - zap_chan_type_t type; - zap_socket_t sockfd; - zap_channel_flag_t flags; - uint32_t pflags; - uint32_t sflags; - zap_alarm_flag_t alarm_flags; - zap_channel_feature_t features; - zap_codec_t effective_codec; - zap_codec_t native_codec; - uint32_t effective_interval; - uint32_t native_interval; - uint32_t packet_len; - zap_channel_state_t state; - zap_channel_state_t last_state; - zap_channel_state_t init_state; - zap_mutex_t *mutex; - teletone_dtmf_detect_state_t dtmf_detect; - uint32_t buffer_delay; - zap_event_t event_header; - char last_error[256]; - zio_event_cb_t event_callback; - uint32_t skip_read_frames; - zap_buffer_t *dtmf_buffer; - zap_buffer_t *gen_dtmf_buffer; - zap_buffer_t *pre_buffer; - zap_buffer_t *digit_buffer; - zap_buffer_t *fsk_buffer; - zap_mutex_t *pre_buffer_mutex; - uint32_t dtmf_on; - uint32_t dtmf_off; - char *dtmf_hangup_buf; - teletone_generation_session_t tone_session; - zap_time_t last_event_time; - zap_time_t ring_time; - char tokens[ZAP_MAX_TOKENS+1][ZAP_TOKEN_STRLEN]; - uint8_t needed_tones[ZAP_TONEMAP_INVALID]; - uint8_t detected_tones[ZAP_TONEMAP_INVALID]; - zap_tonemap_t last_detected_tone; - uint32_t token_count; - char chan_name[128]; - char chan_number[32]; - zap_filehandle_t fds[2]; - zap_fsk_data_state_t fsk; - uint8_t fsk_buf[80]; - uint32_t ring_count; - void *mod_data; - void *call_data; - struct zap_caller_data caller_data; - struct zap_span *span; - struct zap_io_interface *zio; - zap_hash_t *variable_hash; - unsigned char rx_cas_bits; - uint32_t pre_buffer_size; - unsigned char rxgain_table[ZAP_GAINS_TABLE_SIZE]; - unsigned char txgain_table[ZAP_GAINS_TABLE_SIZE]; - float rxgain; - float txgain; -}; - - -struct zap_sigmsg { - zap_signal_event_t event_id; - uint32_t chan_id; - uint32_t span_id; - zap_channel_t *channel; - void *raw_data; - uint32_t raw_data_len; -}; - - -struct zap_span { - zap_data_type_t data_type; - char *name; - uint32_t span_id; - uint32_t chan_count; - zap_span_flag_t flags; - struct zap_io_interface *zio; - zio_event_cb_t event_callback; - zap_mutex_t *mutex; - zap_trunk_type_t trunk_type; - zap_analog_start_type_t start_type; - zap_signal_type_t signal_type; - void *signal_data; - zap_event_t event_header; - char last_error[256]; - char tone_map[ZAP_TONEMAP_INVALID+1][ZAP_TONEMAP_LEN]; - teletone_tone_map_t tone_detect_map[ZAP_TONEMAP_INVALID+1]; - teletone_multi_tone_t tone_finder[ZAP_TONEMAP_INVALID+1]; - zap_channel_t *channels[ZAP_MAX_CHANNELS_SPAN+1]; - zio_channel_outgoing_call_t outgoing_call; - zio_channel_set_sig_status_t set_channel_sig_status; - zio_channel_get_sig_status_t get_channel_sig_status; - zio_span_set_sig_status_t set_span_sig_status; - zio_span_get_sig_status_t get_span_sig_status; - zio_channel_request_t channel_request; - zap_span_start_t start; - zap_span_stop_t stop; - void *mod_data; - char *type; - char *dtmf_hangup; - size_t dtmf_hangup_len; - int suggest_chan_id; - zap_state_map_t *state_map; - struct zap_span *next; -}; - -struct zap_group { - char *name; - uint32_t group_id; - uint32_t chan_count; - zap_channel_t *channels[ZAP_MAX_CHANNELS_GROUP]; - uint32_t last_used_index; - zap_mutex_t *mutex; - struct zap_group *next; -}; - -OZ_DECLARE_DATA extern zap_logger_t zap_log; - -typedef enum { - ZAP_CRASH_NEVER = 0, - ZAP_CRASH_ON_ASSERT -} zap_crash_policy_t; - -OZ_DECLARE_DATA extern zap_crash_policy_t g_zap_crash_policy; - -typedef void *(*zap_malloc_func_t)(void *pool, zap_size_t len); -typedef void *(*zap_calloc_func_t)(void *pool, zap_size_t elements, zap_size_t len); -typedef void (*zap_free_func_t)(void *pool, void *ptr); -typedef struct zap_memory_handler { - void *pool; - zap_malloc_func_t malloc; - zap_calloc_func_t calloc; - zap_free_func_t free; -} zap_memory_handler_t; - -OZ_DECLARE_DATA extern zap_memory_handler_t g_zap_mem_handler; - -struct zap_io_interface { - const char *name; - zio_configure_span_t configure_span; - zio_configure_t configure; - zio_open_t open; - zio_close_t close; - zio_channel_destroy_t channel_destroy; - zio_span_destroy_t span_destroy; - zio_get_alarms_t get_alarms; - zio_command_t command; - zio_wait_t wait; - zio_read_t read; - zio_write_t write; - zio_span_poll_event_t poll_event; - zio_span_next_event_t next_event; - zio_api_t api; -}; - -typedef struct zap_queue zap_queue_t; -typedef zap_status_t (*zap_queue_create_func_t)(zap_queue_t **queue, zap_size_t capacity); -typedef zap_status_t (*zap_queue_enqueue_func_t)(zap_queue_t *queue, void *obj); -typedef void *(*zap_queue_dequeue_func_t)(zap_queue_t *queue); -typedef zap_status_t (*zap_queue_wait_func_t)(zap_queue_t *queue, int ms); -typedef zap_status_t (*zap_queue_destroy_func_t)(zap_queue_t **queue); -typedef struct zap_queue_handler { - zap_queue_create_func_t create; - zap_queue_enqueue_func_t enqueue; - zap_queue_dequeue_func_t dequeue; - zap_queue_wait_func_t wait; - zap_queue_destroy_func_t destroy; -} zap_queue_handler_t; -OZ_DECLARE_DATA extern zap_queue_handler_t g_zap_queue_handler; - -/*! brief create a new queue */ -#define zap_queue_create(queue, capacity) g_zap_queue_handler.create(queue, capacity) - -/*! Enqueue an object */ -#define zap_queue_enqueue(queue, obj) g_zap_queue_handler.enqueue(queue, obj) - -/*! dequeue an object from the queue */ -#define zap_queue_dequeue(queue) g_zap_queue_handler.dequeue(queue) - -/*! wait ms milliseconds for a queue to have available objects, -1 to wait forever */ -#define zap_queue_wait(queue, ms) g_zap_queue_handler.wait(queue, ms) - -/*! destroy the queue */ -#define zap_queue_destroy(queue) g_zap_queue_handler.destroy(queue) - -/*! \brief Override the default queue handler */ -OZ_DECLARE(zap_status_t) zap_global_set_queue_handler(zap_queue_handler_t *handler); - -/*! \brief Duplicate string */ -OZ_DECLARE(char *) zap_strdup(const char *str); -OZ_DECLARE(char *) zap_strndup(const char *str, zap_size_t inlen); - -OZ_DECLARE(zap_size_t) zap_fsk_modulator_generate_bit(zap_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, zap_size_t buflen); -OZ_DECLARE(int32_t) zap_fsk_modulator_generate_carrier_bits(zap_fsk_modulator_t *fsk_trans, uint32_t bits); -OZ_DECLARE(void) zap_fsk_modulator_generate_chan_sieze(zap_fsk_modulator_t *fsk_trans); -OZ_DECLARE(void) zap_fsk_modulator_send_data(zap_fsk_modulator_t *fsk_trans); -#define zap_fsk_modulator_send_all(_it) zap_fsk_modulator_generate_chan_sieze(_it); \ - zap_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_start); \ - zap_fsk_modulator_send_data(_it); \ - zap_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_stop) - -OZ_DECLARE(zap_status_t) zap_fsk_modulator_init(zap_fsk_modulator_t *fsk_trans, - fsk_modem_types_t modem_type, - uint32_t sample_rate, - zap_fsk_data_state_t *fsk_data, - float db_level, - uint32_t carrier_bits_start, - uint32_t carrier_bits_stop, - uint32_t chan_sieze_bits, - zap_fsk_write_sample_t write_sample_callback, - void *user_data); -OZ_DECLARE(int8_t) zap_bitstream_get_bit(zap_bitstream_t *bsp); -OZ_DECLARE(void) zap_bitstream_init(zap_bitstream_t *bsp, uint8_t *data, uint32_t datalen, zap_endian_t endian, uint8_t ss); -OZ_DECLARE(zap_status_t) zap_fsk_data_parse(zap_fsk_data_state_t *state, zap_size_t *type, char **data, zap_size_t *len); -OZ_DECLARE(zap_status_t) zap_fsk_demod_feed(zap_fsk_data_state_t *state, int16_t *data, size_t samples); -OZ_DECLARE(zap_status_t) zap_fsk_demod_destroy(zap_fsk_data_state_t *state); -OZ_DECLARE(int) zap_fsk_demod_init(zap_fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize); -OZ_DECLARE(zap_status_t) zap_fsk_data_init(zap_fsk_data_state_t *state, uint8_t *data, uint32_t datalen); -OZ_DECLARE(zap_status_t) zap_fsk_data_add_mdmf(zap_fsk_data_state_t *state, zap_mdmf_type_t type, const uint8_t *data, uint32_t datalen); -OZ_DECLARE(zap_status_t) zap_fsk_data_add_checksum(zap_fsk_data_state_t *state); -OZ_DECLARE(zap_status_t) zap_fsk_data_add_sdmf(zap_fsk_data_state_t *state, const char *date, char *number); -OZ_DECLARE(zap_status_t) zap_channel_outgoing_call(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_channel_set_sig_status(zap_channel_t *zchan, zap_signaling_status_t status); -OZ_DECLARE(zap_status_t) zap_channel_get_sig_status(zap_channel_t *zchan, zap_signaling_status_t *status); -OZ_DECLARE(zap_status_t) zap_span_set_sig_status(zap_span_t *span, zap_signaling_status_t status); -OZ_DECLARE(zap_status_t) zap_span_get_sig_status(zap_span_t *span, zap_signaling_status_t *status); -OZ_DECLARE(void) zap_channel_rotate_tokens(zap_channel_t *zchan); -OZ_DECLARE(void) zap_channel_clear_detected_tones(zap_channel_t *zchan); -OZ_DECLARE(void) zap_channel_clear_needed_tones(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_channel_get_alarms(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_channel_send_fsk_data(zap_channel_t *zchan, zap_fsk_data_state_t *fsk_data, float db_level); -OZ_DECLARE(zap_status_t) zap_channel_clear_token(zap_channel_t *zchan, const char *token); -OZ_DECLARE(void) zap_channel_replace_token(zap_channel_t *zchan, const char *old_token, const char *new_token); -OZ_DECLARE(zap_status_t) zap_channel_add_token(zap_channel_t *zchan, char *token, int end); -OZ_DECLARE(zap_status_t) zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state, int lock); -OZ_DECLARE(zap_status_t) zap_span_load_tones(zap_span_t *span, const char *mapname); -OZ_DECLARE(zap_size_t) zap_channel_dequeue_dtmf(zap_channel_t *zchan, char *dtmf, zap_size_t len); -OZ_DECLARE(zap_status_t) zap_channel_queue_dtmf(zap_channel_t *zchan, const char *dtmf); -OZ_DECLARE(void) zap_channel_flush_dtmf(zap_channel_t *zchan); -OZ_DECLARE(zap_time_t) zap_current_time_in_ms(void); -OZ_DECLARE(zap_status_t) zap_span_poll_event(zap_span_t *span, uint32_t ms); -OZ_DECLARE(zap_status_t) zap_span_next_event(zap_span_t *span, zap_event_t **event); -OZ_DECLARE(zap_status_t) zap_span_find(uint32_t id, zap_span_t **span); -OZ_DECLARE(zap_status_t) zap_span_create(zap_io_interface_t *zio, zap_span_t **span, const char *name); -OZ_DECLARE(zap_status_t) zap_span_close_all(void); -OZ_DECLARE(zap_status_t) zap_span_add_channel(zap_span_t *span, zap_socket_t sockfd, zap_chan_type_t type, zap_channel_t **chan); -OZ_DECLARE(zap_status_t) zap_span_set_event_callback(zap_span_t *span, zio_event_cb_t event_callback); -OZ_DECLARE(zap_status_t) zap_channel_add_to_group(const char* name, zap_channel_t* zchan); -OZ_DECLARE(zap_status_t) zap_group_add_channels(const char* name, zap_span_t* span, const char* val); -OZ_DECLARE(zap_status_t) zap_channel_remove_from_group(zap_group_t* group, zap_channel_t* zchan); -OZ_DECLARE(zap_status_t) zap_group_find(uint32_t id, zap_group_t **group); -OZ_DECLARE(zap_status_t) zap_group_find_by_name(const char *name, zap_group_t **group); -OZ_DECLARE(zap_status_t) zap_group_create(zap_group_t **group, const char *name); -OZ_DECLARE(zap_status_t) zap_channel_set_event_callback(zap_channel_t *zchan, zio_event_cb_t event_callback); -OZ_DECLARE(zap_status_t) zap_channel_open(uint32_t span_id, uint32_t chan_id, zap_channel_t **zchan); -OZ_DECLARE(zap_status_t) zap_channel_open_chan(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_span_channel_use_count(zap_span_t *span, uint32_t *count); -OZ_DECLARE(zap_status_t) zap_group_channel_use_count(zap_group_t *group, uint32_t *count); -OZ_DECLARE(zap_status_t) zap_channel_open_by_span(uint32_t span_id, zap_direction_t direction, zap_caller_data_t *caller_data, zap_channel_t **zchan); -OZ_DECLARE(zap_status_t) zap_channel_open_by_group(uint32_t group_id, zap_direction_t direction, zap_caller_data_t *caller_data, zap_channel_t **zchan); -OZ_DECLARE(zap_status_t) zap_channel_close(zap_channel_t **zchan); -OZ_DECLARE(zap_status_t) zap_channel_done(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_channel_use(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_channel_command(zap_channel_t *zchan, zap_command_t command, void *obj); -OZ_DECLARE(zap_status_t) zap_channel_wait(zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to); -OZ_DECLARE(zap_status_t) zap_channel_read(zap_channel_t *zchan, void *data, zap_size_t *datalen); -OZ_DECLARE(void) zap_generate_sln_silence(int16_t *data, uint32_t samples, uint32_t divisor); -OZ_DECLARE(zap_status_t) zap_channel_write(zap_channel_t *zchan, void *data, zap_size_t datasize, zap_size_t *datalen); -OZ_DECLARE(zap_status_t) zap_channel_add_var(zap_channel_t *zchan, const char *var_name, const char *value); -OZ_DECLARE(const char *) zap_channel_get_var(zap_channel_t *zchan, const char *var_name); -OZ_DECLARE(zap_status_t) zap_channel_clear_vars(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_global_init(void); -OZ_DECLARE(zap_status_t) zap_global_configuration(void); -OZ_DECLARE(zap_status_t) zap_global_destroy(void); -OZ_DECLARE(zap_status_t) zap_global_set_memory_handler(zap_memory_handler_t *handler); -OZ_DECLARE(void) zap_global_set_crash_policy(zap_crash_policy_t policy); -OZ_DECLARE(void) zap_global_set_logger(zap_logger_t logger); -OZ_DECLARE(void) zap_global_set_default_logger(int level); -OZ_DECLARE(uint32_t) zap_separate_string(char *buf, char delim, char **array, int arraylen); -OZ_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, int e, uint8_t ss); -OZ_DECLARE(void) print_hex_bytes(uint8_t *data, zap_size_t dlen, char *buf, zap_size_t blen); -OZ_DECLARE_NONSTD(int) zap_hash_equalkeys(void *k1, void *k2); -OZ_DECLARE_NONSTD(uint32_t) zap_hash_hashfromstring(void *ky); -OZ_DECLARE(uint32_t) zap_running(void); -OZ_DECLARE(zap_status_t) zap_channel_complete_state(zap_channel_t *zchan); -OZ_DECLARE(zap_status_t) zap_channel_init(zap_channel_t *zchan); -OZ_DECLARE(int) zap_load_modules(void); -OZ_DECLARE(zap_status_t) zap_unload_modules(void); -OZ_DECLARE(zap_status_t) zap_configure_span(const char *type, zap_span_t *span, zio_signal_cb_t sig_cb, ...); -OZ_DECLARE(zap_status_t) zap_configure_span_signaling(const char *type, zap_span_t *span, zio_signal_cb_t sig_cb, zap_conf_parameter_t *parameters); -OZ_DECLARE(zap_status_t) zap_span_start(zap_span_t *span); -OZ_DECLARE(zap_status_t) zap_span_stop(zap_span_t *span); -OZ_DECLARE(char *) zap_build_dso_path(const char *name, char *path, zap_size_t len); -OZ_DECLARE(zap_status_t) zap_global_add_io_interface(zap_io_interface_t *io_interface); -OZ_DECLARE(int) zap_load_module(const char *name); -OZ_DECLARE(int) zap_load_module_assume(const char *name); -OZ_DECLARE(zap_status_t) zap_span_find_by_name(const char *name, zap_span_t **span); -OZ_DECLARE(char *) zap_api_execute(const char *type, const char *cmd); -OZ_DECLARE(int) zap_vasprintf(char **ret, const char *fmt, va_list ap); - -ZIO_CODEC_FUNCTION(zio_slin2ulaw); -ZIO_CODEC_FUNCTION(zio_ulaw2slin); -ZIO_CODEC_FUNCTION(zio_slin2alaw); -ZIO_CODEC_FUNCTION(zio_alaw2slin); -ZIO_CODEC_FUNCTION(zio_ulaw2alaw); -ZIO_CODEC_FUNCTION(zio_alaw2ulaw); - -#ifdef DEBUG_LOCKS -#define zap_mutex_lock(_x) printf("++++++lock %s:%d\n", __FILE__, __LINE__) && _zap_mutex_lock(_x) -#define zap_mutex_trylock(_x) printf("++++++try %s:%d\n", __FILE__, __LINE__) && _zap_mutex_trylock(_x) -#define zap_mutex_unlock(_x) printf("------unlock %s:%d\n", __FILE__, __LINE__) && _zap_mutex_unlock(_x) -#else -#define zap_mutex_lock(_x) _zap_mutex_lock(_x) -#define zap_mutex_trylock(_x) _zap_mutex_trylock(_x) -#define zap_mutex_unlock(_x) _zap_mutex_unlock(_x) -#endif - -/*! - \brief Assert condition -*/ -#define zap_assert(assertion, msg) \ - if (!(assertion)) { \ - zap_log(ZAP_LOG_CRIT, msg); \ - if (g_zap_crash_policy & ZAP_CRASH_ON_ASSERT) { \ - zap_abort(); \ - } \ - } - -/*! - \brief Assert condition and return -*/ -#define zap_assert_return(assertion, retval, msg) \ - if (!(assertion)) { \ - zap_log(ZAP_LOG_CRIT, msg); \ - if (g_zap_crash_policy & ZAP_CRASH_ON_ASSERT) { \ - zap_abort(); \ - } else { \ - return retval; \ - } \ - } - -/*! - \brief Allocate uninitialized memory - \command chunksize the chunk size -*/ -#define zap_malloc(chunksize) g_zap_mem_handler.malloc(g_zap_mem_handler.pool, chunksize) - -/*! - \brief Allocate initialized memory - \command chunksize the chunk size -*/ -#define zap_calloc(elements, chunksize) g_zap_mem_handler.calloc(g_zap_mem_handler.pool, elements, chunksize) - -/*! - \brief Free chunk of memory - \command chunksize the chunk size -*/ -#define zap_free(chunk) g_zap_mem_handler.free(g_zap_mem_handler.pool, chunk) - -/*! - \brief Free a pointer and set it to NULL unless it already is NULL - \command it the pointer -*/ -#define zap_safe_free(it) if (it) { zap_free(it); it = NULL; } - -/*! - \brief Socket the given socket - \command it the socket -*/ -#define zap_socket_close(it) if (it > -1) { close(it); it = -1;} - -static __inline__ void zap_abort(void) -{ -#ifdef __cplusplus - ::abort(); -#else - abort(); -#endif -} - -static __inline__ void zap_set_state_all(zap_span_t *span, zap_channel_state_t state) -{ - uint32_t j; - zap_mutex_lock(span->mutex); - for(j = 1; j <= span->chan_count; j++) { - zap_set_state_locked((span->channels[j]), state); - } - zap_mutex_unlock(span->mutex); -} - -static __inline__ int zap_check_state_all(zap_span_t *span, zap_channel_state_t state) -{ - uint32_t j; - for(j = 1; j <= span->chan_count; j++) { - if (span->channels[j]->state != state || zap_test_flag(span->channels[j], ZAP_CHANNEL_STATE_CHANGE)) { - return 0; - } - } - - return 1; -} - -static __inline__ void zap_set_flag_all(zap_span_t *span, uint32_t flag) -{ - uint32_t j; - zap_mutex_lock(span->mutex); - for(j = 1; j <= span->chan_count; j++) { - zap_set_flag_locked((span->channels[j]), flag); - } - zap_mutex_unlock(span->mutex); -} - -static __inline__ void zap_clear_flag_all(zap_span_t *span, uint32_t flag) -{ - uint32_t j; - zap_mutex_lock(span->mutex); - for(j = 1; j <= span->chan_count; j++) { - zap_clear_flag_locked((span->channels[j]), flag); - } - zap_mutex_unlock(span->mutex); -} - -#ifdef __cplusplus -} /* extern C */ -#endif - -#endif - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ diff --git a/libs/freetdm/src/include/zap_buffer.h b/libs/freetdm/src/include/zap_buffer.h deleted file mode 100644 index 03d4caae11..0000000000 --- a/libs/freetdm/src/include/zap_buffer.h +++ /dev/null @@ -1,154 +0,0 @@ -/* - * Copyright (c) 2007, Anthony Minessale II - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#ifndef ZAP_BUFFER_H -#define ZAP_BUFFER_H - -#include "openzap.h" - -#ifdef __cplusplus -extern "C" { -#endif - -/** - * @defgroup zap_buffer Buffer Routines - * @ingroup buffer - * The purpose of this module is to make a plain buffering interface that can be used for read/write buffers - * throughout the application. - * @{ - */ -struct zap_buffer; -typedef struct zap_buffer zap_buffer_t; - -/*! \brief Allocate a new dynamic zap_buffer - * \param buffer returned pointer to the new buffer - * \param blocksize length to realloc by as data is added - * \param start_len ammount of memory to reserve initially - * \param max_len length the buffer is allowed to grow to - * \return status - */ -OZ_DECLARE(zap_status_t) zap_buffer_create(zap_buffer_t **buffer, zap_size_t blocksize, zap_size_t start_len, zap_size_t max_len); - -/*! \brief Get the length of a zap_buffer_t - * \param buffer any buffer of type zap_buffer_t - * \return int size of the buffer. - */ -OZ_DECLARE(zap_size_t) zap_buffer_len(zap_buffer_t *buffer); - -/*! \brief Get the freespace of a zap_buffer_t - * \param buffer any buffer of type zap_buffer_t - * \return int freespace in the buffer. - */ -OZ_DECLARE(zap_size_t) zap_buffer_freespace(zap_buffer_t *buffer); - -/*! \brief Get the in use amount of a zap_buffer_t - * \param buffer any buffer of type zap_buffer_t - * \return int ammount of buffer curently in use - */ -OZ_DECLARE(zap_size_t) zap_buffer_inuse(zap_buffer_t *buffer); - -/*! \brief Read data from a zap_buffer_t up to the ammount of datalen if it is available. Remove read data from buffer. - * \param buffer any buffer of type zap_buffer_t - * \param data pointer to the read data to be returned - * \param datalen amount of data to be returned - * \return int ammount of data actually read - */ -OZ_DECLARE(zap_size_t) zap_buffer_read(zap_buffer_t *buffer, void *data, zap_size_t datalen); - -/*! \brief Read data endlessly from a zap_buffer_t - * \param buffer any buffer of type zap_buffer_t - * \param data pointer to the read data to be returned - * \param datalen amount of data to be returned - * \return int ammount of data actually read - * \note Once you have read all the data from the buffer it will loop around. - */ -OZ_DECLARE(zap_size_t) zap_buffer_read_loop(zap_buffer_t *buffer, void *data, zap_size_t datalen); - -/*! \brief Assign a number of loops to read - * \param buffer any buffer of type zap_buffer_t - * \param loops the number of loops (-1 for infinite) - */ -OZ_DECLARE(void) zap_buffer_set_loops(zap_buffer_t *buffer, int32_t loops); - -/*! \brief Write data into a zap_buffer_t up to the length of datalen - * \param buffer any buffer of type zap_buffer_t - * \param data pointer to the data to be written - * \param datalen amount of data to be written - * \return int amount of buffer used after the write, or 0 if no space available - */ -OZ_DECLARE(zap_size_t) zap_buffer_write(zap_buffer_t *buffer, const void *data, zap_size_t datalen); - -/*! \brief Remove data from the buffer - * \param buffer any buffer of type zap_buffer_t - * \param datalen amount of data to be removed - * \return int size of buffer, or 0 if unable to toss that much data - */ -OZ_DECLARE(zap_size_t) zap_buffer_toss(zap_buffer_t *buffer, zap_size_t datalen); - -/*! \brief Remove all data from the buffer - * \param buffer any buffer of type zap_buffer_t - */ -OZ_DECLARE(void) zap_buffer_zero(zap_buffer_t *buffer); - -/*! \brief Destroy the buffer - * \param buffer buffer to destroy - * \note only neccessary on dynamic buffers (noop on pooled ones) - */ -OZ_DECLARE(void) zap_buffer_destroy(zap_buffer_t **buffer); - -/*! \brief Seek to offset from the beginning of the buffer - * \param buffer buffer to seek - * \param datalen offset in bytes - * \return new position - */ -OZ_DECLARE(zap_size_t) zap_buffer_seek(zap_buffer_t *buffer, zap_size_t datalen); - -/** @} */ - -OZ_DECLARE(zap_size_t) zap_buffer_zwrite(zap_buffer_t *buffer, const void *data, zap_size_t datalen); - -#ifdef __cplusplus -} -#endif - -#endif -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ diff --git a/libs/freetdm/src/include/zap_config.h b/libs/freetdm/src/include/zap_config.h deleted file mode 100644 index d961700ea4..0000000000 --- a/libs/freetdm/src/include/zap_config.h +++ /dev/null @@ -1,145 +0,0 @@ -/* - * Copyright (c) 2007, Anthony Minessale II - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -/** - * @defgroup config Config File Parser - * @ingroup config - * This module implements a basic interface and file format parser - * - * 
- *
- * EXAMPLE 
- * 
- * [category1]
- * var1 => val1
- * var2 => val2
- * \# lines that begin with \# are comments
- * \#var3 => val3
- *
- * @{ - */ - -#ifndef ZAP_CONFIG_H -#define ZAP_CONFIG_H - -#include "openzap.h" -#define ZAP_URL_SEPARATOR "://" - - -#ifdef WIN32 -#define ZAP_PATH_SEPARATOR "\\" -#ifndef ZAP_CONFIG_DIR -#define ZAP_CONFIG_DIR "c:\\openzap" -#endif -#define zap_is_file_path(file) (*(file +1) == ':' || *file == '/' || strstr(file, SWITCH_URL_SEPARATOR)) -#else -#define ZAP_PATH_SEPARATOR "/" -#ifndef ZAP_CONFIG_DIR -#define ZAP_CONFIG_DIR "/etc/openzap" -#endif -#define zap_is_file_path(file) ((*file == '/') || strstr(file, SWITCH_URL_SEPARATOR)) -#endif - -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct zap_config zap_config_t; - -/*! \brief A simple file handle representing an open configuration file **/ -struct zap_config { - /*! FILE stream buffer to the opened file */ - FILE *file; - /*! path to the file */ - char path[512]; - /*! current category */ - char category[256]; - /*! current section */ - char section[256]; - /*! buffer of current line being read */ - char buf[1024]; - /*! current line number in file */ - int lineno; - /*! current category number in file */ - int catno; - /*! current section number in file */ - int sectno; - - int lockto; -}; - -/*! - \brief Open a configuration file - \param cfg (zap_config_t *) config handle to use - \param file_path path to the file - \return 1 (true) on success 0 (false) on failure -*/ -int zap_config_open_file(zap_config_t * cfg, const char *file_path); - -/*! - \brief Close a previously opened configuration file - \param cfg (zap_config_t *) config handle to use -*/ -void zap_config_close_file(zap_config_t * cfg); - -/*! - \brief Retrieve next name/value pair from configuration file - \param cfg (zap_config_t *) config handle to use - \param var pointer to aim at the new variable name - \param val pointer to aim at the new value -*/ -int zap_config_next_pair(zap_config_t * cfg, char **var, char **val); - -/*! - \brief Retrieve the CAS bits from a configuration string value - \param strvalue pointer to the configuration string value (expected to be in format whatever:xxxx) - \param outbits pointer to aim at the CAS bits -*/ -OZ_DECLARE (int) zap_config_get_cas_bits(char *strvalue, unsigned char *outbits); - -#ifdef __cplusplus -} -#endif - -/** @} */ -#endif -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ diff --git a/libs/freetdm/src/include/zap_dso.h b/libs/freetdm/src/include/zap_dso.h deleted file mode 100644 index c5d1457b95..0000000000 --- a/libs/freetdm/src/include/zap_dso.h +++ /dev/null @@ -1,51 +0,0 @@ -/* - * Cross Platform dso/dll load abstraction - * Copyright(C) 2008 Michael Jerris - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so. - * - * This work is provided under this license on an "as is" basis, without warranty of any kind, - * either expressed or implied, including, without limitation, warranties that the covered code - * is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire - * risk as to the quality and performance of the covered code is with you. Should any covered - * code prove defective in any respect, you (not the initial developer or any other contributor) - * assume the cost of any necessary servicing, repair or correction. This disclaimer of warranty - * constitutes an essential part of this license. No use of any covered code is authorized hereunder - * except under this disclaimer. - * - */ - - -#ifndef _ZAP_DSO_H -#define _ZAP_DSO_H - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void (*zap_func_ptr_t) (void); -typedef void * zap_dso_lib_t; - -OZ_DECLARE(void) zap_dso_destroy(zap_dso_lib_t *lib); -OZ_DECLARE(zap_dso_lib_t) zap_dso_open(const char *path, char **err); -OZ_DECLARE(void *) zap_dso_func_sym(zap_dso_lib_t lib, const char *sym, char **err); - -#ifdef __cplusplus -} -#endif - -#endif - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4 - */ - diff --git a/libs/freetdm/src/include/zap_m3ua.h b/libs/freetdm/src/include/zap_m3ua.h deleted file mode 100644 index c06d112093..0000000000 --- a/libs/freetdm/src/include/zap_m3ua.h +++ /dev/null @@ -1,134 +0,0 @@ -/* - * zap_m3ua.h - * openzap - * - * Created by Shane Burrell on 4/3/08. - * Copyright 2008 Shane Burrell. All rights reserved. - * - * Copyright (c) 2007, Anthony Minessale II, Nenad Corbic - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - - -//#include "m3ua_client.h" -#include "openzap.h" - -#ifdef __cplusplus -extern "C" { -#endif -enum e_sigboost_event_id_values -{ - SIGBOOST_EVENT_CALL_START = 0x80, /*128*/ - SIGBOOST_EVENT_CALL_START_ACK = 0x81, /*129*/ - SIGBOOST_EVENT_CALL_START_NACK = 0x82, /*130*/ - SIGBOOST_EVENT_CALL_START_NACK_ACK = 0x83, /*131*/ - SIGBOOST_EVENT_CALL_ANSWERED = 0x84, /*132*/ - SIGBOOST_EVENT_CALL_STOPPED = 0x85, /*133*/ - SIGBOOST_EVENT_CALL_STOPPED_ACK = 0x86, /*134*/ - SIGBOOST_EVENT_SYSTEM_RESTART = 0x87, /*135*/ - SIGBOOST_EVENT_SYSTEM_RESTART_ACK = 0x88, /*136*/ - /* Following IDs are ss7boost to sangoma_mgd only. */ - SIGBOOST_EVENT_HEARTBEAT = 0x89, /*137*/ - SIGBOOST_EVENT_INSERT_CHECK_LOOP = 0x8a, /*138*/ - SIGBOOST_EVENT_REMOVE_CHECK_LOOP = 0x8b, /*139*/ - SIGBOOST_EVENT_AUTO_CALL_GAP_ABATE = 0x8c, /*140*/ -}; -enum e_sigboost_release_cause_values -{ - SIGBOOST_RELEASE_CAUSE_UNDEFINED = 0, - SIGBOOST_RELEASE_CAUSE_NORMAL = 16, - SIGBOOST_RELEASE_CAUSE_BUSY = 17, - /* probable elimination */ - //SIGBOOST_RELEASE_CAUSE_BUSY = 0x91, /* 145 */ - //SIGBOOST_RELEASE_CAUSE_CALLED_NOT_EXIST = 0x92, /* 146 */ - //SIGBOOST_RELEASE_CAUSE_CIRCUIT_RESET = 0x93, /* 147 */ - //SIGBOOST_RELEASE_CAUSE_NOANSWER = 0x94, /* 148 */ -}; - -enum e_sigboost_call_setup_ack_nack_cause_values -{ - SIGBOOST_CALL_SETUP_NACK_ALL_CKTS_BUSY = 117, /* unused Q.850 value */ - SIGBOOST_CALL_SETUP_NACK_TEST_CKT_BUSY = 118, /* unused Q.850 value */ - SIGBOOST_CALL_SETUP_NACK_INVALID_NUMBER = 28, - /* probable elimination */ - //SIGBOOST_CALL_SETUP_RESERVED = 0x00, - //SIGBOOST_CALL_SETUP_CIRCUIT_RESET = 0x10, - //SIGBOOST_CALL_SETUP_NACK_CKT_START_TIMEOUT = 0x11, - //SIGBOOST_CALL_SETUP_NACK_AUTO_CALL_GAP = 0x17, -}; -typedef enum { - M3UA_SPAN_SIGNALING_M3UA, - M3UA_SPAN_SIGNALING_SS7BOX, - -} M3UA_TSpanSignaling; -#define M3UA_SPAN_STRINGS "M3UA", "SS7BOX" -ZAP_STR2ENUM_P(m3ua_str2span, m3ua_span2str, M3UA_TSpanSignaling) - - - -typedef enum { - ZAP_M3UA_RUNNING = (1 << 0) -} zap_m3uat_flag_t; - -/*typedef struct m3ua_data { - m3uac_connection_t mcon; - m3uac_connection_t pcon; - zio_signal_cb_t signal_cb; - uint32_t flags; -} m3ua_data_t; - -*/ -/*typedef struct mu3a_link { - ss7bc_connection_t mcon; - ss7bc_connection_t pcon; - zio_signal_cb_t signal_cb; - uint32_t flags; -} zap_m3ua_data_t; -*/ - -zap_status_t m3ua_init(zap_io_interface_t **zint); -zap_status_t m3ua_destroy(void); -zap_status_t m3ua_start(zap_span_t *span); - -#ifdef __cplusplus -} -#endif - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ - diff --git a/libs/freetdm/src/include/zap_threadmutex.h b/libs/freetdm/src/include/zap_threadmutex.h deleted file mode 100644 index 488dca1c42..0000000000 --- a/libs/freetdm/src/include/zap_threadmutex.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Cross Platform Thread/Mutex abstraction - * Copyright(C) 2007 Michael Jerris - * - * You may opt to use, copy, modify, merge, publish, distribute and/or sell - * copies of the Software, and permit persons to whom the Software is - * furnished to do so. - * - * This work is provided under this license on an "as is" basis, without warranty of any kind, - * either expressed or implied, including, without limitation, warranties that the covered code - * is free of defects, merchantable, fit for a particular purpose or non-infringing. The entire - * risk as to the quality and performance of the covered code is with you. Should any covered - * code prove defective in any respect, you (not the initial developer or any other contributor) - * assume the cost of any necessary servicing, repair or correction. This disclaimer of warranty - * constitutes an essential part of this license. No use of any covered code is authorized hereunder - * except under this disclaimer. - * - * Contributors: - * - * Moises Silva - * - */ - - -#ifndef _ZAP_THREADMUTEX_H -#define _ZAP_THREADMUTEX_H - -#include "openzap.h" - -#ifdef __cplusplus -extern "C" { -#endif -typedef struct zap_mutex zap_mutex_t; -typedef struct zap_thread zap_thread_t; -typedef struct zap_condition zap_condition_t; -typedef void *(*zap_thread_function_t) (zap_thread_t *, void *); - -OZ_DECLARE(zap_status_t) zap_thread_create_detached(zap_thread_function_t func, void *data); -OZ_DECLARE(zap_status_t) zap_thread_create_detached_ex(zap_thread_function_t func, void *data, zap_size_t stack_size); -OZ_DECLARE(void) zap_thread_override_default_stacksize(zap_size_t size); -OZ_DECLARE(zap_status_t) zap_mutex_create(zap_mutex_t **mutex); -OZ_DECLARE(zap_status_t) zap_mutex_destroy(zap_mutex_t **mutex); -OZ_DECLARE(zap_status_t) _zap_mutex_lock(zap_mutex_t *mutex); -OZ_DECLARE(zap_status_t) _zap_mutex_trylock(zap_mutex_t *mutex); -OZ_DECLARE(zap_status_t) _zap_mutex_unlock(zap_mutex_t *mutex); -OZ_DECLARE(zap_status_t) zap_condition_create(zap_condition_t **cond, zap_mutex_t *mutex); -OZ_DECLARE(zap_status_t) zap_condition_destroy(zap_condition_t **cond); -OZ_DECLARE(zap_status_t) zap_condition_signal(zap_condition_t *cond); -OZ_DECLARE(zap_status_t) zap_condition_wait(zap_condition_t *cond, int ms); - -#ifdef __cplusplus -} -#endif - -#endif - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ - diff --git a/libs/freetdm/src/include/zap_types.h b/libs/freetdm/src/include/zap_types.h deleted file mode 100644 index e4f6811b57..0000000000 --- a/libs/freetdm/src/include/zap_types.h +++ /dev/null @@ -1,703 +0,0 @@ -/* - * Copyright (c) 2007, Anthony Minessale II - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * Contributors: - * - * Moises Silva - * - */ - -#ifndef ZAP_TYPES_H -#define ZAP_TYPES_H -#include "fsk.h" - -#ifdef WIN32 -#include -typedef HANDLE zap_socket_t; -typedef unsigned __int64 uint64_t; -typedef unsigned __int32 uint32_t; -typedef unsigned __int16 uint16_t; -typedef unsigned __int8 uint8_t; -typedef __int64 int64_t; -typedef __int32 int32_t; -typedef __int16 int16_t; -typedef __int8 int8_t; -typedef intptr_t zap_ssize_t; -typedef int zap_filehandle_t; -#else -#include -#include -#include -#include -typedef int zap_socket_t; -typedef ssize_t zap_ssize_t; -typedef int zap_filehandle_t; -#endif - -#ifdef __cplusplus -extern "C" { -#endif -#define TAG_END NULL - -typedef size_t zap_size_t; -struct zap_io_interface; - -#define ZAP_COMMAND_OBJ_INT *((int *)obj) -#define ZAP_COMMAND_OBJ_CHAR_P (char *)obj -#define ZAP_COMMAND_OBJ_FLOAT *(float *)obj -#define ZAP_FSK_MOD_FACTOR 0x10000 -#define ZAP_DEFAULT_DTMF_ON 250 -#define ZAP_DEFAULT_DTMF_OFF 50 - -#define ZAP_END -1 -#define ZAP_ANY_STATE -1 - -typedef uint64_t zap_time_t; - -typedef enum { - ZAP_ENDIAN_BIG = 1, - ZAP_ENDIAN_LITTLE = -1 -} zap_endian_t; - -typedef enum { - ZAP_CID_TYPE_SDMF = 0x04, - ZAP_CID_TYPE_MDMF = 0x80 -} zap_cid_type_t; - -typedef enum { - MDMF_DATETIME = 1, - MDMF_PHONE_NUM = 2, - MDMF_DDN = 3, - MDMF_NO_NUM = 4, - MDMF_PHONE_NAME = 7, - MDMF_NO_NAME = 8, - MDMF_ALT_ROUTE = 9, - MDMF_INVALID = 10 -} zap_mdmf_type_t; -#define MDMF_STRINGS "X", "DATETIME", "PHONE_NUM", "DDN", "NO_NUM", "X", "X", "PHONE_NAME", "NO_NAME", "ALT_ROUTE", "INVALID" -ZAP_STR2ENUM_P(zap_str2zap_mdmf_type, zap_mdmf_type2str, zap_mdmf_type_t) - -#define ZAP_TONEMAP_LEN 128 -typedef enum { - ZAP_TONEMAP_NONE, - ZAP_TONEMAP_DIAL, - ZAP_TONEMAP_RING, - ZAP_TONEMAP_BUSY, - ZAP_TONEMAP_FAIL1, - ZAP_TONEMAP_FAIL2, - ZAP_TONEMAP_FAIL3, - ZAP_TONEMAP_ATTN, - ZAP_TONEMAP_CALLWAITING_CAS, - ZAP_TONEMAP_CALLWAITING_SAS, - ZAP_TONEMAP_CALLWAITING_ACK, - ZAP_TONEMAP_INVALID -} zap_tonemap_t; -#define TONEMAP_STRINGS "NONE", "DIAL", "RING", "BUSY", "FAIL1", "FAIL2", "FAIL3", "ATTN", "CALLWAITING-CAS", "CALLWAITING-SAS", "CALLWAITING-ACK", "INVALID" -ZAP_STR2ENUM_P(zap_str2zap_tonemap, zap_tonemap2str, zap_tonemap_t) - -typedef enum { - ZAP_TRUNK_E1, - ZAP_TRUNK_T1, - ZAP_TRUNK_J1, - ZAP_TRUNK_BRI, - ZAP_TRUNK_BRI_PTMP, - ZAP_TRUNK_FXO, - ZAP_TRUNK_FXS, - ZAP_TRUNK_EM, - ZAP_TRUNK_NONE -} zap_trunk_type_t; -#define TRUNK_STRINGS "E1", "T1", "J1", "BRI", "BRI_PTMP", "FXO", "FXS", "EM", "NONE" -ZAP_STR2ENUM_P(zap_str2zap_trunk_type, zap_trunk_type2str, zap_trunk_type_t) - -typedef enum { - ZAP_ANALOG_START_KEWL, - ZAP_ANALOG_START_LOOP, - ZAP_ANALOG_START_GROUND, - ZAP_ANALOG_START_WINK, - ZAP_ANALOG_START_NA -} zap_analog_start_type_t; -#define START_TYPE_STRINGS "KEWL", "LOOP", "GROUND", "WINK", "NA" -ZAP_STR2ENUM_P(zap_str2zap_analog_start_type, zap_analog_start_type2str, zap_analog_start_type_t) - -typedef enum { - ZAP_OOB_ONHOOK, - ZAP_OOB_OFFHOOK, - ZAP_OOB_WINK, - ZAP_OOB_FLASH, - ZAP_OOB_RING_START, - ZAP_OOB_RING_STOP, - ZAP_OOB_ALARM_TRAP, - ZAP_OOB_ALARM_CLEAR, - ZAP_OOB_NOOP, - ZAP_OOB_CAS_BITS_CHANGE, - ZAP_OOB_INVALID -} zap_oob_event_t; -#define OOB_STRINGS "DTMF", "ONHOOK", "OFFHOOK", "WINK", "FLASH", "RING_START", "RING_STOP", "ALARM_TRAP", "ALARM_CLEAR", "NOOP", "CAS_BITS_CHANGE", "INVALID" -ZAP_STR2ENUM_P(zap_str2zap_oob_event, zap_oob_event2str, zap_oob_event_t) - -typedef enum { - ZAP_ALARM_NONE = 0, - ZAP_ALARM_RECOVER = (1 << 0), - ZAP_ALARM_LOOPBACK = (1 << 2), - ZAP_ALARM_YELLOW = (1 << 3), - ZAP_ALARM_RED = (1 << 4), - ZAP_ALARM_BLUE = (1 << 5), - ZAP_ALARM_NOTOPEN = ( 1 << 6), - ZAP_ALARM_AIS = ( 1 << 7), - ZAP_ALARM_RAI = ( 1 << 8), - ZAP_ALARM_GENERAL = ( 1 << 30) -} zap_alarm_flag_t; - -typedef enum { - ZAP_SIGTYPE_NONE, - ZAP_SIGTYPE_ISDN, - ZAP_SIGTYPE_RBS, - ZAP_SIGTYPE_ANALOG, - ZAP_SIGTYPE_SANGOMABOOST, - ZAP_SIGTYPE_M3UA, - ZAP_SIGTYPE_R2 -} zap_signal_type_t; - -/*! - \brief Signaling status on a given span or specific channel on protocols that support it - */ -typedef enum { - /* The signaling link is down (no d-chans up in the span/group, MFC-R2 bit pattern unidentified) */ - ZAP_SIG_STATE_DOWN, - /* The signaling link is suspended (MFC-R2 bit pattern blocked, ss7 blocked?) */ - ZAP_SIG_STATE_SUSPENDED, - /* The signaling link is ready and calls can be placed */ - ZAP_SIG_STATE_UP, - /* Invalid status */ - ZAP_SIG_STATE_INVALID -} zap_signaling_status_t; -#define SIGSTATUS_STRINGS "DOWN", "SUSPENDED", "UP", "INVALID" -ZAP_STR2ENUM_P(zap_str2zap_signaling_status, zap_signaling_status2str, zap_signaling_status_t) - -typedef enum { - ZAP_SIGEVENT_START, - ZAP_SIGEVENT_STOP, - ZAP_SIGEVENT_TRANSFER, - ZAP_SIGEVENT_ANSWER, - ZAP_SIGEVENT_UP, - ZAP_SIGEVENT_FLASH, - ZAP_SIGEVENT_PROGRESS, - ZAP_SIGEVENT_PROGRESS_MEDIA, - ZAP_SIGEVENT_NOTIFY, - ZAP_SIGEVENT_TONE_DETECTED, - ZAP_SIGEVENT_ALARM_TRAP, - ZAP_SIGEVENT_ALARM_CLEAR, - ZAP_SIGEVENT_MISC, - ZAP_SIGEVENT_COLLECTED_DIGIT, - ZAP_SIGEVENT_ADD_CALL, - ZAP_SIGEVENT_RESTART, - /* Signaling link status changed (D-chan up, down, R2 blocked etc) */ - ZAP_SIGEVENT_SIGSTATUS_CHANGED, - /* Hardware link status changed (Line connected, disconnected) */ - ZAP_SIGEVENT_HWSTATUS_CHANGED, - ZAP_SIGEVENT_INVALID -} zap_signal_event_t; -#define SIGNAL_STRINGS "START", "STOP", "TRANSFER", "ANSWER", "UP", "FLASH", "PROGRESS", \ - "PROGRESS_MEDIA", "NOTIFY", "TONE_DETECTED", "ALARM_TRAP", "ALARM_CLEAR", "MISC", \ - "COLLECTED_DIGIT", "ADD_CALL", "RESTART", "SIGLINK_CHANGED", "HWSTATUS_CHANGED", "INVALID" -ZAP_STR2ENUM_P(zap_str2zap_signal_event, zap_signal_event2str, zap_signal_event_t) - -typedef enum { - ZAP_EVENT_NONE, - ZAP_EVENT_DTMF, - ZAP_EVENT_OOB, - ZAP_EVENT_COUNT -} zap_event_type_t; - -typedef enum { - ZAP_TOP_DOWN, - ZAP_BOTTOM_UP -} zap_direction_t; - -typedef enum { - ZAP_SUCCESS, - ZAP_FAIL, - ZAP_MEMERR, - ZAP_TIMEOUT, - ZAP_NOTIMPL, - ZAP_CHECKSUM_ERROR, - ZAP_STATUS_COUNT, - ZAP_BREAK -} zap_status_t; - -typedef enum { - ZAP_NO_FLAGS = 0, - ZAP_READ = (1 << 0), - ZAP_WRITE = (1 << 1), - ZAP_EVENTS = (1 << 2) -} zap_wait_flag_t; - -typedef enum { - ZAP_CODEC_ULAW = 0, - ZAP_CODEC_ALAW = 8, - ZAP_CODEC_SLIN = 10, - ZAP_CODEC_NONE = (1 << 30) -} zap_codec_t; - -typedef enum { - ZAP_TONE_DTMF = (1 << 0) -} zap_tone_type_t; - -typedef enum { - ZAP_COMMAND_NOOP, - ZAP_COMMAND_SET_INTERVAL, - ZAP_COMMAND_GET_INTERVAL, - ZAP_COMMAND_SET_CODEC, - ZAP_COMMAND_GET_CODEC, - ZAP_COMMAND_SET_NATIVE_CODEC, - ZAP_COMMAND_GET_NATIVE_CODEC, - ZAP_COMMAND_ENABLE_DTMF_DETECT, - ZAP_COMMAND_DISABLE_DTMF_DETECT, - ZAP_COMMAND_SEND_DTMF, - ZAP_COMMAND_SET_DTMF_ON_PERIOD, - ZAP_COMMAND_GET_DTMF_ON_PERIOD, - ZAP_COMMAND_SET_DTMF_OFF_PERIOD, - ZAP_COMMAND_GET_DTMF_OFF_PERIOD, - ZAP_COMMAND_GENERATE_RING_ON, - ZAP_COMMAND_GENERATE_RING_OFF, - ZAP_COMMAND_OFFHOOK, - ZAP_COMMAND_ONHOOK, - ZAP_COMMAND_FLASH, - ZAP_COMMAND_WINK, - ZAP_COMMAND_ENABLE_PROGRESS_DETECT, - ZAP_COMMAND_DISABLE_PROGRESS_DETECT, - ZAP_COMMAND_TRACE_INPUT, - ZAP_COMMAND_TRACE_OUTPUT, - ZAP_COMMAND_ENABLE_CALLERID_DETECT, - ZAP_COMMAND_DISABLE_CALLERID_DETECT, - ZAP_COMMAND_ENABLE_ECHOCANCEL, - ZAP_COMMAND_DISABLE_ECHOCANCEL, - ZAP_COMMAND_ENABLE_ECHOTRAIN, - ZAP_COMMAND_DISABLE_ECHOTRAIN, - ZAP_COMMAND_SET_CAS_BITS, - ZAP_COMMAND_GET_CAS_BITS, - ZAP_COMMAND_SET_RX_GAIN, - ZAP_COMMAND_GET_RX_GAIN, - ZAP_COMMAND_SET_TX_GAIN, - ZAP_COMMAND_GET_TX_GAIN, - ZAP_COMMAND_FLUSH_TX_BUFFERS, - ZAP_COMMAND_FLUSH_RX_BUFFERS, - ZAP_COMMAND_FLUSH_BUFFERS, - ZAP_COMMAND_SET_PRE_BUFFER_SIZE, - ZAP_COMMAND_SET_LINK_STATUS, - ZAP_COMMAND_GET_LINK_STATUS, - ZAP_COMMAND_COUNT -} zap_command_t; - -typedef enum { - ZAP_SPAN_CONFIGURED = (1 << 0), - ZAP_SPAN_READY = (1 << 1), - ZAP_SPAN_STATE_CHANGE = (1 << 2), - ZAP_SPAN_SUSPENDED = (1 << 3), - ZAP_SPAN_IN_THREAD = (1 << 4), - ZAP_SPAN_STOP_THREAD = (1 << 5) -} zap_span_flag_t; - -typedef enum { - ZAP_CHAN_TYPE_B, - ZAP_CHAN_TYPE_DQ921, - ZAP_CHAN_TYPE_DQ931, - ZAP_CHAN_TYPE_FXS, - ZAP_CHAN_TYPE_FXO, - ZAP_CHAN_TYPE_EM, - ZAP_CHAN_TYPE_CAS, - ZAP_CHAN_TYPE_COUNT -} zap_chan_type_t; - -#define CHAN_TYPE_STRINGS "B", "DQ921", "DQ931", "FXS", "FXO", "EM", "CAS", "INVALID" -ZAP_STR2ENUM_P(zap_str2zap_chan_type, zap_chan_type2str, zap_chan_type_t) - -typedef enum { - ZAP_CHANNEL_FEATURE_DTMF_DETECT = (1 << 0), - ZAP_CHANNEL_FEATURE_DTMF_GENERATE = (1 << 1), - ZAP_CHANNEL_FEATURE_CODECS = (1 << 2), - ZAP_CHANNEL_FEATURE_INTERVAL = (1 << 3), - ZAP_CHANNEL_FEATURE_CALLERID = (1 << 4), - ZAP_CHANNEL_FEATURE_PROGRESS = (1 << 5) -} zap_channel_feature_t; - -typedef enum { - ZAP_CHANNEL_STATE_DOWN, - ZAP_CHANNEL_STATE_HOLD, - ZAP_CHANNEL_STATE_SUSPENDED, - ZAP_CHANNEL_STATE_DIALTONE, - ZAP_CHANNEL_STATE_COLLECT, - ZAP_CHANNEL_STATE_RING, - ZAP_CHANNEL_STATE_BUSY, - ZAP_CHANNEL_STATE_ATTN, - ZAP_CHANNEL_STATE_GENRING, - ZAP_CHANNEL_STATE_DIALING, - ZAP_CHANNEL_STATE_GET_CALLERID, - ZAP_CHANNEL_STATE_CALLWAITING, - ZAP_CHANNEL_STATE_RESTART, - ZAP_CHANNEL_STATE_PROGRESS, - ZAP_CHANNEL_STATE_PROGRESS_MEDIA, - ZAP_CHANNEL_STATE_UP, - ZAP_CHANNEL_STATE_IDLE, - ZAP_CHANNEL_STATE_TERMINATING, - ZAP_CHANNEL_STATE_CANCEL, - ZAP_CHANNEL_STATE_HANGUP, - ZAP_CHANNEL_STATE_HANGUP_COMPLETE, - ZAP_CHANNEL_STATE_INVALID -} zap_channel_state_t; -#define CHANNEL_STATE_STRINGS "DOWN", "HOLD", "SUSPENDED", "DIALTONE", "COLLECT", \ - "RING", "BUSY", "ATTN", "GENRING", "DIALING", "GET_CALLERID", "CALLWAITING", \ - "RESTART", "PROGRESS", "PROGRESS_MEDIA", "UP", "IDLE", "TERMINATING", "CANCEL", "HANGUP", "HANGUP_COMPLETE", "INVALID" -ZAP_STR2ENUM_P(zap_str2zap_channel_state, zap_channel_state2str, zap_channel_state_t) - -typedef enum { - ZAP_CHANNEL_CONFIGURED = (1 << 0), - ZAP_CHANNEL_READY = (1 << 1), - ZAP_CHANNEL_OPEN = (1 << 2), - ZAP_CHANNEL_DTMF_DETECT = (1 << 3), - ZAP_CHANNEL_SUPRESS_DTMF = (1 << 4), - ZAP_CHANNEL_TRANSCODE = (1 << 5), - ZAP_CHANNEL_BUFFER = (1 << 6), - ZAP_CHANNEL_EVENT = (1 << 7), - ZAP_CHANNEL_INTHREAD = (1 << 8), - ZAP_CHANNEL_WINK = (1 << 9), - ZAP_CHANNEL_FLASH = (1 << 10), - ZAP_CHANNEL_STATE_CHANGE = (1 << 11), - ZAP_CHANNEL_HOLD = (1 << 12), - ZAP_CHANNEL_INUSE = (1 << 13), - ZAP_CHANNEL_OFFHOOK = (1 << 14), - ZAP_CHANNEL_RINGING = (1 << 15), - ZAP_CHANNEL_PROGRESS_DETECT = (1 << 16), - ZAP_CHANNEL_CALLERID_DETECT = (1 << 17), - ZAP_CHANNEL_OUTBOUND = (1 << 18), - ZAP_CHANNEL_SUSPENDED = (1 << 19), - ZAP_CHANNEL_3WAY = (1 << 20), - ZAP_CHANNEL_PROGRESS = (1 << 21), - ZAP_CHANNEL_MEDIA = (1 << 22), - ZAP_CHANNEL_ANSWERED = (1 << 23), - ZAP_CHANNEL_MUTE = (1 << 24), - ZAP_CHANNEL_USE_RX_GAIN = (1 << 25), - ZAP_CHANNEL_USE_TX_GAIN = (1 << 26), -} zap_channel_flag_t; -#if defined(__cplusplus) && defined(WIN32) - // fix C2676 -__inline__ zap_channel_flag_t operator|=(zap_channel_flag_t a, int32_t b) { - a = (zap_channel_flag_t)(a | b); - return a; -} -__inline__ zap_channel_flag_t operator&=(zap_channel_flag_t a, int32_t b) { - a = (zap_channel_flag_t)(a & b); - return a; -} -#endif - -typedef enum { - ZSM_NONE, - ZSM_UNACCEPTABLE, - ZSM_ACCEPTABLE -} zap_state_map_type_t; - -typedef enum { - ZSD_INBOUND, - ZSD_OUTBOUND, -} zap_state_direction_t; - -#define ZAP_MAP_NODE_SIZE 512 -#define ZAP_MAP_MAX ZAP_CHANNEL_STATE_INVALID+2 - -struct zap_state_map_node { - zap_state_direction_t direction; - zap_state_map_type_t type; - zap_channel_state_t check_states[ZAP_MAP_MAX]; - zap_channel_state_t states[ZAP_MAP_MAX]; -}; -typedef struct zap_state_map_node zap_state_map_node_t; - -struct zap_state_map { - zap_state_map_node_t nodes[ZAP_MAP_NODE_SIZE]; -}; -typedef struct zap_state_map zap_state_map_t; - -typedef enum zap_channel_hw_link_status { - ZAP_HW_LINK_DISCONNECTED = 0, - ZAP_HW_LINK_CONNECTED -} zap_channel_hw_link_status_t; - -typedef struct zap_conf_parameter_s { - const char *var; - const char *val; -} zap_conf_parameter_t; - -typedef struct zap_channel zap_channel_t; -typedef struct zap_event zap_event_t; -typedef struct zap_sigmsg zap_sigmsg_t; -typedef struct zap_span zap_span_t; -typedef struct zap_group zap_group_t; -typedef struct zap_caller_data zap_caller_data_t; -typedef struct zap_io_interface zap_io_interface_t; - -struct zap_stream_handle; -typedef struct zap_stream_handle zap_stream_handle_t; - -typedef zap_status_t (*zap_stream_handle_raw_write_function_t) (zap_stream_handle_t *handle, uint8_t *data, zap_size_t datalen); -typedef zap_status_t (*zap_stream_handle_write_function_t) (zap_stream_handle_t *handle, const char *fmt, ...); - -#define ZIO_CHANNEL_REQUEST_ARGS (zap_span_t *span, uint32_t chan_id, zap_direction_t direction, zap_caller_data_t *caller_data, zap_channel_t **zchan) -#define ZIO_CHANNEL_OUTGOING_CALL_ARGS (zap_channel_t *zchan) -#define ZIO_CHANNEL_SET_SIG_STATUS_ARGS (zap_channel_t *zchan, zap_signaling_status_t status) -#define ZIO_CHANNEL_GET_SIG_STATUS_ARGS (zap_channel_t *zchan, zap_signaling_status_t *status) -#define ZIO_SPAN_SET_SIG_STATUS_ARGS (zap_span_t *span, zap_signaling_status_t status) -#define ZIO_SPAN_GET_SIG_STATUS_ARGS (zap_span_t *span, zap_signaling_status_t *status) -#define ZIO_SPAN_POLL_EVENT_ARGS (zap_span_t *span, uint32_t ms) -#define ZIO_SPAN_NEXT_EVENT_ARGS (zap_span_t *span, zap_event_t **event) -#define ZIO_SIGNAL_CB_ARGS (zap_sigmsg_t *sigmsg) -#define ZIO_EVENT_CB_ARGS (zap_channel_t *zchan, zap_event_t *event) -#define ZIO_CODEC_ARGS (void *data, zap_size_t max, zap_size_t *datalen) -#define ZIO_CONFIGURE_SPAN_ARGS (zap_span_t *span, const char *str, zap_chan_type_t type, char *name, char *number) -#define ZIO_CONFIGURE_ARGS (const char *category, const char *var, const char *val, int lineno) -#define ZIO_OPEN_ARGS (zap_channel_t *zchan) -#define ZIO_CLOSE_ARGS (zap_channel_t *zchan) -#define ZIO_CHANNEL_DESTROY_ARGS (zap_channel_t *zchan) -#define ZIO_SPAN_DESTROY_ARGS (zap_span_t *span) -#define ZIO_COMMAND_ARGS (zap_channel_t *zchan, zap_command_t command, void *obj) -#define ZIO_WAIT_ARGS (zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to) -#define ZIO_GET_ALARMS_ARGS (zap_channel_t *zchan) -#define ZIO_READ_ARGS (zap_channel_t *zchan, void *data, zap_size_t *datalen) -#define ZIO_WRITE_ARGS (zap_channel_t *zchan, void *data, zap_size_t *datalen) -#define ZIO_IO_LOAD_ARGS (zap_io_interface_t **zio) -#define ZIO_IO_UNLOAD_ARGS (void) -#define ZIO_SIG_LOAD_ARGS (void) -#define ZIO_SIG_CONFIGURE_ARGS (zap_span_t *span, zio_signal_cb_t sig_cb, va_list ap) -#define ZIO_CONFIGURE_SPAN_SIGNALING_ARGS (zap_span_t *span, zio_signal_cb_t sig_cb, zap_conf_parameter_t *zap_parameters) -#define ZIO_SIG_UNLOAD_ARGS (void) -#define ZIO_API_ARGS (zap_stream_handle_t *stream, const char *data) - -typedef zap_status_t (*zio_channel_request_t) ZIO_CHANNEL_REQUEST_ARGS ; -typedef zap_status_t (*zio_channel_outgoing_call_t) ZIO_CHANNEL_OUTGOING_CALL_ARGS ; -typedef zap_status_t (*zio_channel_set_sig_status_t) ZIO_CHANNEL_SET_SIG_STATUS_ARGS; -typedef zap_status_t (*zio_channel_get_sig_status_t) ZIO_CHANNEL_GET_SIG_STATUS_ARGS; -typedef zap_status_t (*zio_span_set_sig_status_t) ZIO_SPAN_SET_SIG_STATUS_ARGS; -typedef zap_status_t (*zio_span_get_sig_status_t) ZIO_SPAN_GET_SIG_STATUS_ARGS; -typedef zap_status_t (*zio_span_poll_event_t) ZIO_SPAN_POLL_EVENT_ARGS ; -typedef zap_status_t (*zio_span_next_event_t) ZIO_SPAN_NEXT_EVENT_ARGS ; -typedef zap_status_t (*zio_signal_cb_t) ZIO_SIGNAL_CB_ARGS ; -typedef zap_status_t (*zio_event_cb_t) ZIO_EVENT_CB_ARGS ; -typedef zap_status_t (*zio_codec_t) ZIO_CODEC_ARGS ; -typedef zap_status_t (*zio_configure_span_t) ZIO_CONFIGURE_SPAN_ARGS ; -typedef zap_status_t (*zio_configure_t) ZIO_CONFIGURE_ARGS ; -typedef zap_status_t (*zio_open_t) ZIO_OPEN_ARGS ; -typedef zap_status_t (*zio_close_t) ZIO_CLOSE_ARGS ; -typedef zap_status_t (*zio_channel_destroy_t) ZIO_CHANNEL_DESTROY_ARGS ; -typedef zap_status_t (*zio_span_destroy_t) ZIO_SPAN_DESTROY_ARGS ; -typedef zap_status_t (*zio_get_alarms_t) ZIO_GET_ALARMS_ARGS ; -typedef zap_status_t (*zio_command_t) ZIO_COMMAND_ARGS ; -typedef zap_status_t (*zio_wait_t) ZIO_WAIT_ARGS ; -typedef zap_status_t (*zio_read_t) ZIO_READ_ARGS ; -typedef zap_status_t (*zio_write_t) ZIO_WRITE_ARGS ; -typedef zap_status_t (*zio_io_load_t) ZIO_IO_LOAD_ARGS ; -typedef zap_status_t (*zio_sig_load_t) ZIO_SIG_LOAD_ARGS ; -typedef zap_status_t (*zio_sig_configure_t) ZIO_SIG_CONFIGURE_ARGS ; -typedef zap_status_t (*zio_configure_span_signaling_t) ZIO_CONFIGURE_SPAN_SIGNALING_ARGS ; -typedef zap_status_t (*zio_io_unload_t) ZIO_IO_UNLOAD_ARGS ; -typedef zap_status_t (*zio_sig_unload_t) ZIO_SIG_UNLOAD_ARGS ; -typedef zap_status_t (*zio_api_t) ZIO_API_ARGS ; - - -#define ZIO_CHANNEL_REQUEST_FUNCTION(name) zap_status_t name ZIO_CHANNEL_REQUEST_ARGS -#define ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(name) zap_status_t name ZIO_CHANNEL_OUTGOING_CALL_ARGS -#define ZIO_CHANNEL_SET_SIG_STATUS_FUNCTION(name) zap_status_t name ZIO_CHANNEL_SET_SIG_STATUS_ARGS -#define ZIO_CHANNEL_GET_SIG_STATUS_FUNCTION(name) zap_status_t name ZIO_CHANNEL_GET_SIG_STATUS_ARGS -#define ZIO_SPAN_SET_SIG_STATUS_FUNCTION(name) zap_status_t name ZIO_SPAN_SET_SIG_STATUS_ARGS -#define ZIO_SPAN_GET_SIG_STATUS_FUNCTION(name) zap_status_t name ZIO_SPAN_GET_SIG_STATUS_ARGS -#define ZIO_SPAN_POLL_EVENT_FUNCTION(name) zap_status_t name ZIO_SPAN_POLL_EVENT_ARGS -#define ZIO_SPAN_NEXT_EVENT_FUNCTION(name) zap_status_t name ZIO_SPAN_NEXT_EVENT_ARGS -#define ZIO_SIGNAL_CB_FUNCTION(name) zap_status_t name ZIO_SIGNAL_CB_ARGS -#define ZIO_EVENT_CB_FUNCTION(name) zap_status_t name ZIO_EVENT_CB_ARGS -#define ZIO_CODEC_FUNCTION(name) OZ_DECLARE_NONSTD(zap_status_t) name ZIO_CODEC_ARGS -#define ZIO_CONFIGURE_SPAN_FUNCTION(name) zap_status_t name ZIO_CONFIGURE_SPAN_ARGS -#define ZIO_CONFIGURE_FUNCTION(name) zap_status_t name ZIO_CONFIGURE_ARGS -#define ZIO_OPEN_FUNCTION(name) zap_status_t name ZIO_OPEN_ARGS -#define ZIO_CLOSE_FUNCTION(name) zap_status_t name ZIO_CLOSE_ARGS -#define ZIO_CHANNEL_DESTROY_FUNCTION(name) zap_status_t name ZIO_CHANNEL_DESTROY_ARGS -#define ZIO_SPAN_DESTROY_FUNCTION(name) zap_status_t name ZIO_SPAN_DESTROY_ARGS -#define ZIO_GET_ALARMS_FUNCTION(name) zap_status_t name ZIO_GET_ALARMS_ARGS -#define ZIO_COMMAND_FUNCTION(name) zap_status_t name ZIO_COMMAND_ARGS -#define ZIO_WAIT_FUNCTION(name) zap_status_t name ZIO_WAIT_ARGS -#define ZIO_READ_FUNCTION(name) zap_status_t name ZIO_READ_ARGS -#define ZIO_WRITE_FUNCTION(name) zap_status_t name ZIO_WRITE_ARGS -#define ZIO_IO_LOAD_FUNCTION(name) zap_status_t name ZIO_IO_LOAD_ARGS -#define ZIO_SIG_LOAD_FUNCTION(name) zap_status_t name ZIO_SIG_LOAD_ARGS -#define ZIO_SIG_CONFIGURE_FUNCTION(name) zap_status_t name ZIO_SIG_CONFIGURE_ARGS -#define ZIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(name) zap_status_t name ZIO_CONFIGURE_SPAN_SIGNALING_ARGS -#define ZIO_IO_UNLOAD_FUNCTION(name) zap_status_t name ZIO_IO_UNLOAD_ARGS -#define ZIO_SIG_UNLOAD_FUNCTION(name) zap_status_t name ZIO_SIG_UNLOAD_ARGS -#define ZIO_API_FUNCTION(name) zap_status_t name ZIO_API_ARGS - -#include "zap_dso.h" - -typedef struct { - char name[256]; - zio_io_load_t io_load; - zio_io_unload_t io_unload; - zio_sig_load_t sig_load; - zio_sig_configure_t sig_configure; - zio_sig_unload_t sig_unload; - /*! - \brief configure a given span signaling - \see sig_configure - This is just like sig_configure but receives - an array of paramters instead of va_list - I'd like to deprecate sig_configure and move - all modules to use sigparam_configure - */ - zio_configure_span_signaling_t configure_span_signaling; - zap_dso_lib_t lib; - char path[256]; -} zap_module_t; - -#ifndef __FUNCTION__ -#define __FUNCTION__ (const char *)__func__ -#endif - -#define ZAP_PRE __FILE__, __FUNCTION__, __LINE__ -#define ZAP_LOG_LEVEL_DEBUG 7 -#define ZAP_LOG_LEVEL_INFO 6 -#define ZAP_LOG_LEVEL_NOTICE 5 -#define ZAP_LOG_LEVEL_WARNING 4 -#define ZAP_LOG_LEVEL_ERROR 3 -#define ZAP_LOG_LEVEL_CRIT 2 -#define ZAP_LOG_LEVEL_ALERT 1 -#define ZAP_LOG_LEVEL_EMERG 0 - -#define ZAP_LOG_DEBUG ZAP_PRE, ZAP_LOG_LEVEL_DEBUG -#define ZAP_LOG_INFO ZAP_PRE, ZAP_LOG_LEVEL_INFO -#define ZAP_LOG_NOTICE ZAP_PRE, ZAP_LOG_LEVEL_NOTICE -#define ZAP_LOG_WARNING ZAP_PRE, ZAP_LOG_LEVEL_WARNING -#define ZAP_LOG_ERROR ZAP_PRE, ZAP_LOG_LEVEL_ERROR -#define ZAP_LOG_CRIT ZAP_PRE, ZAP_LOG_LEVEL_CRIT -#define ZAP_LOG_ALERT ZAP_PRE, ZAP_LOG_LEVEL_ALERT -#define ZAP_LOG_EMERG ZAP_PRE, ZAP_LOG_LEVEL_EMERG - -typedef struct zap_fsk_data_state zap_fsk_data_state_t; -typedef int (*zap_fsk_data_decoder_t)(zap_fsk_data_state_t *state); -typedef zap_status_t (*zap_fsk_write_sample_t)(int16_t *buf, zap_size_t buflen, void *user_data); -typedef void (*zap_logger_t)(const char *file, const char *func, int line, int level, const char *fmt, ...); -typedef struct hashtable zap_hash_t; -typedef struct hashtable_iterator zap_hash_iterator_t; -typedef struct key zap_hash_key_t; -typedef struct value zap_hash_val_t; -typedef struct zap_bitstream zap_bitstream_t; -typedef struct zap_fsk_modulator zap_fsk_modulator_t; -typedef zap_status_t (*zap_span_start_t)(zap_span_t *span); -typedef zap_status_t (*zap_span_stop_t)(zap_span_t *span); - -typedef enum { - ZAP_CAUSE_NONE = 0, - ZAP_CAUSE_UNALLOCATED = 1, - ZAP_CAUSE_NO_ROUTE_TRANSIT_NET = 2, - ZAP_CAUSE_NO_ROUTE_DESTINATION = 3, - ZAP_CAUSE_CHANNEL_UNACCEPTABLE = 6, - ZAP_CAUSE_CALL_AWARDED_DELIVERED = 7, - ZAP_CAUSE_NORMAL_CLEARING = 16, - ZAP_CAUSE_USER_BUSY = 17, - ZAP_CAUSE_NO_USER_RESPONSE = 18, - ZAP_CAUSE_NO_ANSWER = 19, - ZAP_CAUSE_SUBSCRIBER_ABSENT = 20, - ZAP_CAUSE_CALL_REJECTED = 21, - ZAP_CAUSE_NUMBER_CHANGED = 22, - ZAP_CAUSE_REDIRECTION_TO_NEW_DESTINATION = 23, - ZAP_CAUSE_EXCHANGE_ROUTING_ERROR = 25, - ZAP_CAUSE_DESTINATION_OUT_OF_ORDER = 27, - ZAP_CAUSE_INVALID_NUMBER_FORMAT = 28, - ZAP_CAUSE_FACILITY_REJECTED = 29, - ZAP_CAUSE_RESPONSE_TO_STATUS_ENQUIRY = 30, - ZAP_CAUSE_NORMAL_UNSPECIFIED = 31, - ZAP_CAUSE_NORMAL_CIRCUIT_CONGESTION = 34, - ZAP_CAUSE_NETWORK_OUT_OF_ORDER = 38, - ZAP_CAUSE_NORMAL_TEMPORARY_FAILURE = 41, - ZAP_CAUSE_SWITCH_CONGESTION = 42, - ZAP_CAUSE_ACCESS_INFO_DISCARDED = 43, - ZAP_CAUSE_REQUESTED_CHAN_UNAVAIL = 44, - ZAP_CAUSE_PRE_EMPTED = 45, - ZAP_CAUSE_FACILITY_NOT_SUBSCRIBED = 50, - ZAP_CAUSE_OUTGOING_CALL_BARRED = 52, - ZAP_CAUSE_INCOMING_CALL_BARRED = 54, - ZAP_CAUSE_BEARERCAPABILITY_NOTAUTH = 57, - ZAP_CAUSE_BEARERCAPABILITY_NOTAVAIL = 58, - ZAP_CAUSE_SERVICE_UNAVAILABLE = 63, - ZAP_CAUSE_BEARERCAPABILITY_NOTIMPL = 65, - ZAP_CAUSE_CHAN_NOT_IMPLEMENTED = 66, - ZAP_CAUSE_FACILITY_NOT_IMPLEMENTED = 69, - ZAP_CAUSE_SERVICE_NOT_IMPLEMENTED = 79, - ZAP_CAUSE_INVALID_CALL_REFERENCE = 81, - ZAP_CAUSE_INCOMPATIBLE_DESTINATION = 88, - ZAP_CAUSE_INVALID_MSG_UNSPECIFIED = 95, - ZAP_CAUSE_MANDATORY_IE_MISSING = 96, - ZAP_CAUSE_MESSAGE_TYPE_NONEXIST = 97, - ZAP_CAUSE_WRONG_MESSAGE = 98, - ZAP_CAUSE_IE_NONEXIST = 99, - ZAP_CAUSE_INVALID_IE_CONTENTS = 100, - ZAP_CAUSE_WRONG_CALL_STATE = 101, - ZAP_CAUSE_RECOVERY_ON_TIMER_EXPIRE = 102, - ZAP_CAUSE_MANDATORY_IE_LENGTH_ERROR = 103, - ZAP_CAUSE_PROTOCOL_ERROR = 111, - ZAP_CAUSE_INTERWORKING = 127, - ZAP_CAUSE_SUCCESS = 142, - ZAP_CAUSE_ORIGINATOR_CANCEL = 487, - ZAP_CAUSE_CRASH = 500, - ZAP_CAUSE_SYSTEM_SHUTDOWN = 501, - ZAP_CAUSE_LOSE_RACE = 502, - ZAP_CAUSE_MANAGER_REQUEST = 503, - ZAP_CAUSE_BLIND_TRANSFER = 600, - ZAP_CAUSE_ATTENDED_TRANSFER = 601, - ZAP_CAUSE_ALLOTTED_TIMEOUT = 602, - ZAP_CAUSE_USER_CHALLENGE = 603, - ZAP_CAUSE_MEDIA_TIMEOUT = 604 -} zap_call_cause_t; - -#ifdef __cplusplus -} -#endif - -#endif - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ - diff --git a/libs/freetdm/src/isdn/Q921.c b/libs/freetdm/src/isdn/Q921.c index 9cfd08a07c..d1cbab6e6f 100644 --- a/libs/freetdm/src/isdn/Q921.c +++ b/libs/freetdm/src/isdn/Q921.c @@ -79,7 +79,7 @@ #include #include -#include "openzap.h" +#include "freetdm.h" #include "Q921.h" #include "Q921priv.h" #include "mfifo.h" @@ -398,7 +398,7 @@ int Q921_InitTrunk(L2TRUNK trunk, /* * Allocate space for per-link context(s) */ - trunk->context = zap_malloc(numlinks * sizeof(struct Q921_Link)); + trunk->context = ftdm_malloc(numlinks * sizeof(struct Q921_Link)); if(!trunk->context) return -1; diff --git a/libs/freetdm/src/libteletone_generate.c b/libs/freetdm/src/libteletone_generate.c index c261772f92..f79c615a36 100644 --- a/libs/freetdm/src/libteletone_generate.c +++ b/libs/freetdm/src/libteletone_generate.c @@ -34,7 +34,7 @@ */ #include -#include "openzap.h" +#include "freetdm.h" #define SMAX 32767 #define SMIN -32768 @@ -111,7 +111,7 @@ TELETONE_API(int) teletone_init_session(teletone_generation_session_t *ts, int b ts->decay_step = 0; ts->decay_factor = 1; if (buflen) { - if ((ts->buffer = zap_calloc(buflen, sizeof(teletone_audio_t))) == 0) { + if ((ts->buffer = ftdm_calloc(buflen, sizeof(teletone_audio_t))) == 0) { return -1; } ts->datalen = buflen; @@ -142,7 +142,7 @@ TELETONE_API(int) teletone_init_session(teletone_generation_session_t *ts, int b TELETONE_API(int) teletone_destroy_session(teletone_generation_session_t *ts) { if (ts->buffer) { - zap_safe_free(ts->buffer); + ftdm_safe_free(ts->buffer); ts->buffer = NULL; ts->samples = 0; } @@ -280,7 +280,7 @@ TELETONE_API(int) teletone_run(teletone_generation_session_t *ts, const char *cm } do { - if (!(data = zap_strdup(cmd))) { + if (!(data = ftdm_strdup(cmd))) { return -1; } @@ -429,7 +429,7 @@ TELETONE_API(int) teletone_run(teletone_generation_session_t *ts, const char *cm } } bottom: - zap_safe_free(data); + ftdm_safe_free(data); data = NULL; if (ts->LOOPS > 0) { ts->LOOPS--; diff --git a/libs/freetdm/src/m3ua_client.c b/libs/freetdm/src/m3ua_client.c index ba33dd4317..7608183896 100644 --- a/libs/freetdm/src/m3ua_client.c +++ b/libs/freetdm/src/m3ua_client.c @@ -1,6 +1,6 @@ /* * m3ua_client.c - * openzap + * freetdm * * Created by Shane Burrell on 4/3/08. * Copyright 2008 Shane Burrell. All rights reserved. @@ -40,7 +40,7 @@ #include #endif -#include "openzap.h" +#include "freetdm.h" #include @@ -85,7 +85,7 @@ static int create_conn_socket(m3uac_connection_t *mcon, char *local_ip, int loca memset(&mcon->local_hp, 0, sizeof(mcon->local_hp)); mcon->socket = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP); - zap_log(ZAP_LOG_DEBUG, "Creating L=%s:%d R=%s:%d\n", + ftdm_log(FTDM_LOG_DEBUG, "Creating L=%s:%d R=%s:%d\n", local_ip,local_port,ip,port); if (mcon->socket >= 0) { @@ -115,7 +115,7 @@ static int create_conn_socket(m3uac_connection_t *mcon, char *local_ip, int loca } } - zap_mutex_create(&mcon->mutex); + ftdm_mutex_create(&mcon->mutex); return mcon->socket; } @@ -126,9 +126,9 @@ int m3uac_connection_close(m3uac_connection_t *mcon) close(mcon->socket); } - zap_mutex_lock(mcon->mutex); - zap_mutex_unlock(mcon->mutex); - zap_mutex_destroy(&mcon->mutex); + ftdm_mutex_lock(mcon->mutex); + ftdm_mutex_unlock(mcon->mutex); + ftdm_mutex_destroy(&mcon->mutex); memset(mcon, 0, sizeof(*mcon)); mcon->socket = -1; @@ -163,11 +163,11 @@ int m3uac_exec_command(m3uac_connection_t *mcon, int span, int chan, int id, int while (m3uac_connection_write(mcon, &oevent) <= 0) { if (--retry <= 0) { - zap_log(ZAP_LOG_CRIT, "Failed to tx on M3UA socket: %s\n", strerror(errno)); + ftdm_log(FTDM_LOG_CRIT, "Failed to tx on M3UA socket: %s\n", strerror(errno)); return -1; } else { - zap_log(ZAP_LOG_WARNING, "Failed to tx on M3UA socket: %s :retry %i\n", strerror(errno), retry); - zap_sleep(1); + ftdm_log(FTDM_LOG_WARNING, "Failed to tx on M3UA socket: %s :retry %i\n", strerror(errno), retry); + ftdm_sleep(1); } } @@ -188,12 +188,12 @@ m3uac_event_t *m3uac_connection_read(m3uac_connection_t *mcon, int iteration) if (mcon->rxseq_reset) { if (mcon->event.event_id == SIGBOOST_EVENT_SYSTEM_RESTART_ACK) { - zap_log(ZAP_LOG_DEBUG, "Rx sync ok\n"); + ftdm_log(FTDM_LOG_DEBUG, "Rx sync ok\n"); mcon->rxseq = mcon->event.fseqno; return &mcon->event; } errno=EAGAIN; - zap_log(ZAP_LOG_DEBUG, "Waiting for rx sync...\n"); + ftdm_log(FTDM_LOG_DEBUG, "Waiting for rx sync...\n"); return NULL; } @@ -201,14 +201,14 @@ m3uac_event_t *m3uac_connection_read(m3uac_connection_t *mcon, int iteration) mcon->rxseq++; if (mcon->rxseq != mcon->event.fseqno) { - zap_log(ZAP_LOG_CRIT, "Invalid Sequence Number Expect=%i Rx=%i\n", mcon->rxseq, mcon->event.fseqno); + ftdm_log(FTDM_LOG_CRIT, "Invalid Sequence Number Expect=%i Rx=%i\n", mcon->rxseq, mcon->event.fseqno); return NULL; } return &mcon->event; } else { if (iteration == 0) { - zap_log(ZAP_LOG_CRIT, "Invalid Event length from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); + ftdm_log(FTDM_LOG_CRIT, "Invalid Event length from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); return NULL; } } @@ -227,7 +227,7 @@ m3uac_event_t *m3uac_connection_readp(m3uac_connection_t *mcon, int iteration) return &mcon->event; } else { if (iteration == 0) { - zap_log(ZAP_LOG_CRIT, "Critical Error: PQ Invalid Event lenght from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); + ftdm_log(FTDM_LOG_CRIT, "Critical Error: PQ Invalid Event lenght from boost rxlen=%i evsz=%i\n", bytes, sizeof(mcon->event)); return NULL; } } @@ -241,28 +241,28 @@ int m3uac_connection_write(m3uac_connection_t *mcon, ss7bc_event_t *event) int err; if (!event || mcon->socket < 0 || !mcon->mutex) { - zap_log(ZAP_LOG_DEBUG, "Critical Error: No Event Device\n"); + ftdm_log(FTDM_LOG_DEBUG, "Critical Error: No Event Device\n"); return -EINVAL; } if (event->span > 16 || event->chan > 31) { - zap_log(ZAP_LOG_CRIT, "Critical Error: TX Cmd=%s Invalid Span=%i Chan=%i\n", m3uac_event_id_name(event->event_id), event->span,event->chan); + ftdm_log(FTDM_LOG_CRIT, "Critical Error: TX Cmd=%s Invalid Span=%i Chan=%i\n", m3uac_event_id_name(event->event_id), event->span,event->chan); return -1; } gettimeofday(&event->tv,NULL); - zap_mutex_lock(mcon->mutex); + ftdm_mutex_lock(mcon->mutex); event->fseqno = mcon->txseq++; event->bseqno = mcon->rxseq; err = sendto(mcon->socket, event, sizeof(m3uac_event_t), 0, (struct sockaddr *) &mcon->remote_addr, sizeof(mcon->remote_addr)); - zap_mutex_unlock(mcon->mutex); + ftdm_mutex_unlock(mcon->mutex); if (err != sizeof(m3uac_event_t)) { err = -1; } - zap_log(ZAP_LOG_DEBUG, "TX EVENT: %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i Cd=[%s] Ci=[%s]\n", + ftdm_log(FTDM_LOG_DEBUG, "TX EVENT: %s:(%X) [w%dg%d] Rc=%i CSid=%i Seq=%i Cd=[%s] Ci=[%s]\n", m3uac_event_id_name(event->event_id), event->event_id, event->span+1, diff --git a/libs/freetdm/src/m3ua_client.h b/libs/freetdm/src/m3ua_client.h index b80309017c..e451156a41 100644 --- a/libs/freetdm/src/m3ua_client.h +++ b/libs/freetdm/src/m3ua_client.h @@ -1,6 +1,6 @@ /* * m3ua_client.h - * openzap + * freetdm * * Created by Shane Burrell on 4/3/08. * Copyright 2008 Shane Burrell. All rights reserved. @@ -109,14 +109,14 @@ typedef struct m3uac_ip_cfg }m3uac_ip_cfg_t; struct m3uac_connection { - zap_socket_t socket; + ftdm_socket_t socket; struct sockaddr_in local_addr; struct sockaddr_in remote_addr; m3uac_event_t event; struct hostent remote_hp; struct hostent local_hp; unsigned int flags; - zap_mutex_t *mutex; + ftdm_mutex_t *mutex; FILE *log; unsigned int txseq; unsigned int rxseq; diff --git a/libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.c b/libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.c deleted file mode 100644 index 6e6a4c9664..0000000000 --- a/libs/freetdm/src/ozmod/ozmod_analog/ozmod_analog.c +++ /dev/null @@ -1,977 +0,0 @@ -/* - * Copyright (c) 2007, Anthony Minessale II - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include "openzap.h" -#include "zap_analog.h" - -#ifndef localtime_r -struct tm * localtime_r(const time_t *clock, struct tm *result); -#endif - -static void *zap_analog_channel_run(zap_thread_t *me, void *obj); - -/** - * \brief Starts an FXO channel thread (outgoing call) - * \param zchan Channel to initiate call on - * \return Success or failure - * - * Initialises state, starts tone progress detection and runs the channel in a new a thread. - */ -static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxo_outgoing_call) -{ - if (!zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && !zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_channel_clear_needed_tones(zchan); - zap_channel_clear_detected_tones(zchan); - - zap_channel_command(zchan, ZAP_COMMAND_OFFHOOK, NULL); - zap_channel_command(zchan, ZAP_COMMAND_ENABLE_PROGRESS_DETECT, NULL); - zchan->needed_tones[ZAP_TONEMAP_DIAL] = 1; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DIALING); - zap_thread_create_detached(zap_analog_channel_run, zchan); - return ZAP_SUCCESS; - } - - return ZAP_FAIL; -} - -/** - * \brief Starts an FXS channel thread (outgoing call) - * \param zchan Channel to initiate call on - * \return Success or failure - * - * Indicates call waiting if channel is already in use, otherwise runs the channel in a new thread. - */ -static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxs_outgoing_call) -{ - - if (zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_CALLWAITING); - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_GENRING); - zap_thread_create_detached(zap_analog_channel_run, zchan); - } - - return ZAP_SUCCESS; -} - -/** - * \brief Starts an analog span thread (monitor) - * \param span Span to monitor - * \return Success or failure - */ -static zap_status_t zap_analog_start(zap_span_t *span) -{ - zap_analog_data_t *analog_data = span->signal_data; - zap_set_flag(analog_data, ZAP_ANALOG_RUNNING); - return zap_thread_create_detached(zap_analog_run, span); -} - -/** - * \brief Initialises an analog span from configuration variables - * \param span Span to configure - * \param sig_cb Callback function for event signals - * \param ap List of configuration variables - * \return Success or failure - */ -static ZIO_SIG_CONFIGURE_FUNCTION(zap_analog_configure_span) -//zap_status_t zap_analog_configure_span(zap_span_t *span, char *tonemap, uint32_t digit_timeout, uint32_t max_dialstr, zio_signal_cb_t sig_cb) -{ - zap_analog_data_t *analog_data; - const char *tonemap = "us"; - const char *hotline = ""; - uint32_t digit_timeout = 10; - uint32_t max_dialstr = MAX_DTMF; - const char *var, *val; - int *intval; - uint32_t flags = ZAP_ANALOG_CALLERID; - - assert(sig_cb != NULL); - - if (span->signal_type) { - snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling."); - return ZAP_FAIL; - } - - analog_data = zap_malloc(sizeof(*analog_data)); - assert(analog_data != NULL); - memset(analog_data, 0, sizeof(*analog_data)); - - while ((var = va_arg(ap, char *))) { - if (!strcasecmp(var, "tonemap")) { - if (!(val = va_arg(ap, char *))) { - break; - } - tonemap = val; - } else if (!strcasecmp(var, "digit_timeout")) { - if (!(intval = va_arg(ap, int *))) { - break; - } - digit_timeout = *intval; - } else if (!strcasecmp(var, "enable_callerid")) { - if (!(val = va_arg(ap, char *))) { - break; - } - - if (zap_true(val)) { - flags |= ZAP_ANALOG_CALLERID; - } else { - flags &= ~ZAP_ANALOG_CALLERID; - } - } else if (!strcasecmp(var, "max_dialstr")) { - if (!(intval = va_arg(ap, int *))) { - break; - } - max_dialstr = *intval; - } else if (!strcasecmp(var, "hotline")) { - if (!(val = va_arg(ap, char *))) { - break; - } - hotline = val; - } else { - snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); - return ZAP_FAIL; - } - } - - - if (digit_timeout < 2000 || digit_timeout > 10000) { - digit_timeout = 2000; - } - - if ((max_dialstr < 1 && !strlen(hotline)) || max_dialstr > MAX_DTMF) { - max_dialstr = MAX_DTMF; - } - - span->start = zap_analog_start; - analog_data->flags = flags; - analog_data->digit_timeout = digit_timeout; - analog_data->max_dialstr = max_dialstr; - analog_data->sig_cb = sig_cb; - strncpy(analog_data->hotline, hotline, sizeof(analog_data->hotline)); - span->signal_type = ZAP_SIGTYPE_ANALOG; - span->signal_data = analog_data; - span->outgoing_call = span->trunk_type == ZAP_TRUNK_FXS ? analog_fxs_outgoing_call : analog_fxo_outgoing_call; - zap_span_load_tones(span, tonemap); - - return ZAP_SUCCESS; - -} - -/** - * \brief Retrieves tone generation output to be sent - * \param ts Teletone generator - * \param map Tone map - * \return -1 on error, 0 on success - */ -static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map) -{ - zap_buffer_t *dt_buffer = ts->user_data; - int wrote; - - if (!dt_buffer) { - return -1; - } - wrote = teletone_mux_tones(ts, map); - zap_buffer_write(dt_buffer, ts->buffer, wrote * 2); - return 0; -} - -/** - * \brief Sends caller id on an analog channel (FSK coded) - * \param zchan Channel to send caller id on - */ -static void send_caller_id(zap_channel_t *zchan) -{ - zap_fsk_data_state_t fsk_data; - uint8_t databuf[1024] = ""; - char time_str[9]; - struct tm tm; - time_t now; - zap_mdmf_type_t mt = MDMF_INVALID; - - time(&now); -#ifdef WIN32 - _tzset(); - _localtime64_s(&tm, &now); -#else - localtime_r(&now, &tm); -#endif - strftime(time_str, sizeof(time_str), "%m%d%H%M", &tm); - - zap_fsk_data_init(&fsk_data, databuf, sizeof(databuf)); - zap_fsk_data_add_mdmf(&fsk_data, MDMF_DATETIME, (uint8_t *) time_str, 8); - - if (zap_strlen_zero(zchan->caller_data.cid_num.digits)) { - mt = MDMF_NO_NUM; - zap_set_string(zchan->caller_data.cid_num.digits, "O"); - } else if (!strcasecmp(zchan->caller_data.cid_num.digits, "P") || !strcasecmp(zchan->caller_data.cid_num.digits, "O")) { - mt = MDMF_NO_NUM; - } else { - mt = MDMF_PHONE_NUM; - } - zap_fsk_data_add_mdmf(&fsk_data, mt, (uint8_t *) zchan->caller_data.cid_num.digits, (uint8_t)strlen(zchan->caller_data.cid_num.digits)); - - if (zap_strlen_zero(zchan->caller_data.cid_name)) { - mt = MDMF_NO_NAME; - zap_set_string(zchan->caller_data.cid_name, "O"); - } else if (!strcasecmp(zchan->caller_data.cid_name, "P") || !strcasecmp(zchan->caller_data.cid_name, "O")) { - mt = MDMF_NO_NAME; - } else { - mt = MDMF_PHONE_NAME; - } - zap_fsk_data_add_mdmf(&fsk_data, mt, (uint8_t *) zchan->caller_data.cid_name, (uint8_t)strlen(zchan->caller_data.cid_name)); - - zap_fsk_data_add_checksum(&fsk_data); - zap_channel_send_fsk_data(zchan, &fsk_data, -14); -} - -/** - * \brief Main thread function for analog channel (outgoing call) - * \param me Current thread - * \param obj Channel to run in this thread - */ -static void *zap_analog_channel_run(zap_thread_t *me, void *obj) -{ - zap_channel_t *zchan = (zap_channel_t *) obj; - zap_buffer_t *dt_buffer = NULL; - teletone_generation_session_t ts; - uint8_t frame[1024]; - zap_size_t len, rlen; - zap_tone_type_t tt = ZAP_TONE_DTMF; - char dtmf[MAX_DTMF+1] = ""; - zap_size_t dtmf_offset = 0; - zap_analog_data_t *analog_data = zchan->span->signal_data; - zap_channel_t *closed_chan; - uint32_t state_counter = 0, elapsed = 0, collecting = 0, interval = 0, last_digit = 0, indicate = 0, dial_timeout = 30000; - zap_sigmsg_t sig; - zap_status_t status; - - zap_log(ZAP_LOG_DEBUG, "ANALOG CHANNEL thread starting.\n"); - - ts.buffer = NULL; - - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "OPEN ERROR [%s]\n", zchan->last_error); - goto done; - } - - if (zap_buffer_create(&dt_buffer, 1024, 3192, 0) != ZAP_SUCCESS) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "memory error!"); - zap_log(ZAP_LOG_ERROR, "MEM ERROR\n"); - goto done; - } - - if (zap_channel_command(zchan, ZAP_COMMAND_ENABLE_DTMF_DETECT, &tt) != ZAP_SUCCESS) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "error initilizing tone detector!"); - zap_log(ZAP_LOG_ERROR, "TONE ERROR\n"); - goto done; - } - - zap_set_flag_locked(zchan, ZAP_CHANNEL_INTHREAD); - teletone_init_session(&ts, 0, teletone_handler, dt_buffer); - ts.rate = 8000; -#if 0 - ts.debug = 1; - ts.debug_stream = stdout; -#endif - zap_channel_command(zchan, ZAP_COMMAND_GET_INTERVAL, &interval); - zap_buffer_set_loops(dt_buffer, -1); - - memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; - - assert(interval != 0); - - while (zap_running() && zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_wait_flag_t flags = ZAP_READ; - zap_size_t dlen = 0; - - len = sizeof(frame); - - elapsed += interval; - state_counter += interval; - - if (!zap_test_flag(zchan, ZAP_CHANNEL_STATE_CHANGE)) { - switch(zchan->state) { - case ZAP_CHANNEL_STATE_GET_CALLERID: - { - if (state_counter > 5000 || !zap_test_flag(zchan, ZAP_CHANNEL_CALLERID_DETECT)) { - zap_channel_command(zchan, ZAP_COMMAND_DISABLE_CALLERID_DETECT, NULL); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_IDLE); - } - } - break; - case ZAP_CHANNEL_STATE_DIALING: - { - if (state_counter > dial_timeout) { - if (zchan->needed_tones[ZAP_TONEMAP_DIAL]) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); - } - } - } - break; - case ZAP_CHANNEL_STATE_GENRING: - { - if (state_counter > 60000) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } else if (!zchan->fsk_buffer || !zap_buffer_inuse(zchan->fsk_buffer)) { - zap_sleep(interval); - continue; - } - } - break; - case ZAP_CHANNEL_STATE_DIALTONE: - { - if (!zap_test_flag(zchan, ZAP_CHANNEL_HOLD) && state_counter > 10000) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } - } - break; - case ZAP_CHANNEL_STATE_BUSY: - { - if (state_counter > 20000) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_ATTN); - } - } - break; - case ZAP_CHANNEL_STATE_ATTN: - { - if (state_counter > 20000) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - break; - case ZAP_CHANNEL_STATE_HANGUP: - { - if (state_counter > 500) { - if (zap_test_flag(zchan, ZAP_CHANNEL_RINGING)) { - zap_channel_command(zchan, ZAP_COMMAND_GENERATE_RING_OFF, NULL); - } - - if (zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && - (zchan->last_state == ZAP_CHANNEL_STATE_RING || zchan->last_state == ZAP_CHANNEL_STATE_DIALTONE - || zchan->last_state >= ZAP_CHANNEL_STATE_IDLE)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - zchan->caller_data.hangup_cause = ZAP_CAUSE_NORMAL_CLEARING; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - } - break; - case ZAP_CHANNEL_STATE_CALLWAITING: - { - int done = 0; - - if (zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK] == 1) { - send_caller_id(zchan); - zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK]++; - } else if (state_counter > 600 && !zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK]) { - send_caller_id(zchan); - zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK]++; - } else if (state_counter > 1000 && !zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK]) { - done = 1; - } else if (state_counter > 10000) { - if (zchan->fsk_buffer) { - zap_buffer_zero(zchan->fsk_buffer); - } else { - zap_buffer_create(&zchan->fsk_buffer, 128, 128, 0); - } - - ts.user_data = zchan->fsk_buffer; - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_CALLWAITING_SAS]); - ts.user_data = dt_buffer; - done = 1; - } - - if (done) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); - zap_clear_flag_locked(zchan, ZAP_CHANNEL_STATE_CHANGE); - zap_clear_flag_locked(zchan->span, ZAP_SPAN_STATE_CHANGE); - zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK] = 0; - } - } - case ZAP_CHANNEL_STATE_UP: - case ZAP_CHANNEL_STATE_IDLE: - { - zap_sleep(interval); - continue; - } - break; - case ZAP_CHANNEL_STATE_DOWN: - { - goto done; - } - break; - default: - break; - } - } else { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_STATE_CHANGE); - zap_clear_flag_locked(zchan->span, ZAP_SPAN_STATE_CHANGE); - zap_channel_complete_state(zchan); - indicate = 0; - state_counter = 0; - - zap_log(ZAP_LOG_DEBUG, "Executing state handler on %d:%d for %s\n", - zchan->span_id, zchan->chan_id, - zap_channel_state2str(zchan->state)); - switch(zchan->state) { - case ZAP_CHANNEL_STATE_UP: - { - zap_channel_use(zchan); - zap_channel_clear_needed_tones(zchan); - zap_channel_flush_dtmf(zchan); - - if (zchan->type == ZAP_CHAN_TYPE_FXO && !zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK)) { - zap_channel_command(zchan, ZAP_COMMAND_OFFHOOK, NULL); - } - - if (zchan->fsk_buffer && zap_buffer_inuse(zchan->fsk_buffer)) { - zap_log(ZAP_LOG_DEBUG, "Cancel FSK transmit due to early answer.\n"); - zap_buffer_zero(zchan->fsk_buffer); - } - - if (zchan->type == ZAP_CHAN_TYPE_FXS && zap_test_flag(zchan, ZAP_CHANNEL_RINGING)) { - zap_channel_command(zchan, ZAP_COMMAND_GENERATE_RING_OFF, NULL); - } - - if (zchan->token_count == 1) { - zap_clear_flag(zchan, ZAP_CHANNEL_HOLD); - } - - if (zap_test_flag(zchan, ZAP_CHANNEL_HOLD)) { - zap_clear_flag(zchan, ZAP_CHANNEL_HOLD); - sig.event_id = ZAP_SIGEVENT_ADD_CALL; - } else { - sig.event_id = ZAP_SIGEVENT_UP; - } - - analog_data->sig_cb(&sig); - continue; - } - break; - case ZAP_CHANNEL_STATE_DIALING: - { - zap_channel_use(zchan); - } - break; - case ZAP_CHANNEL_STATE_IDLE: - { - zap_channel_use(zchan); - sig.event_id = ZAP_SIGEVENT_START; - - if (zchan->type == ZAP_CHAN_TYPE_FXO) { - zap_set_string(zchan->caller_data.dnis.digits, zchan->chan_number); - } else { - zap_set_string(zchan->caller_data.dnis.digits, dtmf); - } - - analog_data->sig_cb(&sig); - continue; - } - break; - case ZAP_CHANNEL_STATE_DOWN: - { - sig.event_id = ZAP_SIGEVENT_STOP; - analog_data->sig_cb(&sig); - goto done; - } - break; - case ZAP_CHANNEL_STATE_DIALTONE: - { - memset(&zchan->caller_data, 0, sizeof(zchan->caller_data)); - *dtmf = '\0'; - dtmf_offset = 0; - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_DIAL]); - indicate = 1; - } - break; - case ZAP_CHANNEL_STATE_CALLWAITING: - { - zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK] = 0; - if (zchan->fsk_buffer) { - zap_buffer_zero(zchan->fsk_buffer); - } else { - zap_buffer_create(&zchan->fsk_buffer, 128, 128, 0); - } - - ts.user_data = zchan->fsk_buffer; - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_CALLWAITING_SAS]); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_CALLWAITING_CAS]); - ts.user_data = dt_buffer; - } - break; - case ZAP_CHANNEL_STATE_GENRING: - { - zap_sigmsg_t sig; - - send_caller_id(zchan); - zap_channel_command(zchan, ZAP_COMMAND_GENERATE_RING_ON, NULL); - - memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; - sig.event_id = ZAP_SIGEVENT_PROGRESS; - analog_data->sig_cb(&sig); - - } - break; - case ZAP_CHANNEL_STATE_GET_CALLERID: - { - memset(&zchan->caller_data, 0, sizeof(zchan->caller_data)); - zap_channel_command(zchan, ZAP_COMMAND_ENABLE_CALLERID_DETECT, NULL); - continue; - } - break; - case ZAP_CHANNEL_STATE_RING: - { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_RING]); - indicate = 1; - - } - break; - case ZAP_CHANNEL_STATE_BUSY: - { - zchan->caller_data.hangup_cause = ZAP_CAUSE_NORMAL_CIRCUIT_CONGESTION; - if (zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && !zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_BUSY]); - indicate = 1; - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - break; - case ZAP_CHANNEL_STATE_ATTN: - { - if (zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && !zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_ATTN]); - indicate = 1; - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - break; - default: - break; - } - } - - - if (zchan->state == ZAP_CHANNEL_STATE_DIALTONE || zchan->state == ZAP_CHANNEL_STATE_COLLECT) { - if ((dlen = zap_channel_dequeue_dtmf(zchan, dtmf + dtmf_offset, sizeof(dtmf) - strlen(dtmf)))) { - - if (zchan->state == ZAP_CHANNEL_STATE_DIALTONE) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_COLLECT); - collecting = 1; - } - dtmf_offset = strlen(dtmf); - last_digit = elapsed; - sig.event_id = ZAP_SIGEVENT_COLLECTED_DIGIT; - sig.raw_data = dtmf; - if (analog_data->sig_cb(&sig) == ZAP_BREAK) { - collecting = 0; - } - } - else if(!analog_data->max_dialstr) - { - last_digit = elapsed; - collecting = 0; - strcpy(dtmf, analog_data->hotline); - } - } - - - if (last_digit && (!collecting || ((elapsed - last_digit > analog_data->digit_timeout) || strlen(dtmf) >= analog_data->max_dialstr))) { - zap_log(ZAP_LOG_DEBUG, "Number obtained [%s]\n", dtmf); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_IDLE); - last_digit = 0; - collecting = 0; - } - - if (zap_channel_wait(zchan, &flags, interval * 2) != ZAP_SUCCESS) { - continue; - } - - if (!(flags & ZAP_READ)) { - continue; - } - - if (zap_channel_read(zchan, frame, &len) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "READ ERROR [%s]\n", zchan->last_error); - goto done; - } - - if (zchan->type == ZAP_CHAN_TYPE_FXO && zchan->detected_tones[0]) { - zap_sigmsg_t sig; - int i; - memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; - sig.event_id = ZAP_SIGEVENT_TONE_DETECTED; - - for (i = 1; i < ZAP_TONEMAP_INVALID; i++) { - if (zchan->detected_tones[i]) { - zap_log(ZAP_LOG_DEBUG, "Detected tone %s on %d:%d\n", zap_tonemap2str(i), zchan->span_id, zchan->chan_id); - sig.raw_data = &i; - if (analog_data->sig_cb) { - analog_data->sig_cb(&sig); - } - } - } - - if (zchan->detected_tones[ZAP_TONEMAP_BUSY] || - zchan->detected_tones[ZAP_TONEMAP_FAIL1] || - zchan->detected_tones[ZAP_TONEMAP_FAIL2] || - zchan->detected_tones[ZAP_TONEMAP_FAIL3] || - zchan->detected_tones[ZAP_TONEMAP_ATTN] - ) { - zap_log(ZAP_LOG_ERROR, "Failure indication detected!\n"); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else if (zchan->detected_tones[ZAP_TONEMAP_DIAL]) { - if (zap_strlen_zero(zchan->caller_data.ani.digits)) { - zap_log(ZAP_LOG_ERROR, "No Digits to send!\n"); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - if (zap_channel_command(zchan, ZAP_COMMAND_SEND_DTMF, zchan->caller_data.ani.digits) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Send Digits Failed [%s]\n", zchan->last_error); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - state_counter = 0; - zchan->needed_tones[ZAP_TONEMAP_RING] = 1; - zchan->needed_tones[ZAP_TONEMAP_BUSY] = 1; - zchan->needed_tones[ZAP_TONEMAP_FAIL1] = 1; - zchan->needed_tones[ZAP_TONEMAP_FAIL2] = 1; - zchan->needed_tones[ZAP_TONEMAP_FAIL3] = 1; - dial_timeout = ((zchan->dtmf_on + zchan->dtmf_off) * strlen(zchan->caller_data.ani.digits)) + 2000; - } - } - } else if (zchan->detected_tones[ZAP_TONEMAP_RING]) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); - } - - zap_channel_clear_detected_tones(zchan); - } - - if ((zchan->dtmf_buffer && zap_buffer_inuse(zchan->dtmf_buffer)) || (zchan->fsk_buffer && zap_buffer_inuse(zchan->fsk_buffer))) { - //rlen = len; - //memset(frame, 0, len); - //zap_channel_write(zchan, frame, sizeof(frame), &rlen); - continue; - } - - if (!indicate) { - continue; - } - - if (zchan->type == ZAP_CHAN_TYPE_FXO && !zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK)) { - zap_channel_command(zchan, ZAP_COMMAND_OFFHOOK, NULL); - } - - if (zchan->effective_codec != ZAP_CODEC_SLIN) { - len *= 2; - } - - rlen = zap_buffer_read_loop(dt_buffer, frame, len); - - if (zchan->effective_codec != ZAP_CODEC_SLIN) { - zio_codec_t codec_func = NULL; - - if (zchan->native_codec == ZAP_CODEC_ULAW) { - codec_func = zio_slin2ulaw; - } else if (zchan->native_codec == ZAP_CODEC_ALAW) { - codec_func = zio_slin2alaw; - } - - if (codec_func) { - status = codec_func(frame, sizeof(frame), &rlen); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "codec error!"); - goto done; - } - } - - zap_channel_write(zchan, frame, sizeof(frame), &rlen); - } - - done: - - - if (zchan->type == ZAP_CHAN_TYPE_FXO && zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK)) { - zap_channel_command(zchan, ZAP_COMMAND_ONHOOK, NULL); - } - - if (zchan->type == ZAP_CHAN_TYPE_FXS && zap_test_flag(zchan, ZAP_CHANNEL_RINGING)) { - zap_channel_command(zchan, ZAP_COMMAND_GENERATE_RING_OFF, NULL); - } - - - closed_chan = zchan; - zap_channel_close(&zchan); - - zap_channel_command(closed_chan, ZAP_COMMAND_SET_NATIVE_CODEC, NULL); - - if (ts.buffer) { - teletone_destroy_session(&ts); - } - - if (dt_buffer) { - zap_buffer_destroy(&dt_buffer); - } - - if (closed_chan->state != ZAP_CHANNEL_STATE_DOWN) { - zap_set_state_locked(closed_chan, ZAP_CHANNEL_STATE_DOWN); - } - - zap_log(ZAP_LOG_DEBUG, "ANALOG CHANNEL %d:%d thread ended.\n", closed_chan->span_id, closed_chan->chan_id); - zap_clear_flag(closed_chan, ZAP_CHANNEL_INTHREAD); - - return NULL; -} - -/** - * \brief Processes openzap event - * \param span Span on which the event was fired - * \param event Event to be treated - * \return Success or failure - */ -static __inline__ zap_status_t process_event(zap_span_t *span, zap_event_t *event) -{ - zap_sigmsg_t sig; - zap_analog_data_t *analog_data = event->channel->span->signal_data; - int locked = 0; - - memset(&sig, 0, sizeof(sig)); - sig.chan_id = event->channel->chan_id; - sig.span_id = event->channel->span_id; - sig.channel = event->channel; - - - zap_log(ZAP_LOG_DEBUG, "EVENT [%s][%d:%d] STATE [%s]\n", - zap_oob_event2str(event->enum_id), event->channel->span_id, event->channel->chan_id, zap_channel_state2str(event->channel->state)); - - zap_mutex_lock(event->channel->mutex); - locked++; - - switch(event->enum_id) { - case ZAP_OOB_RING_START: - { - if (event->channel->type != ZAP_CHAN_TYPE_FXO) { - zap_log(ZAP_LOG_ERROR, "Cannot get a RING_START event on a non-fxo channel, please check your config.\n"); - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_DOWN); - goto end; - } - if (!event->channel->ring_count && (event->channel->state == ZAP_CHANNEL_STATE_DOWN && !zap_test_flag(event->channel, ZAP_CHANNEL_INTHREAD))) { - if (zap_test_flag(analog_data, ZAP_ANALOG_CALLERID)) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_GET_CALLERID); - } else { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_IDLE); - } - event->channel->ring_count = 1; - zap_mutex_unlock(event->channel->mutex); - locked = 0; - zap_thread_create_detached(zap_analog_channel_run, event->channel); - } else { - event->channel->ring_count++; - } - } - break; - case ZAP_OOB_ONHOOK: - { - if (zap_test_flag(event->channel, ZAP_CHANNEL_RINGING)) { - zap_channel_command(event->channel, ZAP_COMMAND_GENERATE_RING_OFF, NULL); - } - - if (event->channel->state != ZAP_CHANNEL_STATE_DOWN) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_DOWN); - } - - } - break; - case ZAP_OOB_FLASH: - { - if (event->channel->state == ZAP_CHANNEL_STATE_CALLWAITING) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_UP); - zap_clear_flag_locked(event->channel, ZAP_CHANNEL_STATE_CHANGE); - zap_clear_flag_locked(event->channel->span, ZAP_SPAN_STATE_CHANGE); - event->channel->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK] = 0; - } - - zap_channel_rotate_tokens(event->channel); - - if (zap_test_flag(event->channel, ZAP_CHANNEL_HOLD) && event->channel->token_count != 1) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_UP); - } else { - sig.event_id = ZAP_SIGEVENT_FLASH; - analog_data->sig_cb(&sig); - } - } - break; - case ZAP_OOB_OFFHOOK: - { - if (event->channel->type == ZAP_CHAN_TYPE_FXS) { - if (zap_test_flag(event->channel, ZAP_CHANNEL_INTHREAD)) { - if (zap_test_flag(event->channel, ZAP_CHANNEL_RINGING)) { - zap_channel_command(event->channel, ZAP_COMMAND_GENERATE_RING_OFF, NULL); - } - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_UP); - } else { - if(!analog_data->max_dialstr) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_COLLECT); - } else { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_DIALTONE); - } - zap_mutex_unlock(event->channel->mutex); - locked = 0; - zap_thread_create_detached(zap_analog_channel_run, event->channel); - } - } else { - if (!zap_test_flag(event->channel, ZAP_CHANNEL_INTHREAD)) { - if (zap_test_flag(event->channel, ZAP_CHANNEL_OFFHOOK)) { - zap_channel_command(event->channel, ZAP_COMMAND_ONHOOK, NULL); - } - } - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_DOWN); - } - } - } - - end: - - if (locked) { - zap_mutex_unlock(event->channel->mutex); - } - return ZAP_SUCCESS; -} - -/** - * \brief Main thread function for analog span (monitor) - * \param me Current thread - * \param obj Span to run in this thread - */ -static void *zap_analog_run(zap_thread_t *me, void *obj) -{ - zap_span_t *span = (zap_span_t *) obj; - zap_analog_data_t *analog_data = span->signal_data; - int errs = 0; - - zap_log(ZAP_LOG_DEBUG, "ANALOG thread starting.\n"); - - while(zap_running() && zap_test_flag(analog_data, ZAP_ANALOG_RUNNING)) { - int waitms = 1000; - zap_status_t status; - - if ((status = zap_span_poll_event(span, waitms)) != ZAP_FAIL) { - errs = 0; - } - - switch(status) { - case ZAP_SUCCESS: - { - zap_event_t *event; - while (zap_span_next_event(span, &event) == ZAP_SUCCESS) { - if (event->enum_id == ZAP_OOB_NOOP) { - continue; - } - if (process_event(span, event) != ZAP_SUCCESS) { - goto end; - } - } - } - break; - case ZAP_FAIL: - { - zap_log(ZAP_LOG_ERROR, "Failure Polling event! [%s]\n", span->last_error); - if (++errs > 300) { - zap_log(ZAP_LOG_CRIT, "Too Many Errors!\n"); - goto end; - } - } - break; - default: - break; - } - - } - - end: - - zap_clear_flag(analog_data, ZAP_ANALOG_RUNNING); - - zap_log(ZAP_LOG_DEBUG, "ANALOG thread ending.\n"); - - return NULL; -} - -/** - * \brief Openzap analog signaling module initialisation - * \return Success - */ -static ZIO_SIG_LOAD_FUNCTION(zap_analog_init) -{ - return ZAP_SUCCESS; -} - -/** - * \brief Openzap analog signaling module definition - */ -EX_DECLARE_DATA zap_module_t zap_module = { - "analog", - NULL, - NULL, - zap_analog_init, - zap_analog_configure_span, - NULL -}; - - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ diff --git a/libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.c b/libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.c deleted file mode 100644 index 53bf1a000f..0000000000 --- a/libs/freetdm/src/ozmod/ozmod_analog_em/ozmod_analog_em.c +++ /dev/null @@ -1,709 +0,0 @@ -/* - * Copyright (c) 2008, Anthony Minessale II - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * Contributor(s): - * - * John Wehle (john@feith.com) - * - */ - -#include "openzap.h" -#include "zap_analog_em.h" - -#ifndef localtime_r -struct tm * localtime_r(const time_t *clock, struct tm *result); -#endif - -static void *zap_analog_em_channel_run(zap_thread_t *me, void *obj); - -/** - * \brief Starts an EM channel thread (outgoing call) - * \param zchan Channel to initiate call on - * \return Success or failure - * - * Initialises state, starts tone progress detection and runs the channel in a new a thread. - */ -static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_em_outgoing_call) -{ - if (!zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && !zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_channel_clear_needed_tones(zchan); - zap_channel_clear_detected_tones(zchan); - - zap_set_flag(zchan, ZAP_CHANNEL_OUTBOUND); - - zap_channel_command(zchan, ZAP_COMMAND_OFFHOOK, NULL); - zap_channel_command(zchan, ZAP_COMMAND_ENABLE_PROGRESS_DETECT, NULL); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DIALING); - zap_thread_create_detached(zap_analog_em_channel_run, zchan); - return ZAP_SUCCESS; - } - - return ZAP_FAIL; -} - -/** - * \brief Starts an EM span thread (monitor) - * \param span Span to monitor - * \return Success or failure - */ -static zap_status_t zap_analog_em_start(zap_span_t *span) -{ - zap_analog_em_data_t *analog_data = span->signal_data; - zap_set_flag(analog_data, ZAP_ANALOG_EM_RUNNING); - return zap_thread_create_detached(zap_analog_em_run, span); -} - -/** - * \brief Initialises an EM span from configuration variables - * \param span Span to configure - * \param sig_cb Callback function for event signals - * \param ap List of configuration variables - * \return Success or failure - */ -static ZIO_SIG_CONFIGURE_FUNCTION(zap_analog_em_configure_span) -//zap_status_t zap_analog_em_configure_span(zap_span_t *span, char *tonemap, uint32_t digit_timeout, uint32_t max_dialstr, zio_signal_cb_t sig_cb) -{ - zap_analog_em_data_t *analog_data; - const char *tonemap = "us"; - uint32_t digit_timeout = 10; - uint32_t max_dialstr = 11; - const char *var, *val; - int *intval; - - assert(sig_cb != NULL); - - if (span->signal_type) { - snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling."); - return ZAP_FAIL; - } - - analog_data = zap_malloc(sizeof(*analog_data)); - assert(analog_data != NULL); - memset(analog_data, 0, sizeof(*analog_data)); - - while((var = va_arg(ap, char *))) { - if (!strcasecmp(var, "tonemap")) { - if (!(val = va_arg(ap, char *))) { - break; - } - tonemap = val; - } else if (!strcasecmp(var, "digit_timeout")) { - if (!(intval = va_arg(ap, int *))) { - break; - } - digit_timeout = *intval; - } else if (!strcasecmp(var, "max_dialstr")) { - if (!(intval = va_arg(ap, int *))) { - break; - } - max_dialstr = *intval; - } else { - snprintf(span->last_error, sizeof(span->last_error), "Unknown parameter [%s]", var); - return ZAP_FAIL; - } - } - - - if (digit_timeout < 2000 || digit_timeout > 10000) { - digit_timeout = 2000; - } - - if (max_dialstr < 2 || max_dialstr > MAX_DIALSTRING) { - zap_log(ZAP_LOG_ERROR, "Invalid max_dialstr, setting to %d\n", MAX_DIALSTRING); - max_dialstr = MAX_DIALSTRING; - } - - span->start = zap_analog_em_start; - analog_data->digit_timeout = digit_timeout; - analog_data->max_dialstr = max_dialstr; - analog_data->sig_cb = sig_cb; - span->signal_type = ZAP_SIGTYPE_ANALOG; - span->signal_data = analog_data; - span->outgoing_call = analog_em_outgoing_call; - zap_span_load_tones(span, tonemap); - - return ZAP_SUCCESS; - -} - -/** - * \brief Retrieves tone generation output to be sent - * \param ts Teletone generator - * \param map Tone map - * \return -1 on error, 0 on success - */ -static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map) -{ - zap_buffer_t *dt_buffer = ts->user_data; - int wrote; - - if (!dt_buffer) { - return -1; - } - wrote = teletone_mux_tones(ts, map); - zap_buffer_write(dt_buffer, ts->buffer, wrote * 2); - return 0; -} - -/** - * \brief Main thread function for EM channel (outgoing call) - * \param me Current thread - * \param obj Channel to run in this thread - */ -static void *zap_analog_em_channel_run(zap_thread_t *me, void *obj) -{ - zap_channel_t *zchan = (zap_channel_t *) obj; - zap_buffer_t *dt_buffer = NULL; - teletone_generation_session_t ts; - uint8_t frame[1024]; - zap_size_t len, rlen; - zap_tone_type_t tt = ZAP_TONE_DTMF; - char dtmf[128] = ""; - zap_size_t dtmf_offset = 0; - zap_analog_em_data_t *analog_data = zchan->span->signal_data; - zap_channel_t *closed_chan; - uint32_t state_counter = 0, elapsed = 0, collecting = 0, interval = 0, last_digit = 0, indicate = 0, dial_timeout = 30000; - zap_sigmsg_t sig; - zap_status_t status; - - zap_log(ZAP_LOG_DEBUG, "ANALOG EM CHANNEL thread starting.\n"); - - ts.buffer = NULL; - - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "OPEN ERROR [%s]\n", zchan->last_error); - goto done; - } - - if (zap_buffer_create(&dt_buffer, 1024, 3192, 0) != ZAP_SUCCESS) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "memory error!"); - zap_log(ZAP_LOG_ERROR, "MEM ERROR\n"); - goto done; - } - - if (zap_channel_command(zchan, ZAP_COMMAND_ENABLE_DTMF_DETECT, &tt) != ZAP_SUCCESS) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "error initilizing tone detector!"); - zap_log(ZAP_LOG_ERROR, "TONE ERROR\n"); - goto done; - } - - zap_set_flag_locked(zchan, ZAP_CHANNEL_INTHREAD); - teletone_init_session(&ts, 0, teletone_handler, dt_buffer); - ts.rate = 8000; -#if 0 - ts.debug = 1; - ts.debug_stream = stdout; -#endif - zap_channel_command(zchan, ZAP_COMMAND_GET_INTERVAL, &interval); - zap_buffer_set_loops(dt_buffer, -1); - - memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; - - assert(interval != 0); - - while (zap_running() && zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_wait_flag_t flags = ZAP_READ; - zap_size_t dlen = 0; - - len = sizeof(frame); - - elapsed += interval; - state_counter += interval; - - if (!zap_test_flag(zchan, ZAP_CHANNEL_STATE_CHANGE)) { - switch(zchan->state) { - case ZAP_CHANNEL_STATE_DIALING: - { - if (! zchan->needed_tones[ZAP_TONEMAP_RING] - && zap_test_flag(zchan, ZAP_CHANNEL_WINK)) { - if (zap_strlen_zero(zchan->caller_data.ani.digits)) { - zap_log(ZAP_LOG_ERROR, "No Digits to send!\n"); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - if (zap_channel_command(zchan, ZAP_COMMAND_SEND_DTMF, zchan->caller_data.ani.digits) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Send Digits Failed [%s]\n", zchan->last_error); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - state_counter = 0; - zchan->needed_tones[ZAP_TONEMAP_RING] = 1; - zchan->needed_tones[ZAP_TONEMAP_BUSY] = 1; - zchan->needed_tones[ZAP_TONEMAP_FAIL1] = 1; - zchan->needed_tones[ZAP_TONEMAP_FAIL2] = 1; - zchan->needed_tones[ZAP_TONEMAP_FAIL3] = 1; - dial_timeout = ((zchan->dtmf_on + zchan->dtmf_off) * strlen(zchan->caller_data.ani.digits)) + 2000; - } - } - break; - } - if (state_counter > dial_timeout) { - if (!zap_test_flag(zchan, ZAP_CHANNEL_WINK)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); - } - } - } - break; - case ZAP_CHANNEL_STATE_DIALTONE: - { - if (state_counter > 10000) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } - } - break; - case ZAP_CHANNEL_STATE_BUSY: - { - if (state_counter > 20000) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_ATTN); - } - } - break; - case ZAP_CHANNEL_STATE_ATTN: - { - if (state_counter > 20000) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - break; - case ZAP_CHANNEL_STATE_HANGUP: - { - if (state_counter > 500) { - if (zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && - (zchan->last_state == ZAP_CHANNEL_STATE_RING || zchan->last_state == ZAP_CHANNEL_STATE_DIALTONE - || zchan->last_state >= ZAP_CHANNEL_STATE_IDLE)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else { - zchan->caller_data.hangup_cause = ZAP_CAUSE_NORMAL_CLEARING; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - } - break; - case ZAP_CHANNEL_STATE_UP: - case ZAP_CHANNEL_STATE_IDLE: - { - zap_sleep(interval); - continue; - } - break; - case ZAP_CHANNEL_STATE_DOWN: - { - goto done; - } - break; - default: - break; - } - } else { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_STATE_CHANGE); - zap_clear_flag_locked(zchan->span, ZAP_SPAN_STATE_CHANGE); - zap_channel_complete_state(zchan); - indicate = 0; - state_counter = 0; - - zap_log(ZAP_LOG_DEBUG, "Executing state handler on %d:%d for %s\n", - zchan->span_id, zchan->chan_id, - zap_channel_state2str(zchan->state)); - switch(zchan->state) { - case ZAP_CHANNEL_STATE_UP: - { - zap_channel_use(zchan); - zap_channel_clear_needed_tones(zchan); - zap_channel_flush_dtmf(zchan); - - if (!zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK)) { - zap_channel_command(zchan, ZAP_COMMAND_OFFHOOK, NULL); - } - - sig.event_id = ZAP_SIGEVENT_UP; - - analog_data->sig_cb(&sig); - continue; - } - break; - case ZAP_CHANNEL_STATE_DIALING: - { - zap_channel_use(zchan); - } - break; - case ZAP_CHANNEL_STATE_IDLE: - { - zap_channel_use(zchan); - - if (zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - zap_set_string(zchan->caller_data.dnis.digits, zchan->chan_number); - } else { - zap_set_string(zchan->caller_data.dnis.digits, dtmf); - } - - sig.event_id = ZAP_SIGEVENT_START; - - analog_data->sig_cb(&sig); - continue; - } - break; - case ZAP_CHANNEL_STATE_DOWN: - { - sig.event_id = ZAP_SIGEVENT_STOP; - analog_data->sig_cb(&sig); - goto done; - } - break; - case ZAP_CHANNEL_STATE_DIALTONE: - { - memset(&zchan->caller_data, 0, sizeof(zchan->caller_data)); - *dtmf = '\0'; - dtmf_offset = 0; - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_DIAL]); - indicate = 1; - - zap_channel_command(zchan, ZAP_COMMAND_WINK, NULL); - } - break; - case ZAP_CHANNEL_STATE_RING: - { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_RING]); - indicate = 1; - } - break; - case ZAP_CHANNEL_STATE_BUSY: - { - zchan->caller_data.hangup_cause = ZAP_CAUSE_NORMAL_CIRCUIT_CONGESTION; - if (zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && !zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_BUSY]); - indicate = 1; - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - break; - case ZAP_CHANNEL_STATE_ATTN: - { - if (zap_test_flag(zchan, ZAP_CHANNEL_OFFHOOK) && !zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - zap_buffer_zero(dt_buffer); - teletone_run(&ts, zchan->span->tone_map[ZAP_TONEMAP_ATTN]); - indicate = 1; - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - break; - default: - break; - } - } - - - if (zchan->state == ZAP_CHANNEL_STATE_DIALTONE || zchan->state == ZAP_CHANNEL_STATE_COLLECT) { - if ((dlen = zap_channel_dequeue_dtmf(zchan, dtmf + dtmf_offset, sizeof(dtmf) - strlen(dtmf)))) { - - if (zchan->state == ZAP_CHANNEL_STATE_DIALTONE) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_COLLECT); - collecting = 1; - } - dtmf_offset = strlen(dtmf); - last_digit = elapsed; - sig.event_id = ZAP_SIGEVENT_COLLECTED_DIGIT; - sig.raw_data = dtmf; - if (analog_data->sig_cb(&sig) == ZAP_BREAK) { - collecting = 0; - } - } - } - - - if (last_digit && (!collecting || ((elapsed - last_digit > analog_data->digit_timeout) || strlen(dtmf) > analog_data->max_dialstr))) { - zap_log(ZAP_LOG_DEBUG, "Number obtained [%s]\n", dtmf); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_IDLE); - last_digit = 0; - collecting = 0; - } - - if (zap_channel_wait(zchan, &flags, interval * 2) != ZAP_SUCCESS) { - continue; - } - - if (!(flags & ZAP_READ)) { - continue; - } - - if (zap_channel_read(zchan, frame, &len) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "READ ERROR [%s]\n", zchan->last_error); - goto done; - } - - if (zchan->detected_tones[0]) { - zap_sigmsg_t sig; - int i; - memset(&sig, 0, sizeof(sig)); - sig.chan_id = zchan->chan_id; - sig.span_id = zchan->span_id; - sig.channel = zchan; - sig.event_id = ZAP_SIGEVENT_TONE_DETECTED; - - for (i = 1; i < ZAP_TONEMAP_INVALID; i++) { - if (zchan->detected_tones[i]) { - zap_log(ZAP_LOG_DEBUG, "Detected tone %s on %d:%d\n", zap_tonemap2str(i), zchan->span_id, zchan->chan_id); - sig.raw_data = &i; - if (analog_data->sig_cb) { - analog_data->sig_cb(&sig); - } - } - } - - if (zchan->detected_tones[ZAP_TONEMAP_BUSY] || - zchan->detected_tones[ZAP_TONEMAP_FAIL1] || - zchan->detected_tones[ZAP_TONEMAP_FAIL2] || - zchan->detected_tones[ZAP_TONEMAP_FAIL3] || - zchan->detected_tones[ZAP_TONEMAP_ATTN] - ) { - zap_log(ZAP_LOG_ERROR, "Failure indication detected!\n"); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_BUSY); - } else if (zchan->detected_tones[ZAP_TONEMAP_RING]) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); - } - - zap_channel_clear_detected_tones(zchan); - } - - if ((zchan->dtmf_buffer && zap_buffer_inuse(zchan->dtmf_buffer))) { - rlen = len; - memset(frame, 0, len); - zap_channel_write(zchan, frame, sizeof(frame), &rlen); - continue; - } - - if (!indicate) { - continue; - } - - if (zchan->effective_codec != ZAP_CODEC_SLIN) { - len *= 2; - } - - rlen = zap_buffer_read_loop(dt_buffer, frame, len); - - if (zchan->effective_codec != ZAP_CODEC_SLIN) { - zio_codec_t codec_func = NULL; - - if (zchan->native_codec == ZAP_CODEC_ULAW) { - codec_func = zio_slin2ulaw; - } else if (zchan->native_codec == ZAP_CODEC_ALAW) { - codec_func = zio_slin2alaw; - } - - if (codec_func) { - status = codec_func(frame, sizeof(frame), &rlen); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "codec error!"); - goto done; - } - } - - zap_channel_write(zchan, frame, sizeof(frame), &rlen); - } - - done: - - zap_channel_command(zchan, ZAP_COMMAND_ONHOOK, NULL); - - closed_chan = zchan; - zap_channel_close(&zchan); - - zap_channel_command(closed_chan, ZAP_COMMAND_SET_NATIVE_CODEC, NULL); - - if (ts.buffer) { - teletone_destroy_session(&ts); - } - - if (dt_buffer) { - zap_buffer_destroy(&dt_buffer); - } - - zap_clear_flag(closed_chan, ZAP_CHANNEL_INTHREAD); - - zap_log(ZAP_LOG_DEBUG, "ANALOG EM CHANNEL thread ended.\n"); - - return NULL; -} - -/** - * \brief Processes EM events coming from zaptel/dahdi - * \param span Span on which the event was fired - * \param event Event to be treated - * \return Success or failure - */ -static __inline__ zap_status_t process_event(zap_span_t *span, zap_event_t *event) -{ - zap_sigmsg_t sig; - int locked = 0; - - memset(&sig, 0, sizeof(sig)); - sig.chan_id = event->channel->chan_id; - sig.span_id = event->channel->span_id; - sig.channel = event->channel; - - - zap_log(ZAP_LOG_DEBUG, "EVENT [%s][%d:%d] STATE [%s]\n", - zap_oob_event2str(event->enum_id), event->channel->span_id, event->channel->chan_id, zap_channel_state2str(event->channel->state)); - - zap_mutex_lock(event->channel->mutex); - locked++; - - switch(event->enum_id) { - case ZAP_OOB_ONHOOK: - { - if (event->channel->state != ZAP_CHANNEL_STATE_DOWN) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_DOWN); - } - - } - break; - case ZAP_OOB_OFFHOOK: - { - if (zap_test_flag(event->channel, ZAP_CHANNEL_INTHREAD)) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_UP); - } else { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_DIALTONE); - zap_mutex_unlock(event->channel->mutex); - locked = 0; - zap_thread_create_detached(zap_analog_em_channel_run, event->channel); - } - break; - } - case ZAP_OOB_WINK: - { - if (event->channel->state != ZAP_CHANNEL_STATE_DIALING) { - zap_set_state_locked(event->channel, ZAP_CHANNEL_STATE_DOWN); - } else { - zap_set_flag_locked(event->channel, ZAP_CHANNEL_WINK); - } - - } - break; - } - if (locked) { - zap_mutex_unlock(event->channel->mutex); - } - return ZAP_SUCCESS; -} - -/** - * \brief Main thread function for EM span (monitor) - * \param me Current thread - * \param obj Span to run in this thread - */ -static void *zap_analog_em_run(zap_thread_t *me, void *obj) -{ - zap_span_t *span = (zap_span_t *) obj; - zap_analog_em_data_t *analog_data = span->signal_data; - - zap_log(ZAP_LOG_DEBUG, "ANALOG EM thread starting.\n"); - - while(zap_running() && zap_test_flag(analog_data, ZAP_ANALOG_EM_RUNNING)) { - int waitms = 10; - zap_status_t status; - - status = zap_span_poll_event(span, waitms); - - switch(status) { - case ZAP_SUCCESS: - { - zap_event_t *event; - while (zap_span_next_event(span, &event) == ZAP_SUCCESS) { - if (event->enum_id == ZAP_OOB_NOOP) { - continue; - } - if (process_event(span, event) != ZAP_SUCCESS) { - goto end; - } - } - } - break; - case ZAP_FAIL: - { - zap_log(ZAP_LOG_ERROR, "Failure Polling event! [%s]\n", span->last_error); - } - break; - default: - break; - } - - } - - end: - - zap_clear_flag(analog_data, ZAP_ANALOG_EM_RUNNING); - - zap_log(ZAP_LOG_DEBUG, "ANALOG EM thread ending.\n"); - - return NULL; -} - -/** - * \brief Openzap analog EM module initialisation - * \return Success - */ -static ZIO_SIG_LOAD_FUNCTION(zap_analog_em_init) -{ - return ZAP_SUCCESS; -} - -/** - * \brief Openzap analog EM module definition - */ -EX_DECLARE_DATA zap_module_t zap_module = { - "analog_em", - NULL, - NULL, - zap_analog_em_init, - zap_analog_em_configure_span, - NULL -}; - - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */ diff --git a/libs/freetdm/src/ozmod/ozmod_r2/ozmod_r2.c b/libs/freetdm/src/ozmod/ozmod_r2/ozmod_r2.c deleted file mode 100644 index acc2de62a1..0000000000 --- a/libs/freetdm/src/ozmod/ozmod_r2/ozmod_r2.c +++ /dev/null @@ -1,1367 +0,0 @@ -/* - * Copyright (c) 2009, Moises Silva - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -#include -#include -#include "openzap.h" - -/* debug thread count for r2 legs */ -static zap_mutex_t* g_thread_count_mutex; -static int32_t g_thread_count = 0; - -/* when the users kills a span we clear this flag to kill the signaling thread */ -/* FIXME: what about the calls that are already up-and-running? */ -typedef enum { - ZAP_R2_RUNNING = (1 << 0), -} zap_r2_flag_t; - -/* private call information stored in zchan->call_data void* ptr */ -#define R2CALL(zchan) ((zap_r2_call_t*)((zchan)->call_data)) -typedef struct zap_r2_call_t { - openr2_chan_t *r2chan; - int accepted:1; - int answer_pending:1; - int state_ack_pending:1; - int disconnect_rcvd:1; - int zap_started:1; - zap_channel_state_t chanstate; - zap_size_t dnis_index; - zap_size_t ani_index; - char name[10]; -} zap_r2_call_t; - -/* this is just used as place holder in the stack when configuring the span to avoid using bunch of locals */ -typedef struct oz_r2_conf_s { - /* openr2 types */ - openr2_variant_t variant; - openr2_calling_party_category_t category; - openr2_log_level_t loglevel; - - /* strings */ - char *logdir; - char *advanced_protocol_file; - - /* ints */ - int32_t max_ani; - int32_t max_dnis; - int32_t mfback_timeout; - int32_t metering_pulse_timeout; - - /* booleans */ - int immediate_accept; - int skip_category; - int get_ani_first; - int call_files; - int double_answer; - int charge_calls; - int forced_release; - int allow_collect_calls; -} oz_r2_conf_t; - -/* r2 configuration stored in span->signal_data */ -typedef struct zap_r2_data_s { - /* signaling callback */ - zio_signal_cb_t sig_cb; - /* span flags */ - zap_r2_flag_t flags; - /* openr2 handle for the R2 variant context */ - openr2_context_t *r2context; - /* category to use when making calls */ - openr2_calling_party_category_t category; - /* whether to use OR2_CALL_WITH_CHARGE or OR2_CALL_NO_CHARGE when accepting a call */ - int charge_calls:1; - /* allow or reject collect calls */ - int allow_collect_calls:1; - /* whether to use forced release when hanging up */ - int forced_release:1; - /* whether accept the call when offered, or wait until the user decides to accept */ - int accept_on_offer:1; -} zap_r2_data_t; - -/* one element per span will be stored in g_mod_data_hash global var to keep track of them - and destroy them on module unload */ -typedef struct zap_r2_span_pvt_s { - openr2_context_t *r2context; /* r2 context allocated for this span */ - zap_hash_t *r2calls; /* hash table of allocated call data per channel for this span */ -} zap_r2_span_pvt_t; - -/* span monitor thread */ -static void *zap_r2_run(zap_thread_t *me, void *obj); - -/* channel monitor thread */ -static void *zap_r2_channel_run(zap_thread_t *me, void *obj); - -/* hash of all the private span allocations - we need to keep track of them to destroy them when unloading the module - since openzap does not notify signaling modules when destroying a span - span -> zap_r2_mod_allocs_t */ -static zap_hash_t *g_mod_data_hash; - -/* IO interface for the command API */ -static zap_io_interface_t g_zap_r2_interface; - -static void oz_r2_clean_call(zap_r2_call_t *call) -{ - openr2_chan_t *r2chan = call->r2chan; - memset(call, 0, sizeof(*call)); - call->r2chan = r2chan; -} - -static void oz_r2_accept_call(zap_channel_t *zchan) -{ - openr2_chan_t *r2chan = R2CALL(zchan)->r2chan; - // FIXME: not always accept as no charge, let the user decide that - // also we should check the return code from openr2_chan_accept_call and handle error condition - // hanging up the call with protocol error as the reason, this openr2 API will fail only when there something - // wrong at the I/O layer or the library itself - openr2_chan_accept_call(r2chan, OR2_CALL_NO_CHARGE); - R2CALL(zchan)->accepted = 1; -} - -static void oz_r2_answer_call(zap_channel_t *zchan) -{ - openr2_chan_t *r2chan = R2CALL(zchan)->r2chan; - // FIXME - // 1. check openr2_chan_answer_call return code - // 2. The openr2_chan_answer_call_with_mode should be used depending on user settings - // openr2_chan_answer_call_with_mode(r2chan, OR2_ANSWER_SIMPLE); - openr2_chan_answer_call(r2chan); - R2CALL(zchan)->answer_pending = 0; -} - -static ZIO_CHANNEL_OUTGOING_CALL_FUNCTION(r2_outgoing_call) -{ - zap_status_t status; - zap_mutex_lock(zchan->mutex); - - /* the channel may be down but the thread not quite done */ - zap_wait_for_flag_cleared(zchan, ZAP_CHANNEL_INTHREAD, 200); - - if (zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_log(ZAP_LOG_ERROR, "%d:%d Yay! R2 outgoing call in channel that is already in thread.\n", - zchan->span_id, zchan->chan_id); - zap_mutex_unlock(zchan->mutex); - return ZAP_FAIL; - } - - oz_r2_clean_call(zchan->call_data); - R2CALL(zchan)->chanstate = ZAP_CHANNEL_STATE_DOWN; - zap_channel_set_state(zchan, ZAP_CHANNEL_STATE_DIALING, 0); - zap_set_flag(zchan, ZAP_CHANNEL_OUTBOUND); - R2CALL(zchan)->zap_started = 1; - zap_mutex_unlock(zchan->mutex); - - status = zap_thread_create_detached(zap_r2_channel_run, zchan); - if (status == ZAP_FAIL) { - zap_log(ZAP_LOG_ERROR, "%d:%d Cannot handle request to start call in channel, failed to create thread!\n", - zchan->span_id, zchan->chan_id); - zap_channel_done(zchan); - return ZAP_FAIL; - } - - return ZAP_SUCCESS; -} - -static zap_status_t zap_r2_start(zap_span_t *span) -{ - zap_r2_data_t *r2_data = span->signal_data; - zap_set_flag(r2_data, ZAP_R2_RUNNING); - return zap_thread_create_detached(zap_r2_run, span); -} - -/* always called from the monitor thread */ -static void zap_r2_on_call_init(openr2_chan_t *r2chan) -{ - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_status_t status; - zap_log(ZAP_LOG_NOTICE, "Received request to start call on chan %d\n", openr2_chan_get_number(r2chan)); - - zap_mutex_lock(zchan->mutex); - - if (zchan->state != ZAP_CHANNEL_STATE_DOWN) { - zap_log(ZAP_LOG_ERROR, "Cannot handle request to start call in channel %d, invalid state (%d)\n", - openr2_chan_get_number(r2chan), zchan->state); - zap_mutex_unlock(zchan->mutex); - return; - } - - /* the channel may be down but the thread not quite done */ - zap_wait_for_flag_cleared(zchan, ZAP_CHANNEL_INTHREAD, 200); - - if (zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_log(ZAP_LOG_ERROR, "Cannot handle request to start call in channel %d, already in thread!\n", - openr2_chan_get_number(r2chan)); - zap_mutex_unlock(zchan->mutex); - return; - } - oz_r2_clean_call(zchan->call_data); - R2CALL(zchan)->chanstate = ZAP_CHANNEL_STATE_DOWN; - zap_channel_set_state(zchan, ZAP_CHANNEL_STATE_COLLECT, 0); - zap_mutex_unlock(zchan->mutex); - - status = zap_thread_create_detached(zap_r2_channel_run, zchan); - if (status == ZAP_FAIL) { - zap_log(ZAP_LOG_ERROR, "Cannot handle request to start call in channel %d, failed to create thread!\n", - openr2_chan_get_number(r2chan)); - } -} - -/* only called for incoming calls when the ANI, DNIS etc is complete and the user has to decide either to accept or reject the call */ -static void zap_r2_on_call_offered(openr2_chan_t *r2chan, const char *ani, const char *dnis, openr2_calling_party_category_t category) -{ - zap_sigmsg_t sigev; - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_r2_data_t *r2data = zchan->span->signal_data; - - zap_log(ZAP_LOG_NOTICE, "Call offered on chan %d, ANI = %s, DNIS = %s, Category = %s\n", openr2_chan_get_number(r2chan), - ani, dnis, openr2_proto_get_category_string(category)); - - /* notify the user about the new call */ - memset(&sigev, 0, sizeof(sigev)); - sigev.chan_id = zchan->chan_id; - sigev.span_id = zchan->span_id; - sigev.channel = zchan; - sigev.event_id = ZAP_SIGEVENT_START; - - if (r2data->sig_cb(&sigev) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_NOTICE, "Failed to handle call offered on chan %d\n", openr2_chan_get_number(r2chan)); - openr2_chan_disconnect_call(r2chan, OR2_CAUSE_OUT_OF_ORDER); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_CANCEL); - return; - } - zap_channel_use(zchan); - R2CALL(zchan)->zap_started = 1; -} - -static void zap_r2_on_call_accepted(openr2_chan_t *r2chan, openr2_call_mode_t mode) -{ - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_log(ZAP_LOG_NOTICE, "Call accepted on chan %d\n", openr2_chan_get_number(r2chan)); - /* at this point the MF signaling has ended and there is no point on keep reading */ - openr2_chan_disable_read(r2chan); - if (OR2_DIR_BACKWARD == openr2_chan_get_direction(r2chan)) { - R2CALL(zchan)->state_ack_pending = 1; - if (R2CALL(zchan)->answer_pending) { - zap_log(ZAP_LOG_DEBUG, "Answer was pending on chan %d, answering now.\n", openr2_chan_get_number(r2chan)); - oz_r2_answer_call(zchan); - return; - } - } else { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_PROGRESS); - } -} - -static void zap_r2_on_call_answered(openr2_chan_t *r2chan) -{ - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_log(ZAP_LOG_NOTICE, "Call answered on chan %d\n", openr2_chan_get_number(r2chan)); - /* notify the upper layer of progress in the outbound call */ - if (OR2_DIR_FORWARD == openr2_chan_get_direction(r2chan)) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_UP); - } -} - -/* may be called in the signaling or media thread depending on whether the hangup is product of MF or CAS signaling */ -static void zap_r2_on_call_disconnect(openr2_chan_t *r2chan, openr2_call_disconnect_cause_t cause) -{ - zap_sigmsg_t sigev; - zap_r2_data_t *r2data; - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_log(ZAP_LOG_NOTICE, "Call disconnected on chan %d\n", openr2_chan_get_number(r2chan)); - - zap_log(ZAP_LOG_DEBUG, "Got openr2 disconnection, clearing call on channel %d\n", zchan->physical_chan_id); - - R2CALL(zchan)->disconnect_rcvd = 1; - - /* acknowledge the hangup, cause will be ignored. From here to -> HANGUP once the openzap side hangs up as well */ - openr2_chan_disconnect_call(r2chan, OR2_CAUSE_NORMAL_CLEARING); - - /* if the call has not been started yet we must go to HANGUP right here */ - if (!R2CALL(zchan)->zap_started) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); - return; - } - - /* FIXME: use the cause received from openr2 and map it to zap cause */ - zchan->caller_data.hangup_cause = ZAP_CAUSE_NORMAL_CLEARING; - - /* notify the user of the call terminating */ - memset(&sigev, 0, sizeof(sigev)); - sigev.chan_id = zchan->chan_id; - sigev.span_id = zchan->span_id; - sigev.channel = zchan; - sigev.event_id = ZAP_SIGEVENT_STOP; - r2data = zchan->span->signal_data; - - r2data->sig_cb(&sigev); -} - -static void zap_r2_on_call_end(openr2_chan_t *r2chan) -{ - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_log(ZAP_LOG_NOTICE, "Call finished on chan %d\n", openr2_chan_get_number(r2chan)); - /* this means the openzap side disconnected the call, therefore we must move to DOWN here */ - if (!R2CALL(zchan)->disconnect_rcvd) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - return; - } -} - -static void zap_r2_on_call_read(openr2_chan_t *r2chan, const unsigned char *buf, int buflen) -{ - zap_log(ZAP_LOG_NOTICE, "Call read data on chan %d\n", openr2_chan_get_number(r2chan)); -} - -static void zap_r2_on_hardware_alarm(openr2_chan_t *r2chan, int alarm) -{ - zap_log(ZAP_LOG_NOTICE, "Alarm on chan %d (%d)\n", openr2_chan_get_number(r2chan), alarm); -} - -static void zap_r2_on_os_error(openr2_chan_t *r2chan, int errorcode) -{ - zap_log(ZAP_LOG_ERROR, "OS error on chan %d: %s\n", openr2_chan_get_number(r2chan), strerror(errorcode)); -} - -static void zap_r2_on_protocol_error(openr2_chan_t *r2chan, openr2_protocol_error_t reason) -{ - zap_sigmsg_t sigev; - zap_r2_data_t *r2data; - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - - zap_log(ZAP_LOG_ERROR, "Protocol error on chan %d\n", openr2_chan_get_number(r2chan)); - - R2CALL(zchan)->disconnect_rcvd = 1; - - if (!R2CALL(zchan)->zap_started) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); - return; - } - - zchan->caller_data.hangup_cause = ZAP_CAUSE_PROTOCOL_ERROR; - - /* notify the user of the call terminating */ - memset(&sigev, 0, sizeof(sigev)); - sigev.chan_id = zchan->chan_id; - sigev.span_id = zchan->span_id; - sigev.channel = zchan; - sigev.event_id = ZAP_SIGEVENT_STOP; - r2data = zchan->span->signal_data; - - r2data->sig_cb(&sigev); -} - -static void zap_r2_on_line_blocked(openr2_chan_t *r2chan) -{ - zap_log(ZAP_LOG_NOTICE, "Far end blocked on chan %d\n", openr2_chan_get_number(r2chan)); -} - -static void zap_r2_on_line_idle(openr2_chan_t *r2chan) -{ - zap_log(ZAP_LOG_NOTICE, "Far end unblocked on chan %d\n", openr2_chan_get_number(r2chan)); -} - -static void zap_r2_write_log(openr2_log_level_t level, const char *message) -{ - switch (level) { - case OR2_LOG_NOTICE: - zap_log(ZAP_LOG_NOTICE, "%s", message); - break; - case OR2_LOG_WARNING: - zap_log(ZAP_LOG_WARNING, "%s", message); - break; - case OR2_LOG_ERROR: - zap_log(ZAP_LOG_ERROR, "%s", message); - break; - case OR2_LOG_STACK_TRACE: - case OR2_LOG_MF_TRACE: - case OR2_LOG_CAS_TRACE: - case OR2_LOG_DEBUG: - case OR2_LOG_EX_DEBUG: - zap_log(ZAP_LOG_DEBUG, "%s", message); - break; - default: - zap_log(ZAP_LOG_WARNING, "We should handle logging level %d here.\n", level); - zap_log(ZAP_LOG_DEBUG, "%s", message); - break; - } -} - -static void zap_r2_on_context_log(openr2_context_t *r2context, openr2_log_level_t level, const char *fmt, va_list ap) -{ -#define CONTEXT_TAG "Context -" - char logmsg[256]; - char completemsg[sizeof(logmsg) + sizeof(CONTEXT_TAG) - 1]; - vsnprintf(logmsg, sizeof(logmsg), fmt, ap); - snprintf(completemsg, sizeof(completemsg), CONTEXT_TAG "%s", logmsg); - zap_r2_write_log(level, completemsg); -#undef CONTEXT_TAG -} - -static void zap_r2_on_chan_log(openr2_chan_t *r2chan, openr2_log_level_t level, const char *fmt, va_list ap) -{ -#define CHAN_TAG "Chan " - char logmsg[256]; - char completemsg[sizeof(logmsg) + sizeof(CHAN_TAG) - 1]; - vsnprintf(logmsg, sizeof(logmsg), fmt, ap); - snprintf(completemsg, sizeof(completemsg), CHAN_TAG "%d: %s", openr2_chan_get_number(r2chan), logmsg); - zap_r2_write_log(level, completemsg); -#undef CHAN_TAG -} - -static int zap_r2_on_dnis_digit_received(openr2_chan_t *r2chan, char digit) -{ - zap_sigmsg_t sigev; - zap_r2_data_t *r2data; - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_size_t collected_len = R2CALL(zchan)->dnis_index; - - zap_log(ZAP_LOG_DEBUG, "DNIS digit %d received chan %d\n", digit, openr2_chan_get_number(r2chan)); - - /* save the digit we just received */ - zchan->caller_data.dnis.digits[collected_len] = digit; - collected_len++; - zchan->caller_data.dnis.digits[collected_len] = '\0'; - R2CALL(zchan)->dnis_index = collected_len; - - /* notify the user about the new digit and check if we should stop requesting more DNIS */ - memset(&sigev, 0, sizeof(sigev)); - sigev.chan_id = zchan->chan_id; - sigev.span_id = zchan->span_id; - sigev.channel = zchan; - sigev.event_id = ZAP_SIGEVENT_COLLECTED_DIGIT; - r2data = zchan->span->signal_data; - if (r2data->sig_cb(&sigev) == ZAP_BREAK) { - zap_log(ZAP_LOG_NOTICE, "Requested to stop getting DNIS. Current DNIS = %s on chan %d\n", zchan->caller_data.dnis.digits, openr2_chan_get_number(r2chan)); - return OR2_STOP_DNIS_REQUEST; - } - - /* the only other reason to stop requesting DNIS is that there is no more room to save it */ - if (collected_len == (sizeof(zchan->caller_data.dnis.digits) - 1)) { - zap_log(ZAP_LOG_NOTICE, "No more room for DNIS. Current DNIS = %s on chan %d\n", zchan->caller_data.dnis.digits, openr2_chan_get_number(r2chan)); - return OR2_STOP_DNIS_REQUEST; - } - - return OR2_CONTINUE_DNIS_REQUEST; -} - -static void zap_r2_on_ani_digit_received(openr2_chan_t *r2chan, char digit) -{ - zap_channel_t *zchan = openr2_chan_get_client_data(r2chan); - zap_size_t collected_len = R2CALL(zchan)->ani_index; - - /* check if we should drop ANI */ - if (collected_len == (sizeof(zchan->caller_data.ani.digits) - 1)) { - zap_log(ZAP_LOG_NOTICE, "No more room for ANI %c on chan %d, digit dropped.\n", digit, openr2_chan_get_number(r2chan)); - return; - } - zap_log(ZAP_LOG_DEBUG, "ANI digit %c received chan %d\n", digit, openr2_chan_get_number(r2chan)); - - /* save the digit we just received */ - zchan->caller_data.ani.digits[collected_len++] = digit; - zchan->caller_data.ani.digits[collected_len] = '\0'; -} - -static openr2_event_interface_t zap_r2_event_iface = { - .on_call_init = zap_r2_on_call_init, - .on_call_offered = zap_r2_on_call_offered, - .on_call_accepted = zap_r2_on_call_accepted, - .on_call_answered = zap_r2_on_call_answered, - .on_call_disconnect = zap_r2_on_call_disconnect, - .on_call_end = zap_r2_on_call_end, - .on_call_read = zap_r2_on_call_read, - .on_hardware_alarm = zap_r2_on_hardware_alarm, - .on_os_error = zap_r2_on_os_error, - .on_protocol_error = zap_r2_on_protocol_error, - .on_line_blocked = zap_r2_on_line_blocked, - .on_line_idle = zap_r2_on_line_idle, - /* cast seems to be needed to get rid of the annoying warning regarding format attribute */ - .on_context_log = (openr2_handle_context_logging_func)zap_r2_on_context_log, - .on_dnis_digit_received = zap_r2_on_dnis_digit_received, - .on_ani_digit_received = zap_r2_on_ani_digit_received, - /* so far we do nothing with billing pulses */ - .on_billing_pulse_received = NULL -}; - -static int zap_r2_io_set_cas(openr2_chan_t *r2chan, int cas) -{ - zap_channel_t *zap_chan = openr2_chan_get_fd(r2chan); - zap_status_t status = zap_channel_command(zap_chan, ZAP_COMMAND_SET_CAS_BITS, &cas); - if (ZAP_FAIL == status) { - return -1; - } - return 0; -} - -static int zap_r2_io_get_cas(openr2_chan_t *r2chan, int *cas) -{ - zap_channel_t *zap_chan = openr2_chan_get_fd(r2chan); - zap_status_t status = zap_channel_command(zap_chan, ZAP_COMMAND_GET_CAS_BITS, cas); - if (ZAP_FAIL == status) { - return -1; - } - return 0; -} - -static int zap_r2_io_flush_write_buffers(openr2_chan_t *r2chan) -{ - zap_channel_t *zap_chan = openr2_chan_get_fd(r2chan); - zap_status_t status = zap_channel_command(zap_chan, ZAP_COMMAND_FLUSH_TX_BUFFERS, NULL); - if (ZAP_FAIL == status) { - return -1; - } - return 0; -} - -static int zap_r2_io_write(openr2_chan_t *r2chan, const void *buf, int size) -{ - zap_channel_t *zap_chan = openr2_chan_get_fd(r2chan); - zap_size_t outsize = size; - zap_status_t status = zap_channel_write(zap_chan, (void *)buf, size, &outsize); - if (ZAP_FAIL == status) { - return -1; - } - return outsize; -} - -static int zap_r2_io_read(openr2_chan_t *r2chan, const void *buf, int size) -{ - zap_channel_t *zap_chan = openr2_chan_get_fd(r2chan); - zap_size_t outsize = size; - zap_status_t status = zap_channel_read(zap_chan, (void *)buf, &outsize); - if (ZAP_FAIL == status) { - return -1; - } - return outsize; -} - -static int zap_r2_io_wait(openr2_chan_t *r2chan, int *flags, int block) -{ - zap_status_t status; - zap_wait_flag_t zapflags = 0; - - zap_channel_t *zap_chan = openr2_chan_get_fd(r2chan); - int32_t timeout = block ? -1 : 0; - - if (*flags & OR2_IO_READ) { - zapflags |= ZAP_READ; - } - if (*flags & OR2_IO_WRITE) { - zapflags |= ZAP_WRITE; - } - if (*flags & OR2_IO_OOB_EVENT) { - zapflags |= ZAP_EVENTS; - } - - status = zap_channel_wait(zap_chan, &zapflags, timeout); - - if (ZAP_SUCCESS != status) { - return -1; - } - - *flags = 0; - if (zapflags & ZAP_READ) { - *flags |= OR2_IO_READ; - } - if (zapflags & ZAP_WRITE) { - *flags |= OR2_IO_WRITE; - } - if (zapflags & ZAP_EVENTS) { - *flags |= OR2_IO_OOB_EVENT; - } - - return 0; -} - -/* The following openr2 hooks never get called, read on for reasoning ... */ -/* since openzap takes care of opening the file descriptor and using openr2_chan_new_from_fd, openr2 should never call this hook */ -static openr2_io_fd_t zap_r2_io_open(openr2_context_t *r2context, int channo) -{ - zap_log(ZAP_LOG_ERROR, "I should not be called (I/O open)!!\n"); - return NULL; -} - -/* since openzap takes care of closing the file descriptor and uses openr2_chan_new_from_fd, openr2 should never call this hook */ -static int zap_r2_io_close(openr2_chan_t *r2chan) -{ - zap_log(ZAP_LOG_ERROR, "I should not be called (I/O close)!!\n"); - return 0; -} - -/* since openzap takes care of opening the file descriptor and using openr2_chan_new_from_fd, openr2 should never call this hook */ -static int zap_r2_io_setup(openr2_chan_t *r2chan) -{ - zap_log(ZAP_LOG_ERROR, "I should not be called (I/O Setup)!!\n"); - return 0; -} - -/* since the signaling thread calls openr2_chan_process_cas_signaling directly, openr2 should never call this hook */ -static int zap_r2_io_get_oob_event(openr2_chan_t *r2chan, openr2_oob_event_t *event) -{ - *event = 0; - zap_log(ZAP_LOG_ERROR, "I should not be called (I/O get oob event)!!\n"); - return 0; -} - -static openr2_io_interface_t zap_r2_io_iface = { - .open = zap_r2_io_open, /* never called */ - .close = zap_r2_io_close, /* never called */ - .set_cas = zap_r2_io_set_cas, - .get_cas = zap_r2_io_get_cas, - .flush_write_buffers = zap_r2_io_flush_write_buffers, - .write = zap_r2_io_write, - .read = zap_r2_io_read, - .setup = zap_r2_io_setup, /* never called */ - .wait = zap_r2_io_wait, - .get_oob_event = zap_r2_io_get_oob_event /* never called */ -}; - -static ZIO_SIG_CONFIGURE_FUNCTION(zap_r2_configure_span) - //zap_status_t (zap_span_t *span, zio_signal_cb_t sig_cb, va_list ap) -{ - int i = 0; - int conf_failure = 0; - char *var = NULL; - char *val = NULL; - zap_r2_data_t *r2data = NULL; - zap_r2_span_pvt_t *spanpvt = NULL; - zap_r2_call_t *r2call = NULL; - openr2_chan_t *r2chan = NULL; - - assert(sig_cb != NULL); - - oz_r2_conf_t r2conf = - { - .variant = OR2_VAR_ITU, - .category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER, - .loglevel = OR2_LOG_ERROR | OR2_LOG_WARNING, - .max_ani = 10, - .max_dnis = 4, - .mfback_timeout = -1, - .metering_pulse_timeout = -1, - .allow_collect_calls = -1, - .immediate_accept = -1, - .skip_category = -1, - .forced_release = -1, - .charge_calls = -1, - .get_ani_first = -1, - .call_files = -1, - .logdir = NULL, - .advanced_protocol_file = NULL - }; - - - if (span->signal_type) { - snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling."); - return ZAP_FAIL; - } - - while ((var = va_arg(ap, char *))) { - zap_log(ZAP_LOG_DEBUG, "Reading R2 parameter %s for span %d\n", var, span->span_id); - if (!strcasecmp(var, "variant")) { - if (!(val = va_arg(ap, char *))) { - break; - } - if (zap_strlen_zero_buf(val)) { - zap_log(ZAP_LOG_NOTICE, "Ignoring empty R2 variant parameter\n"); - continue; - } - r2conf.variant = openr2_proto_get_variant(val); - if (r2conf.variant == OR2_VAR_UNKNOWN) { - zap_log(ZAP_LOG_ERROR, "Unknown R2 variant %s\n", val); - conf_failure = 1; - break; - } - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d for variant %s\n", span->span_id, val); - } else if (!strcasecmp(var, "category")) { - if (!(val = va_arg(ap, char *))) { - break; - } - if (zap_strlen_zero_buf(val)) { - zap_log(ZAP_LOG_NOTICE, "Ignoring empty R2 category parameter\n"); - continue; - } - r2conf.category = openr2_proto_get_category(val); - if (r2conf.category == OR2_CALLING_PARTY_CATEGORY_UNKNOWN) { - zap_log(ZAP_LOG_ERROR, "Unknown R2 caller category %s\n", val); - conf_failure = 1; - break; - } - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with default category %s\n", span->span_id, val); - } else if (!strcasecmp(var, "logdir")) { - if (!(val = va_arg(ap, char *))) { - break; - } - if (zap_strlen_zero_buf(val)) { - zap_log(ZAP_LOG_NOTICE, "Ignoring empty R2 logdir parameter\n"); - continue; - } - r2conf.logdir = val; - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with logdir %s\n", span->span_id, val); - } else if (!strcasecmp(var, "logging")) { - if (!(val = va_arg(ap, char *))) { - break; - } - if (zap_strlen_zero_buf(val)) { - zap_log(ZAP_LOG_NOTICE, "Ignoring empty R2 logging parameter\n"); - continue; - } - openr2_log_level_t tmplevel; - char *clevel; - char *logval = zap_malloc(strlen(val)+1); /* alloca man page scared me, so better to use good ol' malloc */ - if (!logval) { - zap_log(ZAP_LOG_WARNING, "Ignoring R2 logging parameter: '%s', failed to alloc memory\n", val); - continue; - } - strcpy(logval, val); - while (logval) { - clevel = strsep(&logval, ","); - if (-1 == (tmplevel = openr2_log_get_level(clevel))) { - zap_log(ZAP_LOG_WARNING, "Ignoring invalid R2 logging level: '%s'\n", clevel); - continue; - } - r2conf.loglevel |= tmplevel; - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with loglevel %s\n", span->span_id, clevel); - } - zap_safe_free(logval); - } else if (!strcasecmp(var, "advanced_protocol_file")) { - if (!(val = va_arg(ap, char *))) { - break; - } - if (zap_strlen_zero_buf(val)) { - zap_log(ZAP_LOG_NOTICE, "Ignoring empty R2 advanced_protocol_file parameter\n"); - continue; - } - r2conf.advanced_protocol_file = val; - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with advanced protocol file %s\n", span->span_id, val); - } else if (!strcasecmp(var, "allow_collect_calls")) { - r2conf.allow_collect_calls = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with allow collect calls max ani = %d\n", span->span_id, r2conf.allow_collect_calls); - } else if (!strcasecmp(var, "double_answer")) { - r2conf.double_answer = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with double answer = %d\n", span->span_id, r2conf.double_answer); - } else if (!strcasecmp(var, "immediate_accept")) { - r2conf.immediate_accept = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with immediate accept = %d\n", span->span_id, r2conf.immediate_accept); - } else if (!strcasecmp(var, "skip_category")) { - r2conf.skip_category = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with skip category = %d\n", span->span_id, r2conf.skip_category); - } else if (!strcasecmp(var, "forced_release")) { - r2conf.forced_release = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with forced release = %d\n", span->span_id, r2conf.forced_release); - } else if (!strcasecmp(var, "charge_calls")) { - r2conf.charge_calls = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with charge calls = %d\n", span->span_id, r2conf.charge_calls); - } else if (!strcasecmp(var, "get_ani_first")) { - r2conf.get_ani_first = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with get ani first = %d\n", span->span_id, r2conf.get_ani_first); - } else if (!strcasecmp(var, "call_files")) { - r2conf.call_files = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with call files = %d\n", span->span_id, r2conf.call_files); - } else if (!strcasecmp(var, "mfback_timeout")) { - r2conf.mfback_timeout = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with MF backward timeout = %dms\n", span->span_id, r2conf.mfback_timeout); - } else if (!strcasecmp(var, "metering_pulse_timeout")) { - r2conf.metering_pulse_timeout = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with metering pulse timeout = %dms\n", span->span_id, r2conf.metering_pulse_timeout); - } else if (!strcasecmp(var, "max_ani")) { - r2conf.max_ani = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with max ani = %d\n", span->span_id, r2conf.max_ani); - } else if (!strcasecmp(var, "max_dnis")) { - r2conf.max_dnis = va_arg(ap, int); - zap_log(ZAP_LOG_DEBUG, "Configuring R2 span %d with max dnis = %d\n", span->span_id, r2conf.max_dnis); - } else { - snprintf(span->last_error, sizeof(span->last_error), "Unknown R2 parameter [%s]", var); - return ZAP_FAIL; - } - } - - if (conf_failure) { - snprintf(span->last_error, sizeof(span->last_error), "R2 configuration error"); - return ZAP_FAIL; - } - - r2data = zap_malloc(sizeof(*r2data)); - if (!r2data) { - snprintf(span->last_error, sizeof(span->last_error), "Failed to allocate R2 data."); - return ZAP_FAIL; - } - memset(r2data, 0, sizeof(*r2data)); - - spanpvt = zap_malloc(sizeof(*spanpvt)); - if (!spanpvt) { - snprintf(span->last_error, sizeof(span->last_error), "Failed to allocate private span data container."); - goto fail; - } - memset(spanpvt, 0, sizeof(*spanpvt)); - - r2data->r2context = openr2_context_new(r2conf.variant, &zap_r2_event_iface, r2conf.max_ani, r2conf.max_dnis); - if (!r2data->r2context) { - snprintf(span->last_error, sizeof(span->last_error), "Cannot create openr2 context for span."); - goto fail; - } - openr2_context_set_io_type(r2data->r2context, OR2_IO_CUSTOM, &zap_r2_io_iface); - openr2_context_set_log_level(r2data->r2context, r2conf.loglevel); - openr2_context_set_ani_first(r2data->r2context, r2conf.get_ani_first); - openr2_context_set_skip_category_request(r2data->r2context, r2conf.skip_category); - openr2_context_set_mf_back_timeout(r2data->r2context, r2conf.mfback_timeout); - openr2_context_set_metering_pulse_timeout(r2data->r2context, r2conf.metering_pulse_timeout); - openr2_context_set_double_answer(r2data->r2context, r2conf.double_answer); - openr2_context_set_immediate_accept(r2data->r2context, r2conf.immediate_accept); - if (r2conf.logdir) { - openr2_context_set_log_directory(r2data->r2context, r2conf.logdir); - } - if (r2conf.advanced_protocol_file) { - openr2_context_configure_from_advanced_file(r2data->r2context, r2conf.advanced_protocol_file); - } - - spanpvt->r2calls = create_hashtable(ZAP_MAX_CHANNELS_SPAN, zap_hash_hashfromstring, zap_hash_equalkeys); - if (!spanpvt->r2calls) { - snprintf(span->last_error, sizeof(span->last_error), "Cannot create channel calls hash for span."); - goto fail; - } - - for (i = 1; (i <= span->chan_count) && (i <= ZAP_MAX_CHANNELS_SPAN); i++) { - r2chan = openr2_chan_new_from_fd(r2data->r2context, span->channels[i], span->channels[i]->physical_chan_id); - if (!r2chan) { - snprintf(span->last_error, sizeof(span->last_error), "Cannot create all openr2 channels for span."); - goto fail; - } - if (r2conf.call_files) { - openr2_chan_enable_call_files(r2chan); - openr2_chan_set_log_level(r2chan, r2conf.loglevel); - } - - r2call = zap_malloc(sizeof(*r2call)); - if (!r2call) { - snprintf(span->last_error, sizeof(span->last_error), "Cannot create all R2 call data structures for the span."); - zap_safe_free(r2chan); - goto fail; - } - memset(r2call, 0, sizeof(*r2call)); - openr2_chan_set_logging_func(r2chan, zap_r2_on_chan_log); - openr2_chan_set_client_data(r2chan, span->channels[i]); - r2call->r2chan = r2chan; - span->channels[i]->call_data = r2call; - /* value and key are the same so just free one of them */ - snprintf(r2call->name, sizeof(r2call->name), "chancall%d", i); - hashtable_insert(spanpvt->r2calls, (void *)r2call->name, r2call, HASHTABLE_FLAG_FREE_VALUE); - - } - spanpvt->r2context = r2data->r2context; - - /* just the value must be freed by the hash */ - hashtable_insert(g_mod_data_hash, (void *)span->name, spanpvt, HASHTABLE_FLAG_FREE_VALUE); - - span->start = zap_r2_start; - r2data->flags = 0; - r2data->sig_cb = sig_cb; - span->signal_type = ZAP_SIGTYPE_R2; - span->signal_data = r2data; - span->outgoing_call = r2_outgoing_call; - - return ZAP_SUCCESS; - -fail: - - if (r2data && r2data->r2context) { - openr2_context_delete(r2data->r2context); - } - if (spanpvt && spanpvt->r2calls) { - hashtable_destroy(spanpvt->r2calls); - } - zap_safe_free(r2data); - zap_safe_free(spanpvt); - return ZAP_FAIL; - -} - -static void *zap_r2_channel_run(zap_thread_t *me, void *obj) -{ - zap_channel_t *closed_chan; - uint32_t interval = 0; - zap_sigmsg_t sigev; - zap_channel_t *zchan = (zap_channel_t *)obj; - openr2_chan_t *r2chan = R2CALL(zchan)->r2chan; - zap_r2_data_t *r2data = zchan->span->signal_data; - - zap_set_flag_locked(zchan, ZAP_CHANNEL_INTHREAD); - - zap_mutex_lock(g_thread_count_mutex); - g_thread_count++; - zap_mutex_unlock(g_thread_count_mutex); - - zap_log(ZAP_LOG_DEBUG, "R2 CHANNEL thread starting on %d in state %s.\n", - zchan->physical_chan_id, - zap_channel_state2str(zchan->state)); - - if (zap_channel_open_chan(zchan) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "OPEN ERROR [%s]\n", zchan->last_error); - goto endthread; - } - - zap_channel_command(zchan, ZAP_COMMAND_GET_INTERVAL, &interval); - - assert(interval != 0); - zap_log(ZAP_LOG_DEBUG, "Got %d interval for chan %d\n", interval, zchan->physical_chan_id); - - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - /* FIXME: is this needed? */ - memset(zchan->caller_data.dnis.digits, 0, sizeof(zchan->caller_data.collected)); - memset(zchan->caller_data.ani.digits, 0, sizeof(zchan->caller_data.collected)); - } - - memset(&sigev, 0, sizeof(sigev)); - sigev.chan_id = zchan->chan_id; - sigev.span_id = zchan->span_id; - sigev.channel = zchan; - - while (zap_running()) { - int32_t read_enabled = openr2_chan_get_read_enabled(r2chan); - zap_wait_flag_t flags = read_enabled ? ( ZAP_READ | ZAP_WRITE ) : 0; - - if (zap_test_flag(zchan, ZAP_CHANNEL_STATE_CHANGE) && (R2CALL(zchan)->chanstate != zchan->state)) { - - zap_log(ZAP_LOG_DEBUG, "Executing state handler on %d:%d for %s\n", zchan->span_id, zchan->chan_id, zap_channel_state2str(zchan->state)); - R2CALL(zchan)->chanstate = zchan->state; - - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) && !R2CALL(zchan)->accepted && - (zchan->state == ZAP_CHANNEL_STATE_PROGRESS || - zchan->state == ZAP_CHANNEL_STATE_PROGRESS_MEDIA || - zchan->state == ZAP_CHANNEL_STATE_UP) ) { - /* if an accept ack will be required we should not acknowledge the state change just yet, - it will be done below after processing the MF signals, otherwise we have a race condition between openzap calling - openr2_chan_answer_call and openr2 accepting the call first, if openzap calls openr2_chan_answer_call before the accept cycle - completes, openr2 will fail to answer the call */ - zap_log(ZAP_LOG_DEBUG, "State ack in chan %d:%d for state %s will have to wait a bit\n", zchan->span_id, zchan->chan_id, zap_channel_state2str(zchan->state)); - } else if (zchan->state != ZAP_CHANNEL_STATE_DOWN){ - /* the down state will be completed in zap_channel_done below */ - zap_clear_flag_locked(zchan, ZAP_CHANNEL_STATE_CHANGE); - zap_channel_complete_state(zchan); - } - - switch (zchan->state) { - - /* starting an incoming call */ - case ZAP_CHANNEL_STATE_COLLECT: - { - zap_log(ZAP_LOG_DEBUG, "COLLECT: Starting processing of incoming call in channel %d with interval %d\n", zchan->physical_chan_id, interval); - } - break; - - /* starting an outgoing call */ - case ZAP_CHANNEL_STATE_DIALING: - { - // FIXME: use user defined calling party - zap_channel_use(zchan); - zap_log(ZAP_LOG_DEBUG, "DIALING: Starting processing of outgoing call in channel %d with interval %d\n", zchan->physical_chan_id, interval); - if (openr2_chan_make_call(r2chan, zchan->caller_data.cid_num.digits, zchan->caller_data.ani.digits, OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER)) { - zap_log(ZAP_LOG_ERROR, "%d:%d Failed to make call in R2 channel, openr2_chan_make_call failed\n", zchan->span_id, zchan->chan_id); - zchan->caller_data.hangup_cause = ZAP_CAUSE_DESTINATION_OUT_OF_ORDER; - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); - } - } - break; - - /* the call is ringing */ - case ZAP_CHANNEL_STATE_PROGRESS: - case ZAP_CHANNEL_STATE_PROGRESS_MEDIA: - { - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - if (!R2CALL(zchan)->accepted) { - zap_log(ZAP_LOG_DEBUG, "PROGRESS: Accepting call on channel %d\n", zchan->physical_chan_id); - oz_r2_accept_call(zchan); - } - } else { - zap_log(ZAP_LOG_DEBUG, "PROGRESS: Notifying progress in channel %d\n", zchan->physical_chan_id); - sigev.event_id = ZAP_SIGEVENT_PROGRESS; - if (r2data->sig_cb(&sigev) != ZAP_SUCCESS) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); - } - } - } - break; - - /* the call was answered */ - case ZAP_CHANNEL_STATE_UP: - { - zap_log(ZAP_LOG_DEBUG, "UP: Call was answered on channel %d\n", zchan->physical_chan_id); - if (!zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND)) { - if (!R2CALL(zchan)->accepted) { - zap_log(ZAP_LOG_DEBUG, "UP: Call has not been accepted, need to accept first\n"); - // the answering will be done in the on_call_accepted handler - oz_r2_accept_call(zchan); - R2CALL(zchan)->answer_pending = 1; - } else { - oz_r2_answer_call(zchan); - } - } else { - zap_log(ZAP_LOG_DEBUG, "UP: Notifying of call answered in channel %d\n", zchan->physical_chan_id); - sigev.event_id = ZAP_SIGEVENT_UP; - if (r2data->sig_cb(&sigev) != ZAP_SUCCESS) { - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); - } - } - } - break; - - /* just got hangup */ - case ZAP_CHANNEL_STATE_HANGUP: - { - /* FIXME: the cause should be retrieved from zchan->caller_data.hangup_cause and translated from Q931 to R2 cause */ - zap_log(ZAP_LOG_DEBUG, "HANGUP: Clearing call on channel %d\n", zchan->physical_chan_id); - if (!R2CALL(zchan)->disconnect_rcvd) { - /* this will disconnect the call, but need to wait for the call end before moving to DOWN */ - openr2_chan_disconnect_call(r2chan, OR2_CAUSE_NORMAL_CLEARING); - } else { - /* at this point on_call_end possibly was already called, - * but we needed to wait for the openzap confirmation before moving to DOWN */ - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_DOWN); - } - } - break; - - /* just got hangup from the openzap side due to abnormal failure */ - case ZAP_CHANNEL_STATE_CANCEL: - { - zap_log(ZAP_LOG_DEBUG, "CANCEL: Unable to receive call on channel %d\n", zchan->physical_chan_id); - openr2_chan_disconnect_call(r2chan, OR2_CAUSE_OUT_OF_ORDER); - } - break; - - /* finished call for good */ - case ZAP_CHANNEL_STATE_DOWN: - { - zap_log(ZAP_LOG_DEBUG, "DOWN: Placing channel %d back to the pool of available channels\n", zchan->physical_chan_id); - zap_channel_done(zchan); - goto endthread; - } - break; - - default: - { - zap_log(ZAP_LOG_ERROR, "%s: Unhandled channel state change in channel %d\n", zap_channel_state2str(zchan->state), zchan->physical_chan_id); - } - break; - - } - } - - if (flags) { - if (zap_channel_wait(zchan, &flags, interval * 2) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_DEBUG, "zap_channel_wait did not return ZAP_SUCCESS\n"); - continue; - } - - /* handle timeout events first if any */ - openr2_chan_run_schedule(r2chan); - - /* openr2 will now try to detect MF tones, make sense out of them, reply if necessary with another tone and trigger - * telephony events via the call event interface we provided when creating the R2 context. - * openr2 will also call our I/O callbacks to retrieve audio from the channel and call our wait poll I/O registered callback - * and will not return from this function until the I/O poll callback returns no pending events - * */ - openr2_chan_process_mf_signaling(r2chan); - if (R2CALL(zchan)->state_ack_pending) { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_STATE_CHANGE); - zap_channel_complete_state(zchan); - R2CALL(zchan)->state_ack_pending = 0; - } - } else { - /* once the MF signaling has end we just loop here waiting for state changes */ - zap_sleep(interval); - } - - } - -endthread: - - closed_chan = zchan; - zap_channel_close(&closed_chan); - zap_clear_flag(zchan, ZAP_CHANNEL_INTHREAD); - zap_log(ZAP_LOG_DEBUG, "R2 channel %d thread ended.\n", zchan->physical_chan_id); - - zap_mutex_lock(g_thread_count_mutex); - g_thread_count--; - zap_mutex_unlock(g_thread_count_mutex); - - return NULL; -} - -static void *zap_r2_run(zap_thread_t *me, void *obj) -{ - openr2_chan_t *r2chan; - zap_status_t status; - zap_span_t *span = (zap_span_t *) obj; - zap_r2_data_t *r2data = span->signal_data; - int waitms = 1000; - int i; - - zap_log(ZAP_LOG_DEBUG, "OpenR2 monitor thread started.\n"); - r2chan = NULL; - for (i = 1; i <= span->chan_count; i++) { - r2chan = R2CALL(span->channels[i])->r2chan; - openr2_chan_set_idle(r2chan); - openr2_chan_process_cas_signaling(r2chan); - } - - while (zap_running() && zap_test_flag(r2data, ZAP_R2_RUNNING)) { - status = zap_span_poll_event(span, waitms); - if (ZAP_FAIL == status) { - zap_log(ZAP_LOG_ERROR, "Failure Polling event! [%s]\n", span->last_error); - continue; - } - if (ZAP_SUCCESS == status) { - zap_event_t *event; - while (zap_span_next_event(span, &event) == ZAP_SUCCESS) { - if (event->enum_id == ZAP_OOB_CAS_BITS_CHANGE) { - r2chan = R2CALL(event->channel)->r2chan; - zap_log(ZAP_LOG_DEBUG, "Handling CAS on channel %d.\n", openr2_chan_get_number(r2chan)); - // we only expect CAS and other OOB events on this thread/loop, once a call is started - // the MF events (in-band signaling) are handled in the call thread - openr2_chan_process_cas_signaling(r2chan); - } else { - zap_log(ZAP_LOG_DEBUG, "Ignoring event %d on channel %d.\n", event->enum_id, openr2_chan_get_number(r2chan)); - // XXX TODO: handle alarms here XXX - } - } - } else if (status != ZAP_TIMEOUT) { - zap_log(ZAP_LOG_ERROR, "zap_span_poll_event returned %d.\n", status); - } else { - //zap_log(ZAP_LOG_DEBUG, "timed out waiting for event on span %d\n", span->span_id); - } - } - - /* - FIXME: we should set BLOCKED but at this point I/O routines of openzap caused segfault - for (i = 1; i <= span->chan_count; i++) { - r2chan = R2CALL(span->channels[i])->r2chan; - openr2_chan_set_blocked(r2chan); - } - */ - - zap_clear_flag(r2data, ZAP_R2_RUNNING); - zap_log(ZAP_LOG_DEBUG, "R2 thread ending.\n"); - - return NULL; - -} - -static ZIO_API_FUNCTION(zap_r2_api) -{ - char *mycmd = NULL, *argv[10] = { 0 }; - int argc = 0; - - if (data) { - mycmd = zap_strdup(data); - argc = zap_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0]))); - } - - if (argc == 2) { - if (!strcasecmp(argv[0], "kill")) { - int span_id = atoi(argv[1]); - zap_span_t *span = NULL; - - if (zap_span_find_by_name(argv[1], &span) == ZAP_SUCCESS || zap_span_find(span_id, &span) == ZAP_SUCCESS) { - zap_r2_data_t *r2data = span->signal_data; - - if (span->start != zap_r2_start) { - stream->write_function(stream, "-ERR invalid span.\n"); - goto done; - } - - zap_clear_flag(r2data, ZAP_R2_RUNNING); - stream->write_function(stream, "+OK killed.\n"); - goto done; - } else { - stream->write_function(stream, "-ERR invalid span.\n"); - goto done; - } - } - - if (!strcasecmp(argv[0], "status")) { - int span_id = atoi(argv[1]); - zap_r2_data_t *r2data = NULL; - zap_span_t *span = NULL; - openr2_chan_t *r2chan = NULL; - openr2_context_t *r2context = NULL; - int i = 0; - - if (zap_span_find_by_name(argv[1], &span) == ZAP_SUCCESS || zap_span_find(span_id, &span) == ZAP_SUCCESS) { - if (span->start != zap_r2_start) { - stream->write_function(stream, "-ERR not an R2 span.\n"); - goto done; - } - if (!(r2data = span->signal_data)) { - stream->write_function(stream, "-ERR invalid span. No R2 singal data in span.\n"); - goto done; - } - r2context = r2data->r2context; - openr2_variant_t r2variant = openr2_context_get_variant(r2context); - stream->write_function(stream, - "Variant: %s\n" - "Max ANI: %d\n" - "Max DNIS: %d\n" - "ANI First: %s\n" - "Immediate Accept: %s\n", - openr2_proto_get_variant_string(r2variant), - openr2_context_get_max_ani(r2context), - openr2_context_get_max_dnis(r2context), - openr2_context_get_ani_first(r2context) ? "Yes" : "No", - openr2_context_get_immediate_accept(r2context) ? "Yes" : "No"); - stream->write_function(stream, "\n"); - stream->write_function(stream, "%4s %-12.12s %-12.12s\n", "Channel", "Tx CAS", "Rx CAS"); - for (i = 1; i <= span->chan_count; i++) { - if (i == 16) continue; - r2chan = R2CALL(span->channels[i])->r2chan; - stream->write_function(stream, "%4d %-12.12s %-12.12s\n", - span->channels[i]->physical_chan_id, - openr2_chan_get_tx_cas_string(r2chan), - openr2_chan_get_rx_cas_string(r2chan)); - } - stream->write_function(stream, "\n"); - stream->write_function(stream, "+OK.\n"); - goto done; - } else { - stream->write_function(stream, "-ERR invalid span.\n"); - goto done; - } - } - - } - - if (argc == 1) { - if (!strcasecmp(argv[0], "threads")) { - zap_mutex_lock(g_thread_count_mutex); - stream->write_function(stream, "%d R2 channel threads up\n", g_thread_count); - zap_mutex_unlock(g_thread_count_mutex); - stream->write_function(stream, "+OK.\n"); - goto done; - } - - if (!strcasecmp(argv[0], "version")) { - stream->write_function(stream, "OpenR2 version: %s, revision: %s\n", openr2_get_version(), openr2_get_revision()); - stream->write_function(stream, "+OK.\n"); - goto done; - } - - if (!strcasecmp(argv[0], "variants")) { - int32_t numvariants = 0; - const openr2_variant_entry_t *variants = openr2_proto_get_variant_list(&numvariants); - if (!variants) { - stream->write_function(stream, "-ERR failed to retrieve openr2 variant list.\n"); - goto done; - } -#define VARIANT_FORMAT "%4s %40s\n" - stream->write_function(stream, VARIANT_FORMAT, "Variant Code", "Country"); - numvariants--; - for (; numvariants; numvariants--) { - stream->write_function(stream, VARIANT_FORMAT, variants[numvariants].name, variants[numvariants].country); - } - stream->write_function(stream, "+OK.\n"); -#undef VARIANT_FORMAT - goto done; - } - } - - stream->write_function(stream, "-ERR invalid command.\n"); - -done: - - zap_safe_free(mycmd); - - return ZAP_SUCCESS; - -} - -static ZIO_IO_LOAD_FUNCTION(zap_r2_io_init) -{ - assert(zio != NULL); - memset(&g_zap_r2_interface, 0, sizeof(g_zap_r2_interface)); - - g_zap_r2_interface.name = "r2"; - g_zap_r2_interface.api = zap_r2_api; - - *zio = &g_zap_r2_interface; - - return ZAP_SUCCESS; -} - -static ZIO_SIG_LOAD_FUNCTION(zap_r2_init) -{ - g_mod_data_hash = create_hashtable(10, zap_hash_hashfromstring, zap_hash_equalkeys); - if (!g_mod_data_hash) { - return ZAP_FAIL; - } - zap_mutex_create(&g_thread_count_mutex); - return ZAP_SUCCESS; -} - -static ZIO_SIG_UNLOAD_FUNCTION(zap_r2_destroy) -{ - zap_hash_iterator_t *i = NULL; - zap_r2_span_pvt_t *spanpvt = NULL; - const void *key = NULL; - void *val = NULL; - for (i = hashtable_first(g_mod_data_hash); i; i = hashtable_next(i)) { - hashtable_this(i, &key, NULL, &val); - if (key && val) { - spanpvt = val; - openr2_context_delete(spanpvt->r2context); - hashtable_destroy(spanpvt->r2calls); - } - } - hashtable_destroy(g_mod_data_hash); - zap_mutex_destroy(&g_thread_count_mutex); - return ZAP_SUCCESS; -} - -zap_module_t zap_module = { - "r2", - zap_r2_io_init, - NULL, - zap_r2_init, - zap_r2_configure_span, - zap_r2_destroy -}; - - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4 - */ diff --git a/libs/freetdm/src/priserver.c b/libs/freetdm/src/priserver.c index 7a37357083..a6ca7d5c2f 100644 --- a/libs/freetdm/src/priserver.c +++ b/libs/freetdm/src/priserver.c @@ -13,7 +13,7 @@ * ============================================================================ */ -#include "openzap.h" +#include "freetdm.h" #include #include #include @@ -33,9 +33,9 @@ typedef struct { static call_info_t pidmap[SANGOMA_MAX_CHAN_PER_SPAN]; -ZIO_EVENT_CB_FUNCTION(my_zap_event_handler) +ZIO_EVENT_CB_FUNCTION(my_ftdm_event_handler) { - if (event->e_type = ZAP_EVENT_DTMF) { + if (event->e_type = FTDM_EVENT_DTMF) { char *dtmf = event->data; printf("DTMF %s\n", dtmf); } @@ -64,12 +64,12 @@ static void launch_channel(struct sangoma_pri *spri, int channo) fd_set readfds; int mtu_mru=BYTES / 2; int err; - zap_channel_t *chan; - zap_codec_t codec = ZAP_CODEC_SLIN; + ftdm_channel_t *chan; + ftdm_codec_t codec = FTDM_CODEC_SLIN; unsigned ms = 20; unsigned int lead = 50; int ifd = -1; - zap_tone_type_t tt = ZAP_TONE_DTMF; + ftdm_tone_type_t tt = FTDM_TONE_DTMF; char dtmf[] = "1234567890"; int loops = 0; @@ -88,47 +88,47 @@ static void launch_channel(struct sangoma_pri *spri, int channo) memset(inframe, 0, MAX_BYTES); memset(outframe, 0, MAX_BYTES); - if (zap_channel_open(spri->span, channo, &chan) != ZAP_SUCCESS) { + if (ftdm_channel_open(spri->span, channo, &chan) != FTDM_SUCCESS) { printf("DEBUG cant open fd!\n"); } #if 1 - if (zap_channel_command(chan, ZAP_COMMAND_SET_CODEC, &codec) != ZAP_SUCCESS) { + if (ftdm_channel_command(chan, FTDM_COMMAND_SET_CODEC, &codec) != FTDM_SUCCESS) { printf("Critical Error: Failed to set driver codec!\n"); - zap_channel_close(&chan); + ftdm_channel_close(&chan); exit(-1); } #endif #if 1 - if (zap_channel_command(chan, ZAP_COMMAND_ENABLE_DTMF_DETECT, &tt) != ZAP_SUCCESS) { + if (ftdm_channel_command(chan, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) { printf("Critical Error: Failed to set dtmf detect!\n"); - zap_channel_close(&chan); + ftdm_channel_close(&chan); exit(-1); } - zap_channel_set_event_callback(chan, my_zap_event_handler); + ftdm_channel_set_event_callback(chan, my_ftdm_event_handler); #endif - if (zap_channel_command(chan, ZAP_COMMAND_SET_INTERVAL, &ms) != ZAP_SUCCESS) { + if (ftdm_channel_command(chan, FTDM_COMMAND_SET_INTERVAL, &ms) != FTDM_SUCCESS) { printf("Critical Error: Failed to set codec interval!\n"); - zap_channel_close(&chan); + ftdm_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); + ftdm_channel_close(&chan); exit(-1); } while(ready) { - zap_wait_flag_t flags = ZAP_READ; - zap_size_t len; + ftdm_wait_flag_t flags = FTDM_READ; + ftdm_size_t len; loops++; if (lead) { @@ -137,23 +137,23 @@ static void launch_channel(struct sangoma_pri *spri, int channo) if (!lead && loops == 300) { #if 1 - if (zap_channel_command(chan, ZAP_COMMAND_SEND_DTMF, dtmf) != ZAP_SUCCESS) { + if (ftdm_channel_command(chan, FTDM_COMMAND_SEND_DTMF, dtmf) != FTDM_SUCCESS) { printf("Critical Error: Failed to send dtmf\n"); - zap_channel_close(&chan); + ftdm_channel_close(&chan); exit(-1); } #endif } - if (zap_channel_wait(chan, &flags, 2000) != ZAP_SUCCESS) { + if (ftdm_channel_wait(chan, &flags, 2000) != FTDM_SUCCESS) { printf("wait FAIL! [%s]\n", chan->last_error); break; } - if (flags & ZAP_READ) { + if (flags & FTDM_READ) { len = MAX_BYTES; - if (zap_channel_read(chan, inframe, &len) == ZAP_SUCCESS) { + if (ftdm_channel_read(chan, inframe, &len) == FTDM_SUCCESS) { //printf("READ: %d\n", len); //write(ifd, inframe, len); if(!lead && (outlen = read(file, outframe, len)) <= 0) { @@ -167,7 +167,7 @@ static void launch_channel(struct sangoma_pri *spri, int channo) if (lead) { continue; } - zap_channel_write(chan, outframe, sizeof(outframe), &len); + ftdm_channel_write(chan, outframe, sizeof(outframe), &len); } else { printf("BREAK"); break; @@ -181,7 +181,7 @@ static void launch_channel(struct sangoma_pri *spri, int channo) //close(ifd); pri_hangup(spri->pri, channo, 16); - if (zap_channel_close(&chan) != ZAP_SUCCESS) { + if (ftdm_channel_close(&chan) != FTDM_SUCCESS) { printf("Critical Error: Failed to close channel [%s]\n", chan->last_error); } @@ -280,13 +280,13 @@ int main(int argc, char *argv[]) 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"); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); debug = PRI_DEBUG_Q931_DUMP | PRI_DEBUG_Q931_STATE; diff --git a/libs/freetdm/src/sangoma_pri.c b/libs/freetdm/src/sangoma_pri.c index 5cf6a5cd10..402611e518 100644 --- a/libs/freetdm/src/sangoma_pri.c +++ b/libs/freetdm/src/sangoma_pri.c @@ -13,7 +13,7 @@ * ============================================================================ */ -#include "openzap.h" +#include "freetdm.h" #include #ifndef HAVE_GETTIMEOFDAY @@ -92,12 +92,12 @@ char *sangoma_pri_event_str(sangoma_pri_event_t event_id) 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; + ftdm_size_t len = buflen; int res; char bb[4096] = ""; - if (zap_channel_read(spri->zdchan, buf, &len) != ZAP_SUCCESS) { + if (ftdm_channel_read(spri->zdchan, buf, &len) != FTDM_SUCCESS) { printf("D-READ FAIL! [%s]\n", spri->zdchan->last_error); return 0; } @@ -106,7 +106,7 @@ static int __pri_sangoma_read(struct pri *pri, void *buf, int buflen) res+=2; //print_bits(buf, res-2, bb, sizeof(bb), 1, 0); - //zap_log(ZAP_LOG_DEBUG, "READ %d\n%s\n%s\n\n", res-2, LINE, bb); + //ftdm_log(FTDM_LOG_DEBUG, "READ %d\n%s\n%s\n\n", res-2, LINE, bb); return res; } @@ -115,16 +115,16 @@ 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; + ftdm_size_t len = buflen -2; char bb[4096] = ""; - if (zap_channel_write(spri->zdchan, buf, buflen, &len) != ZAP_SUCCESS) { + if (ftdm_channel_write(spri->zdchan, buf, buflen, &len) != FTDM_SUCCESS) { printf("D-WRITE FAIL! [%s]\n", spri->zdchan->last_error); return 0; } //print_bits(buf, (int)buflen-2, bb, sizeof(bb), 1, 0); - //zap_log(ZAP_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)buflen-2, LINE, bb); + //ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)buflen-2, LINE, bb); return (int) buflen; } @@ -132,11 +132,11 @@ static int __pri_sangoma_write(struct pri *pri, void *buf, 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; + ftdm_socket_t dfd = 0; memset(spri, 0, sizeof(struct sangoma_pri)); - if (zap_channel_open(span, dchan, &spri->zdchan) != ZAP_SUCCESS) { + if (ftdm_channel_open(span, dchan, &spri->zdchan) != FTDM_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))){ diff --git a/libs/freetdm/src/sangoma_pri.h b/libs/freetdm/src/sangoma_pri.h index 5ea21eb7b5..2a1b2a2cef 100644 --- a/libs/freetdm/src/sangoma_pri.h +++ b/libs/freetdm/src/sangoma_pri.h @@ -79,7 +79,7 @@ struct sangoma_pri { void *private_info; event_handler eventmap[MAX_EVENT+1]; loop_handler on_loop; - zap_channel_t *zdchan; + ftdm_channel_t *zdchan; }; struct sangoma_pri_event_list { diff --git a/libs/freetdm/src/testanalog.c b/libs/freetdm/src/testanalog.c index 1a9542be4f..7b5d3db874 100644 --- a/libs/freetdm/src/testanalog.c +++ b/libs/freetdm/src/testanalog.c @@ -1,61 +1,61 @@ -#include "openzap.h" +#include "freetdm.h" -static void *test_call(zap_thread_t *me, void *obj) +static void *test_call(ftdm_thread_t *me, void *obj) { - zap_channel_t *chan = (zap_channel_t *) obj; + ftdm_channel_t *chan = (ftdm_channel_t *) obj; uint8_t frame[1024]; - zap_size_t len; + ftdm_size_t len; char *number = strdup("5551212"); - zap_sleep(10 * 1000); + ftdm_sleep(10 * 1000); - zap_log(ZAP_LOG_DEBUG, "answer call and start echo test\n"); + ftdm_log(FTDM_LOG_DEBUG, "answer call and start echo test\n"); - zap_set_state_locked(chan, ZAP_CHANNEL_STATE_UP); - zap_channel_command(chan, ZAP_COMMAND_SEND_DTMF, number); + ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_UP); + ftdm_channel_command(chan, FTDM_COMMAND_SEND_DTMF, number); - while (chan->state == ZAP_CHANNEL_STATE_UP) { - zap_wait_flag_t flags = ZAP_READ; + while (chan->state == FTDM_CHANNEL_STATE_UP) { + ftdm_wait_flag_t flags = FTDM_READ; - if (zap_channel_wait(chan, &flags, -1) == ZAP_FAIL) { + if (ftdm_channel_wait(chan, &flags, -1) == FTDM_FAIL) { break; } len = sizeof(frame); - if (flags & ZAP_READ) { - if (zap_channel_read(chan, frame, &len) == ZAP_SUCCESS) { - //zap_log(ZAP_LOG_DEBUG, "WRITE %d\n", len); - zap_channel_write(chan, frame, sizeof(frame), &len); + if (flags & FTDM_READ) { + if (ftdm_channel_read(chan, frame, &len) == FTDM_SUCCESS) { + //ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n", len); + ftdm_channel_write(chan, frame, sizeof(frame), &len); } else { break; } } } - if (chan->state == ZAP_CHANNEL_STATE_UP) { - zap_set_state_locked(chan, ZAP_CHANNEL_STATE_BUSY); + if (chan->state == FTDM_CHANNEL_STATE_UP) { + ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_BUSY); } - zap_log(ZAP_LOG_DEBUG, "call over\n"); + ftdm_log(FTDM_LOG_DEBUG, "call over\n"); free(number); return NULL; } static ZIO_SIGNAL_CB_FUNCTION(on_signal) { - zap_log(ZAP_LOG_DEBUG, "got sig [%s]\n", zap_signal_event2str(sigmsg->event_id)); + ftdm_log(FTDM_LOG_DEBUG, "got sig [%s]\n", ftdm_signal_event2str(sigmsg->event_id)); switch(sigmsg->event_id) { - case ZAP_SIGEVENT_START: - zap_set_state_locked(sigmsg->channel, ZAP_CHANNEL_STATE_RING); - zap_log(ZAP_LOG_DEBUG, "launching thread and indicating ring\n"); - zap_thread_create_detached(test_call, sigmsg->channel); + case FTDM_SIGEVENT_START: + ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_RING); + ftdm_log(FTDM_LOG_DEBUG, "launching thread and indicating ring\n"); + ftdm_thread_create_detached(test_call, sigmsg->channel); break; default: break; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } static int R = 0; @@ -70,7 +70,7 @@ static void handle_SIGINT(int sig) int main(int argc, char *argv[]) { - zap_span_t *span; + ftdm_span_t *span; int span_id; int digit_timeout = 2000; int max_dialstr = 11; @@ -82,41 +82,41 @@ int main(int argc, char *argv[]) span_id = atoi(argv[1]); - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); - if (zap_global_init() != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error loading OpenFTDM\n"); exit(-1); } - zap_log(ZAP_LOG_DEBUG, "OpenZAP loaded\n"); + ftdm_log(FTDM_LOG_DEBUG, "OpenFTDM loaded\n"); - if (zap_span_find(span_id, &span) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span\n"); + if (ftdm_span_find(span_id, &span) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error finding OpenFTDM span\n"); goto done; } - if (zap_configure_span("analog", span, on_signal, + if (ftdm_configure_span("analog", span, on_signal, "tonemap", "us", "digit_timeout", &digit_timeout, "max_dialstr", &max_dialstr, TAG_END - ) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error configuring OpenZAP span\n"); + ) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error configuring OpenFTDM span\n"); goto done; } - zap_span_start(span); + ftdm_span_start(span); R = 1; - while(zap_running() && R) { - zap_sleep(1 * 1000); + while(ftdm_running() && R) { + ftdm_sleep(1 * 1000); } done: - zap_global_destroy(); + ftdm_global_destroy(); return 0; } diff --git a/libs/freetdm/src/testapp.c b/libs/freetdm/src/testapp.c index cfa27c9296..ffc79e047b 100644 --- a/libs/freetdm/src/testapp.c +++ b/libs/freetdm/src/testapp.c @@ -1,39 +1,39 @@ -#include "openzap.h" +#include "freetdm.h" int main(int argc, char *argv[]) { - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); - zap_channel_t *chan; + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); + ftdm_channel_t *chan; unsigned ms = 20; - zap_codec_t codec = ZAP_CODEC_SLIN; + ftdm_codec_t codec = FTDM_CODEC_SLIN; unsigned runs = 1; - if (zap_global_init() != ZAP_SUCCESS) { - fprintf(stderr, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); top: - //if (zap_channel_open_any("wanpipe", 0, ZAP_TOP_DOWN, &chan) == ZAP_SUCCESS) { - if (zap_channel_open(1, 1, &chan) == ZAP_SUCCESS) { + //if (ftdm_channel_open_any("wanpipe", 0, FTDM_TOP_DOWN, &chan) == FTDM_SUCCESS) { + if (ftdm_channel_open(1, 1, &chan) == FTDM_SUCCESS) { int x = 0; printf("opened channel %d:%d\n", chan->span_id, chan->chan_id); #if 1 - if (zap_channel_command(chan, ZAP_COMMAND_SET_INTERVAL, &ms) == ZAP_SUCCESS) { + if (ftdm_channel_command(chan, FTDM_COMMAND_SET_INTERVAL, &ms) == FTDM_SUCCESS) { ms = 0; - zap_channel_command(chan, ZAP_COMMAND_GET_INTERVAL, &ms); + ftdm_channel_command(chan, FTDM_COMMAND_GET_INTERVAL, &ms); printf("interval set to %u\n", ms); } else { printf("set interval failed [%s]\n", chan->last_error); } #endif - if (zap_channel_command(chan, ZAP_COMMAND_SET_CODEC, &codec) == ZAP_SUCCESS) { + if (ftdm_channel_command(chan, FTDM_COMMAND_SET_CODEC, &codec) == FTDM_SUCCESS) { codec = 1; - zap_channel_command(chan, ZAP_COMMAND_GET_CODEC, &codec); + ftdm_channel_command(chan, FTDM_COMMAND_GET_CODEC, &codec); printf("codec set to %u\n", codec); } else { printf("set codec failed [%s]\n", chan->last_error); @@ -41,14 +41,14 @@ int main(int argc, char *argv[]) for(x = 0; x < 25; x++) { unsigned char buf[2048]; - zap_size_t len = sizeof(buf); - zap_wait_flag_t flags = ZAP_READ; + ftdm_size_t len = sizeof(buf); + ftdm_wait_flag_t flags = FTDM_READ; - if (zap_channel_wait(chan, &flags, -1) == ZAP_FAIL) { + if (ftdm_channel_wait(chan, &flags, -1) == FTDM_FAIL) { printf("wait FAIL! %u [%s]\n", (unsigned)len, chan->last_error); } - if (flags & ZAP_READ) { - if (zap_channel_read(chan, buf, &len) == ZAP_SUCCESS) { + if (flags & FTDM_READ) { + if (ftdm_channel_read(chan, buf, &len) == FTDM_SUCCESS) { printf("READ: %u\n", (unsigned)len); } else { printf("READ FAIL! %u [%s]\n", (unsigned)len, chan->last_error); @@ -58,7 +58,7 @@ int main(int argc, char *argv[]) printf("wait fail [%s]\n", chan->last_error); } } - zap_channel_close(&chan); + ftdm_channel_close(&chan); } else { printf("open fail [%s]\n", chan->last_error); } @@ -67,7 +67,7 @@ int main(int argc, char *argv[]) goto top; } - zap_global_destroy(); + ftdm_global_destroy(); return 0; } diff --git a/libs/freetdm/src/testboost.c b/libs/freetdm/src/testboost.c index a3aea1cfe5..9b68034418 100644 --- a/libs/freetdm/src/testboost.c +++ b/libs/freetdm/src/testboost.c @@ -1,8 +1,8 @@ -#include "openzap.h" +#include "freetdm.h" static ZIO_SIGNAL_CB_FUNCTION(on_signal) { - return ZAP_FAIL; + return FTDM_FAIL; } static int R = 0; @@ -16,13 +16,13 @@ static void handle_SIGINT(int sig) #endif int main(int argc, char *argv[]) { - zap_conf_parameter_t parameters[20]; - zap_span_t *span; + ftdm_conf_parameter_t parameters[20]; + ftdm_span_t *span; int local_port, remote_port; local_port = remote_port = 53000; - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); #if 0 if (argc < 2) { printf("invalid arguments\n"); @@ -30,19 +30,19 @@ int main(int argc, char *argv[]) } #endif - if (zap_global_init() != ZAP_SUCCESS) { - fprintf(stderr, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - if (zap_global_configuration() != ZAP_SUCCESS) { - fprintf(stderr, "Error configuring OpenZAP\n"); + if (ftdm_global_configuration() != FTDM_SUCCESS) { + fprintf(stderr, "Error configuring OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); - if (zap_span_find_by_name("wp1", &span) != ZAP_SUCCESS) { - fprintf(stderr, "Error finding OpenZAP span %s\n", argv[1]); + if (ftdm_span_find_by_name("wp1", &span) != FTDM_SUCCESS) { + fprintf(stderr, "Error finding OpenFTDM span %s\n", argv[1]); goto done; } parameters[0].var = "sigmod"; @@ -52,20 +52,20 @@ int main(int argc, char *argv[]) parameters[1].var = "signalling"; parameters[1].val = "pri_cpe"; parameters[2].var = NULL; - if (zap_configure_span_signaling("sangoma_boost", span, on_signal, parameters) == ZAP_SUCCESS) { - zap_span_start(span); + if (ftdm_configure_span_signaling("sangoma_boost", span, on_signal, parameters) == FTDM_SUCCESS) { + ftdm_span_start(span); } else { fprintf(stderr, "Error starting SS7_BOOST\n"); goto done; } - while(zap_running() && R) { - zap_sleep(1 * 1000); + while(ftdm_running() && R) { + ftdm_sleep(1 * 1000); } done: - zap_global_destroy(); + ftdm_global_destroy(); return 0; } diff --git a/libs/freetdm/src/testcid.c b/libs/freetdm/src/testcid.c index 0018bb9a5d..59086d003d 100644 --- a/libs/freetdm/src/testcid.c +++ b/libs/freetdm/src/testcid.c @@ -1,25 +1,25 @@ -#include "openzap.h" -zap_status_t my_write_sample(int16_t *buf, zap_size_t buflen, void *user_data); +#include "freetdm.h" +ftdm_status_t my_write_sample(int16_t *buf, ftdm_size_t buflen, void *user_data); struct helper { int fd; int wrote; }; -zap_status_t my_write_sample(int16_t *buf, zap_size_t buflen, void *user_data) +ftdm_status_t my_write_sample(int16_t *buf, ftdm_size_t buflen, void *user_data) { struct helper *foo = (struct helper *) user_data; size_t len; len = write(foo->fd, buf, buflen * 2); - if (!len) return ZAP_FAIL; + if (!len) return FTDM_FAIL; foo->wrote += buflen * 2; - return ZAP_SUCCESS; + return FTDM_SUCCESS; } int main(int argc, char *argv[]) { - struct zap_fsk_modulator fsk_trans; - zap_fsk_data_state_t fsk_data = {0}; + struct ftdm_fsk_modulator fsk_trans; + ftdm_fsk_data_state_t fsk_data = {0}; int fd = -1; int16_t buf[160] = {0}; ssize_t len = 0; @@ -48,26 +48,26 @@ int main(int argc, char *argv[]) localtime_r(&now, &tm); strftime(time_str, sizeof(time_str), "%m%d%H%M", &tm); - zap_fsk_data_init(&fsk_data, databuf, sizeof(databuf)); + ftdm_fsk_data_init(&fsk_data, databuf, sizeof(databuf)); #if 1 - zap_fsk_data_add_mdmf(&fsk_data, MDMF_DATETIME, (uint8_t *)time_str, strlen(time_str)); - //zap_fsk_data_add_mdmf(&fsk_data, MDMF_DATETIME, "06091213", 8); - zap_fsk_data_add_mdmf(&fsk_data, MDMF_PHONE_NUM, (uint8_t *)"14149361212", 7); - zap_fsk_data_add_mdmf(&fsk_data, MDMF_PHONE_NAME, (uint8_t *)"Fred Smith", 10); + ftdm_fsk_data_add_mdmf(&fsk_data, MDMF_DATETIME, (uint8_t *)time_str, strlen(time_str)); + //ftdm_fsk_data_add_mdmf(&fsk_data, MDMF_DATETIME, "06091213", 8); + ftdm_fsk_data_add_mdmf(&fsk_data, MDMF_PHONE_NUM, (uint8_t *)"14149361212", 7); + ftdm_fsk_data_add_mdmf(&fsk_data, MDMF_PHONE_NAME, (uint8_t *)"Fred Smith", 10); for(x = 0; x < 0; x++) - zap_fsk_data_add_mdmf(&fsk_data, MDMF_ALT_ROUTE, (uint8_t *)url, strlen(url)); + ftdm_fsk_data_add_mdmf(&fsk_data, MDMF_ALT_ROUTE, (uint8_t *)url, strlen(url)); #else - zap_fsk_data_add_sdmf(&fsk_data, "06061234", "0"); - //zap_fsk_data_add_sdmf(&state, "06061234", "5551212"); + ftdm_fsk_data_add_sdmf(&fsk_data, "06061234", "0"); + //ftdm_fsk_data_add_sdmf(&state, "06061234", "5551212"); #endif - zap_fsk_data_add_checksum(&fsk_data); + ftdm_fsk_data_add_checksum(&fsk_data); foo.fd = fd; - zap_fsk_modulator_init(&fsk_trans, FSK_BELL202, 8000, &fsk_data, -14, 180, 5, 300, my_write_sample, &foo); - zap_fsk_modulator_send_all((&fsk_trans)); + ftdm_fsk_modulator_init(&fsk_trans, FSK_BELL202, 8000, &fsk_data, -14, 180, 5, 300, my_write_sample, &foo); + ftdm_fsk_modulator_send_all((&fsk_trans)); printf("%u %d %d\n", (unsigned) fsk_data.dlen, foo.wrote, fsk_trans.est_bytes); @@ -78,7 +78,7 @@ int main(int argc, char *argv[]) return 0; } - if (zap_fsk_demod_init(&fsk_data, 8000, (uint8_t *)fbuf, sizeof(fbuf))) { + if (ftdm_fsk_demod_init(&fsk_data, 8000, (uint8_t *)fbuf, sizeof(fbuf))) { printf("wtf\n"); return 0; } @@ -89,19 +89,19 @@ int main(int argc, char *argv[]) } while((len = read(fd, buf, sizeof(buf))) > 0) { - if (zap_fsk_demod_feed(&fsk_data, buf, len / 2) != ZAP_SUCCESS) { + if (ftdm_fsk_demod_feed(&fsk_data, buf, len / 2) != FTDM_SUCCESS) { break; } } - while(zap_fsk_data_parse(&fsk_data, &type, &sp, &mlen) == ZAP_SUCCESS) { - zap_copy_string(str, sp, mlen+1); + while(ftdm_fsk_data_parse(&fsk_data, &type, &sp, &mlen) == FTDM_SUCCESS) { + ftdm_copy_string(str, sp, mlen+1); *(str+mlen) = '\0'; - zap_clean_string(str); - printf("TYPE %u (%s) LEN %u VAL [%s]\n", (unsigned)type, zap_mdmf_type2str(type), (unsigned)mlen, str); + ftdm_clean_string(str); + printf("TYPE %u (%s) LEN %u VAL [%s]\n", (unsigned)type, ftdm_mdmf_type2str(type), (unsigned)mlen, str); } - zap_fsk_demod_destroy(&fsk_data); + ftdm_fsk_demod_destroy(&fsk_data); close(fd); return 0; diff --git a/libs/freetdm/src/testisdn.c b/libs/freetdm/src/testisdn.c index f32f47a3f0..61eb235e25 100644 --- a/libs/freetdm/src/testisdn.c +++ b/libs/freetdm/src/testisdn.c @@ -1,10 +1,10 @@ -#include "openzap.h" +#include "freetdm.h" #include static ZIO_SIGNAL_CB_FUNCTION(on_signal) { - return ZAP_FAIL; + return FTDM_FAIL; } static int R = 0; @@ -17,32 +17,32 @@ static void handle_SIGINT(int sig) int main(int argc, char *argv[]) { - zap_span_t *span; + ftdm_span_t *span; - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); if (argc < 2) { printf("umm no\n"); exit(-1); } - if (zap_global_init() != ZAP_SUCCESS) { - fprintf(stderr, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); - if (zap_span_find(atoi(argv[1]), &span) != ZAP_SUCCESS) { - fprintf(stderr, "Error finding OpenZAP span\n"); + if (ftdm_span_find(atoi(argv[1]), &span) != FTDM_SUCCESS) { + fprintf(stderr, "Error finding OpenFTDM span\n"); goto done; } - if (zap_configure_span("isdn", span, on_signal, + if (ftdm_configure_span("isdn", span, on_signal, "mode", "te", "dialect", "national", - TAG_END) == ZAP_SUCCESS) { - zap_span_start(span); + TAG_END) == FTDM_SUCCESS) { + ftdm_span_start(span); } else { fprintf(stderr, "Error starting ISDN D-Channel\n"); goto done; @@ -51,12 +51,12 @@ int main(int argc, char *argv[]) signal(SIGINT, handle_SIGINT); R = 1; while(R) { - zap_sleep(1 * 1000); + ftdm_sleep(1 * 1000); } done: - zap_global_destroy(); + ftdm_global_destroy(); return 1; diff --git a/libs/freetdm/src/testm3ua.c b/libs/freetdm/src/testm3ua.c index 16377cd067..d66952ce34 100644 --- a/libs/freetdm/src/testm3ua.c +++ b/libs/freetdm/src/testm3ua.c @@ -1,6 +1,6 @@ /* * testm3ua.c - * openzap + * freetdm * * Created by Shane Burrell on 4/8/08. * Copyright 2008 __MyCompanyName__. All rights reserved. @@ -8,53 +8,53 @@ */ #include "testm3ua.h" -#include "openzap.h" -#include "zap_m3ua.h" +#include "freetdm.h" +#include "ftdm_m3ua.h" static ZIO_SIGNAL_CB_FUNCTION(on_signal) { - return ZAP_FAIL; + return FTDM_FAIL; } int main(int argc, char *argv[]) { - zap_span_t *span; + ftdm_span_t *span; //m3ua_data_t *data; - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); if (argc < 5) { printf("more args needed\n"); exit(-1); } - if (zap_global_init() != ZAP_SUCCESS) { - fprintf(stderr, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); - if (zap_span_find(atoi(argv[1]), &span) != ZAP_SUCCESS) { - fprintf(stderr, "Error finding OpenZAP span\n"); + if (ftdm_span_find(atoi(argv[1]), &span) != FTDM_SUCCESS) { + fprintf(stderr, "Error finding OpenFTDM span\n"); goto done; } - if (zap_m3ua_configure_span(span) == ZAP_SUCCESS) { + if (ftdm_m3ua_configure_span(span) == FTDM_SUCCESS) { //data = span->signal_data; - zap_m3ua_start(span); + ftdm_m3ua_start(span); } else { fprintf(stderr, "Error starting M3UA\n"); goto done; } - //while(zap_test_flag(data, ZAP_M3UA_RUNNING)) { - // zap_sleep(1 * 1000); + //while(ftdm_test_flag(data, FTDM_M3UA_RUNNING)) { + // ftdm_sleep(1 * 1000); //} done: - zap_global_destroy(); + ftdm_global_destroy(); } diff --git a/libs/freetdm/src/testpri.c b/libs/freetdm/src/testpri.c index 1d203eae55..542f94e549 100644 --- a/libs/freetdm/src/testpri.c +++ b/libs/freetdm/src/testpri.c @@ -1,29 +1,29 @@ -#include "openzap.h" +#include "freetdm.h" #include static int THREADS[4][31] = { {0} }; static int R = 0; static int T = 0; -static zap_mutex_t *mutex = NULL; +static ftdm_mutex_t *mutex = NULL; -static void *channel_run(zap_thread_t *me, void *obj) +static void *channel_run(ftdm_thread_t *me, void *obj) { - zap_channel_t *zchan = obj; + ftdm_channel_t *ftdmchan = obj; int fd = -1; short buf[160]; - zap_mutex_lock(mutex); + ftdm_mutex_lock(mutex); T++; - zap_mutex_unlock(mutex); + ftdm_mutex_unlock(mutex); - zap_set_state_locked_wait(zchan, ZAP_CHANNEL_STATE_UP); + ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_UP); if ((fd = open("test.raw", O_RDONLY, 0)) < 0) { goto end; } - while(R == 1 && THREADS[zchan->span_id][zchan->chan_id] == 1) { + while(R == 1 && THREADS[ftdmchan->span_id][ftdmchan->chan_id] == 1) { ssize_t bytes = read(fd, buf, sizeof(buf)); size_t bbytes; @@ -35,7 +35,7 @@ static void *channel_run(zap_thread_t *me, void *obj) zio_slin2alaw(buf, sizeof(buf), &bbytes); - if (zap_channel_write(zchan, buf, sizeof(buf), &bbytes) != ZAP_SUCCESS) { + if (ftdm_channel_write(ftdmchan, buf, sizeof(buf), &bbytes) != FTDM_SUCCESS) { break; } } @@ -44,31 +44,31 @@ static void *channel_run(zap_thread_t *me, void *obj) end: - zap_set_state_locked_wait(zchan, ZAP_CHANNEL_STATE_HANGUP); + ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); - THREADS[zchan->span_id][zchan->chan_id] = 0; + THREADS[ftdmchan->span_id][ftdmchan->chan_id] = 0; - zap_mutex_lock(mutex); + ftdm_mutex_lock(mutex); T = 0; - zap_mutex_unlock(mutex); + ftdm_mutex_unlock(mutex); return NULL; } static ZIO_SIGNAL_CB_FUNCTION(on_signal) { - zap_log(ZAP_LOG_DEBUG, "got sig %d:%d [%s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, zap_signal_event2str(sigmsg->event_id)); + ftdm_log(FTDM_LOG_DEBUG, "got sig %d:%d [%s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, ftdm_signal_event2str(sigmsg->event_id)); switch(sigmsg->event_id) { - case ZAP_SIGEVENT_STOP: + case FTDM_SIGEVENT_STOP: THREADS[sigmsg->channel->span_id][sigmsg->channel->chan_id] = -1; break; - case ZAP_SIGEVENT_START: + case FTDM_SIGEVENT_START: if (!THREADS[sigmsg->channel->span_id][sigmsg->channel->chan_id]) { THREADS[sigmsg->channel->span_id][sigmsg->channel->chan_id] = 1; - zap_thread_create_detached(channel_run, sigmsg->channel); + ftdm_thread_create_detached(channel_run, sigmsg->channel); } break; @@ -76,7 +76,7 @@ static ZIO_SIGNAL_CB_FUNCTION(on_signal) break; } - return ZAP_SUCCESS; + return FTDM_SUCCESS; } @@ -84,40 +84,40 @@ static void handle_SIGINT(int sig) { if (sig); - zap_mutex_lock(mutex); + ftdm_mutex_lock(mutex); R = 0; - zap_mutex_unlock(mutex); + ftdm_mutex_unlock(mutex); return; } int main(int argc, char *argv[]) { - zap_span_t *span; - zap_mutex_create(&mutex); + ftdm_span_t *span; + ftdm_mutex_create(&mutex); - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); if (argc < 2) { printf("umm no\n"); exit(-1); } - if (zap_global_init() != ZAP_SUCCESS) { - fprintf(stderr, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); - if (zap_span_find(atoi(argv[1]), &span) != ZAP_SUCCESS) { - fprintf(stderr, "Error finding OpenZAP span\n"); + if (ftdm_span_find(atoi(argv[1]), &span) != FTDM_SUCCESS) { + fprintf(stderr, "Error finding OpenFTDM span\n"); goto done; } - if (zap_configure_span( + if (ftdm_configure_span( "libpri", span, on_signal, "node", "cpe", "switch", "euroisdn", @@ -125,26 +125,26 @@ int main(int argc, char *argv[]) "l1", "alaw", "debug", NULL, "opts", 0, - TAG_END) == ZAP_SUCCESS) { + TAG_END) == FTDM_SUCCESS) { - zap_span_start(span); + ftdm_span_start(span); } else { fprintf(stderr, "Error starting ISDN D-Channel\n"); goto done; } signal(SIGINT, handle_SIGINT); - zap_mutex_lock(mutex); + ftdm_mutex_lock(mutex); R = 1; - zap_mutex_unlock(mutex); + ftdm_mutex_unlock(mutex); while(R || T) { - zap_sleep(1 * 1000); + ftdm_sleep(1 * 1000); } done: - zap_global_destroy(); + ftdm_global_destroy(); return 1; diff --git a/libs/freetdm/src/testr2.c b/libs/freetdm/src/testr2.c index 83a950cff0..e83004e20e 100644 --- a/libs/freetdm/src/testr2.c +++ b/libs/freetdm/src/testr2.c @@ -1,74 +1,74 @@ -#include "openzap.h" +#include "freetdm.h" #include static int R = 0; -static zap_mutex_t *mutex = NULL; +static ftdm_mutex_t *mutex = NULL; static ZIO_SIGNAL_CB_FUNCTION(on_r2_signal) { - zap_log(ZAP_LOG_DEBUG, "Got R2 channel sig [%s] in channel\n", zap_signal_event2str(sigmsg->event_id), sigmsg->channel->physical_chan_id); - return ZAP_SUCCESS; + ftdm_log(FTDM_LOG_DEBUG, "Got R2 channel sig [%s] in channel\n", ftdm_signal_event2str(sigmsg->event_id), sigmsg->channel->physical_chan_id); + return FTDM_SUCCESS; } static void handle_SIGINT(int sig) { - zap_mutex_lock(mutex); + ftdm_mutex_lock(mutex); R = 0; - zap_mutex_unlock(mutex); + ftdm_mutex_unlock(mutex); return; } int main(int argc, char *argv[]) { - zap_span_t *span; - zap_mutex_create(&mutex); + ftdm_span_t *span; + ftdm_mutex_create(&mutex); - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); if (argc < 2) { printf("umm no\n"); exit(-1); } - if (zap_global_init() != ZAP_SUCCESS) { - fprintf(stderr, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); - if (zap_span_find(atoi(argv[1]), &span) != ZAP_SUCCESS) { - fprintf(stderr, "Error finding OpenZAP span\n"); + if (ftdm_span_find(atoi(argv[1]), &span) != FTDM_SUCCESS) { + fprintf(stderr, "Error finding OpenFTDM span\n"); goto done; } - if (zap_configure_span("r2", span, on_r2_signal, + if (ftdm_configure_span("r2", span, on_r2_signal, "variant", "mx", "max_ani", 10, "max_dnis", 4, "logging", "all", - TAG_END) == ZAP_SUCCESS) { + TAG_END) == FTDM_SUCCESS) { - zap_span_start(span); + ftdm_span_start(span); } else { fprintf(stderr, "Error starting R2 span\n"); goto done; } signal(SIGINT, handle_SIGINT); - zap_mutex_lock(mutex); + ftdm_mutex_lock(mutex); R = 1; - zap_mutex_unlock(mutex); + ftdm_mutex_unlock(mutex); while(R) { - zap_sleep(1 * 1000); + ftdm_sleep(1 * 1000); } done: - zap_global_destroy(); + ftdm_global_destroy(); return 1; diff --git a/libs/freetdm/src/testsangomaboost.c b/libs/freetdm/src/testsangomaboost.c index a0b02792c4..30733a1770 100644 --- a/libs/freetdm/src/testsangomaboost.c +++ b/libs/freetdm/src/testsangomaboost.c @@ -1,8 +1,8 @@ -#include "openzap.h" +#include "freetdm.h" static ZIO_SIGNAL_CB_FUNCTION(on_signal) { - return ZAP_FAIL; + return FTDM_FAIL; } static int R = 0; @@ -16,44 +16,44 @@ static void handle_SIGINT(int sig) #endif int main(int argc, char *argv[]) { - zap_span_t *span; + ftdm_span_t *span; int local_port, remote_port; local_port = remote_port = 53000; - zap_global_set_default_logger(ZAP_LOG_LEVEL_DEBUG); + ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG); if (argc < 2) { printf("umm no\n"); exit(-1); } - if (zap_global_init() != ZAP_SUCCESS) { - fprintf(stderr, "Error loading OpenZAP\n"); + if (ftdm_global_init() != FTDM_SUCCESS) { + fprintf(stderr, "Error loading OpenFTDM\n"); exit(-1); } - if (zap_global_configuration() != ZAP_SUCCESS) { - fprintf(stderr, "Error configuring OpenZAP\n"); + if (ftdm_global_configuration() != FTDM_SUCCESS) { + fprintf(stderr, "Error configuring OpenFTDM\n"); exit(-1); } - printf("OpenZAP loaded\n"); + printf("OpenFTDM loaded\n"); - if (zap_span_find(atoi(argv[1]), &span) != ZAP_SUCCESS) { - fprintf(stderr, "Error finding OpenZAP span\n"); + if (ftdm_span_find(atoi(argv[1]), &span) != FTDM_SUCCESS) { + fprintf(stderr, "Error finding OpenFTDM span\n"); goto done; } #if 1 if (1) { - if (zap_configure_span("sangoma_boost", span, on_signal, + if (ftdm_configure_span("sangoma_boost", span, on_signal, "sigmod", "sangoma_brid", "local_port", &local_port, "remote_ip", "127.0.0.66", "remote_port", &remote_port, - TAG_END) == ZAP_SUCCESS) { - zap_span_start(span); + TAG_END) == FTDM_SUCCESS) { + ftdm_span_start(span); } else { fprintf(stderr, "Error starting sangoma_boost\n"); @@ -62,13 +62,13 @@ int main(int argc, char *argv[]) } #endif - while(zap_running() && R) { - zap_sleep(1 * 1000); + while(ftdm_running() && R) { + ftdm_sleep(1 * 1000); } done: - zap_global_destroy(); + ftdm_global_destroy(); return 0; } diff --git a/libs/freetdm/src/testtones.c b/libs/freetdm/src/testtones.c index 273b793acf..c4cc327772 100644 --- a/libs/freetdm/src/testtones.c +++ b/libs/freetdm/src/testtones.c @@ -1,4 +1,4 @@ -#include "openzap.h" +#include "freetdm.h" struct ttmp { int fd; diff --git a/libs/freetdm/src/uart.c b/libs/freetdm/src/uart.c index b3728e6fc8..d042496a86 100644 --- a/libs/freetdm/src/uart.c +++ b/libs/freetdm/src/uart.c @@ -32,7 +32,7 @@ * 2005 06 11 R. Krten created */ -#include +#include #include #include #include @@ -77,7 +77,7 @@ dsp_uart_handle_t *dsp_uart_create(dsp_uart_attr_t *attr) { dsp_uart_handle_t *handle; - handle = zap_malloc(sizeof (*handle)); + handle = ftdm_malloc(sizeof (*handle)); if (handle) { memset(handle, 0, sizeof (*handle)); @@ -90,7 +90,7 @@ dsp_uart_handle_t *dsp_uart_create(dsp_uart_attr_t *attr) void dsp_uart_destroy(dsp_uart_handle_t **handle) { if (*handle) { - zap_safe_free(*handle); + ftdm_safe_free(*handle); *handle = NULL; } } diff --git a/libs/freetdm/src/zap_io.c b/libs/freetdm/src/zap_io.c deleted file mode 100644 index 6a39c9fc70..0000000000 --- a/libs/freetdm/src/zap_io.c +++ /dev/null @@ -1,3754 +0,0 @@ -/* - * Copyright (c) 2007, Anthony Minessale II - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * - * * Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * - * * Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * - * * Neither the name of the original author; nor the names of any contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR - * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER - * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, - * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, - * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING - * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - * - * Contributors: - * - * Moises Silva - * David Yat Sin - * - */ - -#define _GNU_SOURCE -#ifndef WIN32 -#endif -#include "openzap.h" -#include -#ifdef WIN32 -#include -#endif -#ifdef ZAP_PIKA_SUPPORT -#include "zap_pika.h" -#endif - -static int time_is_init = 0; - -static void time_init(void) -{ -#ifdef WIN32 - timeBeginPeriod(1); -#endif - time_is_init = 1; -} - -static void time_end(void) -{ -#ifdef WIN32 - timeEndPeriod(1); -#endif - time_is_init = 0; -} - -OZ_DECLARE(zap_time_t) zap_current_time_in_ms(void) -{ -#ifdef WIN32 - return timeGetTime(); -#else - struct timeval tv; - gettimeofday(&tv, NULL); - return ((tv.tv_sec * 1000) + (tv.tv_usec / 1000)); -#endif -} - -static struct { - zap_hash_t *interface_hash; - zap_hash_t *module_hash; - zap_hash_t *span_hash; - zap_hash_t *group_hash; - zap_mutex_t *mutex; - zap_mutex_t *span_mutex; - zap_mutex_t *group_mutex; - uint32_t span_index; - uint32_t group_index; - uint32_t running; - zap_span_t *spans; - zap_group_t *groups; -} globals; - - -/* enum lookup funcs */ -ZAP_ENUM_NAMES(TONEMAP_NAMES, TONEMAP_STRINGS) -ZAP_STR2ENUM(zap_str2zap_tonemap, zap_tonemap2str, zap_tonemap_t, TONEMAP_NAMES, ZAP_TONEMAP_INVALID) - -ZAP_ENUM_NAMES(OOB_NAMES, OOB_STRINGS) -ZAP_STR2ENUM(zap_str2zap_oob_event, zap_oob_event2str, zap_oob_event_t, OOB_NAMES, ZAP_OOB_INVALID) - -ZAP_ENUM_NAMES(TRUNK_TYPE_NAMES, TRUNK_STRINGS) -ZAP_STR2ENUM(zap_str2zap_trunk_type, zap_trunk_type2str, zap_trunk_type_t, TRUNK_TYPE_NAMES, ZAP_TRUNK_NONE) - -ZAP_ENUM_NAMES(START_TYPE_NAMES, START_TYPE_STRINGS) -ZAP_STR2ENUM(zap_str2zap_analog_start_type, zap_analog_start_type2str, zap_analog_start_type_t, START_TYPE_NAMES, ZAP_ANALOG_START_NA) - -ZAP_ENUM_NAMES(SIGNAL_NAMES, SIGNAL_STRINGS) -ZAP_STR2ENUM(zap_str2zap_signal_event, zap_signal_event2str, zap_signal_event_t, SIGNAL_NAMES, ZAP_SIGEVENT_INVALID) - -ZAP_ENUM_NAMES(CHANNEL_STATE_NAMES, CHANNEL_STATE_STRINGS) -ZAP_STR2ENUM(zap_str2zap_channel_state, zap_channel_state2str, zap_channel_state_t, CHANNEL_STATE_NAMES, ZAP_CHANNEL_STATE_INVALID) - -ZAP_ENUM_NAMES(MDMF_TYPE_NAMES, MDMF_STRINGS) -ZAP_STR2ENUM(zap_str2zap_mdmf_type, zap_mdmf_type2str, zap_mdmf_type_t, MDMF_TYPE_NAMES, MDMF_INVALID) - -ZAP_ENUM_NAMES(CHAN_TYPE_NAMES, CHAN_TYPE_STRINGS) -ZAP_STR2ENUM(zap_str2zap_chan_type, zap_chan_type2str, zap_chan_type_t, CHAN_TYPE_NAMES, ZAP_CHAN_TYPE_COUNT) - -ZAP_ENUM_NAMES(SIGNALING_STATUS_NAMES, SIGSTATUS_STRINGS) -ZAP_STR2ENUM(zap_str2zap_signaling_status, zap_signaling_status2str, zap_signaling_status_t, SIGNALING_STATUS_NAMES, ZAP_SIG_STATE_INVALID) - -static const char *cut_path(const char *in) -{ - const char *p, *ret = in; - char delims[] = "/\\"; - char *i; - - for (i = delims; *i; i++) { - p = in; - while ((p = strchr(p, *i)) != 0) { - ret = ++p; - } - } - return ret; -} - -static void null_logger(const char *file, const char *func, int line, int level, const char *fmt, ...) -{ - if (file && func && line && level && fmt) { - return; - } - return; -} - - -static const char *LEVEL_NAMES[] = { - "EMERG", - "ALERT", - "CRIT", - "ERROR", - "WARNING", - "NOTICE", - "INFO", - "DEBUG", - NULL -}; - -static int zap_log_level = 7; - -static void default_logger(const char *file, const char *func, int line, int level, const char *fmt, ...) -{ - const char *fp; - char data[1024]; - va_list ap; - - if (level < 0 || level > 7) { - level = 7; - } - if (level > zap_log_level) { - return; - } - - fp = cut_path(file); - - va_start(ap, fmt); - - vsnprintf(data, sizeof(data), fmt, ap); - - - fprintf(stderr, "[%s] %s:%d %s() %s", LEVEL_NAMES[level], file, line, func, data); - - va_end(ap); - -} - -static __inline__ void *zap_std_malloc(void *pool, zap_size_t size) -{ - void *ptr = malloc(size); - pool = NULL; /* fix warning */ - zap_assert_return(ptr != NULL, NULL, "Out of memory"); - return ptr; -} - -static __inline__ void *zap_std_calloc(void *pool, zap_size_t elements, zap_size_t size) -{ - void *ptr = calloc(elements, size); - pool = NULL; - zap_assert_return(ptr != NULL, NULL, "Out of memory"); - return ptr; -} - -static __inline__ void zap_std_free(void *pool, void *ptr) -{ - pool = NULL; - zap_assert_return(ptr != NULL, , "Attempted to free null pointer"); - free(ptr); -} - -OZ_DECLARE_DATA zap_memory_handler_t g_zap_mem_handler = -{ - /*.pool =*/ NULL, - /*.malloc =*/ zap_std_malloc, - /*.calloc =*/ zap_std_calloc, - /*.free =*/ zap_std_free -}; - -OZ_DECLARE_DATA zap_crash_policy_t g_zap_crash_policy = ZAP_CRASH_NEVER; - -OZ_DECLARE_DATA zap_logger_t zap_log = null_logger; - -OZ_DECLARE(void) zap_global_set_crash_policy(zap_crash_policy_t policy) -{ - g_zap_crash_policy |= policy; -} - -OZ_DECLARE(zap_status_t) zap_global_set_memory_handler(zap_memory_handler_t *handler) -{ - if (!handler) { - return ZAP_FAIL; - } - if (!handler->malloc) { - return ZAP_FAIL; - } - if (!handler->calloc) { - return ZAP_FAIL; - } - if (!handler->free) { - return ZAP_FAIL; - } - memcpy(&g_zap_mem_handler, handler, sizeof(*handler)); - return ZAP_SUCCESS; -} - -OZ_DECLARE(void) zap_global_set_logger(zap_logger_t logger) -{ - if (logger) { - zap_log = logger; - } else { - zap_log = null_logger; - } -} - -OZ_DECLARE(void) zap_global_set_default_logger(int level) -{ - if (level < 0 || level > 7) { - level = 7; - } - - zap_log = default_logger; - zap_log_level = level; -} - -OZ_DECLARE_NONSTD(int) zap_hash_equalkeys(void *k1, void *k2) -{ - return strcmp((char *) k1, (char *) k2) ? 0 : 1; -} - -OZ_DECLARE_NONSTD(uint32_t) zap_hash_hashfromstring(void *ky) -{ - unsigned char *str = (unsigned char *) ky; - uint32_t hash = 0; - int c; - - while ((c = *str++)) { - hash = c + (hash << 6) + (hash << 16) - hash; - } - - return hash; -} - -static zap_status_t zap_channel_destroy(zap_channel_t *zchan) -{ - - if (zap_test_flag(zchan, ZAP_CHANNEL_CONFIGURED)) { - - while (zap_test_flag(zchan, ZAP_CHANNEL_INTHREAD)) { - zap_log(ZAP_LOG_INFO, "Waiting for thread to exit on channel %u:%u\n", zchan->span_id, zchan->chan_id); - zap_sleep(500); - } - - zap_mutex_lock(zchan->pre_buffer_mutex); - zap_buffer_destroy(&zchan->pre_buffer); - zap_mutex_unlock(zchan->pre_buffer_mutex); - - zap_buffer_destroy(&zchan->digit_buffer); - zap_buffer_destroy(&zchan->gen_dtmf_buffer); - zap_buffer_destroy(&zchan->dtmf_buffer); - zap_buffer_destroy(&zchan->fsk_buffer); - zchan->pre_buffer_size = 0; - - hashtable_destroy(zchan->variable_hash); - - zap_safe_free(zchan->dtmf_hangup_buf); - - if (zchan->tone_session.buffer) { - teletone_destroy_session(&zchan->tone_session); - memset(&zchan->tone_session, 0, sizeof(zchan->tone_session)); - } - - - if (zchan->span->zio->channel_destroy) { - zap_log(ZAP_LOG_INFO, "Closing channel %s:%u:%u fd:%d\n", zchan->span->type, zchan->span_id, zchan->chan_id, zchan->sockfd); - if (zchan->span->zio->channel_destroy(zchan) == ZAP_SUCCESS) { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_CONFIGURED); - } else { - zap_log(ZAP_LOG_ERROR, "Error Closing channel %u:%u fd:%d\n", zchan->span_id, zchan->chan_id, zchan->sockfd); - } - } - - zap_mutex_destroy(&zchan->mutex); - zap_mutex_destroy(&zchan->pre_buffer_mutex); - } - - return ZAP_SUCCESS; -} - -static zap_status_t zap_span_destroy(zap_span_t *span) -{ - zap_status_t status = ZAP_SUCCESS; - unsigned j; - - zap_mutex_lock(span->mutex); - - /* stop the signaling */ - if (span->stop) { - status = span->stop(span); - } - - /* destroy the channels */ - zap_clear_flag(span, ZAP_SPAN_CONFIGURED); - for(j = 1; j <= span->chan_count && span->channels[j]; j++) { - zap_channel_t *cur_chan = span->channels[j]; - if (cur_chan) { - if (zap_test_flag(cur_chan, ZAP_CHANNEL_CONFIGURED)) { - zap_channel_destroy(cur_chan); - } - zap_safe_free(cur_chan); - cur_chan = NULL; - } - } - - /* destroy the I/O for the span */ - if (span->zio && span->zio->span_destroy) { - zap_log(ZAP_LOG_INFO, "Destroying span %u type (%s)\n", span->span_id, span->type); - if (span->zio->span_destroy(span) != ZAP_SUCCESS) { - status = ZAP_FAIL; - } - zap_safe_free(span->type); - zap_safe_free(span->dtmf_hangup); - } - - /* destroy final basic resources of the span data structure */ - zap_mutex_unlock(span->mutex); - zap_mutex_destroy(&span->mutex); - zap_safe_free(span->signal_data); - - return status; -} - -OZ_DECLARE(zap_status_t) zap_channel_get_alarms(zap_channel_t *zchan) -{ - zap_status_t status = ZAP_FAIL; - - if (zap_test_flag(zchan, ZAP_CHANNEL_CONFIGURED)) { - if (zchan->span->zio->get_alarms) { - if ((status = zchan->span->zio->get_alarms(zchan)) == ZAP_SUCCESS) { - *zchan->last_error = '\0'; - if (zap_test_alarm_flag(zchan, ZAP_ALARM_RED)) { - snprintf(zchan->last_error + strlen(zchan->last_error), sizeof(zchan->last_error) - strlen(zchan->last_error), "RED/"); - } - if (zap_test_alarm_flag(zchan, ZAP_ALARM_YELLOW)) { - snprintf(zchan->last_error + strlen(zchan->last_error), sizeof(zchan->last_error) - strlen(zchan->last_error), "YELLOW/"); - } - if (zap_test_alarm_flag(zchan, ZAP_ALARM_BLUE)) { - snprintf(zchan->last_error + strlen(zchan->last_error), sizeof(zchan->last_error) - strlen(zchan->last_error), "BLUE/"); - } - if (zap_test_alarm_flag(zchan, ZAP_ALARM_LOOPBACK)) { - snprintf(zchan->last_error + strlen(zchan->last_error), sizeof(zchan->last_error) - strlen(zchan->last_error), "LOOP/"); - } - if (zap_test_alarm_flag(zchan, ZAP_ALARM_RECOVER)) { - snprintf(zchan->last_error + strlen(zchan->last_error), sizeof(zchan->last_error) - strlen(zchan->last_error), "RECOVER/"); - } - *(zchan->last_error + strlen(zchan->last_error) - 1) = '\0'; - - } - } else { - status = ZAP_NOTIMPL; - } - } - - return status; -} - -static void zap_span_add(zap_span_t *span) -{ - zap_span_t *sp; - zap_mutex_lock(globals.span_mutex); - for (sp = globals.spans; sp && sp->next; sp = sp->next); - if (sp) { - sp->next = span; - } else { - globals.spans = span; - } - hashtable_insert(globals.span_hash, (void *)span->name, span, HASHTABLE_FLAG_NONE); - zap_mutex_unlock(globals.span_mutex); -} - -#if 0 -static void zap_span_del(zap_span_t *span) -{ - zap_span_t *last = NULL, *sp; - - zap_mutex_lock(globals.span_mutex); - for (sp = globals.spans; sp; sp = sp->next) { - - if (sp == span) { - if (last) { - last->next = sp->next; - } else { - globals.spans = sp->next; - } - hashtable_remove(globals.span_hash, (void *)sp->name); - break; - } - - last = sp; - } - zap_mutex_unlock(globals.span_mutex); -} -#endif - -OZ_DECLARE(zap_status_t) zap_span_stop(zap_span_t *span) -{ - if (span->stop) { - span->stop(span); - return ZAP_SUCCESS; - } - - return ZAP_FAIL; -} - -OZ_DECLARE(zap_status_t) zap_span_create(zap_io_interface_t *zio, zap_span_t **span, const char *name) -{ - zap_span_t *new_span = NULL; - zap_status_t status = ZAP_FAIL; - - assert(zio != NULL); - - zap_mutex_lock(globals.mutex); - - if (globals.span_index < ZAP_MAX_SPANS_INTERFACE) { - new_span = zap_malloc(sizeof(*new_span)); - assert(new_span); - memset(new_span, 0, sizeof(*new_span)); - status = zap_mutex_create(&new_span->mutex); - assert(status == ZAP_SUCCESS); - - zap_set_flag(new_span, ZAP_SPAN_CONFIGURED); - new_span->span_id = ++globals.span_index; - new_span->zio = zio; - zap_copy_string(new_span->tone_map[ZAP_TONEMAP_DIAL], "%(1000,0,350,440)", ZAP_TONEMAP_LEN); - zap_copy_string(new_span->tone_map[ZAP_TONEMAP_RING], "%(2000,4000,440,480)", ZAP_TONEMAP_LEN); - zap_copy_string(new_span->tone_map[ZAP_TONEMAP_BUSY], "%(500,500,480,620)", ZAP_TONEMAP_LEN); - zap_copy_string(new_span->tone_map[ZAP_TONEMAP_ATTN], "%(100,100,1400,2060,2450,2600)", ZAP_TONEMAP_LEN); - new_span->trunk_type = ZAP_TRUNK_NONE; - new_span->data_type = ZAP_TYPE_SPAN; - - zap_mutex_lock(globals.span_mutex); - if (!zap_strlen_zero(name) && hashtable_search(globals.span_hash, (void *)name)) { - zap_log(ZAP_LOG_WARNING, "name %s is already used, substituting 'span%d' as the name\n", name, new_span->span_id); - name = NULL; - } - zap_mutex_unlock(globals.span_mutex); - - if (!name) { - char buf[128] = ""; - snprintf(buf, sizeof(buf), "span%d", new_span->span_id); - name = buf; - } - new_span->name = zap_strdup(name); - zap_span_add(new_span); - *span = new_span; - status = ZAP_SUCCESS; - } - zap_mutex_unlock(globals.mutex); - return status; -} - -OZ_DECLARE(zap_status_t) zap_span_close_all(void) -{ - zap_span_t *span; - uint32_t i = 0, j; - - zap_mutex_lock(globals.span_mutex); - for (span = globals.spans; span; span = span->next) { - if (zap_test_flag(span, ZAP_SPAN_CONFIGURED)) { - for(j = 1; j <= span->chan_count && span->channels[j]; j++) { - zap_channel_t *toclose = span->channels[j]; - if (zap_test_flag(toclose, ZAP_CHANNEL_INUSE)) { - zap_channel_close(&toclose); - } - i++; - } - } - } - zap_mutex_unlock(globals.span_mutex); - - return i ? ZAP_SUCCESS : ZAP_FAIL; -} - -OZ_DECLARE(zap_status_t) zap_span_load_tones(zap_span_t *span, const char *mapname) -{ - zap_config_t cfg; - char *var, *val; - int x = 0; - - if (!zap_config_open_file(&cfg, "tones.conf")) { - snprintf(span->last_error, sizeof(span->last_error), "error loading tones."); - return ZAP_FAIL; - } - - while (zap_config_next_pair(&cfg, &var, &val)) { - int detect = 0; - - if (!strcasecmp(cfg.category, mapname) && var && val) { - uint32_t index; - char *name = NULL; - - if (!strncasecmp(var, "detect-", 7)) { - name = var + 7; - detect = 1; - } else if (!strncasecmp(var, "generate-", 9)) { - name = var + 9; - } else { - zap_log(ZAP_LOG_WARNING, "Unknown tone name %s\n", var); - continue; - } - - index = zap_str2zap_tonemap(name); - - if (index >= ZAP_TONEMAP_INVALID || index == ZAP_TONEMAP_NONE) { - zap_log(ZAP_LOG_WARNING, "Unknown tone name %s\n", name); - } else { - if (detect) { - char *p = val, *next; - int i = 0; - do { - teletone_process_t this; - next = strchr(p, ','); - this = (teletone_process_t)atof(p); - span->tone_detect_map[index].freqs[i++] = this; - if (next) { - p = next + 1; - } - } while (next); - zap_log(ZAP_LOG_DEBUG, "added tone detect [%s] = [%s]\n", name, val); - } else { - zap_log(ZAP_LOG_DEBUG, "added tone generation [%s] = [%s]\n", name, val); - zap_copy_string(span->tone_map[index], val, sizeof(span->tone_map[index])); - } - x++; - } - } - } - - zap_config_close_file(&cfg); - - if (!x) { - snprintf(span->last_error, sizeof(span->last_error), "error loading tones."); - return ZAP_FAIL; - } - - return ZAP_SUCCESS; - -} - -#define ZAP_SLINEAR_MAX_VALUE 32767 -#define ZAP_SLINEAR_MIN_VALUE -32767 -static void reset_gain_table(unsigned char *gain_table, float new_gain, zap_codec_t codec_gain) -{ - /* sample value */ - unsigned sv = 0; - /* linear gain factor */ - float lingain = 0; - /* linear value for each table sample */ - float linvalue = 0; - /* amplified (or attenuated in case of negative amplification) sample value */ - int ampvalue = 0; - - /* gain tables are only for alaw and ulaw */ - if (codec_gain != ZAP_CODEC_ALAW && codec_gain != ZAP_CODEC_ULAW) { - zap_log(ZAP_LOG_WARNING, "Not resetting gain table because codec is not ALAW or ULAW but %d\n", codec_gain); - return; - } - - if (!new_gain) { - /* for a 0.0db gain table, each alaw/ulaw sample value is left untouched (0 ==0, 1 == 1, 2 == 2 etc)*/ - for (sv = 0; sv < ZAP_GAINS_TABLE_SIZE; sv++) { - gain_table[sv] = sv; - } - return; - } - - /* use the 20log rule to increase the gain: http://en.wikipedia.org/wiki/Gain, http:/en.wipedia.org/wiki/20_log_rule#Definitions */ - lingain = pow(10.0, new_gain/ 20.0); - for (sv = 0; sv < ZAP_GAINS_TABLE_SIZE; sv++) { - /* get the linear value for this alaw/ulaw sample value */ - linvalue = codec_gain == ZAP_CODEC_ALAW ? alaw_to_linear(sv) : ulaw_to_linear(sv); - - /* multiply the linear value and the previously calculated linear gain */ - ampvalue = (int)(linvalue * lingain); - - /* chop it if goes beyond the limits */ - if (ampvalue > ZAP_SLINEAR_MAX_VALUE) { - ampvalue = ZAP_SLINEAR_MAX_VALUE; - } - - if (ampvalue < ZAP_SLINEAR_MIN_VALUE) { - ampvalue = ZAP_SLINEAR_MIN_VALUE; - } - gain_table[sv] = codec_gain == ZAP_CODEC_ALAW ? linear_to_alaw(ampvalue) : linear_to_ulaw(ampvalue); - } -} - -OZ_DECLARE(zap_status_t) zap_span_add_channel(zap_span_t *span, zap_socket_t sockfd, zap_chan_type_t type, zap_channel_t **chan) -{ - unsigned i = 0; - if (span->chan_count < ZAP_MAX_CHANNELS_SPAN) { - zap_channel_t *new_chan = span->channels[++span->chan_count]; - - if (!new_chan) { - if (!(new_chan = zap_calloc(1, sizeof(*new_chan)))) { - return ZAP_FAIL; - } - span->channels[span->chan_count] = new_chan; - } - - new_chan->type = type; - new_chan->sockfd = sockfd; - new_chan->zio = span->zio; - new_chan->span_id = span->span_id; - new_chan->chan_id = span->chan_count; - new_chan->span = span; - new_chan->fds[0] = -1; - new_chan->fds[1] = -1; - new_chan->data_type = ZAP_TYPE_CHANNEL; - if (!new_chan->dtmf_on) { - new_chan->dtmf_on = ZAP_DEFAULT_DTMF_ON; - } - - if (!new_chan->dtmf_off) { - new_chan->dtmf_off = ZAP_DEFAULT_DTMF_OFF; - } - - zap_mutex_create(&new_chan->mutex); - zap_mutex_create(&new_chan->pre_buffer_mutex); - - zap_buffer_create(&new_chan->digit_buffer, 128, 128, 0); - zap_buffer_create(&new_chan->gen_dtmf_buffer, 128, 128, 0); - new_chan->variable_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys); - - new_chan->dtmf_hangup_buf = zap_calloc (span->dtmf_hangup_len + 1, sizeof (char)); - - /* set 0.0db gain table */ - for (i = 0; i < sizeof(new_chan->txgain_table); i++) { - new_chan->txgain_table[i] = i; - new_chan->rxgain_table[i] = i; - } - - zap_set_flag(new_chan, ZAP_CHANNEL_CONFIGURED | ZAP_CHANNEL_READY); - *chan = new_chan; - return ZAP_SUCCESS; - } - - return ZAP_FAIL; -} - -OZ_DECLARE(zap_status_t) zap_span_find_by_name(const char *name, zap_span_t **span) -{ - zap_status_t status = ZAP_FAIL; - - zap_mutex_lock(globals.span_mutex); - if (!zap_strlen_zero(name)) { - if ((*span = hashtable_search(globals.span_hash, (void *)name))) { - status = ZAP_SUCCESS; - } else { - int span_id = atoi(name); - - zap_span_find(span_id, span); - if (*span) { - status = ZAP_SUCCESS; - } - } - } - zap_mutex_unlock(globals.span_mutex); - - return status; -} - -OZ_DECLARE(zap_status_t) zap_span_find(uint32_t id, zap_span_t **span) -{ - zap_span_t *fspan = NULL, *sp; - - if (id > ZAP_MAX_SPANS_INTERFACE) { - return ZAP_FAIL; - } - - zap_mutex_lock(globals.span_mutex); - for (sp = globals.spans; sp; sp = sp->next) { - if (sp->span_id == id) { - fspan = sp; - break; - } - } - zap_mutex_unlock(globals.span_mutex); - - if (!fspan || !zap_test_flag(fspan, ZAP_SPAN_CONFIGURED)) { - return ZAP_FAIL; - } - - *span = fspan; - - return ZAP_SUCCESS; - -} - -OZ_DECLARE(zap_status_t) zap_span_set_event_callback(zap_span_t *span, zio_event_cb_t event_callback) -{ - zap_mutex_lock(span->mutex); - span->event_callback = event_callback; - zap_mutex_unlock(span->mutex); - return ZAP_SUCCESS; -} - - -OZ_DECLARE(zap_status_t) zap_span_poll_event(zap_span_t *span, uint32_t ms) -{ - assert(span->zio != NULL); - - if (span->zio->poll_event) { - return span->zio->poll_event(span, ms); - } else { - zap_log(ZAP_LOG_ERROR, "poll_event method not implemented in module %s!", span->zio->name); - } - - return ZAP_NOTIMPL; -} - -OZ_DECLARE(zap_status_t) zap_span_next_event(zap_span_t *span, zap_event_t **event) -{ - assert(span->zio != NULL); - - if (span->zio->next_event) { - return span->zio->next_event(span, event); - } else { - zap_log(ZAP_LOG_ERROR, "next_event method not implemented in module %s!", span->zio->name); - } - - return ZAP_NOTIMPL; -} - -static zap_status_t zchan_fsk_write_sample(int16_t *buf, zap_size_t buflen, void *user_data) -{ - zap_channel_t *zchan = (zap_channel_t *) user_data; - zap_buffer_write(zchan->fsk_buffer, buf, buflen * 2); - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_send_fsk_data(zap_channel_t *zchan, zap_fsk_data_state_t *fsk_data, float db_level) -{ - struct zap_fsk_modulator fsk_trans; - - if (!zchan->fsk_buffer) { - zap_buffer_create(&zchan->fsk_buffer, 128, 128, 0); - } else { - zap_buffer_zero(zchan->fsk_buffer); - } - - if (zchan->token_count > 1) { - zap_fsk_modulator_init(&fsk_trans, FSK_BELL202, zchan->rate, fsk_data, db_level, 80, 5, 0, zchan_fsk_write_sample, zchan); - zap_fsk_modulator_send_all((&fsk_trans)); - } else { - zap_fsk_modulator_init(&fsk_trans, FSK_BELL202, zchan->rate, fsk_data, db_level, 180, 5, 300, zchan_fsk_write_sample, zchan); - zap_fsk_modulator_send_all((&fsk_trans)); - zchan->buffer_delay = 3500 / zchan->effective_interval; - } - - return ZAP_SUCCESS; -} - - -OZ_DECLARE(zap_status_t) zap_channel_set_event_callback(zap_channel_t *zchan, zio_event_cb_t event_callback) -{ - zap_mutex_lock(zchan->mutex); - zchan->event_callback = event_callback; - zap_mutex_unlock(zchan->mutex); - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_clear_token(zap_channel_t *zchan, const char *token) -{ - zap_status_t status = ZAP_FAIL; - - zap_mutex_lock(zchan->mutex); - if (token == NULL) { - memset(zchan->tokens, 0, sizeof(zchan->tokens)); - zchan->token_count = 0; - } else if (*token != '\0') { - char tokens[ZAP_MAX_TOKENS][ZAP_TOKEN_STRLEN]; - int32_t i, count = zchan->token_count; - memcpy(tokens, zchan->tokens, sizeof(tokens)); - memset(zchan->tokens, 0, sizeof(zchan->tokens)); - zchan->token_count = 0; - - for (i = 0; i < count; i++) { - if (strcmp(tokens[i], token)) { - zap_copy_string(zchan->tokens[zchan->token_count], tokens[i], sizeof(zchan->tokens[zchan->token_count])); - zchan->token_count++; - } - } - - status = ZAP_SUCCESS; - } - zap_mutex_unlock(zchan->mutex); - - return status; -} - -OZ_DECLARE(void) zap_channel_rotate_tokens(zap_channel_t *zchan) -{ - if (zchan->token_count) { - memmove(zchan->tokens[1], zchan->tokens[0], zchan->token_count * ZAP_TOKEN_STRLEN); - zap_copy_string(zchan->tokens[0], zchan->tokens[zchan->token_count], ZAP_TOKEN_STRLEN); - *zchan->tokens[zchan->token_count] = '\0'; - } -} - -OZ_DECLARE(void) zap_channel_replace_token(zap_channel_t *zchan, const char *old_token, const char *new_token) -{ - unsigned int i; - - if (zchan->token_count) { - for(i = 0; i < zchan->token_count; i++) { - if (!strcmp(zchan->tokens[i], old_token)) { - zap_copy_string(zchan->tokens[i], new_token, ZAP_TOKEN_STRLEN); - break; - } - } - } -} - -OZ_DECLARE(zap_status_t) zap_channel_add_token(zap_channel_t *zchan, char *token, int end) -{ - zap_status_t status = ZAP_FAIL; - - zap_mutex_lock(zchan->mutex); - if (zchan->token_count < ZAP_MAX_TOKENS) { - if (end) { - zap_copy_string(zchan->tokens[zchan->token_count++], token, ZAP_TOKEN_STRLEN); - } else { - memmove(zchan->tokens[1], zchan->tokens[0], zchan->token_count * ZAP_TOKEN_STRLEN); - zap_copy_string(zchan->tokens[0], token, ZAP_TOKEN_STRLEN); - zchan->token_count++; - } - status = ZAP_SUCCESS; - } - zap_mutex_unlock(zchan->mutex); - - return status; -} - - -OZ_DECLARE(zap_status_t) zap_channel_complete_state(zap_channel_t *zchan) -{ - zap_channel_state_t state = zchan->state; - - if (state == ZAP_CHANNEL_STATE_PROGRESS) { - zap_set_flag(zchan, ZAP_CHANNEL_PROGRESS); - } else if (state == ZAP_CHANNEL_STATE_UP) { - zap_set_flag(zchan, ZAP_CHANNEL_PROGRESS); - zap_set_flag(zchan, ZAP_CHANNEL_MEDIA); - zap_set_flag(zchan, ZAP_CHANNEL_ANSWERED); - } else if (state == ZAP_CHANNEL_STATE_PROGRESS_MEDIA) { - zap_set_flag(zchan, ZAP_CHANNEL_PROGRESS); - zap_set_flag(zchan, ZAP_CHANNEL_MEDIA); - } - - return ZAP_SUCCESS; -} - -static int zap_parse_state_map(zap_channel_t *zchan, zap_channel_state_t state, zap_state_map_t *state_map) -{ - int x = 0, ok = 0; - zap_state_direction_t direction = zap_test_flag(zchan, ZAP_CHANNEL_OUTBOUND) ? ZSD_OUTBOUND : ZSD_INBOUND; - - for(x = 0; x < ZAP_MAP_NODE_SIZE; x++) { - int i = 0, proceed = 0; - if (!state_map->nodes[x].type) { - break; - } - - if (state_map->nodes[x].direction != direction) { - continue; - } - - if (state_map->nodes[x].check_states[0] == ZAP_ANY_STATE) { - proceed = 1; - } else { - for(i = 0; i < ZAP_MAP_MAX; i++) { - if (state_map->nodes[x].check_states[i] == zchan->state) { - proceed = 1; - break; - } - } - } - - if (!proceed) { - continue; - } - - for(i = 0; i < ZAP_MAP_MAX; i++) { - ok = (state_map->nodes[x].type == ZSM_ACCEPTABLE); - if (state_map->nodes[x].states[i] == ZAP_END) { - break; - } - if (state_map->nodes[x].states[i] == state) { - ok = !ok; - goto end; - } - } - } - end: - - return ok; -} - -OZ_DECLARE(zap_status_t) zap_channel_set_state(zap_channel_t *zchan, zap_channel_state_t state, int lock) -{ - int ok = 1; - - if (!zap_test_flag(zchan, ZAP_CHANNEL_READY)) { - return ZAP_FAIL; - } - - if (zap_test_flag(zchan->span, ZAP_SPAN_SUSPENDED)) { - if (state != ZAP_CHANNEL_STATE_RESTART && state != ZAP_CHANNEL_STATE_DOWN) { - return ZAP_FAIL; - } - } - - if (lock) { - zap_mutex_lock(zchan->mutex); - } - - if (zchan->span->state_map) { - ok = zap_parse_state_map(zchan, state, zchan->span->state_map); - goto end; - } - - switch(zchan->state) { - case ZAP_CHANNEL_STATE_HANGUP: - case ZAP_CHANNEL_STATE_TERMINATING: - { - ok = 0; - switch(state) { - case ZAP_CHANNEL_STATE_DOWN: - case ZAP_CHANNEL_STATE_BUSY: - case ZAP_CHANNEL_STATE_RESTART: - ok = 1; - break; - default: - break; - } - } - break; - case ZAP_CHANNEL_STATE_UP: - { - ok = 1; - switch(state) { - case ZAP_CHANNEL_STATE_PROGRESS: - case ZAP_CHANNEL_STATE_PROGRESS_MEDIA: - case ZAP_CHANNEL_STATE_RING: - ok = 0; - break; - default: - break; - } - } - break; - case ZAP_CHANNEL_STATE_DOWN: - { - ok = 0; - - switch(state) { - case ZAP_CHANNEL_STATE_DIALTONE: - case ZAP_CHANNEL_STATE_COLLECT: - case ZAP_CHANNEL_STATE_DIALING: - case ZAP_CHANNEL_STATE_RING: - case ZAP_CHANNEL_STATE_PROGRESS_MEDIA: - case ZAP_CHANNEL_STATE_PROGRESS: - case ZAP_CHANNEL_STATE_GET_CALLERID: - case ZAP_CHANNEL_STATE_GENRING: - ok = 1; - break; - default: - break; - } - } - break; - case ZAP_CHANNEL_STATE_BUSY: - { - switch(state) { - case ZAP_CHANNEL_STATE_UP: - ok = 0; - break; - default: - break; - } - } - break; - case ZAP_CHANNEL_STATE_RING: - { - switch(state) { - case ZAP_CHANNEL_STATE_UP: - ok = 1; - break; - default: - break; - } - } - break; - default: - break; - } - - end: - - if (state == zchan->state) { - ok = 0; - } - - - if (ok) { - zap_set_flag(zchan, ZAP_CHANNEL_STATE_CHANGE); - zap_set_flag_locked(zchan->span, ZAP_SPAN_STATE_CHANGE); - zchan->last_state = zchan->state; - zchan->state = state; - } - - if (lock) { - zap_mutex_unlock(zchan->mutex); - } - - return ok ? ZAP_SUCCESS : ZAP_FAIL; -} - - -OZ_DECLARE(zap_status_t) zap_group_channel_use_count(zap_group_t *group, uint32_t *count) -{ - uint32_t j; - - *count = 0; - - if (!group) { - return ZAP_FAIL; - } - - for(j = 0; j < group->chan_count && group->channels[j]; j++) { - if (group->channels[j]) { - if (zap_test_flag(group->channels[j], ZAP_CHANNEL_INUSE)) { - (*count)++; - } - } - } - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_open_by_group(uint32_t group_id, zap_direction_t direction, zap_caller_data_t *caller_data, zap_channel_t **zchan) -{ - zap_status_t status = ZAP_FAIL; - zap_channel_t *check; - uint32_t i, count; - zap_group_t *group = NULL; - - if (group_id) { - zap_group_find(group_id, &group); - } - - if (!group ) { - zap_log(ZAP_LOG_CRIT, "GROUP NOT DEFINED!\n"); - *zchan = NULL; - return ZAP_FAIL; - } - - zap_group_channel_use_count(group, &count); - - if (count >= group->chan_count) { - zap_log(ZAP_LOG_CRIT, "All circuits are busy.\n"); - *zchan = NULL; - return ZAP_FAIL; - } - - - if (direction == ZAP_TOP_DOWN) { - i = 0; - } else { - i = group->chan_count-1; - } - - zap_mutex_lock(group->mutex); - for (;;) { - if (direction == ZAP_TOP_DOWN) { - if (i >= group->chan_count) { - break; - } - } else { - if (i < 0) { - break; - } - } - - if (!(check = group->channels[i])) { - status = ZAP_FAIL; - break; - } - - if (zap_test_flag(check, ZAP_CHANNEL_READY) && - !zap_test_flag(check, ZAP_CHANNEL_INUSE) && - !zap_test_flag(check, ZAP_CHANNEL_SUSPENDED) && - check->state == ZAP_CHANNEL_STATE_DOWN && - check->type != ZAP_CHAN_TYPE_DQ921 && - check->type != ZAP_CHAN_TYPE_DQ931 - - ) { - zap_span_t* span = NULL; - zap_span_find(check->span_id, &span); - if (span && span->channel_request) { - status = span->channel_request(span, check->chan_id, direction, caller_data, zchan); - break; - } - - status = check->zio->open(check); - - if (status == ZAP_SUCCESS) { - zap_set_flag(check, ZAP_CHANNEL_INUSE); - zap_channel_open_chan(check); - *zchan = check; - break; - } - } - - if (direction == ZAP_TOP_DOWN) { - i++; - } else { - i--; - } - } - zap_mutex_unlock(group->mutex); - return status; -} - - -OZ_DECLARE(zap_status_t) zap_span_channel_use_count(zap_span_t *span, uint32_t *count) -{ - uint32_t j; - - *count = 0; - - if (!span || !zap_test_flag(span, ZAP_SPAN_CONFIGURED)) { - return ZAP_FAIL; - } - - for(j = 1; j <= span->chan_count && span->channels[j]; j++) { - if (span->channels[j]) { - if (zap_test_flag(span->channels[j], ZAP_CHANNEL_INUSE)) { - (*count)++; - } - } - } - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_open_by_span(uint32_t span_id, zap_direction_t direction, zap_caller_data_t *caller_data, zap_channel_t **zchan) -{ - zap_status_t status = ZAP_FAIL; - zap_channel_t *check; - uint32_t i, j, count; - zap_span_t *span = NULL; - uint32_t span_max; - - if (span_id) { - zap_span_find(span_id, &span); - - if (!span || !zap_test_flag(span, ZAP_SPAN_CONFIGURED)) { - zap_log(ZAP_LOG_CRIT, "SPAN NOT DEFINED!\n"); - *zchan = NULL; - return ZAP_FAIL; - } - - zap_span_channel_use_count(span, &count); - - if (count >= span->chan_count) { - zap_log(ZAP_LOG_CRIT, "All circuits are busy.\n"); - *zchan = NULL; - return ZAP_FAIL; - } - - if (span->channel_request && !span->suggest_chan_id) { - return span->channel_request(span, 0, direction, caller_data, zchan); - } - - span_max = span_id; - j = span_id; - } else { - zap_log(ZAP_LOG_CRIT, "No span supplied\n"); - *zchan = NULL; - return ZAP_FAIL; - } - - zap_mutex_lock(span->mutex); - - if (direction == ZAP_TOP_DOWN) { - i = 1; - } else { - i = span->chan_count; - } - - for(;;) { - - if (direction == ZAP_TOP_DOWN) { - if (i > span->chan_count) { - break; - } - } else { - if (i == 0) { - break; - } - } - - if (!(check = span->channels[i])) { - status = ZAP_FAIL; - break; - } - - if (zap_test_flag(check, ZAP_CHANNEL_READY) && - !zap_test_flag(check, ZAP_CHANNEL_INUSE) && - !zap_test_flag(check, ZAP_CHANNEL_SUSPENDED) && - check->state == ZAP_CHANNEL_STATE_DOWN && - check->type != ZAP_CHAN_TYPE_DQ921 && - check->type != ZAP_CHAN_TYPE_DQ931 - - ) { - - if (span && span->channel_request) { - status = span->channel_request(span, i, direction, caller_data, zchan); - break; - } - - status = check->zio->open(check); - - if (status == ZAP_SUCCESS) { - zap_set_flag(check, ZAP_CHANNEL_INUSE); - zap_channel_open_chan(check); - *zchan = check; - break; - } - } - - if (direction == ZAP_TOP_DOWN) { - i++; - } else { - i--; - } - } - - zap_mutex_unlock(span->mutex); - - return status; -} - -static zap_status_t zap_channel_reset(zap_channel_t *zchan) -{ - zap_clear_flag(zchan, ZAP_CHANNEL_OPEN); - zchan->event_callback = NULL; - zap_clear_flag(zchan, ZAP_CHANNEL_DTMF_DETECT); - zap_clear_flag(zchan, ZAP_CHANNEL_SUPRESS_DTMF); - zap_channel_done(zchan); - zap_clear_flag_locked(zchan, ZAP_CHANNEL_HOLD); - - memset(zchan->tokens, 0, sizeof(zchan->tokens)); - zchan->token_count = 0; - - if (zchan->dtmf_buffer) { - zap_buffer_zero(zchan->dtmf_buffer); - } - - if (zchan->gen_dtmf_buffer) { - zap_buffer_zero(zchan->gen_dtmf_buffer); - } - - if (zchan->digit_buffer) { - zap_buffer_zero(zchan->digit_buffer); - } - - if (!zchan->dtmf_on) { - zchan->dtmf_on = ZAP_DEFAULT_DTMF_ON; - } - - if (!zchan->dtmf_off) { - zchan->dtmf_off = ZAP_DEFAULT_DTMF_OFF; - } - - memset(zchan->dtmf_hangup_buf, '\0', zchan->span->dtmf_hangup_len); - - if (zap_test_flag(zchan, ZAP_CHANNEL_TRANSCODE)) { - zchan->effective_codec = zchan->native_codec; - zchan->packet_len = zchan->native_interval * (zchan->effective_codec == ZAP_CODEC_SLIN ? 16 : 8); - zap_clear_flag(zchan, ZAP_CHANNEL_TRANSCODE); - } - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_init(zap_channel_t *zchan) -{ - if (zchan->init_state != ZAP_CHANNEL_STATE_DOWN) { - zap_set_state_locked(zchan, zchan->init_state); - zchan->init_state = ZAP_CHANNEL_STATE_DOWN; - } - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_open_chan(zap_channel_t *zchan) -{ - zap_status_t status = ZAP_FAIL; - - assert(zchan != NULL); - - if (zap_test_flag(zchan, ZAP_CHANNEL_SUSPENDED)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", "Channel is suspended"); - return ZAP_FAIL; - } - - if (!zap_test_flag(zchan, ZAP_CHANNEL_READY) || (status = zap_mutex_trylock(zchan->mutex)) != ZAP_SUCCESS) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "Channel is not ready or is in use %d %d", zap_test_flag(zchan, ZAP_CHANNEL_READY), status); - return status; - } - - status = ZAP_FAIL; - - if (zap_test_flag(zchan, ZAP_CHANNEL_READY)) { - status = zchan->span->zio->open(zchan); - if (status == ZAP_SUCCESS) { - zap_set_flag(zchan, ZAP_CHANNEL_OPEN | ZAP_CHANNEL_INUSE); - } - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", "Channel is not ready"); - } - - zap_mutex_unlock(zchan->mutex); - return status; -} - -OZ_DECLARE(zap_status_t) zap_channel_open(uint32_t span_id, uint32_t chan_id, zap_channel_t **zchan) -{ - zap_channel_t *check; - zap_status_t status = ZAP_FAIL; - zap_span_t *span = NULL; - - zap_mutex_unlock(globals.mutex); - zap_span_find(span_id, &span); - - if (!span || !zap_test_flag(span, ZAP_SPAN_CONFIGURED) || chan_id >= ZAP_MAX_CHANNELS_SPAN) { - zap_log(ZAP_LOG_CRIT, "SPAN NOT DEFINED!\n"); - *zchan = NULL; - goto done; - } - - if (span->channel_request) { - zap_log(ZAP_LOG_ERROR, "Individual channel selection not implemented on this span.\n"); - *zchan = NULL; - goto done; - } - - if (!(check = span->channels[chan_id])) { - zap_log(ZAP_LOG_ERROR, "Invalid Channel %d\n", chan_id); - *zchan = NULL; - goto done; - } - - if (zap_test_flag(check, ZAP_CHANNEL_SUSPENDED) || - !zap_test_flag(check, ZAP_CHANNEL_READY) || (status = zap_mutex_trylock(check->mutex)) != ZAP_SUCCESS) { - *zchan = NULL; - goto done; - } - - status = ZAP_FAIL; - - if (zap_test_flag(check, ZAP_CHANNEL_READY) && (!zap_test_flag(check, ZAP_CHANNEL_INUSE) || - (check->type == ZAP_CHAN_TYPE_FXS && check->token_count == 1))) { - if (!zap_test_flag(check, ZAP_CHANNEL_OPEN)) { - status = check->zio->open(check); - if (status == ZAP_SUCCESS) { - zap_set_flag(check, ZAP_CHANNEL_OPEN); - } - } else { - status = ZAP_SUCCESS; - } - zap_set_flag(check, ZAP_CHANNEL_INUSE); - *zchan = check; - } - zap_mutex_unlock(check->mutex); - - done: - zap_mutex_unlock(globals.mutex); - - return status; -} - -OZ_DECLARE(zap_status_t) zap_channel_outgoing_call(zap_channel_t *zchan) -{ - zap_status_t status; - - assert(zchan != NULL); - - if (zchan->span->outgoing_call) { - if ((status = zchan->span->outgoing_call(zchan)) == ZAP_SUCCESS) { - zap_set_flag(zchan, ZAP_CHANNEL_OUTBOUND); - } - return status; - } else { - zap_log(ZAP_LOG_ERROR, "outgoing_call method not implemented!\n"); - } - - return ZAP_FAIL; -} - -OZ_DECLARE(zap_status_t) zap_channel_set_sig_status(zap_channel_t *zchan, zap_signaling_status_t sigstatus) -{ - zap_assert_return(zchan != NULL, ZAP_FAIL, "Null channel\n"); - zap_assert_return(zchan->span != NULL, ZAP_FAIL, "Null span\n"); - - if (zchan->span->set_channel_sig_status) { - return zchan->span->set_channel_sig_status(zchan, sigstatus); - } else { - zap_log(ZAP_LOG_ERROR, "set_channel_sig_status method not implemented!\n"); - return ZAP_FAIL; - } -} - -OZ_DECLARE(zap_status_t) zap_channel_get_sig_status(zap_channel_t *zchan, zap_signaling_status_t *sigstatus) -{ - zap_assert_return(zchan != NULL, ZAP_FAIL, "Null channel\n"); - zap_assert_return(zchan->span != NULL, ZAP_FAIL, "Null span\n"); - zap_assert_return(sigstatus != NULL, ZAP_FAIL, "Null sig status parameter\n"); - - if (zchan->span->get_channel_sig_status) { - return zchan->span->get_channel_sig_status(zchan, sigstatus); - } else { - zap_log(ZAP_LOG_ERROR, "get_channel_sig_status method not implemented!\n"); - return ZAP_FAIL; - } -} - -OZ_DECLARE(zap_status_t) zap_span_set_sig_status(zap_span_t *span, zap_signaling_status_t sigstatus) -{ - zap_assert_return(span != NULL, ZAP_FAIL, "Null span\n"); - - if (span->set_span_sig_status) { - return span->set_span_sig_status(span, sigstatus); - } else { - zap_log(ZAP_LOG_ERROR, "set_span_sig_status method not implemented!\n"); - return ZAP_FAIL; - } -} - -OZ_DECLARE(zap_status_t) zap_span_get_sig_status(zap_span_t *span, zap_signaling_status_t *sigstatus) -{ - zap_assert_return(span != NULL, ZAP_FAIL, "Null span\n"); - zap_assert_return(sigstatus != NULL, ZAP_FAIL, "Null sig status parameter\n"); - - if (span->get_span_sig_status) { - return span->get_span_sig_status(span, sigstatus); - } else { - zap_log(ZAP_LOG_ERROR, "get_span_sig_status method not implemented!\n"); - return ZAP_FAIL; - } -} - -OZ_DECLARE(zap_status_t) zap_channel_done(zap_channel_t *zchan) -{ - assert(zchan != NULL); - - zap_mutex_lock(zchan->mutex); - - memset(&zchan->caller_data, 0, sizeof(zchan->caller_data)); - - zap_clear_flag(zchan, ZAP_CHANNEL_INUSE); - zap_clear_flag(zchan, ZAP_CHANNEL_OUTBOUND); - zap_clear_flag(zchan, ZAP_CHANNEL_WINK); - zap_clear_flag(zchan, ZAP_CHANNEL_FLASH); - zap_clear_flag(zchan, ZAP_CHANNEL_STATE_CHANGE); - zap_clear_flag(zchan, ZAP_CHANNEL_HOLD); - zap_clear_flag(zchan, ZAP_CHANNEL_OFFHOOK); - zap_clear_flag(zchan, ZAP_CHANNEL_RINGING); - zap_clear_flag(zchan, ZAP_CHANNEL_PROGRESS_DETECT); - zap_clear_flag(zchan, ZAP_CHANNEL_CALLERID_DETECT); - zap_clear_flag(zchan, ZAP_CHANNEL_3WAY); - zap_clear_flag(zchan, ZAP_CHANNEL_PROGRESS); - zap_clear_flag(zchan, ZAP_CHANNEL_MEDIA); - zap_clear_flag(zchan, ZAP_CHANNEL_ANSWERED); - zap_mutex_lock(zchan->pre_buffer_mutex); - zap_buffer_destroy(&zchan->pre_buffer); - zchan->pre_buffer_size = 0; - zap_mutex_unlock(zchan->pre_buffer_mutex); - - zchan->init_state = ZAP_CHANNEL_STATE_DOWN; - zchan->state = ZAP_CHANNEL_STATE_DOWN; - - zap_log(ZAP_LOG_DEBUG, "channel done %u:%u\n", zchan->span_id, zchan->chan_id); - - zap_mutex_unlock(zchan->mutex); - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_use(zap_channel_t *zchan) -{ - - assert(zchan != NULL); - - zap_set_flag_locked(zchan, ZAP_CHANNEL_INUSE); - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_close(zap_channel_t **zchan) -{ - zap_channel_t *check; - zap_status_t status = ZAP_FAIL; - - assert(zchan != NULL); - check = *zchan; - *zchan = NULL; - - if (!check) { - return ZAP_FAIL; - } - - if (!zap_test_flag(check, ZAP_CHANNEL_INUSE)) { - zap_log(ZAP_LOG_WARNING, "Called zap_channel_close but never zap_channel_open in chan %d:%d??\n", check->span_id, check->chan_id); - return ZAP_FAIL; - } - - if (zap_test_flag(check, ZAP_CHANNEL_CONFIGURED)) { - zap_mutex_lock(check->mutex); - if (zap_test_flag(check, ZAP_CHANNEL_OPEN)) { - status = check->zio->close(check); - if (status == ZAP_SUCCESS) { - zap_clear_flag(check, ZAP_CHANNEL_INUSE); - zap_channel_reset(check); - *zchan = NULL; - } - } - check->ring_count = 0; - zap_mutex_unlock(check->mutex); - } - - return status; -} - - -static zap_status_t zchan_activate_dtmf_buffer(zap_channel_t *zchan) -{ - - if (!zchan->dtmf_buffer) { - if (zap_buffer_create(&zchan->dtmf_buffer, 1024, 3192, 0) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Failed to allocate DTMF Buffer!\n"); - snprintf(zchan->last_error, sizeof(zchan->last_error), "buffer error"); - return ZAP_FAIL; - } else { - zap_log(ZAP_LOG_DEBUG, "Created DTMF Buffer!\n"); - } - } - - - if (!zchan->tone_session.buffer) { - memset(&zchan->tone_session, 0, sizeof(zchan->tone_session)); - teletone_init_session(&zchan->tone_session, 0, NULL, NULL); - } - - zchan->tone_session.rate = zchan->rate; - zchan->tone_session.duration = zchan->dtmf_on * (zchan->tone_session.rate / 1000); - zchan->tone_session.wait = zchan->dtmf_off * (zchan->tone_session.rate / 1000); - zchan->tone_session.volume = -7; - - /* - zchan->tone_session.debug = 1; - zchan->tone_session.debug_stream = stdout; - */ - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_command(zap_channel_t *zchan, zap_command_t command, void *obj) -{ - zap_status_t status = ZAP_FAIL; - - assert(zchan != NULL); - assert(zchan->zio != NULL); - - zap_mutex_lock(zchan->mutex); - - switch(command) { - - case ZAP_COMMAND_ENABLE_CALLERID_DETECT: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_CALLERID)) { - if (zap_fsk_demod_init(&zchan->fsk, zchan->rate, zchan->fsk_buf, sizeof(zchan->fsk_buf)) != ZAP_SUCCESS) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - GOTO_STATUS(done, ZAP_FAIL); - } - zap_set_flag_locked(zchan, ZAP_CHANNEL_CALLERID_DETECT); - } - } - break; - case ZAP_COMMAND_DISABLE_CALLERID_DETECT: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_CALLERID)) { - zap_fsk_demod_destroy(&zchan->fsk); - zap_clear_flag_locked(zchan, ZAP_CHANNEL_CALLERID_DETECT); - } - } - break; - case ZAP_COMMAND_TRACE_INPUT: - { - char *path = (char *) obj; - if (zchan->fds[0] > 0) { - close(zchan->fds[0]); - zchan->fds[0] = -1; - } - if ((zchan->fds[0] = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) > -1) { - zap_log(ZAP_LOG_DEBUG, "Tracing channel %u:%u to [%s]\n", zchan->span_id, zchan->chan_id, path); - GOTO_STATUS(done, ZAP_SUCCESS); - } - - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - GOTO_STATUS(done, ZAP_FAIL); - } - break; - case ZAP_COMMAND_TRACE_OUTPUT: - { - char *path = (char *) obj; - if (zchan->fds[1] > 0) { - close(zchan->fds[1]); - zchan->fds[1] = -1; - } - if ((zchan->fds[1] = open(path, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR)) > -1) { - zap_log(ZAP_LOG_DEBUG, "Tracing channel %u:%u to [%s]\n", zchan->span_id, zchan->chan_id, path); - GOTO_STATUS(done, ZAP_SUCCESS); - } - - snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno)); - GOTO_STATUS(done, ZAP_FAIL); - } - break; - case ZAP_COMMAND_SET_INTERVAL: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_INTERVAL)) { - zchan->effective_interval = ZAP_COMMAND_OBJ_INT; - if (zchan->effective_interval == zchan->native_interval) { - zap_clear_flag(zchan, ZAP_CHANNEL_BUFFER); - } else { - zap_set_flag(zchan, ZAP_CHANNEL_BUFFER); - } - zchan->packet_len = zchan->native_interval * (zchan->effective_codec == ZAP_CODEC_SLIN ? 16 : 8); - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_GET_INTERVAL: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_INTERVAL)) { - ZAP_COMMAND_OBJ_INT = zchan->effective_interval; - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_SET_CODEC: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_CODECS)) { - zchan->effective_codec = ZAP_COMMAND_OBJ_INT; - - if (zchan->effective_codec == zchan->native_codec) { - zap_clear_flag(zchan, ZAP_CHANNEL_TRANSCODE); - } else { - zap_set_flag(zchan, ZAP_CHANNEL_TRANSCODE); - } - zchan->packet_len = zchan->native_interval * (zchan->effective_codec == ZAP_CODEC_SLIN ? 16 : 8); - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - - case ZAP_COMMAND_SET_NATIVE_CODEC: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_CODECS)) { - zchan->effective_codec = zchan->native_codec; - zap_clear_flag(zchan, ZAP_CHANNEL_TRANSCODE); - zchan->packet_len = zchan->native_interval * (zchan->effective_codec == ZAP_CODEC_SLIN ? 16 : 8); - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - - case ZAP_COMMAND_GET_CODEC: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_CODECS)) { - ZAP_COMMAND_OBJ_INT = zchan->effective_codec; - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_GET_NATIVE_CODEC: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_CODECS)) { - ZAP_COMMAND_OBJ_INT = zchan->native_codec; - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_ENABLE_PROGRESS_DETECT: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_PROGRESS)) { - /* if they don't have thier own, use ours */ - zap_channel_clear_detected_tones(zchan); - zap_channel_clear_needed_tones(zchan); - teletone_multi_tone_init(&zchan->span->tone_finder[ZAP_TONEMAP_DIAL], &zchan->span->tone_detect_map[ZAP_TONEMAP_DIAL]); - teletone_multi_tone_init(&zchan->span->tone_finder[ZAP_TONEMAP_RING], &zchan->span->tone_detect_map[ZAP_TONEMAP_RING]); - teletone_multi_tone_init(&zchan->span->tone_finder[ZAP_TONEMAP_BUSY], &zchan->span->tone_detect_map[ZAP_TONEMAP_BUSY]); - zap_set_flag(zchan, ZAP_CHANNEL_PROGRESS_DETECT); - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_DISABLE_PROGRESS_DETECT: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_PROGRESS)) { - zap_clear_flag_locked(zchan, ZAP_CHANNEL_PROGRESS_DETECT); - zap_channel_clear_detected_tones(zchan); - zap_channel_clear_needed_tones(zchan); - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_ENABLE_DTMF_DETECT: - { - /* if they don't have thier own, use ours */ - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_DETECT)) { - zap_tone_type_t tt = ZAP_COMMAND_OBJ_INT; - if (tt == ZAP_TONE_DTMF) { - teletone_dtmf_detect_init (&zchan->dtmf_detect, zchan->rate); - zap_set_flag_locked(zchan, ZAP_CHANNEL_DTMF_DETECT); - zap_set_flag_locked(zchan, ZAP_CHANNEL_SUPRESS_DTMF); - GOTO_STATUS(done, ZAP_SUCCESS); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "invalid command"); - GOTO_STATUS(done, ZAP_FAIL); - } - } - } - break; - case ZAP_COMMAND_DISABLE_DTMF_DETECT: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_DETECT)) { - zap_tone_type_t tt = ZAP_COMMAND_OBJ_INT; - if (tt == ZAP_TONE_DTMF) { - teletone_dtmf_detect_init (&zchan->dtmf_detect, zchan->rate); - zap_clear_flag(zchan, ZAP_CHANNEL_DTMF_DETECT); - zap_clear_flag(zchan, ZAP_CHANNEL_SUPRESS_DTMF); - GOTO_STATUS(done, ZAP_SUCCESS); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "invalid command"); - GOTO_STATUS(done, ZAP_FAIL); - } - } - } - - case ZAP_COMMAND_SET_PRE_BUFFER_SIZE: - { - int val = ZAP_COMMAND_OBJ_INT; - - if (val < 0) { - val = 0; - } - - zchan->pre_buffer_size = val * 8; - - zap_mutex_lock(zchan->pre_buffer_mutex); - if (!zchan->pre_buffer_size) { - zap_buffer_destroy(&zchan->pre_buffer); - } else if (!zchan->pre_buffer) { - zap_buffer_create(&zchan->pre_buffer, 1024, zchan->pre_buffer_size, 0); - } - zap_mutex_unlock(zchan->pre_buffer_mutex); - - GOTO_STATUS(done, ZAP_SUCCESS); - - } - break; - case ZAP_COMMAND_GET_DTMF_ON_PERIOD: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_GENERATE)) { - ZAP_COMMAND_OBJ_INT = zchan->dtmf_on; - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_GET_DTMF_OFF_PERIOD: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_GENERATE)) { - ZAP_COMMAND_OBJ_INT = zchan->dtmf_on; - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - case ZAP_COMMAND_SET_DTMF_ON_PERIOD: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_GENERATE)) { - int val = ZAP_COMMAND_OBJ_INT; - if (val > 10 && val < 1000) { - zchan->dtmf_on = val; - GOTO_STATUS(done, ZAP_SUCCESS); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "invalid value %d range 10-1000", val); - GOTO_STATUS(done, ZAP_FAIL); - } - } - } - break; - case ZAP_COMMAND_SET_DTMF_OFF_PERIOD: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_GENERATE)) { - int val = ZAP_COMMAND_OBJ_INT; - if (val > 10 && val < 1000) { - zchan->dtmf_off = val; - GOTO_STATUS(done, ZAP_SUCCESS); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "invalid value %d range 10-1000", val); - GOTO_STATUS(done, ZAP_FAIL); - } - } - } - break; - case ZAP_COMMAND_SEND_DTMF: - { - if (!zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_GENERATE)) { - char *digits = ZAP_COMMAND_OBJ_CHAR_P; - - if ((status = zchan_activate_dtmf_buffer(zchan)) != ZAP_SUCCESS) { - GOTO_STATUS(done, status); - } - - zap_buffer_write(zchan->gen_dtmf_buffer, digits, strlen(digits)); - - GOTO_STATUS(done, ZAP_SUCCESS); - } - } - break; - - case ZAP_COMMAND_DISABLE_ECHOCANCEL: - { - zap_mutex_lock(zchan->pre_buffer_mutex); - zap_buffer_destroy(&zchan->pre_buffer); - zchan->pre_buffer_size = 0; - zap_mutex_unlock(zchan->pre_buffer_mutex); - } - break; - - /* FIXME: validate user gain values */ - case ZAP_COMMAND_SET_RX_GAIN: - { - zchan->rxgain = ZAP_COMMAND_OBJ_FLOAT; - reset_gain_table(zchan->rxgain_table, zchan->rxgain, zchan->native_codec); - if (zchan->rxgain == 0.0) { - zap_clear_flag(zchan, ZAP_CHANNEL_USE_RX_GAIN); - } else { - zap_set_flag(zchan, ZAP_CHANNEL_USE_RX_GAIN); - } - } - break; - case ZAP_COMMAND_GET_RX_GAIN: - { - ZAP_COMMAND_OBJ_FLOAT = zchan->rxgain; - } - break; - case ZAP_COMMAND_SET_TX_GAIN: - { - zchan->txgain = ZAP_COMMAND_OBJ_FLOAT; - reset_gain_table(zchan->txgain_table, zchan->txgain, zchan->native_codec); - if (zchan->txgain == 0.0) { - zap_clear_flag(zchan, ZAP_CHANNEL_USE_TX_GAIN); - } else { - zap_set_flag(zchan, ZAP_CHANNEL_USE_TX_GAIN); - } - } - break; - case ZAP_COMMAND_GET_TX_GAIN: - { - ZAP_COMMAND_OBJ_FLOAT = zchan->txgain; - } - break; - default: - break; - } - - if (!zchan->zio->command) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented"); - zap_log(ZAP_LOG_ERROR, "no command function defined by the I/O openzap module!\n"); - GOTO_STATUS(done, ZAP_FAIL); - } - - status = zchan->zio->command(zchan, command, obj); - - if (status == ZAP_NOTIMPL) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "I/O command %d not implemented in backend", command); - zap_log(ZAP_LOG_ERROR, "I/O backend does not support command %d!\n", command); - } -done: - zap_mutex_unlock(zchan->mutex); - return status; - -} - -OZ_DECLARE(zap_status_t) zap_channel_wait(zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to) -{ - assert(zchan != NULL); - assert(zchan->zio != NULL); - - if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "channel not open"); - return ZAP_FAIL; - } - - if (!zchan->zio->wait) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented"); - return ZAP_FAIL; - } - - return zchan->zio->wait(zchan, flags, to); - -} - -/*******************************/ -ZIO_CODEC_FUNCTION(zio_slin2ulaw) -{ - int16_t sln_buf[512] = {0}, *sln = sln_buf; - uint8_t *lp = data; - uint32_t i; - zap_size_t len = *datalen; - - if (max > len) { - max = len; - } - - memcpy(sln, data, max); - - for(i = 0; i < max; i++) { - *lp++ = linear_to_ulaw(*sln++); - } - - *datalen = max / 2; - - return ZAP_SUCCESS; - -} - - -ZIO_CODEC_FUNCTION(zio_ulaw2slin) -{ - int16_t *sln = data; - uint8_t law[1024] = {0}, *lp = law; - uint32_t i; - zap_size_t len = *datalen; - - if (max > len) { - max = len; - } - - memcpy(law, data, max); - - for(i = 0; i < max; i++) { - *sln++ = ulaw_to_linear(*lp++); - } - - *datalen = max * 2; - - return ZAP_SUCCESS; -} - -ZIO_CODEC_FUNCTION(zio_slin2alaw) -{ - int16_t sln_buf[512] = {0}, *sln = sln_buf; - uint8_t *lp = data; - uint32_t i; - zap_size_t len = *datalen; - - if (max > len) { - max = len; - } - - memcpy(sln, data, max); - - for(i = 0; i < max; i++) { - *lp++ = linear_to_alaw(*sln++); - } - - *datalen = max / 2; - - return ZAP_SUCCESS; - -} - - -ZIO_CODEC_FUNCTION(zio_alaw2slin) -{ - int16_t *sln = data; - uint8_t law[1024] = {0}, *lp = law; - uint32_t i; - zap_size_t len = *datalen; - - if (max > len) { - max = len; - } - - memcpy(law, data, max); - - for(i = 0; i < max; i++) { - *sln++ = alaw_to_linear(*lp++); - } - - *datalen = max * 2; - - return ZAP_SUCCESS; -} - -ZIO_CODEC_FUNCTION(zio_ulaw2alaw) -{ - zap_size_t len = *datalen; - uint32_t i; - uint8_t *lp = data; - - if (max > len) { - max = len; - } - - for(i = 0; i < max; i++) { - *lp = ulaw_to_alaw(*lp); - lp++; - } - - return ZAP_SUCCESS; -} - -ZIO_CODEC_FUNCTION(zio_alaw2ulaw) -{ - zap_size_t len = *datalen; - uint32_t i; - uint8_t *lp = data; - - if (max > len) { - max = len; - } - - for(i = 0; i < max; i++) { - *lp = alaw_to_ulaw(*lp); - lp++; - } - - return ZAP_SUCCESS; -} - -/******************************/ - -OZ_DECLARE(void) zap_channel_clear_detected_tones(zap_channel_t *zchan) -{ - uint32_t i; - - memset(zchan->detected_tones, 0, sizeof(zchan->detected_tones[0]) * ZAP_TONEMAP_INVALID); - - for (i = 1; i < ZAP_TONEMAP_INVALID; i++) { - zchan->span->tone_finder[i].tone_count = 0; - } -} - -OZ_DECLARE(void) zap_channel_clear_needed_tones(zap_channel_t *zchan) -{ - memset(zchan->needed_tones, 0, sizeof(zchan->needed_tones[0]) * ZAP_TONEMAP_INVALID); -} - -OZ_DECLARE(zap_size_t) zap_channel_dequeue_dtmf(zap_channel_t *zchan, char *dtmf, zap_size_t len) -{ - zap_size_t bytes = 0; - - assert(zchan != NULL); - - if (!zap_test_flag(zchan, ZAP_CHANNEL_READY)) { - return ZAP_FAIL; - } - - if (zchan->digit_buffer && zap_buffer_inuse(zchan->digit_buffer)) { - zap_mutex_lock(zchan->mutex); - if ((bytes = zap_buffer_read(zchan->digit_buffer, dtmf, len)) > 0) { - *(dtmf + bytes) = '\0'; - } - zap_mutex_unlock(zchan->mutex); - } - - return bytes; -} - -OZ_DECLARE(void) zap_channel_flush_dtmf(zap_channel_t *zchan) -{ - if (zchan->digit_buffer && zap_buffer_inuse(zchan->digit_buffer)) { - zap_mutex_lock(zchan->mutex); - zap_buffer_zero(zchan->digit_buffer); - zap_mutex_unlock(zchan->mutex); - } -} - -OZ_DECLARE(zap_status_t) zap_channel_queue_dtmf(zap_channel_t *zchan, const char *dtmf) -{ - zap_status_t status; - register zap_size_t len, inuse; - zap_size_t wr = 0; - const char *p; - - assert(zchan != NULL); - - if (zchan->pre_buffer) { - zap_buffer_zero(zchan->pre_buffer); - } - - zap_mutex_lock(zchan->mutex); - - inuse = zap_buffer_inuse(zchan->digit_buffer); - len = strlen(dtmf); - - if (len + inuse > zap_buffer_len(zchan->digit_buffer)) { - zap_buffer_toss(zchan->digit_buffer, strlen(dtmf)); - } - - if (zchan->span->dtmf_hangup_len) { - for (p = dtmf; zap_is_dtmf(*p); p++) { - memmove (zchan->dtmf_hangup_buf, zchan->dtmf_hangup_buf + 1, zchan->span->dtmf_hangup_len - 1); - zchan->dtmf_hangup_buf[zchan->span->dtmf_hangup_len - 1] = *p; - if (!strcmp(zchan->dtmf_hangup_buf, zchan->span->dtmf_hangup)) { - zap_log(ZAP_LOG_DEBUG, "DTMF hangup detected.\n"); - zap_set_state_locked(zchan, ZAP_CHANNEL_STATE_HANGUP); - break; - } - } - } - - p = dtmf; - while (wr < len && p) { - if (zap_is_dtmf(*p)) { - wr++; - } else { - break; - } - p++; - } - - status = zap_buffer_write(zchan->digit_buffer, dtmf, wr) ? ZAP_SUCCESS : ZAP_FAIL; - zap_mutex_unlock(zchan->mutex); - - return status; -} - - -static zap_status_t handle_dtmf(zap_channel_t *zchan, zap_size_t datalen) -{ - zap_buffer_t *buffer = NULL; - zap_size_t dblen = 0; - int wrote = 0; - - if (zchan->gen_dtmf_buffer && (dblen = zap_buffer_inuse(zchan->gen_dtmf_buffer))) { - char digits[128] = ""; - char *cur; - int x = 0; - - if (dblen > sizeof(digits) - 1) { - dblen = sizeof(digits) - 1; - } - - if (zap_buffer_read(zchan->gen_dtmf_buffer, digits, dblen) && !zap_strlen_zero_buf(digits)) { - zap_log(ZAP_LOG_DEBUG, "%d:%d GENERATE DTMF [%s]\n", zchan->span_id, zchan->chan_id, digits); - - cur = digits; - - if (*cur == 'F') { - zap_channel_command(zchan, ZAP_COMMAND_FLASH, NULL); - cur++; - } - - for (; *cur; cur++) { - if ((wrote = teletone_mux_tones(&zchan->tone_session, &zchan->tone_session.TONES[(int)*cur]))) { - zap_buffer_write(zchan->dtmf_buffer, zchan->tone_session.buffer, wrote * 2); - x++; - } else { - zap_log(ZAP_LOG_ERROR, "%d:%d Problem Adding DTMF SEQ [%s]\n", zchan->span_id, zchan->chan_id, digits); - return ZAP_FAIL; - } - } - - if (x) { - zchan->skip_read_frames = (wrote / (zchan->effective_interval * 8)) + 4; - } - } - } - - - if (!zchan->buffer_delay || --zchan->buffer_delay == 0) { - if (zchan->dtmf_buffer && (dblen = zap_buffer_inuse(zchan->dtmf_buffer))) { - buffer = zchan->dtmf_buffer; - } else if (zchan->fsk_buffer && (dblen = zap_buffer_inuse(zchan->fsk_buffer))) { - buffer = zchan->fsk_buffer; - } - } - - if (buffer) { - zap_size_t dlen = datalen; - uint8_t auxbuf[1024]; - zap_size_t len, br, max = sizeof(auxbuf); - - if (zchan->native_codec != ZAP_CODEC_SLIN) { - dlen *= 2; - } - - len = dblen > dlen ? dlen : dblen; - - br = zap_buffer_read(buffer, auxbuf, len); - if (br < dlen) { - memset(auxbuf + br, 0, dlen - br); - } - - if (zchan->native_codec != ZAP_CODEC_SLIN) { - if (zchan->native_codec == ZAP_CODEC_ULAW) { - zio_slin2ulaw(auxbuf, max, &dlen); - } else if (zchan->native_codec == ZAP_CODEC_ALAW) { - zio_slin2alaw(auxbuf, max, &dlen); - } - } - - return zchan->zio->write(zchan, auxbuf, &dlen); - } - - return ZAP_SUCCESS; - -} - - -OZ_DECLARE(void) zap_generate_sln_silence(int16_t *data, uint32_t samples, uint32_t divisor) -{ - int16_t x; - uint32_t i; - int sum_rnd = 0; - int16_t rnd2 = (int16_t) zap_current_time_in_ms() * (int16_t) (intptr_t) data; - - assert(divisor); - - for (i = 0; i < samples; i++, sum_rnd = 0) { - for (x = 0; x < 6; x++) { - rnd2 = rnd2 * 31821U + 13849U; - sum_rnd += rnd2 ; - } - //switch_normalize_to_16bit(sum_rnd); - *data = (int16_t) ((int16_t) sum_rnd / (int) divisor); - - data++; - } -} - - - -OZ_DECLARE(zap_status_t) zap_channel_read(zap_channel_t *zchan, void *data, zap_size_t *datalen) -{ - zap_status_t status = ZAP_FAIL; - zio_codec_t codec_func = NULL; - zap_size_t max = *datalen; - unsigned i = 0; - - assert(zchan != NULL); - assert(zchan->zio != NULL); - - if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "channel not open"); - return ZAP_FAIL; - } - - if (!zchan->zio->read) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented"); - return ZAP_FAIL; - } - - status = zchan->zio->read(zchan, data, datalen); - if (zchan->fds[0] > -1) { - int dlen = (int) *datalen; - if (write(zchan->fds[0], data, dlen) != dlen) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "file write error!"); - return ZAP_FAIL; - } - } - - if (status == ZAP_SUCCESS) { - if (zap_test_flag(zchan, ZAP_CHANNEL_USE_RX_GAIN) - && (zchan->native_codec == ZAP_CODEC_ALAW || zchan->native_codec == ZAP_CODEC_ULAW)) { - unsigned char *rdata = data; - for (i = 0; i < *datalen; i++) { - rdata[i] = zchan->rxgain_table[rdata[i]]; - } - } - handle_dtmf(zchan, *datalen); - } - - if (status == ZAP_SUCCESS && zap_test_flag(zchan, ZAP_CHANNEL_TRANSCODE) && zchan->effective_codec != zchan->native_codec) { - if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_SLIN) { - codec_func = zio_ulaw2slin; - } else if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_ALAW) { - codec_func = zio_ulaw2alaw; - } else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_SLIN) { - codec_func = zio_alaw2slin; - } else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_ULAW) { - codec_func = zio_alaw2ulaw; - } - - if (codec_func) { - status = codec_func(data, max, datalen); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "codec error!"); - status = ZAP_FAIL; - } - } - - if (zap_test_flag(zchan, ZAP_CHANNEL_DTMF_DETECT) || zap_test_flag(zchan, ZAP_CHANNEL_PROGRESS_DETECT) || - zap_test_flag(zchan, ZAP_CHANNEL_CALLERID_DETECT)) { - uint8_t sln_buf[1024] = {0}; - int16_t *sln; - zap_size_t slen = 0; - char digit_str[80] = ""; - - if (zchan->effective_codec == ZAP_CODEC_SLIN) { - sln = data; - slen = *datalen / 2; - } else { - zap_size_t len = *datalen; - uint32_t i; - uint8_t *lp = data; - - slen = sizeof(sln_buf) / 2; - if (len > slen) { - len = slen; - } - - sln = (int16_t *) sln_buf; - for(i = 0; i < len; i++) { - if (zchan->effective_codec == ZAP_CODEC_ULAW) { - *sln++ = ulaw_to_linear(*lp++); - } else if (zchan->effective_codec == ZAP_CODEC_ALAW) { - *sln++ = alaw_to_linear(*lp++); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "codec error!"); - return ZAP_FAIL; - } - } - sln = (int16_t *) sln_buf; - slen = len; - } - - if (zap_test_flag(zchan, ZAP_CHANNEL_CALLERID_DETECT)) { - if (zap_fsk_demod_feed(&zchan->fsk, sln, slen) != ZAP_SUCCESS) { - zap_size_t type, mlen; - char str[128], *sp; - - while(zap_fsk_data_parse(&zchan->fsk, &type, &sp, &mlen) == ZAP_SUCCESS) { - *(str+mlen) = '\0'; - zap_copy_string(str, sp, ++mlen); - zap_clean_string(str); - zap_log(ZAP_LOG_DEBUG, "FSK: TYPE %s LEN %d VAL [%s]\n", zap_mdmf_type2str(type), mlen-1, str); - - switch(type) { - case MDMF_DDN: - case MDMF_PHONE_NUM: - { - if (mlen > sizeof(zchan->caller_data.ani)) { - mlen = sizeof(zchan->caller_data.ani); - } - zap_set_string(zchan->caller_data.ani.digits, str); - zap_set_string(zchan->caller_data.cid_num.digits, zchan->caller_data.ani.digits); - } - break; - case MDMF_NO_NUM: - { - zap_set_string(zchan->caller_data.ani.digits, *str == 'P' ? "private" : "unknown"); - zap_set_string(zchan->caller_data.cid_name, zchan->caller_data.ani.digits); - } - break; - case MDMF_PHONE_NAME: - { - if (mlen > sizeof(zchan->caller_data.cid_name)) { - mlen = sizeof(zchan->caller_data.cid_name); - } - zap_set_string(zchan->caller_data.cid_name, str); - } - break; - case MDMF_NO_NAME: - { - zap_set_string(zchan->caller_data.cid_name, *str == 'P' ? "private" : "unknown"); - } - case MDMF_DATETIME: - { - if (mlen > sizeof(zchan->caller_data.cid_date)) { - mlen = sizeof(zchan->caller_data.cid_date); - } - zap_set_string(zchan->caller_data.cid_date, str); - } - break; - } - } - zap_channel_command(zchan, ZAP_COMMAND_DISABLE_CALLERID_DETECT, NULL); - } - } - - if (zap_test_flag(zchan, ZAP_CHANNEL_PROGRESS_DETECT) && !zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_PROGRESS)) { - uint32_t i; - - for (i = 1; i < ZAP_TONEMAP_INVALID; i++) { - if (zchan->span->tone_finder[i].tone_count) { - if (zchan->needed_tones[i] && teletone_multi_tone_detect(&zchan->span->tone_finder[i], sln, (int)slen)) { - if (++zchan->detected_tones[i]) { - zchan->needed_tones[i] = 0; - zchan->detected_tones[0]++; - } - } - } - } - } - - - if (zap_test_flag(zchan, ZAP_CHANNEL_DTMF_DETECT) && !zap_channel_test_feature(zchan, ZAP_CHANNEL_FEATURE_DTMF_DETECT)) { - teletone_dtmf_detect(&zchan->dtmf_detect, sln, (int)slen); - teletone_dtmf_get(&zchan->dtmf_detect, digit_str, sizeof(digit_str)); - - if(*digit_str) { - zio_event_cb_t event_callback = NULL; - - if (zchan->state == ZAP_CHANNEL_STATE_CALLWAITING && (*digit_str == 'D' || *digit_str == 'A')) { - zchan->detected_tones[ZAP_TONEMAP_CALLWAITING_ACK]++; - } else { - zap_channel_queue_dtmf(zchan, digit_str); - - if (zchan->span->event_callback) { - event_callback = zchan->span->event_callback; - } else if (zchan->event_callback) { - event_callback = zchan->event_callback; - } - - if (event_callback) { - zchan->event_header.channel = zchan; - zchan->event_header.e_type = ZAP_EVENT_DTMF; - zchan->event_header.data = digit_str; - event_callback(zchan, &zchan->event_header); - zchan->event_header.e_type = ZAP_EVENT_NONE; - zchan->event_header.data = NULL; - } - if (zap_test_flag(zchan, ZAP_CHANNEL_SUPRESS_DTMF)) { - zchan->skip_read_frames = 20; - } - } - } - } - } - - if (zchan->skip_read_frames > 0 || zap_test_flag(zchan, ZAP_CHANNEL_MUTE)) { - - zap_mutex_lock(zchan->pre_buffer_mutex); - if (zchan->pre_buffer && zap_buffer_inuse(zchan->pre_buffer)) { - zap_buffer_zero(zchan->pre_buffer); - } - zap_mutex_unlock(zchan->pre_buffer_mutex); - - - memset(data, 255, *datalen); - - if (zchan->skip_read_frames > 0) { - zchan->skip_read_frames--; - } - } else { - zap_mutex_lock(zchan->pre_buffer_mutex); - if (zchan->pre_buffer_size && zchan->pre_buffer) { - zap_buffer_write(zchan->pre_buffer, data, *datalen); - if (zap_buffer_inuse(zchan->pre_buffer) >= zchan->pre_buffer_size) { - zap_buffer_read(zchan->pre_buffer, data, *datalen); - } else { - memset(data, 255, *datalen); - } - } - zap_mutex_unlock(zchan->pre_buffer_mutex); - } - - - return status; -} - - -OZ_DECLARE(zap_status_t) zap_channel_write(zap_channel_t *zchan, void *data, zap_size_t datasize, zap_size_t *datalen) -{ - zap_status_t status = ZAP_FAIL; - zio_codec_t codec_func = NULL; - zap_size_t max = datasize; - unsigned int i = 0; - - assert(zchan != NULL); - assert(zchan->zio != NULL); - - if (!zchan->buffer_delay && - ((zchan->dtmf_buffer && zap_buffer_inuse(zchan->dtmf_buffer)) || - (zchan->fsk_buffer && zap_buffer_inuse(zchan->fsk_buffer)))) { - /* read size writing DTMF ATM */ - return ZAP_SUCCESS; - } - - - if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "channel not open"); - return ZAP_FAIL; - } - - if (!zchan->zio->write) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented"); - return ZAP_FAIL; - } - - if (zap_test_flag(zchan, ZAP_CHANNEL_TRANSCODE) && zchan->effective_codec != zchan->native_codec) { - if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_SLIN) { - codec_func = zio_slin2ulaw; - } else if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_ALAW) { - codec_func = zio_alaw2ulaw; - } else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_SLIN) { - codec_func = zio_slin2alaw; - } else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_ULAW) { - codec_func = zio_ulaw2alaw; - } - - if (codec_func) { - status = codec_func(data, max, datalen); - } else { - snprintf(zchan->last_error, sizeof(zchan->last_error), "codec error!"); - status = ZAP_FAIL; - } - } - - if (zchan->fds[1] > -1) { - int dlen = (int) *datalen; - if ((write(zchan->fds[1], data, dlen)) != dlen) { - snprintf(zchan->last_error, sizeof(zchan->last_error), "file write error!"); - return ZAP_FAIL; - } - } - - if (zap_test_flag(zchan, ZAP_CHANNEL_USE_TX_GAIN) - && (zchan->native_codec == ZAP_CODEC_ALAW || zchan->native_codec == ZAP_CODEC_ULAW)) { - unsigned char *wdata = data; - for (i = 0; i < *datalen; i++) { - wdata[i] = zchan->txgain_table[wdata[i]]; - } - } - status = zchan->zio->write(zchan, data, datalen); - - return status; -} - -OZ_DECLARE(zap_status_t) zap_channel_clear_vars(zap_channel_t *zchan) -{ - if(zchan->variable_hash) { - hashtable_destroy(zchan->variable_hash); - } - zchan->variable_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys); - - if(!zchan->variable_hash) - return ZAP_FAIL; - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_add_var(zap_channel_t *zchan, const char *var_name, const char *value) -{ - char *t_name = 0, *t_val = 0; - - if(!zchan->variable_hash || !var_name || !value) - { - return ZAP_FAIL; - } - - t_name = zap_strdup(var_name); - t_val = zap_strdup(value); - - if(hashtable_insert(zchan->variable_hash, t_name, t_val, HASHTABLE_FLAG_FREE_KEY | HASHTABLE_FLAG_FREE_VALUE)) { - return ZAP_SUCCESS; - } - return ZAP_FAIL; -} - -OZ_DECLARE(const char *) zap_channel_get_var(zap_channel_t *zchan, const char *var_name) -{ - if(!zchan->variable_hash || !var_name) - { - return NULL; - } - return (const char *) hashtable_search(zchan->variable_hash, (void *)var_name); -} - -static struct { - zap_io_interface_t *pika_interface; -} interfaces; - - -OZ_DECLARE(char *) zap_api_execute(const char *type, const char *cmd) -{ - zap_io_interface_t *zio = NULL; - char *dup = NULL, *p; - char *rval = NULL; - - if (type && !cmd) { - dup = zap_strdup(type); - if ((p = strchr(dup, ' '))) { - *p++ = '\0'; - cmd = p; - } - - type = dup; - } - - zap_mutex_lock(globals.mutex); - if (!(zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, (void *)type))) { - zap_load_module_assume(type); - if ((zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, (void *)type))) { - zap_log(ZAP_LOG_INFO, "auto-loaded '%s'\n", type); - } - } - zap_mutex_unlock(globals.mutex); - - if (zio && zio->api) { - zap_stream_handle_t stream = { 0 }; - zap_status_t status; - ZAP_STANDARD_STREAM(stream); - status = zio->api(&stream, cmd); - - if (status != ZAP_SUCCESS) { - zap_safe_free(stream.data); - } else { - rval = (char *) stream.data; - } - } - - zap_safe_free(dup); - - return rval; -} - - -static zap_status_t load_config(void) -{ - char cfg_name[] = "openzap.conf"; - zap_config_t cfg; - char *var, *val; - int catno = -1; - zap_span_t *span = NULL; - unsigned configured = 0, d = 0; - char name[80] = ""; - char number[25] = ""; - char group_name[80] = "default"; - zap_io_interface_t *zio = NULL; - zap_analog_start_type_t tmp; - zap_size_t len = 0; - - if (!zap_config_open_file(&cfg, cfg_name)) { - return ZAP_FAIL; - } - - while (zap_config_next_pair(&cfg, &var, &val)) { - if (*cfg.category == '#') { - if (cfg.catno != catno) { - zap_log(ZAP_LOG_DEBUG, "Skipping %s\n", cfg.category); - catno = cfg.catno; - } - } else if (!strncasecmp(cfg.category, "span", 4)) { - if (cfg.catno != catno) { - char *type = cfg.category + 4; - char *name; - - if (*type == ' ') { - type++; - } - - zap_log(ZAP_LOG_DEBUG, "found config for span\n"); - catno = cfg.catno; - - if (zap_strlen_zero(type)) { - zap_log(ZAP_LOG_CRIT, "failure creating span, no type specified.\n"); - span = NULL; - continue; - } - - if ((name = strchr(type, ' '))) { - *name++ = '\0'; - } - - zap_mutex_lock(globals.mutex); - if (!(zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, type))) { - zap_load_module_assume(type); - if ((zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, type))) { - zap_log(ZAP_LOG_INFO, "auto-loaded '%s'\n", type); - } - } - zap_mutex_unlock(globals.mutex); - - if (!zio) { - zap_log(ZAP_LOG_CRIT, "failure creating span, no such type '%s'\n", type); - span = NULL; - continue; - } - - if (!zio->configure_span) { - zap_log(ZAP_LOG_CRIT, "failure creating span, no configure_span method for '%s'\n", type); - span = NULL; - continue; - } - - if (zap_span_create(zio, &span, name) == ZAP_SUCCESS) { - span->type = zap_strdup(type); - d = 0; - - zap_log(ZAP_LOG_DEBUG, "created span %d (%s) of type %s\n", span->span_id, span->name, type); - - } else { - zap_log(ZAP_LOG_CRIT, "failure creating span of type %s\n", type); - span = NULL; - continue; - } - } - - if (!span) { - continue; - } - - zap_log(ZAP_LOG_DEBUG, "span %d [%s]=[%s]\n", span->span_id, var, val); - - if (!strcasecmp(var, "trunk_type")) { - span->trunk_type = zap_str2zap_trunk_type(val); - zap_log(ZAP_LOG_DEBUG, "setting trunk type to '%s'\n", zap_trunk_type2str(span->trunk_type)); - } else if (!strcasecmp(var, "name")) { - if (!strcasecmp(val, "undef")) { - *name = '\0'; - } else { - zap_copy_string(name, val, sizeof(name)); - } - } else if (!strcasecmp(var, "number")) { - if (!strcasecmp(val, "undef")) { - *number = '\0'; - } else { - zap_copy_string(number, val, sizeof(number)); - } - } else if (!strcasecmp(var, "analog-start-type")) { - if (span->trunk_type == ZAP_TRUNK_FXS || span->trunk_type == ZAP_TRUNK_FXO || span->trunk_type == ZAP_TRUNK_EM) { - if ((tmp = zap_str2zap_analog_start_type(val)) != ZAP_ANALOG_START_NA) { - span->start_type = tmp; - zap_log(ZAP_LOG_DEBUG, "changing start type to '%s'\n", zap_analog_start_type2str(span->start_type)); - } - } else { - zap_log(ZAP_LOG_ERROR, "This option is only valid on analog trunks!\n"); - } - } else if (!strcasecmp(var, "fxo-channel")) { - if (span->trunk_type == ZAP_TRUNK_NONE) { - span->trunk_type = ZAP_TRUNK_FXO; - zap_log(ZAP_LOG_DEBUG, "setting trunk type to '%s' start(%s)\n", zap_trunk_type2str(span->trunk_type), - zap_analog_start_type2str(span->start_type)); - } - if (span->trunk_type == ZAP_TRUNK_FXO) { - configured += zio->configure_span(span, val, ZAP_CHAN_TYPE_FXO, name, number); - } else { - zap_log(ZAP_LOG_WARNING, "Cannot add FXO channels to an FXS trunk!\n"); - } - } else if (!strcasecmp(var, "fxs-channel")) { - if (span->trunk_type == ZAP_TRUNK_NONE) { - span->trunk_type = ZAP_TRUNK_FXS; - zap_log(ZAP_LOG_DEBUG, "setting trunk type to '%s' start(%s)\n", zap_trunk_type2str(span->trunk_type), - zap_analog_start_type2str(span->start_type)); - } - if (span->trunk_type == ZAP_TRUNK_FXS) { - configured += zio->configure_span(span, val, ZAP_CHAN_TYPE_FXS, name, number); - } else { - zap_log(ZAP_LOG_WARNING, "Cannot add FXS channels to an FXO trunk!\n"); - } - } else if (!strcasecmp(var, "em-channel")) { - if (span->trunk_type == ZAP_TRUNK_NONE) { - span->trunk_type = ZAP_TRUNK_EM; - zap_log(ZAP_LOG_DEBUG, "setting trunk type to '%s' start(%s)\n", zap_trunk_type2str(span->trunk_type), - zap_analog_start_type2str(span->start_type)); - } - if (span->trunk_type == ZAP_TRUNK_EM) { - configured += zio->configure_span(span, val, ZAP_CHAN_TYPE_EM, name, number); - } else { - zap_log(ZAP_LOG_WARNING, "Cannot add EM channels to a non-EM trunk!\n"); - } - } else if (!strcasecmp(var, "b-channel")) { - configured += zio->configure_span(span, val, ZAP_CHAN_TYPE_B, name, number); - zap_group_add_channels(group_name, span, val); - } else if (!strcasecmp(var, "d-channel")) { - if (d) { - zap_log(ZAP_LOG_WARNING, "ignoring extra d-channel\n"); - } else { - zap_chan_type_t qtype; - if (!strncasecmp(val, "lapd:", 5)) { - qtype = ZAP_CHAN_TYPE_DQ931; - val += 5; - } else { - qtype = ZAP_CHAN_TYPE_DQ921; - } - configured += zio->configure_span(span, val, qtype, name, number); - d++; - } - } else if (!strcasecmp(var, "cas-channel")) { - configured += zio->configure_span(span, val, ZAP_CHAN_TYPE_CAS, name, number); - } else if (!strcasecmp(var, "dtmf_hangup")) { - span->dtmf_hangup = zap_strdup(val); - span->dtmf_hangup_len = strlen(val); - } else if (!strcasecmp(var, "group")) { - len = strlen(val); - if (len >= sizeof(group_name)) { - len = sizeof(group_name) - 1; - zap_log(ZAP_LOG_WARNING, "Truncating group name %s to %zd length\n", val, len); - } - memcpy(group_name, val, len); - group_name[len] = '\0'; - } else { - zap_log(ZAP_LOG_ERROR, "unknown span variable '%s'\n", var); - } - } else { - zap_log(ZAP_LOG_ERROR, "unknown param [%s] '%s' / '%s'\n", cfg.category, var, val); - } - } - zap_config_close_file(&cfg); - - zap_log(ZAP_LOG_INFO, "Configured %u channel(s)\n", configured); - - return configured ? ZAP_SUCCESS : ZAP_FAIL; -} - -static zap_status_t process_module_config(zap_io_interface_t *zio) -{ - zap_config_t cfg; - char *var, *val; - char filename[256] = ""; - - zap_assert_return(zio != NULL, ZAP_FAIL, "zio argument is null\n"); - - snprintf(filename, sizeof(filename), "%s.conf", zio->name); - - if (!zio->configure) { - zap_log(ZAP_LOG_DEBUG, "Module %s does not support configuration.\n", zio->name); - return ZAP_FAIL; - } - - if (!zap_config_open_file(&cfg, filename)) { - zap_log(ZAP_LOG_ERROR, "Cannot open %s\n", filename); - return ZAP_FAIL; - } - - while (zap_config_next_pair(&cfg, &var, &val)) { - zio->configure(cfg.category, var, val, cfg.lineno); - } - - zap_config_close_file(&cfg); - - return ZAP_SUCCESS; -} - -OZ_DECLARE(char *) zap_build_dso_path(const char *name, char *path, zap_size_t len) -{ -#ifdef WIN32 - const char *ext = ".dll"; - //const char *EXT = ".DLL"; -#define ZAP_MOD_DIR "." //todo -#elif defined (MACOSX) || defined (DARWIN) - const char *ext = ".dylib"; - //const char *EXT = ".DYLIB"; -#else - const char *ext = ".so"; - //const char *EXT = ".SO"; -#endif - if (*name == *ZAP_PATH_SEPARATOR) { - snprintf(path, len, "%s%s", name, ext); - } else { - snprintf(path, len, "%s%s%s%s", ZAP_MOD_DIR, ZAP_PATH_SEPARATOR, name, ext); - } - return path; -} - -OZ_DECLARE(zap_status_t) zap_global_add_io_interface(zap_io_interface_t *interface1) -{ - zap_status_t ret = ZAP_SUCCESS; - zap_mutex_lock(globals.mutex); - if (hashtable_search(globals.interface_hash, (void *)interface1->name)) { - zap_log(ZAP_LOG_ERROR, "Interface %s already loaded!\n", interface1->name); - } else { - hashtable_insert(globals.interface_hash, (void *)interface1->name, interface1, HASHTABLE_FLAG_NONE); - } - zap_mutex_unlock(globals.mutex); - return ret; -} - -OZ_DECLARE(int) zap_load_module(const char *name) -{ - zap_dso_lib_t lib; - int count = 0, x = 0; - char path[128] = ""; - char *err; - zap_module_t *mod; - - zap_build_dso_path(name, path, sizeof(path)); - - if (!(lib = zap_dso_open(path, &err))) { - zap_log(ZAP_LOG_ERROR, "Error loading %s [%s]\n", path, err); - zap_safe_free(err); - return 0; - } - - if (!(mod = (zap_module_t *) zap_dso_func_sym(lib, "zap_module", &err))) { - zap_log(ZAP_LOG_ERROR, "Error loading %s [%s]\n", path, err); - zap_safe_free(err); - return 0; - } - - if (mod->io_load) { - zap_io_interface_t *interface1 = NULL; /* name conflict w/windows here */ - - if (mod->io_load(&interface1) != ZAP_SUCCESS || !interface1 || !interface1->name) { - zap_log(ZAP_LOG_ERROR, "Error loading %s\n", path); - } else { - zap_log(ZAP_LOG_INFO, "Loading IO from %s [%s]\n", path, interface1->name); - if (zap_global_add_io_interface(interface1) == ZAP_SUCCESS) { - process_module_config(interface1); - x++; - } - } - } - - if (mod->sig_load) { - if (mod->sig_load() != ZAP_SUCCESS) { - zap_log(ZAP_LOG_ERROR, "Error loading %s\n", path); - } else { - zap_log(ZAP_LOG_INFO, "Loading SIG from %s\n", path); - x++; - } - } - - if (x) { - char *p; - mod->lib = lib; - zap_set_string(mod->path, path); - if (mod->name[0] == '\0') { - if (!(p = strrchr(path, *ZAP_PATH_SEPARATOR))) { - p = path; - } - zap_set_string(mod->name, p); - } - - zap_mutex_lock(globals.mutex); - if (hashtable_search(globals.module_hash, (void *)mod->name)) { - zap_log(ZAP_LOG_ERROR, "Module %s already loaded!\n", mod->name); - zap_dso_destroy(&lib); - } else { - hashtable_insert(globals.module_hash, (void *)mod->name, mod, HASHTABLE_FLAG_NONE); - count++; - } - zap_mutex_unlock(globals.mutex); - } else { - zap_log(ZAP_LOG_ERROR, "Unloading %s\n", path); - zap_dso_destroy(&lib); - } - - return count; -} - -OZ_DECLARE(int) zap_load_module_assume(const char *name) -{ - char buf[256] = ""; - - snprintf(buf, sizeof(buf), "ozmod_%s", name); - return zap_load_module(buf); -} - -OZ_DECLARE(int) zap_load_modules(void) -{ - char cfg_name[] = "modules.conf"; - zap_config_t cfg; - char *var, *val; - int count = 0; - - if (!zap_config_open_file(&cfg, cfg_name)) { - return ZAP_FAIL; - } - - while (zap_config_next_pair(&cfg, &var, &val)) { - if (!strcasecmp(cfg.category, "modules")) { - if (!strcasecmp(var, "load")) { - count += zap_load_module(val); - } - } - } - - return count; -} - -OZ_DECLARE(zap_status_t) zap_unload_modules(void) -{ - zap_hash_iterator_t *i; - zap_dso_lib_t lib; - - for (i = hashtable_first(globals.module_hash); i; i = hashtable_next(i)) { - const void *key; - void *val; - - hashtable_this(i, &key, NULL, &val); - - if (key && val) { - zap_module_t *mod = (zap_module_t *) val; - - if (!mod) { - continue; - } - - if (mod->io_unload) { - if (mod->io_unload() == ZAP_SUCCESS) { - zap_log(ZAP_LOG_INFO, "Unloading IO %s\n", mod->name); - } else { - zap_log(ZAP_LOG_ERROR, "Error unloading IO %s\n", mod->name); - } - } - - if (mod->sig_unload) { - if (mod->sig_unload() == ZAP_SUCCESS) { - zap_log(ZAP_LOG_INFO, "Unloading SIG %s\n", mod->name); - } else { - zap_log(ZAP_LOG_ERROR, "Error unloading SIG %s\n", mod->name); - } - } - - - zap_log(ZAP_LOG_INFO, "Unloading %s\n", mod->path); - lib = mod->lib; - zap_dso_destroy(&lib); - - } - } - - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_configure_span(const char *type, zap_span_t *span, zio_signal_cb_t sig_cb, ...) -{ - zap_module_t *mod = (zap_module_t *) hashtable_search(globals.module_hash, (void *)type); - zap_status_t status = ZAP_FAIL; - - if (!mod) { - zap_load_module_assume(type); - if ((mod = (zap_module_t *) hashtable_search(globals.module_hash, (void *)type))) { - zap_log(ZAP_LOG_INFO, "auto-loaded '%s'\n", type); - } - } - - if (mod && mod->sig_configure) { - va_list ap; - va_start(ap, sig_cb); - status = mod->sig_configure(span, sig_cb, ap); - va_end(ap); - } else { - zap_log(ZAP_LOG_ERROR, "can't find '%s'\n", type); - status = ZAP_FAIL; - } - - return status; -} - -OZ_DECLARE(zap_status_t) zap_configure_span_signaling(const char *type, zap_span_t *span, zio_signal_cb_t sig_cb, zap_conf_parameter_t *parameters) -{ - zap_module_t *mod = (zap_module_t *) hashtable_search(globals.module_hash, (void *)type); - zap_status_t status = ZAP_FAIL; - - zap_assert_return(type != NULL, ZAP_FAIL, "No signaling type"); - zap_assert_return(span != NULL, ZAP_FAIL, "No span"); - zap_assert_return(sig_cb != NULL, ZAP_FAIL, "No signaling callback"); - zap_assert_return(parameters != NULL, ZAP_FAIL, "No parameters"); - - if (!mod) { - zap_load_module_assume(type); - if ((mod = (zap_module_t *) hashtable_search(globals.module_hash, (void *)type))) { - zap_log(ZAP_LOG_INFO, "auto-loaded '%s'\n", type); - } - } - - if (!mod) { - zap_log(ZAP_LOG_ERROR, "Failed to load module type: %s\n", type); - return ZAP_FAIL; - } - - if (mod->configure_span_signaling) { - status = mod->configure_span_signaling(span, sig_cb, parameters); - } else { - zap_log(ZAP_LOG_ERROR, "Module %s did not implement the signaling configuration method\n", type); - } - - return status; -} - -OZ_DECLARE(zap_status_t) zap_span_start(zap_span_t *span) -{ - if (span->start) { - return span->start(span); - } - - return ZAP_FAIL; -} - -OZ_DECLARE(zap_status_t) zap_channel_add_to_group(const char* name, zap_channel_t* zchan) -{ - int i; - zap_group_t* group = NULL; - - zap_mutex_lock(globals.group_mutex); - - if (zap_group_find_by_name(name, &group) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_DEBUG, "Creating new group:%s\n", name); - zap_group_create(&group, name); - } - - /*verify that group does not already include this channel first */ - for(i=0; i < group->chan_count; i++) { - if (group->channels[i]->physical_span_id == zchan->physical_span_id && - group->channels[i]->physical_chan_id == zchan->physical_chan_id) { - - zap_mutex_unlock(globals.group_mutex); - return ZAP_SUCCESS; - } - } - - if (group->chan_count >= ZAP_MAX_CHANNELS_GROUP) { - zap_log(ZAP_LOG_CRIT, "Max number of channels exceeded (max:%d)\n", ZAP_MAX_CHANNELS_GROUP); - zap_mutex_unlock(globals.group_mutex); - return ZAP_FAIL; - } - - group->channels[group->chan_count++] = zchan; - zap_mutex_unlock(globals.group_mutex); - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_channel_remove_from_group(zap_group_t* group, zap_channel_t* zchan) -{ - //Need to test this function - zap_mutex_lock(globals.group_mutex); - int i, j; - - for (i=0; i < group->chan_count; i++) { - if (group->channels[i]->physical_span_id == zchan->physical_span_id && - group->channels[i]->physical_chan_id == zchan->physical_chan_id) { - - j=i; - while(j < group->chan_count-1) { - group->channels[j] = group->channels[j+1]; - j++; - } - group->channels[group->chan_count--] = NULL; - if (group->chan_count <=0) { - /* Delete group if it is empty */ - hashtable_remove(globals.group_hash, (void *)group->name); - } - zap_mutex_unlock(globals.group_mutex); - return ZAP_SUCCESS; - } - } - - zap_mutex_unlock(globals.group_mutex); - //Group does not contain this channel - return ZAP_FAIL; -} - -OZ_DECLARE(zap_status_t) zap_group_add_channels(const char* name, zap_span_t* span, const char* val) -{ - char *p, *mydata, *item_list[10]; - int items, i; - - assert(strlen(name) > 0); - - p = strchr(val, ':'); - mydata = zap_strdup(++p); - - zap_assert_return(mydata != NULL, ZAP_FAIL, "zap_strdup failed when adding channels\n"); - - items = zap_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0]))); - - for(i=0; i < items; i++) { - if (!strchr(item_list[i], '-')) { - int chan_no; - - chan_no = atoi (item_list[i]); - zap_assert(chan_no > 0, "Channel number is not bigger than zero, expect a nasty failure!\n"); - - if (zap_channel_add_to_group(name, span->channels[chan_no]) != ZAP_SUCCESS) { - zap_log(ZAP_LOG_CRIT, "Failed to add chan:%d to group:%s\n", chan_no, name); - } - } else { - int chan_no_start, chan_no_end; - if (sscanf(item_list[i], "%d-%d", &chan_no_start, &chan_no_end) == 2) { - while (chan_no_start <= chan_no_end) { - if (zap_channel_add_to_group(name, span->channels[chan_no_start++])) { - zap_log(ZAP_LOG_CRIT, "Failed to add chan:%d to group:%s\n", chan_no_start-1, name); - } - } - } - } - } - zap_safe_free(mydata); - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_group_find(uint32_t id, zap_group_t **group) -{ - zap_group_t *fgroup = NULL, *grp; - - if (id > ZAP_MAX_GROUPS_INTERFACE) { - return ZAP_FAIL; - } - - - zap_mutex_lock(globals.group_mutex); - for (grp = globals.groups; grp; grp = grp->next) { - if (grp->group_id == id) { - fgroup = grp; - break; - } - } - zap_mutex_unlock(globals.group_mutex); - - if (!fgroup) { - return ZAP_FAIL; - } - - *group = fgroup; - - return ZAP_SUCCESS; - -} - -OZ_DECLARE(zap_status_t) zap_group_find_by_name(const char *name, zap_group_t **group) -{ - zap_status_t status = ZAP_FAIL; - *group = NULL; - zap_mutex_lock(globals.group_mutex); - if (!zap_strlen_zero(name)) { - if ((*group = hashtable_search(globals.group_hash, (void *) name))) { - status = ZAP_SUCCESS; - } - } - zap_mutex_unlock(globals.group_mutex); - return status; -} - -static void zap_group_add(zap_group_t *group) -{ - zap_group_t *grp; - zap_mutex_lock(globals.group_mutex); - - for (grp = globals.groups; grp && grp->next; grp = grp->next); - - if (grp) { - grp->next = group; - } else { - globals.groups = group; - } - hashtable_insert(globals.group_hash, (void *)group->name, group, HASHTABLE_FLAG_NONE); - - zap_mutex_unlock(globals.group_mutex); -} - - -OZ_DECLARE(zap_status_t) zap_group_create(zap_group_t **group, const char *name) -{ - zap_group_t *new_group = NULL; - zap_status_t status = ZAP_FAIL; - - zap_mutex_lock(globals.mutex); - if (globals.group_index < ZAP_MAX_GROUPS_INTERFACE) { - new_group = zap_calloc(1, sizeof(*new_group)); - - zap_assert(new_group != NULL, "Failed to create new zap group, expect a crash\n"); - - status = zap_mutex_create(&new_group->mutex); - - zap_assert(status == ZAP_SUCCESS, "Failed to create group mutex, expect a crash\n"); - - new_group->group_id = ++globals.group_index; - new_group->name = zap_strdup(name); - zap_group_add(new_group); - *group = new_group; - status = ZAP_SUCCESS; - } else { - zap_log(ZAP_LOG_CRIT, "Group %s was not added, we exceeded the max number of groups\n", name); - } - zap_mutex_unlock(globals.mutex); - return status; -} - -OZ_DECLARE(zap_status_t) zap_global_init(void) -{ - memset(&globals, 0, sizeof(globals)); - - time_init(); - - zap_thread_override_default_stacksize(ZAP_THREAD_STACKSIZE); - - memset(&interfaces, 0, sizeof(interfaces)); - globals.interface_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys); - globals.module_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys); - globals.span_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys); - globals.group_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys); - zap_mutex_create(&globals.mutex); - zap_mutex_create(&globals.span_mutex); - zap_mutex_create(&globals.group_mutex); - globals.running = 1; - return ZAP_SUCCESS; -} - -OZ_DECLARE(zap_status_t) zap_global_configuration(void) -{ - int modcount = zap_load_modules(); - zap_log(ZAP_LOG_NOTICE, "Modules configured: %d \n", modcount); - - if (load_config() != ZAP_SUCCESS) { - globals.running = 0; - zap_log(ZAP_LOG_ERROR, "OpenZap global configuration failed!\n"); - return ZAP_FAIL; - } - return ZAP_SUCCESS; -} - -OZ_DECLARE(uint32_t) zap_running(void) -{ - return globals.running; -} - - -OZ_DECLARE(zap_status_t) zap_global_destroy(void) -{ - zap_span_t *sp; - - time_end(); - - globals.running = 0; - zap_span_close_all(); - zap_sleep(1000); - - zap_mutex_lock(globals.span_mutex); - for (sp = globals.spans; sp;) { - zap_span_t *cur_span = sp; - sp = sp->next; - - if (cur_span) { - if (zap_test_flag(cur_span, ZAP_SPAN_CONFIGURED)) { - zap_span_destroy(cur_span); - } - - hashtable_remove(globals.span_hash, (void *)cur_span->name); - zap_safe_free(cur_span->type); - zap_safe_free(cur_span->name); - zap_safe_free(cur_span); - cur_span = NULL; - } - } - globals.spans = NULL; - zap_mutex_unlock(globals.span_mutex); - - globals.span_index = 0; - - zap_unload_modules(); - - zap_mutex_lock(globals.mutex); - hashtable_destroy(globals.interface_hash); - hashtable_destroy(globals.module_hash); - hashtable_destroy(globals.span_hash); - zap_mutex_unlock(globals.mutex); - zap_mutex_destroy(&globals.mutex); - zap_mutex_destroy(&globals.span_mutex); - - memset(&globals, 0, sizeof(globals)); - return ZAP_SUCCESS; -} - - -OZ_DECLARE(uint32_t) zap_separate_string(char *buf, char delim, char **array, int arraylen) -{ - int argc; - char *ptr; - int quot = 0; - char qc = '\''; - int x; - - if (!buf || !array || !arraylen) { - return 0; - } - - memset(array, 0, arraylen * sizeof(*array)); - - ptr = buf; - - for (argc = 0; *ptr && (argc < arraylen - 1); argc++) { - array[argc] = ptr; - for (; *ptr; ptr++) { - if (*ptr == qc) { - if (quot) { - quot--; - } else { - quot++; - } - } else if ((*ptr == delim) && !quot) { - *ptr++ = '\0'; - break; - } - } - } - - if (*ptr) { - array[argc++] = ptr; - } - - /* strip quotes and leading / trailing spaces */ - for (x = 0; x < argc; x++) { - char *p; - - while(*(array[x]) == ' ') { - (array[x])++; - } - p = array[x]; - while((p = strchr(array[x], qc))) { - memmove(p, p+1, strlen(p)); - p++; - } - p = array[x] + (strlen(array[x]) - 1); - while(*p == ' ') { - *p-- = '\0'; - } - } - - return argc; -} - -OZ_DECLARE(void) zap_bitstream_init(zap_bitstream_t *bsp, uint8_t *data, uint32_t datalen, zap_endian_t endian, uint8_t ss) -{ - memset(bsp, 0, sizeof(*bsp)); - bsp->data = data; - bsp->datalen = datalen; - bsp->endian = endian; - bsp->ss = ss; - - if (endian < 0) { - bsp->top = bsp->bit_index = 7; - bsp->bot = 0; - } else { - bsp->top = bsp->bit_index = 0; - bsp->bot = 7; - } - -} - -OZ_DECLARE(int8_t) zap_bitstream_get_bit(zap_bitstream_t *bsp) -{ - int8_t bit = -1; - - - if (bsp->byte_index >= bsp->datalen) { - goto done; - } - - if (bsp->ss) { - if (!bsp->ssv) { - bsp->ssv = 1; - return 0; - } else if (bsp->ssv == 2) { - bsp->byte_index++; - bsp->ssv = 0; - return 1; - } - } - - - - - bit = (bsp->data[bsp->byte_index] >> (bsp->bit_index)) & 1; - - if (bsp->bit_index == bsp->bot) { - bsp->bit_index = bsp->top; - if (bsp->ss) { - bsp->ssv = 2; - goto done; - } - - if (++bsp->byte_index > bsp->datalen) { - bit = -1; - goto done; - } - - } else { - bsp->bit_index = bsp->bit_index + bsp->endian; - } - - - done: - return bit; -} - -OZ_DECLARE(void) print_hex_bytes(uint8_t *data, zap_size_t dlen, char *buf, zap_size_t blen) -{ - char *bp = buf; - uint8_t *byte = data; - uint32_t i, j = 0; - - if (blen < (dlen * 3) + 2) { - return; - } - - *bp++ = '['; - j++; - - for(i = 0; i < dlen; i++) { - snprintf(bp, blen-j, "%02x ", *byte++); - bp += 3; - j += 3; - } - - *--bp = ']'; - -} - -OZ_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, zap_endian_t e, uint8_t ss) -{ - zap_bitstream_t bs; - int j = 0, c = 0; - int8_t bit; - uint32_t last; - - if (blen < (bl * 10) + 2) { - return; - } - - zap_bitstream_init(&bs, b, bl, e, ss); - last = bs.byte_index; - while((bit = zap_bitstream_get_bit(&bs)) > -1) { - buf[j++] = bit ? '1' : '0'; - if (bs.byte_index != last) { - buf[j++] = ' '; - last = bs.byte_index; - if (++c == 8) { - buf[j++] = '\n'; - c = 0; - } - } - } - -} - - - -OZ_DECLARE_NONSTD(zap_status_t) zap_console_stream_raw_write(zap_stream_handle_t *handle, uint8_t *data, zap_size_t datalen) -{ - zap_size_t need = handle->data_len + datalen; - - if (need >= handle->data_size) { - void *new_data; - need += handle->alloc_chunk; - - if (!(new_data = realloc(handle->data, need))) { - return ZAP_MEMERR; - } - - handle->data = new_data; - handle->data_size = need; - } - - memcpy((uint8_t *) (handle->data) + handle->data_len, data, datalen); - handle->data_len += datalen; - handle->end = (uint8_t *) (handle->data) + handle->data_len; - *(uint8_t *)handle->end = '\0'; - - return ZAP_SUCCESS; -} - -OZ_DECLARE(int) zap_vasprintf(char **ret, const char *fmt, va_list ap) /* code from switch_apr.c */ -{ -#ifdef HAVE_VASPRINTF - return vasprintf(ret, fmt, ap); -#else - char *buf; - int len; - size_t buflen; - va_list ap2; - char *tmp = NULL; - -#ifdef _MSC_VER -#if _MSC_VER >= 1500 - /* hack for incorrect assumption in msvc header files for code analysis */ - __analysis_assume(tmp); -#endif - ap2 = ap; -#else - va_copy(ap2, ap); -#endif - - len = vsnprintf(tmp, 0, fmt, ap2); - - if (len > 0 && (buf = zap_malloc((buflen = (size_t) (len + 1)))) != NULL) { - len = vsnprintf(buf, buflen, fmt, ap); - *ret = buf; - } else { - *ret = NULL; - len = -1; - } - - va_end(ap2); - return len; -#endif -} - -OZ_DECLARE_NONSTD(zap_status_t) zap_console_stream_write(zap_stream_handle_t *handle, const char *fmt, ...) -{ - va_list ap; - char *buf = handle->data; - char *end = handle->end; - int ret = 0; - char *data = NULL; - - if (handle->data_len >= handle->data_size) { - return ZAP_FAIL; - } - - va_start(ap, fmt); - ret = zap_vasprintf(&data, fmt, ap); - va_end(ap); - - if (data) { - zap_size_t remaining = handle->data_size - handle->data_len; - zap_size_t need = strlen(data) + 1; - - if ((remaining < need) && handle->alloc_len) { - zap_size_t new_len; - void *new_data; - - new_len = handle->data_size + need + handle->alloc_chunk; - if ((new_data = realloc(handle->data, new_len))) { - handle->data_size = handle->alloc_len = new_len; - handle->data = new_data; - buf = handle->data; - remaining = handle->data_size - handle->data_len; - handle->end = (uint8_t *) (handle->data) + handle->data_len; - end = handle->end; - } else { - zap_log(ZAP_LOG_CRIT, "Memory Error!\n"); - zap_safe_free(data); - return ZAP_FAIL; - } - } - - if (remaining < need) { - ret = -1; - } else { - ret = 0; - snprintf(end, remaining, "%s", data); - handle->data_len = strlen(buf); - handle->end = (uint8_t *) (handle->data) + handle->data_len; - } - zap_safe_free(data); - } - - return ret ? ZAP_FAIL : ZAP_SUCCESS; -} - -OZ_DECLARE(char *) zap_strdup(const char *str) -{ - zap_size_t len = strlen(str) + 1; - void *new = zap_malloc(len); - - if (!new) { - return NULL; - } - - return (char *)memcpy(new, str, len); -} - -OZ_DECLARE(char *) zap_strndup(const char *str, zap_size_t inlen) -{ - char *new = NULL; - zap_size_t len = strlen(str) + 1; - if (len > (inlen+1)) { - len = inlen+1; - } - new = (char *)zap_malloc(len); - - if (!new) { - return NULL; - } - - memcpy(new, str, len-1); - new[len-1] = 0; - return new; -} - - -/* For Emacs: - * Local Variables: - * mode:c - * indent-tabs-mode:t - * tab-width:4 - * c-basic-offset:4 - * End: - * For VIM: - * vim:set softtabstop=4 shiftwidth=4 tabstop=4: - */