Call Detail Record API. More...

#include "asterisk.h"
#include <signal.h>
#include <inttypes.h>
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/cdr.h"
#include "asterisk/callerid.h"
#include "asterisk/manager.h"
#include "asterisk/module.h"
#include "asterisk/causes.h"
#include "asterisk/linkedlists.h"
#include "asterisk/utils.h"
#include "asterisk/sched.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/stringfields.h"
#include "asterisk/config_options.h"
#include "asterisk/json.h"
#include "asterisk/parking.h"
#include "asterisk/stasis.h"
#include "asterisk/stasis_channels.h"
#include "asterisk/stasis_bridges.h"
#include "asterisk/stasis_message_router.h"
#include "asterisk/astobj2.h"
#include "asterisk/taskprocessor.h"

Include dependency graph for cdr.c:

Go to the source code of this file.

Data Structures
struct	be_list
	List of registered backends. More...

struct	bridge_leave_data

struct	cdr_batch
	The actual batch queue. More...

struct	cdr_batch_item
	Queued CDR waiting to be batched. More...

struct	cdr_beitem
	Registration object for CDR backends. More...

struct	cdr_object
	An in-memory representation of an active CDR. More...

struct	cdr_object_fn_table
	A virtual table used for cdr_object. More...

struct	cdr_object_snapshot
	A wrapper object around a snapshot. Fields that are mutable by the CDR engine are replicated here. More...

struct	mo_list
	List of registered modifiers. More...

struct	module_config
	The configuration settings for this module. More...

struct	party_b_userfield_update

Macros
#define	CDR_DEBUG(fmt, ...)

#define	cdr_set_debug_mode(mod_cfg)

#define	DEFAULT_BATCH_SAFE_SHUTDOWN "1"

#define	DEFAULT_BATCH_SCHEDULER_ONLY "0"

#define	DEFAULT_BATCH_SIZE "100"

#define	DEFAULT_BATCH_TIME "300"

#define	DEFAULT_BATCHMODE "0"

#define	DEFAULT_CHANNEL_ENABLED "1"

#define	DEFAULT_CONGESTION "0"

#define	DEFAULT_ENABLED "1"

#define	DEFAULT_END_BEFORE_H_EXTEN "1"

#define	DEFAULT_IGNORE_DIAL_CHANGES "0"

#define	DEFAULT_IGNORE_STATE_CHANGES "0"

#define	DEFAULT_INITIATED_SECONDS "0"

#define	DEFAULT_UNANSWERED "0"

#define	FORMAT_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"

#define	FORMAT_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"

#define	MAX_BATCH_SIZE 1000

#define	MAX_BATCH_TIME 86400

#define	TITLE_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"

#define	TITLE_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"

Enumerations
enum	process_bridge_enter_results { BRIDGE_ENTER_ONLY_PARTY , BRIDGE_ENTER_OBTAINED_PARTY_B , BRIDGE_ENTER_NO_PARTY_B , BRIDGE_ENTER_NEED_CDR }
	Return types for `process_bridge_enter` functions. More...

Functions
static void	__reg_module (void)

static void	__unreg_module (void)

static	AO2_GLOBAL_OBJ_STATIC (module_configs)
	The container for the module configuration.

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.

static int	ast_cdr_generic_unregister (struct be_list generic_list, const char name)

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.

struct ast_module *	AST_MODULE_SELF_SYM (void)

