func_cdr.c File Reference

Call Detail Record related dialplan functions. More...

#include "asterisk.h"
#include "asterisk/module.h"
#include "asterisk/channel.h"
#include "asterisk/pbx.h"
#include "asterisk/utils.h"
#include "asterisk/app.h"
#include "asterisk/cdr.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_message_router.h"

Include dependency graph for func_cdr.c:

Go to the source code of this file.

Data Structures
struct	cdr_func_data
struct	cdr_func_payload

Enumerations
enum	cdr_option_flags { OPT_UNPARSED = (1 << 1) , OPT_FLOAT = (1 << 2) }

Functions
static void	__reg_module (void)
static void	__unreg_module (void)
struct ast_module *	AST_MODULE_SELF_SYM (void)
static int	cdr_prop_write (struct ast_channel *chan, const char *cmd, char *parse, const char *value)
static void	cdr_prop_write_callback (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	cdr_read (struct ast_channel *chan, const char *cmd, char *parse, char *buf, size_t len)
static void	cdr_read_callback (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static struct timeval	cdr_retrieve_time (struct ast_channel *chan, const char *time_name)
static int	cdr_write (struct ast_channel *chan, const char *cmd, char *arguments, const char *value)
static void	cdr_write_callback (void *data, struct stasis_subscription *sub, struct stasis_message *message)
static int	load_module (void)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (cdr_prop_write_message_type)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (cdr_read_message_type)
	STASIS_MESSAGE_TYPE_DEFN_LOCAL (cdr_write_message_type)
static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Call Detail Record (CDR) dialplan functions" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "cdr", }
static const struct ast_module_info *	ast_module_info = &__mod_info
static const struct ast_app_option	cdr_func_options [128] = { [ 'f' ] = { .flag = OPT_FLOAT }, [ 'u' ] = { .flag = OPT_UNPARSED }, }
static struct ast_custom_function	cdr_function
static struct ast_custom_function	cdr_prop_function

Detailed Description

Call Detail Record related dialplan functions.

Author

Anthony Minessale II

Definition in file func_cdr.c.

Enumeration Type Documentation

cdr_option_flags

enum cdr_option_flags

Enumerator
OPT_UNPARSED
OPT_FLOAT

Definition at line 197 of file func_cdr.c.

                      {
    OPT_UNPARSED = (1 << 1),
    OPT_FLOAT = (1 << 2),
};

Function Documentation

__reg_module()

static void __reg_module ( void  )

static

Definition at line 714 of file func_cdr.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 714 of file func_cdr.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 714 of file func_cdr.c.

cdr_prop_write()

static int cdr_prop_write ( struct ast_channel *  chan, const char *  cmd, char *  parse, const char *  value  )

static

Definition at line 606 of file func_cdr.c.

{
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
    RAII_VAR(struct cdr_func_payload *, payload, NULL, ao2_cleanup);
    RAII_VAR(struct stasis_message_router *, router, ast_cdr_message_router(), ao2_cleanup);
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
 
    if (!router) {
        ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: no message router\n",
            ast_channel_name(chan));
        return -1;
    }
 
    if (!cdr_prop_write_message_type()) {
        ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: message type not available\n",
            ast_channel_name(chan));
        return -1;
    }
 
    payload = ao2_alloc(sizeof(*payload), NULL);
    if (!payload) {
        return -1;
    }
    payload->chan = chan;
    payload->cmd = cmd;
    payload->arguments = parse;
    payload->value = value;
 
    message = stasis_message_create(cdr_prop_write_message_type(), payload);
    if (!message) {
        ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: unable to create message\n",
            ast_channel_name(chan));
        return -1;
    }
    stasis_message_router_publish_sync(router, message);
 
    return 0;
}

References ao2_alloc, ao2_cleanup, ast_cdr_message_router(), ast_channel_name(), ast_log, AST_LOG_WARNING, LOG_WARNING, NULL, RAII_VAR, router, stasis_message_create(), stasis_message_router_publish_sync(), and value.

cdr_prop_write_callback()

static void cdr_prop_write_callback ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 402 of file func_cdr.c.

