res_parking.h File Reference

Call Parking Resource Internal API. More...

#include "asterisk/pbx.h"
#include "asterisk/bridge.h"
#include "asterisk/parking.h"
#include "asterisk/stasis_channels.h"

Include dependency graph for res_parking.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	park_common_datastore
struct	parked_user
struct	parking_lot
struct	parking_lot_cfg

Macros
#define	BASE_REGISTRAR   "res_parking"
#define	DEFAULT_PARKING_EXTEN   "700"
#define	DEFAULT_PARKING_LOT   "default"
#define	PARK_DIAL_CONTEXT   "park-dial"
#define	PARKED_CALL_APPLICATION   "ParkedCall"

Enumerations
enum	park_call_resolution {   PARK_UNSET = 0 , PARK_ABANDON , PARK_TIMEOUT , PARK_FORCED ,   PARK_ANSWERED }
enum	parked_call_feature_options {   OPT_PARKEDPLAY = 0 , OPT_PARKEDTRANSFERS , OPT_PARKEDREPARKING , OPT_PARKEDHANGUP ,   OPT_PARKEDRECORDING }
enum	parking_lot_modes { PARKINGLOT_NORMAL = 0 , PARKINGLOT_DYNAMIC , PARKINGLOT_DISABLED }

Functions
struct ast_bridge *	bridge_parking_new (struct parking_lot *bridge_lot)
	Create a new parking bridge. More...
int	comeback_goto (struct parked_user *pu, struct parking_lot *lot)
	Set a channel's position in the PBX after timeout using the parking lot settings. More...
int	create_parked_subscription (struct ast_channel *chan, const char *parkee_uuid, int hangup_after)
	Create a parking announcement subscription. More...
const char *	find_channel_parking_lot_name (struct ast_channel *chan)
	Find parking lot name from channel. More...
void	flatten_dial_string (char *dialstring)
	Flattens a dial string so that it can be written to/found from PBX extensions. More...
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...
struct ao2_container *	get_parking_lot_container (void)
	Get a pointer to the parking lot container for purposes such as iteration. More...
int	load_parking_applications (void)
	Register parking applications. More...
int	load_parking_bridge_features (void)
	Register bridge features for parking. More...
int	load_parking_devstate (void)
	Register Parking devstate handler. More...
int	load_parking_manager (void)
	Register manager actions and setup subscriptions for stasis events. More...
int	load_parking_tests (void)
	Register parking unit tests. More...
int	load_parking_ui (void)
	Register CLI commands. More...
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...
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...
void	parked_call_retrieve_enable_features (struct ast_channel *chan, struct parking_lot *lot, int recipient_mode)
	Apply features based on the parking lot feature options. More...
int	parking_channel_set_roles (struct ast_channel *chan, struct parking_lot *lot, int force_ringing)
	Set necessary bridge roles on a channel that is about to enter a parking lot. More...
struct parking_lot *	parking_create_dynamic_lot (const char *name, struct ast_channel *chan)
	Create a dynamic parking lot. More...
int	parking_dynamic_lots_enabled (void)
	Check global configuration to see if dynamic parking is enabled. More...
struct parking_lot *	parking_lot_build_or_update (struct parking_lot_cfg *cfg, int dynamic)
	If a parking lot exists in the parking lot list already, update its status to match the provided configuration and return a reference return a reference to it. Otherwise, create a parking lot struct based on a parking lot configuration and return a reference to the new one. More...
int	parking_lot_cfg_create_extensions (struct parking_lot_cfg *lot_cfg)
	Add extensions for a parking lot configuration. More...
void	parking_lot_cfg_remove_extensions (struct parking_lot_cfg *lot_cfg)
	Remove extensions belonging to a parking lot configuration. More...
struct parking_lot *	parking_lot_find_by_name (const char *lot_name)
	Find a parking lot based on its name. More...
struct ast_bridge *	parking_lot_get_bridge (struct parking_lot *lot)
	Get a reference to a parking lot's bridge. If it doesn't exist, create it and get a reference. More...
int	parking_lot_get_space (struct parking_lot *lot, int target_override)
	Get an available parking space within a parking lot. More...
struct parked_user *	parking_lot_inspect_parked_user (struct parking_lot *lot, int target)
	Determine if there is a parked user in a parking space and return it if there is. More...
int	parking_lot_remove_if_unused (struct parking_lot *lot)
	Remove a parking lot from the usable lists if it is no longer involved in any calls and no configuration currently claims it. More...
struct parked_user *	parking_lot_retrieve_parked_user (struct parking_lot *lot, int target)
	Determine if there is a parked user in a parking space and pull it from the parking lot if there is. More...
void	parking_notify_metermaids (int exten, const char *context, enum ast_device_state state)
	Notify metermaids that we've changed an extension. More...
void	parking_set_duration (struct ast_bridge_features *features, struct parked_user *user)
	Setup timeout interval feature on an ast_bridge_features for parking. More...
void	publish_parked_call (struct parked_user *pu, enum ast_parked_call_event_type event_type)
	Publish a stasis parked call message for a given parked user. More...
void	publish_parked_call_failure (struct ast_channel *parkee)
	Publish a stasis parked call message for the channel indicating failure to park. More...
void	say_parking_space (struct ast_bridge_channel *bridge_channel, const char *payload)
	custom callback function for ast_bridge_channel_queue_playfile which plays a parking space and optionally hangs up the call afterwards based on the payload in playfile. More...
void	unload_parking_applications (void)
	Unregister parking applications. More...
void	unload_parking_bridge_features (void)
	Unregister features registered by load_parking_bridge_features. More...
void	unload_parking_devstate (void)
	Unregister Parking devstate handler. More...
void	unload_parking_manager (void)
	Unregister manager actions and remove subscriptions for stasis events. More...
void	unload_parking_tests (void)
	Unregister parking unit tests. More...
void	unload_parking_ui (void)
	Unregister CLI commands. More...
int	unpark_parked_user (struct parked_user *user)
	Pull a parked user out of its parking lot. Use this when you don't want to use the parked user afterwards. More...

Detailed Description

Call Parking Resource Internal API.

Author

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

Definition in file res_parking.h.

Macro Definition Documentation

BASE_REGISTRAR

#define BASE_REGISTRAR   "res_parking"

Definition at line 36 of file res_parking.h.

DEFAULT_PARKING_EXTEN

#define DEFAULT_PARKING_EXTEN   "700"

Definition at line 35 of file res_parking.h.

DEFAULT_PARKING_LOT

#define DEFAULT_PARKING_LOT   "default"

Definition at line 34 of file res_parking.h.

PARK_DIAL_CONTEXT

