cdr.c File Reference

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_CONGESTION   "0"
#define	DEFAULT_ENABLED   "1"
#define	DEFAULT_END_BEFORE_H_EXTEN   "1"
#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. More...
struct ast_cdr *	ast_cdr_alloc (void)
	Allocate a CDR record. More...
int	ast_cdr_backend_suspend (const char *name)
	Suspend a CDR backend temporarily. More...
int	ast_cdr_backend_unsuspend (const char *name)
	Unsuspend a CDR backend. More...
int	ast_cdr_clear_property (const char *channel_name, enum ast_cdr_options option)
	Clear a property on a CDR for a channel. More...
const char *	ast_cdr_disp2str (int disposition)
	Disposition to a string. More...
struct ast_cdr *	ast_cdr_dup (struct ast_cdr *cdr)
	Duplicate a public CDR. More...
void	ast_cdr_engine_term (void)
int	ast_cdr_fork (const char *channel_name, struct ast_flags *options)
	Fork a CDR. More...
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. More...
void	ast_cdr_free (struct ast_cdr *cdr)
	Free a CDR record. More...
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. More...
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. More...
int	ast_cdr_is_enabled (void)
	Return TRUE if CDR subsystem is enabled. More...
struct stasis_message_router *	ast_cdr_message_router (void)
	Return the message router for the CDR engine. More...
int	ast_cdr_modifier_register (const char *name, const char *desc, ast_cdrbe be)
	Register a CDR modifier. More...
int	ast_cdr_modifier_unregister (const char *name)
	Unregister a CDR modifier. More...
int	ast_cdr_register (const char *name, const char *desc, ast_cdrbe be)
	Register a CDR handling engine. More...
int	ast_cdr_reset (const char *channel_name, int keep_variables)
	Reset the detail record. More...
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. More...
void	ast_cdr_set_config (struct ast_cdr_config *config)
	Set the current CDR configuration. More...
int	ast_cdr_set_property (const char *channel_name, enum ast_cdr_options option)
	Set a property on a CDR for a channel. More...
void	ast_cdr_setuserfield (const char *channel_name, const char *userfield)
	Set CDR user field for channel (stored in CDR) More...
int	ast_cdr_setvar (const char *channel_name, const char *name, const char *value)
	Set a variable on a CDR. More...
int	ast_cdr_unregister (const char *name)
	Unregister a CDR handling engine. More...
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. More...
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 More...
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. More...
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. More...
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. More...
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. More...
static void	cdr_object_dispatch (struct cdr_object *cdr)
	Dispatch a CDR. More...
static int	cdr_object_dispatch_all_cb (void *obj, void *arg, int flags)
	This dispatches all cdr_objects. It should only be used during shutdown, so that we get billing records for everything that we can. More...
static void	cdr_object_dtor (void *obj)
	cdr_object Destructor More...
static void	cdr_object_finalize (struct cdr_object *cdr)
	Finalize a CDR. More...
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. More...
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. More...
static long	cdr_object_get_billsec (struct cdr_object *cdr)
	Compute the billsec for a cdr_object. More...
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. More...
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. More...
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. More...
static void	cdr_object_snapshot_copy (struct cdr_object_snapshot *dst, struct cdr_object_snapshot *src)
	Copy a snapshot and its details. More...
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. More...
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. More...
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. More...
static void	cdr_object_update_cid (struct cdr_object_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
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. More...
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. More...
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. More...
static char *	cli_complete_show (struct ast_cli_args *a)
	Complete user input for 'cdr show'. More...
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. More...
static int	create_subscriptions (void)
	Create the Stasis subcriptions for CDRs. More...
static void	destroy_subscriptions (void)
	Destroy the active Stasis subscriptions. More...
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. More...
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. More...
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. More...
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. More...
static void	handle_cdr_sync_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
	Handler for a synchronization message. More...
static void	handle_channel_snapshot_update_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
	Handler for channel snapshot update messages. More...
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. More...
static void	handle_parked_call_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
	Handler for when a channel is parked. More...
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. More...
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. More...
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. More...
static void	module_config_destructor (void *obj)
	Dispose of a module config object. More...
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. More...
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. More...
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. More...
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. More...
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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .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. More...
static struct ao2_container *	active_cdrs_master
	A container of the active master CDRs indexed by Party A channel uniqueid. More...
static const struct ast_module_info *	ast_module_info = &__mod_info
static struct cdr_batch *	batch = NULL
static struct be_list	be_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
struct cdr_object_fn_table	bridge_state_fn_table
	The virtual table for the Bridged state. More...
static struct stasis_forward *	bridge_subscription
	Our subscription for bridges. More...
static ast_mutex_t	cdr_batch_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	Lock protecting modifications to the batch queue. More...
static int	cdr_debug_enabled
static ast_cond_t	cdr_pending_cond
static ast_mutex_t	cdr_pending_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
	These are used to wake up the CDR thread when there's work to do. More...
static const char *const	cdr_readonly_vars []
static int	cdr_sched = -1
static ast_mutex_t	cdr_sched_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }
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. More...
static struct stasis_forward *	channel_subscription
	Our subscription for channels. More...
static struct ast_cli_entry	cli_commands []
struct cdr_object_fn_table	dial_state_fn_table
	The virtual table for the Dial state. More...
struct cdr_object_fn_table	dialed_pending_state_fn_table
	The virtual table for the Dialed Pending state. More...
struct cdr_object_fn_table	finalized_state_fn_table
	The virtual table for the finalized state. More...
static struct aco_type	general_option
	The type definition for general options. More...
static struct aco_type *	general_options [] = ACO_TYPES(&general_option)
static int	global_cdr_sequence = 0
	The global sequence counter used for CDRs. More...
static const char *	ignore_categories []
static struct aco_type	ignore_option
static struct mo_list	mo_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }
static struct aco_file	module_file_conf
	The file definition. More...
struct cdr_object_fn_table	parked_state_fn_table
	The virtual table for the Parked state. More...
static struct stasis_forward *	parking_subscription
	Our subscription for parking. More...
