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)
	Start the channel monitor thread. More...
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.

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

Referenced by ooh323c_stop_transmit_channel().

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

close_udptl_connection()

void close_udptl_connection

(

ooCallData *

call

)

Definition at line 4901 of file chan_ooh323.c.

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, 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().

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

configure_local_rtp()

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

Definition at line 4599 of file chan_ooh323.c.

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, ooh323_pvt::cap, DEADLOCK_AVOIDANCE, ooh323_pvt::dtmfcodec, ooh323_pvt::dtmfmode, errno, format, gH323Debug, gTOS, H323_DTMF_CISCO, H323_DTMF_RFC2833, 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, and ooh323_pvt::udptl.

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

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

delete_peers()

int delete_peers

(

void

)

Definition at line 4230 of file chan_ooh323.c.

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().

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

delete_users()

int delete_users

(

void

)

Definition at line 4265 of file chan_ooh323.c.

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().

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

find_peer()

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

Definition at line 890 of file chan_ooh323.c.

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, ooh323_peer::next, ooh323_pvt::peer, peerl, and ast_peer_list::peers.

Referenced by ooh323_request().

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

find_user()

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

Definition at line 832 of file chan_ooh323.c.

References ast_mutex_lock, ast_mutex_unlock, ast_verb, gH323Debug, ast_user_list::lock, ooh323_user::mIP, ooh323_user::mUseIP, ooh323_user::name, ooh323_user::next, ooh323_pvt::user, userl, and ast_user_list::users.

Referenced by ooh323_destroy(), and ooh323_onReceivedSetup().

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

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.

References ast_cli_args::argc, 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.

{

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

ooh323_convert_hangupcause_asteriskToH323()

int ooh323_convert_hangupcause_asteriskToH323

(

int

cause

)

Definition at line 5179 of file chan_ooh323.c.

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().

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


}

ooh323_convert_hangupcause_h323ToAsterisk()

int ooh323_convert_hangupcause_h323ToAsterisk

(

int

cause

)

Definition at line 5206 of file chan_ooh323.c.

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, AST_CAUSE_UNALLOCATED, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_CHANNEL_DRIVER, AST_MODULE_INFO(), AST_MODULE_SUPPORT_EXTENDED, ASTERISK_GPL_KEY, load_module(), reload(), reload_module(), and unload_module().

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

ooh323_convertAsteriskCapToH323Cap()

int ooh323_convertAsteriskCapToH323Cap

(

struct ast_format *

format

)

Definition at line 4506 of file chan_ooh323.c.

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().

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

ooh323_delete_peer()

void ooh323_delete_peer

(

struct ooh323_peer *

peer

)

Definition at line 2328 of file chan_ooh323.c.

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().

{
   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");

}

ooh323_destroy()

int ooh323_destroy

(

struct ooh323_pvt *

p

)

Definition at line 4117 of file chan_ooh323.c.

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, ooh323_user::inUse, ooh323_user::lock, ooh323_pvt::next, NULL, and ooh323_pvt::username.

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

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

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.

References ast_channel_trylock, ast_channel_unlock, ast_debug, AST_FRAME_DTMF, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_queue_frame(), ast_frame::data, ast_frame::datalen, DEADLOCK_AVOIDANCE, 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().

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

ooh323_onReceivedSetup()

int ooh323_onReceivedSetup	(	ooCallData *	call,
		Q931Message *	pmsg
	)

Definition at line 1840 of file chan_ooh323.c.