#define PARK_DIAL_CONTEXT   "park-dial"

Definition at line 37 of file res_parking.h.

PARKED_CALL_APPLICATION

#define PARKED_CALL_APPLICATION   "ParkedCall"

Definition at line 38 of file res_parking.h.

Enumeration Type Documentation

park_call_resolution

enum park_call_resolution

Enumerator
PARK_UNSET
PARK_ABANDON	Nothing set a resolution. This should never be observed in practice.
PARK_TIMEOUT	The channel for the parked call hung up
PARK_FORCED	The parked call stayed parked until the parking lot timeout was reached and was removed
PARK_ANSWERED	The parked call was forcibly terminated by an unusual means in Asterisk

Definition at line 40 of file res_parking.h.

                          {
    PARK_UNSET = 0,     /*! Nothing set a resolution. This should never be observed in practice. */
    PARK_ABANDON,       /*! The channel for the parked call hung up */
    PARK_TIMEOUT,       /*! The parked call stayed parked until the parking lot timeout was reached and was removed */
    PARK_FORCED,        /*! The parked call was forcibly terminated by an unusual means in Asterisk */
    PARK_ANSWERED,      /*! The parked call was retrieved successfully */
};

parked_call_feature_options

enum parked_call_feature_options

Enumerator
OPT_PARKEDPLAY
OPT_PARKEDTRANSFERS
OPT_PARKEDREPARKING
OPT_PARKEDHANGUP
OPT_PARKEDRECORDING

Definition at line 48 of file res_parking.h.

                                 {
    OPT_PARKEDPLAY = 0,
    OPT_PARKEDTRANSFERS,
    OPT_PARKEDREPARKING,
    OPT_PARKEDHANGUP,
    OPT_PARKEDRECORDING,
};

parking_lot_modes

enum parking_lot_modes

Enumerator
PARKINGLOT_NORMAL
PARKINGLOT_DYNAMIC	The parking lot is configured normally and can accept new calls. Disable on reload if the config isn't replaced. valid transitions: PARKINGLOT_DISABLED
PARKINGLOT_DISABLED	The parking lot is a dynamically created parking lot. It can be parked to at any time. Disabled on last parked call leaving. valid transitions: PARKINGLOT_DISABLED

Definition at line 56 of file res_parking.h.

                       {
    PARKINGLOT_NORMAL = 0,          /*! The parking lot is configured normally and can accept new calls. Disable on reload if the config isn't replaced.
                                     *  valid transitions: PARKINGLOT_DISABLED */
    PARKINGLOT_DYNAMIC,             /*! The parking lot is a dynamically created parking lot. It can be parked to at any time. Disabled on last parked call leaving.
                                     *  valid transitions: PARKINGLOT_DISABLED */
    PARKINGLOT_DISABLED,            /*! The parking lot is no longer linked to a parking lot in configuration. It can no longer be parked to.
                                     *  and it can not be parked to. This mode has no transitions. */
};

Function Documentation

bridge_parking_new()

struct ast_bridge * bridge_parking_new

(

struct parking_lot *

bridge_lot

)

Create a new parking bridge.

Since

12.0.0

Parameters

bridge_lot

Parking lot which the new bridge should be based on

Return values

NULL	if the bridge can not be created

Returns

Newly created parking bridge

Definition at line 450 of file parking_bridge.c.

{
    void *bridge;
 
    bridge = bridge_alloc(sizeof(struct ast_bridge_parking), &ast_bridge_parking_v_table);
    bridge = bridge_base_init(bridge, AST_BRIDGE_CAPABILITY_HOLDING,
        AST_BRIDGE_FLAG_MERGE_INHIBIT_TO | AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM
        | AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM,  "Parking", bridge_lot->name, NULL);
    bridge = ast_bridge_parking_init(bridge, bridge_lot);
    bridge = bridge_register(bridge);
    return bridge;
}

References AST_BRIDGE_CAPABILITY_HOLDING, AST_BRIDGE_FLAG_MERGE_INHIBIT_FROM, AST_BRIDGE_FLAG_MERGE_INHIBIT_TO, AST_BRIDGE_FLAG_SWAP_INHIBIT_FROM, ast_bridge_parking_init(), ast_bridge_parking_v_table, bridge_alloc(), bridge_base_init(), bridge_register(), parking_lot::name, and NULL.

Referenced by parking_lot_get_bridge().

comeback_goto()

int comeback_goto	(	struct parked_user *	pu,
		struct parking_lot *	lot
	)

Set a channel's position in the PBX after timeout using the parking lot settings.

Since

12.0.0

Parameters

pu	Parked user who is entering/reentering the PBX
lot	Parking lot the user was removed from.

Return values

0	Position set successfully
-1	Failed to set the position

Definition at line 263 of file parking_controller.c.

{
    struct ast_channel *chan = pu->chan;
    char *peername_flat = ast_strdupa(pu->parker_dial_string);
 
    /* Flatten the peername so that it can be used for performing the timeout PBX operations */
    flatten_dial_string(peername_flat);
 
    if (lot->cfg->comebacktoorigin) {
        if (ast_exists_extension(chan, PARK_DIAL_CONTEXT, peername_flat, 1, NULL)) {
            ast_async_goto(chan, PARK_DIAL_CONTEXT, peername_flat, 1);
            return 0;
        } else {
            ast_log(LOG_ERROR, "Can not start %s at %s,%s,1 because extension does not exist. Terminating call.\n",
                ast_channel_name(chan), PARK_DIAL_CONTEXT, peername_flat);
            return -1;
        }
    }
 
    if (ast_exists_extension(chan, lot->cfg->comebackcontext, peername_flat, 1, NULL)) {
        ast_async_goto(chan, lot->cfg->comebackcontext, peername_flat, 1);
        return 0;
    }
 
    if (ast_exists_extension(chan, lot->cfg->comebackcontext, "s", 1, NULL)) {
        ast_verb(2, "Could not start %s at %s,%s,1. Using 's@%s' instead.\n", ast_channel_name(chan),
            lot->cfg->comebackcontext, peername_flat, lot->cfg->comebackcontext);
        ast_async_goto(chan, lot->cfg->comebackcontext, "s", 1);
        return 0;
    }
 
    ast_verb(2, "Can not start %s at %s,%s,1 and exten 's@%s' does not exist. Using 's@default'\n",
        ast_channel_name(chan),
        lot->cfg->comebackcontext, peername_flat, lot->cfg->comebackcontext);
    ast_async_goto(chan, "default", "s", 1);
 
    return 0;
}

