Asterisk - The Open Source Telephony Project GIT-master-b023714
Loading...
Searching...
No Matches
Data Structures | Macros | Enumerations | Functions | Variables
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_CHANNEL_ENABLED   "1"
 
#define DEFAULT_CONGESTION   "0"
 
#define DEFAULT_ENABLED   "1"
 
#define DEFAULT_END_BEFORE_H_EXTEN   "1"
 
#define DEFAULT_IGNORE_DIAL_CHANGES   "0"
 
#define DEFAULT_IGNORE_STATE_CHANGES   "0"
 
#define DEFAULT_INITIATED_SECONDS   "0"
 
#define DEFAULT_UNANSWERED   "0"
 
#define FORMAT_STRING   "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"
 
#define FORMAT_STRING   "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"
 
#define MAX_BATCH_SIZE   1000
 
#define MAX_BATCH_TIME   86400
 
#define TITLE_STRING   "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"
 
#define TITLE_STRING   "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"
 

Enumerations

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

Functions

static void __reg_module (void)
 
static void __unreg_module (void)
 
static AO2_GLOBAL_OBJ_STATIC (module_configs)
 The container for the module configuration.
 
struct ast_cdrast_cdr_alloc (void)
 Allocate a CDR record.
 
int ast_cdr_backend_suspend (const char *name)
 Suspend a CDR backend temporarily.
 
int ast_cdr_backend_unsuspend (const char *name)
 Unsuspend a CDR backend.
 
int ast_cdr_clear_property (const char *channel_name, enum ast_cdr_options option)
 Clear a property on a CDR for a channel.
 
const char * ast_cdr_disp2str (int disposition)
 Disposition to a string.
 
struct ast_cdrast_cdr_dup (struct ast_cdr *cdr)
 Duplicate a public CDR.
 
void ast_cdr_engine_term (void)
 
int ast_cdr_fork (const char *channel_name, struct ast_flags *options)
 Fork a CDR.
 
void ast_cdr_format_var (struct ast_cdr *cdr, const char *name, char **ret, char *workspace, int workspacelen, int raw)
 Format a CDR variable from an already posted CDR.
 
void ast_cdr_free (struct ast_cdr *cdr)
 Free a CDR record.
 
static int ast_cdr_generic_unregister (struct be_list *generic_list, const char *name)
 
struct ast_cdr_configast_cdr_get_config (void)
 Obtain the current CDR configuration.
 
int ast_cdr_getvar (const char *channel_name, const char *name, char *value, size_t length)
 Retrieve a CDR variable from a channel's current CDR.
 
int ast_cdr_is_enabled (void)
 Return TRUE if CDR subsystem is enabled.
 
struct stasis_message_routerast_cdr_message_router (void)
 Return the message router for the CDR engine.
 
int ast_cdr_modifier_register (const char *name, const char *desc, ast_cdrbe be)
 Register a CDR modifier.
 
int ast_cdr_modifier_unregister (const char *name)
 Unregister a CDR modifier.
 
int ast_cdr_register (const char *name, const char *desc, ast_cdrbe be)
 Register a CDR handling engine.
 
int ast_cdr_reset (const char *channel_name, int keep_variables)
 Reset the detail record.
 
int ast_cdr_serialize_variables (const char *channel_name, struct ast_str **buf, char delim, char sep)
 Serializes all the data and variables for a current CDR record.
 
void ast_cdr_set_config (struct ast_cdr_config *config)
 Set the current CDR configuration.
 
int ast_cdr_set_property (const char *channel_name, enum ast_cdr_options option)
 Set a property on a CDR for a channel.
 
void ast_cdr_setuserfield (const char *channel_name, const char *userfield)
 Set CDR user field for channel (stored in CDR)
 
int ast_cdr_setvar (const char *channel_name, const char *name, const char *value)
 Set a variable on a CDR.
 
int ast_cdr_unregister (const char *name)
 Unregister a CDR handling engine.
 
struct ast_moduleAST_MODULE_SELF_SYM (void)
 
