core_local.c File Reference

Local proxy channel driver. More...

#include "asterisk.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/cli.h"
#include "asterisk/manager.h"
#include "asterisk/devicestate.h"
#include "asterisk/astobj2.h"
#include "asterisk/bridge.h"
#include "asterisk/core_unreal.h"
#include "asterisk/core_local.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/_private.h"
#include "asterisk/stream.h"
#include "asterisk/translate.h"

Include dependency graph for core_local.c:

Go to the source code of this file.

Data Structures
struct	local_bridge
struct	local_pvt
	the local pvt structure for all channels More...

Enumerations
enum	local_call_action { LOCAL_CALL_ACTION_DIALPLAN, LOCAL_CALL_ACTION_BRIDGE, LOCAL_CALL_ACTION_MASQUERADE }

Functions
struct ast_channel *	ast_local_get_peer (struct ast_channel *ast)
	Get the other local channel in the pair. More...
int	ast_local_init (void)
	Initialize the local proxy channel. More...
void	ast_local_lock_all (struct ast_channel *chan, void **tech_pvt, struct ast_channel **base_chan, struct ast_channel **base_owner)
	Add a reference to the local channel's private tech, lock the local channel's private base, and add references and lock both sides of the local channel. More...
int	ast_local_setup_bridge (struct ast_channel *ast, struct ast_bridge *bridge, struct ast_channel *swap, struct ast_bridge_features *features)
	Setup the outgoing local channel to join a bridge on ast_call(). More...
int	ast_local_setup_masquerade (struct ast_channel *ast, struct ast_channel *masq)
	Setup the outgoing local channel to masquerade into a channel on ast_call(). More...
void	ast_local_unlock_all (void *tech_pvt, struct ast_channel *base_chan, struct ast_channel *base_owner)
	Remove a reference to the given local channel's private tech, unlock the given local channel's private base, and remove references and unlock both sides of given the local channel. More...
static struct local_pvt *	local_alloc (const char *data, struct ast_stream_topology *topology)
	Create a call structure. More...
static int	local_call (struct ast_channel *ast, const char *dest, int timeout)
	Initiate new call, part of PBX interface dest is the dial string. More...
static struct ast_multi_channel_blob *	local_channel_optimization_blob (struct local_pvt *p, struct ast_json *json_object)
static int	local_devicestate (const char *data)
	Adds devicestate to local channels. More...
static int	local_hangup (struct ast_channel *ast)
	Hangup a call through the local proxy channel. More...
static struct ast_manager_event_blob *	local_message_to_ami (struct stasis_message *msg)
static void	local_optimization_finished_cb (struct ast_unreal_pvt *base, int success, unsigned int id)
	Callback for ast_unreal_pvt_callbacks optimization_finished_cb. More...
static void	local_optimization_started_cb (struct ast_unreal_pvt *base, struct ast_channel *source, enum ast_unreal_channel_indicator dest, unsigned int id)
	Callback for ast_unreal_pvt_callbacks optimization_started_cb. More...
