func_realtime.c File Reference

REALTIME dialplan function. More...

#include "asterisk.h"
#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"

Include dependency graph for func_realtime.c:

Go to the source code of this file.

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
	AST_THREADSTORAGE_CUSTOM_SCOPE (buf1, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (buf2, NULL, ast_free_ptr, static)
	AST_THREADSTORAGE_CUSTOM_SCOPE (buf3, NULL, ast_free_ptr, static)
static int	function_realtime_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	function_realtime_readdestroy (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	function_realtime_store (struct ast_channel *chan, const char *cmd, char *data, const char *value)
static int	function_realtime_write (struct ast_channel *chan, const char *cmd, char *data, const char *value)
static int	function_realtime_writedestroy (struct ast_channel *chan, const char *cmd, char *data, const char *value)
	Wrapper to execute REALTIME_DESTROY from a write operation. Allows execution even if live_dangerously is disabled.
static int	load_module (void)
static int	realtimefield_read (struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t len)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Read/Write/Store/Destroy values from a RealTime repository" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct ast_custom_function	realtime_destroy_function
static struct ast_custom_function	realtime_function
static struct ast_custom_function	realtime_store_function
static struct ast_custom_function	realtimefield_function
static struct ast_custom_function	realtimehash_function

Detailed Description

REALTIME dialplan function.

Author

BJ Weschke bwesc.nosp@m.hke@.nosp@m.btwte.nosp@m.ch.c.nosp@m.om

Definition in file func_realtime.c.

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 562 of file func_realtime.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 562 of file func_realtime.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 562 of file func_realtime.c.

AST_THREADSTORAGE_CUSTOM_SCOPE() [1/3]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	buf1	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [2/3]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	buf2	,
		NULL	,
		ast_free_ptr	,
		static
	)

AST_THREADSTORAGE_CUSTOM_SCOPE() [3/3]

AST_THREADSTORAGE_CUSTOM_SCOPE	(	buf3	,
		NULL	,
		ast_free_ptr	,
		static
	)

function_realtime_read()

static int function_realtime_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 197 of file func_realtime.c.

{
    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);
        if (chan) {
            ast_autoservice_stop(chan);
        }
        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;
}

References args, AST_APP_ARG, ast_autoservice_start(), ast_autoservice_stop(), ast_copy_string(), AST_DECLARE_APP_ARGS, ast_load_realtime_all(), ast_log, AST_STANDARD_APP_ARGS, ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_strlen_zero(), ast_variables_destroy(), buf, len(), LOG_WARNING, ast_variable::next, out, SENTINEL, value, and var.

function_realtime_readdestroy()

static int function_realtime_readdestroy ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 427 of file func_realtime.c.

{
    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);
            if (chan) {
                ast_autoservice_stop(chan);
            }
            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;
}

References args, AST_APP_ARG, ast_autoservice_start(), ast_autoservice_stop(), ast_copy_string(), AST_DECLARE_APP_ARGS, ast_destroy_realtime(), ast_load_realtime_all(), ast_log, AST_STANDARD_APP_ARGS, ast_str_alloca, ast_str_append(), ast_str_buffer(), ast_strlen_zero(), ast_variables_destroy(), buf, len(), LOG_WARNING, ast_variable::next, out, SENTINEL, value, and var.

Referenced by function_realtime_writedestroy().

function_realtime_store()

static int function_realtime_store ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Definition at line 379 of file func_realtime.c.

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

References a, AST_APP_ARG, ast_autoservice_start(), ast_autoservice_stop(), AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_store_realtime(), ast_strdupa, ast_strlen_zero(), LOG_WARNING, pbx_builtin_setvar_helper(), SENTINEL, and value.

function_realtime_write()

static int function_realtime_write ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Definition at line 264 of file func_realtime.c.

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

References args, AST_APP_ARG, ast_autoservice_start(), ast_autoservice_stop(), AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strlen_zero(), ast_update_realtime(), LOG_WARNING, SENTINEL, and value.

function_realtime_writedestroy()