static struct ast_sched_context *	sched
	Scheduler items. More...
struct cdr_object_fn_table	single_state_fn_table
	The virtual table for the Single state. More...
static struct stasis_message_router *	stasis_router
	Message router for stasis messages regarding channel state. More...

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 210 of file cdr.c.

Referenced by bridge_candidate_add_to_cdr(), bridge_candidate_process(), cdr_object_alloc(), cdr_object_check_party_a_answer(), cdr_object_dispatch(), cdr_object_transition_state_init(), handle_bridge_enter_message(), handle_bridge_leave_message(), handle_channel_snapshot_update_message(), handle_cli_debug(), handle_dial_message(), handle_parked_call_message(), handle_parking_bridge_enter_message(), handle_standard_bridge_enter_message(), process_config(), single_state_bridge_enter_comparison(), and single_state_process_dial_begin().

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 203 of file cdr.c.

Referenced by ast_cdr_set_config(), handle_cli_debug(), module_config_post_apply(), and process_config().

DEFAULT_BATCH_SAFE_SHUTDOWN

#define DEFAULT_BATCH_SAFE_SHUTDOWN   "1"

Definition at line 201 of file cdr.c.

Referenced by process_config().

DEFAULT_BATCH_SCHEDULER_ONLY

#define DEFAULT_BATCH_SCHEDULER_ONLY   "0"

Definition at line 200 of file cdr.c.

Referenced by process_config().

DEFAULT_BATCH_SIZE

#define DEFAULT_BATCH_SIZE   "100"

Definition at line 196 of file cdr.c.

Referenced by process_config().

DEFAULT_BATCH_TIME

#define DEFAULT_BATCH_TIME   "300"

Definition at line 198 of file cdr.c.

Referenced by process_config().

DEFAULT_BATCHMODE

#define DEFAULT_BATCHMODE   "0"

Definition at line 190 of file cdr.c.

Referenced by process_config().

DEFAULT_CONGESTION

#define DEFAULT_CONGESTION   "0"

Definition at line 192 of file cdr.c.

DEFAULT_ENABLED

#define DEFAULT_ENABLED   "1"

Definition at line 189 of file cdr.c.

Referenced by process_config().

DEFAULT_END_BEFORE_H_EXTEN

#define DEFAULT_END_BEFORE_H_EXTEN   "1"

Definition at line 193 of file cdr.c.

Referenced by process_config().

DEFAULT_INITIATED_SECONDS

#define DEFAULT_INITIATED_SECONDS   "0"

Definition at line 194 of file cdr.c.

Referenced by process_config().

DEFAULT_UNANSWERED

#define DEFAULT_UNANSWERED   "0"

Definition at line 191 of file cdr.c.

Referenced by process_config().

FORMAT_STRING [1/2]

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

Referenced by cli_show_channel(), and cli_show_channels().

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 197 of file cdr.c.

Referenced by process_config().

MAX_BATCH_TIME

#define MAX_BATCH_TIME   86400

Definition at line 199 of file cdr.c.

Referenced by process_config().

TITLE_STRING [1/2]

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

Referenced by cli_show_channel(), and cli_show_channels().

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 391 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 4651 of file cdr.c.

__unreg_module()

static void __unreg_module ( void  )

static

Definition at line 4651 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.

Return values

a	malloc'd ast_cdr structure
NULL	on error (malloc failure)

Definition at line 3422 of file cdr.c.

References ast_calloc.

Referenced by ast_cdr_dup().

{
   struct ast_cdr *x;

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

ast_cdr_backend_suspend()

int ast_cdr_backend_suspend

(

const char *

name

)

Suspend a CDR backend temporarily.

Return values

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

Definition at line 2866 of file cdr.c.

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

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

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

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 2884 of file cdr.c.

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

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

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

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 3575 of file cdr.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_clear_flag, cdr_object_get_by_name(), cdr_object::flags, cdr_object::fn_table, and cdr_object::next.

Referenced by appcdr_callback(), AST_TEST_DEFINE(), and cdr_prop_write_callback().

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

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 3430 of file cdr.c.

References AST_CDR_ANSWERED, AST_CDR_BUSY, AST_CDR_CONGESTION, AST_CDR_FAILED, AST_CDR_NOANSWER, and AST_CDR_NULL.

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

{
   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";
   }
   return "UNKNOWN";
}

ast_cdr_dup()

struct ast_cdr* ast_cdr_dup

(

struct ast_cdr *

cdr

)

Duplicate a public CDR.

Parameters

cdr	the record to duplicate

Return values

a	malloc'd ast_cdr structure,
NULL	on error (malloc failure)

Definition at line 2998 of file cdr.c.

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

Referenced by custom_log(), load_values_config(), manager_log(), and syslog_log().

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

ast_cdr_engine_term()

void ast_cdr_engine_term

(

void

)

Submit any remaining CDRs and prepare for shutdown

Definition at line 4577 of file cdr.c.

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(), and stasis_message_router_publish_sync().

Referenced by can_safely_quit(), and finalize_batch_mode().

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

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 3637 of file cdr.c.

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(), ast_channel_snapshot::base, cdr_object::bridge, cdr_all_relink(), cdr_object_create_and_append(), cdr_object_finalize(), cdr_object_get_by_name(), cdr_object_transition_state(), context, cdr_object::context, copy_variables(), cdr_object::data, exten, cdr_object::exten, cdr_object_snapshot::flags, cdr_object::flags, cdr_object::fn_table, free_variables(), cdr_object::last, cdr_object::lastevent, lock, ast_channel_snapshot_base::name, cdr_object::next, 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(), and forkcdr_callback().

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

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 extraced, provide epoch seconds. Otherwise format as a date/time stamp

Definition at line 3050 of file cdr.c.

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, NULL, ast_cdr::peeraccount, ast_cdr::sequence, ast_cdr::src, ast_cdr::start, ast_cdr::uniqueid, and ast_cdr::userfield.

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

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

ast_cdr_free()

void ast_cdr_free

(

struct ast_cdr *

cdr

)