static void	local_pvt_destructor (void *vdoomed)
static struct ast_channel *	local_request (const char *type, struct ast_format_cap *cap, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
	Part of PBX interface. More...
static struct ast_channel *	local_request_with_stream_topology (const char *type, struct ast_stream_topology *topology, const struct ast_assigned_ids *assignedids, const struct ast_channel *requestor, const char *data, int *cause)
	Part of PBX interface. More...
static int	local_setoption (struct ast_channel *chan, int option, void *data, int datalen)
static void	local_shutdown (void)
static int	locals_cmp_cb (void *obj, void *arg, int flags)
static char *	locals_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
	CLI command "local show channels". More...
static int	manager_optimize_away (struct mansession *s, const struct message *m)
static void	publish_local_bridge_message (struct local_pvt *p)
	STASIS_MESSAGE_TYPE_DEFN (ast_local_bridge_type,.to_ami=local_message_to_ami,)
	Define local channel message types. More...
	STASIS_MESSAGE_TYPE_DEFN (ast_local_optimization_begin_type,.to_ami=local_message_to_ami,)
	STASIS_MESSAGE_TYPE_DEFN (ast_local_optimization_end_type,.to_ami=local_message_to_ami,)

Variables
static struct ast_cli_entry	cli_local []
static struct ast_channel_tech	local_tech
struct ast_unreal_pvt_callbacks	local_unreal_callbacks
	Callbacks from the unreal core when channel optimization occurs. More...
static struct ao2_container *	locals
static const char	tdesc [] = "Local Proxy Channel Driver"

Detailed Description

Local proxy channel driver.

Author

Richard Mudgett rmudg.nosp@m.ett@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

See Also:

• CREDITS

Definition in file core_local.c.

Enumeration Type Documentation

local_call_action

enum local_call_action

What to do with the ;2 channel when ast_call() happens.

Enumerator
LOCAL_CALL_ACTION_DIALPLAN
LOCAL_CALL_ACTION_BRIDGE
LOCAL_CALL_ACTION_MASQUERADE

Definition at line 197 of file core_local.c.

                       {
   /* The ast_call() will run dialplan on the ;2 channel. */
   LOCAL_CALL_ACTION_DIALPLAN,
   /* The ast_call() will impart the ;2 channel into a bridge. */
   LOCAL_CALL_ACTION_BRIDGE,
   /* The ast_call() will masquerade the ;2 channel into a channel. */
   LOCAL_CALL_ACTION_MASQUERADE,
};

Function Documentation

ast_local_get_peer()

struct ast_channel* ast_local_get_peer

(

struct ast_channel *

ast

)

Get the other local channel in the pair.

Since

12.0.0

Parameters

ast	Local channel to get peer.

Note

On entry, ast must be locked.

Return values

peer	reffed on success.
NULL	if no peer or error.

Definition at line 276 of file core_local.c.

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_channel_ref, ast_channel_tech_pvt(), local_pvt::base, ast_unreal_pvt::chan, NULL, and ast_unreal_pvt::owner.

Referenced by ari_channels_handle_originate_with_id(), and park_local_transfer().

{
   struct local_pvt *p = ast_channel_tech_pvt(ast);
   struct local_pvt *found;
   struct ast_channel *peer;

   if (!p) {
      return NULL;
   }

   found = p ? ao2_find(locals, p, 0) : NULL;
   if (!found) {
      /* ast is either not a local channel or it has alredy been hungup */
      return NULL;
   }
   ao2_lock(found);
   if (ast == p->base.owner) {
      peer = p->base.chan;
   } else if (ast == p->base.chan) {
      peer = p->base.owner;
   } else {
      peer = NULL;
   }
   if (peer) {
      ast_channel_ref(peer);
   }
   ao2_unlock(found);
   ao2_ref(found, -1);
   return peer;
}

ast_local_init()

int ast_local_init

(

void

)

Initialize the local proxy channel.

Since

12.0.0

Return values

0	on success.
-1	on error.

Definition at line 1140 of file core_local.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, ARRAY_LEN, ast_channel_register(), ast_cli_register_multiple, ast_format_cap_alloc, ast_format_cap_append_by_type(), AST_FORMAT_CAP_FLAG_DEFAULT, ast_local_bridge_type(), ast_local_optimization_begin_type(), ast_local_optimization_end_type(), ast_log, ast_manager_register_xml_core, AST_MEDIA_TYPE_UNKNOWN, ast_register_cleanup(), ast_channel_tech::capabilities, EVENT_FLAG_CALL, EVENT_FLAG_SYSTEM, local_shutdown(), locals_cmp_cb(), LOG_ERROR, manager_optimize_away(), NULL, and STASIS_MESSAGE_TYPE_INIT.

Referenced by asterisk_daemon().

{
   if (STASIS_MESSAGE_TYPE_INIT(ast_local_optimization_begin_type)) {
      return -1;
   }

   if (STASIS_MESSAGE_TYPE_INIT(ast_local_optimization_end_type)) {
      return -1;
   }

   if (STASIS_MESSAGE_TYPE_INIT(ast_local_bridge_type)) {
      return -1;
   }

   if (!(local_tech.capabilities = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
      return -1;
   }
   ast_format_cap_append_by_type(local_tech.capabilities, AST_MEDIA_TYPE_UNKNOWN);

   locals = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, locals_cmp_cb);
   if (!locals) {
      return -1;
   }

   /* 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 -1;
   }
   ast_cli_register_multiple(cli_local, ARRAY_LEN(cli_local));
   ast_manager_register_xml_core("LocalOptimizeAway", EVENT_FLAG_SYSTEM|EVENT_FLAG_CALL, manager_optimize_away);

   ast_register_cleanup(local_shutdown);
   return 0;
}

ast_local_lock_all()

void ast_local_lock_all	(	struct ast_channel *	chan,
		void **	tech_pvt,
		struct ast_channel **	base_chan,
		struct ast_channel **	base_owner
	)

Add a reference to the local channel's private tech, lock the local channel's private base, and add references and lock both sides of the local channel.

Note

None of these locks should be held prior to calling this function.

To undo this process call ast_local_unlock_all2.

Since

13.17.0, 14.6.0

Parameters

chan	Must be a local channel
tech_pvt	[out] channel's private tech (ref and lock added)
base_chan	[out] One side of the local channel (ref and lock added)
base_owner	[out] Other side of the local channel (ref and lock added)

Definition at line 241 of file core_local.c.

References ao2_bump, ast_channel_tech_pvt(), ast_unreal_lock_all(), local_pvt::base, and NULL.

Referenced by attended_transfer_bridge().

{
   struct local_pvt *p = ast_channel_tech_pvt(chan);

   *tech_pvt = NULL;
   *base_chan = NULL;
   *base_owner = NULL;

   if (p) {
      *tech_pvt = ao2_bump(p);
      ast_unreal_lock_all(&p->base, base_chan, base_owner);
   }
}

ast_local_setup_bridge()

int ast_local_setup_bridge	(	struct ast_channel *	ast,
		struct ast_bridge *	bridge,
		struct ast_channel *	swap,
		struct ast_bridge_features *	features
	)

Setup the outgoing local channel to join a bridge on ast_call().

Since

12.0.0

Parameters

ast	Either channel of a local channel pair.
bridge	Bridge to join.
swap	Channel to swap with when joining.
features	Bridge features structure.

Note

The features parameter must be NULL or obtained by ast_bridge_features_new(). You must not dereference features after calling even if the call fails.

Intended to be called after ast_request() and before ast_call() on a local channel.

Return values

0	on success.
-1	on error.

Definition at line 599 of file core_local.c.

References local_pvt::action, ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_bridge_features_destroy(), ast_channel_lock, ast_channel_ref, ast_channel_tech_pvt(), ast_channel_unlock, ast_test_flag, AST_UNREAL_CARETAKER_THREAD, local_pvt::base, local_pvt::bridge, ast_unreal_pvt::chan, local_bridge::features, local_bridge::join, LOCAL_CALL_ACTION_BRIDGE, LOCAL_CALL_ACTION_DIALPLAN, NULL, ast_unreal_pvt::owner, local_bridge::swap, and local_pvt::type.

Referenced by attended_transfer_bridge().

{
   struct local_pvt *p;
   struct local_pvt *found;
   int res = -1;

   /* Sanity checks. */
   if (!ast || !bridge) {
      ast_bridge_features_destroy(features);
      return -1;
   }

   ast_channel_lock(ast);
   p = ast_channel_tech_pvt(ast);
   ast_channel_unlock(ast);

   found = p ? ao2_find(locals, p, 0) : NULL;
   if (found) {
      ao2_lock(found);
      if (found->type == LOCAL_CALL_ACTION_DIALPLAN
         && found->base.owner
         && found->base.chan
         && !ast_test_flag(&found->base, AST_UNREAL_CARETAKER_THREAD)) {
         ao2_ref(bridge, +1);
         if (swap) {
            ast_channel_ref(swap);
         }
         found->type = LOCAL_CALL_ACTION_BRIDGE;
         found->action.bridge.join = bridge;
         found->action.bridge.swap = swap;
         found->action.bridge.features = features;
         res = 0;
      } else {
         ast_bridge_features_destroy(features);
      }
      ao2_unlock(found);
      ao2_ref(found, -1);
   }

   return res;
}

ast_local_setup_masquerade()

int ast_local_setup_masquerade	(	struct ast_channel *	ast,
		struct ast_channel *	masq
	)

Setup the outgoing local channel to masquerade into a channel on ast_call().

Since

12.0.0

Parameters

ast	Either channel of a local channel pair.
masq	Channel to masquerade into.

Note

Intended to be called after ast_request() and before ast_call() on a local channel.

Return values

0	on success.
-1	on error.

Definition at line 641 of file core_local.c.

References local_pvt::action, ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_channel_lock, ast_channel_ref, ast_channel_tech_pvt(), ast_channel_unlock, ast_test_flag, AST_UNREAL_CARETAKER_THREAD, local_pvt::base, ast_unreal_pvt::chan, LOCAL_CALL_ACTION_DIALPLAN, LOCAL_CALL_ACTION_MASQUERADE, local_pvt::masq, NULL, ast_unreal_pvt::owner, and local_pvt::type.

Referenced by attended_transfer_bridge().

{
   struct local_pvt *p;
   struct local_pvt *found;
   int res = -1;

   /* Sanity checks. */
   if (!ast || !masq) {
      return -1;
   }

   ast_channel_lock(ast);
   p = ast_channel_tech_pvt(ast);
   ast_channel_unlock(ast);

   found = p ? ao2_find(locals, p, 0) : NULL;
   if (found) {
      ao2_lock(found);
      if (found->type == LOCAL_CALL_ACTION_DIALPLAN
         && found->base.owner
         && found->base.chan
         && !ast_test_flag(&found->base, AST_UNREAL_CARETAKER_THREAD)) {
         ast_channel_ref(masq);
         found->type = LOCAL_CALL_ACTION_MASQUERADE;
         found->action.masq = masq;
         res = 0;
      }
      ao2_unlock(found);
      ao2_ref(found, -1);
   }

   return res;
}

ast_local_unlock_all()

void ast_local_unlock_all	(	void *	tech_pvt,
		struct ast_channel *	base_chan,
		struct ast_channel *	base_owner
	)

Remove a reference to the given local channel's private tech, unlock the given local channel's private base, and remove references and unlock both sides of given the local channel.

Note

This function should be used in conjunction with ast_local_lock_all2.

Since

13.17.0, 14.6.0

Parameters

tech_pvt	channel's private tech (ref and lock removed)
base_chan	One side of the local channel (ref and lock removed)
base_owner	Other side of the local channel (ref and lock removed)

Definition at line 256 of file core_local.c.

References ao2_ref, ao2_unlock, ast_channel_unlock, ast_channel_unref, and local_pvt::base.

Referenced by attended_transfer_bridge().

{
   if (base_chan) {
      ast_channel_unlock(base_chan);
      ast_channel_unref(base_chan);
   }

   if (base_owner) {
      ast_channel_unlock(base_owner);
      ast_channel_unref(base_owner);
   }

   if (tech_pvt) {
      struct local_pvt *p = tech_pvt;
      ao2_unlock(&p->base);
      ao2_ref(tech_pvt, -1);
   }
}

local_alloc()

static struct local_pvt* local_alloc ( const char *  data, struct ast_stream_topology *  topology  )

static

Create a call structure.

Definition at line 866 of file core_local.c.

References ast_clear_flag, ast_copy_string(), AST_JB_ENABLED, ast_log, ast_set_flag, ast_strdupa, ast_test_flag, ast_unreal_alloc_stream_topology(), AST_UNREAL_MOH_INTERCEPT, AST_UNREAL_NO_OPTIMIZATION, local_pvt::base, ast_unreal_pvt::callbacks, context, local_pvt::context, local_pvt::exten, ast_unreal_pvt::jb_conf, local_pvt_destructor(), local_unreal_callbacks, LOG_ERROR, ast_unreal_pvt::name, NULL, parse(), and S_OR.

Referenced by local_request_with_stream_topology().

{
   struct local_pvt *pvt;
   char *parse;
   char *context;
   char *opts;

   pvt = (struct local_pvt *) ast_unreal_alloc_stream_topology(sizeof(*pvt), local_pvt_destructor, topology);
   if (!pvt) {
      return NULL;
   }
   pvt->base.callbacks = &local_unreal_callbacks;

   parse = ast_strdupa(data);

   /*
    * Local channels intercept MOH by default.
    *
    * This is a silly default because it represents state held by
    * the local channels.  Unless local channel optimization is
    * disabled, the state will dissapear when the local channels
    * optimize out.
    */
   ast_set_flag(&pvt->base, AST_UNREAL_MOH_INTERCEPT);

   /* Look for options */
   if ((opts = strchr(parse, '/'))) {
      *opts++ = '\0';
      if (strchr(opts, 'n')) {
         ast_set_flag(&pvt->base, AST_UNREAL_NO_OPTIMIZATION);
      }
      if (strchr(opts, 'j')) {
         if (ast_test_flag(&pvt->base, AST_UNREAL_NO_OPTIMIZATION)) {
            ast_set_flag(&pvt->base.jb_conf, AST_JB_ENABLED);
         } else {
            ast_log(LOG_ERROR, "You must use the 'n' option with the 'j' option to enable the jitter buffer\n");
         }
      }
      if (strchr(opts, 'm')) {
         ast_clear_flag(&pvt->base, AST_UNREAL_MOH_INTERCEPT);
      }
   }

   /* Look for a context */
   if ((context = strchr(parse, '@'))) {
      *context++ = '\0';
   }

   ast_copy_string(pvt->context, S_OR(context, "default"), sizeof(pvt->context));
   ast_copy_string(pvt->exten, parse, sizeof(pvt->exten));
   snprintf(pvt->base.name, sizeof(pvt->base.name), "%s@%s", pvt->exten, pvt->context);

   return pvt; /* this is returned with a ref */
}

local_call()

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

static

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

Definition at line 677 of file core_local.c.

References local_pvt::action, ao2_cleanup, ao2_lock, ao2_ref, ao2_unlock, ast_answer(), ast_bridge_impart(), AST_BRIDGE_IMPART_CHAN_INDEPENDENT, ast_channel_caller(), ast_channel_lock, ast_channel_move(), ast_channel_tech_pvt(), ast_channel_unlock, ast_channel_unref, ast_exists_extension(), ast_hangup(), ast_log, ast_pbx_start(), ast_set_cc_interfaces_chanvar(), ast_set_flag, ast_strdupa, ast_unreal_call_setup(), AST_UNREAL_CARETAKER_THREAD, ast_unreal_lock_all(), local_pvt::base, local_pvt::bridge, local_pvt::context, local_pvt::exten, local_bridge::features, local_bridge::join, LOCAL_CALL_ACTION_BRIDGE, LOCAL_CALL_ACTION_DIALPLAN, LOCAL_CALL_ACTION_MASQUERADE, LOG_NOTICE, local_pvt::masq, NULL, publish_local_bridge_message(), S_COR, local_bridge::swap, and local_pvt::type.

{
   struct local_pvt *p = ast_channel_tech_pvt(ast);
   int pvt_locked = 0;

   struct ast_channel *owner = NULL;
   struct ast_channel *chan = NULL;
   int res;
   char *reduced_dest = ast_strdupa(dest);
   char *slash;
   const char *chan_cid;

   if (!p) {
      return -1;
   }

   /* since we are letting go of channel locks that were locked coming into
    * this function, then we need to give the tech pvt a ref */
   ao2_ref(p, 1);
   ast_channel_unlock(ast);

   ast_unreal_lock_all(&p->base, &chan, &owner);
   pvt_locked = 1;

   if (owner != ast) {
      res = -1;
      goto return_cleanup;
   }

   if (!owner || !chan) {
      res = -1;
      goto return_cleanup;
   }

   ast_unreal_call_setup(owner, chan);

   /*
    * If the local channel has /n on the end of it, we need to lop
    * that off for our argument to setting up the CC_INTERFACES
    * variable.
    */
   if ((slash = strrchr(reduced_dest, '/'))) {
      *slash = '\0';
   }
   ast_set_cc_interfaces_chanvar(chan, reduced_dest);

   ao2_unlock(p);
   pvt_locked = 0;

   ast_channel_unlock(owner);

   chan_cid = S_COR(ast_channel_caller(chan)->id.number.valid,
      ast_channel_caller(chan)->id.number.str, NULL);
   if (chan_cid) {
      chan_cid = ast_strdupa(chan_cid);
   }
   ast_channel_unlock(chan);

   res = -1;
   switch (p->type) {
   case LOCAL_CALL_ACTION_DIALPLAN:
      if (!ast_exists_extension(NULL, p->context, p->exten, 1, chan_cid)) {
         ast_log(LOG_NOTICE, "No such extension/context %s@%s while calling Local channel\n",
            p->exten, p->context);
      } else {
         publish_local_bridge_message(p);

         /* Start switch on sub channel */
         res = ast_pbx_start(chan);
      }
      break;
   case LOCAL_CALL_ACTION_BRIDGE:
      publish_local_bridge_message(p);
      ast_answer(chan);
      res = ast_bridge_impart(p->action.bridge.join, chan, p->action.bridge.swap,
         p->action.bridge.features, AST_BRIDGE_IMPART_CHAN_INDEPENDENT);
      ao2_ref(p->action.bridge.join, -1);
      p->action.bridge.join = NULL;
      ao2_cleanup(p->action.bridge.swap);
      p->action.bridge.swap = NULL;
      p->action.bridge.features = NULL;
      break;
   case LOCAL_CALL_ACTION_MASQUERADE:
      publish_local_bridge_message(p);
      ast_answer(chan);
      res = ast_channel_move(p->action.masq, chan);
      if (!res) {
         /* Chan is now an orphaned zombie.  Destroy it. */
         ast_hangup(chan);
      }
      p->action.masq = ast_channel_unref(p->action.masq);
      break;
   }
   if (!res) {
      ao2_lock(p);
      ast_set_flag(&p->base, AST_UNREAL_CARETAKER_THREAD);
      ao2_unlock(p);
   }

   /* we already unlocked them, clear them here so the cleanup label won't touch them. */
   owner = ast_channel_unref(owner);
   chan = ast_channel_unref(chan);

return_cleanup:
   if (p) {
      if (pvt_locked) {
         ao2_unlock(p);
      }
      ao2_ref(p, -1);
   }
   if (chan) {
      ast_channel_unlock(chan);
      ast_channel_unref(chan);
   }

   /*
    * owner is supposed to be == to ast, if it is, don't unlock it
    * because ast must exit locked
    */
   if (owner) {
      if (owner != ast) {
         ast_channel_unlock(owner);
         ast_channel_lock(ast);
      }
      ast_channel_unref(owner);
   } else {
      /* we have to exit with ast locked */
      ast_channel_lock(ast);
   }

   return res;
}

local_channel_optimization_blob()

static struct ast_multi_channel_blob* local_channel_optimization_blob ( struct local_pvt *  p, struct ast_json *  json_object  )

static

Definition at line 362 of file core_local.c.

References ao2_cleanup, ast_channel_snapshot_get_latest(), ast_channel_uniqueid(), ast_multi_channel_blob_add_channel(), ast_multi_channel_blob_create(), local_pvt::base, ast_unreal_pvt::chan, NULL, ast_unreal_pvt::owner, and RAII_VAR.

Referenced by local_optimization_finished_cb(), and local_optimization_started_cb().

{
   struct ast_multi_channel_blob *payload;
   RAII_VAR(struct ast_channel_snapshot *, local_one_snapshot, NULL, ao2_cleanup);
   RAII_VAR(struct ast_channel_snapshot *, local_two_snapshot, NULL, ao2_cleanup);

   local_one_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(p->base.owner));
   if (!local_one_snapshot) {
      return NULL;
   }

   local_two_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(p->base.chan));
   if (!local_two_snapshot) {
      return NULL;
   }

   payload = ast_multi_channel_blob_create(json_object);
   if (!payload) {
      return NULL;
   }
   ast_multi_channel_blob_add_channel(payload, "1", local_one_snapshot);
   ast_multi_channel_blob_add_channel(payload, "2", local_two_snapshot);

   return payload;
}

