parking_applications.c File Reference

Call Parking Applications. More...

#include "asterisk.h"
#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"
#include "asterisk/bridge_basic.h"
#include "asterisk/format_cache.h"

Include dependency graph for parking_applications.c:

Go to the source code of this file.

Data Structures
struct	park_announce_subscription_data

Macros
#define	PARK_AND_ANNOUNCE_APPLICATION   "ParkAndAnnounce"

Enumerations
enum	park_args { OPT_ARG_COMEBACK , OPT_ARG_TIMEOUT , OPT_ARG_MUSICONHOLD , OPT_ARG_ARRAY_SIZE }
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) , MUXFLAG_MUSICONHOLD = (1 << 5) }

Functions
static void	announce_to_dial (char *dial_string, char *announce_string, int parkingspace, struct ast_channel_snapshot *parkee_snapshot)
static int	apply_option_timeout (int *var, char *timeout_arg)
struct park_common_datastore *	get_park_common_datastore_copy (struct ast_channel *parkee)
	Get a copy of the park_common_datastore from a channel that is being parked. More...
static void	inherit_channel_vars_from_id (struct outgoing_helper *oh, const char *channel_id)
int	load_parking_applications (void)
	Register parking applications. More...
static int	park_and_announce_app_exec (struct ast_channel *chan, const char *data)
static struct park_announce_subscription_data *	park_announce_subscription_data_create (const char *parkee_uuid, const char *dial_string, const char *announce_string)
static void	park_announce_subscription_data_destroy (void *data)
static void	park_announce_update_cb (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	park_app_exec (struct ast_channel *chan, const char *data)
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 **musicclass)
struct ast_bridge *	park_application_setup (struct ast_channel *parkee, struct ast_channel *parker, const char *app_data, int *silence_announcements)
	Function to prepare a channel for parking by determining which parking bridge should be used, setting up a park common datastore so that the parking bridge will have access to necessary parking information when joining, and applying various bridge roles to the channel. More...
static void	park_common_datastore_destroy (void *data)
void	park_common_datastore_free (struct park_common_datastore *datastore)
	Free a park common datastore struct. More...
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)
	Setup a parked call on a parking bridge without needing to parse appdata. More...
static struct ast_bridge *	park_common_setup2 (struct ast_channel *parkee, struct ast_channel *parker, const char *lot_name, const char *comeback_override, const char *musicclass, int use_ringing, int randomize, int time_limit, int silence_announcements)
static int	parked_call_app_exec (struct ast_channel *chan, const char *data)
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)
void	unload_parking_applications (void)
	Unregister parking applications. More...
static void	wipe_park_common_datastore (struct ast_channel *chan)

Variables
static const struct ast_datastore_info	park_common_info
static const struct ast_app_option	park_opts [128] = { [ 'r' ] = { .flag = MUXFLAG_RINGING }, [ 'R' ] = { .flag = MUXFLAG_RANDOMIZE }, [ 's' ] = { .flag = MUXFLAG_NOANNOUNCE }, [ 'c' ] = { .flag = MUXFLAG_COMEBACK_OVERRIDE , .arg_index = OPT_ARG_COMEBACK + 1 }, [ 't' ] = { .flag = MUXFLAG_TIMEOUT_OVERRIDE , .arg_index = OPT_ARG_TIMEOUT + 1 }, [ 'm' ] = { .flag = MUXFLAG_MUSICONHOLD , .arg_index = OPT_ARG_MUSICONHOLD + 1 }, }

Detailed Description

Call Parking Applications.

Author

Jonathan Rose jrose.nosp@m.@dig.nosp@m.ium.c.nosp@m.om

Definition in file parking_applications.c.

Macro Definition Documentation

PARK_AND_ANNOUNCE_APPLICATION

#define PARK_AND_ANNOUNCE_APPLICATION   "ParkAndAnnounce"

Definition at line 246 of file parking_applications.c.

Enumeration Type Documentation

park_args

enum park_args

Enumerator
OPT_ARG_COMEBACK
OPT_ARG_TIMEOUT
OPT_ARG_MUSICONHOLD
OPT_ARG_ARRAY_SIZE

