res_parking.c File Reference

Call Parking Resource. More...

#include "asterisk.h"
#include "parking/res_parking.h"
#include "asterisk/config.h"
#include "asterisk/config_options.h"
#include "asterisk/utils.h"
#include "asterisk/module.h"
#include "asterisk/cli.h"
#include "asterisk/astobj2.h"
#include "asterisk/features.h"
#include "asterisk/manager.h"
#include "asterisk/pbx.h"

Include dependency graph for res_parking.c:

Go to the source code of this file.

Data Structures
struct	parking_config
struct	parking_global_config

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
static struct parking_lot *	alloc_new_parking_lot (struct parking_lot_cfg *lot_cfg)
static	AO2_GLOBAL_OBJ_STATIC (globals)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static struct parking_lot_cfg *	clone_parkinglot_cfg (struct parking_lot_cfg *source, const char *name)
	CONFIG_INFO_STANDARD (cfg_info, globals, parking_config_alloc,.files=ACO_FILES(&parking_lot_conf),.pre_apply_config=config_parking_preapply,.post_apply_config=link_configured_disable_marked_lots,)
static int	config_parking_preapply (void)
static int	configure_parking_extensions (void)
static struct parking_lot *	create_dynamic_lot_full (const char *name, struct ast_channel *chan, int forced)
static void	disable_marked_lots (void)
static int	extension_is_compatible (struct parking_lot_cfg *lot_cfg, const char *app_type, struct ast_exten *extension)
const char *	find_channel_parking_lot_name (struct ast_channel *chan)
	Find parking lot name from channel. More...
static void	generate_or_link_lots_to_configs (void)
struct ao2_container *	get_parking_lot_container (void)
	Get a pointer to the parking lot container for purposes such as iteration. More...
static void	link_configured_disable_marked_lots (void)
static int	load_module (void)
static void	mark_lots_as_disabled (void)
static void *	named_item_find (struct ao2_container *container, const char *name)
	find an item in a container by its name More...
