Sun Aug 6 15:05:13 2006

Asterisk developer's documentation

---

cdr.c File Reference

Call Detail Record API. More...

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <signal.h>
#include "asterisk.h"
#include "asterisk/lock.h"
#include "asterisk/channel.h"
#include "asterisk/cdr.h"
#include "asterisk/logger.h"
#include "asterisk/callerid.h"
#include "asterisk/causes.h"
#include "asterisk/options.h"
#include "asterisk/linkedlists.h"
#include "asterisk/utils.h"
#include "asterisk/sched.h"
#include "asterisk/config.h"
#include "asterisk/cli.h"
#include "asterisk/module.h"

Include dependency graph for cdr.c:

Go to the source code of this file.

Defines
#define	BATCH_SAFE_SHUTDOWN_DEFAULT   1
#define	BATCH_SCHEDULER_ONLY_DEFAULT   0
#define	BATCH_SIZE_DEFAULT   100
#define	BATCH_TIME_DEFAULT   300
Functions
ast_cdr *	ast_cdr_alloc (void)
	Allocate a CDR record Returns a malloc'd ast_cdr structure, returns NULL on error (malloc failure).
int	ast_cdr_amaflags2int (const char *flag)
void	ast_cdr_answer (struct ast_cdr *cdr)
ast_cdr *	ast_cdr_append (struct ast_cdr *cdr, struct ast_cdr *newcdr)
int	ast_cdr_appenduserfield (struct ast_channel *chan, const char *userfield)
void	ast_cdr_busy (struct ast_cdr *cdr)
int	ast_cdr_copy_vars (struct ast_cdr *to_cdr, struct ast_cdr *from_cdr)
void	ast_cdr_detach (struct ast_cdr *cdr)
char *	ast_cdr_disp2str (int disposition)
int	ast_cdr_disposition (struct ast_cdr *cdr, int cause)
ast_cdr *	ast_cdr_dup (struct ast_cdr *cdr)
	Duplicate a record Returns a malloc'd ast_cdr structure, returns NULL on error (malloc failure).
void	ast_cdr_end (struct ast_cdr *cdr)
int	ast_cdr_engine_init (void)
void	ast_cdr_engine_reload (void)
void	ast_cdr_engine_term (void)
void	ast_cdr_failed (struct ast_cdr *cdr)
char *	ast_cdr_flags2str (int flag)
void	ast_cdr_free (struct ast_cdr *cdr)
	Free a CDR record.
void	ast_cdr_free_vars (struct ast_cdr *cdr, int recur)
void	ast_cdr_getvar (struct ast_cdr *cdr, const char *name, char **ret, char *workspace, int workspacelen, int recur)
static const char *	ast_cdr_getvar_internal (struct ast_cdr *cdr, const char *name, int recur)
int	ast_cdr_init (struct ast_cdr *cdr, struct ast_channel *c)
	Initialize based on a channel.
int	ast_cdr_register (char *name, char *desc, ast_cdrbe be)
void	ast_cdr_reset (struct ast_cdr *cdr, struct ast_flags *_flags)
int	ast_cdr_serialize_variables (struct ast_cdr *cdr, char *buf, size_t size, char delim, char sep, int recur)
int	ast_cdr_setaccount (struct ast_channel *chan, const char *account)
int	ast_cdr_setamaflags (struct ast_channel *chan, const char *flag)
void	ast_cdr_setapp (struct ast_cdr *cdr, char *app, char *data)
int	ast_cdr_setcid (struct ast_cdr *cdr, struct ast_channel *c)
void	ast_cdr_setdestchan (struct ast_cdr *cdr, char *chann)
int	ast_cdr_setuserfield (struct ast_channel *chan, const char *userfield)
int	ast_cdr_setvar (struct ast_cdr *cdr, const char *name, const char *value, int recur)
void	ast_cdr_start (struct ast_cdr *cdr)
void	ast_cdr_submit_batch (int shutdown)
void	ast_cdr_unregister (char *name)
int	ast_cdr_update (struct ast_channel *c)
static	AST_LIST_HEAD_STATIC (be_list, ast_cdr_beitem)
	AST_MUTEX_DEFINE_STATIC (cdr_pending_lock)
	AST_MUTEX_DEFINE_STATIC (cdr_batch_lock)
static void *	do_batch_backend_process (void *data)
static void *	do_cdr (void *data)
static int	do_reload (void)
static int	handle_cli_status (int fd, int argc, char *argv[])
static int	handle_cli_submit (int fd, int argc, char *argv[])
static int	init_batch (void)
static void	post_cdr (struct ast_cdr *cdr)
static void	reset_batch (void)
static int	submit_scheduled_batch (void *data)
static void	submit_unscheduled_batch (void)
Variables
char	ast_default_accountcode [AST_MAX_ACCOUNT_CODE] = ""
int	ast_default_amaflags = AST_CDR_DOCUMENTATION
static struct ast_cdr_batch *	batch
static int	batchmode
static int	batchsafeshutdown
static int	batchscheduleronly
static int	batchsize
static int	batchtime
static ast_cond_t	cdr_pending_cond
static int	cdr_sched = -1
static pthread_t	cdr_thread = AST_PTHREADT_NULL
static struct ast_cli_entry	cli_status
static struct ast_cli_entry	cli_submit
static int	enabled
static struct sched_context *	sched

---

Detailed Description

Call Detail Record API.

Includes code and algorithms from the Zapata library.

Note:

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.

---

Define Documentation

#define BATCH_SAFE_SHUTDOWN_DEFAULT   1

Definition at line 87 of file cdr.c. Referenced by do_reload().

#define BATCH_SCHEDULER_ONLY_DEFAULT   0

Definition at line 86 of file cdr.c. Referenced by do_reload().

#define BATCH_SIZE_DEFAULT   100

Definition at line 84 of file cdr.c. Referenced by do_reload().

#define BATCH_TIME_DEFAULT   300

Definition at line 85 of file cdr.c. Referenced by do_reload().

---

Function Documentation

struct ast_cdr* ast_cdr_alloc (  void   )

Allocate a CDR record Returns a malloc'd ast_cdr structure, returns NULL on error (malloc failure). Definition at line 455 of file cdr.c. References malloc. Referenced by __agent_start_monitoring(), __ast_pbx_run(), __ast_request_and_dial(), ast_cdr_dup(), ast_feature_request_and_dial(), ast_pbx_outgoing_app(), ast_pbx_outgoing_cdr_failed(), ast_pbx_outgoing_exten(), and start_monitor_exec(). { struct ast_cdr *cdr; cdr = malloc(sizeof(*cdr)); if (cdr) memset(cdr, 0, sizeof(*cdr)); return cdr; }

int ast_cdr_amaflags2int (  const char *  flag  )

Parameters: flag  string form of flag Converts the string form of the flag to the binary form. Returns the binary form of the flag Definition at line 788 of file cdr.c. References AST_CDR_BILLING, AST_CDR_DOCUMENTATION, and AST_CDR_OMIT. Referenced by ast_cdr_setamaflags(), build_device(), build_gateway(), build_peer(), build_user(), set_config(), and setup_zap(). { if (!strcasecmp(flag, "default")) return 0; if (!strcasecmp(flag, "omit")) return AST_CDR_OMIT; if (!strcasecmp(flag, "billing")) return AST_CDR_BILLING; if (!strcasecmp(flag, "documentation")) return AST_CDR_DOCUMENTATION; return -1; }

void ast_cdr_answer (  struct ast_cdr *  cdr  )