Definition at line 250 of file parking_applications.c.

               {
    OPT_ARG_COMEBACK,
    OPT_ARG_TIMEOUT,
    OPT_ARG_MUSICONHOLD,
    OPT_ARG_ARRAY_SIZE /* Always the last element of the enum */
};

park_flags

enum park_flags

Enumerator
MUXFLAG_RINGING
MUXFLAG_RANDOMIZE
MUXFLAG_NOANNOUNCE
MUXFLAG_COMEBACK_OVERRIDE
MUXFLAG_TIMEOUT_OVERRIDE
MUXFLAG_MUSICONHOLD

Definition at line 257 of file parking_applications.c.

                {
    MUXFLAG_RINGING = (1 << 0),
    MUXFLAG_RANDOMIZE = (1 << 1),
    MUXFLAG_NOANNOUNCE = (1 << 2),
    MUXFLAG_COMEBACK_OVERRIDE = (1 << 3),
    MUXFLAG_TIMEOUT_OVERRIDE = (1 << 4),
    MUXFLAG_MUSICONHOLD = (1 << 5),
};

Function Documentation

announce_to_dial()

static void announce_to_dial ( char *  dial_string, char *  announce_string, int  parkingspace, struct ast_channel_snapshot *  parkee_snapshot  )

static

Definition at line 828 of file parking_applications.c.