{
    struct cdr_func_payload *payload = stasis_message_data(message);
    enum ast_cdr_options option;
    char *parse;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(variable);
        AST_APP_ARG(options);
    );
 
    if (cdr_prop_write_message_type() != stasis_message_type(message)) {
        return;
    }
 
    if (!payload) {
        return;
    }
 
    if (ast_strlen_zero(payload->arguments)) {
        ast_log(AST_LOG_WARNING, "%s requires a variable (%s(variable)=value)\n)",
            payload->cmd, payload->cmd);
        return;
    }
    if (ast_strlen_zero(payload->value)) {
        ast_log(AST_LOG_WARNING, "%s requires a value (%s(variable)=value)\n)",
            payload->cmd, payload->cmd);
        return;
    }
    parse = ast_strdupa(payload->arguments);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (!strcasecmp("party_a", args.variable)) {
        option = AST_CDR_FLAG_PARTY_A;
    } else if (!strcasecmp("disable", args.variable)) {
        option = AST_CDR_FLAG_DISABLE_ALL;
    } else {
        ast_log(AST_LOG_WARNING, "Unknown option %s used with %s\n", args.variable, payload->cmd);
        return;
    }
 
    if (ast_true(payload->value)) {
        ast_cdr_set_property(ast_channel_name(payload->chan), option);
    } else {
        ast_cdr_clear_property(ast_channel_name(payload->chan), option);
    }
}

References args, cdr_func_payload::arguments, AST_APP_ARG, ast_cdr_clear_property(), AST_CDR_FLAG_DISABLE_ALL, AST_CDR_FLAG_PARTY_A, ast_cdr_set_property(), ast_channel_name(), AST_DECLARE_APP_ARGS, ast_log, AST_LOG_WARNING, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), ast_true(), cdr_func_payload::chan, cdr_func_payload::cmd, options, stasis_message_data(), stasis_message_type(), and cdr_func_payload::value.

Referenced by load_module().

cdr_read()

static int cdr_read ( struct ast_channel *  chan, const char *  cmd, char *  parse, char *  buf, size_t  len  )

static

Definition at line 450 of file func_cdr.c.

{
    RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
    RAII_VAR(struct cdr_func_payload *, payload, NULL, ao2_cleanup);
    struct cdr_func_data output = { 0, };
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
 
    if (!cdr_read_message_type()) {
        ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: message type not available\n",
            ast_channel_name(chan));
        return -1;
    }
 
    payload = ao2_alloc(sizeof(*payload), NULL);
    if (!payload) {
        return -1;
    }
    payload->chan = chan;
    payload->cmd = cmd;
    payload->arguments = parse;
    payload->data = &output;
 
    buf[0] = '\0';/* Ensure the buffer is initialized. */
    output.buf = buf;
    output.len = len;
 
    message = stasis_message_create(cdr_read_message_type(), payload);
    if (!message) {
        ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: unable to create message\n",
            ast_channel_name(chan));
        return -1;
    }
 
    /* If this is a request on a dummy channel, we're doing post-processing on an
     * already dispatched CDR. Simply call the callback to calculate the value and
     * return, instead of posting to Stasis as we would for a running channel.
     */
    if (ast_strlen_zero(ast_channel_name(chan))) {
        cdr_read_callback(NULL, NULL, message);
    } else {
        RAII_VAR(struct stasis_message_router *, router, ast_cdr_message_router(), ao2_cleanup);
 
        if (!router) {
            ast_log(AST_LOG_WARNING, "Failed to manipulate CDR for channel %s: no message router\n",
                ast_channel_name(chan));
            return -1;
        }
        stasis_message_router_publish_sync(router, message);
    }
 
    return 0;
}

References ao2_alloc, ao2_cleanup, ast_cdr_message_router(), ast_channel_name(), ast_log, AST_LOG_WARNING, ast_strlen_zero(), buf, cdr_func_data::buf, cdr_read_callback(), ast_channel::data, cdr_func_data::len, len(), LOG_WARNING, NULL, RAII_VAR, router, stasis_message_create(), and stasis_message_router_publish_sync().

cdr_read_callback()

static void cdr_read_callback ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 250 of file func_cdr.c.

