res_stasis_snoop.c File Reference

Stasis application snoop control support. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/stasis_app_impl.h"
#include "asterisk/stasis_app_snoop.h"
#include "asterisk/audiohook.h"
#include "asterisk/pbx.h"
#include "asterisk/timing.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/json.h"
#include "asterisk/format_cache.h"

Include dependency graph for res_stasis_snoop.c:

Go to the source code of this file.

Data Structures
struct	stasis_app_snoop
	Structure which contains all of the snoop information. More...

Macros
#define	SNOOP_INTERVAL   20
	The interval (in milliseconds) that the Snoop timer is triggered, also controls length of audio within frames. More...

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	load_module (void)
static void	publish_chanspy_message (struct stasis_app_snoop *snoop, int start)
static void	snoop_destroy (void *obj)
	Destructor for snoop structure. More...
static void	snoop_determine_format (struct ast_channel *chan, struct stasis_app_snoop *snoop)
	Helper function which gets the format for a Snoop channel based on the channel being snooped on. More...
static int	snoop_fixup (struct ast_channel *oldchan, struct ast_channel *newchan)
static int	snoop_hangup (struct ast_channel *chan)
	Callback function for hanging up a Snoop channel. More...
static struct ast_frame *	snoop_read (struct ast_channel *chan)
	Callback function for reading from a Snoop channel. More...
static int	snoop_setup_audiohook (struct ast_channel *chan, enum ast_audiohook_type type, enum stasis_app_snoop_direction requested_direction, enum ast_audiohook_direction *direction, struct ast_audiohook *audiohook)
	Internal helper function which sets up and attaches a snoop audiohook. More...
static void *	snoop_stasis_thread (void *obj)
	Thread used for running the Stasis application. More...
static int	snoop_write (struct ast_channel *chan, struct ast_frame *frame)
	Callback function for writing to a Snoop whisper audiohook. More...
struct ast_channel *	stasis_app_control_snoop (struct ast_channel *chan, enum stasis_app_snoop_direction spy, enum stasis_app_snoop_direction whisper, const char *app, const char *app_args, const char *snoop_id)
	Create a snoop on the provided channel. More...
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS , .description = "Stasis application snoop support" , .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, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static unsigned int	chan_idx
	Index used to keep Snoop channel names unique. More...
static struct ast_channel_tech	snoop_tech
	Channel interface declaration. More...

Detailed Description

Stasis application snoop control support.

Author

Joshua Colp jcolp.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file res_stasis_snoop.c.

Macro Definition Documentation

SNOOP_INTERVAL

#define SNOOP_INTERVAL   20

The interval (in milliseconds) that the Snoop timer is triggered, also controls length of audio within frames.

Definition at line 44 of file res_stasis_snoop.c.

Referenced by stasis_app_control_snoop().

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 451 of file res_stasis_snoop.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 451 of file res_stasis_snoop.c.

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 451 of file res_stasis_snoop.c.

load_module()

static int load_module ( void  )

static

Definition at line 436 of file res_stasis_snoop.c.

References AST_MODULE_LOAD_SUCCESS.

Referenced by unload_module().

{
   return AST_MODULE_LOAD_SUCCESS;
}

publish_chanspy_message()

static void publish_chanspy_message ( struct stasis_app_snoop *  snoop, int  start  )

static

Definition at line 113 of file res_stasis_snoop.c.

References ao2_cleanup, ast_channel_chanspy_start_type(), ast_channel_chanspy_stop_type(), ast_channel_snapshot_get_latest(), ast_channel_topic(), ast_channel_uniqueid(), ast_json_null(), ast_json_unref(), ast_multi_channel_blob_add_channel(), ast_multi_channel_blob_create(), stasis_app_snoop::chan, NULL, RAII_VAR, stasis_app_snoop::spyee_chan, stasis_message_create(), stasis_publish(), and type.

Referenced by snoop_hangup(), and stasis_app_control_snoop().

{
   RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
   RAII_VAR(struct ast_multi_channel_blob *, payload, NULL, ao2_cleanup);
   RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
   RAII_VAR(struct ast_channel_snapshot *, snoop_snapshot, NULL, ao2_cleanup);
   RAII_VAR(struct ast_channel_snapshot *, spyee_snapshot, NULL, ao2_cleanup);
   struct stasis_message_type *type = start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type();

   blob = ast_json_null();
   if (!blob || !type) {
      return;
   }

   payload = ast_multi_channel_blob_create(blob);
   if (!payload) {
      return;
   }

   snoop_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(snoop->chan));
   if (!snoop_snapshot) {
      return;
   }
   ast_multi_channel_blob_add_channel(payload, "spyer_channel", snoop_snapshot);

   spyee_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(snoop->spyee_chan));
   if (spyee_snapshot) {
      ast_multi_channel_blob_add_channel(payload, "spyee_channel", spyee_snapshot);
   }

   message = stasis_message_create(type, payload);
   if (!message) {
      return;
   }

   stasis_publish(ast_channel_topic(snoop->chan), message);
}

