cdr.h File Reference

Call Detail Record API. More...

#include "asterisk/channel.h"

Include dependency graph for cdr.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ast_cdr
	Responsible for call detail data. More...
struct	ast_cdr_config
	The global options available for CDRs. More...
struct	ast_cdr_config::batch_settings

Typedefs
typedef int(*	ast_cdrbe) (struct ast_cdr *cdr)
	CDR backend callback.

Enumerations
enum	ast_cdr_batch_mode_settings { BATCH_MODE_SCHEDULER_ONLY = 1 << 0 , BATCH_MODE_SAFE_SHUTDOWN = 1 << 1 }
	CDR Batch Mode settings. More...
enum	ast_cdr_disposition {   AST_CDR_NOANSWER = 0 , AST_CDR_NULL = (1 << 0) , AST_CDR_FAILED = (1 << 1) , AST_CDR_BUSY = (1 << 2) ,   AST_CDR_ANSWERED = (1 << 3) , AST_CDR_CONGESTION = (1 << 4) , AST_CDR_CANCEL = (1 << 5) }
	CDR Flags - Disposition. More...
enum	ast_cdr_options {   AST_CDR_FLAG_KEEP_VARS = (1 << 0) , AST_CDR_FLAG_DISABLE = (1 << 1) , AST_CDR_FLAG_DISABLE_ALL = (3 << 1) , AST_CDR_FLAG_PARTY_A = (1 << 3) ,   AST_CDR_FLAG_FINALIZE = (1 << 4) , AST_CDR_FLAG_SET_ANSWER = (1 << 5) , AST_CDR_FLAG_RESET = (1 << 6) , AST_CDR_LOCK_APP = (1 << 7) }
	CDR manipulation options. Certain function calls will manipulate the state of a CDR object based on these flags. More...
enum	ast_cdr_settings {   CDR_ENABLED = 1 << 0 , CDR_BATCHMODE = 1 << 1 , CDR_UNANSWERED = 1 << 2 , CDR_CONGESTION = 1 << 3 ,   CDR_END_BEFORE_H_EXTEN = 1 << 4 , CDR_INITIATED_SECONDS = 1 << 5 , CDR_DEBUG = 1 << 6 , CDR_CHANNEL_DEFAULT_ENABLED = 1 << 7 ,   CDR_IGNORE_STATE_CHANGES = 1 << 8 , CDR_IGNORE_DIAL_CHANGES = 1 << 9 , CDR_CANCEL_DISPOSITION_ENABLED = 1 << 10 }
	CDR engine settings. More...

Functions
struct ast_cdr *	ast_cdr_alloc (void)
	Allocate a CDR record.
int	ast_cdr_backend_suspend (const char *name)
	Suspend a CDR backend temporarily.
int	ast_cdr_backend_unsuspend (const char *name)
	Unsuspend a CDR backend.
int	ast_cdr_clear_property (const char *channel_name, enum ast_cdr_options option)
	Clear a property on a CDR for a channel.
const char *	ast_cdr_disp2str (int disposition)
	Disposition to a string.
struct ast_cdr *	ast_cdr_dup (struct ast_cdr *cdr)
	Duplicate a public CDR.
void	ast_cdr_engine_term (void)
int	ast_cdr_fork (const char *channel_name, struct ast_flags *options)
	Fork a CDR.
void	ast_cdr_format_var (struct ast_cdr *cdr, const char *name, char **ret, char *workspace, int workspacelen, int raw)
	Format a CDR variable from an already posted CDR.
void	ast_cdr_free (struct ast_cdr *cdr)
	Free a CDR record.
struct ast_cdr_config *	ast_cdr_get_config (void)
	Obtain the current CDR configuration.
int	ast_cdr_getvar (const char *channel_name, const char *name, char *value, size_t length)
	Retrieve a CDR variable from a channel's current CDR.
int	ast_cdr_is_enabled (void)
	Return TRUE if CDR subsystem is enabled.
struct stasis_message_router *	ast_cdr_message_router (void)
	Return the message router for the CDR engine.
int	ast_cdr_modifier_register (const char *name, const char *desc, ast_cdrbe be)
	Register a CDR modifier.
int	ast_cdr_modifier_unregister (const char *name)
	Unregister a CDR modifier.
int	ast_cdr_register (const char *name, const char *desc, ast_cdrbe be)
	Register a CDR handling engine.
int	ast_cdr_reset (const char *channel_name, int keep_variables)
	Reset the detail record.
int	ast_cdr_serialize_variables (const char *channel_name, struct ast_str **buf, char delim, char sep)
	Serializes all the data and variables for a current CDR record.
void	ast_cdr_set_config (struct ast_cdr_config *config)
	Set the current CDR configuration.
int	ast_cdr_set_property (const char *channel_name, enum ast_cdr_options option)
	Set a property on a CDR for a channel.
void	ast_cdr_setuserfield (const char *channel_name, const char *userfield)
	Set CDR user field for channel (stored in CDR)
int	ast_cdr_setvar (const char *channel_name, const char *name, const char *value)
	Set a variable on a CDR.
int	ast_cdr_unregister (const char *name)
	Unregister a CDR handling engine.

Detailed Description

Call Detail Record API.

Call Detail Record Engine.

Author

Mark Spencer marks.nosp@m.ter@.nosp@m.digiu.nosp@m.m.co.nosp@m.m

Since

12

Definition in file cdr.h.

Typedef Documentation

ast_cdrbe

typedef int(* ast_cdrbe) (struct ast_cdr *cdr)

CDR backend callback.

Warning

CDR backends should NOT attempt to access the channel associated with a CDR record. This channel is not guaranteed to exist when the CDR backend is invoked.

Definition at line 467 of file cdr.h.

Enumeration Type Documentation

ast_cdr_batch_mode_settings

enum ast_cdr_batch_mode_settings

CDR Batch Mode settings.

