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...
struct parking_lot *	parking_create_dynamic_lot_forced (const char *name, struct ast_channel *chan)
	Create a dynamic parking lot without respect to whether they are enabled by configuration. 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...
struct parking_lot_cfg *	parking_lot_cfg_create (const char *cat)
	Create an empty parking lot configuration structure useful for unit tests. 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.

Referenced by extension_is_compatible(), parking_duration_callback(), parking_lot_cfg_create_extensions(), remove_all_configured_parking_lot_extensions(), and remove_pending_parking_lot_extensions().

DEFAULT_PARKING_EXTEN

#define DEFAULT_PARKING_EXTEN   "700"

Definition at line 35 of file res_parking.h.

Referenced by verify_default_parking_lot().

DEFAULT_PARKING_LOT

#define DEFAULT_PARKING_LOT   "default"

Definition at line 34 of file res_parking.h.

Referenced by create_dynamic_lot_full(), find_channel_parking_lot_name(), and verify_default_parking_lot().

PARK_DIAL_CONTEXT

#define PARK_DIAL_CONTEXT   "park-dial"

Definition at line 37 of file res_parking.h.

Referenced by comeback_goto(), and parking_duration_callback().

PARKED_CALL_APPLICATION

#define PARKED_CALL_APPLICATION   "ParkedCall"

Definition at line 38 of file res_parking.h.

Referenced by load_parking_applications(), parking_lot_cfg_create_extensions(), and unload_parking_applications().

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
Newly	created parking bridge

Definition at line 456 of file parking_bridge.c.

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(), bridge_alloc(), bridge_base_init(), bridge_register(), parking_lot::name, and NULL.

Referenced by parking_lot_get_bridge().

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

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 261 of file parking_controller.c.

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

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

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 233 of file parking_bridge_features.c.

References create_parked_subscription_full(), and NULL.

Referenced by manager_park(), and manager_park_bridged().

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

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 607 of file res_parking.c.

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

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

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

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

peername

unflattened dial string. This will be flattened in place.

Definition at line 249 of file parking_controller.c.

Referenced by comeback_goto(), and parking_duration_callback().

{
   int i;

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

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

Return values

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.
NULL	if the park_common_datastore could not be copied off of the channel.

Definition at line 433 of file parking_applications.c.

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

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

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

Return values

pointer

to the parking lot container.

Definition at line 596 of file res_parking.c.

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

{
   return parking_lot_container;
}

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 989 of file parking_applications.c.

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

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

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 802 of file parking_bridge_features.c.

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

Referenced by load_module().

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

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.

References ast_devstate_prov_add(), and metermaidstate().

Referenced by load_module().

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

load_parking_manager()

int load_parking_manager

(

void

)

Register manager actions and setup subscriptions for stasis events.

Since

12.0.0

Definition at line 694 of file parking_manager.c.

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

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

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.

References AST_TEST_REGISTER.

Referenced by load_module().

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

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.

References ARRAY_LEN, and ast_cli_register_multiple.

Referenced by load_module().

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

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 preparred 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.

Return values

reference	to a parking bridge if successful
NULL	on failure

Note

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

Definition at line 526 of file parking_applications.c.

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

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

{
   int use_ringing = 0;
   int randomize = 0;
   int time_limit = -1;

   RAII_VAR(char *, comeback_override, NULL, ast_free);
   RAII_VAR(char *, lot_name_app_arg, NULL, ast_free);

   if (app_data) {
      park_app_parse_data(app_data, silence_announcements, &use_ringing, &randomize, &time_limit, &comeback_override, &lot_name_app_arg);
   }

   return park_common_setup(parkee, parker, lot_name_app_arg, comeback_override, use_ringing,
      randomize, time_limit, silence_announcements ? *silence_announcements : 0);

}

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 327 of file parking_applications.c.

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

{
   if (!datastore) {
      return;
   }

   ast_free(datastore->parker_uuid);
   ast_free(datastore->parker_dial_string);
   ast_free(datastore->comeback_override);
   ast_free(datastore);
}

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 484 of file parking_applications.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_channel_lock, 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 manager_park_unbridged(), and park_application_setup().

{
   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);
   setup_park_common_datastore(parkee, ast_channel_uniqueid(parker), comeback_override, randomize, time_limit,
      silence_announcements);
   return parking_bridge;
}

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 215 of file parking_controller.c.

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

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

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.

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

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

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

Return values

dynamically	created parking lot on success
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 1059 of file res_parking.c.

References create_dynamic_lot_full().

Referenced by park_common_setup(), and parking_park_call().

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

parking_create_dynamic_lot_forced()

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

Create a dynamic parking lot without respect to whether they are enabled by configuration.

Since

12.0.0

Parameters

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

Return values