References ast_async_goto(), ast_channel_name(), ast_exists_extension(), ast_log, ast_strdupa, ast_verb, parking_lot::cfg, parked_user::chan, parking_lot_cfg::comebackcontext, parking_lot_cfg::comebacktoorigin, flatten_dial_string(), LOG_ERROR, NULL, PARK_DIAL_CONTEXT, and parked_user::parker_dial_string.

Referenced by parking_duration_callback().

create_parked_subscription()

int create_parked_subscription	(	struct ast_channel *	chan,
		const char *	parkee_uuid,
		int	hangup_after
	)

Create a parking announcement subscription.

Since

12.3.0

Parameters

chan	Channel that will receive the announcement
parkee_uuid	Unique ID of the channel being parked
hangup_after	if non-zero, have the channel hangup after hearing the announcement

Return values

0	on success
-1	on failure

Definition at line 236 of file parking_bridge_features.c.

{
    return create_parked_subscription_full(chan, parkee_uuid, hangup_after, NULL);
}

References create_parked_subscription_full(), parked_subscription_data::hangup_after, NULL, and parked_subscription_data::parkee_uuid.

Referenced by manager_park(), and manager_park_bridged().

find_channel_parking_lot_name()

const char * find_channel_parking_lot_name

(

struct ast_channel *

chan

)

Find parking lot name from channel.

Since

12.0.0

Parameters

chan	The channel we want the parking lot name for

Returns

name of the parking lot to use for the channel.

Note

Always returns a parking lot name.

Channel needs to be locked while the returned string is in use.

Definition at line 668 of file res_parking.c.

{
    const char *name;
 
    /* The channel variable overrides everything */
    name = pbx_builtin_getvar_helper(chan, "PARKINGLOT");
    if (ast_strlen_zero(name)) {
        /* Try the channel's parking lot. */
        name = ast_channel_parkinglot(chan);
        if (ast_strlen_zero(name)) {
            /* Fall back to the default parking lot. */
            name = DEFAULT_PARKING_LOT;
        }
    }
 
    return name;
}

References ast_channel_parkinglot(), ast_strlen_zero(), DEFAULT_PARKING_LOT, name, and pbx_builtin_getvar_helper().

Referenced by park_common_setup2(), parked_call_app_exec(), and parking_park_call().

flatten_dial_string()

void flatten_dial_string

(

char *

dialstring

)

Flattens a dial string so that it can be written to/found from PBX extensions.

Since

12.0.0

Parameters

dialstring

unflattened dial string. This will be flattened in place.

Definition at line 251 of file parking_controller.c.

{
    int i;
 
    for (i = 0; dialstring[i]; i++) {
        if (dialstring[i] == '/') {
            /* The underscore is the flattest character of all. */
            dialstring[i] = '_';
        }
    }
}

Referenced by comeback_goto(), and parking_duration_callback().

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().

get_parking_lot_container()

struct ao2_container * get_parking_lot_container

(

void

)

Get a pointer to the parking lot container for purposes such as iteration.

Since

12.0.0

Returns

pointer to the parking lot container.

Definition at line 657 of file res_parking.c.

{
    return parking_lot_container;
}

References parking_lot_container.

Referenced by cli_display_parking_lot_list(), complete_parking_lot(), manager_parking_lot_list(), manager_parking_status_all_lots(), and metermaidstate().

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().

load_parking_bridge_features()

int load_parking_bridge_features

(

void

)

Register bridge features for parking.

Since

12.0.0

Return values

0	on success
-1	on failure

Definition at line 803 of file parking_bridge_features.c.

{
    parking_provider.module = AST_MODULE_SELF;
 
    ast_custom_function_register(&getparkingslotchannel_function);
 
    if (ast_parking_register_bridge_features(&parking_provider)) {
        return -1;
    }
 
    if (ast_bridge_features_register(AST_BRIDGE_BUILTIN_PARKCALL, feature_park_call, NULL)) {
        return -1;
    }
 
    return 0;
}

References AST_BRIDGE_BUILTIN_PARKCALL, ast_bridge_features_register(), ast_custom_function_register, ast_parking_register_bridge_features(), feature_park_call(), getparkingslotchannel_function, ast_parking_bridge_feature_fn_table::module, NULL, and parking_provider.

Referenced by load_module().

load_parking_devstate()

int load_parking_devstate

(

void

)

Register Parking devstate handler.

Since

12.0.0

Definition at line 121 of file parking_devicestate.c.

{
    return ast_devstate_prov_add("Park", metermaidstate);
}

References ast_devstate_prov_add(), and metermaidstate().

Referenced by load_module().

load_parking_manager()

int load_parking_manager

(

void

)

Register manager actions and setup subscriptions for stasis events.

Since

12.0.0

Definition at line 728 of file parking_manager.c.

{
    int res;
 
    res = ast_manager_register_xml("Parkinglots", EVENT_FLAG_CALL, manager_parking_lot_list);
    res |= ast_manager_register_xml("ParkedCalls", EVENT_FLAG_CALL, manager_parking_status);
    res |= ast_manager_register_xml("Park", EVENT_FLAG_CALL, manager_park);
    parking_manager_enable_stasis();
    return res ? -1 : 0;
}

References ast_manager_register_xml, EVENT_FLAG_CALL, manager_park(), manager_parking_lot_list(), manager_parking_status(), and parking_manager_enable_stasis().

Referenced by load_module().

load_parking_tests()

int load_parking_tests

(

void

)

Register parking unit tests.

Since

12.0.0

Return values

0	on success
nonzero	on failure

Definition at line 851 of file parking_tests.c.

{
    int res = 0;
 
/* NOOP without test framework */
#if defined(TEST_FRAMEWORK)
    res |= AST_TEST_REGISTER(create_lot);
    res |= AST_TEST_REGISTER(park_call);
    res |= AST_TEST_REGISTER(retrieve_call);
    res |= AST_TEST_REGISTER(park_extensions);
    res |= AST_TEST_REGISTER(extension_conflicts);
    res |= AST_TEST_REGISTER(dynamic_parking_variables);
#endif
 
    return res;
}

References AST_TEST_REGISTER.

Referenced by load_module().

load_parking_ui()

int load_parking_ui

(

void

)

Register CLI commands.

Since

12.0.0

Return values

0	if successful
-1	on failure

Definition at line 198 of file parking_ui.c.

{
    return ast_cli_register_multiple(cli_parking_lot, ARRAY_LEN(cli_parking_lot));
}

References ARRAY_LEN, ast_cli_register_multiple, and cli_parking_lot.

Referenced by load_module().

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_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().

parked_call_retrieve_enable_features()

void parked_call_retrieve_enable_features	(	struct ast_channel *	chan,
		struct parking_lot *	lot,
		int	recipient_mode
	)

