Doxygen comment tweaks.
[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 && (newvariable = ast_var_assign(name, value))) {
1037                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
1038         }
1039 }
1040
1041 /*!
1042  * \brief Create a chain of \ref ast_cdr objects from a chain of \ref cdr_object
1043  * suitable for consumption by the registered CDR backends
1044  * \param cdr The \ref cdr_object to convert to a public record
1045  * \retval A chain of \ref ast_cdr objects on success
1046  * \retval NULL on failure
1047  */
1048 static struct ast_cdr *cdr_object_create_public_records(struct cdr_object *cdr)
1049 {
1050         struct ast_cdr *pub_cdr = NULL, *cdr_prev = NULL;
1051         struct cdr_object *it_cdr;
1052         struct ast_var_t *it_var, *it_copy_var;
1053         struct ast_channel_snapshot *party_a;
1054         struct ast_channel_snapshot *party_b;
1055
1056         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
1057                 struct ast_cdr *cdr_copy;
1058
1059                 /* Don't create records for CDRs where the party A was a dialed channel */
1060                 if (snapshot_is_dialed(it_cdr->party_a.snapshot)) {
1061                         continue;
1062                 }
1063
1064                 cdr_copy = ast_calloc(1, sizeof(*cdr_copy));
1065                 if (!cdr_copy) {
1066                         ast_free(pub_cdr);
1067                         return NULL;
1068                 }
1069
1070                 party_a = it_cdr->party_a.snapshot;
1071                 party_b = it_cdr->party_b.snapshot;
1072
1073                 /* Party A */
1074                 ast_assert(party_a != NULL);
1075                 ast_copy_string(cdr_copy->accountcode, party_a->accountcode, sizeof(cdr_copy->accountcode));
1076                 cdr_copy->amaflags = party_a->amaflags;
1077                 ast_copy_string(cdr_copy->channel, party_a->name, sizeof(cdr_copy->channel));
1078                 ast_callerid_merge(cdr_copy->clid, sizeof(cdr_copy->clid), party_a->caller_name, party_a->caller_number, "");
1079                 ast_copy_string(cdr_copy->src, party_a->caller_number, sizeof(cdr_copy->src));
1080                 ast_copy_string(cdr_copy->uniqueid, party_a->uniqueid, sizeof(cdr_copy->uniqueid));
1081                 ast_copy_string(cdr_copy->lastapp, it_cdr->appl, sizeof(cdr_copy->lastapp));
1082                 ast_copy_string(cdr_copy->lastdata, it_cdr->data, sizeof(cdr_copy->lastdata));
1083                 ast_copy_string(cdr_copy->dst, party_a->exten, sizeof(cdr_copy->dst));
1084                 ast_copy_string(cdr_copy->dcontext, party_a->context, sizeof(cdr_copy->dcontext));
1085
1086                 /* Party B */
1087                 if (party_b) {
1088                         ast_copy_string(cdr_copy->dstchannel, party_b->name, sizeof(cdr_copy->dstchannel));
1089                         ast_copy_string(cdr_copy->peeraccount, party_b->accountcode, sizeof(cdr_copy->peeraccount));
1090                         if (!ast_strlen_zero(it_cdr->party_b.userfield)) {
1091                                 snprintf(cdr_copy->userfield, sizeof(cdr_copy->userfield), "%s;%s", it_cdr->party_a.userfield, it_cdr->party_b.userfield);
1092                         }
1093                 }
1094                 if (ast_strlen_zero(cdr_copy->userfield) && !ast_strlen_zero(it_cdr->party_a.userfield)) {
1095                         ast_copy_string(cdr_copy->userfield, it_cdr->party_a.userfield, sizeof(cdr_copy->userfield));
1096                 }
1097
1098                 /* Timestamps/durations */
1099                 cdr_copy->start = it_cdr->start;
1100                 cdr_copy->answer = it_cdr->answer;
1101                 cdr_copy->end = it_cdr->end;
1102                 cdr_copy->billsec = cdr_object_get_billsec(it_cdr);
1103                 cdr_copy->duration = cdr_object_get_duration(it_cdr);
1104
1105                 /* Flags and IDs */
1106                 ast_copy_flags(cdr_copy, &it_cdr->flags, AST_FLAGS_ALL);
1107                 ast_copy_string(cdr_copy->linkedid, it_cdr->linkedid, sizeof(cdr_copy->linkedid));
1108                 cdr_copy->disposition = it_cdr->disposition;
1109                 cdr_copy->sequence = it_cdr->sequence;
1110
1111                 /* Variables */
1112                 copy_variables(&cdr_copy->varshead, &it_cdr->party_a.variables);
1113                 AST_LIST_TRAVERSE(&it_cdr->party_b.variables, it_var, entries) {
1114                         int found = 0;
1115                         struct ast_var_t *newvariable;
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 && (newvariable = ast_var_assign(ast_var_name(it_var), ast_var_value(it_var)))) {
1123                                 AST_LIST_INSERT_TAIL(&cdr_copy->varshead, newvariable, entries);
1124                         }
1125                 }
1126
1127                 if (!pub_cdr) {
1128                         pub_cdr = cdr_copy;
1129                         cdr_prev = pub_cdr;
1130                 } else {
1131                         cdr_prev->next = cdr_copy;
1132                         cdr_prev = cdr_copy;
1133                 }
1134         }
1135
1136         return pub_cdr;
1137 }
1138
1139 /*!
1140  * \brief Dispatch a CDR.
1141  * \param cdr The \ref cdr_object to dispatch
1142  *
1143  * This will create a \ref ast_cdr object and publish it to the various backends
1144  */
1145 static void cdr_object_dispatch(struct cdr_object *cdr)
1146 {
1147         RAII_VAR(struct module_config *, mod_cfg,
1148                         ao2_global_obj_ref(module_configs), ao2_cleanup);
1149         struct ast_cdr *pub_cdr;
1150
1151         CDR_DEBUG(mod_cfg, "%p - Dispatching CDR for Party A %s, Party B %s\n", cdr,
1152                         cdr->party_a.snapshot->name,
1153                         cdr->party_b.snapshot ? cdr->party_b.snapshot->name : "<none>");
1154         pub_cdr = cdr_object_create_public_records(cdr);
1155         cdr_detach(pub_cdr);
1156 }
1157
1158 /*!
1159  * \brief Set the disposition on a \ref cdr_object based on a hangupcause code
1160  * \param cdr The \ref cdr_object
1161  * \param hangupcause The Asterisk hangup cause code
1162  */
1163 static void cdr_object_set_disposition(struct cdr_object *cdr, int hangupcause)
1164 {
1165         RAII_VAR(struct module_config *, mod_cfg,
1166                         ao2_global_obj_ref(module_configs), ao2_cleanup);
1167
1168         /* Change the disposition based on the hang up cause */
1169         switch (hangupcause) {
1170         case AST_CAUSE_BUSY:
1171                 cdr->disposition = AST_CDR_BUSY;
1172                 break;
1173         case AST_CAUSE_CONGESTION:
1174                 if (!ast_test_flag(&mod_cfg->general->settings, CDR_CONGESTION)) {
1175                         cdr->disposition = AST_CDR_FAILED;
1176                 } else {
1177                         cdr->disposition = AST_CDR_CONGESTION;
1178                 }
1179                 break;
1180         case AST_CAUSE_NO_ROUTE_DESTINATION:
1181         case AST_CAUSE_UNREGISTERED:
1182                 cdr->disposition = AST_CDR_FAILED;
1183                 break;
1184         case AST_CAUSE_NORMAL_CLEARING:
1185         case AST_CAUSE_NO_ANSWER:
1186                 cdr->disposition = AST_CDR_NOANSWER;
1187                 break;
1188         default:
1189                 break;
1190         }
1191 }
1192
1193 /*!
1194  * \brief Finalize a CDR.
1195  *
1196  * This function is safe to call multiple times. Note that you can call this
1197  * explicitly before going to the finalized state if there's a chance the CDR
1198  * will be re-activated, in which case the \ref cdr_object's end time should be
1199  * cleared. This function is implicitly called when a CDR transitions to the
1200  * finalized state and right before it is dispatched
1201  *
1202  * \param cdr_object The CDR to finalize
1203  */
1204 static void cdr_object_finalize(struct cdr_object *cdr)
1205 {
1206         RAII_VAR(struct module_config *, mod_cfg,
1207                         ao2_global_obj_ref(module_configs), ao2_cleanup);
1208
1209         if (!ast_tvzero(cdr->end)) {
1210                 return;
1211         }
1212         cdr->end = ast_tvnow();
1213
1214         if (cdr->disposition == AST_CDR_NULL) {
1215                 if (!ast_tvzero(cdr->answer)) {
1216                         cdr->disposition = AST_CDR_ANSWERED;
1217                 } else if (cdr->party_a.snapshot->hangupcause) {
1218                         cdr_object_set_disposition(cdr, cdr->party_a.snapshot->hangupcause);
1219                 } else if (cdr->party_b.snapshot && cdr->party_b.snapshot->hangupcause) {
1220                         cdr_object_set_disposition(cdr, cdr->party_b.snapshot->hangupcause);
1221                 } else {
1222                         cdr->disposition = AST_CDR_FAILED;
1223                 }
1224         }
1225
1226         /* tv_usec is suseconds_t, which could be int or long */
1227         ast_debug(1, "Finalized CDR for %s - start %ld.%06ld answer %ld.%06ld end %ld.%06ld dispo %s\n",
1228                         cdr->party_a.snapshot->name,
1229                         cdr->start.tv_sec,
1230                         (long)cdr->start.tv_usec,
1231                         cdr->answer.tv_sec,
1232                         (long)cdr->answer.tv_usec,
1233                         cdr->end.tv_sec,
1234                         (long)cdr->end.tv_usec,
1235                         ast_cdr_disp2str(cdr->disposition));
1236 }
1237
1238 /*!
1239  * \brief Check to see if a CDR needs to move to the finalized state because
1240  * its Party A hungup.
1241  */
1242 static void cdr_object_check_party_a_hangup(struct cdr_object *cdr)
1243 {
1244         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1245
1246         if (ast_test_flag(&mod_cfg->general->settings, CDR_END_BEFORE_H_EXTEN)
1247                 && ast_test_flag(&cdr->party_a.snapshot->softhangup_flags, AST_SOFTHANGUP_HANGUP_EXEC)) {
1248                 cdr_object_finalize(cdr);
1249         }
1250
1251         if (ast_test_flag(&cdr->party_a.snapshot->flags, AST_FLAG_DEAD)
1252                 && cdr->fn_table != &finalized_state_fn_table) {
1253                 cdr_object_transition_state(cdr, &finalized_state_fn_table);
1254         }
1255 }
1256
1257 /*!
1258  * \brief Check to see if a CDR needs to be answered based on its Party A.
1259  * Note that this is safe to call as much as you want - we won't answer twice
1260  */
1261 static void cdr_object_check_party_a_answer(struct cdr_object *cdr) {
1262         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1263
1264         if (cdr->party_a.snapshot->state == AST_STATE_UP && ast_tvzero(cdr->answer)) {
1265                 cdr->answer = ast_tvnow();
1266                 /* tv_usec is suseconds_t, which could be int or long */
1267                 CDR_DEBUG(mod_cfg, "%p - Set answered time to %ld.%06ld\n", cdr,
1268                         cdr->answer.tv_sec,
1269                         (long)cdr->answer.tv_usec);
1270         }
1271 }
1272
1273 /* \brief Set Caller ID information on a CDR */
1274 static void cdr_object_update_cid(struct cdr_object_snapshot *old_snapshot, struct ast_channel_snapshot *new_snapshot)
1275 {
1276         if (!old_snapshot->snapshot) {
1277                 set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller_dnid);
1278                 set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller_subaddr);
1279                 set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->dialed_subaddr);
1280                 return;
1281         }
1282         if (!strcmp(old_snapshot->snapshot->caller_dnid, new_snapshot->caller_dnid)) {
1283                 set_variable(&old_snapshot->variables, "dnid", new_snapshot->caller_dnid);
1284         }
1285         if (!strcmp(old_snapshot->snapshot->caller_subaddr, new_snapshot->caller_subaddr)) {
1286                 set_variable(&old_snapshot->variables, "callingsubaddr", new_snapshot->caller_subaddr);
1287         }
1288         if (!strcmp(old_snapshot->snapshot->dialed_subaddr, new_snapshot->dialed_subaddr)) {
1289                 set_variable(&old_snapshot->variables, "calledsubaddr", new_snapshot->dialed_subaddr);
1290         }
1291 }
1292
1293 /*!
1294  * \brief Swap an old \ref cdr_object_snapshot's \ref ast_channel_snapshot for
1295  * a new \ref ast_channel_snapshot
1296  * \param old_snapshot The old \ref cdr_object_snapshot
1297  * \param new_snapshot The new \ref ast_channel_snapshot for old_snapshot
1298  */
1299 static void cdr_object_swap_snapshot(struct cdr_object_snapshot *old_snapshot,
1300                 struct ast_channel_snapshot *new_snapshot)
1301 {
1302         cdr_object_update_cid(old_snapshot, new_snapshot);
1303         if (old_snapshot->snapshot) {
1304                 ao2_t_ref(old_snapshot->snapshot, -1, "Drop ref for swap");
1305         }
1306         ao2_t_ref(new_snapshot, +1, "Bump ref for swap");
1307         old_snapshot->snapshot = new_snapshot;
1308 }
1309
1310 /* BASE METHOD IMPLEMENTATIONS */
1311
1312 static int base_process_party_a(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1313 {
1314         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1315
1316         ast_assert(strcmp(snapshot->name, cdr->party_a.snapshot->name) == 0);
1317         cdr_object_swap_snapshot(&cdr->party_a, snapshot);
1318
1319         /* When Party A is originated to an application and the application exits, the stack
1320          * will attempt to clear the application and restore the dummy originate application
1321          * of "AppDialX". Prevent that, and any other application changes we might not want
1322          * here.
1323          */
1324         if (!ast_strlen_zero(snapshot->appl)
1325                         && (strncasecmp(snapshot->appl, "appdial", 7) || ast_strlen_zero(cdr->appl))
1326                         && !ast_test_flag(&cdr->flags, AST_CDR_LOCK_APP)) {
1327                 ast_string_field_set(cdr, appl, snapshot->appl);
1328                 ast_string_field_set(cdr, data, snapshot->data);
1329         }
1330
1331         ast_string_field_set(cdr, linkedid, snapshot->linkedid);
1332         cdr_object_check_party_a_answer(cdr);
1333         cdr_object_check_party_a_hangup(cdr);
1334
1335         return 0;
1336 }
1337
1338 static int base_process_bridge_leave(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1339 {
1340         /* In general, most things shouldn't get a bridge leave */
1341         ast_assert(0);
1342         return 1;
1343 }
1344
1345 static int base_process_dial_end(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer, const char *dial_status)
1346 {
1347         /* In general, most things shouldn't get a dial end. */
1348         ast_assert(0);
1349         return 0;
1350 }
1351
1352 static enum process_bridge_enter_results base_process_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1353 {
1354         /* Base process bridge enter simply indicates that we can't handle it */
1355         return BRIDGE_ENTER_NEED_CDR;
1356 }
1357
1358 static int base_process_parked_channel(struct cdr_object *cdr, struct ast_parked_call_payload *parking_info)
1359 {
1360         char park_info[128];
1361
1362         ast_assert(!strcmp(parking_info->parkee->name, cdr->party_a.snapshot->name));
1363
1364         /* Update Party A information regardless */
1365         cdr->fn_table->process_party_a(cdr, parking_info->parkee);
1366
1367         /* Fake out where we're parked */
1368         ast_string_field_set(cdr, appl, "Park");
1369         snprintf(park_info, sizeof(park_info), "%s:%u", parking_info->parkinglot, parking_info->parkingspace);
1370         ast_string_field_set(cdr, data, park_info);
1371
1372         /* Prevent any further changes to the App/Data fields for this record */
1373         ast_set_flag(&cdr->flags, AST_CDR_LOCK_APP);
1374
1375         return 0;
1376 }
1377
1378 /* SINGLE STATE */
1379
1380 static void single_state_init_function(struct cdr_object *cdr) {
1381         cdr->start = ast_tvnow();
1382         cdr_object_check_party_a_answer(cdr);
1383 }
1384
1385 static void single_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1386 {
1387         /* This should never happen! */
1388         ast_assert(cdr->party_b.snapshot == NULL);
1389         ast_assert(0);
1390         return;
1391 }
1392
1393 static int single_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
1394 {
1395         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1396
1397         if (caller && !strcmp(cdr->party_a.snapshot->name, caller->name)) {
1398                 cdr_object_swap_snapshot(&cdr->party_a, caller);
1399                 CDR_DEBUG(mod_cfg, "%p - Updated Party A %s snapshot\n", cdr,
1400                                 cdr->party_a.snapshot->name);
1401                 cdr_object_swap_snapshot(&cdr->party_b, peer);
1402                 CDR_DEBUG(mod_cfg, "%p - Updated Party B %s snapshot\n", cdr,
1403                                 cdr->party_b.snapshot->name);
1404         } else if (!strcmp(cdr->party_a.snapshot->name, peer->name)) {
1405                 /* We're the entity being dialed, i.e., outbound origination */
1406                 cdr_object_swap_snapshot(&cdr->party_a, peer);
1407                 CDR_DEBUG(mod_cfg, "%p - Updated Party A %s snapshot\n", cdr,
1408                                 cdr->party_a.snapshot->name);
1409         }
1410
1411         cdr_object_transition_state(cdr, &dial_state_fn_table);
1412         return 0;
1413 }
1414
1415 /*!
1416  * \brief Handle a comparison between our \ref cdr_object and a \ref cdr_object
1417  * already in the bridge while in the Single state. The goal of this is to find
1418  * a Party B for our CDR.
1419  *
1420  * \param cdr Our \ref cdr_object in the Single state
1421  * \param cand_cdr The \ref cdr_object already in the Bridge state
1422  *
1423  * \retval 0 The cand_cdr had a Party A or Party B that we could use as our
1424  * Party B
1425  * \retval 1 No party in the cand_cdr could be used as our Party B
1426  */
1427 static int single_state_bridge_enter_comparison(struct cdr_object *cdr,
1428                 struct cdr_object *cand_cdr)
1429 {
1430         struct cdr_object_snapshot *party_a;
1431
1432         /* Don't match on ourselves */
1433         if (!strcmp(cdr->party_a.snapshot->name, cand_cdr->party_a.snapshot->name)) {
1434                 return 1;
1435         }
1436
1437         /* Try the candidate CDR's Party A first */
1438         party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_a);
1439         if (!strcmp(party_a->snapshot->name, cdr->party_a.snapshot->name)) {
1440                 cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
1441                 if (!cand_cdr->party_b.snapshot) {
1442                         /* We just stole them - finalize their CDR. Note that this won't
1443                          * transition their state, it just sets the end time and the
1444                          * disposition - if we need to re-activate them later, we can.
1445                          */
1446                         cdr_object_finalize(cand_cdr);
1447                 }
1448                 return 0;
1449         }
1450
1451         /* Try their Party B, unless it's us */
1452         if (!cand_cdr->party_b.snapshot || !strcmp(cdr->party_a.snapshot->name, cand_cdr->party_b.snapshot->name)) {
1453                 return 1;
1454         }
1455         party_a = cdr_object_pick_party_a(&cdr->party_a, &cand_cdr->party_b);
1456         if (!strcmp(party_a->snapshot->name, cdr->party_a.snapshot->name)) {
1457                 cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_b);
1458                 return 0;
1459         }
1460
1461         return 1;
1462 }
1463
1464 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)
1465 {
1466         struct ao2_iterator *it_cdrs;
1467         struct cdr_object *cand_cdr_master;
1468         char *bridge_id = ast_strdupa(bridge->uniqueid);
1469         int success = 0;
1470
1471         ast_string_field_set(cdr, bridge, bridge->uniqueid);
1472
1473         /* Get parties in the bridge */
1474         it_cdrs = ao2_callback(active_cdrs_by_channel, OBJ_MULTIPLE,
1475                         cdr_object_bridge_cmp_fn, bridge_id);
1476         if (!it_cdrs) {
1477                 /* No one in the bridge yet! */
1478                 cdr_object_transition_state(cdr, &bridge_state_fn_table);
1479                 return BRIDGE_ENTER_ONLY_PARTY;
1480         }
1481
1482         while ((cand_cdr_master = ao2_iterator_next(it_cdrs))) {
1483                 struct cdr_object *cand_cdr;
1484                 RAII_VAR(struct cdr_object *, cdr_cleanup, cand_cdr_master, ao2_cleanup);
1485                 SCOPED_AO2LOCK(lock, cand_cdr_master);
1486
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         }
1503         ao2_iterator_destroy(it_cdrs);
1504
1505         /* We always transition state, even if we didn't get a peer */
1506         cdr_object_transition_state(cdr, &bridge_state_fn_table);
1507
1508         /* Success implies that we have a Party B */
1509         if (success) {
1510                 return BRIDGE_ENTER_OBTAINED_PARTY_B;
1511         }
1512
1513         return BRIDGE_ENTER_NO_PARTY_B;
1514 }
1515
1516 static int single_state_process_parking_bridge_enter(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge, struct ast_channel_snapshot *channel)
1517 {
1518         cdr_object_transition_state(cdr, &parked_state_fn_table);
1519         return 0;
1520 }
1521
1522
1523 /* DIAL STATE */
1524
1525 static void dial_state_process_party_b(struct cdr_object *cdr, struct ast_channel_snapshot *snapshot)
1526 {
1527         ast_assert(snapshot != NULL);
1528
1529         if (!cdr->party_b.snapshot || strcmp(cdr->party_b.snapshot->name, snapshot->name)) {
1530                 return;
1531         }
1532         cdr_object_swap_snapshot(&cdr->party_b, snapshot);
1533
1534         /* If party B hangs up, finalize this CDR */
1535         if (ast_test_flag(&cdr->party_b.snapshot->flags, AST_FLAG_DEAD)) {
1536                 cdr_object_transition_state(cdr, &finalized_state_fn_table);
1537         }
1538 }
1539
1540 static int dial_state_process_dial_begin(struct cdr_object *cdr, struct ast_channel_snapshot *caller, struct ast_channel_snapshot *peer)
1541 {
1542         /* Don't process a begin dial here. A party A already in the dial state will
1543          * who receives a dial begin for something else will be handled by the
1544          * message router callback and will add a new CDR for the party A */
1545         return 1;
1546 }
1547
1548 /*!
1549  * \internal
1550  * \brief Convert a dial status to a CDR disposition
1551  */
1552 static enum ast_cdr_disposition dial_status_to_disposition(const char *dial_status)
1553 {
1554         RAII_VAR(struct module_config *, mod_cfg,
1555                 ao2_global_obj_ref(module_configs), ao2_cleanup);
1556
1557         if (!strcmp(dial_status, "ANSWER")) {
1558                 return AST_CDR_ANSWERED;
1559         } else if (!strcmp(dial_status, "BUSY")) {
1560                 return AST_CDR_BUSY;
1561         } else if (!strcmp(dial_status, "CANCEL") || !strcmp(dial_status, "NOANSWER")) {
1562                 return AST_CDR_NOANSWER;
1563         } else if (!strcmp(dial_status, "CONGESTION")) {
1564                 if (!ast_test_flag(&mod_cfg->general->settings, CDR_CONGESTION)) {
1565                         return AST_CDR_FAILED;
1566                 } else {
1567                         return AST_CDR_CONGESTION;
1568                 }
1569         } else if (!strcmp(dial_status, "FAILED")) {
1570                 return AST_CDR_FAILED;
1571         }
1572         return AST_CDR_FAILED;
1573 }
1574
1575 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)
1576 {
1577         RAII_VAR(struct module_config *, mod_cfg,
1578                         ao2_global_obj_ref(module_configs), ao2_cleanup);
1579         struct ast_channel_snapshot *party_a;
1580
1581         if (caller) {
1582                 party_a = caller;
1583         } else {
1584                 party_a = peer;
1585         }
1586         ast_assert(!strcmp(cdr->party_a.snapshot->name, party_a->name));
1587         cdr_object_swap_snapshot(&cdr->party_a, party_a);
1588
1589         if (cdr->party_b.snapshot) {
1590                 if (strcmp(cdr->party_b.snapshot->name, peer->name)) {
1591                         /* Not the status for this CDR - defer back to the message router */
1592                         return 1;
1593                 }
1594                 cdr_object_swap_snapshot(&cdr->party_b, peer);
1595         }
1596
1597         /* Set the disposition based on the dial string. */
1598         cdr->disposition = dial_status_to_disposition(dial_status);
1599         if (cdr->disposition == AST_CDR_ANSWERED) {
1600                 /* Switch to dial pending to wait and see what the caller does */
1601                 cdr_object_transition_state(cdr, &dialed_pending_state_fn_table);
1602         } else {
1603                 cdr_object_transition_state(cdr, &finalized_state_fn_table);
1604         }
1605
1606         return 0;
1607 }
1608
1609 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)
1610 {
1611         struct ao2_iterator *it_cdrs;
1612         char *bridge_id = ast_strdupa(bridge->uniqueid);
1613         struct cdr_object *cand_cdr_master;
1614         int success = 0;
1615
1616         ast_string_field_set(cdr, bridge, bridge->uniqueid);
1617
1618         /* Get parties in the bridge */
1619         it_cdrs = ao2_callback(active_cdrs_by_channel, OBJ_MULTIPLE,
1620                         cdr_object_bridge_cmp_fn, bridge_id);
1621         if (!it_cdrs) {
1622                 /* No one in the bridge yet! */
1623                 cdr_object_transition_state(cdr, &bridge_state_fn_table);
1624                 return BRIDGE_ENTER_ONLY_PARTY;
1625         }
1626
1627         while ((cand_cdr_master = ao2_iterator_next(it_cdrs))) {
1628                 struct cdr_object *cand_cdr;
1629                 RAII_VAR(struct cdr_object *, cdr_cleanup, cand_cdr_master, ao2_cleanup);
1630                 SCOPED_AO2LOCK(lock, cand_cdr_master);
1631
1632                 for (cand_cdr = cand_cdr_master; cand_cdr; cand_cdr = cand_cdr->next) {
1633                         /* Skip any records that are not in a bridge or in this bridge.
1634                          * I'm not sure how that would happen, but it pays to be careful. */
1635                         if (cand_cdr->fn_table != &bridge_state_fn_table ||
1636                                         strcmp(cdr->bridge, cand_cdr->bridge)) {
1637                                 continue;
1638                         }
1639
1640                         /* If we don't have a Party B (originated channel), skip it */
1641                         if (!cdr->party_b.snapshot) {
1642                                 continue;
1643                         }
1644
1645                         /* Skip any records that aren't our Party B */
1646                         if (strcmp(cdr->party_b.snapshot->name, cand_cdr->party_a.snapshot->name)) {
1647                                 continue;
1648                         }
1649                         cdr_object_snapshot_copy(&cdr->party_b, &cand_cdr->party_a);
1650                         /* If they have a Party B, they joined up with someone else as their
1651                          * Party A. Don't finalize them as they're active. Otherwise, we
1652                          * have stolen them so they need to be finalized.
1653                          */
1654                         if (!cand_cdr->party_b.snapshot) {
1655                                 cdr_object_finalize(cand_cdr);
1656                         }
1657                         success = 1;
1658                         break;
1659                 }
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         if (!cdr) {
1825                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", caller ? caller->name : peer->name);
1826                 return;
1827         }
1828
1829         ao2_lock(cdr);
1830         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
1831                 if (ast_strlen_zero(dial_status)) {
1832                         if (!it_cdr->fn_table->process_dial_begin) {
1833                                 continue;
1834                         }
1835                         CDR_DEBUG(mod_cfg, "%p - Processing Dial Begin message for channel %s, peer %s\n",
1836                                         cdr,
1837                                         caller ? caller->name : "(none)",
1838                                         peer ? peer->name : "(none)");
1839                         res &= it_cdr->fn_table->process_dial_begin(it_cdr,
1840                                         caller,
1841                                         peer);
1842                 } else {
1843                         if (!it_cdr->fn_table->process_dial_end) {
1844                                 continue;
1845                         }
1846                         CDR_DEBUG(mod_cfg, "%p - Processing Dial End message for channel %s, peer %s\n",
1847                                         cdr,
1848                                         caller ? caller->name : "(none)",
1849                                         peer ? peer->name : "(none)");
1850                         it_cdr->fn_table->process_dial_end(it_cdr,
1851                                         caller,
1852                                         peer,
1853                                         dial_status);
1854                 }
1855         }
1856
1857         /* If no CDR handled a dial begin message, make a new one */
1858         if (res && ast_strlen_zero(dial_status)) {
1859                 struct cdr_object *new_cdr;
1860
1861                 new_cdr = cdr_object_create_and_append(cdr);
1862                 if (!new_cdr) {
1863                         return;
1864                 }
1865                 new_cdr->fn_table->process_dial_begin(new_cdr,
1866                                 caller,
1867                                 peer);
1868         }
1869         ao2_unlock(cdr);
1870 }
1871
1872 static int cdr_object_finalize_party_b(void *obj, void *arg, int flags)
1873 {
1874         struct cdr_object *cdr = obj;
1875         struct ast_channel_snapshot *party_b = arg;
1876         struct cdr_object *it_cdr;
1877         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
1878                 if (it_cdr->party_b.snapshot && !strcmp(it_cdr->party_b.snapshot->name, party_b->name)) {
1879                         /* Don't transition to the finalized state - let the Party A do
1880                          * that when its ready
1881                          */
1882                         cdr_object_finalize(it_cdr);
1883                 }
1884         }
1885         return 0;
1886 }
1887
1888 static int cdr_object_update_party_b(void *obj, void *arg, int flags)
1889 {
1890         struct cdr_object *cdr = obj;
1891         struct ast_channel_snapshot *party_b = arg;
1892         struct cdr_object *it_cdr;
1893         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
1894                 if (!it_cdr->fn_table->process_party_b) {
1895                         continue;
1896                 }
1897                 if (it_cdr->party_b.snapshot && !strcmp(it_cdr->party_b.snapshot->name, party_b->name)) {
1898                         it_cdr->fn_table->process_party_b(it_cdr, party_b);
1899                 }
1900         }
1901         return 0;
1902 }
1903
1904 /*!
1905  * \internal
1906  * \brief Filter channel snapshots by technology
1907  */
1908 static int filter_channel_snapshot(struct ast_channel_snapshot *snapshot)
1909 {
1910         return snapshot->tech_properties & AST_CHAN_TP_INTERNAL;
1911 }
1912
1913 /*!
1914  * \internal
1915  * \brief Filter a channel cache update
1916  */
1917 static int filter_channel_cache_message(struct ast_channel_snapshot *old_snapshot,
1918                 struct ast_channel_snapshot *new_snapshot)
1919 {
1920         int ret = 0;
1921
1922         /* Drop cache updates from certain channel technologies */
1923         if (old_snapshot) {
1924                 ret |= filter_channel_snapshot(old_snapshot);
1925         }
1926         if (new_snapshot) {
1927                 ret |= filter_channel_snapshot(new_snapshot);
1928         }
1929
1930         return ret;
1931 }
1932
1933 /*! \brief Determine if we need to add a new CDR based on snapshots */
1934 static int check_new_cdr_needed(struct ast_channel_snapshot *old_snapshot,
1935                 struct ast_channel_snapshot *new_snapshot)
1936 {
1937         RAII_VAR(struct module_config *, mod_cfg,
1938                         ao2_global_obj_ref(module_configs), ao2_cleanup);
1939
1940         if (!new_snapshot) {
1941                 return 0;
1942         }
1943
1944         if (ast_test_flag(&new_snapshot->flags, AST_FLAG_DEAD)) {
1945                 return 0;
1946         }
1947
1948         /* Auto-fall through will increment the priority but have no application */
1949         if (ast_strlen_zero(new_snapshot->appl)) {
1950                 return 0;
1951         }
1952
1953         if (old_snapshot && !snapshot_cep_changed(old_snapshot, new_snapshot)) {
1954                 return 0;
1955         }
1956
1957         return 1;
1958 }
1959
1960 /*!
1961  * \brief Handler for Stasis-Core channel cache update messages
1962  * \param data Passed on
1963  * \param sub The stasis subscription for this message callback
1964  * \param topic The topic this message was published for
1965  * \param message The message
1966  */
1967 static void handle_channel_cache_message(void *data, struct stasis_subscription *sub, struct stasis_topic *topic, struct stasis_message *message)
1968 {
1969         RAII_VAR(struct cdr_object *, cdr, NULL, ao2_cleanup);
1970         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
1971         struct stasis_cache_update *update = stasis_message_data(message);
1972         struct ast_channel_snapshot *old_snapshot;
1973         struct ast_channel_snapshot *new_snapshot;
1974         const char *name;
1975         struct cdr_object *it_cdr;
1976
1977         ast_assert(update != NULL);
1978         ast_assert(ast_channel_snapshot_type() == update->type);
1979
1980         old_snapshot = stasis_message_data(update->old_snapshot);
1981         new_snapshot = stasis_message_data(update->new_snapshot);
1982         name = new_snapshot ? new_snapshot->name : old_snapshot->name;
1983
1984         if (filter_channel_cache_message(old_snapshot, new_snapshot)) {
1985                 return;
1986         }
1987
1988         CDR_DEBUG(mod_cfg, "Channel Update message for %s: %u.%08u\n",
1989                         name,
1990                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
1991                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
1992
1993         if (new_snapshot && !old_snapshot) {
1994                 cdr = cdr_object_alloc(new_snapshot);
1995                 if (!cdr) {
1996                         return;
1997                 }
1998                 ao2_link(active_cdrs_by_channel, cdr);
1999         }
2000
2001         /* Handle Party A */
2002         if (!cdr) {
2003                 cdr = ao2_find(active_cdrs_by_channel, name, OBJ_KEY);
2004         }
2005         if (!cdr) {
2006                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", name);
2007         } else {
2008                 ao2_lock(cdr);
2009                 if (new_snapshot) {
2010                         int all_reject = 1;
2011                         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2012                                 if (!it_cdr->fn_table->process_party_a) {
2013                                         continue;
2014                                 }
2015                                 CDR_DEBUG(mod_cfg, "%p - Processing new channel snapshot %s\n", it_cdr, new_snapshot->name);
2016                                 all_reject &= it_cdr->fn_table->process_party_a(it_cdr, new_snapshot);
2017                         }
2018                         if (all_reject && check_new_cdr_needed(old_snapshot, new_snapshot)) {
2019                                 /* We're not hung up and we have a new snapshot - we need a new CDR */
2020                                 struct cdr_object *new_cdr;
2021                                 new_cdr = cdr_object_create_and_append(cdr);
2022                                 if (new_cdr) {
2023                                         new_cdr->fn_table->process_party_a(new_cdr, new_snapshot);
2024                                 }
2025                         }
2026                 } else {
2027                         CDR_DEBUG(mod_cfg, "%p - Beginning finalize/dispatch for %s\n", cdr, old_snapshot->name);
2028                         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2029                                 cdr_object_finalize(it_cdr);
2030                         }
2031                         cdr_object_dispatch(cdr);
2032                         ao2_unlink(active_cdrs_by_channel, cdr);
2033                 }
2034                 ao2_unlock(cdr);
2035         }
2036
2037         /* Handle Party B */
2038         if (new_snapshot) {
2039                 ao2_callback(active_cdrs_by_channel, OBJ_NODATA, cdr_object_update_party_b,
2040                         new_snapshot);
2041         } else {
2042                 ao2_callback(active_cdrs_by_channel, OBJ_NODATA, cdr_object_finalize_party_b,
2043                         old_snapshot);
2044         }
2045
2046 }
2047
2048 struct bridge_leave_data {
2049         struct ast_bridge_snapshot *bridge;
2050         struct ast_channel_snapshot *channel;
2051 };
2052
2053 /*! \brief Callback used to notify CDRs of a Party B leaving the bridge */
2054 static int cdr_object_party_b_left_bridge_cb(void *obj, void *arg, int flags)
2055 {
2056         struct cdr_object *cdr = obj;
2057         struct bridge_leave_data *leave_data = arg;
2058         struct cdr_object *it_cdr;
2059
2060         if (strcmp(cdr->bridge, leave_data->bridge->uniqueid)) {
2061                 return 0;
2062         }
2063         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2064                 if (it_cdr->fn_table != &bridge_state_fn_table) {
2065                         continue;
2066                 }
2067                 if (!it_cdr->party_b.snapshot) {
2068                         continue;
2069                 }
2070                 if (strcmp(it_cdr->party_b.snapshot->name, leave_data->channel->name)) {
2071                         continue;
2072                 }
2073                 /* It is our Party B, in our bridge. Set the end time and let the handler
2074                  * transition our CDR appropriately when we leave the bridge.
2075                  */
2076                 cdr_object_finalize(it_cdr);
2077         }
2078         return 0;
2079 }
2080
2081 /*! \brief Filter bridge messages based on bridge technology */
2082 static int filter_bridge_messages(struct ast_bridge_snapshot *bridge)
2083 {
2084         /* Ignore holding bridge technology messages. We treat this simply as an application
2085          * that a channel enters into.
2086          */
2087         if (!strcmp(bridge->technology, "holding_bridge") && strcmp(bridge->subclass, "parking")) {
2088                 return 1;
2089         }
2090         return 0;
2091 }
2092
2093 /*!
2094  * \brief Handler for when a channel leaves a bridge
2095  * \param data Passed on
2096  * \param sub The stasis subscription for this message callback
2097  * \param topic The topic this message was published for
2098  * \param message The message - hopefully a bridge one!
2099  */
2100 static void handle_bridge_leave_message(void *data, struct stasis_subscription *sub,
2101                 struct stasis_topic *topic, struct stasis_message *message)
2102 {
2103         struct ast_bridge_blob *update = stasis_message_data(message);
2104         struct ast_bridge_snapshot *bridge = update->bridge;
2105         struct ast_channel_snapshot *channel = update->channel;
2106         RAII_VAR(struct module_config *, mod_cfg,
2107                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2108         RAII_VAR(struct cdr_object *, cdr,
2109                         ao2_find(active_cdrs_by_channel, channel->name, OBJ_KEY),
2110                         ao2_cleanup);
2111         struct cdr_object *it_cdr;
2112         struct bridge_leave_data leave_data = {
2113                 .bridge = bridge,
2114                 .channel = channel,
2115         };
2116         int left_bridge = 0;
2117
2118         if (filter_bridge_messages(bridge)) {
2119                 return;
2120         }
2121
2122         CDR_DEBUG(mod_cfg, "Bridge Leave message for %s: %u.%08u\n",
2123                         channel->name,
2124                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
2125                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
2126
2127         if (!cdr) {
2128                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->name);
2129                 return;
2130         }
2131
2132         /* Party A */
2133         ao2_lock(cdr);
2134         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2135                 if (!it_cdr->fn_table->process_bridge_leave) {
2136                         continue;
2137                 }
2138                 CDR_DEBUG(mod_cfg, "%p - Processing Bridge Leave for %s\n",
2139                                 it_cdr, channel->name);
2140                 if (!it_cdr->fn_table->process_bridge_leave(it_cdr, bridge, channel)) {
2141                         ast_string_field_set(it_cdr, bridge, "");
2142                         left_bridge = 1;
2143                 }
2144         }
2145         if (!left_bridge) {
2146                 ao2_unlock(cdr);
2147                 return;
2148         }
2149         ao2_unlock(cdr);
2150
2151         if (strcmp(bridge->subclass, "parking")) {
2152                 /* Party B */
2153                 ao2_callback(active_cdrs_by_channel, OBJ_NODATA,
2154                                 cdr_object_party_b_left_bridge_cb,
2155                                 &leave_data);
2156         }
2157 }
2158
2159 struct bridge_candidate {
2160         struct cdr_object *cdr;                                 /*!< The actual CDR this candidate belongs to, either as A or B */
2161         struct cdr_object_snapshot candidate;   /*!< The candidate for a new pairing */
2162 };
2163
2164 /*! \internal
2165  * \brief Comparison function for \ref bridge_candidate objects
2166  */
2167 static int bridge_candidate_cmp_fn(void *obj, void *arg, int flags)
2168 {
2169         struct bridge_candidate *left = obj;
2170         struct bridge_candidate *right = arg;
2171         const char *match = (flags & OBJ_KEY) ? arg : right->candidate.snapshot->name;
2172         return strcasecmp(left->candidate.snapshot->name, match) ? 0 : (CMP_MATCH | CMP_STOP);
2173 }
2174
2175 /*! \internal
2176  * \brief Hash function for \ref bridge_candidate objects
2177  */
2178 static int bridge_candidate_hash_fn(const void *obj, const int flags)
2179 {
2180         const struct bridge_candidate *bc = obj;
2181         const char *id = (flags & OBJ_KEY) ? obj : bc->candidate.snapshot->name;
2182         return ast_str_case_hash(id);
2183 }
2184
2185 /*! \brief \ref bridge_candidate Destructor */
2186 static void bridge_candidate_dtor(void *obj)
2187 {
2188         struct bridge_candidate *bcand = obj;
2189         ao2_cleanup(bcand->cdr);
2190         ao2_cleanup(bcand->candidate.snapshot);
2191         free_variables(&bcand->candidate.variables);
2192 }
2193
2194 /*!
2195  * \brief \ref bridge_candidate Constructor
2196  * \param cdr The \ref cdr_object that is a candidate for being compared to in
2197  *  a bridge operation
2198  * \param candidate The \ref cdr_object_snapshot candidate snapshot in the CDR
2199  *  that should be used during the operaton
2200  */
2201 static struct bridge_candidate *bridge_candidate_alloc(struct cdr_object *cdr, struct cdr_object_snapshot *candidate)
2202 {
2203         struct bridge_candidate *bcand;
2204
2205         bcand = ao2_alloc(sizeof(*bcand), bridge_candidate_dtor);
2206         if (!bcand) {
2207                 return NULL;
2208         }
2209         bcand->cdr = cdr;
2210         ao2_ref(bcand->cdr, +1);
2211         bcand->candidate.flags = candidate->flags;
2212         strcpy(bcand->candidate.userfield, candidate->userfield);
2213         bcand->candidate.snapshot = candidate->snapshot;
2214         ao2_ref(bcand->candidate.snapshot, +1);
2215         copy_variables(&bcand->candidate.variables, &candidate->variables);
2216
2217         return bcand;
2218 }
2219
2220 /*!
2221  * \internal
2222  * \brief Build and add bridge candidates based on a CDR
2223  *
2224  * \param bridge_id The ID of the bridge we need candidates for
2225  * \param candidates The container of \ref bridge_candidate objects
2226  * \param cdr The \ref cdr_object that is our candidate
2227  * \param party_a Non-zero if we should look at the Party A channel; 0 if Party B
2228  */
2229 static void add_candidate_for_bridge(const char *bridge_id,
2230                 struct ao2_container *candidates,
2231                 struct cdr_object *cdr,
2232                 int party_a)
2233 {
2234         struct cdr_object *it_cdr;
2235
2236         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2237                 struct cdr_object_snapshot *party_snapshot;
2238                 RAII_VAR(struct bridge_candidate *, bcand, NULL, ao2_cleanup);
2239
2240                 party_snapshot = party_a ? &it_cdr->party_a : &it_cdr->party_b;
2241
2242                 if (it_cdr->fn_table != &bridge_state_fn_table || strcmp(bridge_id, it_cdr->bridge)) {
2243                         continue;
2244                 }
2245
2246                 if (!party_snapshot->snapshot) {
2247                         continue;
2248                 }
2249
2250                 /* Don't add a party twice */
2251                 bcand = ao2_find(candidates, party_snapshot->snapshot->name, OBJ_KEY);
2252                 if (bcand) {
2253                         continue;
2254                 }
2255
2256                 bcand = bridge_candidate_alloc(it_cdr, party_snapshot);
2257                 if (bcand) {
2258                         ao2_link(candidates, bcand);
2259                 }
2260         }
2261 }
2262
2263 /*!
2264  * \brief Create new \ref bridge_candidate objects for each party currently
2265  * in a bridge
2266  * \param bridge The \param ast_bridge_snapshot for the bridge we're processing
2267  *
2268  * Note that we use two passes here instead of one so that we only create a
2269  * candidate for a party B if they are never a party A in the bridge. Otherwise,
2270  * we don't care about them.
2271  */
2272 static struct ao2_container *create_candidates_for_bridge(struct ast_bridge_snapshot *bridge)
2273 {
2274         struct ao2_container *candidates = ao2_container_alloc(51, bridge_candidate_hash_fn, bridge_candidate_cmp_fn);
2275         char *bridge_id = ast_strdupa(bridge->uniqueid);
2276         struct ao2_iterator *it_cdrs;
2277         struct cdr_object *cand_cdr_master;
2278
2279         if (!candidates) {
2280                 return NULL;
2281         }
2282
2283         /* For each CDR that has a record in the bridge, get their Party A and
2284          * make them a candidate. Note that we do this in two passes as opposed to one so
2285          * that we give preference CDRs where the channel is Party A */
2286         it_cdrs = ao2_callback(active_cdrs_by_channel, OBJ_MULTIPLE,
2287                         cdr_object_bridge_cmp_fn, bridge_id);
2288         if (!it_cdrs) {
2289                 /* No one in the bridge yet! */
2290                 ao2_cleanup(candidates);
2291                 return NULL;
2292         }
2293         for (; (cand_cdr_master = ao2_iterator_next(it_cdrs)); ao2_cleanup(cand_cdr_master)) {
2294                 SCOPED_AO2LOCK(lock, cand_cdr_master);
2295                 add_candidate_for_bridge(bridge->uniqueid, candidates, cand_cdr_master, 1);
2296         }
2297         ao2_iterator_destroy(it_cdrs);
2298         /* For each CDR that has a record in the bridge, get their Party B and
2299          * make them a candidate. */
2300         it_cdrs = ao2_callback(active_cdrs_by_channel, OBJ_MULTIPLE,
2301                         cdr_object_bridge_cmp_fn, bridge_id);
2302         if (!it_cdrs) {
2303                 /* Now it's just an error. */
2304                 ao2_cleanup(candidates);
2305                 return NULL;
2306         }
2307         for (; (cand_cdr_master = ao2_iterator_next(it_cdrs)); ao2_cleanup(cand_cdr_master)) {
2308                 SCOPED_AO2LOCK(lock, cand_cdr_master);
2309                 add_candidate_for_bridge(bridge->uniqueid, candidates, cand_cdr_master, 0);
2310         }
2311         ao2_iterator_destroy(it_cdrs);
2312
2313         return candidates;
2314 }
2315
2316 /*!
2317  * \internal
2318  * \brief Create a new CDR, append it to an existing CDR, and update its snapshots
2319  *
2320  * \note The new CDR will be automatically transitioned to the bridge state
2321  */
2322 static void bridge_candidate_add_to_cdr(struct cdr_object *cdr,
2323                 const char *bridge_id,
2324                 struct cdr_object_snapshot *party_b)
2325 {
2326         struct cdr_object *new_cdr;
2327
2328         new_cdr = cdr_object_create_and_append(cdr);
2329         if (!new_cdr) {
2330                 return;
2331         }
2332         cdr_object_snapshot_copy(&new_cdr->party_b, party_b);
2333         cdr_object_check_party_a_answer(new_cdr);
2334         ast_string_field_set(new_cdr, bridge, cdr->bridge);
2335         cdr_object_transition_state(new_cdr, &bridge_state_fn_table);
2336 }
2337
2338 /*!
2339  * \brief Process a single \ref bridge_candidate. Note that this is called as
2340  * part of an \ref ao2_callback on an \ref ao2_container of \ref bridge_candidate
2341  * objects previously created by \ref create_candidates_for_bridge.
2342  *
2343  * \param obj The \ref bridge_candidate being processed
2344  * \param arg The \ref cdr_object that is being compared against the candidates
2345  *
2346  * The purpose of this function is to create the necessary CDR entries as a
2347  * result of \ref cdr_object having entered the same bridge as the CDR
2348  * represented by \ref bridge_candidate.
2349  */
2350 static int bridge_candidate_process(void *obj, void *arg, int flags)
2351 {
2352         struct bridge_candidate *bcand = obj;
2353         struct cdr_object *cdr = arg;
2354         struct cdr_object_snapshot *party_a;
2355
2356         /* If the candidate is us or someone we've taken on, pass on by */
2357         if (!strcmp(cdr->party_a.snapshot->name, bcand->candidate.snapshot->name)
2358                 || (cdr->party_b.snapshot && !(strcmp(cdr->party_b.snapshot->name, bcand->candidate.snapshot->name)))) {
2359                 return 0;
2360         }
2361         party_a = cdr_object_pick_party_a(&cdr->party_a, &bcand->candidate);
2362         /* We're party A - make a new CDR, append it to us, and set the candidate as
2363          * Party B */
2364         if (!strcmp(party_a->snapshot->name, cdr->party_a.snapshot->name)) {
2365                 bridge_candidate_add_to_cdr(cdr, cdr->bridge, &bcand->candidate);
2366                 return 0;
2367         }
2368
2369         /* We're Party B. Check if the candidate is the CDR's Party A. If so, find out if we
2370          * can add ourselves directly as the Party B, or if we need a new CDR. */
2371         if (!strcmp(bcand->cdr->party_a.snapshot->name, bcand->candidate.snapshot->name)) {
2372                 if (bcand->cdr->party_b.snapshot
2373                                 && strcmp(bcand->cdr->party_b.snapshot->name, cdr->party_a.snapshot->name)) {
2374                         bridge_candidate_add_to_cdr(bcand->cdr, cdr->bridge, &cdr->party_a);
2375                 } else {
2376                         cdr_object_snapshot_copy(&bcand->cdr->party_b, &cdr->party_a);
2377                         /* It's possible that this joined at one point and was never chosen
2378                          * as party A. Clear their end time, as it would be set in such a
2379                          * case.
2380                          */
2381                         memset(&bcand->cdr->end, 0, sizeof(bcand->cdr->end));
2382                 }
2383         } else {
2384                 /* We are Party B to a candidate CDR's Party B. Since a candidate
2385                  * CDR will only have a Party B represented here if that channel
2386                  * was never a Party A in the bridge, we have to go looking for
2387                  * that channel's primary CDR record.
2388                  */
2389                 struct cdr_object *b_party = ao2_find(active_cdrs_by_channel, bcand->candidate.snapshot->name, OBJ_KEY);
2390                 if (!b_party) {
2391                         /* Holy cow - no CDR? */
2392                         b_party = cdr_object_alloc(bcand->candidate.snapshot);
2393                         cdr_object_snapshot_copy(&b_party->party_a, &bcand->candidate);
2394                         cdr_object_snapshot_copy(&b_party->party_b, &cdr->party_a);
2395                         cdr_object_check_party_a_answer(b_party);
2396                         ast_string_field_set(b_party, bridge, cdr->bridge);
2397                         cdr_object_transition_state(b_party, &bridge_state_fn_table);
2398                         ao2_link(active_cdrs_by_channel, b_party);
2399                 } else {
2400                         bridge_candidate_add_to_cdr(b_party, cdr->bridge, &cdr->party_a);
2401                 }
2402                 ao2_ref(b_party, -1);
2403         }
2404
2405         return 0;
2406 }
2407
2408 /*!
2409  * \brief Handle creating bridge pairings for the \ref cdr_object that just
2410  * entered a bridge
2411  * \param cdr The \ref cdr_object that just entered the bridge
2412  * \param bridge The \ref ast_bridge_snapshot representing the bridge it just entered
2413  */
2414 static void handle_bridge_pairings(struct cdr_object *cdr, struct ast_bridge_snapshot *bridge)
2415 {
2416         RAII_VAR(struct ao2_container *, candidates,
2417                         create_candidates_for_bridge(bridge),
2418                         ao2_cleanup);
2419
2420         if (!candidates) {
2421                 return;
2422         }
2423         ao2_callback(candidates, OBJ_NODATA,
2424                         bridge_candidate_process,
2425                         cdr);
2426
2427         return;
2428 }
2429
2430 /*! \brief Handle entering into a parking bridge
2431  * \param cdr The CDR to operate on
2432  * \param bridge The bridge the channel just entered
2433  * \param channel The channel snapshot
2434  */
2435 static void handle_parking_bridge_enter_message(struct cdr_object *cdr,
2436                 struct ast_bridge_snapshot *bridge,
2437                 struct ast_channel_snapshot *channel)
2438 {
2439         RAII_VAR(struct module_config *, mod_cfg,
2440                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2441         int res = 1;
2442         struct cdr_object *it_cdr;
2443         struct cdr_object *new_cdr;
2444
2445         ao2_lock(cdr);
2446
2447         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2448                 if (it_cdr->fn_table->process_parking_bridge_enter) {
2449                         res &= it_cdr->fn_table->process_parking_bridge_enter(it_cdr, bridge, channel);
2450                 }
2451                 if (it_cdr->fn_table->process_party_a) {
2452                         CDR_DEBUG(mod_cfg, "%p - Updating Party A %s snapshot\n", it_cdr,
2453                                         channel->name);
2454                         it_cdr->fn_table->process_party_a(it_cdr, channel);
2455                 }
2456         }
2457
2458         if (res) {
2459                 /* No one handled it - we need a new one! */
2460                 new_cdr = cdr_object_create_and_append(cdr);
2461                 if (new_cdr) {
2462                         /* Let the single state transition us to Parked */
2463                         cdr_object_transition_state(new_cdr, &single_state_fn_table);
2464                         new_cdr->fn_table->process_parking_bridge_enter(new_cdr, bridge, channel);
2465                 }
2466         }
2467         ao2_unlock(cdr);
2468 }
2469
2470 /*! \brief Handle a bridge enter message for a 'normal' bridge
2471  * \param cdr The CDR to operate on
2472  * \param bridge The bridge the channel just entered
2473  * \param channel The channel snapshot
2474  */
2475 static void handle_standard_bridge_enter_message(struct cdr_object *cdr,
2476                 struct ast_bridge_snapshot *bridge,
2477                 struct ast_channel_snapshot *channel)
2478 {
2479         RAII_VAR(struct module_config *, mod_cfg,
2480                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2481         enum process_bridge_enter_results result;
2482         struct cdr_object *it_cdr;
2483         struct cdr_object *new_cdr;
2484         struct cdr_object *handled_cdr = NULL;
2485
2486         ao2_lock(cdr);
2487
2488         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2489                 if (it_cdr->fn_table->process_party_a) {
2490                         CDR_DEBUG(mod_cfg, "%p - Updating Party A %s snapshot\n", it_cdr,
2491                                         channel->name);
2492                         it_cdr->fn_table->process_party_a(it_cdr, channel);
2493                 }
2494
2495                 /* Notify all states that they have entered a bridge */
2496                 if (it_cdr->fn_table->process_bridge_enter) {
2497                         CDR_DEBUG(mod_cfg, "%p - Processing bridge enter for %s\n", it_cdr,
2498                                         channel->name);
2499                         result = it_cdr->fn_table->process_bridge_enter(it_cdr, bridge, channel);
2500                         switch (result) {
2501                         case BRIDGE_ENTER_ONLY_PARTY:
2502                                 /* Fall through */
2503                         case BRIDGE_ENTER_OBTAINED_PARTY_B:
2504                                 if (!handled_cdr) {
2505                                         handled_cdr = it_cdr;
2506                                 }
2507                         break;
2508                         case BRIDGE_ENTER_NEED_CDR:
2509                                 /* Pass */
2510                         break;
2511                         case BRIDGE_ENTER_NO_PARTY_B:
2512                                 /* We didn't win on any - end this CDR. If someone else comes in later
2513                                  * that is Party B to this CDR, it can re-activate this CDR.
2514                                  */
2515                                 if (!handled_cdr) {
2516                                         handled_cdr = it_cdr;
2517                                 }
2518                                 cdr_object_finalize(cdr);
2519                         break;
2520                         }
2521                 }
2522         }
2523
2524         /* Create the new matchings, but only for either:
2525          *  * The first CDR in the chain that handled it. This avoids issues with
2526          *    forked CDRs.
2527          *  * If no one handled it, the last CDR in the chain. This would occur if
2528          *    a CDR joined a bridge and it wasn't Party A for anyone. We still need
2529          *    to make pairings with everyone in the bridge.
2530          */
2531         if (handled_cdr) {
2532                 handle_bridge_pairings(handled_cdr, bridge);
2533         } else {
2534                 /* Nothing handled it - we need a new one! */
2535                 new_cdr = cdr_object_create_and_append(cdr);
2536                 if (new_cdr) {
2537                         /* This is guaranteed to succeed: the new CDR is created in the single state
2538                          * and will be able to handle the bridge enter message
2539                          */
2540                         handle_standard_bridge_enter_message(cdr, bridge, channel);
2541                 }
2542         }
2543         ao2_unlock(cdr);
2544 }
2545
2546 /*!
2547  * \brief Handler for Stasis-Core bridge enter messages
2548  * \param data Passed on
2549  * \param sub The stasis subscription for this message callback
2550  * \param topic The topic this message was published for
2551  * \param message The message - hopefully a bridge one!
2552  */
2553 static void handle_bridge_enter_message(void *data, struct stasis_subscription *sub,
2554                 struct stasis_topic *topic, struct stasis_message *message)
2555 {
2556         struct ast_bridge_blob *update = stasis_message_data(message);
2557         struct ast_bridge_snapshot *bridge = update->bridge;
2558         struct ast_channel_snapshot *channel = update->channel;
2559         RAII_VAR(struct cdr_object *, cdr,
2560                         ao2_find(active_cdrs_by_channel, channel->name, OBJ_KEY),
2561                         ao2_cleanup);
2562         RAII_VAR(struct module_config *, mod_cfg,
2563                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2564
2565         if (filter_bridge_messages(bridge)) {
2566                 return;
2567         }
2568
2569         CDR_DEBUG(mod_cfg, "Bridge Enter message for channel %s: %u.%08u\n",
2570                         channel->name,
2571                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
2572                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
2573
2574         if (!cdr) {
2575                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->name);
2576                 return;
2577         }
2578
2579         if (!strcmp(bridge->subclass, "parking")) {
2580                 handle_parking_bridge_enter_message(cdr, bridge, channel);
2581         } else {
2582                 handle_standard_bridge_enter_message(cdr, bridge, channel);
2583         }
2584 }
2585
2586 /*!
2587  * \brief Handler for when a channel is parked
2588  * \param data Passed on
2589  * \param sub The stasis subscription for this message callback
2590  * \param topic The topic this message was published for
2591  * \param message The message about who got parked
2592  * */
2593 static void handle_parked_call_message(void *data, struct stasis_subscription *sub,
2594                 struct stasis_topic *topic, struct stasis_message *message)
2595 {
2596         struct ast_parked_call_payload *payload = stasis_message_data(message);
2597         struct ast_channel_snapshot *channel = payload->parkee;
2598         RAII_VAR(struct cdr_object *, cdr, NULL, ao2_cleanup);
2599         RAII_VAR(struct module_config *, mod_cfg,
2600                         ao2_global_obj_ref(module_configs), ao2_cleanup);
2601         struct cdr_object *it_cdr;
2602
2603         /* Anything other than getting parked will be handled by other updates */
2604         if (payload->event_type != PARKED_CALL) {
2605                 return;
2606         }
2607
2608         /* No one got parked? */
2609         if (!channel) {
2610                 return;
2611         }
2612
2613         CDR_DEBUG(mod_cfg, "Parked Call message for channel %s: %u.%08u\n",
2614                         channel->name,
2615                         (unsigned int)stasis_message_timestamp(message)->tv_sec,
2616                         (unsigned int)stasis_message_timestamp(message)->tv_usec);
2617
2618         cdr = ao2_find(active_cdrs_by_channel, channel->name, OBJ_KEY);
2619         if (!cdr) {
2620                 ast_log(AST_LOG_WARNING, "No CDR for channel %s\n", channel->name);
2621                 return;
2622         }
2623
2624         ao2_lock(cdr);
2625
2626         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2627                 if (it_cdr->fn_table->process_parked_channel) {
2628                         it_cdr->fn_table->process_parked_channel(it_cdr, payload);
2629                 }
2630         }
2631
2632         ao2_unlock(cdr);
2633
2634 }
2635
2636 struct ast_cdr_config *ast_cdr_get_config(void)
2637 {
2638         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
2639         ao2_ref(mod_cfg->general, +1);
2640         return mod_cfg->general;
2641 }
2642
2643 void ast_cdr_set_config(struct ast_cdr_config *config)
2644 {
2645         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
2646         ao2_cleanup(mod_cfg->general);
2647         mod_cfg->general = config;
2648         ao2_ref(mod_cfg->general, +1);
2649 }
2650
2651 int ast_cdr_is_enabled(void)
2652 {
2653         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
2654         return ast_test_flag(&mod_cfg->general->settings, CDR_ENABLED);
2655 }
2656
2657 int ast_cdr_register(const char *name, const char *desc, ast_cdrbe be)
2658 {
2659         struct cdr_beitem *i = NULL;
2660
2661         if (!name)
2662                 return -1;
2663
2664         if (!be) {
2665                 ast_log(LOG_WARNING, "CDR engine '%s' lacks backend\n", name);
2666                 return -1;
2667         }
2668
2669         AST_RWLIST_WRLOCK(&be_list);
2670         AST_RWLIST_TRAVERSE(&be_list, i, list) {
2671                 if (!strcasecmp(name, i->name)) {
2672                         ast_log(LOG_WARNING, "Already have a CDR backend called '%s'\n", name);
2673                         AST_RWLIST_UNLOCK(&be_list);
2674                         return -1;
2675                 }
2676         }
2677
2678         if (!(i = ast_calloc(1, sizeof(*i))))
2679                 return -1;
2680
2681         i->be = be;
2682         ast_copy_string(i->name, name, sizeof(i->name));
2683         ast_copy_string(i->desc, desc, sizeof(i->desc));
2684
2685         AST_RWLIST_INSERT_HEAD(&be_list, i, list);
2686         AST_RWLIST_UNLOCK(&be_list);
2687
2688         return 0;
2689 }
2690
2691 void ast_cdr_unregister(const char *name)
2692 {
2693         struct cdr_beitem *i = NULL;
2694
2695         AST_RWLIST_WRLOCK(&be_list);
2696         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&be_list, i, list) {
2697                 if (!strcasecmp(name, i->name)) {
2698                         AST_RWLIST_REMOVE_CURRENT(list);
2699                         break;
2700                 }
2701         }
2702         AST_RWLIST_TRAVERSE_SAFE_END;
2703         AST_RWLIST_UNLOCK(&be_list);
2704
2705         if (i) {
2706                 ast_verb(2, "Unregistered '%s' CDR backend\n", name);
2707                 ast_free(i);
2708         }
2709 }
2710
2711 struct ast_cdr *ast_cdr_dup(struct ast_cdr *cdr)
2712 {
2713         struct ast_cdr *newcdr;
2714
2715         if (!cdr) {
2716                 return NULL;
2717         }
2718         newcdr = ast_cdr_alloc();
2719         if (!newcdr) {
2720                 return NULL;
2721         }
2722
2723         memcpy(newcdr, cdr, sizeof(*newcdr));
2724         memset(&newcdr->varshead, 0, sizeof(newcdr->varshead));
2725         copy_variables(&newcdr->varshead, &cdr->varshead);
2726         newcdr->next = NULL;
2727
2728         return newcdr;
2729 }
2730
2731 static const char *cdr_format_var_internal(struct ast_cdr *cdr, const char *name)
2732 {
2733         struct ast_var_t *variables;
2734         struct varshead *headp = &cdr->varshead;
2735
2736         if (ast_strlen_zero(name)) {
2737                 return NULL;
2738         }
2739
2740         AST_LIST_TRAVERSE(headp, variables, entries) {
2741                 if (!strcasecmp(name, ast_var_name(variables))) {
2742                         return ast_var_value(variables);
2743                 }
2744         }
2745
2746         return '\0';
2747 }
2748
2749 static void cdr_get_tv(struct timeval when, const char *fmt, char *buf, int bufsize)
2750 {
2751         if (fmt == NULL) {      /* raw mode */
2752                 snprintf(buf, bufsize, "%ld.%06ld", (long)when.tv_sec, (long)when.tv_usec);
2753         } else {
2754                 if (when.tv_sec) {
2755                         struct ast_tm tm;
2756
2757                         ast_localtime(&when, &tm, NULL);
2758                         ast_strftime(buf, bufsize, fmt, &tm);
2759                 }
2760         }
2761 }
2762
2763 void ast_cdr_format_var(struct ast_cdr *cdr, const char *name, char **ret, char *workspace, int workspacelen, int raw)
2764 {
2765         const char *fmt = "%Y-%m-%d %T";
2766         const char *varbuf;
2767
2768         if (!cdr) {
2769                 return;
2770         }
2771
2772         *ret = NULL;
2773
2774         if (!strcasecmp(name, "clid")) {
2775                 ast_copy_string(workspace, cdr->clid, workspacelen);
2776         } else if (!strcasecmp(name, "src")) {
2777                 ast_copy_string(workspace, cdr->src, workspacelen);
2778         } else if (!strcasecmp(name, "dst")) {
2779                 ast_copy_string(workspace, cdr->dst, workspacelen);
2780         } else if (!strcasecmp(name, "dcontext")) {
2781                 ast_copy_string(workspace, cdr->dcontext, workspacelen);
2782         } else if (!strcasecmp(name, "channel")) {
2783                 ast_copy_string(workspace, cdr->channel, workspacelen);
2784         } else if (!strcasecmp(name, "dstchannel")) {
2785                 ast_copy_string(workspace, cdr->dstchannel, workspacelen);
2786         } else if (!strcasecmp(name, "lastapp")) {
2787                 ast_copy_string(workspace, cdr->lastapp, workspacelen);
2788         } else if (!strcasecmp(name, "lastdata")) {
2789                 ast_copy_string(workspace, cdr->lastdata, workspacelen);
2790         } else if (!strcasecmp(name, "start")) {
2791                 cdr_get_tv(cdr->start, raw ? NULL : fmt, workspace, workspacelen);
2792         } else if (!strcasecmp(name, "answer")) {
2793                 cdr_get_tv(cdr->answer, raw ? NULL : fmt, workspace, workspacelen);
2794         } else if (!strcasecmp(name, "end")) {
2795                 cdr_get_tv(cdr->end, raw ? NULL : fmt, workspace, workspacelen);
2796         } else if (!strcasecmp(name, "duration")) {
2797                 snprintf(workspace, workspacelen, "%ld", cdr->end.tv_sec != 0 ? cdr->duration : (long)ast_tvdiff_ms(ast_tvnow(), cdr->start) / 1000);
2798         } else if (!strcasecmp(name, "billsec")) {
2799                 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);
2800         } else if (!strcasecmp(name, "disposition")) {
2801                 if (raw) {
2802                         snprintf(workspace, workspacelen, "%ld", cdr->disposition);
2803                 } else {
2804                         ast_copy_string(workspace, ast_cdr_disp2str(cdr->disposition), workspacelen);
2805                 }
2806         } else if (!strcasecmp(name, "amaflags")) {
2807                 if (raw) {
2808                         snprintf(workspace, workspacelen, "%ld", cdr->amaflags);
2809                 } else {
2810                         ast_copy_string(workspace, ast_channel_amaflags2string(cdr->amaflags), workspacelen);
2811                 }
2812         } else if (!strcasecmp(name, "accountcode")) {
2813                 ast_copy_string(workspace, cdr->accountcode, workspacelen);
2814         } else if (!strcasecmp(name, "peeraccount")) {
2815                 ast_copy_string(workspace, cdr->peeraccount, workspacelen);
2816         } else if (!strcasecmp(name, "uniqueid")) {
2817                 ast_copy_string(workspace, cdr->uniqueid, workspacelen);
2818         } else if (!strcasecmp(name, "linkedid")) {
2819                 ast_copy_string(workspace, cdr->linkedid, workspacelen);
2820         } else if (!strcasecmp(name, "userfield")) {
2821                 ast_copy_string(workspace, cdr->userfield, workspacelen);
2822         } else if (!strcasecmp(name, "sequence")) {
2823                 snprintf(workspace, workspacelen, "%d", cdr->sequence);
2824         } else if ((varbuf = cdr_format_var_internal(cdr, name))) {
2825                 ast_copy_string(workspace, varbuf, workspacelen);
2826         } else {
2827                 workspace[0] = '\0';
2828         }
2829
2830         if (!ast_strlen_zero(workspace)) {
2831                 *ret = workspace;
2832         }
2833 }
2834
2835 /*
2836  * \internal
2837  * \brief Callback that finds all CDRs that reference a particular channel
2838  */
2839 static int cdr_object_select_all_by_channel_cb(void *obj, void *arg, int flags)
2840 {
2841         struct cdr_object *cdr = obj;
2842         const char *name = arg;
2843
2844         if (!strcasecmp(cdr->party_a.snapshot->name, name) ||
2845                         (cdr->party_b.snapshot && !strcasecmp(cdr->party_b.snapshot->name, name))) {
2846                 return CMP_MATCH;
2847         }
2848         return 0;
2849 }
2850
2851 /* Read Only CDR variables */
2852 static const char * const cdr_readonly_vars[] = { "clid", "src", "dst", "dcontext",
2853         "channel", "dstchannel", "lastapp", "lastdata", "start", "answer", "end", "duration",
2854         "billsec", "disposition", "amaflags", "accountcode", "uniqueid", "linkedid",
2855         "userfield", "sequence", "total_duration", "total_billsec", "first_start",
2856         "first_answer", NULL };
2857
2858 int ast_cdr_setvar(const char *channel_name, const char *name, const char *value)
2859 {
2860         struct cdr_object *cdr;
2861         struct cdr_object *it_cdr;
2862         struct ao2_iterator *it_cdrs;
2863         char *arg = ast_strdupa(channel_name);
2864         int x;
2865
2866         for (x = 0; cdr_readonly_vars[x]; x++) {
2867                 if (!strcasecmp(name, cdr_readonly_vars[x])) {
2868                         ast_log(LOG_ERROR, "Attempt to set the '%s' read-only variable!\n", name);
2869                         return -1;
2870                 }
2871         }
2872
2873         it_cdrs = ao2_callback(active_cdrs_by_channel, OBJ_MULTIPLE, cdr_object_select_all_by_channel_cb, arg);
2874         if (!it_cdrs) {
2875                 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
2876                 return -1;
2877         }
2878
2879         for (; (cdr = ao2_iterator_next(it_cdrs)); ao2_unlock(cdr), ao2_cleanup(cdr)) {
2880                 ao2_lock(cdr);
2881                 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
2882                         struct varshead *headp = NULL;
2883                         if (it_cdr->fn_table == &finalized_state_fn_table) {
2884                                 continue;
2885                         }
2886                         if (!strcmp(channel_name, it_cdr->party_a.snapshot->name)) {
2887                                 headp = &it_cdr->party_a.variables;
2888                         } else if (it_cdr->party_b.snapshot && !strcmp(channel_name, it_cdr->party_b.snapshot->name)) {
2889                                 headp = &it_cdr->party_b.variables;
2890                         }
2891                         if (headp) {
2892                                 set_variable(headp, name, value);
2893                         }
2894                 }
2895         }
2896         ao2_iterator_destroy(it_cdrs);
2897
2898         return 0;
2899 }
2900
2901 /*!
2902  * \brief Format a variable on a \ref cdr_object
2903  */
2904 static void cdr_object_format_var_internal(struct cdr_object *cdr, const char *name, char *value, size_t length)
2905 {
2906         struct ast_var_t *variable;
2907
2908         AST_LIST_TRAVERSE(&cdr->party_a.variables, variable, entries) {
2909                 if (!strcasecmp(name, ast_var_name(variable))) {
2910                         ast_copy_string(value, ast_var_value(variable), length);
2911                         return;
2912                 }
2913         }
2914
2915         *value = '\0';
2916 }
2917
2918 /*!
2919  * \brief Format one of the standard properties on a \ref cdr_object
2920  */
2921 static int cdr_object_format_property(struct cdr_object *cdr_obj, const char *name, char *value, size_t length)
2922 {
2923         struct ast_channel_snapshot *party_a = cdr_obj->party_a.snapshot;
2924         struct ast_channel_snapshot *party_b = cdr_obj->party_b.snapshot;
2925
2926         if (!strcasecmp(name, "clid")) {
2927                 ast_callerid_merge(value, length, party_a->caller_name, party_a->caller_number, "");
2928         } else if (!strcasecmp(name, "src")) {
2929                 ast_copy_string(value, party_a->caller_number, length);
2930         } else if (!strcasecmp(name, "dst")) {
2931                 ast_copy_string(value, party_a->exten, length);
2932         } else if (!strcasecmp(name, "dcontext")) {
2933                 ast_copy_string(value, party_a->context, length);
2934         } else if (!strcasecmp(name, "channel")) {
2935                 ast_copy_string(value, party_a->name, length);
2936         } else if (!strcasecmp(name, "dstchannel")) {
2937                 if (party_b) {
2938                         ast_copy_string(value, party_b->name, length);
2939                 } else {
2940                         ast_copy_string(value, "", length);
2941                 }
2942         } else if (!strcasecmp(name, "lastapp")) {
2943                 ast_copy_string(value, party_a->appl, length);
2944         } else if (!strcasecmp(name, "lastdata")) {
2945                 ast_copy_string(value, party_a->data, length);
2946         } else if (!strcasecmp(name, "start")) {
2947                 cdr_get_tv(cdr_obj->start, NULL, value, length);
2948         } else if (!strcasecmp(name, "answer")) {
2949                 cdr_get_tv(cdr_obj->answer, NULL, value, length);
2950         } else if (!strcasecmp(name, "end")) {
2951                 cdr_get_tv(cdr_obj->end, NULL, value, length);
2952         } else if (!strcasecmp(name, "duration")) {
2953                 snprintf(value, length, "%ld", cdr_object_get_duration(cdr_obj));
2954         } else if (!strcasecmp(name, "billsec")) {
2955                 snprintf(value, length, "%ld", cdr_object_get_billsec(cdr_obj));
2956         } else if (!strcasecmp(name, "disposition")) {
2957                 snprintf(value, length, "%d", cdr_obj->disposition);
2958         } else if (!strcasecmp(name, "amaflags")) {
2959                 snprintf(value, length, "%d", party_a->amaflags);
2960         } else if (!strcasecmp(name, "accountcode")) {
2961                 ast_copy_string(value, party_a->accountcode, length);
2962         } else if (!strcasecmp(name, "peeraccount")) {
2963                 if (party_b) {
2964                         ast_copy_string(value, party_b->accountcode, length);
2965                 } else {
2966                         ast_copy_string(value, "", length);
2967                 }
2968         } else if (!strcasecmp(name, "uniqueid")) {
2969                 ast_copy_string(value, party_a->uniqueid, length);
2970         } else if (!strcasecmp(name, "linkedid")) {
2971                 ast_copy_string(value, cdr_obj->linkedid, length);
2972         } else if (!strcasecmp(name, "userfield")) {
2973                 ast_copy_string(value, cdr_obj->party_a.userfield, length);
2974         } else if (!strcasecmp(name, "sequence")) {
2975                 snprintf(value, length, "%d", cdr_obj->sequence);
2976         } else {
2977                 return 1;
2978         }
2979
2980         return 0;
2981 }
2982
2983 int ast_cdr_getvar(const char *channel_name, const char *name, char *value, size_t length)
2984 {
2985         RAII_VAR(struct cdr_object *, cdr,
2986                 ao2_find(active_cdrs_by_channel, channel_name, OBJ_KEY),
2987                 ao2_cleanup);
2988         struct cdr_object *cdr_obj;
2989
2990         if (!cdr) {
2991                 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
2992                 return 1;
2993         }
2994
2995         if (ast_strlen_zero(name)) {
2996                 return 1;
2997         }
2998
2999         ao2_lock(cdr);
3000
3001         cdr_obj = cdr->last;
3002         if (cdr_object_format_property(cdr_obj, name, value, length)) {
3003                 /* Property failed; attempt variable */
3004                 cdr_object_format_var_internal(cdr_obj, name, value, length);
3005         }
3006
3007         ao2_unlock(cdr);
3008
3009         return 0;
3010 }
3011
3012 int ast_cdr_serialize_variables(const char *channel_name, struct ast_str **buf, char delim, char sep)
3013 {
3014         RAII_VAR(struct cdr_object *, cdr,
3015                 ao2_find(active_cdrs_by_channel, channel_name, OBJ_KEY),
3016                 ao2_cleanup);
3017         struct cdr_object *it_cdr;
3018         struct ast_var_t *variable;
3019         const char *var;
3020         RAII_VAR(char *, workspace, ast_malloc(256), ast_free);
3021         int total = 0, x = 0, i;
3022
3023         if (!workspace) {
3024                 return 1;
3025         }
3026
3027         if (!cdr) {
3028                 ast_log(AST_LOG_ERROR, "Unable to find CDR for channel %s\n", channel_name);
3029                 return 1;
3030         }
3031
3032         ast_str_reset(*buf);
3033
3034         ao2_lock(cdr);
3035         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3036                 if (++x > 1)
3037                         ast_str_append(buf, 0, "\n");
3038
3039                 AST_LIST_TRAVERSE(&it_cdr->party_a.variables, variable, entries) {
3040                         if (!(var = ast_var_name(variable))) {
3041                                 continue;
3042                         }
3043
3044                         if (ast_str_append(buf, 0, "level %d: %s%c%s%c", x, var, delim, S_OR(ast_var_value(variable), ""), sep) < 0) {
3045                                 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
3046                                 break;
3047                         }
3048
3049                         total++;
3050                 }
3051
3052                 for (i = 0; cdr_readonly_vars[i]; i++) {
3053                         /* null out the workspace, because the cdr_get_tv() won't write anything if time is NULL, so you get old vals */
3054                         workspace[0] = 0;
3055                         cdr_object_format_property(it_cdr, cdr_readonly_vars[i], workspace, sizeof(workspace));
3056
3057                         if (!ast_strlen_zero(workspace)
3058                                 && ast_str_append(buf, 0, "level %d: %s%c%s%c", x, cdr_readonly_vars[i], delim, workspace, sep) < 0) {
3059                                 ast_log(LOG_ERROR, "Data Buffer Size Exceeded!\n");
3060                                 break;
3061                         }
3062                         total++;
3063                 }
3064         }
3065         ao2_unlock(cdr);
3066         return total;
3067 }
3068
3069 void ast_cdr_free(struct ast_cdr *cdr)
3070 {
3071         while (cdr) {
3072                 struct ast_cdr *next = cdr->next;
3073
3074                 free_variables(&cdr->varshead);
3075                 ast_free(cdr);
3076                 cdr = next;
3077         }
3078 }
3079
3080 struct ast_cdr *ast_cdr_alloc(void)
3081 {
3082         struct ast_cdr *x;
3083
3084         x = ast_calloc(1, sizeof(*x));
3085         return x;
3086 }
3087
3088 const char *ast_cdr_disp2str(int disposition)
3089 {
3090         switch (disposition) {
3091         case AST_CDR_NULL:
3092                 return "NO ANSWER"; /* by default, for backward compatibility */
3093         case AST_CDR_NOANSWER:
3094                 return "NO ANSWER";
3095         case AST_CDR_FAILED:
3096                 return "FAILED";
3097         case AST_CDR_BUSY:
3098                 return "BUSY";
3099         case AST_CDR_ANSWERED:
3100                 return "ANSWERED";
3101         case AST_CDR_CONGESTION:
3102                 return "CONGESTION";
3103         }
3104         return "UNKNOWN";
3105 }
3106
3107 struct party_b_userfield_update {
3108         const char *channel_name;
3109         const char *userfield;
3110 };
3111
3112 /*! \brief Callback used to update the userfield on Party B on all CDRs */
3113 static int cdr_object_update_party_b_userfield_cb(void *obj, void *arg, int flags)
3114 {
3115         struct cdr_object *cdr = obj;
3116         struct party_b_userfield_update *info = arg;
3117         struct cdr_object *it_cdr;
3118         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3119                 if (it_cdr->fn_table == &finalized_state_fn_table) {
3120                         continue;
3121                 }
3122                 if (it_cdr->party_b.snapshot
3123                         && !strcmp(it_cdr->party_b.snapshot->name, info->channel_name)) {
3124                         strcpy(it_cdr->party_b.userfield, info->userfield);
3125                 }
3126         }
3127         return 0;
3128 }
3129
3130 void ast_cdr_setuserfield(const char *channel_name, const char *userfield)
3131 {
3132         RAII_VAR(struct cdr_object *, cdr,
3133                         ao2_find(active_cdrs_by_channel, channel_name, OBJ_KEY),
3134                         ao2_cleanup);
3135         struct party_b_userfield_update party_b_info = {
3136                         .channel_name = channel_name,
3137                         .userfield = userfield,
3138         };
3139         struct cdr_object *it_cdr;
3140
3141         /* Handle Party A */
3142         if (cdr) {
3143                 ao2_lock(cdr);
3144                 for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3145                         if (it_cdr->fn_table == &finalized_state_fn_table) {
3146                                 continue;
3147                         }
3148                         strcpy(it_cdr->party_a.userfield, userfield);
3149                 }
3150                 ao2_unlock(cdr);
3151         }
3152
3153         /* Handle Party B */
3154         ao2_callback(active_cdrs_by_channel, OBJ_NODATA,
3155                         cdr_object_update_party_b_userfield_cb,
3156                         &party_b_info);
3157
3158 }
3159
3160 static void post_cdr(struct ast_cdr *cdr)
3161 {
3162         RAII_VAR(struct module_config *, mod_cfg, ao2_global_obj_ref(module_configs), ao2_cleanup);
3163         struct cdr_beitem *i;
3164
3165         for (; cdr ; cdr = cdr->next) {
3166                 /* For people, who don't want to see unanswered single-channel events */
3167                 if (!ast_test_flag(&mod_cfg->general->settings, CDR_UNANSWERED) &&
3168                                 cdr->disposition < AST_CDR_ANSWERED &&
3169                                 (ast_strlen_zero(cdr->channel) || ast_strlen_zero(cdr->dstchannel))) {
3170                         ast_debug(1, "Skipping CDR  for %s since we weren't answered\n", cdr->channel);
3171                         continue;
3172                 }
3173
3174                 if (ast_test_flag(cdr, AST_CDR_FLAG_DISABLE)) {
3175                         continue;
3176                 }
3177                 AST_RWLIST_RDLOCK(&be_list);
3178                 AST_RWLIST_TRAVERSE(&be_list, i, list) {
3179                         i->be(cdr);
3180                 }
3181                 AST_RWLIST_UNLOCK(&be_list);
3182         }
3183 }
3184
3185 int ast_cdr_set_property(const char *channel_name, enum ast_cdr_options option)
3186 {
3187         RAII_VAR(struct cdr_object *, cdr,
3188                         ao2_find(active_cdrs_by_channel, channel_name, OBJ_KEY),
3189                         ao2_cleanup);
3190         struct cdr_object *it_cdr;
3191
3192         if (!cdr) {
3193                 return -1;
3194         }
3195
3196         ao2_lock(cdr);
3197         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3198                 if (it_cdr->fn_table == &finalized_state_fn_table) {
3199                         continue;
3200                 }
3201                 /* Note: in general, set the flags on both the CDR record as well as the
3202                  * Party A. Sometimes all we have is the Party A to look at.
3203                  */
3204                 ast_set_flag(&it_cdr->flags, option);
3205                 ast_set_flag(&it_cdr->party_a, option);
3206         }
3207         ao2_unlock(cdr);
3208
3209         return 0;
3210 }
3211
3212 int ast_cdr_clear_property(const char *channel_name, enum ast_cdr_options option)
3213 {
3214         RAII_VAR(struct cdr_object *, cdr,
3215                         ao2_find(active_cdrs_by_channel, channel_name, OBJ_KEY),
3216                         ao2_cleanup);
3217         struct cdr_object *it_cdr;
3218
3219         if (!cdr) {
3220                 return -1;
3221         }
3222
3223         ao2_lock(cdr);
3224         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3225                 if (it_cdr->fn_table == &finalized_state_fn_table) {
3226                         continue;
3227                 }
3228                 ast_clear_flag(&it_cdr->flags, option);
3229         }
3230         ao2_unlock(cdr);
3231
3232         return 0;
3233 }
3234
3235 int ast_cdr_reset(const char *channel_name, struct ast_flags *options)
3236 {
3237         RAII_VAR(struct cdr_object *, cdr,
3238                         ao2_find(active_cdrs_by_channel, channel_name, OBJ_KEY),
3239                         ao2_cleanup);
3240         struct ast_var_t *vardata;
3241         struct cdr_object *it_cdr;
3242
3243         if (!cdr) {
3244                 return -1;
3245         }
3246
3247         ao2_lock(cdr);
3248         for (it_cdr = cdr; it_cdr; it_cdr = it_cdr->next) {
3249                 /* clear variables */
3250                 if (!ast_test_flag(options, AST_CDR_FLAG_KEEP_VARS)) {
3251                         while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_a.variables, entries))) {
3252                                 ast_var_delete(vardata);
3253                         }
3254                         if (cdr->party_b.snapshot) {
3255                                 while ((vardata = AST_LIST_REMOVE_HEAD(&it_cdr->party_b.variables, entries))) {
3256                                         ast_var_delete(vardata);
3257                                 }
3258                         }
3259                 }
3260
3261                 /* Reset to initial state */
3262                 memset(&it_cdr->start, 0, sizeof(it_cdr->start));
3263                 memset(&it_cdr->end, 0, sizeof(it_cdr->end));
3264                 memset(&it_cdr->answer, 0, sizeof(it_cdr->answer));
3265                 it_cdr->start = ast_tvnow();
3266                 cdr_object_check_party_a_answer(it_cdr);
3267         }
3268         ao2_unlock(cdr);
3269
3270         return 0;
3271 }
3272
3273 int ast_cdr_fork(const char *channel_name, struct ast_flags