snoop_destroy()

static void snoop_destroy ( void *  obj )

static

Destructor for snoop structure.

Definition at line 80 of file res_stasis_snoop.c.

References stasis_app_snoop::app, ast_audiohook_destroy(), ast_channel_cleanup, ast_free, ast_timer_close(), stasis_app_snoop::chan, ast_frame::data, NULL, ast_frame::ptr, stasis_app_snoop::silence, stasis_app_snoop::spy, stasis_app_snoop::spy_active, stasis_app_snoop::spyee_chan, stasis_app_snoop::timer, stasis_app_snoop::whisper, and stasis_app_snoop::whisper_active.

Referenced by stasis_app_control_snoop().

{
   struct stasis_app_snoop *snoop = obj;

   if (snoop->timer) {
      ast_timer_close(snoop->timer);
   }

   if (snoop->spy_active) {
      ast_audiohook_destroy(&snoop->spy);
   }

   if (snoop->whisper_active) {
      ast_audiohook_destroy(&snoop->whisper);
   }

   if (snoop->silence.data.ptr) {
      ast_free(snoop->silence.data.ptr);
      snoop->silence.data.ptr = NULL;
   }

   ast_free(snoop->app);

   ast_channel_cleanup(snoop->spyee_chan);
   ast_channel_cleanup(snoop->chan);
}

snoop_determine_format()

static void snoop_determine_format ( struct ast_channel *  chan, struct stasis_app_snoop *  snoop  )

static

Helper function which gets the format for a Snoop channel based on the channel being snooped on.

Definition at line 300 of file res_stasis_snoop.c.

References ast_channel_rawreadformat(), ast_channel_rawwriteformat(), ast_format_cache_get_slin_by_rate(), ast_format_get_sample_rate(), lock, MAX, SCOPED_CHANNELLOCK, and stasis_app_snoop::spy_format.

Referenced by stasis_app_control_snoop().

{
   SCOPED_CHANNELLOCK(lock, chan);
   unsigned int rate = MAX(ast_format_get_sample_rate(ast_channel_rawwriteformat(chan)),
      ast_format_get_sample_rate(ast_channel_rawreadformat(chan)));

   snoop->spy_format = ast_format_cache_get_slin_by_rate(rate);
}

snoop_fixup()

static int snoop_fixup ( struct ast_channel *  oldchan, struct ast_channel *  newchan  )

static

Definition at line 237 of file res_stasis_snoop.c.

References ast_channel_ref, ast_channel_tech_pvt(), ast_channel_unref, and stasis_app_snoop::chan.

{
   struct stasis_app_snoop *snoop = ast_channel_tech_pvt(oldchan);

   if (snoop->chan != oldchan) {
      return -1;
   }

   ast_channel_unref(snoop->chan);
   ast_channel_ref(newchan);
   snoop->chan = newchan;

   return 0;
}

snoop_hangup()

static int snoop_hangup ( struct ast_channel *  chan )

static

Callback function for hanging up a Snoop channel.

Definition at line 212 of file res_stasis_snoop.c.

References ao2_cleanup, ast_audiohook_detach(), ast_audiohook_lock, ast_audiohook_unlock, ast_channel_tech_pvt(), ast_channel_tech_pvt_set(), NULL, publish_chanspy_message(), stasis_app_snoop::spy, stasis_app_snoop::spy_active, stasis_app_snoop::whisper, and stasis_app_snoop::whisper_active.

{
   struct stasis_app_snoop *snoop = ast_channel_tech_pvt(chan);

   if (snoop->spy_active) {
      ast_audiohook_lock(&snoop->spy);
      ast_audiohook_detach(&snoop->spy);
      ast_audiohook_unlock(&snoop->spy);
   }

   if (snoop->whisper_active) {
      ast_audiohook_lock(&snoop->whisper);
      ast_audiohook_detach(&snoop->whisper);
      ast_audiohook_unlock(&snoop->whisper);
   }

   publish_chanspy_message(snoop, 0);

   ao2_cleanup(snoop);

   ast_channel_tech_pvt_set(chan, NULL);

   return 0;
}

snoop_read()

static struct ast_frame* snoop_read ( struct ast_channel *  chan )

