This patch modified pjsip_options to retrieve only permament contacts for aor if the qualify_frequency is > 0 and persisted contacts if the qualify_frequency is > 0. This patch also fixed a bug in res_sorcery_astdb. res_sorcery_astdb doesn't save object data retrived from astdb. ASTERISK-25826 Change-Id: I1831fa46c4578eae5a3e574ee3362fddf08a1f05
342 lines
11 KiB
C
342 lines
11 KiB
C
/*
|
|
* Asterisk -- An open source telephony toolkit.
|
|
*
|
|
* Copyright (C) 2013, Digium, Inc.
|
|
*
|
|
* Joshua Colp <jcolp@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 Sorcery Astdb Object Wizard
|
|
*
|
|
* \author Joshua Colp <jcolp@digium.com>
|
|
*/
|
|
|
|
/*** MODULEINFO
|
|
<support_level>core</support_level>
|
|
***/
|
|
|
|
#include "asterisk.h"
|
|
|
|
ASTERISK_REGISTER_FILE()
|
|
|
|
#include <regex.h>
|
|
|
|
#include "asterisk/module.h"
|
|
#include "asterisk/sorcery.h"
|
|
#include "asterisk/astdb.h"
|
|
#include "asterisk/json.h"
|
|
|
|
static void *sorcery_astdb_open(const char *data);
|
|
static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object);
|
|
static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id);
|
|
static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields);
|
|
static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects,
|
|
const struct ast_variable *fields);
|
|
static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex);
|
|
static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object);
|
|
static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object);
|
|
static void sorcery_astdb_close(void *data);
|
|
|
|
static struct ast_sorcery_wizard astdb_object_wizard = {
|
|
.name = "astdb",
|
|
.open = sorcery_astdb_open,
|
|
.create = sorcery_astdb_create,
|
|
.retrieve_id = sorcery_astdb_retrieve_id,
|
|
.retrieve_fields = sorcery_astdb_retrieve_fields,
|
|
.retrieve_multiple = sorcery_astdb_retrieve_multiple,
|
|
.retrieve_regex = sorcery_astdb_retrieve_regex,
|
|
.update = sorcery_astdb_update,
|
|
.delete = sorcery_astdb_delete,
|
|
.close = sorcery_astdb_close,
|
|
};
|
|
|
|
static int sorcery_astdb_create(const struct ast_sorcery *sorcery, void *data, void *object)
|
|
{
|
|
RAII_VAR(struct ast_json *, objset, ast_sorcery_objectset_json_create(sorcery, object), ast_json_unref);
|
|
RAII_VAR(char *, value, NULL, ast_json_free);
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
|
|
|
|
if (!objset || !(value = ast_json_dump_string(objset))) {
|
|
return -1;
|
|
}
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
|
|
|
|
return ast_db_put(family, ast_sorcery_object_get_id(object), value);
|
|
}
|
|
|
|
/*! \brief Internal helper function which retrieves an object, or multiple objects, using fields for criteria */
|
|
static void *sorcery_astdb_retrieve_fields_common(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields, struct ao2_container *objects)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(type) + 2];
|
|
RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
|
|
struct ast_db_entry *entry;
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, type);
|
|
|
|
if (!(entries = ast_db_gettree(family, NULL))) {
|
|
return NULL;
|
|
}
|
|
|
|
for (entry = entries; entry; entry = entry->next) {
|
|
const char *key = entry->key + strlen(family) + 2;
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ast_json_error error;
|
|
RAII_VAR(struct ast_variable *, existing, NULL, ast_variables_destroy);
|
|
void *object = NULL;
|
|
|
|
if (!(json = ast_json_load_string(entry->data, &error))) {
|
|
return NULL;
|
|
}
|
|
if (ast_json_to_ast_variables(json, &existing) != AST_JSON_TO_AST_VARS_CODE_SUCCESS) {
|
|
return NULL;
|
|
}
|
|
|
|
if (fields && !ast_variable_lists_match(existing, fields, 0)) {
|
|
continue;
|
|
}
|
|
|
|
if (!(object = ast_sorcery_alloc(sorcery, type, key)) ||
|
|
ast_sorcery_objectset_apply(sorcery, object, existing)) {
|
|
ao2_cleanup(object);
|
|
return NULL;
|
|
}
|
|
|
|
if (!objects) {
|
|
return object;
|
|
}
|
|
|
|
ao2_link(objects, object);
|
|
ao2_cleanup(object);
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void *sorcery_astdb_retrieve_fields(const struct ast_sorcery *sorcery, void *data, const char *type, const struct ast_variable *fields)
|
|
{
|
|
return sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, NULL);
|
|
}
|
|
|
|
static void *sorcery_astdb_retrieve_id(const struct ast_sorcery *sorcery, void *data, const char *type, const char *id)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(type) + 2];
|
|
RAII_VAR(char *, value, NULL, ast_free_ptr);
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ast_json_error error;
|
|
RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
|
|
void *object = NULL;
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, type);
|
|
|
|
if (ast_db_get_allocated(family, id, &value)
|
|
|| !(json = ast_json_load_string(value, &error))
|
|
|| (ast_json_to_ast_variables(json, &objset) != AST_JSON_TO_AST_VARS_CODE_SUCCESS)
|
|
|| !(object = ast_sorcery_alloc(sorcery, type, id))
|
|
|| ast_sorcery_objectset_apply(sorcery, object, objset)) {
|
|
ast_debug(3, "Failed to retrieve object '%s' from astdb\n", id);
|
|
ao2_cleanup(object);
|
|
return NULL;
|
|
}
|
|
|
|
return object;
|
|
}
|
|
|
|
static void sorcery_astdb_retrieve_multiple(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const struct ast_variable *fields)
|
|
{
|
|
sorcery_astdb_retrieve_fields_common(sorcery, data, type, fields, objects);
|
|
}
|
|
|
|
/*!
|
|
* \internal
|
|
* \brief Convert regex prefix pattern to astDB prefix pattern if possible.
|
|
*
|
|
* \param tree astDB prefix pattern buffer to fill.
|
|
* \param regex Extended regular expression with the start anchor character '^'.
|
|
*
|
|
* \note Since this is a helper function, the tree buffer is
|
|
* assumed to always be large enough.
|
|
*
|
|
* \retval 0 on success.
|
|
* \retval -1 on error. regex is invalid.
|
|
*/
|
|
static int make_astdb_prefix_pattern(char *tree, const char *regex)
|
|
{
|
|
const char *src;
|
|
char *dst;
|
|
|
|
for (dst = tree, src = regex + 1; *src; ++src) {
|
|
if (*src == '\\') {
|
|
/* Escaped regex char. */
|
|
++src;
|
|
if (!*src) {
|
|
/* Invalid regex. The caller escaped the string terminator. */
|
|
return -1;
|
|
}
|
|
} else if (*src == '$') {
|
|
if (!src[1]) {
|
|
/* Remove the tail anchor character. */
|
|
*dst = '\0';
|
|
return 0;
|
|
}
|
|
} else if (strchr(".?*+{[(|", *src)) {
|
|
/*
|
|
* The regex is not a simple prefix pattern.
|
|
*
|
|
* XXX With more logic, it is possible to simply
|
|
* use the current prefix pattern. The last character
|
|
* needs to be removed if possible when the current regex
|
|
* token is "?*{". Also the rest of the regex pattern
|
|
* would need to be checked for subgroup/alternation.
|
|
* Subgroup/alternation is too complex for a simple prefix
|
|
* match.
|
|
*/
|
|
dst = tree;
|
|
break;
|
|
}
|
|
*dst++ = *src;
|
|
}
|
|
if (dst != tree) {
|
|
*dst++ = '%';
|
|
}
|
|
*dst = '\0';
|
|
return 0;
|
|
}
|
|
|
|
static void sorcery_astdb_retrieve_regex(const struct ast_sorcery *sorcery, void *data, const char *type, struct ao2_container *objects, const char *regex)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(type) + 2];
|
|
char tree[strlen(regex) + 1];
|
|
RAII_VAR(struct ast_db_entry *, entries, NULL, ast_db_freetree);
|
|
regex_t expression;
|
|
struct ast_db_entry *entry;
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, type);
|
|
|
|
if (regex[0] == '^') {
|
|
/*
|
|
* For performance reasons, try to create an astDB prefix
|
|
* pattern from the regex to reduce the number of entries
|
|
* retrieved from astDB for regex to then match.
|
|
*/
|
|
if (make_astdb_prefix_pattern(tree, regex)) {
|
|
return;
|
|
}
|
|
} else {
|
|
tree[0] = '\0';
|
|
}
|
|
|
|
if (!(entries = ast_db_gettree(family, tree))
|
|
|| regcomp(&expression, regex, REG_EXTENDED | REG_NOSUB)) {
|
|
return;
|
|
}
|
|
|
|
for (entry = entries; entry; entry = entry->next) {
|
|
/* The key in the entry includes the family, so we need to strip it out for regex purposes */
|
|
const char *key = entry->key + strlen(family) + 2;
|
|
RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
|
|
struct ast_json_error error;
|
|
RAII_VAR(void *, object, NULL, ao2_cleanup);
|
|
RAII_VAR(struct ast_variable *, objset, NULL, ast_variables_destroy);
|
|
|
|
if (regexec(&expression, key, 0, NULL, 0)) {
|
|
continue;
|
|
} else if (!(json = ast_json_load_string(entry->data, &error))
|
|
|| (ast_json_to_ast_variables(json, &objset) != AST_JSON_TO_AST_VARS_CODE_SUCCESS)
|
|
|| !(object = ast_sorcery_alloc(sorcery, type, key))
|
|
|| ast_sorcery_objectset_apply(sorcery, object, objset)) {
|
|
regfree(&expression);
|
|
return;
|
|
}
|
|
|
|
ao2_link(objects, object);
|
|
}
|
|
|
|
regfree(&expression);
|
|
}
|
|
|
|
static int sorcery_astdb_update(const struct ast_sorcery *sorcery, void *data, void *object)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2], value[2];
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
|
|
|
|
/* It is okay for the value to be truncated, we are only checking that it exists */
|
|
if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
|
|
return -1;
|
|
}
|
|
|
|
/* The only difference between update and create is that for update the object must already exist */
|
|
return sorcery_astdb_create(sorcery, data, object);
|
|
}
|
|
|
|
static int sorcery_astdb_delete(const struct ast_sorcery *sorcery, void *data, void *object)
|
|
{
|
|
const char *prefix = data;
|
|
char family[strlen(prefix) + strlen(ast_sorcery_object_get_type(object)) + 2];
|
|
char value[2];
|
|
|
|
snprintf(family, sizeof(family), "%s/%s", prefix, ast_sorcery_object_get_type(object));
|
|
|
|
if (ast_db_get(family, ast_sorcery_object_get_id(object), value, sizeof(value))) {
|
|
return -1;
|
|
}
|
|
|
|
return ast_db_del(family, ast_sorcery_object_get_id(object));
|
|
}
|
|
|
|
static void *sorcery_astdb_open(const char *data)
|
|
{
|
|
/* We require a prefix for family string generation, or else stuff could mix together */
|
|
if (ast_strlen_zero(data)) {
|
|
return NULL;
|
|
}
|
|
|
|
return ast_strdup(data);
|
|
}
|
|
|
|
static void sorcery_astdb_close(void *data)
|
|
{
|
|
ast_free(data);
|
|
}
|
|
|
|
static int load_module(void)
|
|
{
|
|
if (ast_sorcery_wizard_register(&astdb_object_wizard)) {
|
|
return AST_MODULE_LOAD_DECLINE;
|
|
}
|
|
|
|
return AST_MODULE_LOAD_SUCCESS;
|
|
}
|
|
|
|
static int unload_module(void)
|
|
{
|
|
ast_sorcery_wizard_unregister(&astdb_object_wizard);
|
|
return 0;
|
|
}
|
|
|
|
AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "Sorcery Astdb Object Wizard",
|
|
.support_level = AST_MODULE_SUPPORT_CORE,
|
|
.load = load_module,
|
|
.unload = unload_module,
|
|
.load_pri = AST_MODPRI_REALTIME_DRIVER,
|
|
);
|