static enum process_bridge_enter_results base_process_bridge_enter (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static int base_process_bridge_leave (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static int base_process_dial_end (struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status)
 
static int base_process_parked_channel (struct cdr_object *cdr, struct ast_parked_call_payload *parking_info)
 
static int base_process_party_a (struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
 
static void bridge_candidate_add_to_cdr (struct cdr_object *cdr, struct cdr_object_snapshot *party_b)
 
static void bridge_candidate_process (struct cdr_object *cdr, struct cdr_object *base_cand_cdr)
 Process a single bridge_candidate.
 
static int bridge_state_process_bridge_leave (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static void bridge_state_process_party_b (struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
 
static int cdr_all_cmp_fn (void *obj, void *arg, int flags)
 
static int cdr_all_hash_fn (const void *obj, const int flags)
 
static void cdr_all_print_fn (void *v_obj, void *where, ao2_prnt_fn *prnt)
 
static void cdr_all_relink (struct cdr_object *cdr)
 
static void cdr_all_unlink (struct cdr_object *cdr)
 
static void cdr_detach (struct ast_cdr *cdr)
 
static void cdr_enable_batch_mode (struct ast_cdr_config *config)
 
static void cdr_engine_shutdown (void)
 
static const char * cdr_format_var_internal (struct ast_cdr *cdr, const char *name)
 
static int cdr_generic_register (struct be_list *generic_list, const char *name, const char *desc, ast_cdrbe be)
 
static void cdr_get_tv (struct timeval when, const char *fmt, char *buf, int bufsize)
 
static int cdr_master_cmp_fn (void *obj, void *arg, int flags)
 
static int cdr_master_hash_fn (const void *obj, const int flags)
 
static void cdr_master_print_fn (void *v_obj, void *where, ao2_prnt_fn *prnt)
 
static struct cdr_objectcdr_object_alloc (struct ast_channel_snapshot *chan, const struct timeval *event_time)
 cdr_object constructor
 
static void cdr_object_check_party_a_answer (struct cdr_object *cdr)
 Check to see if a CDR needs to be answered based on its Party A. Note that this is safe to call as much as you want - we won't answer twice.
 
static void cdr_object_check_party_a_hangup (struct cdr_object *cdr)
 Check to see if a CDR needs to move to the finalized state because its Party A hungup.
 
static struct cdr_objectcdr_object_create_and_append (struct cdr_object *cdr, const struct timeval *event_time)
 Create a new cdr_object and append it to an existing chain.
 
static struct ast_cdrcdr_object_create_public_records (struct cdr_object *cdr)
 Create a chain of ast_cdr objects from a chain of cdr_object suitable for consumption by the registered CDR backends.
 
static void cdr_object_dispatch (struct cdr_object *cdr)
 Dispatch a CDR.
 
static int cdr_object_dispatch_all_cb (void *obj, void *arg, int flags)
 This dispatches all cdr_object. It should only be used during shutdown, so that we get billing records for everything that we can.
 
static void cdr_object_dtor (void *obj)
 cdr_object Destructor
 
static void cdr_object_finalize (struct cdr_object *cdr)
 Finalize a CDR.
 
static int cdr_object_finalize_party_b (void *obj, void *arg, void *data, int flags)
 
static int cdr_object_format_property (struct cdr_object *cdr_obj, const char *name, char *value, size_t length)
 Format one of the standard properties on a cdr_object.
 
static void cdr_object_format_var_internal (struct cdr_object *cdr, const char *name, char *value, size_t length)
 Format a variable on a cdr_object.
 
static long cdr_object_get_billsec (struct cdr_object *cdr)
 Compute the billsec for a cdr_object.
 
static struct cdr_objectcdr_object_get_by_name (const char *name)
 
static int cdr_object_get_by_name_cb (void *obj, void *arg, int flags)
 
static long cdr_object_get_duration (struct cdr_object *cdr)
 
static int cdr_object_party_b_left_bridge_cb (void *obj, void *arg, void *data, int flags)
 Callback used to notify CDRs of a Party B leaving the bridge.
 
static struct cdr_object_snapshotcdr_object_pick_party_a (struct cdr_object_snapshot *left, struct cdr_object_snapshot *right)
 Given two CDR snapshots, figure out who should be Party A for the resulting CDR.
 
static int cdr_object_select_all_by_name_cb (void *obj, void *arg, int flags)
 
static void cdr_object_set_disposition (struct cdr_object *cdr, int hangupcause)
 Set the disposition on a cdr_object based on a hangupcause code.
 
static void cdr_object_snapshot_copy (struct cdr_object_snapshot *dst, struct cdr_object_snapshot *src)
 Copy a snapshot and its details.
 
static void cdr_object_swap_snapshot (struct cdr_object_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
 Swap an old cdr_object_snapshot's ast_channel_snapshot for a new ast_channel_snapshot.
 
static void cdr_object_transition_state (struct cdr_object *cdr, struct cdr_object_fn_table *fn_table)
 Transition a cdr_object to a new state.
 
static void cdr_object_transition_state_init (struct cdr_object *cdr, struct cdr_object_fn_table *fn_table, int do_init)
 Transition a cdr_object to a new state with initiation flag.
 
static void cdr_object_update_cid (struct cdr_object_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
 Set Caller ID information on a CDR.
 
static int cdr_object_update_party_b (void *obj, void *arg, void *data, int flags)
 
static int cdr_object_update_party_b_userfield_cb (void *obj, void *arg, void *data, int flags)
 Callback used to update the userfield on Party B on all CDRs.
 
static void cdr_submit_batch (int shutdown)
 
static int cdr_toggle_runtime_options (void)
 Checks if CDRs are enabled and enables/disables the necessary options.
 
static int check_new_cdr_needed (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
 Determine if we need to add a new CDR based on snapshots.
 
static char * cli_complete_show (struct ast_cli_args *a)
 Complete user input for 'cdr show'.
 
static void cli_show_channel (struct ast_cli_args *a)
 
static void cli_show_channels (struct ast_cli_args *a)
 
 CONFIG_INFO_CORE ("cdr", cfg_info, module_configs, module_config_alloc,.files=ACO_FILES(&module_file_conf),.post_apply_config=module_config_post_apply,)
 
static int copy_variables (struct varshead *to_list, struct varshead *from_list)
 Copy variables from one list to another.
 
static int create_subscriptions (void)
 Create the Stasis subscriptions for CDRs.
 
static void destroy_subscriptions (void)
 Destroy the active Stasis subscriptions.
 
static enum process_bridge_enter_results dial_state_process_bridge_enter (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static int dial_state_process_dial_begin (struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
 
static int dial_state_process_dial_end (struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status)
 
static void dial_state_process_party_b (struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
 
static int dial_status_end (const char *dialstatus)
 
static enum ast_cdr_disposition dial_status_to_disposition (const char *dial_status)
 
static enum process_bridge_enter_results dialed_pending_state_process_bridge_enter (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static int dialed_pending_state_process_dial_begin (struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
 
static int dialed_pending_state_process_parking_bridge_enter (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static int dialed_pending_state_process_party_a (struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
 
static void * do_batch_backend_process (void *data)
 
static void * do_cdr (void *data)
 
static int filter_bridge_messages (struct ast_bridge_snapshot *bridge)
 Filter bridge messages based on bridge technology.
 
static int filter_channel_snapshot (struct ast_channel_snapshot *snapshot)
 
static int filter_channel_snapshot_message (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
 
static void finalize_batch_mode (void)
 
static void finalized_state_init_function (struct cdr_object *cdr)
 
static int finalized_state_process_party_a (struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
 
static void free_variables (struct varshead *headp)
 Delete all variables from a variable list.
 
static void handle_bridge_enter_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 
static void handle_bridge_leave_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 Handler for when a channel leaves a bridge.
 
static void handle_bridge_pairings (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge)
 Handle creating bridge pairings for the cdr_object that just entered a bridge.
 
static void handle_cdr_sync_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 Handler for a synchronization message.
 
static void handle_channel_snapshot_update_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 Handler for channel snapshot update messages.
 
static char * handle_cli_debug (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static char * handle_cli_show (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static char * handle_cli_status (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static char * handle_cli_submit (struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
 
static void handle_dial_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 Handler for Stasis-Core dial messages.
 
static void handle_parked_call_message (void *data, struct stasis_subscription *sub, struct stasis_message *message)
 Handler for when a channel is parked.
 
static void handle_parking_bridge_enter_message (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel, const struct timeval *event_time)
 Handle entering into a parking bridge.
 
static void handle_standard_bridge_enter_message (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel, const struct timeval *event_time)
 Handle a bridge enter message for a 'normal' bridge.
 
static int init_batch (void)
 
static int is_cdr_flag_set (unsigned int cdr_flag)
 
static int load_module (void)
 
static void * module_config_alloc (void)
 Create a new module config object.
 
static void module_config_destructor (void *obj)
 Dispose of a module config object.
 
static void module_config_post_apply (void)
 
static int parked_state_process_bridge_leave (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static void post_cdr (struct ast_cdr *cdr)
 
static int process_config (int reload)
 
static int reload_module (void)
 
static void reset_batch (void)
 
static void set_variable (struct varshead *headp, const char *name, const char *value)
 
static int single_state_bridge_enter_comparison (struct cdr_object *cdr, struct cdr_object *cand_cdr)
 Handle a comparison between our cdr_object and a cdr_object already in the bridge while in the Single state. The goal of this is to find a Party B for our CDR.
 
static void single_state_init_function (struct cdr_object *cdr)
 
static enum process_bridge_enter_results single_state_process_bridge_enter (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static int single_state_process_dial_begin (struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
 
static int single_state_process_parking_bridge_enter (struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
 
static void single_state_process_party_b (struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
 
static int snapshot_cep_changed (struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
 Return whether or not a channel has changed its state in the dialplan, subject to endbeforehexten logic.
 
static int snapshot_is_dialed (struct ast_channel_snapshot *snapshot)
 Return whether or not a ast_channel_snapshot is for a channel that was created as the result of a dial operation.
 
static void start_batch_mode (void)
 
 STASIS_MESSAGE_TYPE_DEFN_LOCAL (cdr_sync_message_type)
 A message type used to synchronize with the CDR topic.
 
static int submit_scheduled_batch (const void *data)
 
static int unload_module (void)
 

Variables

static struct ast_module_info __mod_info = { .name = AST_MODULE, .flags = AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER , .description = "CDR Engine" , .key = ASTERISK_GPL_KEY , .buildopt_sum = AST_BUILDOPT_SUM, .support_level = AST_MODULE_SUPPORT_CORE, .load = load_module, .unload = unload_module, .reload = reload_module, .load_pri = AST_MODPRI_CORE, .requires = "extconfig", }
 
static struct ao2_containeractive_cdrs_all
 A container of all active CDRs with a Party B indexed by Party B channel name.
 
static struct ao2_containeractive_cdrs_master
 A container of the active master CDRs indexed by Party A channel uniqueid.
 
static const struct ast_module_infoast_module_info = &__mod_info
 
static struct cdr_batchbatch = NULL
 
static struct be_list be_list = AST_RWLIST_HEAD_INIT_VALUE
 
struct cdr_object_fn_table bridge_state_fn_table
 The virtual table for the Bridged state.
 
static struct stasis_forwardbridge_subscription
 Our subscription for bridges.
 
static ast_mutex_t cdr_batch_lock = AST_MUTEX_INIT_VALUE
 Lock protecting modifications to the batch queue.
 
static int cdr_debug_enabled
 
static ast_cond_t cdr_pending_cond
 
static ast_mutex_t cdr_pending_lock = AST_MUTEX_INIT_VALUE
 These are used to wake up the CDR thread when there's work to do.
 
static const char *const cdr_readonly_vars []
 
static int cdr_sched = -1
 
static ast_mutex_t cdr_sched_lock = AST_MUTEX_INIT_VALUE
 
static pthread_t cdr_thread = AST_PTHREADT_NULL
 
static struct stasis_topiccdr_topic
 The parent topic for all topics we want to aggregate for CDRs.
 
static struct stasis_forwardchannel_subscription
 Our subscription for channels.
 
static struct ast_cli_entry cli_commands []
 
static int dial_changes_ignored
 
struct cdr_object_fn_table dial_state_fn_table
 The virtual table for the Dial state.
 
struct cdr_object_fn_table dialed_pending_state_fn_table
 The virtual table for the Dialed Pending state.
 
struct cdr_object_fn_table finalized_state_fn_table
 The virtual table for the finalized state.
 
static struct aco_type general_option
 The type definition for general options.
 
static struct aco_typegeneral_options [] = ACO_TYPES(&general_option)
 
static int global_cdr_sequence = 0
 The global sequence counter used for CDRs.
 
static const char * ignore_categories []
 
static struct aco_type ignore_option
 
static struct mo_list mo_list = AST_RWLIST_HEAD_INIT_VALUE
 
static struct aco_file module_file_conf
 The file definition.
 
struct cdr_object_fn_table parked_state_fn_table
 The virtual table for the Parked state.
 
static struct stasis_forwardparking_subscription
 Our subscription for parking.
 
static struct ast_sched_contextsched
 Scheduler items.
 
struct cdr_object_fn_table single_state_fn_table
 The virtual table for the Single state.
 
static struct stasis_message_routerstasis_router
 Message router for stasis messages regarding channel state.
 

Detailed Description

Call Detail Record API.

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

Definition in file cdr.c.

Macro Definition Documentation

◆ CDR_DEBUG

#define CDR_DEBUG (   fmt,
  ... 
)
Value:
do { \
ast_verbose((fmt), ##__VA_ARGS__); \
} \
} while (0)
static int cdr_debug_enabled
Definition cdr.c:311

Definition at line 314 of file cdr.c.

315 { \
316 if (cdr_debug_enabled) { \
317 ast_verbose((fmt), ##__VA_ARGS__); \
318 } \
319 } while (0)

◆ cdr_set_debug_mode

#define cdr_set_debug_mode (   mod_cfg)
Value:
do { \
cdr_debug_enabled = ast_test_flag(&(mod_cfg)->general->settings, CDR_DEBUG); \
} while (0)
#define CDR_DEBUG(fmt,...)
Definition cdr.c:314
#define ast_test_flag(p, flag)
Definition utils.h:63

Definition at line 306 of file cdr.c.

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

◆ DEFAULT_BATCH_SAFE_SHUTDOWN

#define DEFAULT_BATCH_SAFE_SHUTDOWN   "1"

Definition at line 304 of file cdr.c.

◆ DEFAULT_BATCH_SCHEDULER_ONLY

#define DEFAULT_BATCH_SCHEDULER_ONLY   "0"

Definition at line 303 of file cdr.c.

◆ DEFAULT_BATCH_SIZE

#define DEFAULT_BATCH_SIZE   "100"

Definition at line 299 of file cdr.c.

◆ DEFAULT_BATCH_TIME

#define DEFAULT_BATCH_TIME   "300"

Definition at line 301 of file cdr.c.

◆ DEFAULT_BATCHMODE

#define DEFAULT_BATCHMODE   "0"

Definition at line 290 of file cdr.c.

◆ DEFAULT_CHANNEL_ENABLED

#define DEFAULT_CHANNEL_ENABLED   "1"

Definition at line 295 of file cdr.c.

◆ DEFAULT_CONGESTION

#define DEFAULT_CONGESTION   "0"

Definition at line 292 of file cdr.c.

◆ DEFAULT_ENABLED

#define DEFAULT_ENABLED   "1"

Definition at line 289 of file cdr.c.

◆ DEFAULT_END_BEFORE_H_EXTEN

#define DEFAULT_END_BEFORE_H_EXTEN   "1"

Definition at line 293 of file cdr.c.

◆ DEFAULT_IGNORE_DIAL_CHANGES

#define DEFAULT_IGNORE_DIAL_CHANGES   "0"

Definition at line 297 of file cdr.c.

◆ DEFAULT_IGNORE_STATE_CHANGES

#define DEFAULT_IGNORE_STATE_CHANGES   "0"

Definition at line 296 of file cdr.c.

◆ DEFAULT_INITIATED_SECONDS

#define DEFAULT_INITIATED_SECONDS   "0"

Definition at line 294 of file cdr.c.

◆ DEFAULT_UNANSWERED

#define DEFAULT_UNANSWERED   "0"

Definition at line 291 of file cdr.c.

◆ FORMAT_STRING [1/2]

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

◆ FORMAT_STRING [2/2]

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

◆ MAX_BATCH_SIZE

#define MAX_BATCH_SIZE   1000

Definition at line 300 of file cdr.c.

◆ MAX_BATCH_TIME

#define MAX_BATCH_TIME   86400

Definition at line 302 of file cdr.c.

◆ TITLE_STRING [1/2]

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

◆ TITLE_STRING [2/2]

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

Enumeration Type Documentation

◆ process_bridge_enter_results

Return types for process_bridge_enter functions.

Enumerator
BRIDGE_ENTER_ONLY_PARTY 

The CDR was the only party in the bridge.

BRIDGE_ENTER_OBTAINED_PARTY_B 

The CDR was able to obtain a Party B from some other party already in the bridge

BRIDGE_ENTER_NO_PARTY_B 

The CDR was not able to obtain a Party B

BRIDGE_ENTER_NEED_CDR 

This CDR can't handle a bridge enter message and a new CDR needs to be created

Definition at line 495 of file cdr.c.

495 {
496 /*!
497 * The CDR was the only party in the bridge.
498 */
500 /*!
501 * The CDR was able to obtain a Party B from some other party already in the bridge
502 */
504 /*!
505 * The CDR was not able to obtain a Party B
506 */
508 /*!
509 * This CDR can't handle a bridge enter message and a new CDR needs to be created
510 */
512};
@ BRIDGE_ENTER_ONLY_PARTY
Definition cdr.c:499
@ BRIDGE_ENTER_NO_PARTY_B
Definition cdr.c:507
@ BRIDGE_ENTER_NEED_CDR
Definition cdr.c:511
@ BRIDGE_ENTER_OBTAINED_PARTY_B
Definition cdr.c:503

Function Documentation

◆ __reg_module()

static void __reg_module ( void  )
static

Definition at line 4827 of file cdr.c.

◆ __unreg_module()

static void __unreg_module ( void  )
static

Definition at line 4827 of file cdr.c.

◆ AO2_GLOBAL_OBJ_STATIC()

static AO2_GLOBAL_OBJ_STATIC ( module_configs  )
static

The container for the module configuration.

◆ ast_cdr_alloc()

struct ast_cdr * ast_cdr_alloc ( void  )

Allocate a CDR record.

Returns
a malloc'd ast_cdr structure
Return values
NULLon error (malloc failure)

Definition at line 3568 of file cdr.c.

3569{
3570 struct ast_cdr *x;
3571
3572 x = ast_calloc(1, sizeof(*x));
3573 return x;
3574}
#define ast_calloc(num, len)
A wrapper for calloc()
Definition astmm.h:202
Responsible for call detail data.
Definition cdr.h:281

References ast_calloc.

Referenced by ast_cdr_dup().

◆ ast_cdr_backend_suspend()

int ast_cdr_backend_suspend ( const char *  name)

Suspend a CDR backend temporarily.

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

Definition at line 2999 of file cdr.c.

3000{
3001 int success = -1;
3002 struct cdr_beitem *i = NULL;
3003
3006 if (!strcasecmp(name, i->name)) {
3007 ast_debug(3, "Suspending CDR backend %s\n", i->name);
3008 i->suspended = 1;
3009 success = 0;
3010 }
3011 }
3013
3014 return success;
3015}
static const char name[]
Definition format_mp3.c:68
#define ast_debug(level,...)
Log a DEBUG message.
#define AST_RWLIST_WRLOCK(head)
Write locks a list.
Definition linkedlists.h:52
#define AST_RWLIST_UNLOCK(head)
Attempts to unlock a read/write based list.
#define AST_RWLIST_TRAVERSE
#define NULL
Definition resample.c:96
List of registered backends.
Definition cdr.c:434
Registration object for CDR backends.
Definition cdr.c:425
char name[20]
Definition cdr.c:426
struct cdr_beitem::@349 list
int suspended
Definition cdr.c:430

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

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

◆ ast_cdr_backend_unsuspend()

int ast_cdr_backend_unsuspend ( const char *  name)

Unsuspend a CDR backend.

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

Definition at line 3017 of file cdr.c.

3018{
3019 int success = -1;
3020 struct cdr_beitem *i = NULL;
3021
3024 if (!strcasecmp(name, i->name)) {
3025 ast_debug(3, "Unsuspending CDR backend %s\n", i->name);
3026 i->suspended = 0;
3027 success = 0;
3028 }
3029 }
3031
3032 return success;
3033}

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

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

◆ ast_cdr_clear_property()

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

Clear a property on a CDR for a channel.

Since
12

Clears a flag previously set by ast_cdr_set_property

Parameters
channel_nameThe CDR's channel
optionOption to clear from the CDR
Return values
0on success
1on error

Definition at line 3723 of file cdr.c.

3724{
3725 struct cdr_object *cdr;
3726 struct cdr_object *it_cdr;
3727
3728 cdr = cdr_object_get_by_name(channel_name);
3729 if (!cdr) {
3730 return -1;
3731 }
3732
3733 ao2_lock(cdr);
3734 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3735 if (it_cdr->fn_table == &finalized_state_fn_table) {
3736 continue;
3737 }
3738 ast_clear_flag(&it_cdr->flags, option);
3739 }
3740 ao2_unlock(cdr);
3741
3742 ao2_cleanup(cdr);
3743 return 0;
3744}
#define ao2_cleanup(obj)
Definition astobj2.h:1934
#define ao2_unlock(a)
Definition astobj2.h:729
#define ao2_lock(a)
Definition astobj2.h:717
struct cdr_object_fn_table finalized_state_fn_table
The virtual table for the finalized state.
Definition cdr.c:798
static struct cdr_object * cdr_object_get_by_name(const char *name)
Definition cdr.c:3458
An in-memory representation of an active CDR.
Definition cdr.c:816
struct timeval start
Definition cdr.c:822
#define ast_clear_flag(p, flag)
Definition utils.h:77

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

Referenced by AST_TEST_DEFINE(), and cdr_prop_write_callback().

◆ ast_cdr_disp2str()

const char * ast_cdr_disp2str ( int  disposition)

Disposition to a string.

Parameters
dispositioninput binary form Converts the binary form of a disposition to string form.
Returns
a pointer to the string form

Definition at line 3576 of file cdr.c.

3577{
3578 switch (disposition) {
3579 case AST_CDR_NULL:
3580 return "NO ANSWER"; /* by default, for backward compatibility */
3581 case AST_CDR_NOANSWER:
3582 return "NO ANSWER";
3583 case AST_CDR_FAILED:
3584 return "FAILED";
3585 case AST_CDR_BUSY:
3586 return "BUSY";
3587 case AST_CDR_ANSWERED:
3588 return "ANSWERED";
3589 case AST_CDR_CONGESTION:
3590 return "CONGESTION";
3591 case AST_CDR_CANCEL:
3592 return "CANCEL";
3593 }
3594 return "UNKNOWN";
3595}
@ AST_CDR_CONGESTION
Definition cdr.h:263
@ AST_CDR_NULL
Definition cdr.h:259
@ AST_CDR_NOANSWER
Definition cdr.h:258
@ AST_CDR_ANSWERED
Definition cdr.h:262
@ AST_CDR_CANCEL
Definition cdr.h:264
@ AST_CDR_BUSY
Definition cdr.h:261
@ AST_CDR_FAILED
Definition cdr.h:260

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

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

◆ ast_cdr_dup()

struct ast_cdr * ast_cdr_dup ( struct ast_cdr cdr)

Duplicate a public CDR.

Parameters
cdrthe record to duplicate
Returns
a malloc'd ast_cdr structure,
Return values
NULLon error (malloc failure)

Definition at line 3131 of file cdr.c.

3132{
3133 struct ast_cdr *newcdr;
3134
3135 if (!cdr) {
3136 return NULL;
3137 }
3139 if (!newcdr) {
3140 return NULL;
3141 }
3142
3143 *newcdr = *cdr;
3145 copy_variables(&newcdr->varshead, &cdr->varshead);
3146 newcdr->next = NULL;
3147
3148 return newcdr;
3149}
struct ast_cdr * ast_cdr_alloc(void)
Allocate a CDR record.
Definition cdr.c:3568
static int copy_variables(struct varshead *to_list, struct varshead *from_list)
Copy variables from one list to another.
Definition cdr.c:851
#define AST_LIST_HEAD_INIT_NOLOCK(head)
Initializes a list head structure.
struct varshead varshead
Definition cdr.h:332
struct timeval start
Definition cdr.h:299

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

Referenced by custom_log(), manager_log(), and write_cdr().

◆ ast_cdr_engine_term()

void ast_cdr_engine_term ( void  )

Submit any remaining CDRs and prepare for shutdown

Definition at line 4753 of file cdr.c.

4754{
4755 RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
4756
4757 /* Since this is called explicitly during process shutdown, we might not have ever
4758 * been initialized. If so, the config object will be NULL.
4759 */
4760 if (!mod_cfg) {
4761 return;
4762 }
4763
4764 if (cdr_sync_message_type()) {
4765 void *payload;
4766 struct stasis_message *message;
4767
4768 if (!stasis_router) {
4769 return;
4770 }
4771
4772 /* Make sure we have the needed items */
4773 payload = ao2_alloc(sizeof(*payload), NULL);
4774 if (!payload) {
4775 return;
4776 }
4777
4778 ast_debug(1, "CDR Engine termination request received; waiting on messages...\n");
4779
4780 message = stasis_message_create(cdr_sync_message_type(), payload);
4781 if (message) {
4783 }
4785 ao2_cleanup(payload);
4786 }
4787
4788 if (ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
4789 cdr_submit_batch(ast_test_flag(&mod_cfg->general->batch_settings.settings, BATCH_MODE_SAFE_SHUTDOWN));
4790 }
4791}
#define ao2_global_obj_ref(holder)
Get a reference to the object stored in the global holder.
Definition astobj2.h:918
#define ao2_alloc(data_size, destructor_fn)
Definition astobj2.h:409
static struct stasis_message_router * stasis_router
Message router for stasis messages regarding channel state.
Definition cdr.c:475
static void cdr_submit_batch(int shutdown)
Definition cdr.c:3914
@ CDR_BATCHMODE
Definition cdr.h:221
@ BATCH_MODE_SAFE_SHUTDOWN
Definition cdr.h:236
struct stasis_message * stasis_message_create(struct stasis_message_type *type, void *data)
Create a new message.
void stasis_message_router_publish_sync(struct stasis_message_router *router, struct stasis_message *message)
Publish a message to a message router's subscription synchronously.
The configuration settings for this module.
Definition cdr.c:326
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition utils.h:978

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

Referenced by can_safely_quit(), and finalize_batch_mode().

◆ ast_cdr_fork()

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

Fork a CDR.

Since
12
Parameters
channel_nameThe name of the channel whose CDR should be forked
optionsOptions to control how the fork occurs.
Return values
0on success
-1on failure

Definition at line 3785 of file cdr.c.

3786{
3787 RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3788 struct cdr_object *new_cdr;
3789 struct cdr_object *it_cdr;
3790 struct cdr_object *cdr_obj;
3791
3792 if (!cdr) {
3793 return -1;
3794 }
3795
3796 {
3797 SCOPED_AO2LOCK(lock, cdr);
3798 struct timeval now = ast_tvnow();
3799
3800 cdr_obj = cdr->last;
3801 if (cdr_obj->fn_table == &finalized_state_fn_table) {
3802 /* If the last CDR in the chain is finalized, don't allow a fork -
3803 * things are already dying at this point
3804 */
3805 return -1;
3806 }
3807
3808 /* Copy over the basic CDR information. The Party A information is
3809 * copied over automatically as part of the append
3810 */
3811 ast_debug(1, "Forking CDR for channel %s\n", cdr->party_a.snapshot->base->name);
3812 new_cdr = cdr_object_create_and_append(cdr, &now);
3813 if (!new_cdr) {
3814 return -1;
3815 }
3816 new_cdr->fn_table = cdr_obj->fn_table;
3817 ast_string_field_set(new_cdr, bridge, cdr->bridge);
3818 ast_string_field_set(new_cdr, appl, cdr->appl);
3819 ast_string_field_set(new_cdr, data, cdr->data);
3820 ast_string_field_set(new_cdr, context, cdr->context);
3821 ast_string_field_set(new_cdr, exten, cdr->exten);
3822 new_cdr->flags = cdr->flags;
3823 /* Explicitly clear the AST_CDR_LOCK_APP flag - we want
3824 * the application to be changed on the new CDR if the
3825 * dialplan demands it
3826 */
3828
3829 /* If there's a Party B, copy it over as well */
3830 if (cdr_obj->party_b.snapshot) {
3831 new_cdr->party_b.snapshot = cdr_obj->party_b.snapshot;
3832 ao2_ref(new_cdr->party_b.snapshot, +1);
3833 cdr_all_relink(new_cdr);
3834 strcpy(new_cdr->party_b.userfield, cdr_obj->party_b.userfield);
3835 new_cdr->party_b.flags = cdr_obj->party_b.flags;
3837 copy_variables(&new_cdr->party_b.variables, &cdr_obj->party_b.variables);
3838 }
3839 }
3840 new_cdr->start = cdr_obj->start;
3841 new_cdr->answer = cdr_obj->answer;
3842 new_cdr->lastevent = ast_tvnow();
3843
3844 /* Modify the times based on the flags passed in */
3846 && new_cdr->party_a.snapshot->state == AST_STATE_UP) {
3847 new_cdr->answer = ast_tvnow();
3848 }
3850 new_cdr->answer = ast_tvnow();
3851 new_cdr->start = ast_tvnow();
3852 }
3853
3854 /* Create and append, by default, copies over the variables */
3856 free_variables(&new_cdr->party_a.variables);
3857 }
3858
3859 /* Finalize any current CDRs */
3861 for (it_cdr = cdr; it_cdr != new_cdr; it_cdr = it_cdr->next) {
3862 if (it_cdr->fn_table == &finalized_state_fn_table) {
3863 continue;
3864 }
3865 /* Force finalization on the CDR. This will bypass any checks for
3866 * end before 'h' extension.
3867 */
3868 cdr_object_finalize(it_cdr);
3870 }
3871 }
3872 }
3873
3874 return 0;
3875}
ast_mutex_t lock
Definition app_sla.c:337
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition astobj2.h:459
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.
Definition cdr.c:1179
static void cdr_object_finalize(struct cdr_object *cdr)
Finalize a CDR.
Definition cdr.c:1544
static void cdr_all_relink(struct cdr_object *cdr)
Definition cdr.c:1053
static void free_variables(struct varshead *headp)
Delete all variables from a variable list.
Definition cdr.c:882
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.
Definition cdr.c:927
@ AST_CDR_LOCK_APP
Definition cdr.h:251
@ AST_CDR_FLAG_FINALIZE
Definition cdr.h:248
@ AST_CDR_FLAG_KEEP_VARS
Definition cdr.h:244
@ AST_CDR_FLAG_RESET
Definition cdr.h:250
@ AST_CDR_FLAG_SET_ANSWER
Definition cdr.h:249
@ AST_STATE_UP
#define SCOPED_AO2LOCK(varname, obj)
scoped lock specialization for ao2 mutexes.
Definition lock.h:611
#define ast_string_field_set(x, field, data)
Set a field to a simple string value.
enum ast_channel_state state
unsigned int flags
Definition utils.h:218
char userfield[AST_MAX_USER_FIELD]
Definition cdr.c:810
struct varshead variables
Definition cdr.c:812
struct ast_channel_snapshot * snapshot
Definition cdr.c:809
unsigned int flags
Definition cdr.c:811
struct cdr_object_fn_table * fn_table
Definition cdr.c:819
struct cdr_object * next
Definition cdr.c:840
struct timeval answer
Definition cdr.c:823
struct cdr_object_snapshot party_a
Definition cdr.c:817
struct timeval lastevent
Definition cdr.c:825
struct cdr_object * last
Definition cdr.c:841
struct ast_flags flags
Definition cdr.c:827
struct cdr_object_snapshot party_b
Definition cdr.c:818
static struct test_options options
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition time.h:159

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

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

◆ ast_cdr_format_var()

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

Format a CDR variable from an already posted CDR.

Since
12
Parameters
cdrThe dispatched CDR to process
nameThe name of the variable
retPointer to the formatted buffer
workspaceA pointer to the buffer to use to format the variable
workspacelenThe size of workspace
rawIf non-zero and a date/time is extracted, provide epoch seconds. Otherwise format as a date/time stamp

Definition at line 3183 of file cdr.c.

3184{
3185 const char *fmt = "%Y-%m-%d %T";
3186 const char *varbuf;
3187
3188 if (!cdr) {
3189 return;
3190 }
3191
3192 *ret = NULL;
3193
3194 if (!strcasecmp(name, "clid")) {
3195 ast_copy_string(workspace, cdr->clid, workspacelen);
3196 } else if (!strcasecmp(name, "src")) {
3197 ast_copy_string(workspace, cdr->src, workspacelen);
3198 } else if (!strcasecmp(name, "dst")) {
3199 ast_copy_string(workspace, cdr->dst, workspacelen);
3200 } else if (!strcasecmp(name, "dcontext")) {
3201 ast_copy_string(workspace, cdr->dcontext, workspacelen);
3202 } else if (!strcasecmp(name, "channel")) {
3203 ast_copy_string(workspace, cdr->channel, workspacelen);
3204 } else if (!strcasecmp(name, "dstchannel")) {
3205 ast_copy_string(workspace, cdr->dstchannel, workspacelen);
3206 } else if (!strcasecmp(name, "lastapp")) {
3207 ast_copy_string(workspace, cdr->lastapp, workspacelen);
3208 } else if (!strcasecmp(name, "lastdata")) {
3209 ast_copy_string(workspace, cdr->lastdata, workspacelen);
3210 } else if (!strcasecmp(name, "start")) {
3211 cdr_get_tv(cdr->start, raw ? NULL : fmt, workspace, workspacelen);
3212 } else if (!strcasecmp(name, "answer")) {
3213 cdr_get_tv(cdr->answer, raw ? NULL : fmt, workspace, workspacelen);
3214 } else if (!strcasecmp(name, "end")) {
3215 cdr_get_tv(cdr->end, raw ? NULL : fmt, workspace, workspacelen);
3216 } else if (!strcasecmp(name, "duration")) {
3217 snprintf(workspace, workspacelen, "%ld", cdr->end.tv_sec != 0 ? cdr->duration : (long)ast_tvdiff_ms(ast_tvnow(), cdr->start) / 1000);
3218 } else if (!strcasecmp(name, "billsec")) {
3219 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);
3220 } else if (!strcasecmp(name, "disposition")) {
3221 if (raw) {
3222 snprintf(workspace, workspacelen, "%ld", cdr->disposition);
3223 } else {
3224 ast_copy_string(workspace, ast_cdr_disp2str(cdr->disposition), workspacelen);
3225 }
3226 } else if (!strcasecmp(name, "amaflags")) {
3227 if (raw) {
3228 snprintf(workspace, workspacelen, "%ld", cdr->amaflags);
3229 } else {
3230 ast_copy_string(workspace, ast_channel_amaflags2string(cdr->amaflags), workspacelen);
3231 }
3232 } else if (!strcasecmp(name, "accountcode")) {
3233 ast_copy_string(workspace, cdr->accountcode, workspacelen);
3234 } else if (!strcasecmp(name, "peeraccount")) {
3235 ast_copy_string(workspace, cdr->peeraccount, workspacelen);
3236 } else if (!strcasecmp(name, "uniqueid")) {
3237 ast_copy_string(workspace, cdr->uniqueid, workspacelen);
3238 } else if (!strcasecmp(name, "linkedid")) {
3239 ast_copy_string(workspace, cdr->linkedid, workspacelen);
3240 } else if (!strcasecmp(name, "tenantid")) {
3241 ast_copy_string(workspace, cdr->tenantid, workspacelen);
3242 } else if (!strcasecmp(name, "peertenantid")) {
3243 ast_copy_string(workspace, cdr->peertenantid, workspacelen);
3244 } else if (!strcasecmp(name, "userfield")) {
3245 ast_copy_string(workspace, cdr->userfield, workspacelen);
3246 } else if (!strcasecmp(name, "sequence")) {
3247 snprintf(workspace, workspacelen, "%d", cdr->sequence);
3248 } else if ((varbuf = cdr_format_var_internal(cdr, name))) {
3249 ast_copy_string(workspace, varbuf, workspacelen);
3250 } else {
3251 workspace[0] = '\0';
3252 }
3253
3254 if (!ast_strlen_zero(workspace)) {
3255 *ret = workspace;
3256 }
3257}
static void cdr_get_tv(struct timeval when, const char *fmt, char *buf, int bufsize)
Definition cdr.c:3168
static const char * cdr_format_var_internal(struct ast_cdr *cdr, const char *name)
Definition cdr.c:3151
const char * ast_cdr_disp2str(int disposition)
Disposition to a string.
Definition cdr.c:3576
static int answer(void *data)
Definition chan_pjsip.c:687
const char * ast_channel_amaflags2string(enum ama_flags flags)
Convert the enum representation of an AMA flag to a string representation.
Definition channel.c:4342
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition strings.h:65
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition strings.h:425
char dstchannel[AST_MAX_EXTENSION]
Definition cdr.h:293
long int disposition
Definition cdr.h:309
char lastdata[AST_MAX_EXTENSION]
Definition cdr.h:297
char linkedid[AST_MAX_UNIQUEID]
Definition cdr.h:321
char userfield[AST_MAX_USER_FIELD]
Definition cdr.h:327
char peertenantid[AST_MAX_TENANT_ID]
Definition cdr.h:325
long int billsec
Definition cdr.h:307
struct timeval answer
Definition cdr.h:301
char channel[AST_MAX_EXTENSION]
Definition cdr.h:291
char peeraccount[AST_MAX_ACCOUNT_CODE]
Definition cdr.h:315
long int duration
Definition cdr.h:305
long int amaflags
Definition cdr.h:311
char src[AST_MAX_EXTENSION]
Definition cdr.h:285
char dst[AST_MAX_EXTENSION]
Definition cdr.h:287
char clid[AST_MAX_EXTENSION]
Definition cdr.h:283
char uniqueid[AST_MAX_UNIQUEID]
Definition cdr.h:319
char tenantid[AST_MAX_TENANT_ID]
Definition cdr.h:323
int sequence
Definition cdr.h:329
char accountcode[AST_MAX_ACCOUNT_CODE]
Definition cdr.h:313
char lastapp[AST_MAX_EXTENSION]
Definition cdr.h:295
char dcontext[AST_MAX_EXTENSION]
Definition cdr.h:289
struct timeval end
Definition cdr.h:303
int ast_tvzero(const struct timeval t)
Returns true if the argument is 0,0.
Definition time.h:117
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition time.h:107

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

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

◆ ast_cdr_free()

void ast_cdr_free ( struct ast_cdr cdr)

Free a CDR record.

Parameters
cdrast_cdr structure to free

Definition at line 3557 of file cdr.c.

3558{
3559 while (cdr) {
3560 struct ast_cdr *next = cdr->next;
3561
3562 free_variables(&cdr->varshead);
3563 ast_free(cdr);
3564 cdr = next;
3565 }
3566}
#define ast_free(a)
Definition astmm.h:180
struct ast_cdr * next
Definition cdr.h:334

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

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

◆ ast_cdr_generic_unregister()

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

Definition at line 3086 of file cdr.c.

3087{
3088 struct cdr_beitem *match = NULL;
3089 int active_count;
3090
3091 AST_RWLIST_WRLOCK(generic_list);
3092 AST_RWLIST_TRAVERSE(generic_list, match, list) {
3093 if (!strcasecmp(name, match->name)) {
3094 break;
3095 }
3096 }
3097
3098 if (!match) {
3099 AST_RWLIST_UNLOCK(generic_list);
3100 return 0;
3101 }
3102
3104
3105 if (!match->suspended && active_count != 0) {
3106 AST_RWLIST_UNLOCK(generic_list);
3107 ast_log(AST_LOG_WARNING, "Unable to unregister CDR backend %s; %d CDRs are still active\n",
3108 name, active_count);
3109 return -1;
3110 }
3111
3112 AST_RWLIST_REMOVE(generic_list, match, list);
3113 AST_RWLIST_UNLOCK(generic_list);
3114
3115 ast_verb(5, "Unregistered '%s' CDR backend\n", name);
3116 ast_free(match);
3117
3118 return 0;
3119}
#define ast_log
Definition astobj2.c:42
int ao2_container_count(struct ao2_container *c)
Returns the number of elements in a container.
static struct ao2_container * active_cdrs_master
A container of the active master CDRs indexed by Party A channel uniqueid.
Definition cdr.c:469
static int match(struct ast_sockaddr *addr, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
Definition chan_iax2.c:2388
#define AST_LOG_WARNING
#define ast_verb(level,...)
#define AST_RWLIST_REMOVE

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

Referenced by ast_cdr_modifier_unregister(), and ast_cdr_unregister().

◆ ast_cdr_get_config()

struct ast_cdr_config * ast_cdr_get_config ( void  )

Obtain the current CDR configuration.

Since
12

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

Return values
NULLon error
Returns
The current CDR configuration

Definition at line 2959 of file cdr.c.

2960{
2961 struct ast_cdr_config *general;
2962 struct module_config *mod_cfg;
2963
2964 mod_cfg = ao2_global_obj_ref(module_configs);
2965 if (!mod_cfg) {
2966 return NULL;
2967 }
2968 general = ao2_bump(mod_cfg->general);
2969 ao2_cleanup(mod_cfg);
2970 return general;
2971}
#define ao2_bump(obj)
Bump refcount on an AO2 object by one, returning the object.
Definition astobj2.h:480
The global options available for CDRs.
Definition cdr.h:269
struct ast_cdr_config * general
Definition cdr.c:327

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

Referenced by test_cdr_init_cb().

◆ ast_cdr_getvar()

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

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

Since
12
Parameters
channel_nameThe name of the party A channel that the CDR is associated with
nameThe name of the variable to retrieve
valueBuffer to hold the value
lengthThe size of the buffer
Return values
0on success
non-zeroon failure

Definition at line 3470 of file cdr.c.

3471{
3472 struct cdr_object *cdr;
3473 struct cdr_object *cdr_obj;
3474
3475 if (ast_strlen_zero(name)) {
3476 return 1;
3477 }
3478
3479 cdr = cdr_object_get_by_name(channel_name);
3480 if (!cdr) {
3481 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
3482 return 1;
3483 }
3484
3485 ao2_lock(cdr);
3486
3487 cdr_obj = cdr->last;
3489 /* Property failed; attempt variable */
3491 }
3492
3493 ao2_unlock(cdr);
3494
3495 ao2_cleanup(cdr);
3496 return 0;
3497}
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.
Definition cdr.c:3381
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.
Definition cdr.c:3364
#define AST_LOG_ERROR
int value
Definition syslog.c:37

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

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

◆ ast_cdr_is_enabled()

int ast_cdr_is_enabled ( void  )

Return TRUE if CDR subsystem is enabled.

Definition at line 2994 of file cdr.c.

2995{
2997}
static int is_cdr_flag_set(unsigned int cdr_flag)
Definition cdr.c:1229
@ CDR_ENABLED
Definition cdr.h:220

References CDR_ENABLED, and is_cdr_flag_set().

Referenced by action_coresettings(), and handle_show_settings().

◆ ast_cdr_message_router()

struct stasis_message_router * ast_cdr_message_router ( void  )

Return the message router for the CDR engine.

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

Return values
NULLif the CDR engine is disabled or unavailable
Returns
the stasis_message_router otherwise

Definition at line 4443 of file cdr.c.

4444{
4445 if (!stasis_router) {
4446 return NULL;
4447 }
4448
4450 return stasis_router;
4451}

References ao2_bump, NULL, and stasis_router.

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

◆ ast_cdr_modifier_register()

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

Register a CDR modifier.

Parameters
namename associated with the particular CDR modifier
descdescription of the CDR modifier
befunction 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
0on success.
-1on error

Definition at line 3081 of file cdr.c.

3082{
3083 return cdr_generic_register((struct be_list *)&mo_list, name, desc, be);
3084}
static int cdr_generic_register(struct be_list *generic_list, const char *name, const char *desc, ast_cdrbe be)
Definition cdr.c:3035
static const char desc[]
Definition cdr_radius.c:84
char * be
Definition eagi_proxy.c:73
List of registered modifiers.
Definition cdr.c:437

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

◆ ast_cdr_modifier_unregister()

int ast_cdr_modifier_unregister ( const char *  name)

Unregister a CDR modifier.

Parameters
namename of CDR modifier to unregister Unregisters a CDR modifier by its name
Return values
0The modifier unregistered successfully
-1The modifier could not be unregistered at this time

Definition at line 3126 of file cdr.c.

3127{
3128 return ast_cdr_generic_unregister((struct be_list *)&mo_list, name);
3129}
static int ast_cdr_generic_unregister(struct be_list *generic_list, const char *name)
Definition cdr.c:3086

References ast_cdr_generic_unregister(), and name.

◆ ast_cdr_register()

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

Register a CDR handling engine.

Parameters
namename associated with the particular CDR handler
descdescription of the CDR handler
befunction pointer to a CDR handler Used to register a Call Detail Record handler.
Return values
0on success.
-1on error

Definition at line 3076 of file cdr.c.

3077{
3079}

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

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

◆ ast_cdr_reset()

int ast_cdr_reset ( const char *  channel_name,
int  keep_variables 
)

Reset the detail record.

Parameters
channel_nameThe channel that the CDR is associated with
keep_variablesKeep the variables during the reset. If zero, variables are discarded during the reset.
Return values
0on success
-1on failure

Definition at line 3746 of file cdr.c.

3747{
3748 struct cdr_object *cdr;
3749 struct ast_var_t *vardata;
3750 struct cdr_object *it_cdr;
3751
3752 cdr = cdr_object_get_by_name(channel_name);
3753 if (!cdr) {
3754 return -1;
3755 }
3756
3757 ao2_lock(cdr);
3758 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3759 /* clear variables */
3760 if (!keep_variables) {
3761 while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_a.variables, entries))) {
3763 }
3764 if (cdr->party_b.snapshot) {
3765 while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_b.variables, entries))) {
3767 }
3768 }
3769 }
3770
3771 /* Reset to initial state */
3772 memset(&it_cdr->start, 0, sizeof(it_cdr->start));
3773 memset(&it_cdr->end, 0, sizeof(it_cdr->end));
3774 memset(&it_cdr->answer, 0, sizeof(it_cdr->answer));
3775 it_cdr->start = ast_tvnow();
3776 it_cdr->lastevent = it_cdr->start;
3778 }
3779 ao2_unlock(cdr);
3780
3781 ao2_cleanup(cdr);
3782 return 0;
3783}
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 mu...
Definition cdr.c:1598
void ast_var_delete(struct ast_var_t *var)
Definition extconf.c:2469
#define AST_LIST_REMOVE_HEAD(head, field)
Removes and returns the head entry from a list.

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

Referenced by appcdr_callback(), and dial_exec_full().

◆ ast_cdr_serialize_variables()

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

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

Parameters
channel_nameThe channel to get the CDR for
bufA buffer to use for formatting the data
delimA delimeter to use to separate variable keys/values
sepA separator to use between nestings
Returns
the total number of serialized variables

Definition at line 3499 of file cdr.c.

3500{
3501 struct cdr_object *cdr;
3502 struct cdr_object *it_cdr;
3503 struct ast_var_t *variable;
3504 const char *var;
3505 char workspace[256];
3506 int total = 0, x = 0, i;
3507
3508 cdr = cdr_object_get_by_name(channel_name);
3509 if (!cdr) {
3511 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
3512 }
3513 return 0;
3514 }
3515
3517
3518 ao2_lock(cdr);
3519 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3520 if (++x > 1) {
3521 ast_str_append(buf, 0, "\n");
3522 }
3523
3524 AST_LIST_TRAVERSE(&it_cdr->party_a.variables, variable, entries) {
3525 if (!(var = ast_var_name(variable))) {
3526 continue;
3527 }
3528
3529 if (ast_str_append(buf, 0, "level %d: %s%c%s%c", x, var, delim, S_OR(ast_var_value(variable), ""), sep) < 0) {
3530 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
3531 break;
3532 }
3533
3534 total++;
3535 }
3536
3537 for (i = 0; cdr_readonly_vars[i]; i++) {
3538 if (cdr_object_format_property(it_cdr, cdr_readonly_vars[i], workspace, sizeof(workspace))) {
3539 /* Unhandled read-only CDR variable. */
3540 ast_assert(0);
3541 continue;
3542 }
3543
3544 if (!ast_strlen_zero(workspace)
3545 && ast_str_append(buf, 0, "level %d: %s%c%s%c", x, cdr_readonly_vars[i], delim, workspace, sep) < 0) {
3546 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
3547 break;
3548 }
3549 total++;
3550 }
3551 }
3552 ao2_unlock(cdr);
3553 ao2_cleanup(cdr);
3554 return total;
3555}
#define var
Definition ast_expr2f.c:605
static const char *const cdr_readonly_vars[]
Definition cdr.c:3291
const char * ast_var_name(const struct ast_var_t *var)
Definition chanvars.c:60
const char * ast_var_value(const struct ast_var_t *var)
Definition chanvars.c:80
char buf[BUFSIZE]
Definition eagi_proxy.c:66
#define LOG_ERROR
#define AST_LIST_TRAVERSE(head, var, field)
Loops over (traverses) the entries in a list.
static int total
Definition res_adsi.c:970
int ast_str_append(struct ast_str **buf, ssize_t max_len, const char *fmt,...)
Append to a thread local dynamic string.
Definition strings.h:1139
#define S_OR(a, b)
returns the equivalent of logic or for strings: first one if not empty, otherwise second one.
Definition strings.h:80
void ast_str_reset(struct ast_str *buf)
Reset the content of a dynamic string. Useful before a series of ast_str_append.
Definition strings.h:693
struct ast_var_t::@224 entries
#define ast_assert(a)
Definition utils.h:776

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

Referenced by handle_showchan().

◆ ast_cdr_set_config()

void ast_cdr_set_config ( struct ast_cdr_config config)

Set the current CDR configuration.

Since
12
Parameters
configThe new CDR configuration

Definition at line 2973 of file cdr.c.

2974{
2975 struct module_config *mod_cfg;
2976
2977 if (!config) {
2978 return;
2979 }
2980
2981 mod_cfg = ao2_global_obj_ref(module_configs);
2982 if (!mod_cfg) {
2983 return;
2984 }
2985
2986 ao2_replace(mod_cfg->general, config);
2987
2988 cdr_set_debug_mode(mod_cfg);
2990
2991 ao2_cleanup(mod_cfg);
2992}
#define ao2_replace(dst, src)
Replace one object reference with another cleaning up the original.
Definition astobj2.h:501
#define cdr_set_debug_mode(mod_cfg)
Definition cdr.c:306
static int cdr_toggle_runtime_options(void)
Checks if CDRs are enabled and enables/disables the necessary options.
Definition cdr.c:4640
static const char config[]

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

Referenced by test_cdr_cleanup_cb().

◆ ast_cdr_set_property()

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

Set a property on a CDR for a channel.

Since
12

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

Parameters
channel_nameThe CDR's channel
optionOption to apply to the CDR
Return values
0on success
1on error

Definition at line 3696 of file cdr.c.

3697{
3698 struct cdr_object *cdr;
3699 struct cdr_object *it_cdr;
3700
3701 cdr = cdr_object_get_by_name(channel_name);
3702 if (!cdr) {
3703 return -1;
3704 }
3705
3706 ao2_lock(cdr);
3707 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3708 if (it_cdr->fn_table == &finalized_state_fn_table) {
3709 continue;
3710 }
3711 /* Note: in general, set the flags on both the CDR record as well as the
3712 * Party A. Sometimes all we have is the Party A to look at.
3713 */
3714 ast_set_flag(&it_cdr->flags, option);
3715 ast_set_flag(&it_cdr->party_a, option);
3716 }
3717 ao2_unlock(cdr);
3718
3719 ao2_cleanup(cdr);
3720 return 0;
3721}
#define ast_set_flag(p, flag)
Definition utils.h:70

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

Referenced by AST_TEST_DEFINE(), and cdr_prop_write_callback().

◆ ast_cdr_setuserfield()

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

Set CDR user field for channel (stored in CDR)

Parameters
channel_nameThe name of the channel that owns the CDR
userfieldThe user field to set

Definition at line 3625 of file cdr.c.

3626{
3627 struct cdr_object *cdr;
3628 struct party_b_userfield_update party_b_info = {
3630 .userfield = userfield,
3631 };
3632 struct cdr_object *it_cdr;
3633
3634 /* Handle Party A */
3635 cdr = cdr_object_get_by_name(channel_name);
3636 if (cdr) {
3637 ao2_lock(cdr);
3638 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3639 if (it_cdr->fn_table == &finalized_state_fn_table && it_cdr->next != NULL) {
3640 continue;
3641 }
3642 ast_copy_string(it_cdr->party_a.userfield, userfield,
3643 sizeof(it_cdr->party_a.userfield));
3644 }
3645 ao2_unlock(cdr);
3646 }
3647
3648 /* Handle Party B */
3651 &party_b_info);
3652
3653 ao2_cleanup(cdr);
3654}
#define ao2_callback_data(container, flags, cb_fn, arg, data)
Definition astobj2.h:1723
@ OBJ_NODATA
Definition astobj2.h:1044
@ OBJ_MULTIPLE
Definition astobj2.h:1049
@ OBJ_SEARCH_KEY
The arg parameter is a search key, but is not an object.
Definition astobj2.h:1101
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.
Definition cdr.c:3603
static struct ao2_container * active_cdrs_all
A container of all active CDRs with a Party B indexed by Party B channel name.
Definition cdr.c:472
const char * userfield
Definition cdr.c:3599
const char * channel_name
Definition cdr.c:3598

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

Referenced by AST_TEST_DEFINE(), and cdr_write_callback().

◆ ast_cdr_setvar()

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

Set a variable on a CDR.

Since
12
Parameters
channel_nameThe channel to set the variable on
nameThe name of the variable to set
valueThe value of the variable to set
Return values
0on success
non-zeroon failure

Definition at line 3316 of file cdr.c.

3317{
3318 struct cdr_object *cdr;
3319 struct cdr_object *it_cdr;
3320 struct ao2_iterator *it_cdrs;
3321 char *arg = ast_strdupa(channel_name);
3322 int x;
3323
3324 for (x = 0; cdr_readonly_vars[x]; x++) {
3325 if (!strcasecmp(name, cdr_readonly_vars[x])) {
3326 ast_log(LOG_ERROR, "Attempt to set the '%s' read-only variable!\n", name);
3327 return -1;
3328 }
3329 }
3330
3332 if (!it_cdrs) {
3333 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
3334 return -1;
3335 }
3336
3337 for (; (cdr = ao2_iterator_next(it_cdrs)); ao2_unlock(cdr), ao2_cleanup(cdr)) {
3338 ao2_lock(cdr);
3339 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3340 struct varshead *headp = NULL;
3341
3342 if (it_cdr->fn_table == &finalized_state_fn_table && it_cdr->next != NULL) {
3343 continue;
3344 }
3345 if (!strcasecmp(channel_name, it_cdr->party_a.snapshot->base->name)) {
3346 headp = &it_cdr->party_a.variables;
3347 } else if (it_cdr->party_b.snapshot
3348 && !strcasecmp(channel_name, it_cdr->party_b.snapshot->base->name)) {
3349 headp = &it_cdr->party_b.variables;
3350 }
3351 if (headp) {
3352 set_variable(headp, name, value);
3353 }
3354 }
3355 }
3356 ao2_iterator_destroy(it_cdrs);
3357
3358 return 0;
3359}
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition astmm.h:298
#define ao2_iterator_next(iter)
Definition astobj2.h:1911
#define ao2_callback(c, flags, cb_fn, arg)
ao2_callback() is a generic function that applies cb_fn() to all objects in a container,...
Definition astobj2.h:1693
void ao2_iterator_destroy(struct ao2_iterator *iter)
Destroy a container iterator.
static int cdr_object_select_all_by_name_cb(void *obj, void *arg, int flags)
Definition cdr.c:3263
static void set_variable(struct varshead *headp, const char *name, const char *value)
Definition cdr.c:1364
When we need to walk through a container, we use an ao2_iterator to keep track of the current positio...
Definition astobj2.h:1821
const ast_string_field name
struct ast_channel_snapshot_base * base

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

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

◆ ast_cdr_unregister()

int ast_cdr_unregister ( const char *  name)

Unregister a CDR handling engine.

Parameters
namename of CDR handler to unregister Unregisters a CDR by it's name
Return values
0The backend unregistered successfully
-1The backend could not be unregistered at this time

Definition at line 3121 of file cdr.c.

3122{
3124}

References ast_cdr_generic_unregister(), and name.

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

◆ AST_MODULE_SELF_SYM()

struct ast_module * AST_MODULE_SELF_SYM ( void  )

Definition at line 4827 of file cdr.c.

◆ base_process_bridge_enter()

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

Definition at line 1715 of file cdr.c.

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

References BRIDGE_ENTER_NEED_CDR.

◆ base_process_bridge_leave()

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

Definition at line 1705 of file cdr.c.

1706{
1707 return 0;
1708}

◆ base_process_dial_end()

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

Definition at line 1710 of file cdr.c.

1711{
1712 return 0;
1713}

◆ base_process_parked_channel()

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

Definition at line 1721 of file cdr.c.

1722{
1723 char park_info[128];
1724
1725 ast_assert(!strcasecmp(parking_info->parkee->base->name, cdr->party_a.snapshot->base->name));
1726
1727 /* Update Party A information regardless */
1728 cdr->fn_table->process_party_a(cdr, parking_info->parkee);
1729
1730 /* Fake out where we're parked */
1731 ast_string_field_set(cdr, appl, "Park");
1732 snprintf(park_info, sizeof(park_info), "%s:%u", parking_info->parkinglot, parking_info->parkingspace);
1733 ast_string_field_set(cdr, data, park_info);
1734
1735 /* Prevent any further changes to the App/Data fields for this record */
1737
1738 return 0;
1739}
unsigned int parkingspace
Definition parking.h:65
const ast_string_field parkinglot
Definition parking.h:69
struct ast_channel_snapshot * parkee
Definition parking.h:60
int(*const process_party_a)(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Process a Party A update for the cdr_object.
Definition cdr.c:541

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

◆ base_process_party_a()

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

Definition at line 1644 of file cdr.c.

1645{
1646 ast_assert(strcasecmp(snapshot->base->name, cdr->party_a.snapshot->base->name) == 0);
1647
1648 /* Finalize the CDR if we're in hangup logic and we're set to do so */
1652 return 0;
1653 }
1654
1655 /*
1656 * Only record the context and extension if we aren't in a subroutine, or if
1657 * we are executing hangup logic.
1658 */
1661 if (strcmp(cdr->context, snapshot->dialplan->context)) {
1662 ast_string_field_set(cdr, context, snapshot->dialplan->context);
1663 }
1664 if (strcmp(cdr->exten, snapshot->dialplan->exten)) {
1665 ast_string_field_set(cdr, exten, snapshot->dialplan->exten);
1666 }
1667 }
1668
1669 cdr_object_swap_snapshot(&cdr->party_a, snapshot);
1670
1671 /* When Party A is originated to an application and the application exits, the stack
1672 * will attempt to clear the application and restore the dummy originate application
1673 * of "AppDialX". Prevent that, and any other application changes we might not want
1674 * here.
1675 */
1677 && !ast_strlen_zero(snapshot->dialplan->appl)
1678 && (strncasecmp(snapshot->dialplan->appl, "appdial", 7) || ast_strlen_zero(cdr->appl))) {
1679 if (strcmp(cdr->appl, snapshot->dialplan->appl)) {
1680 ast_string_field_set(cdr, appl, snapshot->dialplan->appl);
1681 }
1682 if (strcmp(cdr->data, snapshot->dialplan->data)) {
1683 ast_string_field_set(cdr, data, snapshot->dialplan->data);
1684 }
1685
1686 /* Dial (app_dial) is a special case. Because pre-dial handlers, which
1687 * execute before the dial begins, will alter the application/data to
1688 * something people typically don't want to see, if we see a channel enter
1689 * into Dial here, we set the appl/data accordingly and lock it.
1690 */
1691 if (!strcmp(snapshot->dialplan->appl, "Dial")) {
1693 }
1694 }
1695
1696 if (strcmp(cdr->linkedid, snapshot->peer->linkedid)) {
1697 ast_string_field_set(cdr, linkedid, snapshot->peer->linkedid);
1698 }
1701
1702 return 0;
1703}
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.
Definition cdr.c:1635
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.
Definition cdr.c:1581
@ CDR_END_BEFORE_H_EXTEN
Definition cdr.h:224
@ AST_FLAG_SUBROUTINE_EXEC
Definition channel.h:1078
@ AST_SOFTHANGUP_HANGUP_EXEC
Definition channel.h:1174
const ast_string_field data
const ast_string_field context
const ast_string_field exten
const ast_string_field appl
struct ast_channel_snapshot_dialplan * dialplan
struct ast_channel_snapshot_peer * peer
struct ast_flags softhangup_flags
struct ast_flags flags
const ast_string_field linkedid
Definition cdr.c:839
const ast_string_field data
Definition cdr.c:839
const ast_string_field context
Definition cdr.c:839
const ast_string_field exten
Definition cdr.c:839
const ast_string_field appl
Definition cdr.c:839

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, cdr_object::context, ast_channel_snapshot_dialplan::data, cdr_object::data, ast_channel_snapshot::dialplan, ast_channel_snapshot_dialplan::exten, cdr_object::exten, ast_channel_snapshot::flags, cdr_object::flags, is_cdr_flag_set(), ast_cdr::linkedid, ast_channel_snapshot_peer::linkedid, cdr_object::linkedid, ast_channel_snapshot_base::name, cdr_object::party_a, ast_channel_snapshot::peer, cdr_object_snapshot::snapshot, ast_channel_snapshot::softhangup_flags, and ast_cdr::start.

Referenced by dialed_pending_state_process_party_a(), and single_state_process_dial_begin().

◆ bridge_candidate_add_to_cdr()

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

Definition at line 2606 of file cdr.c.

2608{
2609 struct cdr_object *new_cdr;
2610
2612 if (!new_cdr) {
2613 return;
2614 }
2620 CDR_DEBUG("%p - Party A %s has new Party B %s\n",
2621 new_cdr, new_cdr->party_a.snapshot->base->name,
2623}
struct cdr_object_fn_table bridge_state_fn_table
The virtual table for the Bridged state.
Definition cdr.c:763
static void cdr_object_snapshot_copy(struct cdr_object_snapshot *dst, struct cdr_object_snapshot *src)
Copy a snapshot and its details.
Definition cdr.c:896
const ast_string_field bridge
Definition cdr.c:839

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

Referenced by bridge_candidate_process().

◆ bridge_candidate_process()

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

Process a single bridge_candidate.

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

Parameters
cdrThe cdr_object being processed
base_cand_cdrThe cdr_object that is a candidate

Definition at line 2637 of file cdr.c.

2638{
2639 struct cdr_object_snapshot *party_a;
2640 struct cdr_object *cand_cdr;
2641
2643
2644 for (cand_cdr = base_cand_cdr; cand_cdr; cand_cdr = cand_cdr->next) {
2645 /* Skip any records that are not in this bridge */
2646 if (strcmp(cand_cdr->bridge, cdr->bridge)) {
2647 continue;
2648 }
2649
2650 /* If the candidate is us or someone we've taken on, pass on by */
2651 if (!strcasecmp(cdr->party_a.snapshot->base->name, cand_cdr->party_a.snapshot->base->name)
2652 || (cdr->party_b.snapshot
2653 && !strcasecmp(cdr->party_b.snapshot->base->name, cand_cdr->party_a.snapshot->base->name))) {
2654 break;
2655 }
2656
2657 party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_a);
2658 /* We're party A - make a new CDR, append it to us, and set the candidate as
2659 * Party B */
2661 bridge_candidate_add_to_cdr(cdr, &cand_cdr->party_a);
2662 break;
2663 }
2664
2665 /* We're Party B. Check if we can add ourselves immediately or if we need
2666 * a new CDR for them (they already have a Party B) */
2667 if (cand_cdr->party_b.snapshot
2668 && strcasecmp(cand_cdr->party_b.snapshot->base->name, cdr->party_a.snapshot->base->name)) {
2670 } else {
2671 CDR_DEBUG("%p - Party A %s has new Party B %s\n",
2672 cand_cdr, cand_cdr->party_a.snapshot->base->name,
2673 cdr->party_a.snapshot->base->name);
2674 cdr_object_snapshot_copy(&cand_cdr->party_b, &cdr->party_a);
2676 /* It's possible that this joined at one point and was never chosen
2677 * as party A. Clear their end time, as it would be set in such a
2678 * case.
2679 */
2680 memset(&cand_cdr->end, 0, sizeof(cand_cdr->end));
2681 }
2682
2683 break;
2684 }
2685
2687}
static void bridge_candidate_add_to_cdr(struct cdr_object *cdr, struct cdr_object_snapshot *party_b)
Definition cdr.c:2606
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.
Definition cdr.c:1294
A wrapper object around a snapshot. Fields that are mutable by the CDR engine are replicated here.
Definition cdr.c:808

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

Referenced by handle_bridge_pairings().

◆ bridge_state_process_bridge_leave()

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

Definition at line 2125 of file cdr.c.

2126{
2127 if (strcmp(cdr->bridge, bridge->uniqueid)) {
2128 return 1;
2129 }
2130 if (strcasecmp(cdr->party_a.snapshot->base->name, channel->base->name)
2131 && cdr->party_b.snapshot
2132 && strcasecmp(cdr->party_b.snapshot->base->name, channel->base->name)) {
2133 return 1;
2134 }
2136
2137 return 0;
2138}
const ast_string_field uniqueid
Definition bridge.h:332

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

◆ bridge_state_process_party_b()

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

◆ cdr_all_cmp_fn()

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

Definition at line 1018 of file cdr.c.

1019{
1020 struct cdr_object *left = obj;
1021 struct cdr_object *right = arg;
1022 const char *right_key = arg;
1023 int cmp;
1024
1025 switch (flags & OBJ_SEARCH_MASK) {
1026 case OBJ_SEARCH_OBJECT:
1027 right_key = right->party_b_name;
1028 /* Fall through */
1029 case OBJ_SEARCH_KEY:
1031 break;
1033 /*
1034 * We could also use a partial key struct containing a length
1035 * so strlen() does not get called for every comparison instead.
1036 */
1038 break;
1039 default:
1040 /* Sort can only work on something with a full or partial key. */
1041 ast_assert(0);
1042 cmp = 0;
1043 break;
1044 }
1045 return cmp ? 0 : CMP_MATCH;
1046}
@ CMP_MATCH
Definition astobj2.h:1027
@ OBJ_SEARCH_PARTIAL_KEY
The arg parameter is a partial search key similar to OBJ_SEARCH_KEY.
Definition astobj2.h:1116
@ OBJ_SEARCH_OBJECT
The arg parameter is an object of the same type.
Definition astobj2.h:1087
@ OBJ_SEARCH_MASK
Search option field mask.
Definition astobj2.h:1072
const ast_string_field party_b_name
Definition cdr.c:839

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

Referenced by load_module().

◆ cdr_all_hash_fn()

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

Definition at line 994 of file cdr.c.

995{
996 const struct cdr_object *cdr;
997 const char *key;
998
999 switch (flags & OBJ_SEARCH_MASK) {
1000 case OBJ_SEARCH_KEY:
1001 key = obj;
1002 break;
1003 case OBJ_SEARCH_OBJECT:
1004 cdr = obj;
1005 key = cdr->party_b_name;
1006 break;
1007 default:
1008 ast_assert(0);
1009 return 0;
1010 }
1011 return ast_str_case_hash(key);
1012}
static force_inline int attribute_pure ast_str_case_hash(const char *str)
Compute a hash value on a case-insensitive string.
Definition strings.h:1303

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

Referenced by load_module().

◆ cdr_all_print_fn()

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

Definition at line 4624 of file cdr.c.

4625{
4626 struct cdr_object *cdr = v_obj;
4627
4628 if (!cdr) {
4629 return;
4630 }
4631 prnt(where, "Party A: %s; Party B: %s; Bridge %s",
4632 cdr->party_a.snapshot->base->name,
4633 cdr->party_b.snapshot ? cdr->party_b.snapshot->base->name : "<unknown>",
4634 cdr->bridge);
4635}

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

Referenced by load_module().

◆ cdr_all_relink()

static void cdr_all_relink ( struct cdr_object cdr)
static

Definition at line 1053 of file cdr.c.

1054{
1056 if (cdr->party_b.snapshot) {
1057 if (strcasecmp(cdr->party_b_name, cdr->party_b.snapshot->base->name)) {
1059 ast_string_field_set(cdr, party_b_name, cdr->party_b.snapshot->base->name);
1061 }
1062 } else {
1064 ast_string_field_set(cdr, party_b_name, "");
1065 }
1067}
#define ao2_unlink_flags(container, obj, flags)
Remove an object from a container.
Definition astobj2.h:1600
#define ao2_link_flags(container, obj, flags)
Add an object to a container.
Definition astobj2.h:1554
@ OBJ_NOLOCK
Assume that the ao2_container is already locked.
Definition astobj2.h:1063

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

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

◆ cdr_all_unlink()

static void cdr_all_unlink ( struct cdr_object cdr)
static

Definition at line 1074 of file cdr.c.

1075{
1076 struct cdr_object *cur;
1077 struct cdr_object *next;
1078
1079 ast_assert(cdr->is_root);
1080
1081 /* Hold a ref to the root CDR to ensure the list members don't go away on us. */
1082 ao2_ref(cdr, +1);
1084 for (cur = cdr; cur; cur = next) {
1085 next = cur->next;
1087 /*
1088 * It is safe to still use cur after unlinking because the
1089 * root CDR holds a ref to all the CDRs in the list and we
1090 * have a ref to the root CDR.
1091 */
1093 }
1095 ao2_ref(cdr, -1);
1096}
int is_root
Definition cdr.c:842

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

Referenced by cdr_object_dispatch_all_cb(), and handle_channel_snapshot_update_message().

◆ cdr_detach()

static void cdr_detach ( struct ast_cdr cdr)
static

Definition at line 3989 of file cdr.c.

3990{
3991 struct cdr_batch_item *newtail;
3992 int curr;
3993 RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
3994 int submit_batch = 0;
3995
3996 if (!cdr) {
3997 return;
3998 }
3999
4000 /* maybe they disabled CDR stuff completely, so just drop it */
4001 if (!mod_cfg || !ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
4002 ast_debug(1, "Dropping CDR !\n");
4004 return;
4005 }
4006
4007 /* post stuff immediately if we are not in batch mode, this is legacy behaviour */
4008 if (!ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
4009 post_cdr(cdr);
4011 return;
4012 }
4013
4014 /* otherwise, each CDR gets put into a batch list (at the end) */
4015 ast_debug(1, "CDR detaching from this thread\n");
4016
4017 /* we'll need a new tail for every CDR */
4018 if (!(newtail = ast_calloc(1, sizeof(*newtail)))) {
4019 post_cdr(cdr);
4021 return;
4022 }
4023
4024 /* don't traverse a whole list (just keep track of the tail) */
4026 if (!batch)
4027 init_batch();
4028 if (!batch->head) {
4029 /* new batch is empty, so point the head at the new tail */
4030 batch->head = newtail;
4031 } else {
4032 /* already got a batch with something in it, so just append a new tail */
4033 batch->tail->next = newtail;
4034 }
4035 newtail->cdr = cdr;
4036 batch->tail = newtail;
4037 curr = batch->size++;
4038
4039 /* if we have enough stuff to post, then do it */
4040 if (curr >= (mod_cfg->general->batch_settings.size - 1)) {
4041 submit_batch = 1;
4042 }
4044
4045 /* Don't submit a batch with cdr_batch_lock held */
4046 if (submit_batch) {
4048 }
4049}
void ast_cdr_free(struct ast_cdr *cdr)
Free a CDR record.
Definition cdr.c:3557
static ast_mutex_t cdr_batch_lock
Lock protecting modifications to the batch queue.
Definition cdr.c:462
static struct cdr_batch * batch
static int init_batch(void)
Definition cdr.c:3886
static void start_batch_mode(void)
Definition cdr.c:3973
static void post_cdr(struct ast_cdr *cdr)
Definition cdr.c:3656
#define ast_mutex_unlock(a)
Definition lock.h:197
#define ast_mutex_lock(a)
Definition lock.h:196
Queued CDR waiting to be batched.
Definition cdr.c:440
struct ast_cdr * cdr
Definition cdr.c:441
struct cdr_batch_item * next
Definition cdr.c:442
int size
Definition cdr.c:447
struct cdr_batch_item * head
Definition cdr.c:448
struct cdr_batch_item * tail
Definition cdr.c:449

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

Referenced by cdr_object_dispatch().

◆ cdr_enable_batch_mode()

static void cdr_enable_batch_mode ( struct ast_cdr_config config)
static

Definition at line 4572 of file cdr.c.

4573{
4574 /* Only create the thread level portions once */
4578 ast_log(LOG_ERROR, "Unable to start CDR thread.\n");
4579 return;
4580 }
4581 }
4582
4583 /* Start the batching process */
4585
4586 ast_log(LOG_NOTICE, "CDR batch mode logging enabled, first of either size %u or time %u seconds.\n",
4587 config->batch_settings.size, config->batch_settings.time);
4588}
static pthread_t cdr_thread
Definition cdr.c:459
static ast_cond_t cdr_pending_cond
Definition cdr.c:466
static void * do_cdr(void *data)
Definition cdr.c:4051
#define LOG_NOTICE
#define AST_PTHREADT_NULL
Definition lock.h:73
#define ast_cond_init(cond, attr)
Definition lock.h:208
#define ast_pthread_create_background(a, b, c, d)
Definition utils.h:629

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

