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 = ASTERISK_GPL_KEY , .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 203 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 720 of file func_cdr.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 720 of file func_cdr.c.

AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM

(

void

)

Definition at line 720 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 612 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 408 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(), 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 456 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 256 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, cdr_func_data::len, NULL, OPT_FLOAT, OPT_UNPARSED, options, stasis_message_data(), 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 230 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 514 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 365 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(), and cdr_func_payload::value.

Referenced by load_module().

load_module()

static int load_module ( void  )

static

Definition at line 687 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 668 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 = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .requires = "cdr", }

static

Definition at line 720 of file func_cdr.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 720 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 211 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 656 of file func_cdr.c.

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

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 662 of file func_cdr.c.

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

Referenced by load_module(), and unload_module().