{
    struct ast_channel *dchan;
    struct outgoing_helper oh = { 0, };
    int outstate;
    struct ast_format_cap *cap_slin = ast_format_cap_alloc(AST_FORMAT_CAP_FLAG_DEFAULT);
    char buf[13];
    char *dial_tech;
    char *cur_announce;
 
    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_append(cap_slin, ast_format_slin, 0);
 
    snprintf(buf, sizeof(buf), "%d", parkingspace);
    oh.vars = ast_variable_new("_PARKEDAT", buf, "");
 
    inherit_channel_vars_from_id(&oh, parkee_snapshot->base->uniqueid);
 
    dchan = __ast_request_and_dial(dial_tech, cap_slin, NULL, NULL, dial_string, 30000,
        &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:
    ao2_cleanup(cap_slin);
}

References __ast_request_and_dial(), ao2_cleanup, ast_channel_language(), ast_channel_name(), ast_format_cap_alloc, ast_format_cap_append, AST_FORMAT_CAP_FLAG_DEFAULT, ast_format_slin, ast_hangup(), ast_log, ast_say_digits(), ast_stopstream(), ast_streamfile(), ast_variable_new, ast_variables_destroy(), ast_verb, ast_waitstream(), ast_channel_snapshot::base, buf, ast_channel_snapshot::caller, inherit_channel_vars_from_id(), LOG_WARNING, ast_channel_snapshot_caller::name, NULL, ast_channel_snapshot_caller::number, strsep(), ast_channel_snapshot_base::uniqueid, and outgoing_helper::vars.

Referenced by park_announce_update_cb().

apply_option_timeout()

static int apply_option_timeout ( int *  var, char *  timeout_arg  )

static

Definition at line 275 of file parking_applications.c.

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

References ast_log, ast_strlen_zero(), LOG_ERROR, and var.

Referenced by park_app_parse_data().

get_park_common_datastore_copy()

struct park_common_datastore * get_park_common_datastore_copy

(

struct ast_channel *

parkee

)

Get a copy of the park_common_datastore from a channel that is being parked.

Since

12.0.0

Parameters

parkee

The channel entering parking with the datastore we are checking

Returns

Pointer to a copy of the park common datastore for parkee if it could be cloned. This needs to be free'd with park_common_datastore free.

Return values

NULL	if the park_common_datastore could not be copied off of the channel.

Definition at line 450 of file parking_applications.c.

{
    struct ast_datastore *datastore;
    struct park_common_datastore *data;
    struct park_common_datastore *data_copy;
 
    SCOPED_CHANNELLOCK(lock, parkee);
 
    if (!(datastore = ast_channel_datastore_find(parkee, &park_common_info, NULL))) {
        return NULL;
    }
 
    data = datastore->data;
 
    /* This data should always be populated if this datastore was appended to the channel */
    ast_assert(data != NULL);
 
    data_copy = ast_calloc(1, sizeof(*data_copy));
    if (!data_copy) {
        return NULL;
    }
 
    data_copy->parker_uuid = ast_strdup(data->parker_uuid);
    if (!data_copy->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;
 
    if (data->comeback_override) {
        data_copy->comeback_override = ast_strdup(data->comeback_override);
        if (!data_copy->comeback_override) {
            park_common_datastore_free(data_copy);
            return NULL;
        }
    }
 
    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;
}

References ast_assert, ast_calloc, ast_channel_datastore_find(), ast_strdup, park_common_datastore::comeback_override, ast_datastore::data, lock, NULL, park_common_datastore_free(), park_common_info, park_common_datastore::parker_dial_string, park_common_datastore::parker_uuid, park_common_datastore::randomize, SCOPED_CHANNELLOCK, park_common_datastore::silence_announce, and park_common_datastore::time_limit.

Referenced by bridge_parking_push().

inherit_channel_vars_from_id()

static void inherit_channel_vars_from_id ( struct outgoing_helper *  oh, const char *  channel_id  )

static

Definition at line 774 of file parking_applications.c.

{
    struct ast_channel *chan = ast_channel_get_by_name(channel_id);
    struct ast_var_t *current;
    struct ast_variable *newvar;
    const char *varname;
    int vartype;
 
 
    if (!chan) {
        /* Already gone */
        return;
    }
 
    ast_channel_lock(chan);
 
    AST_LIST_TRAVERSE(ast_channel_varshead((struct ast_channel *) chan), current, entries) {
        varname = ast_var_full_name(current);
        if (!varname) {
            continue;
        }
 
        vartype = 0;
        if (varname[0] == '_') {
            vartype = 1;
            if (varname[1] == '_') {
                vartype = 2;
            }
        }
 
        switch (vartype) {
        case 1:
            newvar = ast_variable_new(&varname[1], ast_var_value(current), "");
            break;
        case 2:
            newvar = ast_variable_new(varname, ast_var_value(current), "");
            break;
        default:
            continue;
        }
        if (newvar) {
            ast_debug(1, "Inheriting variable %s from %s.\n",
                newvar->name, ast_channel_name(chan));
            if (oh->vars) {
                newvar->next = oh->vars;
                oh->vars = newvar;
            }
        }
    }
 
    ast_channel_unlock(chan);
    ast_channel_cleanup(chan);
}

References ast_channel_cleanup, ast_channel_get_by_name(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, ast_channel_varshead(), ast_debug, AST_LIST_TRAVERSE, ast_var_full_name(), ast_var_value(), ast_variable_new, current, ast_variable::name, ast_variable::next, and outgoing_helper::vars.

Referenced by announce_to_dial().

load_parking_applications()

int load_parking_applications

(

void

)

Register parking applications.

Since

12.0.0

Return values

0	if successful
-1	on failure

Definition at line 1017 of file parking_applications.c.

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

References ast_register_application_xml, park_and_announce_app_exec(), PARK_AND_ANNOUNCE_APPLICATION, park_app_exec(), PARK_APPLICATION, parked_call_app_exec(), and PARKED_CALL_APPLICATION.

Referenced by load_module().

park_and_announce_app_exec()

static int park_and_announce_app_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 920 of file parking_applications.c.

{
    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 */
    if (!(parking_bridge = park_application_setup(chan, NULL, data, &silence_announcements))) {
        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_pool(ast_parking_topic(), park_announce_update_cb, pa_data))) {
        /* Failed to create subscription */
        park_announce_subscription_data_destroy(pa_data);
        return -1;
    }
 
    stasis_subscription_accept_message_type(parking_subscription, ast_parked_call_type());
    stasis_subscription_accept_message_type(parking_subscription, stasis_subscription_change_type());
    stasis_subscription_set_filter(parking_subscription, STASIS_SUBSCRIPTION_FILTER_SELECTIVE);
 
    /* 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;
}

References ao2_cleanup, args, AST_APP_ARG, ast_bridge_features_cleanup(), ast_bridge_features_init(), ast_bridge_join(), ast_channel_lock, ast_channel_softhangup_internal_flag(), ast_channel_uniqueid(), ast_channel_unlock, AST_DECLARE_APP_ARGS, ast_log, ast_parked_call_type(), ast_parking_topic(), AST_SOFTHANGUP_ASYNCGOTO, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), LOG_ERROR, NULL, options, park_announce_subscription_data_create(), park_announce_subscription_data_destroy(), park_announce_update_cb(), park_application_setup(), parking_subscription, RAII_VAR, stasis_subscribe_pool, stasis_subscription_accept_message_type(), stasis_subscription_change_type(), STASIS_SUBSCRIPTION_FILTER_SELECTIVE, stasis_subscription_set_filter(), and stasis_unsubscribe().

Referenced by load_parking_applications().

park_announce_subscription_data_create()

static struct park_announce_subscription_data * park_announce_subscription_data_create ( const char *  parkee_uuid, const char *  dial_string, const char *  announce_string  )

static

Definition at line 748 of file parking_applications.c.

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

References park_announce_subscription_data::announce_string, ast_calloc, ast_strdup, park_announce_subscription_data::dial_string, NULL, park_announce_subscription_data_destroy(), and park_announce_subscription_data::parkee_uuid.

Referenced by park_and_announce_app_exec().

park_announce_subscription_data_destroy()

static void park_announce_subscription_data_destroy ( void *  data )

static

Definition at line 739 of file parking_applications.c.

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

References park_announce_subscription_data::announce_string, ast_free, park_announce_subscription_data::dial_string, and park_announce_subscription_data::parkee_uuid.

Referenced by park_and_announce_app_exec(), park_announce_subscription_data_create(), and park_announce_update_cb().

park_announce_update_cb()

static void park_announce_update_cb ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 887 of file parking_applications.c.

{
    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 (ast_parked_call_type() != stasis_message_type(message)) {
        return;
    }
 
    if (payload->event_type != PARKED_CALL) {
        /* We are only concerned with calls parked */
        return;
    }
 
    if (strcmp(payload->parkee->base->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. */
}

References park_announce_subscription_data::announce_string, announce_to_dial(), ast_parked_call_type(), ast_strlen_zero(), ast_channel_snapshot::base, park_announce_subscription_data::dial_string, ast_parked_call_payload::event_type, park_announce_subscription_data_destroy(), PARKED_CALL, ast_parked_call_payload::parkee, park_announce_subscription_data::parkee_uuid, ast_parked_call_payload::parkingspace, stasis_message_data(), stasis_message_type(), stasis_subscription_final_message(), sub, and ast_channel_snapshot_base::uniqueid.

Referenced by park_and_announce_app_exec().

park_app_exec()

static int park_app_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 574 of file parking_applications.c.

{
    RAII_VAR(struct ast_bridge *, parking_bridge, NULL, ao2_cleanup);
 
    struct ast_bridge_features chan_features;
    int res = 0;
    int silence_announcements = 0;
    int blind_transfer;
 
    /* Answer the channel if needed */
    if (ast_channel_state(chan) != AST_STATE_UP) {
        ast_answer(chan);
    }
 
    ast_channel_lock(chan);
    blind_transfer = !ast_strlen_zero(pbx_builtin_getvar_helper(chan, "BLINDTRANSFER"));
    ast_channel_unlock(chan);
 
    /* Handle the common parking setup stuff */
    if (!(parking_bridge = park_application_setup(chan, NULL, data, &silence_announcements))) {
        if (!silence_announcements && !blind_transfer) {
            ast_stream_and_wait(chan, "pbx-parkingfailed", "");
        }
        publish_parked_call_failure(chan);
        return 0;
    }
 
    /* Initialize bridge features for the channel. */
    res = ast_bridge_features_init(&chan_features);
    /* Now for the fun part... park it! */
    if (res || ast_bridge_join(parking_bridge, chan, NULL, &chan_features, NULL, 0)) {
        if (!silence_announcements && !blind_transfer) {
            ast_stream_and_wait(chan, "pbx-parkingfailed", "");
        }
        ast_bridge_features_cleanup(&chan_features);
        publish_parked_call_failure(chan);
        return res;
    }
 
    /*
     * 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;
}

References ao2_cleanup, ast_answer(), ast_bridge_features_cleanup(), ast_bridge_features_init(), ast_bridge_join(), ast_channel_lock, ast_channel_softhangup_internal_flag(), ast_channel_unlock, AST_SOFTHANGUP_ASYNCGOTO, AST_STATE_UP, ast_stream_and_wait(), ast_strlen_zero(), NULL, park_application_setup(), pbx_builtin_getvar_helper(), publish_parked_call_failure(), and RAII_VAR.

Referenced by load_parking_applications().

park_app_parse_data()

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 **  musicclass  )

static

Definition at line 290 of file parking_applications.c.

{
    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_MUSICONHOLD)) {
            *musicclass = ast_strdup(opts[OPT_ARG_MUSICONHOLD]);
        }
 
        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;
}

References apply_option_timeout(), args, AST_APP_ARG, ast_app_parse_options(), AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, ast_strdup, ast_strdupa, ast_strlen_zero(), ast_test_flag, ast_flags::flags, MUXFLAG_COMEBACK_OVERRIDE, MUXFLAG_MUSICONHOLD, MUXFLAG_NOANNOUNCE, MUXFLAG_RANDOMIZE, MUXFLAG_RINGING, MUXFLAG_TIMEOUT_OVERRIDE, NULL, OPT_ARG_ARRAY_SIZE, OPT_ARG_COMEBACK, OPT_ARG_MUSICONHOLD, OPT_ARG_TIMEOUT, options, and park_opts.

Referenced by park_application_setup().

park_application_setup()

struct ast_bridge * park_application_setup	(	struct ast_channel *	parkee,
		struct ast_channel *	parker,
		const char *	app_data,
		int *	silence_announcements
	)

Function to prepare a channel for parking by determining which parking bridge should be used, setting up a park common datastore so that the parking bridge will have access to necessary parking information when joining, and applying various bridge roles to the channel.

Since

12.0.0

Parameters

parkee	The channel being prepared for parking
parker	The channel initiating the park; may be the parkee as well. May be NULL.
app_data	arguments supplied to the Park application. May be NULL.
silence_announcements	optional pointer to an integer where we want to store the silence option flag this value should be initialized to 0 prior to calling park_common_setup.

Returns

reference to a parking bridge if successful

Return values

NULL	on failure

Note

ao2_cleanup this reference when you are done using it or you'll cause leaks.

Definition at line 554 of file parking_applications.c.

{
    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);
    RAII_VAR(char *, musicclass, 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, &musicclass);
    }
 
    return park_common_setup2(parkee, parker, lot_name_app_arg, comeback_override, musicclass, use_ringing,
        randomize, time_limit, silence_announcements ? *silence_announcements : 0);
 
}

References ast_free, NULL, park_app_parse_data(), park_common_setup2(), and RAII_VAR.

Referenced by park_and_announce_app_exec(), park_app_exec(), and parking_park_bridge_channel().

park_common_datastore_destroy()

static void park_common_datastore_destroy ( void *  data )

static

Definition at line 356 of file parking_applications.c.

{
    struct park_common_datastore *datastore = data;
    park_common_datastore_free(datastore);
}

References park_common_datastore_free().

park_common_datastore_free()

void park_common_datastore_free

(

struct park_common_datastore *

datastore

)

Free a park common datastore struct.

Since

12.0.0

Parameters

datastore

The park_common_datastore being free'd. (NULL tolerant)

Definition at line 344 of file parking_applications.c.

{
    if (!datastore) {
        return;
    }
 
    ast_free(datastore->parker_uuid);
    ast_free(datastore->parker_dial_string);
    ast_free(datastore->comeback_override);
    ast_free(datastore);
}

References ast_free, park_common_datastore::comeback_override, park_common_datastore::parker_dial_string, and park_common_datastore::parker_uuid.

Referenced by bridge_parking_push(), get_park_common_datastore_copy(), and park_common_datastore_destroy().

park_common_setup()

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
	)

Setup a parked call on a parking bridge without needing to parse appdata.

Since

12.0.0

Definition at line 547 of file parking_applications.c.

{
    return park_common_setup2(parkee, parker, lot_name, comeback_override, NULL, use_ringing, randomize, time_limit, silence_announcements);
}

References NULL, and park_common_setup2().

Referenced by manager_park_unbridged().

park_common_setup2()

static struct ast_bridge * park_common_setup2 ( struct ast_channel *  parkee, struct ast_channel *  parker, const char *  lot_name, const char *  comeback_override, const char *  musicclass, int  use_ringing, int  randomize, int  time_limit, int  silence_announcements  )

static

Definition at line 501 of file parking_applications.c.

{
    struct ast_bridge *parking_bridge;
    RAII_VAR(struct parking_lot *, lot, NULL, ao2_cleanup);
 
    if (!parker) {
        parker = parkee;
    }
 
    /* 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);
    if (!lot) {
        lot = parking_create_dynamic_lot(lot_name, parker);
    }
    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);
 
    if (!parking_bridge) {
        return NULL;
    }
 
    /* Apply relevant bridge roles and such to the parking channel */
    parking_channel_set_roles(parkee, lot, use_ringing);
    /* If requested, override the MOH class */
    if (!ast_strlen_zero(musicclass)) {
        ast_channel_set_bridge_role_option(parkee, "holding_participant", "moh_class", musicclass);
    }
    setup_park_common_datastore(parkee, ast_channel_uniqueid(parker), comeback_override, randomize, time_limit,
        silence_announcements);
    return parking_bridge;
}

References ao2_cleanup, ao2_lock, ao2_unlock, ast_channel_lock, ast_channel_set_bridge_role_option(), ast_channel_uniqueid(), ast_channel_unlock, ast_log, ast_strdupa, ast_strlen_zero(), find_channel_parking_lot_name(), LOG_ERROR, NULL, parking_channel_set_roles(), parking_create_dynamic_lot(), parking_lot_find_by_name(), parking_lot_get_bridge(), RAII_VAR, and setup_park_common_datastore().

Referenced by park_application_setup(), and park_common_setup().

parked_call_app_exec()

static int parked_call_app_exec ( struct ast_channel *  chan, const char *  data  )

static

Definition at line 633 of file parking_applications.c.

{
    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;
    const 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 */
    ast_assert(pu->retriever == NULL);
    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)) {
        ast_bridge_destroy(retrieval_bridge, 0);
        return -1;
    }
 
    /* Initialize our bridge features */
    res = ast_bridge_features_init(&chan_features);
    if (res) {
        ast_bridge_destroy(retrieval_bridge, 0);
        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... */
    ast_bridge_join(retrieval_bridge, chan, NULL, &chan_features, NULL,
        AST_BRIDGE_JOIN_PASS_REFERENCE);
 
    ast_bridge_features_cleanup(&chan_features);
 
    /* Return -1 so that call does not continue in the dialplan. This is to make
     * behavior consistent with Asterisk versions prior to 12.
     */
    return -1;
}

References ao2_cleanup, args, ast_answer(), AST_APP_ARG, ast_assert, ast_bridge_basic_new(), ast_bridge_destroy(), ast_bridge_features_cleanup(), ast_bridge_features_init(), ast_bridge_join(), AST_BRIDGE_JOIN_PASS_REFERENCE, ast_bridge_move(), ast_channel_lock, ast_channel_snapshot_create(), ast_channel_unlock, AST_DECLARE_APP_ARGS, AST_FEATURE_FLAG_BYCALLER, ast_log, AST_STANDARD_APP_ARGS, AST_STATE_UP, ast_strdupa, ast_stream_and_wait(), ast_strlen_zero(), find_channel_parking_lot_name(), LOG_ERROR, NULL, parked_call_retrieve_enable_features(), parking_lot_find_by_name(), parking_lot_retrieve_parked_user(), and RAII_VAR.

Referenced by load_parking_applications().

setup_park_common_datastore()

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  )

static

Definition at line 380 of file parking_applications.c.

{
    struct ast_datastore *datastore = NULL;
    struct park_common_datastore *park_datastore;
    const char *attended_transfer;
    const char *blind_transfer;
    char *parker_dial_string = NULL;
 
    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;
    }
    datastore->data = park_datastore;
 
    park_datastore->parker_uuid = ast_strdup(parker_uuid);
    if (!park_datastore->parker_uuid) {
        ast_datastore_free(datastore);
        return -1;
    }
 
    ast_channel_lock(parkee);
    attended_transfer = pbx_builtin_getvar_helper(parkee, "ATTENDEDTRANSFER");
    blind_transfer = pbx_builtin_getvar_helper(parkee, "BLINDTRANSFER");
    if (!ast_strlen_zero(attended_transfer)) {
        parker_dial_string = ast_strdupa(attended_transfer);
    } else if (!ast_strlen_zero(blind_transfer)) {
        parker_dial_string = ast_strdupa(blind_transfer);
        /* Ensure that attended_transfer is NULL and not an empty string. */
        attended_transfer = NULL;
    }
    ast_channel_unlock(parkee);
 
    if (!ast_strlen_zero(parker_dial_string)) {
        ast_channel_name_to_dial_string(parker_dial_string);
        ast_verb(4, "Setting Parker dial string to %s from %s value\n",
            parker_dial_string,
            attended_transfer ? "ATTENDEDTRANSFER" : "BLINDTRANSFER");
        park_datastore->parker_dial_string = ast_strdup(parker_dial_string);
        if (!park_datastore->parker_dial_string) {
            ast_datastore_free(datastore);
            return -1;
        }
    }
 
    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);
        if (!park_datastore->comeback_override) {
            ast_datastore_free(datastore);
            return -1;
        }
    }
 
 
    ast_channel_lock(parkee);
    ast_channel_datastore_add(parkee, datastore);
    ast_channel_unlock(parkee);
 
    return 0;
}

