2013-07-03 17:58:45 +00:00
|
|
|
/*
|
2013-04-22 14:58:53 +00:00
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2012 - 2013, Digium, Inc.
|
|
|
|
*
|
|
|
|
* David M. Lee, II <dlee@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
|
|
|
|
*
|
2013-07-27 23:11:02 +00:00
|
|
|
* \brief Implementation for ARI stubs.
|
2013-04-22 14:58:53 +00:00
|
|
|
*
|
|
|
|
* \author David M. Lee, II <dlee@digium.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*** MODULEINFO
|
2015-04-29 11:46:44 +00:00
|
|
|
<depend type="module">res_stasis_answer</depend>
|
|
|
|
<depend type="module">res_stasis_playback</depend>
|
|
|
|
<depend type="module">res_stasis_recording</depend>
|
|
|
|
<depend type="module">res_stasis_snoop</depend>
|
2013-04-22 14:58:53 +00:00
|
|
|
<support_level>core</support_level>
|
|
|
|
***/
|
|
|
|
|
|
|
|
#include "asterisk.h"
|
|
|
|
|
2013-05-23 20:11:35 +00:00
|
|
|
#include "asterisk/file.h"
|
2013-06-07 18:39:42 +00:00
|
|
|
#include "asterisk/pbx.h"
|
2013-07-25 04:06:32 +00:00
|
|
|
#include "asterisk/bridge.h"
|
2013-06-07 18:39:42 +00:00
|
|
|
#include "asterisk/callerid.h"
|
2013-04-22 14:58:53 +00:00
|
|
|
#include "asterisk/stasis_app.h"
|
2013-05-23 20:11:35 +00:00
|
|
|
#include "asterisk/stasis_app_playback.h"
|
2013-07-03 17:58:45 +00:00
|
|
|
#include "asterisk/stasis_app_recording.h"
|
2013-11-23 12:40:46 +00:00
|
|
|
#include "asterisk/stasis_app_snoop.h"
|
2013-04-22 14:58:53 +00:00
|
|
|
#include "asterisk/stasis_channels.h"
|
2013-11-01 14:38:21 +00:00
|
|
|
#include "asterisk/causes.h"
|
media formats: re-architect handling of media for performance improvements
In the old times media formats were represented using a bit field. This was
fast but had a few limitations.
1. Asterisk was limited in how many formats it could handle.
2. Formats, being a bit field, could not include any attribute information.
A format was strictly its type, e.g., "this is ulaw".
This was changed in Asterisk 10 (see
https://wiki.asterisk.org/wiki/display/AST/Media+Architecture+Proposal for
notes on that work) which led to the creation of the ast_format structure.
This structure allowed Asterisk to handle attributes and bundle information
with a format.
Additionally, ast_format_cap was created to act as a container for multiple
formats that, together, formed the capability of some entity. Another
mechanism was added to allow logic to be registered which performed format
attribute negotiation. Everywhere throughout the codebase Asterisk was
changed to use this strategy.
Unfortunately, in software, there is no free lunch. These new capabilities
came at a cost.
Performance analysis and profiling showed that we spend an inordinate
amount of time comparing, copying, and generally manipulating formats and
their related structures. Basic prototyping has shown that a reasonably
large performance improvement could be made in this area. This patch is the
result of that project, which overhauled the media format architecture
and its usage in Asterisk to improve performance.
Generally, the new philosophy for handling formats is as follows:
* The ast_format structure is reference counted. This removed a large amount
of the memory allocations and copying that was done in prior versions.
* In order to prevent race conditions while keeping things performant, the
ast_format structure is immutable by convention and lock-free. Violate this
tenet at your peril!
* Because formats are reference counted, codecs are also reference counted.
The Asterisk core generally provides built-in codecs and caches the
ast_format structures created to represent them. Generally, to prevent
inordinate amounts of module reference bumping, codecs and formats can be
added at run-time but cannot be removed.
* All compatibility with the bit field representation of codecs/formats has
been moved to a compatibility API. The primary user of this representation
is chan_iax2, which must continue to maintain its bit-field usage of formats
for interoperability concerns.
* When a format is negotiated with attributes, or when a format cannot be
represented by one of the cached formats, a new format object is created or
cloned from an existing format. That format may have the same codec
underlying it, but is a different format than a version of the format with
different attributes or without attributes.
* While formats are reference counted objects, the reference count maintained
on the format should be manipulated with care. Formats are generally cached
and will persist for the lifetime of Asterisk and do not explicitly need
to have their lifetime modified. An exception to this is when the user of a
format does not know where the format came from *and* the user may outlive
the provider of the format. This occurs, for example, when a format is read
from a channel: the channel may have a format with attributes (hence,
non-cached) and the user of the format may last longer than the channel (if
the reference to the channel is released prior to the format's reference).
For more information on this work, see the API design notes:
https://wiki.asterisk.org/wiki/display/AST/Media+Format+Rewrite
Finally, this work was the culmination of a large number of developer's
efforts. Extra thanks goes to Corey Farrell, who took on a large amount of the
work in the Asterisk core, chan_sip, and was an invaluable resource in peer
reviews throughout this project.
There were a substantial number of patches contributed during this work; the
following issues/patch names simply reflect some of the work (and will cause
the release scripts to give attribution to the individuals who work on them).
Reviews:
https://reviewboard.asterisk.org/r/3814
https://reviewboard.asterisk.org/r/3808
https://reviewboard.asterisk.org/r/3805
https://reviewboard.asterisk.org/r/3803
https://reviewboard.asterisk.org/r/3801
https://reviewboard.asterisk.org/r/3798
https://reviewboard.asterisk.org/r/3800
https://reviewboard.asterisk.org/r/3794
https://reviewboard.asterisk.org/r/3793
https://reviewboard.asterisk.org/r/3792
https://reviewboard.asterisk.org/r/3791
https://reviewboard.asterisk.org/r/3790
https://reviewboard.asterisk.org/r/3789
https://reviewboard.asterisk.org/r/3788
https://reviewboard.asterisk.org/r/3787
https://reviewboard.asterisk.org/r/3786
https://reviewboard.asterisk.org/r/3784
https://reviewboard.asterisk.org/r/3783
https://reviewboard.asterisk.org/r/3778
https://reviewboard.asterisk.org/r/3774
https://reviewboard.asterisk.org/r/3775
https://reviewboard.asterisk.org/r/3772
https://reviewboard.asterisk.org/r/3761
https://reviewboard.asterisk.org/r/3754
https://reviewboard.asterisk.org/r/3753
https://reviewboard.asterisk.org/r/3751
https://reviewboard.asterisk.org/r/3750
https://reviewboard.asterisk.org/r/3748
https://reviewboard.asterisk.org/r/3747
https://reviewboard.asterisk.org/r/3746
https://reviewboard.asterisk.org/r/3742
https://reviewboard.asterisk.org/r/3740
https://reviewboard.asterisk.org/r/3739
https://reviewboard.asterisk.org/r/3738
https://reviewboard.asterisk.org/r/3737
https://reviewboard.asterisk.org/r/3736
https://reviewboard.asterisk.org/r/3734
https://reviewboard.asterisk.org/r/3722
https://reviewboard.asterisk.org/r/3713
https://reviewboard.asterisk.org/r/3703
https://reviewboard.asterisk.org/r/3689
https://reviewboard.asterisk.org/r/3687
https://reviewboard.asterisk.org/r/3674
https://reviewboard.asterisk.org/r/3671
https://reviewboard.asterisk.org/r/3667
https://reviewboard.asterisk.org/r/3665
https://reviewboard.asterisk.org/r/3625
https://reviewboard.asterisk.org/r/3602
https://reviewboard.asterisk.org/r/3519
https://reviewboard.asterisk.org/r/3518
https://reviewboard.asterisk.org/r/3516
https://reviewboard.asterisk.org/r/3515
https://reviewboard.asterisk.org/r/3512
https://reviewboard.asterisk.org/r/3506
https://reviewboard.asterisk.org/r/3413
https://reviewboard.asterisk.org/r/3410
https://reviewboard.asterisk.org/r/3387
https://reviewboard.asterisk.org/r/3388
https://reviewboard.asterisk.org/r/3389
https://reviewboard.asterisk.org/r/3390
https://reviewboard.asterisk.org/r/3321
https://reviewboard.asterisk.org/r/3320
https://reviewboard.asterisk.org/r/3319
https://reviewboard.asterisk.org/r/3318
https://reviewboard.asterisk.org/r/3266
https://reviewboard.asterisk.org/r/3265
https://reviewboard.asterisk.org/r/3234
https://reviewboard.asterisk.org/r/3178
ASTERISK-23114 #close
Reported by: mjordan
media_formats_translation_core.diff uploaded by kharwell (License 6464)
rb3506.diff uploaded by mjordan (License 6283)
media_format_app_file.diff uploaded by kharwell (License 6464)
misc-2.diff uploaded by file (License 5000)
chan_mild-3.diff uploaded by file (License 5000)
chan_obscure.diff uploaded by file (License 5000)
jingle.diff uploaded by file (License 5000)
funcs.diff uploaded by file (License 5000)
formats.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
bridges.diff uploaded by file (License 5000)
mf-codecs-2.diff uploaded by file (License 5000)
mf-app_fax.diff uploaded by file (License 5000)
mf-apps-3.diff uploaded by file (License 5000)
media-formats-3.diff uploaded by file (License 5000)
ASTERISK-23715
rb3713.patch uploaded by coreyfarrell (License 5909)
rb3689.patch uploaded by mjordan (License 6283)
ASTERISK-23957
rb3722.patch uploaded by mjordan (License 6283)
mf-attributes-3.diff uploaded by file (License 5000)
ASTERISK-23958
Tested by: jrose
rb3822.patch uploaded by coreyfarrell (License 5909)
rb3800.patch uploaded by jrose (License 6182)
chan_sip.diff uploaded by mjordan (License 6283)
rb3747.patch uploaded by jrose (License 6182)
ASTERISK-23959 #close
Tested by: sgriepentrog, mjordan, coreyfarrell
sip_cleanup.diff uploaded by opticron (License 6273)
chan_sip_caps.diff uploaded by mjordan (License 6283)
rb3751.patch uploaded by coreyfarrell (License 5909)
chan_sip-3.diff uploaded by file (License 5000)
ASTERISK-23960 #close
Tested by: opticron
direct_media.diff uploaded by opticron (License 6273)
pjsip-direct-media.diff uploaded by file (License 5000)
format_cap_remove.diff uploaded by opticron (License 6273)
media_format_fixes.diff uploaded by opticron (License 6273)
chan_pjsip-2.diff uploaded by file (License 5000)
ASTERISK-23966 #close
Tested by: rmudgett
rb3803.patch uploaded by rmudgetti (License 5621)
chan_dahdi.diff uploaded by file (License 5000)
ASTERISK-24064 #close
Tested by: coreyfarrell, mjordan, opticron, file, rmudgett, sgriepentrog, jrose
rb3814.patch uploaded by rmudgett (License 5621)
moh_cleanup.diff uploaded by opticron (License 6273)
bridge_leak.diff uploaded by opticron (License 6273)
translate.diff uploaded by file (License 5000)
rb3795.patch uploaded by rmudgett (License 5621)
tls_fix.diff uploaded by mjordan (License 6283)
fax-mf-fix-2.diff uploaded by file (License 5000)
rtp_transfer_stuff uploaded by mjordan (License 6283)
rb3787.patch uploaded by rmudgett (License 5621)
media-formats-explicit-translate-format-3.diff uploaded by file (License 5000)
format_cache_case_fix.diff uploaded by opticron (License 6273)
rb3774.patch uploaded by rmudgett (License 5621)
rb3775.patch uploaded by rmudgett (License 5621)
rtp_engine_fix.diff uploaded by opticron (License 6273)
rtp_crash_fix.diff uploaded by opticron (License 6273)
rb3753.patch uploaded by mjordan (License 6283)
rb3750.patch uploaded by mjordan (License 6283)
rb3748.patch uploaded by rmudgett (License 5621)
media_format_fixes.diff uploaded by opticron (License 6273)
rb3740.patch uploaded by mjordan (License 6283)
rb3739.patch uploaded by mjordan (License 6283)
rb3734.patch uploaded by mjordan (License 6283)
rb3689.patch uploaded by mjordan (License 6283)
rb3674.patch uploaded by coreyfarrell (License 5909)
rb3671.patch uploaded by coreyfarrell (License 5909)
rb3667.patch uploaded by coreyfarrell (License 5909)
rb3665.patch uploaded by mjordan (License 6283)
rb3625.patch uploaded by coreyfarrell (License 5909)
rb3602.patch uploaded by coreyfarrell (License 5909)
format_compatibility-2.diff uploaded by file (License 5000)
core.diff uploaded by file (License 5000)
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@419044 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-20 22:06:33 +00:00
|
|
|
#include "asterisk/format_cache.h"
|
ARI/res_stasis: Subscribe to both Local channel halves when originating to app
This patch fixes two bugs:
1. When originating a channel into a Stasis application, we already create a
subscription for the channel that is going into our Stasis app.
Unfortunately, when you create a Local channel and pass it off to a Stasis
app, you really aren't creating just one channel: you're creating two. This
patch snags the second half of the Local channel pair (assuming it is a
Local channel pair, but luckily core_local is kind about such assumptions)
and subscribes to it as well.
2. Subscriptions are a bit sticky right now. If a subscription is made, the
'interest' count gets bumped on the Stasis subscription - but unless
something explicitly unsubscribes the channel, said subscription sticks
around. This is not much of a problem is a user is creating the subscription
- if they made it, they must want it. However, when we are creating
implicit subscriptions, we need to make sure something clears them out.
This patch takes a pessimistic approach: it watches the cache updates
coming from Stasis and, if we notice that the cache just cleared out an
object, we delete our subscription object. This keeps our ao2 container of
Stasis forwards in an application from growing out of hand; it also is a
bit more forgiving for end users who may not realize they were supposed to
unsubscribe from that channel that just hung up.
Review: https://reviewboard.asterisk.org/r/3710/
#ASTERISK-23939 #close
........
Merged revisions 418089 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@418090 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-07 02:15:00 +00:00
|
|
|
#include "asterisk/core_local.h"
|
2014-12-09 15:45:19 +00:00
|
|
|
#include "asterisk/dial.h"
|
2016-05-09 19:48:51 +00:00
|
|
|
#include "asterisk/max_forwards.h"
|
2013-04-22 14:58:53 +00:00
|
|
|
#include "resource_channels.h"
|
|
|
|
|
2013-05-23 20:11:35 +00:00
|
|
|
#include <limits.h>
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
/*!
|
|
|
|
* \brief Ensure channel is in a state that allows operation to be performed.
|
|
|
|
*
|
|
|
|
* Since Asterisk 14, it has been possible for down channels, as well as unanswered
|
|
|
|
* outbound channels to enter Stasis. While some operations are fine to perform on
|
|
|
|
* such channels, operations that
|
|
|
|
*
|
|
|
|
* - Attempt to manipulate channel state
|
|
|
|
* - Attempt to play media
|
|
|
|
* - Attempt to control the channel's location in the dialplan
|
|
|
|
*
|
|
|
|
* are invalid. This function can be used to determine if the channel is in an
|
|
|
|
* appropriate state.
|
|
|
|
*
|
|
|
|
* \note When this function returns an error, the HTTP response is taken care of.
|
|
|
|
*
|
|
|
|
* \param control The app control
|
|
|
|
* \param response Response to fill in if there is an error
|
|
|
|
*
|
|
|
|
* \retval 0 Channel is in a valid state. Continue on!
|
|
|
|
* \retval non-zero Channel is in an invalid state. Bail!
|
|
|
|
*/
|
|
|
|
static int channel_state_invalid(struct stasis_app_control *control,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
struct ast_channel_snapshot *snapshot;
|
|
|
|
|
|
|
|
snapshot = stasis_app_control_get_snapshot(control);
|
|
|
|
if (!snapshot) {
|
|
|
|
ast_ari_response_error(response, 404, "Not Found", "Channel not found");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* These channel states apply only to outbound channels:
|
|
|
|
* - Down: Channel has been created, and nothing else has been done
|
|
|
|
* - Reserved: For a PRI, an underlying B-channel is reserved,
|
|
|
|
* but the channel is not yet dialed
|
|
|
|
* - Ringing: The channel has been dialed.
|
|
|
|
*
|
|
|
|
* This does not affect inbound channels. Inbound channels, when they
|
|
|
|
* enter the dialplan, are in the "Ring" state. If they have already
|
|
|
|
* been answered, then they are in the "Up" state.
|
|
|
|
*/
|
|
|
|
if (snapshot->state == AST_STATE_DOWN
|
|
|
|
|| snapshot->state == AST_STATE_RESERVED
|
|
|
|
|| snapshot->state == AST_STATE_RINGING) {
|
|
|
|
ast_ari_response_error(response, 412, "Precondition Failed",
|
|
|
|
"Channel in invalid state");
|
2017-10-31 18:18:45 +00:00
|
|
|
ao2_ref(snapshot, -1);
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-10-31 18:18:45 +00:00
|
|
|
ao2_ref(snapshot, -1);
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-04-22 14:58:53 +00:00
|
|
|
/*!
|
|
|
|
* \brief Finds the control object for a channel, filling the response with an
|
|
|
|
* error, if appropriate.
|
|
|
|
* \param[out] response Response to fill with an error if control is not found.
|
|
|
|
* \param channel_id ID of the channel to lookup.
|
|
|
|
* \return Channel control object.
|
|
|
|
* \return \c NULL if control object does not exist.
|
|
|
|
*/
|
|
|
|
static struct stasis_app_control *find_control(
|
2013-07-27 23:11:02 +00:00
|
|
|
struct ast_ari_response *response,
|
2013-04-22 14:58:53 +00:00
|
|
|
const char *channel_id)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
ast_assert(response != NULL);
|
|
|
|
|
|
|
|
control = stasis_app_control_find_by_channel_id(channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Distinguish between 404 and 409 errors */
|
|
|
|
RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
|
|
|
|
chan = ast_channel_get_by_name(channel_id);
|
|
|
|
if (chan == NULL) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(response, 404, "Not Found",
|
2013-04-22 14:58:53 +00:00
|
|
|
"Channel not found");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(response, 409, "Conflict",
|
2013-04-22 14:58:53 +00:00
|
|
|
"Channel not in Stasis application");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ao2_ref(control, +1);
|
|
|
|
return control;
|
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_continue_in_dialplan(
|
2013-04-22 14:58:53 +00:00
|
|
|
struct ast_variable *headers,
|
2013-11-07 21:10:31 +00:00
|
|
|
struct ast_ari_channels_continue_in_dialplan_args *args,
|
2013-07-27 23:11:02 +00:00
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
2015-01-07 18:54:06 +00:00
|
|
|
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
|
|
|
|
int ipri;
|
|
|
|
const char *context;
|
|
|
|
const char *exten;
|
2013-04-22 14:58:53 +00:00
|
|
|
|
|
|
|
ast_assert(response != NULL);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-07 18:54:06 +00:00
|
|
|
snapshot = stasis_app_control_get_snapshot(control);
|
|
|
|
if (!snapshot) {
|
2016-06-01 18:48:00 +00:00
|
|
|
ast_ari_response_error(response, 404, "Not Found", "Channel not found");
|
2015-01-07 18:54:06 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_strlen_zero(args->context)) {
|
|
|
|
context = snapshot->context;
|
|
|
|
exten = S_OR(args->extension, snapshot->exten);
|
|
|
|
} else {
|
|
|
|
context = args->context;
|
|
|
|
exten = S_OR(args->extension, "s");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(args->label)) {
|
|
|
|
/* A label was provided in the request, use that */
|
|
|
|
|
|
|
|
if (sscanf(args->label, "%30d", &ipri) != 1) {
|
|
|
|
ipri = ast_findlabel_extension(NULL, context, exten, args->label, NULL);
|
|
|
|
if (ipri == -1) {
|
|
|
|
ast_log(AST_LOG_ERROR, "Requested label: %s can not be found in context: %s\n", args->label, context);
|
|
|
|
ast_ari_response_error(response, 404, "Not Found", "Requested label can not be found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ast_debug(3, "Numeric value provided for label, jumping to that priority\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ipri == 0) {
|
|
|
|
ast_log(AST_LOG_ERROR, "Invalid priority label '%s' specified for extension %s in context: %s\n",
|
|
|
|
args->label, exten, context);
|
|
|
|
ast_ari_response_error(response, 400, "Bad Request", "Requested priority is illegal");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
} else if (args->priority) {
|
|
|
|
/* No label provided, use provided priority */
|
|
|
|
ipri = args->priority;
|
|
|
|
} else if (ast_strlen_zero(args->context) && ast_strlen_zero(args->extension)) {
|
|
|
|
/* Special case. No exten, context, or priority provided, then move on to the next priority */
|
|
|
|
ipri = snapshot->priority + 1;
|
|
|
|
} else {
|
|
|
|
ipri = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (stasis_app_control_continue(control, context, exten, ipri)) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-06-26 19:29:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
|
|
|
|
ARI/PJSIP: Add the ability to redirect (transfer) a channel in a Stasis app
This patch adds a new feature to ARI to redirect a channel to another server,
and fixes a few bugs in PJSIP's handling of the Transfer dialplan
application/ARI redirect capability.
*New Feature*
A new operation has been added to the ARI channels resource, redirect. With
this, a channel in a Stasis application can be redirected to another endpoint
of the same underlying channel technology.
*Bug fixes*
In the process of writing this new feature, two bugs were fixed in the PJSIP
stack:
(1) The existing .transfer channel callback had the limitation that it could
only transfer channels to a SIP URI, i.e., you had to pass
'PJSIP/sip:foo@my_provider.com' to the dialplan application. While this is
still supported, it is somewhat unintuitive - particularly in a world full
of endpoints. As such, we now also support specifying the PJSIP endpoint to
transfer to.
(2) res_pjsip_multihomed was, unfortunately, trying to 'help' a 302 redirect by
updating its Contact header. Alas, that resulted in the forwarding
destination set by the dialplan application/ARI resource/whatever being
rewritten with very incorrect information. Hence, we now don't bother
updating an outgoing response if it is a 302. Since this took a looong time
to find, some additional debug statements have been added to those modules
that update the Contact headers.
Review: https://reviewboard.asterisk.org/r/4316/
ASTERISK-24015 #close
Reported by: Private Name
ASTERISK-24703 #close
Reported by: Matt Jordan
........
Merged revisions 431717 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@431718 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-12 20:34:37 +00:00
|
|
|
void ast_ari_channels_redirect(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_redirect_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct ast_channel_snapshot *, chan_snapshot, NULL, ao2_cleanup);
|
|
|
|
char *tech;
|
|
|
|
char *resource;
|
|
|
|
int tech_len;
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (!control) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
ARI/PJSIP: Add the ability to redirect (transfer) a channel in a Stasis app
This patch adds a new feature to ARI to redirect a channel to another server,
and fixes a few bugs in PJSIP's handling of the Transfer dialplan
application/ARI redirect capability.
*New Feature*
A new operation has been added to the ARI channels resource, redirect. With
this, a channel in a Stasis application can be redirected to another endpoint
of the same underlying channel technology.
*Bug fixes*
In the process of writing this new feature, two bugs were fixed in the PJSIP
stack:
(1) The existing .transfer channel callback had the limitation that it could
only transfer channels to a SIP URI, i.e., you had to pass
'PJSIP/sip:foo@my_provider.com' to the dialplan application. While this is
still supported, it is somewhat unintuitive - particularly in a world full
of endpoints. As such, we now also support specifying the PJSIP endpoint to
transfer to.
(2) res_pjsip_multihomed was, unfortunately, trying to 'help' a 302 redirect by
updating its Contact header. Alas, that resulted in the forwarding
destination set by the dialplan application/ARI resource/whatever being
rewritten with very incorrect information. Hence, we now don't bother
updating an outgoing response if it is a 302. Since this took a looong time
to find, some additional debug statements have been added to those modules
that update the Contact headers.
Review: https://reviewboard.asterisk.org/r/4316/
ASTERISK-24015 #close
Reported by: Private Name
ASTERISK-24703 #close
Reported by: Matt Jordan
........
Merged revisions 431717 from http://svn.asterisk.org/svn/asterisk/branches/13
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@431718 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2015-02-12 20:34:37 +00:00
|
|
|
if (ast_strlen_zero(args->endpoint)) {
|
|
|
|
ast_ari_response_error(response, 400, "Not Found",
|
|
|
|
"Required parameter 'endpoint' not provided.");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
tech = ast_strdupa(args->endpoint);
|
|
|
|
if (!(resource = strchr(tech, '/')) || !(tech_len = resource - tech)) {
|
|
|
|
ast_ari_response_error(response, 422, "Unprocessable Entity",
|
|
|
|
"Endpoint parameter '%s' does not contain tech/resource", args->endpoint);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
*resource++ = '\0';
|
|
|
|
if (ast_strlen_zero(resource)) {
|
|
|
|
ast_ari_response_error(response, 422, "Unprocessable Entity",
|
|
|
|
"No resource provided in endpoint parameter '%s'", args->endpoint);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
chan_snapshot = ast_channel_snapshot_get_latest(args->channel_id);
|
|
|
|
if (!chan_snapshot) {
|
|
|
|
ast_ari_response_error(response, 500, "Internal Server Error",
|
|
|
|
"Unable to find channel snapshot for '%s'", args->channel_id);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strncasecmp(chan_snapshot->type, tech, tech_len)) {
|
|
|
|
ast_ari_response_error(response, 422, "Unprocessable Entity",
|
|
|
|
"Endpoint technology '%s' does not match channel technology '%s'",
|
|
|
|
tech, chan_snapshot->type);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (stasis_app_control_redirect(control, resource)) {
|
|
|
|
ast_ari_response_error(response, 500, "Internal Server Error",
|
|
|
|
"Failed to redirect channel");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_ari_response_no_content(response);
|
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_answer(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_answer_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-04-22 14:58:53 +00:00
|
|
|
if (stasis_app_control_answer(control) != 0) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-04-22 14:58:53 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Failed to answer channel");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_ring(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_ring_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-11-01 14:38:21 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-01 14:38:21 +00:00
|
|
|
stasis_app_control_ring(control);
|
|
|
|
|
2013-11-13 23:11:32 +00:00
|
|
|
ast_ari_response_no_content(response);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ast_ari_channels_ring_stop(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_ring_stop_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-13 23:11:32 +00:00
|
|
|
stasis_app_control_ring_stop(control);
|
|
|
|
|
2013-11-01 14:38:21 +00:00
|
|
|
ast_ari_response_no_content(response);
|
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_mute(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_mute_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-07-18 16:03:12 +00:00
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
unsigned int direction = 0;
|
|
|
|
enum ast_frame_type frametype = AST_FRAME_VOICE;
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-03 19:06:48 +00:00
|
|
|
if (ast_strlen_zero(args->direction)) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Direction is required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-18 16:03:12 +00:00
|
|
|
if (!strcmp(args->direction, "in")) {
|
|
|
|
direction = AST_MUTE_DIRECTION_READ;
|
|
|
|
} else if (!strcmp(args->direction, "out")) {
|
|
|
|
direction = AST_MUTE_DIRECTION_WRITE;
|
|
|
|
} else if (!strcmp(args->direction, "both")) {
|
|
|
|
direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
|
|
|
|
} else {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-18 16:03:12 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Invalid direction specified");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
stasis_app_control_mute(control, direction, frametype);
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
2013-07-18 16:03:12 +00:00
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_unmute(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_unmute_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-07-18 16:03:12 +00:00
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
unsigned int direction = 0;
|
|
|
|
enum ast_frame_type frametype = AST_FRAME_VOICE;
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-03 19:06:48 +00:00
|
|
|
if (ast_strlen_zero(args->direction)) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Direction is required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-18 16:03:12 +00:00
|
|
|
if (!strcmp(args->direction, "in")) {
|
|
|
|
direction = AST_MUTE_DIRECTION_READ;
|
|
|
|
} else if (!strcmp(args->direction, "out")) {
|
|
|
|
direction = AST_MUTE_DIRECTION_WRITE;
|
|
|
|
} else if (!strcmp(args->direction, "both")) {
|
|
|
|
direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
|
|
|
|
} else {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-18 16:03:12 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Invalid direction specified");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
stasis_app_control_unmute(control, direction, frametype);
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
2013-07-18 16:03:12 +00:00
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_send_dtmf(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_send_dtmf_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-11-01 14:38:21 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-01 14:38:21 +00:00
|
|
|
if (ast_strlen_zero(args->dtmf)) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"DTMF is required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
stasis_app_control_dtmf(control, args->dtmf, args->before, args->between, args->duration, args->after);
|
|
|
|
|
|
|
|
ast_ari_response_no_content(response);
|
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_hold(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_hold_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-07-01 18:56:21 +00:00
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-01 18:56:21 +00:00
|
|
|
stasis_app_control_hold(control);
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
2013-07-01 18:56:21 +00:00
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_unhold(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_unhold_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-07-01 18:56:21 +00:00
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-01 18:56:21 +00:00
|
|
|
stasis_app_control_unhold(control);
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
2013-05-23 20:11:35 +00:00
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_start_moh(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_start_moh_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-07-19 19:40:27 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-19 19:40:27 +00:00
|
|
|
stasis_app_control_moh_start(control, args->moh_class);
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-07-19 19:40:27 +00:00
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_stop_moh(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_stop_moh_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-07-19 19:40:27 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-19 19:40:27 +00:00
|
|
|
stasis_app_control_moh_stop(control);
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-07-19 19:40:27 +00:00
|
|
|
}
|
|
|
|
|
2013-11-21 15:56:34 +00:00
|
|
|
void ast_ari_channels_start_silence(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_start_silence_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-21 15:56:34 +00:00
|
|
|
stasis_app_control_silence_start(control);
|
|
|
|
ast_ari_response_no_content(response);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ast_ari_channels_stop_silence(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_stop_silence_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-21 15:56:34 +00:00
|
|
|
stasis_app_control_silence_stop(control);
|
|
|
|
ast_ari_response_no_content(response);
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
static void ari_channels_handle_play(
|
|
|
|
const char *args_channel_id,
|
ARI: Add the ability to play multiple media URIs in a single operation
Many ARI applications will want to play multiple media files in a row to
a resource. The most common use case is when building long-ish IVR prompts
made up of multiple, smaller sound files. Today, that requires building a
small state machine, listening for each PlaybackFinished event, and triggering
the next sound file to play. While not especially challenging, it is tedious
work. Since requiring developers to write tedious code to do normal activities
stinks, this patch adds the ability to play back a list of media files to a
resource.
Each of the 'play' operations on supported resources (channels and bridges)
now accepts a comma delineated list of media URIs to play. A single Playback
resource is created as a handle to the entire list. The operation of playing
a list is identical to playing a single media URI, save that a new event,
PlaybackContinuing, is raised instead of a PlaybackFinished for each non-final
media URI. When the entire list is finished being played, a PlaybackFinished
event is raised.
In order to help inform applications where they are in the list playback, the
Playback resource now includes a new, optional attribute, 'next_media_uri',
that contains the next URI in the list to be played.
It's important to note the following:
- If an offset is provided to the 'play' operations, it only applies to the
first media URI, as it would be weird to skip n seconds forward in every
media resource.
- Operations that control the position of the media only affect the current
media being played. For example, once a media resource in the list
completes, a 'reverse' operation on a subsequent media resource will not
start a previously completed media resource at the appropiate offset.
- This patch does not add any new operations to control the list. Hopefully,
user feedback and/or future patches would add that if people want it.
ASTERISK-26022 #close
Change-Id: Ie1ea5356573447b8f51f2e7964915ea01792f16f
2016-04-18 23:17:08 +00:00
|
|
|
const char **args_media,
|
|
|
|
size_t args_media_count,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
const char *args_lang,
|
|
|
|
int args_offsetms,
|
|
|
|
int args_skipms,
|
|
|
|
const char *args_playback_id,
|
2013-07-27 23:11:02 +00:00
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-05-23 20:11:35 +00:00
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct stasis_app_playback *, playback, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(char *, playback_url, NULL, ast_free);
|
2014-01-12 22:24:27 +00:00
|
|
|
struct ast_json *json;
|
2013-05-23 20:11:35 +00:00
|
|
|
const char *language;
|
|
|
|
|
|
|
|
ast_assert(response != NULL);
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
control = find_control(response, args_channel_id);
|
2013-05-23 20:11:35 +00:00
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-06-01 18:48:00 +00:00
|
|
|
if (channel_state_invalid(control, response)) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-05-23 20:11:35 +00:00
|
|
|
snapshot = stasis_app_control_get_snapshot(control);
|
|
|
|
if (!snapshot) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-05-23 20:11:35 +00:00
|
|
|
response, 404, "Not Found",
|
|
|
|
"Channel not found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (args_skipms < 0) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-06-28 15:36:49 +00:00
|
|
|
response, 400, "Bad Request",
|
2013-05-23 20:21:16 +00:00
|
|
|
"skipms cannot be negative");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (args_offsetms < 0) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-06-28 15:36:49 +00:00
|
|
|
response, 400, "Bad Request",
|
2013-05-23 20:21:16 +00:00
|
|
|
"offsetms cannot be negative");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
language = S_OR(args_lang, snapshot->language);
|
2013-05-23 20:11:35 +00:00
|
|
|
|
ARI: Add the ability to play multiple media URIs in a single operation
Many ARI applications will want to play multiple media files in a row to
a resource. The most common use case is when building long-ish IVR prompts
made up of multiple, smaller sound files. Today, that requires building a
small state machine, listening for each PlaybackFinished event, and triggering
the next sound file to play. While not especially challenging, it is tedious
work. Since requiring developers to write tedious code to do normal activities
stinks, this patch adds the ability to play back a list of media files to a
resource.
Each of the 'play' operations on supported resources (channels and bridges)
now accepts a comma delineated list of media URIs to play. A single Playback
resource is created as a handle to the entire list. The operation of playing
a list is identical to playing a single media URI, save that a new event,
PlaybackContinuing, is raised instead of a PlaybackFinished for each non-final
media URI. When the entire list is finished being played, a PlaybackFinished
event is raised.
In order to help inform applications where they are in the list playback, the
Playback resource now includes a new, optional attribute, 'next_media_uri',
that contains the next URI in the list to be played.
It's important to note the following:
- If an offset is provided to the 'play' operations, it only applies to the
first media URI, as it would be weird to skip n seconds forward in every
media resource.
- Operations that control the position of the media only affect the current
media being played. For example, once a media resource in the list
completes, a 'reverse' operation on a subsequent media resource will not
start a previously completed media resource at the appropiate offset.
- This patch does not add any new operations to control the list. Hopefully,
user feedback and/or future patches would add that if people want it.
ASTERISK-26022 #close
Change-Id: Ie1ea5356573447b8f51f2e7964915ea01792f16f
2016-04-18 23:17:08 +00:00
|
|
|
playback = stasis_app_control_play_uri(control, args_media, args_media_count, language,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
args_channel_id, STASIS_PLAYBACK_TARGET_CHANNEL, args_skipms, args_offsetms, args_playback_id);
|
2013-05-23 20:11:35 +00:00
|
|
|
if (!playback) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-05-23 20:11:35 +00:00
|
|
|
response, 500, "Internal Server Error",
|
2013-05-23 20:21:16 +00:00
|
|
|
"Failed to queue media for playback");
|
2013-05-23 20:11:35 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-14 17:29:09 +00:00
|
|
|
if (ast_asprintf(&playback_url, "/playbacks/%s",
|
2014-04-18 20:09:24 +00:00
|
|
|
stasis_app_playback_get_id(playback)) == -1) {
|
|
|
|
playback_url = NULL;
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-05-23 20:11:35 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Out of memory");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-05-23 21:46:38 +00:00
|
|
|
json = stasis_app_playback_to_json(playback);
|
|
|
|
if (!json) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-05-23 21:46:38 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Out of memory");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_created(response, playback_url, json);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
2013-07-03 17:58:45 +00:00
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
void ast_ari_channels_play(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_play_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
ari_channels_handle_play(
|
|
|
|
args->channel_id,
|
|
|
|
args->media,
|
ARI: Add the ability to play multiple media URIs in a single operation
Many ARI applications will want to play multiple media files in a row to
a resource. The most common use case is when building long-ish IVR prompts
made up of multiple, smaller sound files. Today, that requires building a
small state machine, listening for each PlaybackFinished event, and triggering
the next sound file to play. While not especially challenging, it is tedious
work. Since requiring developers to write tedious code to do normal activities
stinks, this patch adds the ability to play back a list of media files to a
resource.
Each of the 'play' operations on supported resources (channels and bridges)
now accepts a comma delineated list of media URIs to play. A single Playback
resource is created as a handle to the entire list. The operation of playing
a list is identical to playing a single media URI, save that a new event,
PlaybackContinuing, is raised instead of a PlaybackFinished for each non-final
media URI. When the entire list is finished being played, a PlaybackFinished
event is raised.
In order to help inform applications where they are in the list playback, the
Playback resource now includes a new, optional attribute, 'next_media_uri',
that contains the next URI in the list to be played.
It's important to note the following:
- If an offset is provided to the 'play' operations, it only applies to the
first media URI, as it would be weird to skip n seconds forward in every
media resource.
- Operations that control the position of the media only affect the current
media being played. For example, once a media resource in the list
completes, a 'reverse' operation on a subsequent media resource will not
start a previously completed media resource at the appropiate offset.
- This patch does not add any new operations to control the list. Hopefully,
user feedback and/or future patches would add that if people want it.
ASTERISK-26022 #close
Change-Id: Ie1ea5356573447b8f51f2e7964915ea01792f16f
2016-04-18 23:17:08 +00:00
|
|
|
args->media_count,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
args->lang,
|
|
|
|
args->offsetms,
|
|
|
|
args->skipms,
|
|
|
|
args->playback_id,
|
|
|
|
response);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ast_ari_channels_play_with_id(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_play_with_id_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
ari_channels_handle_play(
|
|
|
|
args->channel_id,
|
|
|
|
args->media,
|
ARI: Add the ability to play multiple media URIs in a single operation
Many ARI applications will want to play multiple media files in a row to
a resource. The most common use case is when building long-ish IVR prompts
made up of multiple, smaller sound files. Today, that requires building a
small state machine, listening for each PlaybackFinished event, and triggering
the next sound file to play. While not especially challenging, it is tedious
work. Since requiring developers to write tedious code to do normal activities
stinks, this patch adds the ability to play back a list of media files to a
resource.
Each of the 'play' operations on supported resources (channels and bridges)
now accepts a comma delineated list of media URIs to play. A single Playback
resource is created as a handle to the entire list. The operation of playing
a list is identical to playing a single media URI, save that a new event,
PlaybackContinuing, is raised instead of a PlaybackFinished for each non-final
media URI. When the entire list is finished being played, a PlaybackFinished
event is raised.
In order to help inform applications where they are in the list playback, the
Playback resource now includes a new, optional attribute, 'next_media_uri',
that contains the next URI in the list to be played.
It's important to note the following:
- If an offset is provided to the 'play' operations, it only applies to the
first media URI, as it would be weird to skip n seconds forward in every
media resource.
- Operations that control the position of the media only affect the current
media being played. For example, once a media resource in the list
completes, a 'reverse' operation on a subsequent media resource will not
start a previously completed media resource at the appropiate offset.
- This patch does not add any new operations to control the list. Hopefully,
user feedback and/or future patches would add that if people want it.
ASTERISK-26022 #close
Change-Id: Ie1ea5356573447b8f51f2e7964915ea01792f16f
2016-04-18 23:17:08 +00:00
|
|
|
args->media_count,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
args->lang,
|
|
|
|
args->offsetms,
|
|
|
|
args->skipms,
|
|
|
|
args->playback_id,
|
|
|
|
response);
|
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_record(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_record_args *args,
|
2013-07-27 23:11:02 +00:00
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-07-03 17:58:45 +00:00
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct stasis_app_recording *, recording, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(char *, recording_url, NULL, ast_free);
|
2014-01-12 22:24:27 +00:00
|
|
|
struct ast_json *json;
|
2013-07-03 17:58:45 +00:00
|
|
|
RAII_VAR(struct stasis_app_recording_options *, options, NULL,
|
|
|
|
ao2_cleanup);
|
|
|
|
RAII_VAR(char *, uri_encoded_name, NULL, ast_free);
|
|
|
|
size_t uri_name_maxlen;
|
|
|
|
|
|
|
|
ast_assert(response != NULL);
|
|
|
|
|
|
|
|
if (args->max_duration_seconds < 0) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"max_duration_seconds cannot be negative");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (args->max_silence_seconds < 0) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"max_silence_seconds cannot be negative");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
options = stasis_app_recording_options_create(args->name, args->format);
|
|
|
|
if (options == NULL) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Out of memory");
|
|
|
|
}
|
2014-03-06 18:20:37 +00:00
|
|
|
ast_string_field_build(options, target, "channel:%s", args->channel_id);
|
2013-07-03 17:58:45 +00:00
|
|
|
options->max_silence_seconds = args->max_silence_seconds;
|
|
|
|
options->max_duration_seconds = args->max_duration_seconds;
|
|
|
|
options->terminate_on =
|
|
|
|
stasis_app_recording_termination_parse(args->terminate_on);
|
|
|
|
options->if_exists =
|
|
|
|
stasis_app_recording_if_exists_parse(args->if_exists);
|
|
|
|
options->beep = args->beep;
|
|
|
|
|
|
|
|
if (options->terminate_on == STASIS_APP_RECORDING_TERMINATE_INVALID) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"terminateOn invalid");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-04-09 12:57:21 +00:00
|
|
|
if (options->if_exists == AST_RECORD_IF_EXISTS_ERROR) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"ifExists invalid");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-10-25 22:01:43 +00:00
|
|
|
if (!ast_get_format_for_file_ext(options->format)) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 422, "Unprocessable Entity",
|
|
|
|
"specified format is unknown on this system");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-03 17:58:45 +00:00
|
|
|
recording = stasis_app_control_record(control, options);
|
|
|
|
if (recording == NULL) {
|
|
|
|
switch(errno) {
|
|
|
|
case EINVAL:
|
|
|
|
/* While the arguments are invalid, we should have
|
|
|
|
* caught them prior to calling record.
|
|
|
|
*/
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Error parsing request");
|
|
|
|
break;
|
|
|
|
case EEXIST:
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(response, 409, "Conflict",
|
2013-10-25 21:28:32 +00:00
|
|
|
"Recording '%s' already exists and can not be overwritten",
|
2013-07-03 17:58:45 +00:00
|
|
|
args->name);
|
|
|
|
break;
|
|
|
|
case ENOMEM:
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Out of memory");
|
|
|
|
break;
|
|
|
|
case EPERM:
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Recording name invalid");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ast_log(LOG_WARNING,
|
|
|
|
"Unrecognized recording error: %s\n",
|
|
|
|
strerror(errno));
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Internal Server Error");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
uri_name_maxlen = strlen(args->name) * 3;
|
|
|
|
uri_encoded_name = ast_malloc(uri_name_maxlen);
|
|
|
|
if (!uri_encoded_name) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Out of memory");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ast_uri_encode(args->name, uri_encoded_name, uri_name_maxlen,
|
|
|
|
ast_uri_http);
|
|
|
|
|
2014-04-18 20:09:24 +00:00
|
|
|
if (ast_asprintf(&recording_url, "/recordings/live/%s",
|
|
|
|
uri_encoded_name) == -1) {
|
|
|
|
recording_url = NULL;
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Out of memory");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
json = stasis_app_recording_to_json(recording);
|
|
|
|
if (!json) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-03 17:58:45 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Out of memory");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_created(response, recording_url, json);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
2013-07-03 17:58:45 +00:00
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_get(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_get_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
|
2013-08-01 13:49:34 +00:00
|
|
|
struct stasis_cache *cache;
|
2013-04-22 14:58:53 +00:00
|
|
|
struct ast_channel_snapshot *snapshot;
|
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
cache = ast_channel_cache();
|
|
|
|
if (!cache) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-04-22 14:58:53 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Message bus not initialized");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
msg = stasis_cache_get(cache, ast_channel_snapshot_type(),
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
args->channel_id);
|
2013-04-22 14:58:53 +00:00
|
|
|
if (!msg) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-04-22 14:58:53 +00:00
|
|
|
response, 404, "Not Found",
|
|
|
|
"Channel not found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
snapshot = stasis_message_data(msg);
|
|
|
|
ast_assert(snapshot != NULL);
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_ok(response,
|
2013-11-22 20:10:46 +00:00
|
|
|
ast_channel_snapshot_to_json(snapshot, NULL));
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_hangup(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_hangup_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
|
2013-11-01 14:38:21 +00:00
|
|
|
int cause;
|
2013-04-22 14:58:53 +00:00
|
|
|
|
|
|
|
chan = ast_channel_get_by_name(args->channel_id);
|
|
|
|
if (chan == NULL) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-04-22 14:58:53 +00:00
|
|
|
response, 404, "Not Found",
|
|
|
|
"Channel not found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-01 14:38:21 +00:00
|
|
|
if (ast_strlen_zero(args->reason) || !strcmp(args->reason, "normal")) {
|
|
|
|
cause = AST_CAUSE_NORMAL;
|
|
|
|
} else if (!strcmp(args->reason, "busy")) {
|
|
|
|
cause = AST_CAUSE_BUSY;
|
|
|
|
} else if (!strcmp(args->reason, "congestion")) {
|
|
|
|
cause = AST_CAUSE_CONGESTION;
|
2015-02-09 03:12:16 +00:00
|
|
|
} else if (!strcmp(args->reason, "no_answer")) {
|
|
|
|
cause = AST_CAUSE_NOANSWER;
|
2016-08-31 10:33:28 +00:00
|
|
|
} else if(!strcmp(args->reason, "answered_elsewhere")) {
|
|
|
|
cause = AST_CAUSE_ANSWERED_ELSEWHERE;
|
2013-11-01 14:38:21 +00:00
|
|
|
} else {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Invalid Reason",
|
|
|
|
"Invalid reason for hangup provided");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_hangupcause_set(chan, cause);
|
2013-04-22 14:58:53 +00:00
|
|
|
ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_list(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_list_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-08-01 13:49:34 +00:00
|
|
|
RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
|
2013-04-22 14:58:53 +00:00
|
|
|
RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
|
|
struct ao2_iterator i;
|
|
|
|
void *obj;
|
2013-11-22 20:10:46 +00:00
|
|
|
struct stasis_message_sanitizer *sanitize = stasis_app_get_sanitizer();
|
2013-04-22 14:58:53 +00:00
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
cache = ast_channel_cache();
|
|
|
|
if (!cache) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-04-22 14:58:53 +00:00
|
|
|
response, 500, "Internal Server Error",
|
|
|
|
"Message bus not initialized");
|
|
|
|
return;
|
|
|
|
}
|
2013-08-01 13:49:34 +00:00
|
|
|
ao2_ref(cache, +1);
|
2013-04-22 14:58:53 +00:00
|
|
|
|
2013-08-01 13:49:34 +00:00
|
|
|
snapshots = stasis_cache_dump(cache, ast_channel_snapshot_type());
|
2013-04-22 14:58:53 +00:00
|
|
|
if (!snapshots) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
json = ast_json_array_create();
|
|
|
|
if (!json) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-04-22 14:58:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-12-20 20:00:50 +00:00
|
|
|
i = ao2_iterator_init(snapshots, 0);
|
|
|
|
while ((obj = ao2_iterator_next(&i))) {
|
2013-04-22 14:58:53 +00:00
|
|
|
RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
|
|
|
|
struct ast_channel_snapshot *snapshot = stasis_message_data(msg);
|
2013-11-22 20:10:46 +00:00
|
|
|
int r;
|
|
|
|
|
|
|
|
if (sanitize && sanitize->channel_snapshot
|
|
|
|
&& sanitize->channel_snapshot(snapshot)) {
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
r = ast_json_array_append(
|
|
|
|
json, ast_channel_snapshot_to_json(snapshot, NULL));
|
2013-04-22 14:58:53 +00:00
|
|
|
if (r != 0) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-11-22 20:10:46 +00:00
|
|
|
ao2_iterator_destroy(&i);
|
2013-04-22 14:58:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ao2_iterator_destroy(&i);
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_ok(response, ast_json_ref(json));
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
|
|
|
|
2014-12-09 15:45:19 +00:00
|
|
|
/*! \brief Structure used for origination */
|
|
|
|
struct ari_origination {
|
|
|
|
/*! \brief Dialplan context */
|
|
|
|
char context[AST_MAX_CONTEXT];
|
|
|
|
/*! \brief Dialplan extension */
|
|
|
|
char exten[AST_MAX_EXTENSION];
|
|
|
|
/*! \brief Dialplan priority */
|
|
|
|
int priority;
|
|
|
|
/*! \brief Application data to pass to Stasis application */
|
|
|
|
char appdata[0];
|
|
|
|
};
|
|
|
|
|
|
|
|
/*! \brief Thread which dials and executes upon answer */
|
|
|
|
static void *ari_originate_dial(void *data)
|
|
|
|
{
|
|
|
|
struct ast_dial *dial = data;
|
|
|
|
struct ari_origination *origination = ast_dial_get_user_data(dial);
|
|
|
|
enum ast_dial_result res;
|
|
|
|
|
|
|
|
res = ast_dial_run(dial, NULL, 0);
|
|
|
|
if (res != AST_DIAL_RESULT_ANSWERED) {
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(origination->appdata)) {
|
|
|
|
struct ast_app *app = pbx_findapp("Stasis");
|
|
|
|
|
|
|
|
if (app) {
|
|
|
|
ast_verb(4, "Launching Stasis(%s) on %s\n", origination->appdata,
|
|
|
|
ast_channel_name(ast_dial_answered(dial)));
|
|
|
|
pbx_exec(ast_dial_answered(dial), app, origination->appdata);
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_WARNING, "No such application 'Stasis'\n");
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct ast_channel *answered = ast_dial_answered(dial);
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(origination->context)) {
|
|
|
|
ast_channel_context_set(answered, origination->context);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(origination->exten)) {
|
|
|
|
ast_channel_exten_set(answered, origination->exten);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (origination->priority > 0) {
|
|
|
|
ast_channel_priority_set(answered, origination->priority);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_pbx_run(answered)) {
|
|
|
|
ast_log(LOG_ERROR, "Failed to start PBX on %s\n", ast_channel_name(answered));
|
|
|
|
} else {
|
|
|
|
/* PBX will have taken care of hanging up, so we steal the answered channel so dial doesn't do it */
|
|
|
|
ast_dial_answered_steal(dial);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
end:
|
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
static void ari_channels_handle_originate_with_id(const char *args_endpoint,
|
|
|
|
const char *args_extension,
|
|
|
|
const char *args_context,
|
|
|
|
long args_priority,
|
2015-01-07 18:54:06 +00:00
|
|
|
const char *args_label,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
const char *args_app,
|
|
|
|
const char *args_app_args,
|
|
|
|
const char *args_caller_id,
|
|
|
|
int args_timeout,
|
|
|
|
struct ast_variable *variables,
|
|
|
|
const char *args_channel_id,
|
|
|
|
const char *args_other_channel_id,
|
2014-12-09 15:45:19 +00:00
|
|
|
const char *args_originator,
|
2016-05-27 19:49:42 +00:00
|
|
|
const char *args_formats,
|
2013-11-07 21:10:31 +00:00
|
|
|
struct ast_ari_response *response)
|
2013-04-22 14:58:53 +00:00
|
|
|
{
|
2013-06-28 16:23:24 +00:00
|
|
|
char *dialtech;
|
2013-06-07 18:39:42 +00:00
|
|
|
char dialdevice[AST_CHANNEL_NAME];
|
2014-12-09 15:45:19 +00:00
|
|
|
struct ast_dial *dial;
|
2013-06-07 18:39:42 +00:00
|
|
|
char *caller_id = NULL;
|
|
|
|
char *cid_num = NULL;
|
|
|
|
char *cid_name = NULL;
|
2013-06-28 16:23:24 +00:00
|
|
|
char *stuff;
|
2014-12-09 15:45:19 +00:00
|
|
|
struct ast_channel *other = NULL;
|
2015-01-07 18:54:06 +00:00
|
|
|
struct ast_channel *chan = NULL;
|
2013-10-19 14:45:14 +00:00
|
|
|
RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
|
2014-03-20 16:35:57 +00:00
|
|
|
struct ast_assigned_ids assignedids = {
|
|
|
|
.uniqueid = args_channel_id,
|
|
|
|
.uniqueid2 = args_other_channel_id,
|
|
|
|
};
|
2014-12-09 15:45:19 +00:00
|
|
|
struct ari_origination *origination;
|
|
|
|
pthread_t thread;
|
2016-05-27 19:49:42 +00:00
|
|
|
struct ast_format_cap *format_cap = NULL;
|
2013-06-07 18:39:42 +00:00
|
|
|
|
2014-03-20 16:35:57 +00:00
|
|
|
if ((assignedids.uniqueid && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid))
|
|
|
|
|| (assignedids.uniqueid2 && AST_MAX_PUBLIC_UNIQUEID < strlen(assignedids.uniqueid2))) {
|
|
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
2014-07-03 19:06:12 +00:00
|
|
|
"Uniqueid length exceeds maximum of %d", AST_MAX_PUBLIC_UNIQUEID);
|
2014-03-20 16:35:57 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (ast_strlen_zero(args_endpoint)) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
2013-06-28 16:23:24 +00:00
|
|
|
"Endpoint must be specified");
|
2013-06-07 18:39:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-27 19:49:42 +00:00
|
|
|
if (!ast_strlen_zero(args_originator) && !ast_strlen_zero(args_formats)) {
|
|
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
|
|
|
"Originator and formats can't both be specified");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
dialtech = ast_strdupa(args_endpoint);
|
2013-06-28 16:23:24 +00:00
|
|
|
if ((stuff = strchr(dialtech, '/'))) {
|
|
|
|
*stuff++ = '\0';
|
|
|
|
ast_copy_string(dialdevice, stuff, sizeof(dialdevice));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_strlen_zero(dialtech) || ast_strlen_zero(dialdevice)) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
2013-06-28 16:23:24 +00:00
|
|
|
"Invalid endpoint specified");
|
|
|
|
return;
|
2013-06-07 18:39:42 +00:00
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (!ast_strlen_zero(args_app)) {
|
2013-06-28 16:23:24 +00:00
|
|
|
RAII_VAR(struct ast_str *, appdata, ast_str_create(64), ast_free);
|
|
|
|
|
|
|
|
if (!appdata) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-06-28 16:23:24 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
ast_str_set(&appdata, 0, "%s", args_app);
|
|
|
|
if (!ast_strlen_zero(args_app_args)) {
|
|
|
|
ast_str_append(&appdata, 0, ",%s", args_app_args);
|
2013-06-28 16:23:24 +00:00
|
|
|
}
|
|
|
|
|
2014-12-09 15:45:19 +00:00
|
|
|
origination = ast_calloc(1, sizeof(*origination) + ast_str_size(appdata) + 1);
|
|
|
|
if (!origination) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-06-28 16:23:24 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-12-09 15:45:19 +00:00
|
|
|
|
|
|
|
strcpy(origination->appdata, ast_str_buffer(appdata));
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (!ast_strlen_zero(args_extension)) {
|
2014-12-09 15:45:19 +00:00
|
|
|
origination = ast_calloc(1, sizeof(*origination) + 1);
|
|
|
|
if (!origination) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-06-28 16:23:24 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-12-09 15:45:19 +00:00
|
|
|
|
|
|
|
ast_copy_string(origination->context, S_OR(args_context, "default"), sizeof(origination->context));
|
|
|
|
ast_copy_string(origination->exten, args_extension, sizeof(origination->exten));
|
2015-01-07 18:54:06 +00:00
|
|
|
|
|
|
|
if (!ast_strlen_zero(args_label)) {
|
|
|
|
/* A label was provided in the request, use that */
|
|
|
|
int ipri = 1;
|
|
|
|
if (sscanf(args_label, "%30d", &ipri) != 1) {
|
|
|
|
ipri = ast_findlabel_extension(chan, origination->context, origination->exten, args_label, args_caller_id);
|
|
|
|
|
|
|
|
if (ipri == -1) {
|
|
|
|
ast_log(AST_LOG_ERROR, "Requested label: %s can not be found in context: %s\n", args_label, args_context);
|
|
|
|
ast_ari_response_error(response, 404, "Not Found", "Requested label can not be found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ast_debug(3, "Numeric value provided for label, jumping to that priority\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ipri == 0) {
|
|
|
|
ast_log(AST_LOG_ERROR, "Invalid priority label '%s' specified for extension %s in context: %s\n",
|
|
|
|
args_label, args_extension, args_context);
|
|
|
|
ast_ari_response_error(response, 400, "Bad Request", "Requested priority is illegal");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Our priority was provided by a label */
|
|
|
|
origination->priority = ipri;
|
|
|
|
} else {
|
|
|
|
/* No label provided, use provided priority */
|
|
|
|
origination->priority = args_priority ? args_priority : 1;
|
|
|
|
}
|
|
|
|
|
2014-12-09 15:45:19 +00:00
|
|
|
origination->appdata[0] = '\0';
|
2013-06-28 16:23:24 +00:00
|
|
|
} else {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
2013-06-28 16:23:24 +00:00
|
|
|
"Application or extension must be specified");
|
2013-06-07 18:39:42 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-12-09 15:45:19 +00:00
|
|
|
dial = ast_dial_create();
|
|
|
|
if (!dial) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
ast_free(origination);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ast_dial_set_user_data(dial, origination);
|
|
|
|
|
|
|
|
if (ast_dial_append(dial, dialtech, dialdevice, &assignedids)) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (args_timeout > 0) {
|
|
|
|
ast_dial_set_global_timeout(dial, args_timeout * 1000);
|
|
|
|
} else if (args_timeout == -1) {
|
|
|
|
ast_dial_set_global_timeout(dial, -1);
|
|
|
|
} else {
|
|
|
|
ast_dial_set_global_timeout(dial, 30000);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(args_caller_id)) {
|
|
|
|
caller_id = ast_strdupa(args_caller_id);
|
|
|
|
ast_callerid_parse(caller_id, &cid_name, &cid_num);
|
|
|
|
|
|
|
|
if (ast_is_shrinkable_phonenumber(cid_num)) {
|
|
|
|
ast_shrink_phone_number(cid_num);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(args_originator)) {
|
|
|
|
other = ast_channel_get_by_name(args_originator);
|
|
|
|
if (!other) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Provided originator channel was not found");
|
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-27 19:49:42 +00:00
|
|
|
if (!ast_strlen_zero(args_formats)) {
|
|
|
|
char *format_name;
|
|
|
|
char *formats_copy = ast_strdupa(args_formats);
|
|
|
|
|
|
|
|
if (!(format_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
ast_channel_cleanup(other);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((format_name = ast_strip(strsep(&formats_copy, ",")))) {
|
|
|
|
struct ast_format *fmt = ast_format_cache_get(format_name);
|
|
|
|
|
|
|
|
if (!fmt || ast_format_cap_append(format_cap, fmt, 0)) {
|
|
|
|
if (!fmt) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Provided format (%s) was not found", format_name);
|
|
|
|
} else {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
}
|
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
ast_channel_cleanup(other);
|
|
|
|
ao2_ref(format_cap, -1);
|
|
|
|
ao2_cleanup(fmt);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ao2_ref(fmt, -1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_dial_prerun(dial, other, format_cap)) {
|
2016-10-17 19:18:57 +00:00
|
|
|
if (ast_channel_errno() == AST_CHANNEL_ERROR_ID_EXISTS) {
|
|
|
|
ast_ari_response_error(response, 409, "Conflict",
|
|
|
|
"Channel with given unique ID already exists");
|
|
|
|
} else {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
}
|
2014-12-09 15:45:19 +00:00
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
ast_channel_cleanup(other);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_cleanup(other);
|
2016-05-27 19:49:42 +00:00
|
|
|
ao2_cleanup(format_cap);
|
2014-12-09 15:45:19 +00:00
|
|
|
|
|
|
|
chan = ast_dial_get_channel(dial, 0);
|
|
|
|
if (!chan) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(cid_num) || !ast_strlen_zero(cid_name)) {
|
|
|
|
struct ast_party_connected_line connected;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* It seems strange to set the CallerID on an outgoing call leg
|
|
|
|
* to whom we are calling, but this function's callers are doing
|
|
|
|
* various Originate methods. This call leg goes to the local
|
|
|
|
* user. Once the called party answers, the dialplan needs to
|
|
|
|
* be able to access the CallerID from the CALLERID function as
|
|
|
|
* if the called party had placed this call.
|
|
|
|
*/
|
|
|
|
ast_set_callerid(chan, cid_num, cid_name, cid_num);
|
|
|
|
|
|
|
|
ast_party_connected_line_set_init(&connected, ast_channel_connected(chan));
|
|
|
|
if (!ast_strlen_zero(cid_num)) {
|
|
|
|
connected.id.number.valid = 1;
|
|
|
|
connected.id.number.str = (char *) cid_num;
|
|
|
|
connected.id.number.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
|
|
|
|
}
|
|
|
|
if (!ast_strlen_zero(cid_name)) {
|
|
|
|
connected.id.name.valid = 1;
|
|
|
|
connected.id.name.str = (char *) cid_name;
|
|
|
|
connected.id.name.presentation = AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED;
|
|
|
|
}
|
|
|
|
ast_channel_set_connected_line(chan, &connected, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
if (variables) {
|
|
|
|
ast_set_variables(chan, variables);
|
|
|
|
}
|
|
|
|
ast_set_flag(ast_channel_flags(chan), AST_FLAG_ORIGINATED);
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (!ast_strlen_zero(args_app)) {
|
2014-08-14 16:33:27 +00:00
|
|
|
struct ast_channel *local_peer;
|
|
|
|
|
ARI/res_stasis: Subscribe to both Local channel halves when originating to app
This patch fixes two bugs:
1. When originating a channel into a Stasis application, we already create a
subscription for the channel that is going into our Stasis app.
Unfortunately, when you create a Local channel and pass it off to a Stasis
app, you really aren't creating just one channel: you're creating two. This
patch snags the second half of the Local channel pair (assuming it is a
Local channel pair, but luckily core_local is kind about such assumptions)
and subscribes to it as well.
2. Subscriptions are a bit sticky right now. If a subscription is made, the
'interest' count gets bumped on the Stasis subscription - but unless
something explicitly unsubscribes the channel, said subscription sticks
around. This is not much of a problem is a user is creating the subscription
- if they made it, they must want it. However, when we are creating
implicit subscriptions, we need to make sure something clears them out.
This patch takes a pessimistic approach: it watches the cache updates
coming from Stasis and, if we notice that the cache just cleared out an
object, we delete our subscription object. This keeps our ao2 container of
Stasis forwards in an application from growing out of hand; it also is a
bit more forgiving for end users who may not realize they were supposed to
unsubscribe from that channel that just hung up.
Review: https://reviewboard.asterisk.org/r/3710/
#ASTERISK-23939 #close
........
Merged revisions 418089 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@418090 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-07 02:15:00 +00:00
|
|
|
stasis_app_subscribe_channel(args_app, chan);
|
2014-08-14 16:33:27 +00:00
|
|
|
|
|
|
|
/* Subscribe to the Local channel peer also. */
|
|
|
|
local_peer = ast_local_get_peer(chan);
|
ARI/res_stasis: Subscribe to both Local channel halves when originating to app
This patch fixes two bugs:
1. When originating a channel into a Stasis application, we already create a
subscription for the channel that is going into our Stasis app.
Unfortunately, when you create a Local channel and pass it off to a Stasis
app, you really aren't creating just one channel: you're creating two. This
patch snags the second half of the Local channel pair (assuming it is a
Local channel pair, but luckily core_local is kind about such assumptions)
and subscribes to it as well.
2. Subscriptions are a bit sticky right now. If a subscription is made, the
'interest' count gets bumped on the Stasis subscription - but unless
something explicitly unsubscribes the channel, said subscription sticks
around. This is not much of a problem is a user is creating the subscription
- if they made it, they must want it. However, when we are creating
implicit subscriptions, we need to make sure something clears them out.
This patch takes a pessimistic approach: it watches the cache updates
coming from Stasis and, if we notice that the cache just cleared out an
object, we delete our subscription object. This keeps our ao2 container of
Stasis forwards in an application from growing out of hand; it also is a
bit more forgiving for end users who may not realize they were supposed to
unsubscribe from that channel that just hung up.
Review: https://reviewboard.asterisk.org/r/3710/
#ASTERISK-23939 #close
........
Merged revisions 418089 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@418090 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-07 02:15:00 +00:00
|
|
|
if (local_peer) {
|
|
|
|
stasis_app_subscribe_channel(args_app, local_peer);
|
2014-08-14 16:33:27 +00:00
|
|
|
ast_channel_unref(local_peer);
|
ARI/res_stasis: Subscribe to both Local channel halves when originating to app
This patch fixes two bugs:
1. When originating a channel into a Stasis application, we already create a
subscription for the channel that is going into our Stasis app.
Unfortunately, when you create a Local channel and pass it off to a Stasis
app, you really aren't creating just one channel: you're creating two. This
patch snags the second half of the Local channel pair (assuming it is a
Local channel pair, but luckily core_local is kind about such assumptions)
and subscribes to it as well.
2. Subscriptions are a bit sticky right now. If a subscription is made, the
'interest' count gets bumped on the Stasis subscription - but unless
something explicitly unsubscribes the channel, said subscription sticks
around. This is not much of a problem is a user is creating the subscription
- if they made it, they must want it. However, when we are creating
implicit subscriptions, we need to make sure something clears them out.
This patch takes a pessimistic approach: it watches the cache updates
coming from Stasis and, if we notice that the cache just cleared out an
object, we delete our subscription object. This keeps our ao2 container of
Stasis forwards in an application from growing out of hand; it also is a
bit more forgiving for end users who may not realize they were supposed to
unsubscribe from that channel that just hung up.
Review: https://reviewboard.asterisk.org/r/3710/
#ASTERISK-23939 #close
........
Merged revisions 418089 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@418090 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-07 02:15:00 +00:00
|
|
|
}
|
2013-10-19 14:45:14 +00:00
|
|
|
}
|
|
|
|
|
ARI/res_stasis: Subscribe to both Local channel halves when originating to app
This patch fixes two bugs:
1. When originating a channel into a Stasis application, we already create a
subscription for the channel that is going into our Stasis app.
Unfortunately, when you create a Local channel and pass it off to a Stasis
app, you really aren't creating just one channel: you're creating two. This
patch snags the second half of the Local channel pair (assuming it is a
Local channel pair, but luckily core_local is kind about such assumptions)
and subscribes to it as well.
2. Subscriptions are a bit sticky right now. If a subscription is made, the
'interest' count gets bumped on the Stasis subscription - but unless
something explicitly unsubscribes the channel, said subscription sticks
around. This is not much of a problem is a user is creating the subscription
- if they made it, they must want it. However, when we are creating
implicit subscriptions, we need to make sure something clears them out.
This patch takes a pessimistic approach: it watches the cache updates
coming from Stasis and, if we notice that the cache just cleared out an
object, we delete our subscription object. This keeps our ao2 container of
Stasis forwards in an application from growing out of hand; it also is a
bit more forgiving for end users who may not realize they were supposed to
unsubscribe from that channel that just hung up.
Review: https://reviewboard.asterisk.org/r/3710/
#ASTERISK-23939 #close
........
Merged revisions 418089 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@418090 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-07-07 02:15:00 +00:00
|
|
|
snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan));
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
|
2014-12-09 15:45:19 +00:00
|
|
|
/* Before starting the async dial bump the ref in case the dial quickly goes away and takes
|
|
|
|
* the reference with it
|
|
|
|
*/
|
|
|
|
ast_channel_ref(chan);
|
|
|
|
|
|
|
|
if (ast_pthread_create_detached(&thread, NULL, ari_originate_dial, dial)) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
ast_dial_destroy(dial);
|
|
|
|
ast_free(origination);
|
|
|
|
} else {
|
|
|
|
ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot, NULL));
|
|
|
|
}
|
|
|
|
|
2013-10-19 14:45:14 +00:00
|
|
|
ast_channel_unref(chan);
|
2014-12-09 15:45:19 +00:00
|
|
|
return;
|
2013-04-22 14:58:53 +00:00
|
|
|
}
|
2013-07-08 14:46:20 +00:00
|
|
|
|
2015-02-27 18:31:31 +00:00
|
|
|
/*!
|
|
|
|
* \internal
|
|
|
|
* \brief Convert a \c ast_json list of key/value pair tuples into a \c ast_variable list
|
|
|
|
* \since 13.3.0
|
|
|
|
*
|
|
|
|
* \param[out] response HTTP response if error
|
|
|
|
* \param json_variables The JSON blob containing the variable
|
|
|
|
* \param[out] variables An out reference to the variables to populate.
|
|
|
|
*
|
|
|
|
* \retval 0 on success.
|
|
|
|
* \retval -1 on error.
|
|
|
|
*/
|
|
|
|
static int json_to_ast_variables(struct ast_ari_response *response, struct ast_json *json_variables, struct ast_variable **variables)
|
|
|
|
{
|
|
|
|
enum ast_json_to_ast_vars_code res;
|
|
|
|
|
|
|
|
res = ast_json_to_ast_variables(json_variables, variables);
|
|
|
|
switch (res) {
|
|
|
|
case AST_JSON_TO_AST_VARS_CODE_SUCCESS:
|
|
|
|
return 0;
|
|
|
|
case AST_JSON_TO_AST_VARS_CODE_INVALID_TYPE:
|
|
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
|
|
|
"Only string values in the 'variables' object allowed");
|
|
|
|
break;
|
|
|
|
case AST_JSON_TO_AST_VARS_CODE_OOM:
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ast_log(AST_LOG_ERROR, "Unable to convert 'variables' in JSON body to channel variables\n");
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
void ast_ari_channels_originate_with_id(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_originate_with_id_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
2015-02-27 18:31:31 +00:00
|
|
|
struct ast_variable *variables = NULL;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
|
|
|
|
/* Parse any query parameters out of the body parameter */
|
|
|
|
if (args->variables) {
|
|
|
|
struct ast_json *json_variables;
|
|
|
|
|
|
|
|
ast_ari_channels_originate_with_id_parse_body(args->variables, args);
|
|
|
|
json_variables = ast_json_object_get(args->variables, "variables");
|
2015-02-27 18:31:31 +00:00
|
|
|
if (json_variables
|
|
|
|
&& json_to_ast_variables(response, json_variables, &variables)) {
|
|
|
|
return;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ari_channels_handle_originate_with_id(
|
|
|
|
args->endpoint,
|
|
|
|
args->extension,
|
|
|
|
args->context,
|
|
|
|
args->priority,
|
2015-01-07 18:54:06 +00:00
|
|
|
args->label,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
args->app,
|
|
|
|
args->app_args,
|
|
|
|
args->caller_id,
|
|
|
|
args->timeout,
|
|
|
|
variables,
|
|
|
|
args->channel_id,
|
|
|
|
args->other_channel_id,
|
2014-12-09 15:45:19 +00:00
|
|
|
args->originator,
|
2016-05-27 19:49:42 +00:00
|
|
|
args->formats,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
response);
|
2015-02-27 18:31:31 +00:00
|
|
|
ast_variables_destroy(variables);
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void ast_ari_channels_originate(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_originate_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
2015-02-27 18:31:31 +00:00
|
|
|
struct ast_variable *variables = NULL;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
|
|
|
|
/* Parse any query parameters out of the body parameter */
|
|
|
|
if (args->variables) {
|
|
|
|
struct ast_json *json_variables;
|
|
|
|
|
|
|
|
ast_ari_channels_originate_parse_body(args->variables, args);
|
|
|
|
json_variables = ast_json_object_get(args->variables, "variables");
|
2015-02-27 18:31:31 +00:00
|
|
|
if (json_variables
|
|
|
|
&& json_to_ast_variables(response, json_variables, &variables)) {
|
|
|
|
return;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ari_channels_handle_originate_with_id(
|
|
|
|
args->endpoint,
|
|
|
|
args->extension,
|
|
|
|
args->context,
|
|
|
|
args->priority,
|
2015-01-07 18:54:06 +00:00
|
|
|
args->label,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
args->app,
|
|
|
|
args->app_args,
|
|
|
|
args->caller_id,
|
|
|
|
args->timeout,
|
|
|
|
variables,
|
|
|
|
args->channel_id,
|
|
|
|
args->other_channel_id,
|
2014-12-09 15:45:19 +00:00
|
|
|
args->originator,
|
2016-05-27 19:49:42 +00:00
|
|
|
args->formats,
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
response);
|
2015-02-27 18:31:31 +00:00
|
|
|
ast_variables_destroy(variables);
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
void ast_ari_channels_get_channel_var(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_get_channel_var_args *args,
|
|
|
|
struct ast_ari_response *response)
|
2013-07-08 14:46:20 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
2014-08-18 00:57:01 +00:00
|
|
|
RAII_VAR(struct ast_str *, value, ast_str_create(32), ast_free);
|
|
|
|
RAII_VAR(struct ast_channel *, channel, NULL, ast_channel_cleanup);
|
2013-07-08 14:46:20 +00:00
|
|
|
|
|
|
|
ast_assert(response != NULL);
|
|
|
|
|
2015-02-21 20:48:17 +00:00
|
|
|
if (!value) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-21 16:23:59 +00:00
|
|
|
if (ast_strlen_zero(args->variable)) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Variable name is required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-08-18 00:57:01 +00:00
|
|
|
if (ast_strlen_zero(args->channel_id)) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Channel ID is required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
channel = ast_channel_get_by_name(args->channel_id);
|
|
|
|
if (!channel) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 404, "Channel Not Found",
|
|
|
|
"Provided channel was not found");
|
2013-07-08 14:46:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-08-18 00:57:01 +00:00
|
|
|
/* You may be tempted to lock the channel you're about to read from. You
|
|
|
|
* would be wrong. Some dialplan functions put the channel into
|
|
|
|
* autoservice, which deadlocks if the channel is already locked.
|
|
|
|
* ast_str_retrieve_variable() does its own locking, and the dialplan
|
|
|
|
* functions need to as well. We should be fine without the lock.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (args->variable[strlen(args->variable) - 1] == ')') {
|
|
|
|
if (ast_func_read2(channel, args->variable, &value, 0)) {
|
2014-08-18 01:14:51 +00:00
|
|
|
ast_ari_response_error(
|
|
|
|
response, 500, "Error With Function",
|
|
|
|
"Unable to read provided function");
|
2014-08-18 00:57:01 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!ast_str_retrieve_variable(&value, 0, channel, NULL, args->variable)) {
|
2015-02-21 20:48:17 +00:00
|
|
|
ast_ari_response_error(
|
|
|
|
response, 404, "Variable Not Found",
|
|
|
|
"Provided variable was not found");
|
2014-08-18 00:57:01 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2013-07-08 14:46:20 +00:00
|
|
|
|
2014-08-18 00:57:01 +00:00
|
|
|
if (!(json = ast_json_pack("{s: s}", "value", S_OR(ast_str_buffer(value), "")))) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
2013-07-08 14:46:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_ok(response, ast_json_ref(json));
|
2013-07-08 14:46:20 +00:00
|
|
|
}
|
|
|
|
|
2013-11-07 21:10:31 +00:00
|
|
|
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)
|
2013-07-08 14:46:20 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
ast_assert(response != NULL);
|
|
|
|
|
|
|
|
if (ast_strlen_zero(args->variable)) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-08 14:46:20 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Variable name is required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-08-21 16:23:59 +00:00
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-08 14:46:20 +00:00
|
|
|
if (stasis_app_control_set_channel_var(control, args->variable, args->value)) {
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_error(
|
2013-07-08 14:46:20 +00:00
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Failed to execute function");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-07-27 23:11:02 +00:00
|
|
|
ast_ari_response_no_content(response);
|
2013-07-08 14:46:20 +00:00
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
static void ari_channels_handle_snoop_channel(
|
|
|
|
const char *args_channel_id,
|
|
|
|
const char *args_spy,
|
|
|
|
const char *args_whisper,
|
|
|
|
const char *args_app,
|
|
|
|
const char *args_app_args,
|
|
|
|
const char *args_snoop_id,
|
|
|
|
struct ast_ari_response *response)
|
2013-11-23 12:40:46 +00:00
|
|
|
{
|
|
|
|
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);
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (ast_strlen_zero(args_spy) || !strcmp(args_spy, "none")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
spy = STASIS_SNOOP_DIRECTION_NONE;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (!strcmp(args_spy, "both")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
spy = STASIS_SNOOP_DIRECTION_BOTH;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (!strcmp(args_spy, "out")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
spy = STASIS_SNOOP_DIRECTION_OUT;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (!strcmp(args_spy, "in")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
spy = STASIS_SNOOP_DIRECTION_IN;
|
|
|
|
} else {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Invalid direction specified for spy");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
if (ast_strlen_zero(args_whisper) || !strcmp(args_whisper, "none")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
whisper = STASIS_SNOOP_DIRECTION_NONE;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (!strcmp(args_whisper, "both")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
whisper = STASIS_SNOOP_DIRECTION_BOTH;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (!strcmp(args_whisper, "out")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
whisper = STASIS_SNOOP_DIRECTION_OUT;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (!strcmp(args_whisper, "in")) {
|
2013-11-23 12:40:46 +00:00
|
|
|
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;
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
} else if (ast_strlen_zero(args_app)) {
|
2013-11-23 12:40:46 +00:00
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Application name is required");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
chan = ast_channel_get_by_name(args_channel_id);
|
2013-11-23 12:40:46 +00:00
|
|
|
if (chan == NULL) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 404, "Channel Not Found",
|
|
|
|
"Provided channel was not found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
snoop = stasis_app_control_snoop(chan, spy, whisper, args_app, args_app_args,
|
|
|
|
args_snoop_id);
|
2013-11-23 12:40:46 +00:00
|
|
|
if (snoop == NULL) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 500, "Internal error",
|
|
|
|
"Snoop channel could not be created");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
stasis: Reduce creation of channel snapshots to improve performance
During some performance testing of Asterisk with AGI, ARI, and lots of Local
channels, we noticed that there's quite a hit in performance during channel
creation and releasing to the dialplan (ARI continue). After investigating
the performance spike that occurs during channel creation, we discovered
that we create a lot of channel snapshots that are technically unnecessary.
This includes creating snapshots during:
* AGI execution
* Returning objects for ARI commands
* During some Local channel operations
* During some dialling operations
* During variable setting
* During some bridging operations
And more.
This patch does the following:
- It removes a number of fields from channel snapshots. These fields were
rarely used, were expensive to have on the snapshot, and hurt performance.
This included formats, translation paths, Log Call ID, callgroup, pickup
group, and all channel variables. As a result, AMI Status,
"core show channel", "core show channelvar", and "pjsip show channel" were
modified to either hit the live channel or not show certain pieces of data.
While this is unfortunate, the performance gain from this patch is worth
the loss in behaviour.
- It adds a mechanism to publish a cached snapshot + blob. A large number of
publications were changed to use this, including:
- During Dial begin
- During Variable assignment (if no AMI variables are emitted - if AMI
variables are set, we have to make snapshots when a variable is changed)
- During channel pickup
- When a channel is put on hold/unhold
- When a DTMF digit is begun/ended
- When creating a bridge snapshot
- When an AOC event is raised
- During Local channel optimization/Local bridging
- When endpoint snapshots are generated
- All AGI events
- All ARI responses that return a channel
- Events in the AgentPool, MeetMe, and some in Queue
- Additionally, some extraneous channel snapshots were being made that were
unnecessary. These were removed.
- The result of ast_hashtab_hash_string is now cached in stasis_cache. This
reduces a large number of calls to ast_hashtab_hash_string, which reduced
the amount of time spent in this function in gprof by around 50%.
#ASTERISK-23811 #close
Reported by: Matt Jordan
Review: https://reviewboard.asterisk.org/r/3568/
........
Merged revisions 416211 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@416216 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-06-13 18:24:49 +00:00
|
|
|
snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(snoop));
|
2013-11-23 12:40:46 +00:00
|
|
|
ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot, NULL));
|
2013-12-13 17:19:23 +00:00
|
|
|
}
|
uniqueid: channel linkedid, ami, ari object creation with id's
Much needed was a way to assign id to objects on creation, and
much change was necessary to accomplish it. Channel uniqueids
and linkedids are split into separate string and creation time
components without breaking linkedid propgation. This allowed
the uniqueid to be specified by the user interface - and those
values are now carried through to channel creation, adding the
assignedids value to every function in the chain including the
channel drivers. For local channels, the second channel can be
specified or left to default to a ;2 suffix of first. In ARI,
bridge, playback, and snoop objects can also be created with a
specified uniqueid.
Along the way, the args order to allocating channels was fixed
in chan_mgcp and chan_gtalk, and linkedid is no longer lost as
masquerade occurs.
(closes issue ASTERISK-23120)
Review: https://reviewboard.asterisk.org/r/3191/
........
Merged revisions 410157 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@410158 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2014-03-07 15:47:55 +00:00
|
|
|
|
|
|
|
void ast_ari_channels_snoop_channel(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_snoop_channel_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
ari_channels_handle_snoop_channel(
|
|
|
|
args->channel_id,
|
|
|
|
args->spy,
|
|
|
|
args->whisper,
|
|
|
|
args->app,
|
|
|
|
args->app_args,
|
|
|
|
args->snoop_id,
|
|
|
|
response);
|
|
|
|
}
|
|
|
|
|
|
|
|
void ast_ari_channels_snoop_channel_with_id(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_snoop_channel_with_id_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
ari_channels_handle_snoop_channel(
|
|
|
|
args->channel_id,
|
|
|
|
args->spy,
|
|
|
|
args->whisper,
|
|
|
|
args->app,
|
|
|
|
args->app_args,
|
|
|
|
args->snoop_id,
|
|
|
|
response);
|
|
|
|
}
|
2016-03-30 22:01:28 +00:00
|
|
|
|
|
|
|
struct ari_channel_thread_data {
|
|
|
|
struct ast_channel *chan;
|
|
|
|
struct ast_str *stasis_stuff;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void chan_data_destroy(struct ari_channel_thread_data *chan_data)
|
|
|
|
{
|
|
|
|
ast_free(chan_data->stasis_stuff);
|
|
|
|
ast_hangup(chan_data->chan);
|
|
|
|
ast_free(chan_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Thread that owns stasis-created channel.
|
|
|
|
*
|
|
|
|
* The channel enters into a Stasis application immediately upon creation. In this
|
|
|
|
* way, the channel can be manipulated by the Stasis application. Once the channel
|
|
|
|
* exits the Stasis application, it is hung up.
|
|
|
|
*/
|
|
|
|
static void *ari_channel_thread(void *data)
|
|
|
|
{
|
|
|
|
struct ari_channel_thread_data *chan_data = data;
|
|
|
|
struct ast_app *stasis_app;
|
|
|
|
|
|
|
|
stasis_app = pbx_findapp("Stasis");
|
|
|
|
if (!stasis_app) {
|
|
|
|
ast_log(LOG_ERROR, "Stasis dialplan application is not registered");
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
pbx_exec(chan_data->chan, stasis_app, ast_str_buffer(chan_data->stasis_stuff));
|
|
|
|
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
struct ast_datastore_info dialstring_info = {
|
|
|
|
.type = "ARI Dialstring",
|
|
|
|
.destroy = ast_free_ptr,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Save dialstring onto a channel datastore
|
|
|
|
*
|
|
|
|
* This will later be retrieved when it comes time to actually dial the channel
|
|
|
|
*
|
|
|
|
* \param chan The channel on which to save the dialstring
|
|
|
|
* \param dialstring The dialstring to save
|
|
|
|
* \retval 0 SUCCESS!
|
|
|
|
* \reval -1 Failure :(
|
|
|
|
*/
|
|
|
|
static int save_dialstring(struct ast_channel *chan, const char *dialstring)
|
|
|
|
{
|
|
|
|
struct ast_datastore *datastore;
|
|
|
|
|
|
|
|
datastore = ast_datastore_alloc(&dialstring_info, NULL);
|
|
|
|
if (!datastore) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
datastore->data = ast_strdup(dialstring);
|
|
|
|
if (!datastore->data) {
|
|
|
|
ast_datastore_free(datastore);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
if (ast_channel_datastore_add(chan, datastore)) {
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
ast_datastore_free(datastore);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*!
|
|
|
|
* \brief Retrieve the dialstring from the channel datastore
|
|
|
|
*
|
|
|
|
* \pre chan is locked
|
|
|
|
* \param chan Channel that was previously created in ARI
|
|
|
|
* \retval NULL Failed to find datastore
|
|
|
|
* \retval non-NULL The dialstring
|
|
|
|
*/
|
|
|
|
static char *restore_dialstring(struct ast_channel *chan)
|
|
|
|
{
|
|
|
|
struct ast_datastore *datastore;
|
|
|
|
|
|
|
|
datastore = ast_channel_datastore_find(chan, &dialstring_info, NULL);
|
|
|
|
if (!datastore) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return datastore->data;
|
|
|
|
}
|
|
|
|
|
2016-03-30 22:01:28 +00:00
|
|
|
void ast_ari_channels_create(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_create_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
struct ast_assigned_ids assignedids = {
|
|
|
|
.uniqueid = args->channel_id,
|
|
|
|
.uniqueid2 = args->other_channel_id,
|
|
|
|
};
|
|
|
|
struct ari_channel_thread_data *chan_data;
|
|
|
|
struct ast_channel_snapshot *snapshot;
|
|
|
|
pthread_t thread;
|
|
|
|
char *dialtech;
|
|
|
|
char dialdevice[AST_CHANNEL_NAME];
|
|
|
|
char *stuff;
|
|
|
|
int cause;
|
|
|
|
struct ast_format_cap *request_cap;
|
|
|
|
struct ast_channel *originator;
|
|
|
|
|
|
|
|
chan_data = ast_calloc(1, sizeof(*chan_data));
|
|
|
|
if (!chan_data) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-27 19:49:42 +00:00
|
|
|
if (!ast_strlen_zero(args->originator) && !ast_strlen_zero(args->formats)) {
|
|
|
|
ast_ari_response_error(response, 400, "Bad Request",
|
|
|
|
"Originator and formats can't both be specified");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-03-30 22:01:28 +00:00
|
|
|
chan_data->stasis_stuff = ast_str_create(32);
|
|
|
|
if (!chan_data->stasis_stuff) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_str_append(&chan_data->stasis_stuff, 0, "%s", args->app);
|
|
|
|
if (!ast_strlen_zero(args->app_args)) {
|
|
|
|
ast_str_append(&chan_data->stasis_stuff, 0, ",%s", args->app_args);
|
|
|
|
}
|
|
|
|
|
|
|
|
dialtech = ast_strdupa(args->endpoint);
|
|
|
|
if ((stuff = strchr(dialtech, '/'))) {
|
|
|
|
*stuff++ = '\0';
|
|
|
|
ast_copy_string(dialdevice, stuff, sizeof(dialdevice));
|
|
|
|
}
|
|
|
|
|
|
|
|
originator = ast_channel_get_by_name(args->originator);
|
|
|
|
if (originator) {
|
|
|
|
request_cap = ao2_bump(ast_channel_nativeformats(originator));
|
2016-07-12 01:07:20 +00:00
|
|
|
if (!ast_strlen_zero(args->app)) {
|
|
|
|
stasis_app_subscribe_channel(args->app, originator);
|
|
|
|
}
|
2016-05-27 19:49:42 +00:00
|
|
|
} else if (!ast_strlen_zero(args->formats)) {
|
|
|
|
char *format_name;
|
|
|
|
char *formats_copy = ast_strdupa(args->formats);
|
|
|
|
|
|
|
|
if (!(request_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
while ((format_name = ast_strip(strsep(&formats_copy, ",")))) {
|
|
|
|
struct ast_format *fmt = ast_format_cache_get(format_name);
|
|
|
|
|
|
|
|
if (!fmt || ast_format_cap_append(request_cap, fmt, 0)) {
|
|
|
|
if (!fmt) {
|
|
|
|
ast_ari_response_error(
|
|
|
|
response, 400, "Bad Request",
|
|
|
|
"Provided format (%s) was not found", format_name);
|
|
|
|
} else {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
}
|
|
|
|
ao2_ref(request_cap, -1);
|
|
|
|
ao2_cleanup(fmt);
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ao2_ref(fmt, -1);
|
|
|
|
}
|
2016-03-30 22:01:28 +00:00
|
|
|
} else {
|
2016-05-27 19:49:42 +00:00
|
|
|
if (!(request_cap = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT))) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-03-30 22:01:28 +00:00
|
|
|
ast_format_cap_append_by_type(request_cap, AST_MEDIA_TYPE_AUDIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
chan_data->chan = ast_request(dialtech, request_cap, &assignedids, originator, dialdevice, &cause);
|
|
|
|
ao2_cleanup(request_cap);
|
2016-07-12 01:07:20 +00:00
|
|
|
|
2016-03-30 22:01:28 +00:00
|
|
|
if (!chan_data->chan) {
|
2016-10-19 17:05:28 +00:00
|
|
|
if (ast_channel_errno() == AST_CHANNEL_ERROR_ID_EXISTS) {
|
|
|
|
ast_ari_response_error(response, 409, "Conflict",
|
|
|
|
"Channel with given unique ID already exists");
|
|
|
|
} else {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
}
|
2016-07-12 01:07:20 +00:00
|
|
|
ast_channel_cleanup(originator);
|
2016-03-30 22:01:28 +00:00
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-07-12 01:07:20 +00:00
|
|
|
if (!ast_strlen_zero(args->app)) {
|
|
|
|
stasis_app_subscribe_channel(args->app, chan_data->chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_cleanup(originator);
|
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
if (save_dialstring(chan_data->chan, stuff)) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-03-30 22:01:28 +00:00
|
|
|
snapshot = ast_channel_snapshot_get_latest(ast_channel_uniqueid(chan_data->chan));
|
|
|
|
|
|
|
|
if (ast_pthread_create_detached(&thread, NULL, ari_channel_thread, chan_data)) {
|
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
chan_data_destroy(chan_data);
|
|
|
|
} else {
|
|
|
|
ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot, NULL));
|
|
|
|
}
|
|
|
|
|
|
|
|
ao2_ref(snapshot, -1);
|
|
|
|
}
|
2016-03-30 22:18:39 +00:00
|
|
|
|
|
|
|
void ast_ari_channels_dial(struct ast_variable *headers,
|
|
|
|
struct ast_ari_channels_dial_args *args,
|
|
|
|
struct ast_ari_response *response)
|
|
|
|
{
|
|
|
|
RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct ast_channel *, caller, NULL, ast_channel_cleanup);
|
2016-05-09 19:48:51 +00:00
|
|
|
RAII_VAR(struct ast_channel *, callee, NULL, ast_channel_cleanup);
|
|
|
|
char *dialstring;
|
2016-03-30 22:18:39 +00:00
|
|
|
|
|
|
|
control = find_control(response, args->channel_id);
|
|
|
|
if (control == NULL) {
|
|
|
|
/* Response filled in by find_control */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
caller = ast_channel_get_by_name(args->caller);
|
|
|
|
|
|
|
|
callee = ast_channel_get_by_name(args->channel_id);
|
|
|
|
if (!callee) {
|
|
|
|
ast_ari_response_error(response, 404, "Not Found",
|
|
|
|
"Callee not found");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
if (ast_channel_state(callee) != AST_STATE_DOWN
|
|
|
|
&& ast_channel_state(callee) != AST_STATE_RESERVED) {
|
2016-03-30 22:18:39 +00:00
|
|
|
ast_ari_response_error(response, 409, "Conflict",
|
|
|
|
"Channel is not in the 'Down' state");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
/* XXX This is straight up copied from main/dial.c. It's probably good
|
|
|
|
* to separate this to some common method.
|
|
|
|
*/
|
|
|
|
if (caller) {
|
|
|
|
ast_channel_lock_both(caller, callee);
|
|
|
|
} else {
|
|
|
|
ast_channel_lock(callee);
|
2016-03-30 22:18:39 +00:00
|
|
|
}
|
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
dialstring = restore_dialstring(callee);
|
|
|
|
if (!dialstring) {
|
|
|
|
ast_channel_unlock(callee);
|
|
|
|
if (caller) {
|
|
|
|
ast_channel_unlock(caller);
|
|
|
|
}
|
|
|
|
ast_ari_response_error(response, 409, "Conflict",
|
|
|
|
"Dialing a channel not created by ARI");
|
2016-03-30 22:18:39 +00:00
|
|
|
return;
|
|
|
|
}
|
2016-05-09 19:48:51 +00:00
|
|
|
/* Make a copy of the dialstring just in case some jerk tries to hang up the
|
|
|
|
* channel before we can actually dial
|
2016-03-30 22:18:39 +00:00
|
|
|
*/
|
2016-05-09 19:48:51 +00:00
|
|
|
dialstring = ast_strdupa(dialstring);
|
2016-03-30 22:18:39 +00:00
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
ast_channel_stage_snapshot(callee);
|
|
|
|
if (caller) {
|
|
|
|
ast_channel_inherit_variables(caller, callee);
|
|
|
|
ast_channel_datastore_inherit(caller, callee);
|
|
|
|
ast_max_forwards_decrement(callee);
|
|
|
|
|
|
|
|
/* Copy over callerid information */
|
|
|
|
ast_party_redirecting_copy(ast_channel_redirecting(callee), ast_channel_redirecting(caller));
|
|
|
|
|
|
|
|
ast_channel_dialed(callee)->transit_network_select = ast_channel_dialed(caller)->transit_network_select;
|
|
|
|
|
|
|
|
ast_connected_line_copy_from_caller(ast_channel_connected(callee), ast_channel_caller(caller));
|
|
|
|
|
|
|
|
ast_channel_language_set(callee, ast_channel_language(caller));
|
|
|
|
ast_channel_req_accountcodes(callee, caller, AST_CHANNEL_REQUESTOR_BRIDGE_PEER);
|
|
|
|
if (ast_strlen_zero(ast_channel_musicclass(callee)))
|
|
|
|
ast_channel_musicclass_set(callee, ast_channel_musicclass(caller));
|
|
|
|
|
|
|
|
ast_channel_adsicpe_set(callee, ast_channel_adsicpe(caller));
|
|
|
|
ast_channel_transfercapability_set(callee, ast_channel_transfercapability(caller));
|
|
|
|
ast_channel_unlock(caller);
|
2016-03-30 22:18:39 +00:00
|
|
|
}
|
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
ast_channel_stage_snapshot_done(callee);
|
|
|
|
ast_channel_unlock(callee);
|
2016-03-30 22:18:39 +00:00
|
|
|
|
2016-05-09 19:48:51 +00:00
|
|
|
if (stasis_app_control_dial(control, dialstring, args->timeout)) {
|
2016-03-30 22:18:39 +00:00
|
|
|
ast_ari_response_alloc_failed(response);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_ari_response_no_content(response);
|
|
|
|
}
|