Enumerator
BATCH_MODE_SCHEDULER_ONLY	Don't spawn a thread to handle the batches - do it on the scheduler
BATCH_MODE_SAFE_SHUTDOWN	During safe shutdown, submit the batched CDRs

Definition at line 234 of file cdr.h.

                                 {
    BATCH_MODE_SCHEDULER_ONLY = 1 << 0, /*!< Don't spawn a thread to handle the batches - do it on the scheduler */
    BATCH_MODE_SAFE_SHUTDOWN = 1 << 1,  /*!< During safe shutdown, submit the batched CDRs */
};

ast_cdr_disposition

enum ast_cdr_disposition

CDR Flags - Disposition.

Enumerator
AST_CDR_NOANSWER
AST_CDR_NULL
AST_CDR_FAILED
AST_CDR_BUSY
AST_CDR_ANSWERED
AST_CDR_CONGESTION
AST_CDR_CANCEL

Definition at line 257 of file cdr.h.

                         {
    AST_CDR_NOANSWER   = 0,
    AST_CDR_NULL       = (1 << 0),
    AST_CDR_FAILED     = (1 << 1),
    AST_CDR_BUSY       = (1 << 2),
    AST_CDR_ANSWERED   = (1 << 3),
    AST_CDR_CONGESTION = (1 << 4),
    AST_CDR_CANCEL     = (1 << 5),
};

ast_cdr_options

enum ast_cdr_options

CDR manipulation options. Certain function calls will manipulate the state of a CDR object based on these flags.

Enumerator
AST_CDR_FLAG_KEEP_VARS	Copy variables during the operation
AST_CDR_FLAG_DISABLE	Disable the current CDR
AST_CDR_FLAG_DISABLE_ALL	Disable the CDR and all future CDRs
AST_CDR_FLAG_PARTY_A	Set the channel as party A
AST_CDR_FLAG_FINALIZE	Finalize the current CDRs
AST_CDR_FLAG_SET_ANSWER	If the channel is answered, set the answer time to now
AST_CDR_FLAG_RESET	If set, set the start and answer time to now
AST_CDR_LOCK_APP	Prevent any further changes to the application field/data field for this CDR

Definition at line 243 of file cdr.h.

                     {
    AST_CDR_FLAG_KEEP_VARS = (1 << 0),   /*!< Copy variables during the operation */
    AST_CDR_FLAG_DISABLE = (1 << 1),     /*!< Disable the current CDR */
    AST_CDR_FLAG_DISABLE_ALL = (3 << 1), /*!< Disable the CDR and all future CDRs */
    AST_CDR_FLAG_PARTY_A = (1 << 3),     /*!< Set the channel as party A */
    AST_CDR_FLAG_FINALIZE = (1 << 4),    /*!< Finalize the current CDRs */
    AST_CDR_FLAG_SET_ANSWER = (1 << 5),  /*!< If the channel is answered, set the answer time to now */
    AST_CDR_FLAG_RESET = (1 << 6),       /*!< If set, set the start and answer time to now */
    AST_CDR_LOCK_APP = (1 << 7),         /*!< Prevent any further changes to the application field/data field for this CDR */
};

ast_cdr_settings

enum ast_cdr_settings

CDR engine settings.

Enumerator
CDR_ENABLED	Enable CDRs
CDR_BATCHMODE	Whether or not we should dispatch CDRs in batches
CDR_UNANSWERED	Log unanswered CDRs
CDR_CONGESTION	Treat congestion as if it were a failed call
CDR_END_BEFORE_H_EXTEN	End the CDR before the 'h' extension runs
CDR_INITIATED_SECONDS	Include microseconds into the billing time
CDR_DEBUG	Enables extra debug statements
CDR_CHANNEL_DEFAULT_ENABLED	Whether CDR is enabled for each channel by default
CDR_IGNORE_STATE_CHANGES	Whether to ignore bridge and other call state change events
CDR_IGNORE_DIAL_CHANGES	Whether to ignore dial state changes
CDR_CANCEL_DISPOSITION_ENABLED	Whether to enable CANCEL disposition in CDR

Definition at line 219 of file cdr.h.

                      {
    CDR_ENABLED = 1 << 0,               /*!< Enable CDRs */
    CDR_BATCHMODE = 1 << 1,             /*!< Whether or not we should dispatch CDRs in batches */
    CDR_UNANSWERED = 1 << 2,            /*!< Log unanswered CDRs */
    CDR_CONGESTION = 1 << 3,            /*!< Treat congestion as if it were a failed call */
    CDR_END_BEFORE_H_EXTEN = 1 << 4,    /*!< End the CDR before the 'h' extension runs */
    CDR_INITIATED_SECONDS = 1 << 5,     /*!< Include microseconds into the billing time */
    CDR_DEBUG = 1 << 6,                 /*!< Enables extra debug statements */
    CDR_CHANNEL_DEFAULT_ENABLED = 1 << 7, /*!< Whether CDR is enabled for each channel by default */
    CDR_IGNORE_STATE_CHANGES = 1 << 8,  /*!< Whether to ignore bridge and other call state change events */
    CDR_IGNORE_DIAL_CHANGES = 1 << 9,   /*!< Whether to ignore dial state changes */
    CDR_CANCEL_DISPOSITION_ENABLED = 1 << 10, /*!< Whether to enable CANCEL disposition in CDR */
};

Function Documentation

ast_cdr_alloc()

struct ast_cdr * ast_cdr_alloc

(

void

)

Allocate a CDR record.

Returns

a malloc'd ast_cdr structure

Return values

NULL	on error (malloc failure)

Definition at line 3573 of file cdr.c.

{
    struct ast_cdr *x;
 
    x = ast_calloc(1, sizeof(*x));
    return x;
}

References ast_calloc.

Referenced by ast_cdr_dup().

ast_cdr_backend_suspend()