Parameters: cdr  the cdr you wish to associate with the call Starts all CDR stuff necessary for doing CDR when answering a call Definition at line 483 of file cdr.c. References ast_cdr::answer, AST_CDR_ANSWERED, AST_CDR_FLAG_POSTED, ast_log(), ast_strlen_zero(), ast_test_flag, ast_cdr::channel, ast_cdr::disposition, LOG_WARNING, and ast_cdr::next. Referenced by ast_answer(), and ast_read(). { char *chan; while (cdr) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (cdr->disposition < AST_CDR_ANSWERED) cdr->disposition = AST_CDR_ANSWERED; if (ast_tvzero(cdr->answer)) cdr->answer = ast_tvnow(); cdr = cdr->next; } }

struct ast_cdr* ast_cdr_append (  struct ast_cdr *  cdr, struct ast_cdr *  newcdr )

Definition at line 870 of file cdr.c. References ast_cdr::next. Referenced by ast_cdr_fork(), and attempt_transfer(). { struct ast_cdr *ret; if (cdr) { ret = cdr; while (cdr->next) cdr = cdr->next; cdr->next = newcdr; } else { ret = newcdr; } return ret; }

int ast_cdr_appenduserfield (  struct ast_channel *  chan, const char *  userfield )

Definition at line 741 of file cdr.c. References AST_CDR_FLAG_LOCKED, ast_test_flag, ast_channel::cdr, ast_cdr::next, and ast_cdr::userfield. Referenced by action_setcdruserfield(), appendcdruserfield_exec(), and ast_bridge_call(). { struct ast_cdr *cdr = chan->cdr; while (cdr) { int len = strlen(cdr->userfield); if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) strncpy(cdr->userfield+len, userfield, sizeof(cdr->userfield) - len - 1); cdr = cdr->next; } return 0; }

void ast_cdr_busy (  struct ast_cdr *  cdr  )

Parameters: cdr  the cdr you wish to associate with the call Returns nothing important Definition at line 499 of file cdr.c. References AST_CDR_BUSY, AST_CDR_FLAG_LOCKED, AST_CDR_FLAG_POSTED, ast_log(), ast_strlen_zero(), ast_test_flag, ast_cdr::channel, ast_cdr::disposition, LOG_WARNING, and ast_cdr::next. Referenced by ast_cdr_disposition(), and ring_entry(). { char *chan; while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (cdr->disposition < AST_CDR_BUSY) cdr->disposition = AST_CDR_BUSY; } cdr = cdr->next; } }

int ast_cdr_copy_vars (  struct ast_cdr *  to_cdr, struct ast_cdr *  from_cdr )

Definition at line 326 of file cdr.c. References AST_LIST_INSERT_HEAD, AST_LIST_TRAVERSE, ast_strlen_zero(), ast_var_assign(), ast_var_name(), ast_var_value(), var, and ast_cdr::varshead. Referenced by ast_cdr_dup(). { struct ast_var_t *variables, *newvariable = NULL; struct varshead *headpa, *headpb; char *var, *val; int x = 0; headpa = &from_cdr->varshead; headpb = &to_cdr->varshead; AST_LIST_TRAVERSE(headpa,variables,entries) { if (variables && (var = ast_var_name(variables)) && (val = ast_var_value(variables)) && !ast_strlen_zero(var) && !ast_strlen_zero(val)) { newvariable = ast_var_assign(var, val); AST_LIST_INSERT_HEAD(headpb, newvariable, entries); x++; } } return x; }

void ast_cdr_detach (  struct ast_cdr *  cdr  )

Parameters: cdr  Which CDR to detach from the channel thread Prevents the channel thread from blocking on the CDR handling Returns nothing Definition at line 984 of file cdr.c. References AST_CDR_FLAG_POST_DISABLED, ast_cdr_free(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_set_flag, batch, batchmode, batchsize, ast_cdr_batch_item::cdr, enabled, ast_cdr_batch::head, init_batch(), LOG_DEBUG, LOG_WARNING, malloc, ast_cdr_batch_item::next, option_debug, post_cdr(), ast_cdr_batch::size, submit_unscheduled_batch(), and ast_cdr_batch::tail. Referenced by ast_cdr_reset(), ast_hangup(), and ast_pbx_outgoing_cdr_failed(). { struct ast_cdr_batch_item *newtail; int curr; /* maybe they disabled CDR stuff completely, so just drop it */ if (!enabled) { if (option_debug) ast_log(LOG_DEBUG, "Dropping CDR !\n"); ast_set_flag(cdr, AST_CDR_FLAG_POST_DISABLED); ast_cdr_free(cdr); return; } /* post stuff immediately if we are not in batch mode, this is legacy behaviour */ if (!batchmode) { post_cdr(cdr); ast_cdr_free(cdr); return; } /* otherwise, each CDR gets put into a batch list (at the end) */ if (option_debug) ast_log(LOG_DEBUG, "CDR detaching from this thread\n"); /* we'll need a new tail for every CDR */ newtail = malloc(sizeof(*newtail)); if (!newtail) { ast_log(LOG_WARNING, "CDR: out of memory while trying to detach, will try in this thread instead\n"); post_cdr(cdr); ast_cdr_free(cdr); return; } memset(newtail, 0, sizeof(*newtail)); /* don't traverse a whole list (just keep track of the tail) */ ast_mutex_lock(&cdr_batch_lock); if (!batch) init_batch(); if (!batch->head) { /* new batch is empty, so point the head at the new tail */ batch->head = newtail; } else { /* already got a batch with something in it, so just append a new tail */ batch->tail->next = newtail; } newtail->cdr = cdr; batch->tail = newtail; curr = batch->size++; ast_mutex_unlock(&cdr_batch_lock); /* if we have enough stuff to post, then do it */ if (curr >= (batchsize - 1)) submit_unscheduled_batch(); }

char* ast_cdr_disp2str (  int  disposition  )

Parameters: disposition  input binary form Converts the binary form of a disposition to string form. Returns a pointer to the string form Definition at line 671 of file cdr.c. References AST_CDR_ANSWERED, AST_CDR_BUSY, AST_CDR_FAILED, and AST_CDR_NOANSWER. Referenced by ast_cdr_getvar(), build_csv_record(), csv_log(), manager_log(), odbc_log(), pgsql_log(), and tds_log(). { switch (disposition) { case AST_CDR_NOANSWER: return "NO ANSWER"; case AST_CDR_FAILED: return "FAILED"; case AST_CDR_BUSY: return "BUSY"; case AST_CDR_ANSWERED: return "ANSWERED"; } return "UNKNOWN"; }

int ast_cdr_disposition (  struct ast_cdr *  cdr, int  cause )

Parameters: cdr  the cdr you wish to associate with the call Returns nothing important cause  the AST_CAUSE_* Definition at line 531 of file cdr.c. References AST_CAUSE_BUSY, AST_CAUSE_FAILURE, AST_CAUSE_NORMAL, AST_CAUSE_NOTDEFINED, ast_cdr_busy(), ast_cdr_failed(), ast_log(), and LOG_WARNING. Referenced by __ast_request_and_dial(), ast_feature_request_and_dial(), ast_pbx_outgoing_app(), and ast_pbx_outgoing_exten(). { int res = 0; while (cdr) { switch(cause) { case AST_CAUSE_BUSY: ast_cdr_busy(cdr); break; case AST_CAUSE_FAILURE: ast_cdr_failed(cdr); break; case AST_CAUSE_NORMAL: break; case AST_CAUSE_NOTDEFINED: res = -1; break; default: res = -1; ast_log(LOG_WARNING, "Cause not handled\n"); } cdr = cdr->next; } return res; }

struct ast_cdr* ast_cdr_dup (  struct ast_cdr *  cdr  )

Duplicate a record Returns a malloc'd ast_cdr structure, returns NULL on error (malloc failure). Duplicate a CDR record Returns: Pointer to new CDR record Definition at line 167 of file cdr.c. References ast_cdr_alloc(), ast_cdr_copy_vars(), ast_log(), and LOG_ERROR. Referenced by ast_cdr_fork(), and ast_cdr_reset(). { struct ast_cdr *newcdr; if (!(newcdr = ast_cdr_alloc())) { ast_log(LOG_ERROR, "Memory Error!\n"); return NULL; } memcpy(newcdr, cdr, sizeof(*newcdr)); /* The varshead is unusable, volatile even, after the memcpy so we take care of that here */ memset(&newcdr->varshead, 0, sizeof(newcdr->varshead)); ast_cdr_copy_vars(newcdr, cdr); newcdr->next = NULL; return newcdr; }

void ast_cdr_end (  struct ast_cdr *  cdr  )

Parameters: cdr  the cdr you have associated the call with Registers the end of call time in the cdr structure. Returns nothing important Definition at line 655 of file cdr.c. References AST_CDR_FLAG_POSTED, ast_log(), ast_strlen_zero(), ast_test_flag, ast_cdr::channel, ast_cdr::end, LOG_WARNING, ast_cdr::next, and ast_cdr::start. Referenced by __ast_request_and_dial(), ast_cdr_reset(), ast_feature_request_and_dial(), ast_hangup(), ast_pbx_outgoing_cdr_failed(), and ast_read(). { char *chan; while (cdr) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (ast_tvzero(cdr->start)) ast_log(LOG_WARNING, "CDR on channel '%s' has not started\n", chan); if (ast_tvzero(cdr->end)) cdr->end = ast_tvnow(); cdr = cdr->next; } }