Free a CDR record.

Parameters

cdr	ast_cdr structure to free Returns nothing

Definition at line 3411 of file cdr.c.

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

{
   while (cdr) {
      struct ast_cdr *next = cdr->next;

      free_variables(&cdr->varshead);
      ast_free(cdr);
      cdr = next;
   }
}

ast_cdr_generic_unregister()

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

static

Definition at line 2953 of file cdr.c.

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

Referenced by ast_cdr_modifier_unregister(), and ast_cdr_unregister().

{
   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(2, "Unregistered '%s' CDR backend\n", name);
   ast_free(match);

   return 0;
}

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
The	current CDR configuration

Definition at line 2826 of file cdr.c.

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

Referenced by test_cdr_init_cb().

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

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 3324 of file cdr.c.

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(), and cdr_object::last.

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

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

ast_cdr_is_enabled()

int ast_cdr_is_enabled

(

void

)

Return TRUE if CDR subsystem is enabled.

Definition at line 2861 of file cdr.c.

References CDR_ENABLED, and is_cdr_flag_set().

Referenced by action_coresettings(), and handle_show_settings().

{
   return is_cdr_flag_set(CDR_ENABLED);
}

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
the	stasis_message_router otherwise

Definition at line 4291 of file cdr.c.

References ao2_bump, NULL, and stasis_router.

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

{
   if (!stasis_router) {
      return NULL;
   }

   ao2_bump(stasis_router);
   return stasis_router;
}

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 2948 of file cdr.c.

References cdr_generic_register().

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

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 2993 of file cdr.c.

References ast_cdr_generic_unregister().