Apply features based on the parking lot feature options.

Since

12.0.0

Parameters

chan	Which channel's feature set is being modified
lot	parking lot which establishes the features used
recipient_mode	AST_FEATURE_FLAG_BYCALLER if the user is the retriever AST_FEATURE_FLAG_BYCALLEE if the user is the parkee

Definition at line 217 of file parking_controller.c.

{
    /* Enabling features here should be additive to features that are already on the channel. */
    struct ast_flags feature_flags = { 0 };
    struct ast_flags *existing_features;
 
    ast_channel_lock(chan);
    existing_features = ast_bridge_features_ds_get(chan);
    if (existing_features) {
        feature_flags = *existing_features;
    }
 
    if (lot->cfg->parkedcalltransfers & recipient_mode) {
        ast_set_flag(&feature_flags, AST_FEATURE_REDIRECT);
    }
 
    if (lot->cfg->parkedcallreparking & recipient_mode) {
        ast_set_flag(&feature_flags, AST_FEATURE_PARKCALL);
    }
 
    if (lot->cfg->parkedcallhangup & recipient_mode) {
        ast_set_flag(&feature_flags, AST_FEATURE_DISCONNECT);
    }
 
    if (lot->cfg->parkedcallrecording & recipient_mode) {
        ast_set_flag(&feature_flags, AST_FEATURE_AUTOMIXMON);
    }
 
    ast_bridge_features_ds_set(chan, &feature_flags);
    ast_channel_unlock(chan);
 
    return;
}

References ast_bridge_features_ds_get(), ast_bridge_features_ds_set(), ast_channel_lock, ast_channel_unlock, AST_FEATURE_AUTOMIXMON, AST_FEATURE_DISCONNECT, AST_FEATURE_PARKCALL, AST_FEATURE_REDIRECT, ast_set_flag, parking_lot::cfg, parking_lot_cfg::parkedcallhangup, parking_lot_cfg::parkedcallrecording, parking_lot_cfg::parkedcallreparking, and parking_lot_cfg::parkedcalltransfers.

Referenced by bridge_parking_pull(), and parked_call_app_exec().

parking_channel_set_roles()

int parking_channel_set_roles	(	struct ast_channel *	chan,
		struct parking_lot *	lot,
		int	force_ringing
	)

Set necessary bridge roles on a channel that is about to enter a parking lot.

Since

12.0.0

Parameters

chan	Entering channel
lot	The parking lot the channel will be entering
force_ringing	Use ringing instead of music on hold

Return values

0	on success
non-zero	on failure

Definition at line 57 of file parking_controller.c.

{
    if (ast_channel_add_bridge_role(chan, "holding_participant")) {
        return -1;
    }
 
    if (force_ringing) {
        if (ast_channel_set_bridge_role_option(chan, "holding_participant", "idle_mode", "ringing")) {
            return -1;
        }
    } else {
        if (ast_channel_set_bridge_role_option(chan, "holding_participant", "idle_mode", "musiconhold")) {
            return -1;
        }
        if (!ast_strlen_zero(lot->cfg->mohclass)) {
            if (ast_channel_set_bridge_role_option(chan, "holding_participant", "moh_class", lot->cfg->mohclass)) {
                return -1;
            }
        }
    }
 
    return 0;
}

References ast_channel_add_bridge_role(), ast_channel_set_bridge_role_option(), ast_strlen_zero(), parking_lot::cfg, and parking_lot_cfg::mohclass.

Referenced by bridge_parking_push(), and park_common_setup2().

parking_create_dynamic_lot()

struct parking_lot * parking_create_dynamic_lot	(	const char *	name,
		struct ast_channel *	chan
	)

Create a dynamic parking lot.

Since

12.0.0

Parameters

name	Dynamic parking lot name to create
chan	Channel parkee to get dynamic parking lot parameters from

Returns

dynamically created parking lot on success

Return values

NULL

on error

Note

This should be called only after verifying that the named parking lot doesn't already exist in a non-dynamic way.

Definition at line 1120 of file res_parking.c.

                                                                                          {
    return create_dynamic_lot_full(name, chan, 0);
}

References create_dynamic_lot_full(), and name.

Referenced by park_common_setup2(), and parking_park_call().

parking_dynamic_lots_enabled()

int parking_dynamic_lots_enabled

(

void

)

Check global configuration to see if dynamic parking is enabled.

Since

12.0.0

Return values

1	if dynamic parking is enabled
0	if dynamic parking is disabled

Definition at line 989 of file res_parking.c.