local_devicestate()

static int local_devicestate ( const char *  data )

static

Adds devicestate to local channels.

Definition at line 308 of file core_local.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_debug, AST_DEVICE_INUSE, AST_DEVICE_INVALID, AST_DEVICE_NOT_INUSE, ast_exists_extension(), ast_log, ast_strdupa, ast_test_flag, AST_UNREAL_CARETAKER_THREAD, local_pvt::base, context, local_pvt::context, exten, local_pvt::exten, LOG_WARNING, NULL, and ast_unreal_pvt::owner.

{
   int is_inuse = 0;
   int res = AST_DEVICE_INVALID;
   char *exten = ast_strdupa(data);
   char *context;
   char *opts;
   struct local_pvt *lp;
   struct ao2_iterator it;

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

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

   it = ao2_iterator_init(locals, 0);
   for (; (lp = ao2_iterator_next(&it)); ao2_ref(lp, -1)) {
      ao2_lock(lp);
      if (!strcmp(exten, lp->exten)
         && !strcmp(context, lp->context)) {
         res = AST_DEVICE_NOT_INUSE;
         if (lp->base.owner
            && ast_test_flag(&lp->base, AST_UNREAL_CARETAKER_THREAD)) {
            is_inuse = 1;
         }
      }
      ao2_unlock(lp);
      if (is_inuse) {
         res = AST_DEVICE_INUSE;
         ao2_ref(lp, -1);
         break;
      }
   }
   ao2_iterator_destroy(&it);

   if (res == AST_DEVICE_INVALID) {
      ast_debug(3, "Checking if extension %s@%s exists (devicestate)\n", exten, context);
      if (ast_exists_extension(NULL, context, exten, 1, NULL)) {
         res = AST_DEVICE_NOT_INUSE;
      }
   }

   return res;
}