{
    struct cdr_func_payload *payload = stasis_message_data(message);
    struct cdr_func_data *output;
    char *info;
    char *value = NULL;
    struct ast_flags flags = { 0 };
    char tempbuf[512];
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(variable);
        AST_APP_ARG(options);
    );
 
    if (cdr_read_message_type() != stasis_message_type(message)) {
        return;
    }
 
    ast_assert(payload != NULL);
    output = payload->data;
    ast_assert(output != NULL);
 
    if (ast_strlen_zero(payload->arguments)) {
        ast_log(AST_LOG_WARNING, "%s requires a variable (%s(variable[,option]))\n)",
            payload->cmd, payload->cmd);
        return;
    }
    info = ast_strdupa(payload->arguments);
    AST_STANDARD_APP_ARGS(args, info);
 
    if (!ast_strlen_zero(args.options)) {
        ast_app_parse_options(cdr_func_options, &flags, NULL, args.options);
    }
 
    if (ast_strlen_zero(ast_channel_name(payload->chan))) {
        /* Format request on a dummy channel */
        ast_cdr_format_var(ast_channel_cdr(payload->chan), args.variable, &value, tempbuf, sizeof(tempbuf), ast_test_flag(&flags, OPT_UNPARSED));
        if (ast_strlen_zero(value)) {
            return;
        }
        ast_copy_string(tempbuf, value, sizeof(tempbuf));
        ast_set_flag(&flags, OPT_UNPARSED);
    } else if (ast_cdr_getvar(ast_channel_name(payload->chan), args.variable, tempbuf, sizeof(tempbuf))) {
        return;
    }
 
    if (ast_test_flag(&flags, OPT_FLOAT)
        && (!strcasecmp("billsec", args.variable) || !strcasecmp("duration", args.variable))) {
        struct timeval start = cdr_retrieve_time(payload->chan, !strcasecmp("billsec", args.variable) ? "answer" : "start");
        struct timeval finish = cdr_retrieve_time(payload->chan, "end");
        double delta;
 
        if (ast_tvzero(finish)) {
            finish = ast_tvnow();
        }
 
        if (ast_tvzero(start)) {
            delta = 0.0;
        } else {
            delta = (double)(ast_tvdiff_us(finish, start) / 1000000.0);
        }
        snprintf(tempbuf, sizeof(tempbuf), "%lf", delta);
 
    } else if (!ast_test_flag(&flags, OPT_UNPARSED)) {
        if (!strcasecmp("start", args.variable)
            || !strcasecmp("end", args.variable)
            || !strcasecmp("answer", args.variable)) {
            struct timeval fmt_time;
            struct ast_tm tm;
            /* tv_usec is suseconds_t, which could be int or long */
            long int tv_sec;
            long int tv_usec;
 
            if (sscanf(tempbuf, "%ld.%ld", &tv_sec, &tv_usec) != 2) {
                ast_log(AST_LOG_WARNING, "Unable to parse %s (%s) from the CDR for channel %s\n",
                    args.variable, tempbuf, ast_channel_name(payload->chan));
                return;
            }
            if (tv_sec) {
                fmt_time.tv_sec = tv_sec;
                fmt_time.tv_usec = tv_usec;
                ast_localtime(&fmt_time, &tm, NULL);
                ast_strftime(tempbuf, sizeof(tempbuf), "%Y-%m-%d %T", &tm);
            } else {
                tempbuf[0] = '\0';
            }
        } else if (!strcasecmp("disposition", args.variable)) {
            int disposition;
 
            if (sscanf(tempbuf, "%8d", &disposition) != 1) {
                ast_log(AST_LOG_WARNING, "Unable to parse %s (%s) from the CDR for channel %s\n",
                    args.variable, tempbuf, ast_channel_name(payload->chan));
                return;
            }
            snprintf(tempbuf, sizeof(tempbuf), "%s", ast_cdr_disp2str(disposition));
        } else if (!strcasecmp("amaflags", args.variable)) {
            int amaflags;
 
            if (sscanf(tempbuf, "%8d", &amaflags) != 1) {
                ast_log(AST_LOG_WARNING, "Unable to parse %s (%s) from the CDR for channel %s\n",
                    args.variable, tempbuf, ast_channel_name(payload->chan));
                return;
            }
            snprintf(tempbuf, sizeof(tempbuf), "%s", ast_channel_amaflags2string(amaflags));
        }
    }
 
    ast_copy_string(output->buf, tempbuf, output->len);
}

