chan_local.c File Reference

Local Proxy Channel. More...

#include "asterisk.h"
#include <fcntl.h>
#include <sys/signal.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/sched.h"
#include "asterisk/io.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/stringfields.h"
#include "asterisk/devicestate.h"

Include dependency graph for chan_local.c:

Go to the source code of this file.

Data Structures
struct	local_pvt
struct	locals
Defines
#define	IS_OUTBOUND(a, b)   (a == b->chan ? 1 : 0)
#define	LOCAL_ALREADY_MASQED   (1 << 2)
#define	LOCAL_BRIDGE   (1 << 5)
#define	LOCAL_CANCEL_QUEUE   (1 << 1)
#define	LOCAL_GLARE_DETECT   (1 << 0)
#define	LOCAL_LAUNCHED_PBX   (1 << 3)
#define	LOCAL_NO_OPTIMIZATION   (1 << 4)
Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static void	check_bridge (struct local_pvt *p, int isoutbound)
static int	load_module (void)
	Load module into PBX, register channel.
static struct local_pvt *	local_alloc (const char *data, int format)
	Create a call structure.
static int	local_answer (struct ast_channel *ast)
static struct ast_channel *	local_bridgedchannel (struct ast_channel *chan, struct ast_channel *bridge)
	Return the bridged channel of a Local channel.
static int	local_call (struct ast_channel *ast, char *dest, int timeout)
	Initiate new call, part of PBX interface dest is the dial string.
static int	local_devicestate (void *data)
	Adds devicestate to local channels.
static int	local_digit_begin (struct ast_channel *ast, char digit)
static int	local_digit_end (struct ast_channel *ast, char digit, unsigned int duration)
static int	local_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static int	local_hangup (struct ast_channel *ast)
	Hangup a call through the local proxy channel.
static int	local_indicate (struct ast_channel *ast, int condition, const void *data, size_t datalen)
static struct ast_channel *	local_new (struct local_pvt *p, int state, const char *linkedid)
	Start new local channel.
static struct local_pvt *	local_pvt_destroy (struct local_pvt *pvt)
static int	local_queue_frame (struct local_pvt *p, int isoutbound, struct ast_frame *f, struct ast_channel *us, int us_locked)
static struct ast_frame *	local_read (struct ast_channel *ast)
static struct ast_channel *	local_request (const char *type, int format, const struct ast_channel *requestor, void *data, int *cause)
	Part of PBX interface.
static int	local_sendhtml (struct ast_channel *ast, int subclass, const char *data, int datalen)
static int	local_sendtext (struct ast_channel *ast, const char *text)
static int	local_write (struct ast_channel *ast, struct ast_frame *f)
static char *	locals_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command "local show channels".
static int	unload_module (void)
	Unload the local proxy channel from Asterisk.
Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Local Proxy Channel (Note: used internally by other modules)" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, }
static struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_cli_entry	cli_local []
static struct ast_jb_conf	g_jb_conf
static struct ast_channel_tech	local_tech
static const char	tdesc [] = "Local Proxy Channel Driver"

---

Detailed Description

Local Proxy Channel.

Author:

Mark Spencer <markster@digium.com>

Definition in file chan_local.c.

---

Define Documentation

#define IS_OUTBOUND	(	a,
		b		)	(a == b->chan ? 1 : 0)

Definition at line 54 of file chan_local.c.

Referenced by local_answer(), local_digit_begin(), local_digit_end(), local_hangup(), local_indicate(), local_sendhtml(), local_sendtext(), and local_write().

#define LOCAL_ALREADY_MASQED   (1 << 2)

Already masqueraded

Definition at line 117 of file chan_local.c.

Referenced by check_bridge(), and local_write().

#define LOCAL_BRIDGE   (1 << 5)

Report back the "true" channel as being bridged to

Definition at line 120 of file chan_local.c.

Referenced by local_alloc(), and local_bridgedchannel().

#define LOCAL_CANCEL_QUEUE   (1 << 1)

Cancel queue

Definition at line 116 of file chan_local.c.

Referenced by local_hangup(), and local_queue_frame().

#define LOCAL_GLARE_DETECT   (1 << 0)

Detect glare on hangup

Definition at line 115 of file chan_local.c.

Referenced by local_hangup(), and local_queue_frame().

#define LOCAL_LAUNCHED_PBX   (1 << 3)

PBX was launched

Definition at line 118 of file chan_local.c.

Referenced by local_call(), and local_hangup().

#define LOCAL_NO_OPTIMIZATION   (1 << 4)

Do not optimize using masquerading

Definition at line 119 of file chan_local.c.

Referenced by check_bridge(), and local_alloc().

---

Function Documentation

static void __reg_module

(

void

)

[static]

Definition at line 938 of file chan_local.c.

: used internally by other modules)");

static void __unreg_module

(

void

)

[static]

Definition at line 938 of file chan_local.c.

: used internally by other modules)");

static void check_bridge	(	struct local_pvt *	p,
		int	isoutbound
	)			[static]

Definition at line 277 of file chan_local.c.

References ast_channel::_bridge, ast_app_group_update(), ast_bridged_channel(), ast_channel_masquerade(), ast_channel_trylock, ast_channel_unlock, ast_check_hangup(), AST_LIST_EMPTY, ast_mutex_trylock(), ast_mutex_unlock(), ast_set_flag, ast_test_flag, ast_channel::audiohooks, local_pvt::chan, LOCAL_ALREADY_MASQED, LOCAL_NO_OPTIMIZATION, ast_channel::monitor, local_pvt::owner, and ast_channel::readq.