static int	option_handler_findslot (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Custom field handler for the findslot option. More...
static int	option_handler_parkedfeature (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Custom field handler for feature mapping on parked call pickup options. More...
static int	option_handler_parkpos (const struct aco_option *opt, struct ast_variable *var, void *obj)
	Custom field handler for parking positions. More...
static int	parked_user_cmp_fn (void *obj, void *arg, int flags)
static int	parked_user_sort_fn (const void *obj_left, const void *obj_right, int flags)
static int	parking_add_extension (struct ast_context *context, int replace, const char *extension, int priority, const char *application, const char *data, const char *registrar)
static void *	parking_config_alloc (void)
	allocator callback for parking_config. Notice it returns void * since it is only used by the backend config code More...
static void	parking_config_destructor (void *obj)
	destructor for parking_config 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...
static int	parking_feature_flag_cfg (int *param, const char *var)
	Maps string values for option_handler_parkedfeature to their ENUM values. More...
static void	parking_global_config_destructor (void *obj)
	destructor for parking_global_config More...
struct parking_lot *	parking_lot_build_or_update (struct parking_lot_cfg *lot_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...
static void *	parking_lot_cfg_alloc (const char *cat)
	create a parking lot structure More...
static int	parking_lot_cfg_cmp_fn (void *obj, void *arg, const int flags)
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...
static void	parking_lot_cfg_destructor (void *obj)
	Destroy a parking lot cfg object. More...
static int	parking_lot_cfg_hash_fn (const void *obj, const int flags)
void	parking_lot_cfg_remove_extensions (struct parking_lot_cfg *lot_cfg)
	Remove extensions belonging to a parking lot configuration. More...
static void	parking_lot_destructor (void *obj)
static void	parking_lot_disable (struct parking_lot *lot)
struct parking_lot *	parking_lot_find_by_name (const char *lot_name)
	Find a parking lot based on its name. 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...
static int	parking_lot_sort_fn (const void *obj_left, const void *obj_right, int flags)
static int	reload_module (void)
static void	remove_all_configured_parking_lot_extensions (void)
static void	remove_pending_parking_lot_extensions (struct parking_config *cfg_pending)
static int	unload_module (void)
static int	verify_default_parking_lot (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Call Parking Resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct aco_type	global_option
struct aco_type *	global_options [] = ACO_TYPES(&global_option)
struct aco_file	parking_lot_conf
static struct ao2_container *	parking_lot_container
static struct aco_type	parking_lot_type
struct aco_type *	parking_lot_types [] = ACO_TYPES(&parking_lot_type)

Detailed Description

Call Parking Resource.

Author

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

Definition in file res_parking.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 1295 of file res_parking.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1295 of file res_parking.c.

alloc_new_parking_lot()

static struct parking_lot* alloc_new_parking_lot ( struct parking_lot_cfg *  lot_cfg )

static

Definition at line 637 of file res_parking.c.

References ao2_alloc, AO2_ALLOC_OPT_LOCK_RWLOCK, ao2_cleanup, ao2_container_alloc_list, AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, ast_string_field_init, ast_string_field_set, name, parking_lot_cfg::name, NULL, parked_user_cmp_fn(), parked_user_sort_fn(), parking_lot::parked_users, and parking_lot_destructor().

Referenced by parking_lot_build_or_update().

{
   struct parking_lot *lot;
   if (!(lot = ao2_alloc(sizeof(*lot), parking_lot_destructor))) {
      return NULL;
   }

   if (ast_string_field_init(lot, 32)) {
      return NULL;
   }

   /* Create parked user ordered list */
   lot->parked_users = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_RWLOCK,
      AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT,
      parked_user_sort_fn,
      parked_user_cmp_fn);

   if (!lot->parked_users) {
      ao2_cleanup(lot);
      return NULL;
   }

   ast_string_field_set(lot, name, lot_cfg->name);
   return lot;
}

AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( globals  )

static

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 1295 of file res_parking.c.

clone_parkinglot_cfg()

static struct parking_lot_cfg* clone_parkinglot_cfg ( struct parking_lot_cfg *  source, const char *  name  )

static

Definition at line 939 of file res_parking.c.

References ast_string_field_set, ast_string_fields_copy, parking_lot_cfg::comebackdialtime, parking_lot_cfg::comebacktoorigin, NULL, parking_lot_cfg::parkaddhints, parking_lot_cfg::parkedcallhangup, parking_lot_cfg::parkedcallrecording, parking_lot_cfg::parkedcallreparking, parking_lot_cfg::parkedcalltransfers, parking_lot_cfg::parkedplay, parking_lot_cfg::parkext_exclusive, parking_lot_cfg::parkfindnext, parking_lot_cfg_alloc(), parking_lot_cfg::parking_start, parking_lot_cfg::parking_stop, and parking_lot_cfg::parkingtime.

Referenced by create_dynamic_lot_full().

{
   struct parking_lot_cfg *cfg = parking_lot_cfg_alloc(name);

   if (!cfg) {
      return NULL;
   }

   ast_string_fields_copy(cfg, source);

   /* Needs to be reset after being copied */
   ast_string_field_set(cfg, name, name);

   /* Stuff that should be cloned that isn't hit by string field copy */
   cfg->parking_start = source->parking_start;
   cfg->parking_stop = source->parking_stop;
   cfg->parkingtime = source->parkingtime;
   cfg->comebackdialtime = source->comebackdialtime;
   cfg->parkfindnext = source->parkfindnext;
   cfg->parkext_exclusive = source->parkext_exclusive;
   cfg->parkaddhints = source->parkaddhints;
   cfg->comebacktoorigin = source->comebacktoorigin;
   cfg->parkedplay = source->parkedplay;
   cfg->parkedcalltransfers = source->parkedcalltransfers;
   cfg->parkedcallreparking = source->parkedcallreparking;
   cfg->parkedcallhangup = source->parkedcallhangup;
   cfg->parkedcallrecording = source->parkedcallrecording;

   return cfg;
}

CONFIG_INFO_STANDARD()

CONFIG_INFO_STANDARD	(	cfg_info	,
		globals	,
		parking_config_alloc	,
		.	files = ACO_FILES(&parking_lot_conf),
		.	pre_apply_config = config_parking_preapply,
		.	post_apply_config = link_configured_disable_marked_lots
	)

config_parking_preapply()

static int config_parking_preapply ( void  )

static

Definition at line 1155 of file res_parking.c.

References configure_parking_extensions(), mark_lots_as_disabled(), and verify_default_parking_lot().

{
   mark_lots_as_disabled();

   if (verify_default_parking_lot()) {
      return -1;
   }

   if (configure_parking_extensions()) {
      return -1;
   }

   return 0;
}

configure_parking_extensions()

static int configure_parking_extensions ( void  )

static

Definition at line 1110 of file res_parking.c.

References aco_pending_config(), ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_log, LOG_ERROR, NULL, parking_lot_cfg_create_extensions(), parking_config::parking_lots, RAII_VAR, remove_all_configured_parking_lot_extensions(), and remove_pending_parking_lot_extensions().

Referenced by config_parking_preapply().

{
   struct parking_config *cfg = aco_pending_config(&cfg_info);
   struct ao2_iterator iter;
   RAII_VAR(struct parking_lot_cfg *, lot_cfg, NULL, ao2_cleanup);
   int res = 0;

   if (!cfg) {
      return 0;
   }

   /* Clear existing extensions */
   remove_all_configured_parking_lot_extensions();

   /* Attempt to build new extensions for each lot */
   for (iter = ao2_iterator_init(cfg->parking_lots, 0); (lot_cfg = ao2_iterator_next(&iter)); ao2_ref(lot_cfg, -1)) {
      if (parking_lot_cfg_create_extensions(lot_cfg)) {
         ao2_cleanup(lot_cfg);
         lot_cfg = NULL;
         res = -1;
         break;
      }
   }
   ao2_iterator_destroy(&iter);

   if (res) {
      remove_pending_parking_lot_extensions(cfg);
      ast_log(LOG_ERROR, "Extension registration failed. Previously configured lot extensions were removed and can not be safely restored.\n");
   }

   return res;
}

create_dynamic_lot_full()

static struct parking_lot* create_dynamic_lot_full ( const char *  name, struct ast_channel *  chan, int  forced  )

static

Definition at line 970 of file res_parking.c.

References ao2_cleanup, ao2_lock, ao2_ref, ao2_unlock, ast_channel_lock, ast_channel_unlock, ast_log, ast_strdupa, ast_string_field_set, ast_strlen_zero, parking_lot::cfg, clone_parkinglot_cfg(), DEFAULT_PARKING_LOT, LOG_ERROR, LOG_NOTICE, NULL, parking_dynamic_lots_enabled(), parking_lot_build_or_update(), parking_lot_cfg_create_extensions(), parking_lot_find_by_name(), parking_lot_cfg::parking_start, parking_lot_cfg::parking_stop, pbx_builtin_getvar_helper(), RAII_VAR, and S_OR.

Referenced by parking_create_dynamic_lot(), and parking_create_dynamic_lot_forced().

{
   RAII_VAR(struct parking_lot_cfg *, cfg, NULL, ao2_cleanup);
   RAII_VAR(struct parking_lot *, template_lot, NULL, ao2_cleanup);

   struct parking_lot *lot;
   const char *dyn_context;
   const char *dyn_exten;
   const char *dyn_range;
   const char *template_name;
   const char *chan_template_name;
   int dyn_start;
   int dyn_end;

   if (!forced && !parking_dynamic_lots_enabled()) {
      return NULL;
   }

   ast_channel_lock(chan);
   chan_template_name = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNAMIC"), ""));
   dyn_context = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNCONTEXT"), ""));
   dyn_exten = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNEXTEN"), ""));
   dyn_range = ast_strdupa(S_OR(pbx_builtin_getvar_helper(chan, "PARKINGDYNPOS"), ""));
   ast_channel_unlock(chan);

   template_name = S_OR(chan_template_name, DEFAULT_PARKING_LOT);

   template_lot = parking_lot_find_by_name(template_name);
   if (!template_lot) {
      ast_log(LOG_ERROR, "Lot %s does not exist. Can not use it as a dynamic parking lot template.\n",
         template_name);
      return NULL;
   }

   cfg = clone_parkinglot_cfg(template_lot->cfg, name);

   if (!cfg) {
      ast_log(LOG_ERROR, "Failed to allocate dynamic parking lot configuration.\n");
      return NULL;
   }

   if (!ast_strlen_zero(dyn_exten)) {
      ast_string_field_set(cfg, parkext, dyn_exten);
   }

   if (!ast_strlen_zero(dyn_context)) {
      ast_string_field_set(cfg, parking_con, dyn_context);
   }

   if (!ast_strlen_zero(dyn_range)) {
      if (sscanf(dyn_range, "%30d-%30d", &dyn_start, &dyn_end) != 2) {
         ast_log(LOG_ERROR,
            "Invalid parking range %s specified in PARKINGDYNPOS: could not parse minimum/maximum parking space range\n", dyn_range);
            return NULL;
      }
      if (dyn_end < dyn_start || dyn_start < 0) {
         ast_log(LOG_ERROR,
            "Invalid parking range %s specified for PARKINGDYNPOS: end parking space must be greater than starting parking space.\n", dyn_range);
            return NULL;
      }

      cfg->parking_start = dyn_start;
      cfg->parking_stop = dyn_end;
   }

   if (parking_lot_cfg_create_extensions(cfg)) {
      ast_log(LOG_ERROR, "Extensions for dynamic parking lot '%s' could not be registered. Dynamic lot creation failed.\n", name);
      return NULL;
   }

   ao2_lock(parking_lot_container);

   if ((lot = parking_lot_find_by_name(name))) {
      ao2_unlock(parking_lot_container);
      ast_log(LOG_ERROR, "Started creating dynamic parking lot '%s', but a parking lot with that name already exists.\n", name);
      ao2_ref(lot, -1);
      return NULL;
   }

   lot = parking_lot_build_or_update(cfg, 1);
   ao2_unlock(parking_lot_container);

   if (!lot) {
      ast_log(LOG_NOTICE, "Failed to build dynamic parking lot '%s'\n", name);
   }

   return lot;
}

disable_marked_lots()

static void disable_marked_lots ( void  )

static

Definition at line 1170 of file res_parking.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, parking_lot::disable_mark, and parking_lot_disable().

Referenced by link_configured_disable_marked_lots().

{
   struct ao2_iterator iter;
   struct parking_lot *lot;

   for (iter = ao2_iterator_init(parking_lot_container, 0); (lot = ao2_iterator_next(&iter)); ao2_ref(lot, -1)) {
      if (lot->disable_mark) {
         parking_lot_disable(lot);
      }
   }

   ao2_iterator_destroy(&iter);
}

extension_is_compatible()

static int extension_is_compatible ( struct parking_lot_cfg *  lot_cfg, const char *  app_type, struct ast_exten *  extension  )

static

Definition at line 730 of file res_parking.c.

References ast_assert, ast_debug, ast_get_context_name(), ast_get_extension_app(), ast_get_extension_context(), ast_get_extension_name(), ast_get_extension_registrar(), ast_log, BASE_REGISTRAR, LOG_ERROR, and parking_lot_cfg::name.

Referenced by parking_lot_cfg_create_extensions().

{
   const char *extension_registrar = ast_get_extension_registrar(extension);
   const char *extension_context = ast_get_context_name(ast_get_extension_context(extension));
   const char *extension_name = ast_get_extension_name(extension);
   const char *extension_application = ast_get_extension_app(extension);

   ast_assert(extension_registrar && extension_context && extension_name && extension_application);

   if (strcmp(extension_registrar, BASE_REGISTRAR)) {
      ast_log(LOG_ERROR, "Parking lot '%s' -- Needs an extension '%s@%s', but that extension is already owned by %s.\n",
              lot_cfg->name, extension_name, extension_context, extension_registrar);
      return 0;
   }

   if (strcmp(extension_application, app_type)) {
      ast_log(LOG_ERROR, "Parking lot '%s' -- Needs an extension '%s@%s' with a non-exclusive %s application, "
              "but a/an %s application is already registered to that extension by %s.\n",
              lot_cfg->name, extension_name, extension_context, app_type,
              extension_application, BASE_REGISTRAR);
      return 0;
   }

   ast_debug(3, "Parking lot '%s' -- extension '%s@%s' with application %s is compatible.\n",
             lot_cfg->name, extension_name, extension_context, app_type);
   return 1;
}

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

generate_or_link_lots_to_configs()

static void generate_or_link_lots_to_configs ( void  )

static

Definition at line 915 of file res_parking.c.

References ao2_cleanup, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, globals, parking_lot_build_or_update(), and RAII_VAR.

Referenced by link_configured_disable_marked_lots().

{
   RAII_VAR(struct parking_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
   struct parking_lot_cfg *lot_cfg;
   struct ao2_iterator iter;

   iter = ao2_iterator_init(cfg->parking_lots, 0);
   for (; (lot_cfg = ao2_iterator_next(&iter)); ao2_ref(lot_cfg, -1)) {
      ao2_cleanup(parking_lot_build_or_update(lot_cfg, 0));
   }
   ao2_iterator_destroy(&iter);
}

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

link_configured_disable_marked_lots()

static void link_configured_disable_marked_lots ( void  )

static

Definition at line 1184 of file res_parking.c.

References disable_marked_lots(), and generate_or_link_lots_to_configs().

{
   generate_or_link_lots_to_configs();
   disable_marked_lots();
}

load_module()

static int load_module ( void  )

static

Definition at line 1207 of file res_parking.c.

References ACO_EXACT, aco_info_init(), aco_option_register, aco_option_register_custom, aco_process_config(), ACO_PROCESS_ERROR, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_list, AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, error(), FLDSET, load_parking_applications(), load_parking_bridge_features(), load_parking_devstate(), load_parking_manager(), load_parking_tests(), load_parking_ui(), NULL, OPT_BOOL_T, OPT_PARKEDHANGUP, OPT_PARKEDPLAY, OPT_PARKEDRECORDING, OPT_PARKEDREPARKING, OPT_PARKEDTRANSFERS, OPT_STRINGFIELD_T, OPT_UINT_T, option_handler_findslot(), option_handler_parkedfeature(), option_handler_parkpos(), parking_global_config::parkeddynamic, parking_lot_sort_fn(), STRFLDSET, and unload_module().

Referenced by reload_module().

{
   parking_lot_container = ao2_container_alloc_list(AO2_ALLOC_OPT_LOCK_MUTEX,
      AO2_CONTAINER_ALLOC_OPT_DUPS_REJECT,
      parking_lot_sort_fn,
      NULL);
   if (!parking_lot_container) {
      goto error;
   }

   if (aco_info_init(&cfg_info)) {
      goto error;
   }

   /* Global options */
   aco_option_register(&cfg_info, "parkeddynamic", ACO_EXACT, global_options, "no", OPT_BOOL_T, 1, FLDSET(struct parking_global_config, parkeddynamic));

   /* Register the per parking lot options. */
   aco_option_register(&cfg_info, "parkext", ACO_EXACT, parking_lot_types, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct parking_lot_cfg, parkext));
   aco_option_register(&cfg_info, "context", ACO_EXACT, parking_lot_types, "parkedcalls", OPT_STRINGFIELD_T, 0, STRFLDSET(struct parking_lot_cfg, parking_con));
   aco_option_register(&cfg_info, "parkingtime", ACO_EXACT, parking_lot_types, "45", OPT_UINT_T, 0, FLDSET(struct parking_lot_cfg, parkingtime));
   aco_option_register(&cfg_info, "comebacktoorigin", ACO_EXACT, parking_lot_types, "yes", OPT_BOOL_T, 1, FLDSET(struct parking_lot_cfg, comebacktoorigin));
   aco_option_register(&cfg_info, "comebackcontext", ACO_EXACT, parking_lot_types, "parkedcallstimeout", OPT_STRINGFIELD_T, 0, STRFLDSET(struct parking_lot_cfg, comebackcontext));
   aco_option_register(&cfg_info, "comebackdialtime", ACO_EXACT, parking_lot_types, "30", OPT_UINT_T, 0, FLDSET(struct parking_lot_cfg, comebackdialtime));
   aco_option_register(&cfg_info, "parkedmusicclass", ACO_EXACT, parking_lot_types, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct parking_lot_cfg, mohclass));
   aco_option_register(&cfg_info, "parkext_exclusive", ACO_EXACT, parking_lot_types, "no", OPT_BOOL_T, 1, FLDSET(struct parking_lot_cfg, parkext_exclusive));
   aco_option_register(&cfg_info, "parkinghints", ACO_EXACT, parking_lot_types, "no", OPT_BOOL_T, 1, FLDSET(struct parking_lot_cfg, parkaddhints));
   aco_option_register(&cfg_info, "courtesytone", ACO_EXACT, parking_lot_types, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct parking_lot_cfg, courtesytone));

   /* More complicated parking lot options that require special handling */
   aco_option_register_custom(&cfg_info, "parkpos", ACO_EXACT, parking_lot_types, "701-750", option_handler_parkpos, 0);
   aco_option_register_custom(&cfg_info, "findslot", ACO_EXACT, parking_lot_types, "first", option_handler_findslot, 0);
   aco_option_register_custom(&cfg_info, "parkedplay", ACO_EXACT, parking_lot_types, "caller", option_handler_parkedfeature, OPT_PARKEDPLAY);
   aco_option_register_custom(&cfg_info, "parkedcalltransfers", ACO_EXACT, parking_lot_types, "no", option_handler_parkedfeature, OPT_PARKEDTRANSFERS);
   aco_option_register_custom(&cfg_info, "parkedcallreparking", ACO_EXACT, parking_lot_types, "no", option_handler_parkedfeature, OPT_PARKEDREPARKING);
   aco_option_register_custom(&cfg_info, "parkedcallhangup", ACO_EXACT, parking_lot_types, "no", option_handler_parkedfeature, OPT_PARKEDHANGUP);
   aco_option_register_custom(&cfg_info, "parkedcallrecording", ACO_EXACT, parking_lot_types, "no", option_handler_parkedfeature, OPT_PARKEDRECORDING);

   if (aco_process_config(&cfg_info, 0) == ACO_PROCESS_ERROR) {
      goto error;
   }

   if (load_parking_applications()) {
      goto error;
   }

   if (load_parking_ui()) {
      goto error;
   }

   if (load_parking_manager()) {
      goto error;
   }

   if (load_parking_bridge_features()) {
      goto error;
   }

   if (load_parking_devstate()) {
      goto error;
   }

   if (load_parking_tests()) {
      goto error;
   }

   return AST_MODULE_LOAD_SUCCESS;

error:
   unload_module();
   return AST_MODULE_LOAD_DECLINE;
}

mark_lots_as_disabled()

static void mark_lots_as_disabled ( void  )

static

Definition at line 1143 of file res_parking.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, and parking_lot::disable_mark.

Referenced by config_parking_preapply().

{
   struct ao2_iterator iter;
   struct parking_lot *lot;

   for (iter = ao2_iterator_init(parking_lot_container, 0); (lot = ao2_iterator_next(&iter)); ao2_ref(lot, -1)) {
      lot->disable_mark = 1;
   }

   ao2_iterator_destroy(&iter);
}

named_item_find()

static void * named_item_find ( struct ao2_container *  container, const char *  name  )

static

find an item in a container by its name

XXX This is actually incredibly generic and might be better placed in something like astobj2 if there isn't already an equivalent

Parameters

container	ao2container where we want the item from
key	name of the item wanted to be found

Return values

pointer

to the parking lot if available. NULL if not found.

Definition at line 496 of file res_parking.c.

References ao2_find, and OBJ_KEY.

Referenced by parking_lot_build_or_update(), and parking_lot_find_by_name().

{
   return ao2_find(container, name, OBJ_KEY);
}

option_handler_findslot()

static int option_handler_findslot ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Custom field handler for the findslot option.

Definition at line 525 of file res_parking.c.

References ast_log, LOG_WARNING, parking_lot_cfg::parkfindnext, and ast_variable::value.

Referenced by load_module().

{
   struct parking_lot_cfg *lot_cfg = obj;

   if (!strcmp(var->value, "first")) {
      lot_cfg->parkfindnext = 0;
   } else if (!strcmp(var->value, "next")) {
      lot_cfg->parkfindnext = 1;
   } else {
      ast_log(LOG_WARNING, "value '%s' is not valid for findslot option.\n", var->value);
      return -1;
   }

   return 0;
}

option_handler_parkedfeature()

static int option_handler_parkedfeature ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Custom field handler for feature mapping on parked call pickup options.

Definition at line 564 of file res_parking.c.

References aco_option_get_flags(), ast_assert, NULL, OPT_PARKEDHANGUP, OPT_PARKEDPLAY, OPT_PARKEDRECORDING, OPT_PARKEDREPARKING, OPT_PARKEDTRANSFERS, parking_lot_cfg::parkedcallhangup, parking_lot_cfg::parkedcallrecording, parking_lot_cfg::parkedcallreparking, parking_lot_cfg::parkedcalltransfers, parking_lot_cfg::parkedplay, parking_feature_flag_cfg(), and ast_variable::value.

Referenced by load_module().

{
   struct parking_lot_cfg *cfg = obj;
   enum parked_call_feature_options option = aco_option_get_flags(opt);
   int *parameter = NULL;

   switch (option) {
   case OPT_PARKEDPLAY:
      parameter = &cfg->parkedplay;
      break;
   case OPT_PARKEDTRANSFERS:
      parameter = &cfg->parkedcalltransfers;
      break;
   case OPT_PARKEDREPARKING:
      parameter = &cfg->parkedcallreparking;
      break;
   case OPT_PARKEDHANGUP:
      parameter = &cfg->parkedcallhangup;
      break;
   case OPT_PARKEDRECORDING:
      parameter = &cfg->parkedcallrecording;
      break;
   }

   ast_assert(parameter != NULL);
   if (!parameter || parking_feature_flag_cfg(parameter, var->value)) {
      return -1;
   }

   return 0;
}

option_handler_parkpos()

static int option_handler_parkpos ( const struct aco_option *  opt, struct ast_variable *  var, void *  obj  )

static

Custom field handler for parking positions.

Definition at line 504 of file res_parking.c.

References ast_log, LOG_WARNING, parking_lot_cfg::parking_start, parking_lot_cfg::parking_stop, and ast_variable::value.

Referenced by load_module().

{
   struct parking_lot_cfg *lot_cfg = obj;
   int low;
   int high;

   if (sscanf(var->value, "%30d-%30d", &low, &high) != 2) {
      ast_log(LOG_WARNING, "Format for parking positions is a-b, where a and b are numbers\n");
   } else if (high < low || low <= 0 || high <= 0) {
      ast_log(LOG_WARNING, "Format for parking positions is a-b, where a <= b\n");
   } else {
      lot_cfg->parking_start = low;
      lot_cfg->parking_stop = high;
      return 0;
   }
   return -1;
}

parked_user_cmp_fn()

static int parked_user_cmp_fn ( void *  obj, void *  arg, int  flags  )

static

Definition at line 435 of file res_parking.c.

References CMP_MATCH, and parked_user::parking_space.

Referenced by alloc_new_parking_lot().

{
   int *search_space = arg;
   struct parked_user *user = obj;
   int object_space = user->parking_space;

   if (*search_space == object_space) {
      return CMP_MATCH;
   }
   return 0;
}

parked_user_sort_fn()

static int parked_user_sort_fn ( const void *  obj_left, const void *  obj_right, int  flags  )

static

Definition at line 447 of file res_parking.c.

References parked_user::parking_space.

Referenced by alloc_new_parking_lot().

{
   const struct parked_user *left = obj_left;
   const struct parked_user *right = obj_right;

   return left->parking_space - right->parking_space;
}

parking_add_extension()

static int parking_add_extension ( struct ast_context *  context, int  replace, const char *  extension, int  priority, const char *  application, const char *  data, const char *  registrar  )

static

Definition at line 713 of file res_parking.c.

References ast_add_extension2_nolock(), ast_free_ptr(), ast_strdup, and NULL.

Referenced by parking_lot_cfg_create_extensions().

{
   char *data_duplicate = ast_strdup(data);

   if (!data_duplicate) {
      return -1;
   }

   if (ast_add_extension2_nolock(context, replace, extension, priority, NULL, NULL,
         application, data_duplicate, ast_free_ptr, registrar, NULL, 0)) {
      return -1;
   }

   return 0;
}

parking_config_alloc()

static void * parking_config_alloc ( void  )

static

allocator callback for parking_config. Notice it returns void * since it is only used by the backend config code

Definition at line 377 of file res_parking.c.

References ao2_alloc, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_hash, ao2_ref, NULL, parking_config_destructor(), parking_global_config_destructor(), parking_lot_cfg_cmp_fn(), parking_lot_cfg_hash_fn(), and RAII_VAR.

{
   RAII_VAR(struct parking_config *, cfg, NULL, ao2_cleanup);

   if (!(cfg = ao2_alloc(sizeof(*cfg), parking_config_destructor))) {
      return NULL;
   }

   cfg->parking_lots = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0, 37,
      parking_lot_cfg_hash_fn, NULL, parking_lot_cfg_cmp_fn);
   if (!cfg->parking_lots) {
      return NULL;
   }

   if (!(cfg->global = ao2_alloc(sizeof(*cfg->global), parking_global_config_destructor))) {
      return NULL;
   }

   /* Bump the ref count since RAII_VAR is going to eat one */
   ao2_ref(cfg, +1);
   return cfg;
}