{
   return ast_cdr_generic_unregister((struct be_list *)&mo_list, 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 2943 of file cdr.c.

References cdr_generic_register().

Referenced by load_module(), load_values_config(), my_load_module(), odbc_load_module(), and unload_module().

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

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 3598 of file cdr.c.

References cdr_object::answer, 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::end, cdr_object::lastevent, 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 appcdr_callback(), and dial_exec_full().

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

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

Return values

the	total number of serialized variables

Definition at line 3353 of file cdr.c.

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(), CDR_ENABLED, cdr_object_format_property(), cdr_object_get_by_name(), ast_var_t::entries, is_cdr_flag_set(), LOG_ERROR, cdr_object::next, cdr_object::party_a, S_OR, total, var, and cdr_object_snapshot::variables.

Referenced by handle_showchan().

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

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 2840 of file cdr.c.

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

Referenced by test_cdr_cleanup_cb().

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

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 enum 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 3548 of file cdr.c.

References ao2_cleanup, ao2_lock, ao2_unlock, ast_set_flag, cdr_object_get_by_name(), cdr_object::flags, cdr_object::fn_table, cdr_object::next, and cdr_object::party_a.

Referenced by appcdr_callback(), AST_TEST_DEFINE(), and cdr_prop_write_callback().

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

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 3477 of file cdr.c.

References 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, cdr_object::fn_table, cdr_object::next, NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, cdr_object::party_a, cdr_object_snapshot::userfield, and party_b_userfield_update::userfield.

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

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

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 3178 of file cdr.c.

References 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_object::fn_table, LOG_ERROR, 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, and cdr_object_snapshot::variables.

Referenced by AST_TEST_DEFINE(), and cdr_write_callback().

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

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 2988 of file cdr.c.

References ast_cdr_generic_unregister().

Referenced by load_module(), load_values_config(), my_unload_module(), reload(), tds_unload_module(), and unload_module().

{
   return ast_cdr_generic_unregister(&be_list, name);
}

AST_MODULE_SELF_SYM()

struct ast_module* AST_MODULE_SELF_SYM

(

void

)

Definition at line 4651 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 1611 of file cdr.c.

References BRIDGE_ENTER_NEED_CDR.

{
   /* Base process bridge enter simply indicates that we can't handle it */
   return 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 1601 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 1606 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 1617 of file cdr.c.

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, ast_parked_call_payload::parkee, ast_parked_call_payload::parkinglot, ast_parked_call_payload::parkingspace, cdr_object::party_a, cdr_object_fn_table::process_party_a, and cdr_object_snapshot::snapshot.

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

base_process_party_a()

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

static

Definition at line 1540 of file cdr.c.

References ast_channel_snapshot_dialplan::appl, cdr_object::appl, ast_assert, AST_CDR_LOCK_APP, AST_FLAG_SUBROUTINE_EXEC, ast_set_flag, AST_SOFTHANGUP_HANGUP_EXEC, ast_string_field_set, ast_strlen_zero, ast_test_flag, ast_channel_snapshot::base, CDR_END_BEFORE_H_EXTEN, cdr_object_check_party_a_answer(), cdr_object_check_party_a_hangup(), cdr_object_finalize(), cdr_object_swap_snapshot(), ast_channel_snapshot_dialplan::context, context, cdr_object::context, ast_channel_snapshot_dialplan::data, cdr_object::data, ast_channel_snapshot::dialplan, ast_channel_snapshot_dialplan::exten, exten, cdr_object::exten, ast_channel_snapshot::flags, cdr_object::flags, is_cdr_flag_set(), ast_channel_snapshot_peer::linkedid, ast_cdr::linkedid, cdr_object::linkedid, ast_channel_snapshot_base::name, cdr_object::party_a, ast_channel_snapshot::peer, cdr_object_snapshot::snapshot, and ast_channel_snapshot::softhangup_flags.

Referenced by dialed_pending_state_process_party_a(), and single_state_process_dial_begin().

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

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 2472 of file cdr.c.

References ast_string_field_set, ast_channel_snapshot::base, cdr_object::bridge, 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_a, cdr_object::party_b, and cdr_object_snapshot::snapshot.

Referenced by bridge_candidate_process().

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

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_obj being processed
cand_cdr	The cdr_object that is a candidate

Definition at line 2503 of file cdr.c.

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(), cdr_object::end, ast_channel_snapshot_base::name, cdr_object::next, cdr_object::party_a, cdr_object::party_b, and cdr_object_snapshot::snapshot.

Referenced by handle_bridge_pairings().

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

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 2015 of file cdr.c.

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

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

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 2002 of file cdr.c.

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

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

cdr_all_cmp_fn()

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

static

Definition at line 912 of file cdr.c.

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

Referenced by load_module().

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

cdr_all_hash_fn()

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

static

Definition at line 888 of file cdr.c.

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

Referenced by load_module().

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

cdr_all_print_fn()

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

static

Definition at line 4472 of file cdr.c.

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

Referenced by load_module().

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

cdr_all_relink()

static void cdr_all_relink ( struct cdr_object *  cdr )

static

Definition at line 949 of file cdr.c.

References 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, and cdr_object_snapshot::snapshot.

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

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

cdr_all_unlink()

static void cdr_all_unlink ( struct cdr_object *  cdr )

static

Definition at line 972 of file cdr.c.

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

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

cdr_detach()

static void cdr_detach ( struct ast_cdr *  cdr )

static

Definition at line 3841 of file cdr.c.

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

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

cdr_enable_batch_mode()

static void cdr_enable_batch_mode ( struct ast_cdr_config *  config )

static

Definition at line 4416 of file cdr.c.

References ast_cond_init, ast_log, ast_pthread_create_background, AST_PTHREADT_NULL, ast_cdr_config::batch_settings, cdr_pending_cond, cdr_thread, do_cdr(), LOG_ERROR, LOG_NOTICE, NULL, ast_cdr_config::batch_settings::size, start_batch_mode(), and ast_cdr_config::batch_settings::time.

Referenced by cdr_toggle_runtime_options().

{
   /* 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);
}

cdr_engine_shutdown()

static void cdr_engine_shutdown ( void  )

static

Definition at line 4385 of file cdr.c.

References aco_info_destroy(), 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(), finalize_batch_mode(), NULL, OBJ_MULTIPLE, OBJ_NODATA, OBJ_UNLINK, stasis_message_router_unsubscribe_and_join(), and STASIS_MESSAGE_TYPE_CLEANUP.

Referenced by load_module().

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

cdr_format_var_internal()

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

static

Definition at line 3018 of file cdr.c.

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

Referenced by ast_cdr_format_var().

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

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 2902 of file cdr.c.

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, LOG_WARNING, and cdr_beitem::name.

Referenced by ast_cdr_modifier_register(), and ast_cdr_register().

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

cdr_get_tv()

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

static

Definition at line 3035 of file cdr.c.

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

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

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

cdr_master_cmp_fn()

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

static

Definition at line 854 of file cdr.c.

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

Referenced by load_module().

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

cdr_master_hash_fn()

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

static

Definition at line 830 of file cdr.c.

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

Referenced by load_module().

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

cdr_master_print_fn()

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

static

Definition at line 4445 of file cdr.c.

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

Referenced by load_module().

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

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

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

Definition at line 1039 of file cdr.c.

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

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

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 1494 of file cdr.c.

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

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

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 1477 of file cdr.c.

References AST_FLAG_DEAD, AST_SOFTHANGUP_HANGUP_EXEC, ast_test_flag, CDR_END_BEFORE_H_EXTEN, cdr_object_finalize(), cdr_object_transition_state(), 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().

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

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

Definition at line 1075 of file cdr.c.

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(), context, cdr_object::context, cdr_object::data, cdr_object::disposition, exten, cdr_object::exten, cdr_object::flags, cdr_object::last, cdr_object::linkedid, cdr_object::next, NULL, cdr_object::party_a, and cdr_object_snapshot::snapshot.

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

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

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

Return values

A	chain of ast_cdr objects on success
NULL	on failure

Definition at line 1287 of file cdr.c.

References ast_channel_snapshot_base::accountcode, ast_cdr::accountcode, ast_channel_snapshot::amaflags, ast_cdr::amaflags, ast_cdr::answer, cdr_object::answer, cdr_object::appl, ast_assert, ast_callerid_merge(), ast_calloc, ast_copy_flags, ast_copy_string(), ast_debug, AST_FLAGS_ALL, ast_free, AST_LIST_INSERT_TAIL, AST_LIST_TRAVERSE, ast_strlen_zero, ast_var_assign, ast_var_name(), ast_var_value(), ast_channel_snapshot::base, ast_cdr::billsec, ast_channel_snapshot::caller, cdr_object_get_billsec(), cdr_object_get_duration(), ast_cdr::channel, ast_cdr::clid, cdr_object::context, copy_variables(), cdr_object::data, ast_cdr::dcontext, ast_cdr::disposition, cdr_object::disposition, ast_cdr::dst, ast_cdr::dstchannel, ast_cdr::duration, ast_cdr::end, cdr_object::end, ast_var_t::entries, cdr_object::exten, cdr_object::flags, ast_cdr::lastapp, ast_cdr::lastdata, ast_cdr::linkedid, cdr_object::linkedid, ast_channel_snapshot_caller::name, ast_channel_snapshot_base::name, ast_cdr::next, cdr_object::next, NULL, ast_channel_snapshot_caller::number, cdr_object::party_a, cdr_object::party_b, ast_cdr::peeraccount, ast_cdr::sequence, cdr_object::sequence, cdr_object_snapshot::snapshot, snapshot_is_dialed(), ast_cdr::src, ast_cdr::start, cdr_object::start, ast_channel_snapshot_base::uniqueid, ast_cdr::uniqueid, ast_cdr::userfield, cdr_object_snapshot::userfield, cdr_object_snapshot::variables, and ast_cdr::varshead.

Referenced by cdr_object_dispatch().

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

      /* 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);
         }
      }
      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;
}

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 1386 of file cdr.c.

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, and cdr_object_snapshot::snapshot.

Referenced by cdr_object_dispatch_all_cb(), and handle_channel_snapshot_update_message().

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

cdr_object_dispatch_all_cb()

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

static

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

Definition at line 4260 of file cdr.c.

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

Referenced by cdr_engine_shutdown().

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

cdr_object_dtor()

static void cdr_object_dtor ( void *  obj )

static

cdr_object Destructor

Definition at line 999 of file cdr.c.

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, and cdr_object_snapshot::variables.

Referenced by cdr_object_alloc().

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

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_object'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_object

The CDR to finalize

Definition at line 1440 of file cdr.c.

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

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

cdr_object_finalize_party_b()

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

static

Definition at line 2196 of file cdr.c.

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

Referenced by handle_channel_snapshot_update_message().

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

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 3243 of file cdr.c.

References ast_channel_snapshot_base::accountcode, ast_channel_snapshot::amaflags, cdr_object::answer, ast_channel_snapshot_dialplan::appl, ast_callerid_merge(), ast_copy_string(), ast_channel_snapshot::base, ast_channel_snapshot::caller, cdr_get_tv(), cdr_object_get_billsec(), cdr_object_get_duration(), ast_channel_snapshot_dialplan::context, ast_channel_snapshot_dialplan::data, ast_channel_snapshot::dialplan, cdr_object::disposition, cdr_object::end, ast_channel_snapshot_dialplan::exten, cdr_object::linkedid, ast_channel_snapshot_caller::name, ast_channel_snapshot_base::name, NULL, ast_channel_snapshot_caller::number, cdr_object::party_a, cdr_object::party_b, cdr_object::sequence, cdr_object_snapshot::snapshot, cdr_object::start, ast_channel_snapshot_base::uniqueid, and cdr_object_snapshot::userfield.

Referenced by ast_cdr_getvar(), and ast_cdr_serialize_variables().

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

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 3226 of file cdr.c.

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

Referenced by ast_cdr_getvar().

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

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 1235 of file cdr.c.

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

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

cdr_object_get_by_name()

static struct cdr_object* cdr_object_get_by_name ( const char *  name )

static

Definition at line 3312 of file cdr.c.

References ao2_callback, ast_strdupa, ast_strlen_zero, cdr_object_get_by_name_cb(), 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().

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

cdr_object_get_by_name_cb()

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

static

Definition at line 3142 of file cdr.c.

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

Referenced by cdr_object_get_by_name().

{
   struct cdr_object *cdr = obj;
   const char *name = arg;

   if (!strcasecmp(cdr->party_a.snapshot->base->name, name)) {
      return CMP_MATCH;
   }
   return 0;
}

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 1227 of file cdr.c.

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

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

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 2361 of file cdr.c.

References ast_assert, ast_channel_snapshot::base, cdr_object::bridge, bridge_leave_data::bridge, 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().

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

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

Return values

The	snapshot that won

Definition at line 1192 of file cdr.c.

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

{
   /* 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(right, 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;
   }
}

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 3126 of file cdr.c.

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

Referenced by ast_cdr_setvar().

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

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 1402 of file cdr.c.

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

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

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 791 of file cdr.c.

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

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

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 1531 of file cdr.c.

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_update_cid(old_snapshot, new_snapshot);
   ao2_t_replace(old_snapshot->snapshot, new_snapshot, "Swap CDR shapshot");
}

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 821 of file cdr.c.

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(cdr, fn_table, 1);
}

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

Definition at line 804 of file cdr.c.

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_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);
   }
}

cdr_object_update_cid()

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

static

Definition at line 1506 of file cdr.c.

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

Referenced by cdr_object_swap_snapshot().

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

cdr_object_update_party_b()

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

static

Definition at line 2220 of file cdr.c.

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, and cdr_object_snapshot::snapshot.

Referenced by handle_channel_snapshot_update_message().

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

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 3455 of file cdr.c.

References ast_assert, ast_copy_string(), ast_channel_snapshot::base, party_b_userfield_update::channel_name, cdr_object::fn_table, sip_to_pjsip::info(), ast_channel_snapshot_base::name, cdr_object::next, cdr_object::party_b, cdr_object::party_b_name, cdr_object_snapshot::snapshot, cdr_object_snapshot::userfield, and party_b_userfield_update::userfield.

Referenced by ast_cdr_setuserfield().

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

cdr_submit_batch()

static void cdr_submit_batch ( int  shutdown )

static

Definition at line 3766 of file cdr.c.

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

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

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 4488 of file cdr.c.

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

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

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 2249 of file cdr.c.

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

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

cli_complete_show()

static char* cli_complete_show ( struct ast_cli_args *  a )

static

Complete user input for 'cdr show'.

Definition at line 3970 of file cdr.c.

References 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 ast_cli_args::word.

Referenced by handle_cli_show().

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

cli_show_channel()

static void cli_show_channel ( struct ast_cli_args *  a )

static

Definition at line 4055 of file cdr.c.

References ast_channel_snapshot_base::accountcode, cdr_object::answer, ao2_cleanup, ao2_lock, ao2_unlock, cdr_object::appl, ast_cli_args::argv, 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, cdr_object::end, ast_cli_args::fd, 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().

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

cli_show_channels()

static void cli_show_channels ( struct ast_cli_args *  a )

static

Definition at line 3991 of file cdr.c.

References 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, ast_cli_args::fd, 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().

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

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

Return values

The	number of copied variables

Definition at line 746 of file cdr.c.

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

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

create_subscriptions()

static int create_subscriptions ( void  )

static

Create the Stasis subcriptions for CDRs.

Definition at line 4314 of file cdr.c.

References ast_bridge_topic_all(), ast_channel_topic_all(), ast_parking_topic(), and stasis_forward_all().

Referenced by cdr_toggle_runtime_options().

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

destroy_subscriptions()

static void destroy_subscriptions ( void  )

static

Destroy the active Stasis subscriptions.

Definition at line 4304 of file cdr.c.

References stasis_forward_cancel().

Referenced by cdr_toggle_runtime_options(), and unload_module().

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

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 1880 of file cdr.c.

References 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, cdr_object::bridge, BRIDGE_ENTER_NO_PARTY_B, BRIDGE_ENTER_OBTAINED_PARTY_B, BRIDGE_ENTER_ONLY_PARTY, cdr_object_finalize(), cdr_object_snapshot_copy(), cdr_object_transition_state(), ast_bridge_snapshot::channels, cdr_object::fn_table, ast_channel_snapshot_base::name, cdr_object::next, OBJ_SEARCH_KEY, cdr_object::party_a, cdr_object::party_b, cdr_object_snapshot::snapshot, and ast_bridge_snapshot::uniqueid.

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

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 1816 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 1848 of file cdr.c.

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(), cdr_object::disposition, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, ast_channel_snapshot::peer, and cdr_object_snapshot::snapshot.

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

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 1802 of file cdr.c.

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

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

dial_status_end()

static int dial_status_end ( const char *  dialstatus )

static

Definition at line 2089 of file cdr.c.

Referenced by handle_dial_message().

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

dial_status_to_disposition()

static enum ast_cdr_disposition dial_status_to_disposition ( const char *  dial_status )

static

Definition at line 1828 of file cdr.c.

References AST_CDR_ANSWERED, AST_CDR_BUSY, AST_CDR_CONGESTION, AST_CDR_FAILED, AST_CDR_NOANSWER, CDR_CONGESTION, and is_cdr_flag_set().

Referenced by dial_state_process_dial_end().

{
   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") || !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;
}

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 1976 of file cdr.c.

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

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

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 1992 of file cdr.c.

References cdr_object_transition_state().

{
   cdr_object_transition_state(cdr, &finalized_state_fn_table);

   /* Ask for a new CDR */
   return 1;
}

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 1982 of file cdr.c.

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

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

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 1951 of file cdr.c.

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

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

do_batch_backend_process()

static void* do_batch_backend_process ( void *  data )

static

Definition at line 3749 of file cdr.c.

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

Referenced by cdr_submit_batch().

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

do_cdr()

static void* do_cdr ( void *  data )

static

Definition at line 3903 of file cdr.c.

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

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

filter_bridge_messages()

static int filter_bridge_messages ( struct ast_bridge_snapshot *  bridge )

static

Filter bridge messages based on bridge technology.

Definition at line 2386 of file cdr.c.

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

Referenced by handle_bridge_enter_message(), and handle_bridge_leave_message().

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

filter_channel_snapshot()

static int filter_channel_snapshot ( struct ast_channel_snapshot *  snapshot )

static

Definition at line 2064 of file cdr.c.

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

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

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 2073 of file cdr.c.

References filter_channel_snapshot().

Referenced by handle_channel_snapshot_update_message().

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

finalize_batch_mode()

static void finalize_batch_mode ( void  )

static

Definition at line 4277 of file cdr.c.

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

Referenced by cdr_engine_shutdown(), and reload_module().

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

finalized_state_init_function()

static void finalized_state_init_function ( struct cdr_object *  cdr )

static

Definition at line 2044 of file cdr.c.

References cdr_object_finalize().

{
   cdr_object_finalize(cdr);
}

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 2049 of file cdr.c.

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

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

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 777 of file cdr.c.

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

Referenced by ast_cdr_fork(), and ast_cdr_free().

{
   struct ast_var_t *vardata;

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

handle_bridge_enter_message()

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

static

Definition at line 2708 of file cdr.c.

References ao2_cleanup, ao2_find, ast_assert, ast_log, AST_LOG_WARNING, ast_channel_snapshot::base, ast_bridge_blob::bridge, CDR_DEBUG, ast_bridge_blob::channel, filter_bridge_messages(), filter_channel_snapshot(), handle_parking_bridge_enter_message(), handle_standard_bridge_enter_message(), ast_channel_snapshot_base::name, OBJ_SEARCH_KEY, stasis_message_data(), stasis_message_timestamp(), ast_bridge_snapshot::subclass, ast_channel_snapshot_base::uniqueid, and update().

Referenced by load_module().

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

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
topic	The topic this message was published for
message	The message - hopefully a bridge one!

Definition at line 2404 of file cdr.c.

References 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, ast_bridge_blob::bridge, bridge_leave_data::bridge, CDR_DEBUG, cdr_object_party_b_left_bridge_cb(), ast_bridge_blob::channel, 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, stasis_message_data(), stasis_message_timestamp(), ast_bridge_snapshot::subclass, ast_channel_snapshot_base::uniqueid, and update().

Referenced by load_module().

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

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 2561 of file cdr.c.

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

Referenced by handle_standard_bridge_enter_message().

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

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
topic	The topic this message was published for
message	A blank ao2 object

Definition at line 2820 of file cdr.c.

Referenced by load_module().

{
   return;
}

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
topic	The topic this message was published for
message	The message

Definition at line 2278 of file cdr.c.

References ao2_callback_data, ao2_cleanup, ao2_find, ao2_link, ao2_lock, ao2_unlink, ao2_unlock, ast_assert, AST_FLAG_DEAD, ast_log, AST_LOG_WARNING, ast_test_flag, ast_channel_snapshot::base, cdr_all_unlink(), 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(), ast_channel_snapshot::flags, cdr_object::fn_table, cdr_object::is_root, cdr_object::lastevent, ast_channel_snapshot_base::name, ast_channel_snapshot_update::new_snapshot, cdr_object::next, OBJ_MULTIPLE, OBJ_NODATA, OBJ_SEARCH_KEY, ast_channel_snapshot_update::old_snapshot, cdr_object_fn_table::process_party_a, stasis_message_data(), stasis_message_timestamp(), ast_channel_snapshot_base::uniqueid, and update().

Referenced by load_module().

{
   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) {
      cdr = cdr_object_alloc(update->new_snapshot, stasis_message_timestamp(message));
      if (!cdr) {
         return;
      }
      cdr->is_root = 1;
      ao2_link(active_cdrs_master, cdr);
   } 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);
}

handle_cli_debug()

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

static

Definition at line 3929 of file cdr.c.

References ao2_cleanup, ao2_global_obj_ref, ast_cli_args::argc, ast_cli_args::argv, 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, ast_cli_args::fd, module_config::general, NULL, ast_cdr_config::settings, and ast_cli_entry::usage.

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

handle_cli_show()

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

static

Definition at line 4115 of file cdr.c.

References ast_cli_args::argc, 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.

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

handle_cli_status()

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

static

Definition at line 4145 of file cdr.c.

References ao2_cleanup, ao2_global_obj_ref, ast_cli_args::argc, 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_CONGESTION, CDR_ENABLED, cdr_sched, CDR_UNANSWERED, CLI_FAILURE, CLI_GENERATE, CLI_INIT, CLI_SHOWUSAGE, CLI_SUCCESS, ast_cli_entry::command, ESS, ast_cli_args::fd, module_config::general, cdr_beitem::name, NULL, ast_cdr_config::batch_settings::settings, ast_cdr_config::settings, ast_cdr_config::batch_settings::size, cdr_batch::size, ast_cdr_config::batch_settings::time, and ast_cli_entry::usage.

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

handle_cli_submit()

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

static

Definition at line 4212 of file cdr.c.

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

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

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
topic	The topic this message was published for
message	The message

Definition at line 2105 of file cdr.c.

References ao2_cleanup, ao2_find, ao2_lock, ao2_unlock, ast_assert, 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_status_end(), 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, stasis_message_data(), stasis_message_timestamp(), and ast_channel_snapshot_base::uniqueid.

Referenced by load_module().

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

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
topic	The topic this message was published for
message	The message about who got parked

Definition at line 2751 of file cdr.c.

References 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(), cdr_object::fn_table, cdr_object::lastevent, ast_channel_snapshot_base::name, cdr_object::next, OBJ_SEARCH_KEY, PARKED_CALL, ast_parked_call_payload::parkee, cdr_object_fn_table::process_parked_channel, stasis_message_data(), stasis_message_timestamp(), and ast_channel_snapshot_base::uniqueid.

Referenced by load_module().

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

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

Definition at line 2586 of file cdr.c.

References ao2_lock, ao2_unlock, ast_channel_snapshot::base, CDR_DEBUG, cdr_object_create_and_append(), cdr_object_transition_state(), cdr_object::fn_table, cdr_object::lastevent, ast_channel_snapshot_base::name, cdr_object::next, cdr_object_fn_table::process_parking_bridge_enter, and cdr_object_fn_table::process_party_a.

Referenced by handle_bridge_enter_message().

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

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

Definition at line 2627 of file cdr.c.

References ao2_lock, ao2_unlock, ast_channel_snapshot::base, 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(), cdr_object::fn_table, handle_bridge_pairings(), cdr_object::lastevent, ast_channel_snapshot_base::name, cdr_object::next, NULL, cdr_object_fn_table::process_bridge_enter, cdr_object_fn_table::process_party_a, and result.

Referenced by handle_bridge_enter_message().

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

init_batch()

static int init_batch ( void  )

static

Note

Don't call without cdr_batch_lock

Definition at line 3738 of file cdr.c.

References ast_malloc, batch, and reset_batch().

Referenced by cdr_detach().

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

is_cdr_flag_set()

static int is_cdr_flag_set ( unsigned int  cdr_flag )

static

Definition at line 1127 of file cdr.c.

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

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

load_module()

static int load_module ( void  )

static

Definition at line 4522 of file cdr.c.

References AO2_ALLOC_OPT_LOCK_MUTEX, ao2_container_alloc_hash, ao2_container_register(), 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, cdr_all_cmp_fn(), cdr_all_hash_fn(), cdr_all_print_fn(), cdr_engine_shutdown(), cdr_master_cmp_fn(), cdr_master_hash_fn(), cdr_master_print_fn(), cdr_toggle_runtime_options(), 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, NULL, process_config(), stasis_message_router_add(), stasis_message_router_create, stasis_message_router_set_congestion_limits(), STASIS_MESSAGE_TYPE_INIT, and stasis_topic_create().

Referenced by reload_module().

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

   stasis_message_router_add(stasis_router, ast_channel_snapshot_type(), handle_channel_snapshot_update_message, NULL);
   stasis_message_router_add(stasis_router, ast_channel_dial_type(), handle_dial_message, NULL);
   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);
   stasis_message_router_add(stasis_router, cdr_sync_message_type(), handle_cdr_sync_message, NULL);

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

module_config_alloc()

static void * module_config_alloc ( void  )

static

Create a new module config object.

Definition at line 300 of file cdr.c.

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

Referenced by process_config().

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

module_config_destructor()

static void module_config_destructor ( void *  obj )

static

Dispose of a module config object.

Definition at line 289 of file cdr.c.

References ao2_ref, and module_config::general.

Referenced by module_config_alloc().

{
   struct module_config *cfg = obj;

   if (!cfg) {
      return;
   }
   ao2_ref(cfg->general, -1);
}

module_config_post_apply()

static void module_config_post_apply ( void  )

static

Definition at line 276 of file cdr.c.

References ao2_cleanup, ao2_global_obj_ref, and cdr_set_debug_mode.

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

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 2032 of file cdr.c.

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

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

   return 0;
}