Referenced by local_write().

{
   struct ast_channel_monitor *tmp;
   if (ast_test_flag(p, LOCAL_ALREADY_MASQED) || ast_test_flag(p, LOCAL_NO_OPTIMIZATION) || !p->chan || !p->owner || (p->chan->_bridge != ast_bridged_channel(p->chan)))
      return;

   /* only do the masquerade if we are being called on the outbound channel,
      if it has been bridged to another channel and if there are no pending
      frames on the owner channel (because they would be transferred to the
      outbound channel during the masquerade)
   */
   if (isoutbound && p->chan->_bridge /* Not ast_bridged_channel!  Only go one step! */ && AST_LIST_EMPTY(&p->owner->readq)) {
      /* Masquerade bridged channel into owner */
      /* Lock everything we need, one by one, and give up if
         we can't get everything.  Remember, we'll get another
         chance in just a little bit */
      if (!ast_channel_trylock(p->chan->_bridge)) {
         if (!ast_check_hangup(p->chan->_bridge)) {
            if (!ast_channel_trylock(p->owner)) {
               if (!ast_check_hangup(p->owner)) {
                  if (p->owner->monitor && !p->chan->_bridge->monitor) {
                     /* If a local channel is being monitored, we don't want a masquerade
                      * to cause the monitor to go away. Since the masquerade swaps the monitors,
                      * pre-swapping the monitors before the masquerade will ensure that the monitor
                      * ends up where it is expected.
                      */
                     tmp = p->owner->monitor;
                     p->owner->monitor = p->chan->_bridge->monitor;
                     p->chan->_bridge->monitor = tmp;
                  }
                  if (p->chan->audiohooks) {
                     struct ast_audiohook_list *audiohooks_swapper;
                     audiohooks_swapper = p->chan->audiohooks;
                     p->chan->audiohooks = p->owner->audiohooks;
                     p->owner->audiohooks = audiohooks_swapper;
                  }
                  ast_app_group_update(p->chan, p->owner);
                  ast_channel_masquerade(p->owner, p->chan->_bridge);
                  ast_set_flag(p, LOCAL_ALREADY_MASQED);
               }
               ast_channel_unlock(p->owner);
            }
            ast_channel_unlock(p->chan->_bridge);
         }
      }
   /* We only allow masquerading in one 'direction'... it's important to preserve the state
      (group variables, etc.) that live on p->chan->_bridge (and were put there by the dialplan)
      when the local channels go away.
   */
#if 0
   } else if (!isoutbound && p->owner && p->owner->_bridge && p->chan && AST_LIST_EMPTY(&p->chan->readq)) {
      /* Masquerade bridged channel into chan */
      if (!ast_mutex_trylock(&(p->owner->_bridge)->lock)) {
         if (!ast_check_hangup(p->owner->_bridge)) {
            if (!ast_mutex_trylock(&p->chan->lock)) {
               if (!ast_check_hangup(p->chan)) {
                  ast_channel_masquerade(p->chan, p->owner->_bridge);
                  ast_set_flag(p, LOCAL_ALREADY_MASQED);
               }
               ast_mutex_unlock(&p->chan->lock);
            }
         }
         ast_mutex_unlock(&(p->owner->_bridge)->lock);
      }
#endif
   }
}

static int load_module

(

void

)

[static]

Load module into PBX, register channel.

Definition at line 905 of file chan_local.c.

References ast_channel_register(), ast_cli_register_multiple(), ast_log(), AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, cli_local, and LOG_ERROR.

{
   /* Make sure we can register our channel type */
   if (ast_channel_register(&local_tech)) {
      ast_log(LOG_ERROR, "Unable to register channel class 'Local'\n");
      return AST_MODULE_LOAD_FAILURE;
   }
   ast_cli_register_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
   return AST_MODULE_LOAD_SUCCESS;
}

static struct local_pvt* local_alloc	(	const char *	data,
		int	format
	)			[static, read]

Create a call structure.

Definition at line 725 of file chan_local.c.

References ast_calloc, ast_copy_string(), ast_exists_extension(), AST_JB_ENABLED, AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_UNLOCK, ast_log(), ast_mutex_init(), ast_set_flag, ast_test_flag, local_pvt::context, local_pvt::exten, local_pvt::jb_conf, LOCAL_BRIDGE, LOCAL_NO_OPTIMIZATION, local_pvt_destroy(), local_pvt::lock, LOG_ERROR, LOG_NOTICE, and local_pvt::reqformat.

Referenced by local_request().

{
   struct local_pvt *tmp = NULL;
   char *c = NULL, *opts = NULL;

   if (!(tmp = ast_calloc(1, sizeof(*tmp))))
      return NULL;

   /* Initialize private structure information */
   ast_mutex_init(&tmp->lock);
   ast_copy_string(tmp->exten, data, sizeof(tmp->exten));

   memcpy(&tmp->jb_conf, &g_jb_conf, sizeof(tmp->jb_conf));

   /* Look for options */
   if ((opts = strchr(tmp->exten, '/'))) {
      *opts++ = '\0';
      if (strchr(opts, 'n'))
         ast_set_flag(tmp, LOCAL_NO_OPTIMIZATION);
      if (strchr(opts, 'j')) {
         if (ast_test_flag(tmp, LOCAL_NO_OPTIMIZATION))
            ast_set_flag(&tmp->jb_conf, AST_JB_ENABLED);
         else {
            ast_log(LOG_ERROR, "You must use the 'n' option for chan_local "
               "to use the 'j' option to enable the jitterbuffer\n");
         }
      }
      if (strchr(opts, 'b')) {
         ast_set_flag(tmp, LOCAL_BRIDGE);
      }
   }

   /* Look for a context */
   if ((c = strchr(tmp->exten, '@')))
      *c++ = '\0';

   ast_copy_string(tmp->context, c ? c : "default", sizeof(tmp->context));

   tmp->reqformat = format;

#if 0
   /* We can't do this check here, because we don't know the CallerID yet, and
    * the CallerID could potentially affect what step is actually taken (or
    * even if that step exists). */
   if (!ast_exists_extension(NULL, tmp->context, tmp->exten, 1, NULL)) {
      ast_log(LOG_NOTICE, "No such extension/context %s@%s creating local channel\n", tmp->exten, tmp->context);
      tmp = local_pvt_destroy(tmp);
   } else {
#endif
      /* Add to list */
      AST_LIST_LOCK(&locals);
      AST_LIST_INSERT_HEAD(&locals, tmp, list);
      AST_LIST_UNLOCK(&locals);
#if 0
   }
#endif
   
   return tmp;
}