local_hangup()

static int local_hangup ( struct ast_channel *  ast )

static

Hangup a call through the local proxy channel.

Definition at line 811 of file core_local.c.

References ao2_lock, ao2_ref, ao2_unlink, ao2_unlock, ast_channel_tech_pvt(), ast_unreal_hangup(), local_pvt::base, ast_unreal_pvt::chan, and ast_unreal_pvt::owner.

{
   struct local_pvt *p = ast_channel_tech_pvt(ast);
   int res;

   if (!p) {
      return -1;
   }

   /* give the pvt a ref to fulfill calling requirements. */
   ao2_ref(p, +1);
   res = ast_unreal_hangup(&p->base, ast);
   if (!res) {
      int unlink;

      ao2_lock(p);
      unlink = !p->base.owner && !p->base.chan;
      ao2_unlock(p);
      if (unlink) {
         ao2_unlink(locals, p);
      }
   }
   ao2_ref(p, -1);

   return res;
}

local_message_to_ami()

static struct ast_manager_event_blob * local_message_to_ami ( struct stasis_message *  msg )

static

Definition at line 463 of file core_local.c.

References ast_free, ast_json_integer_get(), ast_json_is_true(), ast_json_object_get(), ast_json_string_get(), ast_local_bridge_type(), ast_local_optimization_begin_type(), ast_local_optimization_end_type(), ast_manager_build_channel_state_string_prefix(), ast_manager_event_blob_create(), ast_multi_channel_blob_get_channel(), ast_multi_channel_blob_get_json(), ast_str_append(), ast_str_buffer(), ast_str_create, AST_UNREAL_OWNER, ast_channel_snapshot::base, EVENT_FLAG_CALL, NULL, RAII_VAR, stasis_message_data(), stasis_message_type(), and ast_channel_snapshot_base::uniqueid.

