chan_ooh323.h File Reference

#include "asterisk.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/param.h>
#include <arpa/inet.h>
#include <net/if.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/ip.h>
#include <unistd.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/utils.h"
#include "asterisk/options.h"
#include "asterisk/sched.h"
#include "asterisk/io.h"
#include "asterisk/causes.h"
#include "asterisk/rtp_engine.h"
#include "asterisk/acl.h"
#include "asterisk/callerid.h"
#include "asterisk/file.h"
#include "asterisk/cli.h"
#include "asterisk/app.h"
#include "asterisk/musiconhold.h"
#include "asterisk/manager.h"
#include "asterisk/dsp.h"
#include "asterisk/stringfields.h"
#include "asterisk/format.h"
#include "asterisk/format_cap.h"
#include "asterisk/udptl.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/format_cache.h"
#include "asterisk/paths.h"
#include "ootypes.h"
#include "ooUtils.h"
#include "ooCapability.h"
#include "oochannels.h"
#include "ooh323ep.h"
#include "ooh323cDriver.h"
#include "ooCalls.h"
#include "ooq931.h"
#include "ooStackCmds.h"
#include "ooGkClient.h"

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	close_rtp_connection (ooCallData *call)
void	close_udptl_connection (ooCallData *call)
int	configure_local_rtp (struct ooh323_pvt *p, ooCallData *call)
int	delete_peers (void)
int	delete_users (void)
struct ooh323_peer *	find_peer (const char *name, int port)
struct ooh323_user *	find_user (const char *name, const char *ip)
EXTERN char *	handle_cli_ooh323_reload (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
int	ooh323_convert_hangupcause_asteriskToH323 (int cause)
int	ooh323_convert_hangupcause_h323ToAsterisk (int cause)
int	ooh323_convertAsteriskCapToH323Cap (struct ast_format *format)
void	ooh323_delete_peer (struct ooh323_peer *peer)
int	ooh323_destroy (struct ooh323_pvt *p)
int	ooh323_onReceivedDigit (OOH323CallData *call, const char *digit)
int	ooh323_onReceivedSetup (ooCallData *call, Q931Message *pmsg)
struct ast_frame *	ooh323_rtp_read (struct ast_channel *ast, struct ooh323_pvt *p)
void	ooh323_set_read_format (ooCallData *call, struct ast_format *fmt)
void	ooh323_set_write_format (ooCallData *call, struct ast_format *fmt, int txframes)
int	reload_config (int reload)
int	restart_monitor (void)
void	setup_rtp_connection (ooCallData *call, const char *remoteIp, int remotePort)
void	setup_udptl_connection (ooCallData *call, const char *remoteIp, int remotePort)
int	update_our_aliases (ooCallData *call, struct ooh323_pvt *p)

Function Documentation

close_rtp_connection()

void close_rtp_connection

(

ooCallData *

call

)

Definition at line 4810 of file chan_ooh323.c.

{
    struct ooh323_pvt *p = NULL;
 
   if(gH323Debug)
        ast_verb(0, "---   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_instance_stop(p->rtp);
    }
    ast_mutex_unlock(&p->lock);
 
   if(gH323Debug)
        ast_verb(0, "+++   close_rtp_connection\n");
 
    return;
}

References ast_log, ast_mutex_lock, ast_mutex_unlock, ast_rtp_instance_stop(), ast_verb, call(), find_call(), gH323Debug, ooh323_pvt::lock, LOG_ERROR, NULL, and ooh323_pvt::rtp.

Referenced by ooh323c_stop_transmit_channel().

close_udptl_connection()

void close_udptl_connection

(

ooCallData *

call

)

Definition at line 4901 of file chan_ooh323.c.

{
    struct ooh323_pvt *p = NULL;
 
    if(gH323Debug)
        ast_verb(0, "---   close_udptl_connection\n");
 
    p = find_call(call);
    if (!p) {
            ast_log(LOG_ERROR, "Couldn't find matching call to close udptl "
                         "connection\n");
        return;
    }
    ast_mutex_lock(&p->lock);
    if (p->owner) {
        while (p->owner && ast_channel_trylock(p->owner)) {
            ast_debug(1, "Failed to grab lock, trying again\n");
            DEADLOCK_AVOIDANCE(&p->lock);
        }
        if (!p->owner) {
            ast_mutex_unlock(&p->lock);
            ast_log(LOG_ERROR, "Channel has no owner\n");
            return;
        }
    } else {
        ast_mutex_unlock(&p->lock);
        ast_log(LOG_ERROR, "Channel has no owner\n");
        return;
    }
 
    p->t38_tx_enable = 0;
    if (p->t38support == T38_ENABLED) {
        struct ast_control_t38_parameters parameters = { .request_response = 0 };
        parameters.request_response = AST_T38_TERMINATED;
        ast_queue_control_data(p->owner, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters));
    }
 
    ast_channel_unlock(p->owner);
    ast_mutex_unlock(&p->lock);
 
    if(gH323Debug)
        ast_verb(0, "+++   close_udptl_connection\n");
 
    return;
}

References ast_channel_trylock, ast_channel_unlock, AST_CONTROL_T38_PARAMETERS, ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_queue_control_data(), AST_T38_TERMINATED, ast_verb, call(), DEADLOCK_AVOIDANCE, find_call(), gH323Debug, ooh323_pvt::lock, LOG_ERROR, NULL, ooh323_pvt::owner, ast_control_t38_parameters::request_response, T38_ENABLED, ooh323_pvt::t38_tx_enable, and ooh323_pvt::t38support.

Referenced by ooh323c_stop_transmit_datachannel().

configure_local_rtp()

int configure_local_rtp	(	struct ooh323_pvt *	p,
		ooCallData *	call
	)

Definition at line 4599 of file chan_ooh323.c.