static

Callback function for reading from a Snoop channel.

Definition at line 173 of file res_stasis_snoop.c.

References AST_AUDIOHOOK_DIRECTION_BOTH, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_lock, ast_audiohook_read_frame(), AST_AUDIOHOOK_STATUS_RUNNING, ast_audiohook_unlock, ast_channel_tech_pvt(), ast_frame_dtor(), ast_null_frame, ast_timer_ack(), NULL, stasis_app_snoop::silence, stasis_app_snoop::spy, stasis_app_snoop::spy_active, stasis_app_snoop::spy_direction, stasis_app_snoop::spy_format, stasis_app_snoop::spy_samples, ast_audiohook::status, stasis_app_snoop::timer, stasis_app_snoop::whisper, and stasis_app_snoop::whisper_active.

{
   struct stasis_app_snoop *snoop = ast_channel_tech_pvt(chan);
   struct ast_frame *frame = NULL;

   /* If we fail to ack the timer OR if any active audiohooks are done hangup */
   if ((ast_timer_ack(snoop->timer, 1) < 0) ||
      (snoop->spy_active && snoop->spy.status != AST_AUDIOHOOK_STATUS_RUNNING) ||
      (snoop->whisper_active && snoop->whisper.status != AST_AUDIOHOOK_STATUS_RUNNING)) {
      return NULL;
   }

   /* Only get audio from the spy audiohook if it is active */
   if (!snoop->spy_active) {
      return &ast_null_frame;
   }

   ast_audiohook_lock(&snoop->spy);
   if (snoop->spy_direction != AST_AUDIOHOOK_DIRECTION_BOTH) {
      /*
       * When a singular direction is chosen frames are still written to the
       * opposing direction's queue. Those frames must be read so the queue
       * does not continue to grow, however since they are not needed for the
       * selected direction they can be dropped.
       */
      enum ast_audiohook_direction opposing_direction =
         snoop->spy_direction == AST_AUDIOHOOK_DIRECTION_READ ?
         AST_AUDIOHOOK_DIRECTION_WRITE : AST_AUDIOHOOK_DIRECTION_READ;
      ast_frame_dtor(ast_audiohook_read_frame(&snoop->spy, snoop->spy_samples,
                     opposing_direction, snoop->spy_format));
   }

   frame = ast_audiohook_read_frame(&snoop->spy, snoop->spy_samples, snoop->spy_direction, snoop->spy_format);
   ast_audiohook_unlock(&snoop->spy);

   return frame ? frame : &snoop->silence;
}

snoop_setup_audiohook()

static int snoop_setup_audiohook ( struct ast_channel *  chan, enum ast_audiohook_type  type, enum stasis_app_snoop_direction  requested_direction, enum ast_audiohook_direction *  direction, struct ast_audiohook *  audiohook  )

static

Internal helper function which sets up and attaches a snoop audiohook.

Definition at line 281 of file res_stasis_snoop.c.

References ast_audiohook_attach(), AST_AUDIOHOOK_DIRECTION_BOTH, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_init(), STASIS_SNOOP_DIRECTION_BOTH, STASIS_SNOOP_DIRECTION_IN, and STASIS_SNOOP_DIRECTION_OUT.

Referenced by stasis_app_control_snoop().

{
   ast_audiohook_init(audiohook, type, "Snoop", 0);

   if (requested_direction == STASIS_SNOOP_DIRECTION_OUT) {
      *direction = AST_AUDIOHOOK_DIRECTION_WRITE;
   } else if (requested_direction == STASIS_SNOOP_DIRECTION_IN) {
      *direction = AST_AUDIOHOOK_DIRECTION_READ;
   } else if (requested_direction == STASIS_SNOOP_DIRECTION_BOTH) {
      *direction = AST_AUDIOHOOK_DIRECTION_BOTH;
   } else {
      return -1;
   }

   return ast_audiohook_attach(chan, audiohook);
}

snoop_stasis_thread()

static void* snoop_stasis_thread ( void *  obj )

static

Thread used for running the Stasis application.

Definition at line 263 of file res_stasis_snoop.c.

References ao2_cleanup, ast_hangup(), ast_str_buffer(), NULL, pbx_exec(), pbx_findapp(), RAII_VAR, and stasis.

Referenced by stasis_app_control_snoop().

{
   RAII_VAR(struct stasis_app_snoop *, snoop, obj, ao2_cleanup);
   struct ast_app *stasis = pbx_findapp("Stasis");

   if (!stasis) {
      ast_hangup(snoop->chan);
      return NULL;
   }

   pbx_exec(snoop->chan, stasis, ast_str_buffer(snoop->app));

   ast_hangup(snoop->chan);

   return NULL;
}