int ast_cdr_backend_suspend

(

const char *

name

)

Suspend a CDR backend temporarily.

Return values

0	The backend is suspended
-1	The backend could not be suspended

Definition at line 3004 of file cdr.c.

{
    int success = -1;
    struct cdr_beitem *i = NULL;
 
    AST_RWLIST_WRLOCK(&be_list);
    AST_RWLIST_TRAVERSE(&be_list, i, list) {
        if (!strcasecmp(name, i->name)) {
            ast_debug(3, "Suspending CDR backend %s\n", i->name);
            i->suspended = 1;
            success = 0;
        }
    }
    AST_RWLIST_UNLOCK(&be_list);
 
    return success;
}

References ast_debug, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, cdr_beitem::list, cdr_beitem::name, name, NULL, and cdr_beitem::suspended.

Referenced by load_config(), load_config(), and odbc_load_module().

ast_cdr_backend_unsuspend()

int ast_cdr_backend_unsuspend

(

const char *

name

)

Unsuspend a CDR backend.

Return values

0	The backend was unsuspended
-1	The back could not be unsuspended

Definition at line 3022 of file cdr.c.

{
    int success = -1;
    struct cdr_beitem *i = NULL;
 
    AST_RWLIST_WRLOCK(&be_list);
    AST_RWLIST_TRAVERSE(&be_list, i, list) {
        if (!strcasecmp(name, i->name)) {
            ast_debug(3, "Unsuspending CDR backend %s\n", i->name);
            i->suspended = 0;
            success = 0;
        }
    }
    AST_RWLIST_UNLOCK(&be_list);
 
    return success;
}

References ast_debug, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, cdr_beitem::list, cdr_beitem::name, name, NULL, and cdr_beitem::suspended.

Referenced by load_config(), load_config(), and odbc_load_module().

ast_cdr_clear_property()

int ast_cdr_clear_property	(	const char *	channel_name,
		enum ast_cdr_options	option
	)

Clear a property on a CDR for a channel.

Since

12

Clears a flag previously set by ast_cdr_set_property

Parameters

channel_name	The CDR's channel
option	Option to clear from the CDR

Return values

0	on success
1	on error

Definition at line 3728 of file cdr.c.

{
    struct cdr_object *cdr;
    struct cdr_object *it_cdr;
 
    cdr = cdr_object_get_by_name(channel_name);
    if (!cdr) {
        return -1;
    }
 
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        if (it_cdr->fn_table == &finalized_state_fn_table) {
            continue;
        }
        ast_clear_flag(&it_cdr->flags, option);
    }
    ao2_unlock(cdr);
 
    ao2_cleanup(cdr);
    return 0;
}

References ao2_cleanup, ao2_lock, ao2_unlock, ast_clear_flag, cdr_object_get_by_name(), finalized_state_fn_table, cdr_object::next, and cdr_object::start.

Referenced by AST_TEST_DEFINE(), and cdr_prop_write_callback().

ast_cdr_disp2str()

const char * ast_cdr_disp2str

(

int

disposition

)

Disposition to a string.

Parameters

disposition

input binary form Converts the binary form of a disposition to string form.

Returns

a pointer to the string form

Definition at line 3581 of file cdr.c.

{
    switch (disposition) {
    case AST_CDR_NULL:
        return "NO ANSWER"; /* by default, for backward compatibility */
    case AST_CDR_NOANSWER:
        return "NO ANSWER";
    case AST_CDR_FAILED:
        return "FAILED";
    case AST_CDR_BUSY:
        return "BUSY";
    case AST_CDR_ANSWERED:
        return "ANSWERED";
    case AST_CDR_CONGESTION:
        return "CONGESTION";
    case AST_CDR_CANCEL:
        return "CANCEL";
    }
    return "UNKNOWN";
}

References AST_CDR_ANSWERED, AST_CDR_BUSY, AST_CDR_CANCEL, AST_CDR_CONGESTION, AST_CDR_FAILED, AST_CDR_NOANSWER, AST_CDR_NULL, and ast_cdr::disposition.

Referenced by ast_cdr_format_var(), beanstalk_put(), build_csv_record(), build_radius_record(), cdr_object_finalize(), cdr_read_callback(), execute_cb(), format_disposition(), manager_log(), and tds_log().

ast_cdr_dup()

struct ast_cdr * ast_cdr_dup

(

struct ast_cdr *

cdr

)

Duplicate a public CDR.

Parameters

cdr	the record to duplicate

Returns

a malloc'd ast_cdr structure,

Return values

NULL	on error (malloc failure)

Definition at line 3136 of file cdr.c.

{
    struct ast_cdr *newcdr;
 
    if (!cdr) {
        return NULL;
    }
    newcdr = ast_cdr_alloc();
    if (!newcdr) {
        return NULL;
    }
 
    *newcdr = *cdr;
    AST_LIST_HEAD_INIT_NOLOCK(&newcdr->varshead);
    copy_variables(&newcdr->varshead, &cdr->varshead);
    newcdr->next = NULL;
 
    return newcdr;
}

References ast_cdr_alloc(), AST_LIST_HEAD_INIT_NOLOCK, copy_variables(), NULL, ast_cdr::start, and ast_cdr::varshead.

Referenced by dummy_chan_alloc_cdr(), and manager_log().

ast_cdr_engine_term()

void ast_cdr_engine_term

(

void

)

Submit any remaining CDRs and prepare for shutdown

Definition at line 4758 of file cdr.c.