{
   struct ast_multi_channel_blob *obj = stasis_message_data(message);
   struct ast_json *blob = ast_multi_channel_blob_get_json(obj);
   struct ast_channel_snapshot *local_snapshot_one;
   struct ast_channel_snapshot *local_snapshot_two;
   RAII_VAR(struct ast_str *, local_channel_one, NULL, ast_free);
   RAII_VAR(struct ast_str *, local_channel_two, NULL, ast_free);
   RAII_VAR(struct ast_str *, event_buffer, NULL, ast_free);
   const char *event;

   local_snapshot_one = ast_multi_channel_blob_get_channel(obj, "1");
   local_snapshot_two = ast_multi_channel_blob_get_channel(obj, "2");
   if (!local_snapshot_one || !local_snapshot_two) {
      return NULL;
   }

   event_buffer = ast_str_create(1024);
   local_channel_one = ast_manager_build_channel_state_string_prefix(local_snapshot_one, "LocalOne");
   local_channel_two = ast_manager_build_channel_state_string_prefix(local_snapshot_two, "LocalTwo");
   if (!event_buffer || !local_channel_one || !local_channel_two) {
      return NULL;
   }

   if (stasis_message_type(message) == ast_local_optimization_begin_type()) {
      struct ast_channel_snapshot *source_snapshot;
      RAII_VAR(struct ast_str *, source_str, NULL, ast_free);
      const char *dest_uniqueid;

      source_snapshot = ast_multi_channel_blob_get_channel(obj, "source");
      if (source_snapshot) {
         source_str = ast_manager_build_channel_state_string_prefix(source_snapshot, "Source");
         if (!source_str) {
            return NULL;
         }
      }

      dest_uniqueid = ast_json_object_get(blob, "dest") == AST_UNREAL_OWNER ?
            local_snapshot_one->base->uniqueid : local_snapshot_two->base->uniqueid;

      event = "LocalOptimizationBegin";
      if (source_str) {
         ast_str_append(&event_buffer, 0, "%s", ast_str_buffer(source_str));
      }
      ast_str_append(&event_buffer, 0, "DestUniqueId: %s\r\n", dest_uniqueid);
      ast_str_append(&event_buffer, 0, "Id: %u\r\n", (unsigned int) ast_json_integer_get(ast_json_object_get(blob, "id")));
   } else if (stasis_message_type(message) == ast_local_optimization_end_type()) {
      event = "LocalOptimizationEnd";
      ast_str_append(&event_buffer, 0, "Success: %s\r\n", ast_json_integer_get(ast_json_object_get(blob, "success")) ? "Yes" : "No");
      ast_str_append(&event_buffer, 0, "Id: %u\r\n", (unsigned int) ast_json_integer_get(ast_json_object_get(blob, "id")));
   } else if (stasis_message_type(message) == ast_local_bridge_type()) {
      event = "LocalBridge";
      ast_str_append(&event_buffer, 0, "Context: %s\r\n", ast_json_string_get(ast_json_object_get(blob, "context")));
      ast_str_append(&event_buffer, 0, "Exten: %s\r\n", ast_json_string_get(ast_json_object_get(blob, "exten")));
      ast_str_append(&event_buffer, 0, "LocalOptimization: %s\r\n", ast_json_is_true(ast_json_object_get(blob, "can_optimize")) ? "Yes" : "No");
   } else {
      return NULL;
   }

   return ast_manager_event_blob_create(EVENT_FLAG_CALL, event,
      "%s"
      "%s"
      "%s",
      ast_str_buffer(local_channel_one),
      ast_str_buffer(local_channel_two),
      ast_str_buffer(event_buffer));
}

