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.

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.
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.
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.
static struct ast_frame *	snoop_read (struct ast_channel *chan)
	Callback function for reading from a Snoop channel.
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.
static void *	snoop_stasis_thread (void *obj)
	Thread used for running the Stasis application.
static int	snoop_write (struct ast_channel *chan, struct ast_frame *frame)
	Callback function for writing to a Snoop whisper audiohook.
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.
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 = ASTERISK_GPL_KEY , .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.
static struct ast_channel_tech	snoop_tech
	Channel interface declaration.

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.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 445 of file res_stasis_snoop.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 445 of file res_stasis_snoop.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 445 of file res_stasis_snoop.c.

load_module()

static int load_module ( void  )

static

Definition at line 430 of file res_stasis_snoop.c.

{
    return AST_MODULE_LOAD_SUCCESS;
}

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

{
    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);
 
    if (snoop->spyee_chan) {
        ast_channel_lock(snoop->spyee_chan);
        spyee_snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(snoop->spyee_chan));
        ast_channel_unlock(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);
}

References ao2_cleanup, ast_channel_chanspy_start_type(), ast_channel_chanspy_stop_type(), ast_channel_lock, ast_channel_snapshot_get_latest(), ast_channel_topic(), ast_channel_uniqueid(), ast_channel_unlock, 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().

snoop_destroy()

static void snoop_destroy ( void *  obj )

static

Destructor for snoop structure.

Definition at line 80 of file res_stasis_snoop.c.

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

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

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 294 of file res_stasis_snoop.c.

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

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

snoop_fixup()

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

static

Definition at line 229 of file res_stasis_snoop.c.

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

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

snoop_hangup()

static int snoop_hangup ( struct ast_channel *  chan )

static

Callback function for hanging up a Snoop channel.

Definition at line 204 of file res_stasis_snoop.c.

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

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

snoop_read()

static struct ast_frame * snoop_read ( struct ast_channel *  chan )

static

Callback function for reading from a Snoop channel.

Definition at line 177 of file res_stasis_snoop.c.

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

References ast_audiohook_lock, ast_audiohook_read_frame(), AST_AUDIOHOOK_STATUS_RUNNING, ast_audiohook_unlock, ast_channel_tech_pvt(), ast_null_frame, ast_timer_ack(), stasis_app_snoop::chan, 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.

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 267 of file res_stasis_snoop.c.

{
    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;
    }
 
    /* Set the audiohook direction so we don't write unnecessary frames */
    if (ast_audiohook_set_frame_feed_direction(audiohook, *direction)) {
        /* If we are unable to set direction, the audiohook either failed to init
           or someone else started using it already.  If we don't bail here, we risk
           feeding frames that will never be read */
        return -1;
    }
 
    return ast_audiohook_attach(chan, audiohook);
}

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

Referenced by stasis_app_control_snoop().

snoop_stasis_thread()

static void * snoop_stasis_thread ( void *  obj )

static

Thread used for running the Stasis application.

Definition at line 255 of file res_stasis_snoop.c.

{
    RAII_VAR(struct stasis_app_snoop *, snoop, obj, ao2_cleanup);
 
    ast_pbx_exec_application(snoop->chan, "Stasis", ast_str_buffer(snoop->app));
 
    ast_hangup(snoop->chan);
 
    return NULL;
}

References ao2_cleanup, ast_hangup(), ast_pbx_exec_application(), ast_str_buffer(), NULL, and RAII_VAR.

Referenced by stasis_app_control_snoop().

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 156 of file res_stasis_snoop.c.

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

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::chan, stasis_app_snoop::whisper, stasis_app_snoop::whisper_active, and stasis_app_snoop::whisper_direction.

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

Returns

ast_channel ast_channel_unref() when done.

Return values

NULL	if snoop channel couldn't be created.

Definition at line 303 of file res_stasis_snoop.c.

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

References AO2_ALLOC_OPT_LOCK_NOLOCK, ao2_alloc_options, ao2_cleanup, ao2_ref, app, 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(), snoop_tech, STASIS_SNOOP_DIRECTION_NONE, thread, and ast_assigned_ids::uniqueid.

Referenced by ari_channels_handle_snoop_channel().

unload_module()

static int unload_module ( void  )

static

Definition at line 435 of file res_stasis_snoop.c.

{
    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 = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "res_stasis", }

static

Definition at line 445 of file res_stasis_snoop.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 445 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 245 of file res_stasis_snoop.c.

                                            {
    .type = "Snoop",
    .description = "Snoop Channel Driver",
    .write = snoop_write,
    .read = snoop_read,
    .hangup = snoop_hangup,
    .fixup = snoop_fixup,
};

Referenced by stasis_app_control_snoop().