{
    char lhost[INET6_ADDRSTRLEN];
    unsigned lport = 0;
    struct ast_sockaddr tmp;
    ooMediaInfo mediaInfo;
    int x;
 
    if (gH323Debug)
        ast_verb(0, "---   configure_local_rtp\n");
 
    memset(&mediaInfo, 0, sizeof(mediaInfo));
    if (ast_parse_arg(call->localIP, PARSE_ADDR, &tmp)) {
        ast_sockaddr_copy(&tmp, &bindaddr);
    }
    if (!(p->rtp = ast_rtp_instance_new("asterisk", sched, &tmp, NULL))) {
        ast_log(LOG_WARNING, "Unable to create RTP session: %s\n",
            strerror(errno));
        return 0;
    }
 
    ast_rtp_instance_set_qos(p->rtp, gTOS, 0, "ooh323-rtp");
 
    if (!(p->udptl = ast_udptl_new_with_bindaddr(sched, io, 0, &tmp))) {
        ast_log(LOG_WARNING, "Unable to create UDPTL session: %s\n",
            strerror(errno));
        return 0;
    }
    ast_udptl_set_far_max_datagram(p->udptl, 144);
 
    if (p->owner) {
        while (p->owner && ast_channel_trylock(p->owner)) {
            ast_debug(1,"Failed to grab lock, trying again\n");
            DEADLOCK_AVOIDANCE(&p->lock);
        }
        if (!p->owner) {
            ast_mutex_unlock(&p->lock);
            ast_log(LOG_ERROR, "Channel has no owner\n");
            return 0;
        }
    } else {
        ast_log(LOG_ERROR, "Channel has no owner\n");
        return 0;
    }
 
    ast_channel_set_fd(p->owner, 0, ast_rtp_instance_fd(p->rtp, 0));
    ast_channel_set_fd(p->owner, 1, ast_rtp_instance_fd(p->rtp, 1));
    ast_channel_set_fd(p->owner, 5, ast_udptl_fd(p->udptl));
 
    ast_channel_unlock(p->owner);
 
    if (p->rtp) {
        if (p->cap) {
            ast_rtp_codecs_set_framing(ast_rtp_instance_get_codecs(p->rtp),
                ast_format_cap_get_framing(p->cap));
        }
        if (p->nat) {
            ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_NAT, 1);
        }
        if (p->dtmfmode & H323_DTMF_RFC2833 && p->dtmfcodec) {
            ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_DTMF, 1);
            ast_rtp_codecs_payloads_set_rtpmap_type(ast_rtp_instance_get_codecs(p->rtp),
                 p->rtp, p->dtmfcodec, "audio", "telephone-event", 0);
        }
        if (p->dtmfmode & H323_DTMF_CISCO && p->dtmfcodec) {
            ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_DTMF, 1);
            ast_rtp_codecs_payloads_set_rtpmap_type(ast_rtp_instance_get_codecs(p->rtp),
                 p->rtp, p->dtmfcodec, "audio", "cisco-telephone-event", 0);
        }
        /* figure out our local RTP port and tell the H.323 stack about it*/
        ast_rtp_instance_get_local_address(p->rtp, &tmp);
        ast_copy_string(lhost, ast_sockaddr_stringify_addr(&tmp), sizeof(lhost));
        lport = ast_sockaddr_port(&tmp);
 
        if (p->rtptimeout) {
            ast_rtp_instance_set_timeout(p->rtp, p->rtptimeout);
        }
        ast_rtp_instance_set_prop(p->rtp, AST_RTP_PROPERTY_RTCP, 1);
 
    }
 
    if (p->rtdrcount) {
        if (gH323Debug)
            ast_verb(0, "Setup RTDR info: %d, %d\n", p->rtdrinterval, p->rtdrcount);
        call->rtdrInterval = p->rtdrinterval;
        call->rtdrCount = p->rtdrcount;
    }
 
 
    ast_copy_string(mediaInfo.lMediaIP, lhost, sizeof(mediaInfo.lMediaIP));
    mediaInfo.lMediaPort = lport;
    mediaInfo.lMediaCntrlPort = mediaInfo.lMediaPort + 1;
    for (x = 0; x < ast_format_cap_count(p->cap); x++) {
        struct ast_format *format = ast_format_cap_get_format(p->cap, 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);
 
            strcpy(mediaInfo.dir, "transmit");
            mediaInfo.cap = OO_G729B;
            ooAddMediaInfo(call, mediaInfo);
            strcpy(mediaInfo.dir, "receive");
            ooAddMediaInfo(call, mediaInfo);
        }
 
        ao2_ref(format, -1);
    }
 
    if (p->udptl) {
        ast_udptl_get_us(p->udptl, &tmp);
        ast_copy_string(lhost, ast_sockaddr_stringify_addr(&tmp), sizeof(lhost));
        lport = ast_sockaddr_port(&tmp);
        ast_copy_string(mediaInfo.lMediaIP, lhost, sizeof(mediaInfo.lMediaIP));
        mediaInfo.lMediaPort = lport;
        mediaInfo.lMediaCntrlPort = mediaInfo.lMediaPort +1;
        mediaInfo.cap = OO_T38;
        strcpy(mediaInfo.dir, "transmit");
        ooAddMediaInfo(call, mediaInfo);
        strcpy(mediaInfo.dir, "receive");
        ooAddMediaInfo(call, mediaInfo);
    }
 
    if (gH323Debug)
        ast_verb(0, "+++   configure_local_rtp\n");
 
    return 1;
}

References ao2_ref, ast_channel_set_fd(), ast_channel_trylock, ast_channel_unlock, ast_copy_string(), ast_debug, ast_format_cap_count(), ast_format_cap_get_format(), ast_format_cap_get_framing(), ast_log, ast_mutex_unlock, ast_parse_arg(), ast_rtp_codecs_payloads_set_rtpmap_type(), ast_rtp_codecs_set_framing(), ast_rtp_instance_fd(), ast_rtp_instance_get_codecs(), ast_rtp_instance_get_local_address(), ast_rtp_instance_new(), ast_rtp_instance_set_prop(), ast_rtp_instance_set_qos(), ast_rtp_instance_set_timeout(), AST_RTP_PROPERTY_DTMF, AST_RTP_PROPERTY_NAT, AST_RTP_PROPERTY_RTCP, ast_sockaddr_copy(), ast_sockaddr_port, ast_sockaddr_stringify_addr(), ast_udptl_fd(), ast_udptl_get_us(), ast_udptl_new_with_bindaddr(), ast_udptl_set_far_max_datagram(), ast_verb, bindaddr, call(), ooh323_pvt::cap, DEADLOCK_AVOIDANCE, ooh323_pvt::dtmfcodec, ooh323_pvt::dtmfmode, errno, gH323Debug, gTOS, H323_DTMF_CISCO, H323_DTMF_RFC2833, io, ooh323_pvt::lock, LOG_ERROR, LOG_WARNING, ooh323_pvt::nat, NULL, ooh323_convertAsteriskCapToH323Cap(), ooh323_pvt::owner, PARSE_ADDR, ooh323_pvt::rtdrcount, ooh323_pvt::rtdrinterval, ooh323_pvt::rtp, ooh323_pvt::rtptimeout, tmp(), and ooh323_pvt::udptl.

Referenced by onNewCallCreated(), onOutgoingCall(), and ooh323_onReceivedSetup().

delete_peers()

int delete_peers

(

void

)

Definition at line 4230 of file chan_ooh323.c.

{
    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);
        ast_free(prev->h323id);
        ast_free(prev->email);
        ast_free(prev->url);
        ast_free(prev->e164);
      if(prev->rtpmask) {
        ast_mutex_lock(&prev->rtpmask->lock);
        prev->rtpmask->inuse--;
        ast_mutex_unlock(&prev->rtpmask->lock);
        if (prev->rtpmask->inuse == 0) {
            regfree(&prev->rtpmask->regex);
            ast_mutex_destroy(&prev->rtpmask->lock);
            ast_free(prev->rtpmask);
            }
      }
        ast_free(prev);
 
        if (cur == peerl.peers) {
            break;
        }
    }
    peerl.peers = NULL;
    ast_mutex_unlock(&peerl.lock);
    return 0;
}

References ast_free, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, ast_peer_list::lock, ooh323_peer::next, NULL, peerl, and ast_peer_list::peers.

Referenced by reload_config(), and unload_module().

delete_users()

int delete_users

(

void

)

Definition at line 4265 of file chan_ooh323.c.

{
    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);
 
            if(prev->rtpmask) {
            ast_mutex_lock(&prev->rtpmask->lock);
            prev->rtpmask->inuse--;
            ast_mutex_unlock(&prev->rtpmask->lock);
            if (prev->rtpmask->inuse == 0) {
                regfree(&prev->rtpmask->regex);
                ast_mutex_destroy(&prev->rtpmask->lock);
                ast_free(prev->rtpmask);
                }
            }
        ao2_cleanup(prev->cap);
        ast_free(prev);
        if (cur == userl.users) {
            break;
        }
    }
    userl.users = NULL;
    ast_mutex_unlock(&userl.lock);
    return 0;
}

References ao2_cleanup, ast_free, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, ast_user_list::lock, ooh323_user::next, NULL, userl, and ast_user_list::users.

Referenced by reload_config(), and unload_module().

find_peer()

struct ooh323_peer * find_peer	(	const char *	name,
		int	port
	)

Definition at line 890 of file chan_ooh323.c.

