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...
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)
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 = AST_BUILDOPT_SUM, .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 1296 of file res_parking.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 1296 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 638 of file res_parking.c.

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

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

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

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

References ast_string_field_set, ast_string_fields_copy, parking_lot_cfg::comebackdialtime, parking_lot_cfg::comebacktoorigin, name, 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().

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

{
    mark_lots_as_disabled();
 
    if (verify_default_parking_lot()) {
        return -1;
    }
 
    if (configure_parking_extensions()) {
        return -1;
    }
 
    return 0;
}

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

configure_parking_extensions()

static int configure_parking_extensions ( void  )

static

Definition at line 1111 of file res_parking.c.

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

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

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

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

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, name, NULL, parking_dynamic_lots_enabled(), parking_lot_build_or_update(), parking_lot_cfg_create_extensions(), parking_lot_container, 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().

disable_marked_lots()

static void disable_marked_lots ( void  )

static

Definition at line 1171 of file res_parking.c.

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

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

Referenced by link_configured_disable_marked_lots().

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

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

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

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

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

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

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

generate_or_link_lots_to_configs()

static void generate_or_link_lots_to_configs ( void  )

static

Definition at line 916 of file res_parking.c.

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

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

get_parking_lot_container()

struct ao2_container * get_parking_lot_container

(

void

)

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

Since

12.0.0

Returns

pointer to the parking lot container.

Definition at line 597 of file res_parking.c.

{
    return parking_lot_container;
}

References parking_lot_container.

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

link_configured_disable_marked_lots()

static void link_configured_disable_marked_lots ( void  )

static

Definition at line 1185 of file res_parking.c.

{
    generate_or_link_lots_to_configs();
    disable_marked_lots();
}

References disable_marked_lots(), and generate_or_link_lots_to_configs().

load_module()

static int load_module ( void  )

static

Definition at line 1208 of file res_parking.c.

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

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, global_options, 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_lot_container, parking_lot_sort_fn(), parking_lot_types, STRFLDSET, and unload_module().

mark_lots_as_disabled()

static void mark_lots_as_disabled ( void  )

static

Definition at line 1144 of file res_parking.c.

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

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

Referenced by config_parking_preapply().

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
name	name of the item wanted to be found

Returns

pointer to the parking lot if available.

Return values

NULL	if not found.

Definition at line 497 of file res_parking.c.

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

References ao2_find, container, name, and OBJ_KEY.

Referenced by parking_lot_build_or_update(), and parking_lot_find_by_name().

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

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

References ast_log, LOG_WARNING, parking_lot_cfg::parkfindnext, and var.

Referenced by load_module().

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

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

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

Referenced by load_module().

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

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

References ast_log, LOG_WARNING, parking_lot_cfg::parking_start, parking_lot_cfg::parking_stop, and var.

Referenced by load_module().

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.

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

References CMP_MATCH.

Referenced by alloc_new_parking_lot().

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.

{
    const struct parked_user *left = obj_left;
    const struct parked_user *right = obj_right;
 
    return left->parking_space - right->parking_space;
}

References parked_user::parking_space.

Referenced by alloc_new_parking_lot().

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

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

References ast_add_extension2_nolock(), ast_free_ptr(), ast_strdup, voicemailpwcheck::context, NULL, priority, registrar, and replace().

Referenced by parking_lot_cfg_create_extensions().

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.

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

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.

parking_config_destructor()

static void parking_config_destructor ( void *  obj )

static

destructor for parking_config

Definition at line 363 of file res_parking.c.

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

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

Referenced by parking_config_alloc().

parking_create_dynamic_lot()

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

Create a dynamic parking lot.

Since

12.0.0

Parameters

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

Returns

dynamically created parking lot on success

Return values

NULL

on error

Note

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

Definition at line 1060 of file res_parking.c.

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

References create_dynamic_lot_full(), and name.