static int local_answer

(

struct ast_channel *

ast

)

[static]

Definition at line 255 of file chan_local.c.

References AST_CONTROL_ANSWER, AST_FRAME_CONTROL, ast_log(), ast_mutex_lock(), ast_mutex_unlock(), IS_OUTBOUND, local_queue_frame(), local_pvt::lock, LOG_WARNING, and ast_channel::tech_pvt.

{
   struct local_pvt *p = ast->tech_pvt;
   int isoutbound;
   int res = -1;

   if (!p)
      return -1;

   ast_mutex_lock(&p->lock);
   isoutbound = IS_OUTBOUND(ast, p);
   if (isoutbound) {
      /* Pass along answer since somebody answered us */
      struct ast_frame answer = { AST_FRAME_CONTROL, AST_CONTROL_ANSWER };
      res = local_queue_frame(p, isoutbound, &answer, ast, 1);
   } else
      ast_log(LOG_WARNING, "Huh?  Local is being asked to answer?\n");
   if (!res)
      ast_mutex_unlock(&p->lock);
   return res;
}

static struct ast_channel * local_bridgedchannel	(	struct ast_channel *	chan,
		struct ast_channel *	bridge
	)			[static, read]

Return the bridged channel of a Local channel.

Definition at line 173 of file chan_local.c.

References ast_channel::_bridge, ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, local_pvt::chan, LOCAL_BRIDGE, local_pvt::lock, local_pvt::owner, and ast_channel::tech_pvt.

{
   struct local_pvt *p = bridge->tech_pvt;
   struct ast_channel *bridged = bridge;

   ast_mutex_lock(&p->lock);

   if (ast_test_flag(p, LOCAL_BRIDGE)) {
      /* Find the opposite channel */
      bridged = (bridge == p->owner ? p->chan : p->owner);
      
      /* Now see if the opposite channel is bridged to anything */
      if (!bridged) {
         bridged = bridge;
      } else if (bridged->_bridge) {
         bridged = bridged->_bridge;
      }
   }

   ast_mutex_unlock(&p->lock);

   return bridged;
}

static int local_call	(	struct ast_channel *	ast,
		char *	dest,
		int	timeout
	)			[static]

Initiate new call, part of PBX interface dest is the dial string.

Definition at line 540 of file chan_local.c.

References ast_channel::accountcode, accountcode, ast_calloc, ast_cdr_update(), ast_channel_datastore_inherit(), ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_connected_line_copy_from_caller(), ast_connected_line_copy_to_caller(), ast_exists_extension(), AST_FLAG_ANSWERED_ELSEWHERE, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_log(), ast_mutex_trylock(), ast_mutex_unlock(), ast_party_redirecting_copy(), ast_pbx_start(), ast_set_flag, ast_strdup, ast_string_field_set, ast_test_flag, ast_channel::cdrflags, local_pvt::chan, ast_channel::cid, ast_callerid::cid_dnid, ast_callerid::cid_num, ast_callerid::cid_rdnis, ast_callerid::cid_tns, ast_channel::connected, ast_channel::context, ast_var_t::entries, ast_channel::exten, ast_channel::language, language, len(), LOCAL_LAUNCHED_PBX, local_pvt::lock, LOG_NOTICE, ast_channel::musicclass, musicclass, ast_var_t::name, local_pvt::owner, ast_channel::redirecting, ast_channel::tech_pvt, and ast_channel::varshead.

