00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034 #include "asterisk.h"
00035
00036 ASTERISK_FILE_VERSION(__FILE__, "$Revision: 258705 $")
00037
00038 #include <signal.h>
00039
00040 #include "asterisk/lock.h"
00041 #include "asterisk/channel.h"
00042 #include "asterisk/cdr.h"
00043 #include "asterisk/callerid.h"
00044 #include "asterisk/manager.h"
00045 #include "asterisk/causes.h"
00046 #include "asterisk/linkedlists.h"
00047 #include "asterisk/utils.h"
00048 #include "asterisk/sched.h"
00049 #include "asterisk/config.h"
00050 #include "asterisk/cli.h"
00051 #include "asterisk/stringfields.h"
00052
00053
00054 int ast_default_amaflags = AST_CDR_DOCUMENTATION;
00055 char ast_default_accountcode[AST_MAX_ACCOUNT_CODE];
00056
00057 struct ast_cdr_beitem {
00058 char name[20];
00059 char desc[80];
00060 ast_cdrbe be;
00061 AST_RWLIST_ENTRY(ast_cdr_beitem) list;
00062 };
00063
00064 static AST_RWLIST_HEAD_STATIC(be_list, ast_cdr_beitem);
00065
00066 struct ast_cdr_batch_item {
00067 struct ast_cdr *cdr;
00068 struct ast_cdr_batch_item *next;
00069 };
00070
00071 static struct ast_cdr_batch {
00072 int size;
00073 struct ast_cdr_batch_item *head;
00074 struct ast_cdr_batch_item *tail;
00075 } *batch = NULL;
00076
00077 static struct sched_context *sched;
00078 static int cdr_sched = -1;
00079 static pthread_t cdr_thread = AST_PTHREADT_NULL;
00080
00081 #define BATCH_SIZE_DEFAULT 100
00082 #define BATCH_TIME_DEFAULT 300
00083 #define BATCH_SCHEDULER_ONLY_DEFAULT 0
00084 #define BATCH_SAFE_SHUTDOWN_DEFAULT 1
00085
00086 static int enabled;
00087 static int unanswered;
00088 static int batchmode;
00089 static int batchsize;
00090 static int batchtime;
00091 static int batchscheduleronly;
00092 static int batchsafeshutdown;
00093
00094 AST_MUTEX_DEFINE_STATIC(cdr_batch_lock);
00095
00096
00097 AST_MUTEX_DEFINE_STATIC(cdr_pending_lock);
00098 static ast_cond_t cdr_pending_cond;
00099
00100 int check_cdr_enabled()
00101 {
00102 return enabled;
00103 }
00104
00105
00106
00107
00108 int ast_cdr_register(const char *name, const char *desc, ast_cdrbe be)
00109 {
00110 struct ast_cdr_beitem *i = NULL;
00111
00112 if (!name)
00113 return -1;
00114
00115 if (!be) {
00116 ast_log(LOG_WARNING, "CDR engine '%s' lacks backend\n", name);
00117 return -1;
00118 }
00119
00120 AST_RWLIST_WRLOCK(&be_list);
00121 AST_RWLIST_TRAVERSE(&be_list, i, list) {
00122 if (!strcasecmp(name, i->name)) {
00123 ast_log(LOG_WARNING, "Already have a CDR backend called '%s'\n", name);
00124 AST_RWLIST_UNLOCK(&be_list);
00125 return -1;
00126 }
00127 }
00128
00129 if (!(i = ast_calloc(1, sizeof(*i))))
00130 return -1;
00131
00132 i->be = be;
00133 ast_copy_string(i->name, name, sizeof(i->name));
00134 ast_copy_string(i->desc, desc, sizeof(i->desc));
00135
00136 AST_RWLIST_INSERT_HEAD(&be_list, i, list);
00137 AST_RWLIST_UNLOCK(&be_list);
00138
00139 return 0;
00140 }
00141
00142
00143 void ast_cdr_unregister(const char *name)
00144 {
00145 struct ast_cdr_beitem *i = NULL;
00146
00147 AST_RWLIST_WRLOCK(&be_list);
00148 AST_RWLIST_TRAVERSE_SAFE_BEGIN(&be_list, i, list) {
00149 if (!strcasecmp(name, i->name)) {
00150 AST_RWLIST_REMOVE_CURRENT(list);
00151 ast_verb(2, "Unregistered '%s' CDR backend\n", name);
00152 ast_free(i);
00153 break;
00154 }
00155 }
00156 AST_RWLIST_TRAVERSE_SAFE_END;
00157 AST_RWLIST_UNLOCK(&be_list);
00158 }
00159
00160 int ast_cdr_isset_unanswered(void)
00161 {
00162 return unanswered;
00163 }
00164
00165
00166
00167
00168 struct ast_cdr *ast_cdr_dup(struct ast_cdr *cdr)
00169 {
00170 struct ast_cdr *newcdr;
00171
00172 if (!cdr)
00173 return NULL;
00174 newcdr = ast_cdr_alloc();
00175 if (!newcdr)
00176 return NULL;
00177
00178 memcpy(newcdr, cdr, sizeof(*newcdr));
00179
00180 memset(&newcdr->varshead, 0, sizeof(newcdr->varshead));
00181 ast_cdr_copy_vars(newcdr, cdr);
00182 newcdr->next = NULL;
00183
00184 return newcdr;
00185 }
00186
00187 static const char *ast_cdr_getvar_internal(struct ast_cdr *cdr, const char *name, int recur)
00188 {
00189 if (ast_strlen_zero(name))
00190 return NULL;
00191
00192 for (; cdr; cdr = recur ? cdr->next : NULL) {
00193 struct ast_var_t *variables;
00194 struct varshead *headp = &cdr->varshead;
00195 AST_LIST_TRAVERSE(headp, variables, entries) {
00196 if (!strcasecmp(name, ast_var_name(variables)))
00197 return ast_var_value(variables);
00198 }
00199 }
00200
00201 return NULL;
00202 }
00203
00204 static void cdr_get_tv(struct timeval when, const char *fmt, char *buf, int bufsize)
00205 {
00206 if (fmt == NULL) {
00207 snprintf(buf, bufsize, "%ld.%06ld", (long)when.tv_sec, (long)when.tv_usec);
00208 } else {
00209 if (when.tv_sec) {
00210 struct ast_tm tm;
00211
00212 ast_localtime(&when, &tm, NULL);
00213 ast_strftime(buf, bufsize, fmt, &tm);
00214 }
00215 }
00216 }
00217
00218
00219 void ast_cdr_getvar(struct ast_cdr *cdr, const char *name, char **ret, char *workspace, int workspacelen, int recur, int raw)
00220 {
00221 const char *fmt = "%Y-%m-%d %T";
00222 const char *varbuf;
00223
00224 if (!cdr)
00225 return;
00226
00227 *ret = NULL;
00228
00229
00230
00231 if (!strcasecmp(name, "clid"))
00232 ast_copy_string(workspace, cdr->clid, workspacelen);
00233 else if (!strcasecmp(name, "src"))
00234 ast_copy_string(workspace, cdr->src, workspacelen);
00235 else if (!strcasecmp(name, "dst"))
00236 ast_copy_string(workspace, cdr->dst, workspacelen);
00237 else if (!strcasecmp(name, "dcontext"))
00238 ast_copy_string(workspace, cdr->dcontext, workspacelen);
00239 else if (!strcasecmp(name, "channel"))
00240 ast_copy_string(workspace, cdr->channel, workspacelen);
00241 else if (!strcasecmp(name, "dstchannel"))
00242 ast_copy_string(workspace, cdr->dstchannel, workspacelen);
00243 else if (!strcasecmp(name, "lastapp"))
00244 ast_copy_string(workspace, cdr->lastapp, workspacelen);
00245 else if (!strcasecmp(name, "lastdata"))
00246 ast_copy_string(workspace, cdr->lastdata, workspacelen);
00247 else if (!strcasecmp(name, "start"))
00248 cdr_get_tv(cdr->start, raw ? NULL : fmt, workspace, workspacelen);
00249 else if (!strcasecmp(name, "answer"))
00250 cdr_get_tv(cdr->answer, raw ? NULL : fmt, workspace, workspacelen);
00251 else if (!strcasecmp(name, "end"))
00252 cdr_get_tv(cdr->end, raw ? NULL : fmt, workspace, workspacelen);
00253 else if (!strcasecmp(name, "duration"))
00254 snprintf(workspace, workspacelen, "%ld", cdr->duration ? cdr->duration : (long)ast_tvdiff_ms(ast_tvnow(), cdr->start) / 1000);
00255 else if (!strcasecmp(name, "billsec"))
00256 snprintf(workspace, workspacelen, "%ld", cdr->billsec || cdr->answer.tv_sec == 0 ? cdr->billsec : (long)ast_tvdiff_ms(ast_tvnow(), cdr->answer) / 1000);
00257 else if (!strcasecmp(name, "disposition")) {
00258 if (raw) {
00259 snprintf(workspace, workspacelen, "%ld", cdr->disposition);
00260 } else {
00261 ast_copy_string(workspace, ast_cdr_disp2str(cdr->disposition), workspacelen);
00262 }
00263 } else if (!strcasecmp(name, "amaflags")) {
00264 if (raw) {
00265 snprintf(workspace, workspacelen, "%ld", cdr->amaflags);
00266 } else {
00267 ast_copy_string(workspace, ast_cdr_flags2str(cdr->amaflags), workspacelen);
00268 }
00269 } else if (!strcasecmp(name, "accountcode"))
00270 ast_copy_string(workspace, cdr->accountcode, workspacelen);
00271 else if (!strcasecmp(name, "uniqueid"))
00272 ast_copy_string(workspace, cdr->uniqueid, workspacelen);
00273 else if (!strcasecmp(name, "userfield"))
00274 ast_copy_string(workspace, cdr->userfield, workspacelen);
00275 else if ((varbuf = ast_cdr_getvar_internal(cdr, name, recur)))
00276 ast_copy_string(workspace, varbuf, workspacelen);
00277 else
00278 workspace[0] = '\0';
00279
00280 if (!ast_strlen_zero(workspace))
00281 *ret = workspace;
00282 }
00283
00284
00285 static const char *cdr_readonly_vars[] = { "clid", "src", "dst", "dcontext", "channel", "dstchannel",
00286 "lastapp", "lastdata", "start", "answer", "end", "duration",
00287 "billsec", "disposition", "amaflags", "accountcode", "uniqueid",
00288 "userfield", NULL };
00289
00290
00291
00292 int ast_cdr_setvar(struct ast_cdr *cdr, const char *name, const char *value, int recur)
00293 {
00294 struct ast_var_t *newvariable;
00295 struct varshead *headp;
00296 int x;
00297
00298 if (!cdr)
00299 return -1;
00300
00301 for (x = 0; cdr_readonly_vars[x]; x++) {
00302 if (!strcasecmp(name, cdr_readonly_vars[x])) {
00303 ast_log(LOG_ERROR, "Attempt to set the '%s' read-only variable!.\n", name);
00304 return -1;
00305 }
00306 }
00307
00308 if (!cdr) {
00309 ast_log(LOG_ERROR, "Attempt to set a variable on a nonexistent CDR record.\n");
00310 return -1;
00311 }
00312
00313 for (; cdr; cdr = recur ? cdr->next : NULL) {
00314 if (ast_test_flag(cdr, AST_CDR_FLAG_DONT_TOUCH) && ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00315 continue;
00316 headp = &cdr->varshead;
00317 AST_LIST_TRAVERSE_SAFE_BEGIN(headp, newvariable, entries) {
00318 if (!strcasecmp(ast_var_name(newvariable), name)) {
00319
00320 AST_LIST_REMOVE_CURRENT(entries);
00321 ast_var_delete(newvariable);
00322 break;
00323 }
00324 }
00325 AST_LIST_TRAVERSE_SAFE_END;
00326
00327 if (value) {
00328 newvariable = ast_var_assign(name, value);
00329 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
00330 }
00331 }
00332
00333 return 0;
00334 }
00335
00336 int ast_cdr_copy_vars(struct ast_cdr *to_cdr, struct ast_cdr *from_cdr)
00337 {
00338 struct ast_var_t *variables, *newvariable = NULL;
00339 struct varshead *headpa, *headpb;
00340 const char *var, *val;
00341 int x = 0;
00342
00343 if (!to_cdr || !from_cdr)
00344 return 0;
00345
00346 headpa = &from_cdr->varshead;
00347 headpb = &to_cdr->varshead;
00348
00349 AST_LIST_TRAVERSE(headpa,variables,entries) {
00350 if (variables &&
00351 (var = ast_var_name(variables)) && (val = ast_var_value(variables)) &&
00352 !ast_strlen_zero(var) && !ast_strlen_zero(val)) {
00353 newvariable = ast_var_assign(var, val);
00354 AST_LIST_INSERT_HEAD(headpb, newvariable, entries);
00355 x++;
00356 }
00357 }
00358
00359 return x;
00360 }
00361
00362 int ast_cdr_serialize_variables(struct ast_cdr *cdr, struct ast_str **buf, char delim, char sep, int recur)
00363 {
00364 struct ast_var_t *variables;
00365 const char *var, *val;
00366 char *tmp;
00367 char workspace[256];
00368 int total = 0, x = 0, i;
00369
00370 (*buf)->used = 0;
00371 (*buf)->str[0] = '\0';
00372
00373 for (; cdr; cdr = recur ? cdr->next : NULL) {
00374 if (++x > 1)
00375 ast_str_append(buf, 0, "\n");
00376
00377 AST_LIST_TRAVERSE(&cdr->varshead, variables, entries) {
00378 if (variables &&
00379 (var = ast_var_name(variables)) && (val = ast_var_value(variables)) &&
00380 !ast_strlen_zero(var) && !ast_strlen_zero(val)) {
00381 if (ast_str_append(buf, 0, "level %d: %s%c%s%c", x, var, delim, val, sep) < 0) {
00382 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
00383 break;
00384 } else
00385 total++;
00386 } else
00387 break;
00388 }
00389
00390 for (i = 0; cdr_readonly_vars[i]; i++) {
00391 workspace[0] = 0;
00392 ast_cdr_getvar(cdr, cdr_readonly_vars[i], &tmp, workspace, sizeof(workspace), 0, 0);
00393 if (!tmp)
00394 continue;
00395
00396 if (ast_str_append(buf, 0, "level %d: %s%c%s%c", x, cdr_readonly_vars[i], delim, tmp, sep) < 0) {
00397 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
00398 break;
00399 } else
00400 total++;
00401 }
00402 }
00403
00404 return total;
00405 }
00406
00407
00408 void ast_cdr_free_vars(struct ast_cdr *cdr, int recur)
00409 {
00410
00411
00412 for (; cdr; cdr = recur ? cdr->next : NULL) {
00413 struct ast_var_t *vardata;
00414 struct varshead *headp = &cdr->varshead;
00415 while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries)))
00416 ast_var_delete(vardata);
00417 }
00418 }
00419
00420
00421 static void check_post(struct ast_cdr *cdr)
00422 {
00423 if (!cdr)
00424 return;
00425 if (ast_test_flag(cdr, AST_CDR_FLAG_POSTED))
00426 ast_log(LOG_NOTICE, "CDR on channel '%s' already posted\n", S_OR(cdr->channel, "<unknown>"));
00427 }
00428
00429 void ast_cdr_free(struct ast_cdr *cdr)
00430 {
00431
00432 while (cdr) {
00433 struct ast_cdr *next = cdr->next;
00434
00435 ast_cdr_free_vars(cdr, 0);
00436 ast_free(cdr);
00437 cdr = next;
00438 }
00439 }
00440
00441
00442 void ast_cdr_discard(struct ast_cdr *cdr)
00443 {
00444 while (cdr) {
00445 struct ast_cdr *next = cdr->next;
00446
00447 ast_cdr_free_vars(cdr, 0);
00448 ast_free(cdr);
00449 cdr = next;
00450 }
00451 }
00452
00453 struct ast_cdr *ast_cdr_alloc(void)
00454 {
00455 struct ast_cdr *x;
00456 x = ast_calloc(1, sizeof(*x));
00457 if (!x)
00458 ast_log(LOG_ERROR,"Allocation Failure for a CDR!\n");
00459 return x;
00460 }
00461
00462 static void cdr_merge_vars(struct ast_cdr *to, struct ast_cdr *from)
00463 {
00464 struct ast_var_t *variablesfrom,*variablesto;
00465 struct varshead *headpfrom = &to->varshead;
00466 struct varshead *headpto = &from->varshead;
00467 AST_LIST_TRAVERSE_SAFE_BEGIN(headpfrom, variablesfrom, entries) {
00468
00469 const char *fromvarname, *fromvarval;
00470 const char *tovarname = NULL, *tovarval = NULL;
00471 fromvarname = ast_var_name(variablesfrom);
00472 fromvarval = ast_var_value(variablesfrom);
00473 tovarname = 0;
00474
00475
00476 AST_LIST_TRAVERSE(headpto, variablesto, entries) {
00477
00478
00479 if ( strcasecmp(fromvarname, ast_var_name(variablesto)) == 0 ) {
00480 tovarname = ast_var_name(variablesto);
00481 tovarval = ast_var_value(variablesto);
00482 break;
00483 }
00484 }
00485 if (tovarname && strcasecmp(fromvarval,tovarval) != 0) {
00486 ast_log(LOG_NOTICE, "Merging CDR's: variable %s value %s dropped in favor of value %s\n", tovarname, fromvarval, tovarval);
00487 continue;
00488 } else if (tovarname && strcasecmp(fromvarval,tovarval) == 0)
00489 continue;
00490
00491
00492 AST_LIST_MOVE_CURRENT(headpto, entries);
00493 }
00494 AST_LIST_TRAVERSE_SAFE_END;
00495 }
00496
00497 void ast_cdr_merge(struct ast_cdr *to, struct ast_cdr *from)
00498 {
00499 struct ast_cdr *zcdr;
00500 struct ast_cdr *lto = NULL;
00501 struct ast_cdr *lfrom = NULL;
00502 int discard_from = 0;
00503
00504 if (!to || !from)
00505 return;
00506
00507
00508 if (ast_test_flag(to, AST_CDR_FLAG_LOCKED)) {
00509 zcdr = to;
00510 while (to->next) {
00511 lto = to;
00512 to = to->next;
00513 }
00514
00515 if (ast_test_flag(to, AST_CDR_FLAG_LOCKED)) {
00516 ast_log(LOG_WARNING, "Merging into locked CDR... no choice.");
00517 to = zcdr;
00518 lto = NULL;
00519 }
00520 }
00521
00522 if (ast_test_flag(from, AST_CDR_FLAG_LOCKED)) {
00523 struct ast_cdr *llfrom = NULL;
00524 discard_from = 1;
00525 if (lto) {
00526
00527 lto->next = from;
00528 lfrom = from;
00529 while (lfrom && lfrom->next) {
00530 if (!lfrom->next->next)
00531 llfrom = lfrom;
00532 lfrom = lfrom->next;
00533 }
00534
00535 llfrom->next = to;
00536 from = lfrom;
00537 } else {
00538
00539 struct ast_cdr tcdr;
00540 memcpy(&tcdr, to, sizeof(tcdr));
00541
00542 memcpy(to, from, sizeof(*to));
00543 lfrom = from;
00544 while (lfrom && lfrom->next) {
00545 if (!lfrom->next->next)
00546 llfrom = lfrom;
00547 lfrom = lfrom->next;
00548 }
00549 from->next = NULL;
00550
00551 if (llfrom == from)
00552 to = to->next = ast_cdr_dup(&tcdr);
00553 else
00554 to = llfrom->next = ast_cdr_dup(&tcdr);
00555 from = lfrom;
00556 }
00557 }
00558
00559 if (!ast_tvzero(from->start)) {
00560 if (!ast_tvzero(to->start)) {
00561 if (ast_tvcmp(to->start, from->start) > 0 ) {
00562 to->start = from->start;
00563 from->start = ast_tv(0,0);
00564 }
00565
00566 } else {
00567 to->start = from->start;
00568 from->start = ast_tv(0,0);
00569 }
00570 }
00571 if (!ast_tvzero(from->answer)) {
00572 if (!ast_tvzero(to->answer)) {
00573 if (ast_tvcmp(to->answer, from->answer) > 0 ) {
00574 to->answer = from->answer;
00575 from->answer = ast_tv(0,0);
00576 }
00577
00578 } else {
00579 to->answer = from->answer;
00580 from->answer = ast_tv(0,0);
00581 }
00582 }
00583 if (!ast_tvzero(from->end)) {
00584 if (!ast_tvzero(to->end)) {
00585 if (ast_tvcmp(to->end, from->end) < 0 ) {
00586 to->end = from->end;
00587 from->end = ast_tv(0,0);
00588 to->duration = to->end.tv_sec - to->start.tv_sec;
00589 to->billsec = ast_tvzero(to->answer) ? 0 : to->end.tv_sec - to->answer.tv_sec;
00590 }
00591
00592 } else {
00593 to->end = from->end;
00594 from->end = ast_tv(0,0);
00595 to->duration = to->end.tv_sec - to->start.tv_sec;
00596 to->billsec = ast_tvzero(to->answer) ? 0 : to->end.tv_sec - to->answer.tv_sec;
00597 }
00598 }
00599 if (to->disposition < from->disposition) {
00600 to->disposition = from->disposition;
00601 from->disposition = AST_CDR_NOANSWER;
00602 }
00603 if (ast_strlen_zero(to->lastapp) && !ast_strlen_zero(from->lastapp)) {
00604 ast_copy_string(to->lastapp, from->lastapp, sizeof(to->lastapp));
00605 from->lastapp[0] = 0;
00606 }
00607 if (ast_strlen_zero(to->lastdata) && !ast_strlen_zero(from->lastdata)) {
00608 ast_copy_string(to->lastdata, from->lastdata, sizeof(to->lastdata));
00609 from->lastdata[0] = 0;
00610 }
00611 if (ast_strlen_zero(to->dcontext) && !ast_strlen_zero(from->dcontext)) {
00612 ast_copy_string(to->dcontext, from->dcontext, sizeof(to->dcontext));
00613 from->dcontext[0] = 0;
00614 }
00615 if (ast_strlen_zero(to->dstchannel) && !ast_strlen_zero(from->dstchannel)) {
00616 ast_copy_string(to->dstchannel, from->dstchannel, sizeof(to->dstchannel));
00617 from->dstchannel[0] = 0;
00618 }
00619 if (!ast_strlen_zero(from->channel) && (ast_strlen_zero(to->channel) || !strncasecmp(from->channel, "Agent/", 6))) {
00620 ast_copy_string(to->channel, from->channel, sizeof(to->channel));
00621 from->channel[0] = 0;
00622 }
00623 if (ast_strlen_zero(to->src) && !ast_strlen_zero(from->src)) {
00624 ast_copy_string(to->src, from->src, sizeof(to->src));
00625 from->src[0] = 0;
00626 }
00627 if (ast_strlen_zero(to->clid) && !ast_strlen_zero(from->clid)) {
00628 ast_copy_string(to->clid, from->clid, sizeof(to->clid));
00629 from->clid[0] = 0;
00630 }
00631 if (ast_strlen_zero(to->dst) && !ast_strlen_zero(from->dst)) {
00632 ast_copy_string(to->dst, from->dst, sizeof(to->dst));
00633 from->dst[0] = 0;
00634 }
00635 if (!to->amaflags)
00636 to->amaflags = AST_CDR_DOCUMENTATION;
00637 if (!from->amaflags)
00638 from->amaflags = AST_CDR_DOCUMENTATION;
00639 if (ast_test_flag(from, AST_CDR_FLAG_LOCKED) || (to->amaflags == AST_CDR_DOCUMENTATION && from->amaflags != AST_CDR_DOCUMENTATION)) {
00640 to->amaflags = from->amaflags;
00641 }
00642 if (ast_test_flag(from, AST_CDR_FLAG_LOCKED) || (ast_strlen_zero(to->accountcode) && !ast_strlen_zero(from->accountcode))) {
00643 ast_copy_string(to->accountcode, from->accountcode, sizeof(to->accountcode));
00644 }
00645 if (ast_test_flag(from, AST_CDR_FLAG_LOCKED) || (ast_strlen_zero(to->userfield) && !ast_strlen_zero(from->userfield))) {
00646 ast_copy_string(to->userfield, from->userfield, sizeof(to->userfield));
00647 }
00648
00649 cdr_merge_vars(from, to);
00650
00651 if (ast_test_flag(from, AST_CDR_FLAG_KEEP_VARS))
00652 ast_set_flag(to, AST_CDR_FLAG_KEEP_VARS);
00653 if (ast_test_flag(from, AST_CDR_FLAG_POSTED))
00654 ast_set_flag(to, AST_CDR_FLAG_POSTED);
00655 if (ast_test_flag(from, AST_CDR_FLAG_LOCKED))
00656 ast_set_flag(to, AST_CDR_FLAG_LOCKED);
00657 if (ast_test_flag(from, AST_CDR_FLAG_CHILD))
00658 ast_set_flag(to, AST_CDR_FLAG_CHILD);
00659 if (ast_test_flag(from, AST_CDR_FLAG_POST_DISABLED))
00660 ast_set_flag(to, AST_CDR_FLAG_POST_DISABLED);
00661
00662
00663 while (from->next) {
00664
00665 zcdr = from->next;
00666 from->next = zcdr->next;
00667 zcdr->next = NULL;
00668
00669 ast_cdr_append(to, zcdr);
00670 }
00671 if (discard_from)
00672 ast_cdr_discard(from);
00673 }
00674
00675 void ast_cdr_start(struct ast_cdr *cdr)
00676 {
00677 char *chan;
00678
00679 for (; cdr; cdr = cdr->next) {
00680 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00681 chan = S_OR(cdr->channel, "<unknown>");
00682 check_post(cdr);
00683 cdr->start = ast_tvnow();
00684 }
00685 }
00686 }
00687
00688 void ast_cdr_answer(struct ast_cdr *cdr)
00689 {
00690
00691 for (; cdr; cdr = cdr->next) {
00692 if (ast_test_flag(cdr, AST_CDR_FLAG_ANSLOCKED))
00693 continue;
00694 if (ast_test_flag(cdr, AST_CDR_FLAG_DONT_TOUCH) && ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00695 continue;
00696 check_post(cdr);
00697 if (cdr->disposition < AST_CDR_ANSWERED)
00698 cdr->disposition = AST_CDR_ANSWERED;
00699 if (ast_tvzero(cdr->answer))
00700 cdr->answer = ast_tvnow();
00701 }
00702 }
00703
00704 void ast_cdr_busy(struct ast_cdr *cdr)
00705 {
00706
00707 for (; cdr; cdr = cdr->next) {
00708 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00709 check_post(cdr);
00710 cdr->disposition = AST_CDR_BUSY;
00711 }
00712 }
00713 }
00714
00715 void ast_cdr_failed(struct ast_cdr *cdr)
00716 {
00717 for (; cdr; cdr = cdr->next) {
00718 check_post(cdr);
00719 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00720 check_post(cdr);
00721 if (cdr->disposition < AST_CDR_FAILED)
00722 cdr->disposition = AST_CDR_FAILED;
00723 }
00724 }
00725 }
00726
00727 void ast_cdr_noanswer(struct ast_cdr *cdr)
00728 {
00729 char *chan;
00730
00731 while (cdr) {
00732 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00733 chan = !ast_strlen_zero(cdr->channel) ? cdr->channel : "<unknown>";
00734 check_post(cdr);
00735 cdr->disposition = AST_CDR_NOANSWER;
00736 }
00737 cdr = cdr->next;
00738 }
00739 }
00740
00741
00742
00743
00744 int ast_cdr_disposition(struct ast_cdr *cdr, int cause)
00745 {
00746 int res = 0;
00747
00748 for (; cdr; cdr = cdr->next) {
00749 switch (cause) {
00750
00751 case AST_CAUSE_BUSY:
00752 ast_cdr_busy(cdr);
00753 break;
00754 case AST_CAUSE_NO_ANSWER:
00755 ast_cdr_noanswer(cdr);
00756 break;
00757 case AST_CAUSE_NORMAL:
00758 break;
00759 default:
00760 res = -1;
00761 }
00762 }
00763 return res;
00764 }
00765
00766 void ast_cdr_setdestchan(struct ast_cdr *cdr, const char *chann)
00767 {
00768 for (; cdr; cdr = cdr->next) {
00769 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00770 check_post(cdr);
00771 ast_copy_string(cdr->dstchannel, chann, sizeof(cdr->dstchannel));
00772 }
00773 }
00774 }
00775
00776 void ast_cdr_setapp(struct ast_cdr *cdr, char *app, char *data)
00777 {
00778
00779 for (; cdr; cdr = cdr->next) {
00780 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00781 check_post(cdr);
00782 ast_copy_string(cdr->lastapp, S_OR(app, ""), sizeof(cdr->lastapp));
00783 ast_copy_string(cdr->lastdata, S_OR(data, ""), sizeof(cdr->lastdata));
00784 }
00785 }
00786 }
00787
00788 void ast_cdr_setanswer(struct ast_cdr *cdr, struct timeval t)
00789 {
00790
00791 for (; cdr; cdr = cdr->next) {
00792 if (ast_test_flag(cdr, AST_CDR_FLAG_ANSLOCKED))
00793 continue;
00794 if (ast_test_flag(cdr, AST_CDR_FLAG_DONT_TOUCH) && ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00795 continue;
00796 check_post(cdr);
00797 cdr->answer = t;
00798 }
00799 }
00800
00801 void ast_cdr_setdisposition(struct ast_cdr *cdr, long int disposition)
00802 {
00803
00804 for (; cdr; cdr = cdr->next) {
00805 if (ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00806 continue;
00807 check_post(cdr);
00808 cdr->disposition = disposition;
00809 }
00810 }
00811
00812
00813 static void set_one_cid(struct ast_cdr *cdr, struct ast_channel *c)
00814 {
00815
00816 const char *num = S_OR(c->cid.cid_ani, c->cid.cid_num);
00817 if (!cdr)
00818 return;
00819 if (!ast_strlen_zero(c->cid.cid_name)) {
00820 if (!ast_strlen_zero(num))
00821 snprintf(cdr->clid, sizeof(cdr->clid), "\"%s\" <%s>", c->cid.cid_name, num);
00822 else
00823 ast_copy_string(cdr->clid, c->cid.cid_name, sizeof(cdr->clid));
00824 } else if (!ast_strlen_zero(num)) {
00825 ast_copy_string(cdr->clid, num, sizeof(cdr->clid));
00826 } else {
00827 cdr->clid[0] = '\0';
00828 }
00829 ast_copy_string(cdr->src, S_OR(num, ""), sizeof(cdr->src));
00830 ast_cdr_setvar(cdr, "dnid", S_OR(c->cid.cid_dnid, ""), 0);
00831
00832 }
00833 int ast_cdr_setcid(struct ast_cdr *cdr, struct ast_channel *c)
00834 {
00835 for (; cdr; cdr = cdr->next) {
00836 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00837 set_one_cid(cdr, c);
00838 }
00839 return 0;
00840 }
00841
00842 int ast_cdr_init(struct ast_cdr *cdr, struct ast_channel *c)
00843 {
00844 char *chan;
00845
00846 for ( ; cdr ; cdr = cdr->next) {
00847 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00848 chan = S_OR(cdr->channel, "<unknown>");
00849 ast_copy_string(cdr->channel, c->name, sizeof(cdr->channel));
00850 set_one_cid(cdr, c);
00851
00852 cdr->disposition = (c->_state == AST_STATE_UP) ? AST_CDR_ANSWERED : AST_CDR_NOANSWER;
00853 cdr->amaflags = c->amaflags ? c->amaflags : ast_default_amaflags;
00854 ast_copy_string(cdr->accountcode, c->accountcode, sizeof(cdr->accountcode));
00855
00856 ast_copy_string(cdr->dst, S_OR(c->macroexten,c->exten), sizeof(cdr->dst));
00857 ast_copy_string(cdr->dcontext, S_OR(c->macrocontext,c->context), sizeof(cdr->dcontext));
00858
00859 ast_copy_string(cdr->uniqueid, c->uniqueid, sizeof(cdr->uniqueid));
00860 }
00861 }
00862 return 0;
00863 }
00864
00865
00866
00867
00868
00869
00870
00871
00872
00873
00874
00875
00876
00877 void ast_cdr_end(struct ast_cdr *cdr)
00878 {
00879 for ( ; cdr ; cdr = cdr->next) {
00880 if (ast_test_flag(cdr, AST_CDR_FLAG_DONT_TOUCH) && ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00881 continue;
00882 check_post(cdr);
00883 if (ast_tvzero(cdr->end))
00884 cdr->end = ast_tvnow();
00885 if (ast_tvzero(cdr->start)) {
00886 ast_log(LOG_WARNING, "CDR on channel '%s' has not started\n", S_OR(cdr->channel, "<unknown>"));
00887 cdr->disposition = AST_CDR_FAILED;
00888 } else
00889 cdr->duration = cdr->end.tv_sec - cdr->start.tv_sec;
00890 if (ast_tvzero(cdr->answer)) {
00891 if (cdr->disposition == AST_CDR_ANSWERED) {
00892 ast_log(LOG_WARNING, "CDR on channel '%s' has no answer time but is 'ANSWERED'\n", S_OR(cdr->channel, "<unknown>"));
00893 cdr->disposition = AST_CDR_FAILED;
00894 }
00895 } else
00896 cdr->billsec = cdr->end.tv_sec - cdr->answer.tv_sec;
00897 }
00898 }
00899
00900 char *ast_cdr_disp2str(int disposition)
00901 {
00902 switch (disposition) {
00903 case AST_CDR_NULL:
00904 return "NO ANSWER";
00905 case AST_CDR_NOANSWER:
00906 return "NO ANSWER";
00907 case AST_CDR_FAILED:
00908 return "FAILED";
00909 case AST_CDR_BUSY:
00910 return "BUSY";
00911 case AST_CDR_ANSWERED:
00912 return "ANSWERED";
00913 }
00914 return "UNKNOWN";
00915 }
00916
00917
00918 char *ast_cdr_flags2str(int flag)
00919 {
00920 switch (flag) {
00921 case AST_CDR_OMIT:
00922 return "OMIT";
00923 case AST_CDR_BILLING:
00924 return "BILLING";
00925 case AST_CDR_DOCUMENTATION:
00926 return "DOCUMENTATION";
00927 }
00928 return "Unknown";
00929 }
00930
00931 int ast_cdr_setaccount(struct ast_channel *chan, const char *account)
00932 {
00933 struct ast_cdr *cdr = chan->cdr;
00934 char buf[BUFSIZ/2] = "";
00935 if (!ast_strlen_zero(chan->accountcode))
00936 ast_copy_string(buf, chan->accountcode, sizeof(buf));
00937
00938 ast_string_field_set(chan, accountcode, account);
00939 for ( ; cdr ; cdr = cdr->next) {
00940 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00941 ast_copy_string(cdr->accountcode, chan->accountcode, sizeof(cdr->accountcode));
00942 }
00943 }
00944
00945
00946 manager_event(EVENT_FLAG_CALL, "NewAccountCode", "Channel: %s\r\nUniqueid: %s\r\nAccountCode: %s\r\nOldAccountCode: %s\r\n", chan->name, chan->uniqueid, chan->accountcode, buf);
00947 return 0;
00948 }
00949
00950 int ast_cdr_setamaflags(struct ast_channel *chan, const char *flag)
00951 {
00952 struct ast_cdr *cdr;
00953 int newflag = ast_cdr_amaflags2int(flag);
00954 if (newflag) {
00955 for (cdr = chan->cdr; cdr; cdr = cdr->next) {
00956 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00957 cdr->amaflags = newflag;
00958 }
00959 }
00960 }
00961
00962 return 0;
00963 }
00964
00965 int ast_cdr_setuserfield(struct ast_channel *chan, const char *userfield)
00966 {
00967 struct ast_cdr *cdr = chan->cdr;
00968
00969 for ( ; cdr ; cdr = cdr->next) {
00970 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00971 ast_copy_string(cdr->userfield, userfield, sizeof(cdr->userfield));
00972 }
00973
00974 return 0;
00975 }
00976
00977 int ast_cdr_appenduserfield(struct ast_channel *chan, const char *userfield)
00978 {
00979 struct ast_cdr *cdr = chan->cdr;
00980
00981 for ( ; cdr ; cdr = cdr->next) {
00982 int len = strlen(cdr->userfield);
00983
00984 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED))
00985 ast_copy_string(cdr->userfield + len, userfield, sizeof(cdr->userfield) - len);
00986 }
00987
00988 return 0;
00989 }
00990
00991 int ast_cdr_update(struct ast_channel *c)
00992 {
00993 struct ast_cdr *cdr = c->cdr;
00994
00995 for ( ; cdr ; cdr = cdr->next) {
00996 if (!ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
00997 set_one_cid(cdr, c);
00998
00999
01000 ast_copy_string(cdr->accountcode, c->accountcode, sizeof(cdr->accountcode));
01001
01002
01003 ast_copy_string(cdr->dst, S_OR(c->macroexten, c->exten), sizeof(cdr->dst));
01004 ast_copy_string(cdr->dcontext, S_OR(c->macrocontext, c->context), sizeof(cdr->dcontext));
01005 }
01006 }
01007
01008 return 0;
01009 }
01010
01011 int ast_cdr_amaflags2int(const char *flag)
01012 {
01013 if (!strcasecmp(flag, "default"))
01014 return 0;
01015 if (!strcasecmp(flag, "omit"))
01016 return AST_CDR_OMIT;
01017 if (!strcasecmp(flag, "billing"))
01018 return AST_CDR_BILLING;
01019 if (!strcasecmp(flag, "documentation"))
01020 return AST_CDR_DOCUMENTATION;
01021 return -1;
01022 }
01023
01024 static void post_cdr(struct ast_cdr *cdr)
01025 {
01026 char *chan;
01027 struct ast_cdr_beitem *i;
01028
01029 for ( ; cdr ; cdr = cdr->next) {
01030 if (!unanswered && cdr->disposition < AST_CDR_ANSWERED && (ast_strlen_zero(cdr->channel) || ast_strlen_zero(cdr->dstchannel))) {
01031
01032 ast_set_flag(cdr, AST_CDR_FLAG_POST_DISABLED);
01033 continue;
01034 }
01035
01036
01037
01038
01039 if (ast_test_flag(cdr, AST_CDR_FLAG_DIALED) && !ast_test_flag(cdr, AST_CDR_FLAG_ORIGINATED)) {
01040 ast_set_flag(cdr, AST_CDR_FLAG_POST_DISABLED);
01041 continue;
01042 }
01043
01044 chan = S_OR(cdr->channel, "<unknown>");
01045 check_post(cdr);
01046 ast_set_flag(cdr, AST_CDR_FLAG_POSTED);
01047 if (ast_test_flag(cdr, AST_CDR_FLAG_POST_DISABLED))
01048 continue;
01049 AST_RWLIST_RDLOCK(&be_list);
01050 AST_RWLIST_TRAVERSE(&be_list, i, list) {
01051 i->be(cdr);
01052 }
01053 AST_RWLIST_UNLOCK(&be_list);
01054 }
01055 }
01056
01057 void ast_cdr_reset(struct ast_cdr *cdr, struct ast_flags *_flags)
01058 {
01059 struct ast_cdr *duplicate;
01060 struct ast_flags flags = { 0 };
01061
01062 if (_flags)
01063 ast_copy_flags(&flags, _flags, AST_FLAGS_ALL);
01064
01065 for ( ; cdr ; cdr = cdr->next) {
01066
01067 if (ast_test_flag(&flags, AST_CDR_FLAG_LOCKED) || !ast_test_flag(cdr, AST_CDR_FLAG_LOCKED)) {
01068 if (ast_test_flag(&flags, AST_CDR_FLAG_POSTED)) {
01069 ast_cdr_end(cdr);
01070 if ((duplicate = ast_cdr_dup(cdr))) {
01071 ast_cdr_detach(duplicate);
01072 }
01073 ast_set_flag(cdr, AST_CDR_FLAG_POSTED);
01074 }
01075
01076
01077 if (ast_test_flag(&flags, AST_CDR_FLAG_POST_ENABLE)) {
01078 ast_clear_flag(cdr, AST_CDR_FLAG_POST_DISABLED);
01079 continue;
01080 }
01081
01082
01083 if (!ast_test_flag(&flags, AST_CDR_FLAG_KEEP_VARS)) {
01084 ast_cdr_free_vars(cdr, 0);
01085 }
01086
01087
01088 ast_clear_flag(cdr, AST_FLAGS_ALL);
01089 memset(&cdr->start, 0, sizeof(cdr->start));
01090 memset(&cdr->end, 0, sizeof(cdr->end));
01091 memset(&cdr->answer, 0, sizeof(cdr->answer));
01092 cdr->billsec = 0;
01093 cdr->duration = 0;
01094 ast_cdr_start(cdr);
01095 cdr->disposition = AST_CDR_NOANSWER;
01096 }
01097 }
01098 }
01099
01100 void ast_cdr_specialized_reset(struct ast_cdr *cdr, struct ast_flags *_flags)
01101 {
01102 struct ast_flags flags = { 0 };
01103
01104 if (_flags)
01105 ast_copy_flags(&flags, _flags, AST_FLAGS_ALL);
01106
01107
01108 if (ast_test_flag(cdr, AST_CDR_FLAG_POST_DISABLED)) {
01109 ast_clear_flag(cdr, AST_FLAGS_ALL);
01110 ast_set_flag(cdr, AST_CDR_FLAG_POST_DISABLED);
01111 } else {
01112 ast_clear_flag(cdr, AST_FLAGS_ALL);
01113 }
01114
01115 memset(&cdr->start, 0, sizeof(cdr->start));
01116 memset(&cdr->end, 0, sizeof(cdr->end));
01117 memset(&cdr->answer, 0, sizeof(cdr->answer));
01118 cdr->billsec = 0;
01119 cdr->duration = 0;
01120 ast_cdr_start(cdr);
01121 cdr->disposition = AST_CDR_NULL;
01122 }
01123
01124 struct ast_cdr *ast_cdr_append(struct ast_cdr *cdr, struct ast_cdr *newcdr)
01125 {
01126 struct ast_cdr *ret;
01127
01128 if (cdr) {
01129 ret = cdr;
01130
01131 while (cdr->next)
01132 cdr = cdr->next;
01133 cdr->next = newcdr;
01134 } else {
01135 ret = newcdr;
01136 }
01137
01138 return ret;
01139 }
01140
01141
01142 static void reset_batch(void)
01143 {
01144 batch->size = 0;
01145 batch->head = NULL;
01146 batch->tail = NULL;
01147 }
01148
01149
01150 static int init_batch(void)
01151 {
01152
01153 if (!(batch = ast_malloc(sizeof(*batch))))
01154 return -1;
01155
01156 reset_batch();
01157
01158 return 0;
01159 }
01160
01161 static void *do_batch_backend_process(void *data)
01162 {
01163 struct ast_cdr_batch_item *processeditem;
01164 struct ast_cdr_batch_item *batchitem = data;
01165
01166
01167 while (batchitem) {
01168 post_cdr(batchitem->cdr);
01169 ast_cdr_free(batchitem->cdr);
01170 processeditem = batchitem;
01171 batchitem = batchitem->next;
01172 ast_free(processeditem);
01173 }
01174
01175 return NULL;
01176 }
01177
01178 void ast_cdr_submit_batch(int do_shutdown)
01179 {
01180 struct ast_cdr_batch_item *oldbatchitems = NULL;
01181 pthread_t batch_post_thread = AST_PTHREADT_NULL;
01182
01183
01184 if (!batch || !batch->head)
01185 return;
01186
01187
01188 ast_mutex_lock(&cdr_batch_lock);
01189 oldbatchitems = batch->head;
01190 reset_batch();
01191 ast_mutex_unlock(&cdr_batch_lock);
01192
01193
01194
01195 if (batchscheduleronly || do_shutdown) {
01196 ast_debug(1, "CDR single-threaded batch processing begins now\n");
01197 do_batch_backend_process(oldbatchitems);
01198 } else {
01199 if (ast_pthread_create_detached_background(&batch_post_thread, NULL, do_batch_backend_process, oldbatchitems)) {
01200 ast_log(LOG_WARNING, "CDR processing thread could not detach, now trying in this thread\n");
01201 do_batch_backend_process(oldbatchitems);
01202 } else {
01203 ast_debug(1, "CDR multi-threaded batch processing begins now\n");
01204 }
01205 }
01206 }
01207
01208 static int submit_scheduled_batch(const void *data)
01209 {
01210 ast_cdr_submit_batch(0);
01211
01212 cdr_sched = ast_sched_add(sched, batchtime * 1000, submit_scheduled_batch, NULL);
01213
01214 return 0;
01215 }
01216
01217 static void submit_unscheduled_batch(void)
01218 {
01219
01220 AST_SCHED_DEL(sched, cdr_sched);
01221
01222 cdr_sched = ast_sched_add(sched, 1, submit_scheduled_batch, NULL);
01223
01224 ast_mutex_lock(&cdr_pending_lock);
01225 ast_cond_signal(&cdr_pending_cond);
01226 ast_mutex_unlock(&cdr_pending_lock);
01227 }
01228
01229 void ast_cdr_detach(struct ast_cdr *cdr)
01230 {
01231 struct ast_cdr_batch_item *newtail;
01232 int curr;
01233
01234 if (!cdr)
01235 return;
01236
01237
01238 if (!enabled) {
01239 ast_debug(1, "Dropping CDR !\n");
01240 ast_set_flag(cdr, AST_CDR_FLAG_POST_DISABLED);
01241 ast_cdr_free(cdr);
01242 return;
01243 }
01244
01245
01246 if (!batchmode) {
01247 post_cdr(cdr);
01248 ast_cdr_free(cdr);
01249 return;
01250 }
01251
01252
01253 ast_debug(1, "CDR detaching from this thread\n");
01254
01255
01256 if (!(newtail = ast_calloc(1, sizeof(*newtail)))) {
01257 post_cdr(cdr);
01258 ast_cdr_free(cdr);
01259 return;
01260 }
01261
01262
01263 ast_mutex_lock(&cdr_batch_lock);
01264 if (!batch)
01265 init_batch();
01266 if (!batch->head) {
01267
01268 batch->head = newtail;
01269 } else {
01270
01271 batch->tail->next = newtail;
01272 }
01273 newtail->cdr = cdr;
01274 batch->tail = newtail;
01275 curr = batch->size++;
01276 ast_mutex_unlock(&cdr_batch_lock);
01277
01278
01279 if (curr >= (batchsize - 1))
01280 submit_unscheduled_batch();
01281 }
01282
01283 static void *do_cdr(void *data)
01284 {
01285 struct timespec timeout;
01286 int schedms;
01287 int numevents = 0;
01288
01289 for (;;) {
01290 struct timeval now;
01291 schedms = ast_sched_wait(sched);
01292
01293 if (schedms <= 0)
01294 schedms = 1000;
01295 now = ast_tvadd(ast_tvnow(), ast_samp2tv(schedms, 1000));
01296 timeout.tv_sec = now.tv_sec;
01297 timeout.tv_nsec = now.tv_usec * 1000;
01298
01299 ast_mutex_lock(&cdr_pending_lock);
01300 ast_cond_timedwait(&cdr_pending_cond, &cdr_pending_lock, &timeout);
01301 numevents = ast_sched_runq(sched);
01302 ast_mutex_unlock(&cdr_pending_lock);
01303 ast_debug(2, "Processed %d scheduled CDR batches from the run queue\n", numevents);
01304 }
01305
01306 return NULL;
01307 }
01308
01309 static char *handle_cli_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
01310 {
01311 struct ast_cdr_beitem *beitem=NULL;
01312 int cnt=0;
01313 long nextbatchtime=0;
01314
01315 switch (cmd) {
01316 case CLI_INIT:
01317 e->command = "cdr show status";
01318 e->usage =
01319 "Usage: cdr show status\n"
01320 " Displays the Call Detail Record engine system status.\n";
01321 return NULL;
01322 case CLI_GENERATE:
01323 return NULL;
01324 }
01325
01326 if (a->argc > 3)
01327 return CLI_SHOWUSAGE;
01328
01329 ast_cli(a->fd, "\n");
01330 ast_cli(a->fd, "Call Detail Record (CDR) settings\n");
01331 ast_cli(a->fd, "----------------------------------\n");
01332 ast_cli(a->fd, " Logging: %s\n", enabled ? "Enabled" : "Disabled");
01333 ast_cli(a->fd, " Mode: %s\n", batchmode ? "Batch" : "Simple");
01334 if (enabled) {
01335 ast_cli(a->fd, " Log unanswered calls: %s\n\n", unanswered ? "Yes" : "No");
01336 if (batchmode) {
01337 ast_cli(a->fd, "* Batch Mode Settings\n");
01338 ast_cli(a->fd, " -------------------\n");
01339 if (batch)
01340 cnt = batch->size;
01341 if (cdr_sched > -1)
01342 nextbatchtime = ast_sched_when(sched, cdr_sched);
01343 ast_cli(a->fd, " Safe shutdown: %s\n", batchsafeshutdown ? "Enabled" : "Disabled");
01344 ast_cli(a->fd, " Threading model: %s\n", batchscheduleronly ? "Scheduler only" : "Scheduler plus separate threads");
01345 ast_cli(a->fd, " Current batch size: %d record%s\n", cnt, ESS(cnt));
01346 ast_cli(a->fd, " Maximum batch size: %d record%s\n", batchsize, ESS(batchsize));
01347 ast_cli(a->fd, " Maximum batch time: %d second%s\n", batchtime, ESS(batchtime));
01348 ast_cli(a->fd, " Next batch processing time: %ld second%s\n\n", nextbatchtime, ESS(nextbatchtime));
01349 }
01350 ast_cli(a->fd, "* Registered Backends\n");
01351 ast_cli(a->fd, " -------------------\n");
01352 AST_RWLIST_RDLOCK(&be_list);
01353 if (AST_RWLIST_EMPTY(&be_list)) {
01354 ast_cli(a->fd, " (none)\n");
01355 } else {
01356 AST_RWLIST_TRAVERSE(&be_list, beitem, list) {
01357 ast_cli(a->fd, " %s\n", beitem->name);
01358 }
01359 }
01360 AST_RWLIST_UNLOCK(&be_list);
01361 ast_cli(a->fd, "\n");
01362 }
01363
01364 return CLI_SUCCESS;
01365 }
01366
01367 static char *handle_cli_status_deprecated(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
01368 {
01369 char *res = handle_cli_status(e, cmd, a);
01370 if (cmd == CLI_INIT)
01371 e->command = "cdr status";
01372 return res;
01373 }
01374
01375 static char *handle_cli_submit(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
01376 {
01377 switch (cmd) {
01378 case CLI_INIT:
01379 e->command = "cdr submit";
01380 e->usage =
01381 "Usage: cdr submit\n"
01382 " Posts all pending batched CDR data to the configured CDR backend engine modules.\n";
01383 return NULL;
01384 case CLI_GENERATE:
01385 return NULL;
01386 }
01387 if (a->argc > 2)
01388 return CLI_SHOWUSAGE;
01389
01390 submit_unscheduled_batch();
01391 ast_cli(a->fd, "Submitted CDRs to backend engines for processing. This may take a while.\n");
01392
01393 return CLI_SUCCESS;
01394 }
01395
01396 static struct ast_cli_entry cli_submit = AST_CLI_DEFINE(handle_cli_submit, "Posts all pending batched CDR data");
01397 static struct ast_cli_entry cli_status_deprecated = AST_CLI_DEFINE(handle_cli_status_deprecated, "Display the CDR status");
01398 static struct ast_cli_entry cli_status = AST_CLI_DEFINE(handle_cli_status, "Display the CDR status", .deprecate_cmd = &cli_status_deprecated);
01399
01400 static int do_reload(int reload)
01401 {
01402 struct ast_config *config;
01403 const char *enabled_value;
01404 const char *unanswered_value;
01405 const char *batched_value;
01406 const char *scheduleronly_value;
01407 const char *batchsafeshutdown_value;
01408 const char *size_value;
01409 const char *time_value;
01410 const char *end_before_h_value;
01411 int cfg_size;
01412 int cfg_time;
01413 int was_enabled;
01414 int was_batchmode;
01415 int res=0;
01416 struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 };
01417
01418 if ((config = ast_config_load2("cdr.conf", "cdr", config_flags)) == CONFIG_STATUS_FILEUNCHANGED)
01419 return 0;
01420
01421 ast_mutex_lock(&cdr_batch_lock);
01422
01423 batchsize = BATCH_SIZE_DEFAULT;
01424 batchtime = BATCH_TIME_DEFAULT;
01425 batchscheduleronly = BATCH_SCHEDULER_ONLY_DEFAULT;
01426 batchsafeshutdown = BATCH_SAFE_SHUTDOWN_DEFAULT;
01427 was_enabled = enabled;
01428 was_batchmode = batchmode;
01429 enabled = 1;
01430 batchmode = 0;
01431
01432
01433 AST_SCHED_DEL(sched, cdr_sched);
01434
01435 if (config) {
01436 if ((enabled_value = ast_variable_retrieve(config, "general", "enable"))) {
01437 enabled = ast_true(enabled_value);
01438 }
01439 if ((unanswered_value = ast_variable_retrieve(config, "general", "unanswered"))) {
01440 unanswered = ast_true(unanswered_value);
01441 }
01442 if ((batched_value = ast_variable_retrieve(config, "general", "batch"))) {
01443 batchmode = ast_true(batched_value);
01444 }
01445 if ((scheduleronly_value = ast_variable_retrieve(config, "general", "scheduleronly"))) {
01446 batchscheduleronly = ast_true(scheduleronly_value);
01447 }
01448 if ((batchsafeshutdown_value = ast_variable_retrieve(config, "general", "safeshutdown"))) {
01449 batchsafeshutdown = ast_true(batchsafeshutdown_value);
01450 }
01451 if ((size_value = ast_variable_retrieve(config, "general", "size"))) {
01452 if (sscanf(size_value, "%30d", &cfg_size) < 1)
01453 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", size_value);
01454 else if (cfg_size < 0)
01455 ast_log(LOG_WARNING, "Invalid maximum batch size '%d' specified, using default\n", cfg_size);
01456 else
01457 batchsize = cfg_size;
01458 }
01459 if ((time_value = ast_variable_retrieve(config, "general", "time"))) {
01460 if (sscanf(time_value, "%30d", &cfg_time) < 1)
01461 ast_log(LOG_WARNING, "Unable to convert '%s' to a numeric value.\n", time_value);
01462 else if (cfg_time < 0)
01463 ast_log(LOG_WARNING, "Invalid maximum batch time '%d' specified, using default\n", cfg_time);
01464 else
01465 batchtime = cfg_time;
01466 }
01467 if ((end_before_h_value = ast_variable_retrieve(config, "general", "endbeforehexten")))
01468 ast_set2_flag(&ast_options, ast_true(end_before_h_value), AST_OPT_FLAG_END_CDR_BEFORE_H_EXTEN);
01469 }
01470
01471 if (enabled && !batchmode) {
01472 ast_log(LOG_NOTICE, "CDR simple logging enabled.\n");
01473 } else if (enabled && batchmode) {
01474 cdr_sched = ast_sched_add(sched, batchtime * 1000, submit_scheduled_batch, NULL);
01475 ast_log(LOG_NOTICE, "CDR batch mode logging enabled, first of either size %d or time %d seconds.\n", batchsize, batchtime);
01476 } else {
01477 ast_log(LOG_NOTICE, "CDR logging disabled, data will be lost.\n");
01478 }
01479
01480
01481
01482 if (enabled && batchmode && (!was_enabled || !was_batchmode) && (cdr_thread == AST_PTHREADT_NULL)) {
01483 ast_cond_init(&cdr_pending_cond, NULL);
01484 if (ast_pthread_create_background(&cdr_thread, NULL, do_cdr, NULL) < 0) {
01485 ast_log(LOG_ERROR, "Unable to start CDR thread.\n");
01486 AST_SCHED_DEL(sched, cdr_sched);
01487 } else {
01488 ast_cli_register(&cli_submit);
01489 ast_register_atexit(ast_cdr_engine_term);
01490 res = 0;
01491 }
01492
01493
01494 } else if (((!enabled && was_enabled) || (!batchmode && was_batchmode)) && (cdr_thread != AST_PTHREADT_NULL)) {
01495
01496 pthread_cancel(cdr_thread);
01497 pthread_kill(cdr_thread, SIGURG);
01498 pthread_join(cdr_thread, NULL);
01499 cdr_thread = AST_PTHREADT_NULL;
01500 ast_cond_destroy(&cdr_pending_cond);
01501 ast_cli_unregister(&cli_submit);
01502 ast_unregister_atexit(ast_cdr_engine_term);
01503 res = 0;
01504
01505
01506 if (!batchmode && was_batchmode) {
01507 ast_cdr_engine_term();
01508 }
01509 } else {
01510 res = 0;
01511 }
01512
01513 ast_mutex_unlock(&cdr_batch_lock);
01514 ast_config_destroy(config);
01515 manager_event(EVENT_FLAG_SYSTEM, "Reload", "Module: CDR\r\nMessage: CDR subsystem reload requested\r\n");
01516
01517 return res;
01518 }
01519
01520 int ast_cdr_engine_init(void)
01521 {
01522 int res;
01523
01524 sched = sched_context_create();
01525 if (!sched) {
01526 ast_log(LOG_ERROR, "Unable to create schedule context.\n");
01527 return -1;
01528 }
01529
01530 ast_cli_register(&cli_status);
01531
01532 res = do_reload(0);
01533 if (res) {
01534 ast_mutex_lock(&cdr_batch_lock);
01535 res = init_batch();
01536 ast_mutex_unlock(&cdr_batch_lock);
01537 }
01538
01539 return res;
01540 }
01541
01542
01543
01544 void ast_cdr_engine_term(void)
01545 {
01546 ast_cdr_submit_batch(batchsafeshutdown);
01547 }
01548
01549 int ast_cdr_engine_reload(void)
01550 {
01551 return do_reload(1);
01552 }
01553