parking_config_destructor()

static void parking_config_destructor ( void *  obj )

static

destructor for parking_config

Definition at line 363 of file res_parking.c.

References ao2_cleanup, parking_config::global, and parking_config::parking_lots.

Referenced by parking_config_alloc().

{
   struct parking_config *cfg = obj;
   ao2_cleanup(cfg->parking_lots);
   ao2_cleanup(cfg->global);
}

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

static int parking_feature_flag_cfg ( int *  param, const char *  var  )

static

Maps string values for option_handler_parkedfeature to their ENUM values.

Definition at line 544 of file res_parking.c.

References ast_false(), AST_FEATURE_FLAG_BYBOTH, AST_FEATURE_FLAG_BYCALLEE, and AST_FEATURE_FLAG_BYCALLER.

Referenced by option_handler_parkedfeature().

{
   if (ast_false(var)) {
      *param = 0;
   } else if (!strcasecmp(var, "both")) {
      *param = AST_FEATURE_FLAG_BYBOTH;
   } else if (!strcasecmp(var, "caller")) {
      *param = AST_FEATURE_FLAG_BYCALLER;
   } else if (!strcasecmp(var, "callee")) {
      *param = AST_FEATURE_FLAG_BYCALLEE;
   } else {
      return -1;
   }

   return 0;
}