post_cdr()

static void post_cdr ( struct ast_cdr *  cdr )

static

Definition at line 3508 of file cdr.c.

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, ast_cdr::next, and ast_cdr_config::settings.

Referenced by cdr_detach(), and do_batch_backend_process().

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

process_config()

static int process_config ( int  reload )

static

Definition at line 4340 of file cdr.c.

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_CONGESTION, CDR_DEBUG, CDR_ENABLED, CDR_END_BEFORE_H_EXTEN, 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_ENABLED, DEFAULT_END_BEFORE_H_EXTEN, DEFAULT_INITIATED_SECONDS, DEFAULT_UNANSWERED, FLDSET, module_config::general, LOG_NOTICE, MAX_BATCH_SIZE, MAX_BATCH_TIME, module_config_alloc(), OPT_BOOLFLAG_T, OPT_UINT_T, PARSE_IN_RANGE, settings, and ast_cdr_config::settings.

Referenced by load_module(), and reload_module().

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

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

reload_module()

static int reload_module ( void  )

static

Definition at line 4617 of file cdr.c.

References ao2_cleanup, ao2_global_obj_ref, AST_MODFLAG_GLOBAL_SYMBOLS, AST_MODFLAG_LOAD_ORDER, AST_MODPRI_CORE, AST_MODULE_INFO(), AST_MODULE_SUPPORT_CORE, ast_test_flag, ASTERISK_GPL_KEY, CDR_BATCHMODE, CDR_ENABLED, cdr_toggle_runtime_options(), finalize_batch_mode(), module_config::general, load_module(), process_config(), reload(), ast_cdr_config::settings, and unload_module().

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

