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