{
    RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
 
    /* Since this is called explicitly during process shutdown, we might not have ever
     * been initialized. If so, the config object will be NULL.
     */
    if (!mod_cfg) {
        return;
    }
 
    if (cdr_sync_message_type()) {
        void *payload;
        struct stasis_message *message;
 
        if (!stasis_router) {
            return;
        }
 
        /* Make sure we have the needed items */
        payload = ao2_alloc(sizeof(*payload), NULL);
        if (!payload) {
            return;
        }
 
        ast_debug(1, "CDR Engine termination request received; waiting on messages...\n");
 
        message = stasis_message_create(cdr_sync_message_type(), payload);
        if (message) {
            stasis_message_router_publish_sync(stasis_router, message);
        }
        ao2_cleanup(message);
        ao2_cleanup(payload);
    }
 
    if (ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
        cdr_submit_batch(ast_test_flag(&mod_cfg->general->batch_settings.settings, BATCH_MODE_SAFE_SHUTDOWN));
    }
}

References ao2_alloc, ao2_cleanup, ao2_global_obj_ref, ast_debug, ast_test_flag, BATCH_MODE_SAFE_SHUTDOWN, CDR_BATCHMODE, cdr_submit_batch(), NULL, RAII_VAR, stasis_message_create(), stasis_message_router_publish_sync(), and stasis_router.

Referenced by can_safely_quit(), and finalize_batch_mode().

ast_cdr_fork()

int ast_cdr_fork	(	const char *	channel_name,
		struct ast_flags *	options
	)

Fork a CDR.

Since

12

Parameters

channel_name	The name of the channel whose CDR should be forked
options	Options to control how the fork occurs.

Return values

0	on success
-1	on failure

Definition at line 3790 of file cdr.c.

{
    RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
    struct cdr_object *new_cdr;
    struct cdr_object *it_cdr;
    struct cdr_object *cdr_obj;
 
    if (!cdr) {
        return -1;
    }
 
    {
        SCOPED_AO2LOCK(lock, cdr);
        struct timeval now = ast_tvnow();
 
        cdr_obj = cdr->last;
        if (cdr_obj->fn_table == &finalized_state_fn_table) {
            /* If the last CDR in the chain is finalized, don't allow a fork -
             * things are already dying at this point
             */
            return -1;
        }
 
        /* Copy over the basic CDR information. The Party A information is
         * copied over automatically as part of the append
         */
        ast_debug(1, "Forking CDR for channel %s\n", cdr->party_a.snapshot->base->name);
        new_cdr = cdr_object_create_and_append(cdr, &now);
        if (!new_cdr) {
            return -1;
        }
        new_cdr->fn_table = cdr_obj->fn_table;
        ast_string_field_set(new_cdr, bridge, cdr->bridge);
        ast_string_field_set(new_cdr, appl, cdr->appl);
        ast_string_field_set(new_cdr, data, cdr->data);
        ast_string_field_set(new_cdr, context, cdr->context);
        ast_string_field_set(new_cdr, exten, cdr->exten);
        new_cdr->flags = cdr->flags;
        /* Explicitly clear the AST_CDR_LOCK_APP flag - we want
         * the application to be changed on the new CDR if the
         * dialplan demands it
         */
        ast_clear_flag(&new_cdr->flags, AST_CDR_LOCK_APP);
 
        /* If there's a Party B, copy it over as well */
        if (cdr_obj->party_b.snapshot) {
            new_cdr->party_b.snapshot = cdr_obj->party_b.snapshot;
            ao2_ref(new_cdr->party_b.snapshot, +1);
            cdr_all_relink(new_cdr);
            strcpy(new_cdr->party_b.userfield, cdr_obj->party_b.userfield);
            new_cdr->party_b.flags = cdr_obj->party_b.flags;
            if (ast_test_flag(options, AST_CDR_FLAG_KEEP_VARS)) {
                copy_variables(&new_cdr->party_b.variables, &cdr_obj->party_b.variables);
            }
        }
        new_cdr->start = cdr_obj->start;
        new_cdr->answer = cdr_obj->answer;
        new_cdr->lastevent = ast_tvnow();
 
        /* Modify the times based on the flags passed in */
        if (ast_test_flag(options, AST_CDR_FLAG_SET_ANSWER)
                && new_cdr->party_a.snapshot->state == AST_STATE_UP) {
            new_cdr->answer = ast_tvnow();
        }
        if (ast_test_flag(options, AST_CDR_FLAG_RESET)) {
            new_cdr->answer = ast_tvnow();
            new_cdr->start = ast_tvnow();
        }
 
        /* Create and append, by default, copies over the variables */
        if (!ast_test_flag(options, AST_CDR_FLAG_KEEP_VARS)) {
            free_variables(&new_cdr->party_a.variables);
        }
 
        /* Finalize any current CDRs */
        if (ast_test_flag(options, AST_CDR_FLAG_FINALIZE)) {
            for (it_cdr = cdr; it_cdr != new_cdr; it_cdr = it_cdr->next) {
                if (it_cdr->fn_table == &finalized_state_fn_table) {
                    continue;
                }
                /* Force finalization on the CDR. This will bypass any checks for
                 * end before 'h' extension.
                 */
                cdr_object_finalize(it_cdr);
                cdr_object_transition_state(it_cdr, &finalized_state_fn_table);
            }
        }
    }
 
    return 0;
}

References cdr_object::answer, ao2_cleanup, ao2_ref, cdr_object::appl, AST_CDR_FLAG_FINALIZE, AST_CDR_FLAG_KEEP_VARS, AST_CDR_FLAG_RESET, AST_CDR_FLAG_SET_ANSWER, AST_CDR_LOCK_APP, ast_clear_flag, ast_debug, AST_STATE_UP, ast_string_field_set, ast_test_flag, ast_tvnow(), cdr_object::bridge, cdr_all_relink(), cdr_object_create_and_append(), cdr_object_finalize(), cdr_object_get_by_name(), cdr_object_transition_state(), copy_variables(), cdr_object::data, cdr_object::exten, finalized_state_fn_table, ast_flags::flags, cdr_object_snapshot::flags, cdr_object::flags, cdr_object::fn_table, free_variables(), cdr_object::last, cdr_object::lastevent, lock, cdr_object::next, options, cdr_object::party_a, cdr_object::party_b, RAII_VAR, SCOPED_AO2LOCK, cdr_object_snapshot::snapshot, cdr_object::start, ast_channel_snapshot::state, cdr_object_snapshot::userfield, and cdr_object_snapshot::variables.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), AST_TEST_DEFINE(), and forkcdr_callback().