static enum process_bridge_enter_results	base_process_bridge_enter (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static int	base_process_bridge_leave (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static int	base_process_dial_end (struct cdr_object cdr, struct ast_channel_snapshot caller, struct ast_channel_snapshot peer, const char dial_status)

static int	base_process_parked_channel (struct cdr_object cdr, struct ast_parked_call_payload parking_info)

static int	base_process_party_a (struct cdr_object cdr, struct ast_channel_snapshot snapshot)

static void	bridge_candidate_add_to_cdr (struct cdr_object cdr, struct cdr_object_snapshot party_b)

static void	bridge_candidate_process (struct cdr_object cdr, struct cdr_object base_cand_cdr)
	Process a single `bridge_candidate`.

static int	bridge_state_process_bridge_leave (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static void	bridge_state_process_party_b (struct cdr_object cdr, struct ast_channel_snapshot snapshot)

static int	cdr_all_cmp_fn (void obj, void arg, int flags)

static int	cdr_all_hash_fn (const void *obj, const int flags)

static void	cdr_all_print_fn (void v_obj, void where, ao2_prnt_fn *prnt)

static void	cdr_all_relink (struct cdr_object *cdr)

static void	cdr_all_unlink (struct cdr_object *cdr)

static void	cdr_detach (struct ast_cdr *cdr)

static void	cdr_enable_batch_mode (struct ast_cdr_config *config)

static void	cdr_engine_shutdown (void)

static const char *	cdr_format_var_internal (struct ast_cdr cdr, const char name)

static int	cdr_generic_register (struct be_list generic_list, const char name, const char *desc, ast_cdrbe be)

static void	cdr_get_tv (struct timeval when, const char fmt, char buf, int bufsize)

static int	cdr_master_cmp_fn (void obj, void arg, int flags)

static int	cdr_master_hash_fn (const void *obj, const int flags)

static void	cdr_master_print_fn (void v_obj, void where, ao2_prnt_fn *prnt)

static struct cdr_object *	cdr_object_alloc (struct ast_channel_snapshot chan, const struct timeval event_time)
	cdr_object constructor

static void	cdr_object_check_party_a_answer (struct cdr_object *cdr)
	Check to see if a CDR needs to be answered based on its Party A. Note that this is safe to call as much as you want - we won't answer twice.

static void	cdr_object_check_party_a_hangup (struct cdr_object *cdr)
	Check to see if a CDR needs to move to the finalized state because its Party A hungup.

static struct cdr_object *	cdr_object_create_and_append (struct cdr_object cdr, const struct timeval event_time)
	Create a new cdr_object and append it to an existing chain.

static struct ast_cdr *	cdr_object_create_public_records (struct cdr_object *cdr)
	Create a chain of ast_cdr objects from a chain of cdr_object suitable for consumption by the registered CDR backends.

static void	cdr_object_dispatch (struct cdr_object *cdr)
	Dispatch a CDR.

static int	cdr_object_dispatch_all_cb (void obj, void arg, int flags)
	This dispatches all cdr_object. It should only be used during shutdown, so that we get billing records for everything that we can.

static void	cdr_object_dtor (void *obj)
	cdr_object Destructor

static void	cdr_object_finalize (struct cdr_object *cdr)
	Finalize a CDR.

static int	cdr_object_finalize_party_b (void obj, void arg, void *data, int flags)

static int	cdr_object_format_property (struct cdr_object cdr_obj, const char name, char *value, size_t length)
	Format one of the standard properties on a cdr_object.

static void	cdr_object_format_var_internal (struct cdr_object cdr, const char name, char *value, size_t length)
	Format a variable on a cdr_object.

static long	cdr_object_get_billsec (struct cdr_object *cdr)
	Compute the billsec for a cdr_object.

static struct cdr_object *	cdr_object_get_by_name (const char *name)

static int	cdr_object_get_by_name_cb (void obj, void arg, int flags)

static long	cdr_object_get_duration (struct cdr_object *cdr)

static int	cdr_object_party_b_left_bridge_cb (void obj, void arg, void *data, int flags)
	Callback used to notify CDRs of a Party B leaving the bridge.

static struct cdr_object_snapshot *	cdr_object_pick_party_a (struct cdr_object_snapshot left, struct cdr_object_snapshot right)
	Given two CDR snapshots, figure out who should be Party A for the resulting CDR.

static int	cdr_object_select_all_by_name_cb (void obj, void arg, int flags)

static void	cdr_object_set_disposition (struct cdr_object *cdr, int hangupcause)
	Set the disposition on a cdr_object based on a hangupcause code.

static void	cdr_object_snapshot_copy (struct cdr_object_snapshot dst, struct cdr_object_snapshot src)
	Copy a snapshot and its details.

static void	cdr_object_swap_snapshot (struct cdr_object_snapshot old_snapshot, struct ast_channel_snapshot new_snapshot)
	Swap an old cdr_object_snapshot's ast_channel_snapshot for a new ast_channel_snapshot.

static void	cdr_object_transition_state (struct cdr_object cdr, struct cdr_object_fn_table fn_table)
	Transition a cdr_object to a new state.

static void	cdr_object_transition_state_init (struct cdr_object cdr, struct cdr_object_fn_table fn_table, int do_init)
	Transition a cdr_object to a new state with initiation flag.

static void	cdr_object_update_cid (struct cdr_object_snapshot old_snapshot, struct ast_channel_snapshot new_snapshot)
	Set Caller ID information on a CDR.

static int	cdr_object_update_party_b (void obj, void arg, void *data, int flags)

static int	cdr_object_update_party_b_userfield_cb (void obj, void arg, void *data, int flags)
	Callback used to update the userfield on Party B on all CDRs.

static void	cdr_submit_batch (int shutdown)

static int	cdr_toggle_runtime_options (void)
	Checks if CDRs are enabled and enables/disables the necessary options.

static int	check_new_cdr_needed (struct ast_channel_snapshot old_snapshot, struct ast_channel_snapshot new_snapshot)
	Determine if we need to add a new CDR based on snapshots.

static char *	cli_complete_show (struct ast_cli_args *a)
	Complete user input for 'cdr show'.

static void	cli_show_channel (struct ast_cli_args *a)

static void	cli_show_channels (struct ast_cli_args *a)

	CONFIG_INFO_CORE ("cdr", cfg_info, module_configs, module_config_alloc,.files=ACO_FILES(&module_file_conf),.post_apply_config=module_config_post_apply,)

static int	copy_variables (struct varshead to_list, struct varshead from_list)
	Copy variables from one list to another.

static int	create_subscriptions (void)
	Create the Stasis subscriptions for CDRs.

static void	destroy_subscriptions (void)
	Destroy the active Stasis subscriptions.

static enum process_bridge_enter_results	dial_state_process_bridge_enter (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static int	dial_state_process_dial_begin (struct cdr_object cdr, struct ast_channel_snapshot caller, struct ast_channel_snapshot *peer)

static int	dial_state_process_dial_end (struct cdr_object cdr, struct ast_channel_snapshot caller, struct ast_channel_snapshot peer, const char dial_status)

static void	dial_state_process_party_b (struct cdr_object cdr, struct ast_channel_snapshot snapshot)

static int	dial_status_end (const char *dialstatus)

static enum ast_cdr_disposition	dial_status_to_disposition (const char *dial_status)

static enum process_bridge_enter_results	dialed_pending_state_process_bridge_enter (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static int	dialed_pending_state_process_dial_begin (struct cdr_object cdr, struct ast_channel_snapshot caller, struct ast_channel_snapshot *peer)

static int	dialed_pending_state_process_parking_bridge_enter (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static int	dialed_pending_state_process_party_a (struct cdr_object cdr, struct ast_channel_snapshot snapshot)

static void *	do_batch_backend_process (void *data)

static void *	do_cdr (void *data)

static int	filter_bridge_messages (struct ast_bridge_snapshot *bridge)
	Filter bridge messages based on bridge technology.

static int	filter_channel_snapshot (struct ast_channel_snapshot *snapshot)

static int	filter_channel_snapshot_message (struct ast_channel_snapshot old_snapshot, struct ast_channel_snapshot new_snapshot)

static void	finalize_batch_mode (void)

static void	finalized_state_init_function (struct cdr_object *cdr)

static int	finalized_state_process_party_a (struct cdr_object cdr, struct ast_channel_snapshot snapshot)

static void	free_variables (struct varshead *headp)
	Delete all variables from a variable list.

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

static void	handle_bridge_leave_message (void data, struct stasis_subscription sub, struct stasis_message *message)
	Handler for when a channel leaves a bridge.

static void	handle_bridge_pairings (struct cdr_object cdr, struct ast_bridge_snapshot bridge)
	Handle creating bridge pairings for the cdr_object that just entered a bridge.

static void	handle_cdr_sync_message (void data, struct stasis_subscription sub, struct stasis_message *message)
	Handler for a synchronization message.

static void	handle_channel_snapshot_update_message (void data, struct stasis_subscription sub, struct stasis_message *message)
	Handler for channel snapshot update messages.

static char *	handle_cli_debug (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_show (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_status (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static char *	handle_cli_submit (struct ast_cli_entry e, int cmd, struct ast_cli_args a)

static void	handle_dial_message (void data, struct stasis_subscription sub, struct stasis_message *message)
	Handler for Stasis-Core dial messages.

static void	handle_parked_call_message (void data, struct stasis_subscription sub, struct stasis_message *message)
	Handler for when a channel is parked.

static void	handle_parking_bridge_enter_message (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot channel, const struct timeval event_time)
	Handle entering into a parking bridge.

static void	handle_standard_bridge_enter_message (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot channel, const struct timeval event_time)
	Handle a bridge enter message for a 'normal' bridge.

static int	init_batch (void)

static int	is_cdr_flag_set (unsigned int cdr_flag)

static int	load_module (void)

static void *	module_config_alloc (void)
	Create a new module config object.

static void	module_config_destructor (void *obj)
	Dispose of a module config object.

static void	module_config_post_apply (void)

static int	parked_state_process_bridge_leave (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static void	post_cdr (struct ast_cdr *cdr)

static int	process_config (int reload)

static int	reload_module (void)

static void	reset_batch (void)

static void	set_variable (struct varshead headp, const char name, const char *value)

static int	single_state_bridge_enter_comparison (struct cdr_object cdr, struct cdr_object cand_cdr)
	Handle a comparison between our cdr_object and a cdr_object already in the bridge while in the Single state. The goal of this is to find a Party B for our CDR.

static void	single_state_init_function (struct cdr_object *cdr)

static enum process_bridge_enter_results	single_state_process_bridge_enter (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static int	single_state_process_dial_begin (struct cdr_object cdr, struct ast_channel_snapshot caller, struct ast_channel_snapshot *peer)

static int	single_state_process_parking_bridge_enter (struct cdr_object cdr, struct ast_bridge_snapshot bridge, struct ast_channel_snapshot *channel)

static void	single_state_process_party_b (struct cdr_object cdr, struct ast_channel_snapshot snapshot)

static int	snapshot_cep_changed (struct ast_channel_snapshot old_snapshot, struct ast_channel_snapshot new_snapshot)
	Return whether or not a channel has changed its state in the dialplan, subject to endbeforehexten logic.

static int	snapshot_is_dialed (struct ast_channel_snapshot *snapshot)
	Return whether or not a ast_channel_snapshot is for a channel that was created as the result of a dial operation.

static void	start_batch_mode (void)

	STASIS_MESSAGE_TYPE_DEFN_LOCAL (cdr_sync_message_type)
	A message type used to synchronize with the CDR topic.

static int	submit_scheduled_batch (const void *data)

static int	unload_module (void)

Variables
static struct ast_module_info	__mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS \| AST_MODFLAG_LOAD_ORDER , .description = "CDR Engine" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig", }

static struct ao2_container *	active_cdrs_all
	A container of all active CDRs with a Party B indexed by Party B channel name.

static struct ao2_container *	active_cdrs_master
	A container of the active master CDRs indexed by Party A channel uniqueid.

static const struct ast_module_info *	ast_module_info = &__mod_info

static struct cdr_batch *	batch = NULL

static struct be_list	be_list = AST_RWLIST_HEAD_INIT_VALUE

struct cdr_object_fn_table	bridge_state_fn_table
	The virtual table for the Bridged state.

static struct stasis_forward *	bridge_subscription
	Our subscription for bridges.

static ast_mutex_t	cdr_batch_lock = AST_MUTEX_INIT_VALUE
	Lock protecting modifications to the batch queue.

static int	cdr_debug_enabled

static ast_cond_t	cdr_pending_cond

static ast_mutex_t	cdr_pending_lock = AST_MUTEX_INIT_VALUE
	These are used to wake up the CDR thread when there's work to do.

static const char *const	cdr_readonly_vars []

static int	cdr_sched = -1

static ast_mutex_t	cdr_sched_lock = AST_MUTEX_INIT_VALUE

static pthread_t	cdr_thread = AST_PTHREADT_NULL

static struct stasis_topic *	cdr_topic
	The parent topic for all topics we want to aggregate for CDRs.

static struct stasis_forward *	channel_subscription
	Our subscription for channels.

static struct ast_cli_entry	cli_commands []

static int	dial_changes_ignored

struct cdr_object_fn_table	dial_state_fn_table
	The virtual table for the Dial state.

struct cdr_object_fn_table	dialed_pending_state_fn_table
	The virtual table for the Dialed Pending state.

struct cdr_object_fn_table	finalized_state_fn_table
	The virtual table for the finalized state.

static struct aco_type	general_option
	The type definition for general options.

static struct aco_type *	general_options [] = ACO_TYPES(&general_option)

static int	global_cdr_sequence = 0
	The global sequence counter used for CDRs.

static const char *	ignore_categories []

static struct aco_type	ignore_option

static struct mo_list	mo_list = AST_RWLIST_HEAD_INIT_VALUE

static struct aco_file	module_file_conf
	The file definition.

struct cdr_object_fn_table	parked_state_fn_table
	The virtual table for the Parked state.

static struct stasis_forward *	parking_subscription
	Our subscription for parking.

static struct ast_sched_context *	sched
	Scheduler items.

struct cdr_object_fn_table	single_state_fn_table
	The virtual table for the Single state.

static struct stasis_message_router *	stasis_router
	Message router for stasis messages regarding channel state.

Detailed Description

Call Detail Record API.

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

Note: Includes code and algorithms from the Zapata library.; We do a lot of checking here in the CDR code to try to be sure we don't ever let a CDR slip through our fingers somehow. If someone allocates a CDR, it must be completely handled normally or a WARNING shall be logged, so that we can best keep track of any escape condition where the CDR isn't properly generated and posted.

Definition in file cdr.c.

Macro Definition Documentation

◆ CDR_DEBUG

#define CDR_DEBUG	(	fmt,
		...
	)

Value:

    do { \
        if (cdr_debug_enabled) { \
            ast_verbose((fmt), ##__VA_ARGS__); \
        } \
    } while (0)

Definition at line 314 of file cdr.c.

       { \
        if (cdr_debug_enabled) { \
            ast_verbose((fmt), ##__VA_ARGS__); \
        } \
    } while (0)

◆ cdr_set_debug_mode

#define cdr_set_debug_mode ( mod_cfg )

Value:

    do { \
        cdr_debug_enabled = ast_test_flag(&(mod_cfg)->general->settings, CDR_DEBUG); \
    } while (0)

Definition at line 306 of file cdr.c.

       { \
        cdr_debug_enabled = ast_test_flag(&(mod_cfg)->general->settings, CDR_DEBUG); \
    } while (0)

◆ DEFAULT_BATCH_SAFE_SHUTDOWN

#define DEFAULT_BATCH_SAFE_SHUTDOWN "1"

Definition at line 304 of file cdr.c.

◆ DEFAULT_BATCH_SCHEDULER_ONLY

#define DEFAULT_BATCH_SCHEDULER_ONLY "0"

Definition at line 303 of file cdr.c.

◆ DEFAULT_BATCH_SIZE

#define DEFAULT_BATCH_SIZE "100"

Definition at line 299 of file cdr.c.

◆ DEFAULT_BATCH_TIME

#define DEFAULT_BATCH_TIME "300"

Definition at line 301 of file cdr.c.

◆ DEFAULT_BATCHMODE

#define DEFAULT_BATCHMODE "0"

Definition at line 290 of file cdr.c.

◆ DEFAULT_CHANNEL_ENABLED

#define DEFAULT_CHANNEL_ENABLED "1"

Definition at line 295 of file cdr.c.

◆ DEFAULT_CONGESTION

#define DEFAULT_CONGESTION "0"

Definition at line 292 of file cdr.c.

◆ DEFAULT_ENABLED

#define DEFAULT_ENABLED "1"

Definition at line 289 of file cdr.c.

◆ DEFAULT_END_BEFORE_H_EXTEN

#define DEFAULT_END_BEFORE_H_EXTEN "1"

Definition at line 293 of file cdr.c.

◆ DEFAULT_IGNORE_DIAL_CHANGES

#define DEFAULT_IGNORE_DIAL_CHANGES "0"

Definition at line 297 of file cdr.c.

◆ DEFAULT_IGNORE_STATE_CHANGES

#define DEFAULT_IGNORE_STATE_CHANGES "0"

Definition at line 296 of file cdr.c.

◆ DEFAULT_INITIATED_SECONDS

#define DEFAULT_INITIATED_SECONDS "0"

Definition at line 294 of file cdr.c.

◆ DEFAULT_UNANSWERED

#define DEFAULT_UNANSWERED "0"

Definition at line 291 of file cdr.c.

◆ FORMAT_STRING [1/2]

#define FORMAT_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"

◆ FORMAT_STRING [2/2]

#define FORMAT_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"

◆ MAX_BATCH_SIZE

#define MAX_BATCH_SIZE 1000

Definition at line 300 of file cdr.c.

◆ MAX_BATCH_TIME

#define MAX_BATCH_TIME 86400

Definition at line 302 of file cdr.c.

◆ TITLE_STRING [1/2]

#define TITLE_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"

◆ TITLE_STRING [2/2]

#define TITLE_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"

Enumeration Type Documentation

◆ process_bridge_enter_results

enum process_bridge_enter_results

Return types for process_bridge_enter functions.

Enumerator
BRIDGE_ENTER_ONLY_PARTY	The CDR was the only party in the bridge.
BRIDGE_ENTER_OBTAINED_PARTY_B	The CDR was able to obtain a Party B from some other party already in the bridge
BRIDGE_ENTER_NO_PARTY_B	The CDR was not able to obtain a Party B
BRIDGE_ENTER_NEED_CDR	This CDR can't handle a bridge enter message and a new CDR needs to be created

Definition at line 495 of file cdr.c.

                                  {
    /*!
     * The CDR was the only party in the bridge.
     */
    BRIDGE_ENTER_ONLY_PARTY,
    /*!
     * The CDR was able to obtain a Party B from some other party already in the bridge
     */
    BRIDGE_ENTER_OBTAINED_PARTY_B,
    /*!
     * The CDR was not able to obtain a Party B
     */
    BRIDGE_ENTER_NO_PARTY_B,
    /*!
     * This CDR can't handle a bridge enter message and a new CDR needs to be created
     */
    BRIDGE_ENTER_NEED_CDR,
};

Function Documentation

◆ __reg_module()

static void __reg_module ( void )

static

Definition at line 4832 of file cdr.c.

◆ __unreg_module()

static void __unreg_module ( void )

static

Definition at line 4832 of file cdr.c.

◆ AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( module_configs )

static

The container for the module configuration.

◆ 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_generic_unregister()

static int ast_cdr_generic_unregister	(	struct be_list *	generic_list,
		const char *	name
	)

static

Definition at line 3091 of file cdr.c.

{
    struct cdr_beitem *match = NULL;
    int active_count;
 
    AST_RWLIST_WRLOCK(generic_list);
    AST_RWLIST_TRAVERSE(generic_list, match, list) {
        if (!strcasecmp(name, match->name)) {
            break;
        }
    }
 
    if (!match) {
        AST_RWLIST_UNLOCK(generic_list);
        return 0;
    }
 
    active_count = ao2_container_count(active_cdrs_master);
 
    if (!match->suspended && active_count != 0) {
        AST_RWLIST_UNLOCK(generic_list);
        ast_log(AST_LOG_WARNING, "Unable to unregister CDR backend %s; %d CDRs are still active\n",
            name, active_count);
        return -1;
    }
 
    AST_RWLIST_REMOVE(generic_list, match, list);
    AST_RWLIST_UNLOCK(generic_list);
 
    ast_verb(5, "Unregistered '%s' CDR backend\n", name);
    ast_free(match);
 
    return 0;
}

References active_cdrs_master, ao2_container_count(), ast_free, ast_log, AST_LOG_WARNING, AST_RWLIST_REMOVE, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, ast_verb, cdr_beitem::list, match(), name, and NULL.

Referenced by ast_cdr_modifier_unregister(), and ast_cdr_unregister().

◆ 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().

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void )

Definition at line 4832 of file cdr.c.

◆ base_process_bridge_enter()

static enum process_bridge_enter_results base_process_bridge_enter	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 1715 of file cdr.c.

{
    /* Base process bridge enter simply indicates that we can't handle it */
    return BRIDGE_ENTER_NEED_CDR;
}

References BRIDGE_ENTER_NEED_CDR.

◆ base_process_bridge_leave()

static int base_process_bridge_leave	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 1705 of file cdr.c.

{
    return 0;
}

◆ base_process_dial_end()

static int base_process_dial_end	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	caller,
		struct ast_channel_snapshot *	peer,
		const char *	dial_status
	)

static

Definition at line 1710 of file cdr.c.

{
    return 0;
}

◆ base_process_parked_channel()

static int base_process_parked_channel	(	struct cdr_object *	cdr,
		struct ast_parked_call_payload *	parking_info
	)

static

Definition at line 1721 of file cdr.c.

{
    char park_info[128];
 
    ast_assert(!strcasecmp(parking_info->parkee->base->name, cdr->party_a.snapshot->base->name));
 
    /* Update Party A information regardless */
    cdr->fn_table->process_party_a(cdr, parking_info->parkee);
 
    /* Fake out where we're parked */
    ast_string_field_set(cdr, appl, "Park");
    snprintf(park_info, sizeof(park_info), "%s:%u", parking_info->parkinglot, parking_info->parkingspace);
    ast_string_field_set(cdr, data, park_info);
 
    /* Prevent any further changes to the App/Data fields for this record */
    ast_set_flag(&cdr->flags, AST_CDR_LOCK_APP);
 
    return 0;
}

References ast_assert, AST_CDR_LOCK_APP, ast_set_flag, ast_string_field_set, ast_channel_snapshot::base, cdr_object::flags, cdr_object::fn_table, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object_fn_table::process_party_a, cdr_object_snapshot::snapshot, and ast_cdr::start.

◆ base_process_party_a()

static int base_process_party_a	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	snapshot
	)

static

Definition at line 1644 of file cdr.c.

{
    ast_assert(strcasecmp(snapshot->base->name, cdr->party_a.snapshot->base->name) == 0);
 
    /* Finalize the CDR if we're in hangup logic and we're set to do so */
    if (ast_test_flag(&snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
        && is_cdr_flag_set(CDR_END_BEFORE_H_EXTEN)) {
        cdr_object_finalize(cdr);
        return 0;
    }
 
    /*
     * Only record the context and extension if we aren't in a subroutine, or if
     * we are executing hangup logic.
     */
    if (!ast_test_flag(&snapshot->flags, AST_FLAG_SUBROUTINE_EXEC)
        || ast_test_flag(&snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)) {
        if (strcmp(cdr->context, snapshot->dialplan->context)) {
            ast_string_field_set(cdr, context, snapshot->dialplan->context);
        }
        if (strcmp(cdr->exten, snapshot->dialplan->exten)) {
            ast_string_field_set(cdr, exten, snapshot->dialplan->exten);
        }
    }
 
    cdr_object_swap_snapshot(&cdr->party_a, snapshot);
 
    /* When Party A is originated to an application and the application exits, the stack
     * will attempt to clear the application and restore the dummy originate application
     * of "AppDialX". Prevent that, and any other application changes we might not want
     * here.
     */
    if (!ast_test_flag(&cdr->flags, AST_CDR_LOCK_APP)
        && !ast_strlen_zero(snapshot->dialplan->appl)
        && (strncasecmp(snapshot->dialplan->appl, "appdial", 7) || ast_strlen_zero(cdr->appl))) {
        if (strcmp(cdr->appl, snapshot->dialplan->appl)) {
            ast_string_field_set(cdr, appl, snapshot->dialplan->appl);
        }
        if (strcmp(cdr->data, snapshot->dialplan->data)) {
            ast_string_field_set(cdr, data, snapshot->dialplan->data);
        }
 
        /* Dial (app_dial) is a special case. Because pre-dial handlers, which
         * execute before the dial begins, will alter the application/data to
         * something people typically don't want to see, if we see a channel enter
         * into Dial here, we set the appl/data accordingly and lock it.
         */
        if (!strcmp(snapshot->dialplan->appl, "Dial")) {
            ast_set_flag(&cdr->flags, AST_CDR_LOCK_APP);
        }
    }
 
    if (strcmp(cdr->linkedid, snapshot->peer->linkedid)) {
        ast_string_field_set(cdr, linkedid, snapshot->peer->linkedid);
    }
    cdr_object_check_party_a_answer(cdr);
    cdr_object_check_party_a_hangup(cdr);
 
    return 0;
}

Referenced by dialed_pending_state_process_party_a(), and single_state_process_dial_begin().

◆ bridge_candidate_add_to_cdr()

static void bridge_candidate_add_to_cdr	(	struct cdr_object *	cdr,
		struct cdr_object_snapshot *	party_b
	)

static

Definition at line 2611 of file cdr.c.

{
    struct cdr_object *new_cdr;
 
    new_cdr = cdr_object_create_and_append(cdr, &cdr->lastevent);
    if (!new_cdr) {
        return;
    }
    cdr_object_snapshot_copy(&new_cdr->party_b, party_b);
    cdr_all_relink(new_cdr);
    cdr_object_check_party_a_answer(new_cdr);
    ast_string_field_set(new_cdr, bridge, cdr->bridge);
    cdr_object_transition_state(new_cdr, &bridge_state_fn_table);
    CDR_DEBUG("%p - Party A %s has new Party B %s\n",
        new_cdr, new_cdr->party_a.snapshot->base->name,
        party_b->snapshot->base->name);
}

References ast_string_field_set, ast_channel_snapshot::base, cdr_object::bridge, bridge_state_fn_table, cdr_all_relink(), CDR_DEBUG, cdr_object_check_party_a_answer(), cdr_object_create_and_append(), cdr_object_snapshot_copy(), cdr_object_transition_state(), cdr_object::lastevent, ast_channel_snapshot_base::name, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by bridge_candidate_process().

◆ bridge_candidate_process()

static void bridge_candidate_process	(	struct cdr_object *	cdr,
		struct cdr_object *	base_cand_cdr
	)

static

Process a single bridge_candidate.

When a CDR enters a bridge, it needs to make pairings with everyone else that it is not currently paired with. This function determines, for the CDR for the channel that entered the bridge and the CDR for every other channel currently in the bridge, who is Party A and makes new CDRs.

Parameters

cdr	The cdr_object being processed
base_cand_cdr	The cdr_object that is a candidate

Definition at line 2642 of file cdr.c.

{
    struct cdr_object_snapshot *party_a;
    struct cdr_object *cand_cdr;
 
    ao2_lock(base_cand_cdr);
 
    for (cand_cdr = base_cand_cdr; cand_cdr; cand_cdr = cand_cdr->next) {
        /* Skip any records that are not in this bridge */
        if (strcmp(cand_cdr->bridge, cdr->bridge)) {
            continue;
        }
 
        /* If the candidate is us or someone we've taken on, pass on by */
        if (!strcasecmp(cdr->party_a.snapshot->base->name, cand_cdr->party_a.snapshot->base->name)
            || (cdr->party_b.snapshot
                && !strcasecmp(cdr->party_b.snapshot->base->name, cand_cdr->party_a.snapshot->base->name))) {
            break;
        }
 
        party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_a);
        /* We're party A - make a new CDR, append it to us, and set the candidate as
         * Party B */
        if (!strcasecmp(party_a->snapshot->base->name, cdr->party_a.snapshot->base->name)) {
            bridge_candidate_add_to_cdr(cdr, &cand_cdr->party_a);
            break;
        }
 
        /* We're Party B. Check if we can add ourselves immediately or if we need
         * a new CDR for them (they already have a Party B) */
        if (cand_cdr->party_b.snapshot
            && strcasecmp(cand_cdr->party_b.snapshot->base->name, cdr->party_a.snapshot->base->name)) {
            bridge_candidate_add_to_cdr(cand_cdr, &cdr->party_a);
        } else {
            CDR_DEBUG("%p - Party A %s has new Party B %s\n",
                cand_cdr, cand_cdr->party_a.snapshot->base->name,
                cdr->party_a.snapshot->base->name);
            cdr_object_snapshot_copy(&cand_cdr->party_b, &cdr->party_a);
            cdr_all_relink(cand_cdr);
            /* It's possible that this joined at one point and was never chosen
             * as party A. Clear their end time, as it would be set in such a
             * case.
             */
            memset(&cand_cdr->end, 0, sizeof(cand_cdr->end));
        }
 
        break;
    }
 
    ao2_unlock(base_cand_cdr);
}

References ao2_lock, ao2_unlock, ast_channel_snapshot::base, cdr_object::bridge, bridge_candidate_add_to_cdr(), cdr_all_relink(), CDR_DEBUG, cdr_object_pick_party_a(), cdr_object_snapshot_copy(), ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by handle_bridge_pairings().

◆ bridge_state_process_bridge_leave()

static int bridge_state_process_bridge_leave	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 2125 of file cdr.c.

{
    if (strcmp(cdr->bridge, bridge->uniqueid)) {
        return 1;
    }
    if (strcasecmp(cdr->party_a.snapshot->base->name, channel->base->name)
        && cdr->party_b.snapshot
        && strcasecmp(cdr->party_b.snapshot->base->name, channel->base->name)) {
        return 1;
    }
    cdr_object_transition_state(cdr, &finalized_state_fn_table);
 
    return 0;
}

References ast_channel_snapshot::base, cdr_object::bridge, cdr_object_transition_state(), finalized_state_fn_table, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

◆ bridge_state_process_party_b()

static void bridge_state_process_party_b	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	snapshot
	)

static

Definition at line 2112 of file cdr.c.

{
    ast_assert(cdr->party_b.snapshot
        && !strcasecmp(cdr->party_b.snapshot->base->name, snapshot->base->name));
 
    cdr_object_swap_snapshot(&cdr->party_b, snapshot);
 
    /* If party B hangs up, finalize this CDR */
    if (ast_test_flag(&cdr->party_b.snapshot->flags, AST_FLAG_DEAD)) {
        cdr_object_transition_state(cdr, &finalized_state_fn_table);
    }
}

References ast_assert, AST_FLAG_DEAD, ast_test_flag, ast_channel_snapshot::base, cdr_object_swap_snapshot(), cdr_object_transition_state(), finalized_state_fn_table, ast_channel_snapshot::flags, ast_channel_snapshot_base::name, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

◆ cdr_all_cmp_fn()

static int cdr_all_cmp_fn	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 1018 of file cdr.c.

{
    struct cdr_object *left = obj;
    struct cdr_object *right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = right->party_b_name;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcasecmp(left->party_b_name, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /*
         * We could also use a partial key struct containing a length
         * so strlen() does not get called for every comparison instead.
         */
        cmp = strncasecmp(left->party_b_name, right_key, strlen(right_key));
        break;
    default:
        /* Sort can only work on something with a full or partial key. */
        ast_assert(0);
        cmp = 0;
        break;
    }
    return cmp ? 0 : CMP_MATCH;
}

References ast_assert, CMP_MATCH, cdr_object::flags, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, cdr_object::party_b_name, and cdr_object::start.

Referenced by load_module().

◆ cdr_all_hash_fn()

static int cdr_all_hash_fn	(	const void *	obj,
		const int	flags
	)

static

Definition at line 994 of file cdr.c.

{
    const struct cdr_object *cdr;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        cdr = obj;
        key = cdr->party_b_name;
        break;
    default:
        ast_assert(0);
        return 0;
    }
    return ast_str_case_hash(key);
}

References ast_assert, ast_str_case_hash(), cdr_object::flags, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and cdr_object::party_b_name.

Referenced by load_module().

◆ cdr_all_print_fn()

static void cdr_all_print_fn	(	void *	v_obj,
		void *	where,
		ao2_prnt_fn *	prnt
	)

static

Definition at line 4629 of file cdr.c.

{
    struct cdr_object *cdr = v_obj;
 
    if (!cdr) {
        return;
    }
    prnt(where, "Party A: %s; Party B: %s; Bridge %s",
        cdr->party_a.snapshot->base->name,
        cdr->party_b.snapshot ? cdr->party_b.snapshot->base->name : "<unknown>",
        cdr->bridge);
}

References ast_channel_snapshot::base, cdr_object::bridge, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by load_module().

◆ cdr_all_relink()

static void cdr_all_relink ( struct cdr_object * cdr )

static

Definition at line 1053 of file cdr.c.

{
    ao2_lock(active_cdrs_all);
    if (cdr->party_b.snapshot) {
        if (strcasecmp(cdr->party_b_name, cdr->party_b.snapshot->base->name)) {
            ao2_unlink_flags(active_cdrs_all, cdr, OBJ_NOLOCK);
            ast_string_field_set(cdr, party_b_name, cdr->party_b.snapshot->base->name);
            ao2_link_flags(active_cdrs_all, cdr, OBJ_NOLOCK);
        }
    } else {
        ao2_unlink_flags(active_cdrs_all, cdr, OBJ_NOLOCK);
        ast_string_field_set(cdr, party_b_name, "");
    }
    ao2_unlock(active_cdrs_all);
}

References active_cdrs_all, ao2_link_flags, ao2_lock, ao2_unlink_flags, ao2_unlock, ast_string_field_set, ast_channel_snapshot::base, ast_channel_snapshot_base::name, OBJ_NOLOCK, cdr_object::party_b, cdr_object::party_b_name, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by ast_cdr_fork(), bridge_candidate_add_to_cdr(), bridge_candidate_process(), single_state_bridge_enter_comparison(), and single_state_process_dial_begin().

◆ cdr_all_unlink()

static void cdr_all_unlink ( struct cdr_object * cdr )

static

Definition at line 1074 of file cdr.c.

{
    struct cdr_object *cur;
    struct cdr_object *next;
 
    ast_assert(cdr->is_root);
 
    /* Hold a ref to the root CDR to ensure the list members don't go away on us. */
    ao2_ref(cdr, +1);
    ao2_lock(active_cdrs_all);
    for (cur = cdr; cur; cur = next) {
        next = cur->next;
        ao2_unlink_flags(active_cdrs_all, cur, OBJ_NOLOCK);
        /*
         * It is safe to still use cur after unlinking because the
         * root CDR holds a ref to all the CDRs in the list and we
         * have a ref to the root CDR.
         */
        ast_string_field_set(cur, party_b_name, "");
    }
    ao2_unlock(active_cdrs_all);
    ao2_ref(cdr, -1);
}

References active_cdrs_all, ao2_lock, ao2_ref, ao2_unlink_flags, ao2_unlock, ast_assert, ast_string_field_set, cdr_object::is_root, cdr_object::next, OBJ_NOLOCK, and cdr_object::party_b_name.

Referenced by cdr_object_dispatch_all_cb(), and handle_channel_snapshot_update_message().

◆ cdr_detach()

static void cdr_detach ( struct ast_cdr * cdr )

static

Definition at line 3994 of file cdr.c.

{
    struct cdr_batch_item *newtail;
    int curr;
    RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
    int submit_batch = 0;
 
    if (!cdr) {
        return;
    }
 
    /* maybe they disabled CDR stuff completely, so just drop it */
    if (!mod_cfg || !ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
        ast_debug(1, "Dropping CDR !\n");
        ast_cdr_free(cdr);
        return;
    }
 
    /* post stuff immediately if we are not in batch mode, this is legacy behaviour */
    if (!ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
        post_cdr(cdr);
        ast_cdr_free(cdr);
        return;
    }
 
    /* otherwise, each CDR gets put into a batch list (at the end) */
    ast_debug(1, "CDR detaching from this thread\n");
 
    /* we'll need a new tail for every CDR */
    if (!(newtail = ast_calloc(1, sizeof(*newtail)))) {
        post_cdr(cdr);
        ast_cdr_free(cdr);
        return;
    }
 
    /* don't traverse a whole list (just keep track of the tail) */
    ast_mutex_lock(&cdr_batch_lock);
    if (!batch)
        init_batch();
    if (!batch->head) {
        /* new batch is empty, so point the head at the new tail */
        batch->head = newtail;
    } else {
        /* already got a batch with something in it, so just append a new tail */
        batch->tail->next = newtail;
    }
    newtail->cdr = cdr;
    batch->tail = newtail;
    curr = batch->size++;
 
    /* if we have enough stuff to post, then do it */
    if (curr >= (mod_cfg->general->batch_settings.size - 1)) {
        submit_batch = 1;
    }
    ast_mutex_unlock(&cdr_batch_lock);
 
    /* Don't submit a batch with cdr_batch_lock held */
    if (submit_batch) {
        start_batch_mode();
    }
}

References ao2_cleanup, ao2_global_obj_ref, ast_calloc, ast_cdr_free(), ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_test_flag, batch, cdr_batch_item::cdr, cdr_batch_lock, CDR_BATCHMODE, CDR_ENABLED, cdr_batch::head, init_batch(), cdr_batch_item::next, post_cdr(), RAII_VAR, cdr_batch::size, start_batch_mode(), and cdr_batch::tail.

Referenced by cdr_object_dispatch().

◆ cdr_enable_batch_mode()

static void cdr_enable_batch_mode ( struct ast_cdr_config * config )

static

Definition at line 4577 of file cdr.c.

{
    /* Only create the thread level portions once */
    if (cdr_thread == AST_PTHREADT_NULL) {
        ast_cond_init(&cdr_pending_cond, NULL);
        if (ast_pthread_create_background(&cdr_thread, NULL, do_cdr, NULL) < 0) {
            ast_log(LOG_ERROR, "Unable to start CDR thread.\n");
            return;
        }
    }
 
    /* Start the batching process */
    start_batch_mode();
 
    ast_log(LOG_NOTICE, "CDR batch mode logging enabled, first of either size %u or time %u seconds.\n",
            config->batch_settings.size, config->batch_settings.time);
}

References ast_cond_init, ast_log, ast_pthread_create_background, AST_PTHREADT_NULL, cdr_pending_cond, cdr_thread, config, do_cdr(), LOG_ERROR, LOG_NOTICE, NULL, and start_batch_mode().

Referenced by cdr_toggle_runtime_options().

◆ cdr_engine_shutdown()

static void cdr_engine_shutdown ( void )

static

Definition at line 4546 of file cdr.c.

{
    stasis_message_router_unsubscribe_and_join(stasis_router);
    stasis_router = NULL;
 
    ao2_cleanup(cdr_topic);
    cdr_topic = NULL;
 
    STASIS_MESSAGE_TYPE_CLEANUP(cdr_sync_message_type);
 
    ao2_callback(active_cdrs_master, OBJ_NODATA | OBJ_MULTIPLE | OBJ_UNLINK,
        cdr_object_dispatch_all_cb, NULL);
    finalize_batch_mode();
    ast_cli_unregister_multiple(cli_commands, ARRAY_LEN(cli_commands));
    ast_sched_context_destroy(sched);
    sched = NULL;
    ast_free(batch);
    batch = NULL;
 
    aco_info_destroy(&cfg_info);
    ao2_global_obj_release(module_configs);
 
    ao2_container_unregister("cdrs_master");
    ao2_cleanup(active_cdrs_master);
    active_cdrs_master = NULL;
 
    ao2_container_unregister("cdrs_all");
    ao2_cleanup(active_cdrs_all);
    active_cdrs_all = NULL;
}

References aco_info_destroy(), active_cdrs_all, active_cdrs_master, ao2_callback, ao2_cleanup, ao2_container_unregister(), ao2_global_obj_release, ARRAY_LEN, ast_cli_unregister_multiple(), ast_free, ast_sched_context_destroy(), batch, cdr_object_dispatch_all_cb(), cdr_topic, cli_commands, finalize_batch_mode(), NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, stasis_message_router_unsubscribe_and_join(), STASIS_MESSAGE_TYPE_CLEANUP, and stasis_router.

Referenced by load_module().

◆ cdr_format_var_internal()

static const char * cdr_format_var_internal	(	struct ast_cdr *	cdr,
		const char *	name
	)

static

Definition at line 3156 of file cdr.c.

{
    struct ast_var_t *variables;
 
    if (ast_strlen_zero(name)) {
        return NULL;
    }
 
    AST_LIST_TRAVERSE(&cdr->varshead, variables, entries) {
        if (!strcasecmp(name, ast_var_name(variables))) {
            return ast_var_value(variables);
        }
    }
 
    return NULL;
}

References AST_LIST_TRAVERSE, ast_strlen_zero(), ast_var_name(), ast_var_value(), ast_var_t::entries, name, NULL, and ast_cdr::varshead.

Referenced by ast_cdr_format_var().

◆ cdr_generic_register()

static int cdr_generic_register	(	struct be_list *	generic_list,
		const char *	name,
		const char *	desc,
		ast_cdrbe	be
	)

static

Definition at line 3040 of file cdr.c.

{
    struct cdr_beitem *i;
    struct cdr_beitem *cur;
 
    if (!name) {
        return -1;
    }
 
    if (!be) {
        ast_log(LOG_WARNING, "CDR engine '%s' lacks backend\n", name);
 
        return -1;
    }
 
    i = ast_calloc(1, sizeof(*i));
    if (!i) {
        return -1;
    }
 
    i->be = be;
    ast_copy_string(i->name, name, sizeof(i->name));
    ast_copy_string(i->desc, desc, sizeof(i->desc));
 
    AST_RWLIST_WRLOCK(generic_list);
    AST_RWLIST_TRAVERSE(generic_list, cur, list) {
        if (!strcasecmp(name, cur->name)) {
            ast_log(LOG_WARNING, "Already have a CDR backend called '%s'\n", name);
            AST_RWLIST_UNLOCK(generic_list);
            ast_free(i);
 
            return -1;
        }
    }
 
    AST_RWLIST_INSERT_HEAD(generic_list, i, list);
    AST_RWLIST_UNLOCK(generic_list);
 
    return 0;
}

References ast_calloc, ast_copy_string(), ast_free, ast_log, AST_RWLIST_INSERT_HEAD, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, AST_RWLIST_WRLOCK, be, cdr_beitem::be, cdr_beitem::desc, desc, cdr_beitem::list, LOG_WARNING, cdr_beitem::name, and name.

Referenced by ast_cdr_modifier_register(), and ast_cdr_register().

◆ cdr_get_tv()

static void cdr_get_tv	(	struct timeval	when,
		const char *	fmt,
		char *	buf,
		int	bufsize
	)

static

Definition at line 3173 of file cdr.c.

{
    if (fmt == NULL) {  /* raw mode */
        snprintf(buf, bufsize, "%ld.%06ld", (long)when.tv_sec, (long)when.tv_usec);
    } else {
        buf[0] = '\0';/* Ensure the buffer is initialized. */
        if (when.tv_sec) {
            struct ast_tm tm;
 
            ast_localtime(&when, &tm, NULL);
            ast_strftime(buf, bufsize, fmt, &tm);
        }
    }
}

References ast_localtime(), ast_strftime(), buf, and NULL.

Referenced by ast_cdr_format_var(), cdr_object_format_property(), cli_show_channel(), and cli_show_channels().

◆ cdr_master_cmp_fn()

static int cdr_master_cmp_fn	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 960 of file cdr.c.

{
    struct cdr_object *left = obj;
    struct cdr_object *right = arg;
    const char *right_key = arg;
    int cmp;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_OBJECT:
        right_key = right->uniqueid;
        /* Fall through */
    case OBJ_SEARCH_KEY:
        cmp = strcmp(left->uniqueid, right_key);
        break;
    case OBJ_SEARCH_PARTIAL_KEY:
        /*
         * We could also use a partial key struct containing a length
         * so strlen() does not get called for every comparison instead.
         */
        cmp = strncmp(left->uniqueid, right_key, strlen(right_key));
        break;
    default:
        /* Sort can only work on something with a full or partial key. */
        ast_assert(0);
        cmp = 0;
        break;
    }
    return cmp ? 0 : CMP_MATCH;
}

References ast_assert, CMP_MATCH, cdr_object::flags, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, OBJ_SEARCH_PARTIAL_KEY, cdr_object::start, and cdr_object::uniqueid.

Referenced by load_module().

◆ cdr_master_hash_fn()

static int cdr_master_hash_fn	(	const void *	obj,
		const int	flags
	)

static

Definition at line 936 of file cdr.c.

{
    const struct cdr_object *cdr;
    const char *key;
 
    switch (flags & OBJ_SEARCH_MASK) {
    case OBJ_SEARCH_KEY:
        key = obj;
        break;
    case OBJ_SEARCH_OBJECT:
        cdr = obj;
        key = cdr->uniqueid;
        break;
    default:
        ast_assert(0);
        return 0;
    }
    return ast_str_case_hash(key);
}

References ast_assert, ast_str_case_hash(), cdr_object::flags, OBJ_SEARCH_KEY, OBJ_SEARCH_MASK, OBJ_SEARCH_OBJECT, and cdr_object::uniqueid.

Referenced by load_module().

◆ cdr_master_print_fn()

static void cdr_master_print_fn	(	void *	v_obj,
		void *	where,
		ao2_prnt_fn *	prnt
	)

static

Definition at line 4604 of file cdr.c.

{
    struct cdr_object *cdr = v_obj;
    struct cdr_object *it_cdr;
 
    if (!cdr) {
        return;
    }
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        prnt(where, "Party A: %s; Party B: %s; Bridge %s\n",
            it_cdr->party_a.snapshot->base->name,
            it_cdr->party_b.snapshot ? it_cdr->party_b.snapshot->base->name : "<unknown>",
            it_cdr->bridge);
    }
}

References cdr_object::next, and cdr_object::start.

Referenced by load_module().

◆ cdr_object_alloc()

static struct cdr_object * cdr_object_alloc	(	struct ast_channel_snapshot *	chan,
		const struct timeval *	event_time
	)

static

cdr_object constructor

Parameters

chan	The ast_channel_snapshot that is the CDR's Party A
event_time

This implicitly sets the state of the newly created CDR to the Single state (single_state_fn_table)

Definition at line 1142 of file cdr.c.

{
    struct cdr_object *cdr;
 
    ast_assert(chan != NULL);
 
    cdr = ao2_alloc(sizeof(*cdr), cdr_object_dtor);
    if (!cdr) {
        return NULL;
    }
    cdr->last = cdr;
    if (ast_string_field_init(cdr, 64)) {
        ao2_cleanup(cdr);
        return NULL;
    }
    ast_string_field_set(cdr, uniqueid, chan->base->uniqueid);
    ast_string_field_set(cdr, name, chan->base->name);
    ast_string_field_set(cdr, linkedid, chan->peer->linkedid);
    cdr->disposition = AST_CDR_NULL;
    cdr->sequence = ast_atomic_fetchadd_int(&global_cdr_sequence, +1);
    cdr->lastevent = *event_time;
 
    cdr->party_a.snapshot = chan;
    ao2_t_ref(cdr->party_a.snapshot, +1, "bump snapshot during CDR creation");
 
    CDR_DEBUG("%p - Created CDR for channel %s\n", cdr, chan->base->name);
 
    cdr_object_transition_state(cdr, &single_state_fn_table);
 
    return cdr;
}

References ao2_alloc, ao2_cleanup, ao2_t_ref, ast_assert, ast_atomic_fetchadd_int(), AST_CDR_NULL, ast_string_field_init, ast_string_field_set, ast_channel_snapshot::base, CDR_DEBUG, cdr_object_dtor(), cdr_object_transition_state(), cdr_object::disposition, global_cdr_sequence, cdr_object::last, cdr_object::lastevent, ast_channel_snapshot_peer::linkedid, cdr_object::linkedid, name, ast_channel_snapshot_base::name, NULL, cdr_object::party_a, ast_channel_snapshot::peer, cdr_object::sequence, single_state_fn_table, cdr_object_snapshot::snapshot, ast_channel_snapshot_base::uniqueid, and cdr_object::uniqueid.

Referenced by cdr_object_create_and_append(), and handle_channel_snapshot_update_message().

◆ cdr_object_check_party_a_answer()

static void cdr_object_check_party_a_answer ( struct cdr_object * cdr )

static

Check to see if a CDR needs to be answered based on its Party A. Note that this is safe to call as much as you want - we won't answer twice.

Definition at line 1598 of file cdr.c.

{
    if (cdr->party_a.snapshot->state == AST_STATE_UP && ast_tvzero(cdr->answer)) {
        cdr->answer = cdr->lastevent;
        /* tv_usec is suseconds_t, which could be int or long */
        CDR_DEBUG("%p - Set answered time to %ld.%06ld\n", cdr,
            (long)cdr->answer.tv_sec,
            (long)cdr->answer.tv_usec);
    }
}

References cdr_object::answer, AST_STATE_UP, ast_tvzero(), CDR_DEBUG, cdr_object::lastevent, cdr_object::party_a, cdr_object_snapshot::snapshot, and ast_channel_snapshot::state.

Referenced by ast_cdr_reset(), base_process_party_a(), bridge_candidate_add_to_cdr(), and single_state_init_function().

◆ cdr_object_check_party_a_hangup()

static void cdr_object_check_party_a_hangup ( struct cdr_object * cdr )

static

Check to see if a CDR needs to move to the finalized state because its Party A hungup.

Definition at line 1581 of file cdr.c.

{
    if (ast_test_flag(&cdr->party_a.snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
        && is_cdr_flag_set(CDR_END_BEFORE_H_EXTEN)) {
        cdr_object_finalize(cdr);
    }
 
    if (ast_test_flag(&cdr->party_a.snapshot->flags, AST_FLAG_DEAD)
        && cdr->fn_table != &finalized_state_fn_table) {
        cdr_object_transition_state(cdr, &finalized_state_fn_table);
    }
}

References AST_FLAG_DEAD, AST_SOFTHANGUP_HANGUP_EXEC, ast_test_flag, CDR_END_BEFORE_H_EXTEN, cdr_object_finalize(), cdr_object_transition_state(), finalized_state_fn_table, ast_channel_snapshot::flags, cdr_object::fn_table, is_cdr_flag_set(), cdr_object::party_a, cdr_object_snapshot::snapshot, and ast_channel_snapshot::softhangup_flags.

Referenced by base_process_party_a().

◆ cdr_object_create_and_append()

static struct cdr_object * cdr_object_create_and_append	(	struct cdr_object *	cdr,
		const struct timeval *	event_time
	)

static

Create a new cdr_object and append it to an existing chain.

Parameters

cdr	The cdr_object to append to
event_time

Definition at line 1179 of file cdr.c.

{
    struct cdr_object *new_cdr;
    struct cdr_object *it_cdr;
    struct cdr_object *cdr_last;
 
    cdr_last = cdr->last;
    new_cdr = cdr_object_alloc(cdr_last->party_a.snapshot, event_time);
    if (!new_cdr) {
        return NULL;
    }
    new_cdr->disposition = AST_CDR_NULL;
 
    /* Copy over the linkedid, as it may have changed */
    ast_string_field_set(new_cdr, linkedid, cdr_last->linkedid);
    ast_string_field_set(new_cdr, appl, cdr_last->appl);
    ast_string_field_set(new_cdr, data, cdr_last->data);
    ast_string_field_set(new_cdr, context, cdr_last->context);
    ast_string_field_set(new_cdr, exten, cdr_last->exten);
 
    /*
     * If the current CDR says to disable all future ones,
     * keep the disable chain going
     */
    if (ast_test_flag(&cdr_last->flags, AST_CDR_FLAG_DISABLE_ALL)) {
        ast_set_flag(&new_cdr->flags, AST_CDR_FLAG_DISABLE_ALL);
    }
 
    /* Copy over other Party A information */
    cdr_object_snapshot_copy(&new_cdr->party_a, &cdr_last->party_a);
 
    /* Append the CDR to the end of the list */
    for (it_cdr = cdr; it_cdr->next; it_cdr = it_cdr->next) {
        it_cdr->last = new_cdr;
    }
    it_cdr->last = new_cdr;
    it_cdr->next = new_cdr;
 
    return new_cdr;
}

References cdr_object::appl, AST_CDR_FLAG_DISABLE_ALL, AST_CDR_NULL, ast_set_flag, ast_string_field_set, ast_test_flag, cdr_object_alloc(), cdr_object_snapshot_copy(), cdr_object::context, cdr_object::data, cdr_object::exten, cdr_object::last, cdr_object::linkedid, cdr_object::next, NULL, and cdr_object::start.

Referenced by ast_cdr_fork(), bridge_candidate_add_to_cdr(), handle_channel_snapshot_update_message(), handle_dial_message(), handle_parked_call_message(), handle_parking_bridge_enter_message(), and handle_standard_bridge_enter_message().

◆ cdr_object_create_public_records()

static struct ast_cdr * cdr_object_create_public_records ( struct cdr_object * cdr )

static

Create a chain of ast_cdr objects from a chain of cdr_object suitable for consumption by the registered CDR backends.

Parameters

cdr	The cdr_object to convert to a public record

Returns: A chain of ast_cdr objects on success

Return values

NULL	on failure

Definition at line 1389 of file cdr.c.

{
    struct ast_cdr *pub_cdr = NULL, *cdr_prev = NULL;
    struct cdr_object *it_cdr;
    struct ast_var_t *it_var, *it_copy_var;
    struct ast_channel_snapshot *party_a;
    struct ast_channel_snapshot *party_b;
 
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        struct ast_cdr *cdr_copy;
 
        /* Don't create records for CDRs where the party A was a dialed channel */
        if (snapshot_is_dialed(it_cdr->party_a.snapshot) && !it_cdr->party_b.snapshot) {
            ast_debug(1, "CDR for %s is dialed and has no Party B; discarding\n",
                it_cdr->party_a.snapshot->base->name);
            continue;
        }
 
        cdr_copy = ast_calloc(1, sizeof(*cdr_copy));
        if (!cdr_copy) {
            ast_free(pub_cdr);
            return NULL;
        }
 
        party_a = it_cdr->party_a.snapshot;
        party_b = it_cdr->party_b.snapshot;
 
        /* Party A */
        ast_assert(party_a != NULL);
        ast_copy_string(cdr_copy->accountcode, party_a->base->accountcode, sizeof(cdr_copy->accountcode));
        cdr_copy->amaflags = party_a->amaflags;
        ast_copy_string(cdr_copy->channel, party_a->base->name, sizeof(cdr_copy->channel));
        ast_callerid_merge(cdr_copy->clid, sizeof(cdr_copy->clid), party_a->caller->name, party_a->caller->number, "");
        ast_copy_string(cdr_copy->src, party_a->caller->number, sizeof(cdr_copy->src));
        ast_copy_string(cdr_copy->uniqueid, party_a->base->uniqueid, sizeof(cdr_copy->uniqueid));
        ast_copy_string(cdr_copy->lastapp, it_cdr->appl, sizeof(cdr_copy->lastapp));
        ast_copy_string(cdr_copy->lastdata, it_cdr->data, sizeof(cdr_copy->lastdata));
        ast_copy_string(cdr_copy->dst, it_cdr->exten, sizeof(cdr_copy->dst));
        ast_copy_string(cdr_copy->dcontext, it_cdr->context, sizeof(cdr_copy->dcontext));
        ast_copy_string(cdr_copy->tenantid, party_a->base->tenantid, sizeof(cdr_copy->tenantid));
 
        /* Party B */
        if (party_b) {
            ast_copy_string(cdr_copy->dstchannel, party_b->base->name, sizeof(cdr_copy->dstchannel));
            ast_copy_string(cdr_copy->peeraccount, party_b->base->accountcode, sizeof(cdr_copy->peeraccount));
            if (!ast_strlen_zero(it_cdr->party_b.userfield)) {
                snprintf(cdr_copy->userfield, sizeof(cdr_copy->userfield), "%s;%s", it_cdr->party_a.userfield, it_cdr->party_b.userfield);
            }
            ast_copy_string(cdr_copy->peertenantid, party_b->base->tenantid, sizeof(cdr_copy->peertenantid));
        }
        if (ast_strlen_zero(cdr_copy->userfield) && !ast_strlen_zero(it_cdr->party_a.userfield)) {
            ast_copy_string(cdr_copy->userfield, it_cdr->party_a.userfield, sizeof(cdr_copy->userfield));
        }
 
        /* Timestamps/durations */
        cdr_copy->start = it_cdr->start;
        cdr_copy->answer = it_cdr->answer;
        cdr_copy->end = it_cdr->end;
        cdr_copy->billsec = cdr_object_get_billsec(it_cdr);
        cdr_copy->duration = cdr_object_get_duration(it_cdr);
 
        /* Flags and IDs */
        ast_copy_flags(cdr_copy, &it_cdr->flags, AST_FLAGS_ALL);
        ast_copy_string(cdr_copy->linkedid, it_cdr->linkedid, sizeof(cdr_copy->linkedid));
        cdr_copy->disposition = it_cdr->disposition;
        cdr_copy->sequence = it_cdr->sequence;
 
        /* Variables */
        copy_variables(&cdr_copy->varshead, &it_cdr->party_a.variables);
        AST_LIST_TRAVERSE(&it_cdr->party_b.variables, it_var, entries) {
            int found = 0;
            struct ast_var_t *newvariable;
            AST_LIST_TRAVERSE(&cdr_copy->varshead, it_copy_var, entries) {
                if (!strcasecmp(ast_var_name(it_var), ast_var_name(it_copy_var))) {
                    found = 1;
                    break;
                }
            }
            if (!found && (newvariable = ast_var_assign(ast_var_name(it_var), ast_var_value(it_var)))) {
                AST_LIST_INSERT_TAIL(&cdr_copy->varshead, newvariable, entries);
            }
        }
 
        if (!pub_cdr) {
            pub_cdr = cdr_copy;
            cdr_prev = pub_cdr;
        } else {
            cdr_prev->next = cdr_copy;
            cdr_prev = cdr_copy;
        }
    }
 
    return pub_cdr;
}

Referenced by cdr_object_dispatch().

◆ cdr_object_dispatch()

static void cdr_object_dispatch ( struct cdr_object * cdr )

static

Dispatch a CDR.

Parameters

cdr	The cdr_object to dispatch

This will create a ast_cdr object and publish it to the various backends

Definition at line 1490 of file cdr.c.

{
    struct ast_cdr *pub_cdr;
 
    CDR_DEBUG("%p - Dispatching CDR for Party A %s, Party B %s\n", cdr,
        cdr->party_a.snapshot->base->name,
        cdr->party_b.snapshot ? cdr->party_b.snapshot->base->name : "<none>");
    pub_cdr = cdr_object_create_public_records(cdr);
    cdr_detach(pub_cdr);
}

References ast_channel_snapshot::base, CDR_DEBUG, cdr_detach(), cdr_object_create_public_records(), ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and ast_cdr::start.

Referenced by cdr_object_dispatch_all_cb(), and handle_channel_snapshot_update_message().

◆ cdr_object_dispatch_all_cb()

static int cdr_object_dispatch_all_cb	(	void *	obj,
		void *	arg,
		int	flags
	)

static

This dispatches all cdr_object. It should only be used during shutdown, so that we get billing records for everything that we can.

Definition at line 4417 of file cdr.c.

{
    struct cdr_object *cdr = obj;
    struct cdr_object *it_cdr;
 
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        cdr_object_transition_state(it_cdr, &finalized_state_fn_table);
    }
    cdr_object_dispatch(cdr);
    ao2_unlock(cdr);
 
    cdr_all_unlink(cdr);
 
    return CMP_MATCH;
}

References ao2_lock, ao2_unlock, cdr_all_unlink(), cdr_object_dispatch(), cdr_object_transition_state(), CMP_MATCH, finalized_state_fn_table, cdr_object::next, and cdr_object::start.

Referenced by cdr_engine_shutdown().

◆ cdr_object_dtor()

static void cdr_object_dtor ( void * obj )

static

cdr_object Destructor

Definition at line 1101 of file cdr.c.

{
    struct cdr_object *cdr = obj;
    struct ast_var_t *it_var;
 
    ao2_cleanup(cdr->party_a.snapshot);
    ao2_cleanup(cdr->party_b.snapshot);
    while ((it_var = AST_LIST_REMOVE_HEAD(&cdr->party_a.variables, entries))) {
        ast_var_delete(it_var);
    }
    while ((it_var = AST_LIST_REMOVE_HEAD(&cdr->party_b.variables, entries))) {
        ast_var_delete(it_var);
    }
    ast_string_field_free_memory(cdr);
 
    /* CDR destruction used to work by calling ao2_cleanup(next) and
     * allowing the chain to destroy itself neatly. Unfortunately, for
     * really long chains, this can result in a stack overflow. So now
     * when the root CDR is destroyed, it is responsible for unreffing
     * all CDRs in the chain
     */
    if (cdr->is_root) {
        struct cdr_object *curr = cdr->next;
        struct cdr_object *next;
 
        while (curr) {
            next = curr->next;
            ao2_cleanup(curr);
            curr = next;
        }
    }
}

References ao2_cleanup, AST_LIST_REMOVE_HEAD, ast_string_field_free_memory, ast_var_delete(), ast_var_t::entries, cdr_object::is_root, cdr_object::next, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, cdr_object::start, and cdr_object_snapshot::variables.

Referenced by cdr_object_alloc().

◆ cdr_object_finalize()

static void cdr_object_finalize ( struct cdr_object * cdr )

static

Finalize a CDR.

This function is safe to call multiple times. Note that you can call this explicitly before going to the finalized state if there's a chance the CDR will be re-activated, in which case the cdr's end time should be cleared. This function is implicitly called when a CDR transitions to the finalized state and right before it is dispatched

Parameters

cdr	The CDR to finalize

Definition at line 1544 of file cdr.c.

{
    if (!ast_tvzero(cdr->end)) {
        return;
    }
    cdr->end = cdr->lastevent;
 
    if (cdr->disposition == AST_CDR_NULL) {
        if (!ast_tvzero(cdr->answer)) {
            cdr->disposition = AST_CDR_ANSWERED;
        } else if (cdr->party_a.snapshot->hangup->cause) {
            cdr_object_set_disposition(cdr, cdr->party_a.snapshot->hangup->cause);
        } else if (cdr->party_b.snapshot && cdr->party_b.snapshot->hangup->cause) {
            cdr_object_set_disposition(cdr, cdr->party_b.snapshot->hangup->cause);
        } else {
            cdr->disposition = AST_CDR_FAILED;
        }
    }
 
    /* tv_usec is suseconds_t, which could be int or long */
    ast_debug(1, "Finalized CDR for %s - start %ld.%06ld answer %ld.%06ld end %ld.%06ld dur %.3f bill %.3f dispo %s\n",
            cdr->party_a.snapshot->base->name,
            (long)cdr->start.tv_sec,
            (long)cdr->start.tv_usec,
            (long)cdr->answer.tv_sec,
            (long)cdr->answer.tv_usec,
            (long)cdr->end.tv_sec,
            (long)cdr->end.tv_usec,
            (double)ast_tvdiff_ms(cdr->end, cdr->start) / 1000.0,
            (double)ast_tvdiff_ms(cdr->end, cdr->answer) / 1000.0,
            ast_cdr_disp2str(cdr->disposition));
}

References cdr_object::answer, AST_CDR_ANSWERED, ast_cdr_disp2str(), AST_CDR_FAILED, AST_CDR_NULL, ast_debug, ast_tvdiff_ms(), ast_tvzero(), ast_channel_snapshot::base, ast_channel_snapshot_hangup::cause, cdr_object_set_disposition(), cdr_object::disposition, cdr_object::end, ast_channel_snapshot::hangup, cdr_object::lastevent, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by ast_cdr_fork(), base_process_party_a(), cdr_object_check_party_a_hangup(), cdr_object_finalize_party_b(), cdr_object_party_b_left_bridge_cb(), dial_state_process_bridge_enter(), finalized_state_init_function(), handle_channel_snapshot_update_message(), handle_standard_bridge_enter_message(), and single_state_bridge_enter_comparison().

◆ cdr_object_finalize_party_b()

static int cdr_object_finalize_party_b	(	void *	obj,
		void *	arg,
		void *	data,
		int	flags
	)

static

Definition at line 2324 of file cdr.c.

{
    struct cdr_object *cdr = obj;
 
    if (!strcasecmp(cdr->party_b_name, arg)) {
#ifdef AST_DEVMODE
        struct ast_channel_snapshot *party_b = data;
 
        /*
         * For sanity's sake we also assert the party_b snapshot
         * is consistent with the key.
         */
        ast_assert(cdr->party_b.snapshot
            && !strcasecmp(cdr->party_b.snapshot->base->name, party_b->base->name));
#endif
 
        /* Don't transition to the finalized state - let the Party A do
         * that when its ready
         */
        cdr_object_finalize(cdr);
    }
    return 0;
}

References ast_assert, ast_channel_snapshot::base, cdr_object_finalize(), ast_channel_snapshot_base::name, cdr_object::party_b, cdr_object::party_b_name, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by handle_channel_snapshot_update_message().

◆ cdr_object_format_property()

static int cdr_object_format_property	(	struct cdr_object *	cdr_obj,
		const char *	name,
		char *	value,
		size_t	length
	)

static

Format one of the standard properties on a cdr_object.

Definition at line 3386 of file cdr.c.

{
    struct ast_channel_snapshot *party_a = cdr_obj->party_a.snapshot;
    struct ast_channel_snapshot *party_b = cdr_obj->party_b.snapshot;
 
    if (!strcasecmp(name, "clid")) {
        ast_callerid_merge(value, length, party_a->caller->name, party_a->caller->number, "");
    } else if (!strcasecmp(name, "src")) {
        ast_copy_string(value, party_a->caller->number, length);
    } else if (!strcasecmp(name, "dst")) {
        ast_copy_string(value, party_a->dialplan->exten, length);
    } else if (!strcasecmp(name, "dcontext")) {
        ast_copy_string(value, party_a->dialplan->context, length);
    } else if (!strcasecmp(name, "channel")) {
        ast_copy_string(value, party_a->base->name, length);
    } else if (!strcasecmp(name, "dstchannel")) {
        if (party_b) {
            ast_copy_string(value, party_b->base->name, length);
        } else {
            ast_copy_string(value, "", length);
        }
    } else if (!strcasecmp(name, "lastapp")) {
        ast_copy_string(value, party_a->dialplan->appl, length);
    } else if (!strcasecmp(name, "lastdata")) {
        ast_copy_string(value, party_a->dialplan->data, length);
    } else if (!strcasecmp(name, "start")) {
        cdr_get_tv(cdr_obj->start, NULL, value, length);
    } else if (!strcasecmp(name, "answer")) {
        cdr_get_tv(cdr_obj->answer, NULL, value, length);
    } else if (!strcasecmp(name, "end")) {
        cdr_get_tv(cdr_obj->end, NULL, value, length);
    } else if (!strcasecmp(name, "duration")) {
        snprintf(value, length, "%ld", cdr_object_get_duration(cdr_obj));
    } else if (!strcasecmp(name, "billsec")) {
        snprintf(value, length, "%ld", cdr_object_get_billsec(cdr_obj));
    } else if (!strcasecmp(name, "disposition")) {
        snprintf(value, length, "%u", cdr_obj->disposition);
    } else if (!strcasecmp(name, "amaflags")) {
        snprintf(value, length, "%d", party_a->amaflags);
    } else if (!strcasecmp(name, "accountcode")) {
        ast_copy_string(value, party_a->base->accountcode, length);
    } else if (!strcasecmp(name, "peeraccount")) {
        if (party_b) {
            ast_copy_string(value, party_b->base->accountcode, length);
        } else {
            ast_copy_string(value, "", length);
        }
    } else if (!strcasecmp(name, "uniqueid")) {
        ast_copy_string(value, party_a->base->uniqueid, length);
    } else if (!strcasecmp(name, "linkedid")) {
        ast_copy_string(value, cdr_obj->linkedid, length);
    } else if (!strcasecmp(name, "tenantid")) {
        ast_copy_string(value, party_a->base->tenantid, length);
    } else if (!strcasecmp(name, "peertenantid")) {
        if (party_b) {
            ast_copy_string(value, party_b->base->tenantid, length);
        } else {
            ast_copy_string(value, "", length);
        }
    } else if (!strcasecmp(name, "userfield")) {
        ast_copy_string(value, cdr_obj->party_a.userfield, length);
    } else if (!strcasecmp(name, "sequence")) {
        snprintf(value, length, "%u", cdr_obj->sequence);
    } else {
        return 1;
    }
 
    return 0;
}

Referenced by ast_cdr_getvar(), and ast_cdr_serialize_variables().

◆ cdr_object_format_var_internal()

static void cdr_object_format_var_internal	(	struct cdr_object *	cdr,
		const char *	name,
		char *	value,
		size_t	length
	)

static

Format a variable on a cdr_object.

Definition at line 3369 of file cdr.c.

{
    struct ast_var_t *variable;
 
    AST_LIST_TRAVERSE(&cdr->party_a.variables, variable, entries) {
        if (!strcasecmp(name, ast_var_name(variable))) {
            ast_copy_string(value, ast_var_value(variable), length);
            return;
        }
    }
 
    *value = '\0';
}

References ast_copy_string(), AST_LIST_TRAVERSE, ast_var_name(), ast_var_value(), ast_var_t::entries, name, cdr_object::party_a, value, and cdr_object_snapshot::variables.

Referenced by ast_cdr_getvar().

◆ cdr_object_get_billsec()

static long cdr_object_get_billsec ( struct cdr_object * cdr )

static

Compute the billsec for a cdr_object.

Definition at line 1337 of file cdr.c.

{
    long int ms;
 
    if (ast_tvzero(cdr->answer)) {
        return 0;
    }
 
    ms = ast_tvdiff_ms(ast_tvzero(cdr->end) ? ast_tvnow() : cdr->end, cdr->answer);
    if (ms % 1000 >= 500
        && is_cdr_flag_set(CDR_INITIATED_SECONDS)) {
        ms = (ms / 1000) + 1;
    } else {
        ms = ms / 1000;
    }
 
    return ms;
}

References cdr_object::answer, ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), CDR_INITIATED_SECONDS, cdr_object::end, and is_cdr_flag_set().

Referenced by cdr_object_create_public_records(), and cdr_object_format_property().

◆ cdr_object_get_by_name()

static struct cdr_object * cdr_object_get_by_name ( const char * name )

static

Definition at line 3463 of file cdr.c.

{
    char *param;
 
    if (ast_strlen_zero(name)) {
        return NULL;
    }
 
    param = ast_strdupa(name);
    return ao2_callback(active_cdrs_master, 0, cdr_object_get_by_name_cb, param);
}

References active_cdrs_master, ao2_callback, ast_strdupa, ast_strlen_zero(), cdr_object_get_by_name_cb(), name, and NULL.

Referenced by ast_cdr_clear_property(), ast_cdr_fork(), ast_cdr_getvar(), ast_cdr_reset(), ast_cdr_serialize_variables(), ast_cdr_set_property(), ast_cdr_setuserfield(), and cli_show_channel().

◆ cdr_object_get_by_name_cb()

static int cdr_object_get_by_name_cb	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 3284 of file cdr.c.

{
    struct cdr_object *cdr = obj;
    const char *name = arg;
 
    if (!strcasecmp(cdr->party_a.snapshot->base->name, name)) {
        return CMP_MATCH;
    }
    return 0;
}

References ast_channel_snapshot::base, CMP_MATCH, name, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by cdr_object_get_by_name().

◆ cdr_object_get_duration()

static long cdr_object_get_duration ( struct cdr_object * cdr )

static

Compute the duration for a cdr_object

Definition at line 1329 of file cdr.c.

{
    return (long)(ast_tvdiff_ms(ast_tvzero(cdr->end) ? ast_tvnow() : cdr->end, cdr->start) / 1000);
}

References ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), cdr_object::end, and cdr_object::start.

Referenced by cdr_object_create_public_records(), and cdr_object_format_property().

◆ cdr_object_party_b_left_bridge_cb()

static int cdr_object_party_b_left_bridge_cb	(	void *	obj,
		void *	arg,
		void *	data,
		int	flags
	)

static

Callback used to notify CDRs of a Party B leaving the bridge.

Definition at line 2501 of file cdr.c.

{
    struct cdr_object *cdr = obj;
    struct bridge_leave_data *leave_data = data;
 
    if (cdr->fn_table == &bridge_state_fn_table
        && !strcmp(cdr->bridge, leave_data->bridge->uniqueid)
        && !strcasecmp(cdr->party_b_name, arg)) {
        /*
         * For sanity's sake we also assert the party_b snapshot
         * is consistent with the key.
         */
        ast_assert(cdr->party_b.snapshot
            && !strcasecmp(cdr->party_b.snapshot->base->name, leave_data->channel->base->name));
 
        /* It is our Party B, in our bridge. Set the last event and let the handler
         * transition our CDR appropriately when we leave the bridge.
         */
        cdr->lastevent = *leave_data->lastevent;
        cdr_object_finalize(cdr);
    }
    return 0;
}

References ast_assert, ast_channel_snapshot::base, cdr_object::bridge, bridge_leave_data::bridge, bridge_state_fn_table, cdr_object_finalize(), bridge_leave_data::channel, cdr_object::fn_table, cdr_object::lastevent, bridge_leave_data::lastevent, ast_channel_snapshot_base::name, cdr_object::party_b, cdr_object::party_b_name, cdr_object_snapshot::snapshot, and ast_bridge_snapshot::uniqueid.

Referenced by handle_bridge_leave_message().

◆ cdr_object_pick_party_a()

static struct cdr_object_snapshot * cdr_object_pick_party_a	(	struct cdr_object_snapshot *	left,
		struct cdr_object_snapshot *	right
	)

static

Given two CDR snapshots, figure out who should be Party A for the resulting CDR.

Parameters

left	One of the snapshots
right	The other snapshot

Returns: The snapshot that won

Definition at line 1294 of file cdr.c.

{
    /* Check whether or not the party is dialed. A dialed party is never the
     * Party A with a party that was not dialed.
     */
    if (!snapshot_is_dialed(left->snapshot) && snapshot_is_dialed(right->snapshot)) {
        return left;
    } else if (snapshot_is_dialed(left->snapshot) && !snapshot_is_dialed(right->snapshot)) {
        return right;
    }
 
    /* Try the Party A flag */
    if (ast_test_flag(left, AST_CDR_FLAG_PARTY_A) && !ast_test_flag(right, AST_CDR_FLAG_PARTY_A)) {
        return left;
    } else if (!ast_test_flag(left, AST_CDR_FLAG_PARTY_A) && ast_test_flag(right, AST_CDR_FLAG_PARTY_A)) {
        return right;
    }
 
    /* Neither party is dialed and neither has the Party A flag - defer to
     * creation time */
    if (left->snapshot->base->creationtime.tv_sec < right->snapshot->base->creationtime.tv_sec) {
        return left;
    } else if (left->snapshot->base->creationtime.tv_sec > right->snapshot->base->creationtime.tv_sec) {
        return right;
    } else if (left->snapshot->base->creationtime.tv_usec > right->snapshot->base->creationtime.tv_usec) {
        return right;
    } else {
        /* Okay, fine, take the left one */
        return left;
    }
}

References AST_CDR_FLAG_PARTY_A, ast_test_flag, ast_channel_snapshot::base, ast_channel_snapshot_base::creationtime, cdr_object_snapshot::snapshot, and snapshot_is_dialed().

Referenced by bridge_candidate_process(), and single_state_bridge_enter_comparison().

◆ cdr_object_select_all_by_name_cb()

static int cdr_object_select_all_by_name_cb	(	void *	obj,
		void *	arg,
		int	flags
	)

static

Definition at line 3268 of file cdr.c.

{
    struct cdr_object *cdr = obj;
    const char *name = arg;
 
    if (!strcasecmp(cdr->party_a.snapshot->base->name, name) ||
            (cdr->party_b.snapshot && !strcasecmp(cdr->party_b.snapshot->base->name, name))) {
        return CMP_MATCH;
    }
    return 0;
}

References ast_channel_snapshot::base, CMP_MATCH, name, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by ast_cdr_setvar().

◆ cdr_object_set_disposition()

static void cdr_object_set_disposition	(	struct cdr_object *	cdr,
		int	hangupcause
	)

static

Set the disposition on a cdr_object based on a hangupcause code.

Parameters

cdr	The cdr_object
hangupcause	The Asterisk hangup cause code

Definition at line 1506 of file cdr.c.

{
    /* Change the disposition based on the hang up cause */
    switch (hangupcause) {
    case AST_CAUSE_BUSY:
        cdr->disposition = AST_CDR_BUSY;
        break;
    case AST_CAUSE_CONGESTION:
        if (!is_cdr_flag_set(CDR_CONGESTION)) {
            cdr->disposition = AST_CDR_FAILED;
        } else {
            cdr->disposition = AST_CDR_CONGESTION;
        }
        break;
    case AST_CAUSE_NO_ROUTE_DESTINATION:
    case AST_CAUSE_UNREGISTERED:
        cdr->disposition = AST_CDR_FAILED;
        break;
    case AST_CAUSE_NORMAL_CLEARING:
    case AST_CAUSE_NO_ANSWER:
        cdr->disposition = AST_CDR_NOANSWER;
        break;
    default:
        break;
    }
}

References AST_CAUSE_BUSY, AST_CAUSE_CONGESTION, AST_CAUSE_NO_ANSWER, AST_CAUSE_NO_ROUTE_DESTINATION, AST_CAUSE_NORMAL_CLEARING, AST_CAUSE_UNREGISTERED, AST_CDR_BUSY, AST_CDR_CONGESTION, AST_CDR_FAILED, AST_CDR_NOANSWER, CDR_CONGESTION, cdr_object::disposition, and is_cdr_flag_set().

Referenced by cdr_object_finalize().

◆ cdr_object_snapshot_copy()

static void cdr_object_snapshot_copy	(	struct cdr_object_snapshot *	dst,
		struct cdr_object_snapshot *	src
	)

static

Copy a snapshot and its details.

Parameters

dst	The destination
src	The source

Definition at line 896 of file cdr.c.

{
    ao2_t_replace(dst->snapshot, src->snapshot, "CDR snapshot copy");
    strcpy(dst->userfield, src->userfield);
    dst->flags = src->flags;
    copy_variables(&dst->variables, &src->variables);
}

References ao2_t_replace, copy_variables(), cdr_object_snapshot::flags, cdr_object_snapshot::snapshot, cdr_object_snapshot::userfield, and cdr_object_snapshot::variables.

Referenced by bridge_candidate_add_to_cdr(), bridge_candidate_process(), cdr_object_create_and_append(), dial_state_process_bridge_enter(), and single_state_bridge_enter_comparison().

◆ cdr_object_swap_snapshot()

static void cdr_object_swap_snapshot	(	struct cdr_object_snapshot *	old_snapshot,
		struct ast_channel_snapshot *	new_snapshot
	)

static

Swap an old cdr_object_snapshot's ast_channel_snapshot for a new ast_channel_snapshot.

Parameters

old_snapshot	The old cdr_object_snapshot
new_snapshot	The new ast_channel_snapshot for old_snapshot

Definition at line 1635 of file cdr.c.

{
    cdr_object_update_cid(old_snapshot, new_snapshot);
    ao2_t_replace(old_snapshot->snapshot, new_snapshot, "Swap CDR snapshot");
}

References ao2_t_replace, cdr_object_update_cid(), and cdr_object_snapshot::snapshot.

Referenced by base_process_party_a(), bridge_state_process_party_b(), dial_state_process_dial_end(), dial_state_process_party_b(), and single_state_process_dial_begin().

◆ cdr_object_transition_state()

static void cdr_object_transition_state	(	struct cdr_object *	cdr,
		struct cdr_object_fn_table *	fn_table
	)

static

Transition a cdr_object to a new state.

Parameters

cdr	The cdr_object to transition
fn_table	The cdr_object_fn_table state to go to

Definition at line 927 of file cdr.c.

{
    cdr_object_transition_state_init(cdr, fn_table, 1);
}

References cdr_object_transition_state_init().

Referenced by ast_cdr_fork(), bridge_candidate_add_to_cdr(), bridge_state_process_bridge_leave(), bridge_state_process_party_b(), cdr_object_alloc(), cdr_object_check_party_a_hangup(), cdr_object_dispatch_all_cb(), dial_state_process_bridge_enter(), dial_state_process_dial_end(), dial_state_process_party_b(), dialed_pending_state_process_bridge_enter(), dialed_pending_state_process_dial_begin(), dialed_pending_state_process_parking_bridge_enter(), dialed_pending_state_process_party_a(), handle_parking_bridge_enter_message(), parked_state_process_bridge_leave(), single_state_process_bridge_enter(), single_state_process_dial_begin(), and single_state_process_parking_bridge_enter().

◆ cdr_object_transition_state_init()

static void cdr_object_transition_state_init	(	struct cdr_object *	cdr,
		struct cdr_object_fn_table *	fn_table,
		int	do_init
	)

static

Transition a cdr_object to a new state with initiation flag.

Parameters

cdr	The cdr_object to transition
fn_table	The cdr_object_fn_table state to go to
do_init

Definition at line 910 of file cdr.c.

{
    CDR_DEBUG("%p - Transitioning CDR for %s from state %s to %s\n",
        cdr, cdr->party_a.snapshot->base->name,
        cdr->fn_table ? cdr->fn_table->name : "NONE", fn_table->name);
    cdr->fn_table = fn_table;
 
    if (cdr->fn_table->init_function && do_init) {
        cdr->fn_table->init_function(cdr);
    }
}

References ast_channel_snapshot::base, CDR_DEBUG, cdr_object::fn_table, cdr_object_fn_table::init_function, ast_channel_snapshot_base::name, cdr_object_fn_table::name, cdr_object::party_a, and cdr_object_snapshot::snapshot.

Referenced by cdr_object_transition_state(), and dialed_pending_state_process_party_a().

◆ cdr_object_update_cid()

static void cdr_object_update_cid	(	struct cdr_object_snapshot *	old_snapshot,
		struct ast_channel_snapshot *	new_snapshot
	)

static

Set Caller ID information on a CDR.

Definition at line 1610 of file cdr.c.

{
    if (!old_snapshot->snapshot) {
        set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller->dnid);
        set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller->subaddr);
        set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->caller->dialed_subaddr);
        return;
    }
    if (strcmp(old_snapshot->snapshot->caller->dnid, new_snapshot->caller->dnid)) {
        set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller->dnid);
    }
    if (strcmp(old_snapshot->snapshot->caller->subaddr, new_snapshot->caller->subaddr)) {
        set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller->subaddr);
    }
    if (strcmp(old_snapshot->snapshot->caller->dialed_subaddr, new_snapshot->caller->dialed_subaddr)) {
        set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->caller->dialed_subaddr);
    }
}

