[asterisk-commits] russell: branch group/addons-merge r204407 - in /team/group/addons-merge: add...

SVN commits to the Asterisk project asterisk-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 asterisk-commits mailing list