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