local_optimization_finished_cb()

static void local_optimization_finished_cb ( struct ast_unreal_pvt *  base, int  success, unsigned int  id  )

static

Callback for ast_unreal_pvt_callbacks optimization_finished_cb.

Definition at line 433 of file core_local.c.

References ao2_cleanup, ast_channel_topic(), ast_json_null(), ast_json_pack(), ast_json_unref(), ast_local_optimization_end_type(), local_pvt::base, local_channel_optimization_blob(), NULL, ast_unreal_pvt::owner, RAII_VAR, stasis_message_create(), and stasis_publish().

{
   RAII_VAR(struct ast_json *, json_object, ast_json_null(), ast_json_unref);
   RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
   RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
   struct local_pvt *p = (struct local_pvt *)base;

   if (!ast_local_optimization_end_type()) {
      return;
   }

   json_object = ast_json_pack("{s: i, s: I}", "success", success, "id", (ast_json_int_t)id);

   if (!json_object) {
      return;
   }

   payload = local_channel_optimization_blob(p, json_object);
   if (!payload) {
      return;
   }

   msg = stasis_message_create(ast_local_optimization_end_type(), payload);
   if (!msg) {
      return;
   }

   stasis_publish(ast_channel_topic(p->base.owner), msg);
}

local_optimization_started_cb()

static void local_optimization_started_cb ( struct ast_unreal_pvt *  base, struct ast_channel *  source, enum ast_unreal_channel_indicator  dest, unsigned int  id  )

static

Callback for ast_unreal_pvt_callbacks optimization_started_cb.

Definition at line 390 of file core_local.c.

References ao2_cleanup, ast_channel_snapshot_get_latest(), ast_channel_topic(), ast_channel_uniqueid(), ast_json_null(), ast_json_pack(), ast_json_unref(), ast_local_optimization_begin_type(), ast_multi_channel_blob_add_channel(), local_pvt::base, local_channel_optimization_blob(), NULL, ast_unreal_pvt::owner, RAII_VAR, stasis_message_create(), and stasis_publish().

{
   RAII_VAR(struct ast_json *, json_object, ast_json_null(), ast_json_unref);
   RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
   RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
   struct local_pvt *p = (struct local_pvt *)base;

   if (!ast_local_optimization_begin_type()) {
      return;
   }

   json_object = ast_json_pack("{s: i, s: I}",
         "dest", dest, "id", (ast_json_int_t)id);

   if (!json_object) {
      return;
   }

   payload = local_channel_optimization_blob(p, json_object);
   if (!payload) {
      return;
   }

   if (source) {
      RAII_VAR(struct ast_channel_snapshot *, source_snapshot, NULL, ao2_cleanup);
      source_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(source));
      if (!source_snapshot) {
         return;
      }

      ast_multi_channel_blob_add_channel(payload, "source", source_snapshot);
   }

   msg = stasis_message_create(ast_local_optimization_begin_type(), payload);
   if (!msg) {
      return;
   }

   stasis_publish(ast_channel_topic(p->base.owner), msg);
}

local_pvt_destructor()

static void local_pvt_destructor ( void *  vdoomed )

static

Definition at line 846 of file core_local.c.

References local_pvt::action, ao2_cleanup, ast_bridge_features_destroy(), ast_unreal_destructor(), local_pvt::base, local_pvt::bridge, local_bridge::features, local_bridge::join, LOCAL_CALL_ACTION_BRIDGE, LOCAL_CALL_ACTION_DIALPLAN, LOCAL_CALL_ACTION_MASQUERADE, local_pvt::masq, local_bridge::swap, and local_pvt::type.

Referenced by local_alloc().

{
   struct local_pvt *doomed = vdoomed;

   switch (doomed->type) {
   case LOCAL_CALL_ACTION_DIALPLAN:
      break;
   case LOCAL_CALL_ACTION_BRIDGE:
      ao2_cleanup(doomed->action.bridge.join);
      ao2_cleanup(doomed->action.bridge.swap);
      ast_bridge_features_destroy(doomed->action.bridge.features);
      break;
   case LOCAL_CALL_ACTION_MASQUERADE:
      ao2_cleanup(doomed->action.masq);
      break;
   }
   ast_unreal_destructor(&doomed->base);
}

local_request()

static struct ast_channel * local_request ( const char *  type, struct ast_format_cap *  cap, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor, const char *  data, int *  cause  )

static

Part of PBX interface.

Definition at line 922 of file core_local.c.

References ast_stream_topology_create_from_format_cap(), ast_stream_topology_free(), local_request_with_stream_topology(), and NULL.

{
   struct ast_stream_topology *topology;
   struct ast_channel *chan;

   topology = ast_stream_topology_create_from_format_cap(cap);
   if (!topology) {
      return NULL;
   }

   chan = local_request_with_stream_topology(type, topology, assignedids, requestor, data, cause);

   ast_stream_topology_free(topology);

   return chan;
}

local_request_with_stream_topology()

static struct ast_channel * local_request_with_stream_topology ( const char *  type, struct ast_stream_topology *  topology, const struct ast_assigned_ids *  assignedids, const struct ast_channel *  requestor, const char *  data, int *  cause  )

static

Part of PBX interface.

Definition at line 940 of file core_local.c.