{
    struct ooh323_peer *peer;
 
    if (gH323Debug)
        ast_verb(0, "---   find_peer \"%s\"\n", name);
 
 
    ast_mutex_lock(&peerl.lock);
    for (peer = peerl.peers; peer; peer = peer->next) {
        if (gH323Debug) {
            ast_verb(0, "       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_verb(0, "       found matching peer\n");
        }
        ast_verb(0, "+++   find_peer \"%s\"\n", name);
    }
 
    return peer;
}

References ast_mutex_lock, ast_mutex_unlock, ast_verb, ooh323_peer::e164, gH323Debug, ooh323_peer::h323id, ooh323_peer::ip, ast_peer_list::lock, ooh323_peer::name, name, ooh323_peer::next, peerl, and ast_peer_list::peers.

Referenced by ooh323_request().

find_user()

struct ooh323_user * find_user	(	const char *	name,
		const char *	ip
	)

Definition at line 832 of file chan_ooh323.c.

{
    struct ooh323_user *user;
 
    if (gH323Debug)
      ast_verb(0, "---   find_user: %s, %s\n",name,ip);
 
    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_verb(0, "+++   find_user\n");
 
    return user;
}

References ast_mutex_lock, ast_mutex_unlock, ast_verb, gH323Debug, ast_user_list::lock, name, user, userl, and ast_user_list::users.

Referenced by ooh323_destroy(), and ooh323_onReceivedSetup().

handle_cli_ooh323_reload()

EXTERN char * handle_cli_ooh323_reload	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

Definition at line 2778 of file chan_ooh323.c.

{
 
       switch (cmd) {
       case CLI_INIT:
               e->command = "ooh323 reload";
               e->usage =
                       "Usage: ooh323 reload\n"
                       "                Reload OOH323 config.\n";
               return NULL;
       case CLI_GENERATE:
               return NULL;
       }
 
       if (a->argc != 2)
               return CLI_SHOWUSAGE;
 
    if (gH323Debug)
        ast_verb(0, "---   ooh323_reload\n");
 
    ast_mutex_lock(&h323_reload_lock);
    if (h323_reloading) {
        ast_verb(0, "Previous OOH323 reload not yet done\n");
   } else {
        h323_reloading = 1;
    }
    ast_mutex_unlock(&h323_reload_lock);
    restart_monitor();
 
    if (gH323Debug)
        ast_verb(0, "+++   ooh323_reload\n");
 
    return 0;
}

References a, ast_mutex_lock, ast_mutex_unlock, ast_verb, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, ast_cli_entry::command, gH323Debug, h323_reload_lock, h323_reloading, NULL, restart_monitor(), and ast_cli_entry::usage.

ooh323_convert_hangupcause_asteriskToH323()

int ooh323_convert_hangupcause_asteriskToH323

(

int

cause

)

Definition at line 5179 of file chan_ooh323.c.

{
    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;
 
 
}

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_BUSY, AST_CAUSE_CALL_REJECTED, AST_CAUSE_CONGESTION, AST_CAUSE_FAILURE, AST_CAUSE_NO_ANSWER, AST_CAUSE_NORMAL, and AST_CAUSE_UNALLOCATED.

Referenced by ooh323_hangup(), and ooh323_onReceivedSetup().

ooh323_convert_hangupcause_h323ToAsterisk()

int ooh323_convert_hangupcause_h323ToAsterisk

(

int

cause

)

Definition at line 5206 of file chan_ooh323.c.

{
    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;
}

References AST_CAUSE_BEARERCAPABILITY_NOTAVAIL, AST_CAUSE_BUSY, AST_CAUSE_CALL_REJECTED, AST_CAUSE_CONGESTION, AST_CAUSE_FAILURE, AST_CAUSE_NO_ANSWER, AST_CAUSE_NORMAL, and AST_CAUSE_UNALLOCATED.

ooh323_convertAsteriskCapToH323Cap()

int ooh323_convertAsteriskCapToH323Cap

(

struct ast_format *

format

)

Definition at line 4506 of file chan_ooh323.c.

{
    if (ast_format_cmp(format, ast_format_ulaw) == AST_FORMAT_CMP_EQUAL) {
        return OO_G711ULAW64K;
    } else if (ast_format_cmp(format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL) {
        return OO_G711ALAW64K;
    } else if (ast_format_cmp(format, ast_format_gsm) == AST_FORMAT_CMP_EQUAL) {
        return OO_GSMFULLRATE;
    } else if (ast_format_cmp(format, ast_format_speex) == AST_FORMAT_CMP_EQUAL) {
        return OO_SPEEX;
    } else if (ast_format_cmp(format, ast_format_g729) == AST_FORMAT_CMP_EQUAL) {
        return OO_G729A;
    } else if (ast_format_cmp(format, ast_format_g726) == AST_FORMAT_CMP_EQUAL) {
        return OO_G726;
    } else if (ast_format_cmp(format, ast_format_g726_aal2) == AST_FORMAT_CMP_EQUAL) {
        return OO_G726AAL2;
    } else if (ast_format_cmp(format, ast_format_g723) == AST_FORMAT_CMP_EQUAL) {
        return OO_G7231;
    } else if (ast_format_cmp(format, ast_format_h263) == AST_FORMAT_CMP_EQUAL) {
        return OO_H263VIDEO;
    } else {
        ast_log(LOG_NOTICE, "Don't know how to deal with mode %s\n", ast_format_get_name(format));
        return -1;
    }
}

References ast_format_alaw, ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_g723, ast_format_g726, ast_format_g726_aal2, ast_format_g729, ast_format_get_name(), ast_format_gsm, ast_format_h263, ast_format_speex, ast_format_ulaw, ast_log, and LOG_NOTICE.

Referenced by configure_local_rtp(), and ooh323_set_rtp_peer().

ooh323_delete_peer()

void ooh323_delete_peer

(

struct ooh323_peer *

peer

)

Definition at line 2328 of file chan_ooh323.c.

{
    struct ooh323_peer *prev = NULL, *cur = NULL;
 
    if (gH323Debug)
        ast_verb(0, "---   ooh323_delete_peer\n");
 
    if (peer) {
      cur = peerl.peers;
        ast_mutex_lock(&peerl.lock);
      while(cur) {
         if(cur==peer) break;
         prev = cur;
         cur = cur->next;
        }
 
        if (cur) {
         if(prev)
                prev->next = cur->next;
         else
                peerl.peers = cur->next;
            }
        ast_mutex_unlock(&peerl.lock);
 
        ast_free(peer->h323id);
        ast_free(peer->email);
        ast_free(peer->url);
        ast_free(peer->e164);
 
        ao2_cleanup(peer->cap);
        ast_free(peer);
    }
 
    if (gH323Debug)
        ast_verb(0, "+++   ooh323_delete_peer\n");
 
}

References ao2_cleanup, ast_free, ast_mutex_lock, ast_mutex_unlock, ast_verb, ooh323_peer::cap, ooh323_peer::e164, ooh323_peer::email, gH323Debug, ooh323_peer::h323id, ast_peer_list::lock, ooh323_peer::next, NULL, peerl, ast_peer_list::peers, and ooh323_peer::url.

Referenced by build_peer().

ooh323_destroy()

int ooh323_destroy

(

struct ooh323_pvt *

p

)

Definition at line 4117 of file chan_ooh323.c.

{
    /* NOTE: Assumes iflock already acquired */
    struct ooh323_pvt *prev = NULL, *cur = NULL;
    struct ooh323_user *user = NULL;
 
    if (gH323Debug) {
        ast_verb(0, "---   ooh323_destroy \n");
 
        if (p)
            ast_verb(0, " 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) {
            if (gH323Debug)
                ast_verb(0, " Destroying %s\n", cur->callToken);
            ast_free(cur->callToken);
            cur->callToken = 0;
        }
 
        if (cur->username) {
            ast_free(cur->username);
            cur->username = 0;
        }
 
        if (cur->host) {
            ast_free(cur->host);
            cur->host = 0;
        }
 
        if (cur->callerid_name) {
            ast_free(cur->callerid_name);
            cur->callerid_name = 0;
        }
 
        if (cur->callerid_num) {
            ast_free(cur->callerid_num);
            cur->callerid_num = 0;
        }
 
        if (cur->rtp) {
            ast_rtp_instance_stop(cur->rtp);
            ast_rtp_instance_destroy(cur->rtp);
            cur->rtp = NULL;
        }
 
        if (cur->udptl) {
            ast_udptl_destroy(cur->udptl);
            cur->udptl = NULL;
        }
 
        /* Unlink us from the owner if we have one */
        if (cur->owner) {
                while(ast_channel_trylock(cur->owner)) {
                        ast_debug(1, "Failed to grab lock, trying again\n");
                DEADLOCK_AVOIDANCE(&cur->lock);
                }
            ast_debug(1, "Detaching from %s\n", ast_channel_name(cur->owner));
            ast_channel_tech_pvt_set(cur->owner, NULL);
            ast_channel_unlock(cur->owner);
            cur->owner = NULL;
            ast_module_unref(myself);
        }
 
        if (cur->vad) {
            ast_dsp_free(cur->vad);
            cur->vad = NULL;
        }
 
/* decrement user/peer count */
 
      if(!ast_test_flag(cur, H323_OUTGOING)) {
     if (cur->neighbor.user) {
      user = find_user(p->callerid_name, cur->neighbor.user);
      if(user && user->inUse > 0) {
        ast_mutex_lock(&user->lock);
        user->inUse--;
        ast_mutex_unlock(&user->lock);
      }
      ast_free(cur->neighbor.user);
     }
      } else {
/* outgoing limit decrement here !!! */
      }
 
        ast_mutex_unlock(&cur->lock);
        ast_mutex_destroy(&cur->lock);
        ao2_cleanup(cur->writeformat);
        ao2_cleanup(cur->readformat);
        ao2_cleanup(cur->cap);
        ast_free(cur);
    }
 
    if (gH323Debug)
        ast_verb(0, "+++   ooh323_destroy\n");
 
    return 0;
}

References ao2_cleanup, ast_channel_name(), ast_channel_tech_pvt_set(), ast_channel_trylock, ast_channel_unlock, ast_debug, ast_dsp_free(), ast_free, ast_module_unref, ast_mutex_destroy, ast_mutex_lock, ast_mutex_unlock, ast_rtp_instance_destroy(), ast_rtp_instance_stop(), ast_test_flag, ast_udptl_destroy(), ast_verb, ooh323_pvt::callerid_name, DEADLOCK_AVOIDANCE, find_user(), gH323Debug, H323_OUTGOING, iflist, myself, ooh323_pvt::next, NULL, and ooh323_pvt::username.

Referenced by do_monitor(), ooh323_request(), and unload_module().

ooh323_onReceivedDigit()

int ooh323_onReceivedDigit	(	OOH323CallData *	call,
		const char *	digit
	)

Callback for sending digits from H.323 up to asterisk

Definition at line 1798 of file chan_ooh323.c.

{
    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.integer = digit[0];
    f.datalen = 0;
    f.samples = 800;
    f.offset = 0;
    f.data.ptr = NULL;
    f.mallocd = 0;
    f.src = "SEND_DIGIT";
 
    while (p->owner && ast_channel_trylock(p->owner)) {
        ast_debug(1, "Failed to grab lock, trying again\n");
        DEADLOCK_AVOIDANCE(&p->lock);
    }
    if (!p->owner) {
        ast_mutex_unlock(&p->lock);
        ast_log(LOG_ERROR, "Channel has no owner\n");
        return 0;
    }
    res = ast_queue_frame(p->owner, &f);
    ast_channel_unlock(p->owner);
    ast_mutex_unlock(&p->lock);
    return res;
}

References ast_channel_trylock, ast_channel_unlock, ast_debug, AST_FRAME_DTMF, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_queue_frame(), call(), ast_frame::data, ast_frame::datalen, DEADLOCK_AVOIDANCE, digit, find_call(), ast_frame::frametype, ast_frame_subclass::integer, ooh323_pvt::lock, LOG_ERROR, ast_frame::mallocd, NULL, ast_frame::offset, ooh323_pvt::owner, ast_frame::ptr, ast_frame::samples, ast_frame::src, and ast_frame::subclass.

Referenced by load_module().

ooh323_onReceivedSetup()

int ooh323_onReceivedSetup	(	ooCallData *	call,
		Q931Message *	pmsg
	)

Definition at line 1840 of file chan_ooh323.c.

{
    struct ooh323_pvt *p = NULL;
    struct ooh323_user *user = NULL;
    struct ast_channel *c = NULL;
    ooAliases *alias = NULL;
    char *at = NULL;
    char number [OO_MAX_NUMBER_LENGTH];
 
    if (gH323Debug)
        ast_verb(0, "---   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 = ast_strdup(call->remoteDisplayName);
    }
 
    if (ooCallGetCallingPartyNumber(call, number, OO_MAX_NUMBER_LENGTH) == OO_OK) {
        p->callerid_num = ast_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 = ast_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 = ast_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)) {
            p->exten[0]='s';
            p->exten[1]='\0';
    }
 
        user = find_user(p->callerid_name, call->remoteIP);
        if(user && (user->incominglimit == 0 || user->inUse < user->incominglimit)) {
        ast_mutex_lock(&user->lock);
        p->username = ast_strdup(user->name);
        p->neighbor.user = user->mUseIP ? ast_strdup(user->mIP) :
                          ast_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;
        ast_format_cap_append_from_cap(p->cap, user->cap, AST_MEDIA_TYPE_UNKNOWN);
        p->g729onlyA = user->g729onlyA;
        p->dtmfmode |= user->dtmfmode;
        p->dtmfcodec = user->dtmfcodec;
        p->faxdetect = user->faxdetect;
        p->t38support = user->t38support;
        p->rtptimeout = user->rtptimeout;
        p->nat = user->nat;
        p->h245tunneling = user->h245tunneling;
        p->faststart = user->faststart;
        p->directrtp = user->directrtp;
        p->earlydirect = user->earlydirect;
 
        if (p->faststart)
                OO_SETFLAG(call->flags, OO_M_FASTSTART);
        else
            OO_CLRFLAG(call->flags, OO_M_FASTSTART);
        /* if we disable h245tun for this user then we clear flag */
        /* in any other case we don't must touch this */
        /* ie if we receive setup without h245tun but enabled
                        we can't enable it per call */
        if (!p->h245tunneling)
            OO_CLRFLAG(call->flags, OO_M_TUNNELING);
 
        if (user->rtpmask && user->rtpmaskstr[0]) {
            p->rtpmask = user->rtpmask;
            ast_copy_string(p->rtpmaskstr, user->rtpmaskstr,
                             sizeof(p->rtpmaskstr));
        }
        if (user->rtdrcount > 0 && user->rtdrinterval > 0) {
            p->rtdrcount = user->rtdrcount;
            p->rtdrinterval = user->rtdrinterval;
        }
 
        p->aniasdni = user->aniasdni;
 
        if (user->incominglimit) user->inUse++;
        ast_mutex_unlock(&user->lock);
    } else {
     if (!OO_TESTFLAG(p->flags,H323_DISABLEGK)) {
        p->username = ast_strdup(call->remoteIP);
        p->directrtp = gDirectRTP;
        p->earlydirect = gEarlyDirect;
    } else {
      ast_mutex_unlock(&p->lock);
      ast_log(LOG_ERROR, "Unacceptable ip %s\n", call->remoteIP);
      if (!user) {
       ooHangCall(call->callToken, ooh323_convert_hangupcause_asteriskToH323(AST_CAUSE_CALL_REJECTED), AST_CAUSE_CALL_REJECTED);
       call->callEndReason = OO_REASON_REMOTE_REJECTED;
      }
      else {
       ooHangCall(call->callToken, ooh323_convert_hangupcause_asteriskToH323(AST_CAUSE_NORMAL_CIRCUIT_CONGESTION), AST_CAUSE_NORMAL_CIRCUIT_CONGESTION);
       call->callEndReason = OO_REASON_REMOTE_REJECTED;
      }
      ast_set_flag(p, H323_NEEDDESTROY);
      return -1;
     }
    }
 
    ooh323c_set_capability_for_call(call, p->cap, p->dtmfmode, p->dtmfcodec,
                     p->t38support, p->g729onlyA);
/* Incoming call */
    c = ooh323_new(p, AST_STATE_RING, p->username, 0, NULL, NULL);
    if(!c) {
    ast_mutex_unlock(&p->lock);
    ast_log(LOG_ERROR, "Could not create ast_channel\n");
         return -1;
    }
 
    if (p->aniasdni) {
        ooCallSetCallerId(call, p->exten);
    }
    if (!configure_local_rtp(p, call)) {
        ast_mutex_unlock(&p->lock);
        ast_log(LOG_ERROR, "Couldn't create rtp structure\n");
        return -1;
    }
 
    ast_mutex_unlock(&p->lock);
 
    if (gH323Debug)
        ast_verb(0, "+++   ooh323_onReceivedSetup - Determined context %s, "
                        "extension %s\n", p->context, p->exten);
 
    return OO_OK;
}

References ooh323_pvt::accountcode, ooh323_pvt::amaflags, ooh323_pvt::aniasdni, AST_CAUSE_CALL_REJECTED, AST_CAUSE_NORMAL_CIRCUIT_CONGESTION, ast_clear_flag, ast_copy_string(), ast_format_cap_append_from_cap(), ast_log, AST_MEDIA_TYPE_UNKNOWN, ast_mutex_lock, ast_mutex_unlock, ast_set_flag, AST_STATE_RING, ast_strdup, ast_strlen_zero(), ast_verb, c, call(), ooh323_pvt::callee_dialedDigits, ooh323_pvt::callee_email, ooh323_pvt::callee_h323id, ooh323_pvt::caller_dialedDigits, ooh323_pvt::caller_email, ooh323_pvt::caller_h323id, ooh323_pvt::caller_url, ooh323_pvt::callerid_name, ooh323_pvt::callerid_num, ooh323_pvt::cap, configure_local_rtp(), ooh323_pvt::context, ooh323_pvt::directrtp, ooh323_pvt::dtmfcodec, ooh323_pvt::dtmfmode, ooh323_pvt::earlydirect, ooh323_pvt::exten, ooh323_pvt::faststart, ooh323_pvt::faxdetect, find_user(), ooh323_pvt::flags, ooh323_pvt::g729onlyA, gDirectRTP, gEarlyDirect, gH323Debug, ooh323_pvt::h245tunneling, H323_DISABLEGK, H323_NEEDDESTROY, H323_OUTGOING, ooh323_pvt::lock, LOG_ERROR, ooh323_pvt::nat, ooh323_pvt::neighbor, NULL, ooh323_alloc(), ooh323_convert_hangupcause_asteriskToH323(), ooh323_new(), ooh323c_set_capability_for_call(), ooh323_pvt::rtdrcount, ooh323_pvt::rtdrinterval, ooh323_pvt::rtpmask, ooh323_pvt::rtpmaskstr, ooh323_pvt::rtptimeout, ooh323_pvt::t38support, update_our_aliases(), ooh323_pvt::user, and ooh323_pvt::username.

Referenced by load_module().

ooh323_rtp_read()

struct ast_frame * ooh323_rtp_read	(	struct ast_channel *	ast,
		struct ooh323_pvt *	p
	)

Definition at line 4978 of file chan_ooh323.c.

{
    /* Retrieve audio/etc from channel.  Assumes p->lock is already held. */
    struct ast_frame *f;
    struct ast_frame *dfr = NULL;
    static struct ast_frame null_frame = { AST_FRAME_NULL, };
    switch (ast_channel_fdno(ast)) {
    case 0:
        f = ast_rtp_instance_read(p->rtp, 0);   /* RTP Audio */
        p->lastrtprx = time(NULL);
        break;
    case 1:
        f = ast_rtp_instance_read(p->rtp, 1);   /* RTCP Control Channel */
        break;
    case 2:
        f = ast_rtp_instance_read(p->vrtp, 0);  /* RTP Video */
        p->lastrtprx = time(NULL);
        break;
    case 3:
        f = ast_rtp_instance_read(p->vrtp, 1);  /* RTCP Control Channel for video */
        break;
    case 5:
        f = ast_udptl_read(p->udptl);       /* UDPTL t.38 data */
        if (gH323Debug) {
             ast_debug(1, "Got UDPTL %u/%d len %d for %s\n",
                f->frametype, f->subclass.integer, f->datalen, ast_channel_name(ast));
        }
        p->lastrtprx = time(NULL);
        break;
 
    default:
        f = &null_frame;
    }
 
    if (f && p->owner && !p->faxmode && (f->frametype == AST_FRAME_VOICE)) {
        /* We already hold the channel lock */
        if (ast_format_cap_iscompatible_format(ast_channel_nativeformats(p->owner), f->subclass.format) == AST_FORMAT_CMP_NOT_EQUAL) {
            struct ast_format_cap *caps;
 
            ast_debug(1, "Oooh, voice format changed to %s\n", ast_format_get_name(f->subclass.format));
 
            caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
            if (caps) {
                ast_format_cap_append(caps, f->subclass.format, 0);
                ast_channel_nativeformats_set(p->owner, caps);
                ao2_ref(caps, -1);
            }
            ast_set_read_format(p->owner, ast_channel_readformat(p->owner));
            ast_set_write_format(p->owner, ast_channel_writeformat(p->owner));
        }
        if (((p->dtmfmode & H323_DTMF_INBAND) || (p->faxdetect & FAXDETECT_CNG)) && p->vad &&
            ((ast_format_cmp(f->subclass.format, ast_format_slin) == AST_FORMAT_CMP_EQUAL) ||
            (ast_format_cmp(f->subclass.format, ast_format_ulaw) == AST_FORMAT_CMP_EQUAL) ||
            (ast_format_cmp(f->subclass.format, ast_format_alaw) == AST_FORMAT_CMP_EQUAL))) {
            dfr = ast_frdup(f);
            dfr = ast_dsp_process(p->owner, p->vad, dfr);
        }
    } else {
        return f;
    }
 
    /* process INBAND DTMF*/
    if (dfr && (dfr->frametype == AST_FRAME_DTMF) && ((dfr->subclass.integer == 'f') || (dfr->subclass.integer == 'e'))) {
        ast_debug(1, "* Detected FAX Tone %s\n", (dfr->subclass.integer == 'e') ? "CED" : "CNG");
        /* Switch to T.38 ON CED*/
        if (!p->faxmode && !p->chmodepend && (dfr->subclass.integer == 'e') && (p->t38support != T38_DISABLED)) {
            if (gH323Debug)
                ast_verb(0, "request to change %s to t.38 because fax ced\n", p->callToken);
            p->chmodepend = 1;
            p->faxdetected = 1;
            ooRequestChangeMode(p->callToken, 1);
        } else if ((dfr->subclass.integer == 'f') && !p->faxdetected) {
            const char *target_context = ast_channel_context(p->owner);
            if ((strcmp(ast_channel_exten(p->owner), "fax")) &&
                (ast_exists_extension(p->owner, target_context, "fax", 1,
                    S_COR(ast_channel_caller(p->owner)->id.number.valid, ast_channel_caller(p->owner)->id.number.str, NULL)))) {
                ast_verb(2, "Redirecting '%s' to fax extension due to CNG detection\n", ast_channel_name(p->owner));
                pbx_builtin_setvar_helper(p->owner, "FAXEXTEN", ast_channel_exten(p->owner));
                if (ast_async_goto(p->owner, target_context, "fax", 1)) {
                    ast_log(LOG_NOTICE, "Failed to async goto '%s' into fax of '%s'\n", ast_channel_name(p->owner),target_context);
                }
                p->faxdetected = 1;
                ast_frfree(dfr);
                return &ast_null_frame;
            }
        }
    } else if (dfr && dfr->frametype == AST_FRAME_DTMF) {
        ast_debug(1, "* Detected inband DTMF '%c'\n", f->subclass.integer);
        ast_frfree(f);
        return dfr;
    }
 
    if (dfr) {
        ast_frfree(dfr);
    }
    return f;
}

References ao2_ref, ast_async_goto(), ast_channel_caller(), ast_channel_context(), ast_channel_exten(), ast_channel_fdno(), ast_channel_name(), ast_channel_nativeformats(), ast_channel_nativeformats_set(), ast_channel_readformat(), ast_channel_writeformat(), ast_debug, ast_dsp_process(), ast_exists_extension(), ast_format_alaw, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_iscompatible_format(), ast_format_cmp(), AST_FORMAT_CMP_EQUAL, AST_FORMAT_CMP_NOT_EQUAL, ast_format_get_name(), ast_format_slin, ast_format_ulaw, AST_FRAME_DTMF, AST_FRAME_NULL, AST_FRAME_VOICE, ast_frdup, ast_frfree, ast_log, ast_null_frame, ast_rtp_instance_read(), ast_set_read_format(), ast_set_write_format(), ast_udptl_read(), ast_verb, ooh323_pvt::callToken, ooh323_pvt::chmodepend, ast_frame::datalen, ooh323_pvt::dtmfmode, ooh323_pvt::faxdetect, FAXDETECT_CNG, ooh323_pvt::faxdetected, ooh323_pvt::faxmode, ast_frame_subclass::format, ast_frame::frametype, gH323Debug, H323_DTMF_INBAND, ast_party_caller::id, ast_frame_subclass::integer, ooh323_pvt::lastrtprx, LOG_NOTICE, NULL, ast_party_id::number, ooh323_pvt::owner, pbx_builtin_setvar_helper(), ooh323_pvt::rtp, S_COR, ast_party_number::str, ast_frame::subclass, T38_DISABLED, ooh323_pvt::t38support, ooh323_pvt::udptl, ooh323_pvt::vad, ast_party_number::valid, and ooh323_pvt::vrtp.

Referenced by ooh323_read().

ooh323_set_read_format()

void ooh323_set_read_format	(	ooCallData *	call,
		struct ast_format *	fmt
	)

Definition at line 1625 of file chan_ooh323.c.

{
    struct ooh323_pvt *p = NULL;
 
    if (gH323Debug)
        ast_verb(0, "---   ooh323_update_readformat %s\n",
                ast_format_get_name(fmt));
 
    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);
 
    ao2_replace(p->readformat, fmt);
 
    if (p->owner) {
        struct ast_format_cap *caps;
 
        caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
        if (!caps) {
            ast_log(LOG_ERROR, "Could not allocate capabilities structure\n");
            return;
        }
 
        while (p->owner && ast_channel_trylock(p->owner)) {
            ast_debug(1,"Failed to grab lock, trying again\n");
            DEADLOCK_AVOIDANCE(&p->lock);
        }
        if (!p->owner) {
            ast_mutex_unlock(&p->lock);
            ast_log(LOG_ERROR, "Channel has no owner\n");
            ao2_ref(caps, -1);
            return;
        }
 
        if (gH323Debug) {
            ast_verb(0, "Readformat before update %s\n",
              ast_format_get_name(ast_channel_readformat(p->owner)));
        }
        ast_format_cap_append(caps, fmt, 0);
        ast_channel_nativeformats_set(p->owner, caps);
        ao2_ref(caps, -1);
        ast_set_read_format(p->owner, ast_channel_readformat(p->owner));
        ast_channel_unlock(p->owner);
    } else
        ast_log(LOG_ERROR, "No owner found\n");
 
    ast_mutex_unlock(&p->lock);
 
    if (gH323Debug)
        ast_verb(0, "+++   ooh323_update_readformat\n");
}