References ast_channel_snapshot::caller, ast_channel_snapshot_caller::dialed_subaddr, ast_channel_snapshot_caller::dnid, set_variable(), cdr_object_snapshot::snapshot, ast_cdr::start, ast_channel_snapshot_caller::subaddr, and cdr_object_snapshot::variables.

Referenced by cdr_object_swap_snapshot().

◆ cdr_object_update_party_b()

static int cdr_object_update_party_b	(	void *	obj,
		void *	arg,
		void *	data,
		int	flags
	)

static

Definition at line 2348 of file cdr.c.

{
    struct cdr_object *cdr = obj;
 
    if (cdr->fn_table->process_party_b
        && !strcasecmp(cdr->party_b_name, arg)) {
        struct ast_channel_snapshot *party_b = data;
 
        /*
         * For sanity's sake we also check the party_b snapshot
         * for consistency with the key.  The callback needs and
         * asserts the snapshot to be this way.
         */
        if (!cdr->party_b.snapshot
            || strcasecmp(cdr->party_b.snapshot->base->name, party_b->base->name)) {
            ast_log(LOG_NOTICE,
                "CDR for Party A %s(%s) has inconsistent Party B %s name.  Message can be ignored but this shouldn't happen.\n",
                cdr->linkedid,
                cdr->party_a.snapshot->base->name,
                cdr->party_b_name);
            return 0;
        }
 
        cdr->fn_table->process_party_b(cdr, party_b);
    }
    return 0;
}