parking_global_config_destructor()

static void parking_global_config_destructor ( void *  obj )

static

destructor for parking_global_config

Definition at line 371 of file res_parking.c.

Referenced by parking_config_alloc().

{
   /* For now, do nothing. */
}

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

static void * parking_lot_cfg_alloc ( const char *  cat )

static

create a parking lot structure

Parameters

cat	name given to the parking lot

Return values

NULL	failure
non-NULL	successfully allocated parking lot

Definition at line 461 of file res_parking.c.

References ao2_alloc, ao2_cleanup, ast_string_field_init, ast_string_field_set, name, NULL, and parking_lot_cfg_destructor().

Referenced by clone_parkinglot_cfg(), parking_lot_cfg_create(), and verify_default_parking_lot().

{
   struct parking_lot_cfg *lot_cfg;

   lot_cfg = ao2_alloc(sizeof(*lot_cfg), parking_lot_cfg_destructor);
   if (!lot_cfg) {
      return NULL;
   }

   if (ast_string_field_init(lot_cfg, 32)) {
      ao2_cleanup(lot_cfg);
      return NULL;
   }

   ast_string_field_set(lot_cfg, name, cat);

   return lot_cfg;
}

parking_lot_cfg_cmp_fn()

static int parking_lot_cfg_cmp_fn ( void *  obj, void *  arg, const int  flags  )