References ao2_ref, ao2_replace, ast_channel_nativeformats_set(), ast_channel_readformat(), ast_channel_trylock, ast_channel_unlock, ast_debug, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_get_name(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_set_read_format(), ast_verb, call(), DEADLOCK_AVOIDANCE, find_call(), gH323Debug, ooh323_pvt::lock, LOG_ERROR, NULL, ooh323_pvt::owner, and ooh323_pvt::readformat.

ooh323_set_write_format()

void ooh323_set_write_format	(	ooCallData *	call,
		struct ast_format *	fmt,
		int	txframes
	)

Definition at line 1553 of file chan_ooh323.c.

{
    struct ooh323_pvt *p = NULL;
 
    if (gH323Debug)
        ast_verb(0, "---   ooh323_update_writeformat %s/%d\n",
                ast_format_get_name(fmt), txframes);
 
    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);
 
    ao2_replace(p->writeformat, fmt);
 
    if (p->owner) {
        struct ast_format_cap *caps;
 
        caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
        if (!caps) {
            ast_log(LOG_ERROR, "Could not allocate capabilities structure\n");
            return;
        }
 
        while (p->owner && ast_channel_trylock(p->owner)) {
            ast_debug(1,"Failed to grab lock, trying again\n");
            DEADLOCK_AVOIDANCE(&p->lock);
        }
        if (!p->owner) {
            ast_mutex_unlock(&p->lock);
            ast_log(LOG_ERROR, "Channel has no owner\n");
            ao2_ref(caps, -1);
            return;
        }
        if (gH323Debug) {
            struct ast_str *codec_buf = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
            ast_verb(0, "Writeformat before update %s/%s\n",
              ast_format_get_name(ast_channel_writeformat(p->owner)),
              ast_format_cap_get_names(ast_channel_nativeformats(p->owner), &codec_buf));
        }
 
        if (p->dtmfmode & H323_DTMF_RFC2833 && p->dtmfcodec) {
            ast_rtp_codecs_payloads_set_rtpmap_type(ast_rtp_instance_get_codecs(p->rtp),
                 p->rtp, p->dtmfcodec, "audio", "telephone-event", 0);
        }
        if (p->dtmfmode & H323_DTMF_CISCO && p->dtmfcodec) {
            ast_rtp_codecs_payloads_set_rtpmap_type(ast_rtp_instance_get_codecs(p->rtp),
                 p->rtp, p->dtmfcodec, "audio", "cisco-telephone-event", 0);
        }
 
        if (txframes) {
            ast_format_cap_set_framing(caps, txframes);
        }
        ast_format_cap_append(caps, fmt, 0);
        ast_channel_nativeformats_set(p->owner, caps);
        ao2_ref(caps, -1);
        ast_set_write_format(p->owner, ast_channel_writeformat(p->owner));
        ast_set_read_format(p->owner, ast_channel_readformat(p->owner));
        ast_channel_unlock(p->owner);
    } else
        ast_log(LOG_ERROR, "No owner found\n");
 
 
    ast_mutex_unlock(&p->lock);
 
    if (gH323Debug)
        ast_verb(0, "+++   ooh323_update_writeformat\n");
}