snoop_write()

static int snoop_write ( struct ast_channel *  chan, struct ast_frame *  frame  )

static

Callback function for writing to a Snoop whisper audiohook.

Definition at line 152 of file res_stasis_snoop.c.

References AST_AUDIOHOOK_DIRECTION_BOTH, AST_AUDIOHOOK_DIRECTION_READ, AST_AUDIOHOOK_DIRECTION_WRITE, ast_audiohook_lock, ast_audiohook_unlock, ast_audiohook_write_frame(), ast_channel_tech_pvt(), stasis_app_snoop::whisper, stasis_app_snoop::whisper_active, and stasis_app_snoop::whisper_direction.

{
   struct stasis_app_snoop *snoop = ast_channel_tech_pvt(chan);

   if (!snoop->whisper_active) {
      return 0;
   }

   ast_audiohook_lock(&snoop->whisper);
   if (snoop->whisper_direction == AST_AUDIOHOOK_DIRECTION_BOTH) {
      ast_audiohook_write_frame(&snoop->whisper, AST_AUDIOHOOK_DIRECTION_READ, frame);
      ast_audiohook_write_frame(&snoop->whisper, AST_AUDIOHOOK_DIRECTION_WRITE, frame);
   } else {
      ast_audiohook_write_frame(&snoop->whisper, snoop->whisper_direction, frame);
   }
   ast_audiohook_unlock(&snoop->whisper);

   return 0;
}

stasis_app_control_snoop()

struct ast_channel* stasis_app_control_snoop	(	struct ast_channel *	chan,
		enum stasis_app_snoop_direction	spy,
		enum stasis_app_snoop_direction	whisper,
		const char *	app,
		const char *	app_args,
		const char *	snoop_id
	)

Create a snoop on the provided channel.

Parameters

chan	Channel to snoop on.
spy	Direction of media that should be spied on.
whisper	Direction of media that should be whispered into.
app	Stasis application to execute on the snoop channel.
app_args	Stasis application arguments.

Returns

Snoop channel. ast_channel_unref() when done.

NULL if snoop channel couldn't be created.

Definition at line 309 of file res_stasis_snoop.c.

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ao2_ref, ast_atomic_fetchadd_int(), AST_AUDIOHOOK_TYPE_SPY, AST_AUDIOHOOK_TYPE_WHISPER, ast_calloc, ast_channel_alloc, ast_channel_nativeformats_set(), ast_channel_ref, ast_channel_set_fd(), ast_channel_set_rawreadformat(), ast_channel_set_rawwriteformat(), ast_channel_set_readformat(), ast_channel_set_writeformat(), ast_channel_tech_pvt_set(), ast_channel_tech_set(), ast_channel_uniqueid(), ast_channel_unlock, ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_get_sample_rate(), AST_FRAME_VOICE, ast_hangup(), ast_pthread_create_detached_background, AST_STATE_UP, ast_str_append(), ast_str_create, ast_str_set(), ast_strlen_zero, ast_timer_fd(), ast_timer_open(), ast_timer_set_rate(), chan_idx, NULL, publish_chanspy_message(), RAII_VAR, snoop_destroy(), snoop_determine_format(), SNOOP_INTERVAL, snoop_setup_audiohook(), snoop_stasis_thread(), STASIS_SNOOP_DIRECTION_NONE, thread, and ast_assigned_ids::uniqueid.

Referenced by ari_channels_handle_snoop_channel().