References ao2_link, ao2_ref, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_cap_get_names(), AST_FORMAT_CAP_NAMES_LEN, ast_log, AST_MEDIA_TYPE_AUDIO, ast_read_threadstorage_callid(), AST_STATE_DOWN, AST_STATE_RING, ast_str_alloca, ast_stream_get_formats(), ast_stream_get_state(), ast_stream_get_type(), ast_stream_set_formats(), AST_STREAM_STATE_REMOVED, ast_stream_topology_clone(), ast_stream_topology_get_count(), ast_stream_topology_get_stream(), ast_translator_best_choice(), ast_unreal_new_channels(), local_pvt::base, ast_channel::callid, ast_channel_tech::capabilities, local_pvt::context, local_pvt::exten, local_alloc(), LOG_WARNING, and NULL.

Referenced by local_request().

{
   struct ast_stream_topology *audio_filtered_topology;
   int i;
   struct local_pvt *p;
   struct ast_channel *chan;
   ast_callid callid;

   /* Create a copy of the requested topology as we don't have ownership over
    * the one that is passed in.
    */
   audio_filtered_topology = ast_stream_topology_clone(topology);
   if (!audio_filtered_topology) {
      return NULL;
   }

   /* Some users of Local channels request every known format in the
    * universe. The core itself automatically pruned this list down to a single
    * "best" format for audio in non-multistream. We replicate the logic here to
    * do the same thing.
    */
   for (i = 0; i < ast_stream_topology_get_count(audio_filtered_topology); ++i) {
      struct ast_stream *stream;
      int res;
      struct ast_format *tmp_fmt = NULL;
      struct ast_format *best_audio_fmt = NULL;
      struct ast_format_cap *caps;

      stream = ast_stream_topology_get_stream(audio_filtered_topology, i);

      if (ast_stream_get_type(stream) != AST_MEDIA_TYPE_AUDIO ||
         ast_stream_get_state(stream) == AST_STREAM_STATE_REMOVED) {
         continue;
      }

      /* Respect the immutable state of formats on the stream and create a new
       * format capabilities to replace the existing one.
       */
      caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
      if (!caps) {
         ao2_ref(audio_filtered_topology, -1);
         return NULL;
      }

      /* The ast_translator_best_choice function treats both caps as const
       * but does not declare it in the API.
       */
      res = ast_translator_best_choice((struct ast_format_cap *)ast_stream_get_formats(stream), local_tech.capabilities,
         &tmp_fmt, &best_audio_fmt);
      if (res < 0) {
         struct ast_str *tech_codecs = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);
         struct ast_str *request_codecs = ast_str_alloca(AST_FORMAT_CAP_NAMES_LEN);

         ast_log(LOG_WARNING, "No translator path exists for channel type %s (native %s) to %s\n", type,
            ast_format_cap_get_names(local_tech.capabilities, &tech_codecs),
            ast_format_cap_get_names(ast_stream_get_formats(stream), &request_codecs));

         /* If there are no formats then we abort */
         ao2_ref(caps, -1);
         ao2_ref(audio_filtered_topology, -1);
         return NULL;
      }

      ast_format_cap_append(caps, best_audio_fmt, 0);
      ast_stream_set_formats(stream, caps);

      ao2_ref(caps, -1);
      ao2_ref(tmp_fmt, -1);
      ao2_ref(best_audio_fmt, -1);
   }

   /* Allocate a new private structure and then Asterisk channels */
   p = local_alloc(data, audio_filtered_topology);
   ao2_ref(audio_filtered_topology, -1);
   if (!p) {
      return NULL;
   }
   callid = ast_read_threadstorage_callid();
   chan = ast_unreal_new_channels(&p->base, &local_tech, AST_STATE_DOWN, AST_STATE_RING,
      p->exten, p->context, assignedids, requestor, callid);
   if (chan) {
      ao2_link(locals, p);
   }
   ao2_ref(p, -1); /* kill the ref from the alloc */

   return chan;
}

local_setoption()

int local_setoption ( struct ast_channel *  chan, int  option, void *  data, int  datalen  )

static

Definition at line 1177 of file core_local.c.

References AST_OPTION_SECURE_MEDIA, AST_OPTION_SECURE_SIGNALING, and ast_unreal_setoption().

{
   switch (option) {
   case AST_OPTION_SECURE_SIGNALING:
   case AST_OPTION_SECURE_MEDIA:
         return 0; /* local calls (like forwardings) are secure always */
   default:
         return ast_unreal_setoption(ast, option, data, datalen);
   }
}

local_shutdown()

static void local_shutdown ( void  )

static

Definition at line 1122 of file core_local.c.

References ao2_cleanup, ao2_ref, ARRAY_LEN, ast_channel_unregister(), ast_cli_unregister_multiple(), ast_local_bridge_type(), ast_local_optimization_begin_type(), ast_local_optimization_end_type(), ast_manager_unregister(), ast_channel_tech::capabilities, NULL, and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by ast_local_init().

{
   /* First, take us out of the channel loop */
   ast_cli_unregister_multiple(cli_local, ARRAY_LEN(cli_local));
   ast_manager_unregister("LocalOptimizeAway");
   ast_channel_unregister(&local_tech);

   ao2_ref(locals, -1);
   locals = NULL;

   ao2_cleanup(local_tech.capabilities);
   local_tech.capabilities = NULL;

   STASIS_MESSAGE_TYPE_CLEANUP(ast_local_optimization_begin_type);
   STASIS_MESSAGE_TYPE_CLEANUP(ast_local_optimization_end_type);
   STASIS_MESSAGE_TYPE_CLEANUP(ast_local_bridge_type);
}

locals_cmp_cb()

static int locals_cmp_cb ( void *  obj, void *  arg, int  flags  )

static

Definition at line 1110 of file core_local.c.

References CMP_MATCH.

Referenced by ast_local_init().

{
   return (obj == arg) ? CMP_MATCH : 0;
}

locals_show()

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 1030 of file core_local.c.

References ao2_container_count(), ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_cli_args::argc, ast_channel_name(), ast_cli(), local_pvt::base, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ast_cli_args::fd, ast_unreal_pvt::name, NULL, ast_unreal_pvt::owner, RESULT_SUCCESS, and ast_cli_entry::usage.