ast_cdr_format_var()

void ast_cdr_format_var	(	struct ast_cdr *	cdr,
		const char *	name,
		char **	ret,
		char *	workspace,
		int	workspacelen,
		int	raw
	)

Format a CDR variable from an already posted CDR.

Since

12

Parameters

cdr	The dispatched CDR to process
name	The name of the variable
ret	Pointer to the formatted buffer
workspace	A pointer to the buffer to use to format the variable
workspacelen	The size of workspace
raw	If non-zero and a date/time is extracted, provide epoch seconds. Otherwise format as a date/time stamp

Definition at line 3188 of file cdr.c.

{
    const char *fmt = "%Y-%m-%d %T";
    const char *varbuf;
 
    if (!cdr) {
        return;
    }
 
    *ret = NULL;
 
    if (!strcasecmp(name, "clid")) {
        ast_copy_string(workspace, cdr->clid, workspacelen);
    } else if (!strcasecmp(name, "src")) {
        ast_copy_string(workspace, cdr->src, workspacelen);
    } else if (!strcasecmp(name, "dst")) {
        ast_copy_string(workspace, cdr->dst, workspacelen);
    } else if (!strcasecmp(name, "dcontext")) {
        ast_copy_string(workspace, cdr->dcontext, workspacelen);
    } else if (!strcasecmp(name, "channel")) {
        ast_copy_string(workspace, cdr->channel, workspacelen);
    } else if (!strcasecmp(name, "dstchannel")) {
        ast_copy_string(workspace, cdr->dstchannel, workspacelen);
    } else if (!strcasecmp(name, "lastapp")) {
        ast_copy_string(workspace, cdr->lastapp, workspacelen);
    } else if (!strcasecmp(name, "lastdata")) {
        ast_copy_string(workspace, cdr->lastdata, workspacelen);
    } else if (!strcasecmp(name, "start")) {
        cdr_get_tv(cdr->start, raw ? NULL : fmt, workspace, workspacelen);
    } else if (!strcasecmp(name, "answer")) {
        cdr_get_tv(cdr->answer, raw ? NULL : fmt, workspace, workspacelen);
    } else if (!strcasecmp(name, "end")) {
        cdr_get_tv(cdr->end, raw ? NULL : fmt, workspace, workspacelen);
    } else if (!strcasecmp(name, "duration")) {
        snprintf(workspace, workspacelen, "%ld", cdr->end.tv_sec != 0 ? cdr->duration : (long)ast_tvdiff_ms(ast_tvnow(), cdr->start) / 1000);
    } else if (!strcasecmp(name, "billsec")) {
        snprintf(workspace, workspacelen, "%ld", (cdr->billsec || !ast_tvzero(cdr->end) || ast_tvzero(cdr->answer)) ? cdr->billsec : (long)ast_tvdiff_ms(ast_tvnow(), cdr->answer) / 1000);
    } else if (!strcasecmp(name, "disposition")) {
        if (raw) {
            snprintf(workspace, workspacelen, "%ld", cdr->disposition);
        } else {
            ast_copy_string(workspace, ast_cdr_disp2str(cdr->disposition), workspacelen);
        }
    } else if (!strcasecmp(name, "amaflags")) {
        if (raw) {
            snprintf(workspace, workspacelen, "%ld", cdr->amaflags);
        } else {
            ast_copy_string(workspace, ast_channel_amaflags2string(cdr->amaflags), workspacelen);
        }
    } else if (!strcasecmp(name, "accountcode")) {
        ast_copy_string(workspace, cdr->accountcode, workspacelen);
    } else if (!strcasecmp(name, "peeraccount")) {
        ast_copy_string(workspace, cdr->peeraccount, workspacelen);
    } else if (!strcasecmp(name, "uniqueid")) {
        ast_copy_string(workspace, cdr->uniqueid, workspacelen);
    } else if (!strcasecmp(name, "linkedid")) {
        ast_copy_string(workspace, cdr->linkedid, workspacelen);
    } else if (!strcasecmp(name, "tenantid")) {
        ast_copy_string(workspace, cdr->tenantid, workspacelen);
    } else if (!strcasecmp(name, "peertenantid")) {
        ast_copy_string(workspace, cdr->peertenantid, workspacelen);
    } else if (!strcasecmp(name, "userfield")) {
        ast_copy_string(workspace, cdr->userfield, workspacelen);
    } else if (!strcasecmp(name, "sequence")) {
        snprintf(workspace, workspacelen, "%d", cdr->sequence);
    } else if ((varbuf = cdr_format_var_internal(cdr, name))) {
        ast_copy_string(workspace, varbuf, workspacelen);
    } else {
        workspace[0] = '\0';
    }
 
    if (!ast_strlen_zero(workspace)) {
        *ret = workspace;
    }
}

References ast_cdr::accountcode, ast_cdr::amaflags, ast_cdr::answer, ast_cdr_disp2str(), ast_channel_amaflags2string(), ast_copy_string(), ast_strlen_zero(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), ast_cdr::billsec, cdr_format_var_internal(), cdr_get_tv(), ast_cdr::channel, ast_cdr::clid, ast_cdr::dcontext, ast_cdr::disposition, ast_cdr::dst, ast_cdr::dstchannel, ast_cdr::duration, ast_cdr::end, ast_cdr::lastapp, ast_cdr::lastdata, ast_cdr::linkedid, name, NULL, ast_cdr::peeraccount, ast_cdr::peertenantid, ast_cdr::sequence, ast_cdr::src, ast_cdr::start, ast_cdr::tenantid, ast_cdr::uniqueid, and ast_cdr::userfield.