Referenced by cdr_toggle_runtime_options().

◆ cdr_engine_shutdown()

static void cdr_engine_shutdown ( void  )
static

Definition at line 4541 of file cdr.c.

4542{
4545
4547 cdr_topic = NULL;
4548
4549 STASIS_MESSAGE_TYPE_CLEANUP(cdr_sync_message_type);
4550
4556 sched = NULL;
4557 ast_free(batch);
4558 batch = NULL;
4559
4560 aco_info_destroy(&cfg_info);
4561 ao2_global_obj_release(module_configs);
4562
4563 ao2_container_unregister("cdrs_master");
4566
4567 ao2_container_unregister("cdrs_all");
4570}
void ast_cli_unregister_multiple(void)
Definition ael_main.c:408
void ao2_container_unregister(const char *name)
Unregister a container for CLI stats and integrity check.
#define ao2_global_obj_release(holder)
Release the ao2 object held in the global holder.
Definition astobj2.h:859
@ OBJ_UNLINK
Definition astobj2.h:1039
static int cdr_object_dispatch_all_cb(void *obj, void *arg, int flags)
This dispatches all cdr_object. It should only be used during shutdown, so that we get billing record...
Definition cdr.c:4412
static struct ast_cli_entry cli_commands[]
Definition cdr.c:4401
static void finalize_batch_mode(void)
Definition cdr.c:4429
static struct stasis_topic * cdr_topic
The parent topic for all topics we want to aggregate for CDRs.
Definition cdr.c:487
void aco_info_destroy(struct aco_info *info)
Destroy an initialized aco_info struct.
void ast_sched_context_destroy(struct ast_sched_context *c)
destroys a schedule context
Definition sched.c:271
#define STASIS_MESSAGE_TYPE_CLEANUP(name)
Boiler-plate messaging macro for cleaning up message types.
Definition stasis.h:1515
void stasis_message_router_unsubscribe_and_join(struct stasis_message_router *router)
Unsubscribe the router from the upstream topic, blocking until the final message has been processed.
Definition sched.c:76
#define ARRAY_LEN(a)
Definition utils.h:703

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