References ast_calloc, ast_channel_datastore_add(), ast_channel_lock, ast_channel_name_to_dial_string(), ast_channel_unlock, ast_datastore_alloc, ast_datastore_free(), ast_strdup, ast_strdupa, ast_strlen_zero(), ast_verb, park_common_datastore::comeback_override, ast_datastore::data, NULL, park_common_info, park_common_datastore::parker_dial_string, park_common_datastore::parker_uuid, pbx_builtin_getvar_helper(), park_common_datastore::randomize, park_common_datastore::silence_announce, park_common_datastore::time_limit, and wipe_park_common_datastore().

Referenced by park_common_setup2().

unload_parking_applications()

void unload_parking_applications

(

void

)

Unregister parking applications.

Since

12.0.0

Definition at line 1034 of file parking_applications.c.

{
    ast_unregister_application(PARK_APPLICATION);
    ast_unregister_application(PARKED_CALL_APPLICATION);
    ast_unregister_application(PARK_AND_ANNOUNCE_APPLICATION);
}

References ast_unregister_application(), PARK_AND_ANNOUNCE_APPLICATION, PARK_APPLICATION, and PARKED_CALL_APPLICATION.

Referenced by unload_module().

wipe_park_common_datastore()

static void wipe_park_common_datastore ( struct ast_channel *  chan )