References ast_log, ast_channel_snapshot::base, cdr_object::fn_table, cdr_object::linkedid, LOG_NOTICE, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object::party_b_name, cdr_object_fn_table::process_party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by handle_channel_snapshot_update_message().

◆ cdr_object_update_party_b_userfield_cb()

static int cdr_object_update_party_b_userfield_cb	(	void *	obj,
		void *	arg,
		void *	data,
		int	flags
	)

static

Callback used to update the userfield on Party B on all CDRs.

Definition at line 3608 of file cdr.c.

{
    struct cdr_object *cdr = obj;
 
    if ((cdr->fn_table != &finalized_state_fn_table || !cdr->next)
        && !strcasecmp(cdr->party_b_name, arg)) {
        struct party_b_userfield_update *info = data;
 
        /*
         * For sanity's sake we also assert the party_b snapshot
         * is consistent with the key.
         */
        ast_assert(cdr->party_b.snapshot
            && !strcasecmp(cdr->party_b.snapshot->base->name, info->channel_name));
 
        ast_copy_string(cdr->party_b.userfield, info->userfield,
            sizeof(cdr->party_b.userfield));
    }
 
    return 0;
}

References ast_assert, ast_copy_string(), ast_channel_snapshot::base, finalized_state_fn_table, cdr_object::fn_table, ast_channel_snapshot_base::name, cdr_object::next, cdr_object::party_b, cdr_object::party_b_name, cdr_object_snapshot::snapshot, cdr_object::start, and cdr_object_snapshot::userfield.

Referenced by ast_cdr_setuserfield().

◆ cdr_submit_batch()

static void cdr_submit_batch ( int shutdown )

static

Definition at line 3919 of file cdr.c.

{
    struct module_config *mod_cfg;
    struct cdr_batch_item *oldbatchitems = NULL;
    pthread_t batch_post_thread = AST_PTHREADT_NULL;
 
    /* if there's no batch, or no CDRs in the batch, then there's nothing to do */
    if (!batch || !batch->head) {
        return;
    }
 
    /* move the old CDRs aside, and prepare a new CDR batch */
    ast_mutex_lock(&cdr_batch_lock);
    oldbatchitems = batch->head;
    reset_batch();
    ast_mutex_unlock(&cdr_batch_lock);
 
    mod_cfg = ao2_global_obj_ref(module_configs);
 
    /* if configured, spawn a new thread to post these CDRs,
       also try to save as much as possible if we are shutting down safely */
    if (!mod_cfg
        || ast_test_flag(&mod_cfg->general->batch_settings.settings, BATCH_MODE_SCHEDULER_ONLY)
        || do_shutdown) {
        ast_debug(1, "CDR single-threaded batch processing begins now\n");
        do_batch_backend_process(oldbatchitems);
    } else {
        if (ast_pthread_create_detached_background(&batch_post_thread, NULL, do_batch_backend_process, oldbatchitems)) {
            ast_log(LOG_WARNING, "CDR processing thread could not detach, now trying in this thread\n");
            do_batch_backend_process(oldbatchitems);
        } else {
            ast_debug(1, "CDR multi-threaded batch processing begins now\n");
        }
    }
 
    ao2_cleanup(mod_cfg);
}

References ao2_cleanup, ao2_global_obj_ref, ast_debug, ast_log, ast_mutex_lock, ast_mutex_unlock, ast_pthread_create_detached_background, AST_PTHREADT_NULL, ast_test_flag, batch, BATCH_MODE_SCHEDULER_ONLY, ast_cdr_config::batch_settings, cdr_batch_lock, do_batch_backend_process(), module_config::general, cdr_batch::head, LOG_WARNING, NULL, reset_batch(), and ast_cdr_config::batch_settings::settings.

Referenced by ast_cdr_engine_term(), and submit_scheduled_batch().

◆ cdr_toggle_runtime_options()

static int cdr_toggle_runtime_options ( void )

static

Checks if CDRs are enabled and enables/disables the necessary options.

Definition at line 4645 of file cdr.c.

{
    struct module_config *mod_cfg;
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (mod_cfg
        && ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
        if (create_subscriptions()) {
            destroy_subscriptions();
            ast_log(AST_LOG_ERROR, "Failed to create Stasis subscriptions\n");
            ao2_cleanup(mod_cfg);
            return -1;
        }
        if (ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
            cdr_enable_batch_mode(mod_cfg->general);
        } else {
            ast_log(LOG_NOTICE, "CDR simple logging enabled.\n");
        }
    } else {
        destroy_subscriptions();
        ast_log(LOG_NOTICE, "CDR logging disabled.\n");
    }
    ao2_cleanup(mod_cfg);
 
    return mod_cfg ? 0 : -1;
}

References ao2_cleanup, ao2_global_obj_ref, ast_log, AST_LOG_ERROR, ast_test_flag, CDR_BATCHMODE, cdr_enable_batch_mode(), CDR_ENABLED, create_subscriptions(), destroy_subscriptions(), module_config::general, LOG_NOTICE, and ast_cdr_config::settings.

Referenced by ast_cdr_set_config(), load_module(), and reload_module().

◆ check_new_cdr_needed()

static int check_new_cdr_needed	(	struct ast_channel_snapshot *	old_snapshot,
		struct ast_channel_snapshot *	new_snapshot
	)

static

Determine if we need to add a new CDR based on snapshots.

Definition at line 2377 of file cdr.c.

{
    /* If we're dead, we don't need a new CDR */
    if (!new_snapshot
        || (ast_test_flag(&new_snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
            && is_cdr_flag_set(CDR_END_BEFORE_H_EXTEN))) {
        return 0;
    }
 
    /* Auto-fall through will increment the priority but have no application */
    if (ast_strlen_zero(new_snapshot->dialplan->appl)) {
        return 0;
    }
 
    if (old_snapshot && !snapshot_cep_changed(old_snapshot, new_snapshot)) {
        return 0;
    }
 
    return 1;
}

References ast_channel_snapshot_dialplan::appl, AST_SOFTHANGUP_HANGUP_EXEC, ast_strlen_zero(), ast_test_flag, CDR_END_BEFORE_H_EXTEN, ast_channel_snapshot::dialplan, is_cdr_flag_set(), snapshot_cep_changed(), and ast_channel_snapshot::softhangup_flags.

Referenced by handle_channel_snapshot_update_message().

◆ cli_complete_show()

static char * cli_complete_show ( struct ast_cli_args * a )

static

Complete user input for 'cdr show'.

Definition at line 4123 of file cdr.c.

{
    int wordlen = strlen(a->word);
    struct ao2_iterator it_cdrs;
    struct cdr_object *cdr;
 
    it_cdrs = ao2_iterator_init(active_cdrs_master, 0);
    while ((cdr = ao2_iterator_next(&it_cdrs))) {
        if (!strncasecmp(a->word, cdr->party_a.snapshot->base->name, wordlen)) {
            if (ast_cli_completion_add(ast_strdup(cdr->party_a.snapshot->base->name))) {
                ao2_ref(cdr, -1);
                break;
            }
        }
        ao2_ref(cdr, -1);
    }
    ao2_iterator_destroy(&it_cdrs);
 
    return NULL;
}

References a, active_cdrs_master, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, ast_cli_completion_add(), ast_strdup, ast_channel_snapshot::base, ast_channel_snapshot_base::name, NULL, cdr_object::party_a, cdr_object_snapshot::snapshot, and cdr_object::start.

Referenced by handle_cli_show().

◆ cli_show_channel()

static void cli_show_channel ( struct ast_cli_args * a )

static

Definition at line 4208 of file cdr.c.

{
    struct cdr_object *it_cdr;
    char clid[64];
    char start_time_buffer[64];
    char answer_time_buffer[64];
    char end_time_buffer[64];
    const char *channel_name = a->argv[3];
    struct cdr_object *cdr;
 
#define TITLE_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"
#define FORMAT_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"
 
    cdr = cdr_object_get_by_name(channel_name);
    if (!cdr) {
        ast_cli(a->fd, "Unknown channel: %s\n", channel_name);
        return;
    }
 
    ast_cli(a->fd, "\n");
    ast_cli(a->fd, "Call Detail Record (CDR) Information for %s\n", channel_name);
    ast_cli(a->fd, "--------------------------------------------------\n");
    ast_cli(a->fd, TITLE_STRING, "AccountCode", "CallerID", "Dst. Channel", "LastApp", "Data", "Start", "Answer", "End", "Billsec", "Duration");
 
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        struct timeval end;
 
        if (snapshot_is_dialed(it_cdr->party_a.snapshot)) {
            continue;
        }
        ast_callerid_merge(clid, sizeof(clid), it_cdr->party_a.snapshot->caller->name, it_cdr->party_a.snapshot->caller->number, "");
        if (ast_tvzero(it_cdr->end)) {
            end = ast_tvnow();
        } else {
            end = it_cdr->end;
        }
        cdr_get_tv(it_cdr->start, "%T", start_time_buffer, sizeof(start_time_buffer));
        cdr_get_tv(it_cdr->answer, "%T", answer_time_buffer, sizeof(answer_time_buffer));
        cdr_get_tv(end, "%T", end_time_buffer, sizeof(end_time_buffer));
        ast_cli(a->fd, FORMAT_STRING,
                it_cdr->party_a.snapshot->base->accountcode,
                clid,
                it_cdr->party_b.snapshot ? it_cdr->party_b.snapshot->base->name : "<none>",
                it_cdr->appl,
                it_cdr->data,
                start_time_buffer,
                answer_time_buffer,
                end_time_buffer,
                (long)ast_tvdiff_ms(end, it_cdr->answer) / 1000,
                (long)ast_tvdiff_ms(end, it_cdr->start) / 1000);
    }
    ao2_unlock(cdr);
 
    ao2_cleanup(cdr);
 
#undef FORMAT_STRING
#undef TITLE_STRING
}

References a, ast_channel_snapshot_base::accountcode, cdr_object::answer, ao2_cleanup, ao2_lock, ao2_unlock, cdr_object::appl, ast_callerid_merge(), ast_cli(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), ast_channel_snapshot::base, ast_channel_snapshot::caller, cdr_get_tv(), cdr_object_get_by_name(), cdr_object::data, end, cdr_object::end, FORMAT_STRING, ast_channel_snapshot_caller::name, ast_channel_snapshot_base::name, cdr_object::next, ast_channel_snapshot_caller::number, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, snapshot_is_dialed(), cdr_object::start, and TITLE_STRING.

Referenced by handle_cli_show().

◆ cli_show_channels()

static void cli_show_channels ( struct ast_cli_args * a )

static

Definition at line 4144 of file cdr.c.

{
    struct ao2_iterator it_cdrs;
    struct cdr_object *cdr;
    char start_time_buffer[64];
    char answer_time_buffer[64];
    char end_time_buffer[64];
 
#define TITLE_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"
#define FORMAT_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"
 
    ast_cli(a->fd, "\n");
    ast_cli(a->fd, "Channels with Call Detail Record (CDR) Information\n");
    ast_cli(a->fd, "--------------------------------------------------\n");
    ast_cli(a->fd, TITLE_STRING, "Channel", "Dst. Channel", "LastApp", "Start", "Answer", "End", "Billsec", "Duration");
 
    it_cdrs = ao2_iterator_init(active_cdrs_master, 0);
    for (; (cdr = ao2_iterator_next(&it_cdrs)); ao2_cleanup(cdr)) {
        struct cdr_object *it_cdr;
        struct timeval start_time = { 0, };
        struct timeval answer_time = { 0, };
        struct timeval end_time = { 0, };
 
        SCOPED_AO2LOCK(lock, cdr);
 
        /* Calculate the start, end, answer, billsec, and duration over the
         * life of all of the CDR entries
         */
        for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
            if (snapshot_is_dialed(it_cdr->party_a.snapshot)) {
                continue;
            }
            if (ast_tvzero(start_time)) {
                start_time = it_cdr->start;
            }
            if (!ast_tvzero(it_cdr->answer) && ast_tvzero(answer_time)) {
                answer_time = it_cdr->answer;
            }
        }
 
        /* If there was no start time, then all CDRs were for a dialed channel; skip */
        if (ast_tvzero(start_time)) {
            continue;
        }
        it_cdr = cdr->last;
 
        end_time = ast_tvzero(it_cdr->end) ? ast_tvnow() : it_cdr->end;
        cdr_get_tv(start_time, "%T", start_time_buffer, sizeof(start_time_buffer));
        cdr_get_tv(answer_time, "%T", answer_time_buffer, sizeof(answer_time_buffer));
        cdr_get_tv(end_time, "%T", end_time_buffer, sizeof(end_time_buffer));
        ast_cli(a->fd, FORMAT_STRING, it_cdr->party_a.snapshot->base->name,
                it_cdr->party_b.snapshot ? it_cdr->party_b.snapshot->base->name : "<none>",
                it_cdr->appl,
                start_time_buffer,
                answer_time_buffer,
                end_time_buffer,
                ast_tvzero(answer_time) ? 0 : (long)ast_tvdiff_ms(end_time, answer_time) / 1000,
                (long)ast_tvdiff_ms(end_time, start_time) / 1000);
    }
    ao2_iterator_destroy(&it_cdrs);
