2013-05-21 18:00:22 +00:00
|
|
|
/*
|
|
|
|
* Asterisk -- An open source telephony toolkit.
|
|
|
|
*
|
|
|
|
* Copyright (C) 2013, Digium, Inc.
|
|
|
|
*
|
|
|
|
* Jonathan Rose <jrose@digium.com>
|
|
|
|
*
|
|
|
|
* See http://www.asterisk.org for more information about
|
|
|
|
* the Asterisk project. Please do not directly contact
|
|
|
|
* any of the maintainers of this project for assistance;
|
|
|
|
* the project provides a web site, mailing lists and IRC
|
|
|
|
* channels for your use.
|
|
|
|
*
|
|
|
|
* This program is free software, distributed under the terms of
|
|
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
|
|
* at the top of the source tree.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*! \file
|
|
|
|
*
|
|
|
|
* \brief Call Parking Applications
|
|
|
|
*
|
|
|
|
* \author Jonathan Rose <jrose@digium.com>
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "asterisk.h"
|
|
|
|
|
|
|
|
ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
|
|
|
|
|
|
|
|
#include "res_parking.h"
|
|
|
|
#include "asterisk/config.h"
|
|
|
|
#include "asterisk/config_options.h"
|
|
|
|
#include "asterisk/utils.h"
|
|
|
|
#include "asterisk/astobj2.h"
|
|
|
|
#include "asterisk/features.h"
|
|
|
|
#include "asterisk/module.h"
|
|
|
|
#include "asterisk/app.h"
|
|
|
|
#include "asterisk/say.h"
|
2013-07-25 04:06:32 +00:00
|
|
|
#include "asterisk/bridge_basic.h"
|
2013-05-21 18:00:22 +00:00
|
|
|
|
|
|
|
/*** DOCUMENTATION
|
|
|
|
<application name="Park" language="en_US">
|
|
|
|
<synopsis>
|
|
|
|
Park yourself.
|
|
|
|
</synopsis>
|
|
|
|
<syntax>
|
|
|
|
<parameter name="parking_lot_name">
|
|
|
|
<para>Specify in which parking lot to park a call.</para>
|
|
|
|
<para>The parking lot used is selected in the following order:</para>
|
|
|
|
<para>1) parking_lot_name option to this application</para>
|
|
|
|
<para>2) <variable>PARKINGLOT</variable> variable</para>
|
|
|
|
<para>3) <literal>CHANNEL(parkinglot)</literal> function
|
|
|
|
(Possibly preset by the channel driver.)</para>
|
|
|
|
<para>4) Default parking lot.</para>
|
|
|
|
</parameter>
|
|
|
|
<parameter name="options">
|
|
|
|
<para>A list of options for this parked call.</para>
|
|
|
|
<optionlist>
|
|
|
|
<option name="r">
|
|
|
|
<para>Send ringing instead of MOH to the parked call.</para>
|
|
|
|
</option>
|
|
|
|
<option name="R">
|
|
|
|
<para>Randomize the selection of a parking space.</para>
|
|
|
|
</option>
|
|
|
|
<option name="s">
|
|
|
|
<para>Silence announcement of the parking space number.</para>
|
|
|
|
</option>
|
|
|
|
<option name="c" argsep=",">
|
|
|
|
<argument name="context" required="false" />
|
|
|
|
<argument name="extension" required="false" />
|
|
|
|
<argument name="priority" required="true" />
|
|
|
|
<para>If the parking times out, go to this place in the dialplan
|
|
|
|
instead of where the parking lot defines the call should go.
|
|
|
|
</para>
|
|
|
|
</option>
|
|
|
|
<option name="t">
|
|
|
|
<argument name="duration" required="true" />
|
|
|
|
<para>Use a timeout of <literal>duration</literal> seconds instead
|
|
|
|
of the timeout specified by the parking lot.</para>
|
|
|
|
</option>
|
|
|
|
</optionlist>
|
|
|
|
</parameter>
|
|
|
|
</syntax>
|
|
|
|
<description>
|
|
|
|
<para>Used to park yourself (typically in combination with an attended
|
|
|
|
transfer to know the parking space).</para>
|
|
|
|
<para>If you set the <variable>PARKINGEXTEN</variable> variable to a
|
|
|
|
parking space extension in the parking lot, Park() will attempt to park the
|
|
|
|
call on that extension. If the extension is already in use then execution
|
|
|
|
will continue at the next priority.
|
|
|
|
</para>
|
|
|
|
</description>
|
|
|
|
<see-also>
|
|
|
|
<ref type="application">ParkedCall</ref>
|
|
|
|
</see-also>
|
|
|
|
</application>
|
|
|
|
|
|
|
|
<application name="ParkedCall" language="en_US">
|
|
|
|
<synopsis>
|
|
|
|
Retrieve a parked call.
|
|
|
|
</synopsis>
|
|
|
|
<syntax>
|
|
|
|
<parameter name="parking_lot_name">
|
|
|
|
<para>Specify from which parking lot to retrieve a parked call.</para>
|
|
|
|
<para>The parking lot used is selected in the following order:</para>
|
|
|
|
<para>1) parking_lot_name option</para>
|
|
|
|
<para>2) <variable>PARKINGLOT</variable> variable</para>
|
|
|
|
<para>3) <literal>CHANNEL(parkinglot)</literal> function
|
|
|
|
(Possibly preset by the channel driver.)</para>
|
|
|
|
<para>4) Default parking lot.</para>
|
|
|
|
</parameter>
|
|
|
|
<parameter name="parking_space">
|
|
|
|
<para>Parking space to retrieve a parked call from.
|
|
|
|
If not provided then the first available parked call in the
|
|
|
|
parking lot will be retrieved.</para>
|
|
|
|
</parameter>
|
|
|
|
</syntax>
|
|
|
|
<description>
|
|
|
|
<para>Used to retrieve a parked call from a parking lot.</para>
|
|
|
|
<note>
|
|
|
|
<para>If a parking lot's parkext option is set, then Parking lots
|
|
|
|
will automatically create and manage dialplan extensions in
|
|
|
|
the parking lot context. If that is the case then you will not
|
|
|
|
need to manage parking extensions yourself, just include the
|
|
|
|
parking context of the parking lot.</para>
|
|
|
|
</note>
|
|
|
|
</description>
|
|
|
|
<see-also>
|
|
|
|
<ref type="application">Park</ref>
|
|
|
|
</see-also>
|
|
|
|
</application>
|
|
|
|
|
|
|
|
<application name="ParkAndAnnounce" language="en_US">
|
|
|
|
<synopsis>
|
|
|
|
Park and Announce.
|
|
|
|
</synopsis>
|
|
|
|
<syntax>
|
|
|
|
<parameter name="parking_lot_name">
|
|
|
|
<para>Specify in which parking lot to park a call.</para>
|
|
|
|
<para>The parking lot used is selected in the following order:</para>
|
|
|
|
<para>1) parking_lot_name option to this application</para>
|
|
|
|
<para>2) <variable>PARKINGLOT</variable> variable</para>
|
|
|
|
<para>3) <literal>CHANNEL(parkinglot)</literal> function
|
|
|
|
(Possibly preset by the channel driver.)</para>
|
|
|
|
<para>4) Default parking lot.</para>
|
|
|
|
</parameter>
|
|
|
|
<parameter name="options">
|
|
|
|
<para>A list of options for this parked call.</para>
|
|
|
|
<optionlist>
|
|
|
|
<option name="r">
|
|
|
|
<para>Send ringing instead of MOH to the parked call.</para>
|
|
|
|
</option>
|
|
|
|
<option name="R">
|
|
|
|
<para>Randomize the selection of a parking space.</para>
|
|
|
|
</option>
|
|
|
|
<option name="c" argsep=",">
|
|
|
|
<argument name="context" required="false" />
|
|
|
|
<argument name="extension" required="false" />
|
|
|
|
<argument name="priority" required="true" />
|
|
|
|
<para>If the parking times out, go to this place in the dialplan
|
|
|
|
instead of where the parking lot defines the call should go.
|
|
|
|
</para>
|
|
|
|
</option>
|
|
|
|
<option name="t">
|
|
|
|
<argument name="duration" required="true" />
|
|
|
|
<para>Use a timeout of <literal>duration</literal> seconds instead
|
|
|
|
of the timeout specified by the parking lot.</para>
|
|
|
|
</option>
|
|
|
|
</optionlist>
|
|
|
|
</parameter>
|
|
|
|
<parameter name="announce_template" required="true" argsep=":">
|
|
|
|
<argument name="announce" required="true">
|
|
|
|
<para>Colon-separated list of files to announce. The word
|
|
|
|
<literal>PARKED</literal> will be replaced by a say_digits of the extension in which
|
|
|
|
the call is parked.</para>
|
|
|
|
</argument>
|
|
|
|
<argument name="announce1" multiple="true" />
|
|
|
|
</parameter>
|
|
|
|
<parameter name="dial" required="true">
|
|
|
|
<para>The app_dial style resource to call to make the
|
|
|
|
announcement. Console/dsp calls the console.</para>
|
|
|
|
</parameter>
|
|
|
|
</syntax>
|
|
|
|
<description>
|
|
|
|
<para>Park a call into the parkinglot and announce the call to another channel.</para>
|
|
|
|
<para>The variable <variable>PARKEDAT</variable> will contain the parking extension
|
|
|
|
into which the call was placed. Use with the Local channel to allow the dialplan to make
|
|
|
|
use of this information.</para>
|
|
|
|
</description>
|
|
|
|
<see-also>
|
|
|
|
<ref type="application">Park</ref>
|
|
|
|
<ref type="application">ParkedCall</ref>
|
|
|
|
</see-also>
|
|
|
|
</application>
|
|
|
|
***/
|
|
|
|
|
2013-08-17 15:01:54 +00:00
|
|
|
#define PARK_AND_ANNOUNCE_APPLICATION "ParkAndAnnounce"
|
|
|
|
|
2013-05-21 18:00:22 +00:00
|
|
|
/* Park a call */
|
|
|
|
|
|
|
|
enum park_args {
|
|
|
|
OPT_ARG_COMEBACK,
|
|
|
|
OPT_ARG_TIMEOUT,
|
|
|
|
OPT_ARG_ARRAY_SIZE /* Always the last element of the enum */
|
|
|
|
};
|
|
|
|
|
|
|
|
enum park_flags {
|
|
|
|
MUXFLAG_RINGING = (1 << 0),
|
|
|
|
MUXFLAG_RANDOMIZE = (1 << 1),
|
|
|
|
MUXFLAG_NOANNOUNCE = (1 << 2),
|
|
|
|
MUXFLAG_COMEBACK_OVERRIDE = (1 << 3),
|
|
|
|
MUXFLAG_TIMEOUT_OVERRIDE = (1 << 4),
|
|
|
|
};
|
|
|
|
|
|
|
|
AST_APP_OPTIONS(park_opts, {
|
|
|
|
AST_APP_OPTION('r', MUXFLAG_RINGING),
|
|
|
|
AST_APP_OPTION('R', MUXFLAG_RANDOMIZE),
|
|
|
|
AST_APP_OPTION('s', MUXFLAG_NOANNOUNCE),
|
|
|
|
AST_APP_OPTION_ARG('c', MUXFLAG_COMEBACK_OVERRIDE, OPT_ARG_COMEBACK),
|
|
|
|
AST_APP_OPTION_ARG('t', MUXFLAG_TIMEOUT_OVERRIDE, OPT_ARG_TIMEOUT),
|
|
|
|
});
|
|
|
|
|
|
|
|
static int apply_option_timeout (int *var, char *timeout_arg)
|
|
|
|
{
|
|
|
|
if (ast_strlen_zero(timeout_arg)) {
|
|
|
|
ast_log(LOG_ERROR, "No duration value provided for the timeout ('t') option.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (sscanf(timeout_arg, "%d", var) != 1 || *var < 0) {
|
|
|
|
ast_log(LOG_ERROR, "Duration value provided for timeout ('t') option must be 0 or greater.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int park_app_parse_data(const char *data, int *disable_announce, int *use_ringing, int *randomize, int *time_limit, char **comeback_override, char **lot_name)
|
|
|
|
{
|
|
|
|
char *parse;
|
|
|
|
struct ast_flags flags = { 0 };
|
|
|
|
|
|
|
|
AST_DECLARE_APP_ARGS(args,
|
|
|
|
AST_APP_ARG(lot_name);
|
|
|
|
AST_APP_ARG(options);
|
|
|
|
AST_APP_ARG(other); /* Any remaining unused arguments */
|
|
|
|
);
|
|
|
|
|
|
|
|
parse = ast_strdupa(data);
|
|
|
|
AST_STANDARD_APP_ARGS(args, parse);
|
|
|
|
|
|
|
|
if (args.options) {
|
|
|
|
char *opts[OPT_ARG_ARRAY_SIZE] = { NULL, };
|
|
|
|
ast_app_parse_options(park_opts, &flags, opts, args.options);
|
|
|
|
if (ast_test_flag(&flags, MUXFLAG_TIMEOUT_OVERRIDE)) {
|
|
|
|
if (apply_option_timeout(time_limit, opts[OPT_ARG_TIMEOUT])) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_test_flag(&flags, MUXFLAG_COMEBACK_OVERRIDE)) {
|
|
|
|
*comeback_override = ast_strdup(opts[OPT_ARG_COMEBACK]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_test_flag(&flags, MUXFLAG_NOANNOUNCE)) {
|
|
|
|
if (disable_announce) {
|
|
|
|
*disable_announce = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_test_flag(&flags, MUXFLAG_RINGING)) {
|
|
|
|
*use_ringing = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_test_flag(&flags, MUXFLAG_RANDOMIZE)) {
|
|
|
|
*randomize = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(args.lot_name)) {
|
|
|
|
*lot_name = ast_strdup(args.lot_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
void park_common_datastore_free(struct park_common_datastore *datastore)
|
2013-05-21 18:00:22 +00:00
|
|
|
{
|
2013-07-04 18:46:56 +00:00
|
|
|
if (!datastore) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-05-21 18:00:22 +00:00
|
|
|
ast_free(datastore->parker_uuid);
|
2013-07-04 18:46:56 +00:00
|
|
|
ast_free(datastore->parker_dial_string);
|
2013-05-21 18:00:22 +00:00
|
|
|
ast_free(datastore->comeback_override);
|
|
|
|
ast_free(datastore);
|
|
|
|
}
|
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
static void park_common_datastore_destroy(void *data)
|
|
|
|
{
|
|
|
|
struct park_common_datastore *datastore = data;
|
|
|
|
park_common_datastore_free(datastore);
|
|
|
|
}
|
|
|
|
|
2013-05-21 18:00:22 +00:00
|
|
|
static const struct ast_datastore_info park_common_info = {
|
|
|
|
.type = "park entry data",
|
|
|
|
.destroy = park_common_datastore_destroy,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void wipe_park_common_datastore(struct ast_channel *chan)
|
|
|
|
{
|
|
|
|
struct ast_datastore *datastore;
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
datastore = ast_channel_datastore_find(chan, &park_common_info, NULL);
|
|
|
|
if (datastore) {
|
|
|
|
ast_channel_datastore_remove(chan, datastore);
|
|
|
|
ast_datastore_free(datastore);
|
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int setup_park_common_datastore(struct ast_channel *parkee, const char *parker_uuid, const char *comeback_override, int randomize, int time_limit, int silence_announce)
|
|
|
|
{
|
|
|
|
struct ast_datastore *datastore = NULL;
|
|
|
|
struct park_common_datastore *park_datastore;
|
2013-07-04 18:46:56 +00:00
|
|
|
const char *attended_transfer;
|
|
|
|
const char *blind_transfer;
|
|
|
|
char *parker_dial_string = NULL;
|
2013-05-21 18:00:22 +00:00
|
|
|
|
|
|
|
wipe_park_common_datastore(parkee);
|
|
|
|
|
|
|
|
if (!(datastore = ast_datastore_alloc(&park_common_info, NULL))) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(park_datastore = ast_calloc(1, sizeof(*park_datastore)))) {
|
|
|
|
ast_datastore_free(datastore);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
if (parker_uuid) {
|
|
|
|
park_datastore->parker_uuid = ast_strdup(parker_uuid);
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_lock(parkee);
|
|
|
|
|
|
|
|
attended_transfer = pbx_builtin_getvar_helper(parkee, "ATTENDEDTRANSFER");
|
|
|
|
blind_transfer = pbx_builtin_getvar_helper(parkee, "BLINDTRANSFER");
|
|
|
|
|
|
|
|
if (attended_transfer || blind_transfer) {
|
|
|
|
parker_dial_string = ast_strdupa(S_OR(attended_transfer, blind_transfer));
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_channel_unlock(parkee);
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(parker_dial_string)) {
|
|
|
|
ast_channel_name_to_dial_string(parker_dial_string);
|
|
|
|
ast_verb(5, "Setting dial string to %s from %s value", parker_dial_string, attended_transfer ? "ATTENDEDTRANSFER" : "BLINDTRANSFER");
|
|
|
|
park_datastore->parker_dial_string = ast_strdup(parker_dial_string);
|
|
|
|
}
|
|
|
|
|
2013-05-21 18:00:22 +00:00
|
|
|
park_datastore->randomize = randomize;
|
|
|
|
park_datastore->time_limit = time_limit;
|
|
|
|
park_datastore->silence_announce = silence_announce;
|
|
|
|
|
|
|
|
if (comeback_override) {
|
|
|
|
park_datastore->comeback_override = ast_strdup(comeback_override);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
datastore->data = park_datastore;
|
|
|
|
ast_channel_lock(parkee);
|
|
|
|
ast_channel_datastore_add(parkee, datastore);
|
|
|
|
ast_channel_unlock(parkee);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
struct park_common_datastore *get_park_common_datastore_copy(struct ast_channel *parkee)
|
2013-05-21 18:00:22 +00:00
|
|
|
{
|
|
|
|
struct ast_datastore *datastore;
|
|
|
|
struct park_common_datastore *data;
|
2013-07-04 18:46:56 +00:00
|
|
|
struct park_common_datastore *data_copy;
|
2013-05-21 18:00:22 +00:00
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
SCOPED_CHANNELLOCK(lock, parkee);
|
2013-05-21 18:00:22 +00:00
|
|
|
if (!(datastore = ast_channel_datastore_find(parkee, &park_common_info, NULL))) {
|
2013-07-04 18:46:56 +00:00
|
|
|
return NULL;
|
2013-05-21 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
data = datastore->data;
|
|
|
|
|
|
|
|
if (!data) {
|
|
|
|
/* This data should always be populated if this datastore was appended to the channel */
|
|
|
|
ast_assert(0);
|
|
|
|
}
|
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
data_copy = ast_calloc(1, sizeof(*data_copy));
|
|
|
|
if (!data_copy) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(data_copy->parker_uuid = ast_strdup(data->parker_uuid))) {
|
|
|
|
park_common_datastore_free(data_copy);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
data_copy->randomize = data->randomize;
|
|
|
|
data_copy->time_limit = data->time_limit;
|
|
|
|
data_copy->silence_announce = data->silence_announce;
|
2013-05-21 18:00:22 +00:00
|
|
|
|
|
|
|
if (data->comeback_override) {
|
2013-07-04 18:46:56 +00:00
|
|
|
data_copy->comeback_override = ast_strdup(data->comeback_override);
|
|
|
|
if (!data_copy->comeback_override) {
|
|
|
|
park_common_datastore_free(data_copy);
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-05-21 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
if (data->parker_dial_string) {
|
|
|
|
data_copy->parker_dial_string = ast_strdup(data->parker_dial_string);
|
|
|
|
if (!data_copy->parker_dial_string) {
|
|
|
|
park_common_datastore_free(data_copy);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return data_copy;
|
2013-05-21 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
2013-06-25 22:28:22 +00:00
|
|
|
struct ast_bridge *park_common_setup(struct ast_channel *parkee, struct ast_channel *parker,
|
|
|
|
const char *lot_name, const char *comeback_override,
|
|
|
|
int use_ringing, int randomize, int time_limit, int silence_announcements)
|
2013-05-21 18:00:22 +00:00
|
|
|
{
|
|
|
|
struct ast_bridge *parking_bridge;
|
|
|
|
RAII_VAR(struct parking_lot *, lot, NULL, ao2_cleanup);
|
|
|
|
|
2013-07-04 18:46:56 +00:00
|
|
|
if (!parker) {
|
|
|
|
parker = parkee;
|
|
|
|
}
|
|
|
|
|
2013-05-21 18:00:22 +00:00
|
|
|
/* If the name of the parking lot isn't specified in the arguments, find it based on the channel. */
|
|
|
|
if (ast_strlen_zero(lot_name)) {
|
|
|
|
ast_channel_lock(parker);
|
|
|
|
lot_name = ast_strdupa(find_channel_parking_lot_name(parker));
|
|
|
|
ast_channel_unlock(parker);
|
|
|
|
}
|
|
|
|
|
|
|
|
lot = parking_lot_find_by_name(lot_name);
|
2013-06-28 19:22:16 +00:00
|
|
|
if (!lot) {
|
|
|
|
lot = parking_create_dynamic_lot(lot_name, parkee);
|
|
|
|
}
|
2013-05-21 18:00:22 +00:00
|
|
|
|
|
|
|
if (!lot) {
|
|
|
|
ast_log(LOG_ERROR, "Could not find parking lot: '%s'\n", lot_name);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ao2_lock(lot);
|
|
|
|
parking_bridge = parking_lot_get_bridge(lot);
|
|
|
|
ao2_unlock(lot);
|
|
|
|
|
2013-06-25 22:28:22 +00:00
|
|
|
if (!parking_bridge) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Apply relevant bridge roles and such to the parking channel */
|
|
|
|
parking_channel_set_roles(parkee, lot, use_ringing);
|
|
|
|
setup_park_common_datastore(parkee, ast_channel_uniqueid(parker), comeback_override, randomize, time_limit,
|
|
|
|
silence_announcements);
|
|
|
|
return parking_bridge;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct ast_bridge *park_application_setup(struct ast_channel *parkee, struct ast_channel *parker, const char *app_data,
|
|
|
|
int *silence_announcements)
|
|
|
|
{
|
|
|
|
int use_ringing = 0;
|
|
|
|
int randomize = 0;
|
|
|
|
int time_limit = -1;
|
|
|
|
|
|
|
|
RAII_VAR(char *, comeback_override, NULL, ast_free);
|
|
|
|
RAII_VAR(char *, lot_name_app_arg, NULL, ast_free);
|
|
|
|
|
|
|
|
if (app_data) {
|
|
|
|
park_app_parse_data(app_data, silence_announcements, &use_ringing, &randomize, &time_limit, &comeback_override, &lot_name_app_arg);
|
2013-05-21 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
2013-06-25 22:28:22 +00:00
|
|
|
return park_common_setup(parkee, parker, lot_name_app_arg, comeback_override, use_ringing,
|
|
|
|
randomize, time_limit, silence_announcements ? *silence_announcements : 0);
|
|
|
|
|
2013-05-21 18:00:22 +00:00
|
|
|
}
|
|
|
|
|
2013-08-17 15:01:54 +00:00
|
|
|
static int park_app_exec(struct ast_channel *chan, const char *data)
|
2013-05-21 18:00:22 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct ast_bridge *, parking_bridge, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
struct ast_bridge_features chan_features;
|
|
|
|
int res;
|
|
|
|
int silence_announcements = 0;
|
2013-07-04 18:46:56 +00:00
|
|
|
const char *transferer;
|
2013-05-21 18:00:22 +00:00
|
|
|
|
2013-06-28 19:22:16 +00:00
|
|
|
/* Answer the channel if needed */
|
|
|
|
if (ast_channel_state(chan) != AST_STATE_UP) {
|
|
|
|
ast_answer(chan);
|
|
|
|
}
|
|
|
|
|
2013-05-21 18:00:22 +00:00
|
|
|
ast_channel_lock(chan);
|
2013-07-04 18:46:56 +00:00
|
|
|
if (!(transferer = pbx_builtin_getvar_helper(chan, "ATTENDEDTRANSFER"))) {
|
|
|
|
transferer = pbx_builtin_getvar_helper(chan, "BLINDTRANSFER");
|
2013-05-21 18:00:22 +00:00
|
|
|
}
|
2013-07-04 18:46:56 +00:00
|
|
|
transferer = ast_strdupa(S_OR(transferer, ""));
|
2013-05-21 18:00:22 +00:00
|
|
|
ast_channel_unlock(chan);
|
|
|
|
|
|
|
|
/* Handle the common parking setup stuff */
|
2013-07-04 18:46:56 +00:00
|
|
|
if (!(parking_bridge = park_application_setup(chan, NULL, data, &silence_announcements))) {
|
|
|
|
if (!silence_announcements && !transferer) {
|
2013-05-21 18:00:22 +00:00
|
|
|
ast_stream_and_wait(chan, "pbx-parkingfailed", "");
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize bridge features for the channel. */
|
|
|
|
res = ast_bridge_features_init(&chan_features);
|
|
|
|
if (res) {
|
|
|
|
ast_bridge_features_cleanup(&chan_features);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now for the fun part... park it! */
|
|
|
|
ast_bridge_join(parking_bridge, chan, NULL, &chan_features, NULL, 0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the bridge was broken for a hangup that isn't real, then
|
|
|
|
* don't run the h extension, because the channel isn't really
|
|
|
|
* hung up. This should only happen with AST_SOFTHANGUP_ASYNCGOTO.
|
|
|
|
*/
|
|
|
|
res = -1;
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
if (ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO) {
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
|
|
|
|
ast_bridge_features_cleanup(&chan_features);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Retrieve a parked call */
|
|
|
|
|
2013-08-17 15:01:54 +00:00
|
|
|
static int parked_call_app_exec(struct ast_channel *chan, const char *data)
|
2013-05-21 18:00:22 +00:00
|
|
|
{
|
|
|
|
RAII_VAR(struct parking_lot *, lot, NULL, ao2_cleanup);
|
|
|
|
RAII_VAR(struct parked_user *, pu, NULL, ao2_cleanup); /* Parked user being retrieved */
|
|
|
|
struct ast_bridge *retrieval_bridge;
|
|
|
|
int res;
|
|
|
|
int target_space = -1;
|
|
|
|
struct ast_bridge_features chan_features;
|
|
|
|
char *parse;
|
|
|
|
char *lot_name;
|
|
|
|
|
|
|
|
AST_DECLARE_APP_ARGS(args,
|
|
|
|
AST_APP_ARG(lot_name);
|
|
|
|
AST_APP_ARG(parking_space);
|
|
|
|
AST_APP_ARG(other); /* Any remaining unused arguments */
|
|
|
|
);
|
|
|
|
|
|
|
|
parse = ast_strdupa(data);
|
|
|
|
AST_STANDARD_APP_ARGS(args, parse);
|
|
|
|
|
|
|
|
/* Answer the channel if needed */
|
|
|
|
if (ast_channel_state(chan) != AST_STATE_UP) {
|
|
|
|
ast_answer(chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
lot_name = args.lot_name;
|
|
|
|
|
|
|
|
/* If the name of the parking lot isn't in the arguments, find it based on the channel. */
|
|
|
|
if (ast_strlen_zero(lot_name)) {
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
lot_name = ast_strdupa(find_channel_parking_lot_name(chan));
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
}
|
|
|
|
|
|
|
|
lot = parking_lot_find_by_name(lot_name);
|
|
|
|
|
|
|
|
if (!lot) {
|
|
|
|
ast_log(LOG_ERROR, "Could not find the requested parking lot\n");
|
|
|
|
ast_stream_and_wait(chan, "pbx-invalidpark", "");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(args.parking_space)) {
|
|
|
|
if (sscanf(args.parking_space, "%d", &target_space) != 1 || target_space < 0) {
|
|
|
|
ast_stream_and_wait(chan, "pbx-invalidpark", "");
|
|
|
|
ast_log(LOG_ERROR, "value '%s' for parking_space argument is invalid. Must be an integer greater than 0.\n", args.parking_space);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Attempt to get the parked user from the parking lot */
|
|
|
|
pu = parking_lot_retrieve_parked_user(lot, target_space);
|
|
|
|
if (!pu) {
|
|
|
|
ast_stream_and_wait(chan, "pbx-invalidpark", "");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The parked call needs to know who is retrieving it before we move it out of the parking bridge */
|
|
|
|
pu->retriever = ast_channel_snapshot_create(chan);
|
|
|
|
|
|
|
|
/* Create bridge */
|
|
|
|
retrieval_bridge = ast_bridge_basic_new();
|
|
|
|
if (!retrieval_bridge) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move the parkee into the new bridge */
|
|
|
|
if (ast_bridge_move(retrieval_bridge, lot->parking_bridge, pu->chan, NULL, 0)) {
|
2013-08-22 21:09:52 +00:00
|
|
|
ast_bridge_destroy(retrieval_bridge, 0);
|
2013-05-21 18:00:22 +00:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize our bridge features */
|
|
|
|
res = ast_bridge_features_init(&chan_features);
|
|
|
|
if (res) {
|
2013-08-22 21:09:52 +00:00
|
|
|
ast_bridge_destroy(retrieval_bridge, 0);
|
2013-05-21 18:00:22 +00:00
|
|
|
ast_bridge_features_cleanup(&chan_features);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the features */
|
|
|
|
parked_call_retrieve_enable_features(chan, lot, AST_FEATURE_FLAG_BYCALLER);
|
|
|
|
|
|
|
|
/* If the parkedplay option is set for the caller to hear, play that tone now. */
|
|
|
|
if (lot->cfg->parkedplay & AST_FEATURE_FLAG_BYCALLER) {
|
|
|
|
ast_stream_and_wait(chan, lot->cfg->courtesytone, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now we should try to join the new bridge ourselves... */
|
2013-09-13 22:19:23 +00:00
|
|
|
ast_bridge_join(retrieval_bridge, chan, NULL, &chan_features, NULL,
|
|
|
|
AST_BRIDGE_JOIN_PASS_REFERENCE);
|
2013-05-21 18:00:22 +00:00
|
|
|
|
|
|
|
ast_bridge_features_cleanup(&chan_features);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct park_announce_subscription_data {
|
|
|
|
char *parkee_uuid;
|
|
|
|
char *dial_string;
|
|
|
|
char *announce_string;
|
|
|
|
};
|
|
|
|
|
|
|
|
static void park_announce_subscription_data_destroy(void *data)
|
|
|
|
{
|
|
|
|
struct park_announce_subscription_data *pa_data = data;
|
|
|
|
ast_free(pa_data->parkee_uuid);
|
|
|
|
ast_free(pa_data->dial_string);
|
|
|
|
ast_free(pa_data->announce_string);
|
|
|
|
ast_free(pa_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct park_announce_subscription_data *park_announce_subscription_data_create(const char *parkee_uuid,
|
|
|
|
const char *dial_string,
|
|
|
|
const char *announce_string)
|
|
|
|
{
|
|
|
|
struct park_announce_subscription_data *pa_data;
|
|
|
|
|
|
|
|
if (!(pa_data = ast_calloc(1, sizeof(*pa_data)))) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(pa_data->parkee_uuid = ast_strdup(parkee_uuid))
|
|
|
|
|| !(pa_data->dial_string = ast_strdup(dial_string))
|
|
|
|
|| !(pa_data->announce_string = ast_strdup(announce_string))) {
|
|
|
|
park_announce_subscription_data_destroy(pa_data);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return pa_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void announce_to_dial(char *dial_string, char *announce_string, int parkingspace, struct ast_channel_snapshot *parkee_snapshot)
|
|
|
|
{
|
|
|
|
struct ast_channel *dchan;
|
|
|
|
struct outgoing_helper oh = { 0, };
|
|
|
|
int outstate;
|
2013-10-03 14:58:16 +00:00
|
|
|
struct ast_format_cap *cap_slin = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_NOLOCK);
|
2013-05-21 18:00:22 +00:00
|
|
|
char buf[13];
|
|
|
|
char *dial_tech;
|
|
|
|
char *cur_announce;
|
|
|
|
struct ast_format tmpfmt;
|
|
|
|
|
|
|
|
dial_tech = strsep(&dial_string, "/");
|
|
|
|
ast_verb(3, "Dial Tech,String: (%s,%s)\n", dial_tech, dial_string);
|
|
|
|
|
|
|
|
if (!cap_slin) {
|
|
|
|
ast_log(LOG_WARNING, "PARK: Failed to announce park.\n");
|
|
|
|
goto announce_cleanup;
|
|
|
|
}
|
|
|
|
ast_format_cap_add(cap_slin, ast_format_set(&tmpfmt, AST_FORMAT_SLINEAR, 0));
|
|
|
|
|
|
|
|
snprintf(buf, sizeof(buf), "%d", parkingspace);
|
|
|
|
oh.vars = ast_variable_new("_PARKEDAT", buf, "");
|
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
|
|
|
dchan = __ast_request_and_dial(dial_tech, cap_slin, NULL, NULL, dial_string, 30000,
|
2013-05-21 18:00:22 +00:00
|
|
|
&outstate,
|
|
|
|
parkee_snapshot->caller_number,
|
|
|
|
parkee_snapshot->caller_name,
|
|
|
|
&oh);
|
|
|
|
|
|
|
|
ast_variables_destroy(oh.vars);
|
|
|
|
if (!dchan) {
|
|
|
|
ast_log(LOG_WARNING, "PARK: Unable to allocate announce channel.\n");
|
|
|
|
goto announce_cleanup;
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_verb(4, "Announce Template: %s\n", announce_string);
|
|
|
|
|
|
|
|
for (cur_announce = strsep(&announce_string, ":"); cur_announce; cur_announce = strsep(&announce_string, ":")) {
|
|
|
|
ast_verb(4, "Announce:%s\n", cur_announce);
|
|
|
|
if (!strcmp(cur_announce, "PARKED")) {
|
|
|
|
ast_say_digits(dchan, parkingspace, "", ast_channel_language(dchan));
|
|
|
|
} else {
|
|
|
|
int dres = ast_streamfile(dchan, cur_announce, ast_channel_language(dchan));
|
|
|
|
if (!dres) {
|
|
|
|
dres = ast_waitstream(dchan, "");
|
|
|
|
} else {
|
|
|
|
ast_log(LOG_WARNING, "ast_streamfile of %s failed on %s\n", cur_announce, ast_channel_name(dchan));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ast_stopstream(dchan);
|
|
|
|
ast_hangup(dchan);
|
|
|
|
|
|
|
|
announce_cleanup:
|
|
|
|
cap_slin = ast_format_cap_destroy(cap_slin);
|
|
|
|
}
|
|
|
|
|
Multiple revisions 399887,400138,400178,400180-400181
........
r399887 | dlee | 2013-09-26 10:41:47 -0500 (Thu, 26 Sep 2013) | 1 line
Minor performance bump by not allocate manager variable struct if we don't need it
........
r400138 | dlee | 2013-09-30 10:24:00 -0500 (Mon, 30 Sep 2013) | 23 lines
Stasis performance improvements
This patch addresses several performance problems that were found in
the initial performance testing of Asterisk 12.
The Stasis dispatch object was allocated as an AO2 object, even though
it has a very confined lifecycle. This was replaced with a straight
ast_malloc().
The Stasis message router was spending an inordinate amount of time
searching hash tables. In this case, most of our routers had 6 or
fewer routes in them to begin with. This was replaced with an array
that's searched linearly for the route.
We more heavily rely on AO2 objects in Asterisk 12, and the memset()
in ao2_ref() actually became noticeable on the profile. This was
#ifdef'ed to only run when AO2_DEBUG was enabled.
After being misled by an erroneous comment in taskprocessor.c during
profiling, the wrong comment was removed.
Review: https://reviewboard.asterisk.org/r/2873/
........
r400178 | dlee | 2013-09-30 13:26:27 -0500 (Mon, 30 Sep 2013) | 24 lines
Taskprocessor optimization; switch Stasis to use taskprocessors
This patch optimizes taskprocessor to use a semaphore for signaling,
which the OS can do a better job at managing contention and waiting
that we can with a mutex and condition.
The taskprocessor execution was also slightly optimized to reduce the
number of locks taken.
The only observable difference in the taskprocessor implementation is
that when the final reference to the taskprocessor goes away, it will
execute all tasks to completion instead of discarding the unexecuted
tasks.
For systems where unnamed semaphores are not supported, a really
simple semaphore implementation is provided. (Which gives identical
performance as the original taskprocessor implementation).
The way we ended up implementing Stasis caused the threadpool to be a
burden instead of a boost to performance. This was switched to just
use taskprocessors directly for subscriptions.
Review: https://reviewboard.asterisk.org/r/2881/
........
r400180 | dlee | 2013-09-30 13:39:34 -0500 (Mon, 30 Sep 2013) | 28 lines
Optimize how Stasis forwards are dispatched
This patch optimizes how forwards are dispatched in Stasis.
Originally, forwards were dispatched as subscriptions that are invoked
on the publishing thread. This did not account for the vast number of
forwards we would end up having in the system, and the amount of work it
would take to walk though the forward subscriptions.
This patch modifies Stasis so that rather than walking the tree of
forwards on every dispatch, when forwards and subscriptions are changed,
the subscriber list for every topic in the tree is changed.
This has a couple of benefits. First, this reduces the workload of
dispatching messages. It also reduces contention when dispatching to
different topics that happen to forward to the same aggregation topic
(as happens with all of the channel, bridge and endpoint topics).
Since forwards are no longer subscriptions, the bulk of this patch is
simply changing stasis_subscription objects to stasis_forward objects
(which, admittedly, I should have done in the first place.)
Since this required me to yet again put in a growing array, I finally
abstracted that out into a set of ast_vector macros in
asterisk/vector.h.
Review: https://reviewboard.asterisk.org/r/2883/
........
r400181 | dlee | 2013-09-30 13:48:57 -0500 (Mon, 30 Sep 2013) | 28 lines
Remove dispatch object allocation from Stasis publishing
While looking for areas for performance improvement, I realized that an
unused feature in Stasis was negatively impacting performance.
When a message is sent to a subscriber, a dispatch object is allocated
for the dispatch, containing the topic the message was published to, the
subscriber the message is being sent to, and the message itself.
The topic is actually unused by any subscriber in Asterisk today. And
the subscriber is associated with the taskprocessor the message is being
dispatched to.
First, this patch removes the unused topic parameter from Stasis
subscription callbacks.
Second, this patch introduces the concept of taskprocessor local data,
data that may be set on a taskprocessor and provided along with the data
pointer when a task is pushed using the ast_taskprocessor_push_local()
call. This allows the task to have both data specific to that
taskprocessor, in addition to data specific to that invocation.
With those two changes, the dispatch object can be removed completely,
and the message is simply refcounted and sent directly to the
taskprocessor.
Review: https://reviewboard.asterisk.org/r/2884/
........
Merged revisions 399887,400138,400178,400180-400181 from http://svn.asterisk.org/svn/asterisk/branches/12
git-svn-id: https://origsvn.digium.com/svn/asterisk/trunk@400186 65c4cc65-6c06-0410-ace0-fbb531ad65f3
2013-09-30 18:55:27 +00:00
|
|
|
static void park_announce_update_cb(void *data, struct stasis_subscription *sub, struct stasis_message *message)
|
2013-05-21 18:00:22 +00:00
|
|
|
{
|
|
|
|
struct park_announce_subscription_data *pa_data = data;
|
|
|
|
char *dial_string = pa_data->dial_string;
|
|
|
|
|
|
|
|
struct ast_parked_call_payload *payload = stasis_message_data(message);
|
|
|
|
|
|
|
|
if (stasis_subscription_final_message(sub, message)) {
|
|
|
|
park_announce_subscription_data_destroy(data);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (payload->event_type != PARKED_CALL) {
|
|
|
|
/* We are only concerned with calls parked */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(payload->parkee->uniqueid, pa_data->parkee_uuid)) {
|
|
|
|
/* We are only concerned with the parkee we are subscribed for. */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ast_strlen_zero(dial_string)) {
|
|
|
|
announce_to_dial(dial_string, pa_data->announce_string, payload->parkingspace, payload->parkee);
|
|
|
|
}
|
|
|
|
|
|
|
|
*dial_string = '\0'; /* If we observe this dial string on a second pass, we don't want to do anything with it. */
|
|
|
|
}
|
|
|
|
|
2013-08-17 15:01:54 +00:00
|
|
|
static int park_and_announce_app_exec(struct ast_channel *chan, const char *data)
|
2013-05-21 18:00:22 +00:00
|
|
|
{
|
|
|
|
struct ast_bridge_features chan_features;
|
|
|
|
char *parse;
|
|
|
|
int res;
|
|
|
|
int silence_announcements = 1;
|
|
|
|
|
|
|
|
struct stasis_subscription *parking_subscription;
|
|
|
|
struct park_announce_subscription_data *pa_data;
|
|
|
|
|
|
|
|
RAII_VAR(struct ast_bridge *, parking_bridge, NULL, ao2_cleanup);
|
|
|
|
|
|
|
|
AST_DECLARE_APP_ARGS(args,
|
|
|
|
AST_APP_ARG(lot_name);
|
|
|
|
AST_APP_ARG(options);
|
|
|
|
AST_APP_ARG(announce_template);
|
|
|
|
AST_APP_ARG(dial);
|
|
|
|
AST_APP_ARG(others);/* Any remaining unused arguments */
|
|
|
|
);
|
|
|
|
|
|
|
|
if (ast_strlen_zero(data)) {
|
|
|
|
ast_log(LOG_ERROR, "ParkAndAnnounce has required arguments. No arguments were provided.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
parse = ast_strdupa(data);
|
|
|
|
AST_STANDARD_APP_ARGS(args, parse);
|
|
|
|
|
|
|
|
if (ast_strlen_zero(args.announce_template)) {
|
|
|
|
/* improperly configured arguments for the application */
|
|
|
|
ast_log(LOG_ERROR, "ParkAndAnnounce requires the announce_template argument.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_strlen_zero(args.dial)) {
|
|
|
|
/* improperly configured arguments */
|
|
|
|
ast_log(LOG_ERROR, "ParkAndAnnounce requires the dial argument.\n");
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!strchr(args.dial, '/')) {
|
|
|
|
ast_log(LOG_ERROR, "ParkAndAnnounce dial string '%s' is improperly formed.\n", args.dial);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Handle the common parking setup stuff */
|
2013-07-04 18:46:56 +00:00
|
|
|
if (!(parking_bridge = park_application_setup(chan, NULL, data, &silence_announcements))) {
|
2013-05-21 18:00:22 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Initialize bridge features for the channel. */
|
|
|
|
res = ast_bridge_features_init(&chan_features);
|
|
|
|
if (res) {
|
|
|
|
ast_bridge_features_cleanup(&chan_features);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* subscribe to the parking message so that we can announce once it is parked */
|
|
|
|
pa_data = park_announce_subscription_data_create(ast_channel_uniqueid(chan), args.dial, args.announce_template);
|
|
|
|
if (!pa_data) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(parking_subscription = stasis_subscribe(ast_parking_topic(), park_announce_update_cb, pa_data))) {
|
|
|
|
/* Failed to create subscription */
|
|
|
|
park_announce_subscription_data_destroy(pa_data);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Now for the fun part... park it! */
|
|
|
|
ast_bridge_join(parking_bridge, chan, NULL, &chan_features, NULL, 0);
|
|
|
|
|
|
|
|
/* Toss the subscription since we aren't bridged at this point. */
|
|
|
|
stasis_unsubscribe(parking_subscription);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the bridge was broken for a hangup that isn't real, then
|
|
|
|
* don't run the h extension, because the channel isn't really
|
|
|
|
* hung up. This should only happen with AST_SOFTHANGUP_ASYNCGOTO.
|
|
|
|
*/
|
|
|
|
res = -1;
|
|
|
|
|
|
|
|
ast_channel_lock(chan);
|
|
|
|
if (ast_channel_softhangup_internal_flag(chan) & AST_SOFTHANGUP_ASYNCGOTO) {
|
|
|
|
res = 0;
|
|
|
|
}
|
|
|
|
ast_channel_unlock(chan);
|
|
|
|
|
|
|
|
ast_bridge_features_cleanup(&chan_features);
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
2013-08-17 15:01:54 +00:00
|
|
|
|
|
|
|
int load_parking_applications(void)
|
|
|
|
{
|
|
|
|
const struct ast_module_info *ast_module_info = parking_get_module_info();
|
|
|
|
|
|
|
|
if (ast_register_application_xml(PARK_APPLICATION, park_app_exec)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_register_application_xml(PARKED_CALL_APPLICATION, parked_call_app_exec)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ast_register_application_xml(PARK_AND_ANNOUNCE_APPLICATION, park_and_announce_app_exec)) {
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void unload_parking_applications(void)
|
|
|
|
{
|
|
|
|
ast_unregister_application(PARK_APPLICATION);
|
|
|
|
ast_unregister_application(PARKED_CALL_APPLICATION);
|
|
|
|
ast_unregister_application(PARK_AND_ANNOUNCE_APPLICATION);
|
|
|
|
}
|