In the event that the desired extension already exists, ast_add_extension2_lockopt() will free the 'data' it is passed before returning an error, so we should not be freeing it ourselves. Additionally, there were two places where ast_add_extension2_lockopt() could return an error without also freeing the 'data' pointer, so we add that. ASTERISK-29097 #close Change-Id: I904707aae55169feda050a5ed7c6793b53fe6eae
1296 lines
44 KiB
C
1296 lines
44 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 2013, Digium, Inc.
|
|
*
|
|
* Jonathan Rose <jrose@digium.com>
|
|
*
|
|
* See http://www.asterisk.org for more information about
|
|
* the Asterisk project. Please do not directly contact
|
|
* any of the maintainers of this project for assistance;
|
|
* the project provides a web site, mailing lists and IRC
|
|
* channels for your use.
|
|
*
|
|
* This program is free software, distributed under the terms of
|
|
* the GNU General Public License Version 2. See the LICENSE file
|
|
* at the top of the source tree.
|
|
*/
|
|
|
|
/*! \file
|
|
*
|
|
* \brief Call Parking Resource
|
|
*
|
|
* \author Jonathan Rose <jrose@digium.com>
|
|
*/
|
|
|
|
/*** MODULEINFO
|
|
<depend>bridge_holding</depend>
|
|
<support_level>core</support_level>
|
|
***/
|
|
|
|
/*** DOCUMENTATION
|
|
<configInfo name="res_parking" language="en_US">
|
|
<configFile name="res_parking.conf">
|
|
<configObject name="globals">
|
|
<synopsis>Options that apply to every parking lot</synopsis>
|
|
<configOption name="parkeddynamic">
|
|
<synopsis>Enables dynamically created parkinglots.</synopsis>
|
|
<description>
|
|
<para>If the option is enabled then the following variables can
|
|
be used to dynamically create new parking lots.
|
|
</para>
|
|
<para>The <variable>PARKINGDYNAMIC</variable> variable specifies the
|
|
parking lot to use as a template to create a dynamic parking lot. It
|
|
is an error to specify a non-existent parking lot for the template.
|
|
If not set then the default parking lot is used as the template.
|
|
</para>
|
|
<para>The <variable>PARKINGDYNCONTEXT</variable> variable specifies the
|
|
dialplan context to use for the newly created dynamic parking lot. If
|
|
not set then the context from the parking lot template is used. The
|
|
context is created if it does not already exist and the new parking lot
|
|
needs to create extensions.
|
|
</para>
|
|
<para>The <variable>PARKINGDYNEXTEN</variable> variable specifies the
|
|
<literal>parkext</literal> to use for the newly created dynamic
|
|
parking lot. If not set then the <literal>parkext</literal> is used from
|
|
the parking lot template. If the template does not specify a
|
|
<literal>parkext</literal> then no extensions are created for the newly
|
|
created parking lot. The dynamic parking lot cannot be created if it
|
|
needs to create extensions that overlap existing parking lot extensions.
|
|
The only exception to this is for the <literal>parkext</literal>
|
|
extension and only if neither of the overlaping parking lot's
|
|
<literal>parkext</literal> is exclusive.
|
|
</para>
|
|
<para>The <variable>PARKINGDYNPOS</variable> variable specifies the
|
|
parking positions to use for the newly created dynamic parking lot. If
|
|
not set then the <literal>parkpos</literal> from the parking lot template
|
|
is used.
|
|
</para>
|
|
</description>
|
|
</configOption>
|
|
</configObject>
|
|
<configObject name="parking_lot">
|
|
<synopsis>Defined parking lots for res_parking to use to park calls on</synopsis>
|
|
<configOption name="context" default="parkedcalls">
|
|
<synopsis>The name of the context where calls are parked and picked up from.</synopsis>
|
|
<description><para>This option is only used if parkext is set.</para></description>
|
|
</configOption>
|
|
<configOption name="parkext">
|
|
<synopsis>Extension to park calls to this parking lot.</synopsis>
|
|
<description>
|
|
<para>If this option is used, this extension will automatically
|
|
be created to place calls into parking lots. In addition, if
|
|
<literal>parkext_exclusive</literal> is set for this parking
|
|
lot, the name of the parking lot will be included in the
|
|
application's arguments so that it only parks to this parking
|
|
lot. The extension will be created in <literal>context</literal>.
|
|
Using this option also creates extensions for retrieving
|
|
parked calls from the parking spaces in the same context.
|
|
</para>
|
|
<note>
|
|
<para>Generated parking extensions cannot overlap.
|
|
The only exception is if neither overlapping
|
|
<literal>parkext</literal> is exclusive.
|
|
</para>
|
|
</note>
|
|
</description>
|
|
</configOption>
|
|
<configOption name="parkext_exclusive" default="no">
|
|
<synopsis>If yes, the extension registered as parkext will park exclusively to this parking lot.</synopsis>
|
|
</configOption>
|
|
<configOption name="parkpos" default="701-750">
|
|
<synopsis>Numerical range of parking spaces which can be used to retrieve parked calls.</synopsis>
|
|
<description>
|
|
<para>If <literal>parkext</literal> is set, these extensions
|
|
will automatically be mapped in <literal>context</literal>
|
|
in order to pick up calls parked to these parking spaces.
|
|
</para>
|
|
</description>
|
|
</configOption>
|
|
<configOption name="parkinghints" default="no">
|
|
<synopsis>If yes, this parking lot will add hints automatically for parking spaces.</synopsis>
|
|
</configOption>
|
|
<configOption name="parkingtime" default="45">
|
|
<synopsis>Amount of time a call will remain parked before giving up (in seconds).</synopsis>
|
|
</configOption>
|
|
<configOption name="parkedmusicclass">
|
|
<synopsis>Which music class to use for parked calls. They will use the default if unspecified.</synopsis>
|
|
</configOption>
|
|
<configOption name="comebacktoorigin" default="yes">
|
|
<synopsis>Determines what should be done with the parked channel if no one picks it up before it times out.</synopsis>
|
|
<description><para>Valid Options:</para>
|
|
<enumlist>
|
|
<enum name="yes">
|
|
<para>Automatically have the parked channel dial the device that parked the call with dial
|
|
timeout set by the <literal>parkingtime</literal> option. When the call times out an extension
|
|
to dial the PARKER will automatically be created in the <literal>park-dial</literal> context with
|
|
an extension of the flattened parker device name. If the call is not answered, the parked channel
|
|
that is timing out will continue in the dial plan at that point if there are more priorities in
|
|
the extension (which won't be the case unless the dialplan deliberately includes such priorities
|
|
in the <literal>park-dial</literal> context through pattern matching or deliberately written
|
|
flattened peer extensions).</para>
|
|
</enum>
|
|
<enum name="no">
|
|
<para>Place the call into the PBX at <literal>comebackcontext</literal> instead. The extension will
|
|
still be set as the flattened peer name. If an extension the flattened peer name isn't available
|
|
then it will fall back to the <literal>s</literal> extension. If that also is unavailable it will
|
|
attempt to fall back to <literal>s@default</literal>. The normal dial extension will still be
|
|
created in the <literal>park-dial</literal> context with the extension also being the flattened
|
|
peer name.</para>
|
|
</enum>
|
|
</enumlist>
|
|
<note><para>Flattened Peer Names - Extensions can not include slash characters since those are used for pattern
|
|
matching. When a peer name is flattened, slashes become underscores. For example if the parker of a call
|
|
is called <literal>SIP/0004F2040001</literal> then flattened peer name and therefor the extensions created
|
|
and used on timeouts will be <literal>SIP_0004F204001</literal>.</para></note>
|
|
<note><para>When parking times out and the channel returns to the dial plan, the following variables are set:
|
|
</para></note>
|
|
<variablelist>
|
|
<variable name="PARKING_SPACE">
|
|
<para>extension that the call was parked in prior to timing out.</para>
|
|
</variable>
|
|
<variable name="PARKEDLOT">
|
|
<para>name of the lot that the call was parked in prior to timing out.</para>
|
|
</variable>
|
|
<variable name="PARKER">
|
|
<para>The device that parked the call</para>
|
|
</variable>
|
|
<variable name="PARKER_FLAT">
|
|
<para>The flat version of <variable>PARKER</variable></para>
|
|
</variable>
|
|
</variablelist>
|
|
</description>
|
|
</configOption>
|
|
<configOption name="comebackdialtime" default="30">
|
|
<synopsis>Timeout for the Dial extension created to call back the parker when a parked call times out.</synopsis>
|
|
</configOption>
|
|
<configOption name="comebackcontext" default="parkedcallstimeout">
|
|
<synopsis>Context where parked calls will enter the PBX on timeout when comebacktoorigin=no</synopsis>
|
|
<description><para>The extension the call enters will prioritize the flattened peer name in this context.
|
|
If the flattened peer name extension is unavailable, then the 's' extension in this context will be
|
|
used. If that also is unavailable, the 's' extension in the 'default' context will be used.</para>
|
|
</description>
|
|
</configOption>
|
|
<configOption name="courtesytone">
|
|
<synopsis>If the name of a sound file is provided, use this as the courtesy tone</synopsis>
|
|
<description><para>By default, this tone is only played to the caller of a parked call. Who receives the tone
|
|
can be changed using the <literal>parkedplay</literal> option.</para>
|
|
</description>
|
|
</configOption>
|
|
<configOption name="parkedplay" default="caller">
|
|
<synopsis>Who we should play the courtesytone to on the pickup of a parked call from this lot</synopsis>
|
|
<description>
|
|
<enumlist>
|
|
<enum name="no"><para>Apply to neither side.</para></enum>
|
|
<enum name="caller"><para>Apply only to the call connecting with the call coming out of the parking lot.</para></enum>
|
|
<enum name="callee"><para>Apply only to the call coming out of the parking lot.</para></enum>
|
|
<enum name="both"><para>Apply to both sides.</para></enum>
|
|
</enumlist>
|
|
<note><para>If courtesy tone is not specified then this option will be ignored.</para></note>
|
|
</description>
|
|
</configOption>
|
|
<configOption name="parkedcalltransfers" default="no">
|
|
<synopsis>Who to apply the DTMF transfer features to when parked calls are picked up or timeout.</synopsis>
|
|
<description>
|
|
<xi:include xpointer="xpointer(/docs/configInfo[@name='res_parking']/configFile[@name='res_parking.conf']/configObject[@name='parking_lot']/configOption[@name='parkedplay']/description/enumlist)" />
|
|
</description>
|
|
</configOption>
|
|
<configOption name="parkedcallreparking" default="no">
|
|
<synopsis>Who to apply the DTMF parking feature to when parked calls are picked up or timeout.</synopsis>
|
|
<description>
|
|
<xi:include xpointer="xpointer(/docs/configInfo[@name='res_parking']/configFile[@name='res_parking.conf']/configObject[@name='parking_lot']/configOption[@name='parkedplay']/description/enumlist)" />
|
|
</description>
|
|
</configOption>
|
|
<configOption name="parkedcallhangup" default="no">
|
|
<synopsis>Who to apply the DTMF hangup feature to when parked calls are picked up or timeout.</synopsis>
|
|
<description>
|
|
<xi:include xpointer="xpointer(/docs/configInfo[@name='res_parking']/configFile[@name='res_parking.conf']/configObject[@name='parking_lot']/configOption[@name='parkedplay']/description/enumlist)" />
|
|
</description>
|
|
</configOption>
|
|
<configOption name="parkedcallrecording" default="no">
|
|
<synopsis>Who to apply the DTMF MixMonitor recording feature to when parked calls are picked up or timeout.</synopsis>
|
|
<description>
|
|
<xi:include xpointer="xpointer(/docs/configInfo[@name='res_parking']/configFile[@name='res_parking.conf']/configObject[@name='parking_lot']/configOption[@name='parkedplay']/description/enumlist)" />
|
|
</description>
|
|
</configOption>
|
|
<configOption name="findslot" default="first">
|
|
<synopsis>Rule to use when trying to figure out which parking space a call should be parked with.</synopsis>
|
|
<description>
|
|
<enumlist>
|
|
<enum name="first"><para>Always try to place in the lowest available space in the parking lot</para></enum>
|
|
<enum name="next"><para>Track the last parking space used and always attempt to use the one immediately after.
|
|
</para></enum>
|
|
</enumlist>
|
|
</description>
|
|
</configOption>
|
|
</configObject>
|
|
</configFile>
|
|
</configInfo>
|
|
***/
|
|
|
|
#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"
|
|
|
|
static int parking_lot_sort_fn(const void *obj_left, const void *obj_right, int flags)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*! All parking lots that are currently alive in some fashion can be obtained from here */
|
|
static struct ao2_container *parking_lot_container;
|
|
|
|
static void *parking_config_alloc(void);
|
|
|
|
static void *parking_lot_cfg_alloc(const char *cat);
|
|
static void *named_item_find(struct ao2_container *container, const char *name); /* XXX This is really just a generic string find. Move to astobj2.c? */
|
|
|
|
static int config_parking_preapply(void);
|
|
static void link_configured_disable_marked_lots(void);
|
|
|
|
struct parking_global_config {
|
|
int parkeddynamic;
|
|
};
|
|
|
|
struct parking_config {
|
|
struct parking_global_config *global;
|
|
struct ao2_container *parking_lots;
|
|
};
|
|
|
|
static struct aco_type global_option = {
|
|
.type = ACO_GLOBAL,
|
|
.name = "globals",
|
|
.item_offset = offsetof(struct parking_config, global),
|
|
.category_match = ACO_WHITELIST_EXACT,
|
|
.category = "general",
|
|
};
|
|
|
|
struct aco_type *global_options[] = ACO_TYPES(&global_option);
|
|
|
|
static struct aco_type parking_lot_type = {
|
|
.type = ACO_ITEM,
|
|
.name = "parking_lot",
|
|
.category_match = ACO_BLACKLIST_EXACT,
|
|
.category = "general",
|
|
.item_alloc = parking_lot_cfg_alloc,
|
|
.item_find = named_item_find,
|
|
.item_offset = offsetof(struct parking_config, parking_lots),
|
|
};
|
|
|
|
struct aco_type *parking_lot_types[] = ACO_TYPES(&parking_lot_type);
|
|
|
|
struct aco_file parking_lot_conf = {
|
|
.filename = "res_parking.conf",
|
|
.types = ACO_TYPES(&global_option, &parking_lot_type),
|
|
};
|
|
|
|
static AO2_GLOBAL_OBJ_STATIC(globals);
|
|
|
|
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 parking_lot_cfg_hash_fn(const void *obj, const int flags)
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
static int parking_lot_cfg_cmp_fn(void *obj, void *arg, const int flags)
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
|
|
/*! \brief destructor for parking_config */
|
|
static void parking_config_destructor(void *obj)
|
|
{
|
|
struct parking_config *cfg = obj;
|
|
ao2_cleanup(cfg->parking_lots);
|
|
ao2_cleanup(cfg->global);
|
|
}
|
|
|
|
/*! \brief destructor for parking_global_config */
|
|
static void parking_global_config_destructor(void *obj)
|
|
{
|
|
/* For now, do nothing. */
|
|
}
|
|
|
|
/*! \brief allocator callback for parking_config. Notice it returns void * since it is only used by the backend config code */
|
|
static void *parking_config_alloc(void)
|
|
{
|
|
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;
|
|
}
|
|
|
|
int parking_lot_remove_if_unused(struct parking_lot *lot)
|
|
{
|
|
if (lot->mode != PARKINGLOT_DISABLED) {
|
|
return -1;
|
|
}
|
|
|
|
if (!ao2_container_count(lot->parked_users)) {
|
|
ao2_unlink(parking_lot_container, lot);
|
|
return 0;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static void parking_lot_disable(struct parking_lot *lot)
|
|
{
|
|
/* 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;
|
|
}
|
|
}
|
|
|
|
/*! \brief Destroy a parking lot cfg object */
|
|
static void parking_lot_cfg_destructor(void *obj)
|
|
{
|
|
struct parking_lot_cfg *lot_cfg = obj;
|
|
parking_lot_cfg_remove_extensions(lot_cfg);
|
|
ast_string_field_free_memory(lot_cfg);
|
|
}
|
|
|
|
/* The arg just needs to have the parking space with it */
|
|
static int parked_user_cmp_fn(void *obj, void *arg, int flags)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static int parked_user_sort_fn(const void *obj_left, const void *obj_right, int flags)
|
|
{
|
|
const struct parked_user *left = obj_left;
|
|
const struct parked_user *right = obj_right;
|
|
|
|
return left->parking_space - right->parking_space;
|
|
}
|
|
|
|
/*!
|
|
* \brief create a parking lot structure
|
|
* \param cat name given to the parking lot
|
|
* \retval NULL failure
|
|
* \retval non-NULL successfully allocated parking lot
|
|
*/
|
|
static void *parking_lot_cfg_alloc(const char *cat)
|
|
{
|
|
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;
|
|
}
|
|
|
|
#if defined(TEST_FRAMEWORK)
|
|
struct parking_lot_cfg *parking_lot_cfg_create(const char *cat)
|
|
{
|
|
return parking_lot_cfg_alloc(cat);
|
|
}
|
|
#endif
|
|
|
|
/*!
|
|
* XXX This is actually incredibly generic and might be better placed in something like astobj2 if there isn't already an equivalent
|
|
* \brief find an item in a container by its name
|
|
*
|
|
* \param container ao2container where we want the item from
|
|
* \param key name of the item wanted to be found
|
|
*
|
|
* \retval pointer to the parking lot if available. NULL if not found.
|
|
*/
|
|
static void *named_item_find(struct ao2_container *container, const char *name)
|
|
{
|
|
return ao2_find(container, name, OBJ_KEY);
|
|
}
|
|
|
|
/*!
|
|
* \brief Custom field handler for parking positions
|
|
*/
|
|
static int option_handler_parkpos(const struct aco_option *opt, struct ast_variable *var, void *obj)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*!
|
|
* \brief Custom field handler for the findslot option
|
|
*/
|
|
static int option_handler_findslot(const struct aco_option *opt, struct ast_variable *var, void *obj)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*!
|
|
* \brief Maps string values for option_handler_parkedfeature to their ENUM values
|
|
*/
|
|
static int parking_feature_flag_cfg(int *param, const char *var)
|
|
{
|
|
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;
|
|
}
|
|
|
|
/*!
|
|
* \brief Custom field handler for feature mapping on parked call pickup options
|
|
*/
|
|
static int option_handler_parkedfeature(const struct aco_option *opt, struct ast_variable *var, void *obj)
|
|
{
|
|
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;
|
|
}
|
|
|
|
struct ao2_container *get_parking_lot_container(void)
|
|
{
|
|
return parking_lot_container;
|
|
}
|
|
|
|
struct parking_lot *parking_lot_find_by_name(const char *lot_name)
|
|
{
|
|
struct parking_lot *lot = named_item_find(parking_lot_container, lot_name);
|
|
return lot;
|
|
}
|
|
|
|
const char *find_channel_parking_lot_name(struct ast_channel *chan)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void parking_lot_destructor(void *obj)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static struct parking_lot *alloc_new_parking_lot(struct parking_lot_cfg *lot_cfg)
|
|
{
|
|
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;
|
|
}
|
|
|
|
void parking_lot_cfg_remove_extensions(struct parking_lot_cfg *lot_cfg)
|
|
{
|
|
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, "");
|
|
}
|
|
|
|
static void remove_all_configured_parking_lot_extensions(void)
|
|
{
|
|
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);
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
* \since 12
|
|
* \brief Create an extension using ast_add_extension2_nolock. This function automatically allocates a duplicate
|
|
* of the data string so that whatever calls it doesn't have to deal with freeing it if the ast_add_extension2_nolock
|
|
* fails.
|
|
*
|
|
* \param context a write locked ast_context. Make certain it is write locked prior to calling this function
|
|
* \param replace whether the extension should replace existing extensions
|
|
* \param extension name of the extension desired
|
|
* \param priority priority of the extension we are registering
|
|
* \param application name of the application being used for the extension
|
|
* \param data application arguments
|
|
* \param registrar name of the registrar you should use for the extension.
|
|
* Make sure this string doesn't go anywhere while there are still extensions using it.
|
|
*/
|
|
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)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static int extension_is_compatible(struct parking_lot_cfg *lot_cfg, const char *app_type, struct ast_exten *extension)
|
|
{
|
|
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;
|
|
}
|
|
|
|
int parking_lot_cfg_create_extensions(struct parking_lot_cfg *lot_cfg)
|
|
{
|
|
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;
|
|
}
|
|
|
|
struct parking_lot *parking_lot_build_or_update(struct parking_lot_cfg *lot_cfg, int dynamic)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void generate_or_link_lots_to_configs(void)
|
|
{
|
|
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);
|
|
}
|
|
|
|
int parking_dynamic_lots_enabled(void)
|
|
{
|
|
RAII_VAR(struct parking_config *, cfg, ao2_global_obj_ref(globals), ao2_cleanup);
|
|
|
|
if (!cfg) {
|
|
return 0;
|
|
}
|
|
|
|
return cfg->global->parkeddynamic;
|
|
}
|
|
|
|
static struct parking_lot_cfg *clone_parkinglot_cfg(struct parking_lot_cfg *source, const char *name)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static struct parking_lot *create_dynamic_lot_full(const char *name, struct ast_channel *chan, int 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;
|
|
}
|
|
|
|
struct parking_lot *parking_create_dynamic_lot(const char *name, struct ast_channel *chan){
|
|
return create_dynamic_lot_full(name, chan, 0);
|
|
}
|
|
|
|
#if defined(TEST_FRAMEWORK)
|
|
struct parking_lot *parking_create_dynamic_lot_forced(const char *name, struct ast_channel *chan) {
|
|
return create_dynamic_lot_full(name, chan, 1);
|
|
}
|
|
#endif
|
|
|
|
/* Preapply */
|
|
|
|
static int verify_default_parking_lot(void)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void remove_pending_parking_lot_extensions(struct parking_config *cfg_pending)
|
|
{
|
|
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);
|
|
|
|
}
|
|
|
|
static int configure_parking_extensions(void)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static void mark_lots_as_disabled(void)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static int config_parking_preapply(void)
|
|
{
|
|
mark_lots_as_disabled();
|
|
|
|
if (verify_default_parking_lot()) {
|
|
return -1;
|
|
}
|
|
|
|
if (configure_parking_extensions()) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void disable_marked_lots(void)
|
|
{
|
|
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);
|
|
}
|
|
|
|
static void link_configured_disable_marked_lots(void)
|
|
{
|
|
generate_or_link_lots_to_configs();
|
|
disable_marked_lots();
|
|
}
|
|
|
|
static int unload_module(void)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static int load_module(void)
|
|
{
|
|
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;
|
|
}
|
|
|
|
static int reload_module(void)
|
|
{
|
|
if (aco_process_config(&cfg_info, 1) == ACO_PROCESS_ERROR) {
|
|
return AST_MODULE_LOAD_DECLINE;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_LOAD_ORDER, "Call Parking Resource",
|
|
.support_level = AST_MODULE_SUPPORT_CORE,
|
|
.load = load_module,
|
|
.unload = unload_module,
|
|
.reload = reload_module,
|
|
.load_pri = AST_MODPRI_DEVSTATE_PROVIDER,
|
|
);
|