{
   struct local_pvt *p = ast->tech_pvt;
   int res;
   struct ast_var_t *varptr = NULL, *new;
   size_t len, namelen;

   if (!p)
      return -1;

   /* If you value your sanity, please don't look at this code */
start_over:
   while (ast_channel_trylock(p->chan)) {
      ast_channel_unlock(p->owner);
      usleep(1);
      ast_channel_lock(p->owner);
   }

   /* p->owner and p->chan are locked now. Let's get p locked */
   if (ast_mutex_trylock(&p->lock)) {
      /* @#$&$@ */
      ast_channel_unlock(p->chan);
      ast_channel_unlock(p->owner);
      usleep(1);
      ast_channel_lock(p->owner);
      goto start_over;
   }

   /*
    * Note that cid_num and cid_name aren't passed in the ast_channel_alloc
    * call, so it's done here instead.
    *
    * All these failure points just return -1. The individual strings will
    * be cleared when we destroy the channel.
    */
   if (p->owner->cid.cid_rdnis) {
      if (!(p->chan->cid.cid_rdnis = ast_strdup(p->owner->cid.cid_rdnis))) {
         ast_mutex_unlock(&p->lock);
         ast_channel_unlock(p->chan);
         return -1;
      }
   }
   ast_party_redirecting_copy(&p->chan->redirecting, &p->owner->redirecting);

   if (p->owner->cid.cid_dnid) {
      if (!(p->chan->cid.cid_dnid = ast_strdup(p->owner->cid.cid_dnid))) {
         ast_mutex_unlock(&p->lock);
         ast_channel_unlock(p->chan);
         return -1;
      }
   }
   p->chan->cid.cid_tns = p->owner->cid.cid_tns;

   ast_connected_line_copy_to_caller(&p->chan->cid, &p->owner->connected);
   ast_connected_line_copy_from_caller(&p->chan->connected, &p->owner->cid);

   ast_string_field_set(p->chan, language, p->owner->language);
   ast_string_field_set(p->chan, accountcode, p->owner->accountcode);
   ast_string_field_set(p->chan, musicclass, p->owner->musicclass);
   ast_cdr_update(p->chan);
   p->chan->cdrflags = p->owner->cdrflags;

   if (!ast_exists_extension(NULL, p->chan->context, p->chan->exten, 1, p->owner->cid.cid_num)) {
      ast_log(LOG_NOTICE, "No such extension/context %s@%s while calling Local channel\n", p->chan->exten, p->chan->context);
      ast_mutex_unlock(&p->lock);
      ast_channel_unlock(p->chan);
      return -1;
   }

   /* Make sure we inherit the ANSWERED_ELSEWHERE flag if it's set on the queue/dial call request in the dialplan */
   if (ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE)) {
      ast_set_flag(p->chan, AST_FLAG_ANSWERED_ELSEWHERE);
   }

   /* copy the channel variables from the incoming channel to the outgoing channel */
   /* Note that due to certain assumptions, they MUST be in the same order */
   AST_LIST_TRAVERSE(&p->owner->varshead, varptr, entries) {
      namelen = strlen(varptr->name);
      len = sizeof(struct ast_var_t) + namelen + strlen(varptr->value) + 2;
      if ((new = ast_calloc(1, len))) {
         memcpy(new, varptr, len);
         new->value = &(new->name[0]) + namelen + 1;
         AST_LIST_INSERT_TAIL(&p->chan->varshead, new, entries);
      }
   }
   ast_channel_datastore_inherit(p->owner, p->chan);

   /* Start switch on sub channel */
   if (!(res = ast_pbx_start(p->chan)))
      ast_set_flag(p, LOCAL_LAUNCHED_PBX);

   ast_mutex_unlock(&p->lock);
   ast_channel_unlock(p->chan);
   return res;
}

static int local_devicestate

(

void *

data

)

[static]

Adds devicestate to local channels.

Definition at line 125 of file chan_local.c.

References ast_debug, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, ast_exists_extension(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_strdupa, local_pvt::context, local_pvt::exten, LOG_WARNING, and local_pvt::owner.

{
   char *exten = ast_strdupa(data);
   char *context = NULL, *opts = NULL;
   int res;
   struct local_pvt *lp;

   if (!(context = strchr(exten, '@'))) {
      ast_log(LOG_WARNING, "Someone used Local/%s somewhere without a @context. This is bad.\n", exten);
      return AST_DEVICE_INVALID; 
   }

   *context++ = '\0';

   /* Strip options if they exist */
   if ((opts = strchr(context, '/')))
      *opts = '\0';

   ast_debug(3, "Checking if extension %s@%s exists (devicestate)\n", exten, context);

   res = ast_exists_extension(NULL, context, exten, 1, NULL);
   if (!res)      
      return AST_DEVICE_INVALID;
   
   res = AST_DEVICE_NOT_INUSE;
   AST_LIST_LOCK(&locals);
   AST_LIST_TRAVERSE(&locals, lp, list) {
      if (!strcmp(exten, lp->exten) && !strcmp(context, lp->context) && lp->owner) {
         res = AST_DEVICE_INUSE;
         break;
      }
   }
   AST_LIST_UNLOCK(&locals);

   return res;
}

static int local_digit_begin	(	struct ast_channel *	ast,
		char	digit
	)			[static]

Definition at line 460 of file chan_local.c.

References AST_FRAME_DTMF_BEGIN, ast_mutex_lock(), ast_mutex_unlock(), IS_OUTBOUND, local_queue_frame(), local_pvt::lock, ast_frame::subclass, and ast_channel::tech_pvt.

{
   struct local_pvt *p = ast->tech_pvt;
   int res = -1;
   struct ast_frame f = { AST_FRAME_DTMF_BEGIN, };
   int isoutbound;

   if (!p)
      return -1;

   ast_mutex_lock(&p->lock);
   isoutbound = IS_OUTBOUND(ast, p);
   f.subclass = digit;
   if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
      ast_mutex_unlock(&p->lock);

   return res;
}

static int local_digit_end	(	struct ast_channel *	ast,
		char	digit,
		unsigned int	duration
	)			[static]

Definition at line 479 of file chan_local.c.

References AST_FRAME_DTMF_END, ast_mutex_lock(), ast_mutex_unlock(), IS_OUTBOUND, ast_frame::len, local_queue_frame(), local_pvt::lock, ast_frame::subclass, and ast_channel::tech_pvt.

{
   struct local_pvt *p = ast->tech_pvt;
   int res = -1;
   struct ast_frame f = { AST_FRAME_DTMF_END, };
   int isoutbound;

   if (!p)
      return -1;

   ast_mutex_lock(&p->lock);
   isoutbound = IS_OUTBOUND(ast, p);
   f.subclass = digit;
   f.len = duration;
   if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
      ast_mutex_unlock(&p->lock);

   return res;
}

static int local_fixup	(	struct ast_channel *	oldchan,
		struct ast_channel *	newchan
	)			[static]

Definition at line 375 of file chan_local.c.

References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), local_pvt::chan, local_pvt::lock, LOG_WARNING, local_pvt::owner, and ast_channel::tech_pvt.