int ast_cdr_engine_init (  void   )

Load the configuration file cdr.conf and possibly start the CDR scheduling thread Definition at line 1238 of file cdr.c. References ast_cli_register(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), do_reload(), init_batch(), LOG_ERROR, and sched_context_create(). Referenced by main(). { int res; sched = sched_context_create(); if (!sched) { ast_log(LOG_ERROR, "Unable to create schedule context.\n"); return -1; } ast_cli_register(&cli_status); res = do_reload(); if (res) { ast_mutex_lock(&cdr_batch_lock); res = init_batch(); ast_mutex_unlock(&cdr_batch_lock); } return res; }

void ast_cdr_engine_reload (  void   )

Reload the configuration file cdr.conf and start/stop CDR scheduling thread Definition at line 1267 of file cdr.c. References do_reload(). Referenced by ast_module_reload(). { do_reload(); }

void ast_cdr_engine_term (  void   )

Submit any remaining CDRs and prepare for shutdown Definition at line 1262 of file cdr.c. References ast_cdr_submit_batch(), and batchsafeshutdown. Referenced by do_reload(), and quit_handler(). { ast_cdr_submit_batch(batchsafeshutdown); }

void ast_cdr_failed (  struct ast_cdr *  cdr  )

Parameters: cdr  the cdr you wish to associate with the call Returns nothing important Definition at line 515 of file cdr.c. References AST_CDR_FAILED, AST_CDR_FLAG_LOCKED, AST_CDR_FLAG_POSTED, ast_log(), ast_strlen_zero(), ast_test_flag, and LOG_WARNING. Referenced by __ast_request_and_dial(), ast_cdr_disposition(), ast_feature_request_and_dial(), ast_pbx_outgoing_app(), ast_pbx_outgoing_cdr_failed(), and ast_pbx_outgoing_exten(). { char *chan; while (cdr) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { if (cdr->disposition < AST_CDR_FAILED) cdr->disposition = AST_CDR_FAILED; } cdr = cdr->next; } }

char* ast_cdr_flags2str (  int  flag  )

Converts AMA flag to printable string Definition at line 687 of file cdr.c. References AST_CDR_BILLING, AST_CDR_DOCUMENTATION, and AST_CDR_OMIT. Referenced by _sip_show_peer(), ast_cdr_getvar(), build_csv_record(), csv_log(), manager_log(), sip_show_user(), and tds_log(). { switch(flag) { case AST_CDR_OMIT: return "OMIT"; case AST_CDR_BILLING: return "BILLING"; case AST_CDR_DOCUMENTATION: return "DOCUMENTATION"; } return "Unknown"; }

void ast_cdr_free (  struct ast_cdr *  cdr  )

Free a CDR record. Parameters: cdr  ast_cdr structure to free Returns nothing important Definition at line 434 of file cdr.c. References AST_CDR_FLAG_POST_DISABLED, AST_CDR_FLAG_POSTED, ast_cdr_free_vars(), ast_log(), ast_strlen_zero(), ast_test_flag, free, LOG_WARNING, and ast_cdr::next. Referenced by ast_cdr_detach(), do_batch_backend_process(), and nocdr_exec(). { char *chan; struct ast_cdr *next; while (cdr) { next = cdr->next; chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (!ast_test_flag(cdr, AST_CDR_FLAG_POSTED) && !ast_test_flag(cdr, AST_CDR_FLAG_POST_DISABLED)) ast_log(LOG_WARNING, "CDR on channel '%s' not posted\n", chan); if (ast_tvzero(cdr->end)) ast_log(LOG_WARNING, "CDR on channel '%s' lacks end\n", chan); if (ast_tvzero(cdr->start)) ast_log(LOG_WARNING, "CDR on channel '%s' lacks start\n", chan); ast_cdr_free_vars(cdr, 0); free(cdr); cdr = next; } }

void ast_cdr_free_vars (  struct ast_cdr *  cdr, int  recur )

Definition at line 413 of file cdr.c. References AST_LIST_EMPTY, AST_LIST_REMOVE_HEAD, ast_var_delete(), ast_cdr::next, and ast_cdr::varshead. Referenced by ast_cdr_fork(), ast_cdr_free(), and ast_cdr_reset(). { struct varshead *headp; struct ast_var_t *vardata; /* clear variables */ while (cdr) { headp = &cdr->varshead; while (!AST_LIST_EMPTY(headp)) { vardata = AST_LIST_REMOVE_HEAD(headp, entries); ast_var_delete(vardata); } if (!recur) { break; } cdr = cdr->next; } }

void ast_cdr_getvar (  struct ast_cdr *  cdr, const char *  name, char **  ret, char *  workspace, int  workspacelen, int  recur )

CDR channel variable retrieval Definition at line 208 of file cdr.c. References ast_cdr_disp2str(), ast_cdr_flags2str(), ast_cdr_getvar_internal(), ast_strlen_zero(), fmt, and t. Referenced by ast_cdr_serialize_variables(), builtin_function_cdr_read(), and pickup_exec(). { struct tm tm; time_t t; const char *fmt = "%Y-%m-%d %T"; const char *varbuf; *ret = NULL; /* special vars (the ones from the struct ast_cdr when requested by name) I'd almost say we should convert all the stringed vals to vars */ if (!strcasecmp(name, "clid")) ast_copy_string(workspace, cdr->clid, workspacelen); else if (!strcasecmp(name, "src")) ast_copy_string(workspace, cdr->src, workspacelen); else if (!strcasecmp(name, "dst")) ast_copy_string(workspace, cdr->dst, workspacelen); else if (!strcasecmp(name, "dcontext")) ast_copy_string(workspace, cdr->dcontext, workspacelen); else if (!strcasecmp(name, "channel")) ast_copy_string(workspace, cdr->channel, workspacelen); else if (!strcasecmp(name, "dstchannel")) ast_copy_string(workspace, cdr->dstchannel, workspacelen); else if (!strcasecmp(name, "lastapp")) ast_copy_string(workspace, cdr->lastapp, workspacelen); else if (!strcasecmp(name, "lastdata")) ast_copy_string(workspace, cdr->lastdata, workspacelen); else if (!strcasecmp(name, "start")) { t = cdr->start.tv_sec; if (t) { localtime_r(&t, &tm); strftime(workspace, workspacelen, fmt, &tm); } } else if (!strcasecmp(name, "answer")) { t = cdr->answer.tv_sec; if (t) { localtime_r(&t, &tm); strftime(workspace, workspacelen, fmt, &tm); } } else if (!strcasecmp(name, "end")) { t = cdr->end.tv_sec; if (t) { localtime_r(&t, &tm); strftime(workspace, workspacelen, fmt, &tm); } } else if (!strcasecmp(name, "duration")) snprintf(workspace, workspacelen, "%ld", cdr->duration); else if (!strcasecmp(name, "billsec")) snprintf(workspace, workspacelen, "%ld", cdr->billsec); else if (!strcasecmp(name, "disposition")) ast_copy_string(workspace, ast_cdr_disp2str(cdr->disposition), workspacelen); else if (!strcasecmp(name, "amaflags")) ast_copy_string(workspace, ast_cdr_flags2str(cdr->amaflags), workspacelen); else if (!strcasecmp(name, "accountcode")) ast_copy_string(workspace, cdr->accountcode, workspacelen); else if (!strcasecmp(name, "uniqueid")) ast_copy_string(workspace, cdr->uniqueid, workspacelen); else if (!strcasecmp(name, "userfield")) ast_copy_string(workspace, cdr->userfield, workspacelen); else if ((varbuf = ast_cdr_getvar_internal(cdr, name, recur))) ast_copy_string(workspace, varbuf, workspacelen); if (!ast_strlen_zero(workspace)) *ret = workspace; }