Referenced by park_common_setup2(), and parking_park_call().

parking_dynamic_lots_enabled()

int parking_dynamic_lots_enabled

(

void

)

Check global configuration to see if dynamic parking is enabled.

Since

12.0.0

Return values

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

Definition at line 929 of file res_parking.c.

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

References ao2_cleanup, ao2_global_obj_ref, globals, and RAII_VAR.

Referenced by cli_display_parking_global(), and create_dynamic_lot_full().

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

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

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

Referenced by option_handler_parkedfeature().

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.

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

Referenced by parking_config_alloc().

parking_lot_build_or_update()

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

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

Since

12.0.0

Parameters

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

Returns

A reference to the new parking lot

Return values

NULL	if it was not found and could not be allocated

Note

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

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

Definition at line 869 of file res_parking.c.

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

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

Referenced by create_dynamic_lot_full(), and generate_or_link_lots_to_configs().

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

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

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

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.

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

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

Referenced by parking_config_alloc().

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

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

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

Referenced by configure_parking_extensions(), and create_dynamic_lot_full().

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

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

References ast_string_field_free_memory, and parking_lot_cfg_remove_extensions().

Referenced by parking_lot_cfg_alloc().

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.

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

References ast_assert, ast_str_hash(), OBJ_KEY, OBJ_PARTIAL_KEY, and OBJ_POINTER.

Referenced by parking_config_alloc().

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

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

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

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

parking_lot_destructor()

static void parking_lot_destructor ( void *  obj )

static

Definition at line 626 of file res_parking.c.

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

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

parking_lot_disable()

static void parking_lot_disable ( struct parking_lot *  lot )

static

Definition at line 414 of file res_parking.c.

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

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

Referenced by disable_marked_lots().

parking_lot_find_by_name()

struct parking_lot * parking_lot_find_by_name

(

const char *

lot_name

)

Find a parking lot based on its name.

Since

12.0.0

Parameters

lot_name

Name of the parking lot sought

Returns

The parking lot if found

Return values

NULL	if no parking lot with the name specified exists

Note

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

Definition at line 602 of file res_parking.c.

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

References named_item_find(), and parking_lot_container.

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

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

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

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

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

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

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

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

Referenced by load_module().

reload_module()

static int reload_module ( void  )

static

Definition at line 1281 of file res_parking.c.

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

References aco_process_config(), ACO_PROCESS_ERROR, and AST_MODULE_LOAD_DECLINE.

remove_all_configured_parking_lot_extensions()

static void remove_all_configured_parking_lot_extensions ( void  )

static

Definition at line 679 of file res_parking.c.

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

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

remove_pending_parking_lot_extensions()

static void remove_pending_parking_lot_extensions ( struct parking_config *  cfg_pending )

static

Definition at line 1096 of file res_parking.c.

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

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

unload_module()

static int unload_module ( void  )

static

Definition at line 1191 of file res_parking.c.

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

References aco_info_destroy(), ao2_cleanup, ao2_global_obj_release, globals, NULL, parking_lot_container, 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().

verify_default_parking_lot()

static int verify_default_parking_lot ( void  )

static

Definition at line 1072 of file res_parking.c.

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

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_lot_type, parking_config::parking_lots, and RAII_VAR.

Referenced by config_parking_preapply().

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 = AST_BUILDOPT_SUM, .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 1296 of file res_parking.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 1296 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.

Referenced by load_module().

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 create_dynamic_lot_full(), disable_marked_lots(), get_parking_lot_container(), load_module(), mark_lots_as_disabled(), parking_lot_build_or_update(), parking_lot_find_by_name(), parking_lot_remove_if_unused(), and unload_module().

parking_lot_type

struct aco_type parking_lot_type

static

Definition at line 295 of file res_parking.c.

Referenced by verify_default_parking_lot().

parking_lot_types

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

Definition at line 305 of file res_parking.c.

Referenced by load_module().