{
   struct local_pvt *p = newchan->tech_pvt;

   if (!p)
      return -1;

   ast_mutex_lock(&p->lock);

   if ((p->owner != oldchan) && (p->chan != oldchan)) {
      ast_log(LOG_WARNING, "Old channel wasn't %p but was %p/%p\n", oldchan, p->owner, p->chan);
      ast_mutex_unlock(&p->lock);
      return -1;
   }
   if (p->owner == oldchan)
      p->owner = newchan;
   else
      p->chan = newchan;
   ast_mutex_unlock(&p->lock);
   return 0;
}

static int local_hangup

(

struct ast_channel *

ast

)

[static]

Hangup a call through the local proxy channel.

Definition at line 637 of file chan_local.c.

References ast_channel_lock, ast_channel_trylock, ast_channel_unlock, ast_clear_flag, AST_CONTROL_HANGUP, ast_debug, AST_FLAG_ANSWERED_ELSEWHERE, AST_FRAME_CONTROL, ast_hangup(), AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, ast_module_user_remove, ast_mutex_lock(), ast_mutex_unlock(), ast_queue_hangup(), ast_set_flag, ast_test_flag, local_pvt::chan, DEADLOCK_AVOIDANCE, ast_channel::hangupcause, IS_OUTBOUND, LOCAL_CANCEL_QUEUE, LOCAL_GLARE_DETECT, LOCAL_LAUNCHED_PBX, local_pvt_destroy(), local_queue_frame(), local_pvt::lock, local_pvt::owner, pbx_builtin_getvar_helper(), pbx_builtin_setvar_helper(), status, ast_channel::tech_pvt, local_pvt::u_chan, and local_pvt::u_owner.

{
   struct local_pvt *p = ast->tech_pvt;
   int isoutbound;
   struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_HANGUP, .data.uint32 = ast->hangupcause };
   struct ast_channel *ochan = NULL;
   int glaredetect = 0, res = 0;

   if (!p)
      return -1;

   ast_mutex_lock(&p->lock);

   isoutbound = IS_OUTBOUND(ast, p);

   if (p->chan && ast_test_flag(ast, AST_FLAG_ANSWERED_ELSEWHERE)) {
      ast_set_flag(p->chan, AST_FLAG_ANSWERED_ELSEWHERE);
      ast_debug(2, "This local call has the ANSWERED_ELSEWHERE flag set.\n");
   }

   if (isoutbound) {
      const char *status = pbx_builtin_getvar_helper(p->chan, "DIALSTATUS");
      if ((status) && (p->owner)) {
         /* Deadlock avoidance */
         while (p->owner && ast_channel_trylock(p->owner)) {
            ast_mutex_unlock(&p->lock);
            if (ast) {
               ast_channel_unlock(ast);
            }
            usleep(1);
            if (ast) {
               ast_channel_lock(ast);
            }
            ast_mutex_lock(&p->lock);
         }
         if (p->owner) {
            pbx_builtin_setvar_helper(p->owner, "CHANLOCALSTATUS", status);
            ast_channel_unlock(p->owner);
         }
      }
      p->chan = NULL;
      ast_clear_flag(p, LOCAL_LAUNCHED_PBX);
      ast_module_user_remove(p->u_chan);
   } else {
      p->owner = NULL;
      ast_module_user_remove(p->u_owner);
      while (p->chan && ast_channel_trylock(p->chan)) {
         DEADLOCK_AVOIDANCE(&p->lock);
      }
      if (p->chan) {
         ast_queue_hangup(p->chan);
         ast_channel_unlock(p->chan);
      }
   }
   
   ast->tech_pvt = NULL;
   
   if (!p->owner && !p->chan) {
      /* Okay, done with the private part now, too. */
      glaredetect = ast_test_flag(p, LOCAL_GLARE_DETECT);
      /* If we have a queue holding, don't actually destroy p yet, but
         let local_queue do it. */
      if (glaredetect)
         ast_set_flag(p, LOCAL_CANCEL_QUEUE);
      /* Remove from list */
      AST_LIST_LOCK(&locals);
      AST_LIST_REMOVE(&locals, p, list);
      AST_LIST_UNLOCK(&locals);
      ast_mutex_unlock(&p->lock);
      /* And destroy */
      if (!glaredetect) {
         p = local_pvt_destroy(p);
      }
      return 0;
   }
   if (p->chan && !ast_test_flag(p, LOCAL_LAUNCHED_PBX))
      /* Need to actually hangup since there is no PBX */
      ochan = p->chan;
   else
      res = local_queue_frame(p, isoutbound, &f, NULL, 1);
   if (!res)
      ast_mutex_unlock(&p->lock);
   if (ochan)
      ast_hangup(ochan);
   return 0;
}

static int local_indicate	(	struct ast_channel *	ast,
		int	condition,
		const void *	data,
		size_t	datalen
	)			[static]

Definition at line 397 of file chan_local.c.