Referenced by load_module().

◆ cdr_format_var_internal()

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

Definition at line 3151 of file cdr.c.

3152{
3153 struct ast_var_t *variables;
3154
3155 if (ast_strlen_zero(name)) {
3156 return NULL;
3157 }
3158
3159 AST_LIST_TRAVERSE(&cdr->varshead, variables, entries) {
3160 if (!strcasecmp(name, ast_var_name(variables))) {
3161 return ast_var_value(variables);
3162 }
3163 }
3164
3165 return NULL;
3166}

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

Referenced by ast_cdr_format_var().

◆ cdr_generic_register()

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

Definition at line 3035 of file cdr.c.

3036{
3037 struct cdr_beitem *i;
3038 struct cdr_beitem *cur;
3039
3040 if (!name) {
3041 return -1;
3042 }
3043
3044 if (!be) {
3045 ast_log(LOG_WARNING, "CDR engine '%s' lacks backend\n", name);
3046
3047 return -1;
3048 }
3049
3050 i = ast_calloc(1, sizeof(*i));
3051 if (!i) {
3052 return -1;
3053 }
3054
3055 i->be = be;
3056 ast_copy_string(i->name, name, sizeof(i->name));
3057 ast_copy_string(i->desc, desc, sizeof(i->desc));
3058
3059 AST_RWLIST_WRLOCK(generic_list);
3060 AST_RWLIST_TRAVERSE(generic_list, cur, list) {
3061 if (!strcasecmp(name, cur->name)) {
3062 ast_log(LOG_WARNING, "Already have a CDR backend called '%s'\n", name);
3063 AST_RWLIST_UNLOCK(generic_list);
3064 ast_free(i);
3065
3066 return -1;
3067 }
3068 }
3069
3070 AST_RWLIST_INSERT_HEAD(generic_list, i, list);
3071 AST_RWLIST_UNLOCK(generic_list);
3072
3073 return 0;
3074}
#define LOG_WARNING
#define AST_RWLIST_INSERT_HEAD
ast_cdrbe be
Definition cdr.c:428
char desc[80]
Definition cdr.c:427

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

Referenced by ast_cdr_modifier_register(), and ast_cdr_register().

◆ cdr_get_tv()

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

Definition at line 3168 of file cdr.c.

3169{
3170 if (fmt == NULL) { /* raw mode */
3171 snprintf(buf, bufsize, "%ld.%06ld", (long)when.tv_sec, (long)when.tv_usec);
3172 } else {
3173 buf[0] = '\0';/* Ensure the buffer is initialized. */
3174 if (when.tv_sec) {
3175 struct ast_tm tm;
3176
3177 ast_localtime(&when, &tm, NULL);
3178 ast_strftime(buf, bufsize, fmt, &tm);
3179 }
3180 }
3181}
struct ast_tm * ast_localtime(const struct timeval *timep, struct ast_tm *p_tm, const char *zone)
Timezone-independent version of localtime_r(3).
Definition localtime.c:1739
int ast_strftime(char *buf, size_t len, const char *format, const struct ast_tm *tm)
Special version of strftime(3) that handles fractions of a second. Takes the same arguments as strfti...
Definition localtime.c:2524

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

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

◆ cdr_master_cmp_fn()

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

Definition at line 960 of file cdr.c.

961{
962 struct cdr_object *left = obj;
963 struct cdr_object *right = arg;
964 const char *right_key = arg;
965 int cmp;
966
967 switch (flags & OBJ_SEARCH_MASK) {
969 right_key = right->uniqueid;
970 /* Fall through */
971 case OBJ_SEARCH_KEY:
972 cmp = strcmp(left->uniqueid, right_key);
973 break;
975 /*
976 * We could also use a partial key struct containing a length
977 * so strlen() does not get called for every comparison instead.
978 */
980 break;
981 default:
982 /* Sort can only work on something with a full or partial key. */
983 ast_assert(0);
984 cmp = 0;
985 break;
986 }
987 return cmp ? 0 : CMP_MATCH;
988}
const ast_string_field uniqueid
Definition cdr.c:839

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

Referenced by load_module().

◆ cdr_master_hash_fn()

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

Definition at line 936 of file cdr.c.

937{
938 const struct cdr_object *cdr;
939 const char *key;
940
941 switch (flags & OBJ_SEARCH_MASK) {
942 case OBJ_SEARCH_KEY:
943 key = obj;
944 break;
946 cdr = obj;
947 key = cdr->uniqueid;
948 break;
949 default:
950 ast_assert(0);
951 return 0;
952 }
953 return ast_str_case_hash(key);
954}

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

Referenced by load_module().

◆ cdr_master_print_fn()

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

Definition at line 4599 of file cdr.c.

4600{
4601 struct cdr_object *cdr = v_obj;
4602 struct cdr_object *it_cdr;
4603
4604 if (!cdr) {
4605 return;
4606 }
4607 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
4608 prnt(where, "Party A: %s; Party B: %s; Bridge %s\n",
4609 it_cdr->party_a.snapshot->base->name,
4610 it_cdr->party_b.snapshot ? it_cdr->party_b.snapshot->base->name : "<unknown>",
4611 it_cdr->bridge);
4612 }
4613}

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

Referenced by load_module().

◆ cdr_object_alloc()

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

cdr_object constructor

Parameters
chanThe ast_channel_snapshot that is the CDR's Party A
event_time

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

Definition at line 1142 of file cdr.c.

1143{
1144 struct cdr_object *cdr;
1145
1146 ast_assert(chan != NULL);
1147
1148 cdr = ao2_alloc(sizeof(*cdr), cdr_object_dtor);
1149 if (!cdr) {
1150 return NULL;
1151 }
1152 cdr->last = cdr;
1153 if (ast_string_field_init(cdr, 64)) {
1154 ao2_cleanup(cdr);
1155 return NULL;
1156 }
1158 ast_string_field_set(cdr, name, chan->base->name);
1162 cdr->lastevent = *event_time;
1163
1164 cdr->party_a.snapshot = chan;
1165 ao2_t_ref(cdr->party_a.snapshot, +1, "bump snapshot during CDR creation");
1166
1167 CDR_DEBUG("%p - Created CDR for channel %s\n", cdr, chan->base->name);
1168
1170
1171 return cdr;
1172}
#define ao2_t_ref(o, delta, tag)
Definition astobj2.h:460
struct cdr_object_fn_table single_state_fn_table
The virtual table for the Single state.
Definition cdr.c:677
static int global_cdr_sequence
The global sequence counter used for CDRs.
Definition cdr.c:453
static void cdr_object_dtor(void *obj)
cdr_object Destructor
Definition cdr.c:1101
int ast_atomic_fetchadd_int(volatile int *p, int v)
Atomically add v to *p and return the previous value of *p.
Definition lock.h:764
#define ast_string_field_init(x, size)
Initialize a field pool and fields.
const ast_string_field uniqueid
unsigned int sequence
Definition cdr.c:826
enum ast_cdr_disposition disposition
Definition cdr.c:821

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

Referenced by cdr_object_create_and_append(), and handle_channel_snapshot_update_message().

◆ cdr_object_check_party_a_answer()

static void cdr_object_check_party_a_answer ( struct cdr_object cdr)
static

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

Definition at line 1598 of file cdr.c.

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

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

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

◆ cdr_object_check_party_a_hangup()

static void cdr_object_check_party_a_hangup ( struct cdr_object cdr)
static

◆ 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
cdrThe cdr_object to append to
event_time

Definition at line 1179 of file cdr.c.

1180{
1181 struct cdr_object *new_cdr;
1182 struct cdr_object *it_cdr;
1183 struct cdr_object *cdr_last;
1184
1185 cdr_last = cdr->last;
1186 new_cdr = cdr_object_alloc(cdr_last->party_a.snapshot, event_time);
1187 if (!new_cdr) {
1188 return NULL;
1189 }
1190 new_cdr->disposition = AST_CDR_NULL;
1191
1192 /* Copy over the linkedid, as it may have changed */
1198
1199 /*
1200 * If the current CDR says to disable all future ones,
1201 * keep the disable chain going
1202 */
1205 }
1206
1207 /* Copy over other Party A information */
1208 cdr_object_snapshot_copy(&new_cdr->party_a, &cdr_last->party_a);
1209
1210 /* Append the CDR to the end of the list */
1211 for (it_cdr = cdr; it_cdr->next; it_cdr = it_cdr->next) {
1212 it_cdr->last = new_cdr;
1213 }
1214 it_cdr->last = new_cdr;
1215 it_cdr->next = new_cdr;
1216
1217 return new_cdr;
1218}
static struct cdr_object * cdr_object_alloc(struct ast_channel_snapshot *chan, const struct timeval *event_time)
cdr_object constructor
Definition cdr.c:1142
@ AST_CDR_FLAG_DISABLE_ALL
Definition cdr.h:246

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

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

◆ cdr_object_create_public_records()

static struct ast_cdr * cdr_object_create_public_records ( struct cdr_object cdr)
static

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

Parameters
cdrThe cdr_object to convert to a public record
Returns
A chain of ast_cdr objects on success
Return values
NULLon failure

Definition at line 1389 of file cdr.c.

1390{
1391 struct ast_cdr *pub_cdr = NULL, *cdr_prev = NULL;
1392 struct cdr_object *it_cdr;
1393 struct ast_var_t *it_var, *it_copy_var;
1394 struct ast_channel_snapshot *party_a;
1395 struct ast_channel_snapshot *party_b;
1396
1397 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
1398 struct ast_cdr *cdr_copy;
1399
1400 /* Don't create records for CDRs where the party A was a dialed channel */
1401 if (snapshot_is_dialed(it_cdr->party_a.snapshot) && !it_cdr->party_b.snapshot) {
1402 ast_debug(1, "CDR for %s is dialed and has no Party B; discarding\n",
1403 it_cdr->party_a.snapshot->base->name);
1404 continue;
1405 }
1406
1407 cdr_copy = ast_calloc(1, sizeof(*cdr_copy));
1408 if (!cdr_copy) {
1410 return NULL;
1411 }
1412
1413 party_a = it_cdr->party_a.snapshot;
1414 party_b = it_cdr->party_b.snapshot;
1415
1416 /* Party A */
1417 ast_assert(party_a != NULL);
1418 ast_copy_string(cdr_copy->accountcode, party_a->base->accountcode, sizeof(cdr_copy->accountcode));
1419 cdr_copy->amaflags = party_a->amaflags;
1420 ast_copy_string(cdr_copy->channel, party_a->base->name, sizeof(cdr_copy->channel));
1421 ast_callerid_merge(cdr_copy->clid, sizeof(cdr_copy->clid), party_a->caller->name, party_a->caller->number, "");
1422 ast_copy_string(cdr_copy->src, party_a->caller->number, sizeof(cdr_copy->src));
1423 ast_copy_string(cdr_copy->uniqueid, party_a->base->uniqueid, sizeof(cdr_copy->uniqueid));
1424 ast_copy_string(cdr_copy->lastapp, it_cdr->appl, sizeof(cdr_copy->lastapp));
1425 ast_copy_string(cdr_copy->lastdata, it_cdr->data, sizeof(cdr_copy->lastdata));
1426 ast_copy_string(cdr_copy->dst, it_cdr->exten, sizeof(cdr_copy->dst));
1427 ast_copy_string(cdr_copy->dcontext, it_cdr->context, sizeof(cdr_copy->dcontext));
1428 ast_copy_string(cdr_copy->tenantid, party_a->base->tenantid, sizeof(cdr_copy->tenantid));
1429
1430 /* Party B */
1431 if (party_b) {
1432 ast_copy_string(cdr_copy->dstchannel, party_b->base->name, sizeof(cdr_copy->dstchannel));
1433 ast_copy_string(cdr_copy->peeraccount, party_b->base->accountcode, sizeof(cdr_copy->peeraccount));
1434 if (!ast_strlen_zero(it_cdr->party_b.userfield)) {
1435 snprintf(cdr_copy->userfield, sizeof(cdr_copy->userfield), "%s;%s", it_cdr->party_a.userfield, it_cdr->party_b.userfield);
1436 }
1437 ast_copy_string(cdr_copy->peertenantid, party_b->base->tenantid, sizeof(cdr_copy->peertenantid));
1438 }
1439 if (ast_strlen_zero(cdr_copy->userfield) && !ast_strlen_zero(it_cdr->party_a.userfield)) {
1440 ast_copy_string(cdr_copy->userfield, it_cdr->party_a.userfield, sizeof(cdr_copy->userfield));
1441 }
1442
1443 /* Timestamps/durations */
1444 cdr_copy->start = it_cdr->start;
1445 cdr_copy->answer = it_cdr->answer;
1446 cdr_copy->end = it_cdr->end;
1449
1450 /* Flags and IDs */
1452 ast_copy_string(cdr_copy->linkedid, it_cdr->linkedid, sizeof(cdr_copy->linkedid));
1453 cdr_copy->disposition = it_cdr->disposition;
1454 cdr_copy->sequence = it_cdr->sequence;
1455
1456 /* Variables */
1457 copy_variables(&cdr_copy->varshead, &it_cdr->party_a.variables);
1458 AST_LIST_TRAVERSE(&it_cdr->party_b.variables, it_var, entries) {
1459 int found = 0;
1460 struct ast_var_t *newvariable;
1461 AST_LIST_TRAVERSE(&cdr_copy->varshead, it_copy_var, entries) {
1462 if (!strcasecmp(ast_var_name(it_var), ast_var_name(it_copy_var))) {
1463 found = 1;
1464 break;
1465 }
1466 }
1467 if (!found && (newvariable = ast_var_assign(ast_var_name(it_var), ast_var_value(it_var)))) {
1468 AST_LIST_INSERT_TAIL(&cdr_copy->varshead, newvariable, entries);
1469 }
1470 }
1471
1472 if (!pub_cdr) {
1473 pub_cdr = cdr_copy;
1474 cdr_prev = pub_cdr;
1475 } else {
1476 cdr_prev->next = cdr_copy;
1477 cdr_prev = cdr_copy;
1478 }
1479 }
1480
1481 return pub_cdr;
1482}
char * ast_callerid_merge(char *buf, int bufsiz, const char *name, const char *num, const char *unknown)
Definition callerid.c:1273
static long cdr_object_get_duration(struct cdr_object *cdr)
Definition cdr.c:1329
static long cdr_object_get_billsec(struct cdr_object *cdr)
Compute the billsec for a cdr_object.
Definition cdr.c:1337
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 dia...
Definition cdr.c:1281
#define ast_var_assign(name, value)
Definition chanvars.h:40
#define AST_LIST_INSERT_TAIL(head, elm, field)
Appends a list entry to the tail of a list.
const ast_string_field tenantid
const ast_string_field accountcode
const ast_string_field number
const ast_string_field name
Structure representing a snapshot of channel state.
struct ast_channel_snapshot_caller * caller
#define ast_copy_flags(dest, src, flagz)
Definition utils.h:84
#define AST_FLAGS_ALL
Definition utils.h:214

References ast_channel_snapshot_base::accountcode, ast_channel_snapshot::amaflags, 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_channel_snapshot::caller, cdr_object_get_billsec(), cdr_object_get_duration(), copy_variables(), ast_var_t::entries, ast_channel_snapshot_caller::name, ast_channel_snapshot_base::name, ast_cdr::next, cdr_object::next, NULL, ast_channel_snapshot_caller::number, snapshot_is_dialed(), ast_cdr::start, cdr_object::start, ast_channel_snapshot_base::tenantid, ast_channel_snapshot_base::uniqueid, and ast_cdr::varshead.

Referenced by cdr_object_dispatch().

◆ cdr_object_dispatch()

static void cdr_object_dispatch ( struct cdr_object cdr)
static

Dispatch a CDR.

Parameters
cdrThe cdr_object to dispatch

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

Definition at line 1490 of file cdr.c.

1491{
1492 struct ast_cdr *pub_cdr;
1493
1494 CDR_DEBUG("%p - Dispatching CDR for Party A %s, Party B %s\n", cdr,
1495 cdr->party_a.snapshot->base->name,
1496 cdr->party_b.snapshot ? cdr->party_b.snapshot->base->name : "<none>");
1499}
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 register...
Definition cdr.c:1389
static void cdr_detach(struct ast_cdr *cdr)
Definition cdr.c:3989

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

Referenced by cdr_object_dispatch_all_cb(), and handle_channel_snapshot_update_message().

◆ cdr_object_dispatch_all_cb()

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

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

Definition at line 4412 of file cdr.c.

4413{
4414 struct cdr_object *cdr = obj;
4415 struct cdr_object *it_cdr;
4416
4417 ao2_lock(cdr);
4418 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
4420 }
4422 ao2_unlock(cdr);
4423
4424 cdr_all_unlink(cdr);
4425
4426 return CMP_MATCH;
4427}
static void cdr_all_unlink(struct cdr_object *cdr)
Definition cdr.c:1074
static void cdr_object_dispatch(struct cdr_object *cdr)
Dispatch a CDR.
Definition cdr.c:1490

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

Referenced by cdr_engine_shutdown().

◆ cdr_object_dtor()

static void cdr_object_dtor ( void *  obj)
static

cdr_object Destructor

Definition at line 1101 of file cdr.c.

1102{
1103 struct cdr_object *cdr = obj;
1104 struct ast_var_t *it_var;
1105
1108 while ((it_var = AST_LIST_REMOVE_HEAD(&cdr->party_a.variables, entries))) {
1109 ast_var_delete(it_var);
1110 }
1111 while ((it_var = AST_LIST_REMOVE_HEAD(&cdr->party_b.variables, entries))) {
1112 ast_var_delete(it_var);
1113 }
1115
1116 /* CDR destruction used to work by calling ao2_cleanup(next) and
1117 * allowing the chain to destroy itself neatly. Unfortunately, for
1118 * really long chains, this can result in a stack overflow. So now
1119 * when the root CDR is destroyed, it is responsible for unreffing
1120 * all CDRs in the chain
1121 */
1122 if (cdr->is_root) {
1123 struct cdr_object *curr = cdr->next;
1124 struct cdr_object *next;
1125
1126 while (curr) {
1127 next = curr->next;
1129 curr = next;
1130 }
1131 }
1132}
#define ast_string_field_free_memory(x)
free all memory - to be called before destroying the object

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

Referenced by cdr_object_alloc().

◆ cdr_object_finalize()

static void cdr_object_finalize ( struct cdr_object cdr)
static

Finalize a CDR.

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

Parameters
cdrThe CDR to finalize

Definition at line 1544 of file cdr.c.

1545{
1546 if (!ast_tvzero(cdr->end)) {
1547 return;
1548 }
1549 cdr->end = cdr->lastevent;
1550
1551 if (cdr->disposition == AST_CDR_NULL) {
1552 if (!ast_tvzero(cdr->answer)) {
1554 } else if (cdr->party_a.snapshot->hangup->cause) {
1556 } else if (cdr->party_b.snapshot && cdr->party_b.snapshot->hangup->cause) {
1558 } else {
1560 }
1561 }
1562
1563 /* tv_usec is suseconds_t, which could be int or long */
1564 ast_debug(1, "Finalized CDR for %s - start %ld.%06ld answer %ld.%06ld end %ld.%06ld dur %.3f bill %.3f dispo %s\n",
1565 cdr->party_a.snapshot->base->name,
1566 (long)cdr->start.tv_sec,
1567 (long)cdr->start.tv_usec,
1568 (long)cdr->answer.tv_sec,
1569 (long)cdr->answer.tv_usec,
1570 (long)cdr->end.tv_sec,
1571 (long)cdr->end.tv_usec,
1572 (double)ast_tvdiff_ms(cdr->end, cdr->start) / 1000.0,
1573 (double)ast_tvdiff_ms(cdr->end, cdr->answer) / 1000.0,
1575}
static void cdr_object_set_disposition(struct cdr_object *cdr, int hangupcause)
Set the disposition on a cdr_object based on a hangupcause code.
Definition cdr.c:1506
struct ast_channel_snapshot_hangup * hangup
struct timeval end
Definition cdr.c:824

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

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

◆ cdr_object_finalize_party_b()

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

Definition at line 2319 of file cdr.c.

2320{
2321 struct cdr_object *cdr = obj;
2322
2323 if (!strcasecmp(cdr->party_b_name, arg)) {
2324#ifdef AST_DEVMODE
2325 struct ast_channel_snapshot *party_b = data;
2326
2327 /*
2328 * For sanity's sake we also assert the party_b snapshot
2329 * is consistent with the key.
2330 */
2332 && !strcasecmp(cdr->party_b.snapshot->base->name, party_b->base->name));
2333#endif
2334
2335 /* Don't transition to the finalized state - let the Party A do
2336 * that when its ready
2337 */
2339 }
2340 return 0;
2341}

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

Referenced by handle_channel_snapshot_update_message().

◆ cdr_object_format_property()

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

Format one of the standard properties on a cdr_object.

Definition at line 3381 of file cdr.c.