#undef FORMAT_STRING
#undef TITLE_STRING
}

References a, active_cdrs_master, cdr_object::answer, ao2_cleanup, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, cdr_object::appl, ast_cli(), ast_tvdiff_ms(), ast_tvnow(), ast_tvzero(), ast_channel_snapshot::base, cdr_get_tv(), cdr_object::end, FORMAT_STRING, cdr_object::last, lock, ast_channel_snapshot_base::name, cdr_object::next, cdr_object::party_a, cdr_object::party_b, SCOPED_AO2LOCK, cdr_object_snapshot::snapshot, snapshot_is_dialed(), cdr_object::start, and TITLE_STRING.

Referenced by handle_cli_show().

◆ CONFIG_INFO_CORE()

CONFIG_INFO_CORE	(	"cdr"	,
		cfg_info	,
		module_configs	,
		module_config_alloc	,
		.	files = `ACO_FILES(&module_file_conf)`,
		.	post_apply_config = `module_config_post_apply`
	)

◆ copy_variables()

static int copy_variables	(	struct varshead *	to_list,
		struct varshead *	from_list
	)

static

Copy variables from one list to another.

Parameters

to_list	destination
from_list	source

Returns: The number of copied variables

Definition at line 851 of file cdr.c.

{
    struct ast_var_t *variables;
    struct ast_var_t *newvariable;
    const char *var;
    const char *val;
    int x = 0;
 
    AST_LIST_TRAVERSE(from_list, variables, entries) {
        var = ast_var_name(variables);
        if (ast_strlen_zero(var)) {
            continue;
        }
        val = ast_var_value(variables);
        if (ast_strlen_zero(val)) {
            continue;
        }
        newvariable = ast_var_assign(var, val);
        if (newvariable) {
            AST_LIST_INSERT_HEAD(to_list, newvariable, entries);
            ++x;
        }
    }
 
    return x;
}

References AST_LIST_INSERT_HEAD, AST_LIST_TRAVERSE, ast_strlen_zero(), ast_var_assign, ast_var_name(), ast_var_value(), ast_var_t::entries, and var.

Referenced by ast_cdr_dup(), ast_cdr_fork(), cdr_object_create_public_records(), and cdr_object_snapshot_copy().

◆ create_subscriptions()

static int create_subscriptions ( void )

static

Create the Stasis subscriptions for CDRs.

Definition at line 4471 of file cdr.c.

{
    if (!cdr_topic) {
        return -1;
    }
 
    if (channel_subscription || bridge_subscription || parking_subscription) {
        return 0;
    }
 
    channel_subscription = stasis_forward_all(ast_channel_topic_all(), cdr_topic);
    if (!channel_subscription) {
        return -1;
    }
    bridge_subscription = stasis_forward_all(ast_bridge_topic_all(), cdr_topic);
    if (!bridge_subscription) {
        return -1;
    }
    parking_subscription = stasis_forward_all(ast_parking_topic(), cdr_topic);
    if (!parking_subscription) {
        return -1;
    }
 
    return 0;
}

References ast_bridge_topic_all(), ast_channel_topic_all(), ast_parking_topic(), bridge_subscription, cdr_topic, channel_subscription, parking_subscription, and stasis_forward_all().

Referenced by cdr_toggle_runtime_options().

◆ destroy_subscriptions()

static void destroy_subscriptions ( void )

static

Destroy the active Stasis subscriptions.

Definition at line 4461 of file cdr.c.

{
    channel_subscription = stasis_forward_cancel(channel_subscription);
    bridge_subscription = stasis_forward_cancel(bridge_subscription);
    parking_subscription = stasis_forward_cancel(parking_subscription);
}

References bridge_subscription, channel_subscription, parking_subscription, and stasis_forward_cancel().

Referenced by cdr_toggle_runtime_options(), create_virtual_subscriptions(), destroy_subscriptions(), destroy_subscriptions_task(), pubsub_on_rx_refresh(), subscription_tree_destructor(), and unload_module().

◆ dial_state_process_bridge_enter()

static enum process_bridge_enter_results dial_state_process_bridge_enter	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 1990 of file cdr.c.

{
    int success = 0;
 
    ast_string_field_set(cdr, bridge, bridge->uniqueid);
 
    /* Get parties in the bridge */
    if (ao2_container_count(bridge->channels) == 1) {
        /* No one in the bridge yet but us! */
        cdr_object_transition_state(cdr, &bridge_state_fn_table);
        return BRIDGE_ENTER_ONLY_PARTY;
    }
 
    /* If we don't have a Party B (originated channel), skip it */
    if (cdr->party_b.snapshot) {
        struct ao2_iterator it_cdrs;
        char *channel_id;
 
        for (it_cdrs = ao2_iterator_init(bridge->channels, 0);
            !success && (channel_id = ao2_iterator_next(&it_cdrs));
            ao2_ref(channel_id, -1)) {
            struct cdr_object *cand_cdr_master;
            struct cdr_object *cand_cdr;
 
            cand_cdr_master = ao2_find(active_cdrs_master, channel_id, OBJ_SEARCH_KEY);
            if (!cand_cdr_master) {
                continue;
            }
 
            ao2_lock(cand_cdr_master);
            for (cand_cdr = cand_cdr_master; cand_cdr; cand_cdr = cand_cdr->next) {
                /* Skip any records that are not in a bridge or in this bridge.
                 * I'm not sure how that would happen, but it pays to be careful. */
                if (cand_cdr->fn_table != &bridge_state_fn_table
                    || strcmp(cdr->bridge, cand_cdr->bridge)) {
                    continue;
                }
 
                /* Skip any records that aren't our Party B */
                if (strcasecmp(cdr->party_b.snapshot->base->name, cand_cdr->party_a.snapshot->base->name)) {
                    continue;
                }
                cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
                /* If they have a Party B, they joined up with someone else as their
                 * Party A. Don't finalize them as they're active. Otherwise, we
                 * have stolen them so they need to be finalized.
                 */
                if (!cand_cdr->party_b.snapshot) {
                    cdr_object_finalize(cand_cdr);
                }
                success = 1;
                break;
            }
            ao2_unlock(cand_cdr_master);
            ao2_cleanup(cand_cdr_master);
        }
        ao2_iterator_destroy(&it_cdrs);
    }
 
    /* We always transition state, even if we didn't get a peer */
    cdr_object_transition_state(cdr, &bridge_state_fn_table);
 
    /* Success implies that we have a Party B */
    if (success) {
        return BRIDGE_ENTER_OBTAINED_PARTY_B;
    }
    return BRIDGE_ENTER_NO_PARTY_B;
}

References active_cdrs_master, ao2_cleanup, ao2_container_count(), ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_string_field_set, ast_channel_snapshot::base, ast_channel_snapshot::bridge, cdr_object::bridge, BRIDGE_ENTER_NO_PARTY_B, BRIDGE_ENTER_OBTAINED_PARTY_B, BRIDGE_ENTER_ONLY_PARTY, bridge_state_fn_table, cdr_object_finalize(), cdr_object_snapshot_copy(), cdr_object_transition_state(), ast_bridge_snapshot::channels, ast_channel_snapshot_base::name, OBJ_SEARCH_KEY, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

◆ dial_state_process_dial_begin()

static int dial_state_process_dial_begin	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	caller,
		struct ast_channel_snapshot *	peer
	)

static

Definition at line 1920 of file cdr.c.

{
    /* Don't process a begin dial here. A party A already in the dial state will
     * who receives a dial begin for something else will be handled by the
     * message router callback and will add a new CDR for the party A */
    return 1;
}

◆ dial_state_process_dial_end()

static int dial_state_process_dial_end	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	caller,
		struct ast_channel_snapshot *	peer,
		const char *	dial_status
	)

static

Definition at line 1958 of file cdr.c.

{
    struct ast_channel_snapshot *party_a;
 
    if (caller) {
        party_a = caller;
    } else {
        party_a = peer;
    }
    ast_assert(!strcasecmp(cdr->party_a.snapshot->base->name, party_a->base->name));
    cdr_object_swap_snapshot(&cdr->party_a, party_a);
 
    if (cdr->party_b.snapshot) {
        if (strcasecmp(cdr->party_b.snapshot->base->name, peer->base->name)) {
            /* Not the status for this CDR - defer back to the message router */
            return 1;
        }
        cdr_object_swap_snapshot(&cdr->party_b, peer);
    }
 
    /* Set the disposition based on the dial string. */
    cdr->disposition = dial_status_to_disposition(dial_status);
    if (cdr->disposition == AST_CDR_ANSWERED) {
        /* Switch to dial pending to wait and see what the caller does */
        cdr_object_transition_state(cdr, &dialed_pending_state_fn_table);
    } else {
        cdr_object_transition_state(cdr, &finalized_state_fn_table);
    }
 
    return 0;
}

References ast_assert, AST_CDR_ANSWERED, ast_channel_snapshot::base, ast_channel_snapshot::caller, cdr_object_swap_snapshot(), cdr_object_transition_state(), dial_status_to_disposition(), dialed_pending_state_fn_table, cdr_object::disposition, finalized_state_fn_table, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, ast_channel_snapshot::peer, and cdr_object_snapshot::snapshot.

◆ dial_state_process_party_b()

static void dial_state_process_party_b	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	snapshot
	)

static

Definition at line 1906 of file cdr.c.

{
    ast_assert(snapshot != NULL);
    ast_assert(cdr->party_b.snapshot
        && !strcasecmp(cdr->party_b.snapshot->base->name, snapshot->base->name));
 
    cdr_object_swap_snapshot(&cdr->party_b, snapshot);
 
    /* If party B hangs up, finalize this CDR */
    if (ast_test_flag(&cdr->party_b.snapshot->flags, AST_FLAG_DEAD)) {
        cdr_object_transition_state(cdr, &finalized_state_fn_table);
    }
}

References ast_assert, AST_FLAG_DEAD, ast_test_flag, ast_channel_snapshot::base, cdr_object_swap_snapshot(), cdr_object_transition_state(), finalized_state_fn_table, ast_channel_snapshot::flags, ast_channel_snapshot_base::name, NULL, cdr_object::party_b, cdr_object_snapshot::snapshot, and cdr_object::start.

◆ dial_status_end()

static int dial_status_end ( const char * dialstatus )

static

Definition at line 2199 of file cdr.c.

{
    return (strcmp(dialstatus, "RINGING") &&
            strcmp(dialstatus, "PROCEEDING") &&
            strcmp(dialstatus, "PROGRESS"));
}

References cdr_object::start.

Referenced by handle_dial_message().

◆ dial_status_to_disposition()

static enum ast_cdr_disposition dial_status_to_disposition ( const char * dial_status )

static

Definition at line 1932 of file cdr.c.

{
    if (!strcmp(dial_status, "ANSWER")) {
        return AST_CDR_ANSWERED;
    } else if (!strcmp(dial_status, "BUSY")) {
        return AST_CDR_BUSY;
    } else if (!strcmp(dial_status, "CANCEL")) {
        if (!is_cdr_flag_set(CDR_CANCEL_DISPOSITION_ENABLED)) {
            return AST_CDR_NOANSWER;
        } else {
            return AST_CDR_CANCEL;
        }
    } else if (!strcmp(dial_status, "NOANSWER")) {
        return AST_CDR_NOANSWER;
    } else if (!strcmp(dial_status, "CONGESTION")) {
        if (!is_cdr_flag_set(CDR_CONGESTION)) {
            return AST_CDR_FAILED;
        } else {
            return AST_CDR_CONGESTION;
        }
    } else if (!strcmp(dial_status, "FAILED")) {
        return AST_CDR_FAILED;
    }
    return AST_CDR_FAILED;
}

References AST_CDR_ANSWERED, AST_CDR_BUSY, AST_CDR_CANCEL, AST_CDR_CONGESTION, AST_CDR_FAILED, AST_CDR_NOANSWER, CDR_CANCEL_DISPOSITION_ENABLED, CDR_CONGESTION, is_cdr_flag_set(), and cdr_object::start.

Referenced by dial_state_process_dial_end(), and handle_dial_message().

◆ dialed_pending_state_process_bridge_enter()

static enum process_bridge_enter_results dialed_pending_state_process_bridge_enter	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 2086 of file cdr.c.

{
    cdr_object_transition_state(cdr, &dial_state_fn_table);
    return cdr->fn_table->process_bridge_enter(cdr, bridge, channel);
}

References cdr_object::bridge, cdr_object_transition_state(), dial_state_fn_table, cdr_object::fn_table, and cdr_object_fn_table::process_bridge_enter.

◆ dialed_pending_state_process_dial_begin()

static int dialed_pending_state_process_dial_begin	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	caller,
		struct ast_channel_snapshot *	peer
	)

static

Definition at line 2102 of file cdr.c.

{
    cdr_object_transition_state(cdr, &finalized_state_fn_table);
 
    /* Ask for a new CDR */
    return 1;
}

References cdr_object_transition_state(), and finalized_state_fn_table.

◆ dialed_pending_state_process_parking_bridge_enter()

static int dialed_pending_state_process_parking_bridge_enter	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 2092 of file cdr.c.

{
    if (cdr->party_b.snapshot) {
        /* We can't handle this as we have a Party B - ask for a new one */
        return 1;
    }
    cdr_object_transition_state(cdr, &parked_state_fn_table);
    return 0;
}

References cdr_object_transition_state(), parked_state_fn_table, cdr_object::party_b, and cdr_object_snapshot::snapshot.

◆ dialed_pending_state_process_party_a()

static int dialed_pending_state_process_party_a	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	snapshot
	)

static

Definition at line 2061 of file cdr.c.

{
    /* If we get a CEP change, we're executing dialplan. If we have a Party B
     * that means we need a new CDR; otherwise, switch us over to single.
     */
    if (snapshot_cep_changed(cdr->party_a.snapshot, snapshot)) {
        if (cdr->party_b.snapshot) {
            cdr_object_transition_state(cdr, &finalized_state_fn_table);
            cdr->fn_table->process_party_a(cdr, snapshot);
            return 1;
        } else {
            /* The CDR does not need to be reinitialized when transitioning
             * to its single state as this would overwrite the start time,
             * causing potentially both the answer and the start time to be
             * the same which is incorrect.
             */
            cdr_object_transition_state_init(cdr, &single_state_fn_table, 0);
            cdr->fn_table->process_party_a(cdr, snapshot);
            return 0;
        }
    }
    base_process_party_a(cdr, snapshot);
    return 0;
}

References base_process_party_a(), cdr_object_transition_state(), cdr_object_transition_state_init(), finalized_state_fn_table, cdr_object::fn_table, cdr_object::party_a, cdr_object::party_b, cdr_object_fn_table::process_party_a, single_state_fn_table, cdr_object_snapshot::snapshot, and snapshot_cep_changed().

◆ do_batch_backend_process()

static void * do_batch_backend_process ( void * data )

static

Definition at line 3902 of file cdr.c.

{
    struct cdr_batch_item *processeditem;
    struct cdr_batch_item *batchitem = data;
 
    /* Push each CDR into storage mechanism(s) and free all the memory */
    while (batchitem) {
        post_cdr(batchitem->cdr);
        ast_cdr_free(batchitem->cdr);
        processeditem = batchitem;
        batchitem = batchitem->next;
        ast_free(processeditem);
    }
 
    return NULL;
}

References ast_cdr_free(), ast_free, cdr_batch_item::cdr, cdr_batch_item::next, NULL, and post_cdr().

Referenced by cdr_submit_batch().

◆ do_cdr()

static void * do_cdr ( void * data )

static

Definition at line 4056 of file cdr.c.

{
    struct timespec timeout;
    int schedms;
    int numevents = 0;
 
    for (;;) {
        struct timeval now;
        schedms = ast_sched_wait(sched);
        /* this shouldn't happen, but provide a 1 second default just in case */
        if (schedms < 0)
            schedms = 1000;
        now = ast_tvadd(ast_tvnow(), ast_samp2tv(schedms, 1000));
        timeout.tv_sec = now.tv_sec;
        timeout.tv_nsec = now.tv_usec * 1000;
        /* prevent stuff from clobbering cdr_pending_cond, then wait on signals sent to it until the timeout expires */
        ast_mutex_lock(&cdr_pending_lock);
        ast_cond_timedwait(&cdr_pending_cond, &cdr_pending_lock, &timeout);
        numevents = ast_sched_runq(sched);
        ast_mutex_unlock(&cdr_pending_lock);
        ast_debug(2, "Processed %d CDR batches from the run queue\n", numevents);
    }
 
    return NULL;
}

References ast_cond_timedwait, ast_debug, ast_mutex_lock, ast_mutex_unlock, ast_samp2tv(), ast_sched_runq(), ast_sched_wait(), ast_tvadd(), ast_tvnow(), cdr_pending_cond, cdr_pending_lock, and NULL.

Referenced by cdr_enable_batch_mode().

◆ filter_bridge_messages()

static int filter_bridge_messages ( struct ast_bridge_snapshot * bridge )

static

Filter bridge messages based on bridge technology.

Definition at line 2526 of file cdr.c.

{
    /* Ignore holding bridge technology messages. We treat this simply as an application
     * that a channel enters into.
     */
    if (!strcmp(bridge->technology, "holding_bridge") && strcmp(bridge->subclass, "parking")) {
        return 1;
    }
    return 0;
}

References bridge_leave_data::bridge, ast_bridge_snapshot::subclass, and ast_bridge_snapshot::technology.

Referenced by handle_bridge_enter_message(), and handle_bridge_leave_message().

◆ filter_channel_snapshot()

static int filter_channel_snapshot ( struct ast_channel_snapshot * snapshot )

static

Definition at line 2174 of file cdr.c.

{
    return snapshot->base->tech_properties & AST_CHAN_TP_INTERNAL;
}

References AST_CHAN_TP_INTERNAL, ast_channel_snapshot::base, and ast_channel_snapshot_base::tech_properties.

Referenced by filter_channel_snapshot_message(), handle_bridge_enter_message(), handle_bridge_leave_message(), handle_dial_message(), and handle_parked_call_message().

◆ filter_channel_snapshot_message()

static int filter_channel_snapshot_message	(	struct ast_channel_snapshot *	old_snapshot,
		struct ast_channel_snapshot *	new_snapshot
	)

static

Definition at line 2183 of file cdr.c.

{
    int ret = 0;
 
    /* Drop cache updates from certain channel technologies */
    if (old_snapshot) {
        ret |= filter_channel_snapshot(old_snapshot);
    }
    if (new_snapshot) {
        ret |= filter_channel_snapshot(new_snapshot);
    }
 
    return ret;
}

References filter_channel_snapshot().

Referenced by handle_channel_snapshot_update_message().

◆ finalize_batch_mode()

static void finalize_batch_mode ( void )

static

Definition at line 4434 of file cdr.c.

{
    if (cdr_thread == AST_PTHREADT_NULL) {
        return;
    }
    /* wake up the thread so it will exit */
    pthread_cancel(cdr_thread);
    pthread_kill(cdr_thread, SIGURG);
    pthread_join(cdr_thread, NULL);
    cdr_thread = AST_PTHREADT_NULL;
    ast_cond_destroy(&cdr_pending_cond);
    ast_cdr_engine_term();
}

References ast_cdr_engine_term(), ast_cond_destroy, AST_PTHREADT_NULL, cdr_pending_cond, cdr_thread, NULL, and cdr_object::start.

Referenced by cdr_engine_shutdown(), and reload_module().

◆ finalized_state_init_function()

static void finalized_state_init_function ( struct cdr_object * cdr )

static

Definition at line 2154 of file cdr.c.

{
    cdr_object_finalize(cdr);
}

References cdr_object_finalize().

◆ finalized_state_process_party_a()

static int finalized_state_process_party_a	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	snapshot
	)

static

Definition at line 2159 of file cdr.c.

{
    if (ast_test_flag(&snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
        && is_cdr_flag_set(CDR_END_BEFORE_H_EXTEN)) {
        return 0;
    }
 
    /* Indicate that, if possible, we should get a new CDR */
    return 1;
}

References AST_SOFTHANGUP_HANGUP_EXEC, ast_test_flag, CDR_END_BEFORE_H_EXTEN, is_cdr_flag_set(), and ast_channel_snapshot::softhangup_flags.

◆ free_variables()

static void free_variables ( struct varshead * headp )

static

Delete all variables from a variable list.

Parameters

headp The head pointer to the variable list to delete

Definition at line 882 of file cdr.c.

{
    struct ast_var_t *vardata;
 
    while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries))) {
        ast_var_delete(vardata);
    }
}

References AST_LIST_REMOVE_HEAD, ast_var_delete(), and ast_var_t::entries.

Referenced by ast_cdr_fork(), and ast_cdr_free().

◆ handle_bridge_enter_message()

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

static

Definition at line 2848 of file cdr.c.

{
    struct ast_bridge_blob *update = stasis_message_data(message);
    struct ast_bridge_snapshot *bridge = update->bridge;
    struct ast_channel_snapshot *channel = update->channel;
    struct cdr_object *cdr;
 
    if (filter_bridge_messages(bridge)) {
        return;
    }
 
    if (filter_channel_snapshot(channel)) {
        return;
    }
 
    CDR_DEBUG("Bridge Enter message for channel %s: %u.%08u\n",
        channel->base->name,
        (unsigned int)stasis_message_timestamp(message)->tv_sec,
        (unsigned int)stasis_message_timestamp(message)->tv_usec);
 
    cdr = ao2_find(active_cdrs_master, channel->base->uniqueid, OBJ_SEARCH_KEY);
    if (!cdr) {
        ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->base->name);
        ast_assert(0);
        return;
    }
 
    if (!strcmp(bridge->subclass, "parking")) {
        handle_parking_bridge_enter_message(cdr, bridge, channel, stasis_message_timestamp(message));
    } else {
        handle_standard_bridge_enter_message(cdr, bridge, channel, stasis_message_timestamp(message));
    }
    ao2_cleanup(cdr);
}

References active_cdrs_master, ao2_cleanup, ao2_find, ast_assert, ast_log, AST_LOG_WARNING, ast_channel_snapshot::base, cdr_object::bridge, CDR_DEBUG, filter_bridge_messages(), filter_channel_snapshot(), handle_parking_bridge_enter_message(), handle_standard_bridge_enter_message(), ast_channel_snapshot_base::name, OBJ_SEARCH_KEY, cdr_object::start, stasis_message_data(), stasis_message_timestamp(), ast_channel_snapshot_base::uniqueid, and update().

Referenced by load_module().

◆ handle_bridge_leave_message()

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

static

Handler for when a channel leaves a bridge.

Parameters

data	Passed on
sub	The stasis subscription for this message callback
message	The message - hopefully a bridge one!

Definition at line 2543 of file cdr.c.

{
    struct ast_bridge_blob *update = stasis_message_data(message);
    struct ast_bridge_snapshot *bridge = update->bridge;
    struct ast_channel_snapshot *channel = update->channel;
    struct cdr_object *cdr;
    struct cdr_object *it_cdr;
    struct bridge_leave_data leave_data = {
        .bridge = bridge,
        .channel = channel,
        .lastevent = stasis_message_timestamp(message)
    };
    int left_bridge = 0;
 
    if (filter_bridge_messages(bridge)) {
        return;
    }
 
    if (filter_channel_snapshot(channel)) {
        return;
    }
 
    CDR_DEBUG("Bridge Leave message for %s: %u.%08u\n",
        channel->base->name,
        (unsigned int)leave_data.lastevent->tv_sec,
        (unsigned int)leave_data.lastevent->tv_usec);
 
    cdr = ao2_find(active_cdrs_master, channel->base->uniqueid, OBJ_SEARCH_KEY);
    if (!cdr) {
        ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->base->name);
        ast_assert(0);
        return;
    }
 
    /* Party A */
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        it_cdr->lastevent = *leave_data.lastevent;
        if (!it_cdr->fn_table->process_bridge_leave) {
            continue;
        }
        CDR_DEBUG("%p - Processing Bridge Leave for %s\n",
            it_cdr, channel->base->name);
        if (!it_cdr->fn_table->process_bridge_leave(it_cdr, bridge, channel)) {
            ast_string_field_set(it_cdr, bridge, "");
            left_bridge = 1;
        }
    }
    ao2_unlock(cdr);
 
    /* Party B */
    if (left_bridge
        && strcmp(bridge->subclass, "parking")) {
        ao2_callback_data(active_cdrs_all, OBJ_NODATA | OBJ_MULTIPLE | OBJ_SEARCH_KEY,
            cdr_object_party_b_left_bridge_cb, (char *) leave_data.channel->base->name,
            &leave_data);
    }
 
    ao2_cleanup(cdr);
}