References ast_connected_line_build_data(), AST_CONTROL_CONNECTED_LINE, AST_CONTROL_HOLD, AST_CONTROL_REDIRECTING, AST_CONTROL_UNHOLD, AST_FRAME_CONTROL, ast_moh_start(), ast_moh_stop(), ast_mutex_lock(), ast_mutex_unlock(), ast_redirecting_build_data(), local_pvt::chan, ast_channel::connected, ast_frame::data, ast_frame::datalen, IS_OUTBOUND, local_queue_frame(), local_pvt::lock, local_pvt::owner, ast_frame::ptr, ast_channel::redirecting, ast_frame::subclass, and ast_channel::tech_pvt.

{
   struct local_pvt *p = ast->tech_pvt;
   int res = 0;
   struct ast_frame f = { AST_FRAME_CONTROL, };
   int isoutbound;

   if (!p)
      return -1;

   /* If this is an MOH hold or unhold, do it on the Local channel versus real channel */
   if (condition == AST_CONTROL_HOLD) {
      ast_moh_start(ast, data, NULL);
   } else if (condition == AST_CONTROL_UNHOLD) {
      ast_moh_stop(ast);
   } else if (condition == AST_CONTROL_CONNECTED_LINE || condition == AST_CONTROL_REDIRECTING) {
      struct ast_channel *this_channel;
      struct ast_channel *the_other_channel;
      /* A connected line update frame may only contain a partial amount of data, such
       * as just a source, or just a ton, and not the full amount of information. However,
       * the collected information is all stored in the outgoing channel's connectedline
       * structure, so when receiving a connected line update on an outgoing local channel,
       * we need to transmit the collected connected line information instead of whatever
       * happens to be in this control frame. The same applies for redirecting information, which
       * is why it is handled here as well.*/
      ast_mutex_lock(&p->lock);
      isoutbound = IS_OUTBOUND(ast, p);
      if (isoutbound) {
         this_channel = p->chan;
         the_other_channel = p->owner;
      } else {
         this_channel = p->owner;
         the_other_channel = p->chan;
      }
      if (the_other_channel) {
         unsigned char frame_data[1024];
         if (condition == AST_CONTROL_CONNECTED_LINE) {
            f.datalen = ast_connected_line_build_data(frame_data, sizeof(frame_data), &this_channel->connected);
         } else {
            f.datalen = ast_redirecting_build_data(frame_data, sizeof(frame_data), &this_channel->redirecting);
         }
         f.subclass = condition;
         f.data.ptr = frame_data;
         if (!(res = local_queue_frame(p, isoutbound, &f, ast, 1))) {
            ast_mutex_unlock(&p->lock);
         }
      } else {
         ast_mutex_unlock(&p->lock);
      }
   } else {
      /* Queue up a frame representing the indication as a control frame */
      ast_mutex_lock(&p->lock);
      isoutbound = IS_OUTBOUND(ast, p);
      f.subclass = condition;
      f.data.ptr = (void*)data;
      f.datalen = datalen;
      if (!(res = local_queue_frame(p, isoutbound, &f, ast, 1)))
         ast_mutex_unlock(&p->lock);
   }

   return res;
}

static struct ast_channel* local_new	(	struct local_pvt *	p,
		int	state,
		const char *	linkedid
	)			[static, read]

Start new local channel.

Definition at line 786 of file chan_local.c.

References ast_channel::accountcode, ast_channel::amaflags, ast_best_codec(), ast_channel_alloc, ast_channel_release(), ast_copy_string(), ast_jb_configure(), ast_log(), ast_module_user_add, ast_random(), AST_STATE_RING, local_pvt::chan, ast_channel::context, local_pvt::context, ast_channel::exten, local_pvt::exten, local_pvt::jb_conf, LOG_WARNING, ast_channel::nativeformats, local_pvt::owner, ast_channel::priority, ast_channel::rawreadformat, ast_channel::rawwriteformat, ast_channel::readformat, local_pvt::reqformat, ast_channel::tech, ast_channel::tech_pvt, local_pvt::u_chan, local_pvt::u_owner, and ast_channel::writeformat.

Referenced by local_request().

{
   struct ast_channel *tmp = NULL, *tmp2 = NULL;
   int randnum = ast_random() & 0xffff, fmt = 0;
   const char *t;
   int ama;

   /* Allocate two new Asterisk channels */
   /* safe accountcode */
   if (p->owner && p->owner->accountcode)
      t = p->owner->accountcode;
   else
      t = "";

   if (p->owner)
      ama = p->owner->amaflags;
   else
      ama = 0;
   if (!(tmp = ast_channel_alloc(1, state, 0, 0, t, p->exten, p->context, linkedid, ama, "Local/%s@%s-%04x;1", p->exten, p->context, randnum)) 
      || !(tmp2 = ast_channel_alloc(1, AST_STATE_RING, 0, 0, t, p->exten, p->context, linkedid, ama, "Local/%s@%s-%04x;2", p->exten, p->context, randnum))) {
      if (tmp) {
         tmp = ast_channel_release(tmp);
      }
      ast_log(LOG_WARNING, "Unable to allocate channel structure(s)\n");
      return NULL;
   }

   tmp2->tech = tmp->tech = &local_tech;

   tmp->nativeformats = p->reqformat;
   tmp2->nativeformats = p->reqformat;

   /* Determine our read/write format and set it on each channel */
   fmt = ast_best_codec(p->reqformat);
   tmp->writeformat = fmt;
   tmp2->writeformat = fmt;
   tmp->rawwriteformat = fmt;
   tmp2->rawwriteformat = fmt;
   tmp->readformat = fmt;
   tmp2->readformat = fmt;
   tmp->rawreadformat = fmt;
   tmp2->rawreadformat = fmt;

   tmp->tech_pvt = p;
   tmp2->tech_pvt = p;

   p->owner = tmp;
   p->chan = tmp2;
   p->u_owner = ast_module_user_add(p->owner);
   p->u_chan = ast_module_user_add(p->chan);

   ast_copy_string(tmp->context, p->context, sizeof(tmp->context));
   ast_copy_string(tmp2->context, p->context, sizeof(tmp2->context));
   ast_copy_string(tmp2->exten, p->exten, sizeof(tmp->exten));
   tmp->priority = 1;
   tmp2->priority = 1;

   ast_jb_configure(tmp, &p->jb_conf);

   return tmp;
}