3382{
3383 struct ast_channel_snapshot *party_a = cdr_obj->party_a.snapshot;
3384 struct ast_channel_snapshot *party_b = cdr_obj->party_b.snapshot;
3385
3386 if (!strcasecmp(name, "clid")) {
3387 ast_callerid_merge(value, length, party_a->caller->name, party_a->caller->number, "");
3388 } else if (!strcasecmp(name, "src")) {
3389 ast_copy_string(value, party_a->caller->number, length);
3390 } else if (!strcasecmp(name, "dst")) {
3391 ast_copy_string(value, party_a->dialplan->exten, length);
3392 } else if (!strcasecmp(name, "dcontext")) {
3393 ast_copy_string(value, party_a->dialplan->context, length);
3394 } else if (!strcasecmp(name, "channel")) {
3395 ast_copy_string(value, party_a->base->name, length);
3396 } else if (!strcasecmp(name, "dstchannel")) {
3397 if (party_b) {
3398 ast_copy_string(value, party_b->base->name, length);
3399 } else {
3400 ast_copy_string(value, "", length);
3401 }
3402 } else if (!strcasecmp(name, "lastapp")) {
3403 ast_copy_string(value, party_a->dialplan->appl, length);
3404 } else if (!strcasecmp(name, "lastdata")) {
3405 ast_copy_string(value, party_a->dialplan->data, length);
3406 } else if (!strcasecmp(name, "start")) {
3407 cdr_get_tv(cdr_obj->start, NULL, value, length);
3408 } else if (!strcasecmp(name, "answer")) {
3409 cdr_get_tv(cdr_obj->answer, NULL, value, length);
3410 } else if (!strcasecmp(name, "end")) {
3411 cdr_get_tv(cdr_obj->end, NULL, value, length);
3412 } else if (!strcasecmp(name, "duration")) {
3413 snprintf(value, length, "%ld", cdr_object_get_duration(cdr_obj));
3414 } else if (!strcasecmp(name, "billsec")) {
3415 snprintf(value, length, "%ld", cdr_object_get_billsec(cdr_obj));
3416 } else if (!strcasecmp(name, "disposition")) {
3417 snprintf(value, length, "%u", cdr_obj->disposition);
3418 } else if (!strcasecmp(name, "amaflags")) {
3419 snprintf(value, length, "%d", party_a->amaflags);
3420 } else if (!strcasecmp(name, "accountcode")) {
3421 ast_copy_string(value, party_a->base->accountcode, length);
3422 } else if (!strcasecmp(name, "peeraccount")) {
3423 if (party_b) {
3424 ast_copy_string(value, party_b->base->accountcode, length);
3425 } else {
3426 ast_copy_string(value, "", length);
3427 }
3428 } else if (!strcasecmp(name, "uniqueid")) {
3429 ast_copy_string(value, party_a->base->uniqueid, length);
3430 } else if (!strcasecmp(name, "linkedid")) {
3431 ast_copy_string(value, cdr_obj->linkedid, length);
3432 } else if (!strcasecmp(name, "tenantid")) {
3433 ast_copy_string(value, party_a->base->tenantid, length);
3434 } else if (!strcasecmp(name, "peertenantid")) {
3435 if (party_b) {
3436 ast_copy_string(value, party_b->base->tenantid, length);
3437 } else {
3438 ast_copy_string(value, "", length);
3439 }
3440 } else if (!strcasecmp(name, "userfield")) {
3441 ast_copy_string(value, cdr_obj->party_a.userfield, length);
3442 } else if (!strcasecmp(name, "sequence")) {
3443 snprintf(value, length, "%u", cdr_obj->sequence);
3444 } else {
3445 return 1;
3446 }
3447
3448 return 0;
3449}

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, name, 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::tenantid, ast_channel_snapshot_base::uniqueid, cdr_object_snapshot::userfield, and value.

Referenced by ast_cdr_getvar(), and ast_cdr_serialize_variables().

◆ cdr_object_format_var_internal()

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

Format a variable on a cdr_object.

Definition at line 3364 of file cdr.c.

3365{
3366 struct ast_var_t *variable;
3367
3368 AST_LIST_TRAVERSE(&cdr->party_a.variables, variable, entries) {
3369 if (!strcasecmp(name, ast_var_name(variable))) {
3370 ast_copy_string(value, ast_var_value(variable), length);
3371 return;
3372 }
3373 }
3374
3375 *value = '\0';
3376}

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

Referenced by ast_cdr_getvar().

◆ cdr_object_get_billsec()

static long cdr_object_get_billsec ( struct cdr_object cdr)
static

Compute the billsec for a cdr_object.

Definition at line 1337 of file cdr.c.

1338{
1339 long int ms;
1340
1341 if (ast_tvzero(cdr->answer)) {
1342 return 0;
1343 }
1344
1345 ms = ast_tvdiff_ms(ast_tvzero(cdr->end) ? ast_tvnow() : cdr->end, cdr->answer);
1346 if (ms % 1000 >= 500
1348 ms = (ms / 1000) + 1;
1349 } else {
1350 ms = ms / 1000;
1351 }
1352
1353 return ms;
1354}
@ CDR_INITIATED_SECONDS
Definition cdr.h:225
char * end
Definition eagi_proxy.c:73

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

Referenced by cdr_object_create_public_records(), and cdr_object_format_property().

◆ cdr_object_get_by_name()

static struct cdr_object * cdr_object_get_by_name ( const char *  name)
static

Definition at line 3458 of file cdr.c.

3459{
3460 char *param;
3461
3462 if (ast_strlen_zero(name)) {
3463 return NULL;
3464 }
3465
3466 param = ast_strdupa(name);
3468}
static int cdr_object_get_by_name_cb(void *obj, void *arg, int flags)
Definition cdr.c:3279

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

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

◆ cdr_object_get_by_name_cb()

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

Definition at line 3279 of file cdr.c.

3280{
3281 struct cdr_object *cdr = obj;
3282 const char *name = arg;
3283
3284 if (!strcasecmp(cdr->party_a.snapshot->base->name, name)) {
3285 return CMP_MATCH;
3286 }
3287 return 0;
3288}

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

Referenced by cdr_object_get_by_name().

◆ cdr_object_get_duration()

static long cdr_object_get_duration ( struct cdr_object cdr)
static

Compute the duration for a cdr_object

Definition at line 1329 of file cdr.c.

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

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

Referenced by cdr_object_create_public_records(), and cdr_object_format_property().

◆ cdr_object_party_b_left_bridge_cb()

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

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

Definition at line 2496 of file cdr.c.

2497{
2498 struct cdr_object *cdr = obj;
2499 struct bridge_leave_data *leave_data = data;
2500
2501 if (cdr->fn_table == &bridge_state_fn_table
2502 && !strcmp(cdr->bridge, leave_data->bridge->uniqueid)
2503 && !strcasecmp(cdr->party_b_name, arg)) {
2504 /*
2505 * For sanity's sake we also assert the party_b snapshot
2506 * is consistent with the key.
2507 */
2509 && !strcasecmp(cdr->party_b.snapshot->base->name, leave_data->channel->base->name));
2510
2511 /* It is our Party B, in our bridge. Set the last event and let the handler
2512 * transition our CDR appropriately when we leave the bridge.
2513 */
2514 cdr->lastevent = *leave_data->lastevent;
2516 }
2517 return 0;
2518}
const struct timeval * lastevent
Definition cdr.c:2492
struct ast_bridge_snapshot * bridge
Definition cdr.c:2490
struct ast_channel_snapshot * channel
Definition cdr.c:2491

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

Referenced by handle_bridge_leave_message().

◆ cdr_object_pick_party_a()

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

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

Parameters
leftOne of the snapshots
rightThe other snapshot
Returns
The snapshot that won

Definition at line 1294 of file cdr.c.

1295{
1296 /* Check whether or not the party is dialed. A dialed party is never the
1297 * Party A with a party that was not dialed.
1298 */
1299 if (!snapshot_is_dialed(left->snapshot) && snapshot_is_dialed(right->snapshot)) {
1300 return left;
1301 } else if (snapshot_is_dialed(left->snapshot) && !snapshot_is_dialed(right->snapshot)) {
1302 return right;
1303 }
1304
1305 /* Try the Party A flag */
1307 return left;
1309 return right;
1310 }
1311
1312 /* Neither party is dialed and neither has the Party A flag - defer to
1313 * creation time */
1314 if (left->snapshot->base->creationtime.tv_sec < right->snapshot->base->creationtime.tv_sec) {
1315 return left;
1316 } else if (left->snapshot->base->creationtime.tv_sec > right->snapshot->base->creationtime.tv_sec) {
1317 return right;
1318 } else if (left->snapshot->base->creationtime.tv_usec > right->snapshot->base->creationtime.tv_usec) {
1319 return right;
1320 } else {
1321 /* Okay, fine, take the left one */
1322 return left;
1323 }
1324}
@ AST_CDR_FLAG_PARTY_A
Definition cdr.h:247

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

Referenced by bridge_candidate_process(), and single_state_bridge_enter_comparison().

◆ cdr_object_select_all_by_name_cb()

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

Definition at line 3263 of file cdr.c.

3264{
3265 struct cdr_object *cdr = obj;
3266 const char *name = arg;
3267
3268 if (!strcasecmp(cdr->party_a.snapshot->base->name, name) ||
3269 (cdr->party_b.snapshot && !strcasecmp(cdr->party_b.snapshot->base->name, name))) {
3270 return CMP_MATCH;
3271 }
3272 return 0;
3273}

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

Referenced by ast_cdr_setvar().

◆ cdr_object_set_disposition()

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

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

Parameters
cdrThe cdr_object
hangupcauseThe Asterisk hangup cause code

Definition at line 1506 of file cdr.c.

1507{
1508 /* Change the disposition based on the hang up cause */
1509 switch (hangupcause) {
1510 case AST_CAUSE_BUSY:
1512 break;
1516 } else {
1518 }
1519 break;
1523 break;
1527 break;
1528 default:
1529 break;
1530 }
1531}
#define AST_CAUSE_CONGESTION
Definition causes.h:153
#define AST_CAUSE_NO_ROUTE_DESTINATION
Definition causes.h:100
#define AST_CAUSE_UNREGISTERED
Definition causes.h:154
#define AST_CAUSE_BUSY
Definition causes.h:149
#define AST_CAUSE_NO_ANSWER
Definition causes.h:109
#define AST_CAUSE_NORMAL_CLEARING
Definition causes.h:106
@ CDR_CONGESTION
Definition cdr.h:223

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

Referenced by cdr_object_finalize().

◆ cdr_object_snapshot_copy()

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

Copy a snapshot and its details.

Parameters
dstThe destination
srcThe source

Definition at line 896 of file cdr.c.

897{
898 ao2_t_replace(dst->snapshot, src->snapshot, "CDR snapshot copy");
899 strcpy(dst->userfield, src->userfield);
900 dst->flags = src->flags;
901 copy_variables(&dst->variables, &src->variables);
902}
#define ao2_t_replace(dst, src, tag)
Definition astobj2.h:504

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

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

◆ cdr_object_swap_snapshot()

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

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

Parameters
old_snapshotThe old cdr_object_snapshot
new_snapshotThe new ast_channel_snapshot for old_snapshot

Definition at line 1635 of file cdr.c.

1637{
1638 cdr_object_update_cid(old_snapshot, new_snapshot);
1639 ao2_t_replace(old_snapshot->snapshot, new_snapshot, "Swap CDR snapshot");
1640}
static void cdr_object_update_cid(struct cdr_object_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
Set Caller ID information on a CDR.
Definition cdr.c:1610

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

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

◆ cdr_object_transition_state()

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

◆ 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
cdrThe cdr_object to transition
fn_tableThe cdr_object_fn_table state to go to
do_init

Definition at line 910 of file cdr.c.

911{
912 CDR_DEBUG("%p - Transitioning CDR for %s from state %s to %s\n",
913 cdr, cdr->party_a.snapshot->base->name,
914 cdr->fn_table ? cdr->fn_table->name : "NONE", fn_table->name);
915 cdr->fn_table = fn_table;
916
917 if (cdr->fn_table->init_function && do_init) {
918 cdr->fn_table->init_function(cdr);
919 }
920}
const char * name
Name of the subclass.
Definition cdr.c:522
void(*const init_function)(struct cdr_object *cdr)
An initialization function. This will be called automatically when a cdr_object is switched to this t...
Definition cdr.c:531

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

Referenced by cdr_object_transition_state(), and dialed_pending_state_process_party_a().

◆ cdr_object_update_cid()

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

Set Caller ID information on a CDR.

Definition at line 1610 of file cdr.c.

1611{
1612 if (!old_snapshot->snapshot) {
1613 set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller->dnid);
1614 set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller->subaddr);
1615 set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->caller->dialed_subaddr);
1616 return;
1617 }
1618 if (strcmp(old_snapshot->snapshot->caller->dnid, new_snapshot->caller->dnid)) {
1619 set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller->dnid);
1620 }
1621 if (strcmp(old_snapshot->snapshot->caller->subaddr, new_snapshot->caller->subaddr)) {
1622 set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller->subaddr);
1623 }
1624 if (strcmp(old_snapshot->snapshot->caller->dialed_subaddr, new_snapshot->caller->dialed_subaddr)) {
1625 set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->caller->dialed_subaddr);
1626 }
1627}
const ast_string_field dialed_subaddr
const ast_string_field subaddr
const ast_string_field dnid

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

Referenced by cdr_object_swap_snapshot().

◆ cdr_object_update_party_b()

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

Definition at line 2343 of file cdr.c.

2344{
2345 struct cdr_object *cdr = obj;
2346
2347 if (cdr->fn_table->process_party_b
2348 && !strcasecmp(cdr->party_b_name, arg)) {
2349 struct ast_channel_snapshot *party_b = data;
2350
2351 /*
2352 * For sanity's sake we also check the party_b snapshot
2353 * for consistency with the key. The callback needs and
2354 * asserts the snapshot to be this way.
2355 */
2356 if (!cdr->party_b.snapshot
2357 || strcasecmp(cdr->party_b.snapshot->base->name, party_b->base->name)) {
2359 "CDR for Party A %s(%s) has inconsistent Party B %s name. Message can be ignored but this shouldn't happen.\n",
2360 cdr->linkedid,
2361 cdr->party_a.snapshot->base->name,
2362 cdr->party_b_name);
2363 return 0;
2364 }
2365
2366 cdr->fn_table->process_party_b(cdr, party_b);
2367 }
2368 return 0;
2369}
void(*const process_party_b)(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Process a Party B update for the cdr_object.
Definition cdr.c:550

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

Referenced by handle_channel_snapshot_update_message().

◆ cdr_object_update_party_b_userfield_cb()

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

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

Definition at line 3603 of file cdr.c.

3604{
3605 struct cdr_object *cdr = obj;
3606
3607 if ((cdr->fn_table != &finalized_state_fn_table || !cdr->next)
3608 && !strcasecmp(cdr->party_b_name, arg)) {
3609 struct party_b_userfield_update *info = data;
3610
3611 /*
3612 * For sanity's sake we also assert the party_b snapshot
3613 * is consistent with the key.
3614 */
3616 && !strcasecmp(cdr->party_b.snapshot->base->name, info->channel_name));
3617
3618 ast_copy_string(cdr->party_b.userfield, info->userfield,
3619 sizeof(cdr->party_b.userfield));
3620 }
3621
3622 return 0;
3623}

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

Referenced by ast_cdr_setuserfield().

◆ cdr_submit_batch()

static void cdr_submit_batch ( int  shutdown)
static

Definition at line 3914 of file cdr.c.

3915{
3916 struct module_config *mod_cfg;
3917 struct cdr_batch_item *oldbatchitems = NULL;
3918 pthread_t batch_post_thread = AST_PTHREADT_NULL;
3919
3920 /* if there's no batch, or no CDRs in the batch, then there's nothing to do */
3921 if (!batch || !batch->head) {
3922 return;
3923 }
3924
3925 /* move the old CDRs aside, and prepare a new CDR batch */
3927 oldbatchitems = batch->head;
3928 reset_batch();
3930
3931 mod_cfg = ao2_global_obj_ref(module_configs);
3932
3933 /* if configured, spawn a new thread to post these CDRs,
3934 also try to save as much as possible if we are shutting down safely */
3935 if (!mod_cfg
3937 || do_shutdown) {
3938 ast_debug(1, "CDR single-threaded batch processing begins now\n");
3939 do_batch_backend_process(oldbatchitems);
3940 } else {
3941 if (ast_pthread_create_detached_background(&batch_post_thread, NULL, do_batch_backend_process, oldbatchitems)) {
3942 ast_log(LOG_WARNING, "CDR processing thread could not detach, now trying in this thread\n");
3943 do_batch_backend_process(oldbatchitems);
3944 } else {
3945 ast_debug(1, "CDR multi-threaded batch processing begins now\n");
3946 }
3947 }
3948
3949 ao2_cleanup(mod_cfg);
3950}
static void reset_batch(void)
Definition cdr.c:3878
static void * do_batch_backend_process(void *data)
Definition cdr.c:3897
@ BATCH_MODE_SCHEDULER_ONLY
Definition cdr.h:235
struct ast_flags settings
Definition cdr.h:274
struct ast_cdr_config::batch_settings batch_settings
#define ast_pthread_create_detached_background(a, b, c, d)
Definition utils.h:634

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

Referenced by ast_cdr_engine_term(), and submit_scheduled_batch().

◆ cdr_toggle_runtime_options()

static int cdr_toggle_runtime_options ( void  )
static

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

Definition at line 4640 of file cdr.c.

4641{
4642 struct module_config *mod_cfg;
4643
4644 mod_cfg = ao2_global_obj_ref(module_configs);
4645 if (mod_cfg
4646 && ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
4647 if (create_subscriptions()) {
4649 ast_log(AST_LOG_ERROR, "Failed to create Stasis subscriptions\n");
4650 ao2_cleanup(mod_cfg);
4651 return -1;
4652 }
4653 if (ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
4655 } else {
4656 ast_log(LOG_NOTICE, "CDR simple logging enabled.\n");
4657 }
4658 } else {
4660 ast_log(LOG_NOTICE, "CDR logging disabled.\n");
4661 }
4662 ao2_cleanup(mod_cfg);
4663
4664 return mod_cfg ? 0 : -1;
4665}
static int create_subscriptions(void)
Create the Stasis subscriptions for CDRs.
Definition cdr.c:4466
static void cdr_enable_batch_mode(struct ast_cdr_config *config)
Definition cdr.c:4572
static void destroy_subscriptions(void)
Destroy the active Stasis subscriptions.
Definition cdr.c:4456
struct ast_flags settings
Definition cdr.h:270

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

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

◆ check_new_cdr_needed()

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

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

Definition at line 2372 of file cdr.c.

2374{
2375 /* If we're dead, we don't need a new CDR */
2376 if (!new_snapshot
2379 return 0;
2380 }
2381
2382 /* Auto-fall through will increment the priority but have no application */
2383 if (ast_strlen_zero(new_snapshot->dialplan->appl)) {
2384 return 0;
2385 }
2386
2387 if (old_snapshot && !snapshot_cep_changed(old_snapshot, new_snapshot)) {
2388 return 0;
2389 }
2390
2391 return 1;
2392}
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 log...
Definition cdr.c:1250

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

Referenced by handle_channel_snapshot_update_message().

◆ cli_complete_show()

static char * cli_complete_show ( struct ast_cli_args a)
static

Complete user input for 'cdr show'.

Definition at line 4118 of file cdr.c.

4119{
4120 int wordlen = strlen(a->word);
4121 struct ao2_iterator it_cdrs;
4122 struct cdr_object *cdr;
4123
4125 while ((cdr = ao2_iterator_next(&it_cdrs))) {
4126 if (!strncasecmp(a->word, cdr->party_a.snapshot->base->name, wordlen)) {
4128 ao2_ref(cdr, -1);
4129 break;
4130 }
4131 }
4132 ao2_ref(cdr, -1);
4133 }
4135
4136 return NULL;
4137}
#define ast_strdup(str)
A wrapper for strdup()
Definition astmm.h:241
struct ao2_iterator ao2_iterator_init(struct ao2_container *c, int flags) attribute_warn_unused_result
Create an iterator for a container.
int ast_cli_completion_add(char *value)
Add a result to a request for completion options.
Definition main/cli.c:2737
static struct test_val a

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

Referenced by handle_cli_show().

◆ cli_show_channel()

static void cli_show_channel ( struct ast_cli_args a)
static

Definition at line 4203 of file cdr.c.

4204{
4205 struct cdr_object *it_cdr;
4206 char clid[64];
4207 char start_time_buffer[64];
4208 char answer_time_buffer[64];
4209 char end_time_buffer[64];
4210 const char *channel_name = a->argv[3];
4211 struct cdr_object *cdr;
4212
4213#define TITLE_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"
4214#define FORMAT_STRING "%-10.10s %-20.20s %-25.25s %-15.15s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"
4215
4216 cdr = cdr_object_get_by_name(channel_name);
4217 if (!cdr) {
4218 ast_cli(a->fd, "Unknown channel: %s\n", channel_name);
4219 return;
4220 }
4221
4222 ast_cli(a->fd, "\n");
4223 ast_cli(a->fd, "Call Detail Record (CDR) Information for %s\n", channel_name);
4224 ast_cli(a->fd, "--------------------------------------------------\n");
4225 ast_cli(a->fd, TITLE_STRING, "AccountCode", "CallerID", "Dst. Channel", "LastApp", "Data", "Start", "Answer", "End", "Billsec", "Duration");
4226
4227 ao2_lock(cdr);
4228 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
4229 struct timeval end;
4230
4231 if (snapshot_is_dialed(it_cdr->party_a.snapshot)) {
4232 continue;
4233 }
4234 ast_callerid_merge(clid, sizeof(clid), it_cdr->party_a.snapshot->caller->name, it_cdr->party_a.snapshot->caller->number, "");
4235 if (ast_tvzero(it_cdr->end)) {
4236 end = ast_tvnow();
4237 } else {
4238 end = it_cdr->end;
4239 }
4240 cdr_get_tv(it_cdr->start, "%T", start_time_buffer, sizeof(start_time_buffer));
4241 cdr_get_tv(it_cdr->answer, "%T", answer_time_buffer, sizeof(answer_time_buffer));
4242 cdr_get_tv(end, "%T", end_time_buffer, sizeof(end_time_buffer));
4243 ast_cli(a->fd, FORMAT_STRING,
4244 it_cdr->party_a.snapshot->base->accountcode,
4245 clid,
4246 it_cdr->party_b.snapshot ? it_cdr->party_b.snapshot->base->name : "<none>",
4247 it_cdr->appl,
4248 it_cdr->data,
4249 start_time_buffer,
4250 answer_time_buffer,
4251 end_time_buffer,
4252 (long)ast_tvdiff_ms(end, it_cdr->answer) / 1000,
4253 (long)ast_tvdiff_ms(end, it_cdr->start) / 1000);
4254 }
4255 ao2_unlock(cdr);
4256
4257 ao2_cleanup(cdr);
4258
4259#undef FORMAT_STRING
4260#undef TITLE_STRING
4261}
#define FORMAT_STRING
#define TITLE_STRING
void ast_cli(int fd, const char *fmt,...)
Definition clicompat.c:6

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

Referenced by handle_cli_show().

◆ cli_show_channels()

static void cli_show_channels ( struct ast_cli_args a)
static

Definition at line 4139 of file cdr.c.

4140{
4141 struct ao2_iterator it_cdrs;
4142 struct cdr_object *cdr;
4143 char start_time_buffer[64];
4144 char answer_time_buffer[64];
4145 char end_time_buffer[64];
4146
4147#define TITLE_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"
4148#define FORMAT_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"
4149
4150 ast_cli(a->fd, "\n");
4151 ast_cli(a->fd, "Channels with Call Detail Record (CDR) Information\n");
4152 ast_cli(a->fd, "--------------------------------------------------\n");
4153 ast_cli(a->fd, TITLE_STRING, "Channel", "Dst. Channel", "LastApp", "Start", "Answer", "End", "Billsec", "Duration");
4154
4156 for (; (cdr = ao2_iterator_next(&it_cdrs)); ao2_cleanup(cdr)) {
4157 struct cdr_object *it_cdr;
4158 struct timeval start_time = { 0, };
4159 struct timeval answer_time = { 0, };
4160 struct timeval end_time = { 0, };
4161
4162 SCOPED_AO2LOCK(lock, cdr);
4163
4164 /* Calculate the start, end, answer, billsec, and duration over the
4165 * life of all of the CDR entries
4166 */
4167 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
4168 if (snapshot_is_dialed(it_cdr->party_a.snapshot)) {
4169 continue;
4170 }
4171 if (ast_tvzero(start_time)) {
4172 start_time = it_cdr->start;
4173 }
4174 if (!ast_tvzero(it_cdr->answer) && ast_tvzero(answer_time)) {
4175 answer_time = it_cdr->answer;
4176 }
4177 }
4178
4179 /* If there was no start time, then all CDRs were for a dialed channel; skip */
4180 if (ast_tvzero(start_time)) {
4181 continue;
4182 }
4183 it_cdr = cdr->last;
4184
4185 end_time = ast_tvzero(it_cdr->end) ? ast_tvnow() : it_cdr->end;
4186 cdr_get_tv(start_time, "%T", start_time_buffer, sizeof(start_time_buffer));
4187 cdr_get_tv(answer_time, "%T", answer_time_buffer, sizeof(answer_time_buffer));
4188 cdr_get_tv(end_time, "%T", end_time_buffer, sizeof(end_time_buffer));
4190 it_cdr->party_b.snapshot ? it_cdr->party_b.snapshot->base->name : "<none>",
4191 it_cdr->appl,
4192 start_time_buffer,
4193 answer_time_buffer,
4194 end_time_buffer,
4195 ast_tvzero(answer_time) ? 0 : (long)ast_tvdiff_ms(end_time, answer_time) / 1000,
4196 (long)ast_tvdiff_ms(end_time, start_time) / 1000);
4197 }
4198 ao2_iterator_destroy(&it_cdrs);
4199#undef FORMAT_STRING
4200#undef TITLE_STRING
4201}

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

Referenced by handle_cli_show().

◆ CONFIG_INFO_CORE()

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

◆ copy_variables()

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

Copy variables from one list to another.

Parameters
to_listdestination
from_listsource
Returns
The number of copied variables

Definition at line 851 of file cdr.c.

852{
853 struct ast_var_t *variables;
854 struct ast_var_t *newvariable;
855 const char *var;
856 const char *val;
857 int x = 0;
858
859 AST_LIST_TRAVERSE(from_list, variables, entries) {
860 var = ast_var_name(variables);
861 if (ast_strlen_zero(var)) {
862 continue;
863 }
864 val = ast_var_value(variables);
865 if (ast_strlen_zero(val)) {
866 continue;
867 }
868 newvariable = ast_var_assign(var, val);
869 if (newvariable) {
870 AST_LIST_INSERT_HEAD(to_list, newvariable, entries);
871 ++x;
872 }
873 }
874
875 return x;
876}
#define AST_LIST_INSERT_HEAD(head, elm, field)
Inserts a list entry at the head of a list.

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

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

◆ create_subscriptions()

static int create_subscriptions ( void  )
static

Create the Stasis subscriptions for CDRs.