References active_cdrs_all, active_cdrs_master, ao2_callback_data, ao2_cleanup, ao2_find, ao2_lock, ao2_unlock, ast_assert, ast_log, AST_LOG_WARNING, ast_string_field_set, ast_channel_snapshot::base, bridge_leave_data::bridge, CDR_DEBUG, cdr_object_party_b_left_bridge_cb(), bridge_leave_data::channel, filter_bridge_messages(), filter_channel_snapshot(), cdr_object::fn_table, cdr_object::lastevent, bridge_leave_data::lastevent, ast_channel_snapshot_base::name, cdr_object::next, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, cdr_object_fn_table::process_bridge_leave, cdr_object::start, stasis_message_data(), stasis_message_timestamp(), ast_bridge_snapshot::subclass, ast_channel_snapshot_base::uniqueid, and update().

Referenced by load_module().

◆ handle_bridge_pairings()

static void handle_bridge_pairings	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge
	)

static

Handle creating bridge pairings for the cdr_object that just entered a bridge.

Parameters

cdr	The cdr_object that just entered the bridge
bridge	The ast_bridge_snapshot representing the bridge it just entered

Definition at line 2700 of file cdr.c.

{
    struct ao2_iterator it_channels;
    char *channel_id;
 
    it_channels = ao2_iterator_init(bridge->channels, 0);
    while ((channel_id = ao2_iterator_next(&it_channels))) {
        struct cdr_object *cand_cdr;
 
        cand_cdr = ao2_find(active_cdrs_master, channel_id, OBJ_SEARCH_KEY);
        if (cand_cdr) {
            bridge_candidate_process(cdr, cand_cdr);
            ao2_ref(cand_cdr, -1);
        }
 
        ao2_ref(channel_id, -1);
    }
    ao2_iterator_destroy(&it_channels);
}

References active_cdrs_master, ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_ref, bridge_candidate_process(), ast_bridge_snapshot::channels, OBJ_SEARCH_KEY, and cdr_object::start.

Referenced by handle_standard_bridge_enter_message().

◆ handle_cdr_sync_message()

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

static

Handler for a synchronization message.

Parameters

data	Passed on
sub	The stasis subscription for this message callback
message	A blank ao2 object

Definition at line 2958 of file cdr.c.

{
    return;
}

Referenced by load_module().

◆ handle_channel_snapshot_update_message()

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

static

Handler for channel snapshot update messages.

Parameters

data	Passed on
sub	The stasis subscription for this message callback
message	The message

Definition at line 2405 of file cdr.c.

{
    struct cdr_object *cdr;
    struct ast_channel_snapshot_update *update = stasis_message_data(message);
    struct cdr_object *it_cdr;
 
    if (filter_channel_snapshot_message(update->old_snapshot, update->new_snapshot)) {
        return;
    }
 
    if (update->new_snapshot && !update->old_snapshot) {
        struct module_config *mod_cfg = NULL;
 
        cdr = cdr_object_alloc(update->new_snapshot, stasis_message_timestamp(message));
        if (!cdr) {
            return;
        }
        mod_cfg = ao2_global_obj_ref(module_configs);
        cdr->is_root = 1;
        ao2_link(active_cdrs_master, cdr);
 
        /* If CDR should be disabled unless enabled on a per-channel basis, then disable
            CDR, right from the get go */
        if (mod_cfg) {
            if (!ast_test_flag(&mod_cfg->general->settings, CDR_CHANNEL_DEFAULT_ENABLED)) {
                ast_debug(3, "Disable CDR by default\n");
                ast_set_flag(&cdr->flags, AST_CDR_FLAG_DISABLE_ALL);
            }
            ao2_cleanup(mod_cfg);
        }
    } else {
        cdr = ao2_find(active_cdrs_master, update->new_snapshot->base->uniqueid, OBJ_SEARCH_KEY);
    }
 
    /* Handle Party A */
    if (!cdr) {
        ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", update->new_snapshot->base->name);
        ast_assert(0);
    } else {
        int all_reject = 1;
 
        ao2_lock(cdr);
        for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
            it_cdr->lastevent = *stasis_message_timestamp(message);
            if (!it_cdr->fn_table->process_party_a) {
                continue;
            }
            all_reject &= it_cdr->fn_table->process_party_a(it_cdr, update->new_snapshot);
        }
        if (all_reject && check_new_cdr_needed(update->old_snapshot, update->new_snapshot)) {
            /* We're not hung up and we have a new snapshot - we need a new CDR */
            struct cdr_object *new_cdr;
 
            new_cdr = cdr_object_create_and_append(cdr, stasis_message_timestamp(message));
            if (new_cdr) {
                new_cdr->fn_table->process_party_a(new_cdr, update->new_snapshot);
            }
        }
        ao2_unlock(cdr);
    }
 
    if (ast_test_flag(&update->new_snapshot->flags, AST_FLAG_DEAD)) {
        ao2_lock(cdr);
        CDR_DEBUG("%p - Beginning finalize/dispatch for %s\n", cdr, update->old_snapshot->base->name);
        for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
            it_cdr->lastevent = *stasis_message_timestamp(message);
            cdr_object_finalize(it_cdr);
        }
        cdr_object_dispatch(cdr);
        ao2_unlock(cdr);
 
        cdr_all_unlink(cdr);
        ao2_unlink(active_cdrs_master, cdr);
    }
 
    /* Handle Party B */
    if (update->new_snapshot) {
        ao2_callback_data(active_cdrs_all, OBJ_NODATA | OBJ_MULTIPLE | OBJ_SEARCH_KEY,
            cdr_object_update_party_b, (char *) update->new_snapshot->base->name, update->new_snapshot);
    }
 
    if (ast_test_flag(&update->new_snapshot->flags, AST_FLAG_DEAD)) {
        ao2_callback_data(active_cdrs_all, OBJ_NODATA | OBJ_MULTIPLE | OBJ_SEARCH_KEY,
            cdr_object_finalize_party_b, (char *) update->new_snapshot->base->name, update->new_snapshot);
    }
 
    ao2_cleanup(cdr);
}

References active_cdrs_all, active_cdrs_master, ao2_callback_data, ao2_cleanup, ao2_find, ao2_global_obj_ref, ao2_link, ao2_lock, ao2_unlink, ao2_unlock, ast_assert, AST_CDR_FLAG_DISABLE_ALL, ast_debug, AST_FLAG_DEAD, ast_log, AST_LOG_WARNING, ast_set_flag, ast_test_flag, cdr_all_unlink(), CDR_CHANNEL_DEFAULT_ENABLED, CDR_DEBUG, cdr_object_alloc(), cdr_object_create_and_append(), cdr_object_dispatch(), cdr_object_finalize(), cdr_object_finalize_party_b(), cdr_object_update_party_b(), check_new_cdr_needed(), filter_channel_snapshot_message(), cdr_object::flags, cdr_object::fn_table, module_config::general, cdr_object::is_root, cdr_object::lastevent, cdr_object::name, cdr_object::next, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, cdr_object_fn_table::process_party_a, ast_cdr_config::settings, cdr_object::start, stasis_message_data(), stasis_message_timestamp(), and update().

Referenced by load_module().

◆ handle_cli_debug()

static char * handle_cli_debug	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 4082 of file cdr.c.

{
    struct module_config *mod_cfg;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "cdr set debug [on|off]";
        e->usage = "Enable or disable extra debugging in the CDR Engine. Note\n"
                "that this will dump debug information to the VERBOSE setting\n"
                "and should only be used when debugging information from the\n"
                "CDR engine is needed.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc != 4) {
        return CLI_SHOWUSAGE;
    }
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        ast_cli(a->fd, "Could not set CDR debugging mode\n");
        return CLI_SUCCESS;
    }
    if (!strcasecmp(a->argv[3], "on")
        && !ast_test_flag(&mod_cfg->general->settings, CDR_DEBUG)) {
        ast_set_flag(&mod_cfg->general->settings, CDR_DEBUG);
        ast_cli(a->fd, "CDR debugging enabled\n");
    } else if (!strcasecmp(a->argv[3], "off")
        && ast_test_flag(&mod_cfg->general->settings, CDR_DEBUG)) {
        ast_clear_flag(&mod_cfg->general->settings, CDR_DEBUG);
        ast_cli(a->fd, "CDR debugging disabled\n");
    }
    cdr_set_debug_mode(mod_cfg);
    ao2_cleanup(mod_cfg);
 
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_global_obj_ref, ast_clear_flag, ast_cli(), ast_set_flag, ast_test_flag, CDR_DEBUG, cdr_set_debug_mode, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, module_config::general, NULL, ast_cdr_config::settings, and ast_cli_entry::usage.

◆ handle_cli_show()

static char * handle_cli_show	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 4268 of file cdr.c.

{
    switch (cmd) {
    case CLI_INIT:
            e->command = "cdr show active";
            e->usage =
                "Usage: cdr show active [channel]\n"
                "   Displays a summary of all Call Detail Records when [channel]\n"
                "   is omitted; displays all of the Call Detail Records\n"
                "   currently in flight for a given [channel] when [channel] is\n"
                "   specified.\n\n"
                "   Note that this will not display Call Detail Records that\n"
                "   have already been dispatched to a backend storage, nor for\n"
                "   channels that are no longer active.\n";
            return NULL;
    case CLI_GENERATE:
        return cli_complete_show(a);
    }
 
    if (a->argc > 4) {
        return CLI_SHOWUSAGE;
    } else if (a->argc < 4) {
        cli_show_channels(a);
    } else {
        cli_show_channel(a);
    }
 
    return CLI_SUCCESS;
}

References a, cli_complete_show(), CLI_GENERATE, CLI_INIT, cli_show_channel(), cli_show_channels(), CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, NULL, and ast_cli_entry::usage.

◆ handle_cli_status()

static char * handle_cli_status	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 4298 of file cdr.c.

{
    struct cdr_beitem *beitem = NULL;
    struct module_config *mod_cfg;
    int cnt = 0;
    long nextbatchtime = 0;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "cdr show status";
        e->usage =
            "Usage: cdr show status\n"
            "   Displays the Call Detail Record engine system status.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
 
    if (a->argc > 3) {
        return CLI_SHOWUSAGE;
    }
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        return CLI_FAILURE;
    }
 
    ast_cli(a->fd, "\n");
    ast_cli(a->fd, "Call Detail Record (CDR) settings\n");
    ast_cli(a->fd, "----------------------------------\n");
    ast_cli(a->fd, "  Logging:                    %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED) ? "Enabled" : "Disabled");
    ast_cli(a->fd, "  Mode:                       %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE) ? "Batch" : "Simple");
    if (ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
        ast_cli(a->fd, "  Log calls by default:       %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_CHANNEL_DEFAULT_ENABLED) ? "Yes" : "No");
        ast_cli(a->fd, "  Log unanswered calls:       %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_UNANSWERED) ? "Yes" : "No");
        ast_cli(a->fd, "  Log congestion:             %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_CONGESTION) ? "Yes" : "No");
        ast_cli(a->fd, "  Ignore bridging changes:    %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_STATE_CHANGES) ? "Yes" : "No");
        ast_cli(a->fd, "  Ignore dial state changes:  %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_DIAL_CHANGES) ? "Yes" : "No");
        ast_cli(a->fd, "  Cancel disposition enabled: %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_CANCEL_DISPOSITION_ENABLED) ? "Yes" : "No");
        if (ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
            ast_cli(a->fd, "* Batch Mode Settings\n");
            ast_cli(a->fd, "  -------------------\n");
            if (batch)
                cnt = batch->size;
            if (cdr_sched > -1)
                nextbatchtime = ast_sched_when(sched, cdr_sched);
            ast_cli(a->fd, "  Safe shutdown:              %s\n", ast_test_flag(&mod_cfg->general->batch_settings.settings, BATCH_MODE_SAFE_SHUTDOWN) ? "Enabled" : "Disabled");
            ast_cli(a->fd, "  Threading model:            %s\n", ast_test_flag(&mod_cfg->general->batch_settings.settings, BATCH_MODE_SCHEDULER_ONLY) ? "Scheduler only" : "Scheduler plus separate threads");
            ast_cli(a->fd, "  Current batch size:         %d record%s\n", cnt, ESS(cnt));
            ast_cli(a->fd, "  Maximum batch size:         %u record%s\n", mod_cfg->general->batch_settings.size, ESS(mod_cfg->general->batch_settings.size));
            ast_cli(a->fd, "  Maximum batch time:         %u second%s\n", mod_cfg->general->batch_settings.time, ESS(mod_cfg->general->batch_settings.time));
            ast_cli(a->fd, "  Next batch processing time: %ld second%s\n\n", nextbatchtime, ESS(nextbatchtime));
        }
        ast_cli(a->fd, "* Registered Backends\n");
        ast_cli(a->fd, "  -------------------\n");
        AST_RWLIST_RDLOCK(&be_list);
        if (AST_RWLIST_EMPTY(&be_list)) {
            ast_cli(a->fd, "    (none)\n");
        } else {
            AST_RWLIST_TRAVERSE(&be_list, beitem, list) {
                ast_cli(a->fd, "    %s%s\n", beitem->name, beitem->suspended ? " (suspended) " : "");
            }
        }
        AST_RWLIST_UNLOCK(&be_list);
        ast_cli(a->fd, "\n");
    }
 
    ao2_cleanup(mod_cfg);
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_global_obj_ref, ast_cli(), AST_RWLIST_EMPTY, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_sched_when(), ast_test_flag, batch, BATCH_MODE_SAFE_SHUTDOWN, BATCH_MODE_SCHEDULER_ONLY, ast_cdr_config::batch_settings, CDR_BATCHMODE, CDR_CANCEL_DISPOSITION_ENABLED, CDR_CHANNEL_DEFAULT_ENABLED, CDR_CONGESTION, CDR_ENABLED, CDR_IGNORE_DIAL_CHANGES, CDR_IGNORE_STATE_CHANGES, cdr_sched, CDR_UNANSWERED, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ESS, module_config::general, cdr_beitem::name, NULL, ast_cdr_config::settings, ast_cdr_config::batch_settings::settings, ast_cdr_config::batch_settings::size, cdr_batch::size, cdr_beitem::suspended, ast_cdr_config::batch_settings::time, and ast_cli_entry::usage.

◆ handle_cli_submit()

static char * handle_cli_submit	(	struct ast_cli_entry *	e,
		int	cmd,
		struct ast_cli_args *	a
	)

static

Definition at line 4369 of file cdr.c.

{
    struct module_config *mod_cfg;
 
    switch (cmd) {
    case CLI_INIT:
        e->command = "cdr submit";
        e->usage =
            "Usage: cdr submit\n"
            "Posts all pending batched CDR data to the configured CDR\n"
            "backend engine modules.\n";
        return NULL;
    case CLI_GENERATE:
        return NULL;
    }
    if (a->argc > 2) {
        return CLI_SHOWUSAGE;
    }
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        return CLI_FAILURE;
    }
 
    if (!ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
        ast_cli(a->fd, "Cannot submit CDR batch: CDR engine disabled.\n");
    } else if (!ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
        ast_cli(a->fd, "Cannot submit CDR batch: batch mode not enabled.\n");
    } else {
        start_batch_mode();
        ast_cli(a->fd, "Submitted CDRs to backend engines for processing.  This may take a while.\n");
    }
    ao2_cleanup(mod_cfg);
 
    return CLI_SUCCESS;
}

References a, ao2_cleanup, ao2_global_obj_ref, ast_cli(), ast_test_flag, CDR_BATCHMODE, CDR_ENABLED, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, module_config::general, NULL, ast_cdr_config::settings, start_batch_mode(), and ast_cli_entry::usage.

◆ handle_dial_message()

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

static

Handler for Stasis-Core dial messages.

Parameters

data	Passed on
sub	The stasis subscription for this message callback
message	The message

Definition at line 2214 of file cdr.c.

{
    struct cdr_object *cdr;
    struct ast_multi_channel_blob *payload = stasis_message_data(message);
    struct ast_channel_snapshot *caller;
    struct ast_channel_snapshot *peer;
    struct cdr_object *it_cdr;
    struct ast_json *dial_status_blob;
    const char *dial_status = NULL;
    int res = 1;
 
    caller = ast_multi_channel_blob_get_channel(payload, "caller");
    peer = ast_multi_channel_blob_get_channel(payload, "peer");
    if (!peer && !caller) {
        return;
    }
 
    if (peer && filter_channel_snapshot(peer)) {
        return;
    }
 
    if (caller && filter_channel_snapshot(caller)) {
        return;
    }
 
    dial_status_blob = ast_json_object_get(ast_multi_channel_blob_get_json(payload), "dialstatus");
    if (dial_status_blob) {
        dial_status = ast_json_string_get(dial_status_blob);
    }
 
    CDR_DEBUG("Dial %s message for %s, %s: %u.%08u\n",
        ast_strlen_zero(dial_status) ? "Begin" : "End",
        caller ? caller->base->name : "(none)",
        peer ? peer->base->name : "(none)",
        (unsigned int)stasis_message_timestamp(message)->tv_sec,
        (unsigned int)stasis_message_timestamp(message)->tv_usec);
 
    /* Figure out who is running this show */
    if (caller) {
        cdr = ao2_find(active_cdrs_master, caller->base->uniqueid, OBJ_SEARCH_KEY);
    } else {
        cdr = ao2_find(active_cdrs_master, peer->base->uniqueid, OBJ_SEARCH_KEY);
    }
    if (!cdr) {
        ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", caller ? caller->base->name : peer->base->name);
        ast_assert(0);
        return;
    }
 
    ao2_lock(cdr);
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        it_cdr->lastevent = *stasis_message_timestamp(message);
        if (ast_strlen_zero(dial_status)) {
            if (!it_cdr->fn_table->process_dial_begin) {
                continue;
            }
            if (dial_changes_ignored) {
                CDR_DEBUG("%p - Ignoring Dial Begin message\n", it_cdr);
                continue;
            }
            CDR_DEBUG("%p - Processing Dial Begin message for channel %s, peer %s\n",
                it_cdr,
                caller ? caller->base->name : "(none)",
                peer ? peer->base->name : "(none)");
            res &= it_cdr->fn_table->process_dial_begin(it_cdr,
                    caller,
                    peer);
        } else if (dial_status_end(dial_status)) {
            if (!it_cdr->fn_table->process_dial_end) {
                continue;
            }
            if (dial_changes_ignored) {
                /*
                 * Once a dial has been answered, later non-answer Dial End events
                 * must not downgrade the CDR disposition.
                 */
                if (it_cdr->disposition != AST_CDR_ANSWERED) {
                    it_cdr->disposition = dial_status_to_disposition(dial_status);
                }
                CDR_DEBUG("%p - Handling disposition only (%s)\n", it_cdr, dial_status);
                continue;
            }
            CDR_DEBUG("%p - Processing Dial End message for channel %s, peer %s\n",
                it_cdr,
                caller ? caller->base->name : "(none)",
                peer ? peer->base->name : "(none)");
            it_cdr->fn_table->process_dial_end(it_cdr,
                    caller,
                    peer,
                    dial_status);
        }
    }
 
    /* If we're ignoring dial changes, don't allow multiple CDRs for this channel. */
    if (!dial_changes_ignored) {
        /* If no CDR handled a dial begin message, make a new one */
        if (res && ast_strlen_zero(dial_status)) {
            struct cdr_object *new_cdr;
 
            new_cdr = cdr_object_create_and_append(cdr, stasis_message_timestamp(message));
            if (new_cdr) {
                new_cdr->fn_table->process_dial_begin(new_cdr, caller, peer);
            }
        }
    }
 
    ao2_unlock(cdr);
    ao2_cleanup(cdr);
}

References active_cdrs_master, ao2_cleanup, ao2_find, ao2_lock, ao2_unlock, ast_assert, AST_CDR_ANSWERED, ast_json_object_get(), ast_json_string_get(), ast_log, AST_LOG_WARNING, ast_multi_channel_blob_get_channel(), ast_multi_channel_blob_get_json(), ast_strlen_zero(), ast_channel_snapshot::base, ast_channel_snapshot::caller, CDR_DEBUG, cdr_object_create_and_append(), dial_changes_ignored, dial_status_end(), dial_status_to_disposition(), cdr_object::disposition, filter_channel_snapshot(), cdr_object::fn_table, cdr_object::lastevent, ast_channel_snapshot_base::name, cdr_object::next, NULL, OBJ_SEARCH_KEY, ast_channel_snapshot::peer, cdr_object_fn_table::process_dial_begin, cdr_object_fn_table::process_dial_end, cdr_object::start, stasis_message_data(), stasis_message_timestamp(), and ast_channel_snapshot_base::uniqueid.

Referenced by load_module().

◆ handle_parked_call_message()

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

static

Handler for when a channel is parked.

Parameters

data	Passed on
sub	The stasis subscription for this message callback
message	The message about who got parked

Definition at line 2890 of file cdr.c.

{
    struct ast_parked_call_payload *payload = stasis_message_data(message);
    struct ast_channel_snapshot *channel = payload->parkee;
    struct cdr_object *cdr;
    int unhandled = 1;
    struct cdr_object *it_cdr;
 
    /* Anything other than getting parked will be handled by other updates */
    if (payload->event_type != PARKED_CALL) {
        return;
    }
 
    /* No one got parked? */
    if (!channel) {
        return;
    }
 
    if (filter_channel_snapshot(channel)) {
        return;
    }
 
    CDR_DEBUG("Parked Call message for channel %s: %u.%08u\n",
        channel->base->name,
        (unsigned int)stasis_message_timestamp(message)->tv_sec,
        (unsigned int)stasis_message_timestamp(message)->tv_usec);
 
    cdr = ao2_find(active_cdrs_master, channel->base->uniqueid, OBJ_SEARCH_KEY);
    if (!cdr) {
        ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->base->name);
        ast_assert(0);
        return;
    }
 
    ao2_lock(cdr);
 
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        it_cdr->lastevent = *stasis_message_timestamp(message);
        if (it_cdr->fn_table->process_parked_channel) {
            unhandled &= it_cdr->fn_table->process_parked_channel(it_cdr, payload);
        }
    }
 
    if (unhandled) {
        /* Nothing handled the message - we need a new one! */
        struct cdr_object *new_cdr;
 
        new_cdr = cdr_object_create_and_append(cdr, stasis_message_timestamp(message));
        if (new_cdr) {
            /* As the new CDR is created in the single state, it is guaranteed
             * to have a function for the parked call message and will handle
             * the message */
            new_cdr->fn_table->process_parked_channel(new_cdr, payload);
        }
    }
 
    ao2_unlock(cdr);
 
    ao2_cleanup(cdr);
}

References active_cdrs_master, ao2_cleanup, ao2_find, ao2_lock, ao2_unlock, ast_assert, ast_log, AST_LOG_WARNING, ast_channel_snapshot::base, CDR_DEBUG, cdr_object_create_and_append(), ast_parked_call_payload::event_type, filter_channel_snapshot(), ast_channel_snapshot_base::name, cdr_object::next, OBJ_SEARCH_KEY, PARKED_CALL, ast_parked_call_payload::parkee, cdr_object::start, stasis_message_data(), stasis_message_timestamp(), and ast_channel_snapshot_base::uniqueid.

Referenced by load_module().

◆ handle_parking_bridge_enter_message()

static void handle_parking_bridge_enter_message	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel,
		const struct timeval *	event_time
	)

static

Handle entering into a parking bridge.

Parameters

cdr	The CDR to operate on
bridge	The bridge the channel just entered
channel	The channel snapshot
event_time

Definition at line 2726 of file cdr.c.

{
    int res = 1;
    struct cdr_object *it_cdr;
    struct cdr_object *new_cdr;
 
    ao2_lock(cdr);
 
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        it_cdr->lastevent = *event_time;
 
        if (it_cdr->fn_table->process_parking_bridge_enter) {
            res &= it_cdr->fn_table->process_parking_bridge_enter(it_cdr, bridge, channel);
        }
        if (it_cdr->fn_table->process_party_a) {
            CDR_DEBUG("%p - Updating Party A %s snapshot\n", it_cdr,
                channel->base->name);
            it_cdr->fn_table->process_party_a(it_cdr, channel);
        }
    }
 
    if (res) {
        /* No one handled it - we need a new one! */
        new_cdr = cdr_object_create_and_append(cdr, event_time);
        if (new_cdr) {
            /* Let the single state transition us to Parked */
            cdr_object_transition_state(new_cdr, &single_state_fn_table);
            new_cdr->fn_table->process_parking_bridge_enter(new_cdr, bridge, channel);
        }
    }
    ao2_unlock(cdr);
}

References ao2_lock, ao2_unlock, ast_channel_snapshot::base, cdr_object::bridge, CDR_DEBUG, cdr_object_create_and_append(), cdr_object_transition_state(), ast_channel_snapshot_base::name, cdr_object::next, single_state_fn_table, and cdr_object::start.

Referenced by handle_bridge_enter_message().

◆ handle_standard_bridge_enter_message()

static void handle_standard_bridge_enter_message	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel,
		const struct timeval *	event_time
	)

static

Handle a bridge enter message for a 'normal' bridge.

Parameters

cdr	The CDR to operate on
bridge	The bridge the channel just entered
channel	The channel snapshot
event_time

Definition at line 2768 of file cdr.c.

{
    enum process_bridge_enter_results result;
    struct cdr_object *it_cdr;
    struct cdr_object *new_cdr;
    struct cdr_object *handled_cdr = NULL;
 
    ao2_lock(cdr);
 
try_again:
    for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
        it_cdr->lastevent = *event_time;
 
        if (it_cdr->fn_table->process_party_a) {
            CDR_DEBUG("%p - Updating Party A %s snapshot\n", it_cdr,
                channel->base->name);
            it_cdr->fn_table->process_party_a(it_cdr, channel);
        }
 
        /* Notify all states that they have entered a bridge */
        if (it_cdr->fn_table->process_bridge_enter) {
            CDR_DEBUG("%p - Processing bridge enter for %s\n", it_cdr,
                channel->base->name);
            result = it_cdr->fn_table->process_bridge_enter(it_cdr, bridge, channel);
            switch (result) {
            case BRIDGE_ENTER_ONLY_PARTY:
                /* Fall through */
            case BRIDGE_ENTER_OBTAINED_PARTY_B:
                if (!handled_cdr) {
                    handled_cdr = it_cdr;
                }
                break;
            case BRIDGE_ENTER_NEED_CDR:
                /* Pass */
                break;
            case BRIDGE_ENTER_NO_PARTY_B:
                /* We didn't win on any - end this CDR. If someone else comes in later
                 * that is Party B to this CDR, it can re-activate this CDR.
                 */
                if (!handled_cdr) {
                    handled_cdr = it_cdr;
                }
                cdr_object_finalize(cdr);
                break;
            }
        }
    }
 
    /* Create the new matchings, but only for either:
     *  * The first CDR in the chain that handled it. This avoids issues with
     *    forked CDRs.
     *  * If no one handled it, the last CDR in the chain. This would occur if
     *    a CDR joined a bridge and it wasn't Party A for anyone. We still need
     *    to make pairings with everyone in the bridge.
     */
    if (handled_cdr) {
        handle_bridge_pairings(handled_cdr, bridge);
    } else {
        /* Nothing handled it - we need a new one! */
        new_cdr = cdr_object_create_and_append(cdr, event_time);
        if (new_cdr) {
            /* This is guaranteed to succeed: the new CDR is created in the single state
             * and will be able to handle the bridge enter message
             */
            goto try_again;
        }
    }
    ao2_unlock(cdr);
}

