sysmocom/asterisk
11
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
asterisk/funcs/func_realtime.c
Matt Jordan 4a58261694 git migration: Refactor the ASTERISK_FILE_VERSION macro 
Git does not support the ability to replace a token with a version
string during check-in. While it does have support for replacing a
token on clone, this is somewhat sub-optimal: the token is replaced
with the object hash, which is not particularly easy for human
consumption. What's more, in practice, the source file version was often
not terribly useful. Generally, when triaging bugs, the overall version
of Asterisk is far more useful than an individual SVN version of a file. As a
result, this patch removes Asterisk's support for showing source file
versions.

Specifically, it does the following:

* Rename ASTERISK_FILE_VERSION macro to ASTERISK_REGISTER_FILE, and
  remove passing the version in with the macro. Other facilities
  than 'core show file version' make use of the file names, such as
  setting a debug level only on a specific file. As such, the act of
  registering source files with the Asterisk core still has use. The
  macro rename now reflects the new macro purpose.

* main/asterisk:
  - Refactor the file_version structure to reflect that it no longer
    tracks a version field.
  - Remove the "core show file version" CLI command. Without the file
    version, it is no longer useful.
  - Remove the ast_file_version_find function. The file version is no
    longer tracked.
  - Rename ast_register_file_version/ast_unregister_file_version to
    ast_register_file/ast_unregister_file, respectively.

* main/manager: Remove value from the Version key of the ModuleCheck
  Action. The actual key itself has not been removed, as doing so would
  absolutely constitute a backwards incompatible change. However, since
  the file version is no longer tracked, there is no need to attempt to
  include it in the Version key.

* UPGRADE: Add notes for:
  - Modification to the ModuleCheck AMI Action
  - Removal of the "core show file version" CLI command

Change-Id: I6cf0ff280e1668bf4957dc21f32a5ff43444a40e
2015-04-13 03:48:57 -04:00

544 lines
16 KiB
C
Raw Blame History