{
    RAII_VAR(struct parking_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
 
    if (!cfg) {
        return 0;
    }
 
    return cfg->global->parkeddynamic;
}

References ao2_cleanup, ao2_global_obj_ref, globals, and RAII_VAR.

Referenced by cli_display_parking_global(), and create_dynamic_lot_full().

parking_lot_build_or_update()

struct parking_lot * parking_lot_build_or_update	(	struct parking_lot_cfg *	cfg,
		int	dynamic
	)

If a parking lot exists in the parking lot list already, update its status to match the provided configuration and return a reference return a reference to it. Otherwise, create a parking lot struct based on a parking lot configuration and return a reference to the new one.

Since

12.0.0

Parameters

cfg	The configuration being used as a reference to build the parking lot from.
dynamic	non-zero if creating a dynamic parking lot with this. Don't replace existing parking lots. Ever.

Returns

A reference to the new parking lot

Return values

NULL	if it was not found and could not be allocated

Note

The parking lot will need to be unreffed if it ever falls out of scope

The parking lot will automatically be added to the parking lot container if needed as part of this process

Definition at line 929 of file res_parking.c.

{
    struct parking_lot *lot;
    struct parking_lot_cfg *replaced_cfg = NULL;
    int found = 0;
 
    /* Start by trying to find it. If that works we can skip the rest. */
    lot = named_item_find(parking_lot_container, lot_cfg->name);
    if (!lot) {
        lot = alloc_new_parking_lot(lot_cfg);
 
        /* If we still don't have a lot, we failed to alloc one. */
        if (!lot) {
            return NULL;
        }
    } else {
        found = 1;
 
        if (dynamic) {
            ast_log(LOG_ERROR, "Tried to create dynamic parking lot with name '%s' but a lot with that name already exists.\n", lot_cfg->name);
            ao2_cleanup(lot);
            return NULL;
        }
    }
 
    /* Set the configuration reference. Unref the one currently in the lot if it's there. */
    if (lot->cfg) {
        replaced_cfg = lot->cfg;
    }
 
    ao2_ref(lot_cfg, +1);
    lot->cfg = lot_cfg;
 
    ao2_cleanup(replaced_cfg);
 
    /* Set the operating mode to normal since the parking lot has a configuration. */
    lot->disable_mark = 0;
    lot->mode = dynamic ? PARKINGLOT_DYNAMIC : PARKINGLOT_NORMAL;
 
    if (!found) {
        /* Link after configuration is set since a lot without configuration will cause all kinds of trouble. */
        ao2_link(parking_lot_container, lot);
    };
 
    return lot;
}

References alloc_new_parking_lot(), ao2_cleanup, ao2_link, ao2_ref, ast_log, parking_lot::cfg, parking_lot::disable_mark, LOG_ERROR, parking_lot::mode, parking_lot_cfg::name, named_item_find(), NULL, parking_lot_container, PARKINGLOT_DYNAMIC, and PARKINGLOT_NORMAL.

Referenced by create_dynamic_lot_full(), and generate_or_link_lots_to_configs().

parking_lot_cfg_create_extensions()

int parking_lot_cfg_create_extensions

(

struct parking_lot_cfg *

lot_cfg

)

Add extensions for a parking lot configuration.

Since

12.0.0

Parameters

lot_cfg

parking lot configuration to generate extensions for

Return values

0	on success
non-zero	on failure

Definition at line 819 of file res_parking.c.

{
    int parkingspace;
    struct ast_exten *existing_exten;
    struct ast_context *lot_context;
    struct pbx_find_info find_info = { .stacklen = 0 }; /* the rest is reset in pbx_find_extension */
    const char *parkext_registrar_pointer; /* Used for park extension */
    const char *parkedcall_registrar_pointer; /* Used for parkedcall extensions/hints */
 
    if (ast_strlen_zero(lot_cfg->parkext)) {
        return 0;
    }
 
    ast_string_field_build(lot_cfg, registrar, "%s/%s", BASE_REGISTRAR, lot_cfg->name);
    parkedcall_registrar_pointer = lot_cfg->registrar;
 
    if (lot_cfg->parkext_exclusive) {
        parkext_registrar_pointer = lot_cfg->registrar;
    } else {
        parkext_registrar_pointer = BASE_REGISTRAR;
    }
 
    /* We need the contexts list locked to safely be able to both read and lock the specific context within */
    ast_wrlock_contexts();
 
    if (!(lot_context = ast_context_find_or_create(NULL, NULL, lot_cfg->parking_con, parkext_registrar_pointer))) {
        ast_log(LOG_ERROR, "Parking lot '%s' -- Needs a context '%s' which does not exist and Asterisk was unable to create\n",
            lot_cfg->name, lot_cfg->parking_con);
        ast_unlock_contexts();
        return -1;
    }
 
    /* Once we know what context we will be modifying, we need to write lock it because we will be reading extensions
     * and we don't want something else to destroy them while we are looking at them.
     */
    ast_wrlock_context(lot_context);
 
    ast_unlock_contexts();
 
    /* Handle generation/confirmation for the Park extension */
    if ((existing_exten = pbx_find_extension(NULL, NULL, &find_info, lot_cfg->parking_con, lot_cfg->parkext, 1, NULL, NULL, E_MATCH))) {
        if (lot_cfg->parkext_exclusive || !extension_is_compatible(lot_cfg, PARK_APPLICATION, existing_exten)) {
            ast_unlock_context(lot_context);
            return -1;
        }
    } else if (parking_add_extension(lot_context, 0, lot_cfg->parkext, 1, PARK_APPLICATION,
               lot_cfg->parkext_exclusive ? lot_cfg->name : "", parkext_registrar_pointer)) {
        ast_log(LOG_ERROR, "Parking lot '%s' -- Failed to add %s extension '%s@%s' to the PBX.\n",
                lot_cfg->name, PARK_APPLICATION, lot_cfg->parkext, lot_cfg->parking_con);
        ast_unlock_context(lot_context);
        return -1;
    }
 
    /* Handle generation/confirmation for the ParkedCall extensions and hints */
    for (parkingspace = lot_cfg->parking_start; parkingspace <= lot_cfg->parking_stop; parkingspace++) {
        char space[AST_MAX_EXTENSION];
        RAII_VAR(struct ast_str *, arguments_string, NULL, ast_free);
        find_info.stacklen = 0; /* reset for pbx_find_exten */
 
        snprintf(space, sizeof(space), "%d", parkingspace);
 
        /* Unlike the Park extensions, ParkedCall extensions and their hints may never be shared for any reason. */
        if ((existing_exten = pbx_find_extension(NULL, NULL, &find_info, lot_cfg->parking_con, space, 1, NULL, NULL, E_MATCH))) {
            ast_unlock_context(lot_context);
            return -1;
        }
 
        arguments_string = ast_str_create(32);
        if (!arguments_string) {
            ast_unlock_context(lot_context);
            return -1;
        }
 
        ast_str_set(&arguments_string, 0, "%s,%s", lot_cfg->name, space);
        if (parking_add_extension(lot_context, 0, space, 1, PARKED_CALL_APPLICATION,
            ast_str_buffer(arguments_string), parkedcall_registrar_pointer)) {
            ast_log(LOG_ERROR, "Parking lot '%s' -- Failed to add %s extension '%s@%s' to the PBX.\n",
                    lot_cfg->name, PARKED_CALL_APPLICATION, space, lot_cfg->parking_con);
            ast_unlock_context(lot_context);
            return -1;
        }
 
        find_info.stacklen = 0; /* reset for pbx_find_exten */
 
        if (lot_cfg->parkaddhints) {
            char hint_device[AST_MAX_EXTENSION];
 
            snprintf(hint_device, sizeof(hint_device), "park:%s@%s", space, lot_cfg->parking_con);
 
            if ((existing_exten = pbx_find_extension(NULL, NULL, &find_info, lot_cfg->parking_con, space, PRIORITY_HINT, NULL, NULL, E_MATCH))) {
                ast_log(LOG_ERROR, "Parking lot '%s' -- Needs to add a hint '%s' at '%s@%s' but one already exists owned by %s\n",
                    lot_cfg->name, hint_device, space, lot_cfg->parking_con, ast_get_extension_registrar(existing_exten));
                    ast_unlock_context(lot_context);
                    return -1;
            }
 
            if (parking_add_extension(lot_context, 0, space, PRIORITY_HINT, hint_device, "", parkedcall_registrar_pointer)) {
                ast_log(LOG_ERROR, "Parking lot '%s' -- Failed to add hint '%s@%s' to the PBX.\n",
                        lot_cfg->name, space, lot_cfg->parking_con);
                ast_unlock_context(lot_context);
                return -1;
            }
        }
    }
 
    ast_unlock_context(lot_context);
 
    return 0;
}

References ast_context_find_or_create(), ast_free, ast_get_extension_registrar(), ast_log, AST_MAX_EXTENSION, ast_str_buffer(), ast_str_create, ast_str_set(), ast_string_field_build, ast_strlen_zero(), ast_unlock_context(), ast_unlock_contexts(), ast_wrlock_context(), ast_wrlock_contexts(), BASE_REGISTRAR, E_MATCH, extension_is_compatible(), LOG_ERROR, parking_lot_cfg::name, NULL, PARK_APPLICATION, parking_lot_cfg::parkaddhints, PARKED_CALL_APPLICATION, parking_lot_cfg::parkext, parking_lot_cfg::parkext_exclusive, parking_add_extension(), parking_lot_cfg::parking_con, parking_lot_cfg::parking_start, pbx_find_extension(), PRIORITY_HINT, RAII_VAR, registrar, parking_lot_cfg::registrar, and pbx_find_info::stacklen.

Referenced by configure_parking_extensions(), and create_dynamic_lot_full().

parking_lot_cfg_remove_extensions()

void parking_lot_cfg_remove_extensions

(

struct parking_lot_cfg *

lot_cfg

)

Remove extensions belonging to a parking lot configuration.

Since

12.0.0

Parameters

lot_cfg

parking lot configuratin to remove extensions from

Note

This will not remove extensions registered non-exclusively even if those extensions were registered by lot_cfg. Those are only purged on a res_parking module reload.

Definition at line 724 of file res_parking.c.

{
    if (!ast_strlen_zero(lot_cfg->registrar)) {
        /* Although the function is called ast_context_destroy, the use of this funtion is
         * intended only to remove extensions, hints, etc registered by the parking lot's registrar.
         * It won't actually destroy the context unless that context is empty afterwards and it is
         * unreferenced.
         */
        ast_context_destroy(NULL, lot_cfg->registrar);
    }
 
    /* If we come back for a second pass, someone else has this registrar now. */
    ast_string_field_set(lot_cfg, registrar, "");
}

References ast_context_destroy(), ast_string_field_set, ast_strlen_zero(), NULL, registrar, and parking_lot_cfg::registrar.

Referenced by parking_lot_cfg_destructor(), remove_all_configured_parking_lot_extensions(), and remove_pending_parking_lot_extensions().

parking_lot_find_by_name()

struct parking_lot * parking_lot_find_by_name

(

const char *

lot_name

)

Find a parking lot based on its name.

Since

12.0.0

Parameters

lot_name

Name of the parking lot sought

Returns

The parking lot if found

Return values

NULL	if no parking lot with the name specified exists

Note

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

Definition at line 662 of file res_parking.c.

{
    struct parking_lot *lot = named_item_find(parking_lot_container, lot_name);
    return lot;
}

References named_item_find(), and parking_lot_container.

Referenced by cli_display_parking_lot(), create_dynamic_lot_full(), func_get_parkingslot_channel(), manager_parking_status_single_lot(), park_common_setup2(), parked_call_app_exec(), and parking_park_call().

parking_lot_get_bridge()

struct ast_bridge * parking_lot_get_bridge

(

struct parking_lot *

lot

)

Get a reference to a parking lot's bridge. If it doesn't exist, create it and get a reference.

Since

12.0.0

Parameters

lot	Which parking lot we need the bridge from. This parking lot must be locked before calling this function.

Returns

A reference to the ast_bridge associated with the parking lot

Return values

NULL	if it didn't already have a bridge and one couldn't be created

Note

This bridge will need to be unreffed if it ever falls out of scope.

Definition at line 36 of file parking_controller.c.

{
    struct ast_bridge *lot_bridge;
 
    if (lot->parking_bridge) {
        ao2_ref(lot->parking_bridge, +1);
        return lot->parking_bridge;
    }
 
    lot_bridge = bridge_parking_new(lot);
    if (!lot_bridge) {
        return NULL;
    }
 
    /* The parking lot needs a reference to the bridge as well. */
    lot->parking_bridge = lot_bridge;
    ao2_ref(lot->parking_bridge, +1);
 
    return lot_bridge;
}

References ao2_ref, bridge_parking_new(), NULL, and parking_lot::parking_bridge.

Referenced by park_common_setup2().

parking_lot_get_space()

int parking_lot_get_space	(	struct parking_lot *	lot,
		int	target_override
	)

Get an available parking space within a parking lot.

Since

12.0.0

Parameters

lot	Which parking lot we are getting a space from
target_override	If there is a specific slot we want, provide it here and we'll start from that position

Return values

-1	if No slot can be found

Returns

integer value of parking space selected

Note

lot should be locked before this is called and unlocked only after a parked_user with the space returned has been added to the parking lot.

Definition at line 96 of file parking_controller.c.

{
    int original_target;
    int current_target;
    struct ao2_iterator i;
    struct parked_user *user;
    int wrap;
 
    if (lot->cfg->parkfindnext) {
        /* Use next_space if the lot already has next_space set; otherwise use lot start. */
        original_target = lot->next_space ? lot->next_space : lot->cfg->parking_start;
    } else {
        original_target = lot->cfg->parking_start;
    }
 
    if (target_override >= lot->cfg->parking_start && target_override <= lot->cfg->parking_stop) {
        original_target = target_override;
    } else if (target_override > -1) {
        ast_log(LOG_WARNING, "Preferred parking spot %d is out of bounds (%d-%d)\n", target_override, lot->cfg->parking_start, lot->cfg->parking_stop);
    }
 
    current_target = original_target;
 
    wrap = lot->cfg->parking_start;
 
    i = ao2_iterator_init(lot->parked_users, 0);
    while ((user = ao2_iterator_next(&i))) {
        /* Increment the wrap on each pass until we find an empty space */
        if (wrap == user->parking_space) {
            wrap += 1;
        }
 
        if (user->parking_space < current_target) {
            /* It's lower than the anticipated target, so we haven't reached the target yet. */
            ao2_ref(user, -1);
            continue;
        }
 
        if (user->parking_space > current_target) {
            /* The current target is usable because all items below have been read and the next target is higher than the one we want. */
            ao2_ref(user, -1);
            break;
        }
 
        /* We found one already parked here. */
        current_target += 1;
        ao2_ref(user, -1);
    }
    ao2_iterator_destroy(&i);
 
    if (current_target <= lot->cfg->parking_stop) {
        return current_target;
    }
 
    if (wrap <= lot->cfg->parking_stop) {
        return wrap;
    }
 
    return -1;
}

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, parking_lot::cfg, LOG_WARNING, parked_user::lot, parking_lot::next_space, parking_lot::parked_users, parking_lot_cfg::parkfindnext, parking_lot_cfg::parking_start, parking_lot_cfg::parking_stop, and user.

Referenced by generate_parked_user().

parking_lot_inspect_parked_user()

struct parked_user * parking_lot_inspect_parked_user	(	struct parking_lot *	lot,
		int	target
	)

Determine if there is a parked user in a parking space and return it if there is.

Parameters

lot	Parking lot being pulled from
target	If < 0 search for the first occupied space in the parking lot If >= 0 Only pull from the indicated target

Return values

NULL	if no parked user could be pulled from the requested parking lot at the requested parking space

Returns

reference to the requested parked user

Definition at line 168 of file parking_controller.c.

{
    struct parked_user *user;
 
    if (target < 0) {
        user = ao2_callback(lot->parked_users, 0, NULL, NULL);
    } else {
        user = ao2_callback(lot->parked_users, 0, retrieve_parked_user_targeted, &target);
    }
 
    if (!user) {
        return NULL;
    }
 
    return user;
}

References ao2_callback, parked_user::lot, NULL, parking_lot::parked_users, retrieve_parked_user_targeted(), and user.

Referenced by func_get_parkingslot_channel().

parking_lot_remove_if_unused()

int parking_lot_remove_if_unused

(

struct parking_lot *

lot

)

Remove a parking lot from the usable lists if it is no longer involved in any calls and no configuration currently claims it.

Since

12.0.0

Parameters

lot	Which parking lot is being checked for elimination

Return values

0	if the parking lot was removed
-1	if the parking lot wasn't removed.

Note

This should generally be called when something is happening that could cause a parking lot to die such as a call being unparked or a parking lot no longer existing in configurations.

Definition at line 460 of file res_parking.c.

{
    if (lot->mode != PARKINGLOT_DISABLED) {
        return -1;
    }
 
    if (!ao2_container_count(lot->parked_users)) {
        ao2_unlink(parking_lot_container, lot);
        return 0;
    }
 
    return -1;
}

References ao2_container_count(), ao2_unlink, parking_lot::mode, parking_lot::parked_users, parking_lot_container, and PARKINGLOT_DISABLED.

Referenced by parking_lot_disable(), parking_lot_retrieve_parked_user(), and unpark_parked_user().

parking_lot_retrieve_parked_user()

struct parked_user * parking_lot_retrieve_parked_user	(	struct parking_lot *	lot,
		int	target
	)

Determine if there is a parked user in a parking space and pull it from the parking lot if there is.

Since

12.0.0

Parameters

lot	Parking lot being pulled from
target	If < 0 search for the first occupied space in the parking lot If >= 0 Only pull from the indicated target

Return values

NULL	if no parked user could be pulled from the requested parking lot at the requested parking space

Returns

reference to the requested parked user

Note

The parked user will be removed from parking lot as part of this process

Remove this reference with ao2_cleanup once it falls out of scope.

Definition at line 185 of file parking_controller.c.

{
    RAII_VAR(struct parked_user *, user, NULL, ao2_cleanup);
 
    if (target < 0) {
        user = ao2_callback(lot->parked_users, 0, NULL, NULL);
    } else {
        user = ao2_callback(lot->parked_users, 0, retrieve_parked_user_targeted, &target);
    }
 
    if (!user) {
        return NULL;
    }
 
    ao2_lock(user);
    if (user->resolution != PARK_UNSET) {
        /* Abandon. Something else has resolved the parked user before we got to it. */
        ao2_unlock(user);
        return NULL;
    }
 
    ao2_unlink(lot->parked_users, user);
    user->resolution = PARK_ANSWERED;
    ao2_unlock(user);
 
    parking_lot_remove_if_unused(user->lot);
 
    /* Bump the ref count by 1 since the RAII_VAR will eat the reference otherwise */
    ao2_ref(user, +1);
    return user;
}

References ao2_callback, ao2_cleanup, ao2_lock, ao2_ref, ao2_unlink, ao2_unlock, parked_user::lot, NULL, PARK_ANSWERED, PARK_UNSET, parking_lot::parked_users, parking_lot_remove_if_unused(), RAII_VAR, retrieve_parked_user_targeted(), and user.

Referenced by parked_call_app_exec().

parking_notify_metermaids()

void parking_notify_metermaids	(	int	exten,
		const char *	context,
		enum ast_device_state	state
	)

Notify metermaids that we've changed an extension.

Since

12.0.0

Parameters

exten	Extension of the call parked/unparked
context	Context of the call parked/unparked
state	new device state

Definition at line 108 of file parking_devicestate.c.

{
    ast_debug(4, "Notification of state change to metermaids %d@%s\n to state '%s'\n",
        exten, context, ast_devstate2str(state));
 
    ast_devstate_changed(state, AST_DEVSTATE_CACHABLE, "park:%d@%s", exten, context);
}

References ast_debug, ast_devstate2str(), AST_DEVSTATE_CACHABLE, ast_devstate_changed(), voicemailpwcheck::context, and parking_lot_extension_inuse_search::exten.

Referenced by bridge_parking_pull(), and bridge_parking_push().

parking_set_duration()

void parking_set_duration	(	struct ast_bridge_features *	features,
		struct parked_user *	user
	)

Setup timeout interval feature on an ast_bridge_features for parking.

Since

12.0.0

Parameters

features	The ast_bridge_features we are establishing the interval hook on
user	The parked_user receiving the timeout duration limits

Definition at line 706 of file parking_bridge_features.c.

{
    unsigned int time_limit;
 
    time_limit = user->time_limit * 1000;
 
    if (!time_limit) {
        /* There is no duration limit that we need to apply. */
        return;
    }
 
    /* If the time limit has already been passed, set a really low time limit so we can kick them out immediately. */
    time_limit = ast_remaining_ms(user->start, time_limit);
    if (time_limit <= 0) {
        time_limit = 1;
    }
 
    /* The interval hook is going to need a reference to the parked_user */
    ao2_ref(user, +1);
 
    if (ast_bridge_interval_hook(features, 0, time_limit,
        parking_duration_callback, user, __ao2_cleanup, AST_BRIDGE_HOOK_REMOVE_ON_PULL)) {
        ast_log(LOG_ERROR, "Failed to apply duration limit to the parked call.\n");
        ao2_ref(user, -1);
    }
}

References __ao2_cleanup(), ao2_ref, AST_BRIDGE_HOOK_REMOVE_ON_PULL, ast_bridge_interval_hook(), ast_log, ast_remaining_ms(), LOG_ERROR, and parking_duration_callback().

Referenced by bridge_parking_push().

publish_parked_call()

void publish_parked_call	(	struct parked_user *	pu,
		enum ast_parked_call_event_type	event_type
	)

Publish a stasis parked call message for a given parked user.

Since

12.0.0

Parameters

pu	pointer to a parked_user that we are generating the message for
event_type	What parked call event type is provoking this message

Definition at line 651 of file parking_manager.c.

{
    RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
 
    if (!ast_parked_call_type()) {
        return;
    }
 
    payload = parked_call_payload_from_parked_user(pu, event_type);
    if (!payload) {
        return;
    }
 
    msg = stasis_message_create(ast_parked_call_type(), payload);
    if (!msg) {
        return;
    }
 
    stasis_publish(ast_parking_topic(), msg);
}

References ao2_cleanup, ast_parked_call_type(), ast_parking_topic(), NULL, parked_call_payload_from_parked_user(), RAII_VAR, stasis_message_create(), and stasis_publish().

Referenced by bridge_parking_pull(), and bridge_parking_push().

publish_parked_call_failure()

void publish_parked_call_failure

(

struct ast_channel *

parkee

)

Publish a stasis parked call message for the channel indicating failure to park.

Since

12.0.0

Parameters

parkee

channel belonging to the failed parkee

Definition at line 629 of file parking_manager.c.

{
    RAII_VAR(struct ast_parked_call_payload *, payload, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
 
    if (!ast_parked_call_type()) {
        return;
    }
 
    payload = parked_call_payload_from_failure(parkee);
    if (!payload) {
        return;
    }
 
    msg = stasis_message_create(ast_parked_call_type(), payload);
    if (!msg) {
        return;
    }
 
    stasis_publish(ast_parking_topic(), msg);
}

References ao2_cleanup, ast_parked_call_type(), ast_parking_topic(), NULL, parked_call_payload_from_failure(), RAII_VAR, stasis_message_create(), and stasis_publish().

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

say_parking_space()

void say_parking_space	(	struct ast_bridge_channel *	bridge_channel,
		const char *	payload
	)

custom callback function for ast_bridge_channel_queue_playfile which plays a parking space and optionally hangs up the call afterwards based on the payload in playfile.

Since

12.0.0

Definition at line 684 of file parking_bridge_features.c.

{
    unsigned int numeric_value;
    unsigned int hangup_after;
 
    if (sscanf(payload, "%u %u", &hangup_after, &numeric_value) != 2) {
        /* If say_parking_space is called with a non-numeric string, we have a problem. */
        ast_assert(0);
        ast_bridge_channel_leave_bridge(bridge_channel,
            BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
        return;
    }
 
    ast_say_digits(bridge_channel->chan, numeric_value, "",
        ast_channel_language(bridge_channel->chan));
 
    if (hangup_after) {
        ast_bridge_channel_leave_bridge(bridge_channel,
            BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, AST_CAUSE_NORMAL_CLEARING);
    }
}

References ast_assert, ast_bridge_channel_leave_bridge(), AST_CAUSE_NORMAL_CLEARING, ast_channel_language(), ast_say_digits(), BRIDGE_CHANNEL_STATE_END_NO_DISSOLVE, and ast_bridge_channel::chan.

Referenced by bridge_parking_push(), and parker_parked_call_message_response().

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().

unload_parking_bridge_features()

void unload_parking_bridge_features

(

void

)

Unregister features registered by load_parking_bridge_features.

Since

12.0.0

Definition at line 796 of file parking_bridge_features.c.

{
    ast_bridge_features_unregister(AST_BRIDGE_BUILTIN_PARKCALL);
    ast_parking_unregister_bridge_features(parking_provider.module_name);
    ast_custom_function_unregister(&getparkingslotchannel_function);
}

References AST_BRIDGE_BUILTIN_PARKCALL, ast_bridge_features_unregister(), ast_custom_function_unregister(), ast_parking_unregister_bridge_features(), getparkingslotchannel_function, ast_parking_bridge_feature_fn_table::module_name, and parking_provider.

Referenced by unload_module().

unload_parking_devstate()

void unload_parking_devstate

(

void

)

Unregister Parking devstate handler.

Since

12.0.0

Definition at line 116 of file parking_devicestate.c.

{
    ast_devstate_prov_del("Park");
}

References ast_devstate_prov_del().

Referenced by unload_module().

unload_parking_manager()

void unload_parking_manager

(

void

)

Unregister manager actions and remove subscriptions for stasis events.

Since

12.0.0

Definition at line 744 of file parking_manager.c.

{
    ast_manager_unregister("Parkinglots");
    ast_manager_unregister("ParkedCalls");
    ast_manager_unregister("Park");
    parking_manager_disable_stasis();
}

References ast_manager_unregister(), and parking_manager_disable_stasis().

Referenced by unload_module().

unload_parking_tests()

void unload_parking_tests

(

void

)

Unregister parking unit tests.

Since

12.0.0

Definition at line 838 of file parking_tests.c.

{
/* NOOP without test framework */
#if defined(TEST_FRAMEWORK)
    AST_TEST_UNREGISTER(create_lot);
    AST_TEST_UNREGISTER(park_call);
    AST_TEST_UNREGISTER(retrieve_call);
    AST_TEST_UNREGISTER(park_extensions);
    AST_TEST_UNREGISTER(extension_conflicts);
    AST_TEST_UNREGISTER(dynamic_parking_variables);
#endif
}

References AST_TEST_UNREGISTER.

Referenced by unload_module().

unload_parking_ui()

void unload_parking_ui

(

void

)

Unregister CLI commands.

Since

12.0.0

Definition at line 203 of file parking_ui.c.

{
    ast_cli_unregister_multiple(cli_parking_lot, ARRAY_LEN(cli_parking_lot));
}

References ARRAY_LEN, ast_cli_unregister_multiple(), and cli_parking_lot.

Referenced by unload_module().

unpark_parked_user()

int unpark_parked_user

(

struct parked_user *

user

)

Pull a parked user out of its parking lot. Use this when you don't want to use the parked user afterwards.

Since

12.0.0

Parameters

user	The parked user being pulled.

Return values

0	on success
-1	if the user didn't have its parking lot set

Definition at line 85 of file parking_controller.c.

{
    if (pu->lot) {
        ao2_unlink(pu->lot->parked_users, pu);
        parking_lot_remove_if_unused(pu->lot);
        return 0;
    }
 
    return -1;
}

References ao2_unlink, parked_user::lot, parking_lot::parked_users, and parking_lot_remove_if_unused().

Referenced by bridge_parking_pull().