[svn-commits] russell: branch group/addons-merge r204407 - in /team/group/addons-merge: add...
SVN commits to the Digium repositories
svn-commits at lists.digium.com
Tue Jun 30 11:06:00 CDT 2009
Author: russell
Date: Tue Jun 30 11:05:56 2009
New Revision: 204407
URL: http://svn.asterisk.org/svn-view/asterisk?view=rev&rev=204407
Log:
Add chan_ooh323, but it doesn't build because it's behind trunk
Added:
team/group/addons-merge/addons/chan_ooh323.c (with props)
team/group/addons-merge/addons/chan_ooh323.h (with props)
team/group/addons-merge/addons/ooh323c/
team/group/addons-merge/addons/ooh323c/COPYING (with props)
team/group/addons-merge/addons/ooh323c/README (with props)
team/group/addons-merge/addons/ooh323c/src/
team/group/addons-merge/addons/ooh323c/src/Makefile.in (with props)
team/group/addons-merge/addons/ooh323c/src/context.c (with props)
team/group/addons-merge/addons/ooh323c/src/decode.c (with props)
team/group/addons-merge/addons/ooh323c/src/dlist.c (with props)
team/group/addons-merge/addons/ooh323c/src/dlist.h (with props)
team/group/addons-merge/addons/ooh323c/src/encode.c (with props)
team/group/addons-merge/addons/ooh323c/src/errmgmt.c (with props)
team/group/addons-merge/addons/ooh323c/src/eventHandler.c (with props)
team/group/addons-merge/addons/ooh323c/src/eventHandler.h (with props)
team/group/addons-merge/addons/ooh323c/src/h323/
team/group/addons-merge/addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h (with props)
team/group/addons-merge/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c (with props)
team/group/addons-merge/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c (with props)
team/group/addons-merge/addons/ooh323c/src/h323/H323-MESSAGES.c (with props)
team/group/addons-merge/addons/ooh323c/src/h323/H323-MESSAGES.h (with props)
team/group/addons-merge/addons/ooh323c/src/h323/H323-MESSAGESDec.c (with props)
team/group/addons-merge/addons/ooh323c/src/h323/H323-MESSAGESEnc.c (with props)
team/group/addons-merge/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c (with props)
team/group/addons-merge/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h (with props)
team/group/addons-merge/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c (with props)
team/group/addons-merge/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c (with props)
team/group/addons-merge/addons/ooh323c/src/memheap.c (with props)
team/group/addons-merge/addons/ooh323c/src/memheap.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooCalls.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooCalls.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooCapability.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooCapability.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooCmdChannel.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooCmdChannel.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooCommon.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooDateTime.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooDateTime.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooGkClient.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooGkClient.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooLogChan.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooLogChan.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooSocket.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooSocket.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooStackCmds.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooStackCmds.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooTimer.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooTimer.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooUtils.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooUtils.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooasn1.h (with props)
team/group/addons-merge/addons/ooh323c/src/oochannels.c (with props)
team/group/addons-merge/addons/ooh323c/src/oochannels.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooh245.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooh245.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooh323.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooh323.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooh323ep.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooh323ep.h (with props)
team/group/addons-merge/addons/ooh323c/src/oohdr.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooper.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooports.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooports.h (with props)
team/group/addons-merge/addons/ooh323c/src/ooq931.c (with props)
team/group/addons-merge/addons/ooh323c/src/ooq931.h (with props)
team/group/addons-merge/addons/ooh323c/src/ootrace.c (with props)
team/group/addons-merge/addons/ooh323c/src/ootrace.h (with props)
team/group/addons-merge/addons/ooh323c/src/ootypes.h (with props)
team/group/addons-merge/addons/ooh323c/src/perutil.c (with props)
team/group/addons-merge/addons/ooh323c/src/printHandler.c (with props)
team/group/addons-merge/addons/ooh323c/src/printHandler.h (with props)
team/group/addons-merge/addons/ooh323c/src/rtctype.c (with props)
team/group/addons-merge/addons/ooh323c/src/rtctype.h (with props)
team/group/addons-merge/addons/ooh323cDriver.c (with props)
team/group/addons-merge/addons/ooh323cDriver.h (with props)
team/group/addons-merge/configs/ooh323.conf.sample (with props)
Modified:
team/group/addons-merge/addons/Makefile
Modified: team/group/addons-merge/addons/Makefile
URL: http://svn.asterisk.org/svn-view/asterisk/team/group/addons-merge/addons/Makefile?view=diff&rev=204407&r1=204406&r2=204407
==============================================================================
--- team/group/addons-merge/addons/Makefile (original)
+++ team/group/addons-merge/addons/Makefile Tue Jun 30 11:05:56 2009
@@ -15,11 +15,29 @@
MENUSELECT_CATEGORY=Addons
MENUSELECT_DESCRIPTION=Add-ons (README-addons.txt)
+H323OBJS:=ooCmdChannel.o ooLogChan.o ooUtils.o ooGkClient.o context.o \
+ ooDateTime.o decode.o dlist.o encode.o errmgmt.o \
+ memheap.o ootrace.o oochannels.o ooh245.o ooports.o \
+ ooq931.o ooCapability.o ooSocket.o perutil.o eventHandler.o \
+ ooCalls.o ooStackCmds.o ooh323.o ooh323ep.o printHandler.o \
+ rtctype.o ooTimer.o h323/H235-SECURITY-MESSAGESDec.o \
+ h323/H235-SECURITY-MESSAGESEnc.o h323/H323-MESSAGES.o h323/H323-MESSAGESDec.o \
+ h323/H323-MESSAGESEnc.o h323/MULTIMEDIA-SYSTEM-CONTROL.o \
+ h323/MULTIMEDIA-SYSTEM-CONTROLDec.o h323/MULTIMEDIA-SYSTEM-CONTROLEnc.o
+
+H323CFLAGS:=-Iooh323c/src -Iooh323c/src/h323
+
all: _all
include $(ASTTOPDIR)/Makefile.moddir_rules
clean::
$(MAKE) -C mp3 clean
+ rm -f $(addprefix ooh323c/src/,$(H323OBJS))
$(if $(filter format_mp3,$(EMBEDDED_MODS)),modules.link,format_mp3.so): mp3/common.o mp3/dct64_i386.o mp3/decode_ntom.o mp3/layer3.o mp3/tabinit.o mp3/interface.o
+
+chan_ooh323.o: ASTCFLAGS+=$(H323CFLAGS)
+
+$(if $(filter chan_ooh323,$(EMBEDDED_MODS)),modules.link,chan_ooh323.so): ASTCFLAGS+=$(H323CFLAGS)
+$(if $(filter chan_ooh323,$(EMBEDDED_MODS)),modules.link,chan_ooh323.so): $(addprefix ooh323c/src/,$(H323OBJS)) chan_ooh323.o ooh323cDriver.o
Added: team/group/addons-merge/addons/chan_ooh323.c
URL: http://svn.asterisk.org/svn-view/asterisk/team/group/addons-merge/addons/chan_ooh323.c?view=auto&rev=204407
==============================================================================
--- team/group/addons-merge/addons/chan_ooh323.c (added)
+++ team/group/addons-merge/addons/chan_ooh323.c Tue Jun 30 11:05:56 2009
@@ -1,0 +1,3162 @@
+/*
+ * Copyright (C) 2004-2005 by Objective Systems, Inc.
+ *
+ * This software is furnished under an open source license and may be
+ * used and copied only in accordance with the terms of this license.
+ * The text of the license may generally be found in the root
+ * directory of this installation in the COPYING file. It
+ * can also be viewed online at the following URL:
+ *
+ * http://www.obj-sys.com/open/license.html
+ *
+ * Any redistributions of this file including modified versions must
+ * maintain this copyright notice.
+ *
+ *****************************************************************************/
+
+
+#include "chan_ooh323.h"
+
+/*** MODULEINFO
+ <defaultenabled>no</defaultenabled>
+ ***/
+
+/* Defaults */
+#define DEFAULT_CONTEXT "default"
+#define DEFAULT_H323ID "Asterisk PBX"
+#define DEFAULT_LOGFILE "/var/log/asterisk/h323_log"
+#define DEFAULT_H323ACCNT "ast_h323"
+
+/* Flags */
+#define H323_SILENCESUPPRESSION (1<<0)
+#define H323_GKROUTED (1<<1)
+#define H323_TUNNELING (1<<2)
+#define H323_FASTSTART (1<<3)
+#define H323_OUTGOING (1<<4)
+#define H323_ALREADYGONE (1<<5)
+#define H323_NEEDDESTROY (1<<6)
+#define H323_DISABLEGK (1<<7)
+
+/* Channel description */
+static const char type[] = "OOH323";
+static const char tdesc[] = "Objective Systems H323 Channel Driver";
+static const char config[] = "ooh323.conf";
+
+
+/* Channel Definition */
+static struct ast_channel *ooh323_request(const char *type, int format,
+ void *data, int *cause);
+static int ooh323_digit_begin(struct ast_channel *ast, char digit);
+static int ooh323_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
+static int ooh323_call(struct ast_channel *ast, char *dest, int timeout);
+static int ooh323_hangup(struct ast_channel *ast);
+static int ooh323_answer(struct ast_channel *ast);
+static struct ast_frame *ooh323_read(struct ast_channel *ast);
+static int ooh323_write(struct ast_channel *ast, struct ast_frame *f);
+static int ooh323_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen);
+static int ooh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
+
+static enum ast_rtp_get_result ooh323_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
+static enum ast_rtp_get_result ooh323_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp);
+static int ooh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp,
+ struct ast_rtp *vrtp, struct ast_rtp *trtp, int codecs, int nat_active);
+
+static void print_codec_to_cli(int fd, struct ast_codec_pref *pref);
+
+#if 0
+static void ast_ooh323c_exit();
+#endif
+
+static const struct ast_channel_tech ooh323_tech = {
+ .type = type,
+ .description = tdesc,
+ .capabilities = -1,
+ .requester = ooh323_request,
+ .send_digit_begin = ooh323_digit_begin,
+ .send_digit_end = ooh323_digit_end,
+ .call = ooh323_call,
+ .hangup = ooh323_hangup,
+ .answer = ooh323_answer,
+ .read = ooh323_read,
+ .write = ooh323_write,
+ .exception = ooh323_read,
+ .indicate = ooh323_indicate,
+ .fixup = ooh323_fixup,
+ .send_html = 0,
+ .bridge = ast_rtp_bridge,
+};
+
+static struct ast_rtp_protocol ooh323_rtp = {
+ .type = type,
+ .get_rtp_info = ooh323_get_rtp_peer,
+ .get_vrtp_info = ooh323_get_vrtp_peer,
+ .set_rtp_peer = ooh323_set_rtp_peer
+};
+
+/* H.323 channel private structure */
+static struct ooh323_pvt {
+ ast_mutex_t lock; /* Channel private lock */
+ struct ast_rtp *rtp;
+ struct ast_rtp *vrtp; /* Placeholder for now */
+ struct ast_channel *owner; /* Master Channel */
+ time_t lastrtptx;
+ time_t lastrtprx;
+ unsigned int flags;
+ unsigned int call_reference;
+ char *callToken;
+ char *username;
+ char *host;
+ char *callerid_name;
+ char *callerid_num;
+ char caller_h323id[AST_MAX_EXTENSION];
+ char caller_dialedDigits[AST_MAX_EXTENSION];
+ char caller_email[AST_MAX_EXTENSION];
+ char caller_url[256];
+ char callee_h323id[AST_MAX_EXTENSION];
+ char callee_dialedDigits[AST_MAX_EXTENSION];
+ char callee_email[AST_MAX_EXTENSION];
+ char callee_url[AST_MAX_EXTENSION];
+
+ int port;
+ int readformat; /* negotiated read format */
+ int writeformat; /* negotiated write format */
+ int capability;
+ struct ast_codec_pref prefs;
+ int dtmfmode;
+ char exten[AST_MAX_EXTENSION]; /* Requested extension */
+ char context[AST_MAX_EXTENSION]; /* Context where to start */
+ char accountcode[256]; /* Account code */
+ int nat;
+ int amaflags;
+ struct ast_dsp *vad;
+ struct ooh323_pvt *next; /* Next entity */
+} *iflist = NULL;
+
+/* Protect the channel/interface list (ooh323_pvt) */
+AST_MUTEX_DEFINE_STATIC(iflock);
+
+/* Profile of H.323 user registered with PBX*/
+struct ooh323_user{
+ ast_mutex_t lock;
+ char name[256];
+ char context[AST_MAX_EXTENSION];
+ int incominglimit;
+ unsigned inUse;
+ char accountcode[20];
+ int amaflags;
+ int capability;
+ struct ast_codec_pref prefs;
+ int dtmfmode;
+ int rtptimeout;
+ int mUseIP; /* Use IP address or H323-ID to search user */
+ char mIP[20];
+ struct ooh323_user *next;
+};
+
+/* Profile of valid asterisk peers */
+struct ooh323_peer{
+ ast_mutex_t lock;
+ char name[256];
+ unsigned outgoinglimit;
+ unsigned outUse;
+ int capability;
+ struct ast_codec_pref prefs;
+ char accountcode[20];
+ int amaflags;
+ int dtmfmode;
+ int mFriend; /* indicates defined as friend */
+ char ip[20];
+ int port;
+ char *h323id; /* H323-ID alias, which asterisk will register with gk to reach this peer*/
+ char *email; /* Email alias, which asterisk will register with gk to reach this peer*/
+ char *url; /* url alias, which asterisk will register with gk to reach this peer*/
+ char *e164; /* e164 alias, which asterisk will register with gk to reach this peer*/
+ int rtptimeout;
+ struct ooh323_peer *next;
+};
+
+
+/* List of H.323 users known to PBX */
+static struct ast_user_list {
+ struct ooh323_user *users;
+ ast_mutex_t lock;
+} userl;
+
+static struct ast_peer_list {
+ struct ooh323_peer *peers;
+ ast_mutex_t lock;
+} peerl;
+
+/* Mutex to protect H.323 reload process */
+static int h323_reloading = 0;
+AST_MUTEX_DEFINE_STATIC(h323_reload_lock);
+
+/* Mutex to protect usage counter */
+static int usecnt = 0;
+AST_MUTEX_DEFINE_STATIC(usecnt_lock);
+
+AST_MUTEX_DEFINE_STATIC(ooh323c_cmd_lock);
+
+/* stack callbacks */
+int onAlerting(ooCallData *call);
+int onNewCallCreated(ooCallData *call);
+int onCallEstablished(ooCallData *call);
+int onCallCleared(ooCallData *call);
+
+static char gLogFile[256] = DEFAULT_LOGFILE;
+static int gPort = 1720;
+static char gIP[20];
+static char gCallerID[AST_MAX_EXTENSION] = DEFAULT_H323ID;
+static struct ooAliases *gAliasList;
+static int gCapability = AST_FORMAT_ULAW;
+static struct ast_codec_pref gPrefs;
+static int gDTMFMode = H323_DTMF_RFC2833;
+static char gGatekeeper[100];
+static enum RasGatekeeperMode gRasGkMode = RasNoGatekeeper;
+
+static int gIsGateway = 0;
+static int gFastStart = 1;
+static int gTunneling = 1;
+static int gMediaWaitForConnect = 0;
+static int gTOS = 0;
+static int gRTPTimeout = 60;
+static char gAccountcode[80] = DEFAULT_H323ACCNT;
+static int gAMAFLAGS;
+static char gContext[AST_MAX_EXTENSION] = DEFAULT_CONTEXT;
+static int gIncomingLimit = 4;
+static int gOutgoingLimit = 4;
+OOBOOL gH323Debug = FALSE;
+
+static struct ooh323_config
+{
+ int mTCPPortStart;
+ int mTCPPortEnd;
+} ooconfig;
+
+/** Asterisk RTP stuff*/
+static struct sched_context *sched;
+static struct io_context *io;
+
+/* Protect the monitoring thread, so only one process can kill or start it,
+ and not when it's doing something critical. */
+AST_MUTEX_DEFINE_STATIC(monlock);
+
+
+/* This is the thread for the monitor which checks for input on the channels
+ which are not currently in use. */
+static pthread_t monitor_thread = AST_PTHREADT_NULL;
+
+
+static struct ast_channel *ooh323_new(struct ooh323_pvt *i, int state,
+ const char *host)
+{
+ struct ast_channel *ch = NULL;
+ int fmt;
+ if (gH323Debug)
+ ast_verbose("--- ooh323_new - %s\n", host);
+
+
+ /* Don't hold a h323 pvt lock while we allocate a channel */
+ ast_mutex_unlock(&i->lock);
+ ch = ast_channel_alloc(1, state, i->callerid_num, i->callerid_name, i->accountcode, i->exten, i->context, i->amaflags, "OOH323/%s-%08x", host, (unsigned int)(unsigned long) i);
+ ast_mutex_lock(&i->lock);
+
+ if (ch) {
+ ast_channel_lock(ch);
+ ch->tech = &ooh323_tech;
+
+ ch->nativeformats = i->capability;
+
+ fmt = ast_best_codec(ch->nativeformats);
+
+ ch->fds[0] = ast_rtp_fd(i->rtp);
+ ch->fds[1] = ast_rtcp_fd(i->rtp);
+
+ if (state == AST_STATE_RING)
+ ch->rings = 1;
+
+ ch->adsicpe = AST_ADSI_UNAVAILABLE;
+ ch->writeformat = fmt;
+ ch->rawwriteformat = fmt;
+ ch->readformat = fmt;
+ ch->rawreadformat = fmt;
+ ch->tech_pvt = i;
+ i->owner = ch;
+
+ /* Allocate dsp for in-band DTMF support */
+ if (i->dtmfmode & H323_DTMF_INBAND) {
+ i->vad = ast_dsp_new();
+ ast_dsp_set_features(i->vad, DSP_FEATURE_DIGIT_DETECT);
+ }
+
+ ast_mutex_lock(&usecnt_lock);
+ usecnt++;
+ ast_mutex_unlock(&usecnt_lock);
+
+ /* Notify the module monitors that use count for resource has changed*/
+ ast_update_use_count();
+
+ ast_copy_string(ch->context, i->context, sizeof(ch->context));
+ ast_copy_string(ch->exten, i->exten, sizeof(ch->exten));
+
+ ch->priority = 1;
+ if (i->callerid_name) {
+ ch->cid.cid_name = strdup(i->callerid_name);
+ }
+ if (i->callerid_num) {
+
+ ch->cid.cid_num = strdup(i->callerid_num);
+ }
+
+ if (!ast_test_flag(i, H323_OUTGOING)) {
+
+ if (!ast_strlen_zero(i->caller_h323id)) {
+ pbx_builtin_setvar_helper(ch, "_CALLER_H323ID", i->caller_h323id);
+
+ }
+ if (!ast_strlen_zero(i->caller_dialedDigits)) {
+ pbx_builtin_setvar_helper(ch, "_CALLER_H323DIALEDDIGITS",
+ i->caller_dialedDigits);
+ }
+ if (!ast_strlen_zero(i->caller_email)) {
+ pbx_builtin_setvar_helper(ch, "_CALLER_H323EMAIL",
+ i->caller_email);
+ }
+ if (!ast_strlen_zero(i->caller_url)) {
+ pbx_builtin_setvar_helper(ch, "_CALLER_H323URL", i->caller_url);
+ }
+ }
+
+ if (!ast_strlen_zero(i->accountcode))
+ ast_string_field_set(ch, accountcode, i->accountcode);
+
+ if (i->amaflags)
+ ch->amaflags = i->amaflags;
+
+ ast_setstate(ch, state);
+ if (state != AST_STATE_DOWN) {
+ if (ast_pbx_start(ch)) {
+ ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ch->name);
+ ast_channel_unlock(ch);
+ ast_hangup(ch);
+ ch = NULL;
+ }
+ }
+ } else
+ ast_log(LOG_WARNING, "Unable to allocate channel structure\n");
+
+
+ if (ch)
+ ast_channel_unlock(ch);
+
+ if (gH323Debug)
+ ast_verbose("+++ h323_new\n");
+
+ return ch;
+}
+
+
+
+static struct ooh323_pvt *ooh323_alloc(int callref, char *callToken)
+{
+ struct ooh323_pvt *pvt = NULL;
+ struct in_addr ipAddr;
+ if (gH323Debug)
+ ast_verbose("--- ooh323_alloc\n");
+
+ if (!(pvt = ast_calloc(1, sizeof(*pvt)))) {
+ ast_log(LOG_ERROR, "Couldn't allocate private ooh323 structure\n");
+ return NULL;
+ }
+
+ ast_mutex_init(&pvt->lock);
+ ast_mutex_lock(&pvt->lock);
+
+ if (!inet_aton(gIP, &ipAddr)) {
+ ast_log(LOG_ERROR, "Invalid OOH323 driver ip address\n");
+ ast_mutex_unlock(&pvt->lock);
+ ast_mutex_destroy(&pvt->lock);
+ free(pvt);
+ return NULL;
+ }
+
+ if (!(pvt->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, ipAddr))) {
+ ast_log(LOG_WARNING, "Unable to create RTP session: %s\n",
+ strerror(errno));
+ ast_mutex_unlock(&pvt->lock);
+ ast_mutex_destroy(&pvt->lock);
+ free(pvt);
+ return NULL;
+ }
+
+ ast_rtp_setqos(pvt->rtp, gTOS, 0, "ooh323");
+
+ pvt->call_reference = callref;
+ if (callToken)
+ pvt->callToken = strdup(callToken);
+
+ /* whether to use gk for this call */
+ if (gRasGkMode == RasNoGatekeeper)
+ OO_SETFLAG(pvt->flags, H323_DISABLEGK);
+
+ pvt->dtmfmode = gDTMFMode;
+ ast_copy_string(pvt->context, gContext, sizeof(pvt->context));
+ ast_copy_string(pvt->accountcode, gAccountcode, sizeof(pvt->accountcode));
+ pvt->amaflags = gAMAFLAGS;
+ pvt->capability = gCapability;
+ memcpy(&pvt->prefs, &gPrefs, sizeof(pvt->prefs));
+
+ ast_mutex_unlock(&pvt->lock);
+ /* Add to interface list */
+ ast_mutex_lock(&iflock);
+ pvt->next = iflist;
+ iflist = pvt;
+ ast_mutex_unlock(&iflock);
+
+ if (gH323Debug)
+ ast_verbose("+++ ooh323_alloc\n");
+
+ return pvt;
+}
+
+
+/*
+ Possible data values - peername, exten/peername, exten at ip
+ */
+static struct ast_channel *ooh323_request(const char *type, int format,
+ void *data, int *cause)
+{
+ struct ast_channel *chan = NULL;
+ struct ooh323_pvt *p = NULL;
+ struct ooh323_peer *peer = NULL;
+ char *dest = NULL;
+ char *ext = NULL;
+ char tmp[256];
+ char formats[512];
+ int oldformat;
+ int port = 0;
+
+ if (gH323Debug)
+ ast_verbose("--- ooh323_request - data %s format %s\n", (char*)data,
+ ast_getformatname_multiple(formats,512,format));
+
+ oldformat = format;
+ format &= AST_FORMAT_AUDIO_MASK;
+ if (!format) {
+ ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format "
+ "'%d'\n", format);
+ return NULL;
+ }
+
+ p = ooh323_alloc(0,0); /* Initial callRef is zero */
+
+ if (!p) {
+ ast_log(LOG_WARNING, "Unable to build pvt data for '%s'\n", (char*)data);
+ return NULL;
+ }
+ ast_mutex_lock(&p->lock);
+
+ /* This is an outgoing call, since ooh323_request is called */
+ ast_set_flag(p, H323_OUTGOING);
+
+ ast_copy_string(tmp, data, sizeof(data));
+
+ dest = strchr(tmp, '/');
+
+ if (dest) {
+ *dest = '\0';
+ dest++;
+ ext = tmp;
+ } else if ((dest = strchr(tmp, '@'))) {
+ *dest = '\0';
+ dest++;
+ ext = tmp;
+ } else {
+ dest = tmp;
+ ext = NULL;
+ }
+
+#if 0
+ if ((sport = strchr(dest, ':'))) {
+ *sport = '\0';
+ sport++;
+ port = atoi(sport);
+ }
+#endif
+
+ if (dest) {
+ peer = find_peer(dest, port);
+ } else{
+ ast_log(LOG_ERROR, "Destination format is not supported\n");
+ return NULL;
+ }
+
+ if (peer) {
+ p->username = strdup(peer->name);
+ p->host = strdup(peer->ip);
+ p->port = peer->port;
+ /* Disable gk as we are going to call a known peer*/
+ OO_SETFLAG(p->flags, H323_DISABLEGK);
+
+ if (ext)
+ ast_copy_string(p->exten, ext, sizeof(p->exten));
+
+ if (peer->capability & format) {
+ p->capability = peer->capability & format;
+ } else {
+ p->capability = peer->capability;
+ }
+ memcpy(&p->prefs, &peer->prefs, sizeof(struct ast_codec_pref));
+ p->dtmfmode = peer->dtmfmode;
+ ast_copy_string(p->accountcode, peer->accountcode, sizeof(p->accountcode));
+ p->amaflags = peer->amaflags;
+ } else {
+ p->dtmfmode = gDTMFMode;
+ p->capability = gCapability;
+
+ memcpy(&p->prefs, &gPrefs, sizeof(struct ast_codec_pref));
+ p->username = strdup(dest);
+
+ p->host = strdup(dest);
+ if (port > 0) {
+ p->port = port;
+ }
+ if (ext) {
+ ast_copy_string(p->exten, ext, sizeof(p->exten));
+ }
+ }
+
+
+ chan = ooh323_new(p, AST_STATE_DOWN, p->username);
+
+ ast_mutex_unlock(&p->lock);
+
+ if (!chan) {
+ ast_mutex_lock(&iflock);
+ ooh323_destroy(p);
+ ast_mutex_unlock(&iflock);
+ }
+
+ restart_monitor();
+ if (gH323Debug)
+ ast_verbose("+++ ooh323_request\n");
+
+ return chan;
+
+}
+
+
+static struct ooh323_pvt* find_call(ooCallData *call)
+{
+ struct ooh323_pvt *p;
+
+ if (gH323Debug)
+ ast_verbose("--- find_call\n");
+
+ ast_mutex_lock(&iflock);
+
+ for (p = iflist; p; p = p->next) {
+ if (p->callToken && !strcmp(p->callToken, call->callToken)) {
+ break;
+ }
+ }
+ ast_mutex_unlock(&iflock);
+
+ if (gH323Debug)
+ ast_verbose("+++ find_call\n");
+
+ return p;
+}
+
+struct ooh323_user *find_user(const char * name, const char* ip)
+{
+ struct ooh323_user *user;
+
+ if (gH323Debug)
+ ast_verbose("--- find_user\n");
+
+ ast_mutex_lock(&userl.lock);
+ for (user = userl.users; user; user = user->next) {
+ if (ip && user->mUseIP && !strcmp(user->mIP, ip)) {
+ break;
+ }
+ if (name && !strcmp(user->name, name)) {
+ break;
+ }
+ }
+ ast_mutex_unlock(&userl.lock);
+
+ if (gH323Debug)
+ ast_verbose("+++ find_user\n");
+
+ return user;
+}
+
+struct ooh323_peer *find_friend(const char *name, int port)
+{
+ struct ooh323_peer *peer;
+
+ if (gH323Debug)
+ ast_verbose("--- find_friend \"%s\"\n", name);
+
+
+ ast_mutex_lock(&peerl.lock);
+ for (peer = peerl.peers; peer; peer = peer->next) {
+ if (gH323Debug) {
+ ast_verbose(" comparing with \"%s\"\n", peer->ip);
+ }
+ if (!strcmp(peer->ip, name)) {
+ if (port <= 0 || (port > 0 && peer->port == port)) {
+ break;
+ }
+ }
+ }
+ ast_mutex_unlock(&peerl.lock);
+
+ if (gH323Debug) {
+ if (peer) {
+ ast_verbose(" found matching friend\n");
+ }
+ ast_verbose("+++ find_friend \"%s\"\n", name);
+ }
+
+ return peer;
+}
+
+
+struct ooh323_peer *find_peer(const char * name, int port)
+{
+ struct ooh323_peer *peer;
+
+ if (gH323Debug)
+ ast_verbose("--- find_peer \"%s\"\n", name);
+
+ ast_mutex_lock(&peerl.lock);
+ for (peer = peerl.peers; peer; peer = peer->next) {
+ if (gH323Debug) {
+ ast_verbose(" comparing with \"%s\"\n", peer->ip);
+ }
+ if (!strcasecmp(peer->name, name))
+ break;
+ if (peer->h323id && !strcasecmp(peer->h323id, name))
+ break;
+ if (peer->e164 && !strcasecmp(peer->e164, name))
+ break;
+ /*
+ if (!strcmp(peer->ip, name)) {
+ if (port > 0 && peer->port == port) { break; }
+ else if (port <= 0) { break; }
+ }
+ */
+ }
+ ast_mutex_unlock(&peerl.lock);
+
+ if (gH323Debug) {
+ if (peer) {
+ ast_verbose(" found matching peer\n");
+ }
+ ast_verbose("+++ find_peer \"%s\"\n", name);
+ }
+
+ return peer;
+}
+
+static int ooh323_digit_begin(struct ast_channel *chan, char digit)
+{
+ char dtmf[2];
+ struct ooh323_pvt *p = (struct ooh323_pvt *) chan->tech_pvt;
+
+ if (gH323Debug)
+ ast_verbose("--- ooh323_digit_begin\n");
+
+ if (!p) {
+ ast_log(LOG_ERROR, "No private structure for call\n");
+ return -1;
+ }
+ ast_mutex_lock(&p->lock);
+ if (p->rtp && (p->dtmfmode & H323_DTMF_RFC2833)) {
+ ast_rtp_senddigit_begin(p->rtp, digit);
+ } else if (((p->dtmfmode & H323_DTMF_Q931) ||
+ (p->dtmfmode & H323_DTMF_H245ALPHANUMERIC) ||
+ (p->dtmfmode & H323_DTMF_H245SIGNAL))) {
+ dtmf[0] = digit;
+ dtmf[1] = '\0';
+ ast_mutex_lock(&ooh323c_cmd_lock);
+ ooSendDTMFDigit(p->callToken, dtmf);
+ ast_mutex_unlock(&ooh323c_cmd_lock);
+ }
+ ast_mutex_unlock(&p->lock);
+ if (gH323Debug)
+ ast_verbose("+++ ooh323_digit_begin\n");
+
+ return 0;
+}
+
+static int ooh323_digit_end(struct ast_channel *chan, char digit, unsigned int duration)
+{
+ struct ooh323_pvt *p = (struct ooh323_pvt *) chan->tech_pvt;
+
+ if (gH323Debug)
+ ast_verbose("--- ooh323_digit_end\n");
+
+ if (!p) {
+ ast_log(LOG_ERROR, "No private structure for call\n");
+ return -1;
+ }
+ ast_mutex_lock(&p->lock);
+ if (p->rtp && (p->dtmfmode & H323_DTMF_RFC2833))
+ ast_rtp_senddigit_end(p->rtp, digit);
+
+ ast_mutex_unlock(&p->lock);
+ if (gH323Debug)
+ ast_verbose("+++ ooh323_digit_end\n");
+
+ return 0;
+}
+
+
+static int ooh323_call(struct ast_channel *ast, char *dest, int timeout)
+{
+ struct ooh323_pvt *p = ast->tech_pvt;
+ char destination[256];
+ int res = 0;
+ const char *val = NULL;
+ ooCallOptions opts = {
+ .fastStart = TRUE,
+ .tunneling = TRUE,
+ .disableGk = TRUE,
+ .callMode = OO_CALLMODE_AUDIOCALL
+ };
+ if (gH323Debug)
+ ast_verbose("--- ooh323_call- %s\n", dest);
+
+ if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) {
+ ast_log(LOG_WARNING, "ooh323_call called on %s, neither down nor "
+ "reserved\n", ast->name);
+ return -1;
+ }
+ ast_mutex_lock(&p->lock);
+ ast_set_flag(p, H323_OUTGOING);
+ if (ast->cid.cid_num) {
+ if (p->callerid_num) {
+ free(p->callerid_num);
+ }
+ p->callerid_num = strdup(ast->cid.cid_num);
+ }
+
+ if (ast->cid.cid_name) {
+ if (p->callerid_name) {
+ free(p->callerid_name);
+ }
+ p->callerid_name = strdup(ast->cid.cid_name);
+ }
+ else{
+ ast->cid.cid_name = strdup(gCallerID);
+ if (p->callerid_name) {
+ free(p->callerid_name);
+ }
+ p->callerid_name = strdup(ast->cid.cid_name);
+ }
+
+ /* Retrieve vars */
+
+
+ if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323ID"))) {
+ ast_copy_string(p->caller_h323id, val, sizeof(p->caller_h323id));
+ }
+
+ if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323DIALEDDIGITS"))) {
+ ast_copy_string(p->caller_dialedDigits, val, sizeof(p->caller_dialedDigits));
+ if (!p->callerid_num) {
+ p->callerid_num = strdup(val);
+ }
+ }
+
+ if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323EMAIL"))) {
+ ast_copy_string(p->caller_email, val, sizeof(p->caller_email));
+ }
+
+ if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323URL"))) {
+ ast_copy_string(p->caller_url, val, sizeof(p->caller_url));
+ }
+
+
+ if (!(p->callToken = (char*)malloc(AST_MAX_EXTENSION))) {
+ ast_mutex_unlock(&p->lock);
+ ast_log(LOG_ERROR, "Failed to allocate memory for callToken\n");
+ return -1; /* TODO: need to clean/hangup?? */
+ }
+
+ if (p->host && p->port != 0)
+ snprintf(destination, sizeof(destination), "%s:%d", p->host, p->port);
+ else if (p->host)
+ snprintf(destination, sizeof(destination), "%s", p->host);
+ else
+ ast_copy_string(destination, dest, sizeof(destination));
+
+ ast_mutex_lock(&ooh323c_cmd_lock);
+ if (OO_TESTFLAG(p->flags, H323_DISABLEGK))
+ res = ooMakeCall(destination, p->callToken, AST_MAX_EXTENSION, &opts);
+ else
+ res = ooMakeCall(destination, p->callToken, AST_MAX_EXTENSION, NULL);
+ ast_mutex_unlock(&ooh323c_cmd_lock);
+
+ ast_mutex_unlock(&p->lock);
+ if (res != OO_OK) {
+ ast_log(LOG_ERROR, "Failed to make call\n");
+ return -1; /* TODO: cleanup */
+ }
+ if (gH323Debug)
+ ast_verbose("+++ ooh323_call\n");
+
+ return 0;
+}
+
+static int ooh323_hangup(struct ast_channel *ast)
+{
+ struct ooh323_pvt *p = ast->tech_pvt;
+
+ if (gH323Debug)
+ ast_verbose("--- ooh323_hangup\n");
+
+ if (p) {
+ ast_mutex_lock(&p->lock);
+
+ if (gH323Debug)
+ ast_verbose(" hanging %s\n", p->username);
+ ast->tech_pvt = NULL;
+ if (!ast_test_flag(p, H323_ALREADYGONE)) {
+ ast_mutex_lock(&ooh323c_cmd_lock);
+ ooHangCall(p->callToken,
+ ooh323_convert_hangupcause_asteriskToH323(p->owner->hangupcause));
+ ast_mutex_unlock(&ooh323c_cmd_lock);
+ ast_set_flag(p, H323_ALREADYGONE);
+ /* ast_mutex_unlock(&p->lock); */
+ } else {
+ ast_set_flag(p, H323_NEEDDESTROY);
+ }
+ /* detach channel here */
+ if (p->owner) {
+ p->owner->tech_pvt = NULL;
+ p->owner = NULL;
+ }
+
+ ast_mutex_unlock(&p->lock);
+ ast_mutex_lock(&usecnt_lock);
+ usecnt--;
+ ast_mutex_unlock(&usecnt_lock);
+
+ /* Notify the module monitors that use count for resource has changed */
+ ast_update_use_count();
+
+ } else {
+ ast_log(LOG_ERROR, "No call to hangup\n" );
+ return -1;
+ }
+
+ if (gH323Debug)
+ ast_verbose("+++ ooh323_hangup\n");
+
+ return 0;
+}
+
+static int ooh323_answer(struct ast_channel *ast)
+{
+ struct ooh323_pvt *p = ast->tech_pvt;
+
+ if (gH323Debug)
+ ast_verbose("--- ooh323_answer\n");
+
+ ast_mutex_lock(&p->lock);
+ if (ast->_state != AST_STATE_UP) {
+ ast_channel_lock(ast);
+ ast_setstate(ast, AST_STATE_UP);
+ ast_debug(1, "ooh323_answer(%s)\n", ast->name);
+ ast_channel_unlock(ast);
+ ast_mutex_lock(&ooh323c_cmd_lock);
+ ooAnswerCall(p->callToken);
+ ast_mutex_unlock(&ooh323c_cmd_lock);
+ }
+ ast_mutex_unlock(&p->lock);
+
+ if (gH323Debug)
+ ast_verbose("+++ ooh323_answer\n");
+
+ return 0;
+}
+
+static struct ast_frame *ooh323_read(struct ast_channel *ast)
+{
+ struct ast_frame *fr;
+ static struct ast_frame null_frame = { AST_FRAME_NULL, };
+ struct ooh323_pvt *p = ast->tech_pvt;
+
+ ast_mutex_lock(&p->lock);
+ if (p->rtp)
+ fr = ooh323_rtp_read(ast, p);
+ else
+ fr = &null_frame;
+ /* time(&p->lastrtprx); */
+ ast_mutex_unlock(&p->lock);
+ return fr;
+}
+
+static int ooh323_write(struct ast_channel *ast, struct ast_frame *f)
+{
+ struct ooh323_pvt *p = ast->tech_pvt;
+ int res = 0;
+
+ if (f->frametype == AST_FRAME_VOICE) {
+ if (!(f->subclass & ast->nativeformats)) {
+ ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native "
+ "formats is %d (read/write = %d/%d)\n",
+ f->subclass, ast->nativeformats, ast->readformat,
+ ast->writeformat);
+ return 0;
+ }
+ if (p) {
+ ast_mutex_lock(&p->lock);
+ if (p->rtp)
+ res = ast_rtp_write(p->rtp, f);
+ ast_mutex_unlock(&p->lock);
+ }
+ } else if (f->frametype == AST_FRAME_IMAGE) {
+ return 0;
+ } else {
+ ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n",
+ f->frametype);
+ return 0;
+ }
+
+ return res;
+}
+
+static int ooh323_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen)
+{
+
+ struct ooh323_pvt *p = (struct ooh323_pvt *) ast->tech_pvt;
+ char *callToken = (char *)NULL;
+
+ ast_mutex_lock(&p->lock);
+ callToken = (p->callToken ? strdup(p->callToken) : NULL);
+ ast_mutex_unlock(&p->lock);
+
+ if (!callToken) {
+ if (gH323Debug)
+ ast_verbose(" ooh323_indicate - No callToken\n");
+ return -1;
+ }
+
+ if (gH323Debug)
+ ast_verbose("----- ooh323_indicate %d on call %s\n", condition, callToken);
+
+
+ switch (condition) {
+ case AST_CONTROL_CONGESTION:
+ if (!ast_test_flag(p, H323_ALREADYGONE)) {
+ ast_mutex_lock(&ooh323c_cmd_lock);
+ ooHangCall(callToken, OO_REASON_LOCAL_CONGESTED);
+ ast_mutex_unlock(&ooh323c_cmd_lock);
+ ast_set_flag(p, H323_ALREADYGONE);
+ }
+ break;
+ case AST_CONTROL_BUSY:
+ if (!ast_test_flag(p, H323_ALREADYGONE)) {
+ ast_mutex_lock(&ooh323c_cmd_lock);
+ ooHangCall(callToken, OO_REASON_LOCAL_BUSY);
+ ast_mutex_unlock(&ooh323c_cmd_lock);
+ ast_set_flag(p, H323_ALREADYGONE);
+ }
+ break;
+ case AST_CONTROL_HOLD:
+ ast_moh_start(ast, data, NULL);
+ break;
+ case AST_CONTROL_UNHOLD:
+ ast_moh_stop(ast);
+ break;
+ case AST_CONTROL_PROCEEDING:
+ case AST_CONTROL_RINGING:
+ case AST_CONTROL_PROGRESS:
+ case -1:
+ break;
+ default:
+ ast_log(LOG_WARNING, "Don't know how to indicate condition %d on %s\n",
+ condition, callToken);
+ }
+
+ if (gH323Debug)
+ ast_verbose("++++ ooh323_indicate %d on %s\n", condition, callToken);
+
+
+ return -1;
+}
+
+static int ooh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan)
+{
+ struct ooh323_pvt *p = newchan->tech_pvt;
+
+ if (gH323Debug)
+ ast_verbose("--- ooh323c ooh323_fixup\n");
+
+ ast_mutex_lock(&p->lock);
+ if (p->owner != oldchan) {
+ ast_log(LOG_WARNING, "Old channel wasn't %p but was %p\n", oldchan, p->owner);
+ ast_mutex_unlock(&p->lock);
+ return -1;
+ }
+
+ if (p->owner == oldchan) {
+ p->owner = newchan;
+ } else {
+ p->owner = oldchan;
+ }
+
+ ast_mutex_unlock(&p->lock);
+
+ if (gH323Debug)
+ ast_verbose("+++ ooh323c ooh323_fixup \n");
+
+ return 0;
+}
+
+
+void ooh323_set_write_format(ooCallData *call, int fmt)
+{
+#if 0
+ struct ooh323_pvt *p = NULL;
+ char formats[512];
+#ifdef print_debug
+ printf("--- ooh323_update_writeformat %s\n",
+ ast_getformatname_multiple(formats,512, fmt));
+#endif
+
+ p = find_call(call);
+ if (!p) {
+ ast_log(LOG_ERROR, "No matching call found for %s\n", call->callToken);
+ return;
+ }
+
+ ast_mutex_lock(&p->lock);
+
+ p->writeformat = fmt;
+ ast_mutex_unlock(&p->lock);
+
+ if (p->owner) {
+ printf("Writeformat before update %s\n",
+ ast_getformatname_multiple(formats,512, p->owner->writeformat));
+ ast_set_write_format(p->owner, fmt);
+ }
+ else
+ ast_log(LOG_ERROR, "No owner found\n");
+
+
+#ifdef print_debug
+ printf("+++ ooh323_update_writeformat\n");
+#endif
+#endif
+}
+
+
+void ooh323_set_read_format(ooCallData *call, int fmt)
+{
+#if 0
+ struct ooh323_pvt *p = NULL;
+ char formats[512];
+#ifdef print_debug
+ printf("--- ooh323_update_readformat %s\n",
+ ast_getformatname_multiple(formats,512, fmt));
+#endif
+
+ p = find_call(call);
+ if (!p) {
+ ast_log(LOG_ERROR, "No matching call found for %s\n", call->callToken);
+ return;
+ }
+
+ ast_mutex_lock(&p->lock);
+ p->readformat = fmt;
+ ast_mutex_unlock(&p->lock);
+ ast_set_read_format(p->owner, fmt);
+
+#ifdef print_debug
+ printf("+++ ooh323_update_readformat\n");
+#endif
+#endif
+}
+
+int onAlerting(ooCallData *call)
+{
+ struct ooh323_pvt *p = NULL;
+ struct ast_channel *c = NULL;
+
+ if (gH323Debug)
+ ast_verbose("--- onAlerting %s\n", call->callToken);
+
+ if (!(p = find_call(call))) {
+ ast_log(LOG_ERROR, "No matching call found\n");
+ return -1;
+ }
+ ast_mutex_lock(&p->lock);
+ if (!ast_test_flag(p, H323_OUTGOING)) {
+ if (!(c = ooh323_new(p, AST_STATE_RING, p->username))) {
+ ast_mutex_unlock(&p->lock);
+ ast_log(LOG_ERROR, "Could not create ast_channel\n");
+ return -1;
+ }
+ ast_mutex_unlock(&p->lock);
+ } else {
+ if (!p->owner) {
+ ast_mutex_unlock(&p->lock);
+ ast_log(LOG_ERROR, "Channel has no owner\n");
+ return 0;
+ }
+ c = p->owner;
+ ast_mutex_unlock(&p->lock);
+ ast_channel_lock(c);
+ ast_setstate(c, AST_STATE_RINGING);
+ ast_channel_unlock(c);
+ ast_queue_control(c, AST_CONTROL_RINGING);
+ }
+
+ if (gH323Debug)
+ ast_verbose("+++ onAlerting %s\n", call->callToken);
+
+ return OO_OK;
+}
+
+/**
+ * Callback for sending digits from H.323 up to asterisk
+ *
+ */
+int ooh323_onReceivedDigit(OOH323CallData *call, const char *digit)
+{
+ struct ooh323_pvt *p = NULL;
+ struct ast_frame f;
+ int res;
+
+ ast_debug(1, "Received Digit: %c\n", digit[0]);
+ p = find_call(call);
+ if (!p) {
+ ast_log(LOG_ERROR, "Failed to find a matching call.\n");
+ return -1;
+ }
+ if (!p->owner) {
+ ast_log(LOG_ERROR, "Channel has no owner\n");
+ return -1;
+ }
+ ast_mutex_lock(&p->lock);
+ memset(&f, 0, sizeof(f));
+ f.frametype = AST_FRAME_DTMF;
+ f.subclass = digit[0];
+ f.datalen = 0;
+ f.samples = 800;
+ f.offset = 0;
+ f.data.ptr = NULL;
+ f.mallocd = 0;
+ f.src = "SEND_DIGIT";
+ ast_mutex_unlock(&p->lock);
+ res = ast_queue_frame(p->owner, &f);
+ return res;
+}
+
+int ooh323_onReceivedSetup(ooCallData *call, Q931Message *pmsg)
+{
+ struct ooh323_pvt *p = NULL;
+ struct ooh323_user *user = NULL;
+ ooAliases *alias = NULL;
+ char *at = NULL;
+ char number [OO_MAX_NUMBER_LENGTH];
+
+ if (gH323Debug)
+ ast_verbose("--- ooh323_onReceivedSetup %s\n", call->callToken);
+
+
+ if (!(p = ooh323_alloc(call->callReference, call->callToken))) {
+ ast_log(LOG_ERROR, "Failed to create a new call.\n");
+ return -1;
+ }
+ ast_mutex_lock(&p->lock);
+ ast_clear_flag(p, H323_OUTGOING);
+
+
+ if (call->remoteDisplayName) {
+ p->callerid_name = strdup(call->remoteDisplayName);
+ }
+
+ if (ooCallGetCallingPartyNumber(call, number, OO_MAX_NUMBER_LENGTH) == OO_OK) {
+ p->callerid_num = strdup(number);
+ }
+
+ if (call->remoteAliases) {
+ for (alias = call->remoteAliases; alias; alias = alias->next) {
+ if (alias->type == T_H225AliasAddress_h323_ID) {
+ if (!p->callerid_name) {
+ p->callerid_name = strdup(alias->value);
+ }
+ ast_copy_string(p->caller_h323id, alias->value, sizeof(p->caller_h323id));
+ } else if (alias->type == T_H225AliasAddress_dialedDigits) {
+ if (!p->callerid_num) {
+ p->callerid_num = strdup(alias->value);
+ }
+ ast_copy_string(p->caller_dialedDigits, alias->value,
+ sizeof(p->caller_dialedDigits));
+ } else if (alias->type == T_H225AliasAddress_email_ID) {
+ ast_copy_string(p->caller_email, alias->value, sizeof(p->caller_email));
+ } else if (alias->type == T_H225AliasAddress_url_ID) {
+ ast_copy_string(p->caller_url, alias->value, sizeof(p->caller_url));
+ }
+ }
+ }
+
+ number[0] = '\0';
+ if (ooCallGetCalledPartyNumber(call, number, OO_MAX_NUMBER_LENGTH) == OO_OK) {
+ ast_copy_string(p->exten, number, sizeof(p->exten));
+ } else {
+ update_our_aliases(call, p);
[... 178131 lines stripped ...]
More information about the svn-commits
mailing list