static const char* ast_cdr_getvar_internal (  struct ast_cdr *  cdr, const char *  name, int  recur )  [static]

Definition at line 185 of file cdr.c. References AST_LIST_TRAVERSE, ast_strlen_zero(), ast_var_name(), and ast_var_value(). Referenced by ast_cdr_getvar(). { struct ast_var_t *variables; struct varshead *headp; if (ast_strlen_zero(name)) return NULL; while (cdr) { headp = &cdr->varshead; AST_LIST_TRAVERSE(headp, variables, entries) { if (!strcasecmp(name, ast_var_name(variables))) return ast_var_value(variables); } if (!recur) break; cdr = cdr->next; } return NULL; }

int ast_cdr_init (  struct ast_cdr *  cdr, struct ast_channel *  chan )

Initialize based on a channel. Parameters: cdr  Call Detail Record to use for channel chan  Channel to bind CDR with Initializes a CDR and associates it with a particular channel Return is negligible. (returns 0 by default) Definition at line 617 of file cdr.c. References ast_channel::_state, ast_cdr::accountcode, ast_channel::accountcode, ast_cdr::amaflags, ast_channel::amaflags, AST_CDR_ANSWERED, AST_CDR_FLAG_LOCKED, AST_CDR_NOANSWER, ast_default_amaflags, ast_log(), AST_MAX_EXTENSION, AST_STATE_UP, ast_strlen_zero(), ast_test_flag, ast_cdr::channel, ast_channel::cid, ast_callerid::cid_ani, ast_callerid::cid_name, ast_callerid::cid_num, ast_cdr::clid, ast_channel::context, ast_cdr::dcontext, ast_cdr::disposition, ast_cdr::dst, ast_channel::exten, LOG_WARNING, ast_channel::name, ast_cdr::next, ast_cdr::src, ast_cdr::uniqueid, and ast_channel::uniqueid. Referenced by __ast_pbx_run(), __ast_request_and_dial(), ast_feature_request_and_dial(), ast_pbx_outgoing_app(), ast_pbx_outgoing_cdr_failed(), and ast_pbx_outgoing_exten(). { char *chan; char *num; char tmp[AST_MAX_EXTENSION] = ""; while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (!ast_strlen_zero(cdr->channel)) ast_log(LOG_WARNING, "CDR already initialized on '%s'\n", chan); ast_copy_string(cdr->channel, c->name, sizeof(cdr->channel)); /* Grab source from ANI or normal Caller*ID */ num = c->cid.cid_ani ? c->cid.cid_ani : c->cid.cid_num; if (c->cid.cid_name && num) snprintf(tmp, sizeof(tmp), "\"%s\" <%s>", c->cid.cid_name, num); else if (c->cid.cid_name) ast_copy_string(tmp, c->cid.cid_name, sizeof(tmp)); else if (num) ast_copy_string(tmp, num, sizeof(tmp)); ast_copy_string(cdr->clid, tmp, sizeof(cdr->clid)); ast_copy_string(cdr->src, num ? num : "", sizeof(cdr->src)); cdr->disposition = (c->_state == AST_STATE_UP) ? AST_CDR_ANSWERED : AST_CDR_NOANSWER; cdr->amaflags = c->amaflags ? c->amaflags : ast_default_amaflags; ast_copy_string(cdr->accountcode, c->accountcode, sizeof(cdr->accountcode)); /* Destination information */ ast_copy_string(cdr->dst, c->exten, sizeof(cdr->dst)); ast_copy_string(cdr->dcontext, c->context, sizeof(cdr->dcontext)); /* Unique call identifier */ ast_copy_string(cdr->uniqueid, c->uniqueid, sizeof(cdr->uniqueid)); } cdr = cdr->next; } return 0; }

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

Register a CDR driver. Each registered CDR driver generates a CDR Returns: 0 on success, -1 on failure Definition at line 106 of file cdr.c. References AST_LIST_INSERT_HEAD, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), list, LOG_WARNING, malloc, and ast_cdr_beitem::name. Referenced by load_module(), odbc_load_module(), process_my_load_module(), and tds_load_module(). { struct ast_cdr_beitem *i; if (!name) return -1; if (!be) { ast_log(LOG_WARNING, "CDR engine '%s' lacks backend\n", name); return -1; } AST_LIST_LOCK(&be_list); AST_LIST_TRAVERSE(&be_list, i, list) { if (!strcasecmp(name, i->name)) break; } AST_LIST_UNLOCK(&be_list); if (i) { ast_log(LOG_WARNING, "Already have a CDR backend called '%s'\n", name); return -1; } i = malloc(sizeof(*i)); if (!i) return -1; memset(i, 0, sizeof(*i)); i->be = be; ast_copy_string(i->name, name, sizeof(i->name)); ast_copy_string(i->desc, desc, sizeof(i->desc)); AST_LIST_LOCK(&be_list); AST_LIST_INSERT_HEAD(&be_list, i, list); AST_LIST_UNLOCK(&be_list); return 0; }

void ast_cdr_reset (  struct ast_cdr *  cdr, struct ast_flags *  flags )

Parameters: cdr  which cdr to act upon flags  |AST_CDR_FLAG_POSTED whether or not to post the cdr first before resetting it |AST_CDR_FLAG_LOCKED whether or not to reset locked CDR's Definition at line 831 of file cdr.c. References ast_cdr::answer, ast_cdr_detach(), ast_cdr_dup(), ast_cdr_end(), AST_CDR_FLAG_KEEP_VARS, AST_CDR_FLAG_LOCKED, AST_CDR_FLAG_POSTED, ast_cdr_free_vars(), AST_CDR_NOANSWER, ast_cdr_start(), ast_clear_flag, ast_copy_flags, AST_FLAGS_ALL, ast_set_flag, ast_test_flag, ast_cdr::billsec, ast_cdr::disposition, ast_cdr::duration, ast_cdr::end, ast_cdr::next, and ast_cdr::start. Referenced by ast_bridge_call_thread(), ast_cdr_fork(), dial_exec_full(), disa_exec(), and pbx_builtin_resetcdr(). { struct ast_cdr *dup; struct ast_flags flags = { 0 }; if (_flags) ast_copy_flags(&flags, _flags, AST_FLAGS_ALL); while (cdr) { /* Detach if post is requested */ if (ast_test_flag(&flags, AST_CDR_FLAG_LOCKED) || !ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { if (ast_test_flag(&flags, AST_CDR_FLAG_POSTED)) { ast_cdr_end(cdr); if ((dup = ast_cdr_dup(cdr))) { ast_cdr_detach(dup); } ast_set_flag(cdr, AST_CDR_FLAG_POSTED); } /* clear variables */ if (!ast_test_flag(&flags, AST_CDR_FLAG_KEEP_VARS)) { ast_cdr_free_vars(cdr, 0); } /* Reset to initial state */ ast_clear_flag(cdr, AST_FLAGS_ALL); memset(&cdr->start, 0, sizeof(cdr->start)); memset(&cdr->end, 0, sizeof(cdr->end)); memset(&cdr->answer, 0, sizeof(cdr->answer)); cdr->billsec = 0; cdr->duration = 0; ast_cdr_start(cdr); cdr->disposition = AST_CDR_NOANSWER; } cdr = cdr->next; } }