static int function_realtime_writedestroy ( struct ast_channel *  chan, const char *  cmd, char *  data, const char *  value  )

static

Wrapper to execute REALTIME_DESTROY from a write operation. Allows execution even if live_dangerously is disabled.

Definition at line 507 of file func_realtime.c.

{
    return function_realtime_readdestroy(chan, cmd, data, NULL, 0);
}

References function_realtime_readdestroy(), and NULL.

load_module()

static int load_module ( void  )

static

Definition at line 551 of file func_realtime.c.

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

References AST_CFE_READ, ast_custom_function_register, ast_custom_function_register_escalating, realtime_destroy_function, realtime_function, realtime_store_function, realtimefield_function, and realtimehash_function.

realtimefield_read()

static int realtimefield_read ( struct ast_channel *  chan, const char *  cmd, char *  data, char *  buf, size_t  len  )

static

Definition at line 303 of file func_realtime.c.

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

References args, AST_APP_ARG, ast_autoservice_start(), ast_autoservice_stop(), ast_copy_string(), ast_debug, AST_DECLARE_APP_ARGS, ast_load_realtime_all(), ast_log, AST_STANDARD_APP_ARGS, ast_str_append(), ast_str_buffer(), ast_str_reset(), ast_str_set_escapecommas(), ast_str_thread_get(), ast_strlen_zero(), ast_variables_destroy(), buf, first, len(), LOG_WARNING, ast_variable::next, pbx_builtin_setvar_helper(), SENTINEL, value, and var.

unload_module()

static int unload_module ( void  )

static

Definition at line 540 of file func_realtime.c.

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

References ast_custom_function_unregister(), realtime_destroy_function, realtime_function, realtime_store_function, realtimefield_function, and realtimehash_function.

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_LOAD_ORDER , .description = "Read/Write/Store/Destroy values from a RealTime repository" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .load = load_module, .unload = unload_module, .load_pri = AST_MODPRI_DEFAULT, .support_level = AST_MODULE_SUPPORT_CORE, }

static

Definition at line 562 of file func_realtime.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 562 of file func_realtime.c.

realtime_destroy_function

struct ast_custom_function realtime_destroy_function

static

Initial value:

= {
    .name = "REALTIME_DESTROY",
    .read = function_realtime_readdestroy,
    .write = function_realtime_writedestroy,
}

Definition at line 534 of file func_realtime.c.

                                                              {
    .name = "REALTIME_DESTROY",
    .read = function_realtime_readdestroy,
    .write = function_realtime_writedestroy,
};

Referenced by load_module(), and unload_module().

realtime_function

struct ast_custom_function realtime_function

static

Initial value:

= {
    .name = "REALTIME",
    .read = function_realtime_read,
    .write = function_realtime_write,
}

Definition at line 512 of file func_realtime.c.

                                                      {
    .name = "REALTIME",
    .read = function_realtime_read,
    .write = function_realtime_write,
};

Referenced by load_module(), and unload_module().

realtime_store_function

struct ast_custom_function realtime_store_function

static

Initial value:

= {
    .name = "REALTIME_STORE",
    .write = function_realtime_store,
}

Definition at line 529 of file func_realtime.c.

                                                            {
    .name = "REALTIME_STORE",
    .write = function_realtime_store,
};

Referenced by load_module(), and unload_module().

realtimefield_function

struct ast_custom_function realtimefield_function

static

Initial value:

= {
    .name = "REALTIME_FIELD",
    .read = realtimefield_read,
    .write = function_realtime_write,
}

Definition at line 518 of file func_realtime.c.

                                                           {
    .name = "REALTIME_FIELD",
    .read = realtimefield_read,
    .write = function_realtime_write,
};

Referenced by load_module(), and unload_module().

realtimehash_function

struct ast_custom_function realtimehash_function

static

Initial value:

= {
    .name = "REALTIME_HASH",
    .read = realtimefield_read,
}

Definition at line 524 of file func_realtime.c.

                                                          {
    .name = "REALTIME_HASH",
    .read = realtimefield_read,
};

Referenced by load_module(), and unload_module().