Referenced by cdr_read_callback(), cdr_retrieve_time(), odbc_log(), and pgsql_log().

ast_cdr_free()

void ast_cdr_free

(

struct ast_cdr *

cdr

)

Free a CDR record.

Parameters

cdr	ast_cdr structure to free

Definition at line 3562 of file cdr.c.

{
    while (cdr) {
        struct ast_cdr *next = cdr->next;
 
        free_variables(&cdr->varshead);
        ast_free(cdr);
        cdr = next;
    }
}

References ast_free, free_variables(), ast_cdr::next, and ast_cdr::varshead.

Referenced by ast_channel_destructor(), ast_dummy_channel_destructor(), cdr_detach(), clear_mock_cdr_backend(), and do_batch_backend_process().

ast_cdr_get_config()

struct ast_cdr_config * ast_cdr_get_config

(

void

)

Obtain the current CDR configuration.

Since

12

The configuration is a ref counted object. The caller of this function must decrement the ref count when finished with the configuration.

Return values

NULL

on error

Returns

The current CDR configuration

Definition at line 2964 of file cdr.c.

{
    struct ast_cdr_config *general;
    struct module_config *mod_cfg;
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        return NULL;
    }
    general = ao2_bump(mod_cfg->general);
    ao2_cleanup(mod_cfg);
    return general;
}

References ao2_bump, ao2_cleanup, ao2_global_obj_ref, module_config::general, and NULL.

Referenced by test_cdr_init_cb().

ast_cdr_getvar()

int ast_cdr_getvar	(	const char *	channel_name,
		const char *	name,
		char *	value,
		size_t	length
	)

Retrieve a CDR variable from a channel's current CDR.

Since

12

Parameters

channel_name	The name of the party A channel that the CDR is associated with
name	The name of the variable to retrieve
value	Buffer to hold the value
length	The size of the buffer

Return values

0	on success
non-zero	on failure

Definition at line 3475 of file cdr.c.

{
    struct cdr_object *cdr;
    struct cdr_object *cdr_obj;
 
    if (ast_strlen_zero(name)) {
        return 1;
    }
 
    cdr = cdr_object_get_by_name(channel_name);
    if (!cdr) {
        ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
        return 1;
    }
 
    ao2_lock(cdr);
 
    cdr_obj = cdr->last;
    if (cdr_object_format_property(cdr_obj, name, value, length)) {
        /* Property failed; attempt variable */
        cdr_object_format_var_internal(cdr_obj, name, value, length);
    }
 
    ao2_unlock(cdr);
 
    ao2_cleanup(cdr);
    return 0;
}

References ao2_cleanup, ao2_lock, ao2_unlock, ast_log, AST_LOG_ERROR, ast_strlen_zero(), cdr_object_format_property(), cdr_object_format_var_internal(), cdr_object_get_by_name(), cdr_object::last, name, cdr_object::start, and value.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), cdr_read_callback(), and cdr_retrieve_time().

ast_cdr_is_enabled()

int ast_cdr_is_enabled

(

void

)

Return TRUE if CDR subsystem is enabled.

Definition at line 2999 of file cdr.c.

{
    return is_cdr_flag_set(CDR_ENABLED);
}

References CDR_ENABLED, and is_cdr_flag_set().

Referenced by action_coresettings(), and handle_show_settings().

ast_cdr_message_router()

struct stasis_message_router * ast_cdr_message_router

(

void

)

Return the message router for the CDR engine.

This returns the stasis_message_router that the CDR engine uses for dispatching Stasis Message Bus API messages. The reference on the message router is bumped and must be released by the caller of this function.

Return values

NULL	if the CDR engine is disabled or unavailable

Returns

the stasis_message_router otherwise

Definition at line 4448 of file cdr.c.

{
    if (!stasis_router) {
        return NULL;
    }
 
    ao2_bump(stasis_router);
    return stasis_router;
}

References ao2_bump, NULL, and stasis_router.

Referenced by cdr_prop_write(), cdr_read(), cdr_write(), forkcdr_exec(), load_module(), load_module(), load_module(), publish_app_cdr_message(), unload_module(), unload_module(), and unload_module().

ast_cdr_modifier_register()

int ast_cdr_modifier_register	(	const char *	name,
		const char *	desc,
		ast_cdrbe	be
	)

Register a CDR modifier.

Parameters

name	name associated with the particular CDR modifier
desc	description of the CDR modifier
be	function pointer to a CDR modifier

Used to register a Call Detail Record modifier.

This gives modules a chance to modify CDR fields before they are dispatched to registered backends (odbc, syslog, etc).

Note

The modified CDR will be passed to all registered backends for logging. For instance, if cdr_manager changes the CDR data, cdr_adaptive_odbc will also get the modified CDR.

Return values

0	on success.
-1	on error

Definition at line 3086 of file cdr.c.

{
    return cdr_generic_register((struct be_list *)&mo_list, name, desc, be);
}

References be, cdr_generic_register(), desc, and name.

ast_cdr_modifier_unregister()

int ast_cdr_modifier_unregister

(

const char *

name

)

Unregister a CDR modifier.

Parameters

name	name of CDR modifier to unregister Unregisters a CDR modifier by its name

Return values

0	The modifier unregistered successfully
-1	The modifier could not be unregistered at this time

Definition at line 3131 of file cdr.c.

{
    return ast_cdr_generic_unregister((struct be_list *)&mo_list, name);
}

References ast_cdr_generic_unregister(), and name.

ast_cdr_register()

int ast_cdr_register	(	const char *	name,
		const char *	desc,
		ast_cdrbe	be
	)

Register a CDR handling engine.

Parameters

name	name associated with the particular CDR handler
desc	description of the CDR handler
be	function pointer to a CDR handler Used to register a Call Detail Record handler.

Return values

