ari: Add Snoop operation for spying/whispering on channels.
authorJoshua Colp <jcolp@digium.com>
Sat, 23 Nov 2013 12:40:46 +0000 (12:40 +0000)
committerJoshua Colp <jcolp@digium.com>
Sat, 23 Nov 2013 12:40:46 +0000 (12:40 +0000)
The Snoop operation can be invoked on a channel to spy or
whisper on it. It returns a channel that any channel operations
can then be invoked on (such as record to do monitoring).

(closes issue ASTERISK-22780)
Reported by: Matt Jordan

Review: https://reviewboard.asterisk.org/r/3003/
........

Merged revisions 403117 from http://svn.asterisk.org/svn/asterisk/branches/12

git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@403118 65c4cc65-6c06-0410-ace0-fbb531ad65f3

include/asterisk/stasis_app_snoop.h [new file with mode: 0644]
main/audiohook.c
res/ari/resource_channels.c
res/ari/resource_channels.h
res/res_ari_channels.c
res/res_stasis_snoop.c [new file with mode: 0644]
res/res_stasis_snoop.exports.in [new file with mode: 0644]
rest-api/api-docs/channels.json

diff --git a/include/asterisk/stasis_app_snoop.h b/include/asterisk/stasis_app_snoop.h
new file mode 100644 (file)
index 0000000..a9c998f
--- /dev/null
@@ -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 */
index 6e02946..5aba9ec 100644 (file)
@@ -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:
        /* 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) {
        case AST_AUDIOHOOK_TYPE_WHISPER:
                if (reset) {
+                       ast_slinfactory_destroy(&audiohook->read_factory);
                        ast_slinfactory_destroy(&audiohook->write_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:
                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:
        /* 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:
        case AST_AUDIOHOOK_TYPE_WHISPER:
+               ast_slinfactory_destroy(&audiohook->read_factory);
                ast_slinfactory_destroy(&audiohook->write_factory);
                break;
        default:
                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 */
        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) {
                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);
                        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);
                                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);
                                /* 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);
index 75d56d9..824c5e6 100644 (file)
@@ -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.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"
 #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);
 }
 
        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
index a9ac72e..49ab8eb 100644 (file)
@@ -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);
  * \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 */
 
 #endif /* _ASTERISK_RESOURCE_CHANNELS_H */
index d11066b..7e7da35 100644 (file)
@@ -1392,6 +1392,79 @@ static void ast_ari_channels_set_channel_var_cb(
 fin: __attribute__((unused))
        return;
 }
 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 = {
 
 /*! \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} */
        .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,
 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,
        },
                [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 = {
 };
 /*! \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 (file)
index 0000000..1a40112
--- /dev/null
@@ -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 (file)
index 0000000..7ec8ecc
--- /dev/null
@@ -0,0 +1,6 @@
+{
+       global:
+               LINKER_SYMBOL_PREFIXstasis_app_control_snoop;
+       local:
+               *;
+};
index bb63c9a..3958668 100644 (file)
                                        ]
                                }
                        ]
                                        ]
                                }
                        ]
+               },
+               {
+                       "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": {
                }
        ],
        "models": {