Definition at line 4466 of file cdr.c.

4467{
4468 if (!cdr_topic) {
4469 return -1;
4470 }
4471
4473 return 0;
4474 }
4475
4477 if (!channel_subscription) {
4478 return -1;
4479 }
4481 if (!bridge_subscription) {
4482 return -1;
4483 }
4485 if (!parking_subscription) {
4486 return -1;
4487 }
4488
4489 return 0;
4490}
static struct stasis_forward * bridge_subscription
Our subscription for bridges.
Definition cdr.c:478
static struct stasis_forward * channel_subscription
Our subscription for channels.
Definition cdr.c:481
static struct stasis_forward * parking_subscription
Our subscription for parking.
Definition cdr.c:484
struct stasis_topic * ast_parking_topic(void)
accessor for the parking stasis topic
Definition parking.c:67
struct stasis_topic * ast_channel_topic_all(void)
A topic which publishes the events for all channels.
struct stasis_forward * stasis_forward_all(struct stasis_topic *from_topic, struct stasis_topic *to_topic)
Create a subscription which forwards all messages from one topic to another.
Definition stasis.c:1645
struct stasis_topic * ast_bridge_topic_all(void)
A topic which publishes the events for all bridges.

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

Referenced by cdr_toggle_runtime_options().

◆ destroy_subscriptions()

static void destroy_subscriptions ( void  )
static

◆ dial_state_process_bridge_enter()

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

Definition at line 1990 of file cdr.c.

1991{
1992 int success = 0;
1993
1994 ast_string_field_set(cdr, bridge, bridge->uniqueid);
1995
1996 /* Get parties in the bridge */
1997 if (ao2_container_count(bridge->channels) == 1) {
1998 /* No one in the bridge yet but us! */
2001 }
2002
2003 /* If we don't have a Party B (originated channel), skip it */
2004 if (cdr->party_b.snapshot) {
2005 struct ao2_iterator it_cdrs;
2006 char *channel_id;
2007
2008 for (it_cdrs = ao2_iterator_init(bridge->channels, 0);
2009 !success && (channel_id = ao2_iterator_next(&it_cdrs));
2010 ao2_ref(channel_id, -1)) {
2012 struct cdr_object *cand_cdr;
2013
2015 if (!cand_cdr_master) {
2016 continue;
2017 }
2018
2021 /* Skip any records that are not in a bridge or in this bridge.
2022 * I'm not sure how that would happen, but it pays to be careful. */
2023 if (cand_cdr->fn_table != &bridge_state_fn_table
2024 || strcmp(cdr->bridge, cand_cdr->bridge)) {
2025 continue;
2026 }
2027
2028 /* Skip any records that aren't our Party B */
2029 if (strcasecmp(cdr->party_b.snapshot->base->name, cand_cdr->party_a.snapshot->base->name)) {
2030 continue;
2031 }
2032 cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
2033 /* If they have a Party B, they joined up with someone else as their
2034 * Party A. Don't finalize them as they're active. Otherwise, we
2035 * have stolen them so they need to be finalized.
2036 */
2037 if (!cand_cdr->party_b.snapshot) {
2039 }
2040 success = 1;
2041 break;
2042 }
2045 }
2047 }
2048
2049 /* We always transition state, even if we didn't get a peer */
2051
2052 /* Success implies that we have a Party B */
2053 if (success) {
2055 }
2057}
#define ao2_find(container, arg, flags)
Definition astobj2.h:1736
struct ao2_container * channels
Definition bridge.h:335

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

◆ dial_state_process_dial_begin()

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

Definition at line 1920 of file cdr.c.

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

◆ dial_state_process_dial_end()

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

Definition at line 1958 of file cdr.c.

1959{
1960 struct ast_channel_snapshot *party_a;
1961
1962 if (caller) {
1963 party_a = caller;
1964 } else {
1965 party_a = peer;
1966 }
1967 ast_assert(!strcasecmp(cdr->party_a.snapshot->base->name, party_a->base->name));
1968 cdr_object_swap_snapshot(&cdr->party_a, party_a);
1969
1970 if (cdr->party_b.snapshot) {
1971 if (strcasecmp(cdr->party_b.snapshot->base->name, peer->base->name)) {
1972 /* Not the status for this CDR - defer back to the message router */
1973 return 1;
1974 }
1976 }
1977
1978 /* Set the disposition based on the dial string. */
1979 cdr->disposition = dial_status_to_disposition(dial_status);
1980 if (cdr->disposition == AST_CDR_ANSWERED) {
1981 /* Switch to dial pending to wait and see what the caller does */
1983 } else {
1985 }
1986
1987 return 0;
1988}
static enum ast_cdr_disposition dial_status_to_disposition(const char *dial_status)
Definition cdr.c:1932
struct cdr_object_fn_table dialed_pending_state_fn_table
The virtual table for the Dialed Pending state.
Definition cdr.c:741

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

◆ dial_state_process_party_b()

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

◆ dial_status_end()

static int dial_status_end ( const char *  dialstatus)
static

Definition at line 2199 of file cdr.c.

2200{
2201 return (strcmp(dialstatus, "RINGING") &&
2202 strcmp(dialstatus, "PROCEEDING") &&
2203 strcmp(dialstatus, "PROGRESS"));
2204}

References cdr_object::start.

Referenced by handle_dial_message().

◆ dial_status_to_disposition()

static enum ast_cdr_disposition dial_status_to_disposition ( const char *  dial_status)
static

Definition at line 1932 of file cdr.c.

1933{
1934 if (!strcmp(dial_status, "ANSWER")) {
1935 return AST_CDR_ANSWERED;
1936 } else if (!strcmp(dial_status, "BUSY")) {
1937 return AST_CDR_BUSY;
1938 } else if (!strcmp(dial_status, "CANCEL")) {
1940 return AST_CDR_NOANSWER;
1941 } else {
1942 return AST_CDR_CANCEL;
1943 }
1944 } else if (!strcmp(dial_status, "NOANSWER")) {
1945 return AST_CDR_NOANSWER;
1946 } else if (!strcmp(dial_status, "CONGESTION")) {
1948 return AST_CDR_FAILED;
1949 } else {
1950 return AST_CDR_CONGESTION;
1951 }
1952 } else if (!strcmp(dial_status, "FAILED")) {
1953 return AST_CDR_FAILED;
1954 }
1955 return AST_CDR_FAILED;
1956}
@ CDR_CANCEL_DISPOSITION_ENABLED
Definition cdr.h:230

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

Referenced by dial_state_process_dial_end(), and handle_dial_message().

◆ dialed_pending_state_process_bridge_enter()

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

Definition at line 2086 of file cdr.c.

2087{
2089 return cdr->fn_table->process_bridge_enter(cdr, bridge, channel);
2090}
struct cdr_object_fn_table dial_state_fn_table
The virtual table for the Dial state.
Definition cdr.c:708
enum process_bridge_enter_results(*const process_bridge_enter)(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Process the entering of a bridge by this CDR. The purpose of this callback is to have the CDR prepare...
Definition cdr.c:607

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

◆ dialed_pending_state_process_dial_begin()

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

Definition at line 2102 of file cdr.c.

2103{
2105
2106 /* Ask for a new CDR */
2107 return 1;
2108}

References cdr_object_transition_state(), and finalized_state_fn_table.

◆ dialed_pending_state_process_parking_bridge_enter()

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

Definition at line 2092 of file cdr.c.

2093{
2094 if (cdr->party_b.snapshot) {
2095 /* We can't handle this as we have a Party B - ask for a new one */
2096 return 1;
2097 }
2099 return 0;
2100}
struct cdr_object_fn_table parked_state_fn_table
The virtual table for the Parked state.
Definition cdr.c:782

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

◆ dialed_pending_state_process_party_a()

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

Definition at line 2061 of file cdr.c.

2062{
2063 /* If we get a CEP change, we're executing dialplan. If we have a Party B
2064 * that means we need a new CDR; otherwise, switch us over to single.
2065 */
2066 if (snapshot_cep_changed(cdr->party_a.snapshot, snapshot)) {
2067 if (cdr->party_b.snapshot) {
2069 cdr->fn_table->process_party_a(cdr, snapshot);
2070 return 1;
2071 } else {
2072 /* The CDR does not need to be reinitialized when transitioning
2073 * to its single state as this would overwrite the start time,
2074 * causing potentially both the answer and the start time to be
2075 * the same which is incorrect.
2076 */
2078 cdr->fn_table->process_party_a(cdr, snapshot);
2079 return 0;
2080 }
2081 }
2082 base_process_party_a(cdr, snapshot);
2083 return 0;
2084}
static int base_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Definition cdr.c:1644

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

◆ do_batch_backend_process()

static void * do_batch_backend_process ( void *  data)
static

Definition at line 3897 of file cdr.c.

3898{
3899 struct cdr_batch_item *processeditem;
3900 struct cdr_batch_item *batchitem = data;
3901
3902 /* Push each CDR into storage mechanism(s) and free all the memory */
3903 while (batchitem) {
3904 post_cdr(batchitem->cdr);
3905 ast_cdr_free(batchitem->cdr);
3906 processeditem = batchitem;
3907 batchitem = batchitem->next;
3908 ast_free(processeditem);
3909 }
3910
3911 return NULL;
3912}

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

Referenced by cdr_submit_batch().

◆ do_cdr()

static void * do_cdr ( void *  data)
static

Definition at line 4051 of file cdr.c.

4052{
4053 struct timespec timeout;
4054 int schedms;
4055 int numevents = 0;
4056
4057 for (;;) {
4058 struct timeval now;
4059 schedms = ast_sched_wait(sched);
4060 /* this shouldn't happen, but provide a 1 second default just in case */
4061 if (schedms < 0)
4062 schedms = 1000;
4063 now = ast_tvadd(ast_tvnow(), ast_samp2tv(schedms, 1000));
4064 timeout.tv_sec = now.tv_sec;
4065 timeout.tv_nsec = now.tv_usec * 1000;
4066 /* prevent stuff from clobbering cdr_pending_cond, then wait on signals sent to it until the timeout expires */
4069 numevents = ast_sched_runq(sched);
4071 ast_debug(2, "Processed %d CDR batches from the run queue\n", numevents);
4072 }
4073
4074 return NULL;
4075}
static ast_mutex_t cdr_pending_lock
These are used to wake up the CDR thread when there's work to do.
Definition cdr.c:465
#define ast_cond_timedwait(cond, mutex, time)
Definition lock.h:213
int ast_sched_runq(struct ast_sched_context *con)
Runs the queue.
Definition sched.c:786
int ast_sched_wait(struct ast_sched_context *con) attribute_warn_unused_result
Determines number of seconds until the next outstanding event to take place.
Definition sched.c:433
struct timeval ast_samp2tv(unsigned int _nsamp, unsigned int _rate)
Returns a timeval corresponding to the duration of n samples at rate r. Useful to convert samples to ...
Definition time.h:282
struct timeval ast_tvadd(struct timeval a, struct timeval b)
Returns the sum of two timevals a + b.
Definition extconf.c:2280

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

Referenced by cdr_enable_batch_mode().

◆ filter_bridge_messages()

static int filter_bridge_messages ( struct ast_bridge_snapshot bridge)
static

Filter bridge messages based on bridge technology.

Definition at line 2521 of file cdr.c.

2522{
2523 /* Ignore holding bridge technology messages. We treat this simply as an application
2524 * that a channel enters into.
2525 */
2526 if (!strcmp(bridge->technology, "holding_bridge") && strcmp(bridge->subclass, "parking")) {
2527 return 1;
2528 }
2529 return 0;
2530}
const ast_string_field technology
Definition bridge.h:332
const ast_string_field subclass
Definition bridge.h:332

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

Referenced by handle_bridge_enter_message(), and handle_bridge_leave_message().

◆ filter_channel_snapshot()

static int filter_channel_snapshot ( struct ast_channel_snapshot snapshot)
static

Definition at line 2174 of file cdr.c.

2175{
2176 return snapshot->base->tech_properties & AST_CHAN_TP_INTERNAL;
2177}
@ AST_CHAN_TP_INTERNAL
Channels with this particular technology are an implementation detail of Asterisk and should generall...
Definition channel.h:991

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

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

◆ filter_channel_snapshot_message()

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

Definition at line 2183 of file cdr.c.

2185{
2186 int ret = 0;
2187
2188 /* Drop cache updates from certain channel technologies */
2189 if (old_snapshot) {
2190 ret |= filter_channel_snapshot(old_snapshot);
2191 }
2192 if (new_snapshot) {
2193 ret |= filter_channel_snapshot(new_snapshot);
2194 }
2195
2196 return ret;
2197}
static int filter_channel_snapshot(struct ast_channel_snapshot *snapshot)
Definition cdr.c:2174

References filter_channel_snapshot().

Referenced by handle_channel_snapshot_update_message().

◆ finalize_batch_mode()

static void finalize_batch_mode ( void  )
static

Definition at line 4429 of file cdr.c.

4430{
4432 return;
4433 }
4434 /* wake up the thread so it will exit */
4435 pthread_cancel(cdr_thread);
4436 pthread_kill(cdr_thread, SIGURG);
4437 pthread_join(cdr_thread, NULL);
4441}
void ast_cdr_engine_term(void)
Definition cdr.c:4753
#define ast_cond_destroy(cond)
Definition lock.h:209

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

Referenced by cdr_engine_shutdown(), and reload_module().

◆ finalized_state_init_function()

static void finalized_state_init_function ( struct cdr_object cdr)
static

Definition at line 2154 of file cdr.c.

2155{
2157}

References cdr_object_finalize().

◆ finalized_state_process_party_a()

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

Definition at line 2159 of file cdr.c.

2160{
2163 return 0;
2164 }
2165
2166 /* Indicate that, if possible, we should get a new CDR */
2167 return 1;
2168}

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

◆ free_variables()

static void free_variables ( struct varshead headp)
static

Delete all variables from a variable list.

Parameters
headpThe head pointer to the variable list to delete

Definition at line 882 of file cdr.c.

883{
884 struct ast_var_t *vardata;
885
886 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries))) {
887 ast_var_delete(vardata);
888 }
889}

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

Referenced by ast_cdr_fork(), and ast_cdr_free().

◆ handle_bridge_enter_message()

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

Definition at line 2843 of file cdr.c.

2845{
2847 struct ast_bridge_snapshot *bridge = update->bridge;
2848 struct ast_channel_snapshot *channel = update->channel;
2849 struct cdr_object *cdr;
2850
2852 return;
2853 }
2854
2855 if (filter_channel_snapshot(channel)) {
2856 return;
2857 }
2858
2859 CDR_DEBUG("Bridge Enter message for channel %s: %u.%08u\n",
2860 channel->base->name,
2861 (unsigned int)stasis_message_timestamp(message)->tv_sec,
2862 (unsigned int)stasis_message_timestamp(message)->tv_usec);
2863
2865 if (!cdr) {
2866 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->base->name);
2867 ast_assert(0);
2868 return;
2869 }
2870
2871 if (!strcmp(bridge->subclass, "parking")) {
2873 } else {
2875 }
2876 ao2_cleanup(cdr);
2877}
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.
Definition cdr.c:2763
static int filter_bridge_messages(struct ast_bridge_snapshot *bridge)
Filter bridge messages based on bridge technology.
Definition cdr.c:2521
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.
Definition cdr.c:2721
static void update(int code_size, int y, int wi, int fi, int dq, int sr, int dqsez, struct g726_state *state_ptr)
Definition codec_g726.c:367
void * stasis_message_data(const struct stasis_message *msg)
Get the data contained in a message.
const struct timeval * stasis_message_timestamp(const struct stasis_message *msg)
Get the time when a message was created.
Blob of data associated with a bridge.
Structure that contains a snapshot of information about a bridge.
Definition bridge.h:318

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

Referenced by load_module().

◆ handle_bridge_leave_message()

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

Handler for when a channel leaves a bridge.

Parameters
dataPassed on
subThe stasis subscription for this message callback
messageThe message - hopefully a bridge one!

Definition at line 2538 of file cdr.c.