References ooh323_pvt::accountcode, ooh323_user::accountcode, ooh323_pvt::amaflags, ooh323_user::amaflags, ooh323_pvt::aniasdni, ooh323_user::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, 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, ooh323_user::cap, configure_local_rtp(), ooh323_pvt::context, ooh323_user::context, ooh323_pvt::directrtp, ooh323_user::directrtp, ooh323_pvt::dtmfcodec, ooh323_user::dtmfcodec, ooh323_pvt::dtmfmode, ooh323_user::dtmfmode, ooh323_pvt::earlydirect, ooh323_user::earlydirect, ooh323_pvt::exten, ooh323_pvt::faststart, ooh323_user::faststart, ooh323_pvt::faxdetect, ooh323_user::faxdetect, find_user(), ooh323_pvt::flags, ooh323_pvt::g729onlyA, ooh323_user::g729onlyA, gDirectRTP, gEarlyDirect, gH323Debug, ooh323_pvt::h245tunneling, ooh323_user::h245tunneling, H323_DISABLEGK, H323_NEEDDESTROY, H323_OUTGOING, ooh323_user::incominglimit, ooh323_user::inUse, ooh323_pvt::lock, ooh323_user::lock, LOG_ERROR, ooh323_user::mIP, ooh323_user::mUseIP, ooh323_user::name, ooh323_pvt::nat, ooh323_user::nat, ooh323_pvt::neighbor, NULL, ooh323_alloc(), ooh323_convert_hangupcause_asteriskToH323(), ooh323_new(), ooh323c_set_capability_for_call(), ooh323_pvt::rtdrcount, ooh323_user::rtdrcount, ooh323_pvt::rtdrinterval, ooh323_user::rtdrinterval, ooh323_pvt::rtpmask, ooh323_user::rtpmask, ooh323_pvt::rtpmaskstr, ooh323_user::rtpmaskstr, ooh323_pvt::rtptimeout, ooh323_user::rtptimeout, ooh323_pvt::t38support, ooh323_user::t38support, update_our_aliases(), ooh323_pvt::user, and ooh323_pvt::username.

Referenced by load_module().

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

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.

References ao2_ref, ast_async_goto(), ast_channel_caller(), ast_channel_context(), ast_channel_exten(), ast_channel_fdno(), ast_channel_macrocontext(), 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, S_OR, 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().

{
   /* 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 = S_OR(ast_channel_macrocontext(p->owner), 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;
}

ooh323_set_read_format()

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

Definition at line 1625 of file chan_ooh323.c.

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, DEADLOCK_AVOIDANCE, find_call(), gH323Debug, ooh323_pvt::lock, LOG_ERROR, NULL, ooh323_pvt::owner, and ooh323_pvt::readformat.

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

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.

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, 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().

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

reload_config()

int reload_config

(

int

reload

)

Definition at line 2813 of file chan_ooh323.c.

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_LOGFILE, delete_peers(), delete_users(), FALSE, FAXDETECT_CNG, FAXDETECT_T38, format, ooh323_pvt::g729onlyA, gAccountcode, gAliasList, gAMAFLAGS, gANIasDNI, gBeMaster, gCallerID, 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, ast_variable::next, ooh323_pvt::next, ooh323_user::next, ooh323_peer::next, NULL, ooconfig, PARSE_ADDR, ooh323_pvt::peer, peerl, ast_peer_list::peers, RESULT_SUCCESS, strsep(), t35countrycode, t35extensions, T38_DISABLED, T38_ENABLED, T38_FAXGW, tmp(), ooh323_pvt::user, userl, ast_user_list::users, v6mode, ast_variable::value, vendor, and version.

Referenced by load_module(), and ooh323_do_reload().

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

}

restart_monitor()

int restart_monitor

(

void

)

Start the channel monitor thread.

Definition at line 4082 of file chan_ooh323.c.

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().

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

setup_rtp_connection()

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

Definition at line 4775 of file chan_ooh323.c.

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, find_call(), gH323Debug, ooh323_pvt::lock, LOG_ERROR, NULL, PARSE_ADDR, ooh323_pvt::rtp, and ooh323_pvt::writeformat.

Referenced by ooh323c_start_transmit_channel().

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

setup_udptl_connection()

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

Definition at line 4839 of file chan_ooh323.c.

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, 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().

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

update_our_aliases()

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

Definition at line 4949 of file chan_ooh323.c.

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

Referenced by ooh323_onReceivedSetup().

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