References ao2_lock, ao2_unlock, ast_channel_snapshot::base, cdr_object::bridge, BRIDGE_ENTER_NEED_CDR, BRIDGE_ENTER_NO_PARTY_B, BRIDGE_ENTER_OBTAINED_PARTY_B, BRIDGE_ENTER_ONLY_PARTY, CDR_DEBUG, cdr_object_create_and_append(), cdr_object_finalize(), handle_bridge_pairings(), ast_channel_snapshot_base::name, cdr_object::next, NULL, result, and cdr_object::start.

Referenced by handle_bridge_enter_message().

◆ init_batch()

static int init_batch ( void )

static

Note: Don't call without cdr_batch_lock

Definition at line 3891 of file cdr.c.

{
    /* This is the single meta-batch used to keep track of all CDRs during the entire life of the program */
    if (!(batch = ast_malloc(sizeof(*batch))))
        return -1;
 
    reset_batch();
 
    return 0;
}

References ast_malloc, batch, and reset_batch().

Referenced by cdr_detach().

◆ is_cdr_flag_set()

static int is_cdr_flag_set ( unsigned int cdr_flag )

static

Definition at line 1229 of file cdr.c.

{
    struct module_config *mod_cfg;
    int flag_set;
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    flag_set = mod_cfg && ast_test_flag(&mod_cfg->general->settings, cdr_flag);
    ao2_cleanup(mod_cfg);
    return flag_set;
}

References ao2_cleanup, ao2_global_obj_ref, ast_test_flag, module_config::general, and ast_cdr_config::settings.

Referenced by ast_cdr_is_enabled(), ast_cdr_serialize_variables(), base_process_party_a(), cdr_object_check_party_a_hangup(), cdr_object_get_billsec(), cdr_object_set_disposition(), check_new_cdr_needed(), dial_status_to_disposition(), finalized_state_process_party_a(), and snapshot_cep_changed().

◆ load_module()

static int load_module ( void )

static

Definition at line 4679 of file cdr.c.

{
    struct module_config *mod_cfg = NULL;
    if (process_config(0)) {
        return AST_MODULE_LOAD_FAILURE;
    }
 
    cdr_topic = stasis_topic_create("cdr:aggregator");
    if (!cdr_topic) {
        return AST_MODULE_LOAD_FAILURE;
    }
 
    stasis_router = stasis_message_router_create(cdr_topic);
    if (!stasis_router) {
        return AST_MODULE_LOAD_FAILURE;
    }
    stasis_message_router_set_congestion_limits(stasis_router, -1,
        10 * AST_TASKPROCESSOR_HIGH_WATER_LEVEL);
 
    if (STASIS_MESSAGE_TYPE_INIT(cdr_sync_message_type)) {
        return AST_MODULE_LOAD_FAILURE;
    }
 
    mod_cfg = ao2_global_obj_ref(module_configs);
 
    stasis_message_router_add(stasis_router, ast_channel_snapshot_type(), handle_channel_snapshot_update_message, NULL);
 
    /* Always process dial messages, because even if we ignore most of it, we do want the dial status for the disposition. */
    stasis_message_router_add(stasis_router, ast_channel_dial_type(), handle_dial_message, NULL);
    if (!mod_cfg || !ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_DIAL_CHANGES)) {
        dial_changes_ignored = 0;
    } else {
        dial_changes_ignored = 1;
        CDR_DEBUG("Dial messages will be mostly ignored\n");
    }
 
    /* If explicitly instructed to ignore call state changes, then ignore bridging events, parking, etc. */
    if (!mod_cfg || !ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_STATE_CHANGES)) {
        stasis_message_router_add(stasis_router, ast_channel_entered_bridge_type(), handle_bridge_enter_message, NULL);
        stasis_message_router_add(stasis_router, ast_channel_left_bridge_type(), handle_bridge_leave_message, NULL);
        stasis_message_router_add(stasis_router, ast_parked_call_type(), handle_parked_call_message, NULL);
    } else {
        CDR_DEBUG("All bridge and parking messages will be ignored\n");
    }
 
    stasis_message_router_add(stasis_router, cdr_sync_message_type(), handle_cdr_sync_message, NULL);
 
    if (mod_cfg) {
        ao2_cleanup(mod_cfg);
    } else {
        ast_log(LOG_WARNING, "Unable to obtain CDR configuration during module load?\n");
    }
 
    active_cdrs_master = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        AST_NUM_CHANNEL_BUCKETS, cdr_master_hash_fn, NULL, cdr_master_cmp_fn);
    if (!active_cdrs_master) {
        return AST_MODULE_LOAD_FAILURE;
    }
    ao2_container_register("cdrs_master", active_cdrs_master, cdr_master_print_fn);
 
    active_cdrs_all = ao2_container_alloc_hash(AO2_ALLOC_OPT_LOCK_MUTEX, 0,
        AST_NUM_CHANNEL_BUCKETS, cdr_all_hash_fn, NULL, cdr_all_cmp_fn);
    if (!active_cdrs_all) {
        return AST_MODULE_LOAD_FAILURE;
    }
    ao2_container_register("cdrs_all", active_cdrs_all, cdr_all_print_fn);
 
    sched = ast_sched_context_create();
    if (!sched) {
        ast_log(LOG_ERROR, "Unable to create schedule context.\n");
        return AST_MODULE_LOAD_FAILURE;
    }
 
    ast_cli_register_multiple(cli_commands, ARRAY_LEN(cli_commands));
    ast_register_atexit(cdr_engine_shutdown);
 
    return cdr_toggle_runtime_options() ? AST_MODULE_LOAD_FAILURE : AST_MODULE_LOAD_SUCCESS;
}

References active_cdrs_all, active_cdrs_master, AO2_ALLOC_OPT_LOCK_MUTEX, ao2_cleanup, ao2_container_alloc_hash, ao2_container_register(), ao2_global_obj_ref, ARRAY_LEN, ast_channel_dial_type(), ast_channel_entered_bridge_type(), ast_channel_left_bridge_type(), ast_channel_snapshot_type(), ast_cli_register_multiple, ast_log, AST_MODULE_LOAD_FAILURE, AST_MODULE_LOAD_SUCCESS, AST_NUM_CHANNEL_BUCKETS, ast_parked_call_type(), ast_register_atexit(), ast_sched_context_create(), AST_TASKPROCESSOR_HIGH_WATER_LEVEL, ast_test_flag, cdr_all_cmp_fn(), cdr_all_hash_fn(), cdr_all_print_fn(), CDR_DEBUG, cdr_engine_shutdown(), CDR_IGNORE_DIAL_CHANGES, CDR_IGNORE_STATE_CHANGES, cdr_master_cmp_fn(), cdr_master_hash_fn(), cdr_master_print_fn(), cdr_toggle_runtime_options(), cdr_topic, cli_commands, dial_changes_ignored, module_config::general, handle_bridge_enter_message(), handle_bridge_leave_message(), handle_cdr_sync_message(), handle_channel_snapshot_update_message(), handle_dial_message(), handle_parked_call_message(), LOG_ERROR, LOG_WARNING, NULL, process_config(), ast_cdr_config::settings, stasis_message_router_add(), stasis_message_router_create, stasis_message_router_set_congestion_limits(), STASIS_MESSAGE_TYPE_INIT, stasis_router, and stasis_topic_create().

◆ module_config_alloc()

static void * module_config_alloc ( void )

static

Create a new module config object.

Definition at line 404 of file cdr.c.

{
    struct module_config *mod_cfg;
    struct ast_cdr_config *cdr_config;
 
    mod_cfg = ao2_alloc(sizeof(*mod_cfg), module_config_destructor);
    if (!mod_cfg) {
        return NULL;
    }
 
    cdr_config = ao2_alloc(sizeof(*cdr_config), NULL);
    if (!cdr_config) {
        ao2_ref(cdr_config, -1);
        return NULL;
    }
    mod_cfg->general = cdr_config;
 
    return mod_cfg;
}

References ao2_alloc, ao2_ref, cdr_config, module_config::general, module_config_destructor(), and NULL.

Referenced by process_config().

◆ module_config_destructor()

static void module_config_destructor ( void * obj )

static

Dispose of a module config object.

Definition at line 393 of file cdr.c.

{
    struct module_config *cfg = obj;
 
    if (!cfg) {
        return;
    }
    ao2_ref(cfg->general, -1);
}

References ao2_ref, and module_config::general.

Referenced by module_config_alloc().

◆ module_config_post_apply()

static void module_config_post_apply ( void )

static

Definition at line 380 of file cdr.c.

{
    struct module_config *mod_cfg;
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        return;
    }
    cdr_set_debug_mode(mod_cfg);
    ao2_cleanup(mod_cfg);
}

References ao2_cleanup, ao2_global_obj_ref, and cdr_set_debug_mode.

◆ parked_state_process_bridge_leave()

static int parked_state_process_bridge_leave	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 2142 of file cdr.c.

{
    if (strcasecmp(cdr->party_a.snapshot->base->name, channel->base->name)) {
        return 1;
    }
    cdr_object_transition_state(cdr, &finalized_state_fn_table);
 
    return 0;
}

References ast_channel_snapshot::base, cdr_object_transition_state(), finalized_state_fn_table, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object_snapshot::snapshot, and cdr_object::start.

◆ post_cdr()

static void post_cdr ( struct ast_cdr * cdr )

static

Definition at line 3661 of file cdr.c.

{
    struct module_config *mod_cfg;
    struct cdr_beitem *i;
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        return;
    }
 
    for (; cdr ; cdr = cdr->next) {
        /* For people, who don't want to see unanswered single-channel events */
        if (!ast_test_flag(&mod_cfg->general->settings, CDR_UNANSWERED) &&
                cdr->disposition < AST_CDR_ANSWERED &&
                (ast_strlen_zero(cdr->channel) || ast_strlen_zero(cdr->dstchannel))) {
            ast_debug(1, "Skipping CDR for %s since we weren't answered\n", cdr->channel);
            continue;
        }
 
        /* Modify CDR's */
        AST_RWLIST_RDLOCK(&mo_list);
        AST_RWLIST_TRAVERSE(&mo_list, i, list) {
            i->be(cdr);
        }
        AST_RWLIST_UNLOCK(&mo_list);
 
        if (ast_test_flag(cdr, AST_CDR_FLAG_DISABLE)) {
            continue;
        }
        AST_RWLIST_RDLOCK(&be_list);
        AST_RWLIST_TRAVERSE(&be_list, i, list) {
            if (!i->suspended) {
                i->be(cdr);
            }
        }
        AST_RWLIST_UNLOCK(&be_list);
    }
    ao2_cleanup(mod_cfg);
}

References ao2_cleanup, ao2_global_obj_ref, AST_CDR_ANSWERED, AST_CDR_FLAG_DISABLE, ast_debug, AST_RWLIST_RDLOCK, AST_RWLIST_TRAVERSE, AST_RWLIST_UNLOCK, ast_strlen_zero(), ast_test_flag, cdr_beitem::be, CDR_UNANSWERED, ast_cdr::channel, ast_cdr::disposition, ast_cdr::dstchannel, module_config::general, cdr_beitem::list, ast_cdr::next, ast_cdr_config::settings, and cdr_beitem::suspended.

Referenced by cdr_detach(), and do_batch_backend_process().

◆ process_config()

static int process_config ( int reload )

static

Definition at line 4497 of file cdr.c.

{
    if (!reload) {
        if (aco_info_init(&cfg_info)) {
            return 1;
        }
 
        aco_option_register(&cfg_info, "enable", ACO_EXACT, general_options, DEFAULT_ENABLED, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_ENABLED);
        aco_option_register(&cfg_info, "debug", ACO_EXACT, general_options, 0, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_DEBUG);
        aco_option_register(&cfg_info, "unanswered", ACO_EXACT, general_options, DEFAULT_UNANSWERED, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_UNANSWERED);
        aco_option_register(&cfg_info, "congestion", ACO_EXACT, general_options, 0, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_CONGESTION);
        aco_option_register(&cfg_info, "batch", ACO_EXACT, general_options, DEFAULT_BATCHMODE, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_BATCHMODE);
        aco_option_register(&cfg_info, "endbeforehexten", ACO_EXACT, general_options, DEFAULT_END_BEFORE_H_EXTEN, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_END_BEFORE_H_EXTEN);
        aco_option_register(&cfg_info, "initiatedseconds", ACO_EXACT, general_options, DEFAULT_INITIATED_SECONDS, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_INITIATED_SECONDS);
        aco_option_register(&cfg_info, "scheduleronly", ACO_EXACT, general_options, DEFAULT_BATCH_SCHEDULER_ONLY, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, batch_settings.settings), BATCH_MODE_SCHEDULER_ONLY);
        aco_option_register(&cfg_info, "safeshutdown", ACO_EXACT, general_options, DEFAULT_BATCH_SAFE_SHUTDOWN, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, batch_settings.settings), BATCH_MODE_SAFE_SHUTDOWN);
        aco_option_register(&cfg_info, "size", ACO_EXACT, general_options, DEFAULT_BATCH_SIZE, OPT_UINT_T, PARSE_IN_RANGE, FLDSET(struct ast_cdr_config, batch_settings.size), 0, MAX_BATCH_SIZE);
        aco_option_register(&cfg_info, "time", ACO_EXACT, general_options, DEFAULT_BATCH_TIME, OPT_UINT_T, PARSE_IN_RANGE, FLDSET(struct ast_cdr_config, batch_settings.time), 1, MAX_BATCH_TIME);
        aco_option_register(&cfg_info, "channeldefaultenabled", ACO_EXACT, general_options, DEFAULT_CHANNEL_ENABLED, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_CHANNEL_DEFAULT_ENABLED);
        aco_option_register(&cfg_info, "ignorestatechanges", ACO_EXACT, general_options, DEFAULT_IGNORE_STATE_CHANGES, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_IGNORE_STATE_CHANGES);
        aco_option_register(&cfg_info, "ignoredialchanges", ACO_EXACT, general_options, DEFAULT_IGNORE_DIAL_CHANGES, OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_IGNORE_DIAL_CHANGES);
        aco_option_register(&cfg_info, "canceldispositionenabled", ACO_EXACT, general_options, "0", OPT_BOOLFLAG_T, 1, FLDSET(struct ast_cdr_config, settings), CDR_CANCEL_DISPOSITION_ENABLED);
    }
 
    if (aco_process_config(&cfg_info, reload) == ACO_PROCESS_ERROR) {
        struct module_config *mod_cfg;
 
        if (reload) {
            return 1;
        }
 
        /* If we couldn't process the configuration and this wasn't a reload,
         * create a default config
         */
        mod_cfg = module_config_alloc();
        if (!mod_cfg
            || aco_set_defaults(&general_option, "general", mod_cfg->general)) {
            ao2_cleanup(mod_cfg);
            return 1;
        }
        ast_log(LOG_NOTICE, "Failed to process CDR configuration; using defaults\n");
        ao2_global_obj_replace_unref(module_configs, mod_cfg);
        cdr_set_debug_mode(mod_cfg);
        ao2_cleanup(mod_cfg);
    }
 
    return 0;
}

References ACO_EXACT, aco_info_init(), aco_option_register, aco_process_config(), ACO_PROCESS_ERROR, aco_set_defaults(), ao2_cleanup, ao2_global_obj_replace_unref, ast_log, BATCH_MODE_SAFE_SHUTDOWN, BATCH_MODE_SCHEDULER_ONLY, CDR_BATCHMODE, CDR_CANCEL_DISPOSITION_ENABLED, CDR_CHANNEL_DEFAULT_ENABLED, CDR_CONGESTION, CDR_DEBUG, CDR_ENABLED, CDR_END_BEFORE_H_EXTEN, CDR_IGNORE_DIAL_CHANGES, CDR_IGNORE_STATE_CHANGES, CDR_INITIATED_SECONDS, cdr_set_debug_mode, CDR_UNANSWERED, DEFAULT_BATCH_SAFE_SHUTDOWN, DEFAULT_BATCH_SCHEDULER_ONLY, DEFAULT_BATCH_SIZE, DEFAULT_BATCH_TIME, DEFAULT_BATCHMODE, DEFAULT_CHANNEL_ENABLED, DEFAULT_ENABLED, DEFAULT_END_BEFORE_H_EXTEN, DEFAULT_IGNORE_DIAL_CHANGES, DEFAULT_IGNORE_STATE_CHANGES, DEFAULT_INITIATED_SECONDS, DEFAULT_UNANSWERED, FLDSET, module_config::general, general_option, general_options, LOG_NOTICE, MAX_BATCH_SIZE, MAX_BATCH_TIME, module_config_alloc(), OPT_BOOLFLAG_T, OPT_UINT_T, PARSE_IN_RANGE, reload(), settings, and ast_cdr_config::settings.

Referenced by load_module(), and reload_module().

◆ reload_module()

static int reload_module ( void )

static

Definition at line 4798 of file cdr.c.

{
    struct module_config *old_mod_cfg;
    struct module_config *mod_cfg;
 
    old_mod_cfg = ao2_global_obj_ref(module_configs);
 
    if (!old_mod_cfg || process_config(1)) {
        ao2_cleanup(old_mod_cfg);
        return -1;
    }
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg
        || !ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)
        || !ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
        /* If batch mode used to be enabled, finalize the batch */
        if (ast_test_flag(&old_mod_cfg->general->settings, CDR_BATCHMODE)) {
            finalize_batch_mode();
        }
    }
    ao2_cleanup(mod_cfg);
 
    ao2_cleanup(old_mod_cfg);
    return cdr_toggle_runtime_options();
}

References ao2_cleanup, ao2_global_obj_ref, ast_test_flag, CDR_BATCHMODE, CDR_ENABLED, cdr_toggle_runtime_options(), finalize_batch_mode(), module_config::general, process_config(), and ast_cdr_config::settings.

◆ reset_batch()

static void reset_batch ( void )

static

Note: Don't call without cdr_batch_lock

Definition at line 3883 of file cdr.c.

{
    batch->size = 0;
    batch->head = NULL;
    batch->tail = NULL;
}

References batch, cdr_batch::head, NULL, cdr_batch::size, and cdr_batch::tail.

Referenced by cdr_submit_batch(), and init_batch().

◆ set_variable()

static void set_variable	(	struct varshead *	headp,
		const char *	name,
		const char *	value
	)

static

Definition at line 1364 of file cdr.c.

{
    struct ast_var_t *newvariable;
 
    AST_LIST_TRAVERSE_SAFE_BEGIN(headp, newvariable, entries) {
        if (!strcasecmp(ast_var_name(newvariable), name)) {
            AST_LIST_REMOVE_CURRENT(entries);
            ast_var_delete(newvariable);
            break;
        }
    }
    AST_LIST_TRAVERSE_SAFE_END;
 
    if (value && (newvariable = ast_var_assign(name, value))) {
        AST_LIST_INSERT_HEAD(headp, newvariable, entries);
    }
}

References AST_LIST_INSERT_HEAD, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_var_assign, ast_var_delete(), ast_var_name(), ast_var_t::entries, name, and value.

Referenced by ast_cdr_setvar(), and cdr_object_update_cid().

◆ single_state_bridge_enter_comparison()

static int single_state_bridge_enter_comparison	(	struct cdr_object *	cdr,
		struct cdr_object *	cand_cdr
	)

static

Handle a comparison between our cdr_object and a cdr_object already in the bridge while in the Single state. The goal of this is to find a Party B for our CDR.

Parameters

cdr	Our cdr_object in the Single state
cand_cdr	The cdr_object already in the Bridge state

Return values

0	The cand_cdr had a Party A or Party B that we could use as our Party B
1	No party in the cand_cdr could be used as our Party B

Definition at line 1796 of file cdr.c.

{
    struct cdr_object_snapshot *party_a;
 
    /* Don't match on ourselves */
    if (!strcasecmp(cdr->party_a.snapshot->base->name, cand_cdr->party_a.snapshot->base->name)) {
        return 1;
    }
 
    /* Try the candidate CDR's Party A first */
    party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_a);
    if (!strcasecmp(party_a->snapshot->base->name, cdr->party_a.snapshot->base->name)) {
        CDR_DEBUG("%p - Party A %s has new Party B %s\n",
            cdr, cdr->party_a.snapshot->base->name, cand_cdr->party_a.snapshot->base->name);
        cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
        cdr_all_relink(cdr);
        if (!cand_cdr->party_b.snapshot) {
            /* We just stole them - finalize their CDR. Note that this won't
             * transition their state, it just sets the end time and the
             * disposition - if we need to re-activate them later, we can.
             */
            cdr_object_finalize(cand_cdr);
        }
        return 0;
    }
 
    /* Try their Party B, unless it's us */
    if (!cand_cdr->party_b.snapshot
        || !strcasecmp(cdr->party_a.snapshot->base->name, cand_cdr->party_b.snapshot->base->name)) {
        return 1;
    }
    party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_b);
    if (!strcasecmp(party_a->snapshot->base->name, cdr->party_a.snapshot->base->name)) {
        CDR_DEBUG("%p - Party A %s has new Party B %s\n",
            cdr, cdr->party_a.snapshot->base->name, cand_cdr->party_b.snapshot->base->name);
        cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_b);
        cdr_all_relink(cdr);
        return 0;
    }
 
    return 1;
}

References ast_channel_snapshot::base, cdr_all_relink(), CDR_DEBUG, cdr_object_finalize(), cdr_object_pick_party_a(), cdr_object_snapshot_copy(), ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, and cdr_object_snapshot::snapshot.

Referenced by single_state_process_bridge_enter().

◆ single_state_init_function()

static void single_state_init_function ( struct cdr_object * cdr )

static

Definition at line 1743 of file cdr.c.

{
    cdr->start = cdr->lastevent;
    cdr_object_check_party_a_answer(cdr);
}

References cdr_object_check_party_a_answer(), cdr_object::lastevent, and cdr_object::start.

◆ single_state_process_bridge_enter()

static enum process_bridge_enter_results single_state_process_bridge_enter	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 1840 of file cdr.c.

{
    struct ao2_iterator it_cdrs;
    char *channel_id;
    int success = 0;
 
    ast_string_field_set(cdr, bridge, bridge->uniqueid);
 
    if (ao2_container_count(bridge->channels) == 1) {
        /* No one in the bridge yet but us! */
        cdr_object_transition_state(cdr, &bridge_state_fn_table);
        return BRIDGE_ENTER_ONLY_PARTY;
    }
 