static

Definition at line 338 of file res_parking.c.

References CMP_MATCH, CMP_STOP, parking_lot_cfg::name, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by parking_config_alloc().

{
   struct parking_lot_cfg *entry1 = obj;

   char *key;
   size_t key_size;
   struct parking_lot_cfg *entry2;

   switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
   case OBJ_KEY:
      key = arg;
      return (!strcmp(entry1->name, key)) ? CMP_MATCH : 0;
   case OBJ_PARTIAL_KEY:
      key = arg;
      key_size = strlen(key);
      return (!strncmp(entry1->name, key, key_size)) ? CMP_MATCH : 0;
   case OBJ_POINTER:
      entry2 = arg;
      return (!strcmp(entry1->name, entry2->name)) ? CMP_MATCH : 0;
   default:
      return CMP_STOP;
   }
}

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

static void parking_lot_cfg_destructor ( void *  obj )

static

Destroy a parking lot cfg object.

Definition at line 427 of file res_parking.c.

References ast_string_field_free_memory, and parking_lot_cfg_remove_extensions().

Referenced by parking_lot_cfg_alloc().

{
   struct parking_lot_cfg *lot_cfg = obj;
   parking_lot_cfg_remove_extensions(lot_cfg);
   ast_string_field_free_memory(lot_cfg);
}