dynamically	created parking lot on success
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 1064 of file res_parking.c.

References create_dynamic_lot_full().

Referenced by AST_TEST_DEFINE().

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

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 928 of file res_parking.c.

References ao2_cleanup, ao2_global_obj_ref, globals, and RAII_VAR.

Referenced by cli_display_parking_global(), and create_dynamic_lot_full().

{
   RAII_VAR(struct parking_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);

   if (!cfg) {
      return 0;
   }

   return cfg->global->parkeddynamic;
}

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.

Return values

A	reference to the new parking lot
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 868 of file res_parking.c.

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, PARKINGLOT_DYNAMIC, and PARKINGLOT_NORMAL.

Referenced by create_dynamic_lot_full(), generate_or_link_lots_to_configs(), and generate_test_parking_lot().

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

parking_lot_cfg_create()

struct parking_lot_cfg* parking_lot_cfg_create

(

const char *

cat

)

Create an empty parking lot configuration structure useful for unit tests.

Since

12.0.0

Parameters

cat	name given to the parking lot

Return values

NULL	failure
non-NULL	successfully allocated parking lot

Definition at line 481 of file res_parking.c.

References parking_lot_cfg_alloc().

Referenced by AST_TEST_DEFINE(), and generate_test_parking_lot().

{
   return parking_lot_cfg_alloc(cat);
}

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 758 of file res_parking.c.

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(), create_dynamic_lot_full(), and generate_test_parking_lot().

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

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 663 of file res_parking.c.

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

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

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

Return values

The	parking lot if found
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 601 of file res_parking.c.

References named_item_find().

Referenced by AST_TEST_DEFINE(), cli_display_parking_lot(), create_dynamic_lot_full(), dispose_test_lot(), func_get_parkingslot_channel(), manager_parking_status_single_lot(), park_common_setup(), parked_call_app_exec(), and parking_park_call().

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

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.

Return values

A	reference to the ast_bridge associated with the parking lot
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.

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

Referenced by park_common_setup().

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

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

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, parking_lot::cfg, parking_lot::next_space, parking_lot::parked_users, parking_lot_cfg::parkfindnext, parked_user::parking_space, parking_lot_cfg::parking_start, and parking_limits_pvt::user.

Referenced by generate_parked_user().

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

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

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
reference	to the requested parked user

Definition at line 166 of file parking_controller.c.

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

Referenced by func_get_parkingslot_channel().

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

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 400 of file res_parking.c.

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

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

{
   if (lot->mode != PARKINGLOT_DISABLED) {
      return -1;
   }

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

   return -1;
}

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
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 183 of file parking_controller.c.

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

Referenced by AST_TEST_DEFINE(), and parked_call_app_exec().

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

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.

References ast_debug, ast_devstate2str(), AST_DEVSTATE_CACHABLE, and ast_devstate_changed().

Referenced by bridge_parking_pull(), and bridge_parking_push().

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

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 705 of file parking_bridge_features.c.

References __ao2_cleanup(), ao2_ref, AST_BRIDGE_HOOK_REMOVE_ON_PULL, ast_bridge_interval_hook(), ast_log, ast_remaining_ms(), LOG_ERROR, parking_duration_callback(), parked_user::start, and parked_user::time_limit.

Referenced by bridge_parking_push().

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

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 617 of file parking_manager.c.

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

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

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 595 of file parking_manager.c.

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

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

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 683 of file parking_bridge_features.c.

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

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

unload_parking_applications()

void unload_parking_applications

(

void

)

Unregister parking applications.

Since

12.0.0

Definition at line 1006 of file parking_applications.c.

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

Referenced by unload_module().

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

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 795 of file parking_bridge_features.c.

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

Referenced by unload_module().

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

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.

References ast_devstate_prov_del().

Referenced by unload_module().

{
   ast_devstate_prov_del("Park");
}

unload_parking_manager()

void unload_parking_manager

(

void

)

Unregister manager actions and remove subscriptions for stasis events.

Since

12.0.0

Definition at line 710 of file parking_manager.c.

References ast_manager_unregister(), and parking_manager_disable_stasis().

Referenced by unload_module().

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

unload_parking_tests()

void unload_parking_tests

(

void

)

Unregister parking unit tests.

Since

12.0.0

Returns

Nothing

Definition at line 838 of file parking_tests.c.

References AST_TEST_UNREGISTER.

Referenced by unload_module().

{
/* 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
}

unload_parking_ui()

void unload_parking_ui

(

void

)

Unregister CLI commands.

Since

12.0.0

Definition at line 203 of file parking_ui.c.

References ARRAY_LEN, and ast_cli_unregister_multiple().

Referenced by unload_module().

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

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.

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

Referenced by bridge_parking_pull().

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

   return -1;
}