static

Definition at line 367 of file parking_applications.c.

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

References ast_channel_datastore_find(), ast_channel_datastore_remove(), ast_channel_lock, ast_channel_unlock, ast_datastore_free(), NULL, and park_common_info.

Referenced by setup_park_common_datastore().

Variable Documentation

park_common_info

const struct ast_datastore_info park_common_info

static

Initial value:

= {
    .type = "park entry data",
    .destroy = park_common_datastore_destroy,
}

Definition at line 362 of file parking_applications.c.

Referenced by get_park_common_datastore_copy(), setup_park_common_datastore(), and wipe_park_common_datastore().

park_opts

const struct ast_app_option park_opts[128] = { [ 'r' ] = { .flag = MUXFLAG_RINGING }, [ 'R' ] = { .flag = MUXFLAG_RANDOMIZE }, [ 's' ] = { .flag = MUXFLAG_NOANNOUNCE }, [ 'c' ] = { .flag = MUXFLAG_COMEBACK_OVERRIDE , .arg_index = OPT_ARG_COMEBACK + 1 }, [ 't' ] = { .flag = MUXFLAG_TIMEOUT_OVERRIDE , .arg_index = OPT_ARG_TIMEOUT + 1 }, [ 'm' ] = { .flag = MUXFLAG_MUSICONHOLD , .arg_index = OPT_ARG_MUSICONHOLD + 1 }, }

static

Definition at line 273 of file parking_applications.c.

Referenced by park_app_parse_data().