parking_lot_cfg_hash_fn()

static int parking_lot_cfg_hash_fn ( const void *  obj, const int  flags  )

static

Definition at line 320 of file res_parking.c.

References ast_assert, ast_str_hash(), parking_lot_cfg::name, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by parking_config_alloc().

{
   const struct parking_lot_cfg *entry;
   const char *key;

   switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
   case OBJ_KEY:
      key = obj;
      return ast_str_hash(key);
   case OBJ_PARTIAL_KEY:
      ast_assert(0);
      return 0;
   default:
      entry = obj;
      return ast_str_hash(entry->name);
   }
}

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

static void parking_lot_destructor ( void *  obj )

static

Definition at line 625 of file res_parking.c.

References ao2_cleanup, ast_bridge_destroy(), ast_string_field_free_memory, parking_lot::cfg, parking_lot::parked_users, and parking_lot::parking_bridge.

Referenced by alloc_new_parking_lot().

{
   struct parking_lot *lot = obj;

   if (lot->parking_bridge) {
      ast_bridge_destroy(lot->parking_bridge, 0);
   }
   ao2_cleanup(lot->parked_users);
   ao2_cleanup(lot->cfg);
   ast_string_field_free_memory(lot);
}

parking_lot_disable()

static void parking_lot_disable ( struct parking_lot *  lot )

