Sapian
/
asterisk
mirror of http://gerrit.asterisk.org/asterisk
3
0
Fork 0
Code Issues Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c28fb2bf19'
${ noResults }
asterisk/addons/chan_ooh323.c

3167 lines
80 KiB
Raw Blame History

/*
* 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[] = "chan_ooh323.conf";
static const char config_old[] = "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@ip
*/
static struct ast_channel *ooh323_request(const char *type, int format, const struct ast_channel *requestor,
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);
if (!ast_strlen_zero(p->callee_dialedDigits)) {
ast_copy_string(p->exten, p->callee_dialedDigits, sizeof(p->exten));
} else if (!ast_strlen_zero(p->callee_h323id)) {
ast_copy_string(p->exten, p->callee_h323id, sizeof(p->exten));
} else if (!ast_strlen_zero(p->callee_email)) {
ast_copy_string(p->exten, p->callee_email, sizeof(p->exten));
if ((at = strchr(p->exten, '@'))) {
*at = '\0';
}
}
}
/* if no extension found, set to default 's' */
if (ast_strlen_zero(p->exten)) {
ast_copy_string(p->exten, "s", sizeof(p->exten));
}
if (!p->callerid_name) {
p->callerid_name = strdup(call->remoteIP);
}
if (p->callerid_name) {
if ((user = find_user(p->callerid_name, call->remoteIP))) {
ast_mutex_lock(&user->lock);
p->username = strdup(user->name);
ast_copy_string(p->context, user->context, sizeof(p->context));
ast_copy_string(p->accountcode, user->accountcode, sizeof(p->accountcode));
p->amaflags = user->amaflags;
p->capability = user->capability;
memcpy(&p->prefs, &user->prefs, sizeof(struct ast_codec_pref));
p->dtmfmode = user->dtmfmode;
/* Since, call is coming from a pbx user, no need to use gk */
OO_SETFLAG(p->flags, H323_DISABLEGK);
OO_SETFLAG(call->flags, OO_M_DISABLEGK);
ast_mutex_unlock(&user->lock);
}
}
ooh323c_set_capability_for_call(call, &p->prefs, p->capability, p->dtmfmode);
configure_local_rtp(p, call);
ast_mutex_unlock(&p->lock);
if (gH323Debug)
ast_verbose("+++ ooh323_onReceivedSetup - Determined context %s, "
"extension %s\n", p->context, p->exten);
return OO_OK;
}
int onNewCallCreated(ooCallData *call)
{
struct ooh323_pvt *p = NULL;
int i = 0;
if (gH323Debug)
ast_verbose("--- onNewCallCreated %s\n", call->callToken);
if (!strcmp(call->callType, "outgoing")) {
p = find_call(call);
if (!p) {
ast_log(LOG_ERROR, "No matching call found for outgoing call\n");
return -1;
}
ast_mutex_lock(&p->lock);
if (p->callerid_name) {
ooCallSetCallerId(call, p->callerid_name);
}
if (p->callerid_num) {
i = 0;
while (*(p->callerid_num + i) != '\0') {
if (!isdigit(*(p->callerid_num + i))) {
break;
}
i++;
}
if (*(p->callerid_num + i) == '\0') {
ooCallSetCallingPartyNumber(call, p->callerid_num);
} else {
if (!p->callerid_name) {
ooCallSetCallerId(call, p->callerid_num);
}
}
}
if (!ast_strlen_zero(p->caller_h323id))
ooCallAddAliasH323ID(call, p->caller_h323id);
if (!ast_strlen_zero(p->caller_dialedDigits)) {
if (gH323Debug) {
ast_verbose("Setting dialed digits %s\n", p->caller_dialedDigits);
}
ooCallAddAliasDialedDigits(call, p->caller_dialedDigits);
} else if (p->callerid_num) {
if (ooIsDailedDigit(p->callerid_num)) {
if (gH323Debug) {
ast_verbose("setting callid number %s\n", p->callerid_num);
}
ooCallAddAliasDialedDigits(call, p->callerid_num);
} else if (ast_strlen_zero(p->caller_h323id)) {
ooCallAddAliasH323ID(call, p->callerid_num);
}
}
if (!ast_strlen_zero(p->exten)) {
if (ooIsDailedDigit(p->exten)) {
ooCallSetCalledPartyNumber(call, p->exten);
ooCallAddRemoteAliasDialedDigits(call, p->exten);
} else {
ooCallAddRemoteAliasH323ID(call, p->exten);
}
}
if (gH323Debug) {
char prefsBuf[256];
ast_codec_pref_string(&p->prefs, prefsBuf, sizeof(prefsBuf));
ast_verbose(" Outgoing call %s(%s) - Codec prefs - %s\n",
p->username?p->username:"NULL", call->callToken, prefsBuf);
}
ooh323c_set_capability_for_call(call, &p->prefs, p->capability, p->dtmfmode);
configure_local_rtp(p, call);
ast_mutex_unlock(&p->lock);
}
if (gH323Debug)
ast_verbose("+++ onNewCallCreated %s\n", call->callToken);
return OO_OK;
}
int onCallEstablished(ooCallData *call)
{
struct ooh323_pvt *p = NULL;
if (gH323Debug)
ast_verbose("--- onCallEstablished %s\n", call->callToken);
if (!(p = find_call(call))) {
ast_log(LOG_ERROR, "Failed to find a matching call.\n");
return -1;
}
ast_mutex_lock(&p->lock);
if (!p->owner) {
ast_mutex_unlock(&p->lock);
ast_log(LOG_ERROR, "Channel has no owner\n");
return -1;
}
while (ast_channel_trylock(p->owner)) {
ast_debug(1,"Failed to grab lock, trying again\n");
ast_mutex_unlock(&p->lock);
usleep(1);
ast_mutex_lock(&p->lock);
}
if (p->owner->_state != AST_STATE_UP) {
ast_setstate(p->owner, AST_STATE_UP);
}
ast_channel_unlock(p->owner);
if (ast_test_flag(p, H323_OUTGOING)) {
struct ast_channel* c = p->owner;
ast_mutex_unlock(&p->lock);
ast_queue_control(c, AST_CONTROL_ANSWER);
} else {
ast_mutex_unlock(&p->lock);
}
if (gH323Debug)
ast_verbose("+++ onCallEstablished %s\n", call->callToken);
return OO_OK;
}
int onCallCleared(ooCallData *call)
{
struct ooh323_pvt *p = NULL;
int ownerLock = 0;
if (gH323Debug)
ast_verbose("--- onCallCleared %s \n", call->callToken);
p = find_call(call);
if (!p) {
return 0;
}
ast_mutex_lock(&p->lock);
while (p->owner) {
if (ast_channel_trylock(p->owner)) {
ooTrace(OOTRCLVLINFO, "Failed to grab lock, trying again\n");
ast_debug(1,"Failed to grab lock, trying again\n");
ast_mutex_unlock(&p->lock);
usleep(1);
ast_mutex_lock(&p->lock);
} else {
ownerLock = 1;
break;
}
}
if (ownerLock) {
if (!ast_test_flag(p, H323_ALREADYGONE)) {
/* NOTE: Channel is not detached yet */
ast_set_flag(p, H323_ALREADYGONE);
p->owner->hangupcause =
ooh323_convert_hangupcause_h323ToAsterisk(call->callEndReason);
p->owner->_softhangup |= AST_SOFTHANGUP_DEV;
ast_channel_unlock(p->owner);
ast_queue_hangup(p->owner);
ast_mutex_unlock(&p->lock);
return OO_OK;
}
ast_channel_unlock(p->owner);
}
ast_set_flag(p, H323_NEEDDESTROY);
ast_mutex_unlock(&p->lock);
if (gH323Debug)
ast_verbose("+++ onCallCleared\n");
return OO_OK;
}
#if 0
static void ooh323_delete_user(struct ooh323_user *user)
{
struct ooh323_user *prev = NULL, *cur = NULL;
if (gH323Debug)
ast_verbose("--- ooh323_delete_user\n");
if (user) {
cur = userl.users;
ast_mutex_lock(&userl.lock);
while (cur) {
if (cur == user) break;
prev = cur;
cur = cur->next;
}
if (cur) {
if (prev)
prev->next = cur->next;
else
userl.users = cur->next;
}
ast_mutex_unlock(&userl.lock);
free(user);
}
if (gH323Debug)
ast_verbose("+++ ooh323_delete_user\n");
}
#endif
void ooh323_delete_peer(struct ooh323_peer *peer)
{
struct ooh323_peer *prev = NULL, *cur = NULL;
if (gH323Debug)
ast_verbose("--- ooh323_delete_peer\n");
if (peer) {
ast_mutex_lock(&peerl.lock);
for (cur = peerl.peers; cur; prev = cur, cur = cur->next) {
if (cur == peer) {
break;
}
}
if (cur) {
if (prev) {
prev->next = cur->next;
} else {
peerl.peers = cur->next;
}
}
ast_mutex_unlock(&peerl.lock);
if (peer->h323id)
free(peer->h323id);
if (peer->email)
free(peer->email);
if (peer->url)
free(peer->url);
if (peer->e164)
free(peer->e164);
free(peer);
}
if (gH323Debug)
ast_verbose("+++ ooh323_delete_peer\n");
}
static struct ooh323_user *build_user(const char *name, struct ast_variable *v)
{
struct ooh323_user *user = NULL;
if (gH323Debug)
ast_verbose("--- build_user\n");
user = ast_calloc(1, sizeof(*user));
if (user) {
ast_mutex_init(&user->lock);
ast_copy_string(user->name, name, sizeof(user->name));
user->capability = gCapability;
memcpy(&user->prefs, &gPrefs, sizeof(user->prefs));
user->rtptimeout = gRTPTimeout;
user->dtmfmode = gDTMFMode;
/* set default context */
ast_copy_string(user->context, gContext, sizeof(user->context));
ast_copy_string(user->accountcode, gAccountcode, sizeof(user->accountcode));
user->amaflags = gAMAFLAGS;
while (v) {
if (!strcasecmp(v->name, "context")) {
ast_copy_string(user->context, v->value, sizeof(user->context));
} else if (!strcasecmp(v->name, "incominglimit")) {
user->incominglimit = atoi(v->value);
if (user->incominglimit < 0)
user->incominglimit = 0;
} else if (!strcasecmp(v->name, "accountcode")) {
ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode));
} else if (!strcasecmp(v->name, "rtptimeout")) {
user->rtptimeout = atoi(v->value);
if (user->rtptimeout < 0)
user->rtptimeout = gRTPTimeout;
} else if (!strcasecmp(v->name, "disallow")) {
ast_parse_allow_disallow(&user->prefs, &user->capability,
v->value, 0);
} else if (!strcasecmp(v->name, "allow")) {
const char* tcodecs = v->value;
if (!strcasecmp(v->value, "all")) {
tcodecs = "ulaw,alaw,g729,g723,gsm";
}
ast_parse_allow_disallow(&user->prefs, &user->capability,
tcodecs, 1);
} else if (!strcasecmp(v->name, "amaflags")) {
user->amaflags = ast_cdr_amaflags2int(v->value);
} else if (!strcasecmp(v->name, "ip")) {
ast_copy_string(user->mIP, v->value, sizeof(user->mIP));
user->mUseIP = 1;
} else if (!strcasecmp(v->name, "dtmfmode")) {
if (!strcasecmp(v->value, "rfc2833"))
user->dtmfmode = H323_DTMF_RFC2833;
else if (!strcasecmp(v->value, "q931keypad"))
user->dtmfmode = H323_DTMF_Q931;
else if (!strcasecmp(v->value, "h245alphanumeric"))
user->dtmfmode = H323_DTMF_H245ALPHANUMERIC;
else if (!strcasecmp(v->value, "h245signal"))
user->dtmfmode = H323_DTMF_H245SIGNAL;
}
v = v->next;
}
}
if (gH323Debug)
ast_verbose("+++ build_user\n");
return user;
}
static struct ooh323_peer *build_peer(const char *name, struct ast_variable *v, int friend_type)
{
struct ooh323_peer *peer = NULL;
if (gH323Debug)
ast_verbose("--- build_peer\n");
peer = ast_calloc(1, sizeof(*peer));
if (peer) {
memset(peer, 0, sizeof(struct ooh323_peer));
ast_mutex_init(&peer->lock);
ast_copy_string(peer->name, name, sizeof(peer->name));
peer->capability = gCapability;
memcpy(&peer->prefs, &gPrefs, sizeof(struct ast_codec_pref));
peer->rtptimeout = gRTPTimeout;
ast_copy_string(peer->accountcode, gAccountcode, sizeof(peer->accountcode));
peer->amaflags = gAMAFLAGS;
peer->dtmfmode = gDTMFMode;
if (0 == friend_type) {
peer->mFriend = 1;
}
while (v) {
if (!strcasecmp(v->name, "h323id")) {
if (!(peer->h323id = ast_strdup(v->value))) {
ast_log(LOG_ERROR, "Could not allocate memory for h323id of "
"peer %s\n", name);
ooh323_delete_peer(peer);
return NULL;
}
} else if (!strcasecmp(v->name, "e164")) {
if (!(peer->e164 = ast_strdup(v->value))) {
ast_log(LOG_ERROR, "Could not allocate memory for e164 of "
"peer %s\n", name);
ooh323_delete_peer(peer);
return NULL;
}
} else if (!strcasecmp(v->name, "email")) {
if (!(peer->email = ast_strdup(v->value))) {
ast_log(LOG_ERROR, "Could not allocate memory for email of "
"peer %s\n", name);
ooh323_delete_peer(peer);
return NULL;
}
} else if (!strcasecmp(v->name, "url")) {
if (!(peer->url = ast_strdup(v->value))) {
ast_log(LOG_ERROR, "Could not allocate memory for h323id of "
"peer %s\n", name);
ooh323_delete_peer(peer);
return NULL;
}
} else if (!strcasecmp(v->name, "port")) {
peer->port = atoi(v->value);
} else if (!strcasecmp(v->name, "ip")) {
ast_copy_string(peer->ip, v->value, sizeof(peer->ip));
} else if (!strcasecmp(v->name, "outgoinglimit")) {
if ((peer->outgoinglimit = atoi(v->value)) < 0) {
peer->outgoinglimit = 0;
}
} else if (!strcasecmp(v->name, "accountcode")) {
ast_copy_string(peer->accountcode, v->value, sizeof(peer->accountcode));
} else if (!strcasecmp(v->name, "rtptimeout")) {
if ((peer->rtptimeout = atoi(v->value)) < 0) {
peer->rtptimeout = gRTPTimeout;
}
} else if (!strcasecmp(v->name, "disallow")) {
ast_parse_allow_disallow(&peer->prefs, &peer->capability,
v->value, 0);
} else if (!strcasecmp(v->name, "allow")) {
const char* tcodecs = v->value;
if (!strcasecmp(v->value, "all")) {
tcodecs = "ulaw,alaw,g729,g723,gsm";
}
ast_parse_allow_disallow(&peer->prefs, &peer->capability,
tcodecs, 1);
} else if (!strcasecmp(v->name, "amaflags")) {
peer->amaflags = ast_cdr_amaflags2int(v->value);
} else if (!strcasecmp(v->name, "dtmfmode")) {
if (!strcasecmp(v->value, "rfc2833"))
peer->dtmfmode = H323_DTMF_RFC2833;
else if (!strcasecmp(v->value, "q931keypad"))
peer->dtmfmode = H323_DTMF_Q931;
else if (!strcasecmp(v->value, "h245alphanumeric"))
peer->dtmfmode = H323_DTMF_H245ALPHANUMERIC;
else if (!strcasecmp(v->value, "h245signal"))
peer->dtmfmode = H323_DTMF_H245SIGNAL;
}
v = v->next;
}
}
if (gH323Debug)
ast_verbose("+++ build_peer\n");
return peer;
}
static int ooh323_do_reload(void)
{
if (gH323Debug) {
ast_verbose("--- ooh323_do_reload\n");
}
reload_config(1);
if (gH323Debug) {
ast_verbose("+++ ooh323_do_reload\n");
}
return 0;
}
#if 0
/*--- h323_reload: Force reload of module from cli ---*/
static int ooh323_reload(int fd, int argc, char *argv[])
{
if (gH323Debug)
ast_verbose("--- ooh323_reload\n");
ast_mutex_lock(&h323_reload_lock);
if (h323_reloading) {
ast_verbose("Previous OOH323 reload not yet done\n");
}
else {
h323_reloading = 1;
}
ast_mutex_unlock(&h323_reload_lock);
restart_monitor();
if (gH323Debug)
ast_verbose("+++ ooh323_reload\n");
return 0;
}
#endif
#if 0
static int reload(void *mod)
{
return ooh323_reload(0, 0, NULL);
}
#endif
int reload_config(int reload)
{
int format;
struct ooAliases *pNewAlias = NULL;
struct ast_config *cfg;
struct ast_variable *v;
struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
struct ooh323_user *user = NULL;
struct ooh323_peer *peer = NULL;
char *cat;
const char *utype;
if (gH323Debug)
ast_verbose("--- reload_config\n");
cfg = ast_config_load(config, config_flags);
if (!cfg) {
cfg = ast_config_load(config_old, config_flags);
}
/* We *must* have a config file otherwise stop immediately */
if (!cfg) {
ast_log(LOG_NOTICE, "Unable to load config %s, OOH323 disabled\n", config);
return 1;
} else if (cfg == CONFIG_STATUS_FILEUNCHANGED)
return RESULT_SUCCESS;
if (reload) {
delete_users();
delete_peers();
}
/* Inintialize everything to default */
strcpy(gLogFile, DEFAULT_LOGFILE);
gPort = 1720;
gIP[0] = '\0';
strcpy(gCallerID, DEFAULT_H323ID);
gCapability = AST_FORMAT_ULAW;
memset(&gPrefs, 0, sizeof(struct ast_codec_pref));
gDTMFMode = H323_DTMF_RFC2833;
gRasGkMode = RasNoGatekeeper;
gGatekeeper[0] = '\0';
gRTPTimeout = 60;
strcpy(gAccountcode, DEFAULT_H323ACCNT);
gFastStart = 1;
gTunneling = 1;
gTOS = 0;
strcpy(gContext, DEFAULT_CONTEXT);
gAliasList = NULL;
gMediaWaitForConnect = 0;
ooconfig.mTCPPortStart = 12030;
ooconfig.mTCPPortEnd = 12230;
v = ast_variable_browse(cfg, "general");
while (v) {
if (!strcasecmp(v->name, "port")) {
gPort = (int)strtol(v->value, NULL, 10);
} else if (!strcasecmp(v->name, "bindaddr")) {
ast_copy_string(gIP, v->value, sizeof(gIP));
} else if (!strcasecmp(v->name, "h225portrange")) {
char* endlimit = 0;
char temp[256];
ast_copy_string(temp, v->value, sizeof(temp));
endlimit = strchr(temp, ',');
if (endlimit) {
*endlimit = '\0';
endlimit++;
ooconfig.mTCPPortStart = atoi(temp);
ooconfig.mTCPPortEnd = atoi(endlimit);
if (ooH323EpSetTCPPortRange(ooconfig.mTCPPortStart,
ooconfig.mTCPPortEnd) == OO_FAILED) {
ast_log(LOG_ERROR, "h225portrange: Failed to set range\n");
}
} else {
ast_log(LOG_ERROR, "h225portrange: Invalid format, separate port range with \",\"\n");
}
} else if (!strcasecmp(v->name, "gateway")) {
gIsGateway = ast_true(v->value);
} else if (!strcasecmp(v->name, "faststart")) {
gFastStart = ast_true(v->value);
if (gFastStart)
ooH323EpEnableFastStart();
else
ooH323EpDisableFastStart();
} else if (!strcasecmp(v->name, "mediawaitforconnect")) {
gMediaWaitForConnect = ast_true(v->value);
if (gMediaWaitForConnect)
ooH323EpEnableMediaWaitForConnect();
else
ooH323EpDisableMediaWaitForConnect();
} else if (!strcasecmp(v->name, "h245tunneling")) {
gTunneling = ast_true(v->value);
if (gTunneling)
ooH323EpEnableH245Tunneling();
else
ooH323EpDisableH245Tunneling();
} else if (!strcasecmp(v->name, "h323id")) {
pNewAlias = malloc(sizeof(*pNewAlias));
if (!pNewAlias) {
ast_log(LOG_ERROR, "Failed to allocate memory for h323id alias\n");
return 1;
}
pNewAlias->type = T_H225AliasAddress_h323_ID;
pNewAlias->value = strdup(v->value);
pNewAlias->next = gAliasList;
gAliasList = pNewAlias;
pNewAlias = NULL;
} else if (!strcasecmp(v->name, "e164")) {
pNewAlias = malloc(sizeof(*pNewAlias));
if (!pNewAlias) {
ast_log(LOG_ERROR, "Failed to allocate memory for e164 alias\n");
return 1;
}
pNewAlias->type = T_H225AliasAddress_dialedDigits;
pNewAlias->value = strdup(v->value);
pNewAlias->next = gAliasList;
gAliasList = pNewAlias;
pNewAlias = NULL;
} else if (!strcasecmp(v->name, "email")) {
pNewAlias = malloc(sizeof(*pNewAlias));
if (!pNewAlias) {
ast_log(LOG_ERROR, "Failed to allocate memory for email alias\n");
return 1;
}
pNewAlias->type = T_H225AliasAddress_email_ID;
pNewAlias->value = strdup(v->value);
pNewAlias->next = gAliasList;
gAliasList = pNewAlias;
pNewAlias = NULL;
} else if (!strcasecmp(v->name, "callerid")) {
ast_copy_string(gCallerID, v->value, sizeof(gCallerID));
} else if (!strcasecmp(v->name, "incominglimit")) {
gIncomingLimit = atoi(v->value);
} else if (!strcasecmp(v->name, "outgoinglimit")) {
gOutgoingLimit = atoi(v->value);
} else if (!strcasecmp(v->name, "gatekeeper")) {
if (!strcasecmp(v->value, "DISABLE")) {
gRasGkMode = RasNoGatekeeper;
} else if (!strcasecmp(v->value, "DISCOVER")) {
gRasGkMode = RasDiscoverGatekeeper;
} else {
gRasGkMode = RasUseSpecificGatekeeper;
ast_copy_string(gGatekeeper, v->value, sizeof(gGatekeeper));
}
} else if (!strcasecmp(v->name, "logfile")) {
ast_copy_string(gLogFile, v->value, sizeof(gLogFile));
} else if (!strcasecmp(v->name, "context")) {
ast_copy_string(gContext, v->value, sizeof(gContext));
ast_verb(3, " == Setting default context to %s\n", gContext);
} else if (!strcasecmp(v->name, "rtptimeout")) {
gRTPTimeout = atoi(v->value);
if (gRTPTimeout <= 0)
gRTPTimeout = 60;
} else if (!strcasecmp(v->name, "tos")) {
if (sscanf(v->value, "%30i", &format) == 1)
gTOS = format & 0xff;
else if (!strcasecmp(v->value, "lowdelay"))
gTOS = IPTOS_LOWDELAY;
else if (!strcasecmp(v->value, "throughput"))
gTOS = IPTOS_THROUGHPUT;
else if (!strcasecmp(v->value, "reliability"))
gTOS = IPTOS_RELIABILITY;
else if (!strcasecmp(v->value, "mincost"))
gTOS = IPTOS_MINCOST;
else if (!strcasecmp(v->value, "none"))
gTOS = 0;
else
ast_log(LOG_WARNING, "Invalid tos value at line %d, should be "
"'lowdelay', 'throughput', 'reliability', "
"'mincost', or 'none'\n", v->lineno);
} else if (!strcasecmp(v->name, "amaflags")) {
gAMAFLAGS = ast_cdr_amaflags2int(v->value);
} else if (!strcasecmp(v->name, "accountcode")) {
ast_copy_string(gAccountcode, v->value, sizeof(gAccountcode)-1);
} else if (!strcasecmp(v->name, "disallow")) {
ast_parse_allow_disallow(&gPrefs, &gCapability, v->value, 0);
} else if (!strcasecmp(v->name, "allow")) {
const char* tcodecs = v->value;
if (!strcasecmp(v->value, "all")) {
tcodecs = "ulaw,alaw,g729,g723,gsm";
}
ast_parse_allow_disallow(&gPrefs, &gCapability, tcodecs, 1);
} else if (!strcasecmp(v->name, "dtmfmode")) {
if (!strcasecmp(v->value, "inband"))
gDTMFMode = H323_DTMF_INBAND;
else if (!strcasecmp(v->value, "rfc2833"))
gDTMFMode = H323_DTMF_RFC2833;
else if (!strcasecmp(v->value, "q931keypad"))
gDTMFMode = H323_DTMF_Q931;
else if (!strcasecmp(v->value, "h245alphanumeric"))
gDTMFMode = H323_DTMF_H245ALPHANUMERIC;
else if (!strcasecmp(v->value, "h245signal"))
gDTMFMode = H323_DTMF_H245SIGNAL;
else {
ast_log(LOG_WARNING, "Unknown dtmf mode '%s', using rfc2833\n", v->value);
gDTMFMode = H323_DTMF_RFC2833;
}
}
v = v->next;
}
for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) {
if (strcasecmp(cat, "general")) {
int friend_type = 0;
utype = ast_variable_retrieve(cfg, cat, "type");
if (utype) {
friend_type = strcasecmp(utype, "friend");
if (!strcmp(utype, "user") || 0 == friend_type) {
user = build_user(cat, ast_variable_browse(cfg, cat));
if (user) {
ast_mutex_lock(&userl.lock);
user->next = userl.users;
userl.users = user;
ast_mutex_unlock(&userl.lock);
} else {
ast_log(LOG_WARNING, "Failed to build user %s\n", cat);
}
}
if (!strcasecmp(utype, "peer") || 0 == friend_type) {
peer = build_peer(cat, ast_variable_browse(cfg, cat), friend_type);
if (peer) {
ast_mutex_lock(&peerl.lock);
peer->next = peerl.peers;
peerl.peers = peer;
ast_mutex_unlock(&peerl.lock);
} else {
ast_log(LOG_WARNING, "Failed to build peer %s\n", cat);
}
}
}
}
}
ast_config_destroy(cfg);
/* Determine ip address if necessary */
if (ast_strlen_zero(gIP)) {
ooGetLocalIPAddress(gIP);
if (!strcmp(gIP, "127.0.0.1")) {
ast_log(LOG_NOTICE, "Failed to determine local ip address. Please "
"specify it in ooh323.conf. OOH323 Disabled\n");
return 1;
}
}
if (gH323Debug)
ast_verbose("+++ reload_config\n");
return 0;
}
static char *handle_cli_ooh323_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
char ip_port[30];
struct ooh323_peer *prev = NULL, *peer = NULL;
switch (cmd) {
case CLI_INIT:
e->command = "ooh323 show peer";
e->usage =
"Usage: ooh323 show peer <name>\n"
" List details of specific OOH323 peer.\n";
return NULL;
case CLI_GENERATE:
return NULL;
}
if (a->argc != 4)
return CLI_SHOWUSAGE;
ast_mutex_lock(&peerl.lock);
peer = peerl.peers;
while (peer) {
ast_mutex_lock(&peer->lock);
if (!strcmp(peer->name, a->argv[3]))
break;
else {
prev = peer;
peer = peer->next;
ast_mutex_unlock(&prev->lock);
}
}
if (peer) {
snprintf(ip_port, sizeof(ip_port), "%s:%d", peer->ip, peer->port);
ast_cli(a->fd, "%-15.15s%s\n", "Name: ", peer->name);
ast_cli(a->fd, "%-15.15s%s", "Format Prefs: ", "(");
print_codec_to_cli(a->fd, &peer->prefs);
ast_cli(a->fd, ")\n");
ast_cli(a->fd, "%-15.15s", "DTMF Mode: ");
if (peer->dtmfmode & H323_DTMF_RFC2833)
ast_cli(a->fd, "%s\n", "rfc2833");
else if (peer->dtmfmode & H323_DTMF_Q931)
ast_cli(a->fd, "%s\n", "q931keypad");
else if (peer->dtmfmode & H323_DTMF_H245ALPHANUMERIC)
ast_cli(a->fd, "%s\n", "h245alphanumeric");
else if (peer->dtmfmode & H323_DTMF_H245SIGNAL)
ast_cli(a->fd, "%s\n", "h245signal");
else
ast_cli(a->fd, "%s\n", "unknown");
ast_cli(a->fd, "%-15.15s%s\n", "AccountCode: ", peer->accountcode);
ast_cli(a->fd, "%-15.15s%s\n", "AMA flags: ",
ast_cdr_flags2str(peer->amaflags));
ast_cli(a->fd, "%-15.15s%s\n", "Ip:Port: ", ip_port);
ast_cli(a->fd, "%-15.15s%d\n", "OutgoingLimit: ", peer->outgoinglimit);
ast_cli(a->fd, "%-15.15s%d\n", "rtptimeout: ", peer->rtptimeout);
ast_mutex_unlock(&peer->lock);
} else {
ast_cli(a->fd, "Peer %s not found\n", a->argv[3]);
ast_cli(a->fd, "\n");
}
ast_mutex_unlock(&peerl.lock);
return CLI_SUCCESS;
}
static char *handle_cli_ooh323_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
char ip_port[30];
char formats[512];
struct ooh323_peer *prev = NULL, *peer = NULL;
#define FORMAT "%-15.15s %-15.15s %-23.23s %-s\n"
switch (cmd) {
case CLI_INIT:
e->command = "ooh323 show peers";
e->usage =
"Usage: ooh323 show peers\n"
" Lists all known OOH323 peers.\n";
return NULL;
case CLI_GENERATE:
return NULL;
}
if (a->argc != 3)
return CLI_SHOWUSAGE;
ast_cli(a->fd, FORMAT, "Name", "Accountcode", "ip:port", "Formats");
ast_mutex_lock(&peerl.lock);
peer = peerl.peers;
while (peer) {
ast_mutex_lock(&peer->lock);
snprintf(ip_port, sizeof(ip_port), "%s:%d", peer->ip, peer->port);
ast_cli(a->fd, FORMAT, peer->name,
peer->accountcode,
ip_port,
ast_getformatname_multiple(formats, sizeof(formats), peer->capability));
prev = peer;
peer = peer->next;
ast_mutex_unlock(&prev->lock);
}
ast_mutex_unlock(&peerl.lock);
#undef FORMAT
return CLI_SUCCESS;
}
/*! \brief Print codec list from preference to CLI/manager */
static void print_codec_to_cli(int fd, struct ast_codec_pref *pref)
{
int x, codec;
for (x = 0; x < 32; x++) {
codec = ast_codec_pref_index(pref, x);
if (!codec)
break;
ast_cli(fd, "%s", ast_getformatname(codec));
ast_cli(fd, ":%d", pref->framing[x]);
if (x < 31 && ast_codec_pref_index(pref, x + 1))
ast_cli(fd, ",");
}
if (!x)
ast_cli(fd, "none");
}
static char *handle_cli_ooh323_show_user(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
struct ooh323_user *prev = NULL, *user = NULL;
switch (cmd) {
case CLI_INIT:
e->command = "ooh323 show user";
e->usage =
"Usage: ooh323 show user <name>\n"
" List details of specific OOH323 user.\n";
return NULL;
case CLI_GENERATE:
return NULL;
}
if (a->argc != 4)
return CLI_SHOWUSAGE;
ast_mutex_lock(&userl.lock);
user = userl.users;
while (user) {
ast_mutex_lock(&user->lock);
if (!strcmp(user->name, a->argv[3]))
break;
else {
prev = user;
user = user->next;
ast_mutex_unlock(&prev->lock);
}
}
if (user) {
ast_cli(a->fd, "%-15.15s%s\n", "Name: ", user->name);
ast_cli(a->fd, "%-15.15s%s", "Format Prefs: ", "(");
print_codec_to_cli(a->fd, &user->prefs);
ast_cli(a->fd, ")\n");
ast_cli(a->fd, "%-15.15s", "DTMF Mode: ");
if (user->dtmfmode & H323_DTMF_RFC2833)
ast_cli(a->fd, "%s\n", "rfc2833");
else if (user->dtmfmode & H323_DTMF_Q931)
ast_cli(a->fd, "%s\n", "q931keypad");
else if (user->dtmfmode & H323_DTMF_H245ALPHANUMERIC)
ast_cli(a->fd, "%s\n", "h245alphanumeric");
else if (user->dtmfmode & H323_DTMF_H245SIGNAL)
ast_cli(a->fd, "%s\n", "h245signal");
else
ast_cli(a->fd, "%s\n", "unknown");
ast_cli(a->fd, "%-15.15s%s\n", "AccountCode: ", user->accountcode);
ast_cli(a->fd, "%-15.15s%s\n", "AMA flags: ", ast_cdr_flags2str(user->amaflags));
ast_cli(a->fd, "%-15.15s%s\n", "Context: ", user->context);
ast_cli(a->fd, "%-15.15s%d\n", "IncomingLimit: ", user->incominglimit);
ast_cli(a->fd, "%-15.15s%d\n", "rtptimeout: ", user->rtptimeout);
ast_mutex_unlock(&user->lock);
} else {
ast_cli(a->fd, "User %s not found\n", a->argv[3]);
ast_cli(a->fd, "\n");
}
ast_mutex_unlock(&userl.lock);
return CLI_SUCCESS;
}
static char *handle_cli_ooh323_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
char formats[512];
struct ooh323_user *prev = NULL, *user = NULL;
#define FORMAT1 "%-15.15s %-15.15s %-15.15s %-s\n"
switch (cmd) {
case CLI_INIT:
e->command = "ooh323 show users";
e->usage =
"Usage: ooh323 show users \n"
" Lists all known OOH323 users.\n";
return NULL;
case CLI_GENERATE:
return NULL;
}
if (a->argc != 3)
return CLI_SHOWUSAGE;
ast_cli(a->fd, FORMAT1, "Username", "Accountcode", "Context", "Formats");
ast_mutex_lock(&userl.lock);
user = userl.users;
while (user) {
ast_mutex_lock(&user->lock);
ast_cli(a->fd, FORMAT1, user->name,
user->accountcode, user->context,
ast_getformatname_multiple(formats, 512, user->capability));
prev = user;
user = user->next;
ast_mutex_unlock(&prev->lock);
}
ast_mutex_unlock(&userl.lock);
#undef FORMAT1
return CLI_SUCCESS;
}
static char *handle_cli_ooh323_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
switch (cmd) {
case CLI_INIT:
e->command = "ooh323 set debug [off]";
e->usage =
"Usage: ooh323 set debug [off]\n"
" Enables/Disables debugging of OOH323 channel driver\n";
return NULL;
case CLI_GENERATE:
return NULL;
}
if (a->argc < 3 || a->argc > 4)
return CLI_SHOWUSAGE;
if (a->argc == 4 && strcasecmp(a->argv[3], "off"))
return CLI_SHOWUSAGE;
gH323Debug = (a->argc == 4) ? FALSE : TRUE;
ast_cli(a->fd, "OOH323 Debugging %s\n", gH323Debug ? "Enabled" : "Disabled");
return CLI_SUCCESS;
}
#if 0
static int ooh323_show_channels(int fd, int argc, char *argv[])
{
return RESULT_SUCCESS;
}
#endif
static char *handle_cli_ooh323_show_config(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
{
char value[512];
ooAliases *pAlias = NULL, *pAliasNext = NULL;;
switch (cmd) {
case CLI_INIT:
e->command = "ooh323 show config";
e->usage =
"Usage: ooh323 show config\n"
" Shows global configuration of H.323 channel driver\n";
return NULL;
case CLI_GENERATE:
return NULL;
}
if (a->argc != 3)
return CLI_SHOWUSAGE;
snprintf(value, sizeof(value), "%s:%d", gIP, gPort);
ast_cli(a->fd, "\nObjective Open H.323 Channel Driver's Config:\n");
ast_cli(a->fd, "%-20s%s\n", "IP:Port: ", value);
ast_cli(a->fd, "%-20s%s\n", "FastStart", gFastStart?"yes":"no");
ast_cli(a->fd, "%-20s%s\n", "Tunneling", gTunneling?"yes":"no");
ast_cli(a->fd, "%-20s%s\n", "CallerId", gCallerID);
ast_cli(a->fd, "%-20s%s\n", "MediaWaitForConnect", gMediaWaitForConnect ? "yes" : "no");
#if 0
{
extern OOH323EndPoint gH323ep;
ast_cli(a->fd, "%-20s%s\n", "FASTSTART",
(OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART) != 0) ? "yes" : "no");
ast_cli(a->fd, "%-20s%s\n", "TUNNELING",
(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING) != 0) ? "yes" : "no");
ast_cli(a->fd, "%-20s%s\n", "MEDIAWAITFORCONN",
(OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN) != 0) ? "yes" : "no");
}
#endif
if (gRasGkMode == RasNoGatekeeper)
snprintf(value, sizeof(value), "%s", "No Gatekeeper");
else if (gRasGkMode == RasDiscoverGatekeeper)
snprintf(value, sizeof(value), "%s", "Discover");
else
snprintf(value, sizeof(value), "%s", gGatekeeper);
ast_cli(a->fd, "%-20s%s\n", "Gatekeeper:", value);
ast_cli(a->fd, "%-20s%s\n", "H.323 LogFile:", gLogFile);
ast_cli(a->fd, "%-20s%s\n", "Context:", gContext);
ast_cli(a->fd, "%-20s%s\n", "Capability:", ast_getformatname_multiple(value, sizeof(value), gCapability));
ast_cli(a->fd, "%-20s", "DTMF Mode: ");
if (gDTMFMode & H323_DTMF_RFC2833)
ast_cli(a->fd, "%s\n", "rfc2833");
else if (gDTMFMode & H323_DTMF_Q931)
ast_cli(a->fd, "%s\n", "q931keypad");
else if (gDTMFMode & H323_DTMF_H245ALPHANUMERIC)
ast_cli(a->fd, "%s\n", "h245alphanumeric");
else if (gDTMFMode & H323_DTMF_H245SIGNAL)
ast_cli(a->fd, "%s\n", "h245signal");
else
ast_cli(a->fd, "%s\n", "unknown");
ast_cli(a->fd, "%-20s%s\n", "AccountCode: ", gAccountcode);
ast_cli(a->fd, "%-20s%s\n", "AMA flags: ", ast_cdr_flags2str(gAMAFLAGS));
pAlias = gAliasList;
if (pAlias)
ast_cli(a->fd, "%-20s\n", "Aliases: ");
while (pAlias) {
pAliasNext = pAlias->next;
if (pAliasNext) {
ast_cli(a->fd, "\t%-30s\t%-30s\n", pAlias->value, pAliasNext->value);
pAlias = pAliasNext->next;
} else {
ast_cli(a->fd, "\t%-30s\n", pAlias->value);
pAlias = pAlias->next;
}
}
return CLI_SUCCESS;
}
static struct ast_cli_entry cli_ooh323[] = {
AST_CLI_DEFINE(handle_cli_ooh323_set_debug, "Enable/Disable OOH323 debugging"),
AST_CLI_DEFINE(handle_cli_ooh323_show_config, "Show details on global configuration of H.323 channel driver"),
AST_CLI_DEFINE(handle_cli_ooh323_show_peer, "Show details on specific OOH323 peer"),
AST_CLI_DEFINE(handle_cli_ooh323_show_peers, "Show defined OOH323 peers"),
AST_CLI_DEFINE(handle_cli_ooh323_show_user, "Show details on specific OOH323 user"),
AST_CLI_DEFINE(handle_cli_ooh323_show_users, "Show defined OOH323 users"),
};
static int load_module(void)
{
int res;
struct ooAliases * pNewAlias = NULL;
struct ooh323_peer *peer = NULL;
OOH225MsgCallbacks h225Callbacks = {0, 0, 0, 0};
OOH323CALLBACKS h323Callbacks = {
.onNewCallCreated = onNewCallCreated,
.onAlerting = onAlerting,
.onIncomingCall = NULL,
.onOutgoingCall = NULL,
.onCallEstablished = onCallEstablished,
.onCallCleared = onCallCleared,
.openLogicalChannels = NULL,
.onReceivedDTMF = &ooh323_onReceivedDigit
};
ast_log(LOG_NOTICE,
"---------------------------------------------------------------------------------\n"
"--- ******* IMPORTANT NOTE ***********\n"
"---\n"
"--- This module is currently unsupported. Use it at your own risk.\n"
"---\n"
"---------------------------------------------------------------------------------\n");
h225Callbacks.onReceivedSetup = &ooh323_onReceivedSetup;
userl.users = NULL;
ast_mutex_init(&userl.lock);
peerl.peers = NULL;
ast_mutex_init(&peerl.lock);
#if 0
ast_register_atexit(&ast_ooh323c_exit);
#endif
if (!(sched = sched_context_create())) {
ast_log(LOG_WARNING, "Unable to create schedule context\n");
}
if (!(io = io_context_create())) {
ast_log(LOG_WARNING, "Unable to create I/O context\n");
}
if (!(res = reload_config(0))) {
/* Make sure we can register our OOH323 channel type */
if (ast_channel_register(&ooh323_tech)) {
ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
return 0;
}
ast_rtp_proto_register(&ooh323_rtp);
ast_cli_register_multiple(cli_ooh323, sizeof(cli_ooh323) / sizeof(struct ast_cli_entry));
/* fire up the H.323 Endpoint */
if (OO_OK != ooH323EpInitialize(OO_CALLMODE_AUDIOCALL, gLogFile)) {
ast_log(LOG_ERROR, "Failed to initialize OOH323 endpoint-OOH323 Disabled\n");
return 1;
}
if (gIsGateway)
ooH323EpSetAsGateway();
ooH323EpDisableAutoAnswer();
ooH323EpSetH225MsgCallbacks(h225Callbacks);
ooH323EpSetTraceLevel(OOTRCLVLDBGC);
ooH323EpSetLocalAddress(gIP, gPort);
ooH323EpSetCallerID(gCallerID);
/* Set aliases if any */
for (pNewAlias = gAliasList; pNewAlias; pNewAlias = pNewAlias->next) {
switch (pNewAlias->type) {
case T_H225AliasAddress_h323_ID:
ooH323EpAddAliasH323ID(pNewAlias->value);
break;
case T_H225AliasAddress_dialedDigits:
ooH323EpAddAliasDialedDigits(pNewAlias->value);
break;
case T_H225AliasAddress_email_ID:
ooH323EpAddAliasEmailID(pNewAlias->value);
break;
}
}
ast_mutex_lock(&peerl.lock);
peer = peerl.peers;
while (peer) {
if (peer->h323id)
ooH323EpAddAliasH323ID(peer->h323id);
if (peer->email)
ooH323EpAddAliasEmailID(peer->email);
if (peer->e164)
ooH323EpAddAliasDialedDigits(peer->e164);
if (peer->url)
ooH323EpAddAliasURLID(peer->url);
peer = peer->next;
}
ast_mutex_unlock(&peerl.lock);
if (gMediaWaitForConnect)
ooH323EpEnableMediaWaitForConnect();
else
ooH323EpDisableMediaWaitForConnect();
/* Fast start and tunneling options */
if (gFastStart)
ooH323EpEnableFastStart();
else
ooH323EpDisableFastStart();
if (!gTunneling)
ooH323EpDisableH245Tunneling();
/* Gatekeeper */
if (gRasGkMode == RasUseSpecificGatekeeper)
ooGkClientInit(gRasGkMode, gGatekeeper, 0);
else if (gRasGkMode == RasDiscoverGatekeeper)
ooGkClientInit(gRasGkMode, 0, 0);
/* Register callbacks */
ooH323EpSetH323Callbacks(h323Callbacks);
/* Add endpoint capabilities */
if (ooh323c_set_capability(&gPrefs, gCapability, gDTMFMode) < 0) {
ast_log(LOG_ERROR, "Capabilities failure for OOH323. OOH323 Disabled.\n");
return 1;
}
/* Create H.323 listener */
if (ooCreateH323Listener() != OO_OK) {
ast_log(LOG_ERROR, "OOH323 Listener Creation failure. OOH323 DISABLED\n");
ooH323EpDestroy();
return 1;
}
if (ooh323c_start_stack_thread() < 0) {
ast_log(LOG_ERROR, "Failed to start OOH323 stack thread. OOH323 DISABLED\n");
ooH323EpDestroy();
return 1;
}
/* And start the monitor for the first time */
restart_monitor();
}
return 0;
}
static void *do_monitor(void *data)
{
int res;
int reloading;
struct ooh323_pvt *h323 = NULL;
time_t t;
for (;;) {
struct ooh323_pvt *h323_next;
/* Check for a reload request */
ast_mutex_lock(&h323_reload_lock);
reloading = h323_reloading;
h323_reloading = 0;
ast_mutex_unlock(&h323_reload_lock);
if (reloading) {
ast_verb(1, "Reloading H.323\n");
ooh323_do_reload();
}
/* Check for interfaces needing to be killed */
ast_mutex_lock(&iflock);
time(&t);
h323 = iflist;
while (h323) {
h323_next = h323->next;
/* TODO: Need to add rtptimeout keepalive support */
if (ast_test_flag(h323, H323_NEEDDESTROY)) {
ooh323_destroy (h323);
}
h323 = h323_next;
}
ast_mutex_unlock(&iflock);
pthread_testcancel();
/* Wait for sched or io */
res = ast_sched_wait(sched);
if ((res < 0) || (res > 1000)) {
res = 1000;
}
res = ast_io_wait(io, res);
pthread_testcancel();
ast_mutex_lock(&monlock);
if (res >= 0) {
ast_sched_runq(sched);
}
ast_mutex_unlock(&monlock);
}
/* Never reached */
return NULL;
}
int restart_monitor(void)
{
pthread_attr_t attr;
/* If we're supposed to be stopped -- stay stopped */
if (monitor_thread == AST_PTHREADT_STOP)
return 0;
if (ast_mutex_lock(&monlock)) {
ast_log(LOG_WARNING, "Unable to lock monitor\n");
return -1;
}
if (monitor_thread == pthread_self()) {
ast_mutex_unlock(&monlock);
ast_log(LOG_WARNING, "Cannot kill myself\n");
return -1;
}
if (monitor_thread != AST_PTHREADT_NULL) {
/* Wake up the thread */
pthread_kill(monitor_thread, SIGURG);
} else {
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
/* Start a new monitor */
if (ast_pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) {
ast_mutex_unlock(&monlock);
ast_log(LOG_ERROR, "Unable to start monitor thread.\n");
return -1;
}
}
ast_mutex_unlock(&monlock);
return 0;
}
int ooh323_destroy(struct ooh323_pvt *p)
{
/* NOTE: Assumes iflock already acquired */
struct ooh323_pvt *prev = NULL, *cur = NULL;
if (gH323Debug) {
ast_verbose("--- ooh323_destroy \n");
if (p)
ast_verbose(" Destroying %s\n", p->username);
}
cur = iflist;
while (cur) {
if (cur == p) { break; }
prev = cur;
cur = cur->next;
}
if (cur) {
ast_mutex_lock(&cur->lock);
if (prev)
prev->next = cur->next;
else
iflist = cur->next;
if (cur->callToken) {
free(cur->callToken);
cur->callToken = 0;
}
if (cur->username) {
free(cur->username);
cur->username = 0;
}
if (cur->host) {
free(cur->host);
cur->host = 0;
}
if (cur->callerid_name) {
free(cur->callerid_name);
cur->callerid_name = 0;
}
if (cur->callerid_num) {
free(cur->callerid_num);
cur->callerid_num = 0;
}
if (cur->rtp) {
ast_rtp_destroy(cur->rtp);
cur->rtp = 0;
}
/* Unlink us from the owner if we have one */
if (cur->owner) {
ast_channel_lock(cur->owner);
ast_debug(1, "Detaching from %s\n", cur->owner->name);
cur->owner->tech_pvt = NULL;
ast_channel_unlock(cur->owner);
cur->owner = NULL;
}
if (cur->vad) {
ast_dsp_free(cur->vad);
cur->vad = NULL;
}
ast_mutex_unlock(&cur->lock);
ast_mutex_destroy(&cur->lock);
free(cur);
}
if (gH323Debug)
ast_verbose("+++ ooh323_destroy\n");
return 0;
}
int delete_peers()
{
struct ooh323_peer *cur = NULL, *prev = NULL;
ast_mutex_lock(&peerl.lock);
cur = peerl.peers;
while (cur) {
prev = cur;
cur = cur->next;
ast_mutex_destroy(&prev->lock);
if (prev->h323id)
free(prev->h323id);
if (prev->email)
free(prev->email);
if (prev->url)
free(prev->url);
if (prev->e164)
free(prev->e164);
free(prev);
if (cur == peerl.peers) {
break;
}
}
peerl.peers = NULL;
ast_mutex_unlock(&peerl.lock);
return 0;
}
int delete_users()
{
struct ooh323_user *cur = NULL, *prev = NULL;
ast_mutex_lock(&userl.lock);
cur = userl.users;
while (cur) {
prev = cur;
cur = cur->next;
ast_mutex_destroy(&prev->lock);
free(prev);
if (cur == userl.users) {
break;
}
}
userl.users = NULL;
ast_mutex_unlock(&userl.lock);
return 0;
}
static int unload_module(void)
{
struct ooh323_pvt *p;
struct ooAliases *cur = NULL, *prev = NULL;
if (gH323Debug) {
ast_verbose("--- ooh323 unload_module \n");
}
/* First, take us out of the channel loop */
ast_cli_unregister_multiple(cli_ooh323, sizeof(cli_ooh323) / sizeof(struct ast_cli_entry));
ast_rtp_proto_unregister(&ooh323_rtp);
ast_channel_unregister(&ooh323_tech);
#if 0
ast_unregister_atexit(&ast_ooh323c_exit);
#endif
if (gH323Debug) {
ast_verbose(" unload_module - hanging up all interfaces\n");
}
if (!ast_mutex_lock(&iflock)) {
/* Hangup all interfaces if they have an owner */
p = iflist;
while (p) {
if (p->owner) {
ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
}
p = p->next;
}
iflist = NULL;
ast_mutex_unlock(&iflock);
} else {
ast_log(LOG_WARNING, "Unable to lock the interface list\n");
return -1;
}
if (gH323Debug) {
ast_verbose(" unload_module - stopping monitor thread\n");
}
if (monitor_thread != AST_PTHREADT_NULL) {
if (!ast_mutex_lock(&monlock)) {
if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) {
pthread_cancel(monitor_thread);
pthread_kill(monitor_thread, SIGURG);
pthread_join(monitor_thread, NULL);
}
monitor_thread = AST_PTHREADT_STOP;
ast_mutex_unlock(&monlock);
} else {
ast_log(LOG_WARNING, "Unable to lock the monitor\n");
return -1;
}
}
if (gH323Debug) {
ast_verbose(" unload_module - stopping stack thread\n");
}
ooh323c_stop_stack_thread();
if (gH323Debug) {
ast_verbose(" unload_module - freeing up memory used by interfaces\n");
}
if (!ast_mutex_lock(&iflock)) {
struct ooh323_pvt *pl;
/* Destroy all the interfaces and free their memory */
p = iflist;
while (p) {
pl = p;
p = p->next;
/* Free associated memory */
ooh323_destroy(pl);
}
iflist = NULL;
ast_mutex_unlock(&iflock);
} else {
ast_log(LOG_WARNING, "Unable to lock the interface list\n");
return -1;
}
if (gH323Debug) {
ast_verbose(" unload_module - deleting users\n");
}
delete_users();
if (gH323Debug) {
ast_verbose(" unload_module - deleting peers\n");
}
delete_peers();
if (gH323Debug) {
ast_verbose(" unload_module - Freeing up alias list\n");
}
cur = gAliasList;
while (cur) {
prev = cur;
cur = cur->next;
free(prev->value);
free(prev);
}
gAliasList = NULL;
if (gH323Debug) {
ast_verbose(" unload_module- destroying OOH323 endpoint \n");
}
ooH323EpDestroy();
if (gH323Debug) {
ast_verbose("+++ ooh323 unload_module \n");
}
return 0;
}
static enum ast_rtp_get_result ooh323_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
{
struct ooh323_pvt *p = NULL;
enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
if (!(p = (struct ooh323_pvt *) chan->tech_pvt))
return AST_RTP_GET_FAILED;
*rtp = p->rtp;
if (!(p->rtp)) {
return AST_RTP_GET_FAILED;
}
res = AST_RTP_TRY_NATIVE;
return res;
}
static enum ast_rtp_get_result ooh323_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp)
{
struct ooh323_pvt *p = NULL;
enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL;
if (!(p = (struct ooh323_pvt *) chan->tech_pvt))
return AST_RTP_GET_FAILED;
*rtp = p->vrtp;
if (!(p->rtp)) {
return AST_RTP_GET_FAILED;
}
res = AST_RTP_TRY_NATIVE;
return res;
}
int ooh323_update_capPrefsOrderForCall
(ooCallData *call, struct ast_codec_pref *prefs)
{
int i = 0;
int codec = ast_codec_pref_index(prefs, i);
ooResetCapPrefs(call);
while (codec) {
ooAppendCapToCapPrefs(call, ooh323_convertAsteriskCapToH323Cap(codec));
codec = ast_codec_pref_index(prefs, ++i);
}
return 0;
}
int ooh323_convertAsteriskCapToH323Cap(int cap)
{
char formats[512];
switch (cap) {
case AST_FORMAT_ULAW:
return OO_G711ULAW64K;
case AST_FORMAT_ALAW:
return OO_G711ALAW64K;
case AST_FORMAT_GSM:
return OO_GSMFULLRATE;
case AST_FORMAT_G729A:
return OO_G729A;
case AST_FORMAT_G723_1:
return OO_G7231;
case AST_FORMAT_H263:
return OO_H263VIDEO;
default:
ast_log(LOG_NOTICE, "Don't know how to deal with mode %s\n",
ast_getformatname_multiple(formats, sizeof(formats), cap));
return -1;
}
}
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)
{
/* XXX Deal with Video */
struct ooh323_pvt *p;
struct sockaddr_in them;
struct sockaddr_in us;
int mode;
if (gH323Debug)
ast_verbose("--- ooh323_set_peer - %s\n", chan->name);
if (!rtp) {
return 0;
}
mode = ooh323_convertAsteriskCapToH323Cap(chan->writeformat);
p = (struct ooh323_pvt *) chan->tech_pvt;
if (!p) {
ast_log(LOG_ERROR, "No Private Structure, this is bad\n");
return -1;
}
ast_rtp_get_peer(rtp, &them);
ast_rtp_get_us(rtp, &us);
return 0;
}
int configure_local_rtp(struct ooh323_pvt *p, ooCallData *call)
{
struct sockaddr_in us;
ooMediaInfo mediaInfo;
int x, format = 0;
if (gH323Debug)
ast_verbose("--- configure_local_rtp\n");
if (p->rtp) {
ast_rtp_codec_setpref(p->rtp, &p->prefs);
}
/* figure out our local RTP port and tell the H.323 stack about it*/
ast_rtp_get_us(p->rtp, &us);
ast_copy_string(mediaInfo.lMediaIP, ast_inet_ntoa(us.sin_addr), sizeof(mediaInfo.lMediaIP));
mediaInfo.lMediaPort = ntohs(us.sin_port);
mediaInfo.lMediaCntrlPort = mediaInfo.lMediaPort +1;
for (x = 0; 0 != (format = ast_codec_pref_index(&p->prefs, x)); x++) {
strcpy(mediaInfo.dir, "transmit");
mediaInfo.cap = ooh323_convertAsteriskCapToH323Cap(format);
ooAddMediaInfo(call, mediaInfo);
strcpy(mediaInfo.dir, "receive");
ooAddMediaInfo(call, mediaInfo);
if (mediaInfo.cap == OO_G729A) {
strcpy(mediaInfo.dir, "transmit");
mediaInfo.cap = OO_G729;
ooAddMediaInfo(call, mediaInfo);
strcpy(mediaInfo.dir, "receive");
ooAddMediaInfo(call, mediaInfo);
}
}
if (gH323Debug)
ast_verbose("+++ configure_local_rtp\n");
return 1;
}
void setup_rtp_connection(ooCallData *call, const char *remoteIp,
int remotePort)
{
struct ooh323_pvt *p = NULL;
struct sockaddr_in them;
if (gH323Debug)
ast_verbose("--- setup_rtp_connection\n");
/* Find the call or allocate a private structure if call not found */
p = find_call(call);
if (!p) {
ast_log(LOG_ERROR, "Something is wrong: rtp\n");
return;
}
them.sin_family = AF_INET;
them.sin_addr.s_addr = inet_addr(remoteIp); /* only works for IPv4 */
them.sin_port = htons(remotePort);
ast_rtp_set_peer(p->rtp, &them);
if (gH323Debug) {
ast_verbose("+++ setup_rtp_connection\n");
}
return;
}
void close_rtp_connection(ooCallData *call)
{
struct ooh323_pvt *p = NULL;
if (gH323Debug) {
ast_verbose("--- close_rtp_connection\n");
}
p = find_call(call);
if (!p) {
ast_log(LOG_ERROR, "Couldn't find matching call to close rtp connection\n");
return;
}
ast_mutex_lock(&p->lock);
if (p->rtp) {
ast_rtp_stop(p->rtp);
}
ast_mutex_unlock(&p->lock);
if (gH323Debug) {
ast_verbose("+++ close_rtp_connection\n");
}
return;
}
int update_our_aliases(ooCallData *call, struct ooh323_pvt *p)
{
int updated = -1;
ooAliases *psAlias = NULL;
if (!call->ourAliases)
return updated;
for (psAlias = call->ourAliases; psAlias; psAlias = psAlias->next) {
if (psAlias->type == T_H225AliasAddress_h323_ID) {
ast_copy_string(p->callee_h323id, psAlias->value, sizeof(p->callee_h323id));
updated = 1;
}
if (psAlias->type == T_H225AliasAddress_dialedDigits) {
ast_copy_string(p->callee_dialedDigits, psAlias->value, sizeof(p->callee_dialedDigits));
updated = 1;
}
if (psAlias->type == T_H225AliasAddress_url_ID) {
ast_copy_string(p->callee_url, psAlias->value, sizeof(p->callee_url));
updated = 1;
}
if (psAlias->type == T_H225AliasAddress_email_ID) {
ast_copy_string(p->callee_email, psAlias->value, sizeof(p->callee_email));
updated = 1;
}
}
return updated;
}
struct ast_frame *ooh323_rtp_read(struct ast_channel *ast, struct ooh323_pvt *p)
{
/* Retrieve audio/etc from channel. Assumes p->lock is already held. */
struct ast_frame *f;
static struct ast_frame null_frame = { AST_FRAME_NULL, };
switch (ast->fdno) {
case 0:
f = ast_rtp_read(p->rtp); /* RTP Audio */
break;
case 1:
f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */
break;
case 2:
f = ast_rtp_read(p->vrtp); /* RTP Video */
break;
case 3:
f = ast_rtcp_read(p->vrtp); /* RTCP Control Channel for video */
break;
default:
f = &null_frame;
}
/* Don't send RFC2833 if we're not supposed to */
if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & H323_DTMF_RFC2833)) {
return &null_frame;
}
if (p->owner) {
/* We already hold the channel lock */
if (f->frametype == AST_FRAME_VOICE) {
if (f->subclass != p->owner->nativeformats) {
ast_debug(1, "Oooh, format changed to %d\n", f->subclass);
p->owner->nativeformats = f->subclass;
ast_set_read_format(p->owner, p->owner->readformat);
ast_set_write_format(p->owner, p->owner->writeformat);
}
if ((p->dtmfmode & H323_DTMF_INBAND) && p->vad) {
f = ast_dsp_process(p->owner, p->vad, f);
if (f && (f->frametype == AST_FRAME_DTMF)) {
ast_debug(1, "* Detected inband DTMF '%c'\n", f->subclass);
}
}
}
}
return f;
}
int ooh323_convert_hangupcause_asteriskToH323(int cause)
{
switch (cause) {
case AST_CAUSE_CALL_REJECTED:
return OO_REASON_REMOTE_REJECTED;
case AST_CAUSE_UNALLOCATED:
return OO_REASON_NOUSER;
case AST_CAUSE_BUSY:
return OO_REASON_REMOTE_BUSY;
case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL:
return OO_REASON_NOCOMMON_CAPABILITIES;
case AST_CAUSE_CONGESTION:
return OO_REASON_REMOTE_BUSY;
case AST_CAUSE_NO_ANSWER:
return OO_REASON_REMOTE_NOANSWER;
case AST_CAUSE_NORMAL:
return OO_REASON_REMOTE_CLEARED;
case AST_CAUSE_FAILURE:
default:
return OO_REASON_UNKNOWN;
}
return 0;
}
int ooh323_convert_hangupcause_h323ToAsterisk(int cause)
{
switch (cause) {
case OO_REASON_REMOTE_REJECTED:
return AST_CAUSE_CALL_REJECTED;
case OO_REASON_NOUSER:
return AST_CAUSE_UNALLOCATED;
case OO_REASON_REMOTE_BUSY:
case OO_REASON_LOCAL_BUSY:
return AST_CAUSE_BUSY;
case OO_REASON_NOCOMMON_CAPABILITIES: /* No codecs approved */
return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL;
case OO_REASON_REMOTE_CONGESTED:
case OO_REASON_LOCAL_CONGESTED:
return AST_CAUSE_CONGESTION;
case OO_REASON_REMOTE_NOANSWER:
return AST_CAUSE_NO_ANSWER;
case OO_REASON_UNKNOWN:
case OO_REASON_INVALIDMESSAGE:
case OO_REASON_TRANSPORTFAILURE:
return AST_CAUSE_FAILURE;
case OO_REASON_REMOTE_CLEARED:
return AST_CAUSE_NORMAL;
default:
return AST_CAUSE_NORMAL;
}
/* Never reached */
return 0;
}
#if 0
void ast_ooh323c_exit()
{
ooGkClientDestroy();
}
#endif
AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Objective Systems H323 Channel");
Reference in new issue View Git Blame Copy Permalink