2540{
2542 struct ast_bridge_snapshot *bridge = update->bridge;
2543 struct ast_channel_snapshot *channel = update->channel;
2544 struct cdr_object *cdr;
2545 struct cdr_object *it_cdr;
2546 struct bridge_leave_data leave_data = {
2547 .bridge = bridge,
2548 .channel = channel,
2549 .lastevent = stasis_message_timestamp(message)
2550 };
2551 int left_bridge = 0;
2552
2554 return;
2555 }
2556
2558 return;
2559 }
2560
2561 CDR_DEBUG("Bridge Leave message for %s: %u.%08u\n",
2562 channel->base->name,
2563 (unsigned int)leave_data.lastevent->tv_sec,
2564 (unsigned int)leave_data.lastevent->tv_usec);
2565
2567 if (!cdr) {
2568 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->base->name);
2569 ast_assert(0);
2570 return;
2571 }
2572
2573 /* Party A */
2574 ao2_lock(cdr);
2575 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2576 it_cdr->lastevent = *leave_data.lastevent;
2577 if (!it_cdr->fn_table->process_bridge_leave) {
2578 continue;
2579 }
2580 CDR_DEBUG("%p - Processing Bridge Leave for %s\n",
2581 it_cdr, channel->base->name);
2582 if (!it_cdr->fn_table->process_bridge_leave(it_cdr, bridge, channel)) {
2583 ast_string_field_set(it_cdr, bridge, "");
2584 left_bridge = 1;
2585 }
2586 }
2587 ao2_unlock(cdr);
2588
2589 /* Party B */
2590 if (left_bridge
2591 && strcmp(bridge->subclass, "parking")) {
2593 cdr_object_party_b_left_bridge_cb, (char *) leave_data.channel->base->name,
2594 &leave_data);
2595 }
2596
2597 ao2_cleanup(cdr);
2598}
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.
Definition cdr.c:2496
int(*const process_bridge_leave)(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Process the leaving of a bridge by this CDR.
Definition cdr.c:637

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

Referenced by load_module().

◆ handle_bridge_pairings()

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

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

Parameters
cdrThe cdr_object that just entered the bridge
bridgeThe ast_bridge_snapshot representing the bridge it just entered

Definition at line 2695 of file cdr.c.

2696{
2697 struct ao2_iterator it_channels;
2698 char *channel_id;
2699
2700 it_channels = ao2_iterator_init(bridge->channels, 0);
2701 while ((channel_id = ao2_iterator_next(&it_channels))) {
2702 struct cdr_object *cand_cdr;
2703
2705 if (cand_cdr) {
2707 ao2_ref(cand_cdr, -1);
2708 }
2709
2710 ao2_ref(channel_id, -1);
2711 }
2713}
static void bridge_candidate_process(struct cdr_object *cdr, struct cdr_object *base_cand_cdr)
Process a single bridge_candidate.
Definition cdr.c:2637

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

Referenced by handle_standard_bridge_enter_message().

◆ handle_cdr_sync_message()

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

Handler for a synchronization message.

Parameters
dataPassed on
subThe stasis subscription for this message callback
messageA blank ao2 object

Definition at line 2953 of file cdr.c.

2955{
2956 return;
2957}

Referenced by load_module().

◆ handle_channel_snapshot_update_message()

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

Handler for channel snapshot update messages.

Parameters
dataPassed on
subThe stasis subscription for this message callback
messageThe message

Definition at line 2400 of file cdr.c.

2401{
2402 struct cdr_object *cdr;
2404 struct cdr_object *it_cdr;
2405
2406 if (filter_channel_snapshot_message(update->old_snapshot, update->new_snapshot)) {
2407 return;
2408 }
2409
2410 if (update->new_snapshot && !update->old_snapshot) {
2411 struct module_config *mod_cfg = NULL;
2412
2414 if (!cdr) {
2415 return;
2416 }
2417 mod_cfg = ao2_global_obj_ref(module_configs);
2418 cdr->is_root = 1;
2420
2421 /* If CDR should be disabled unless enabled on a per-channel basis, then disable
2422 CDR, right from the get go */
2423 if (mod_cfg) {
2425 ast_debug(3, "Disable CDR by default\n");
2427 }
2428 ao2_cleanup(mod_cfg);
2429 }
2430 } else {
2431 cdr = ao2_find(active_cdrs_master, update->new_snapshot->base->uniqueid, OBJ_SEARCH_KEY);
2432 }
2433
2434 /* Handle Party A */
2435 if (!cdr) {
2436 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", update->new_snapshot->base->name);
2437 ast_assert(0);
2438 } else {
2439 int all_reject = 1;
2440
2441 ao2_lock(cdr);
2442 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2444 if (!it_cdr->fn_table->process_party_a) {
2445 continue;
2446 }
2447 all_reject &= it_cdr->fn_table->process_party_a(it_cdr, update->new_snapshot);
2448 }
2449 if (all_reject && check_new_cdr_needed(update->old_snapshot, update->new_snapshot)) {
2450 /* We're not hung up and we have a new snapshot - we need a new CDR */
2451 struct cdr_object *new_cdr;
2452
2454 if (new_cdr) {
2455 new_cdr->fn_table->process_party_a(new_cdr, update->new_snapshot);
2456 }
2457 }
2458 ao2_unlock(cdr);
2459 }
2460
2461 if (ast_test_flag(&update->new_snapshot->flags, AST_FLAG_DEAD)) {
2462 ao2_lock(cdr);
2463 CDR_DEBUG("%p - Beginning finalize/dispatch for %s\n", cdr, update->old_snapshot->base->name);
2464 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2467 }
2469 ao2_unlock(cdr);
2470
2471 cdr_all_unlink(cdr);
2473 }
2474
2475 /* Handle Party B */
2476 if (update->new_snapshot) {
2478 cdr_object_update_party_b, (char *) update->new_snapshot->base->name, update->new_snapshot);
2479 }
2480
2481 if (ast_test_flag(&update->new_snapshot->flags, AST_FLAG_DEAD)) {
2483 cdr_object_finalize_party_b, (char *) update->new_snapshot->base->name, update->new_snapshot);
2484 }
2485
2486 ao2_cleanup(cdr);
2487}
#define ao2_link(container, obj)
Add an object to a container.
Definition astobj2.h:1532
#define ao2_unlink(container, obj)
Remove an object from a container.
Definition astobj2.h:1578
static int cdr_object_update_party_b(void *obj, void *arg, void *data, int flags)
Definition cdr.c:2343
static int cdr_object_finalize_party_b(void *obj, void *arg, void *data, int flags)
Definition cdr.c:2319
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.
Definition cdr.c:2372
static int filter_channel_snapshot_message(struct ast_channel_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
Definition cdr.c:2183
@ CDR_CHANNEL_DEFAULT_ENABLED
Definition cdr.h:227
Structure representing a change of snapshot of channel state.

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

Referenced by load_module().

◆ handle_cli_debug()

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

Definition at line 4077 of file cdr.c.

4078{
4079 struct module_config *mod_cfg;
4080
4081 switch (cmd) {
4082 case CLI_INIT:
4083 e->command = "cdr set debug [on|off]";
4084 e->usage = "Enable or disable extra debugging in the CDR Engine. Note\n"
4085 "that this will dump debug information to the VERBOSE setting\n"
4086 "and should only be used when debugging information from the\n"
4087 "CDR engine is needed.\n";
4088 return NULL;
4089 case CLI_GENERATE:
4090 return NULL;
4091 }
4092
4093 if (a->argc != 4) {
4094 return CLI_SHOWUSAGE;
4095 }
4096
4097 mod_cfg = ao2_global_obj_ref(module_configs);
4098 if (!mod_cfg) {
4099 ast_cli(a->fd, "Could not set CDR debugging mode\n");
4100 return CLI_SUCCESS;
4101 }
4102 if (!strcasecmp(a->argv[3], "on")
4103 && !ast_test_flag(&mod_cfg->general->settings, CDR_DEBUG)) {
4105 ast_cli(a->fd, "CDR debugging enabled\n");
4106 } else if (!strcasecmp(a->argv[3], "off")
4107 && ast_test_flag(&mod_cfg->general->settings, CDR_DEBUG)) {
4109 ast_cli(a->fd, "CDR debugging disabled\n");
4110 }
4111 cdr_set_debug_mode(mod_cfg);
4112 ao2_cleanup(mod_cfg);
4113
4114 return CLI_SUCCESS;
4115}
#define CLI_SHOWUSAGE
Definition cli.h:45
#define CLI_SUCCESS
Definition cli.h:44
@ CLI_INIT
Definition cli.h:152
@ CLI_GENERATE
Definition cli.h:153
char * command
Definition cli.h:186
const char * usage
Definition cli.h:177

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

◆ handle_cli_show()

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

Definition at line 4263 of file cdr.c.

4264{
4265 switch (cmd) {
4266 case CLI_INIT:
4267 e->command = "cdr show active";
4268 e->usage =
4269 "Usage: cdr show active [channel]\n"
4270 " Displays a summary of all Call Detail Records when [channel]\n"
4271 " is omitted; displays all of the Call Detail Records\n"
4272 " currently in flight for a given [channel] when [channel] is\n"
4273 " specified.\n\n"
4274 " Note that this will not display Call Detail Records that\n"
4275 " have already been dispatched to a backend storage, nor for\n"
4276 " channels that are no longer active.\n";
4277 return NULL;
4278 case CLI_GENERATE:
4279 return cli_complete_show(a);
4280 }
4281
4282 if (a->argc > 4) {
4283 return CLI_SHOWUSAGE;
4284 } else if (a->argc < 4) {
4286 } else {
4288 }
4289
4290 return CLI_SUCCESS;
4291}
static void cli_show_channels(struct ast_cli_args *a)
Definition cdr.c:4139
static char * cli_complete_show(struct ast_cli_args *a)
Complete user input for 'cdr show'.
Definition cdr.c:4118
static void cli_show_channel(struct ast_cli_args *a)
Definition cdr.c:4203

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

◆ handle_cli_status()

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

Definition at line 4293 of file cdr.c.

4294{
4295 struct cdr_beitem *beitem = NULL;
4296 struct module_config *mod_cfg;
4297 int cnt = 0;
4298 long nextbatchtime = 0;
4299
4300 switch (cmd) {
4301 case CLI_INIT:
4302 e->command = "cdr show status";
4303 e->usage =
4304 "Usage: cdr show status\n"
4305 " Displays the Call Detail Record engine system status.\n";
4306 return NULL;
4307 case CLI_GENERATE:
4308 return NULL;
4309 }
4310
4311 if (a->argc > 3) {
4312 return CLI_SHOWUSAGE;
4313 }
4314
4315 mod_cfg = ao2_global_obj_ref(module_configs);
4316 if (!mod_cfg) {
4317 return CLI_FAILURE;
4318 }
4319
4320 ast_cli(a->fd, "\n");
4321 ast_cli(a->fd, "Call Detail Record (CDR) settings\n");
4322 ast_cli(a->fd, "----------------------------------\n");
4323 ast_cli(a->fd, " Logging: %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED) ? "Enabled" : "Disabled");
4324 ast_cli(a->fd, " Mode: %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE) ? "Batch" : "Simple");
4325 if (ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
4326 ast_cli(a->fd, " Log calls by default: %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_CHANNEL_DEFAULT_ENABLED) ? "Yes" : "No");
4327 ast_cli(a->fd, " Log unanswered calls: %s\n", ast_test_flag(&mod_cfg->general->settings, CDR_UNANSWERED) ? "Yes" : "No");
4328 ast_cli(a->fd, " Log congestion: %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_CONGESTION) ? "Yes" : "No");
4329 ast_cli(a->fd, " Ignore bridging changes: %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_STATE_CHANGES) ? "Yes" : "No");
4330 ast_cli(a->fd, " Ignore dial state changes: %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_DIAL_CHANGES) ? "Yes" : "No");
4331 ast_cli(a->fd, " Cancel disposition enabled: %s\n\n", ast_test_flag(&mod_cfg->general->settings, CDR_CANCEL_DISPOSITION_ENABLED) ? "Yes" : "No");
4332 if (ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
4333 ast_cli(a->fd, "* Batch Mode Settings\n");
4334 ast_cli(a->fd, " -------------------\n");
4335 if (batch)
4336 cnt = batch->size;
4337 if (cdr_sched > -1)
4338 nextbatchtime = ast_sched_when(sched, cdr_sched);
4339 ast_cli(a->fd, " Safe shutdown: %s\n", ast_test_flag(&mod_cfg->general->batch_settings.settings, BATCH_MODE_SAFE_SHUTDOWN) ? "Enabled" : "Disabled");
4340 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");
4341 ast_cli(a->fd, " Current batch size: %d record%s\n", cnt, ESS(cnt));
4342 ast_cli(a->fd, " Maximum batch size: %u record%s\n", mod_cfg->general->batch_settings.size, ESS(mod_cfg->general->batch_settings.size));
4343 ast_cli(a->fd, " Maximum batch time: %u second%s\n", mod_cfg->general->batch_settings.time, ESS(mod_cfg->general->batch_settings.time));
4344 ast_cli(a->fd, " Next batch processing time: %ld second%s\n\n", nextbatchtime, ESS(nextbatchtime));
4345 }
4346 ast_cli(a->fd, "* Registered Backends\n");
4347 ast_cli(a->fd, " -------------------\n");
4349 if (AST_RWLIST_EMPTY(&be_list)) {
4350 ast_cli(a->fd, " (none)\n");
4351 } else {
4352 AST_RWLIST_TRAVERSE(&be_list, beitem, list) {
4353 ast_cli(a->fd, " %s%s\n", beitem->name, beitem->suspended ? " (suspended) " : "");
4354 }
4355 }
4357 ast_cli(a->fd, "\n");
4358 }
4359
4360 ao2_cleanup(mod_cfg);
4361 return CLI_SUCCESS;
4362}
static int cdr_sched
Definition cdr.c:457
@ CDR_UNANSWERED
Definition cdr.h:222
@ CDR_IGNORE_STATE_CHANGES
Definition cdr.h:228
@ CDR_IGNORE_DIAL_CHANGES
Definition cdr.h:229
#define ESS(x)
Definition cli.h:59
#define CLI_FAILURE
Definition cli.h:46
#define AST_RWLIST_EMPTY
#define AST_RWLIST_RDLOCK(head)
Read locks a list.
Definition linkedlists.h:78
long ast_sched_when(struct ast_sched_context *con, int id)
Returns the number of seconds before an event takes place.
Definition sched.c:851

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

◆ handle_cli_submit()

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

Definition at line 4364 of file cdr.c.

4365{
4366 struct module_config *mod_cfg;
4367
4368 switch (cmd) {
4369 case CLI_INIT:
4370 e->command = "cdr submit";
4371 e->usage =
4372 "Usage: cdr submit\n"
4373 "Posts all pending batched CDR data to the configured CDR\n"
4374 "backend engine modules.\n";
4375 return NULL;
4376 case CLI_GENERATE:
4377 return NULL;
4378 }
4379 if (a->argc > 2) {
4380 return CLI_SHOWUSAGE;
4381 }
4382
4383 mod_cfg = ao2_global_obj_ref(module_configs);
4384 if (!mod_cfg) {
4385 return CLI_FAILURE;
4386 }
4387
4388 if (!ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
4389 ast_cli(a->fd, "Cannot submit CDR batch: CDR engine disabled.\n");
4390 } else if (!ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
4391 ast_cli(a->fd, "Cannot submit CDR batch: batch mode not enabled.\n");
4392 } else {
4394 ast_cli(a->fd, "Submitted CDRs to backend engines for processing. This may take a while.\n");
4395 }
4396 ao2_cleanup(mod_cfg);
4397
4398 return CLI_SUCCESS;
4399}

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

◆ handle_dial_message()

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

Handler for Stasis-Core dial messages.

Parameters
dataPassed on
subThe stasis subscription for this message callback
messageThe message

Definition at line 2214 of file cdr.c.

2215{
2216 struct cdr_object *cdr;
2219 struct ast_channel_snapshot *peer;
2220 struct cdr_object *it_cdr;
2221 struct ast_json *dial_status_blob;
2222 const char *dial_status = NULL;
2223 int res = 1;
2224
2225 caller = ast_multi_channel_blob_get_channel(payload, "caller");
2226 peer = ast_multi_channel_blob_get_channel(payload, "peer");
2227 if (!peer && !caller) {
2228 return;
2229 }
2230
2231 if (peer && filter_channel_snapshot(peer)) {
2232 return;
2233 }
2234
2235 if (caller && filter_channel_snapshot(caller)) {
2236 return;
2237 }
2238
2239 dial_status_blob = ast_json_object_get(ast_multi_channel_blob_get_json(payload), "dialstatus");
2240 if (dial_status_blob) {
2241 dial_status = ast_json_string_get(dial_status_blob);
2242 }
2243
2244 CDR_DEBUG("Dial %s message for %s, %s: %u.%08u\n",
2245 ast_strlen_zero(dial_status) ? "Begin" : "End",
2246 caller ? caller->base->name : "(none)",
2247 peer ? peer->base->name : "(none)",
2248 (unsigned int)stasis_message_timestamp(message)->tv_sec,
2249 (unsigned int)stasis_message_timestamp(message)->tv_usec);
2250
2251 /* Figure out who is running this show */
2252 if (caller) {
2254 } else {
2256 }
2257 if (!cdr) {
2258 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", caller ? caller->base->name : peer->base->name);
2259 ast_assert(0);
2260 return;
2261 }
2262
2263 ao2_lock(cdr);
2264 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2266 if (ast_strlen_zero(dial_status)) {
2267 if (!it_cdr->fn_table->process_dial_begin) {
2268 continue;
2269 }
2271 CDR_DEBUG("%p - Ignoring Dial Begin message\n", it_cdr);
2272 continue;
2273 }
2274 CDR_DEBUG("%p - Processing Dial Begin message for channel %s, peer %s\n",
2275 it_cdr,
2276 caller ? caller->base->name : "(none)",
2277 peer ? peer->base->name : "(none)");
2278 res &= it_cdr->fn_table->process_dial_begin(it_cdr,
2279 caller,
2280 peer);
2281 } else if (dial_status_end(dial_status)) {
2282 if (!it_cdr->fn_table->process_dial_end) {
2283 continue;
2284 }
2286 /* Set the disposition, and do nothing else. */
2287 it_cdr->disposition = dial_status_to_disposition(dial_status);
2288 CDR_DEBUG("%p - Setting disposition and that's it (%s)\n", it_cdr, dial_status);
2289 continue;
2290 }
2291 CDR_DEBUG("%p - Processing Dial End message for channel %s, peer %s\n",
2292 it_cdr,
2293 caller ? caller->base->name : "(none)",
2294 peer ? peer->base->name : "(none)");
2295 it_cdr->fn_table->process_dial_end(it_cdr,
2296 caller,
2297 peer,
2298 dial_status);
2299 }
2300 }
2301
2302 /* If we're ignoring dial changes, don't allow multiple CDRs for this channel. */
2303 if (!dial_changes_ignored) {
2304 /* If no CDR handled a dial begin message, make a new one */
2305 if (res && ast_strlen_zero(dial_status)) {
2306 struct cdr_object *new_cdr;
2307
2309 if (new_cdr) {
2310 new_cdr->fn_table->process_dial_begin(new_cdr, caller, peer);
2311 }
2312 }
2313 }
2314
2315 ao2_unlock(cdr);
2316 ao2_cleanup(cdr);
2317}
static int dial_changes_ignored
Definition cdr.c:312
static int dial_status_end(const char *dialstatus)
Definition cdr.c:2199
struct ast_channel_snapshot * ast_multi_channel_blob_get_channel(struct ast_multi_channel_blob *obj, const char *role)
Retrieve a channel snapshot associated with a specific role from a ast_multi_channel_blob.
struct ast_json * ast_multi_channel_blob_get_json(struct ast_multi_channel_blob *obj)
Retrieve the JSON blob from a ast_multi_channel_blob. Returned ast_json is still owned by obj.
const char * ast_json_string_get(const struct ast_json *string)
Get the value of a JSON string.
Definition json.c:283
struct ast_json * ast_json_object_get(struct ast_json *object, const char *key)
Get a field from a JSON object.
Definition json.c:407
Abstract JSON element (object, array, string, int, ...).
A multi channel blob data structure for multi_channel_blob stasis messages.
int(*const process_dial_end)(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status)
Process the end of a dial. At the end of a dial, a CDR can be transitioned into one of two states - D...
Definition cdr.c:584
int(*const process_dial_begin)(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
Process the beginning of a dial. A dial message implies one of two things: The cdr_object's Party A h...
Definition cdr.c:566

References active_cdrs_master, 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_changes_ignored, dial_status_end(), dial_status_to_disposition(), cdr_object::disposition, filter_channel_snapshot(), cdr_object::fn_table, cdr_object::lastevent, ast_channel_snapshot_base::name, cdr_object::next, NULL, OBJ_SEARCH_KEY, ast_channel_snapshot::peer, cdr_object_fn_table::process_dial_begin, cdr_object_fn_table::process_dial_end, cdr_object::start, stasis_message_data(), stasis_message_timestamp(), and ast_channel_snapshot_base::uniqueid.

Referenced by load_module().

◆ handle_parked_call_message()

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

Handler for when a channel is parked.

Parameters
dataPassed on
subThe stasis subscription for this message callback
messageThe message about who got parked

Definition at line 2885 of file cdr.c.

2887{
2889 struct ast_channel_snapshot *channel = payload->parkee;
2890 struct cdr_object *cdr;
2891 int unhandled = 1;
2892 struct cdr_object *it_cdr;
2893
2894 /* Anything other than getting parked will be handled by other updates */
2895 if (payload->event_type != PARKED_CALL) {
2896 return;
2897 }
2898
2899 /* No one got parked? */
2900 if (!channel) {
2901 return;
2902 }
2903
2904 if (filter_channel_snapshot(channel)) {
2905 return;
2906 }
2907
2908 CDR_DEBUG("Parked Call message for channel %s: %u.%08u\n",
2909 channel->base->name,
2910 (unsigned int)stasis_message_timestamp(message)->tv_sec,
2911 (unsigned int)stasis_message_timestamp(message)->tv_usec);
2912
2914 if (!cdr) {
2915 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->base->name);
2916 ast_assert(0);
2917 return;
2918 }
2919
2920 ao2_lock(cdr);
2921
2922 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2924 if (it_cdr->fn_table->process_parked_channel) {
2925 unhandled &= it_cdr->fn_table->process_parked_channel(it_cdr, payload);
2926 }
2927 }
2928
2929 if (unhandled) {
2930 /* Nothing handled the message - we need a new one! */
2931 struct cdr_object *new_cdr;
2932
2934 if (new_cdr) {
2935 /* As the new CDR is created in the single state, it is guaranteed
2936 * to have a function for the parked call message and will handle
2937 * the message */
2938 new_cdr->fn_table->process_parked_channel(new_cdr, payload);
2939 }
2940 }
2941
2942 ao2_unlock(cdr);
2943
2944 ao2_cleanup(cdr);
2945}
@ PARKED_CALL
Definition parking.h:47
A parked call message payload.
Definition parking.h:59
enum ast_parked_call_event_type event_type
Definition parking.h:62

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

Referenced by load_module().

◆ handle_parking_bridge_enter_message()

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

Handle entering into a parking bridge.

Parameters
cdrThe CDR to operate on
bridgeThe bridge the channel just entered
channelThe channel snapshot
event_time

Definition at line 2721 of file cdr.c.

2725{
2726 int res = 1;
2727 struct cdr_object *it_cdr;
2728 struct cdr_object *new_cdr;
2729
2730 ao2_lock(cdr);
2731
2732 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2733 it_cdr->lastevent = *event_time;
2734
2735 if (it_cdr->fn_table->process_parking_bridge_enter) {
2736 res &= it_cdr->fn_table->process_parking_bridge_enter(it_cdr, bridge, channel);
2737 }
2738 if (it_cdr->fn_table->process_party_a) {
2739 CDR_DEBUG("%p - Updating Party A %s snapshot\n", it_cdr,
2740 channel->base->name);
2741 it_cdr->fn_table->process_party_a(it_cdr, channel);
2742 }
2743 }
2744
2745 if (res) {
2746 /* No one handled it - we need a new one! */
2747 new_cdr = cdr_object_create_and_append(cdr, event_time);
2748 if (new_cdr) {
2749 /* Let the single state transition us to Parked */
2751 new_cdr->fn_table->process_parking_bridge_enter(new_cdr, bridge, channel);
2752 }
2753 }
2754 ao2_unlock(cdr);
2755}

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

Referenced by handle_bridge_enter_message().

◆ handle_standard_bridge_enter_message()

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

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

Parameters
cdrThe CDR to operate on
bridgeThe bridge the channel just entered
channelThe channel snapshot
event_time

Definition at line 2763 of file cdr.c.

2767{
2769 struct cdr_object *it_cdr;
2770 struct cdr_object *new_cdr;
2771 struct cdr_object *handled_cdr = NULL;
2772
2773 ao2_lock(cdr);
2774
2775try_again:
2776 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2777 it_cdr->lastevent = *event_time;
2778
2779 if (it_cdr->fn_table->process_party_a) {
2780 CDR_DEBUG("%p - Updating Party A %s snapshot\n", it_cdr,
2781 channel->base->name);
2782 it_cdr->fn_table->process_party_a(it_cdr, channel);
2783 }
2784
2785 /* Notify all states that they have entered a bridge */
2786 if (it_cdr->fn_table->process_bridge_enter) {
2787 CDR_DEBUG("%p - Processing bridge enter for %s\n", it_cdr,
2788 channel->base->name);
2789 result = it_cdr->fn_table->process_bridge_enter(it_cdr, bridge, channel);
2790 switch (result) {
2792 /* Fall through */
2794 if (!handled_cdr) {
2796 }
2797 break;
2799 /* Pass */
2800 break;
2802 /* We didn't win on any - end this CDR. If someone else comes in later
2803 * that is Party B to this CDR, it can re-activate this CDR.
2804 */
2805 if (!handled_cdr) {
2807 }
2809 break;
2810 }
2811 }
2812 }
2813
2814 /* Create the new matchings, but only for either:
2815 * * The first CDR in the chain that handled it. This avoids issues with
2816 * forked CDRs.
2817 * * If no one handled it, the last CDR in the chain. This would occur if
2818 * a CDR joined a bridge and it wasn't Party A for anyone. We still need
2819 * to make pairings with everyone in the bridge.
2820 */
2821 if (handled_cdr) {
2823 } else {
2824 /* Nothing handled it - we need a new one! */
2825 new_cdr = cdr_object_create_and_append(cdr, event_time);
2826 if (new_cdr) {
2827 /* This is guaranteed to succeed: the new CDR is created in the single state
2828 * and will be able to handle the bridge enter message
2829 */
2830 goto try_again;
2831 }
2832 }
2833 ao2_unlock(cdr);
2834}
process_bridge_enter_results
Return types for process_bridge_enter functions.
Definition cdr.c:495
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.
Definition cdr.c:2695
static PGresult * result
Definition cel_pgsql.c:84

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

Referenced by handle_bridge_enter_message().

◆ init_batch()

static int init_batch ( void  )
static
Note
Don't call without cdr_batch_lock

Definition at line 3886 of file cdr.c.

3887{
3888 /* This is the single meta-batch used to keep track of all CDRs during the entire life of the program */
3889 if (!(batch = ast_malloc(sizeof(*batch))))
3890 return -1;
3891
3892 reset_batch();
3893
3894 return 0;
3895}
#define ast_malloc(len)
A wrapper for malloc()
Definition astmm.h:191

References ast_malloc, batch, and reset_batch().

Referenced by cdr_detach().

◆ is_cdr_flag_set()

static int is_cdr_flag_set ( unsigned int  cdr_flag)
static

◆ load_module()

static int load_module ( void  )
static

Definition at line 4674 of file cdr.c.

4675{
4676 struct module_config *mod_cfg = NULL;
4677 if (process_config(0)) {
4679 }
4680
4681 cdr_topic = stasis_topic_create("cdr:aggregator");
4682 if (!cdr_topic) {
4684 }
4685
4687 if (!stasis_router) {
4689 }
4692
4693 if (STASIS_MESSAGE_TYPE_INIT(cdr_sync_message_type)) {
4695 }
4696
4697 mod_cfg = ao2_global_obj_ref(module_configs);
4698
4700
4701 /* Always process dial messages, because even if we ignore most of it, we do want the dial status for the disposition. */
4703 if (!mod_cfg || !ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_DIAL_CHANGES)) {
4705 } else {
4707 CDR_DEBUG("Dial messages will be mostly ignored\n");
4708 }
4709
4710 /* If explicitly instructed to ignore call state changes, then ignore bridging events, parking, etc. */
4711 if (!mod_cfg || !ast_test_flag(&mod_cfg->general->settings, CDR_IGNORE_STATE_CHANGES)) {
4715 } else {
4716 CDR_DEBUG("All bridge and parking messages will be ignored\n");
4717 }
4718
4720
4721 if (mod_cfg) {
4722 ao2_cleanup(mod_cfg);
4723 } else {
4724 ast_log(LOG_WARNING, "Unable to obtain CDR configuration during module load?\n");
4725 }
4726
4729 if (!active_cdrs_master) {
4731 }
4733
4736 if (!active_cdrs_all) {
4738 }
4740
4742 if (!sched) {
4743 ast_log(LOG_ERROR, "Unable to create schedule context.\n");
4745 }
4746
4749
4751}
int ast_register_atexit(void(*func)(void))
Register a function to be executed before Asterisk exits.
Definition clicompat.c:13
@ AO2_ALLOC_OPT_LOCK_MUTEX
Definition astobj2.h:363
int ao2_container_register(const char *name, struct ao2_container *self, ao2_prnt_obj_fn *prnt_obj)
Register a container for CLI stats and integrity check.
#define ao2_container_alloc_hash(ao2_options, container_options, n_buckets, hash_fn, sort_fn, cmp_fn)
Allocate and initialize a hash container with the desired number of buckets.
Definition astobj2.h:1303
static void handle_parked_call_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Handler for when a channel is parked.
Definition cdr.c:2885
static int process_config(int reload)
Definition cdr.c:4492
static void cdr_all_print_fn(void *v_obj, void *where, ao2_prnt_fn *prnt)
Definition cdr.c:4624
static int cdr_all_hash_fn(const void *obj, const int flags)
Definition cdr.c:994
static int cdr_master_cmp_fn(void *obj, void *arg, int flags)
Definition cdr.c:960
static void handle_bridge_leave_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Handler for when a channel leaves a bridge.
Definition cdr.c:2538
static void handle_channel_snapshot_update_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Handler for channel snapshot update messages.
Definition cdr.c:2400
static void handle_bridge_enter_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Definition cdr.c:2843
static void handle_cdr_sync_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Handler for a synchronization message.
Definition cdr.c:2953
static void cdr_master_print_fn(void *v_obj, void *where, ao2_prnt_fn *prnt)
Definition cdr.c:4599
static int cdr_all_cmp_fn(void *obj, void *arg, int flags)
Definition cdr.c:1018
static void handle_dial_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
Handler for Stasis-Core dial messages.
Definition cdr.c:2214
static void cdr_engine_shutdown(void)
Definition cdr.c:4541
static int cdr_master_hash_fn(const void *obj, const int flags)
Definition cdr.c:936
#define AST_NUM_CHANNEL_BUCKETS
Definition channel.h:157
#define ast_cli_register_multiple(e, len)
Register multiple commands.
Definition cli.h:265
struct stasis_message_type * ast_parked_call_type(void)
accessor for the parked call stasis message type
struct stasis_message_type * ast_channel_dial_type(void)
Message type for when a channel dials another channel.
struct stasis_message_type * ast_channel_snapshot_type(void)
Message type for ast_channel_snapshot_update.
@ AST_MODULE_LOAD_FAILURE
Module could not be loaded properly.
Definition module.h:102
@ AST_MODULE_LOAD_SUCCESS
Definition module.h:70
struct ast_sched_context * ast_sched_context_create(void)
Create a scheduler context.
Definition sched.c:238
struct stasis_topic * stasis_topic_create(const char *name)
Create a new topic.
Definition stasis.c:684
#define STASIS_MESSAGE_TYPE_INIT(name)
Boiler-plate messaging macro for initializing message types.
Definition stasis.h:1493
struct stasis_message_type * ast_channel_entered_bridge_type(void)
Message type for ast_channel enter bridge blob messages.
struct stasis_message_type * ast_channel_left_bridge_type(void)
Message type for ast_channel leave bridge blob messages.
int stasis_message_router_set_congestion_limits(struct stasis_message_router *router, long low_water, long high_water)
Set the high and low alert water marks of the stasis message router.
#define stasis_message_router_create(topic)
Create a new message router object.
int stasis_message_router_add(struct stasis_message_router *router, struct stasis_message_type *message_type, stasis_subscription_cb callback, void *data)
Add a route to a message router.
#define AST_TASKPROCESSOR_HIGH_WATER_LEVEL

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

◆ module_config_alloc()

static void * module_config_alloc ( void  )
static

Create a new module config object.

Definition at line 404 of file cdr.c.

405{
406 struct module_config *mod_cfg;
408
409 mod_cfg = ao2_alloc(sizeof(*mod_cfg), module_config_destructor);
410 if (!mod_cfg) {
411 return NULL;
412 }
413
414 cdr_config = ao2_alloc(sizeof(*cdr_config), NULL);
415 if (!cdr_config) {
416 ao2_ref(cdr_config, -1);
417 return NULL;
418 }
419 mod_cfg->general = cdr_config;
420
421 return mod_cfg;
422}
static void module_config_destructor(void *obj)
Dispose of a module config object.
Definition cdr.c:393
static const char cdr_config[]
Definition cdr_radius.c:86

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

Referenced by process_config().

◆ module_config_destructor()

static void module_config_destructor ( void *  obj)
static

Dispose of a module config object.

Definition at line 393 of file cdr.c.

394{
395 struct module_config *cfg = obj;
396
397 if (!cfg) {
398 return;
399 }
400 ao2_ref(cfg->general, -1);
401}

References ao2_ref, and module_config::general.

Referenced by module_config_alloc().

◆ module_config_post_apply()

static void module_config_post_apply ( void  )
static

Definition at line 380 of file cdr.c.

381{
382 struct module_config *mod_cfg;
383
384 mod_cfg = ao2_global_obj_ref(module_configs);
385 if (!mod_cfg) {
386 return;
387 }
388 cdr_set_debug_mode(mod_cfg);
389 ao2_cleanup(mod_cfg);
390}

References ao2_cleanup, ao2_global_obj_ref, and cdr_set_debug_mode.

◆ parked_state_process_bridge_leave()

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

◆ post_cdr()

static void post_cdr ( struct ast_cdr cdr)
static

Definition at line 3656 of file cdr.c.

3657{
3658 struct module_config *mod_cfg;
3659 struct cdr_beitem *i;
3660
3661 mod_cfg = ao2_global_obj_ref(module_configs);
3662 if (!mod_cfg) {
3663 return;
3664 }
3665
3666 for (; cdr ; cdr = cdr->next) {
3667 /* For people, who don't want to see unanswered single-channel events */
3668 if (!ast_test_flag(&mod_cfg->general->settings, CDR_UNANSWERED) &&
3671 ast_debug(1, "Skipping CDR for %s since we weren't answered\n", cdr->channel);
3672 continue;
3673 }
3674
3675 /* Modify CDR's */
3678 i->be(cdr);
3679 }
3681
3683 continue;
3684 }
3687 if (!i->suspended) {
3688 i->be(cdr);
3689 }
3690 }
3692 }
3693 ao2_cleanup(mod_cfg);
3694}
@ AST_CDR_FLAG_DISABLE
Definition cdr.h:245

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