static

Definition at line 414 of file res_parking.c.

References parking_lot::disable_mark, parking_lot::mode, parking_lot_remove_if_unused(), PARKINGLOT_DISABLED, and PARKINGLOT_DYNAMIC.

Referenced by disable_marked_lots().

{
   /* If a dynamic lot wasn't removed, we need to restore it to full functionality afterwards. */
   int was_dynamic = (lot->mode == PARKINGLOT_DYNAMIC);

   lot->mode = PARKINGLOT_DISABLED;
   if (parking_lot_remove_if_unused(lot) && was_dynamic) {
      lot->mode = PARKINGLOT_DYNAMIC;
      lot->disable_mark = 0;
   }
}

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

static int parking_lot_sort_fn ( const void *  obj_left, const void *  obj_right, int  flags  )

static

Definition at line 244 of file res_parking.c.

References parking_lot::name, OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by load_module().

{
   const struct parking_lot *left = obj_left;
   const struct parking_lot *right = obj_right;
   const char *right_key = obj_right;
   int cmp;

   switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
   default:
   case OBJ_POINTER:
      right_key = right->name;
      /* Fall through */
   case OBJ_KEY:
      cmp = strcmp(left->name, right_key);
      break;
   case OBJ_PARTIAL_KEY:
      cmp = strncmp(left->name, right_key, strlen(right_key));
   }
   return cmp;
}

reload_module()

static int reload_module ( void  )

static

Definition at line 1280 of file res_parking.c.

References aco_process_config(), ACO_PROCESS_ERROR, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_DEVSTATE_PROVIDER, AST_MODULE_INFO(), AST_MODULE_LOAD_DECLINE, AST_MODULE_SUPPORT_CORE, ASTERISK_GPL_KEY, load_module(), reload(), and unload_module().