0	on success.
-1	on error

Definition at line 3081 of file cdr.c.

{
    return cdr_generic_register(&be_list, name, desc, be);
}

References be, cdr_generic_register(), desc, and name.

Referenced by load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), load_module(), odbc_load_module(), register_backend(), and unload_module().

ast_cdr_reset()

int ast_cdr_reset	(	const char *	channel_name,
		int	keep_variables
	)

Reset the detail record.

Parameters

channel_name	The channel that the CDR is associated with
keep_variables	Keep the variables during the reset. If zero, variables are discarded during the reset.

Return values

0	on success
-1	on failure

Definition at line 3751 of file cdr.c.

{
    struct cdr_object *cdr;
    struct ast_var_t *vardata;
    struct cdr_object *it_cdr;
 
    cdr = cdr_object_get_by_name(channel_name);
    if (!cdr) {
        return -1;
    }
 
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        /* clear variables */
        if (!keep_variables) {
            while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_a.variables, entries))) {
                ast_var_delete(vardata);
            }
            if (cdr->party_b.snapshot) {
                while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_b.variables, entries))) {
                    ast_var_delete(vardata);
                }
            }
        }
 
        /* Reset to initial state */
        memset(&it_cdr->start, 0, sizeof(it_cdr->start));
        memset(&it_cdr->end, 0, sizeof(it_cdr->end));
        memset(&it_cdr->answer, 0, sizeof(it_cdr->answer));
        it_cdr->start = ast_tvnow();
        it_cdr->lastevent = it_cdr->start;
        cdr_object_check_party_a_answer(it_cdr);
    }
    ao2_unlock(cdr);
 
    ao2_cleanup(cdr);
    return 0;
}

References ao2_cleanup, ao2_lock, ao2_unlock, AST_LIST_REMOVE_HEAD, ast_tvnow(), ast_var_delete(), cdr_object_check_party_a_answer(), cdr_object_get_by_name(), cdr_object::next, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by appcdr_callback(), and dial_exec_full().

ast_cdr_serialize_variables()

int ast_cdr_serialize_variables	(	const char *	channel_name,
		struct ast_str **	buf,
		char	delim,
		char	sep
	)

Serializes all the data and variables for a current CDR record.

Parameters

channel_name	The channel to get the CDR for
buf	A buffer to use for formatting the data
delim	A delimeter to use to separate variable keys/values
sep	A separator to use between nestings

Returns

the total number of serialized variables

Definition at line 3504 of file cdr.c.

{
    struct cdr_object *cdr;
    struct cdr_object *it_cdr;
    struct ast_var_t *variable;
    const char *var;
    char workspace[256];
    int total = 0, x = 0, i;
 
    cdr = cdr_object_get_by_name(channel_name);
    if (!cdr) {
        if (is_cdr_flag_set(CDR_ENABLED)) {
            ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
        }
        return 0;
    }
 
    ast_str_reset(*buf);
 
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        if (++x > 1) {
            ast_str_append(buf, 0, "\n");
        }
 
        AST_LIST_TRAVERSE(&it_cdr->party_a.variables, variable, entries) {
            if (!(var = ast_var_name(variable))) {
                continue;
            }
 
            if (ast_str_append(buf, 0, "level %d: %s%c%s%c", x, var, delim, S_OR(ast_var_value(variable), ""), sep) < 0) {
                ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
                break;
            }
 
            total++;
        }
 
        for (i = 0; cdr_readonly_vars[i]; i++) {
            if (cdr_object_format_property(it_cdr, cdr_readonly_vars[i], workspace, sizeof(workspace))) {
                /* Unhandled read-only CDR variable. */
                ast_assert(0);
                continue;
            }
 
            if (!ast_strlen_zero(workspace)
                && ast_str_append(buf, 0, "level %d: %s%c%s%c", x, cdr_readonly_vars[i], delim, workspace, sep) < 0) {
                ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
                break;
            }
            total++;
        }
    }
    ao2_unlock(cdr);
    ao2_cleanup(cdr);
    return total;
}

References ao2_cleanup, ao2_lock, ao2_unlock, ast_assert, AST_LIST_TRAVERSE, ast_log, AST_LOG_ERROR, ast_str_append(), ast_str_reset(), ast_strlen_zero(), ast_var_name(), ast_var_value(), buf, CDR_ENABLED, cdr_object_format_property(), cdr_object_get_by_name(), cdr_readonly_vars, ast_var_t::entries, is_cdr_flag_set(), LOG_ERROR, cdr_object::next, cdr_object::party_a, S_OR, cdr_object::start, total, var, and cdr_object_snapshot::variables.

Referenced by handle_showchan().

ast_cdr_set_config()

void ast_cdr_set_config

(

struct ast_cdr_config *

config

)

Set the current CDR configuration.

Since

12

Parameters

config

The new CDR configuration

Definition at line 2978 of file cdr.c.

{
    struct module_config *mod_cfg;
 
    if (!config) {
        return;
    }
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        return;
    }
 
    ao2_replace(mod_cfg->general, config);
 
    cdr_set_debug_mode(mod_cfg);
    cdr_toggle_runtime_options();
 
    ao2_cleanup(mod_cfg);
}

References ao2_cleanup, ao2_global_obj_ref, ao2_replace, cdr_set_debug_mode, cdr_toggle_runtime_options(), config, and module_config::general.

Referenced by test_cdr_cleanup_cb().

ast_cdr_set_property()

int ast_cdr_set_property	(	const char *	channel_name,
		enum ast_cdr_options	option
	)

Set a property on a CDR for a channel.

Since

12

This function sets specific administrative properties on a CDR for a channel. This includes properties like preventing a CDR from being dispatched, to setting the channel as the preferred Party A in future CDRs. See ast_cdr_options for more information.

Parameters

channel_name	The CDR's channel
option	Option to apply to the CDR

Return values

0	on success
1	on error