int ast_cdr_serialize_variables (  struct ast_cdr *  cdr, char *  buf, size_t  size, char  delim, char  sep, int  recur )

Definition at line 349 of file cdr.c. References ast_build_string(), ast_cdr_getvar(), AST_LIST_TRAVERSE, ast_log(), ast_strlen_zero(), ast_var_name(), ast_var_value(), LOG_ERROR, ast_cdr::next, total, var, and ast_cdr::varshead. Referenced by handle_showchan(). { struct ast_var_t *variables; char *var, *val; char *tmp; char workspace[256]; int total = 0, x = 0, i; const char *cdrcols[] = { "clid", "src", "dst", "dcontext", "channel", "dstchannel", "lastapp", "lastdata", "start", "answer", "end", "duration", "billsec", "disposition", "amaflags", "accountcode", "uniqueid", "userfield" }; memset(buf, 0, size); for (; cdr; cdr = recur ? cdr->next : NULL) { if (++x > 1) ast_build_string(&buf, &size, "\n"); AST_LIST_TRAVERSE(&cdr->varshead, variables, entries) { if (variables && (var = ast_var_name(variables)) && (val = ast_var_value(variables)) && !ast_strlen_zero(var) && !ast_strlen_zero(val)) { if (ast_build_string(&buf, &size, "level %d: %s%c%s%c", x, var, delim, val, sep)) { ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n"); break; } else total++; } else break; } for (i = 0; i < (sizeof(cdrcols) / sizeof(cdrcols[0])); i++) { ast_cdr_getvar(cdr, cdrcols[i], &tmp, workspace, sizeof(workspace), 0); if (!tmp) continue; if (ast_build_string(&buf, &size, "level %d: %s%c%s%c", x, cdrcols[i], delim, tmp, sep)) { ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n"); break; } else total++; } } return total; }

int ast_cdr_setaccount (  struct ast_channel *  chan, const char *  account )

Definition at line 700 of file cdr.c. References ast_channel::accountcode, ast_cdr::accountcode, AST_CDR_FLAG_LOCKED, ast_test_flag, ast_channel::cdr, and ast_cdr::next. Referenced by __ast_request_and_dial(), ast_pbx_outgoing_app(), ast_pbx_outgoing_exten(), auth_exec(), builtin_function_cdr_write(), and pbx_builtin_setaccount(). { struct ast_cdr *cdr = chan->cdr; ast_copy_string(chan->accountcode, account, sizeof(chan->accountcode)); while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) ast_copy_string(cdr->accountcode, chan->accountcode, sizeof(cdr->accountcode)); cdr = cdr->next; } return 0; }

int ast_cdr_setamaflags (  struct ast_channel *  chan, const char *  flag )

Definition at line 713 of file cdr.c. References ast_cdr::amaflags, ast_cdr_amaflags2int(), ast_channel::cdr, and ast_cdr::next. Referenced by pbx_builtin_setamaflags(). { struct ast_cdr *cdr; int newflag; newflag = ast_cdr_amaflags2int(flag); if (newflag) { for (cdr = chan->cdr; cdr; cdr = cdr->next) { cdr->amaflags = newflag; } } return 0; }

void ast_cdr_setapp (  struct ast_cdr *  cdr, char *  app, char *  data )

Parameters: cdr  which cdr to act upon app  the name of the app you wish to change it to data  the data you want in the data field of app you set it to Changes the value of the last executed app Returns nothing Definition at line 571 of file cdr.c. References AST_CDR_FLAG_LOCKED, AST_CDR_FLAG_POSTED, ast_log(), ast_strlen_zero(), ast_test_flag, ast_cdr::channel, ast_cdr::lastapp, ast_cdr::lastdata, LOG_WARNING, and ast_cdr::next. Referenced by __ast_request_and_dial(), ast_feature_request_and_dial(), and pbx_exec(). { char *chan; while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (!app) app = ""; ast_copy_string(cdr->lastapp, app, sizeof(cdr->lastapp)); if (!data) data = ""; ast_copy_string(cdr->lastdata, data, sizeof(cdr->lastdata)); } cdr = cdr->next; } }

int ast_cdr_setcid (  struct ast_cdr *  cdr, struct ast_channel *  chan )

Parameters: cdr  Call Detail Record to use for channel chan  Channel to bind CDR with Initializes a CDR and associates it with a particular channel Return is negligible. (returns 0 by default) Definition at line 591 of file cdr.c. References AST_CDR_FLAG_LOCKED, AST_MAX_EXTENSION, ast_test_flag, ast_channel::cid, ast_callerid::cid_ani, ast_callerid::cid_name, ast_callerid::cid_num, ast_cdr::clid, ast_cdr::next, and ast_cdr::src. Referenced by ast_set_callerid(). { char tmp[AST_MAX_EXTENSION] = ""; char *num; while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { /* Grab source from ANI or normal Caller*ID */ num = c->cid.cid_ani ? c->cid.cid_ani : c->cid.cid_num; if (c->cid.cid_name && num) snprintf(tmp, sizeof(tmp), "\"%s\" <%s>", c->cid.cid_name, num); else if (c->cid.cid_name) ast_copy_string(tmp, c->cid.cid_name, sizeof(tmp)); else if (num) ast_copy_string(tmp, num, sizeof(tmp)); ast_copy_string(cdr->clid, tmp, sizeof(cdr->clid)); ast_copy_string(cdr->src, num ? num : "", sizeof(cdr->src)); } cdr = cdr->next; } return 0; }

void ast_cdr_setdestchan (  struct ast_cdr *  cdr, char *  chan )

Parameters: cdr  Which cdr it's applied to chan  Channel to which dest will be Sets the destination channel the CDR is applied to Returns nothing Definition at line 557 of file cdr.c. References AST_CDR_FLAG_LOCKED, AST_CDR_FLAG_POSTED, ast_log(), ast_strlen_zero(), ast_test_flag, ast_cdr::channel, ast_cdr::dstchannel, LOG_WARNING, and ast_cdr::next. Referenced by ast_bridge_call_thread(), dial_exec_full(), and try_calling(). { char *chan; while (cdr) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) ast_copy_string(cdr->dstchannel, chann, sizeof(cdr->dstchannel)); cdr = cdr->next; } }

int ast_cdr_setuserfield (  struct ast_channel *  chan, const char *  userfield )

Definition at line 728 of file cdr.c. References AST_CDR_FLAG_LOCKED, ast_test_flag, ast_channel::cdr, ast_cdr::next, and ast_cdr::userfield. Referenced by __agent_start_monitoring(), action_setcdruserfield(), ast_bridge_call(), builtin_function_cdr_write(), handle_request_info(), setcdruserfield_exec(), and start_monitor_exec(). { struct ast_cdr *cdr = chan->cdr; while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) ast_copy_string(cdr->userfield, userfield, sizeof(cdr->userfield)); cdr = cdr->next; } return 0; }

int ast_cdr_setvar (  struct ast_cdr *  cdr, const char *  name, const char *  value, int  recur )