reset_batch()

static void reset_batch ( void  )

static

Note

Don't call without cdr_batch_lock

Definition at line 3730 of file cdr.c.

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

Referenced by cdr_submit_batch(), and init_batch().

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

set_variable()

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

static

Definition at line 1262 of file cdr.c.

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(), and ast_var_t::entries.

Referenced by ast_cdr_setvar(), and cdr_object_update_cid().

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

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 1692 of file cdr.c.

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

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

single_state_init_function()

static void single_state_init_function ( struct cdr_object *  cdr )

static

Definition at line 1639 of file cdr.c.

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

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

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 1736 of file cdr.c.

References 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, cdr_object_transition_state(), ast_bridge_snapshot::channels, cdr_object::fn_table, cdr_object::next, OBJ_SEARCH_KEY, single_state_bridge_enter_comparison(), and ast_bridge_snapshot::uniqueid.

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

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 1653 of file cdr.c.

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(), cdr_object::flags, ast_channel_snapshot_base::name, cdr_object::party_a, cdr_object::party_b, and cdr_object_snapshot::snapshot.

{
   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
       * macros/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;
}

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 1793 of file cdr.c.

References cdr_object_transition_state().

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

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 1645 of file cdr.c.

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

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

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 1148 of file cdr.c.

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

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

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 1179 of file cdr.c.

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

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