/*
* Asterisk -- An open source telephony toolkit.
*
* Copyright (C) 2005-2006, BJ Weschke. All rights reserved.
*
* BJ Weschke <bweschke@btwtech.com>
*
* This code is released by the author with no restrictions on usage.
*
* 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.
*
*/
/*! \file
*
* \brief REALTIME dialplan function
*
* \author BJ Weschke <bweschke@btwtech.com>
*
* \ingroup functions
*/
/*** MODULEINFO
<support_level>core</support_level>
***/
#include "asterisk.h"
ASTERISK_REGISTER_FILE()
#include "asterisk/file.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/config.h"
#include "asterisk/module.h"
#include "asterisk/lock.h"
#include "asterisk/utils.h"
#include "asterisk/app.h"
/*** DOCUMENTATION
<function name="REALTIME" language="en_US">
<synopsis>
RealTime Read/Write Functions.
</synopsis>
<syntax>
<parameter name="family" required="true" />
<parameter name="fieldmatch" required="true" />
<parameter name="matchvalue" />
<parameter name="delim1|field">
<para>Use <replaceable>delim1</replaceable> with <replaceable>delim2</replaceable> on
read and <replaceable>field</replaceable> without <replaceable>delim2</replaceable> on
write</para>
<para>If we are reading and <replaceable>delim1</replaceable> is not specified, defaults
to <literal>,</literal></para>
</parameter>
<parameter name="delim2">
<para>Parameter only used when reading, if not specified defaults to <literal>=</literal></para>
</parameter>
</syntax>
<description>
<para>This function will read or write values from/to a RealTime repository.
REALTIME(....) will read names/values from the repository, and
REALTIME(....)= will write a new value/field to the repository. On a
read, this function returns a delimited text string. The name/value
pairs are delimited by <replaceable>delim1</replaceable>, and the name and value are delimited
between each other with delim2.
If there is no match, NULL will be returned by the function.
On a write, this function will always return NULL.</para>
</description>
<see-also>
<ref type="function">REALTIME_STORE</ref>
<ref type="function">REALTIME_DESTROY</ref>
<ref type="function">REALTIME_FIELD</ref>
<ref type="function">REALTIME_HASH</ref>
</see-also>
</function>
<function name="REALTIME_STORE" language="en_US">
<synopsis>
RealTime Store Function.
</synopsis>
<syntax>
<parameter name="family" required="true" />
<parameter name="field1" required="true" />
<parameter name="fieldN" required="true" multiple="true" />
<parameter name="field30" required="true" />
</syntax>
<description>
<para>This function will insert a new set of values into the RealTime repository.
If RT engine provides an unique ID of the stored record, REALTIME_STORE(...)=..
creates channel variable named RTSTOREID, which contains value of unique ID.
Currently, a maximum of 30 field/value pairs is supported.</para>
</description>
<see-also>
<ref type="function">REALTIME</ref>
<ref type="function">REALTIME_DESTROY</ref>
<ref type="function">REALTIME_FIELD</ref>
<ref type="function">REALTIME_HASH</ref>
</see-also>
</function>
<function name="REALTIME_DESTROY" language="en_US">
<synopsis>
RealTime Destroy Function.
</synopsis>
<syntax>
<parameter name="family" required="true" />
<parameter name="fieldmatch" required="true" />
<parameter name="matchvalue" />
<parameter name="delim1" />
<parameter name="delim2" />
</syntax>
<description>
<para>This function acts in the same way as REALTIME(....) does, except that
it destroys the matched record in the RT engine.</para>
<note>
<para>If <literal>live_dangerously</literal> in <literal>asterisk.conf</literal>
is set to <literal>no</literal>, this function can only be read from the
dialplan, and not directly from external protocols. It can, however, be
executed as a write operation (<literal>REALTIME_DESTROY(family, fieldmatch)=ignored</literal>)</para>
</note>
</description>
<see-also>
<ref type="function">REALTIME</ref>
<ref type="function">REALTIME_STORE</ref>
<ref type="function">REALTIME_FIELD</ref>
<ref type="function">REALTIME_HASH</ref>
</see-also>
</function>
<function name="REALTIME_FIELD" language="en_US">
<synopsis>
RealTime query function.
</synopsis>
<syntax>
<parameter name="family" required="true" />
<parameter name="fieldmatch" required="true" />
<parameter name="matchvalue" required="true" />
<parameter name="fieldname" required="true" />
</syntax>
<description>
<para>This function retrieves a single item, <replaceable>fieldname</replaceable>
from the RT engine, where <replaceable>fieldmatch</replaceable> contains the value
<replaceable>matchvalue</replaceable>. When written to, the REALTIME_FIELD() function
performs identically to the REALTIME() function.</para>
</description>
<see-also>
<ref type="function">REALTIME</ref>
<ref type="function">REALTIME_STORE</ref>
<ref type="function">REALTIME_DESTROY</ref>
<ref type="function">REALTIME_HASH</ref>
</see-also>
</function>
<function name="REALTIME_HASH" language="en_US">
<synopsis>
RealTime query function.
</synopsis>
<syntax>
<parameter name="family" required="true" />
<parameter name="fieldmatch" required="true" />
<parameter name="matchvalue" required="true" />
</syntax>
<description>
<para>This function retrieves a single record from the RT engine, where
<replaceable>fieldmatch</replaceable> contains the value
<replaceable>matchvalue</replaceable> and formats the output suitably, such that
it can be assigned to the HASH() function. The HASH() function then provides
a suitable method for retrieving each field value of the record.</para>
</description>
<see-also>
<ref type="function">REALTIME</ref>
<ref type="function">REALTIME_STORE</ref>
<ref type="function">REALTIME_DESTROY</ref>
<ref type="function">REALTIME_FIELD</ref>
</see-also>
</function>
***/
AST_THREADSTORAGE(buf1);
AST_THREADSTORAGE(buf2);
AST_THREADSTORAGE(buf3);
static int function_realtime_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
struct ast_variable *var, *head;
struct ast_str *out;
size_t resultslen;
int n;
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(family);
AST_APP_ARG(fieldmatch);
AST_APP_ARG(value);
AST_APP_ARG(delim1);
AST_APP_ARG(delim2);
);
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "Syntax: REALTIME(family,fieldmatch[,matchvalue[,delim1[,delim2]]]) - missing argument!\n");
return -1;
}
AST_STANDARD_APP_ARGS(args, data);
if (!args.delim1)
args.delim1 = ",";
if (!args.delim2)
args.delim2 = "=";
if (chan)
ast_autoservice_start(chan);
head = ast_load_realtime_all(args.family, args.fieldmatch, args.value, SENTINEL);
if (!head) {
if (chan)
ast_autoservice_stop(chan);
return -1;
}
resultslen = 0;
n = 0;
for (var = head; var; n++, var = var->next)
resultslen += strlen(var->name) + strlen(var->value);
/* add space for delimiters and final '\0' */
resultslen += n * (strlen(args.delim1) + strlen(args.delim2)) + 1;
if (resultslen > len) {
ast_log(LOG_WARNING, "Failed to fetch. Realtime data is too large: need %zu, have %zu.\n", resultslen, len);
return -1;
}
/* len is going to be sensible, so we don't need to check for stack
* overflows here. */
out = ast_str_alloca(resultslen);
for (var = head; var; var = var->next)
ast_str_append(&out, 0, "%s%s%s%s", var->name, args.delim2, var->value, args.delim1);
ast_copy_string(buf, ast_str_buffer(out), len);
ast_variables_destroy(head);
if (chan)
ast_autoservice_stop(chan);
return 0;
}
static int function_realtime_write(struct ast_channel *chan, const char *cmd, char *data, const char *value)
{
int res = 0;
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(family);
AST_APP_ARG(fieldmatch);
AST_APP_ARG(value);
AST_APP_ARG(field);
);
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "Syntax: %s(family,fieldmatch,matchvalue,updatecol) - missing argument!\n", cmd);
return -1;
}
AST_STANDARD_APP_ARGS(args, data);
if (ast_strlen_zero(args.fieldmatch) || ast_strlen_zero(args.field)) {
ast_log(LOG_WARNING, "Syntax: %s(family,fieldmatch,matchvalue,updatecol) - missing argument!\n", cmd);
return -1;
}
if (chan) {
ast_autoservice_start(chan);
}
res = ast_update_realtime(args.family, args.fieldmatch, args.value, args.field, (char *)value, SENTINEL);
if (res < 0) {
ast_log(LOG_WARNING, "Failed to update. Check the debug log for possible data repository related entries.\n");
}
if (chan) {
ast_autoservice_stop(chan);
}
return res;
}
static int realtimefield_read(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
struct ast_variable *var, *head;
struct ast_str *escapebuf = ast_str_thread_get(&buf1, 16);
struct ast_str *fields = ast_str_thread_get(&buf2, 16);
struct ast_str *values = ast_str_thread_get(&buf3, 16);
int first = 0;
enum { rtfield, rthash } which;
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(family);
AST_APP_ARG(fieldmatch);
AST_APP_ARG(value);
AST_APP_ARG(fieldname);
);
if (!strcmp(cmd, "REALTIME_FIELD")) {
which = rtfield;
} else {
which = rthash;
}
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "Syntax: %s(family,fieldmatch,matchvalue%s) - missing argument!\n", cmd, which == rtfield ? ",fieldname" : "");
return -1;
}
AST_STANDARD_APP_ARGS(args, data);
if ((which == rtfield && args.argc != 4) || (which == rthash && args.argc != 3)) {
ast_log(LOG_WARNING, "Syntax: %s(family,fieldmatch,matchvalue%s) - missing argument!\n", cmd, which == rtfield ? ",fieldname" : "");
return -1;
}
if (chan) {
ast_autoservice_start(chan);
}
if (!(head = ast_load_realtime_all(args.family, args.fieldmatch, args.value, SENTINEL))) {
if (chan) {
ast_autoservice_stop(chan);
}
return -1;
}
ast_str_reset(fields);
ast_str_reset(values);
for (var = head; var; var = var->next) {
if (which == rtfield) {
ast_debug(1, "Comparing %s to %s\n", var->name, args.fieldname);
if (!strcasecmp(var->name, args.fieldname)) {
ast_debug(1, "Match! Value is %s\n", var->value);
ast_copy_string(buf, var->value, len);
break;
}
} else if (which == rthash) {
ast_debug(1, "Setting hash key %s to value %s\n", var->name, var->value);
ast_str_append(&fields, 0, "%s%s", first ? "" : ",", ast_str_set_escapecommas(&escapebuf, 0, var->name, INT_MAX));
ast_str_append(&values, 0, "%s%s", first ? "" : ",", ast_str_set_escapecommas(&escapebuf, 0, var->value, INT_MAX));
first = 0;
}
}
ast_variables_destroy(head);
if (which == rthash) {
pbx_builtin_setvar_helper(chan, "~ODBCFIELDS~", ast_str_buffer(fields));
ast_copy_string(buf, ast_str_buffer(values), len);
}
if (chan) {
ast_autoservice_stop(chan);
}
return 0;
}
static int function_realtime_store(struct ast_channel *chan, const char *cmd, char *data, const char *value)
{
int res = 0;
char storeid[32];
char *valcopy;
AST_DECLARE_APP_ARGS(a,
AST_APP_ARG(family);
AST_APP_ARG(f)[30]; /* fields */
);
AST_DECLARE_APP_ARGS(v,
AST_APP_ARG(v)[30]; /* values */
);
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "Syntax: REALTIME_STORE(family,field1,field2,...,field30) - missing argument!\n");
return -1;
}
if (chan)
ast_autoservice_start(chan);
valcopy = ast_strdupa(value);
AST_STANDARD_APP_ARGS(a, data);
AST_STANDARD_APP_ARGS(v, valcopy);
res = ast_store_realtime(a.family,
a.f[0], v.v[0], a.f[1], v.v[1], a.f[2], v.v[2], a.f[3], v.v[3], a.f[4], v.v[4],
a.f[5], v.v[5], a.f[6], v.v[6], a.f[7], v.v[7], a.f[8], v.v[8], a.f[9], v.v[9],
a.f[10], v.v[10], a.f[11], v.v[11], a.f[12], v.v[12], a.f[13], v.v[13], a.f[14], v.v[14],
a.f[15], v.v[15], a.f[16], v.v[16], a.f[17], v.v[17], a.f[18], v.v[18], a.f[19], v.v[19],
a.f[20], v.v[20], a.f[21], v.v[21], a.f[22], v.v[22], a.f[23], v.v[23], a.f[24], v.v[24],
a.f[25], v.v[25], a.f[26], v.v[26], a.f[27], v.v[27], a.f[28], v.v[28], a.f[29], v.v[29], SENTINEL
);
if (res < 0) {
ast_log(LOG_WARNING, "Failed to store. Check the debug log for possible data repository related entries.\n");
} else {
snprintf(storeid, sizeof(storeid), "%d", res);
pbx_builtin_setvar_helper(chan, "RTSTOREID", storeid);
}
if (chan)
ast_autoservice_stop(chan);
return 0;
}
static int function_realtime_readdestroy(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
{
struct ast_variable *var, *head;
struct ast_str *out;
size_t resultslen;
int n;
AST_DECLARE_APP_ARGS(args,
AST_APP_ARG(family);
AST_APP_ARG(fieldmatch);
AST_APP_ARG(value);
AST_APP_ARG(delim1);
AST_APP_ARG(delim2);
);
if (ast_strlen_zero(data)) {
ast_log(LOG_WARNING, "Syntax: REALTIME_DESTROY(family,fieldmatch[,matchvalue[,delim1[,delim2]]]) - missing argument!\n");
return -1;
}
AST_STANDARD_APP_ARGS(args, data);
if (!args.delim1)
args.delim1 = ",";
if (!args.delim2)
args.delim2 = "=";
if (chan)
ast_autoservice_start(chan);
head = ast_load_realtime_all(args.family, args.fieldmatch, args.value, SENTINEL);
if (!head) {
if (chan)
ast_autoservice_stop(chan);
return -1;
}
if (len > 0) {
resultslen = 0;
n = 0;
for (var = head; var; n++, var = var->next) {
resultslen += strlen(var->name) + strlen(var->value);
}
/* add space for delimiters and final '\0' */
resultslen += n * (strlen(args.delim1) + strlen(args.delim2)) + 1;
if (resultslen > len) {
/* Unfortunately this does mean that we cannot destroy
* the row anymore. But OTOH, we're not destroying
* someones data without giving him the chance to look
* at it. */
ast_log(LOG_WARNING, "Failed to fetch/destroy. Realtime data is too large: need %zu, have %zu.\n", resultslen, len);
return -1;
}
/* len is going to be sensible, so we don't need to check for
* stack overflows here. */
out = ast_str_alloca(resultslen);
for (var = head; var; var = var->next) {
ast_str_append(&out, 0, "%s%s%s%s", var->name, args.delim2, var->value, args.delim1);
}
ast_copy_string(buf, ast_str_buffer(out), len);
}
ast_destroy_realtime(args.family, args.fieldmatch, args.value, SENTINEL);
ast_variables_destroy(head);
if (chan)
ast_autoservice_stop(chan);
return 0;
}
/*!
* \brief Wrapper to execute REALTIME_DESTROY from a write operation. Allows
* execution even if live_dangerously is disabled.
*/
static int function_realtime_writedestroy(struct ast_channel *chan, const char *cmd, char *data, const char *value)
{
return function_realtime_readdestroy(chan, cmd, data, NULL, 0);
}
static struct ast_custom_function realtime_function = {
.name = "REALTIME",
.read = function_realtime_read,
.write = function_realtime_write,
};
static struct ast_custom_function realtimefield_function = {
.name = "REALTIME_FIELD",
.read = realtimefield_read,
.write = function_realtime_write,
};
static struct ast_custom_function realtimehash_function = {
.name = "REALTIME_HASH",
.read = realtimefield_read,
};
static struct ast_custom_function realtime_store_function = {
.name = "REALTIME_STORE",
.write = function_realtime_store,
};
static struct ast_custom_function realtime_destroy_function = {
.name = "REALTIME_DESTROY",
.read = function_realtime_readdestroy,
.write = function_realtime_writedestroy,
};
static int unload_module(void)
{
int res = 0;
res |= ast_custom_function_unregister(&realtime_function);
res |= ast_custom_function_unregister(&realtime_store_function);
res |= ast_custom_function_unregister(&realtime_destroy_function);
res |= ast_custom_function_unregister(&realtimefield_function);
res |= ast_custom_function_unregister(&realtimehash_function);
return res;
}
static int load_module(void)
{
int res = 0;
res |= ast_custom_function_register(&realtime_function);
res |= ast_custom_function_register(&realtime_store_function);
res |= ast_custom_function_register_escalating(&realtime_destroy_function, AST_CFE_READ);
res |= ast_custom_function_register(&realtimefield_function);
res |= ast_custom_function_register(&realtimehash_function);
return res;
}
AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Read/Write/Store/Destroy values from a RealTime repository");
Reference in a new issue View git blame Copy permalink