Set a CDR channel variable Note: You can't set the CDR variables that belong to the actual CDR record, like "billsec". Definition at line 277 of file cdr.c. References AST_LIST_INSERT_HEAD, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, ast_log(), ast_var_assign(), ast_var_delete(), ast_var_name(), and LOG_ERROR. Referenced by builtin_function_cdr_write(). { struct ast_var_t *newvariable; struct varshead *headp; const char *read_only[] = { "clid", "src", "dst", "dcontext", "channel", "dstchannel", "lastapp", "lastdata", "start", "answer", "end", "duration", "billsec", "disposition", "amaflags", "accountcode", "uniqueid", "userfield", NULL }; int x; for(x = 0; read_only[x]; x++) { if (!strcasecmp(name, read_only[x])) { ast_log(LOG_ERROR, "Attempt to set a read-only variable!.\n"); return -1; } } if (!cdr) { ast_log(LOG_ERROR, "Attempt to set a variable on a nonexistent CDR record.\n"); return -1; } while (cdr) { headp = &cdr->varshead; AST_LIST_TRAVERSE_SAFE_BEGIN(headp, newvariable, entries) { if (!strcasecmp(ast_var_name(newvariable), name)) { /* there is already such a variable, delete it */ AST_LIST_REMOVE_CURRENT(headp, entries); ast_var_delete(newvariable); break; } } AST_LIST_TRAVERSE_SAFE_END; if (value) { newvariable = ast_var_assign(name, value); AST_LIST_INSERT_HEAD(headp, newvariable, entries); } if (!recur) { break; } cdr = cdr->next; } return 0; }

void ast_cdr_start (  struct ast_cdr *  cdr  )

Parameters: cdr  the cdr you wish to associate with the call Starts all CDR stuff necessary for monitoring a call Returns nothing important Definition at line 466 of file cdr.c. References AST_CDR_FLAG_LOCKED, AST_CDR_FLAG_POSTED, ast_log(), ast_strlen_zero(), ast_test_flag, ast_cdr::channel, LOG_WARNING, ast_cdr::next, and ast_cdr::start. Referenced by __ast_pbx_run(), __ast_request_and_dial(), ast_cdr_reset(), ast_feature_request_and_dial(), ast_pbx_outgoing_app(), ast_pbx_outgoing_cdr_failed(), and ast_pbx_outgoing_exten(). { char *chan; while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (!ast_tvzero(cdr->start)) ast_log(LOG_WARNING, "CDR on channel '%s' already started\n", chan); cdr->start = ast_tvnow(); } cdr = cdr->next; } }

void ast_cdr_submit_batch (  int  shutdown  )

Parameters: shutdown  Whether or not we are shutting down Blocks the asterisk shutdown procedures until the CDR data is submitted. Returns nothing Definition at line 927 of file cdr.c. References ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_pthread_create, AST_PTHREADT_NULL, batch, batchscheduleronly, do_batch_backend_process(), ast_cdr_batch::head, LOG_DEBUG, LOG_WARNING, option_debug, and reset_batch(). Referenced by ast_cdr_engine_term(), and submit_scheduled_batch(). { struct ast_cdr_batch_item *oldbatchitems = NULL; pthread_attr_t attr; pthread_t batch_post_thread = AST_PTHREADT_NULL; /* if there's no batch, or no CDRs in the batch, then there's nothing to do */ if (!batch || !batch->head) return; /* move the old CDRs aside, and prepare a new CDR batch */ ast_mutex_lock(&cdr_batch_lock); oldbatchitems = batch->head; reset_batch(); ast_mutex_unlock(&cdr_batch_lock); /* if configured, spawn a new thread to post these CDRs, also try to save as much as possible if we are shutting down safely */ if (batchscheduleronly || shutdown) { if (option_debug) ast_log(LOG_DEBUG, "CDR single-threaded batch processing begins now\n"); do_batch_backend_process(oldbatchitems); } else { pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (ast_pthread_create(&batch_post_thread, &attr, do_batch_backend_process, oldbatchitems)) { ast_log(LOG_WARNING, "CDR processing thread could not detach, now trying in this thread\n"); do_batch_backend_process(oldbatchitems); } else { if (option_debug) ast_log(LOG_DEBUG, "CDR multi-threaded batch processing begins now\n"); } } }

void ast_cdr_unregister (  char *  name  )

unregister a CDR driver Definition at line 146 of file cdr.c. References AST_LIST_LOCK, AST_LIST_REMOVE_CURRENT, AST_LIST_TRAVERSE_SAFE_BEGIN, AST_LIST_TRAVERSE_SAFE_END, AST_LIST_UNLOCK, ast_verbose(), free, list, ast_cdr_beitem::name, option_verbose, and VERBOSE_PREFIX_2. Referenced by my_unload_module(), odbc_unload_module(), tds_unload_module(), and unload_module(). { struct ast_cdr_beitem *i = NULL; AST_LIST_LOCK(&be_list); AST_LIST_TRAVERSE_SAFE_BEGIN(&be_list, i, list) { if (!strcasecmp(name, i->name)) { AST_LIST_REMOVE_CURRENT(&be_list, list); if (option_verbose > 1) ast_verbose(VERBOSE_PREFIX_2 "Unregistered '%s' CDR backend\n", name); free(i); break; } } AST_LIST_TRAVERSE_SAFE_END; AST_LIST_UNLOCK(&be_list); }

int ast_cdr_update (  struct ast_channel *  c  )

Definition at line 757 of file cdr.c. References ast_cdr::accountcode, ast_channel::accountcode, AST_CDR_FLAG_LOCKED, AST_MAX_EXTENSION, ast_strlen_zero(), ast_test_flag, ast_channel::cdr, ast_channel::cid, ast_callerid::cid_ani, ast_callerid::cid_name, ast_callerid::cid_num, ast_cdr::clid, ast_channel::context, ast_cdr::dcontext, ast_cdr::dst, ast_channel::exten, ast_channel::macrocontext, ast_channel::macroexten, ast_cdr::next, and ast_cdr::src. Referenced by __ast_pbx_run(), __ast_request_and_dial(), ast_feature_request_and_dial(), ast_parseable_goto(), and cb_events(). { struct ast_cdr *cdr = c->cdr; char *num; char tmp[AST_MAX_EXTENSION] = ""; while (cdr) { if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) { num = c->cid.cid_ani ? c->cid.cid_ani : c->cid.cid_num; if (c->cid.cid_name && num) snprintf(tmp, sizeof(tmp), "\"%s\" <%s>", c->cid.cid_name, num); else if (c->cid.cid_name) ast_copy_string(tmp, c->cid.cid_name, sizeof(tmp)); else if (num) ast_copy_string(tmp, num, sizeof(tmp)); ast_copy_string(cdr->clid, tmp, sizeof(cdr->clid)); ast_copy_string(cdr->src, num ? num : "", sizeof(cdr->src)); /* Copy account code et-al */ ast_copy_string(cdr->accountcode, c->accountcode, sizeof(cdr->accountcode)); /* Destination information */ ast_copy_string(cdr->dst, (ast_strlen_zero(c->macroexten)) ? c->exten : c->macroexten, sizeof(cdr->dst)); ast_copy_string(cdr->dcontext, (ast_strlen_zero(c->macrocontext)) ? c->context : c->macrocontext, sizeof(cdr->dcontext)); } cdr = cdr->next; } return 0; }

static AST_LIST_HEAD_STATIC (  be_list  , ast_cdr_beitem  )  [static]

AST_MUTEX_DEFINE_STATIC (  cdr_pending_lock   )

AST_MUTEX_DEFINE_STATIC (  cdr_batch_lock   )

static void* do_batch_backend_process (  void *  data  )  [static]