static struct local_pvt* local_pvt_destroy

(

struct local_pvt *

pvt

)

[static, read]

Note:

Assumes the pvt is no longer in the pvts list

Definition at line 165 of file chan_local.c.

References ast_free, ast_mutex_destroy(), and local_pvt::lock.

Referenced by local_alloc(), local_hangup(), local_queue_frame(), and local_request().

{
   ast_mutex_destroy(&pvt->lock);
   ast_free(pvt);
   return NULL;
}

static int local_queue_frame	(	struct local_pvt *	p,
		int	isoutbound,
		struct ast_frame *	f,
		struct ast_channel *	us,
		int	us_locked
	)			[static]

Definition at line 197 of file chan_local.c.

References ast_channel_trylock, ast_channel_unlock, ast_clear_flag, ast_mutex_lock(), ast_mutex_trylock(), ast_mutex_unlock(), ast_queue_frame(), ast_set_flag, ast_test_flag, local_pvt::chan, CHANNEL_DEADLOCK_AVOIDANCE, ast_channel::generator, LOCAL_CANCEL_QUEUE, LOCAL_GLARE_DETECT, local_pvt_destroy(), local_pvt::lock, and local_pvt::owner.

Referenced by local_answer(), local_digit_begin(), local_digit_end(), local_hangup(), local_indicate(), local_sendhtml(), local_sendtext(), and local_write().

{
   struct ast_channel *other = NULL;

   /* Recalculate outbound channel */
   other = isoutbound ? p->owner : p->chan;

   if (!other) {
      return 0;
   }

   /* do not queue frame if generator is on both local channels */
   if (us && us->generator && other->generator) {
      return 0;
   }

   /* Set glare detection */
   ast_set_flag(p, LOCAL_GLARE_DETECT);

   /* Ensure that we have both channels locked */
   while (other && ast_channel_trylock(other)) {
      ast_mutex_unlock(&p->lock);
      if (us && us_locked) {
         do {
            CHANNEL_DEADLOCK_AVOIDANCE(us);
         } while (ast_mutex_trylock(&p->lock));
      } else {
         usleep(1);
         ast_mutex_lock(&p->lock);
      }
      other = isoutbound ? p->owner : p->chan;
   }

   /* Since glare detection only occurs within this function, and because
    * a pvt flag cannot be set without having the pvt lock, this is the only
    * location where we could detect a cancelling of the queue. */
   if (ast_test_flag(p, LOCAL_CANCEL_QUEUE)) {
      /* We had a glare on the hangup.  Forget all this business,
      return and destroy p.  */
      ast_mutex_unlock(&p->lock);
      p = local_pvt_destroy(p);
      if (other) {
         ast_channel_unlock(other);
      }
      return -1;
   }

   if (other) {
      ast_queue_frame(other, f);
      ast_channel_unlock(other);
   }

   ast_clear_flag(p, LOCAL_GLARE_DETECT);

   return 0;
}

static struct ast_frame * local_read

(

struct ast_channel *

ast

)

[static, read]

Definition at line 345 of file chan_local.c.

References ast_null_frame.

{
   return &ast_null_frame;
}

static struct ast_channel * local_request	(	const char *	type,
		int	format,
		const struct ast_channel *	requestor,
		void *	data,
		int *	cause
	)			[static, read]

Part of PBX interface.

Definition at line 849 of file chan_local.c.

References AST_LIST_LOCK, AST_LIST_REMOVE, AST_LIST_UNLOCK, AST_STATE_DOWN, local_pvt::chan, ast_channel::linkedid, local_alloc(), local_new(), and local_pvt_destroy().

{
   struct local_pvt *p = NULL;
   struct ast_channel *chan = NULL;

   /* Allocate a new private structure and then Asterisk channel */
   if ((p = local_alloc(data, format))) {
      if (!(chan = local_new(p, AST_STATE_DOWN, requestor ? requestor->linkedid : NULL))) {
         AST_LIST_LOCK(&locals);
         AST_LIST_REMOVE(&locals, p, list);
         AST_LIST_UNLOCK(&locals);
         p = local_pvt_destroy(p);
      }
   }

   return chan;
}

static int local_sendhtml	(	struct ast_channel *	ast,
		int	subclass,
		const char *	data,
		int	datalen
	)			[static]

Definition at line 518 of file chan_local.c.

References AST_FRAME_HTML, ast_mutex_lock(), ast_mutex_unlock(), ast_frame::data, ast_frame::datalen, IS_OUTBOUND, local_queue_frame(), local_pvt::lock, ast_frame::ptr, ast_frame::subclass, and ast_channel::tech_pvt.

{
   struct local_pvt *p = ast->tech_pvt;
   int res = -1;
   struct ast_frame f = { AST_FRAME_HTML, };
   int isoutbound;

   if (!p)
      return -1;
   
   ast_mutex_lock(&p->lock);
   isoutbound = IS_OUTBOUND(ast, p);
   f.subclass = subclass;
   f.data.ptr = (char *)data;
   f.datalen = datalen;
   if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
      ast_mutex_unlock(&p->lock);
   return res;
}