Definition at line 3701 of file cdr.c.

{
    struct cdr_object *cdr;
    struct cdr_object *it_cdr;
 
    cdr = cdr_object_get_by_name(channel_name);
    if (!cdr) {
        return -1;
    }
 
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        if (it_cdr->fn_table == &finalized_state_fn_table) {
            continue;
        }
        /* Note: in general, set the flags on both the CDR record as well as the
         * Party A. Sometimes all we have is the Party A to look at.
         */
        ast_set_flag(&it_cdr->flags, option);
        ast_set_flag(&it_cdr->party_a, option);
    }
    ao2_unlock(cdr);
 
    ao2_cleanup(cdr);
    return 0;
}

References ao2_cleanup, ao2_lock, ao2_unlock, ast_set_flag, cdr_object_get_by_name(), finalized_state_fn_table, cdr_object::next, and cdr_object::start.

Referenced by AST_TEST_DEFINE(), and cdr_prop_write_callback().

ast_cdr_setuserfield()

void ast_cdr_setuserfield	(	const char *	channel_name,
		const char *	userfield
	)

Set CDR user field for channel (stored in CDR)

Parameters

channel_name	The name of the channel that owns the CDR
userfield	The user field to set

Definition at line 3630 of file cdr.c.

{
    struct cdr_object *cdr;
    struct party_b_userfield_update party_b_info = {
        .channel_name = channel_name,
        .userfield = userfield,
    };
    struct cdr_object *it_cdr;
 
    /* Handle Party A */
    cdr = cdr_object_get_by_name(channel_name);
    if (cdr) {
        ao2_lock(cdr);
        for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
            if (it_cdr->fn_table == &finalized_state_fn_table && it_cdr->next != NULL) {
                continue;
            }
            ast_copy_string(it_cdr->party_a.userfield, userfield,
                sizeof(it_cdr->party_a.userfield));
        }
        ao2_unlock(cdr);
    }
 
    /* Handle Party B */
    ao2_callback_data(active_cdrs_all, OBJ_NODATA | OBJ_MULTIPLE | OBJ_SEARCH_KEY,
        cdr_object_update_party_b_userfield_cb, (char *) party_b_info.channel_name,
        &party_b_info);
 
    ao2_cleanup(cdr);
}

References active_cdrs_all, ao2_callback_data, ao2_cleanup, ao2_lock, ao2_unlock, ast_copy_string(), cdr_object_get_by_name(), cdr_object_update_party_b_userfield_cb(), party_b_userfield_update::channel_name, finalized_state_fn_table, cdr_object::next, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, cdr_object::start, and party_b_userfield_update::userfield.

Referenced by AST_TEST_DEFINE(), and cdr_write_callback().

ast_cdr_setvar()

int ast_cdr_setvar	(	const char *	channel_name,
		const char *	name,
		const char *	value
	)

Set a variable on a CDR.

Since

12

Parameters

channel_name	The channel to set the variable on
name	The name of the variable to set
value	The value of the variable to set

Return values

0	on success
non-zero	on failure

Definition at line 3321 of file cdr.c.

{
    struct cdr_object *cdr;
    struct cdr_object *it_cdr;
    struct ao2_iterator *it_cdrs;
    char *arg = ast_strdupa(channel_name);
    int x;
 
    for (x = 0; cdr_readonly_vars[x]; x++) {
        if (!strcasecmp(name, cdr_readonly_vars[x])) {
            ast_log(LOG_ERROR, "Attempt to set the '%s' read-only variable!\n", name);
            return -1;
        }
    }
 
    it_cdrs = ao2_callback(active_cdrs_master, OBJ_MULTIPLE, cdr_object_select_all_by_name_cb, arg);
    if (!it_cdrs) {
        ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
        return -1;
    }
 
    for (; (cdr = ao2_iterator_next(it_cdrs)); ao2_unlock(cdr), ao2_cleanup(cdr)) {
        ao2_lock(cdr);
        for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
            struct varshead *headp = NULL;
 
            if (it_cdr->fn_table == &finalized_state_fn_table && it_cdr->next != NULL) {
                continue;
            }
            if (!strcasecmp(channel_name, it_cdr->party_a.snapshot->base->name)) {
                headp = &it_cdr->party_a.variables;
            } else if (it_cdr->party_b.snapshot
                && !strcasecmp(channel_name, it_cdr->party_b.snapshot->base->name)) {
                headp = &it_cdr->party_b.variables;
            }
            if (headp) {
                set_variable(headp, name, value);
            }
        }
    }
    ao2_iterator_destroy(it_cdrs);
 
    return 0;
}

References active_cdrs_master, ao2_callback, ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_next, ao2_lock, ao2_unlock, ast_log, AST_LOG_ERROR, ast_strdupa, ast_channel_snapshot::base, cdr_object_select_all_by_name_cb(), cdr_readonly_vars, finalized_state_fn_table, cdr_object::fn_table, LOG_ERROR, name, ast_channel_snapshot_base::name, cdr_object::next, NULL, OBJ_MULTIPLE, cdr_object::party_a, cdr_object::party_b, set_variable(), cdr_object_snapshot::snapshot, cdr_object::start, value, and cdr_object_snapshot::variables.

Referenced by AST_TEST_DEFINE(), AST_TEST_DEFINE(), and cdr_write_callback().

ast_cdr_unregister()

int ast_cdr_unregister

(

const char *

name

)

Unregister a CDR handling engine.

Parameters

name	name of CDR handler to unregister Unregisters a CDR by it's name

Return values

0	The backend unregistered successfully
-1	The backend could not be unregistered at this time

Definition at line 3126 of file cdr.c.

{
    return ast_cdr_generic_unregister(&be_list, name);
}

References ast_cdr_generic_unregister(), and name.

Referenced by load_module(), load_module(), reload(), tds_unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), unload_module(), and unregister_backend().