Definition at line 910 of file cdr.c. References ast_cdr_free(), ast_cdr_batch_item::cdr, free, ast_cdr_batch_item::next, and post_cdr(). Referenced by ast_cdr_submit_batch(). { struct ast_cdr_batch_item *processeditem; struct ast_cdr_batch_item *batchitem = data; /* Push each CDR into storage mechanism(s) and free all the memory */ while (batchitem) { post_cdr(batchitem->cdr); ast_cdr_free(batchitem->cdr); processeditem = batchitem; batchitem = batchitem->next; free(processeditem); } return NULL; }

static void* do_cdr (  void *  data  )  [static]

Definition at line 1040 of file cdr.c. References ast_cond_timedwait(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_runq(), ast_sched_wait(), cdr_pending_cond, LOG_DEBUG, and option_debug. Referenced by do_reload(). { struct timespec timeout; int schedms; int numevents = 0; for(;;) { struct timeval now = ast_tvnow(); schedms = ast_sched_wait(sched); /* this shouldn't happen, but provide a 1 second default just in case */ if (schedms <= 0) schedms = 1000; timeout.tv_sec = now.tv_sec + (schedms / 1000); timeout.tv_nsec = (now.tv_usec * 1000) + ((schedms % 1000) * 1000); /* prevent stuff from clobbering cdr_pending_cond, then wait on signals sent to it until the timeout expires */ ast_mutex_lock(&cdr_pending_lock); ast_cond_timedwait(&cdr_pending_cond, &cdr_pending_lock, &timeout); numevents = ast_sched_runq(sched); ast_mutex_unlock(&cdr_pending_lock); if (option_debug > 1) ast_log(LOG_DEBUG, "Processed %d scheduled CDR batches from the run queue\n", numevents); } return NULL; }

static int do_reload (  void   )  [static]

Definition at line 1129 of file cdr.c. References ast_cdr_engine_term(), ast_cli_register(), ast_cli_unregister(), ast_cond_destroy(), ast_cond_init(), ast_config_destroy(), ast_config_load(), ast_log(), ast_mutex_lock(), ast_mutex_unlock(), ast_pthread_create, AST_PTHREADT_NULL, ast_register_atexit(), ast_sched_add(), ast_sched_del(), ast_true(), ast_unregister_atexit(), ast_variable_retrieve(), BATCH_SAFE_SHUTDOWN_DEFAULT, BATCH_SCHEDULER_ONLY_DEFAULT, BATCH_SIZE_DEFAULT, BATCH_TIME_DEFAULT, batchmode, batchsafeshutdown, batchscheduleronly, batchsize, batchtime, cdr_pending_cond, cdr_sched, cdr_thread, config, do_cdr(), enabled, LOG_ERROR, LOG_NOTICE, LOG_WARNING, and submit_scheduled_batch(). Referenced by ast_cdr_engine_init(), ast_cdr_engine_reload(), dnsmgr_init(), dnsmgr_reload(), and handle_cli_reload(). { struct ast_config *config; const char *enabled_value; const char *batched_value; const char *scheduleronly_value; const char *batchsafeshutdown_value; const char *size_value; const char *time_value; int cfg_size; int cfg_time; int was_enabled; int was_batchmode; int res=0; ast_mutex_lock(&cdr_batch_lock); batchsize = BATCH_SIZE_DEFAULT; batchtime = BATCH_TIME_DEFAULT; batchscheduleronly = BATCH_SCHEDULER_ONLY_DEFAULT; batchsafeshutdown = BATCH_SAFE_SHUTDOWN_DEFAULT; was_enabled = enabled; was_batchmode = batchmode; enabled = 1; batchmode = 0; /* don't run the next scheduled CDR posting while reloading */ if (cdr_sched > -1) ast_sched_del(sched, cdr_sched); if ((config = ast_config_load("cdr.conf"))) { if ((enabled_value = ast_variable_retrieve(config, "general", "enable"))) { enabled = ast_true(enabled_value); } if ((batched_value = ast_variable_retrieve(config, "general", "batch"))) { batchmode = ast_true(batched_value); } if ((scheduleronly_value = ast_variable_retrieve(config, "general", "scheduleronly"))) { batchscheduleronly = ast_true(scheduleronly_value); } if ((batchsafeshutdown_value = ast_variable_retrieve(config, "general", "safeshutdown"))) { batchsafeshutdown = ast_true(batchsafeshutdown_value); } if ((size_value = ast_variable_retrieve(config, "general", "size"))) { if (sscanf(size_value, "%d", &cfg_size) < 1) ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", size_value); else if (size_value < 0) ast_log(LOG_WARNING, "Invalid maximum batch size '%d' specified, using default\n", cfg_size); else batchsize = cfg_size; } if ((time_value = ast_variable_retrieve(config, "general", "time"))) { if (sscanf(time_value, "%d", &cfg_time) < 1) ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", time_value); else if (time_value < 0) ast_log(LOG_WARNING, "Invalid maximum batch time '%d' specified, using default\n", cfg_time); else batchtime = cfg_time; } } if (enabled && !batchmode) { ast_log(LOG_NOTICE, "CDR simple logging enabled.\n"); } else if (enabled && batchmode) { cdr_sched = ast_sched_add(sched, batchtime * 1000, submit_scheduled_batch, NULL); ast_log(LOG_NOTICE, "CDR batch mode logging enabled, first of either size %d or time %d seconds.\n", batchsize, batchtime); } else { ast_log(LOG_NOTICE, "CDR logging disabled, data will be lost.\n"); } /* if this reload enabled the CDR batch mode, create the background thread if it does not exist */ if (enabled && batchmode && (!was_enabled || !was_batchmode) && (cdr_thread == AST_PTHREADT_NULL)) { ast_cond_init(&cdr_pending_cond, NULL); if (ast_pthread_create(&cdr_thread, NULL, do_cdr, NULL) < 0) { ast_log(LOG_ERROR, "Unable to start CDR thread.\n"); ast_sched_del(sched, cdr_sched); } else { ast_cli_register(&cli_submit); ast_register_atexit(ast_cdr_engine_term); res = 0; } /* if this reload disabled the CDR and/or batch mode and there is a background thread, kill it */ } else if (((!enabled && was_enabled) || (!batchmode && was_batchmode)) && (cdr_thread != AST_PTHREADT_NULL)) { /* wake up the thread so it will exit */ pthread_cancel(cdr_thread); pthread_kill(cdr_thread, SIGURG); pthread_join(cdr_thread, NULL); cdr_thread = AST_PTHREADT_NULL; ast_cond_destroy(&cdr_pending_cond); ast_cli_unregister(&cli_submit); ast_unregister_atexit(ast_cdr_engine_term); res = 0; /* if leaving batch mode, then post the CDRs in the batch, and don't reschedule, since we are stopping CDR logging */ if (!batchmode && was_batchmode) { ast_cdr_engine_term(); } } else { res = 0; } ast_mutex_unlock(&cdr_batch_lock); ast_config_destroy(config); return res; }