static int local_sendtext	(	struct ast_channel *	ast,
		const char *	text
	)			[static]

Definition at line 499 of file chan_local.c.

References AST_FRAME_TEXT, ast_mutex_lock(), ast_mutex_unlock(), ast_frame::data, ast_frame::datalen, IS_OUTBOUND, local_queue_frame(), local_pvt::lock, ast_frame::ptr, and ast_channel::tech_pvt.

{
   struct local_pvt *p = ast->tech_pvt;
   int res = -1;
   struct ast_frame f = { AST_FRAME_TEXT, };
   int isoutbound;

   if (!p)
      return -1;

   ast_mutex_lock(&p->lock);
   isoutbound = IS_OUTBOUND(ast, p);
   f.data.ptr = (char *) text;
   f.datalen = strlen(text) + 1;
   if (!(res = local_queue_frame(p, isoutbound, &f, ast, 0)))
      ast_mutex_unlock(&p->lock);
   return res;
}

static int local_write	(	struct ast_channel *	ast,
		struct ast_frame *	f
	)			[static]

Definition at line 350 of file chan_local.c.

References ast_debug, AST_FRAME_VIDEO, AST_FRAME_VOICE, ast_mutex_lock(), ast_mutex_unlock(), ast_test_flag, check_bridge(), ast_frame::frametype, IS_OUTBOUND, LOCAL_ALREADY_MASQED, local_queue_frame(), local_pvt::lock, ast_channel::name, and ast_channel::tech_pvt.

{
   struct local_pvt *p = ast->tech_pvt;
   int res = -1;
   int isoutbound;

   if (!p)
      return -1;

   /* Just queue for delivery to the other side */
   ast_mutex_lock(&p->lock);
   isoutbound = IS_OUTBOUND(ast, p);
   if (f && (f->frametype == AST_FRAME_VOICE || f->frametype == AST_FRAME_VIDEO))
      check_bridge(p, isoutbound);
   if (!ast_test_flag(p, LOCAL_ALREADY_MASQED))
      res = local_queue_frame(p, isoutbound, f, ast, 1);
   else {
      ast_debug(1, "Not posting to queue since already masked on '%s'\n", ast->name);
      res = 0;
   }
   if (!res)
      ast_mutex_unlock(&p->lock);
   return res;
}

static char* locals_show	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)			[static]

CLI command "local show channels".

Definition at line 868 of file chan_local.c.

References ast_cli_args::argc, ast_cli(), AST_LIST_EMPTY, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_mutex_lock(), ast_mutex_unlock(), CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, local_pvt::context, local_pvt::exten, ast_cli_args::fd, local_pvt::lock, ast_channel::name, local_pvt::owner, and ast_cli_entry::usage.

{
   struct local_pvt *p = NULL;

   switch (cmd) {
   case CLI_INIT:
      e->command = "local show channels";
      e->usage =
         "Usage: local show channels\n"
         "       Provides summary information on active local proxy channels.\n";
      return NULL;
   case CLI_GENERATE:
      return NULL;
   }

   if (a->argc != 3)
      return CLI_SHOWUSAGE;

   AST_LIST_LOCK(&locals);
   if (!AST_LIST_EMPTY(&locals)) {
      AST_LIST_TRAVERSE(&locals, p, list) {
         ast_mutex_lock(&p->lock);
         ast_cli(a->fd, "%s -- %s@%s\n", p->owner ? p->owner->name : "<unowned>", p->exten, p->context);
         ast_mutex_unlock(&p->lock);
      }
   } else
      ast_cli(a->fd, "No local channels in use\n");
   AST_LIST_UNLOCK(&locals);

   return CLI_SUCCESS;
}

static int unload_module

(

void

)

[static]

Unload the local proxy channel from Asterisk.

Definition at line 917 of file chan_local.c.

References ast_channel_unregister(), ast_cli_unregister_multiple(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_softhangup(), AST_SOFTHANGUP_APPUNLOAD, cli_local, LOG_WARNING, and local_pvt::owner.

{
   struct local_pvt *p = NULL;

   /* First, take us out of the channel loop */
   ast_cli_unregister_multiple(cli_local, sizeof(cli_local) / sizeof(struct ast_cli_entry));
   ast_channel_unregister(&local_tech);
   if (!AST_LIST_LOCK(&locals)) {
      /* Hangup all interfaces if they have an owner */
      AST_LIST_TRAVERSE(&locals, p, list) {
         if (p->owner)
            ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD);
      }
      AST_LIST_UNLOCK(&locals);
   } else {
      ast_log(LOG_WARNING, "Unable to lock the monitor\n");
      return -1;
   }     
   return 0;
}

---

Variable Documentation

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Local Proxy Channel (Note: used internally by other modules)" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, } [static]

Definition at line 938 of file chan_local.c.

struct ast_module_info* ast_module_info = &__mod_info [static]

Definition at line 938 of file chan_local.c.

struct ast_cli_entry cli_local[] [static]

Initial value:

 {
   AST_CLI_DEFINE(locals_show, "List status of local channels"),
}

Definition at line 900 of file chan_local.c.

Referenced by load_module(), and unload_module().

struct ast_jb_conf g_jb_conf [static]

Definition at line 56 of file chan_local.c.

struct ast_channel_tech local_tech [static]

Definition at line 79 of file chan_local.c.

const char tdesc[] = "Local Proxy Channel Driver" [static]

Definition at line 52 of file chan_local.c.