diff options
| -rw-r--r-- | include/asterisk/stasis_app_snoop.h | 60 | ||||
| -rw-r--r-- | main/audiohook.c | 14 | ||||
| -rw-r--r-- | res/ari/resource_channels.c | 71 | ||||
| -rw-r--r-- | res/ari/resource_channels.h | 23 | ||||
| -rw-r--r-- | res/res_ari_channels.c | 86 | ||||
| -rw-r--r-- | res/res_stasis_snoop.c | 394 | ||||
| -rw-r--r-- | res/res_stasis_snoop.exports.in | 6 | ||||
| -rw-r--r-- | rest-api/api-docs/channels.json | 85 |
8 files changed, 729 insertions, 10 deletions
diff --git a/include/asterisk/stasis_app_snoop.h b/include/asterisk/stasis_app_snoop.h new file mode 100644 index 000000000..a9c998f03 --- /dev/null +++ b/include/asterisk/stasis_app_snoop.h @@ -0,0 +1,60 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2013, Digium, Inc. + * + * Joshua Colp <jcolp@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +#ifndef _ASTERISK_STASIS_APP_SNOOP_H +#define _ASTERISK_STASIS_APP_SNOOP_H + +/*! \file + * + * \brief Stasis Application Snoop API. See \ref res_stasis "Stasis + * Application API" for detailed documentation. + * + * \author Joshua Colp <jcolp@digium.com> + * \since 12 + */ + +#include "asterisk/stasis_app.h" + +/*! \brief Directions for audio stream flow */ +enum stasis_app_snoop_direction { + /*! \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, +}; + +/*! + * \brief Create a snoop on the provided channel. + * + * \param chan Channel to snoop on. + * \param spy Direction of media that should be spied on. + * \param whisper Direction of media that should be whispered into. + * \param app Stasis application to execute on the snoop channel. + * \param app_args Stasis application arguments. + * \return Snoop channel. ast_channel_unref() when done. + * \return \c NULL if snoop channel couldn't be created. + */ +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); + +#endif /* _ASTERISK_STASIS_APP_SNOOP_H */ diff --git a/main/audiohook.c b/main/audiohook.c index 6e02946aa..5aba9ecfb 100644 --- a/main/audiohook.c +++ b/main/audiohook.c @@ -79,15 +79,12 @@ static int audiohook_set_internal_rate(struct ast_audiohook *audiohook, int rate /* Setup the factories that are needed for this audiohook type */ switch (audiohook->type) { case AST_AUDIOHOOK_TYPE_SPY: - if (reset) { - ast_slinfactory_destroy(&audiohook->read_factory); - } - ast_slinfactory_init_with_format(&audiohook->read_factory, &slin); - /* fall through */ case AST_AUDIOHOOK_TYPE_WHISPER: if (reset) { + ast_slinfactory_destroy(&audiohook->read_factory); ast_slinfactory_destroy(&audiohook->write_factory); } + ast_slinfactory_init_with_format(&audiohook->read_factory, &slin); ast_slinfactory_init_with_format(&audiohook->write_factory, &slin); break; default: @@ -134,8 +131,8 @@ int ast_audiohook_destroy(struct ast_audiohook *audiohook) /* Drop the factories used by this audiohook type */ switch (audiohook->type) { case AST_AUDIOHOOK_TYPE_SPY: - ast_slinfactory_destroy(&audiohook->read_factory); case AST_AUDIOHOOK_TYPE_WHISPER: + ast_slinfactory_destroy(&audiohook->read_factory); ast_slinfactory_destroy(&audiohook->write_factory); break; default: @@ -815,11 +812,12 @@ static struct ast_frame *audio_audiohook_write_list(struct ast_channel *chan, st AST_LIST_TRAVERSE_SAFE_END; /* If this frame is being written out to the channel then we need to use whisper sources */ - if (direction == AST_AUDIOHOOK_DIRECTION_WRITE && !AST_LIST_EMPTY(&audiohook_list->whisper_list)) { + if (!AST_LIST_EMPTY(&audiohook_list->whisper_list)) { int i = 0; short read_buf[samples], combine_buf[samples], *data1 = NULL, *data2 = NULL; memset(&combine_buf, 0, sizeof(combine_buf)); AST_LIST_TRAVERSE_SAFE_BEGIN(&audiohook_list->whisper_list, audiohook, list) { + struct ast_slinfactory *factory = (direction == AST_AUDIOHOOK_DIRECTION_READ ? &audiohook->read_factory : &audiohook->write_factory); ast_audiohook_lock(audiohook); if (audiohook->status != AST_AUDIOHOOK_STATUS_RUNNING) { AST_LIST_REMOVE_CURRENT(list); @@ -829,7 +827,7 @@ static struct ast_frame *audio_audiohook_write_list(struct ast_channel *chan, st continue; } audiohook_set_internal_rate(audiohook, audiohook_list->list_internal_samp_rate, 1); - if (ast_slinfactory_available(&audiohook->write_factory) >= samples && ast_slinfactory_read(&audiohook->write_factory, read_buf, samples)) { + if (ast_slinfactory_available(factory) >= samples && ast_slinfactory_read(factory, read_buf, samples)) { /* Take audio from this whisper source and combine it into our main buffer */ for (i = 0, data1 = combine_buf, data2 = read_buf; i < samples; i++, data1++, data2++) ast_slinear_saturated_add(data1, data2); diff --git a/res/ari/resource_channels.c b/res/ari/resource_channels.c index 75d56d924..824c5e660 100644 --- a/res/ari/resource_channels.c +++ b/res/ari/resource_channels.c @@ -39,6 +39,7 @@ ASTERISK_FILE_VERSION(__FILE__, "$Revision$") #include "asterisk/stasis_app.h" #include "asterisk/stasis_app_playback.h" #include "asterisk/stasis_app_recording.h" +#include "asterisk/stasis_app_snoop.h" #include "asterisk/stasis_channels.h" #include "asterisk/causes.h" #include "resource_channels.h" @@ -847,3 +848,73 @@ void ast_ari_channels_set_channel_var(struct ast_variable *headers, ast_ari_response_no_content(response); } +void ast_ari_channels_snoop_channel(struct ast_variable *headers, struct ast_ari_channels_snoop_channel_args *args, struct ast_ari_response *response) +{ + enum stasis_app_snoop_direction spy, whisper; + RAII_VAR(struct ast_channel *, chan, NULL, ast_channel_cleanup); + RAII_VAR(struct ast_channel *, snoop, NULL, ast_channel_cleanup); + RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup); + + ast_assert(response != NULL); + + if (ast_strlen_zero(args->spy) || !strcmp(args->spy, "none")) { + spy = STASIS_SNOOP_DIRECTION_NONE; + } else if (!strcmp(args->spy, "both")) { + spy = STASIS_SNOOP_DIRECTION_BOTH; + } else if (!strcmp(args->spy, "out")) { + spy = STASIS_SNOOP_DIRECTION_OUT; + } else if (!strcmp(args->spy, "in")) { + spy = STASIS_SNOOP_DIRECTION_IN; + } else { + ast_ari_response_error( + response, 400, "Bad Request", + "Invalid direction specified for spy"); + return; + } + + if (ast_strlen_zero(args->whisper) || !strcmp(args->whisper, "none")) { + whisper = STASIS_SNOOP_DIRECTION_NONE; + } else if (!strcmp(args->whisper, "both")) { + whisper = STASIS_SNOOP_DIRECTION_BOTH; + } else if (!strcmp(args->whisper, "out")) { + whisper = STASIS_SNOOP_DIRECTION_OUT; + } else if (!strcmp(args->whisper, "in")) { + whisper = STASIS_SNOOP_DIRECTION_IN; + } else { + ast_ari_response_error( + response, 400, "Bad Request", + "Invalid direction specified for whisper"); + return; + } + + if (spy == STASIS_SNOOP_DIRECTION_NONE && whisper == STASIS_SNOOP_DIRECTION_NONE) { + ast_ari_response_error( + response, 400, "Bad Request", + "Direction must be specified for at least spy or whisper"); + return; + } else if (ast_strlen_zero(args->app)) { + ast_ari_response_error( + response, 400, "Bad Request", + "Application name is required"); + return; + } + + chan = ast_channel_get_by_name(args->channel_id); + if (chan == NULL) { + ast_ari_response_error( + response, 404, "Channel Not Found", + "Provided channel was not found"); + return; + } + + snoop = stasis_app_control_snoop(chan, spy, whisper, args->app, args->app_args); + if (snoop == NULL) { + ast_ari_response_error( + response, 500, "Internal error", + "Snoop channel could not be created"); + return; + } + + snapshot = ast_channel_snapshot_create(snoop); + ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot, NULL)); +}
\ No newline at end of file diff --git a/res/ari/resource_channels.h b/res/ari/resource_channels.h index a9ac72e39..49ab8eb34 100644 --- a/res/ari/resource_channels.h +++ b/res/ari/resource_channels.h @@ -386,5 +386,28 @@ struct ast_ari_channels_set_channel_var_args { * \param[out] response HTTP response */ void ast_ari_channels_set_channel_var(struct ast_variable *headers, struct ast_ari_channels_set_channel_var_args *args, struct ast_ari_response *response); +/*! \brief Argument struct for ast_ari_channels_snoop_channel() */ +struct ast_ari_channels_snoop_channel_args { + /*! \brief Channel's id */ + const char *channel_id; + /*! \brief Direction of audio to spy on */ + const char *spy; + /*! \brief Direction of audio to whisper into */ + const char *whisper; + /*! \brief Application the snooping channel is placed into */ + const char *app; + /*! \brief The application arguments to pass to the Stasis application */ + const char *app_args; +}; +/*! + * \brief Start snooping. + * + * Snoop (spy/whisper) on a specific channel. + * + * \param headers HTTP headers + * \param args Swagger parameters + * \param[out] response HTTP response + */ +void ast_ari_channels_snoop_channel(struct ast_variable *headers, struct ast_ari_channels_snoop_channel_args *args, struct ast_ari_response *response); #endif /* _ASTERISK_RESOURCE_CHANNELS_H */ diff --git a/res/res_ari_channels.c b/res/res_ari_channels.c index d11066bdc..7e7da356f 100644 --- a/res/res_ari_channels.c +++ b/res/res_ari_channels.c @@ -1392,6 +1392,79 @@ static void ast_ari_channels_set_channel_var_cb( fin: __attribute__((unused)) return; } +/*! + * \brief Parameter parsing callback for /channels/{channelId}/snoop. + * \param get_params GET parameters in the HTTP request. + * \param path_vars Path variables extracted from the request. + * \param headers HTTP headers. + * \param[out] response Response to the HTTP request. + */ +static void ast_ari_channels_snoop_channel_cb( + struct ast_variable *get_params, struct ast_variable *path_vars, + struct ast_variable *headers, struct ast_ari_response *response) +{ + struct ast_ari_channels_snoop_channel_args args = {}; + struct ast_variable *i; +#if defined(AST_DEVMODE) + int is_valid; + int code; +#endif /* AST_DEVMODE */ + + for (i = get_params; i; i = i->next) { + if (strcmp(i->name, "spy") == 0) { + args.spy = (i->value); + } else + if (strcmp(i->name, "whisper") == 0) { + args.whisper = (i->value); + } else + if (strcmp(i->name, "app") == 0) { + args.app = (i->value); + } else + if (strcmp(i->name, "appArgs") == 0) { + args.app_args = (i->value); + } else + {} + } + for (i = path_vars; i; i = i->next) { + if (strcmp(i->name, "channelId") == 0) { + args.channel_id = (i->value); + } else + {} + } + ast_ari_channels_snoop_channel(headers, &args, response); +#if defined(AST_DEVMODE) + code = response->response_code; + + switch (code) { + case 0: /* Implementation is still a stub, or the code wasn't set */ + is_valid = response->message == NULL; + break; + case 500: /* Internal Server Error */ + case 501: /* Not Implemented */ + case 400: /* Invalid parameters */ + case 404: /* Channel not found */ + is_valid = 1; + break; + default: + if (200 <= code && code <= 299) { + is_valid = ast_ari_validate_channel( + response->message); + } else { + ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/snoop\n", code); + is_valid = 0; + } + } + + if (!is_valid) { + ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/snoop\n"); + ast_ari_response_error(response, 500, + "Internal Server Error", "Response validation failed"); + } +#endif /* AST_DEVMODE */ + +fin: __attribute__((unused)) + return; +} /*! \brief REST handler for /api-docs/channels.{format} */ static struct stasis_rest_handlers channels_channelId_continue = { @@ -1499,6 +1572,15 @@ static struct stasis_rest_handlers channels_channelId_variable = { .children = { } }; /*! \brief REST handler for /api-docs/channels.{format} */ +static struct stasis_rest_handlers channels_channelId_snoop = { + .path_segment = "snoop", + .callbacks = { + [AST_HTTP_POST] = ast_ari_channels_snoop_channel_cb, + }, + .num_children = 0, + .children = { } +}; +/*! \brief REST handler for /api-docs/channels.{format} */ static struct stasis_rest_handlers channels_channelId = { .path_segment = "channelId", .is_wildcard = 1, @@ -1506,8 +1588,8 @@ static struct stasis_rest_handlers channels_channelId = { [AST_HTTP_GET] = ast_ari_channels_get_cb, [AST_HTTP_DELETE] = ast_ari_channels_hangup_cb, }, - .num_children = 11, - .children = { &channels_channelId_continue,&channels_channelId_answer,&channels_channelId_ring,&channels_channelId_dtmf,&channels_channelId_mute,&channels_channelId_hold,&channels_channelId_moh,&channels_channelId_silence,&channels_channelId_play,&channels_channelId_record,&channels_channelId_variable, } + .num_children = 12, + .children = { &channels_channelId_continue,&channels_channelId_answer,&channels_channelId_ring,&channels_channelId_dtmf,&channels_channelId_mute,&channels_channelId_hold,&channels_channelId_moh,&channels_channelId_silence,&channels_channelId_play,&channels_channelId_record,&channels_channelId_variable,&channels_channelId_snoop, } }; /*! \brief REST handler for /api-docs/channels.{format} */ static struct stasis_rest_handlers channels = { diff --git a/res/res_stasis_snoop.c b/res/res_stasis_snoop.c new file mode 100644 index 000000000..1a40112d1 --- /dev/null +++ b/res/res_stasis_snoop.c @@ -0,0 +1,394 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2013, Digium, Inc. + * + * Joshua Colp <jcolp@digium.com> + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! \file + * + * \brief Stasis application snoop control support. + * + * \author Joshua Colp <jcolp@digium.com> + */ + +/*** MODULEINFO + <depend type="module">res_stasis</depend> + <support_level>core</support_level> + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#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" + +/*! \brief The interval (in milliseconds) that the Snoop timer is triggered, also controls length of audio within frames */ +#define SNOOP_INTERVAL 20 + +/*! \brief Index used to keep Snoop channel names unique */ +static unsigned int chan_idx; + +/*! \brief Structure which contains all of the snoop information */ +struct stasis_app_snoop { + /*! \brief Timer used for waking up Stasis thread */ + struct ast_timer *timer; + /*! \brief Audiohook used to spy on the channel */ + struct ast_audiohook spy; + /*! \brief Direction for spying */ + enum ast_audiohook_direction spy_direction; + /*! \brief Number of samples to be read in when spying */ + unsigned int spy_samples; + /*! \brief Format in use by the spy audiohook */ + struct ast_format spy_format; + /*! \brief Audiohook used to whisper on the channel */ + struct ast_audiohook whisper; + /*! \brief Direction for whispering */ + enum ast_audiohook_direction whisper_direction; + /*! \brief Stasis application and arguments */ + struct ast_str *app; + /*! \brief Snoop channel */ + struct ast_channel *chan; + /*! \brief Whether the spy capability is active or not */ + unsigned int spy_active:1; + /*! \brief Whether the whisper capability is active or not */ + unsigned int whisper_active:1; + /*! \brief Uniqueid of the channel this snoop is snooping on */ + char uniqueid[AST_MAX_UNIQUEID]; +}; + +/*! \brief Destructor for snoop structure */ +static void snoop_destroy(void *obj) +{ + 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); + } + + ast_free(snoop->app); + + ast_channel_cleanup(snoop->chan); +} + +/*! \internal + * \brief Publish the chanspy message over Stasis-Core + * \param snoop The snoop structure + * \start start If non-zero, the spying is starting. Otherwise, the spyer is + * finishing + */ +static void publish_chanspy_message(struct stasis_app_snoop *snoop, int start) +{ + 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); + + blob = ast_json_null(); + if (!blob) { + 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(snoop->uniqueid); + if (spyee_snapshot) { + ast_multi_channel_blob_add_channel(payload, "spyee_channel", spyee_snapshot); + } + + message = stasis_message_create( + start ? ast_channel_chanspy_start_type(): ast_channel_chanspy_stop_type(), + payload); + if (!message) { + return; + } + + stasis_publish(ast_channel_topic(snoop->chan), message); +} + +/*! \brief Callback function for writing to a Snoop whisper audiohook */ +static int snoop_write(struct ast_channel *chan, struct ast_frame *frame) +{ + 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; +} + +/*! \brief Callback function for reading from a Snoop channel */ +static struct ast_frame *snoop_read(struct ast_channel *chan) +{ + 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) { + 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 : &ast_null_frame; +} + +/*! \brief Callback function for hanging up a Snoop channel */ +static int snoop_hangup(struct ast_channel *chan) +{ + 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; +} + +static int snoop_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) +{ + 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; +} + +/*! \brief Channel interface declaration */ +static struct ast_channel_tech snoop_tech = { + .type = "Snoop", + .description = "Snoop Channel Driver", + .write = snoop_write, + .read = snoop_read, + .hangup = snoop_hangup, + .fixup = snoop_fixup, +}; + +/*! \brief Thread used for running the Stasis application */ +static void *snoop_stasis_thread(void *obj) +{ + 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; +} + +/*! \brief Internal helper function which sets up and attaches a snoop 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) +{ + 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); +} + +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) +{ + RAII_VAR(struct stasis_app_snoop *, snoop, NULL, ao2_cleanup); + unsigned int rate; + pthread_t thread; + + 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); + + /* Allocate a Snoop channel and set up various parameters */ + snoop->chan = ast_channel_alloc(1, AST_STATE_UP, "", "", "", "", "", "", 0, "Snoop/%s-%08x", ast_channel_uniqueid(chan), + ast_atomic_fetchadd_int((int *)&chan_idx, +1)); + if (!snoop->chan) { + return NULL; + } + + strcpy(snoop->uniqueid, ast_channel_uniqueid(chan)); + + /* 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)); + + { + SCOPED_CHANNELLOCK(lock, chan); + + /* Determine the "best" signed linear format capable by the channel we are snooping on */ + rate = MAX(ast_format_rate(ast_channel_rawwriteformat(chan)), ast_format_rate(ast_channel_rawreadformat(chan))); + ast_format_set(&snoop->spy_format, ast_format_slin_by_rate(rate), 0); + + /* The format on the Snoop channel will be this signed linear format, and it will never change */ + ast_format_cap_set(ast_channel_nativeformats(snoop->chan), &snoop->spy_format); + ast_format_copy(ast_channel_writeformat(snoop->chan), &snoop->spy_format); + ast_format_copy(ast_channel_rawwriteformat(snoop->chan), &snoop->spy_format); + ast_format_copy(ast_channel_readformat(snoop->chan), &snoop->spy_format); + ast_format_copy(ast_channel_rawreadformat(snoop->chan), &snoop->spy_format); + + 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 = rate / (1000 / SNOOP_INTERVAL); + snoop->spy_active = 1; + } + + /* 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; + } + + publish_chanspy_message(snoop, 1); + + /* The caller of this has a reference as well */ + return ast_channel_ref(snoop->chan); +} + +static int load_module(void) +{ + return AST_MODULE_LOAD_SUCCESS; +} + +static int unload_module(void) +{ + return 0; +} + +AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS, "Stasis application snoop support", + .load = load_module, + .unload = unload_module, + .nonoptreq = "res_stasis"); diff --git a/res/res_stasis_snoop.exports.in b/res/res_stasis_snoop.exports.in new file mode 100644 index 000000000..7ec8ecc35 --- /dev/null +++ b/res/res_stasis_snoop.exports.in @@ -0,0 +1,6 @@ +{ + global: + LINKER_SYMBOL_PREFIXstasis_app_control_snoop; + local: + *; +}; diff --git a/rest-api/api-docs/channels.json b/rest-api/api-docs/channels.json index bb63c9ad6..39586689f 100644 --- a/rest-api/api-docs/channels.json +++ b/rest-api/api-docs/channels.json @@ -954,6 +954,91 @@ ] } ] + }, + { + "path": "/channels/{channelId}/snoop", + "description": "Snoop (spy/whisper) on a channel", + "operations": [ + { + "httpMethod": "POST", + "summary": "Start snooping.", + "notes": "Snoop (spy/whisper) on a specific channel.", + "nickname": "snoopChannel", + "responseClass": "Channel", + "parameters": [ + { + "name": "channelId", + "description": "Channel's id", + "paramType": "path", + "required": true, + "allowMultiple": false, + "dataType": "string" + }, + { + "name": "spy", + "description": "Direction of audio to spy on", + "paramType": "query", + "required": false, + "allowMultiple": false, + "dataType": "string", + "defaultValue": "none", + "allowableValues": { + "valueType": "LIST", + "values": [ + "none", + "both", + "out", + "in" + ] + } + }, + { + "name": "whisper", + "description": "Direction of audio to whisper into", + "paramType": "query", + "required": false, + "allowMultiple": false, + "dataType": "string", + "defaultValue": "none", + "allowableValues": { + "valueType": "LIST", + "values": [ + "none", + "both", + "out", + "in" + ] + } + }, + { + "name": "app", + "description": "Application the snooping channel is placed into", + "paramType": "query", + "required": true, + "allowMultiple": false, + "dataType": "string" + }, + { + "name": "appArgs", + "description": "The application arguments to pass to the Stasis application", + "paramType": "query", + "required": false, + "allowMultiple": false, + "dataType": "string" + } + ], + "errorResponses": [ + { + "code": 400, + "reason": "Invalid parameters" + }, + { + "code": 404, + "reason": "Channel not found" + } + ] + } + ] } ], "models": { |