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