References amaflags, args, cdr_func_payload::arguments, AST_APP_ARG, ast_app_parse_options(), ast_assert, ast_cdr_disp2str(), ast_cdr_format_var(), ast_cdr_getvar(), ast_channel_amaflags2string(), ast_channel_cdr(), ast_channel_name(), ast_copy_string(), AST_DECLARE_APP_ARGS, ast_localtime(), ast_log, AST_LOG_WARNING, ast_set_flag, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strftime(), ast_strlen_zero(), ast_test_flag, ast_tvdiff_us(), ast_tvnow(), ast_tvzero(), cdr_func_data::buf, cdr_func_options, cdr_retrieve_time(), cdr_func_payload::chan, cdr_func_payload::cmd, cdr_func_payload::data, ast_flags::flags, sip_to_pjsip::info(), cdr_func_data::len, NULL, OPT_FLOAT, OPT_UNPARSED, options, stasis_message_data(), stasis_message_type(), and value.

Referenced by cdr_read(), and load_module().

cdr_retrieve_time()

static struct timeval cdr_retrieve_time ( struct ast_channel *  chan, const char *  time_name  )

static

Definition at line 224 of file func_cdr.c.

{
    struct timeval time = { 0 };
    char *value = NULL;
    char tempbuf[128];
    long int tv_sec;
    long int tv_usec;
 
    if (ast_strlen_zero(ast_channel_name(chan))) {
        /* Format request on a dummy channel */
        ast_cdr_format_var(ast_channel_cdr(chan), time_name, &value, tempbuf, sizeof(tempbuf), 1);
    } else {
        ast_cdr_getvar(ast_channel_name(chan), time_name, tempbuf, sizeof(tempbuf));
    }
 
    /* time.tv_usec is suseconds_t, which could be int or long */
    if (sscanf(tempbuf, "%ld.%ld", &tv_sec, &tv_usec) == 2) {
        time.tv_sec = tv_sec;
        time.tv_usec = tv_usec;
    } else {
        ast_log(AST_LOG_WARNING, "Failed to fully extract '%s' from CDR\n", time_name);
    }
 
    return time;
}

References ast_cdr_format_var(), ast_cdr_getvar(), ast_channel_cdr(), ast_channel_name(), ast_log, AST_LOG_WARNING, ast_strlen_zero(), NULL, and value.

Referenced by cdr_read_callback().

cdr_write()

static int cdr_write ( struct ast_channel *  chan, const char *  cmd, char *  arguments, const char *  value  )

static

Definition at line 508 of file func_cdr.c.