    for (it_cdrs = ao2_iterator_init(bridge->channels, 0);
        !success && (channel_id = ao2_iterator_next(&it_cdrs));
        ao2_ref(channel_id, -1)) {
        struct cdr_object *cand_cdr_master;
        struct cdr_object *cand_cdr;
 
        cand_cdr_master = ao2_find(active_cdrs_master, channel_id, OBJ_SEARCH_KEY);
        if (!cand_cdr_master) {
            continue;
        }
 
        ao2_lock(cand_cdr_master);
        for (cand_cdr = cand_cdr_master; cand_cdr; cand_cdr = cand_cdr->next) {
            /* Skip any records that are not in a bridge or in this bridge.
             * I'm not sure how that would happen, but it pays to be careful. */
            if (cand_cdr->fn_table != &bridge_state_fn_table ||
                    strcmp(cdr->bridge, cand_cdr->bridge)) {
                continue;
            }
 
            if (single_state_bridge_enter_comparison(cdr, cand_cdr)) {
                continue;
            }
            /* We successfully got a party B - break out */
            success = 1;
            break;
        }
        ao2_unlock(cand_cdr_master);
        ao2_cleanup(cand_cdr_master);
    }
    ao2_iterator_destroy(&it_cdrs);
 
    /* We always transition state, even if we didn't get a peer */
    cdr_object_transition_state(cdr, &bridge_state_fn_table);
 
    /* Success implies that we have a Party B */
    if (success) {
        return BRIDGE_ENTER_OBTAINED_PARTY_B;
    }
 
    return BRIDGE_ENTER_NO_PARTY_B;
}

References active_cdrs_master, ao2_cleanup, ao2_container_count(), ao2_find, ao2_iterator_destroy(), ao2_iterator_init(), ao2_iterator_next, ao2_lock, ao2_ref, ao2_unlock, ast_string_field_set, cdr_object::bridge, BRIDGE_ENTER_NO_PARTY_B, BRIDGE_ENTER_OBTAINED_PARTY_B, BRIDGE_ENTER_ONLY_PARTY, bridge_state_fn_table, cdr_object_transition_state(), ast_bridge_snapshot::channels, OBJ_SEARCH_KEY, single_state_bridge_enter_comparison(), cdr_object::start, and ast_bridge_snapshot::uniqueid.

◆ single_state_process_dial_begin()

static int single_state_process_dial_begin	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	caller,
		struct ast_channel_snapshot *	peer
	)

static

Definition at line 1757 of file cdr.c.

{
    if (caller && !strcasecmp(cdr->party_a.snapshot->base->name, caller->base->name)) {
        base_process_party_a(cdr, caller);
        CDR_DEBUG("%p - Updated Party A %s snapshot\n", cdr,
            cdr->party_a.snapshot->base->name);
        cdr_object_swap_snapshot(&cdr->party_b, peer);
        cdr_all_relink(cdr);
        CDR_DEBUG("%p - Updated Party B %s snapshot\n", cdr,
            cdr->party_b.snapshot->base->name);
 
        /* If we have two parties, lock the application that caused the
         * two parties to be associated. This prevents mid-call event
         * gosubs from perturbing the CDR application/data
         */
        ast_set_flag(&cdr->flags, AST_CDR_LOCK_APP);
    } else if (!strcasecmp(cdr->party_a.snapshot->base->name, peer->base->name)) {
        /* We're the entity being dialed, i.e., outbound origination */
        base_process_party_a(cdr, peer);
        CDR_DEBUG("%p - Updated Party A %s snapshot\n", cdr,
            cdr->party_a.snapshot->base->name);
    }
 
    cdr_object_transition_state(cdr, &dial_state_fn_table);
    return 0;
}

References AST_CDR_LOCK_APP, ast_set_flag, ast_channel_snapshot::base, base_process_party_a(), cdr_all_relink(), CDR_DEBUG, cdr_object_swap_snapshot(), cdr_object_transition_state(), dial_state_fn_table, cdr_object::flags, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and ast_cdr::start.

◆ single_state_process_parking_bridge_enter()

static int single_state_process_parking_bridge_enter	(	struct cdr_object *	cdr,
		struct ast_bridge_snapshot *	bridge,
		struct ast_channel_snapshot *	channel
	)

static

Definition at line 1897 of file cdr.c.

{
    cdr_object_transition_state(cdr, &parked_state_fn_table);
    return 0;
}

References cdr_object_transition_state(), and parked_state_fn_table.

◆ single_state_process_party_b()

static void single_state_process_party_b	(	struct cdr_object *	cdr,
		struct ast_channel_snapshot *	snapshot
	)

static

Definition at line 1749 of file cdr.c.

{
    /* This should never happen! */
    ast_assert(cdr->party_b.snapshot == NULL);
    ast_assert(0);
    return;
}

References ast_assert, NULL, cdr_object::party_b, and cdr_object_snapshot::snapshot.

◆ snapshot_cep_changed()

static int snapshot_cep_changed	(	struct ast_channel_snapshot *	old_snapshot,
		struct ast_channel_snapshot *	new_snapshot
	)

static

Return whether or not a channel has changed its state in the dialplan, subject to endbeforehexten logic.

Parameters

old_snapshot	The previous state
new_snapshot	The new state

Return values

0	if the state has not changed
1	if the state changed

Definition at line 1250 of file cdr.c.

{
    /* If we ignore hangup logic, don't indicate that we're executing anything new */
    if (ast_test_flag(&new_snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
        && is_cdr_flag_set(CDR_END_BEFORE_H_EXTEN)) {
        return 0;
    }
 
    /* When Party A is originated to an application and the application exits, the stack
     * will attempt to clear the application and restore the dummy originate application
     * of "AppDialX". Ignore application changes to AppDialX as a result.
     */
    if (strcmp(new_snapshot->dialplan->appl, old_snapshot->dialplan->appl)
        && strncasecmp(new_snapshot->dialplan->appl, "appdial", 7)
        && (strcmp(new_snapshot->dialplan->context, old_snapshot->dialplan->context)
            || strcmp(new_snapshot->dialplan->exten, old_snapshot->dialplan->exten)
            || new_snapshot->dialplan->priority != old_snapshot->dialplan->priority)) {
        return 1;
    }
 
    return 0;
}

References ast_channel_snapshot_dialplan::appl, AST_SOFTHANGUP_HANGUP_EXEC, ast_test_flag, CDR_END_BEFORE_H_EXTEN, ast_channel_snapshot_dialplan::context, ast_channel_snapshot::dialplan, ast_channel_snapshot_dialplan::exten, is_cdr_flag_set(), ast_channel_snapshot_dialplan::priority, and ast_channel_snapshot::softhangup_flags.

Referenced by check_new_cdr_needed(), and dialed_pending_state_process_party_a().

◆ snapshot_is_dialed()

static int snapshot_is_dialed ( struct ast_channel_snapshot * snapshot )

static

Return whether or not a ast_channel_snapshot is for a channel that was created as the result of a dial operation.

Return values

0	the channel was not created as the result of a dial
1	the channel was created as the result of a dial

Definition at line 1281 of file cdr.c.

{
    return (ast_test_flag(&snapshot->flags, AST_FLAG_OUTGOING)
            && !(ast_test_flag(&snapshot->flags, AST_FLAG_ORIGINATED)));
}

References AST_FLAG_ORIGINATED, AST_FLAG_OUTGOING, ast_test_flag, and ast_channel_snapshot::flags.

Referenced by cdr_object_create_public_records(), cdr_object_pick_party_a(), cli_show_channel(), and cli_show_channels().

◆ start_batch_mode()

static void start_batch_mode ( void )

static

Do not hold the batch lock while calling this function

Definition at line 3978 of file cdr.c.

{
    /* Prevent two deletes from happening at the same time */
    ast_mutex_lock(&cdr_sched_lock);
    /* this is okay since we are not being called from within the scheduler */
    AST_SCHED_DEL(sched, cdr_sched);
    /* schedule the submission to occur ASAP (1 ms) */
    cdr_sched = ast_sched_add_variable(sched, 1, submit_scheduled_batch, NULL, 1);
    ast_mutex_unlock(&cdr_sched_lock);
 
    /* signal the do_cdr thread to wakeup early and do some work (that lazy thread ;) */
    ast_mutex_lock(&cdr_pending_lock);
    ast_cond_signal(&cdr_pending_cond);
    ast_mutex_unlock(&cdr_pending_lock);
}

References ast_cond_signal, ast_mutex_lock, ast_mutex_unlock, ast_sched_add_variable(), AST_SCHED_DEL, cdr_pending_cond, cdr_pending_lock, cdr_sched, cdr_sched_lock, NULL, and submit_scheduled_batch().

Referenced by cdr_detach(), cdr_enable_batch_mode(), and handle_cli_submit().

◆ STASIS_MESSAGE_TYPE_DEFN_LOCAL()

STASIS_MESSAGE_TYPE_DEFN_LOCAL ( cdr_sync_message_type )

A message type used to synchronize with the CDR topic.

◆ submit_scheduled_batch()

static int submit_scheduled_batch ( const void * data )

static

Definition at line 3957 of file cdr.c.

{
    struct module_config *mod_cfg;
    int nextms;
 
    cdr_submit_batch(0);
 
    mod_cfg = ao2_global_obj_ref(module_configs);
    if (!mod_cfg) {
        return 0;
    }
 
    /* Calculate the next scheduled interval */
    nextms = mod_cfg->general->batch_settings.time * 1000;
 
    ao2_cleanup(mod_cfg);
 
    return nextms;
}

References ao2_cleanup, ao2_global_obj_ref, ast_cdr_config::batch_settings, cdr_submit_batch(), module_config::general, and ast_cdr_config::batch_settings::time.

Referenced by start_batch_mode().

◆ unload_module()

static int unload_module ( void )

static

Definition at line 4672 of file cdr.c.

{
    destroy_subscriptions();
 
    return 0;
}

References destroy_subscriptions().

Variable Documentation

◆ __mod_info

struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "CDR Engine" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig", }

static

Definition at line 4832 of file cdr.c.

◆ active_cdrs_all

struct ao2_container* active_cdrs_all

static

A container of all active CDRs with a Party B indexed by Party B channel name.

Definition at line 472 of file cdr.c.

Referenced by ast_cdr_setuserfield(), cdr_all_relink(), cdr_all_unlink(), cdr_engine_shutdown(), handle_bridge_leave_message(), handle_channel_snapshot_update_message(), and load_module().

◆ active_cdrs_master

struct ao2_container* active_cdrs_master

static

A container of the active master CDRs indexed by Party A channel uniqueid.

Definition at line 469 of file cdr.c.

Referenced by ast_cdr_generic_unregister(), ast_cdr_setvar(), cdr_engine_shutdown(), cdr_object_get_by_name(), cli_complete_show(), cli_show_channels(), dial_state_process_bridge_enter(), handle_bridge_enter_message(), handle_bridge_leave_message(), handle_bridge_pairings(), handle_channel_snapshot_update_message(), handle_dial_message(), handle_parked_call_message(), load_module(), and single_state_process_bridge_enter().

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 4832 of file cdr.c.

◆ batch

struct cdr_batch * batch = NULL

static

Referenced by cdr_detach(), cdr_engine_shutdown(), cdr_submit_batch(), handle_cli_status(), init_batch(), reset_batch(), sip_options_cancel_target_transactions(), sip_options_qualify_resolve_cb(), sip_options_qualify_resolve_task(), sip_options_queue_target_result(), and sip_options_target_result_task().

◆ be_list

struct be_list be_list = AST_RWLIST_HEAD_INIT_VALUE

static

◆ bridge_state_fn_table

struct cdr_object_fn_table bridge_state_fn_table

The virtual table for the Bridged state.

A cdr_object enters this state when it receives notification that the channel has entered a bridge.

A cdr_object from this state can go to:

finalized_state_fn_table

Definition at line 763 of file cdr.c.

                                                   {
    .name = "Bridged",
    .process_party_a = base_process_party_a,
    .process_party_b = bridge_state_process_party_b,
    .process_bridge_leave = bridge_state_process_bridge_leave,
    .process_parked_channel = base_process_parked_channel,
};

Referenced by bridge_candidate_add_to_cdr(), cdr_object_party_b_left_bridge_cb(), dial_state_process_bridge_enter(), and single_state_process_bridge_enter().

◆ bridge_subscription

struct stasis_forward* bridge_subscription

static

Our subscription for bridges.

Definition at line 478 of file cdr.c.

Referenced by create_subscriptions(), and destroy_subscriptions().

◆ cdr_batch_lock

ast_mutex_t cdr_batch_lock = AST_MUTEX_INIT_VALUE

static

Lock protecting modifications to the batch queue.

Definition at line 462 of file cdr.c.

Referenced by cdr_detach(), and cdr_submit_batch().

◆ cdr_debug_enabled

int cdr_debug_enabled

static

Definition at line 311 of file cdr.c.

◆ cdr_pending_cond

ast_cond_t cdr_pending_cond

static

Definition at line 466 of file cdr.c.

Referenced by cdr_enable_batch_mode(), do_cdr(), finalize_batch_mode(), and start_batch_mode().

◆ cdr_pending_lock

ast_mutex_t cdr_pending_lock = AST_MUTEX_INIT_VALUE

static

These are used to wake up the CDR thread when there's work to do.

Definition at line 465 of file cdr.c.

Referenced by do_cdr(), and start_batch_mode().

◆ cdr_readonly_vars

const char* const cdr_readonly_vars[]

static

Definition at line 3296 of file cdr.c.

                                                {
    "clid",
    "src",
    "dst",
    "dcontext",
    "channel",
    "dstchannel",
    "lastapp",
    "lastdata",
    "start",
    "answer",
    "end",
    "duration",
    "billsec",
    "disposition",
    "amaflags",
    "accountcode",
    "uniqueid",
    "linkedid",
    "tenantid",
    "userfield",
    "sequence",
    NULL
};

Referenced by ast_cdr_serialize_variables(), and ast_cdr_setvar().

◆ cdr_sched

int cdr_sched = -1

static

Definition at line 457 of file cdr.c.

Referenced by handle_cli_status(), and start_batch_mode().

◆ cdr_sched_lock

ast_mutex_t cdr_sched_lock = AST_MUTEX_INIT_VALUE

static

Definition at line 458 of file cdr.c.

Referenced by start_batch_mode().

◆ cdr_thread

pthread_t cdr_thread = AST_PTHREADT_NULL

static

Definition at line 459 of file cdr.c.

Referenced by cdr_enable_batch_mode(), and finalize_batch_mode().

◆ cdr_topic

struct stasis_topic* cdr_topic

static

The parent topic for all topics we want to aggregate for CDRs.

Definition at line 487 of file cdr.c.

Referenced by cdr_engine_shutdown(), create_subscriptions(), and load_module().

◆ channel_subscription

struct stasis_forward* channel_subscription

static

Our subscription for channels.

Definition at line 481 of file cdr.c.

Referenced by create_subscriptions(), and destroy_subscriptions().

◆ cli_commands

struct ast_cli_entry cli_commands[]

static

Definition at line 4406 of file cdr.c.

                                             {
    AST_CLI_DEFINE(handle_cli_submit, "Posts all pending batched CDR data"),
    AST_CLI_DEFINE(handle_cli_status, "Display the CDR status"),
    AST_CLI_DEFINE(handle_cli_show, "Display active CDRs for channels"),
    AST_CLI_DEFINE(handle_cli_debug, "Enable debugging in the CDR engine"),
};

Referenced by cdr_engine_shutdown(), and load_module().

◆ dial_changes_ignored

int dial_changes_ignored

static

Definition at line 312 of file cdr.c.

Referenced by handle_dial_message(), and load_module().

◆ dial_state_fn_table

struct cdr_object_fn_table dial_state_fn_table

The virtual table for the Dial state.

A cdr_object that has begun a dial operation. This state is entered when the Party A for a CDR is determined to be dialing out to a Party B or when a CDR is for an originated channel (in which case the Party A information is the originated channel, and there is no Party B).

A cdr_object from this state can go in any of the following states:

Definition at line 708 of file cdr.c.

                                                 {
    .name = "Dial",
    .process_party_a = base_process_party_a,
    .process_party_b = dial_state_process_party_b,
    .process_dial_begin = dial_state_process_dial_begin,
    .process_dial_end = dial_state_process_dial_end,
    .process_bridge_enter = dial_state_process_bridge_enter,
    .process_bridge_leave = base_process_bridge_leave,
};

Referenced by dialed_pending_state_process_bridge_enter(), and single_state_process_dial_begin().

◆ dialed_pending_state_fn_table

struct cdr_object_fn_table dialed_pending_state_fn_table

The virtual table for the Dialed Pending state.

A cdr_object that has successfully finished a dial operation, but we don't know what they're going to do yet. It's theoretically possible to dial a party and then have that party not be bridged with the caller; likewise, an origination can complete and the channel go off and execute dialplan. The pending state acts as a bridge between either:

Entering a bridge
Getting a new CDR for new dialplan execution
Switching from being originated to executing dialplan

A cdr_object from this state can go in any of the following states:

Definition at line 741 of file cdr.c.

                                                           {
    .name = "DialedPending",
    .process_party_a = dialed_pending_state_process_party_a,
    .process_dial_begin = dialed_pending_state_process_dial_begin,
    .process_bridge_enter = dialed_pending_state_process_bridge_enter,
    .process_parking_bridge_enter = dialed_pending_state_process_parking_bridge_enter,
    .process_bridge_leave = base_process_bridge_leave,
    .process_parked_channel = base_process_parked_channel,
};

Referenced by dial_state_process_dial_end().

◆ finalized_state_fn_table

struct cdr_object_fn_table finalized_state_fn_table

The virtual table for the finalized state.

Once in the finalized state, the CDR is done. No modifications can be made to the CDR.

Definition at line 798 of file cdr.c.

                                                      {
    .name = "Finalized",
    .init_function = finalized_state_init_function,
    .process_party_a = finalized_state_process_party_a,
    .process_bridge_enter = base_process_bridge_enter,
};

Referenced by ast_cdr_clear_property(), ast_cdr_fork(), ast_cdr_set_property(), ast_cdr_setuserfield(), ast_cdr_setvar(), bridge_state_process_bridge_leave(), bridge_state_process_party_b(), cdr_object_check_party_a_hangup(), cdr_object_dispatch_all_cb(), cdr_object_update_party_b_userfield_cb(), dial_state_process_dial_end(), dial_state_process_party_b(), dialed_pending_state_process_dial_begin(), dialed_pending_state_process_party_a(), and parked_state_process_bridge_leave().

◆ general_option

struct aco_type general_option

static

The type definition for general options.

Definition at line 334 of file cdr.c.

                                        {
    .type = ACO_GLOBAL,
    .name = "general",
    .item_offset = offsetof(struct module_config, general),
    .category = "general",
    .category_match = ACO_WHITELIST_EXACT,
};

Referenced by process_config().

◆ general_options

struct aco_type* general_options[] = ACO_TYPES(&general_option)

static

Definition at line 378 of file cdr.c.

Referenced by process_config().

◆ global_cdr_sequence

int global_cdr_sequence = 0

static

The global sequence counter used for CDRs.

Definition at line 453 of file cdr.c.

Referenced by cdr_object_alloc().

◆ ignore_categories

const char* ignore_categories[]

static

Config sections used by existing modules. Do not add to this list.

Definition at line 343 of file cdr.c.

                                         {
    "csv",
    "custom",
    "manager",
    "odbc",
    "pgsql",
    "radius",
    "sqlite",
    "tds",
    "mysql",
    NULL,
};

◆ ignore_option

struct aco_type ignore_option

static

Definition at line 356 of file cdr.c.

                                       {
    .type = ACO_IGNORE,
    .name = "modules",
    .category = (const char*)ignore_categories,
    .category_match = ACO_WHITELIST_ARRAY,
};

◆ mo_list

struct mo_list mo_list = AST_RWLIST_HEAD_INIT_VALUE

static

◆ module_file_conf

struct aco_file module_file_conf

static

Initial value:

= {
    .filename = "cdr.conf",
    .types = ACO_TYPES(&general_option, &ignore_option),
}

The file definition.

Definition at line 368 of file cdr.c.

                                          {
    .filename = "cdr.conf",
    .types = ACO_TYPES(&general_option, &ignore_option),
};

◆ parked_state_fn_table

struct cdr_object_fn_table parked_state_fn_table

The virtual table for the Parked state.

Parking is weird. Unlike typical bridges, it has to be treated somewhat uniquely - a channel in a parking bridge (which is a subclass of a holding bridge) has to be handled as if the channel went into an application. However, when the channel comes out, we need a new CDR - unlike the Single state.

Definition at line 782 of file cdr.c.

                                                   {
    .name = "Parked",
    .process_party_a = base_process_party_a,
    .process_bridge_leave = parked_state_process_bridge_leave,
    .process_parked_channel = base_process_parked_channel,
};

Referenced by dialed_pending_state_process_parking_bridge_enter(), and single_state_process_parking_bridge_enter().

◆ parking_subscription

struct stasis_forward* parking_subscription

static

Our subscription for parking.

Definition at line 484 of file cdr.c.

Referenced by create_subscriptions(), destroy_subscriptions(), and park_and_announce_app_exec().

◆ sched

struct ast_sched_context* sched

static

Scheduler items.

Definition at line 456 of file cdr.c.

◆ single_state_fn_table

struct cdr_object_fn_table single_state_fn_table

The virtual table for the Single state.

A cdr_object starts off in this state. This represents a channel that has no Party B information itself.

A cdr_object from this state can go into any of the following states:

Definition at line 677 of file cdr.c.

                                                   {
    .name = "Single",
    .init_function = single_state_init_function,
    .process_party_a = base_process_party_a,
    .process_party_b = single_state_process_party_b,
    .process_dial_begin = single_state_process_dial_begin,
    .process_dial_end = base_process_dial_end,
    .process_bridge_enter = single_state_process_bridge_enter,
    .process_parking_bridge_enter = single_state_process_parking_bridge_enter,
    .process_bridge_leave = base_process_bridge_leave,
    .process_parked_channel = base_process_parked_channel,
};

Referenced by cdr_object_alloc(), dialed_pending_state_process_party_a(), and handle_parking_bridge_enter_message().

◆ stasis_router

struct stasis_message_router* stasis_router

static

Message router for stasis messages regarding channel state.

Definition at line 475 of file cdr.c.

Referenced by ast_cdr_engine_term(), ast_cdr_message_router(), cdr_engine_shutdown(), and load_module().

Data Structures

Macros

Enumerations

Functions

Variables

Detailed Description

Macro Definition Documentation

◆ CDR_DEBUG

◆ cdr_set_debug_mode

◆ DEFAULT_BATCH_SAFE_SHUTDOWN

◆ DEFAULT_BATCH_SCHEDULER_ONLY

◆ DEFAULT_BATCH_SIZE

◆ DEFAULT_BATCH_TIME

◆ DEFAULT_BATCHMODE

◆ DEFAULT_CHANNEL_ENABLED

◆ DEFAULT_CONGESTION

◆ DEFAULT_ENABLED

◆ DEFAULT_END_BEFORE_H_EXTEN

◆ DEFAULT_IGNORE_DIAL_CHANGES

◆ DEFAULT_IGNORE_STATE_CHANGES

◆ DEFAULT_INITIATED_SECONDS

◆ DEFAULT_UNANSWERED

◆ FORMAT_STRING [1/2]

◆ FORMAT_STRING [2/2]

◆ MAX_BATCH_SIZE

◆ MAX_BATCH_TIME

◆ TITLE_STRING [1/2]

◆ TITLE_STRING [2/2]

Enumeration Type Documentation

◆ process_bridge_enter_results

Function Documentation

◆ __reg_module()

◆ __unreg_module()

◆ AO2_GLOBAL_OBJ_STATIC()

◆ ast_cdr_alloc()

◆ ast_cdr_backend_suspend()

◆ ast_cdr_backend_unsuspend()

◆ ast_cdr_clear_property()

◆ ast_cdr_disp2str()

◆ ast_cdr_dup()

◆ ast_cdr_engine_term()

◆ ast_cdr_fork()

◆ ast_cdr_format_var()

◆ ast_cdr_free()

◆ ast_cdr_generic_unregister()

◆ ast_cdr_get_config()

◆ ast_cdr_getvar()

◆ ast_cdr_is_enabled()

◆ ast_cdr_message_router()

◆ ast_cdr_modifier_register()

◆ ast_cdr_modifier_unregister()

◆ ast_cdr_register()

◆ ast_cdr_reset()

◆ ast_cdr_serialize_variables()

◆ ast_cdr_set_config()

◆ ast_cdr_set_property()

◆ ast_cdr_setuserfield()

◆ ast_cdr_setvar()

◆ ast_cdr_unregister()

◆ AST_MODULE_SELF_SYM()

◆ base_process_bridge_enter()

◆ base_process_bridge_leave()

◆ base_process_dial_end()

◆ base_process_parked_channel()

◆ base_process_party_a()

◆ bridge_candidate_add_to_cdr()

◆ bridge_candidate_process()

◆ bridge_state_process_bridge_leave()

◆ bridge_state_process_party_b()

◆ cdr_all_cmp_fn()

◆ cdr_all_hash_fn()

◆ cdr_all_print_fn()

◆ cdr_all_relink()

◆ cdr_all_unlink()

◆ cdr_detach()

◆ cdr_enable_batch_mode()

◆ cdr_engine_shutdown()

◆ cdr_format_var_internal()

◆ cdr_generic_register()

◆ cdr_get_tv()