{
   RAII_VAR(struct stasis_app_snoop *, snoop, NULL, ao2_cleanup);
   struct ast_format_cap *caps;
   pthread_t thread;
   struct ast_assigned_ids assignedids = {
      .uniqueid = snoop_id,
   };

   if (spy == STASIS_SNOOP_DIRECTION_NONE &&
      whisper == STASIS_SNOOP_DIRECTION_NONE) {
      return NULL;
   }

   snoop = ao2_alloc_options(sizeof(*snoop), snoop_destroy, AO2_ALLOC_OPT_LOCK_NOLOCK);
   if (!snoop) {
      return NULL;
   }

   /* Allocate a buffer to store the Stasis application and arguments in */
   snoop->app = ast_str_create(64);
   if (!snoop->app) {
      return NULL;
   }

   ast_str_set(&snoop->app, 0, "%s", app);
   if (!ast_strlen_zero(app_args)) {
      ast_str_append(&snoop->app, 0, ",%s", app_args);
   }

   /* Set up a timer for the Snoop channel so it wakes up at a specific interval */
   snoop->timer = ast_timer_open();
   if (!snoop->timer) {
      return NULL;
   }
   ast_timer_set_rate(snoop->timer, 1000 / SNOOP_INTERVAL);

   /* Determine which signed linear format should be used */
   snoop_determine_format(chan, snoop);

   /* Allocate a Snoop channel and set up various parameters */
   snoop->chan = ast_channel_alloc(1, AST_STATE_UP, "", "", "", "", "", &assignedids, NULL, 0, "Snoop/%s-%08x", ast_channel_uniqueid(chan),
      (unsigned)ast_atomic_fetchadd_int((int *)&chan_idx, +1));
   if (!snoop->chan) {
      return NULL;
   }

   /* To keep the channel valid on the Snoop structure until it is destroyed we bump the ref up here */
   ast_channel_ref(snoop->chan);

   ast_channel_tech_set(snoop->chan, &snoop_tech);
   ao2_ref(snoop, +1);
   ast_channel_tech_pvt_set(snoop->chan, snoop);
   ast_channel_set_fd(snoop->chan, 0, ast_timer_fd(snoop->timer));

   /* The format on the Snoop channel will be this signed linear format, and it will never change */
   caps = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
   if (!caps) {
      ast_channel_unlock(snoop->chan);
      ast_hangup(snoop->chan);
      return NULL;
   }
   ast_format_cap_append(caps, snoop->spy_format, 0);
   ast_channel_nativeformats_set(snoop->chan, caps);
   ao2_ref(caps, -1);

   ast_channel_set_writeformat(snoop->chan, snoop->spy_format);
   ast_channel_set_rawwriteformat(snoop->chan, snoop->spy_format);
   ast_channel_set_readformat(snoop->chan, snoop->spy_format);
   ast_channel_set_rawreadformat(snoop->chan, snoop->spy_format);

   ast_channel_unlock(snoop->chan);

   if (spy != STASIS_SNOOP_DIRECTION_NONE) {
      if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_SPY, spy, &snoop->spy_direction, &snoop->spy)) {
         ast_hangup(snoop->chan);
         return NULL;
      }

      snoop->spy_samples = ast_format_get_sample_rate(snoop->spy_format) / (1000 / SNOOP_INTERVAL);
      snoop->spy_active = 1;

      snoop->silence.frametype = AST_FRAME_VOICE,
      snoop->silence.datalen = snoop->spy_samples * sizeof(uint16_t),
      snoop->silence.samples = snoop->spy_samples,
      snoop->silence.mallocd = 0,
      snoop->silence.offset = 0,
      snoop->silence.src = __PRETTY_FUNCTION__,
      snoop->silence.subclass.format = snoop->spy_format,
      snoop->silence.data.ptr = ast_calloc(snoop->spy_samples, sizeof(uint16_t));
      if (!snoop->silence.data.ptr) {
         ast_hangup(snoop->chan);
         return NULL;
      }
   }

   /* If whispering is enabled set up the audiohook */
   if (whisper != STASIS_SNOOP_DIRECTION_NONE) {
      if (snoop_setup_audiohook(chan, AST_AUDIOHOOK_TYPE_WHISPER, whisper, &snoop->whisper_direction, &snoop->whisper)) {
         ast_hangup(snoop->chan);
         return NULL;
      }

      snoop->whisper_active = 1;
   }

   /* Create the thread which services the Snoop channel */
   ao2_ref(snoop, +1);
   if (ast_pthread_create_detached_background(&thread, NULL, snoop_stasis_thread, snoop)) {
      ao2_cleanup(snoop);

      /* No other thread is servicing this channel so we can immediately hang it up */
      ast_hangup(snoop->chan);
      return NULL;
   }

   /* Keep a reference to the channel we are spying on */
   snoop->spyee_chan = ast_channel_ref(chan);

   publish_chanspy_message(snoop, 1);

   /* The caller of this has a reference as well */
   return ast_channel_ref(snoop->chan);
}

unload_module()

static int unload_module ( void  )

static

Definition at line 441 of file res_stasis_snoop.c.

References AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, and load_module().

{
   return 0;
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS , .description = "Stasis application snoop support" , .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, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis", }

static

Definition at line 451 of file res_stasis_snoop.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 451 of file res_stasis_snoop.c.

chan_idx

unsigned int chan_idx

static

Index used to keep Snoop channel names unique.

Definition at line 47 of file res_stasis_snoop.c.

Referenced by stasis_app_control_snoop().

snoop_tech

struct ast_channel_tech snoop_tech

static

Channel interface declaration.

Definition at line 253 of file res_stasis_snoop.c.