{
    struct stasis_message *message;
    struct cdr_func_payload *payload;
    struct stasis_message_router *router;
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(variable);
        AST_APP_ARG(options);
    );
    char *parse;
 
    if (!chan) {
        ast_log(LOG_WARNING, "No channel was provided to %s function.\n", cmd);
        return -1;
    }
    if (ast_strlen_zero(arguments)) {
        ast_log(LOG_WARNING, "%s requires a variable (%s(variable)=value)\n)",
            cmd, cmd);
        return -1;
    }
    if (!value) {
        ast_log(LOG_WARNING, "%s requires a value (%s(variable)=value)\n)",
            cmd, cmd);
        return -1;
    }
 
    parse = ast_strdupa(arguments);
    AST_STANDARD_APP_ARGS(args, parse);
 
    /* These CDR variables are no longer supported or set directly on the channel */
    if (!strcasecmp(args.variable, "accountcode")) {
        ast_log(LOG_WARNING, "Using the %s function to set 'accountcode' is deprecated. Please use the CHANNEL function instead.\n",
            cmd);
        ast_channel_lock(chan);
        ast_channel_accountcode_set(chan, value);
        ast_channel_unlock(chan);
        return 0;
    }
    if (!strcasecmp(args.variable, "amaflags")) {
        int amaflags;
 
        ast_log(LOG_WARNING, "Using the %s function to set 'amaflags' is deprecated. Please use the CHANNEL function instead.\n",
            cmd);
        if (isdigit(*value)) {
            if (sscanf(value, "%30d", &amaflags) != 1) {
                amaflags = AST_AMA_NONE;
            }
        } else {
            amaflags = ast_channel_string2amaflag(value);
        }
        ast_channel_lock(chan);
        ast_channel_amaflags_set(chan, amaflags);
        ast_channel_unlock(chan);
        return 0;
    }
    if (!strcasecmp(args.variable, "peeraccount")) {
        ast_log(LOG_WARNING, "The 'peeraccount' setting is not supported. Please set the 'accountcode' on the appropriate channel using the CHANNEL function.\n");
        return 0;
    }
 
    /* The remaining CDR variables are handled by CDR processing code */
    if (!cdr_write_message_type()) {
        ast_log(LOG_WARNING, "Failed to manipulate CDR for channel %s: message type not available\n",
            ast_channel_name(chan));
        return -1;
    }
 
    payload = ao2_alloc(sizeof(*payload), NULL);
    if (!payload) {
        return -1;
    }
    payload->chan = chan;
    payload->cmd = cmd;
    payload->arguments = arguments;
    payload->value = value;
 
    message = stasis_message_create(cdr_write_message_type(), payload);
    ao2_ref(payload, -1);
    if (!message) {
        ast_log(LOG_WARNING, "Failed to manipulate CDR for channel %s: unable to create message\n",
            ast_channel_name(chan));
        return -1;
    }
    router = ast_cdr_message_router();
    if (!router) {
        ast_log(LOG_WARNING, "Failed to manipulate CDR for channel %s: no message router\n",
            ast_channel_name(chan));
        ao2_ref(message, -1);
        return -1;
    }
    stasis_message_router_publish_sync(router, message);
    ao2_ref(router, -1);
    ao2_ref(message, -1);
 
    return 0;
}

References amaflags, ao2_alloc, ao2_ref, args, cdr_func_payload::arguments, AST_AMA_NONE, AST_APP_ARG, ast_cdr_message_router(), ast_channel_amaflags_set(), ast_channel_lock, ast_channel_name(), ast_channel_string2amaflag(), ast_channel_unlock, AST_DECLARE_APP_ARGS, ast_log, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), cdr_func_payload::chan, cdr_func_payload::cmd, LOG_WARNING, NULL, options, router, stasis_message_create(), stasis_message_router_publish_sync(), cdr_func_payload::value, and value.

cdr_write_callback()

static void cdr_write_callback ( void *  data, struct stasis_subscription *  sub, struct stasis_message *  message  )

static

Definition at line 359 of file func_cdr.c.

{
    struct cdr_func_payload *payload;
    struct ast_flags flags = { 0 };
    AST_DECLARE_APP_ARGS(args,
        AST_APP_ARG(variable);
        AST_APP_ARG(options);
    );
    char *parse;
 
    if (cdr_write_message_type() != stasis_message_type(message)) {
        return;
    }
    payload = stasis_message_data(message);
    if (!payload) {
        return;
    }
    if (ast_strlen_zero(payload->arguments)
        || !payload->value) {
        /* Sanity check.  cdr_write() could never send these bad messages */
        ast_assert(0);
        return;
    }
 
    parse = ast_strdupa(payload->arguments);
    AST_STANDARD_APP_ARGS(args, parse);
 
    if (!ast_strlen_zero(args.options)) {
        ast_app_parse_options(cdr_func_options, &flags, NULL, args.options);
    }
 
    /* These are already handled by cdr_write() */
    ast_assert(strcasecmp(args.variable, "accountcode")
        && strcasecmp(args.variable, "peeraccount")
        && strcasecmp(args.variable, "amaflags"));
 
    if (!strcasecmp(args.variable, "userfield")) {
        ast_cdr_setuserfield(ast_channel_name(payload->chan), payload->value);
    } else {
        ast_cdr_setvar(ast_channel_name(payload->chan), args.variable, payload->value);
    }
}

References args, cdr_func_payload::arguments, AST_APP_ARG, ast_app_parse_options(), ast_assert, ast_cdr_setuserfield(), ast_cdr_setvar(), ast_channel_name(), AST_DECLARE_APP_ARGS, AST_STANDARD_APP_ARGS, ast_strdupa, ast_strlen_zero(), cdr_func_options, cdr_func_payload::chan, ast_flags::flags, NULL, options, stasis_message_data(), stasis_message_type(), and cdr_func_payload::value.