Referenced by cdr_detach(), and do_batch_backend_process().

◆ process_config()

static int process_config ( int  reload)
static

Definition at line 4492 of file cdr.c.

4493{
4494 if (!reload) {
4495 if (aco_info_init(&cfg_info)) {
4496 return 1;
4497 }
4498
4514 }
4515
4516 if (aco_process_config(&cfg_info, reload) == ACO_PROCESS_ERROR) {
4517 struct module_config *mod_cfg;
4518
4519 if (reload) {
4520 return 1;
4521 }
4522
4523 /* If we couldn't process the configuration and this wasn't a reload,
4524 * create a default config
4525 */
4526 mod_cfg = module_config_alloc();
4527 if (!mod_cfg
4528 || aco_set_defaults(&general_option, "general", mod_cfg->general)) {
4529 ao2_cleanup(mod_cfg);
4530 return 1;
4531 }
4532 ast_log(LOG_NOTICE, "Failed to process CDR configuration; using defaults\n");
4533 ao2_global_obj_replace_unref(module_configs, mod_cfg);
4534 cdr_set_debug_mode(mod_cfg);
4535 ao2_cleanup(mod_cfg);
4536 }
4537
4538 return 0;
4539}
#define ao2_global_obj_replace_unref(holder, obj)
Replace an ao2 object in the global holder, throwing away any old object.
Definition astobj2.h:901
#define DEFAULT_BATCH_SIZE
Definition cdr.c:299
#define MAX_BATCH_SIZE
Definition cdr.c:300
#define DEFAULT_BATCHMODE
Definition cdr.c:290
#define DEFAULT_IGNORE_STATE_CHANGES
Definition cdr.c:296
#define DEFAULT_UNANSWERED
Definition cdr.c:291
static struct aco_type general_option
The type definition for general options.
Definition cdr.c:334
#define MAX_BATCH_TIME
Definition cdr.c:302
static struct aco_type * general_options[]
Definition cdr.c:378
#define DEFAULT_INITIATED_SECONDS
Definition cdr.c:294
#define DEFAULT_IGNORE_DIAL_CHANGES
Definition cdr.c:297
#define DEFAULT_BATCH_SAFE_SHUTDOWN
Definition cdr.c:304
#define DEFAULT_BATCH_TIME
Definition cdr.c:301
#define DEFAULT_BATCH_SCHEDULER_ONLY
Definition cdr.c:303
#define DEFAULT_CHANNEL_ENABLED
Definition cdr.c:295
#define DEFAULT_ENABLED
Definition cdr.c:289
static void * module_config_alloc(void)
Create a new module config object.
Definition cdr.c:404
#define DEFAULT_END_BEFORE_H_EXTEN
Definition cdr.c:293
static struct cdr_tds_config * settings
Definition cdr_tds.c:95
@ ACO_EXACT
int aco_set_defaults(struct aco_type *type, const char *category, void *obj)
Set all default options of obj.
@ ACO_PROCESS_ERROR
Their was an error and no changes were applied.
int aco_info_init(struct aco_info *info)
Initialize an aco_info structure.
#define FLDSET(type,...)
Convert a struct and list of fields to an argument list of field offsets.
#define aco_option_register(info, name, matchtype, types, default_val, opt_type, flags,...)
Register a config option.
@ OPT_UINT_T
Type for default option handler for unsigned integers.
@ OPT_BOOLFLAG_T
Type for default option handler for bools (ast_true/ast_false) that are stored in a flag.
enum aco_process_status aco_process_config(struct aco_info *info, int reload)
Process a config info via the options registered with an aco_info.
static int reload(void)

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

Referenced by load_module(), and reload_module().

◆ reload_module()

static int reload_module ( void  )
static

Definition at line 4793 of file cdr.c.

4794{
4795 struct module_config *old_mod_cfg;
4796 struct module_config *mod_cfg;
4797
4798 old_mod_cfg = ao2_global_obj_ref(module_configs);
4799
4800 if (!old_mod_cfg || process_config(1)) {
4801 ao2_cleanup(old_mod_cfg);
4802 return -1;
4803 }
4804
4805 mod_cfg = ao2_global_obj_ref(module_configs);
4806 if (!mod_cfg
4807 || !ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)
4808 || !ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
4809 /* If batch mode used to be enabled, finalize the batch */
4810 if (ast_test_flag(&old_mod_cfg->general->settings, CDR_BATCHMODE)) {
4812 }
4813 }
4814 ao2_cleanup(mod_cfg);
4815
4816 ao2_cleanup(old_mod_cfg);
4818}

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

◆ reset_batch()

static void reset_batch ( void  )
static
Note
Don't call without cdr_batch_lock

Definition at line 3878 of file cdr.c.

3879{
3880 batch->size = 0;
3881 batch->head = NULL;
3882 batch->tail = NULL;
3883}

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

Referenced by cdr_submit_batch(), and init_batch().

◆ set_variable()

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

Definition at line 1364 of file cdr.c.

1365{
1366 struct ast_var_t *newvariable;
1367
1368 AST_LIST_TRAVERSE_SAFE_BEGIN(headp, newvariable, entries) {
1369 if (!strcasecmp(ast_var_name(newvariable), name)) {
1371 ast_var_delete(newvariable);
1372 break;
1373 }
1374 }
1376
1377 if (value && (newvariable = ast_var_assign(name, value))) {
1378 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
1379 }
1380}
#define AST_LIST_TRAVERSE_SAFE_END
Closes a safe loop traversal block.
#define AST_LIST_TRAVERSE_SAFE_BEGIN(head, var, field)
Loops safely over (traverses) the entries in a list.
#define AST_LIST_REMOVE_CURRENT(field)
Removes the current entry from a list during a traversal.

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

Referenced by ast_cdr_setvar(), and cdr_object_update_cid().

◆ single_state_bridge_enter_comparison()

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

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

Parameters
cdrOur cdr_object in the Single state
cand_cdrThe cdr_object already in the Bridge state
Return values
0The cand_cdr had a Party A or Party B that we could use as our Party B
1No party in the cand_cdr could be used as our Party B

Definition at line 1796 of file cdr.c.

1798{
1799 struct cdr_object_snapshot *party_a;
1800
1801 /* Don't match on ourselves */
1802 if (!strcasecmp(cdr->party_a.snapshot->base->name, cand_cdr->party_a.snapshot->base->name)) {
1803 return 1;
1804 }
1805
1806 /* Try the candidate CDR's Party A first */
1807 party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_a);
1808 if (!strcasecmp(party_a->snapshot->base->name, cdr->party_a.snapshot->base->name)) {
1809 CDR_DEBUG("%p - Party A %s has new Party B %s\n",
1810 cdr, cdr->party_a.snapshot->base->name, cand_cdr->party_a.snapshot->base->name);
1811 cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
1812 cdr_all_relink(cdr);
1813 if (!cand_cdr->party_b.snapshot) {
1814 /* We just stole them - finalize their CDR. Note that this won't
1815 * transition their state, it just sets the end time and the
1816 * disposition - if we need to re-activate them later, we can.
1817 */
1818 cdr_object_finalize(cand_cdr);
1819 }
1820 return 0;
1821 }
1822
1823 /* Try their Party B, unless it's us */
1824 if (!cand_cdr->party_b.snapshot
1825 || !strcasecmp(cdr->party_a.snapshot->base->name, cand_cdr->party_b.snapshot->base->name)) {
1826 return 1;
1827 }
1828 party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_b);
1829 if (!strcasecmp(party_a->snapshot->base->name, cdr->party_a.snapshot->base->name)) {
1830 CDR_DEBUG("%p - Party A %s has new Party B %s\n",
1831 cdr, cdr->party_a.snapshot->base->name, cand_cdr->party_b.snapshot->base->name);
1832 cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_b);
1833 cdr_all_relink(cdr);
1834 return 0;
1835 }
1836
1837 return 1;
1838}

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

Referenced by single_state_process_bridge_enter().

◆ single_state_init_function()

static void single_state_init_function ( struct cdr_object cdr)
static

Definition at line 1743 of file cdr.c.

1744{
1745 cdr->start = cdr->lastevent;
1747}

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

◆ single_state_process_bridge_enter()

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

Definition at line 1840 of file cdr.c.

1841{
1842 struct ao2_iterator it_cdrs;
1843 char *channel_id;
1844 int success = 0;
1845
1846 ast_string_field_set(cdr, bridge, bridge->uniqueid);
1847
1848 if (ao2_container_count(bridge->channels) == 1) {
1849 /* No one in the bridge yet but us! */
1852 }
1853
1854 for (it_cdrs = ao2_iterator_init(bridge->channels, 0);
1855 !success && (channel_id = ao2_iterator_next(&it_cdrs));
1856 ao2_ref(channel_id, -1)) {
1858 struct cdr_object *cand_cdr;
1859
1861 if (!cand_cdr_master) {
1862 continue;
1863 }
1864
1867 /* Skip any records that are not in a bridge or in this bridge.
1868 * I'm not sure how that would happen, but it pays to be careful. */
1869 if (cand_cdr->fn_table != &bridge_state_fn_table ||
1870 strcmp(cdr->bridge, cand_cdr->bridge)) {
1871 continue;
1872 }
1873
1875 continue;
1876 }
1877 /* We successfully got a party B - break out */
1878 success = 1;
1879 break;
1880 }
1883 }
1885
1886 /* We always transition state, even if we didn't get a peer */
1888
1889 /* Success implies that we have a Party B */
1890 if (success) {
1892 }
1893
1895}
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...
Definition cdr.c:1796

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

◆ single_state_process_dial_begin()

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

Definition at line 1757 of file cdr.c.

1758{
1759 if (caller && !strcasecmp(cdr->party_a.snapshot->base->name, caller->base->name)) {
1760 base_process_party_a(cdr, caller);
1761 CDR_DEBUG("%p - Updated Party A %s snapshot\n", cdr,
1762 cdr->party_a.snapshot->base->name);
1763 cdr_object_swap_snapshot(&cdr->party_b, peer);
1764 cdr_all_relink(cdr);
1765 CDR_DEBUG("%p - Updated Party B %s snapshot\n", cdr,
1766 cdr->party_b.snapshot->base->name);
1767
1768 /* If we have two parties, lock the application that caused the
1769 * two parties to be associated. This prevents mid-call event
1770 * gosubs from perturbing the CDR application/data
1771 */
1773 } else if (!strcasecmp(cdr->party_a.snapshot->base->name, peer->base->name)) {
1774 /* We're the entity being dialed, i.e., outbound origination */
1775 base_process_party_a(cdr, peer);
1776 CDR_DEBUG("%p - Updated Party A %s snapshot\n", cdr,
1777 cdr->party_a.snapshot->base->name);
1778 }
1779
1781 return 0;
1782}

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

◆ single_state_process_parking_bridge_enter()

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

Definition at line 1897 of file cdr.c.

1898{
1900 return 0;
1901}

References cdr_object_transition_state(), and parked_state_fn_table.

◆ single_state_process_party_b()

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

Definition at line 1749 of file cdr.c.

1750{
1751 /* This should never happen! */
1753 ast_assert(0);
1754 return;
1755}

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

◆ snapshot_cep_changed()

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

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

Parameters
old_snapshotThe previous state
new_snapshotThe new state
Return values
0if the state has not changed
1if the state changed

Definition at line 1250 of file cdr.c.

1252{
1253 /* If we ignore hangup logic, don't indicate that we're executing anything new */
1256 return 0;
1257 }
1258
1259 /* When Party A is originated to an application and the application exits, the stack
1260 * will attempt to clear the application and restore the dummy originate application
1261 * of "AppDialX". Ignore application changes to AppDialX as a result.
1262 */
1263 if (strcmp(new_snapshot->dialplan->appl, old_snapshot->dialplan->appl)
1264 && strncasecmp(new_snapshot->dialplan->appl, "appdial", 7)
1265 && (strcmp(new_snapshot->dialplan->context, old_snapshot->dialplan->context)
1266 || strcmp(new_snapshot->dialplan->exten, old_snapshot->dialplan->exten)
1267 || new_snapshot->dialplan->priority != old_snapshot->dialplan->priority)) {
1268 return 1;
1269 }
1270
1271 return 0;
1272}

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

Referenced by check_new_cdr_needed(), and dialed_pending_state_process_party_a().

◆ snapshot_is_dialed()

static int snapshot_is_dialed ( struct ast_channel_snapshot snapshot)
static

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

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

Definition at line 1281 of file cdr.c.

1282{
1283 return (ast_test_flag(&snapshot->flags, AST_FLAG_OUTGOING)
1284 && !(ast_test_flag(&snapshot->flags, AST_FLAG_ORIGINATED)));
1285}
@ AST_FLAG_OUTGOING
Definition channel.h:1019
@ AST_FLAG_ORIGINATED
Definition channel.h:1059

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

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

◆ start_batch_mode()

static void start_batch_mode ( void  )
static

Do not hold the batch lock while calling this function

Definition at line 3973 of file cdr.c.

3974{
3975 /* Prevent two deletes from happening at the same time */
3977 /* this is okay since we are not being called from within the scheduler */
3979 /* schedule the submission to occur ASAP (1 ms) */
3982
3983 /* signal the do_cdr thread to wakeup early and do some work (that lazy thread ;) */
3987}
static int submit_scheduled_batch(const void *data)
Definition cdr.c:3952
static ast_mutex_t cdr_sched_lock
Definition cdr.c:458
#define ast_cond_signal(cond)
Definition lock.h:210
#define AST_SCHED_DEL(sched, id)
Remove a scheduler entry.
Definition sched.h:46
int ast_sched_add_variable(struct ast_sched_context *con, int when, ast_sched_cb callback, const void *data, int variable) attribute_warn_unused_result
Adds a scheduled event with rescheduling support.
Definition sched.c:526

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

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

◆ STASIS_MESSAGE_TYPE_DEFN_LOCAL()

STASIS_MESSAGE_TYPE_DEFN_LOCAL ( cdr_sync_message_type  )

A message type used to synchronize with the CDR topic.

◆ submit_scheduled_batch()

static int submit_scheduled_batch ( const void *  data)
static

Definition at line 3952 of file cdr.c.

3953{
3954 struct module_config *mod_cfg;
3955 int nextms;
3956
3958
3959 mod_cfg = ao2_global_obj_ref(module_configs);
3960 if (!mod_cfg) {
3961 return 0;
3962 }
3963
3964 /* Calculate the next scheduled interval */
3965 nextms = mod_cfg->general->batch_settings.time * 1000;
3966
3967 ao2_cleanup(mod_cfg);
3968
3969 return nextms;
3970}

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

Referenced by start_batch_mode().

◆ unload_module()

static int unload_module ( void  )
static

Definition at line 4667 of file cdr.c.

4668{
4670
4671 return 0;
4672}

References destroy_subscriptions().

Variable Documentation

◆ __mod_info

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

Definition at line 4827 of file cdr.c.

◆ active_cdrs_all

struct ao2_container* active_cdrs_all
static

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

Definition at line 472 of file cdr.c.

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

◆ active_cdrs_master

struct ao2_container* active_cdrs_master
static

◆ ast_module_info

const struct ast_module_info* ast_module_info = &__mod_info
static

Definition at line 4827 of file cdr.c.

◆ batch

struct cdr_batch * batch = NULL
static

◆ be_list

◆ 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:

Definition at line 763 of file cdr.c.

763 {
764 .name = "Bridged",
765 .process_party_a = base_process_party_a,
766 .process_party_b = bridge_state_process_party_b,
767 .process_bridge_leave = bridge_state_process_bridge_leave,
768 .process_parked_channel = base_process_parked_channel,
769};
static void bridge_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Definition cdr.c:2112
static int base_process_parked_channel(struct cdr_object *cdr, struct ast_parked_call_payload *parking_info)
Definition cdr.c:1721
static int bridge_state_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Definition cdr.c:2125

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

◆ bridge_subscription

struct stasis_forward* bridge_subscription
static

Our subscription for bridges.

Definition at line 478 of file cdr.c.

Referenced by create_subscriptions(), and destroy_subscriptions().

◆ cdr_batch_lock

ast_mutex_t cdr_batch_lock = AST_MUTEX_INIT_VALUE
static

Lock protecting modifications to the batch queue.

Definition at line 462 of file cdr.c.

Referenced by cdr_detach(), and cdr_submit_batch().

◆ cdr_debug_enabled

int cdr_debug_enabled
static

Definition at line 311 of file cdr.c.

◆ cdr_pending_cond

ast_cond_t cdr_pending_cond
static

Definition at line 466 of file cdr.c.

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

◆ cdr_pending_lock

ast_mutex_t cdr_pending_lock = AST_MUTEX_INIT_VALUE
static

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

Definition at line 465 of file cdr.c.

Referenced by do_cdr(), and start_batch_mode().

◆ cdr_readonly_vars

const char* const cdr_readonly_vars[]
static

Definition at line 3291 of file cdr.c.

3291 {
3292 "clid",
3293 "src",
3294 "dst",
3295 "dcontext",
3296 "channel",
3297 "dstchannel",
3298 "lastapp",
3299 "lastdata",
3300 "start",
3301 "answer",
3302 "end",
3303 "duration",
3304 "billsec",
3305 "disposition",
3306 "amaflags",
3307 "accountcode",
3308 "uniqueid",
3309 "linkedid",
3310 "tenantid",
3311 "userfield",
3312 "sequence",
3313 NULL
3314};

Referenced by ast_cdr_serialize_variables(), and ast_cdr_setvar().

◆ cdr_sched

int cdr_sched = -1
static

Definition at line 457 of file cdr.c.

Referenced by handle_cli_status(), and start_batch_mode().

◆ cdr_sched_lock

ast_mutex_t cdr_sched_lock = AST_MUTEX_INIT_VALUE
static

Definition at line 458 of file cdr.c.

Referenced by start_batch_mode().

◆ cdr_thread

pthread_t cdr_thread = AST_PTHREADT_NULL
static

Definition at line 459 of file cdr.c.

Referenced by cdr_enable_batch_mode(), and finalize_batch_mode().

◆ cdr_topic

struct stasis_topic* cdr_topic
static

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

Definition at line 487 of file cdr.c.

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

◆ channel_subscription

struct stasis_forward* channel_subscription
static

Our subscription for channels.

Definition at line 481 of file cdr.c.

Referenced by create_subscriptions(), and destroy_subscriptions().

◆ cli_commands

struct ast_cli_entry cli_commands[]
static

Definition at line 4401 of file cdr.c.

4401 {
4402 AST_CLI_DEFINE(handle_cli_submit, "Posts all pending batched CDR data"),
4403 AST_CLI_DEFINE(handle_cli_status, "Display the CDR status"),
4404 AST_CLI_DEFINE(handle_cli_show, "Display active CDRs for channels"),
4405 AST_CLI_DEFINE(handle_cli_debug, "Enable debugging in the CDR engine"),
4406};
static char * handle_cli_show(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition cdr.c:4263
static char * handle_cli_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition cdr.c:4077
static char * handle_cli_submit(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition cdr.c:4364
static char * handle_cli_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
Definition cdr.c:4293
#define AST_CLI_DEFINE(fn, txt,...)
Definition cli.h:197

Referenced by cdr_engine_shutdown(), and load_module().

◆ dial_changes_ignored

int dial_changes_ignored
static

Definition at line 312 of file cdr.c.

Referenced by handle_dial_message(), and load_module().

◆ dial_state_fn_table

struct cdr_object_fn_table dial_state_fn_table

The virtual table for the Dial state.

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

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

Definition at line 708 of file cdr.c.

708 {
709 .name = "Dial",
710 .process_party_a = base_process_party_a,
711 .process_party_b = dial_state_process_party_b,
712 .process_dial_begin = dial_state_process_dial_begin,
713 .process_dial_end = dial_state_process_dial_end,
714 .process_bridge_enter = dial_state_process_bridge_enter,
715 .process_bridge_leave = base_process_bridge_leave,
716};
static int base_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Definition cdr.c:1705
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)
Definition cdr.c:1958
static void dial_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Definition cdr.c:1906
static int dial_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
Definition cdr.c:1920
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)
Definition cdr.c:1990

Referenced by dialed_pending_state_process_bridge_enter(), and single_state_process_dial_begin().

◆ dialed_pending_state_fn_table

struct cdr_object_fn_table dialed_pending_state_fn_table

The virtual table for the Dialed Pending state.

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

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

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

Definition at line 741 of file cdr.c.

741 {
742 .name = "DialedPending",
743 .process_party_a = dialed_pending_state_process_party_a,
744 .process_dial_begin = dialed_pending_state_process_dial_begin,
745 .process_bridge_enter = dialed_pending_state_process_bridge_enter,
746 .process_parking_bridge_enter = dialed_pending_state_process_parking_bridge_enter,
747 .process_bridge_leave = base_process_bridge_leave,
748 .process_parked_channel = base_process_parked_channel,
749};
static int dialed_pending_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
Definition cdr.c:2102
static int dialed_pending_state_process_parking_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Definition cdr.c:2092
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)
Definition cdr.c:2086
static int dialed_pending_state_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Definition cdr.c:2061

Referenced by dial_state_process_dial_end().

◆ finalized_state_fn_table

struct cdr_object_fn_table finalized_state_fn_table

The virtual table for the finalized state.

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

Definition at line 798 of file cdr.c.

798 {
799 .name = "Finalized",
800 .init_function = finalized_state_init_function,
801 .process_party_a = finalized_state_process_party_a,
802 .process_bridge_enter = base_process_bridge_enter,
803};
static void finalized_state_init_function(struct cdr_object *cdr)
Definition cdr.c:2154
static int finalized_state_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Definition cdr.c:2159
static enum process_bridge_enter_results base_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Definition cdr.c:1715

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

◆ general_option

struct aco_type general_option
static

The type definition for general options.

Definition at line 334 of file cdr.c.

334 {
335 .type = ACO_GLOBAL,
336 .name = "general",
337 .item_offset = offsetof(struct module_config, general),
338 .category = "general",
339 .category_match = ACO_WHITELIST_EXACT,
340};
@ ACO_GLOBAL
@ ACO_WHITELIST_EXACT

Referenced by process_config().

◆ general_options

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

Definition at line 378 of file cdr.c.

Referenced by process_config().

◆ global_cdr_sequence

int global_cdr_sequence = 0
static

The global sequence counter used for CDRs.

Definition at line 453 of file cdr.c.

Referenced by cdr_object_alloc().

◆ ignore_categories

const char* ignore_categories[]
static

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

Definition at line 343 of file cdr.c.

343 {
344 "csv",
345 "custom",
346 "manager",
347 "odbc",
348 "pgsql",
349 "radius",
350 "sqlite",
351 "tds",
352 "mysql",
353 NULL,
354};

◆ ignore_option

struct aco_type ignore_option
static

Definition at line 356 of file cdr.c.

356 {
357 .type = ACO_IGNORE,
358 .name = "modules",
359 .category = (const char*)ignore_categories,
360 .category_match = ACO_WHITELIST_ARRAY,
361};
static const char * ignore_categories[]
Definition cdr.c:343
@ ACO_IGNORE
@ ACO_WHITELIST_ARRAY

◆ mo_list

◆ module_file_conf

struct aco_file module_file_conf
static
Initial value:
= {
.filename = "cdr.conf",
}
static struct aco_type ignore_option
Definition cdr.c:356
#define ACO_TYPES(...)
A helper macro to ensure that aco_info types always have a sentinel.

The file definition.

Definition at line 368 of file cdr.c.

368 {
369 .filename = "cdr.conf",
371};

◆ parked_state_fn_table

struct cdr_object_fn_table parked_state_fn_table

The virtual table for the Parked state.

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

Definition at line 782 of file cdr.c.

782 {
783 .name = "Parked",
784 .process_party_a = base_process_party_a,
785 .process_bridge_leave = parked_state_process_bridge_leave,
786 .process_parked_channel = base_process_parked_channel,
787};
static int parked_state_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Definition cdr.c:2142

Referenced by dialed_pending_state_process_parking_bridge_enter(), and single_state_process_parking_bridge_enter().

◆ parking_subscription

struct stasis_forward* parking_subscription
static

Our subscription for parking.

Definition at line 484 of file cdr.c.

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

◆ sched

struct ast_sched_context* sched
static

Scheduler items.

Definition at line 456 of file cdr.c.

◆ single_state_fn_table

struct cdr_object_fn_table single_state_fn_table

The virtual table for the Single state.

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

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

Definition at line 677 of file cdr.c.

677 {
678 .name = "Single",
679 .init_function = single_state_init_function,
680 .process_party_a = base_process_party_a,
681 .process_party_b = single_state_process_party_b,
682 .process_dial_begin = single_state_process_dial_begin,
683 .process_dial_end = base_process_dial_end,
684 .process_bridge_enter = single_state_process_bridge_enter,
685 .process_parking_bridge_enter = single_state_process_parking_bridge_enter,
686 .process_bridge_leave = base_process_bridge_leave,
687 .process_parked_channel = base_process_parked_channel,
688};
static void single_state_init_function(struct cdr_object *cdr)
Definition cdr.c:1743
static int base_process_dial_end(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status)
Definition cdr.c:1710
static void single_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
Definition cdr.c:1749
static int single_state_process_parking_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
Definition cdr.c:1897
static int single_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
Definition cdr.c:1757
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)
Definition cdr.c:1840

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

◆ stasis_router

struct stasis_message_router* stasis_router
static

Message router for stasis messages regarding channel state.

Definition at line 475 of file cdr.c.

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