References ao2_ref, ao2_replace, ast_channel_nativeformats(), ast_channel_nativeformats_set(), ast_channel_readformat(), ast_channel_trylock, ast_channel_unlock, ast_channel_writeformat(), ast_debug, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_names(), AST_FORMAT_CAP_NAMES_LEN, ast_format_cap_set_framing(), ast_format_get_name(), ast_log, ast_mutex_lock, ast_mutex_unlock, ast_rtp_codecs_payloads_set_rtpmap_type(), ast_rtp_instance_get_codecs(), ast_set_read_format(), ast_set_write_format(), ast_str_alloca, ast_verb, call(), DEADLOCK_AVOIDANCE, ooh323_pvt::dtmfcodec, ooh323_pvt::dtmfmode, find_call(), gH323Debug, H323_DTMF_CISCO, H323_DTMF_RFC2833, ooh323_pvt::lock, LOG_ERROR, NULL, ooh323_pvt::owner, ooh323_pvt::rtp, and ooh323_pvt::writeformat.

Referenced by ooh323c_start_transmit_channel().

reload_config()

int reload_config

(

int

reload

)

Definition at line 2813 of file chan_ooh323.c.

{
    int format;
    struct ooAliases  *pNewAlias = NULL, *cur, *prev;
    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_verb(0, "---   reload_config\n");
 
    cfg = ast_config_load((char*)config, 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();
        if (gH323Debug) {
            ast_verb(0, "  reload_config - Freeing up alias list\n");
        }
        cur = gAliasList;
        while (cur) {
            prev = cur;
            cur = cur->next;
            ast_free(prev->value);
            ast_free(prev);
        }
        gAliasList = NULL;
        ooH323EpClearAllAliases();
    }
 
    /* Inintialize everything to default */
    snprintf(gLogFile, sizeof(gLogFile), "%s/%s", ast_config_AST_LOG_DIR, DEFAULT_LOGFILE);
    gPort = 1720;
    gIP[0] = '\0';
    strcpy(gCallerID, DEFAULT_H323ID);
    ast_format_cap_remove_by_type(gCap, AST_MEDIA_TYPE_UNKNOWN);
    ast_format_cap_append(gCap, ast_format_ulaw, 0);
    gDTMFMode = H323_DTMF_RFC2833;
    gDTMFCodec = 101;
    gFAXdetect = FAXDETECT_CNG;
    gT38Support = T38_FAXGW;
    gTRCLVL = OOTRCLVLERR;
    gRasGkMode = RasNoGatekeeper;
    gGatekeeper[0] = '\0';
    gRASIP[0] = '\0';
    gRTPTimeout = 60;
    gNat = FALSE;
    gRTDRInterval = 0;
    gRTDRCount = 0;
    strcpy(gAccountcode, DEFAULT_H323ACCNT);
    gFastStart = 1;
    gTunneling = 1;
    gTOS = 0;
    strcpy(gContext, DEFAULT_CONTEXT);
    gAliasList = NULL;
    gMediaWaitForConnect = 0;
    ooconfig.mTCPPortStart = 12030;
    ooconfig.mTCPPortEnd = 12230;
    memcpy(&global_jbconf, &default_jbconf, sizeof(struct ast_jb_conf));
 
    v = ast_variable_browse(cfg, "general");
    while (v) {
 
        if (!ast_jb_read_conf(&global_jbconf, v->name, v->value)) {
            v = v->next;
            continue;
        }
 
        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));
            if (ast_parse_arg(v->value, PARSE_ADDR, &bindaddr)) {
                ast_log(LOG_WARNING, "Invalid address: %s\n", v->value);
                ast_config_destroy(cfg);
                return 1;
            }
            if (ast_sockaddr_is_ipv6(&bindaddr)) {
                v6mode = 1;
            }
        } else if (!strcasecmp(v->name, "h225portrange")) {
            char* endlimit = 0;
                char temp[512];
            ast_copy_string(temp, v->value, sizeof(temp));
            endlimit = strchr(temp, ',');
            if (endlimit) {
                *endlimit = '\0';
                endlimit++;
                ooconfig.mTCPPortStart = atoi(temp);
                ooconfig.mTCPPortEnd = atoi(endlimit);
 
            } 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, "directrtp") || !strcasecmp(v->name, "directmedia")) {
            gDirectRTP = ast_true(v->value);
            gEarlyDirect = ast_true(v->value);
        } else if (!strcasecmp(v->name, "earlydirect") || !strcasecmp(v->name, "directrtpsetup")) {
            gEarlyDirect = ast_true(v->value);
        } else if (!strcasecmp(v->name, "g729onlyA")) {
            g729onlyA = ast_true(v->value);
        } else if (!strcasecmp(v->name, "roundtrip")) {
            sscanf(v->value, "%d,%d", &gRTDRCount, &gRTDRInterval);
            } else if (!strcasecmp(v->name, "trybemaster")) {
            gBeMaster = ast_true(v->value);
            if (gBeMaster)
                ooH323EpTryBeMaster(1);
            else
                ooH323EpTryBeMaster(0);
        } else if (!strcasecmp(v->name, "h323id")) {
                pNewAlias = ast_calloc(1, sizeof(struct ooAliases));
            if (!pNewAlias) {
                ast_log(LOG_ERROR, "Failed to allocate memory for h323id alias\n");
                ast_config_destroy(cfg);
                return 1;
            }
            if (gAliasList == NULL) { /* first h323id - set as callerid if callerid is not set */
                ast_copy_string(gCallerID, v->value, sizeof(gCallerID));
            }
            pNewAlias->type =  T_H225AliasAddress_h323_ID;
            pNewAlias->value = ast_strdup(v->value);
            pNewAlias->next = gAliasList;
            gAliasList = pNewAlias;
            pNewAlias = NULL;
        } else if (!strcasecmp(v->name, "e164")) {
            int valid = 1;
            const char *tmp;
            for(tmp = v->value; *tmp; tmp++) {
                if (!isdigit(*tmp)) {
                    valid = 0;
                    break;
                }
            }
            if (valid) {
                    pNewAlias = ast_calloc(1, sizeof(struct ooAliases));
                if (!pNewAlias) {
                    ast_log(LOG_ERROR, "Failed to allocate memory for e164 alias\n");
                    ast_config_destroy(cfg);
                    return 1;
                }
                pNewAlias->type =  T_H225AliasAddress_dialedDigits;
                pNewAlias->value = ast_strdup(v->value);
                pNewAlias->next = gAliasList;
                gAliasList = pNewAlias;
                pNewAlias = NULL;
            } else {
                ast_log(LOG_ERROR, "Invalid e164: %s\n", v->value);
            }
        } else if (!strcasecmp(v->name, "email")) {
                pNewAlias = ast_calloc(1, sizeof(struct ooAliases));
            if (!pNewAlias) {
                ast_log(LOG_ERROR, "Failed to allocate memory for email alias\n");
                ast_config_destroy(cfg);
                return 1;
            }
            pNewAlias->type =  T_H225AliasAddress_email_ID;
            pNewAlias->value = ast_strdup(v->value);
            pNewAlias->next = gAliasList;
            gAliasList = pNewAlias;
            pNewAlias = NULL;
      } else if (!strcasecmp(v->name, "t35country")) {
         t35countrycode = atoi(v->value);
      } else if (!strcasecmp(v->name, "t35extensions")) {
         t35extensions = atoi(v->value);
      } else if (!strcasecmp(v->name, "manufacturer")) {
         manufacturer = atoi(v->value);
      } else if (!strcasecmp(v->name, "vendorid")) {
         ast_copy_string(vendor, v->value, sizeof(vendor));
      } else if (!strcasecmp(v->name, "versionid")) {
         ast_copy_string(version, v->value, sizeof(version));
        } 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, "localras")) {
                ast_copy_string(gRASIP, v->value, sizeof(gRASIP));
            ast_verb(3, "  == Setting RAS IP to %s\n", gRASIP);
        } else if (!strcasecmp(v->name, "logfile")) {
            if (v->value[0] == '/') {
                ast_copy_string(gLogFile, v->value, sizeof(gLogFile));
            } else {
                snprintf(gLogFile, sizeof(gLogFile), "%s/%s", ast_config_AST_LOG_DIR, v->value);
            }
        } 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, "nat")) {
            gNat = ast_true(v->value);
        } 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_channel_string2amaflag(v->value);
        } else if (!strcasecmp(v->name, "accountcode")) {
         ast_copy_string(gAccountcode, v->value, sizeof(gAccountcode));
        } else if (!strcasecmp(v->name, "disallow")) {
            ast_format_cap_update_by_allow_disallow(gCap, 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_format_cap_update_by_allow_disallow(gCap, 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, "cisco"))
                gDTMFMode = H323_DTMF_CISCO;
            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;
            }
        } else if (!strcasecmp(v->name, "relaxdtmf")) {
            gDTMFMode |= ast_true(v->value) ? H323_DTMF_INBANDRELAX : 0;
        } else if (!strcasecmp(v->name, "dtmfcodec") && atoi(v->value)) {
            gDTMFCodec = atoi(v->value);
        } else if (!strcasecmp(v->name, "faxdetect")) {
            if (ast_true(v->value)) {
                gFAXdetect = FAXDETECT_CNG | FAXDETECT_T38;
            } else if (ast_false(v->value)) {
                gFAXdetect = 0;
            } else {
                char *buf = ast_strdupa(v->value);
                char *word, *next = buf;
                gFAXdetect = 0;
                while ((word = strsep(&next, ","))) {
                    if (!strcasecmp(word, "cng")) {
                        gFAXdetect |= FAXDETECT_CNG;
                    } else if (!strcasecmp(word, "t38")) {
                        gFAXdetect |= FAXDETECT_T38;
                    } else {
                        ast_log(LOG_WARNING, "Unknown faxdetect mode '%s' on line %d.\n", word, v->lineno);
                    }
                }
 
            }
        } else if (!strcasecmp(v->name, "t38support")) {
            if (!strcasecmp(v->value, "disabled"))
                gT38Support = T38_DISABLED;
            if (!strcasecmp(v->value, "no"))
                gT38Support = T38_DISABLED;
            else if (!strcasecmp(v->value, "faxgw"))
                gT38Support = T38_FAXGW;
            else if (!strcasecmp(v->value, "yes"))
                gT38Support = T38_ENABLED;
        } else if (!strcasecmp(v->name, "tracelevel")) {
            gTRCLVL = atoi(v->value);
            ooH323EpSetTraceLevel(gTRCLVL);
        } else if (!strcasecmp(v->name, "aniasdni")) {
            gANIasDNI = ast_true(v->value);
        }
        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 neccessary */
    if (ast_strlen_zero(gIP)) {
        ooGetLocalIPAddress(gIP);
        if (!strcmp(gIP, "127.0.0.1") || !strcmp(gIP, "::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_verb(0, "+++   reload_config\n");
 
    return 0;
 
}

References ast_calloc, ast_category_browse(), ast_channel_string2amaflag(), ast_config_AST_LOG_DIR, ast_config_destroy(), ast_config_load, ast_copy_string(), ast_false(), ast_format_cap_append, ast_format_cap_remove_by_type(), ast_format_cap_update_by_allow_disallow(), ast_format_ulaw, ast_free, ast_jb_read_conf(), ast_log, AST_MEDIA_TYPE_UNKNOWN, ast_mutex_lock, ast_mutex_unlock, ast_parse_arg(), ast_sockaddr_is_ipv6(), ast_strdup, ast_strdupa, ast_strlen_zero(), ast_true(), ast_variable_browse(), ast_variable_retrieve(), ast_verb, bindaddr, buf, build_peer(), build_user(), config, CONFIG_FLAG_FILEUNCHANGED, CONFIG_STATUS_FILEUNCHANGED, DEFAULT_CONTEXT, DEFAULT_H323ACCNT, DEFAULT_H323ID, default_jbconf, DEFAULT_LOGFILE, delete_peers(), delete_users(), FALSE, FAXDETECT_CNG, FAXDETECT_T38, g729onlyA, gAccountcode, gAliasList, gAMAFLAGS, gANIasDNI, gBeMaster, gCallerID, gCap, gContext, gDirectRTP, gDTMFCodec, gDTMFMode, gEarlyDirect, gFastStart, gFAXdetect, gGatekeeper, gH323Debug, gIncomingLimit, gIP, gIsGateway, global_jbconf, gLogFile, gMediaWaitForConnect, gNat, gOutgoingLimit, gPort, gRasGkMode, gRASIP, gRTDRCount, gRTDRInterval, gRTPTimeout, gT38Support, gTOS, gTRCLVL, gTunneling, H323_DTMF_CISCO, H323_DTMF_H245ALPHANUMERIC, H323_DTMF_H245SIGNAL, H323_DTMF_INBAND, H323_DTMF_INBANDRELAX, H323_DTMF_Q931, H323_DTMF_RFC2833, IPTOS_MINCOST, ast_variable::lineno, ast_user_list::lock, ast_peer_list::lock, LOG_ERROR, LOG_NOTICE, LOG_WARNING, manufacturer, ooh323_config::mTCPPortEnd, ooh323_config::mTCPPortStart, ast_variable::name, ooh323_peer::next, ast_variable::next, NULL, ooconfig, PARSE_ADDR, peerl, ast_peer_list::peers, reload(), RESULT_SUCCESS, strsep(), t35countrycode, t35extensions, T38_DISABLED, T38_ENABLED, T38_FAXGW, tmp(), user, userl, ast_user_list::users, v6mode, ast_variable::value, vendor, and version.

Referenced by load_module(), and ooh323_do_reload().

restart_monitor()

int restart_monitor

(

void

)

Definition at line 4082 of file chan_ooh323.c.

{
    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;
}

References ast_log, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create, AST_PTHREADT_NULL, AST_PTHREADT_STOP, do_monitor(), LOG_ERROR, LOG_WARNING, monitor_thread, monlock, and NULL.

Referenced by handle_cli_ooh323_reload(), load_module(), ooh323_request(), and reload_module().

setup_rtp_connection()

void setup_rtp_connection	(	ooCallData *	call,
		const char *	remoteIp,
		int	remotePort
	)

Definition at line 4775 of file chan_ooh323.c.

{
    struct ooh323_pvt *p = NULL;
    struct ast_sockaddr tmp;
 
    if (gH323Debug)
        ast_verb(0, "---   setup_rtp_connection %s:%d\n", remoteIp, remotePort);
 
    /* Find the call or allocate a private structure if call not found */
    p = find_call(call);
 
    if (!p || !p->rtp) {
        ast_log(LOG_ERROR, "Something is wrong: rtp\n");
        return;
    }
 
    ast_mutex_lock(&p->lock);
 
    ast_parse_arg(remoteIp, PARSE_ADDR, &tmp);
    ast_sockaddr_set_port(&tmp, remotePort);
    ast_rtp_instance_set_remote_address(p->rtp, &tmp);
 
    if (ast_format_cmp(p->writeformat, ast_format_g726_aal2) == AST_FORMAT_CMP_EQUAL) {
                ast_rtp_codecs_payloads_set_rtpmap_type(ast_rtp_instance_get_codecs(p->rtp), p->rtp, 2,
                            "audio", "G726-32", AST_RTP_OPT_G726_NONSTANDARD);
    }
 
    ast_mutex_unlock(&p->lock);
 
    if(gH323Debug)
        ast_verb(0, "+++   setup_rtp_connection\n");
 
    return;
}

References ast_format_cmp(), AST_FORMAT_CMP_EQUAL, ast_format_g726_aal2, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_parse_arg(), ast_rtp_codecs_payloads_set_rtpmap_type(), ast_rtp_instance_get_codecs(), ast_rtp_instance_set_remote_address, AST_RTP_OPT_G726_NONSTANDARD, ast_sockaddr_set_port, ast_verb, call(), find_call(), gH323Debug, ooh323_pvt::lock, LOG_ERROR, NULL, PARSE_ADDR, ooh323_pvt::rtp, tmp(), and ooh323_pvt::writeformat.

Referenced by ooh323c_start_transmit_channel().

setup_udptl_connection()

void setup_udptl_connection	(	ooCallData *	call,
		const char *	remoteIp,
		int	remotePort
	)

Definition at line 4839 of file chan_ooh323.c.

{
    struct ooh323_pvt *p = NULL;
    struct ast_sockaddr them;
 
    if (gH323Debug)
        ast_verb(0, "---   setup_udptl_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;
    }
 
    ast_mutex_lock(&p->lock);
    if (p->owner) {
        while (p->owner && ast_channel_trylock(p->owner)) {
            ast_debug(1, "Failed to grab lock, trying again\n");
            DEADLOCK_AVOIDANCE(&p->lock);
        }
        if (!p->owner) {
            ast_mutex_unlock(&p->lock);
            ast_log(LOG_ERROR, "Channel has no owner\n");
            return;
        }
    } else {
        ast_mutex_unlock(&p->lock);
        ast_log(LOG_ERROR, "Channel has no owner\n");
        return;
    }
 
    ast_parse_arg(remoteIp, PARSE_ADDR, &them);
    ast_sockaddr_set_port(&them, remotePort);
 
    ast_udptl_set_peer(p->udptl, &them);
    ast_udptl_set_tag(p->udptl, "%s", ast_channel_name(p->owner));
    p->t38_tx_enable = 1;
    p->lastTxT38 = time(NULL);
    if (p->t38support == T38_ENABLED) {
        struct ast_control_t38_parameters parameters = { .request_response = 0 };
        parameters.request_response = AST_T38_NEGOTIATED;
        parameters.max_ifp = ast_udptl_get_far_max_ifp(p->udptl);
        parameters.rate = AST_T38_RATE_14400;
        ast_queue_control_data(p->owner, AST_CONTROL_T38_PARAMETERS, &parameters, sizeof(parameters));
    }
    if (gH323Debug) {
        ast_debug(1, "Receiving UDPTL  %s:%d\n", ast_sockaddr_stringify_host(&them),
                            ast_sockaddr_port(&them));
    }
 
    ast_channel_unlock(p->owner);
    ast_mutex_unlock(&p->lock);
 
    if(gH323Debug)
        ast_verb(0, "+++   setup_udptl_connection\n");
 
    return;
}

References ast_channel_name(), ast_channel_trylock, ast_channel_unlock, AST_CONTROL_T38_PARAMETERS, ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_parse_arg(), ast_queue_control_data(), ast_sockaddr_port, ast_sockaddr_set_port, ast_sockaddr_stringify_host(), AST_T38_NEGOTIATED, AST_T38_RATE_14400, ast_udptl_get_far_max_ifp(), ast_udptl_set_peer(), ast_udptl_set_tag(), ast_verb, call(), DEADLOCK_AVOIDANCE, find_call(), gH323Debug, ooh323_pvt::lastTxT38, ooh323_pvt::lock, LOG_ERROR, ast_control_t38_parameters::max_ifp, NULL, ooh323_pvt::owner, PARSE_ADDR, ast_control_t38_parameters::rate, ast_control_t38_parameters::request_response, T38_ENABLED, ooh323_pvt::t38_tx_enable, ooh323_pvt::t38support, and ooh323_pvt::udptl.

Referenced by ooh323c_start_transmit_datachannel().

update_our_aliases()

int update_our_aliases	(	ooCallData *	call,
		struct ooh323_pvt *	p
	)

Definition at line 4949 of file chan_ooh323.c.

{
    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;
}

References ast_copy_string(), call(), ooh323_pvt::callee_dialedDigits, ooh323_pvt::callee_email, ooh323_pvt::callee_h323id, ooh323_pvt::callee_url, and NULL.

Referenced by ooh323_onReceivedSetup().