start_batch_mode()

static void start_batch_mode ( void  )

static

Do not hold the batch lock while calling this function

Definition at line 3825 of file cdr.c.

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

{
   /* 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);
}

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 3804 of file cdr.c.

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

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

unload_module()

static int unload_module ( void  )

static

Definition at line 4515 of file cdr.c.

References destroy_subscriptions().

Referenced by reload_module().

{
   destroy_subscriptions();

   return 0;
}

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 = "This paragraph is copyright (c) 2006 by Digium, Inc. \In order for your module to load, it must return this \key via a function called \"key\". Any code which \includes this paragraph must be licensed under the GNU \General Public License version 2 or later (at your \option). In addition to Digium's general reservations \of rights, Digium expressly reserves the right to \allow other parties to license this paragraph under \different terms. Any use of Digium, Inc. trademarks or \logos (including \"Asterisk\" or \"Digium\") without \express written permission of Digium, Inc. is prohibited.\n" , .buildopt_sum = "30ef0c93b36035ec78c9cfd712d36d9b" , .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 4651 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 368 of file cdr.c.

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 365 of file cdr.c.

ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info

static

Definition at line 4651 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(), and reset_batch().

be_list

struct be_list be_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

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 659 of file cdr.c.

bridge_subscription

struct stasis_forward* bridge_subscription

static

Our subscription for bridges.

Definition at line 374 of file cdr.c.

cdr_batch_lock

ast_mutex_t cdr_batch_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Lock protecting modifications to the batch queue.

Definition at line 358 of file cdr.c.

Referenced by cdr_detach(), and cdr_submit_batch().

cdr_debug_enabled

int cdr_debug_enabled

static

Definition at line 208 of file cdr.c.

cdr_pending_cond

ast_cond_t cdr_pending_cond

static

Definition at line 362 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 = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

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

Definition at line 361 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 3154 of file cdr.c.

cdr_sched

int cdr_sched = -1

static

Definition at line 353 of file cdr.c.

Referenced by handle_cli_status(), and start_batch_mode().

cdr_sched_lock

ast_mutex_t cdr_sched_lock = { PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP , NULL, {1, 0} }

static

Definition at line 354 of file cdr.c.

Referenced by start_batch_mode().

cdr_thread

pthread_t cdr_thread = AST_PTHREADT_NULL

static

Definition at line 355 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 383 of file cdr.c.

channel_subscription

struct stasis_forward* channel_subscription

static

Our subscription for channels.

Definition at line 377 of file cdr.c.

cli_commands

struct ast_cli_entry cli_commands[]

static

Definition at line 4249 of file cdr.c.

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:

• dialed_pending_state_fn_table
• bridge_state_fn_table
• finalized_state_fn_table

Definition at line 604 of file cdr.c.

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:

• single_state_fn_table
• dialed_pending_state_fn_table
• bridge_state_fn_table
• finalized_state_fn_table

Definition at line 637 of file cdr.c.

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 694 of file cdr.c.

general_option

struct aco_type general_option

static

The type definition for general options.

Definition at line 230 of file cdr.c.

general_options

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

static

Definition at line 274 of file cdr.c.

global_cdr_sequence

int global_cdr_sequence = 0

static

The global sequence counter used for CDRs.

Definition at line 349 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 239 of file cdr.c.

ignore_option

struct aco_type ignore_option

static

Definition at line 252 of file cdr.c.

mo_list

struct mo_list mo_list = { .first = NULL, .last = NULL, .lock = { PTHREAD_RWLOCK_INITIALIZER , NULL, {1, 0} } , }

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 264 of file cdr.c.

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 678 of file cdr.c.

parking_subscription

struct stasis_forward* parking_subscription

static

Our subscription for parking.

Definition at line 380 of file cdr.c.

Referenced by park_and_announce_app_exec().

sched

struct ast_sched_context* sched

static

Scheduler items.

Definition at line 352 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:

• dial_state_fn_table
• bridge_state_fn_table
• finalized_state_fn_table

Definition at line 573 of file cdr.c.

stasis_router

struct stasis_message_router* stasis_router

static

Message router for stasis messages regarding channel state.

Definition at line 371 of file cdr.c.

Referenced by ast_cdr_message_router().