{
   if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) {
      return AST_MODULE_LOAD_DECLINE;
   }

   return 0;
}

remove_all_configured_parking_lot_extensions()

static void remove_all_configured_parking_lot_extensions ( void  )

static

Definition at line 678 of file res_parking.c.

References ao2_cleanup, ao2_global_obj_ref, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_context_destroy(), BASE_REGISTRAR, parking_lot::cfg, globals, NULL, parking_lot_cfg_remove_extensions(), and RAII_VAR.

Referenced by configure_parking_extensions(), and unload_module().

{
   RAII_VAR(struct parking_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
   struct parking_lot_cfg *lot_cfg;
   struct ao2_iterator iter;

   if (!cfg) {
      return;
   }

   for (iter = ao2_iterator_init(cfg->parking_lots, 0); (lot_cfg = ao2_iterator_next(&iter)); ao2_ref(lot_cfg, -1)) {
      parking_lot_cfg_remove_extensions(lot_cfg);
   }

   ast_context_destroy(NULL, BASE_REGISTRAR);

   ao2_iterator_destroy(&iter);
}

remove_pending_parking_lot_extensions()

static void remove_pending_parking_lot_extensions ( struct parking_config *  cfg_pending )

static

Definition at line 1095 of file res_parking.c.

References ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_context_destroy(), BASE_REGISTRAR, NULL, parking_lot_cfg_remove_extensions(), and parking_config::parking_lots.

Referenced by configure_parking_extensions().

{
   struct parking_lot_cfg *lot_cfg;
   struct ao2_iterator iter;

   for (iter = ao2_iterator_init(cfg_pending->parking_lots, 0); (lot_cfg = ao2_iterator_next(&iter)); ao2_ref(lot_cfg, -1)) {
      parking_lot_cfg_remove_extensions(lot_cfg);
   }

   ao2_iterator_destroy(&iter);

   ast_context_destroy(NULL, BASE_REGISTRAR);

}

unload_module()

static int unload_module ( void  )

static

Definition at line 1190 of file res_parking.c.

References aco_info_destroy(), ao2_cleanup, ao2_global_obj_release, globals, NULL, remove_all_configured_parking_lot_extensions(), unload_parking_applications(), unload_parking_bridge_features(), unload_parking_devstate(), unload_parking_manager(), unload_parking_tests(), and unload_parking_ui().

Referenced by load_module(), and reload_module().

{
   unload_parking_bridge_features();
   remove_all_configured_parking_lot_extensions();
   unload_parking_applications();
   unload_parking_manager();
   unload_parking_ui();
   unload_parking_devstate();
   unload_parking_tests();
   ao2_cleanup(parking_lot_container);
   parking_lot_container = NULL;
   aco_info_destroy(&cfg_info);
   ao2_global_obj_release(globals);

   return 0;
}

verify_default_parking_lot()

static int verify_default_parking_lot ( void  )

static

Definition at line 1071 of file res_parking.c.

References aco_pending_config(), aco_set_defaults(), ao2_cleanup, ao2_find, ao2_link, ast_log, AST_LOG_NOTICE, ast_string_field_set, DEFAULT_PARKING_EXTEN, DEFAULT_PARKING_LOT, NULL, OBJ_KEY, parking_lot_cfg_alloc(), parking_config::parking_lots, and RAII_VAR.

Referenced by config_parking_preapply().

{
   struct parking_config *cfg = aco_pending_config(&cfg_info);
   RAII_VAR(struct parking_lot_cfg *, lot_cfg, NULL, ao2_cleanup);

   if (!cfg) {
      return 0;
   }

   lot_cfg = ao2_find(cfg->parking_lots, DEFAULT_PARKING_LOT, OBJ_KEY);
   if (!lot_cfg) {
      lot_cfg = parking_lot_cfg_alloc(DEFAULT_PARKING_LOT);
      if (!lot_cfg) {
         return -1;
      }
      ast_log(AST_LOG_NOTICE, "Adding %s profile to res_parking\n", DEFAULT_PARKING_LOT);
      aco_set_defaults(&parking_lot_type, DEFAULT_PARKING_LOT, lot_cfg);
      ast_string_field_set(lot_cfg, parkext, DEFAULT_PARKING_EXTEN);
      ao2_link(cfg->parking_lots, lot_cfg);
   }

   return 0;
}

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Call Parking Resource" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_DEVSTATE_PROVIDER, }

static

Definition at line 1295 of file res_parking.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1295 of file res_parking.c.

global_option

struct aco_type global_option

static

Definition at line 285 of file res_parking.c.

global_options

struct aco_type* global_options[] = ACO_TYPES(&global_option)

Definition at line 293 of file res_parking.c.

parking_lot_conf

struct aco_file parking_lot_conf

Initial value:

= {
   .filename = "res_parking.conf",
   .types = ACO_TYPES(&global_option, &parking_lot_type),
}

Definition at line 307 of file res_parking.c.

parking_lot_container

struct ao2_container* parking_lot_container

static

All parking lots that are currently alive in some fashion can be obtained from here

Definition at line 266 of file res_parking.c.

Referenced by get_parking_lot_container().

parking_lot_type

struct aco_type parking_lot_type

static

Definition at line 295 of file res_parking.c.

parking_lot_types

struct aco_type* parking_lot_types[] = ACO_TYPES(&parking_lot_type)

Definition at line 305 of file res_parking.c.