{
   struct local_pvt *p;
   struct ao2_iterator it;

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

   if (ao2_container_count(locals) == 0) {
      ast_cli(a->fd, "No local channels in use\n");
      return RESULT_SUCCESS;
   }

   it = ao2_iterator_init(locals, 0);
   while ((p = ao2_iterator_next(&it))) {
      ao2_lock(p);
      ast_cli(a->fd, "%s -- %s\n",
         p->base.owner ? ast_channel_name(p->base.owner) : "<unowned>",
         p->base.name);
      ao2_unlock(p);
      ao2_ref(p, -1);
   }
   ao2_iterator_destroy(&it);

   return CLI_SUCCESS;
}

manager_optimize_away()

static int manager_optimize_away ( struct mansession *  s, const struct message *  m  )

static

Definition at line 1073 of file core_local.c.

References ao2_find, ao2_lock, ao2_ref, ao2_unlock, ast_channel_get_by_name(), ast_channel_tech_pvt(), ast_channel_unref, ast_clear_flag, ast_strlen_zero, AST_UNREAL_NO_OPTIMIZATION, astman_get_header(), astman_send_ack(), astman_send_error(), local_pvt::base, and NULL.

Referenced by ast_local_init().

{
   const char *channel;
   struct local_pvt *p;
   struct local_pvt *found;
   struct ast_channel *chan;

   channel = astman_get_header(m, "Channel");
   if (ast_strlen_zero(channel)) {
      astman_send_error(s, m, "'Channel' not specified.");
      return 0;
   }

   chan = ast_channel_get_by_name(channel);
   if (!chan) {
      astman_send_error(s, m, "Channel does not exist.");
      return 0;
   }

   p = ast_channel_tech_pvt(chan);
   ast_channel_unref(chan);

   found = p ? ao2_find(locals, p, 0) : NULL;
   if (found) {
      ao2_lock(found);
      ast_clear_flag(&found->base, AST_UNREAL_NO_OPTIMIZATION);
      ao2_unlock(found);
      ao2_ref(found, -1);
      astman_send_ack(s, m, "Queued channel to be optimized away");
   } else {
      astman_send_error(s, m, "Unable to find channel");
   }

   return 0;
}

publish_local_bridge_message()

static void publish_local_bridge_message ( struct local_pvt *  p )

static

Definition at line 540 of file core_local.c.

References ao2_cleanup, ao2_unlock, ast_channel_snapshot_get_latest(), ast_channel_topic(), ast_channel_uniqueid(), ast_channel_unlock, ast_channel_unref, ast_json_pack(), ast_json_unref(), ast_local_bridge_type(), ast_multi_channel_blob_add_channel(), ast_multi_channel_blob_create(), ast_test_flag, ast_unreal_lock_all(), AST_UNREAL_NO_OPTIMIZATION, local_pvt::base, local_pvt::context, end, local_pvt::exten, NULL, RAII_VAR, stasis_message_create(), and stasis_publish().

Referenced by local_call().

{
   RAII_VAR(struct ast_multi_channel_blob *, multi_blob, NULL, ao2_cleanup);
   RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
   RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
   RAII_VAR(struct ast_channel_snapshot *, one_snapshot, NULL, ao2_cleanup);
   RAII_VAR(struct ast_channel_snapshot *, two_snapshot, NULL, ao2_cleanup);
   struct ast_channel *owner;
   struct ast_channel *chan;

   if (!ast_local_bridge_type()) {
      return;
   }

   ast_unreal_lock_all(&p->base, &chan, &owner);

   blob = ast_json_pack("{s: s, s: s, s: b}",
      "context", p->context,
      "exten", p->exten,
      "can_optimize", !ast_test_flag(&p->base, AST_UNREAL_NO_OPTIMIZATION));
   if (!blob) {
      goto end;
   }

   multi_blob = ast_multi_channel_blob_create(blob);
   if (!multi_blob) {
      goto end;
   }

   one_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(owner));
   if (!one_snapshot) {
      goto end;
   }

   two_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan));
   if (!two_snapshot) {
      goto end;
   }

   ast_multi_channel_blob_add_channel(multi_blob, "1", one_snapshot);
   ast_multi_channel_blob_add_channel(multi_blob, "2", two_snapshot);

   msg = stasis_message_create(ast_local_bridge_type(), multi_blob);
   if (!msg) {
      goto end;
   }

   stasis_publish(ast_channel_topic(owner), msg);

end:
   ast_channel_unlock(owner);
   ast_channel_unref(owner);

   ast_channel_unlock(chan);
   ast_channel_unref(chan);

   ao2_unlock(&p->base);
}

STASIS_MESSAGE_TYPE_DEFN() [1/3]

STASIS_MESSAGE_TYPE_DEFN	(	ast_local_bridge_type	,
		.	to_ami = local_message_to_ami
	)

Define local channel message types.

STASIS_MESSAGE_TYPE_DEFN() [2/3]

STASIS_MESSAGE_TYPE_DEFN	(	ast_local_optimization_begin_type	,
		.	to_ami = local_message_to_ami
	)

STASIS_MESSAGE_TYPE_DEFN() [3/3]

STASIS_MESSAGE_TYPE_DEFN	(	ast_local_optimization_end_type	,
		.	to_ami = local_message_to_ami
	)

Variable Documentation

cli_local

struct ast_cli_entry cli_local[]

static

Initial value:

= {
   { .handler =  locals_show , .summary =  "List status of local channels" ,},
}

Definition at line 1069 of file core_local.c.

local_tech

struct ast_channel_tech local_tech

static

Definition at line 173 of file core_local.c.

local_unreal_callbacks

struct ast_unreal_pvt_callbacks local_unreal_callbacks

Initial value:

= {
   .optimization_started = local_optimization_started_cb,
   .optimization_finished = local_optimization_finished_cb,
}

Callbacks from the unreal core when channel optimization occurs.

Definition at line 167 of file core_local.c.

Referenced by local_alloc().

locals

struct ao2_container* locals

static

Definition at line 138 of file core_local.c.

Referenced by attended_transfer_bridge().

tdesc

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

static

Definition at line 136 of file core_local.c.