stasis_app_snoop.h File Reference

Stasis Application Snoop API. See StasisApplication API" for detailed documentation. More...

#include "asterisk/stasis_app.h"

Include dependency graph for stasis_app_snoop.h:

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

Go to the source code of this file.

Enumerations
enum	stasis_app_snoop_direction { STASIS_SNOOP_DIRECTION_NONE = 0, STASIS_SNOOP_DIRECTION_OUT, STASIS_SNOOP_DIRECTION_IN, STASIS_SNOOP_DIRECTION_BOTH }
	Directions for audio stream flow. More...

Functions
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...

Detailed Description

Stasis Application Snoop API. See StasisApplication API" for detailed documentation.

Author

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

Since

12

Definition in file stasis_app_snoop.h.

Enumeration Type Documentation

stasis_app_snoop_direction

enum stasis_app_snoop_direction

Directions for audio stream flow.

Enumerator
STASIS_SNOOP_DIRECTION_NONE	No direction.
STASIS_SNOOP_DIRECTION_OUT	Audio stream out to the channel.
STASIS_SNOOP_DIRECTION_IN	Audio stream in from the channel.
STASIS_SNOOP_DIRECTION_BOTH	Audio stream to AND from the channel.

Definition at line 34 of file stasis_app_snoop.h.

                                {
   /*! \brief No direction */
   STASIS_SNOOP_DIRECTION_NONE = 0,
   /*! \brief Audio stream out to the channel */
   STASIS_SNOOP_DIRECTION_OUT,
   /*! \brief Audio stream in from the channel */
   STASIS_SNOOP_DIRECTION_IN,
   /*! \brief Audio stream to AND from the channel */
   STASIS_SNOOP_DIRECTION_BOTH,
};

Function Documentation

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