cdr.c: Use current ao2 flag names
[asterisk/asterisk.git] / main / cdr.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Call Detail Record API
22  *
23  * \author Mark Spencer <markster@digium.com>
24  *
25  * \note Includes code and algorithms from the Zapata library.
26  *
27  * \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
28  * through our fingers somehow.  If someone allocates a CDR, it must be completely handled normally
29  * or a WARNING shall be logged, so that we can best keep track of any escape condition where the CDR
30  * isn't properly generated and posted.
31  */
32
33 /*! \li \ref cdr.c uses the configuration file \ref cdr.conf
34  * \addtogroup configuration_file Configuration Files
35  */
36
37 /*!
38  * \page cdr.conf cdr.conf
39  * \verbinclude cdr.conf.sample
40  */
41
42 /*** MODULEINFO
43         <support_level>core</support_level>
44  ***/
45
46 #include "asterisk.h"
47
48 #include <signal.h>
49 #include <inttypes.h>
50
51 #include "asterisk/lock.h"
52 #include "asterisk/channel.h"
53 #include "asterisk/cdr.h"
54 #include "asterisk/callerid.h"
55 #include "asterisk/manager.h"
56 #include "asterisk/causes.h"
57 #include "asterisk/linkedlists.h"
58 #include "asterisk/utils.h"
59 #include "asterisk/sched.h"
60 #include "asterisk/config.h"
61 #include "asterisk/cli.h"
62 #include "asterisk/stringfields.h"
63 #include "asterisk/config_options.h"
64 #include "asterisk/json.h"
65 #include "asterisk/parking.h"
66 #include "asterisk/stasis.h"
67 #include "asterisk/stasis_channels.h"
68 #include "asterisk/stasis_bridges.h"
69 #include "asterisk/stasis_message_router.h"
70 #include "asterisk/astobj2.h"
71 #include "asterisk/taskprocessor.h"
72
73 /*** DOCUMENTATION
74         <configInfo name="cdr" language="en_US">
75                 <synopsis>Call Detail Record configuration</synopsis>
76                 <description>
77                         <para>CDR is Call Detail Record, which provides logging services via a variety of
78                         pluggable backend modules. Detailed call information can be recorded to
79                         databases, files, etc. Useful for billing, fraud prevention, compliance with
80                         Sarbanes-Oxley aka The Enron Act, QOS evaluations, and more.</para>
81                 </description>
82                 <configFile name="cdr.conf">
83                         <configObject name="general">
84                                 <synopsis>Global settings applied to the CDR engine.</synopsis>
85                                 <configOption name="debug">
86                                         <synopsis>Enable/disable verbose CDR debugging.</synopsis>
87                                         <description><para>When set to <literal>True</literal>, verbose updates
88                                         of changes in CDR information will be logged. Note that this is only
89                                         of use when debugging CDR behavior.</para>
90                                         </description>
91                                 </configOption>
92                                 <configOption name="enable">
93                                         <synopsis>Enable/disable CDR logging.</synopsis>
94                                         <description><para>Define whether or not to use CDR logging. Setting this to "no" will override
95                                         any loading of backend CDR modules.  Default is "yes".</para>
96                                         </description>
97                                 </configOption>
98                                 <configOption name="unanswered">
99                                         <synopsis>Log calls that are never answered and don't set an outgoing party.</synopsis>
100                                         <description><para>
101                                         Define whether or not to log unanswered calls that don't involve an outgoing party. Setting
102                                         this to "yes" will make calls to extensions that don't answer and don't set a side B channel
103                                         (such as by using the Dial application) receive CDR log entries. If this option is set to
104                                         "no", then those log entries will not be created. Unanswered calls which get offered to an
105                                         outgoing line will always receive log entries regardless of this option, and that is the
106                                         intended behavior.
107                                         </para>
108                                         </description>
109                                 </configOption>
110                                 <configOption name="congestion">
111                                         <synopsis>Log congested calls.</synopsis>
112                                         <description><para>Define whether or not to log congested calls. Setting this to "yes" will
113                                         report each call that fails to complete due to congestion conditions.</para>
114                                         </description>
115                                 </configOption>
116                                 <configOption name="endbeforehexten">
117                                         <synopsis>Don't produce CDRs while executing hangup logic</synopsis>
118                                         <description>
119                                                 <para>As each CDR for a channel is finished, its end time is updated
120                                                 and the CDR is finalized. When a channel is hung up and hangup
121                                                 logic is present (in the form of a hangup handler or the
122                                                 <literal>h</literal> extension), a new CDR is generated for the
123                                                 channel. Any statistics are gathered from this new CDR. By enabling
124                                                 this option, no new CDR is created for the dialplan logic that is
125                                                 executed in <literal>h</literal> extensions or attached hangup handler
126                                                 subroutines. The default value is <literal>yes</literal>, indicating
127                                                 that a CDR will be generated during hangup logic.</para>
128                                         </description>
129                                 </configOption>
130                                 <configOption name="initiatedseconds">
131                                         <synopsis>Count microseconds for billsec purposes</synopsis>
132                                         <description><para>Normally, the <literal>billsec</literal> field logged to the CDR backends
133                                         is simply the end time (hangup time) minus the answer time in seconds. Internally,
134                                         asterisk stores the time in terms of microseconds and seconds. By setting
135                                         initiatedseconds to <literal>yes</literal>, you can force asterisk to report any seconds
136                                         that were initiated (a sort of round up method). Technically, this is
137                                         when the microsecond part of the end time is greater than the microsecond
138                                         part of the answer time, then the billsec time is incremented one second.</para>
139                                         </description>
140                                 </configOption>
141                                 <configOption name="batch">
142                                         <synopsis>Submit CDRs to the backends for processing in batches</synopsis>
143                                         <description><para>Define the CDR batch mode, where instead of posting the CDR at the end of
144                                         every call, the data will be stored in a buffer to help alleviate load on the
145                                         asterisk server.</para>
146                                         <warning><para>Use of batch mode may result in data loss after unsafe asterisk termination,
147                                         i.e., software crash, power failure, kill -9, etc.</para>
148                                         </warning>
149                                         </description>
150                                 </configOption>
151                                 <configOption name="size">
152                                         <synopsis>The maximum number of CDRs to accumulate before triggering a batch</synopsis>
153                                         <description><para>Define the maximum number of CDRs to accumulate in the buffer before posting
154                                         them to the backend engines. batch must be set to <literal>yes</literal>.</para>
155                                         </description>
156                                 </configOption>
157                                 <configOption name="time">
158                                         <synopsis>The maximum time to accumulate CDRs before triggering a batch</synopsis>
159                                         <description><para>Define the maximum time to accumulate CDRs before posting them in a batch to the
160                                         backend engines. If this time limit is reached, then it will post the records, regardless of the value
161                                         defined for size. batch must be set to <literal>yes</literal>.</para>
162                                         <note><para>Time is expressed in seconds.</para></note>
163                                         </description>
164                                 </configOption>
165                                 <configOption name="scheduleronly">
166                                         <synopsis>Post batched CDRs on their own thread instead of the scheduler</synopsis>
167                                         <description><para>The CDR engine uses the internal asterisk scheduler to determine when to post
168                                         records.  Posting can either occur inside the scheduler thread, or a new
169                                         thread can be spawned for the submission of every batch.  For small batches,
170                                         it might be acceptable to just use the scheduler thread, so set this to <literal>yes</literal>.
171                                         For large batches, say anything over size=10, a new thread is recommended, so
172                                         set this to <literal>no</literal>.</para>
173                                         </description>
174                                 </configOption>
175                                 <configOption name="safeshutdown">
176                                         <synopsis>Block shutdown of Asterisk until CDRs are submitted</synopsis>
177                                         <description><para>When shutting down asterisk, you can block until the CDRs are submitted.  If
178                                         you don't, then data will likely be lost.  You can always check the size of
179                                         the CDR batch buffer with the CLI <astcli>cdr status</astcli> command.  To enable blocking on
180                                         submission of CDR data during asterisk shutdown, set this to <literal>yes</literal>.</para>
181                                         </description>
182                                 </configOption>
183                         </configObject>
184                 </configFile>
185         </configInfo>
186  ***/
187
188
189 /* The prime here should be similar in size to the channel container. */
190 #ifdef LOW_MEMORY
191 #define NUM_CDR_BUCKETS 61
192 #else
193 #define NUM_CDR_BUCKETS 769
194 #endif
195
196 #define DEFAULT_ENABLED "1"
197 #define DEFAULT_BATCHMODE "0"
198 #define DEFAULT_UNANSWERED "0"
199 #define DEFAULT_CONGESTION "0"
200 #define DEFAULT_END_BEFORE_H_EXTEN "1"
201 #define DEFAULT_INITIATED_SECONDS "0"
202
203 #define DEFAULT_BATCH_SIZE "100"
204 #define MAX_BATCH_SIZE 1000
205 #define DEFAULT_BATCH_TIME "300"
206 #define MAX_BATCH_TIME 86400
207 #define DEFAULT_BATCH_SCHEDULER_ONLY "0"
208 #define DEFAULT_BATCH_SAFE_SHUTDOWN "1"
209
210 #define CDR_DEBUG(mod_cfg, fmt, ...) \
211         do { \
212                 if (ast_test_flag(&(mod_cfg)->general->settings, CDR_DEBUG)) { \
213                         ast_verbose((fmt), ##__VA_ARGS__); \
214                 } \
215         } while (0)
216
217 static void cdr_detach(struct ast_cdr *cdr);
218 static void cdr_submit_batch(int shutdown);
219 static int cdr_toggle_runtime_options(void);
220
221 /*! \brief The configuration settings for this module */
222 struct module_config {
223         struct ast_cdr_config *general;         /*< CDR global settings */
224 };
225
226 /*! \brief The container for the module configuration */
227 static AO2_GLOBAL_OBJ_STATIC(module_configs);
228
229 /*! \brief The type definition for general options */
230 static struct aco_type general_option = {
231         .type = ACO_GLOBAL,
232         .name = "general",
233         .item_offset = offsetof(struct module_config, general),
234         .category = "^general$",
235         .category_match = ACO_WHITELIST,
236 };
237
238 static void *module_config_alloc(void);
239 static void module_config_destructor(void *obj);
240
241 /*! \brief The file definition */
242 static struct aco_file module_file_conf = {
243         .filename = "cdr.conf",
244         .skip_category = "(^csv$|^custom$|^manager$|^odbc$|^pgsql$|^radius$|^sqlite$|^tds$|^mysql$)",
245         .types = ACO_TYPES(&general_option),
246 };
247
248 CONFIG_INFO_CORE("cdr", cfg_info, module_configs, module_config_alloc,
249         .files = ACO_FILES(&module_file_conf),
250 );
251
252 static struct aco_type *general_options[] = ACO_TYPES(&general_option);
253
254 /*! \brief Dispose of a module config object */
255 static void module_config_destructor(void *obj)
256 {
257         struct module_config *cfg = obj;
258
259         if (!cfg) {
260                 return;
261         }
262         ao2_ref(cfg->general, -1);
263 }
264
265 /*! \brief Create a new module config object */
266 static void *module_config_alloc(void)
267 {
268         struct module_config *mod_cfg;
269         struct ast_cdr_config *cdr_config;
270
271         mod_cfg = ao2_alloc(sizeof(*mod_cfg), module_config_destructor);
272         if (!mod_cfg) {
273                 return NULL;
274         }
275
276         cdr_config = ao2_alloc(sizeof(*cdr_config), NULL);
277         if (!cdr_config) {
278                 ao2_ref(cdr_config, -1);
279                 return NULL;
280         }
281         mod_cfg->general = cdr_config;
282
283         return mod_cfg;
284 }
285
286 /*! \brief Registration object for CDR backends */
287 struct cdr_beitem {
288         char name[20];
289         char desc[80];
290         ast_cdrbe be;
291         AST_RWLIST_ENTRY(cdr_beitem) list;
292         int suspended:1;
293 };
294
295 /*! \brief List of registered backends */
296 static AST_RWLIST_HEAD_STATIC(be_list, cdr_beitem);
297
298 /*! \brief List of registered modifiers */
299 static AST_RWLIST_HEAD_STATIC(mo_list, cdr_beitem);
300
301 /*! \brief Queued CDR waiting to be batched */
302 struct cdr_batch_item {
303         struct ast_cdr *cdr;
304         struct cdr_batch_item *next;
305 };
306
307 /*! \brief The actual batch queue */
308 static struct cdr_batch {
309         int size;
310         struct cdr_batch_item *head;
311         struct cdr_batch_item *tail;
312 } *batch = NULL;
313
314 /*! \brief The global sequence counter used for CDRs */
315 static int global_cdr_sequence =  0;
316
317 /*! \brief Scheduler items */
318 static struct ast_sched_context *sched;
319 static int cdr_sched = -1;
320 AST_MUTEX_DEFINE_STATIC(cdr_sched_lock);
321 static pthread_t cdr_thread = AST_PTHREADT_NULL;
322
323 /*! \brief Lock protecting modifications to the batch queue */
324 AST_MUTEX_DEFINE_STATIC(cdr_batch_lock);
325
326 /*! \brief These are used to wake up the CDR thread when there's work to do */
327 AST_MUTEX_DEFINE_STATIC(cdr_pending_lock);
328 static ast_cond_t cdr_pending_cond;
329
330 /*! \brief A container of the active CDRs indexed by Party A channel id */
331 static struct ao2_container *active_cdrs_by_channel;
332
333 /*! \brief Message router for stasis messages regarding channel state */
334 static struct stasis_message_router *stasis_router;
335
336 /*! \brief Our subscription for bridges */
337 static struct stasis_forward *bridge_subscription;
338
339 /*! \brief Our subscription for channels */
340 static struct stasis_forward *channel_subscription;
341
342 /*! \brief Our subscription for parking */
343 static struct stasis_forward *parking_subscription;
344
345 /*! \brief The parent topic for all topics we want to aggregate for CDRs */
346 static struct stasis_topic *cdr_topic;
347
348 /*! \brief A message type used to synchronize with the CDR topic */
349 STASIS_MESSAGE_TYPE_DEFN_LOCAL(cdr_sync_message_type);
350
351 struct cdr_object;
352
353 /*! \brief Return types for \ref process_bridge_enter functions */
354 enum process_bridge_enter_results {
355         /*!
356          * The CDR was the only party in the bridge.
357          */
358         BRIDGE_ENTER_ONLY_PARTY,
359         /*!
360          * The CDR was able to obtain a Party B from some other party already in the bridge
361          */
362         BRIDGE_ENTER_OBTAINED_PARTY_B,
363         /*!
364          * The CDR was not able to obtain a Party B
365          */
366         BRIDGE_ENTER_NO_PARTY_B,
367         /*!
368          * This CDR can't handle a bridge enter message and a new CDR needs to be created
369          */
370         BRIDGE_ENTER_NEED_CDR,
371 };
372
373 /*!
374  * \brief A virtual table used for \ref cdr_object.
375  *
376  * Note that all functions are optional - if a subclass does not need an
377  * implementation, it is safe to leave it NULL.
378  */
379 struct cdr_object_fn_table {
380         /*! \brief Name of the subclass */
381         const char *name;
382
383         /*!
384          * \brief An initialization function. This will be called automatically
385          * when a \ref cdr_object is switched to this type in
386          * \ref cdr_object_transition_state
387          *
388          * \param cdr The \ref cdr_object that was just transitioned
389          */
390         void (* const init_function)(struct cdr_object *cdr);
391
392         /*!
393          * \brief Process a Party A update for the \ref cdr_object
394          *
395          * \param cdr The \ref cdr_object to process the update
396          * \param snapshot The snapshot for the CDR's Party A
397          * \retval 0 the CDR handled the update or ignored it
398          * \retval 1 the CDR is finalized and a new one should be made to handle it
399          */
400         int (* const process_party_a)(struct cdr_object *cdr,
401                         struct ast_channel_snapshot *snapshot);
402
403         /*!
404          * \brief Process a Party B update for the \ref cdr_object
405          *
406          * \param cdr The \ref cdr_object to process the update
407          * \param snapshot The snapshot for the CDR's Party B
408          */
409         void (* const process_party_b)(struct cdr_object *cdr,
410                         struct ast_channel_snapshot *snapshot);
411
412         /*!
413          * \brief Process the beginning of a dial. A dial message implies one of two
414          * things:
415          * The \ref cdr_object's Party A has been originated
416          * The \ref cdr_object's Party A is dialing its Party B
417          *
418          * \param cdr The \ref cdr_object
419          * \param caller The originator of the dial attempt
420          * \param peer The destination of the dial attempt
421          *
422          * \retval 0 if the parties in the dial were handled by this CDR
423          * \retval 1 if the parties could not be handled by this CDR
424          */
425         int (* const process_dial_begin)(struct cdr_object *cdr,
426                         struct ast_channel_snapshot *caller,
427                         struct ast_channel_snapshot *peer);
428
429         /*!
430          * \brief Process the end of a dial. At the end of a dial, a CDR can be
431          * transitioned into one of two states - DialedPending
432          * (\ref dialed_pending_state_fn_table) or Finalized
433          * (\ref finalized_state_fn_table).
434          *
435          * \param cdr The \ref cdr_object
436          * \param caller The originator of the dial attempt
437          * \param peer the Destination of the dial attempt
438          * \param dial_status What happened
439          *
440          * \retval 0 if the parties in the dial were handled by this CDR
441          * \retval 1 if the parties could not be handled by this CDR
442          */
443         int (* const process_dial_end)(struct cdr_object *cdr,
444                         struct ast_channel_snapshot *caller,
445                         struct ast_channel_snapshot *peer,
446                         const char *dial_status);
447
448         /*!
449          * \brief Process the entering of a bridge by this CDR. The purpose of this
450          * callback is to have the CDR prepare itself for the bridge and attempt to
451          * find a valid Party B. The act of creating new CDRs based on the entering
452          * of this channel into the bridge is handled by the higher level message
453          * handler.
454          *
455          * Note that this handler is for when a channel enters into a "normal"
456          * bridge, where people actually talk to each other. Parking is its own
457          * thing.
458          *
459          * \param cdr The \ref cdr_object
460          * \param bridge The bridge that the Party A just entered into
461          * \param channel The \ref ast_channel_snapshot for this CDR's Party A
462          *
463          * \retval process_bridge_enter_results Defines whether or not this CDR was able
464          * to fully handle the bridge enter message.
465          */
466         enum process_bridge_enter_results (* const process_bridge_enter)(
467                         struct cdr_object *cdr,
468                         struct ast_bridge_snapshot *bridge,
469                         struct ast_channel_snapshot *channel);
470
471         /*!
472          * \brief Process entering into a parking bridge.
473          *
474          * \param cdr The \ref cdr_object
475          * \param bridge The parking bridge that Party A just entered into
476          * \param channel The \ref ast_channel_snapshot for this CDR's Party A
477          *
478          * \retval 0 This CDR successfully transitioned itself into the parked state
479          * \retval 1 This CDR couldn't handle the parking transition and we need a
480          *  new CDR.
481          */
482         int (* const process_parking_bridge_enter)(struct cdr_object *cdr,
483                         struct ast_bridge_snapshot *bridge,
484                         struct ast_channel_snapshot *channel);
485
486         /*!
487          * \brief Process the leaving of a bridge by this CDR.
488          *
489          * \param cdr The \ref cdr_object
490          * \param bridge The bridge that the Party A just left
491          * \param channel The \ref ast_channel_snapshot for this CDR's Party A
492          *
493          * \retval 0 This CDR left successfully
494          * \retval 1 Error
495          */
496         int (* const process_bridge_leave)(struct cdr_object *cdr,
497                         struct ast_bridge_snapshot *bridge,
498                         struct ast_channel_snapshot *channel);
499
500         /*!
501          * \brief Process an update informing us that the channel got itself parked
502          *
503          * \param cdr The \ref cdr_object
504          * \param channel The parking information for this CDR's party A
505          *
506          * \retval 0 This CDR successfully parked itself
507          * \retval 1 This CDR couldn't handle the park
508          */
509         int (* const process_parked_channel)(struct cdr_object *cdr,
510                         struct ast_parked_call_payload *parking_info);
511 };
512
513 static int base_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot);
514 static enum process_bridge_enter_results base_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
515 static int base_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
516 static int base_process_dial_end(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status);
517 static int base_process_parked_channel(struct cdr_object *cdr, struct ast_parked_call_payload *parking_info);
518
519 static void single_state_init_function(struct cdr_object *cdr);
520 static void single_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot);
521 static int single_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer);
522 static enum process_bridge_enter_results single_state_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
523 static int single_state_process_parking_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
524
525 /*!
526  * \brief The virtual table for the Single state.
527  *
528  * A \ref cdr_object starts off in this state. This represents a channel that
529  * has no Party B information itself.
530  *
531  * A \ref cdr_object from this state can go into any of the following states:
532  * * \ref dial_state_fn_table
533  * * \ref bridge_state_fn_table
534  * * \ref finalized_state_fn_table
535  */
536 struct cdr_object_fn_table single_state_fn_table = {
537         .name = "Single",
538         .init_function = single_state_init_function,
539         .process_party_a = base_process_party_a,
540         .process_party_b = single_state_process_party_b,
541         .process_dial_begin = single_state_process_dial_begin,
542         .process_dial_end = base_process_dial_end,
543         .process_bridge_enter = single_state_process_bridge_enter,
544         .process_parking_bridge_enter = single_state_process_parking_bridge_enter,
545         .process_bridge_leave = base_process_bridge_leave,
546         .process_parked_channel = base_process_parked_channel,
547 };
548
549 static void dial_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot);
550 static int dial_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer);
551 static int dial_state_process_dial_end(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status);
552 static enum process_bridge_enter_results dial_state_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
553
554 /*!
555  * \brief The virtual table for the Dial state.
556  *
557  * A \ref cdr_object that has begun a dial operation. This state is entered when
558  * the Party A for a CDR is determined to be dialing out to a Party B or when
559  * a CDR is for an originated channel (in which case the Party A information is
560  * the originated channel, and there is no Party B).
561  *
562  * A \ref cdr_object from this state can go in any of the following states:
563  * * \ref dialed_pending_state_fn_table
564  * * \ref bridge_state_fn_table
565  * * \ref finalized_state_fn_table
566  */
567 struct cdr_object_fn_table dial_state_fn_table = {
568         .name = "Dial",
569         .process_party_a = base_process_party_a,
570         .process_party_b = dial_state_process_party_b,
571         .process_dial_begin = dial_state_process_dial_begin,
572         .process_dial_end = dial_state_process_dial_end,
573         .process_bridge_enter = dial_state_process_bridge_enter,
574         .process_bridge_leave = base_process_bridge_leave,
575 };
576
577 static int dialed_pending_state_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot);
578 static int dialed_pending_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer);
579 static enum process_bridge_enter_results dialed_pending_state_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
580 static int dialed_pending_state_process_parking_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
581
582 /*!
583  * \brief The virtual table for the Dialed Pending state.
584  *
585  * A \ref cdr_object that has successfully finished a dial operation, but we
586  * don't know what they're going to do yet. It's theoretically possible to dial
587  * a party and then have that party not be bridged with the caller; likewise,
588  * an origination can complete and the channel go off and execute dialplan. The
589  * pending state acts as a bridge between either:
590  * * Entering a bridge
591  * * Getting a new CDR for new dialplan execution
592  * * Switching from being originated to executing dialplan
593  *
594  * A \ref cdr_object from this state can go in any of the following states:
595  * * \ref single_state_fn_table
596  * * \ref dialed_pending_state_fn_table
597  * * \ref bridge_state_fn_table
598  * * \ref finalized_state_fn_table
599  */
600 struct cdr_object_fn_table dialed_pending_state_fn_table = {
601         .name = "DialedPending",
602         .process_party_a = dialed_pending_state_process_party_a,
603         .process_dial_begin = dialed_pending_state_process_dial_begin,
604         .process_bridge_enter = dialed_pending_state_process_bridge_enter,
605         .process_parking_bridge_enter = dialed_pending_state_process_parking_bridge_enter,
606         .process_bridge_leave = base_process_bridge_leave,
607         .process_parked_channel = base_process_parked_channel,
608 };
609
610 static void bridge_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot);
611 static int bridge_state_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
612
613 /*!
614  * \brief The virtual table for the Bridged state
615  *
616  * A \ref cdr_object enters this state when it receives notification that the
617  * channel has entered a bridge.
618  *
619  * A \ref cdr_object from this state can go to:
620  * * \ref finalized_state_fn_table
621  */
622 struct cdr_object_fn_table bridge_state_fn_table = {
623         .name = "Bridged",
624         .process_party_a = base_process_party_a,
625         .process_party_b = bridge_state_process_party_b,
626         .process_bridge_leave = bridge_state_process_bridge_leave,
627         .process_parked_channel = base_process_parked_channel,
628 };
629
630 static int parked_state_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel);
631
632 /*!
633  * \brief The virtual table for the Parked state
634  *
635  * Parking is weird. Unlike typical bridges, it has to be treated somewhat
636  * uniquely - a channel in a parking bridge (which is a subclass of a holding
637  * bridge) has to be handled as if the channel went into an application.
638  * However, when the channel comes out, we need a new CDR - unlike the Single
639  * state.
640  */
641 struct cdr_object_fn_table parked_state_fn_table = {
642         .name = "Parked",
643         .process_party_a = base_process_party_a,
644         .process_bridge_leave = parked_state_process_bridge_leave,
645         .process_parked_channel = base_process_parked_channel,
646 };
647
648 static void finalized_state_init_function(struct cdr_object *cdr);
649 static int finalized_state_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot);
650
651 /*!
652  * \brief The virtual table for the finalized state.
653  *
654  * Once in the finalized state, the CDR is done. No modifications can be made
655  * to the CDR.
656  */
657 struct cdr_object_fn_table finalized_state_fn_table = {
658         .name = "Finalized",
659         .init_function = finalized_state_init_function,
660         .process_party_a = finalized_state_process_party_a,
661         .process_bridge_enter = base_process_bridge_enter,
662 };
663
664 /*! \brief A wrapper object around a snapshot.
665  * Fields that are mutable by the CDR engine are replicated here.
666  */
667 struct cdr_object_snapshot {
668         struct ast_channel_snapshot *snapshot;  /*!< The channel snapshot */
669         char userfield[AST_MAX_USER_FIELD];     /*!< Userfield for the channel */
670         unsigned int flags;                     /*!< Specific flags for this party */
671         struct varshead variables;              /*!< CDR variables for the channel */
672 };
673
674 /*! \brief An in-memory representation of an active CDR */
675 struct cdr_object {
676         struct cdr_object_snapshot party_a;     /*!< The Party A information */
677         struct cdr_object_snapshot party_b;     /*!< The Party B information */
678         struct cdr_object_fn_table *fn_table;   /*!< The current virtual table */
679
680         enum ast_cdr_disposition disposition;   /*!< The disposition of the CDR */
681         struct timeval start;                   /*!< When this CDR was created */
682         struct timeval answer;                  /*!< Either when the channel was answered, or when the path between channels was established */
683         struct timeval end;                     /*!< When this CDR was finalized */
684         unsigned int sequence;                  /*!< A monotonically increasing number for each CDR */
685         struct ast_flags flags;                 /*!< Flags on the CDR */
686         AST_DECLARE_STRING_FIELDS(
687                 AST_STRING_FIELD(linkedid);         /*!< Linked ID. Cached here as it may change out from party A, which must be immutable */
688                 AST_STRING_FIELD(uniqueid);                     /*!< Unique id of party A. Cached here as it is the primary key of this CDR */
689                 AST_STRING_FIELD(name);             /*!< Channel name of party A. Cached here as the party A address may change */
690                 AST_STRING_FIELD(bridge);           /*!< The bridge the party A happens to be in. */
691                 AST_STRING_FIELD(appl);             /*!< The last accepted application party A was in */
692                 AST_STRING_FIELD(data);             /*!< The data for the last accepted application party A was in */
693                 AST_STRING_FIELD(context);          /*!< The accepted context for Party A */
694                 AST_STRING_FIELD(exten);            /*!< The accepted extension for Party A */
695         );
696         struct cdr_object *next;                /*!< The next CDR object in the chain */
697         struct cdr_object *last;                /*!< The last CDR object in the chain */
698         int is_root;                            /*!< True if this is the first CDR in the chain */
699 };
700
701 /*!
702  * \brief Copy variables from one list to another
703  * \param to_list destination
704  * \param from_list source
705  * \retval The number of copied variables
706  */
707 static int copy_variables(struct varshead *to_list, struct varshead *from_list)
708 {
709         struct ast_var_t *variables;
710         struct ast_var_t *newvariable;
711         const char *var;
712         const char *val;
713         int x = 0;
714
715         AST_LIST_TRAVERSE(from_list, variables, entries) {
716                 var = ast_var_name(variables);
717                 if (ast_strlen_zero(var)) {
718                         continue;
719                 }
720                 val = ast_var_value(variables);
721                 if (ast_strlen_zero(val)) {
722                         continue;
723                 }
724                 newvariable = ast_var_assign(var, val);
725                 if (newvariable) {
726                         AST_LIST_INSERT_HEAD(to_list, newvariable, entries);
727                         ++x;
728                 }
729         }
730
731         return x;
732 }
733
734 /*!
735  * \brief Delete all variables from a variable list
736  * \param headp The head pointer to the variable list to delete
737  */
738 static void free_variables(struct varshead *headp)
739 {
740         struct ast_var_t *vardata;
741
742         while ((vardata = AST_LIST_REMOVE_HEAD(headp, entries))) {
743                 ast_var_delete(vardata);
744         }
745 }
746
747 /*!
748  * \brief Copy a snapshot and its details
749  * \param dst The destination
750  * \param src The source
751  */
752 static void cdr_object_snapshot_copy(struct cdr_object_snapshot *dst, struct cdr_object_snapshot *src)
753 {
754         if (dst->snapshot) {
755                 ao2_t_ref(dst->snapshot, -1, "release old snapshot during copy");
756         }
757         dst->snapshot = src->snapshot;
758         ao2_t_ref(dst->snapshot, +1, "bump new snapshot during copy");
759         strcpy(dst->userfield, src->userfield);
760         dst->flags = src->flags;
761         copy_variables(&dst->variables, &src->variables);
762 }
763
764 /*!
765  * \brief Transition a \ref cdr_object to a new state
766  * \param cdr The \ref cdr_object to transition
767  * \param fn_table The \ref cdr_object_fn_table state to go to
768  */
769 static void cdr_object_transition_state(struct cdr_object *cdr, struct cdr_object_fn_table *fn_table)
770 {
771         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
772
773         CDR_DEBUG(mod_cfg, "%p - Transitioning CDR for %s from state %s to %s\n",
774                 cdr, cdr->party_a.snapshot->name,
775                 cdr->fn_table ? cdr->fn_table->name : "NONE", fn_table->name);
776         cdr->fn_table = fn_table;
777         if (cdr->fn_table->init_function) {
778                 cdr->fn_table->init_function(cdr);
779         }
780 }
781 /*! \internal
782  * \brief Hash function for containers of CDRs indexing by Party A uniqueid */
783 static int cdr_object_channel_hash_fn(const void *obj, const int flags)
784 {
785         const struct cdr_object *cdr;
786         const char *key;
787
788         switch (flags & OBJ_SEARCH_MASK) {
789         case OBJ_SEARCH_KEY:
790                 key = obj;
791                 break;
792         case OBJ_SEARCH_OBJECT:
793                 cdr = obj;
794                 key = cdr->uniqueid;
795                 break;
796         default:
797                 ast_assert(0);
798                 return 0;
799         }
800         return ast_str_case_hash(key);
801 }
802
803 /*! \internal
804  * \brief Comparison function for containers of CDRs indexing by Party A uniqueid
805  */
806 static int cdr_object_channel_cmp_fn(void *obj, void *arg, int flags)
807 {
808     struct cdr_object *left = obj;
809     struct cdr_object *right = arg;
810     const char *right_key = arg;
811     int cmp;
812
813     switch (flags & OBJ_SEARCH_MASK) {
814     case OBJ_SEARCH_OBJECT:
815         right_key = right->uniqueid;
816         /* Fall through */
817     case OBJ_SEARCH_KEY:
818         cmp = strcmp(left->uniqueid, right_key);
819         break;
820     case OBJ_SEARCH_PARTIAL_KEY:
821         /*
822          * We could also use a partial key struct containing a length
823          * so strlen() does not get called for every comparison instead.
824          */
825         cmp = strncmp(left->uniqueid, right_key, strlen(right_key));
826         break;
827     default:
828         /* Sort can only work on something with a full or partial key. */
829         ast_assert(0);
830         cmp = 0;
831         break;
832     }
833     return cmp ? 0 : CMP_MATCH;
834 }
835
836 /*!
837  * \brief \ref cdr_object Destructor
838  */
839 static void cdr_object_dtor(void *obj)
840 {
841         struct cdr_object *cdr = obj;
842         struct ast_var_t *it_var;
843
844         ao2_cleanup(cdr->party_a.snapshot);
845         ao2_cleanup(cdr->party_b.snapshot);
846         while ((it_var = AST_LIST_REMOVE_HEAD(&cdr->party_a.variables, entries))) {
847                 ast_var_delete(it_var);
848         }
849         while ((it_var = AST_LIST_REMOVE_HEAD(&cdr->party_b.variables, entries))) {
850                 ast_var_delete(it_var);
851         }
852         ast_string_field_free_memory(cdr);
853
854         /* CDR destruction used to work by calling ao2_cleanup(next) and
855          * allowing the chain to destroy itself neatly. Unfortunately, for
856          * really long chains, this can result in a stack overflow. So now
857          * when the root CDR is destroyed, it is responsible for unreffing
858          * all CDRs in the chain
859          */
860         if (cdr->is_root) {
861                 struct cdr_object *curr = cdr->next;
862                 struct cdr_object *next;
863
864                 while (curr) {
865                         next = curr->next;
866                         ao2_cleanup(curr);
867                         curr = next;
868                 }
869         }
870 }
871
872 /*!
873  * \brief \ref cdr_object constructor
874  * \param chan The \ref ast_channel_snapshot that is the CDR's Party A
875  *
876  * This implicitly sets the state of the newly created CDR to the Single state
877  * (\ref single_state_fn_table)
878  */
879 static struct cdr_object *cdr_object_alloc(struct ast_channel_snapshot *chan)
880 {
881         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
882         struct cdr_object *cdr;
883
884         ast_assert(chan != NULL);
885
886         cdr = ao2_alloc(sizeof(*cdr), cdr_object_dtor);
887         if (!cdr) {
888                 return NULL;
889         }
890         cdr->last = cdr;
891         if (ast_string_field_init(cdr, 64)) {
892                 ao2_cleanup(cdr);
893                 return NULL;
894         }
895         ast_string_field_set(cdr, uniqueid, chan->uniqueid);
896         ast_string_field_set(cdr, name, chan->name);
897         ast_string_field_set(cdr, linkedid, chan->linkedid);
898         cdr->disposition = AST_CDR_NULL;
899         cdr->sequence = ast_atomic_fetchadd_int(&global_cdr_sequence, +1);
900
901         cdr->party_a.snapshot = chan;
902         ao2_t_ref(cdr->party_a.snapshot, +1, "bump snapshot during CDR creation");
903
904         CDR_DEBUG(mod_cfg, "%p - Created CDR for channel %s\n", cdr, chan->name);
905
906         cdr_object_transition_state(cdr, &single_state_fn_table);
907
908         return cdr;
909 }
910
911 /*!
912  * \brief Create a new \ref cdr_object and append it to an existing chain
913  * \param cdr The \ref cdr_object to append to
914  */
915 static struct cdr_object *cdr_object_create_and_append(struct cdr_object *cdr)
916 {
917         struct cdr_object *new_cdr;
918         struct cdr_object *it_cdr;
919         struct cdr_object *cdr_last;
920
921         cdr_last = cdr->last;
922         new_cdr = cdr_object_alloc(cdr_last->party_a.snapshot);
923         if (!new_cdr) {
924                 return NULL;
925         }
926         new_cdr->disposition = AST_CDR_NULL;
927
928         /* Copy over the linkedid, as it may have changed */
929         ast_string_field_set(new_cdr, linkedid, cdr_last->linkedid);
930         ast_string_field_set(new_cdr, appl, cdr_last->appl);
931         ast_string_field_set(new_cdr, data, cdr_last->data);
932         ast_string_field_set(new_cdr, context, cdr_last->context);
933         ast_string_field_set(new_cdr, exten, cdr_last->exten);
934
935         /*
936          * If the current CDR says to disable all future ones,
937          * keep the disable chain going
938          */
939         if (ast_test_flag(&cdr_last->flags, AST_CDR_FLAG_DISABLE_ALL)) {
940                 ast_set_flag(&new_cdr->flags, AST_CDR_FLAG_DISABLE_ALL);
941         }
942
943         /* Copy over other Party A information */
944         cdr_object_snapshot_copy(&new_cdr->party_a, &cdr_last->party_a);
945
946         /* Append the CDR to the end of the list */
947         for (it_cdr = cdr; it_cdr->next; it_cdr = it_cdr->next) {
948                 it_cdr->last = new_cdr;
949         }
950         it_cdr->last = new_cdr;
951         it_cdr->next = new_cdr;
952
953         return new_cdr;
954 }
955
956 /*!
957  * \brief Return whether or not a channel has changed its state in the dialplan, subject
958  * to endbeforehexten logic
959  *
960  * \param old_snapshot The previous state
961  * \param new_snapshot The new state
962  *
963  * \retval 0 if the state has not changed
964  * \retval 1 if the state changed
965  */
966 static int snapshot_cep_changed(struct ast_channel_snapshot *old_snapshot,
967         struct ast_channel_snapshot *new_snapshot)
968 {
969         RAII_VAR(struct module_config *, mod_cfg,
970                 ao2_global_obj_ref(module_configs), ao2_cleanup);
971
972         /* If we ignore hangup logic, don't indicate that we're executing anything new */
973         if (ast_test_flag(&mod_cfg->general->settings, CDR_END_BEFORE_H_EXTEN)
974                 && ast_test_flag(&new_snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)) {
975                 return 0;
976         }
977
978         /* When Party A is originated to an application and the application exits, the stack
979          * will attempt to clear the application and restore the dummy originate application
980          * of "AppDialX". Ignore application changes to AppDialX as a result.
981          */
982         if (strcmp(new_snapshot->appl, old_snapshot->appl) && strncasecmp(new_snapshot->appl, "appdial", 7)
983                 && (strcmp(new_snapshot->context, old_snapshot->context)
984                 || strcmp(new_snapshot->exten, old_snapshot->exten)
985                 || new_snapshot->priority != old_snapshot->priority)) {
986                 return 1;
987         }
988
989         return 0;
990 }
991
992 /*!
993  * \brief Return whether or not a \ref ast_channel_snapshot is for a channel
994  * that was created as the result of a dial operation
995  *
996  * \retval 0 the channel was not created as the result of a dial
997  * \retval 1 the channel was created as the result of a dial
998  */
999 static int snapshot_is_dialed(struct ast_channel_snapshot *snapshot)
1000 {
1001         return (ast_test_flag(&snapshot->flags, AST_FLAG_OUTGOING)
1002                         && !(ast_test_flag(&snapshot->flags, AST_FLAG_ORIGINATED)));
1003 }
1004
1005 /*!
1006  * \brief Given two CDR snapshots, figure out who should be Party A for the
1007  * resulting CDR
1008  * \param left One of the snapshots
1009  * \param right The other snapshot
1010  * \retval The snapshot that won
1011  */
1012 static struct cdr_object_snapshot *cdr_object_pick_party_a(struct cdr_object_snapshot *left, struct cdr_object_snapshot *right)
1013 {
1014         /* Check whether or not the party is dialed. A dialed party is never the
1015          * Party A with a party that was not dialed.
1016          */
1017         if (!snapshot_is_dialed(left->snapshot) && snapshot_is_dialed(right->snapshot)) {
1018                 return left;
1019         } else if (snapshot_is_dialed(left->snapshot) && !snapshot_is_dialed(right->snapshot)) {
1020                 return right;
1021         }
1022
1023         /* Try the Party A flag */
1024         if (ast_test_flag(left, AST_CDR_FLAG_PARTY_A) && !ast_test_flag(right, AST_CDR_FLAG_PARTY_A)) {
1025                 return left;
1026         } else if (!ast_test_flag(right, AST_CDR_FLAG_PARTY_A) && ast_test_flag(right, AST_CDR_FLAG_PARTY_A)) {
1027                 return right;
1028         }
1029
1030         /* Neither party is dialed and neither has the Party A flag - defer to
1031          * creation time */
1032         if (left->snapshot->creationtime.tv_sec < right->snapshot->creationtime.tv_sec) {
1033                 return left;
1034         } else if (left->snapshot->creationtime.tv_sec > right->snapshot->creationtime.tv_sec) {
1035                 return right;
1036         } else if (left->snapshot->creationtime.tv_usec > right->snapshot->creationtime.tv_usec) {
1037                 return right;
1038         } else {
1039                 /* Okay, fine, take the left one */
1040                 return left;
1041         }
1042 }
1043
1044 /*!
1045  * Compute the duration for a \ref cdr_object
1046  */
1047 static long cdr_object_get_duration(struct cdr_object *cdr)
1048 {
1049         return (long)(ast_tvdiff_ms(ast_tvzero(cdr->end) ? ast_tvnow() : cdr->end, cdr->start) / 1000);
1050 }
1051
1052 /*!
1053  * \brief Compute the billsec for a \ref cdr_object
1054  */
1055 static long cdr_object_get_billsec(struct cdr_object *cdr)
1056 {
1057         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1058         long int ms;
1059
1060         if (ast_tvzero(cdr->answer)) {
1061                 return 0;
1062         }
1063         ms = ast_tvdiff_ms(ast_tvzero(cdr->end) ? ast_tvnow() : cdr->end, cdr->answer);
1064         if (ast_test_flag(&mod_cfg->general->settings, CDR_INITIATED_SECONDS)
1065                 && (ms % 1000 >= 500)) {
1066                 ms = (ms / 1000) + 1;
1067         } else {
1068                 ms = ms / 1000;
1069         }
1070
1071         return ms;
1072 }
1073
1074 /*!
1075  * \internal
1076  * \brief Set a variable on a CDR object
1077  *
1078  * \param headp The header pointer to the variable to set
1079  * \param name The name of the variable
1080  * \param value The value of the variable
1081  */
1082 static void set_variable(struct varshead *headp, const char *name, const char *value)
1083 {
1084         struct ast_var_t *newvariable;
1085
1086         AST_LIST_TRAVERSE_SAFE_BEGIN(headp, newvariable, entries) {
1087                 if (!strcasecmp(ast_var_name(newvariable), name)) {
1088                         AST_LIST_REMOVE_CURRENT(entries);
1089                         ast_var_delete(newvariable);
1090                         break;
1091                 }
1092         }
1093         AST_LIST_TRAVERSE_SAFE_END;
1094
1095         if (value && (newvariable = ast_var_assign(name, value))) {
1096                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
1097         }
1098 }
1099
1100 /*!
1101  * \brief Create a chain of \ref ast_cdr objects from a chain of \ref cdr_object
1102  * suitable for consumption by the registered CDR backends
1103  * \param cdr The \ref cdr_object to convert to a public record
1104  * \retval A chain of \ref ast_cdr objects on success
1105  * \retval NULL on failure
1106  */
1107 static struct ast_cdr *cdr_object_create_public_records(struct cdr_object *cdr)
1108 {
1109         struct ast_cdr *pub_cdr = NULL, *cdr_prev = NULL;
1110         struct cdr_object *it_cdr;
1111         struct ast_var_t *it_var, *it_copy_var;
1112         struct ast_channel_snapshot *party_a;
1113         struct ast_channel_snapshot *party_b;
1114
1115         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
1116                 struct ast_cdr *cdr_copy;
1117
1118                 /* Don't create records for CDRs where the party A was a dialed channel */
1119                 if (snapshot_is_dialed(it_cdr->party_a.snapshot) && !it_cdr->party_b.snapshot) {
1120                         ast_debug(1, "CDR for %s is dialed and has no Party B; discarding\n",
1121                                 it_cdr->party_a.snapshot->name);
1122                         continue;
1123                 }
1124
1125                 cdr_copy = ast_calloc(1, sizeof(*cdr_copy));
1126                 if (!cdr_copy) {
1127                         ast_free(pub_cdr);
1128                         return NULL;
1129                 }
1130
1131                 party_a = it_cdr->party_a.snapshot;
1132                 party_b = it_cdr->party_b.snapshot;
1133
1134                 /* Party A */
1135                 ast_assert(party_a != NULL);
1136                 ast_copy_string(cdr_copy->accountcode, party_a->accountcode, sizeof(cdr_copy->accountcode));
1137                 cdr_copy->amaflags = party_a->amaflags;
1138                 ast_copy_string(cdr_copy->channel, party_a->name, sizeof(cdr_copy->channel));
1139                 ast_callerid_merge(cdr_copy->clid, sizeof(cdr_copy->clid), party_a->caller_name, party_a->caller_number, "");
1140                 ast_copy_string(cdr_copy->src, party_a->caller_number, sizeof(cdr_copy->src));
1141                 ast_copy_string(cdr_copy->uniqueid, party_a->uniqueid, sizeof(cdr_copy->uniqueid));
1142                 ast_copy_string(cdr_copy->lastapp, it_cdr->appl, sizeof(cdr_copy->lastapp));
1143                 ast_copy_string(cdr_copy->lastdata, it_cdr->data, sizeof(cdr_copy->lastdata));
1144                 ast_copy_string(cdr_copy->dst, it_cdr->exten, sizeof(cdr_copy->dst));
1145                 ast_copy_string(cdr_copy->dcontext, it_cdr->context, sizeof(cdr_copy->dcontext));
1146
1147                 /* Party B */
1148                 if (party_b) {
1149                         ast_copy_string(cdr_copy->dstchannel, party_b->name, sizeof(cdr_copy->dstchannel));
1150                         ast_copy_string(cdr_copy->peeraccount, party_b->accountcode, sizeof(cdr_copy->peeraccount));
1151                         if (!ast_strlen_zero(it_cdr->party_b.userfield)) {
1152                                 snprintf(cdr_copy->userfield, sizeof(cdr_copy->userfield), "%s;%s", it_cdr->party_a.userfield, it_cdr->party_b.userfield);
1153                         }
1154                 }
1155                 if (ast_strlen_zero(cdr_copy->userfield) && !ast_strlen_zero(it_cdr->party_a.userfield)) {
1156                         ast_copy_string(cdr_copy->userfield, it_cdr->party_a.userfield, sizeof(cdr_copy->userfield));
1157                 }
1158
1159                 /* Timestamps/durations */
1160                 cdr_copy->start = it_cdr->start;
1161                 cdr_copy->answer = it_cdr->answer;
1162                 cdr_copy->end = it_cdr->end;
1163                 cdr_copy->billsec = cdr_object_get_billsec(it_cdr);
1164                 cdr_copy->duration = cdr_object_get_duration(it_cdr);
1165
1166                 /* Flags and IDs */
1167                 ast_copy_flags(cdr_copy, &it_cdr->flags, AST_FLAGS_ALL);
1168                 ast_copy_string(cdr_copy->linkedid, it_cdr->linkedid, sizeof(cdr_copy->linkedid));
1169                 cdr_copy->disposition = it_cdr->disposition;
1170                 cdr_copy->sequence = it_cdr->sequence;
1171
1172                 /* Variables */
1173                 copy_variables(&cdr_copy->varshead, &it_cdr->party_a.variables);
1174                 AST_LIST_TRAVERSE(&it_cdr->party_b.variables, it_var, entries) {
1175                         int found = 0;
1176                         struct ast_var_t *newvariable;
1177                         AST_LIST_TRAVERSE(&cdr_copy->varshead, it_copy_var, entries) {
1178                                 if (!strcasecmp(ast_var_name(it_var), ast_var_name(it_copy_var))) {
1179                                         found = 1;
1180                                         break;
1181                                 }
1182                         }
1183                         if (!found && (newvariable = ast_var_assign(ast_var_name(it_var), ast_var_value(it_var)))) {
1184                                 AST_LIST_INSERT_TAIL(&cdr_copy->varshead, newvariable, entries);
1185                         }
1186                 }
1187
1188                 if (!pub_cdr) {
1189                         pub_cdr = cdr_copy;
1190                         cdr_prev = pub_cdr;
1191                 } else {
1192                         cdr_prev->next = cdr_copy;
1193                         cdr_prev = cdr_copy;
1194                 }
1195         }
1196
1197         return pub_cdr;
1198 }
1199
1200 /*!
1201  * \brief Dispatch a CDR.
1202  * \param cdr The \ref cdr_object to dispatch
1203  *
1204  * This will create a \ref ast_cdr object and publish it to the various backends
1205  */
1206 static void cdr_object_dispatch(struct cdr_object *cdr)
1207 {
1208         RAII_VAR(struct module_config *, mod_cfg,
1209                         ao2_global_obj_ref(module_configs), ao2_cleanup);
1210         struct ast_cdr *pub_cdr;
1211
1212         CDR_DEBUG(mod_cfg, "%p - Dispatching CDR for Party A %s, Party B %s\n", cdr,
1213                         cdr->party_a.snapshot->name,
1214                         cdr->party_b.snapshot ? cdr->party_b.snapshot->name : "<none>");
1215         pub_cdr = cdr_object_create_public_records(cdr);
1216         cdr_detach(pub_cdr);
1217 }
1218
1219 /*!
1220  * \brief Set the disposition on a \ref cdr_object based on a hangupcause code
1221  * \param cdr The \ref cdr_object
1222  * \param hangupcause The Asterisk hangup cause code
1223  */
1224 static void cdr_object_set_disposition(struct cdr_object *cdr, int hangupcause)
1225 {
1226         RAII_VAR(struct module_config *, mod_cfg,
1227                         ao2_global_obj_ref(module_configs), ao2_cleanup);
1228
1229         /* Change the disposition based on the hang up cause */
1230         switch (hangupcause) {
1231         case AST_CAUSE_BUSY:
1232                 cdr->disposition = AST_CDR_BUSY;
1233                 break;
1234         case AST_CAUSE_CONGESTION:
1235                 if (!ast_test_flag(&mod_cfg->general->settings, CDR_CONGESTION)) {
1236                         cdr->disposition = AST_CDR_FAILED;
1237                 } else {
1238                         cdr->disposition = AST_CDR_CONGESTION;
1239                 }
1240                 break;
1241         case AST_CAUSE_NO_ROUTE_DESTINATION:
1242         case AST_CAUSE_UNREGISTERED:
1243                 cdr->disposition = AST_CDR_FAILED;
1244                 break;
1245         case AST_CAUSE_NORMAL_CLEARING:
1246         case AST_CAUSE_NO_ANSWER:
1247                 cdr->disposition = AST_CDR_NOANSWER;
1248                 break;
1249         default:
1250                 break;
1251         }
1252 }
1253
1254 /*!
1255  * \brief Finalize a CDR.
1256  *
1257  * This function is safe to call multiple times. Note that you can call this
1258  * explicitly before going to the finalized state if there's a chance the CDR
1259  * will be re-activated, in which case the \ref cdr_object's end time should be
1260  * cleared. This function is implicitly called when a CDR transitions to the
1261  * finalized state and right before it is dispatched
1262  *
1263  * \param cdr_object The CDR to finalize
1264  */
1265 static void cdr_object_finalize(struct cdr_object *cdr)
1266 {
1267         if (!ast_tvzero(cdr->end)) {
1268                 return;
1269         }
1270         cdr->end = ast_tvnow();
1271
1272         if (cdr->disposition == AST_CDR_NULL) {
1273                 if (!ast_tvzero(cdr->answer)) {
1274                         cdr->disposition = AST_CDR_ANSWERED;
1275                 } else if (cdr->party_a.snapshot->hangupcause) {
1276                         cdr_object_set_disposition(cdr, cdr->party_a.snapshot->hangupcause);
1277                 } else if (cdr->party_b.snapshot && cdr->party_b.snapshot->hangupcause) {
1278                         cdr_object_set_disposition(cdr, cdr->party_b.snapshot->hangupcause);
1279                 } else {
1280                         cdr->disposition = AST_CDR_FAILED;
1281                 }
1282         }
1283
1284         /* tv_usec is suseconds_t, which could be int or long */
1285         ast_debug(1, "Finalized CDR for %s - start %ld.%06ld answer %ld.%06ld end %ld.%06ld dispo %s\n",
1286                         cdr->party_a.snapshot->name,
1287                         (long)cdr->start.tv_sec,
1288                         (long)cdr->start.tv_usec,
1289                         (long)cdr->answer.tv_sec,
1290                         (long)cdr->answer.tv_usec,
1291                         (long)cdr->end.tv_sec,
1292                         (long)cdr->end.tv_usec,
1293                         ast_cdr_disp2str(cdr->disposition));
1294 }
1295
1296 /*!
1297  * \brief Check to see if a CDR needs to move to the finalized state because
1298  * its Party A hungup.
1299  */
1300 static void cdr_object_check_party_a_hangup(struct cdr_object *cdr)
1301 {
1302         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1303
1304         if (ast_test_flag(&mod_cfg->general->settings, CDR_END_BEFORE_H_EXTEN)
1305                 && ast_test_flag(&cdr->party_a.snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)) {
1306                 cdr_object_finalize(cdr);
1307         }
1308
1309         if (ast_test_flag(&cdr->party_a.snapshot->flags, AST_FLAG_DEAD)
1310                 && cdr->fn_table != &finalized_state_fn_table) {
1311                 cdr_object_transition_state(cdr, &finalized_state_fn_table);
1312         }
1313 }
1314
1315 /*!
1316  * \brief Check to see if a CDR needs to be answered based on its Party A.
1317  * Note that this is safe to call as much as you want - we won't answer twice
1318  */
1319 static void cdr_object_check_party_a_answer(struct cdr_object *cdr) {
1320         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1321
1322         if (cdr->party_a.snapshot->state == AST_STATE_UP && ast_tvzero(cdr->answer)) {
1323                 cdr->answer = ast_tvnow();
1324                 /* tv_usec is suseconds_t, which could be int or long */
1325                 CDR_DEBUG(mod_cfg, "%p - Set answered time to %ld.%06ld\n", cdr,
1326                         (long)cdr->answer.tv_sec,
1327                         (long)cdr->answer.tv_usec);
1328         }
1329 }
1330
1331 /* \brief Set Caller ID information on a CDR */
1332 static void cdr_object_update_cid(struct cdr_object_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
1333 {
1334         if (!old_snapshot->snapshot) {
1335                 set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller_dnid);
1336                 set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller_subaddr);
1337                 set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->dialed_subaddr);
1338                 return;
1339         }
1340         if (!strcmp(old_snapshot->snapshot->caller_dnid, new_snapshot->caller_dnid)) {
1341                 set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller_dnid);
1342         }
1343         if (!strcmp(old_snapshot->snapshot->caller_subaddr, new_snapshot->caller_subaddr)) {
1344                 set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller_subaddr);
1345         }
1346         if (!strcmp(old_snapshot->snapshot->dialed_subaddr, new_snapshot->dialed_subaddr)) {
1347                 set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->dialed_subaddr);
1348         }
1349 }
1350
1351 /*!
1352  * \brief Swap an old \ref cdr_object_snapshot's \ref ast_channel_snapshot for
1353  * a new \ref ast_channel_snapshot
1354  * \param old_snapshot The old \ref cdr_object_snapshot
1355  * \param new_snapshot The new \ref ast_channel_snapshot for old_snapshot
1356  */
1357 static void cdr_object_swap_snapshot(struct cdr_object_snapshot *old_snapshot,
1358                 struct ast_channel_snapshot *new_snapshot)
1359 {
1360         cdr_object_update_cid(old_snapshot, new_snapshot);
1361         if (old_snapshot->snapshot) {
1362                 ao2_t_ref(old_snapshot->snapshot, -1, "Drop ref for swap");
1363         }
1364         ao2_t_ref(new_snapshot, +1, "Bump ref for swap");
1365         old_snapshot->snapshot = new_snapshot;
1366 }
1367
1368 /* BASE METHOD IMPLEMENTATIONS */
1369
1370 static int base_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1371 {
1372         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1373
1374         ast_assert(strcasecmp(snapshot->name, cdr->party_a.snapshot->name) == 0);
1375
1376         /* Finalize the CDR if we're in hangup logic and we're set to do so */
1377         if (ast_test_flag(&snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
1378                 && ast_test_flag(&mod_cfg->general->settings, CDR_END_BEFORE_H_EXTEN)) {
1379                 cdr_object_finalize(cdr);
1380                 return 0;
1381         }
1382
1383         /*
1384          * Only record the context and extension if we aren't in a subroutine, or if
1385          * we are executing hangup logic.
1386          */
1387         if (!ast_test_flag(&snapshot->flags, AST_FLAG_SUBROUTINE_EXEC)
1388                 || ast_test_flag(&snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)) {
1389                 ast_string_field_set(cdr, context, snapshot->context);
1390                 ast_string_field_set(cdr, exten, snapshot->exten);
1391         }
1392
1393         cdr_object_swap_snapshot(&cdr->party_a, snapshot);
1394
1395         /* When Party A is originated to an application and the application exits, the stack
1396          * will attempt to clear the application and restore the dummy originate application
1397          * of "AppDialX". Prevent that, and any other application changes we might not want
1398          * here.
1399          */
1400         if (!ast_strlen_zero(snapshot->appl)
1401                         && (strncasecmp(snapshot->appl, "appdial", 7) || ast_strlen_zero(cdr->appl))
1402                         && !ast_test_flag(&cdr->flags, AST_CDR_LOCK_APP)) {
1403                 ast_string_field_set(cdr, appl, snapshot->appl);
1404                 ast_string_field_set(cdr, data, snapshot->data);
1405
1406                 /* Dial (app_dial) is a special case. Because pre-dial handlers, which
1407                  * execute before the dial begins, will alter the application/data to
1408                  * something people typically don't want to see, if we see a channel enter
1409                  * into Dial here, we set the appl/data accordingly and lock it.
1410                  */
1411                 if (!strcmp(snapshot->appl, "Dial")) {
1412                         ast_set_flag(&cdr->flags, AST_CDR_LOCK_APP);
1413                 }
1414         }
1415
1416         ast_string_field_set(cdr, linkedid, snapshot->linkedid);
1417         cdr_object_check_party_a_answer(cdr);
1418         cdr_object_check_party_a_hangup(cdr);
1419
1420         return 0;
1421 }
1422
1423 static int base_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1424 {
1425         return 0;
1426 }
1427
1428 static int base_process_dial_end(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status)
1429 {
1430         return 0;
1431 }
1432
1433 static enum process_bridge_enter_results base_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1434 {
1435         /* Base process bridge enter simply indicates that we can't handle it */
1436         return BRIDGE_ENTER_NEED_CDR;
1437 }
1438
1439 static int base_process_parked_channel(struct cdr_object *cdr, struct ast_parked_call_payload *parking_info)
1440 {
1441         char park_info[128];
1442
1443         ast_assert(!strcasecmp(parking_info->parkee->name, cdr->party_a.snapshot->name));
1444
1445         /* Update Party A information regardless */
1446         cdr->fn_table->process_party_a(cdr, parking_info->parkee);
1447
1448         /* Fake out where we're parked */
1449         ast_string_field_set(cdr, appl, "Park");
1450         snprintf(park_info, sizeof(park_info), "%s:%u", parking_info->parkinglot, parking_info->parkingspace);
1451         ast_string_field_set(cdr, data, park_info);
1452
1453         /* Prevent any further changes to the App/Data fields for this record */
1454         ast_set_flag(&cdr->flags, AST_CDR_LOCK_APP);
1455
1456         return 0;
1457 }
1458
1459 /* SINGLE STATE */
1460
1461 static void single_state_init_function(struct cdr_object *cdr) {
1462         cdr->start = ast_tvnow();
1463         cdr_object_check_party_a_answer(cdr);
1464 }
1465
1466 static void single_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1467 {
1468         /* This should never happen! */
1469         ast_assert(cdr->party_b.snapshot == NULL);
1470         ast_assert(0);
1471         return;
1472 }
1473
1474 static int single_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
1475 {
1476         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1477
1478         if (caller && !strcasecmp(cdr->party_a.snapshot->name, caller->name)) {
1479                 base_process_party_a(cdr, caller);
1480                 CDR_DEBUG(mod_cfg, "%p - Updated Party A %s snapshot\n", cdr,
1481                                 cdr->party_a.snapshot->name);
1482                 cdr_object_swap_snapshot(&cdr->party_b, peer);
1483                 CDR_DEBUG(mod_cfg, "%p - Updated Party B %s snapshot\n", cdr,
1484                                 cdr->party_b.snapshot->name);
1485
1486                 /* If we have two parties, lock the application that caused the
1487                  * two parties to be associated. This prevents mid-call event
1488                  * macros/gosubs from perturbing the CDR application/data
1489                  */
1490                 ast_set_flag(&cdr->flags, AST_CDR_LOCK_APP);
1491         } else if (!strcasecmp(cdr->party_a.snapshot->name, peer->name)) {
1492                 /* We're the entity being dialed, i.e., outbound origination */
1493                 base_process_party_a(cdr, peer);
1494                 CDR_DEBUG(mod_cfg, "%p - Updated Party A %s snapshot\n", cdr,
1495                                 cdr->party_a.snapshot->name);
1496         }
1497
1498         cdr_object_transition_state(cdr, &dial_state_fn_table);
1499         return 0;
1500 }
1501
1502 /*!
1503  * \brief Handle a comparison between our \ref cdr_object and a \ref cdr_object
1504  * already in the bridge while in the Single state. The goal of this is to find
1505  * a Party B for our CDR.
1506  *
1507  * \param cdr Our \ref cdr_object in the Single state
1508  * \param cand_cdr The \ref cdr_object already in the Bridge state
1509  *
1510  * \retval 0 The cand_cdr had a Party A or Party B that we could use as our
1511  * Party B
1512  * \retval 1 No party in the cand_cdr could be used as our Party B
1513  */
1514 static int single_state_bridge_enter_comparison(struct cdr_object *cdr,
1515                 struct cdr_object *cand_cdr)
1516 {
1517         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1518         struct cdr_object_snapshot *party_a;
1519
1520         /* Don't match on ourselves */
1521         if (!strcasecmp(cdr->party_a.snapshot->name, cand_cdr->party_a.snapshot->name)) {
1522                 return 1;
1523         }
1524
1525         /* Try the candidate CDR's Party A first */
1526         party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_a);
1527         if (!strcasecmp(party_a->snapshot->name, cdr->party_a.snapshot->name)) {
1528                 CDR_DEBUG(mod_cfg, "%p - Party A %s has new Party B %s\n",
1529                         cdr, cdr->party_a.snapshot->name, cand_cdr->party_a.snapshot->name);
1530                 cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
1531                 if (!cand_cdr->party_b.snapshot) {
1532                         /* We just stole them - finalize their CDR. Note that this won't
1533                          * transition their state, it just sets the end time and the
1534                          * disposition - if we need to re-activate them later, we can.
1535                          */
1536                         cdr_object_finalize(cand_cdr);
1537                 }
1538                 return 0;
1539         }
1540
1541         /* Try their Party B, unless it's us */
1542         if (!cand_cdr->party_b.snapshot
1543                 || !strcasecmp(cdr->party_a.snapshot->name, cand_cdr->party_b.snapshot->name)) {
1544                 return 1;
1545         }
1546         party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_b);
1547         if (!strcasecmp(party_a->snapshot->name, cdr->party_a.snapshot->name)) {
1548                 CDR_DEBUG(mod_cfg, "%p - Party A %s has new Party B %s\n",
1549                         cdr, cdr->party_a.snapshot->name, cand_cdr->party_b.snapshot->name);
1550                 cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_b);
1551                 return 0;
1552         }
1553
1554         return 1;
1555 }
1556
1557 static enum process_bridge_enter_results single_state_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1558 {
1559         struct ao2_iterator it_cdrs;
1560         char *channel_id;
1561         int success = 0;
1562
1563         ast_string_field_set(cdr, bridge, bridge->uniqueid);
1564
1565         if (ao2_container_count(bridge->channels) == 1) {
1566                 /* No one in the bridge yet but us! */
1567                 cdr_object_transition_state(cdr, &bridge_state_fn_table);
1568                 return BRIDGE_ENTER_ONLY_PARTY;
1569         }
1570
1571         for (it_cdrs = ao2_iterator_init(bridge->channels, 0);
1572                 !success && (channel_id = ao2_iterator_next(&it_cdrs));
1573                 ao2_ref(channel_id, -1)) {
1574                 RAII_VAR(struct cdr_object *, cand_cdr_master,
1575                         ao2_find(active_cdrs_by_channel, channel_id, OBJ_SEARCH_KEY),
1576                         ao2_cleanup);
1577                 struct cdr_object *cand_cdr;
1578
1579                 if (!cand_cdr_master) {
1580                         continue;
1581                 }
1582
1583                 ao2_lock(cand_cdr_master);
1584                 for (cand_cdr = cand_cdr_master; cand_cdr; cand_cdr = cand_cdr->next) {
1585                         /* Skip any records that are not in a bridge or in this bridge.
1586                          * I'm not sure how that would happen, but it pays to be careful. */
1587                         if (cand_cdr->fn_table != &bridge_state_fn_table ||
1588                                         strcmp(cdr->bridge, cand_cdr->bridge)) {
1589                                 continue;
1590                         }
1591
1592                         if (single_state_bridge_enter_comparison(cdr, cand_cdr)) {
1593                                 continue;
1594                         }
1595                         /* We successfully got a party B - break out */
1596                         success = 1;
1597                         break;
1598                 }
1599                 ao2_unlock(cand_cdr_master);
1600         }
1601         ao2_iterator_destroy(&it_cdrs);
1602
1603         /* We always transition state, even if we didn't get a peer */
1604         cdr_object_transition_state(cdr, &bridge_state_fn_table);
1605
1606         /* Success implies that we have a Party B */
1607         if (success) {
1608                 return BRIDGE_ENTER_OBTAINED_PARTY_B;
1609         }
1610
1611         return BRIDGE_ENTER_NO_PARTY_B;
1612 }
1613
1614 static int single_state_process_parking_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1615 {
1616         cdr_object_transition_state(cdr, &parked_state_fn_table);
1617         return 0;
1618 }
1619
1620
1621 /* DIAL STATE */
1622
1623 static void dial_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1624 {
1625         ast_assert(snapshot != NULL);
1626
1627         if (!cdr->party_b.snapshot
1628                 || strcasecmp(cdr->party_b.snapshot->name, snapshot->name)) {
1629                 return;
1630         }
1631         cdr_object_swap_snapshot(&cdr->party_b, snapshot);
1632
1633         /* If party B hangs up, finalize this CDR */
1634         if (ast_test_flag(&cdr->party_b.snapshot->flags, AST_FLAG_DEAD)) {
1635                 cdr_object_transition_state(cdr, &finalized_state_fn_table);
1636         }
1637 }
1638
1639 static int dial_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
1640 {
1641         /* Don't process a begin dial here. A party A already in the dial state will
1642          * who receives a dial begin for something else will be handled by the
1643          * message router callback and will add a new CDR for the party A */
1644         return 1;
1645 }
1646
1647 /*!
1648  * \internal
1649  * \brief Convert a dial status to a CDR disposition
1650  */
1651 static enum ast_cdr_disposition dial_status_to_disposition(const char *dial_status)
1652 {
1653         RAII_VAR(struct module_config *, mod_cfg,
1654                 ao2_global_obj_ref(module_configs), ao2_cleanup);
1655
1656         if (!strcmp(dial_status, "ANSWER")) {
1657                 return AST_CDR_ANSWERED;
1658         } else if (!strcmp(dial_status, "BUSY")) {
1659                 return AST_CDR_BUSY;
1660         } else if (!strcmp(dial_status, "CANCEL") || !strcmp(dial_status, "NOANSWER")) {
1661                 return AST_CDR_NOANSWER;
1662         } else if (!strcmp(dial_status, "CONGESTION")) {
1663                 if (!ast_test_flag(&mod_cfg->general->settings, CDR_CONGESTION)) {
1664                         return AST_CDR_FAILED;
1665                 } else {
1666                         return AST_CDR_CONGESTION;
1667                 }
1668         } else if (!strcmp(dial_status, "FAILED")) {
1669                 return AST_CDR_FAILED;
1670         }
1671         return AST_CDR_FAILED;
1672 }
1673
1674 static int dial_state_process_dial_end(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status)
1675 {
1676         struct ast_channel_snapshot *party_a;
1677
1678         if (caller) {
1679                 party_a = caller;
1680         } else {
1681                 party_a = peer;
1682         }
1683         ast_assert(!strcasecmp(cdr->party_a.snapshot->name, party_a->name));
1684         cdr_object_swap_snapshot(&cdr->party_a, party_a);
1685
1686         if (cdr->party_b.snapshot) {
1687                 if (strcasecmp(cdr->party_b.snapshot->name, peer->name)) {
1688                         /* Not the status for this CDR - defer back to the message router */
1689                         return 1;
1690                 }
1691                 cdr_object_swap_snapshot(&cdr->party_b, peer);
1692         }
1693
1694         /* Set the disposition based on the dial string. */
1695         cdr->disposition = dial_status_to_disposition(dial_status);
1696         if (cdr->disposition == AST_CDR_ANSWERED) {
1697                 /* Switch to dial pending to wait and see what the caller does */
1698                 cdr_object_transition_state(cdr, &dialed_pending_state_fn_table);
1699         } else {
1700                 cdr_object_transition_state(cdr, &finalized_state_fn_table);
1701         }
1702
1703         return 0;
1704 }
1705
1706 static enum process_bridge_enter_results dial_state_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1707 {
1708         struct ao2_iterator it_cdrs;
1709         char *channel_id;
1710         int success = 0;
1711
1712         ast_string_field_set(cdr, bridge, bridge->uniqueid);
1713
1714         /* Get parties in the bridge */
1715         if (ao2_container_count(bridge->channels) == 1) {
1716                 /* No one in the bridge yet but us! */
1717                 cdr_object_transition_state(cdr, &bridge_state_fn_table);
1718                 return BRIDGE_ENTER_ONLY_PARTY;
1719         }
1720
1721         for (it_cdrs = ao2_iterator_init(bridge->channels, 0);
1722                 !success && (channel_id = ao2_iterator_next(&it_cdrs));
1723                 ao2_ref(channel_id, -1)) {
1724                 RAII_VAR(struct cdr_object *, cand_cdr_master,
1725                         ao2_find(active_cdrs_by_channel, channel_id, OBJ_SEARCH_KEY),
1726                         ao2_cleanup);
1727                 struct cdr_object *cand_cdr;
1728
1729                 if (!cand_cdr_master) {
1730                         continue;
1731                 }
1732
1733                 ao2_lock(cand_cdr_master);
1734                 for (cand_cdr = cand_cdr_master; cand_cdr; cand_cdr = cand_cdr->next) {
1735                         /* Skip any records that are not in a bridge or in this bridge.
1736                          * I'm not sure how that would happen, but it pays to be careful. */
1737                         if (cand_cdr->fn_table != &bridge_state_fn_table ||
1738                                         strcmp(cdr->bridge, cand_cdr->bridge)) {
1739                                 continue;
1740                         }
1741
1742                         /* If we don't have a Party B (originated channel), skip it */
1743                         if (!cdr->party_b.snapshot) {
1744                                 continue;
1745                         }
1746
1747                         /* Skip any records that aren't our Party B */
1748                         if (strcasecmp(cdr->party_b.snapshot->name, cand_cdr->party_a.snapshot->name)) {
1749                                 continue;
1750                         }
1751                         cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
1752                         /* If they have a Party B, they joined up with someone else as their
1753                          * Party A. Don't finalize them as they're active. Otherwise, we
1754                          * have stolen them so they need to be finalized.
1755                          */
1756                         if (!cand_cdr->party_b.snapshot) {
1757                                 cdr_object_finalize(cand_cdr);
1758                         }
1759                         success = 1;
1760                         break;
1761                 }
1762                 ao2_unlock(cand_cdr_master);
1763         }
1764         ao2_iterator_destroy(&it_cdrs);
1765
1766         /* We always transition state, even if we didn't get a peer */
1767         cdr_object_transition_state(cdr, &bridge_state_fn_table);
1768
1769         /* Success implies that we have a Party B */
1770         if (success) {
1771                 return BRIDGE_ENTER_OBTAINED_PARTY_B;
1772         }
1773         return BRIDGE_ENTER_NO_PARTY_B;
1774 }
1775
1776 /* DIALED PENDING STATE */
1777
1778 static int dialed_pending_state_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1779 {
1780         /* If we get a CEP change, we're executing dialplan. If we have a Party B
1781          * that means we need a new CDR; otherwise, switch us over to single.
1782          */
1783         if (snapshot_cep_changed(cdr->party_a.snapshot, snapshot)) {
1784                 if (cdr->party_b.snapshot) {
1785                         cdr_object_transition_state(cdr, &finalized_state_fn_table);
1786                         cdr->fn_table->process_party_a(cdr, snapshot);
1787                         return 1;
1788                 } else {
1789                         cdr_object_transition_state(cdr, &single_state_fn_table);
1790                         cdr->fn_table->process_party_a(cdr, snapshot);
1791                         return 0;
1792                 }
1793         }
1794         base_process_party_a(cdr, snapshot);
1795         return 0;
1796 }
1797
1798 static enum process_bridge_enter_results dialed_pending_state_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1799 {
1800         cdr_object_transition_state(cdr, &dial_state_fn_table);
1801         return cdr->fn_table->process_bridge_enter(cdr, bridge, channel);
1802 }
1803
1804 static int dialed_pending_state_process_parking_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1805 {
1806         if (cdr->party_b.snapshot) {
1807                 /* We can't handle this as we have a Party B - ask for a new one */
1808                 return 1;
1809         }
1810         cdr_object_transition_state(cdr, &parked_state_fn_table);
1811         return 0;
1812 }
1813
1814 static int dialed_pending_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
1815 {
1816         cdr_object_transition_state(cdr, &finalized_state_fn_table);
1817
1818         /* Ask for a new CDR */
1819         return 1;
1820 }
1821
1822 /* BRIDGE STATE */
1823
1824 static void bridge_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1825 {
1826         if (!cdr->party_b.snapshot
1827                 || strcasecmp(cdr->party_b.snapshot->name, snapshot->name)) {
1828                 return;
1829         }
1830         cdr_object_swap_snapshot(&cdr->party_b, snapshot);
1831
1832         /* If party B hangs up, finalize this CDR */
1833         if (ast_test_flag(&cdr->party_b.snapshot->flags, AST_FLAG_DEAD)) {
1834                 cdr_object_transition_state(cdr, &finalized_state_fn_table);
1835         }
1836 }
1837
1838 static int bridge_state_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1839 {
1840         if (strcmp(cdr->bridge, bridge->uniqueid)) {
1841                 return 1;
1842         }
1843         if (strcasecmp(cdr->party_a.snapshot->name, channel->name)
1844                 && cdr->party_b.snapshot
1845                 && strcasecmp(cdr->party_b.snapshot->name, channel->name)) {
1846                 return 1;
1847         }
1848         cdr_object_transition_state(cdr, &finalized_state_fn_table);
1849
1850         return 0;
1851 }
1852
1853 /* PARKED STATE */
1854
1855 static int parked_state_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1856 {
1857         if (strcasecmp(cdr->party_a.snapshot->name, channel->name)) {
1858                 return 1;
1859         }
1860         cdr_object_transition_state(cdr, &finalized_state_fn_table);
1861
1862         return 0;
1863 }
1864
1865 /* FINALIZED STATE */
1866
1867 static void finalized_state_init_function(struct cdr_object *cdr)
1868 {
1869         cdr_object_finalize(cdr);
1870 }
1871
1872 static int finalized_state_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1873 {
1874         RAII_VAR(struct module_config *, mod_cfg,
1875                 ao2_global_obj_ref(module_configs), ao2_cleanup);
1876
1877         if (ast_test_flag(&snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
1878                         && ast_test_flag(&mod_cfg->general->settings, CDR_END_BEFORE_H_EXTEN)) {
1879                 return 0;
1880         }
1881
1882         /* Indicate that, if possible, we should get a new CDR */
1883         return 1;
1884 }
1885
1886 /*!
1887  * \internal
1888  * \brief Filter channel snapshots by technology
1889  */
1890 static int filter_channel_snapshot(struct ast_channel_snapshot *snapshot)
1891 {
1892         return snapshot->tech_properties & AST_CHAN_TP_INTERNAL;
1893 }
1894
1895 /*!
1896  * \internal
1897  * \brief Filter a channel cache update
1898  */
1899 static int filter_channel_cache_message(struct ast_channel_snapshot *old_snapshot,
1900                 struct ast_channel_snapshot *new_snapshot)
1901 {
1902         int ret = 0;
1903
1904         /* Drop cache updates from certain channel technologies */
1905         if (old_snapshot) {
1906                 ret |= filter_channel_snapshot(old_snapshot);
1907         }
1908         if (new_snapshot) {
1909                 ret |= filter_channel_snapshot(new_snapshot);
1910         }
1911
1912         return ret;
1913 }
1914
1915 static int dial_status_end(const char *dialstatus)
1916 {
1917         return (strcmp(dialstatus, "RINGING") &&
1918                         strcmp(dialstatus, "PROCEEDING") &&
1919                         strcmp(dialstatus, "PROGRESS"));
1920 }
1921
1922 /* TOPIC ROUTER CALLBACKS */
1923
1924 /*!
1925  * \brief Handler for Stasis-Core dial messages
1926  * \param data Passed on
1927  * \param sub The stasis subscription for this message callback
1928  * \param topic The topic this message was published for
1929  * \param message The message
1930  */
1931 static void handle_dial_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
1932 {
1933         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1934         RAII_VAR(struct cdr_object *, cdr, NULL, ao2_cleanup);
1935         struct ast_multi_channel_blob *payload = stasis_message_data(message);
1936         struct ast_channel_snapshot *caller;
1937         struct ast_channel_snapshot *peer;
1938         struct cdr_object *it_cdr;
1939         struct ast_json *dial_status_blob;
1940         const char *dial_status = NULL;
1941         int res = 1;
1942
1943         caller = ast_multi_channel_blob_get_channel(payload, "caller");
1944         peer = ast_multi_channel_blob_get_channel(payload, "peer");
1945         if (!peer && !caller) {
1946                 return;
1947         }
1948         dial_status_blob = ast_json_object_get(ast_multi_channel_blob_get_json(payload), "dialstatus");
1949         if (dial_status_blob) {
1950                 dial_status = ast_json_string_get(dial_status_blob);
1951         }
1952
1953         CDR_DEBUG(mod_cfg, "Dial %s message for %s, %s: %u.%08u\n",
1954                         ast_strlen_zero(dial_status) ? "Begin" : "End",
1955                         caller ? caller->name : "(none)",
1956                         peer ? peer->name : "(none)",
1957                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
1958                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
1959
1960         if (filter_channel_snapshot(peer) || (caller && filter_channel_snapshot(caller))) {
1961                 return;
1962         }
1963
1964         /* Figure out who is running this show */
1965         if (caller) {
1966                 cdr = ao2_find(active_cdrs_by_channel, caller->uniqueid, OBJ_SEARCH_KEY);
1967         } else {
1968                 cdr = ao2_find(active_cdrs_by_channel, peer->uniqueid, OBJ_SEARCH_KEY);
1969         }
1970
1971         if (!cdr) {
1972                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", caller ? caller->name : peer->name);
1973                 ast_assert(0);
1974                 return;
1975         }
1976
1977         ao2_lock(cdr);
1978         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
1979                 if (ast_strlen_zero(dial_status)) {
1980                         if (!it_cdr->fn_table->process_dial_begin) {
1981                                 continue;
1982                         }
1983                         CDR_DEBUG(mod_cfg, "%p - Processing Dial Begin message for channel %s, peer %s\n",
1984                                         it_cdr,
1985                                         caller ? caller->name : "(none)",
1986                                         peer ? peer->name : "(none)");
1987                         res &= it_cdr->fn_table->process_dial_begin(it_cdr,
1988                                         caller,
1989                                         peer);
1990                 } else if (dial_status_end(dial_status)) {
1991                         if (!it_cdr->fn_table->process_dial_end) {
1992                                 continue;
1993                         }
1994                         CDR_DEBUG(mod_cfg, "%p - Processing Dial End message for channel %s, peer %s\n",
1995                                         it_cdr,
1996                                         caller ? caller->name : "(none)",
1997                                         peer ? peer->name : "(none)");
1998                         it_cdr->fn_table->process_dial_end(it_cdr,
1999                                         caller,
2000                                         peer,
2001                                         dial_status);
2002                 }
2003         }
2004
2005         /* If no CDR handled a dial begin message, make a new one */
2006         if (res && ast_strlen_zero(dial_status)) {
2007                 struct cdr_object *new_cdr;
2008
2009                 new_cdr = cdr_object_create_and_append(cdr);
2010                 if (!new_cdr) {
2011                         ao2_unlock(cdr);
2012                         return;
2013                 }
2014                 new_cdr->fn_table->process_dial_begin(new_cdr,
2015                                 caller,
2016                                 peer);
2017         }
2018         ao2_unlock(cdr);
2019 }
2020
2021 static int cdr_object_finalize_party_b(void *obj, void *arg, int flags)
2022 {
2023         struct cdr_object *cdr = obj;
2024         struct ast_channel_snapshot *party_b = arg;
2025         struct cdr_object *it_cdr;
2026         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2027                 if (it_cdr->party_b.snapshot
2028                         && !strcasecmp(it_cdr->party_b.snapshot->name, party_b->name)) {
2029                         /* Don't transition to the finalized state - let the Party A do
2030                          * that when its ready
2031                          */
2032                         cdr_object_finalize(it_cdr);
2033                 }
2034         }
2035         return 0;
2036 }
2037
2038 static int cdr_object_update_party_b(void *obj, void *arg, int flags)
2039 {
2040         struct cdr_object *cdr = obj;
2041         struct ast_channel_snapshot *party_b = arg;
2042         struct cdr_object *it_cdr;
2043         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2044                 if (!it_cdr->fn_table->process_party_b) {
2045                         continue;
2046                 }
2047                 if (it_cdr->party_b.snapshot
2048                         && !strcasecmp(it_cdr->party_b.snapshot->name, party_b->name)) {
2049                         it_cdr->fn_table->process_party_b(it_cdr, party_b);
2050                 }
2051         }
2052         return 0;
2053 }
2054
2055 /*! \brief Determine if we need to add a new CDR based on snapshots */
2056 static int check_new_cdr_needed(struct ast_channel_snapshot *old_snapshot,
2057                 struct ast_channel_snapshot *new_snapshot)
2058 {
2059         RAII_VAR(struct module_config *, mod_cfg,
2060                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2061
2062         /* If we're dead, we don't need a new CDR */
2063         if (!new_snapshot
2064                 || (ast_test_flag(&new_snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)
2065                         && ast_test_flag(&mod_cfg->general->settings, CDR_END_BEFORE_H_EXTEN))) {
2066                 return 0;
2067         }
2068
2069         /* Auto-fall through will increment the priority but have no application */
2070         if (ast_strlen_zero(new_snapshot->appl)) {
2071                 return 0;
2072         }
2073
2074         if (old_snapshot && !snapshot_cep_changed(old_snapshot, new_snapshot)) {
2075                 return 0;
2076         }
2077
2078         return 1;
2079 }
2080
2081 /*!
2082  * \brief Handler for Stasis-Core channel cache update messages
2083  * \param data Passed on
2084  * \param sub The stasis subscription for this message callback
2085  * \param topic The topic this message was published for
2086  * \param message The message
2087  */
2088 static void handle_channel_cache_message(void *data, struct stasis_subscription *sub, struct stasis_message *message)
2089 {
2090         RAII_VAR(struct cdr_object *, cdr, NULL, ao2_cleanup);
2091         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
2092         struct stasis_cache_update *update = stasis_message_data(message);
2093         struct ast_channel_snapshot *old_snapshot;
2094         struct ast_channel_snapshot *new_snapshot;
2095         const char *uniqueid;
2096         const char *name;
2097         struct cdr_object *it_cdr;
2098
2099         ast_assert(update != NULL);
2100         ast_assert(ast_channel_snapshot_type() == update->type);
2101
2102         old_snapshot = stasis_message_data(update->old_snapshot);
2103         new_snapshot = stasis_message_data(update->new_snapshot);
2104         uniqueid = new_snapshot ? new_snapshot->uniqueid : old_snapshot->uniqueid;
2105         name = new_snapshot ? new_snapshot->name : old_snapshot->name;
2106
2107         if (filter_channel_cache_message(old_snapshot, new_snapshot)) {
2108                 return;
2109         }
2110
2111         if (new_snapshot && !old_snapshot) {
2112                 cdr = cdr_object_alloc(new_snapshot);
2113                 if (!cdr) {
2114                         return;
2115                 }
2116                 cdr->is_root = 1;
2117                 ao2_link(active_cdrs_by_channel, cdr);
2118         }
2119
2120         /* Handle Party A */
2121         if (!cdr) {
2122                 cdr = ao2_find(active_cdrs_by_channel, uniqueid, OBJ_SEARCH_KEY);
2123         }
2124         if (!cdr) {
2125                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", name);
2126                 ast_assert(0);
2127         } else {
2128                 ao2_lock(cdr);
2129                 if (new_snapshot) {
2130                         int all_reject = 1;
2131                         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2132                                 if (!it_cdr->fn_table->process_party_a) {
2133                                         continue;
2134                                 }
2135                                 all_reject &= it_cdr->fn_table->process_party_a(it_cdr, new_snapshot);
2136                         }
2137                         if (all_reject && check_new_cdr_needed(old_snapshot, new_snapshot)) {
2138                                 /* We're not hung up and we have a new snapshot - we need a new CDR */
2139                                 struct cdr_object *new_cdr;
2140                                 new_cdr = cdr_object_create_and_append(cdr);
2141                                 if (new_cdr) {
2142                                         new_cdr->fn_table->process_party_a(new_cdr, new_snapshot);
2143                                 }
2144                         }
2145                 } else {
2146                         CDR_DEBUG(mod_cfg, "%p - Beginning finalize/dispatch for %s\n", cdr, old_snapshot->name);
2147                         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2148                                 cdr_object_finalize(it_cdr);
2149                         }
2150                         cdr_object_dispatch(cdr);
2151                         ao2_unlink(active_cdrs_by_channel, cdr);
2152                 }
2153                 ao2_unlock(cdr);
2154         }
2155
2156         /* Handle Party B */
2157         if (new_snapshot) {
2158                 ao2_callback(active_cdrs_by_channel, OBJ_NODATA, cdr_object_update_party_b,
2159                         new_snapshot);
2160         } else {
2161                 ao2_callback(active_cdrs_by_channel, OBJ_NODATA, cdr_object_finalize_party_b,
2162                         old_snapshot);
2163         }
2164
2165 }
2166
2167 struct bridge_leave_data {
2168         struct ast_bridge_snapshot *bridge;
2169         struct ast_channel_snapshot *channel;
2170 };
2171
2172 /*! \brief Callback used to notify CDRs of a Party B leaving the bridge */
2173 static int cdr_object_party_b_left_bridge_cb(void *obj, void *arg, int flags)
2174 {
2175         struct cdr_object *cdr = obj;
2176         struct bridge_leave_data *leave_data = arg;
2177         struct cdr_object *it_cdr;
2178
2179         if (strcmp(cdr->bridge, leave_data->bridge->uniqueid)) {
2180                 return 0;
2181         }
2182         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2183                 if (it_cdr->fn_table != &bridge_state_fn_table) {
2184                         continue;
2185                 }
2186                 if (!it_cdr->party_b.snapshot) {
2187                         continue;
2188                 }
2189                 if (strcasecmp(it_cdr->party_b.snapshot->name, leave_data->channel->name)) {
2190                         continue;
2191                 }
2192                 /* It is our Party B, in our bridge. Set the end time and let the handler
2193                  * transition our CDR appropriately when we leave the bridge.
2194                  */
2195                 cdr_object_finalize(it_cdr);
2196         }
2197         return 0;
2198 }
2199
2200 /*! \brief Filter bridge messages based on bridge technology */
2201 static int filter_bridge_messages(struct ast_bridge_snapshot *bridge)
2202 {
2203         /* Ignore holding bridge technology messages. We treat this simply as an application
2204          * that a channel enters into.
2205          */
2206         if (!strcmp(bridge->technology, "holding_bridge") && strcmp(bridge->subclass, "parking")) {
2207                 return 1;
2208         }
2209         return 0;
2210 }
2211
2212 /*!
2213  * \brief Handler for when a channel leaves a bridge
2214  * \param data Passed on
2215  * \param sub The stasis subscription for this message callback
2216  * \param topic The topic this message was published for
2217  * \param message The message - hopefully a bridge one!
2218  */
2219 static void handle_bridge_leave_message(void *data, struct stasis_subscription *sub,
2220                 struct stasis_message *message)
2221 {
2222         struct ast_bridge_blob *update = stasis_message_data(message);
2223         struct ast_bridge_snapshot *bridge = update->bridge;
2224         struct ast_channel_snapshot *channel = update->channel;
2225         RAII_VAR(struct module_config *, mod_cfg,
2226                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2227         RAII_VAR(struct cdr_object *, cdr,
2228                         ao2_find(active_cdrs_by_channel, channel->uniqueid, OBJ_SEARCH_KEY),
2229                         ao2_cleanup);
2230         struct cdr_object *it_cdr;
2231         struct bridge_leave_data leave_data = {
2232                 .bridge = bridge,
2233                 .channel = channel,
2234         };
2235         int left_bridge = 0;
2236
2237         if (filter_bridge_messages(bridge)) {
2238                 return;
2239         }
2240
2241         if (filter_channel_snapshot(channel)) {
2242                 return;
2243         }
2244
2245         CDR_DEBUG(mod_cfg, "Bridge Leave message for %s: %u.%08u\n",
2246                         channel->name,
2247                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
2248                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
2249
2250         if (!cdr) {
2251                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->name);
2252                 ast_assert(0);
2253                 return;
2254         }
2255
2256         /* Party A */
2257         ao2_lock(cdr);
2258         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2259                 if (!it_cdr->fn_table->process_bridge_leave) {
2260                         continue;
2261                 }
2262                 CDR_DEBUG(mod_cfg, "%p - Processing Bridge Leave for %s\n",
2263                                 it_cdr, channel->name);
2264                 if (!it_cdr->fn_table->process_bridge_leave(it_cdr, bridge, channel)) {
2265                         ast_string_field_set(it_cdr, bridge, "");
2266                         left_bridge = 1;
2267                 }
2268         }
2269         ao2_unlock(cdr);
2270         if (!left_bridge) {
2271                 return;
2272         }
2273
2274         if (strcmp(bridge->subclass, "parking")) {
2275                 /* Party B */
2276                 ao2_callback(active_cdrs_by_channel, OBJ_NODATA,
2277                                 cdr_object_party_b_left_bridge_cb,
2278                                 &leave_data);
2279         }
2280 }
2281
2282 /*!
2283  * \internal
2284  * \brief Create a new CDR, append it to an existing CDR, and update its snapshots
2285  *
2286  * \note The new CDR will be automatically transitioned to the bridge state
2287  */
2288 static void bridge_candidate_add_to_cdr(struct cdr_object *cdr,
2289                 struct cdr_object_snapshot *party_b)
2290 {
2291         RAII_VAR(struct module_config *,  mod_cfg,
2292                 ao2_global_obj_ref(module_configs), ao2_cleanup);
2293         struct cdr_object *new_cdr;
2294
2295         new_cdr = cdr_object_create_and_append(cdr);
2296         if (!new_cdr) {
2297                 return;
2298         }
2299         cdr_object_snapshot_copy(&new_cdr->party_b, party_b);
2300         cdr_object_check_party_a_answer(new_cdr);
2301         ast_string_field_set(new_cdr, bridge, cdr->bridge);
2302         cdr_object_transition_state(new_cdr, &bridge_state_fn_table);
2303         CDR_DEBUG(mod_cfg, "%p - Party A %s has new Party B %s\n",
2304                 new_cdr, new_cdr->party_a.snapshot->name,
2305                 party_b->snapshot->name);
2306 }
2307
2308 /*!
2309  * \brief Process a single \ref bridge_candidate
2310  *
2311  * When a CDR enters a bridge, it needs to make pairings with everyone else
2312  * that it is not currently paired with. This function determines, for the
2313  * CDR for the channel that entered the bridge and the CDR for every other
2314  * channel currently in the bridge, who is Party A and makes new CDRs.
2315  *
2316  * \param cdr The \ref cdr_obj being processed
2317  * \param cand_cdr The \ref cdr_object that is a candidate
2318  *
2319  */
2320 static int bridge_candidate_process(struct cdr_object *cdr, struct cdr_object *base_cand_cdr)
2321 {
2322         RAII_VAR(struct module_config *, mod_cfg,
2323                 ao2_global_obj_ref(module_configs), ao2_cleanup);
2324         struct cdr_object_snapshot *party_a;
2325         struct cdr_object *cand_cdr;
2326
2327         SCOPED_AO2LOCK(lock, base_cand_cdr);
2328
2329         for (cand_cdr = base_cand_cdr; cand_cdr; cand_cdr = cand_cdr->next) {
2330                 /* Skip any records that are not in this bridge */
2331                 if (strcmp(cand_cdr->bridge, cdr->bridge)) {
2332                         continue;
2333                 }
2334
2335                 /* If the candidate is us or someone we've taken on, pass on by */
2336                 if (!strcasecmp(cdr->party_a.snapshot->name, cand_cdr->party_a.snapshot->name)
2337                         || (cdr->party_b.snapshot
2338                                 && !strcasecmp(cdr->party_b.snapshot->name, cand_cdr->party_a.snapshot->name))) {
2339                         return 0;
2340                 }
2341
2342                 party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_a);
2343                 /* We're party A - make a new CDR, append it to us, and set the candidate as
2344                  * Party B */
2345                 if (!strcasecmp(party_a->snapshot->name, cdr->party_a.snapshot->name)) {
2346                         bridge_candidate_add_to_cdr(cdr, &cand_cdr->party_a);
2347                         return 0;
2348                 }
2349
2350                 /* We're Party B. Check if we can add ourselves immediately or if we need
2351                  * a new CDR for them (they already have a Party B) */
2352                 if (cand_cdr->party_b.snapshot
2353                         && strcasecmp(cand_cdr->party_b.snapshot->name, cdr->party_a.snapshot->name)) {
2354                         bridge_candidate_add_to_cdr(cand_cdr, &cdr->party_a);
2355                 } else {
2356                         CDR_DEBUG(mod_cfg, "%p - Party A %s has new Party B %s\n",
2357                                 cand_cdr, cand_cdr->party_a.snapshot->name,
2358                                 cdr->party_a.snapshot->name);
2359                         cdr_object_snapshot_copy(&cand_cdr->party_b, &cdr->party_a);
2360                         /* It's possible that this joined at one point and was never chosen
2361                          * as party A. Clear their end time, as it would be set in such a
2362                          * case.
2363                          */
2364                         memset(&cand_cdr->end, 0, sizeof(cand_cdr->end));
2365                 }
2366                 return 0;
2367         }
2368         return 0;
2369 }
2370
2371 /*!
2372  * \brief Handle creating bridge pairings for the \ref cdr_object that just
2373  * entered a bridge
2374  * \param cdr The \ref cdr_object that just entered the bridge
2375  * \param bridge The \ref ast_bridge_snapshot representing the bridge it just entered
2376  */
2377 static void handle_bridge_pairings(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge)
2378 {
2379         struct ao2_iterator it_channels;
2380         char *channel_id;
2381
2382         it_channels = ao2_iterator_init(bridge->channels, 0);
2383         while ((channel_id = ao2_iterator_next(&it_channels))) {
2384                 RAII_VAR(struct cdr_object *, cand_cdr,
2385                         ao2_find(active_cdrs_by_channel, channel_id, OBJ_SEARCH_KEY),
2386                         ao2_cleanup);
2387
2388                 if (!cand_cdr) {
2389                         ao2_ref(channel_id, -1);
2390                         continue;
2391                 }
2392
2393                 bridge_candidate_process(cdr, cand_cdr);
2394
2395                 ao2_ref(channel_id, -1);
2396         }
2397         ao2_iterator_destroy(&it_channels);
2398 }
2399
2400 /*! \brief Handle entering into a parking bridge
2401  * \param cdr The CDR to operate on
2402  * \param bridge The bridge the channel just entered
2403  * \param channel The channel snapshot
2404  */
2405 static void handle_parking_bridge_enter_message(struct cdr_object *cdr,
2406                 struct ast_bridge_snapshot *bridge,
2407                 struct ast_channel_snapshot *channel)
2408 {
2409         RAII_VAR(struct module_config *, mod_cfg,
2410                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2411         int res = 1;
2412         struct cdr_object *it_cdr;
2413         struct cdr_object *new_cdr;
2414
2415         ao2_lock(cdr);
2416
2417         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2418                 if (it_cdr->fn_table->process_parking_bridge_enter) {
2419                         res &= it_cdr->fn_table->process_parking_bridge_enter(it_cdr, bridge, channel);
2420                 }
2421                 if (it_cdr->fn_table->process_party_a) {
2422                         CDR_DEBUG(mod_cfg, "%p - Updating Party A %s snapshot\n", it_cdr,
2423                                         channel->name);
2424                         it_cdr->fn_table->process_party_a(it_cdr, channel);
2425                 }
2426         }
2427
2428         if (res) {
2429                 /* No one handled it - we need a new one! */
2430                 new_cdr = cdr_object_create_and_append(cdr);
2431                 if (new_cdr) {
2432                         /* Let the single state transition us to Parked */
2433                         cdr_object_transition_state(new_cdr, &single_state_fn_table);
2434                         new_cdr->fn_table->process_parking_bridge_enter(new_cdr, bridge, channel);
2435                 }
2436         }
2437         ao2_unlock(cdr);
2438 }
2439
2440 /*! \brief Handle a bridge enter message for a 'normal' bridge
2441  * \param cdr The CDR to operate on
2442  * \param bridge The bridge the channel just entered
2443  * \param channel The channel snapshot
2444  */
2445 static void handle_standard_bridge_enter_message(struct cdr_object *cdr,
2446                 struct ast_bridge_snapshot *bridge,
2447                 struct ast_channel_snapshot *channel)
2448 {
2449         RAII_VAR(struct module_config *, mod_cfg,
2450                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2451         enum process_bridge_enter_results result;
2452         struct cdr_object *it_cdr;
2453         struct cdr_object *new_cdr;
2454         struct cdr_object *handled_cdr = NULL;
2455
2456         ao2_lock(cdr);
2457
2458         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2459                 if (it_cdr->fn_table->process_party_a) {
2460                         CDR_DEBUG(mod_cfg, "%p - Updating Party A %s snapshot\n", it_cdr,
2461                                         channel->name);
2462                         it_cdr->fn_table->process_party_a(it_cdr, channel);
2463                 }
2464
2465                 /* Notify all states that they have entered a bridge */
2466                 if (it_cdr->fn_table->process_bridge_enter) {
2467                         CDR_DEBUG(mod_cfg, "%p - Processing bridge enter for %s\n", it_cdr,
2468                                         channel->name);
2469                         result = it_cdr->fn_table->process_bridge_enter(it_cdr, bridge, channel);
2470                         switch (result) {
2471                         case BRIDGE_ENTER_ONLY_PARTY:
2472                                 /* Fall through */
2473                         case BRIDGE_ENTER_OBTAINED_PARTY_B:
2474                                 if (!handled_cdr) {
2475                                         handled_cdr = it_cdr;
2476                                 }
2477                                 break;
2478                         case BRIDGE_ENTER_NEED_CDR:
2479                                 /* Pass */
2480                                 break;
2481                         case BRIDGE_ENTER_NO_PARTY_B:
2482                                 /* We didn't win on any - end this CDR. If someone else comes in later
2483                                  * that is Party B to this CDR, it can re-activate this CDR.
2484                                  */
2485                                 if (!handled_cdr) {
2486                                         handled_cdr = it_cdr;
2487                                 }
2488                                 cdr_object_finalize(cdr);
2489                                 break;
2490                         }
2491                 }
2492         }
2493
2494         /* Create the new matchings, but only for either:
2495          *  * The first CDR in the chain that handled it. This avoids issues with
2496          *    forked CDRs.
2497          *  * If no one handled it, the last CDR in the chain. This would occur if
2498          *    a CDR joined a bridge and it wasn't Party A for anyone. We still need
2499          *    to make pairings with everyone in the bridge.
2500          */
2501         if (handled_cdr) {
2502                 handle_bridge_pairings(handled_cdr, bridge);
2503         } else {
2504                 /* Nothing handled it - we need a new one! */
2505                 new_cdr = cdr_object_create_and_append(cdr);
2506                 if (new_cdr) {
2507                         /* This is guaranteed to succeed: the new CDR is created in the single state
2508                          * and will be able to handle the bridge enter message
2509                          */
2510                         handle_standard_bridge_enter_message(cdr, bridge, channel);
2511                 }
2512         }
2513         ao2_unlock(cdr);
2514 }
2515
2516 /*!
2517  * \internal
2518  * \brief Handler for Stasis-Core bridge enter messages
2519  * \param data Passed on
2520  * \param sub The stasis subscription for this message callback
2521  * \param topic The topic this message was published for
2522  * \param message The message - hopefully a bridge one!
2523  */
2524 static void handle_bridge_enter_message(void *data, struct stasis_subscription *sub,
2525                 struct stasis_message *message)
2526 {
2527         struct ast_bridge_blob *update = stasis_message_data(message);
2528         struct ast_bridge_snapshot *bridge = update->bridge;
2529         struct ast_channel_snapshot *channel = update->channel;
2530         RAII_VAR(struct cdr_object *, cdr,
2531                         ao2_find(active_cdrs_by_channel, channel->uniqueid, OBJ_SEARCH_KEY),
2532                         ao2_cleanup);
2533         RAII_VAR(struct module_config *, mod_cfg,
2534                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2535
2536         if (filter_bridge_messages(bridge)) {
2537                 return;
2538         }
2539
2540         if (filter_channel_snapshot(channel)) {
2541                 return;
2542         }
2543
2544         CDR_DEBUG(mod_cfg, "Bridge Enter message for channel %s: %u.%08u\n",
2545                         channel->name,
2546                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
2547                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
2548
2549         if (!cdr) {
2550                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->name);
2551                 ast_assert(0);
2552                 return;
2553         }
2554
2555         if (!strcmp(bridge->subclass, "parking")) {
2556                 handle_parking_bridge_enter_message(cdr, bridge, channel);
2557         } else {
2558                 handle_standard_bridge_enter_message(cdr, bridge, channel);
2559         }
2560 }
2561
2562 /*!
2563  * \brief Handler for when a channel is parked
2564  * \param data Passed on
2565  * \param sub The stasis subscription for this message callback
2566  * \param topic The topic this message was published for
2567  * \param message The message about who got parked
2568  * */
2569 static void handle_parked_call_message(void *data, struct stasis_subscription *sub,
2570                 struct stasis_message *message)
2571 {
2572         struct ast_parked_call_payload *payload = stasis_message_data(message);
2573         struct ast_channel_snapshot *channel = payload->parkee;
2574         RAII_VAR(struct cdr_object *, cdr, NULL, ao2_cleanup);
2575         RAII_VAR(struct module_config *, mod_cfg,
2576                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2577         int unhandled = 1;
2578         struct cdr_object *it_cdr;
2579
2580         /* Anything other than getting parked will be handled by other updates */
2581         if (payload->event_type != PARKED_CALL) {
2582                 return;
2583         }
2584
2585         /* No one got parked? */
2586         if (!channel) {
2587                 return;
2588         }
2589
2590         if (filter_channel_snapshot(channel)) {
2591                 return;
2592         }
2593
2594         CDR_DEBUG(mod_cfg, "Parked Call message for channel %s: %u.%08u\n",
2595                         channel->name,
2596                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
2597                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
2598
2599         cdr = ao2_find(active_cdrs_by_channel, channel->uniqueid, OBJ_SEARCH_KEY);
2600         if (!cdr) {
2601                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->name);
2602                 ast_assert(0);
2603                 return;
2604         }
2605
2606         ao2_lock(cdr);
2607
2608         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2609                 if (it_cdr->fn_table->process_parked_channel) {
2610                         unhandled &= it_cdr->fn_table->process_parked_channel(it_cdr, payload);
2611                 }
2612         }
2613
2614         if (unhandled) {
2615                 /* Nothing handled the messgae - we need a new one! */
2616                 struct cdr_object *new_cdr = cdr_object_create_and_append(cdr);
2617                 if (new_cdr) {
2618                         /* As the new CDR is created in the single state, it is guaranteed
2619                          * to have a function for the parked call message and will handle
2620                          * the message */
2621                         new_cdr->fn_table->process_parked_channel(new_cdr, payload);
2622                 }
2623         }
2624
2625         ao2_unlock(cdr);
2626
2627 }
2628
2629 /*!
2630  * \brief Handler for a synchronization message
2631  * \param data Passed on
2632  * \param sub The stasis subscription for this message callback
2633  * \param topic The topic this message was published for
2634  * \param message A blank ao2 object
2635  * */
2636 static void handle_cdr_sync_message(void *data, struct stasis_subscription *sub,
2637                 struct stasis_message *message)
2638 {
2639         return;
2640 }
2641
2642 struct ast_cdr_config *ast_cdr_get_config(void)
2643 {
2644         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
2645         ao2_ref(mod_cfg->general, +1);
2646         return mod_cfg->general;
2647 }
2648
2649 void ast_cdr_set_config(struct ast_cdr_config *config)
2650 {
2651         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
2652
2653         ao2_cleanup(mod_cfg->general);
2654         mod_cfg->general = config;
2655         ao2_ref(mod_cfg->general, +1);
2656
2657         cdr_toggle_runtime_options();
2658 }
2659
2660 int ast_cdr_is_enabled(void)
2661 {
2662         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
2663         return ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED);
2664 }
2665
2666 int ast_cdr_backend_suspend(const char *name)
2667 {
2668         int success = -1;
2669         struct cdr_beitem *i = NULL;
2670
2671         AST_RWLIST_WRLOCK(&be_list);
2672         AST_RWLIST_TRAVERSE(&be_list, i, list) {
2673                 if (!strcasecmp(name, i->name)) {
2674                         ast_debug(3, "Suspending CDR backend %s\n", i->name);
2675                         i->suspended = 1;
2676                         success = 0;
2677                 }
2678         }
2679         AST_RWLIST_UNLOCK(&be_list);
2680
2681         return success;
2682 }
2683
2684 int ast_cdr_backend_unsuspend(const char *name)
2685 {
2686         int success = -1;
2687         struct cdr_beitem *i = NULL;
2688
2689         AST_RWLIST_WRLOCK(&be_list);
2690         AST_RWLIST_TRAVERSE(&be_list, i, list) {
2691                 if (!strcasecmp(name, i->name)) {
2692                         ast_debug(3, "Unsuspending CDR backend %s\n", i->name);
2693                         i->suspended = 0;
2694                         success = 0;
2695                 }
2696         }
2697         AST_RWLIST_UNLOCK(&be_list);
2698
2699         return success;
2700 }
2701
2702 static int cdr_generic_register(struct be_list *generic_list, const char *name, const char *desc, ast_cdrbe be)
2703 {
2704         struct cdr_beitem *i = NULL;
2705
2706         if (!name)
2707                 return -1;
2708
2709         if (!be) {
2710                 ast_log(LOG_WARNING, "CDR engine '%s' lacks backend\n", name);
2711                 return -1;
2712         }
2713
2714         AST_RWLIST_WRLOCK(generic_list);
2715         AST_RWLIST_TRAVERSE(generic_list, i, list) {
2716                 if (!strcasecmp(name, i->name)) {
2717                         ast_log(LOG_WARNING, "Already have a CDR backend called '%s'\n", name);
2718                         AST_RWLIST_UNLOCK(generic_list);
2719                         return -1;
2720                 }
2721         }
2722
2723         if (!(i = ast_calloc(1, sizeof(*i))))
2724                 return -1;
2725
2726         i->be = be;
2727         ast_copy_string(i->name, name, sizeof(i->name));
2728         ast_copy_string(i->desc, desc, sizeof(i->desc));
2729
2730         AST_RWLIST_INSERT_HEAD(generic_list, i, list);
2731         AST_RWLIST_UNLOCK(generic_list);
2732
2733         return 0;
2734 }
2735
2736 int ast_cdr_register(const char *name, const char *desc, ast_cdrbe be)
2737 {
2738         return cdr_generic_register(&be_list, name, desc, be);
2739 }
2740
2741 int ast_cdr_modifier_register(const char *name, const char *desc, ast_cdrbe be)
2742 {
2743         return cdr_generic_register((struct be_list *)&mo_list, name, desc, be);
2744 }
2745
2746 static int ast_cdr_generic_unregister(struct be_list *generic_list, const char *name)
2747 {
2748         struct cdr_beitem *match = NULL;
2749         int active_count;
2750
2751         AST_RWLIST_WRLOCK(generic_list);
2752         AST_RWLIST_TRAVERSE(generic_list, match, list) {
2753                 if (!strcasecmp(name, match->name)) {
2754                         break;
2755                 }
2756         }
2757
2758         if (!match) {
2759                 AST_RWLIST_UNLOCK(generic_list);
2760                 return 0;
2761         }
2762
2763         active_count = ao2_container_count(active_cdrs_by_channel);
2764
2765         if (!match->suspended && active_count != 0) {
2766                 AST_RWLIST_UNLOCK(generic_list);
2767                 ast_log(AST_LOG_WARNING, "Unable to unregister CDR backend %s; %d CDRs are still active\n",
2768                         name, active_count);
2769                 return -1;
2770         }
2771
2772         AST_RWLIST_REMOVE(generic_list, match, list);
2773         AST_RWLIST_UNLOCK(generic_list);
2774
2775         ast_verb(2, "Unregistered '%s' CDR backend\n", name);
2776         ast_free(match);
2777
2778         return 0;
2779 }
2780
2781 int ast_cdr_unregister(const char *name)
2782 {
2783         return ast_cdr_generic_unregister(&be_list, name);
2784 }
2785
2786 int ast_cdr_modifier_unregister(const char *name)
2787 {
2788         return ast_cdr_generic_unregister((struct be_list *)&mo_list, name);
2789 }
2790
2791 struct ast_cdr *ast_cdr_dup(struct ast_cdr *cdr)
2792 {
2793         struct ast_cdr *newcdr;
2794
2795         if (!cdr) {
2796                 return NULL;
2797         }
2798         newcdr = ast_cdr_alloc();
2799         if (!newcdr) {
2800                 return NULL;
2801         }
2802
2803         *newcdr = *cdr;
2804         AST_LIST_HEAD_INIT_NOLOCK(&newcdr->varshead);
2805         copy_variables(&newcdr->varshead, &cdr->varshead);
2806         newcdr->next = NULL;
2807
2808         return newcdr;
2809 }
2810
2811 static const char *cdr_format_var_internal(struct ast_cdr *cdr, const char *name)
2812 {
2813         struct ast_var_t *variables;
2814
2815         if (ast_strlen_zero(name)) {
2816                 return NULL;
2817         }
2818
2819         AST_LIST_TRAVERSE(&cdr->varshead, variables, entries) {
2820                 if (!strcasecmp(name, ast_var_name(variables))) {
2821                         return ast_var_value(variables);
2822                 }
2823         }
2824
2825         return NULL;
2826 }
2827
2828 static void cdr_get_tv(struct timeval when, const char *fmt, char *buf, int bufsize)
2829 {
2830         if (fmt == NULL) {      /* raw mode */
2831                 snprintf(buf, bufsize, "%ld.%06ld", (long)when.tv_sec, (long)when.tv_usec);
2832         } else {
2833                 buf[0] = '\0';/* Ensure the buffer is initialized. */
2834                 if (when.tv_sec) {
2835                         struct ast_tm tm;
2836
2837                         ast_localtime(&when, &tm, NULL);
2838                         ast_strftime(buf, bufsize, fmt, &tm);
2839                 }
2840         }
2841 }
2842
2843 void ast_cdr_format_var(struct ast_cdr *cdr, const char *name, char **ret, char *workspace, int workspacelen, int raw)
2844 {
2845         const char *fmt = "%Y-%m-%d %T";
2846         const char *varbuf;
2847
2848         if (!cdr) {
2849                 return;
2850         }
2851
2852         *ret = NULL;
2853
2854         if (!strcasecmp(name, "clid")) {
2855                 ast_copy_string(workspace, cdr->clid, workspacelen);
2856         } else if (!strcasecmp(name, "src")) {
2857                 ast_copy_string(workspace, cdr->src, workspacelen);
2858         } else if (!strcasecmp(name, "dst")) {
2859                 ast_copy_string(workspace, cdr->dst, workspacelen);
2860         } else if (!strcasecmp(name, "dcontext")) {
2861                 ast_copy_string(workspace, cdr->dcontext, workspacelen);
2862         } else if (!strcasecmp(name, "channel")) {
2863                 ast_copy_string(workspace, cdr->channel, workspacelen);
2864         } else if (!strcasecmp(name, "dstchannel")) {
2865                 ast_copy_string(workspace, cdr->dstchannel, workspacelen);
2866         } else if (!strcasecmp(name, "lastapp")) {
2867                 ast_copy_string(workspace, cdr->lastapp, workspacelen);
2868         } else if (!strcasecmp(name, "lastdata")) {
2869                 ast_copy_string(workspace, cdr->lastdata, workspacelen);
2870         } else if (!strcasecmp(name, "start")) {
2871                 cdr_get_tv(cdr->start, raw ? NULL : fmt, workspace, workspacelen);
2872         } else if (!strcasecmp(name, "answer")) {
2873                 cdr_get_tv(cdr->answer, raw ? NULL : fmt, workspace, workspacelen);
2874         } else if (!strcasecmp(name, "end")) {
2875                 cdr_get_tv(cdr->end, raw ? NULL : fmt, workspace, workspacelen);
2876         } else if (!strcasecmp(name, "duration")) {
2877                 snprintf(workspace, workspacelen, "%ld", cdr->end.tv_sec != 0 ? cdr->duration : (long)ast_tvdiff_ms(ast_tvnow(), cdr->start) / 1000);
2878         } else if (!strcasecmp(name, "billsec")) {
2879                 snprintf(workspace, workspacelen, "%ld", (cdr->billsec || !ast_tvzero(cdr->end) || ast_tvzero(cdr->answer)) ? cdr->billsec : (long)ast_tvdiff_ms(ast_tvnow(), cdr->answer) / 1000);
2880         } else if (!strcasecmp(name, "disposition")) {
2881                 if (raw) {
2882                         snprintf(workspace, workspacelen, "%ld", cdr->disposition);
2883                 } else {
2884                         ast_copy_string(workspace, ast_cdr_disp2str(cdr->disposition), workspacelen);
2885                 }
2886         } else if (!strcasecmp(name, "amaflags")) {
2887                 if (raw) {
2888                         snprintf(workspace, workspacelen, "%ld", cdr->amaflags);
2889                 } else {
2890                         ast_copy_string(workspace, ast_channel_amaflags2string(cdr->amaflags), workspacelen);
2891                 }
2892         } else if (!strcasecmp(name, "accountcode")) {
2893                 ast_copy_string(workspace, cdr->accountcode, workspacelen);
2894         } else if (!strcasecmp(name, "peeraccount")) {
2895                 ast_copy_string(workspace, cdr->peeraccount, workspacelen);
2896         } else if (!strcasecmp(name, "uniqueid")) {
2897                 ast_copy_string(workspace, cdr->uniqueid, workspacelen);
2898         } else if (!strcasecmp(name, "linkedid")) {
2899                 ast_copy_string(workspace, cdr->linkedid, workspacelen);
2900         } else if (!strcasecmp(name, "userfield")) {
2901                 ast_copy_string(workspace, cdr->userfield, workspacelen);
2902         } else if (!strcasecmp(name, "sequence")) {
2903                 snprintf(workspace, workspacelen, "%d", cdr->sequence);
2904         } else if ((varbuf = cdr_format_var_internal(cdr, name))) {
2905                 ast_copy_string(workspace, varbuf, workspacelen);
2906         } else {
2907                 workspace[0] = '\0';
2908         }
2909
2910         if (!ast_strlen_zero(workspace)) {
2911                 *ret = workspace;
2912         }
2913 }
2914
2915 /*
2916  * \internal
2917  * \brief Callback that finds all CDRs that reference a particular channel by name
2918  */
2919 static int cdr_object_select_all_by_name_cb(void *obj, void *arg, int flags)
2920 {
2921         struct cdr_object *cdr = obj;
2922         const char *name = arg;
2923
2924         if (!strcasecmp(cdr->party_a.snapshot->name, name) ||
2925                         (cdr->party_b.snapshot && !strcasecmp(cdr->party_b.snapshot->name, name))) {
2926                 return CMP_MATCH;
2927         }
2928         return 0;
2929 }
2930
2931 /*
2932  * \internal
2933  * \brief Callback that finds a CDR by channel name
2934  */
2935 static int cdr_object_get_by_name_cb(void *obj, void *arg, int flags)
2936 {
2937         struct cdr_object *cdr = obj;
2938         const char *name = arg;
2939
2940         if (!strcasecmp(cdr->party_a.snapshot->name, name)) {
2941                 return CMP_MATCH;
2942         }
2943         return 0;
2944 }
2945
2946 /* Read Only CDR variables */
2947 static const char * const cdr_readonly_vars[] = {
2948         "clid",
2949         "src",
2950         "dst",
2951         "dcontext",
2952         "channel",
2953         "dstchannel",
2954         "lastapp",
2955         "lastdata",
2956         "start",
2957         "answer",
2958         "end",
2959         "duration",
2960         "billsec",
2961         "disposition",
2962         "amaflags",
2963         "accountcode",
2964         "uniqueid",
2965         "linkedid",
2966         "userfield",
2967         "sequence",
2968         NULL
2969 };
2970
2971 int ast_cdr_setvar(const char *channel_name, const char *name, const char *value)
2972 {
2973         struct cdr_object *cdr;
2974         struct cdr_object *it_cdr;
2975         struct ao2_iterator *it_cdrs;
2976         char *arg = ast_strdupa(channel_name);
2977         int x;
2978
2979         for (x = 0; cdr_readonly_vars[x]; x++) {
2980                 if (!strcasecmp(name, cdr_readonly_vars[x])) {
2981                         ast_log(LOG_ERROR, "Attempt to set the '%s' read-only variable!\n", name);
2982                         return -1;
2983                 }
2984         }
2985
2986         it_cdrs = ao2_callback(active_cdrs_by_channel, OBJ_MULTIPLE, cdr_object_select_all_by_name_cb, arg);
2987         if (!it_cdrs) {
2988                 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
2989                 return -1;
2990         }
2991
2992         for (; (cdr = ao2_iterator_next(it_cdrs)); ao2_unlock(cdr), ao2_cleanup(cdr)) {
2993                 ao2_lock(cdr);
2994                 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2995                         struct varshead *headp = NULL;
2996
2997                         if (it_cdr->fn_table == &finalized_state_fn_table && it_cdr->next != NULL) {
2998                                 continue;
2999                         }
3000                         if (!strcasecmp(channel_name, it_cdr->party_a.snapshot->name)) {
3001                                 headp = &it_cdr->party_a.variables;
3002                         } else if (it_cdr->party_b.snapshot
3003                                 && !strcasecmp(channel_name, it_cdr->party_b.snapshot->name)) {
3004                                 headp = &it_cdr->party_b.variables;
3005                         }
3006                         if (headp) {
3007                                 set_variable(headp, name, value);
3008                         }
3009                 }
3010         }
3011         ao2_iterator_destroy(it_cdrs);
3012
3013         return 0;
3014 }
3015
3016 /*!
3017  * \brief Format a variable on a \ref cdr_object
3018  */
3019 static void cdr_object_format_var_internal(struct cdr_object *cdr, const char *name, char *value, size_t length)
3020 {
3021         struct ast_var_t *variable;
3022
3023         AST_LIST_TRAVERSE(&cdr->party_a.variables, variable, entries) {
3024                 if (!strcasecmp(name, ast_var_name(variable))) {
3025                         ast_copy_string(value, ast_var_value(variable), length);
3026                         return;
3027                 }
3028         }
3029
3030         *value = '\0';
3031 }
3032
3033 /*!
3034  * \brief Format one of the standard properties on a \ref cdr_object
3035  */
3036 static int cdr_object_format_property(struct cdr_object *cdr_obj, const char *name, char *value, size_t length)
3037 {
3038         struct ast_channel_snapshot *party_a = cdr_obj->party_a.snapshot;
3039         struct ast_channel_snapshot *party_b = cdr_obj->party_b.snapshot;
3040
3041         if (!strcasecmp(name, "clid")) {
3042                 ast_callerid_merge(value, length, party_a->caller_name, party_a->caller_number, "");
3043         } else if (!strcasecmp(name, "src")) {
3044                 ast_copy_string(value, party_a->caller_number, length);
3045         } else if (!strcasecmp(name, "dst")) {
3046                 ast_copy_string(value, party_a->exten, length);
3047         } else if (!strcasecmp(name, "dcontext")) {
3048                 ast_copy_string(value, party_a->context, length);
3049         } else if (!strcasecmp(name, "channel")) {
3050                 ast_copy_string(value, party_a->name, length);
3051         } else if (!strcasecmp(name, "dstchannel")) {
3052                 if (party_b) {
3053                         ast_copy_string(value, party_b->name, length);
3054                 } else {
3055                         ast_copy_string(value, "", length);
3056                 }
3057         } else if (!strcasecmp(name, "lastapp")) {
3058                 ast_copy_string(value, party_a->appl, length);
3059         } else if (!strcasecmp(name, "lastdata")) {
3060                 ast_copy_string(value, party_a->data, length);
3061         } else if (!strcasecmp(name, "start")) {
3062                 cdr_get_tv(cdr_obj->start, NULL, value, length);
3063         } else if (!strcasecmp(name, "answer")) {
3064                 cdr_get_tv(cdr_obj->answer, NULL, value, length);
3065         } else if (!strcasecmp(name, "end")) {
3066                 cdr_get_tv(cdr_obj->end, NULL, value, length);
3067         } else if (!strcasecmp(name, "duration")) {
3068                 snprintf(value, length, "%ld", cdr_object_get_duration(cdr_obj));
3069         } else if (!strcasecmp(name, "billsec")) {
3070                 snprintf(value, length, "%ld", cdr_object_get_billsec(cdr_obj));
3071         } else if (!strcasecmp(name, "disposition")) {
3072                 snprintf(value, length, "%u", cdr_obj->disposition);
3073         } else if (!strcasecmp(name, "amaflags")) {
3074                 snprintf(value, length, "%d", party_a->amaflags);
3075         } else if (!strcasecmp(name, "accountcode")) {
3076                 ast_copy_string(value, party_a->accountcode, length);
3077         } else if (!strcasecmp(name, "peeraccount")) {
3078                 if (party_b) {
3079                         ast_copy_string(value, party_b->accountcode, length);
3080                 } else {
3081                         ast_copy_string(value, "", length);
3082                 }
3083         } else if (!strcasecmp(name, "uniqueid")) {
3084                 ast_copy_string(value, party_a->uniqueid, length);
3085         } else if (!strcasecmp(name, "linkedid")) {
3086                 ast_copy_string(value, cdr_obj->linkedid, length);
3087         } else if (!strcasecmp(name, "userfield")) {
3088                 ast_copy_string(value, cdr_obj->party_a.userfield, length);
3089         } else if (!strcasecmp(name, "sequence")) {
3090                 snprintf(value, length, "%u", cdr_obj->sequence);
3091         } else {
3092                 return 1;
3093         }
3094
3095         return 0;
3096 }
3097
3098 /*! \internal
3099  * \brief Look up and retrieve a CDR object by channel name
3100  * \param name The name of the channel
3101  * \retval NULL on error
3102  * \retval The \ref cdr_object for the channel on success, with the reference
3103  *      count bumped by one.
3104  */
3105 static struct cdr_object *cdr_object_get_by_name(const char *name)
3106 {
3107         char *param;
3108
3109         if (ast_strlen_zero(name)) {
3110                 return NULL;
3111         }
3112
3113         param = ast_strdupa(name);
3114         return ao2_callback(active_cdrs_by_channel, 0, cdr_object_get_by_name_cb, param);
3115 }
3116
3117 int ast_cdr_getvar(const char *channel_name, const char *name, char *value, size_t length)
3118 {
3119         RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3120         struct cdr_object *cdr_obj;
3121
3122         if (!cdr) {
3123                 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
3124                 return 1;
3125         }
3126
3127         if (ast_strlen_zero(name)) {
3128                 return 1;
3129         }
3130
3131         ao2_lock(cdr);
3132
3133         cdr_obj = cdr->last;
3134         if (cdr_object_format_property(cdr_obj, name, value, length)) {
3135                 /* Property failed; attempt variable */
3136                 cdr_object_format_var_internal(cdr_obj, name, value, length);
3137         }
3138
3139         ao2_unlock(cdr);
3140
3141         return 0;
3142 }
3143
3144 int ast_cdr_serialize_variables(const char *channel_name, struct ast_str **buf, char delim, char sep)
3145 {
3146         RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3147         struct cdr_object *it_cdr;
3148         struct ast_var_t *variable;
3149         const char *var;
3150         char workspace[256];
3151         int total = 0, x = 0, i;
3152
3153         if (!cdr) {
3154                 RAII_VAR(struct module_config *, mod_cfg,
3155                          ao2_global_obj_ref(module_configs), ao2_cleanup);
3156
3157                 if (ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
3158                         ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
3159                 }
3160
3161                 return 0;
3162         }
3163
3164         ast_str_reset(*buf);
3165
3166         ao2_lock(cdr);
3167         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3168                 if (++x > 1)
3169                         ast_str_append(buf, 0, "\n");
3170
3171                 AST_LIST_TRAVERSE(&it_cdr->party_a.variables, variable, entries) {
3172                         if (!(var = ast_var_name(variable))) {
3173                                 continue;
3174                         }
3175
3176                         if (ast_str_append(buf, 0, "level %d: %s%c%s%c", x, var, delim, S_OR(ast_var_value(variable), ""), sep) < 0) {
3177                                 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
3178                                 break;
3179                         }
3180
3181                         total++;
3182                 }
3183
3184                 for (i = 0; cdr_readonly_vars[i]; i++) {
3185                         if (cdr_object_format_property(it_cdr, cdr_readonly_vars[i], workspace, sizeof(workspace))) {
3186                                 /* Unhandled read-only CDR variable. */
3187                                 ast_assert(0);
3188                                 continue;
3189                         }
3190
3191                         if (!ast_strlen_zero(workspace)
3192                                 && ast_str_append(buf, 0, "level %d: %s%c%s%c", x, cdr_readonly_vars[i], delim, workspace, sep) < 0) {
3193                                 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
3194                                 break;
3195                         }
3196                         total++;
3197                 }
3198         }
3199         ao2_unlock(cdr);
3200         return total;
3201 }
3202
3203 void ast_cdr_free(struct ast_cdr *cdr)
3204 {
3205         while (cdr) {
3206                 struct ast_cdr *next = cdr->next;
3207
3208                 free_variables(&cdr->varshead);
3209                 ast_free(cdr);
3210                 cdr = next;
3211         }
3212 }
3213
3214 struct ast_cdr *ast_cdr_alloc(void)
3215 {
3216         struct ast_cdr *x;
3217
3218         x = ast_calloc(1, sizeof(*x));
3219         return x;
3220 }
3221
3222 const char *ast_cdr_disp2str(int disposition)
3223 {
3224         switch (disposition) {
3225         case AST_CDR_NULL:
3226                 return "NO ANSWER"; /* by default, for backward compatibility */
3227         case AST_CDR_NOANSWER:
3228                 return "NO ANSWER";
3229         case AST_CDR_FAILED:
3230                 return "FAILED";
3231         case AST_CDR_BUSY:
3232                 return "BUSY";
3233         case AST_CDR_ANSWERED:
3234                 return "ANSWERED";
3235         case AST_CDR_CONGESTION:
3236                 return "CONGESTION";
3237         }
3238         return "UNKNOWN";
3239 }
3240
3241 struct party_b_userfield_update {
3242         const char *channel_name;
3243         const char *userfield;
3244 };
3245
3246 /*! \brief Callback used to update the userfield on Party B on all CDRs */
3247 static int cdr_object_update_party_b_userfield_cb(void *obj, void *arg, int flags)
3248 {
3249         struct cdr_object *cdr = obj;
3250         struct party_b_userfield_update *info = arg;
3251         struct cdr_object *it_cdr;
3252         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3253                 if (it_cdr->fn_table == &finalized_state_fn_table && it_cdr->next != NULL) {
3254                         continue;
3255                 }
3256                 if (it_cdr->party_b.snapshot
3257                         && !strcasecmp(it_cdr->party_b.snapshot->name, info->channel_name)) {
3258                         strcpy(it_cdr->party_b.userfield, info->userfield);
3259                 }
3260         }
3261         return 0;
3262 }
3263
3264 void ast_cdr_setuserfield(const char *channel_name, const char *userfield)
3265 {
3266         RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3267         struct party_b_userfield_update party_b_info = {
3268                         .channel_name = channel_name,
3269                         .userfield = userfield,
3270         };
3271         struct cdr_object *it_cdr;
3272
3273         /* Handle Party A */
3274         if (cdr) {
3275                 ao2_lock(cdr);
3276                 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3277                         if (it_cdr->fn_table == &finalized_state_fn_table && it_cdr->next != NULL) {
3278                                 continue;
3279                         }
3280                         ast_copy_string(it_cdr->party_a.userfield, userfield, AST_MAX_USER_FIELD);
3281                 }
3282                 ao2_unlock(cdr);
3283         }
3284
3285         /* Handle Party B */
3286         ao2_callback(active_cdrs_by_channel, OBJ_NODATA,
3287                         cdr_object_update_party_b_userfield_cb,
3288                         &party_b_info);
3289
3290 }
3291
3292 static void post_cdr(struct ast_cdr *cdr)
3293 {
3294         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
3295         struct cdr_beitem *i;
3296
3297         for (; cdr ; cdr = cdr->next) {
3298                 /* For people, who don't want to see unanswered single-channel events */
3299                 if (!ast_test_flag(&mod_cfg->general->settings, CDR_UNANSWERED) &&
3300                                 cdr->disposition < AST_CDR_ANSWERED &&
3301                                 (ast_strlen_zero(cdr->channel) || ast_strlen_zero(cdr->dstchannel))) {
3302                         ast_debug(1, "Skipping CDR  for %s since we weren't answered\n", cdr->channel);
3303                         continue;
3304                 }
3305
3306                 /* Modify CDR's */
3307                 AST_RWLIST_RDLOCK(&mo_list);
3308                 AST_RWLIST_TRAVERSE(&mo_list, i, list) {
3309                         i->be(cdr);
3310                 }
3311                 AST_RWLIST_UNLOCK(&mo_list);
3312
3313                 if (ast_test_flag(cdr, AST_CDR_FLAG_DISABLE)) {
3314                         continue;
3315                 }
3316                 AST_RWLIST_RDLOCK(&be_list);
3317                 AST_RWLIST_TRAVERSE(&be_list, i, list) {
3318                         if (!i->suspended) {
3319                                 i->be(cdr);
3320                         }
3321                 }
3322                 AST_RWLIST_UNLOCK(&be_list);
3323         }
3324 }
3325
3326 int ast_cdr_set_property(const char *channel_name, enum ast_cdr_options option)
3327 {
3328         RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3329         struct cdr_object *it_cdr;
3330
3331         if (!cdr) {
3332                 return -1;
3333         }
3334
3335         ao2_lock(cdr);
3336         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3337                 if (it_cdr->fn_table == &finalized_state_fn_table) {
3338                         continue;
3339                 }
3340                 /* Note: in general, set the flags on both the CDR record as well as the
3341                  * Party A. Sometimes all we have is the Party A to look at.
3342                  */
3343                 ast_set_flag(&it_cdr->flags, option);
3344                 ast_set_flag(&it_cdr->party_a, option);
3345         }
3346         ao2_unlock(cdr);
3347
3348         return 0;
3349 }
3350
3351 int ast_cdr_clear_property(const char *channel_name, enum ast_cdr_options option)
3352 {
3353         RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3354         struct cdr_object *it_cdr;
3355
3356         if (!cdr) {
3357                 return -1;
3358         }
3359
3360         ao2_lock(cdr);
3361         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3362                 if (it_cdr->fn_table == &finalized_state_fn_table) {
3363                         continue;
3364                 }
3365                 ast_clear_flag(&it_cdr->flags, option);
3366         }
3367         ao2_unlock(cdr);
3368
3369         return 0;
3370 }
3371
3372 int ast_cdr_reset(const char *channel_name, int keep_variables)
3373 {
3374         RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3375         struct ast_var_t *vardata;
3376         struct cdr_object *it_cdr;
3377
3378         if (!cdr) {
3379                 return -1;
3380         }
3381
3382         ao2_lock(cdr);
3383         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3384                 /* clear variables */
3385                 if (!keep_variables) {
3386                         while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_a.variables, entries))) {
3387                                 ast_var_delete(vardata);
3388                         }
3389                         if (cdr->party_b.snapshot) {
3390                                 while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_b.variables, entries))) {
3391                                         ast_var_delete(vardata);
3392                                 }
3393                         }
3394                 }
3395
3396                 /* Reset to initial state */
3397                 memset(&it_cdr->start, 0, sizeof(it_cdr->start));
3398                 memset(&it_cdr->end, 0, sizeof(it_cdr->end));
3399                 memset(&it_cdr->answer, 0, sizeof(it_cdr->answer));
3400                 it_cdr->start = ast_tvnow();
3401                 cdr_object_check_party_a_answer(it_cdr);
3402         }
3403         ao2_unlock(cdr);
3404
3405         return 0;
3406 }
3407
3408 int ast_cdr_fork(const char *channel_name, struct ast_flags *options)
3409 {
3410         RAII_VAR(struct cdr_object *, cdr, cdr_object_get_by_name(channel_name), ao2_cleanup);
3411         struct cdr_object *new_cdr;
3412         struct cdr_object *it_cdr;
3413         struct cdr_object *cdr_obj;
3414
3415         if (!cdr) {
3416                 return -1;
3417         }
3418
3419         {
3420                 SCOPED_AO2LOCK(lock, cdr);
3421
3422                 cdr_obj = cdr->last;
3423                 if (cdr_obj->fn_table == &finalized_state_fn_table) {
3424                         /* If the last CDR in the chain is finalized, don't allow a fork -
3425                          * things are already dying at this point
3426                          */
3427                         return -1;
3428                 }
3429
3430                 /* Copy over the basic CDR information. The Party A information is
3431                  * copied over automatically as part of the append
3432                  */
3433                 ast_debug(1, "Forking CDR for channel %s\n", cdr->party_a.snapshot->name);
3434                 new_cdr = cdr_object_create_and_append(cdr);
3435                 if (!new_cdr) {
3436                         return -1;
3437                 }
3438                 new_cdr->fn_table = cdr_obj->fn_table;
3439                 ast_string_field_set(new_cdr, bridge, cdr->bridge);
3440                 ast_string_field_set(new_cdr, appl, cdr->appl);
3441                 ast_string_field_set(new_cdr, data, cdr->data);
3442                 ast_string_field_set(new_cdr, context, cdr->context);
3443                 ast_string_field_set(new_cdr, exten, cdr->exten);
3444                 new_cdr->flags = cdr->flags;
3445                 /* Explicitly clear the AST_CDR_LOCK_APP flag - we want
3446                  * the application to be changed on the new CDR if the
3447                  * dialplan demands it
3448                  */
3449                 ast_clear_flag(&new_cdr->flags, AST_CDR_LOCK_APP);
3450
3451                 /* If there's a Party B, copy it over as well */
3452                 if (cdr_obj->party_b.snapshot) {
3453                         new_cdr->party_b.snapshot = cdr_obj->party_b.snapshot;
3454                         ao2_ref(new_cdr->party_b.snapshot, +1);
3455                         strcpy(new_cdr->party_b.userfield, cdr_obj->party_b.userfield);
3456                         new_cdr->party_b.flags = cdr_obj->party_b.flags;
3457                         if (ast_test_flag(options, AST_CDR_FLAG_KEEP_VARS)) {
3458                                 copy_variables(&new_cdr->party_b.variables, &cdr_obj->party_b.variables);
3459                         }
3460                 }
3461                 new_cdr->start = cdr_obj->start;
3462                 new_cdr->answer = cdr_obj->answer;
3463
3464                 /* Modify the times based on the flags passed in */
3465                 if (ast_test_flag(options, AST_CDR_FLAG_SET_ANSWER)
3466                                 && new_cdr->party_a.snapshot->state == AST_STATE_UP) {
3467                         new_cdr->answer = ast_tvnow();
3468                 }
3469                 if (ast_test_flag(options, AST_CDR_FLAG_RESET)) {
3470                         new_cdr->answer = ast_tvnow();
3471                         new_cdr->start = ast_tvnow();
3472                 }
3473
3474                 /* Create and append, by default, copies over the variables */
3475                 if (!ast_test_flag(options, AST_CDR_FLAG_KEEP_VARS)) {
3476                         free_variables(&new_cdr->party_a.variables);
3477                 }
3478
3479                 /* Finalize any current CDRs */
3480                 if (ast_test_flag(options, AST_CDR_FLAG_FINALIZE)) {
3481                         for (it_cdr = cdr; it_cdr != new_cdr; it_cdr = it_cdr->next) {
3482                                 if (it_cdr->fn_table == &finalized_state_fn_table) {
3483                                         continue;
3484                                 }
3485                                 /* Force finalization on the CDR. This will bypass any checks for
3486                                  * end before 'h' extension.
3487                                  */
3488                                 cdr_object_finalize(it_cdr);
3489                                 cdr_object_transition_state(it_cdr, &finalized_state_fn_table);
3490                         }
3491                 }
3492         }
3493
3494         return 0;
3495 }
3496
3497 /*! \note Don't call without cdr_batch_lock */
3498 static void reset_batch(void)
3499 {
3500         batch->size = 0;
3501         batch->head = NULL;
3502         batch->tail = NULL;
3503 }
3504
3505 /*! \note Don't call without cdr_batch_lock */
3506 static int init_batch(void)
3507 {
3508         /* This is the single meta-batch used to keep track of all CDRs during the entire life of the program */
3509         if (!(batch = ast_malloc(sizeof(*batch))))
3510                 return -1;
3511
3512         reset_batch();
3513
3514         return 0;
3515 }
3516
3517 static void *do_batch_backend_process(void *data)
3518 {
3519         struct cdr_batch_item *processeditem;
3520         struct cdr_batch_item *batchitem = data;
3521
3522         /* Push each CDR into storage mechanism(s) and free all the memory */
3523         while (batchitem) {
3524                 post_cdr(batchitem->cdr);
3525                 ast_cdr_free(batchitem->cdr);
3526                 processeditem = batchitem;
3527                 batchitem = batchitem->next;
3528                 ast_free(processeditem);
3529         }
3530
3531         return NULL;
3532 }
3533
3534 static void cdr_submit_batch(int do_shutdown)
3535 {
3536         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
3537         struct cdr_batch_item *oldbatchitems = NULL;
3538         pthread_t batch_post_thread = AST_PTHREADT_NULL;
3539
3540         /* if there's no batch, or no CDRs in the batch, then there's nothing to do */
3541         if (!batch || !batch->head) {
3542                 return;
3543         }
3544
3545         /* move the old CDRs aside, and prepare a new CDR batch */
3546         ast_mutex_lock(&cdr_batch_lock);
3547         oldbatchitems = batch->head;
3548         reset_batch();
3549         ast_mutex_unlock(&cdr_batch_lock);
3550
3551         /* if configured, spawn a new thread to post these CDRs,
3552            also try to save as much as possible if we are shutting down safely */
3553         if (ast_test_flag(&mod_cfg->general->batch_settings.settings, BATCH_MODE_SCHEDULER_ONLY) || do_shutdown) {
3554                 ast_debug(1, "CDR single-threaded batch processing begins now\n");
3555                 do_batch_backend_process(oldbatchitems);
3556         } else {
3557                 if (ast_pthread_create_detached_background(&batch_post_thread, NULL, do_batch_backend_process, oldbatchitems)) {
3558                         ast_log(LOG_WARNING, "CDR processing thread could not detach, now trying in this thread\n");
3559                         do_batch_backend_process(oldbatchitems);
3560                 } else {
3561                         ast_debug(1, "CDR multi-threaded batch processing begins now\n");
3562                 }
3563         }
3564 }
3565
3566 static int submit_scheduled_batch(const void *data)
3567 {
3568         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
3569         cdr_submit_batch(0);
3570         /* manually reschedule from this point in time */
3571
3572         ast_mutex_lock(&cdr_sched_lock);
3573         cdr_sched = ast_sched_add(sched, mod_cfg->general->batch_settings.time * 1000, submit_scheduled_batch, NULL);
3574         ast_mutex_unlock(&cdr_sched_lock);
3575         /* returning zero so the scheduler does not automatically reschedule */
3576         return 0;
3577 }
3578
3579 /*! Do not hold the batch lock while calling this function */
3580 static void submit_unscheduled_batch(void)
3581 {
3582         /* Prevent two deletes from happening at the same time */
3583         ast_mutex_lock(&cdr_sched_lock);
3584         /* this is okay since we are not being called from within the scheduler */
3585         AST_SCHED_DEL(sched, cdr_sched);
3586         /* schedule the submission to occur ASAP (1 ms) */
3587         cdr_sched = ast_sched_add(sched, 1, submit_scheduled_batch, NULL);
3588         ast_mutex_unlock(&cdr_sched_lock);
3589
3590         /* signal the do_cdr thread to wakeup early and do some work (that lazy thread ;) */
3591         ast_mutex_lock(&cdr_pending_lock);
3592         ast_cond_signal(&cdr_pending_cond);
3593         ast_mutex_unlock(&cdr_pending_lock);
3594 }
3595
3596 static void cdr_detach(struct ast_cdr *cdr)
3597 {
3598         struct cdr_batch_item *newtail;
3599         int curr;
3600         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
3601         int submit_batch = 0;
3602
3603         if (!cdr) {
3604                 return;
3605         }
3606
3607         /* maybe they disabled CDR stuff completely, so just drop it */
3608         if (!ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED)) {
3609                 ast_debug(1, "Dropping CDR !\n");
3610                 ast_cdr_free(cdr);
3611                 return;
3612         }
3613
3614         /* post stuff immediately if we are not in batch mode, this is legacy behaviour */
3615         if (!ast_test_flag(&mod_cfg->general->settings, CDR_BATCHMODE)) {
3616                 post_cdr(cdr);
3617                 ast_cdr_free(cdr);
3618                 return;
3619         }
3620
3621         /* otherwise, each CDR gets put into a batch list (at the end) */
3622         ast_debug(1, "CDR detaching from this thread\n");
3623
3624         /* we'll need a new tail for every CDR */
3625         if (!(newtail = ast_calloc(1, sizeof(*newtail)))) {
3626                 post_cdr(cdr);
3627                 ast_cdr_free(cdr);
3628                 return;
3629         }
3630
3631         /* don't traverse a whole list (just keep track of the tail) */
3632         ast_mutex_lock(&cdr_batch_lock);
3633         if (!batch)
3634                 init_batch();
3635         if (!batch->head) {
3636                 /* new batch is empty, so point the head at the new tail */
3637                 batch->head = newtail;
3638         } else {
3639                 /* already got a batch with something in it, so just append a new tail */
3640                 batch->tail->next = newtail;
3641         }
3642         newtail->cdr = cdr;
3643         batch->tail = newtail;
3644         curr = batch->size++;
3645
3646         /* if we have enough stuff to post, then do it */
3647         if (curr >= (mod_cfg->general->batch_settings.size - 1)) {
3648                 submit_batch = 1;
3649         }
3650         ast_mutex_unlock(&cdr_batch_lock);
3651
3652         /* Don't call submit_unscheduled_batch with the cdr_batch_lock held */
3653         if (submit_batch) {
3654                 submit_unscheduled_batch();
3655         }
3656 }
3657
3658 static void *do_cdr(void *data)
3659 {
3660         struct timespec timeout;
3661         int schedms;
3662         int numevents = 0;
3663
3664         for (;;) {
3665                 struct timeval now;
3666                 schedms = ast_sched_wait(sched);
3667                 /* this shouldn't happen, but provide a 1 second default just in case */
3668                 if (schedms <= 0)
3669                         schedms = 1000;
3670                 now = ast_tvadd(ast_tvnow(), ast_samp2tv(schedms, 1000));
3671                 timeout.tv_sec = now.tv_sec;
3672                 timeout.tv_nsec = now.tv_usec * 1000;
3673                 /* prevent stuff from clobbering cdr_pending_cond, then wait on signals sent to it until the timeout expires */
3674                 ast_mutex_lock(&cdr_pending_lock);
3675                 ast_cond_timedwait(&cdr_pending_cond, &cdr_pending_lock, &timeout);
3676                 numevents = ast_sched_runq(sched);
3677                 ast_mutex_unlock(&cdr_pending_lock);
3678                 ast_debug(2, "Processed %d scheduled CDR batches from the run queue\n", numevents);
3679         }
3680
3681         return NULL;
3682 }
3683
3684 static char *handle_cli_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
3685 {
3686         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
3687
3688         switch (cmd) {
3689         case CLI_INIT:
3690                 e->command = "cdr set debug [on|off]";
3691                 e->usage = "Enable or disable extra debugging in the CDR Engine. Note\n"
3692                                 "that this will dump debug information to the VERBOSE setting\n"
3693                                 "and should only be used when debugging information from the\n"
3694                                 "CDR engine is needed.\n";
3695                 return NULL;
3696         case CLI_GENERATE:
3697                 return NULL;
3698         }
3699
3700         if (a->argc != 4) {
3701                 return CLI_SHOWUSAGE;
3702         }
3703
3704         if (!strcasecmp(a->argv[3], "on")
3705                 && !ast_test_flag(&mod_cfg->general->settings, CDR_DEBUG)) {
3706                 ast_set_flag(&mod_cfg->general->settings, CDR_DEBUG);
3707                 ast_cli(a->fd, "CDR debugging enabled\n");
3708         } else if (!strcasecmp(a->argv[3], "off")
3709                 && ast_test_flag(&mod_cfg->general->settings, CDR_DEBUG)) {
3710                 ast_clear_flag(&mod_cfg->general->settings, CDR_DEBUG);
3711                 ast_cli(a->fd, "CDR debugging disabled\n");
3712         }
3713
3714         return CLI_SUCCESS;
3715 }
3716
3717 /*! \brief Complete user input for 'cdr show' */
3718 static char *cli_complete_show(struct ast_cli_args *a)
3719 {
3720         char *result = NULL;
3721         int wordlen = strlen(a->word);
3722         int which = 0;
3723         struct ao2_iterator it_cdrs;
3724         struct cdr_object *cdr;
3725
3726         it_cdrs = ao2_iterator_init(active_cdrs_by_channel, 0);
3727         while ((cdr = ao2_iterator_next(&it_cdrs))) {
3728                 if (!strncasecmp(a->word, cdr->party_a.snapshot->name, wordlen) &&
3729                         (++which > a->n)) {
3730                         result = ast_strdup(cdr->party_a.snapshot->name);
3731                         if (result) {
3732                                 ao2_ref(cdr, -1);
3733                                 break;
3734                         }
3735                 }
3736                 ao2_ref(cdr, -1);
3737         }
3738         ao2_iterator_destroy(&it_cdrs);
3739         return result;
3740 }
3741
3742 static void cli_show_channels(struct ast_cli_args *a)
3743 {
3744         struct ao2_iterator it_cdrs;
3745         struct cdr_object *cdr;
3746         char start_time_buffer[64];
3747         char answer_time_buffer[64];
3748         char end_time_buffer[64];
3749
3750 #define TITLE_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8s %-8.8s\n"
3751 #define FORMAT_STRING "%-25.25s %-25.25s %-15.15s %-8.8s %-8.8s %-8.8s %-8.8ld %-8.8ld\n"
3752
3753         ast_cli(a->fd, "\n");
3754         ast_cli(a->fd, "Channels with Call Detail Record (CDR) Information\n");
3755         ast_cli(a->fd, "--------------------------------------------------\n");
3756         ast_cli(a->fd, TITLE_STRING, "Channel", "Dst. Channel", "LastApp", "Start", "Answer", "End", "Billsec", "Duration");
3757
3758         it_cdrs = ao2_iterator_init(active_cdrs_by_channel, 0);
3759         for (; (cdr = ao2_iterator_next(&it_cdrs)); ao2_cleanup(cdr)) {
3760                 struct cdr_object *it_cdr;
3761                 struct timeval start_time = { 0, };
3762                 struct timeval answer_time = { 0, };
3763                 struct timeval end_time = { 0, };
3764
3765                 SCOPED_AO2LOCK(lock, cdr);
3766
3767                 /* Calculate the start, end, answer, billsec, and duration over the
3768                  * life of all of the CDR entries
3769                  */
3770                 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3771                         if (snapshot_is_dialed(it_cdr->party_a.snapshot)) {
3772                                 continue;
3773                         }
3774                         if (ast_tvzero(start_time)) {
3775                                 start_time = it_cdr->start;
3776                         }
3777                         if (!ast_tvzero(it_cdr->answer) && ast_tvzero(answer_time)) {
3778                                 answer_time = it_cdr->answer;
3779                         }
3780                 }
3781
3782                 /* If there was no start time, then all CDRs were for a dialed channel; skip */
3783                 if (ast_tvzero(start_time)) {
3784                         continue;
3785                 }
3786                 it_cdr = cdr->last;
3787
3788                 end_time = ast_tvzero(it_cdr->end) ? ast_tvnow() : it_cdr->end;
3789</