Referenced by load_module().

load_module()

static int load_module ( void  )

static

Definition at line 681 of file func_cdr.c.

{
    RAII_VAR(struct stasis_message_router *, router, ast_cdr_message_router(), ao2_cleanup);
    int res = 0;
 
    if (!router) {
        return AST_MODULE_LOAD_DECLINE;
    }
 
    res |= STASIS_MESSAGE_TYPE_INIT(cdr_read_message_type);
    res |= STASIS_MESSAGE_TYPE_INIT(cdr_write_message_type);
    res |= STASIS_MESSAGE_TYPE_INIT(cdr_prop_write_message_type);
    res |= ast_custom_function_register(&cdr_function);
    res |= ast_custom_function_register(&cdr_prop_function);
    res |= stasis_message_router_add(router, cdr_prop_write_message_type(),
                                     cdr_prop_write_callback, NULL);
    res |= stasis_message_router_add(router, cdr_write_message_type(),
                                     cdr_write_callback, NULL);
    res |= stasis_message_router_add(router, cdr_read_message_type(),
                                     cdr_read_callback, NULL);
 
    if (res) {
        unload_module();
        return AST_MODULE_LOAD_DECLINE;
    }
    return AST_MODULE_LOAD_SUCCESS;
}

References ao2_cleanup, ast_cdr_message_router(), ast_custom_function_register, AST_MODULE_LOAD_DECLINE, AST_MODULE_LOAD_SUCCESS, cdr_function, cdr_prop_function, cdr_prop_write_callback(), cdr_read_callback(), cdr_write_callback(), NULL, RAII_VAR, router, stasis_message_router_add(), STASIS_MESSAGE_TYPE_INIT, and unload_module().

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [1/3]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

cdr_prop_write_message_type

)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [2/3]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

cdr_read_message_type

)

STASIS_MESSAGE_TYPE_DEFN_LOCAL() [3/3]

STASIS_MESSAGE_TYPE_DEFN_LOCAL

(

cdr_write_message_type

)

unload_module()

static int unload_module ( void  )

static

Definition at line 662 of file func_cdr.c.

{
    RAII_VAR(struct stasis_message_router *, router, ast_cdr_message_router(), ao2_cleanup);
    int res = 0;
 
    if (router) {
        stasis_message_router_remove(router, cdr_prop_write_message_type());
        stasis_message_router_remove(router, cdr_write_message_type());
        stasis_message_router_remove(router, cdr_read_message_type());
    }
    STASIS_MESSAGE_TYPE_CLEANUP(cdr_read_message_type);
    STASIS_MESSAGE_TYPE_CLEANUP(cdr_write_message_type);
    STASIS_MESSAGE_TYPE_CLEANUP(cdr_prop_write_message_type);
    res |= ast_custom_function_unregister(&cdr_function);
    res |= ast_custom_function_unregister(&cdr_prop_function);
 
    return res;
}

References ao2_cleanup, ast_cdr_message_router(), ast_custom_function_unregister(), cdr_function, cdr_prop_function, RAII_VAR, router, stasis_message_router_remove(), and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by load_module().

Variable Documentation

__mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_DEFAULT , .description = "Call Detail Record (CDR) dialplan functions" , .key = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "cdr", }

static

Definition at line 714 of file func_cdr.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 714 of file func_cdr.c.

cdr_func_options

const struct ast_app_option cdr_func_options[128] = { [ 'f' ] = { .flag = OPT_FLOAT }, [ 'u' ] = { .flag = OPT_UNPARSED }, }

static

Definition at line 205 of file func_cdr.c.

Referenced by cdr_read_callback(), and cdr_write_callback().

cdr_function

struct ast_custom_function cdr_function

static

Initial value:

= {
    .name = "CDR",
    .read = cdr_read,
    .write = cdr_write,
}

Definition at line 650 of file func_cdr.c.

Referenced by load_module(), and unload_module().

cdr_prop_function

struct ast_custom_function cdr_prop_function

static

Initial value:

= {
    .name = "CDR_PROP",
    .read = NULL,
    .write = cdr_prop_write,
}

Definition at line 656 of file func_cdr.c.

Referenced by load_module(), and unload_module().