static int handle_cli_status (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 1066 of file cdr.c. References ast_cli(), AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_sched_when(), batch, batchmode, batchsafeshutdown, batchscheduleronly, batchsize, batchtime, cdr_sched, enabled, list, ast_cdr_beitem::name, and RESULT_SHOWUSAGE. { struct ast_cdr_beitem *beitem=NULL; int cnt=0; long nextbatchtime=0; if (argc > 2) return RESULT_SHOWUSAGE; ast_cli(fd, "CDR logging: %s\n", enabled ? "enabled" : "disabled"); ast_cli(fd, "CDR mode: %s\n", batchmode ? "batch" : "simple"); if (enabled) { if (batchmode) { if (batch) cnt = batch->size; if (cdr_sched > -1) nextbatchtime = ast_sched_when(sched, cdr_sched); ast_cli(fd, "CDR safe shut down: %s\n", batchsafeshutdown ? "enabled" : "disabled"); ast_cli(fd, "CDR batch threading model: %s\n", batchscheduleronly ? "scheduler only" : "scheduler plus separate threads"); ast_cli(fd, "CDR current batch size: %d record%s\n", cnt, (cnt != 1) ? "s" : ""); ast_cli(fd, "CDR maximum batch size: %d record%s\n", batchsize, (batchsize != 1) ? "s" : ""); ast_cli(fd, "CDR maximum batch time: %d second%s\n", batchtime, (batchtime != 1) ? "s" : ""); ast_cli(fd, "CDR next scheduled batch processing time: %ld second%s\n", nextbatchtime, (nextbatchtime != 1) ? "s" : ""); } AST_LIST_LOCK(&be_list); AST_LIST_TRAVERSE(&be_list, beitem, list) { ast_cli(fd, "CDR registered backend: %s\n", beitem->name); } AST_LIST_UNLOCK(&be_list); } return 0; }

static int handle_cli_submit (  int  fd, int  argc, char *  argv[] )  [static]

Definition at line 1100 of file cdr.c. References ast_cli(), RESULT_SHOWUSAGE, and submit_unscheduled_batch(). { if (argc > 2) return RESULT_SHOWUSAGE; submit_unscheduled_batch(); ast_cli(fd, "Submitted CDRs to backend engines for processing. This may take a while.\n"); return 0; }

static int init_batch (  void   )  [static]

Note: Don't call without cdr_batch_lock Definition at line 896 of file cdr.c. References ast_log(), batch, LOG_WARNING, malloc, and reset_batch(). Referenced by ast_cdr_detach(), and ast_cdr_engine_init(). { /* This is the single meta-batch used to keep track of all CDRs during the entire life of the program */ batch = malloc(sizeof(*batch)); if (!batch) { ast_log(LOG_WARNING, "CDR: out of memory while trying to handle batched records, data will most likely be lost\n"); return -1; } reset_batch(); return 0; }

static void post_cdr (  struct ast_cdr *  cdr  )  [static]

Definition at line 801 of file cdr.c. References ast_cdr::answer, AST_CDR_FAILED, AST_CDR_FLAG_POSTED, AST_LIST_LOCK, AST_LIST_TRAVERSE, AST_LIST_UNLOCK, ast_log(), ast_set_flag, ast_strlen_zero(), ast_test_flag, ast_cdr_beitem::be, ast_cdr::billsec, ast_cdr::channel, ast_cdr::disposition, ast_cdr::duration, ast_cdr::end, list, LOG_WARNING, ast_cdr::next, and ast_cdr::start. Referenced by ast_cdr_detach(), and do_batch_backend_process(). { char *chan; struct ast_cdr_beitem *i; while (cdr) { chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>"; if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED)) ast_log(LOG_WARNING, "CDR on channel '%s' already posted\n", chan); if (ast_tvzero(cdr->end)) ast_log(LOG_WARNING, "CDR on channel '%s' lacks end\n", chan); if (ast_tvzero(cdr->start)) { ast_log(LOG_WARNING, "CDR on channel '%s' lacks start\n", chan); cdr->disposition = AST_CDR_FAILED; } else cdr->duration = cdr->end.tv_sec - cdr->start.tv_sec; if (!ast_tvzero(cdr->answer)) cdr->billsec = cdr->end.tv_sec - cdr->answer.tv_sec; else cdr->billsec = 0; ast_set_flag(cdr, AST_CDR_FLAG_POSTED); AST_LIST_LOCK(&be_list); AST_LIST_TRAVERSE(&be_list, i, list) { i->be(cdr); } AST_LIST_UNLOCK(&be_list); cdr = cdr->next; } }

static void reset_batch (  void   )  [static]

Note: Don't call without cdr_batch_lock Definition at line 888 of file cdr.c. References batch, ast_cdr_batch::head, ast_cdr_batch::size, and ast_cdr_batch::tail. Referenced by ast_cdr_submit_batch(), and init_batch(). { batch->size = 0; batch->head = NULL; batch->tail = NULL; }

static int submit_scheduled_batch (  void *  data  )  [static]

Definition at line 962 of file cdr.c. References ast_cdr_submit_batch(), ast_sched_add(), batchtime, and cdr_sched. Referenced by do_reload(), and submit_unscheduled_batch(). { ast_cdr_submit_batch(0); /* manually reschedule from this point in time */ cdr_sched = ast_sched_add(sched, batchtime * 1000, submit_scheduled_batch, NULL); /* returning zero so the scheduler does not automatically reschedule */ return 0; }

static void submit_unscheduled_batch (  void   )  [static]

Definition at line 971 of file cdr.c. References ast_cond_signal(), ast_mutex_lock(), ast_mutex_unlock(), ast_sched_add(), ast_sched_del(), cdr_pending_cond, cdr_sched, and submit_scheduled_batch(). Referenced by ast_cdr_detach(), and handle_cli_submit(). { /* this is okay since we are not being called from within the scheduler */ if (cdr_sched > -1) ast_sched_del(sched, cdr_sched); /* schedule the submission to occur ASAP (1 ms) */ cdr_sched = ast_sched_add(sched, 1, submit_scheduled_batch, NULL); /* signal the do_cdr thread to wakeup early and do some work (that lazy thread ;) */ ast_mutex_lock(&cdr_pending_lock); ast_cond_signal(&cdr_pending_cond); ast_mutex_unlock(&cdr_pending_lock); }

---

Variable Documentation

char ast_default_accountcode[AST_MAX_ACCOUNT_CODE] = ""

Definition at line 58 of file cdr.c. Referenced by ast_channel_alloc().

int ast_default_amaflags = AST_CDR_DOCUMENTATION

Default AMA flag for billing records (CDR's) Definition at line 57 of file cdr.c. Referenced by ast_cdr_init(), and ast_channel_alloc().

struct ast_cdr_batch * batch [static]

Referenced by ast_cdr_detach(), ast_cdr_submit_batch(), handle_cli_status(), init_batch(), and reset_batch().

int batchmode [static]

Definition at line 90 of file cdr.c. Referenced by ast_cdr_detach(), do_reload(), and handle_cli_status().

int batchsafeshutdown [static]

Definition at line 94 of file cdr.c. Referenced by ast_cdr_engine_term(), do_reload(), and handle_cli_status().

int batchscheduleronly [static]

Definition at line 93 of file cdr.c. Referenced by ast_cdr_submit_batch(), do_reload(), and handle_cli_status().

int batchsize [static]

Definition at line 91 of file cdr.c. Referenced by ast_cdr_detach(), do_reload(), and handle_cli_status().

int batchtime [static]

Definition at line 92 of file cdr.c. Referenced by do_reload(), handle_cli_status(), and submit_scheduled_batch().

ast_cond_t cdr_pending_cond [static]

Definition at line 100 of file cdr.c. Referenced by do_cdr(), do_reload(), and submit_unscheduled_batch().

int cdr_sched = -1 [static]

Definition at line 81 of file cdr.c. Referenced by do_reload(), handle_cli_status(), submit_scheduled_batch(), and submit_unscheduled_batch().

pthread_t cdr_thread = AST_PTHREADT_NULL [static]

Definition at line 82 of file cdr.c. Referenced by do_reload().

struct ast_cli_entry cli_status [static]

Definition at line 1120 of file cdr.c.

struct ast_cli_entry cli_submit [static]

Definition at line 1111 of file cdr.c.

int enabled [static]

Definition at line 89 of file cdr.c. Referenced by ast_cdr_detach(), ast_dnsmgr_lookup(), do_reload(), handle_cli_status(), init_manager(), and load_odbc_config().

struct sched_context* sched [static]

Definition at line 80 of file cdr.c.

---