Fix DEBUG_THREADS when lock is acquired in __constructor__
[asterisk/asterisk.git] / main / cel.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2007 - 2009, Digium, Inc.
5  *
6  * See http://www.asterisk.org for more information about
7  * the Asterisk project. Please do not directly contact
8  * any of the maintainers of this project for assistance;
9  * the project provides a web site, mailing lists and IRC
10  * channels for your use.
11  *
12  * This program is free software, distributed under the terms of
13  * the GNU General Public License Version 2. See the LICENSE file
14  * at the top of the source tree.
15  */
16
17 /*!
18  * \file
19  *
20  * \brief Channel Event Logging API
21  *
22  * \author Steve Murphy <murf@digium.com>
23  * \author Russell Bryant <russell@digium.com>
24  */
25
26 /*! \li \ref cel.c uses the configuration file \ref cel.conf
27  * \addtogroup configuration_file Configuration Files
28  */
29
30 /*!
31  * \page cel.conf cel.conf
32  * \verbinclude cel.conf.sample
33  */
34
35 /*** MODULEINFO
36         <support_level>core</support_level>
37  ***/
38
39 #include "asterisk.h"
40
41 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
42
43 #include "asterisk/_private.h"
44
45 #include "asterisk/channel.h"
46 #include "asterisk/pbx.h"
47 #include "asterisk/cel.h"
48 #include "asterisk/logger.h"
49 #include "asterisk/linkedlists.h"
50 #include "asterisk/utils.h"
51 #include "asterisk/config.h"
52 #include "asterisk/config_options.h"
53 #include "asterisk/cli.h"
54 #include "asterisk/astobj2.h"
55 #include "asterisk/stasis_message_router.h"
56 #include "asterisk/stasis_channels.h"
57 #include "asterisk/stasis_bridges.h"
58 #include "asterisk/bridge.h"
59 #include "asterisk/parking.h"
60 #include "asterisk/pickup.h"
61 #include "asterisk/core_local.h"
62
63 /*** DOCUMENTATION
64         <configInfo name="cel" language="en_US">
65                 <configFile name="cel.conf">
66                         <configObject name="general">
67                                 <synopsis>Options that apply globally to Channel Event Logging (CEL)</synopsis>
68                                 <configOption name="enable">
69                                         <synopsis>Determines whether CEL is enabled</synopsis>
70                                 </configOption>
71                                 <configOption name="dateformat">
72                                         <synopsis>The format to be used for dates when logging</synopsis>
73                                 </configOption>
74                                 <configOption name="apps">
75                                         <synopsis>List of apps for CEL to track</synopsis>
76                                         <description><para>A case-insensitive, comma-separated list of applications
77                                         to track when one or both of APP_START and APP_END events are flagged for
78                                         tracking</para></description>
79                                 </configOption>
80                                 <configOption name="events">
81                                         <synopsis>List of events for CEL to track</synopsis>
82                                         <description><para>A case-sensitive, comma-separated list of event names
83                                         to track. These event names do not include the leading <literal>AST_CEL</literal>.
84                                         </para>
85                                         <enumlist>
86                                                 <enum name="ALL">
87                                                         <para>Special value which tracks all events.</para>
88                                                 </enum>
89                                                 <enum name="CHAN_START"/>
90                                                 <enum name="CHAN_END"/>
91                                                 <enum name="ANSWER"/>
92                                                 <enum name="HANGUP"/>
93                                                 <enum name="APP_START"/>
94                                                 <enum name="APP_END"/>
95                                                 <enum name="PARK_START"/>
96                                                 <enum name="PARK_END"/>
97                                                 <enum name="USER_DEFINED"/>
98                                                 <enum name="BRIDGE_ENTER"/>
99                                                 <enum name="BRIDGE_EXIT"/>
100                                                 <enum name="BLINDTRANSFER"/>
101                                                 <enum name="ATTENDEDTRANSFER"/>
102                                                 <enum name="PICKUP"/>
103                                                 <enum name="FORWARD"/>
104                                                 <enum name="LINKEDID_END"/>
105                                                 <enum name="LOCAL_OPTIMIZE"/>
106                                         </enumlist>
107                                         </description>
108                                 </configOption>
109                         </configObject>
110                 </configFile>
111         </configInfo>
112  ***/
113
114 /*! Message router for state that CEL needs to know about */
115 static struct stasis_message_router *cel_state_router;
116
117 /*! Topic for CEL-specific messages */
118 static struct stasis_topic *cel_topic;
119
120 /*! Aggregation topic for all topics CEL needs to know about */
121 static struct stasis_topic *cel_aggregation_topic;
122
123 /*! Subscription for forwarding the channel caching topic */
124 static struct stasis_subscription *cel_channel_forwarder;
125
126 /*! Subscription for forwarding the channel caching topic */
127 static struct stasis_subscription *cel_bridge_forwarder;
128
129 /*! Subscription for forwarding the parking topic */
130 static struct stasis_subscription *cel_parking_forwarder;
131
132 /*! Subscription for forwarding the CEL-specific topic */
133 static struct stasis_subscription *cel_cel_forwarder;
134
135 struct stasis_message_type *cel_generic_type(void);
136 STASIS_MESSAGE_TYPE_DEFN(cel_generic_type);
137
138 /*! Container for CEL backend information */
139 static struct ao2_container *cel_backends;
140
141 /*! The number of buckets into which backend names will be hashed */
142 #define BACKEND_BUCKETS 13
143
144 /*! Container for dial end multichannel blobs for holding on to dial statuses */
145 static struct ao2_container *cel_dialstatus_store;
146
147 /*!
148  * \brief Maximum possible CEL event IDs
149  * \note This limit is currently imposed by the eventset definition
150  */
151 #define CEL_MAX_EVENT_IDS 64
152
153 /*!
154  * \brief Number of buckets for the appset container
155  */
156 #define NUM_APP_BUCKETS         97
157
158 /*!
159  * \brief Number of buckets for the dialstatus container
160  */
161 #define NUM_DIALSTATUS_BUCKETS  251
162
163 /*!
164  * \brief Container of Asterisk application names
165  *
166  * The apps in this container are the applications that were specified
167  * in the configuration as applications that CEL events should be generated
168  * for when they start and end on a channel.
169  */
170 static struct ao2_container *linkedids;
171
172 /*! \brief Destructor for cel_config */
173 static void cel_general_config_dtor(void *obj)
174 {
175         struct ast_cel_general_config *cfg = obj;
176         ast_string_field_free_memory(cfg);
177         ao2_cleanup(cfg->apps);
178         cfg->apps = NULL;
179 }
180
181 void *ast_cel_general_config_alloc(void)
182 {
183         RAII_VAR(struct ast_cel_general_config *, cfg, NULL, ao2_cleanup);
184
185         if (!(cfg = ao2_alloc(sizeof(*cfg), cel_general_config_dtor))) {
186                 return NULL;
187         }
188
189         if (ast_string_field_init(cfg, 64)) {
190                 return NULL;
191         }
192
193         if (!(cfg->apps = ast_str_container_alloc(NUM_APP_BUCKETS))) {
194                 return NULL;
195         }
196
197         ao2_ref(cfg, +1);
198         return cfg;
199 }
200
201 /*! \brief A container that holds all config-related information */
202 struct cel_config {
203         struct ast_cel_general_config *general;
204 };
205
206
207 static AO2_GLOBAL_OBJ_STATIC(cel_configs);
208
209 /*! \brief Destructor for cel_config */
210 static void cel_config_dtor(void *obj)
211 {
212         struct cel_config *cfg = obj;
213         ao2_cleanup(cfg->general);
214         cfg->general = NULL;
215 }
216
217 static void *cel_config_alloc(void)
218 {
219         RAII_VAR(struct cel_config *, cfg, NULL, ao2_cleanup);
220
221         if (!(cfg = ao2_alloc(sizeof(*cfg), cel_config_dtor))) {
222                 return NULL;
223         }
224
225         if (!(cfg->general = ast_cel_general_config_alloc())) {
226                 return NULL;
227         }
228
229         ao2_ref(cfg, +1);
230         return cfg;
231 }
232
233 /*! \brief An aco_type structure to link the "general" category to the ast_cel_general_config type */
234 static struct aco_type general_option = {
235         .type = ACO_GLOBAL,
236         .name = "general",
237         .item_offset = offsetof(struct cel_config, general),
238         .category_match = ACO_WHITELIST,
239         .category = "^general$",
240 };
241
242 /*! \brief The config file to be processed for the module. */
243 static struct aco_file cel_conf = {
244         .filename = "cel.conf",                  /*!< The name of the config file */
245         .types = ACO_TYPES(&general_option),     /*!< The mapping object types to be processed */
246         .skip_category = "(^manager$|^radius$)", /*!< Config sections used by existing modules. Do not add to this list. */
247 };
248
249 static int cel_pre_apply_config(void);
250
251 CONFIG_INFO_CORE("cel", cel_cfg_info, cel_configs, cel_config_alloc,
252         .files = ACO_FILES(&cel_conf),
253         .pre_apply_config = cel_pre_apply_config,
254 );
255
256 static int cel_pre_apply_config(void)
257 {
258         struct cel_config *cfg = aco_pending_config(&cel_cfg_info);
259
260         if (!cfg->general) {
261                 return -1;
262         }
263
264         if (!ao2_container_count(cfg->general->apps)) {
265                 return 0;
266         }
267
268         if (cfg->general->events & ((int64_t) 1 << AST_CEL_APP_START)) {
269                 return 0;
270         }
271
272         if (cfg->general->events & ((int64_t) 1 << AST_CEL_APP_END)) {
273                 return 0;
274         }
275
276         ast_log(LOG_ERROR, "Applications are listed to be tracked, but APP events are not tracked\n");
277         return -1;
278 }
279
280 static struct aco_type *general_options[] = ACO_TYPES(&general_option);
281
282 /*!
283  * \brief Map of ast_cel_event_type to strings
284  */
285 static const char * const cel_event_types[CEL_MAX_EVENT_IDS] = {
286         [0]                        = "ALL",
287         [AST_CEL_CHANNEL_START]    = "CHAN_START",
288         [AST_CEL_CHANNEL_END]      = "CHAN_END",
289         [AST_CEL_ANSWER]           = "ANSWER",
290         [AST_CEL_HANGUP]           = "HANGUP",
291         [AST_CEL_APP_START]        = "APP_START",
292         [AST_CEL_APP_END]          = "APP_END",
293         [AST_CEL_PARK_START]       = "PARK_START",
294         [AST_CEL_PARK_END]         = "PARK_END",
295         [AST_CEL_USER_DEFINED]     = "USER_DEFINED",
296         [AST_CEL_BRIDGE_ENTER]       = "BRIDGE_ENTER",
297         [AST_CEL_BRIDGE_EXIT]        = "BRIDGE_EXIT",
298         [AST_CEL_BLINDTRANSFER]    = "BLINDTRANSFER",
299         [AST_CEL_ATTENDEDTRANSFER] = "ATTENDEDTRANSFER",
300         [AST_CEL_PICKUP]           = "PICKUP",
301         [AST_CEL_FORWARD]          = "FORWARD",
302         [AST_CEL_LINKEDID_END]     = "LINKEDID_END",
303         [AST_CEL_LOCAL_OPTIMIZE]   = "LOCAL_OPTIMIZE",
304 };
305
306 struct cel_backend {
307         ast_cel_backend_cb callback; /*!< Callback for this backend */
308         char name[0];                /*!< Name of this backend */
309 };
310
311 /*! \brief Hashing function for cel_backend */
312 static int cel_backend_hash(const void *obj, int flags)
313 {
314         const struct cel_backend *backend;
315         const char *name;
316
317         switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
318         case OBJ_POINTER:
319                 backend = obj;
320                 name = backend->name;
321                 break;
322         case OBJ_KEY:
323                 name = obj;
324                 break;
325         default:
326                 /* Hash can only work on something with a full key. */
327                 ast_assert(0);
328                 return 0;
329         }
330
331         return ast_str_hash(name);
332 }
333
334 /*! \brief Comparator function for cel_backend */
335 static int cel_backend_cmp(void *obj, void *arg, int flags)
336 {
337         struct cel_backend *backend2, *backend1 = obj;
338         const char *backend2_id, *backend1_id = backend1->name;
339
340         switch (flags & (OBJ_POINTER | OBJ_KEY | OBJ_PARTIAL_KEY)) {
341         case OBJ_POINTER:
342                 backend2 = arg;
343                 backend2_id = backend2->name;
344                 break;
345         case OBJ_KEY:
346                 backend2_id = arg;
347                 break;
348         default:
349                 /* Hash can only work on something with a full key. */
350                 ast_assert(0);
351                 return 0;
352         }
353
354         return !strcmp(backend1_id, backend2_id) ? CMP_MATCH | CMP_STOP : 0;
355 }
356
357 static const char *get_caller_uniqueid(struct ast_multi_channel_blob *blob)
358 {
359         struct ast_channel_snapshot *caller = ast_multi_channel_blob_get_channel(blob, "caller");
360         if (!caller) {
361                 return NULL;
362         }
363
364         return caller->uniqueid;
365 }
366
367 /*! \brief Hashing function for dialstatus container */
368 static int dialstatus_hash(const void *obj, int flags)
369 {
370         struct ast_multi_channel_blob *blob = (void *) obj;
371         const char *uniqueid = obj;
372         if (!(flags & OBJ_KEY)) {
373                 uniqueid = get_caller_uniqueid(blob);
374         }
375
376         return ast_str_hash(uniqueid);
377 }
378
379 /*! \brief Comparator function for dialstatus container */
380 static int dialstatus_cmp(void *obj, void *arg, int flags)
381 {
382         struct ast_multi_channel_blob *blob1 = obj, *blob2 = arg;
383         const char *blob2_id = arg, *blob1_id = get_caller_uniqueid(blob1);
384         if (!(flags & OBJ_KEY)) {
385                 blob2_id = get_caller_uniqueid(blob2);
386         }
387
388         return !strcmp(blob1_id, blob2_id) ? CMP_MATCH | CMP_STOP : 0;
389 }
390
391 unsigned int ast_cel_check_enabled(void)
392 {
393         RAII_VAR(struct cel_config *, cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
394
395         if (!cfg || !cfg->general) {
396                 return 0;
397         }
398
399         return cfg->general->enable;
400 }
401
402 static int print_app(void *obj, void *arg, int flags)
403 {
404         struct ast_cli_args *a = arg;
405
406         ast_cli(a->fd, "CEL Tracking Application: %s\n", (const char *) obj);
407
408         return 0;
409 }
410
411 static int event_desc_cb(void *obj, void *arg, int flags)
412 {
413         struct ast_cli_args *a = arg;
414         struct cel_backend *backend = obj;
415
416         ast_cli(a->fd, "CEL Event Subscriber: %s\n", backend->name);
417         return 0;
418 }
419
420 static char *handle_cli_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
421 {
422         unsigned int i;
423         RAII_VAR(struct cel_config *, cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
424
425         switch (cmd) {
426         case CLI_INIT:
427                 e->command = "cel show status";
428                 e->usage =
429                         "Usage: cel show status\n"
430                         "       Displays the Channel Event Logging system status.\n";
431                 return NULL;
432         case CLI_GENERATE:
433                 return NULL;
434         case CLI_HANDLER:
435                 break;
436         }
437
438         if (a->argc > 3) {
439                 return CLI_SHOWUSAGE;
440         }
441
442         ast_cli(a->fd, "CEL Logging: %s\n", ast_cel_check_enabled() ? "Enabled" : "Disabled");
443
444         if (!cfg || !cfg->general) {
445                 return CLI_SUCCESS;
446         }
447
448         if (!cfg->general->enable) {
449                 return CLI_SUCCESS;
450         }
451
452         for (i = 0; i < (sizeof(cfg->general->events) * 8); i++) {
453                 const char *name;
454
455                 if (!(cfg->general->events & ((int64_t) 1 << i))) {
456                         continue;
457                 }
458
459                 name = ast_cel_get_type_name(i);
460                 if (strcasecmp(name, "Unknown")) {
461                         ast_cli(a->fd, "CEL Tracking Event: %s\n", name);
462                 }
463         }
464
465         ao2_callback(cfg->general->apps, OBJ_NODATA, print_app, a);
466         ao2_callback(cel_backends, OBJ_MULTIPLE | OBJ_NODATA, event_desc_cb, a);
467
468         return CLI_SUCCESS;
469 }
470
471 static struct ast_cli_entry cli_status = AST_CLI_DEFINE(handle_cli_status, "Display the CEL status");
472
473 enum ast_cel_event_type ast_cel_str_to_event_type(const char *name)
474 {
475         unsigned int i;
476
477         for (i = 0; i < ARRAY_LEN(cel_event_types); i++) {
478                 if (!cel_event_types[i]) {
479                         continue;
480                 }
481
482                 if (!strcasecmp(name, cel_event_types[i])) {
483                         return i;
484                 }
485         }
486
487         return -1;
488 }
489
490 static int ast_cel_track_event(enum ast_cel_event_type et)
491 {
492         RAII_VAR(struct cel_config *, cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
493
494         if (!cfg || !cfg->general) {
495                 return 0;
496         }
497
498         return (cfg->general->events & ((int64_t) 1 << et));
499 }
500
501 static int events_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
502 {
503         struct ast_cel_general_config *cfg = obj;
504         char *events = ast_strdupa(var->value);
505         char *cur_event;
506
507         while ((cur_event = strsep(&events, ","))) {
508                 enum ast_cel_event_type event_type;
509
510                 cur_event = ast_strip(cur_event);
511                 if (ast_strlen_zero(cur_event)) {
512                         continue;
513                 }
514
515                 event_type = ast_cel_str_to_event_type(cur_event);
516
517                 if (event_type == 0) {
518                         /* All events */
519                         cfg->events = (int64_t) -1;
520                 } else if (event_type == -1) {
521                         ast_log(LOG_ERROR, "Unknown event name '%s'\n", cur_event);
522                         return -1;
523                 } else {
524                         cfg->events |= ((int64_t) 1 << event_type);
525                 }
526         }
527
528         return 0;
529 }
530
531 static int apps_handler(const struct aco_option *opt, struct ast_variable *var, void *obj)
532 {
533         struct ast_cel_general_config *cfg = obj;
534         char *apps = ast_strdupa(var->value);
535         char *cur_app;
536
537         while ((cur_app = strsep(&apps, ","))) {
538                 cur_app = ast_strip(cur_app);
539                 if (ast_strlen_zero(cur_app)) {
540                         continue;
541                 }
542
543                 cur_app = ast_str_to_lower(cur_app);
544                 ast_str_container_add(cfg->apps, cur_app);
545         }
546
547         return 0;
548 }
549
550 static int do_reload(void)
551 {
552         if (aco_process_config(&cel_cfg_info, 1) == ACO_PROCESS_ERROR) {
553                 return -1;
554         }
555
556         ast_verb(3, "CEL logging %sabled.\n", ast_cel_check_enabled() ? "en" : "dis");
557
558         return 0;
559 }
560
561 const char *ast_cel_get_type_name(enum ast_cel_event_type type)
562 {
563         return S_OR(cel_event_types[type], "Unknown");
564 }
565
566 static int cel_track_app(const char *const_app)
567 {
568         RAII_VAR(struct cel_config *, cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
569         RAII_VAR(char *, app, NULL, ao2_cleanup);
570         char *app_lower;
571
572         if (!cfg || !cfg->general) {
573                 return 0;
574         }
575
576         app_lower = ast_str_to_lower(ast_strdupa(const_app));
577         app = ao2_find(cfg->general->apps, app_lower, OBJ_KEY);
578         if (!app) {
579                 return 0;
580         }
581
582         return 1;
583 }
584
585 static int cel_linkedid_ref(const char *linkedid);
586 struct ast_event *ast_cel_create_event(struct ast_channel_snapshot *snapshot,
587                 enum ast_cel_event_type event_type, const char *userdefevname,
588                 struct ast_json *extra)
589 {
590         struct timeval eventtime = ast_tvnow();
591         RAII_VAR(char *, extra_txt, NULL, ast_json_free);
592         if (extra) {
593                 extra_txt = ast_json_dump_string(extra);
594         }
595         return ast_event_new(AST_EVENT_CEL,
596                 AST_EVENT_IE_CEL_EVENT_TYPE, AST_EVENT_IE_PLTYPE_UINT, event_type,
597                 AST_EVENT_IE_CEL_EVENT_TIME, AST_EVENT_IE_PLTYPE_UINT, eventtime.tv_sec,
598                 AST_EVENT_IE_CEL_EVENT_TIME_USEC, AST_EVENT_IE_PLTYPE_UINT, eventtime.tv_usec,
599                 AST_EVENT_IE_CEL_USEREVENT_NAME, AST_EVENT_IE_PLTYPE_STR, S_OR(userdefevname, ""),
600                 AST_EVENT_IE_CEL_CIDNAME, AST_EVENT_IE_PLTYPE_STR, snapshot->caller_name,
601                 AST_EVENT_IE_CEL_CIDNUM, AST_EVENT_IE_PLTYPE_STR, snapshot->caller_number,
602                 AST_EVENT_IE_CEL_CIDANI, AST_EVENT_IE_PLTYPE_STR, snapshot->caller_ani,
603                 AST_EVENT_IE_CEL_CIDRDNIS, AST_EVENT_IE_PLTYPE_STR, snapshot->caller_rdnis,
604                 AST_EVENT_IE_CEL_CIDDNID, AST_EVENT_IE_PLTYPE_STR, snapshot->caller_dnid,
605                 AST_EVENT_IE_CEL_EXTEN, AST_EVENT_IE_PLTYPE_STR, snapshot->exten,
606                 AST_EVENT_IE_CEL_CONTEXT, AST_EVENT_IE_PLTYPE_STR, snapshot->context,
607                 AST_EVENT_IE_CEL_CHANNAME, AST_EVENT_IE_PLTYPE_STR, snapshot->name,
608                 AST_EVENT_IE_CEL_APPNAME, AST_EVENT_IE_PLTYPE_STR, snapshot->appl,
609                 AST_EVENT_IE_CEL_APPDATA, AST_EVENT_IE_PLTYPE_STR, snapshot->data,
610                 AST_EVENT_IE_CEL_AMAFLAGS, AST_EVENT_IE_PLTYPE_UINT, snapshot->amaflags,
611                 AST_EVENT_IE_CEL_ACCTCODE, AST_EVENT_IE_PLTYPE_STR, snapshot->accountcode,
612                 AST_EVENT_IE_CEL_PEERACCT, AST_EVENT_IE_PLTYPE_STR, snapshot->peeraccount,
613                 AST_EVENT_IE_CEL_UNIQUEID, AST_EVENT_IE_PLTYPE_STR, snapshot->uniqueid,
614                 AST_EVENT_IE_CEL_LINKEDID, AST_EVENT_IE_PLTYPE_STR, snapshot->linkedid,
615                 AST_EVENT_IE_CEL_USERFIELD, AST_EVENT_IE_PLTYPE_STR, snapshot->userfield,
616                 AST_EVENT_IE_CEL_EXTRA, AST_EVENT_IE_PLTYPE_STR, S_OR(extra_txt, ""),
617                 AST_EVENT_IE_CEL_PEER, AST_EVENT_IE_PLTYPE_STR, "",
618                 AST_EVENT_IE_END);
619 }
620
621 static int cel_backend_send_cb(void *obj, void *arg, int flags)
622 {
623         struct cel_backend *backend = obj;
624
625         backend->callback(arg);
626         return 0;
627 }
628
629 static int cel_report_event(struct ast_channel_snapshot *snapshot,
630                 enum ast_cel_event_type event_type, const char *userdefevname,
631                 struct ast_json *extra)
632 {
633         struct ast_event *ev;
634         char *linkedid = ast_strdupa(snapshot->linkedid);
635         RAII_VAR(struct cel_config *, cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
636
637         if (!cfg || !cfg->general) {
638                 return 0;
639         }
640
641         if (!cfg->general->enable) {
642                 return 0;
643         }
644
645         /* Record the linkedid of new channels if we are tracking LINKEDID_END even if we aren't
646          * reporting on CHANNEL_START so we can track when to send LINKEDID_END */
647         if (ast_cel_track_event(AST_CEL_LINKEDID_END) && event_type == AST_CEL_CHANNEL_START && linkedid) {
648                 if (cel_linkedid_ref(linkedid)) {
649                         return -1;
650                 }
651         }
652
653         if (!ast_cel_track_event(event_type)) {
654                 return 0;
655         }
656
657         if ((event_type == AST_CEL_APP_START || event_type == AST_CEL_APP_END)
658                 && !cel_track_app(snapshot->appl)) {
659                 return 0;
660         }
661
662         ev = ast_cel_create_event(snapshot, event_type, userdefevname, extra);
663         if (!ev) {
664                 return -1;
665         }
666
667         /* Distribute event to backends */
668         ao2_callback(cel_backends, OBJ_MULTIPLE | OBJ_NODATA, cel_backend_send_cb, ev);
669         ast_event_destroy(ev);
670
671         return 0;
672 }
673
674 /* called whenever a channel is destroyed or a linkedid is changed to
675  * potentially emit a CEL_LINKEDID_END event */
676 static void check_retire_linkedid(struct ast_channel_snapshot *snapshot)
677 {
678         char *lid;
679
680         /* make sure we need to do all this work */
681
682         if (ast_strlen_zero(snapshot->linkedid) || !ast_cel_track_event(AST_CEL_LINKEDID_END)) {
683                 return;
684         }
685
686         if (!(lid = ao2_find(linkedids, (void *) snapshot->linkedid, OBJ_POINTER))) {
687                 ast_log(LOG_ERROR, "Something weird happened, couldn't find linkedid %s\n", snapshot->linkedid);
688                 return;
689         }
690
691         /* We have a ref for each channel with this linkedid, the link and the above find, so if
692          * before unreffing the channel we have a refcount of 3, we're done. Unlink and report. */
693         if (ao2_ref(lid, -1) == 3) {
694                 ast_str_container_remove(linkedids, lid);
695                 cel_report_event(snapshot, AST_CEL_LINKEDID_END, NULL, NULL);
696         }
697         ao2_ref(lid, -1);
698 }
699
700 /* Note that no 'chan_fixup' function is provided for this datastore type,
701  * because the channels that will use it will never be involved in masquerades.
702  */
703 static const struct ast_datastore_info fabricated_channel_datastore = {
704         .type = "CEL fabricated channel",
705         .destroy = ast_free_ptr,
706 };
707
708 struct ast_channel *ast_cel_fabricate_channel_from_event(const struct ast_event *event)
709 {
710         struct varshead *headp;
711         struct ast_var_t *newvariable;
712         const char *mixed_name;
713         char timebuf[30];
714         struct ast_channel *tchan;
715         struct ast_cel_event_record record = {
716                 .version = AST_CEL_EVENT_RECORD_VERSION,
717         };
718         struct ast_datastore *datastore;
719         char *app_data;
720         RAII_VAR(struct cel_config *, cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
721
722         if (!cfg || !cfg->general) {
723                 return NULL;
724         }
725
726         /* do not call ast_channel_alloc because this is not really a real channel */
727         if (!(tchan = ast_dummy_channel_alloc())) {
728                 return NULL;
729         }
730
731         headp = ast_channel_varshead(tchan);
732
733         /* first, get the variables from the event */
734         if (ast_cel_fill_record(event, &record)) {
735                 ast_channel_unref(tchan);
736                 return NULL;
737         }
738
739         /* next, fill the channel with their data */
740         mixed_name = (record.event_type == AST_CEL_USER_DEFINED)
741                 ? record.user_defined_name : record.event_name;
742         if ((newvariable = ast_var_assign("eventtype", mixed_name))) {
743                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
744         }
745
746         if (ast_strlen_zero(cfg->general->date_format)) {
747                 snprintf(timebuf, sizeof(timebuf), "%ld.%06ld", (long) record.event_time.tv_sec,
748                                 (long) record.event_time.tv_usec);
749         } else {
750                 struct ast_tm tm;
751                 ast_localtime(&record.event_time, &tm, NULL);
752                 ast_strftime(timebuf, sizeof(timebuf), cfg->general->date_format, &tm);
753         }
754
755         if ((newvariable = ast_var_assign("eventtime", timebuf))) {
756                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
757         }
758
759         if ((newvariable = ast_var_assign("eventenum", record.event_name))) {
760                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
761         }
762         if ((newvariable = ast_var_assign("userdeftype", record.user_defined_name))) {
763                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
764         }
765         if ((newvariable = ast_var_assign("eventextra", record.extra))) {
766                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
767         }
768
769         ast_channel_caller(tchan)->id.name.valid = 1;
770         ast_channel_caller(tchan)->id.name.str = ast_strdup(record.caller_id_name);
771         ast_channel_caller(tchan)->id.number.valid = 1;
772         ast_channel_caller(tchan)->id.number.str = ast_strdup(record.caller_id_num);
773         ast_channel_caller(tchan)->ani.number.valid = 1;
774         ast_channel_caller(tchan)->ani.number.str = ast_strdup(record.caller_id_ani);
775         ast_channel_redirecting(tchan)->from.number.valid = 1;
776         ast_channel_redirecting(tchan)->from.number.str = ast_strdup(record.caller_id_rdnis);
777         ast_channel_dialed(tchan)->number.str = ast_strdup(record.caller_id_dnid);
778
779         ast_channel_exten_set(tchan, record.extension);
780         ast_channel_context_set(tchan, record.context);
781         ast_channel_name_set(tchan, record.channel_name);
782         ast_channel_uniqueid_set(tchan, record.unique_id);
783         ast_channel_linkedid_set(tchan, record.linked_id);
784         ast_channel_accountcode_set(tchan, record.account_code);
785         ast_channel_peeraccount_set(tchan, record.peer_account);
786         ast_channel_userfield_set(tchan, record.user_field);
787
788         if ((newvariable = ast_var_assign("BRIDGEPEER", record.peer))) {
789                 AST_LIST_INSERT_HEAD(headp, newvariable, entries);
790         }
791
792         ast_channel_amaflags_set(tchan, record.amaflag);
793
794         /* We need to store an 'application name' and 'application
795          * data' on the channel for logging purposes, but the channel
796          * structure only provides a place to store pointers, and it
797          * expects these pointers to be pointing to data that does not
798          * need to be freed. This means that the channel's destructor
799          * does not attempt to free any storage that these pointers
800          * point to. However, we can't provide data in that form directly for
801          * these structure members. In order to ensure that these data
802          * elements have a lifetime that matches the channel's
803          * lifetime, we'll put them in a datastore attached to the
804          * channel, and set's the channel's pointers to point into the
805          * datastore.  The datastore will then be automatically destroyed
806          * when the channel is destroyed.
807          */
808
809         if (!(datastore = ast_datastore_alloc(&fabricated_channel_datastore, NULL))) {
810                 ast_channel_unref(tchan);
811                 return NULL;
812         }
813
814         if (!(app_data = ast_malloc(strlen(record.application_name) + strlen(record.application_data) + 2))) {
815                 ast_datastore_free(datastore);
816                 ast_channel_unref(tchan);
817                 return NULL;
818         }
819
820         ast_channel_appl_set(tchan, strcpy(app_data, record.application_name));
821         ast_channel_data_set(tchan, strcpy(app_data + strlen(record.application_name) + 1,
822                 record.application_data));
823
824         datastore->data = app_data;
825         ast_channel_datastore_add(tchan, datastore);
826
827         return tchan;
828 }
829
830 static int cel_linkedid_ref(const char *linkedid)
831 {
832         char *lid;
833
834         if (ast_strlen_zero(linkedid)) {
835                 ast_log(LOG_ERROR, "The linkedid should never be empty\n");
836                 return -1;
837         }
838
839         if (!(lid = ao2_find(linkedids, (void *) linkedid, OBJ_POINTER))) {
840                 if (!(lid = ao2_alloc(strlen(linkedid) + 1, NULL))) {
841                         return -1;
842                 }
843                 strcpy(lid, linkedid);
844                 if (!ao2_link(linkedids, lid)) {
845                         ao2_ref(lid, -1);
846                         return -1;
847                 }
848                 /* Leave both the link and the alloc refs to show a count of 1 + the link */
849         }
850         /* If we've found, go ahead and keep the ref to increment count of how many channels
851          * have this linkedid. We'll clean it up in check_retire */
852         return 0;
853 }
854
855 int ast_cel_fill_record(const struct ast_event *e, struct ast_cel_event_record *r)
856 {
857         if (r->version != AST_CEL_EVENT_RECORD_VERSION) {
858                 ast_log(LOG_ERROR, "Module ABI mismatch for ast_cel_event_record.  "
859                                 "Please ensure all modules were compiled for "
860                                 "this version of Asterisk.\n");
861                 return -1;
862         }
863
864         r->event_type = ast_event_get_ie_uint(e, AST_EVENT_IE_CEL_EVENT_TYPE);
865
866         r->event_time.tv_sec = ast_event_get_ie_uint(e, AST_EVENT_IE_CEL_EVENT_TIME);
867         r->event_time.tv_usec = ast_event_get_ie_uint(e, AST_EVENT_IE_CEL_EVENT_TIME_USEC);
868
869         r->event_name = ast_cel_get_type_name(r->event_type);
870         if (r->event_type == AST_CEL_USER_DEFINED) {
871                 r->user_defined_name = ast_event_get_ie_str(e, AST_EVENT_IE_CEL_USEREVENT_NAME);
872         } else {
873                 r->user_defined_name = "";
874         }
875
876         r->caller_id_name   = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_CIDNAME), "");
877         r->caller_id_num    = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_CIDNUM), "");
878         r->caller_id_ani    = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_CIDANI), "");
879         r->caller_id_rdnis  = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_CIDRDNIS), "");
880         r->caller_id_dnid   = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_CIDDNID), "");
881         r->extension        = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_EXTEN), "");
882         r->context          = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_CONTEXT), "");
883         r->channel_name     = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_CHANNAME), "");
884         r->application_name = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_APPNAME), "");
885         r->application_data = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_APPDATA), "");
886         r->account_code     = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_ACCTCODE), "");
887         r->peer_account     = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_ACCTCODE), "");
888         r->unique_id        = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_UNIQUEID), "");
889         r->linked_id        = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_LINKEDID), "");
890         r->amaflag          = ast_event_get_ie_uint(e, AST_EVENT_IE_CEL_AMAFLAGS);
891         r->user_field       = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_USERFIELD), "");
892         r->peer             = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_PEER), "");
893         r->extra            = S_OR(ast_event_get_ie_str(e, AST_EVENT_IE_CEL_EXTRA), "");
894
895         return 0;
896 }
897
898 /*! \brief Typedef for callbacks that get called on channel snapshot updates */
899 typedef void (*cel_channel_snapshot_monitor)(
900         struct ast_channel_snapshot *old_snapshot,
901         struct ast_channel_snapshot *new_snapshot);
902
903 static struct ast_multi_channel_blob *get_dialstatus_blob(const char *uniqueid)
904 {
905         return ao2_find(cel_dialstatus_store, uniqueid, OBJ_KEY | OBJ_UNLINK);
906 }
907
908 static const char *get_blob_variable(struct ast_multi_channel_blob *blob, const char *varname)
909 {
910         struct ast_json *json = ast_multi_channel_blob_get_json(blob);
911         if (!json) {
912                 return NULL;
913         }
914
915         json = ast_json_object_get(json, varname);
916         if (!json) {
917                 return NULL;
918         }
919
920         return ast_json_string_get(json);
921 }
922
923 /*! \brief Handle channel state changes */
924 static void cel_channel_state_change(
925         struct ast_channel_snapshot *old_snapshot,
926         struct ast_channel_snapshot *new_snapshot)
927 {
928         int is_hungup, was_hungup;
929
930         if (!new_snapshot) {
931                 cel_report_event(old_snapshot, AST_CEL_CHANNEL_END, NULL, NULL);
932                 check_retire_linkedid(old_snapshot);
933                 return;
934         }
935
936         if (!old_snapshot) {
937                 cel_report_event(new_snapshot, AST_CEL_CHANNEL_START, NULL, NULL);
938                 return;
939         }
940
941         was_hungup = ast_test_flag(&old_snapshot->flags, AST_FLAG_DEAD) ? 1 : 0;
942         is_hungup = ast_test_flag(&new_snapshot->flags, AST_FLAG_DEAD) ? 1 : 0;
943
944         if (!was_hungup && is_hungup) {
945                 RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
946                 RAII_VAR(struct ast_multi_channel_blob *, blob, get_dialstatus_blob(new_snapshot->uniqueid), ao2_cleanup);
947                 const char *dialstatus = "";
948                 if (blob && !ast_strlen_zero(get_blob_variable(blob, "dialstatus"))) {
949                         dialstatus = get_blob_variable(blob, "dialstatus");
950                 }
951                 extra = ast_json_pack("{s: i, s: s, s: s}",
952                         "hangupcause", new_snapshot->hangupcause,
953                         "hangupsource", new_snapshot->hangupsource,
954                         "dialstatus", dialstatus);
955                 cel_report_event(new_snapshot, AST_CEL_HANGUP, NULL, extra);
956                 return;
957         }
958
959         if (old_snapshot->state != new_snapshot->state && new_snapshot->state == AST_STATE_UP) {
960                 cel_report_event(new_snapshot, AST_CEL_ANSWER, NULL, NULL);
961                 return;
962         }
963 }
964
965 static void cel_channel_linkedid_change(
966         struct ast_channel_snapshot *old_snapshot,
967         struct ast_channel_snapshot *new_snapshot)
968 {
969         if (!old_snapshot || !new_snapshot) {
970                 return;
971         }
972
973         ast_assert(!ast_strlen_zero(new_snapshot->linkedid));
974         ast_assert(!ast_strlen_zero(old_snapshot->linkedid));
975
976         if (strcmp(old_snapshot->linkedid, new_snapshot->linkedid)) {
977                 cel_linkedid_ref(new_snapshot->linkedid);
978                 check_retire_linkedid(old_snapshot);
979         }
980 }
981
982 static void cel_channel_app_change(
983         struct ast_channel_snapshot *old_snapshot,
984         struct ast_channel_snapshot *new_snapshot)
985 {
986         if (new_snapshot && old_snapshot
987                 && !strcmp(old_snapshot->appl, new_snapshot->appl)) {
988                 return;
989         }
990
991         /* old snapshot has an application, end it */
992         if (old_snapshot && !ast_strlen_zero(old_snapshot->appl)) {
993                 cel_report_event(old_snapshot, AST_CEL_APP_END, NULL, NULL);
994         }
995
996         /* new snapshot has an application, start it */
997         if (new_snapshot && !ast_strlen_zero(new_snapshot->appl)) {
998                 cel_report_event(new_snapshot, AST_CEL_APP_START, NULL, NULL);
999         }
1000 }
1001
1002 /* \brief Handlers for channel snapshot changes.
1003  * \note Order of the handlers matters. Application changes must come before state
1004  * changes to ensure that hangup notifications occur after application changes.
1005  * Linkedid checking should always come last.
1006  */
1007 cel_channel_snapshot_monitor cel_channel_monitors[] = {
1008         cel_channel_app_change,
1009         cel_channel_state_change,
1010         cel_channel_linkedid_change,
1011 };
1012
1013 static int cel_filter_channel_snapshot(struct ast_channel_snapshot *snapshot)
1014 {
1015         if (!snapshot) {
1016                 return 0;
1017         }
1018         return snapshot->tech_properties & AST_CHAN_TP_INTERNAL;
1019 }
1020
1021 static void cel_snapshot_update_cb(void *data, struct stasis_subscription *sub,
1022         struct stasis_topic *topic,
1023         struct stasis_message *message)
1024 {
1025         struct stasis_cache_update *update = stasis_message_data(message);
1026         if (ast_channel_snapshot_type() == update->type) {
1027                 struct ast_channel_snapshot *old_snapshot;
1028                 struct ast_channel_snapshot *new_snapshot;
1029                 size_t i;
1030
1031                 old_snapshot = stasis_message_data(update->old_snapshot);
1032                 new_snapshot = stasis_message_data(update->new_snapshot);
1033
1034                 if (cel_filter_channel_snapshot(old_snapshot) || cel_filter_channel_snapshot(new_snapshot)) {
1035                         return;
1036                 }
1037
1038                 for (i = 0; i < ARRAY_LEN(cel_channel_monitors); ++i) {
1039                         cel_channel_monitors[i](old_snapshot, new_snapshot);
1040                 }
1041         }
1042 }
1043
1044 static void cel_bridge_enter_cb(
1045         void *data, struct stasis_subscription *sub,
1046         struct stasis_topic *topic,
1047         struct stasis_message *message)
1048 {
1049         struct ast_bridge_blob *blob = stasis_message_data(message);
1050         struct ast_bridge_snapshot *snapshot = blob->bridge;
1051         struct ast_channel_snapshot *chan_snapshot = blob->channel;
1052         RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1053
1054         if (cel_filter_channel_snapshot(chan_snapshot)) {
1055                 return;
1056         }
1057
1058         extra = ast_json_pack("{s: s}", "bridge_id", snapshot->uniqueid);
1059         if (!extra) {
1060                 return;
1061         }
1062
1063         cel_report_event(chan_snapshot, AST_CEL_BRIDGE_ENTER, NULL, extra);
1064 }
1065
1066 static void cel_bridge_leave_cb(
1067         void *data, struct stasis_subscription *sub,
1068         struct stasis_topic *topic,
1069         struct stasis_message *message)
1070 {
1071         struct ast_bridge_blob *blob = stasis_message_data(message);
1072         struct ast_bridge_snapshot *snapshot = blob->bridge;
1073         struct ast_channel_snapshot *chan_snapshot = blob->channel;
1074         RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1075
1076         if (cel_filter_channel_snapshot(chan_snapshot)) {
1077                 return;
1078         }
1079
1080         extra = ast_json_pack("{s: s}", "bridge_id", snapshot->uniqueid);
1081         if (!extra) {
1082                 return;
1083         }
1084
1085         cel_report_event(chan_snapshot, AST_CEL_BRIDGE_EXIT, NULL, extra);
1086 }
1087
1088 static void cel_parking_cb(
1089         void *data, struct stasis_subscription *sub,
1090         struct stasis_topic *topic,
1091         struct stasis_message *message)
1092 {
1093         struct ast_parked_call_payload *parked_payload = stasis_message_data(message);
1094         RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1095         const char *reason = NULL;
1096
1097         switch (parked_payload->event_type) {
1098         case PARKED_CALL:
1099                 extra = ast_json_pack("{s: s, s: s}",
1100                         "parker_dial_string", parked_payload->parker_dial_string,
1101                         "parking_lot", parked_payload->parkinglot);
1102                 if (extra) {
1103                         cel_report_event(parked_payload->parkee, AST_CEL_PARK_START, NULL, extra);
1104                 }
1105                 return;
1106         case PARKED_CALL_TIMEOUT:
1107                 reason = "ParkedCallTimeOut";
1108                 break;
1109         case PARKED_CALL_GIVEUP:
1110                 reason = "ParkedCallGiveUp";
1111                 break;
1112         case PARKED_CALL_UNPARKED:
1113                 reason = "ParkedCallUnparked";
1114                 break;
1115         case PARKED_CALL_FAILED:
1116                 reason = "ParkedCallFailed";
1117                 break;
1118         case PARKED_CALL_SWAP:
1119                 reason = "ParkedCallSwap";
1120                 break;
1121         }
1122
1123         extra = ast_json_pack("{s: s}", "reason", reason);
1124         if (extra) {
1125                 cel_report_event(parked_payload->parkee, AST_CEL_PARK_END, NULL, extra);
1126         }
1127 }
1128
1129 static void save_dialstatus(struct ast_multi_channel_blob *blob)
1130 {
1131         ao2_link(cel_dialstatus_store, blob);
1132 }
1133
1134 static void cel_dial_cb(void *data, struct stasis_subscription *sub,
1135         struct stasis_topic *topic,
1136         struct stasis_message *message)
1137 {
1138         struct ast_multi_channel_blob *blob = stasis_message_data(message);
1139
1140         if (cel_filter_channel_snapshot(ast_multi_channel_blob_get_channel(blob, "caller"))) {
1141                 return;
1142         }
1143
1144         if (!get_caller_uniqueid(blob)) {
1145                 return;
1146         }
1147
1148         if (!ast_strlen_zero(get_blob_variable(blob, "forward"))) {
1149                 struct ast_channel_snapshot *caller = ast_multi_channel_blob_get_channel(blob, "caller");
1150                 RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1151                 if (!caller) {
1152                         return;
1153                 }
1154
1155                 extra = ast_json_pack("{s: s}", "forward", get_blob_variable(blob, "forward"));
1156                 if (extra) {
1157                         cel_report_event(caller, AST_CEL_FORWARD, NULL, extra);
1158                 }
1159         }
1160
1161         if (ast_strlen_zero(get_blob_variable(blob, "dialstatus"))) {
1162                 return;
1163         }
1164
1165         save_dialstatus(blob);
1166 }
1167
1168 static void cel_generic_cb(
1169         void *data, struct stasis_subscription *sub,
1170         struct stasis_topic *topic,
1171         struct stasis_message *message)
1172 {
1173         struct ast_channel_blob *obj = stasis_message_data(message);
1174         int event_type = ast_json_integer_get(ast_json_object_get(obj->blob, "event_type"));
1175         struct ast_json *event_details = ast_json_object_get(obj->blob, "event_details");
1176
1177         switch (event_type) {
1178         case AST_CEL_USER_DEFINED:
1179                 {
1180                         const char *event = ast_json_string_get(ast_json_object_get(event_details, "event"));
1181                         struct ast_json *extra = ast_json_object_get(event_details, "extra");
1182                         cel_report_event(obj->snapshot, event_type, event, extra);
1183                         break;
1184                 }
1185         default:
1186                 ast_log(LOG_ERROR, "Unhandled %s event blob\n", ast_cel_get_type_name(event_type));
1187                 break;
1188         }
1189 }
1190
1191 static void cel_blind_transfer_cb(
1192         void *data, struct stasis_subscription *sub,
1193         struct stasis_topic *topic,
1194         struct stasis_message *message)
1195 {
1196         struct ast_bridge_blob *obj = stasis_message_data(message);
1197         struct ast_channel_snapshot *chan_snapshot = obj->channel;
1198         struct ast_bridge_snapshot *bridge_snapshot = obj->bridge;
1199         struct ast_json *blob = obj->blob;
1200         struct ast_json *json_result = ast_json_object_get(blob, "result");
1201         struct ast_json *json_exten;
1202         struct ast_json *json_context;
1203         RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1204         const char *exten, *context;
1205         enum ast_transfer_result result;
1206
1207         if (!json_result) {
1208                 return;
1209         }
1210
1211         result = ast_json_integer_get(json_result);
1212         if (result != AST_BRIDGE_TRANSFER_SUCCESS) {
1213                 return;
1214         }
1215
1216         json_exten = ast_json_object_get(blob, "exten");
1217         json_context = ast_json_object_get(blob, "context");
1218
1219         if (!json_exten || !json_context) {
1220                 return;
1221         }
1222
1223         exten = ast_json_string_get(json_exten);
1224         context = ast_json_string_get(json_context);
1225         if (!exten || !context) {
1226                 return;
1227         }
1228
1229         extra = ast_json_pack("{s: s, s: s, s: s}",
1230                 "extension", exten,
1231                 "context", context,
1232                 "bridge_id", bridge_snapshot->uniqueid);
1233
1234         if (extra) {
1235                 cel_report_event(chan_snapshot, AST_CEL_BLINDTRANSFER, NULL, extra);
1236         }
1237 }
1238
1239 static void cel_attended_transfer_cb(
1240         void *data, struct stasis_subscription *sub,
1241         struct stasis_topic *topic,
1242         struct stasis_message *message)
1243 {
1244         struct ast_attended_transfer_message *xfer = stasis_message_data(message);
1245         RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1246         struct ast_bridge_snapshot *bridge1, *bridge2;
1247         struct ast_channel_snapshot *channel1, *channel2;
1248
1249         /* Make sure bridge1 is always non-NULL */
1250         if (!xfer->to_transferee.bridge_snapshot) {
1251                 bridge1 = xfer->to_transfer_target.bridge_snapshot;
1252                 bridge2 = xfer->to_transferee.bridge_snapshot;
1253                 channel1 = xfer->to_transfer_target.channel_snapshot;
1254                 channel2 = xfer->to_transferee.channel_snapshot;
1255         } else {
1256                 bridge1 = xfer->to_transferee.bridge_snapshot;
1257                 bridge2 = xfer->to_transfer_target.bridge_snapshot;
1258                 channel1 = xfer->to_transferee.channel_snapshot;
1259                 channel2 = xfer->to_transfer_target.channel_snapshot;
1260         }
1261
1262         switch (xfer->dest_type) {
1263         case AST_ATTENDED_TRANSFER_DEST_FAIL:
1264                 return;
1265                 /* handle these three the same */
1266         case AST_ATTENDED_TRANSFER_DEST_BRIDGE_MERGE:
1267         case AST_ATTENDED_TRANSFER_DEST_LINK:
1268         case AST_ATTENDED_TRANSFER_DEST_THREEWAY:
1269                 extra = ast_json_pack("{s: s, s: s, s: s}",
1270                         "bridge1_id", bridge1->uniqueid,
1271                         "channel2_name", channel2->name,
1272                         "bridge2_id", bridge2->uniqueid);
1273
1274                 if (!extra) {
1275                         return;
1276                 }
1277                 break;
1278         case AST_ATTENDED_TRANSFER_DEST_APP:
1279                 extra = ast_json_pack("{s: s, s: s, s: s}",
1280                         "bridge1_id", bridge1->uniqueid,
1281                         "channel2_name", channel2->name,
1282                         "app", xfer->dest.app);
1283
1284                 if (!extra) {
1285                         return;
1286                 }
1287                 break;
1288         }
1289         cel_report_event(channel1, AST_CEL_ATTENDEDTRANSFER, NULL, extra);
1290 }
1291
1292 static void cel_pickup_cb(
1293         void *data, struct stasis_subscription *sub,
1294         struct stasis_topic *topic,
1295         struct stasis_message *message)
1296 {
1297         struct ast_multi_channel_blob *obj = stasis_message_data(message);
1298         struct ast_channel_snapshot *channel = ast_multi_channel_blob_get_channel(obj, "channel");
1299         struct ast_channel_snapshot *target = ast_multi_channel_blob_get_channel(obj, "target");
1300         RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1301
1302         if (!channel || !target) {
1303                 return;
1304         }
1305
1306         extra = ast_json_pack("{s: s}", "pickup_channel", channel->name);
1307         if (!extra) {
1308                 return;
1309         }
1310
1311         cel_report_event(target, AST_CEL_PICKUP, NULL, extra);
1312 }
1313
1314 static void cel_local_cb(
1315         void *data, struct stasis_subscription *sub,
1316         struct stasis_topic *topic,
1317         struct stasis_message *message)
1318 {
1319         struct ast_multi_channel_blob *obj = stasis_message_data(message);
1320         struct ast_channel_snapshot *localone = ast_multi_channel_blob_get_channel(obj, "1");
1321         struct ast_channel_snapshot *localtwo = ast_multi_channel_blob_get_channel(obj, "2");
1322         RAII_VAR(struct ast_json *, extra, NULL, ast_json_unref);
1323
1324         if (!localone || !localtwo) {
1325                 return;
1326         }
1327
1328         extra = ast_json_pack("{s: s}", "local_two", localtwo->name);
1329         if (!extra) {
1330                 return;
1331         }
1332
1333         cel_report_event(localone, AST_CEL_LOCAL_OPTIMIZE, NULL, extra);
1334 }
1335
1336 static void ast_cel_engine_term(void)
1337 {
1338         aco_info_destroy(&cel_cfg_info);
1339         ao2_global_obj_release(cel_configs);
1340         stasis_message_router_unsubscribe_and_join(cel_state_router);
1341         cel_state_router = NULL;
1342         ao2_cleanup(cel_aggregation_topic);
1343         cel_aggregation_topic = NULL;
1344         ao2_cleanup(cel_topic);
1345         cel_topic = NULL;
1346         cel_channel_forwarder = stasis_unsubscribe_and_join(cel_channel_forwarder);
1347         cel_bridge_forwarder = stasis_unsubscribe_and_join(cel_bridge_forwarder);
1348         cel_parking_forwarder = stasis_unsubscribe_and_join(cel_parking_forwarder);
1349         cel_cel_forwarder = stasis_unsubscribe_and_join(cel_cel_forwarder);
1350         ast_cli_unregister(&cli_status);
1351         ao2_cleanup(cel_dialstatus_store);
1352         cel_dialstatus_store = NULL;
1353         ao2_cleanup(linkedids);
1354         linkedids = NULL;
1355         ao2_cleanup(cel_backends);
1356         cel_backends = NULL;
1357         STASIS_MESSAGE_TYPE_CLEANUP(cel_generic_type);
1358 }
1359
1360 int ast_cel_engine_init(void)
1361 {
1362         int ret = 0;
1363         if (!(linkedids = ast_str_container_alloc(NUM_APP_BUCKETS))) {
1364                 return -1;
1365         }
1366
1367         if (!(cel_dialstatus_store = ao2_container_alloc(NUM_DIALSTATUS_BUCKETS, dialstatus_hash, dialstatus_cmp))) {
1368                 return -1;
1369         }
1370
1371         if (STASIS_MESSAGE_TYPE_INIT(cel_generic_type)) {
1372                 return -1;
1373         }
1374
1375         if (ast_cli_register(&cli_status)) {
1376                 return -1;
1377         }
1378
1379         cel_backends = ao2_container_alloc(BACKEND_BUCKETS, cel_backend_hash, cel_backend_cmp);
1380         if (!cel_backends) {
1381                 return -1;
1382         }
1383
1384         cel_aggregation_topic = stasis_topic_create("cel_aggregation_topic");
1385         if (!cel_aggregation_topic) {
1386                 return -1;
1387         }
1388
1389         cel_topic = stasis_topic_create("cel_topic");
1390         if (!cel_topic) {
1391                 return -1;
1392         }
1393
1394         cel_channel_forwarder = stasis_forward_all(
1395                 ast_channel_topic_all_cached(),
1396                 cel_aggregation_topic);
1397         if (!cel_channel_forwarder) {
1398                 return -1;
1399         }
1400
1401         cel_bridge_forwarder = stasis_forward_all(
1402                 ast_bridge_topic_all_cached(),
1403                 cel_aggregation_topic);
1404         if (!cel_bridge_forwarder) {
1405                 return -1;
1406         }
1407
1408         cel_parking_forwarder = stasis_forward_all(
1409                 ast_parking_topic(),
1410                 cel_aggregation_topic);
1411         if (!cel_parking_forwarder) {
1412                 return -1;
1413         }
1414
1415         cel_cel_forwarder = stasis_forward_all(
1416                 ast_cel_topic(),
1417                 cel_aggregation_topic);
1418         if (!cel_cel_forwarder) {
1419                 return -1;
1420         }
1421
1422         cel_state_router = stasis_message_router_create(cel_aggregation_topic);
1423         if (!cel_state_router) {
1424                 return -1;
1425         }
1426
1427         ret |= stasis_message_router_add(cel_state_router,
1428                 stasis_cache_update_type(),
1429                 cel_snapshot_update_cb,
1430                 NULL);
1431
1432         ret |= stasis_message_router_add(cel_state_router,
1433                 ast_channel_dial_type(),
1434                 cel_dial_cb,
1435                 NULL);
1436
1437         ret |= stasis_message_router_add(cel_state_router,
1438                 ast_channel_entered_bridge_type(),
1439                 cel_bridge_enter_cb,
1440                 NULL);
1441
1442         ret |= stasis_message_router_add(cel_state_router,
1443                 ast_channel_left_bridge_type(),
1444                 cel_bridge_leave_cb,
1445                 NULL);
1446
1447         ret |= stasis_message_router_add(cel_state_router,
1448                 ast_parked_call_type(),
1449                 cel_parking_cb,
1450                 NULL);
1451
1452         ret |= stasis_message_router_add(cel_state_router,
1453                 cel_generic_type(),
1454                 cel_generic_cb,
1455                 NULL);
1456
1457         ret |= stasis_message_router_add(cel_state_router,
1458                 ast_blind_transfer_type(),
1459                 cel_blind_transfer_cb,
1460                 NULL);
1461
1462         ret |= stasis_message_router_add(cel_state_router,
1463                 ast_attended_transfer_type(),
1464                 cel_attended_transfer_cb,
1465                 NULL);
1466
1467         ret |= stasis_message_router_add(cel_state_router,
1468                 ast_call_pickup_type(),
1469                 cel_pickup_cb,
1470                 NULL);
1471
1472         ret |= stasis_message_router_add(cel_state_router,
1473                 ast_local_optimization_end_type(),
1474                 cel_local_cb,
1475                 NULL);
1476
1477         /* If somehow we failed to add any routes, just shut down the whole
1478          * thing and fail it.
1479          */
1480         if (ret) {
1481                 ast_cel_engine_term();
1482                 return -1;
1483         }
1484
1485         if (aco_info_init(&cel_cfg_info)) {
1486                 return -1;
1487         }
1488
1489         aco_option_register(&cel_cfg_info, "enable", ACO_EXACT, general_options, "no", OPT_BOOL_T, 1, FLDSET(struct ast_cel_general_config, enable));
1490         aco_option_register(&cel_cfg_info, "dateformat", ACO_EXACT, general_options, "", OPT_STRINGFIELD_T, 0, STRFLDSET(struct ast_cel_general_config, date_format));
1491         aco_option_register_custom(&cel_cfg_info, "apps", ACO_EXACT, general_options, "", apps_handler, 0);
1492         aco_option_register_custom(&cel_cfg_info, "events", ACO_EXACT, general_options, "", events_handler, 0);
1493
1494         if (aco_process_config(&cel_cfg_info, 0)) {
1495                 RAII_VAR(struct cel_config *, cel_cfg, cel_config_alloc(), ao2_cleanup);
1496
1497                 if (!cel_cfg) {
1498                         return -1;
1499                 }
1500
1501                 /* If we couldn't process the configuration and this wasn't a reload,
1502                  * create a default config
1503                  */
1504                 if (!aco_set_defaults(&general_option, "general", cel_cfg->general)) {
1505                         ast_log(LOG_NOTICE, "Failed to process CEL configuration; using defaults\n");
1506                         ao2_global_obj_replace_unref(cel_configs, cel_cfg);
1507                 }
1508         }
1509
1510         ast_register_cleanup(ast_cel_engine_term);
1511
1512         return 0;
1513 }
1514
1515 int ast_cel_engine_reload(void)
1516 {
1517         return do_reload();
1518 }
1519
1520 void ast_cel_publish_event(struct ast_channel *chan,
1521         enum ast_cel_event_type event_type,
1522         struct ast_json *blob)
1523 {
1524         RAII_VAR(struct ast_channel_blob *, obj, NULL, ao2_cleanup);
1525         RAII_VAR(struct ast_json *, cel_blob, NULL, ast_json_unref);
1526         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
1527         cel_blob = ast_json_pack("{s: i, s: O}",
1528                 "event_type", event_type,
1529                 "event_details", blob);
1530
1531         message = ast_channel_blob_create(chan, cel_generic_type(), cel_blob);
1532         if (message) {
1533                 stasis_publish(ast_cel_topic(), message);
1534         }
1535 }
1536
1537 struct stasis_topic *ast_cel_topic(void)
1538 {
1539         return cel_topic;
1540 }
1541
1542 struct ast_cel_general_config *ast_cel_get_config(void)
1543 {
1544         RAII_VAR(struct cel_config *, mod_cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
1545
1546         if (!mod_cfg || !mod_cfg->general) {
1547                 return NULL;
1548         }
1549
1550         ao2_ref(mod_cfg->general, +1);
1551         return mod_cfg->general;
1552 }
1553
1554 void ast_cel_set_config(struct ast_cel_general_config *config)
1555 {
1556         RAII_VAR(struct cel_config *, mod_cfg, ao2_global_obj_ref(cel_configs), ao2_cleanup);
1557         RAII_VAR(struct ast_cel_general_config *, cleanup_config, mod_cfg->general, ao2_cleanup);
1558
1559         if (mod_cfg) {
1560                 mod_cfg->general = config;
1561                 if (mod_cfg->general) {
1562                         ao2_ref(mod_cfg->general, +1);
1563                 }
1564         }
1565 }
1566
1567 int ast_cel_backend_unregister(const char *name)
1568 {
1569         RAII_VAR(struct cel_backend *, backend, NULL, ao2_cleanup);
1570
1571         backend = ao2_find(cel_backends, name, OBJ_KEY | OBJ_UNLINK);
1572         if (!backend) {
1573                 return -1;
1574         }
1575
1576         return 0;
1577 }
1578
1579 int ast_cel_backend_register(const char *name, ast_cel_backend_cb backend_callback)
1580 {
1581         RAII_VAR(struct cel_backend *, backend, NULL, ao2_cleanup);
1582
1583         if (ast_strlen_zero(name)) {
1584                 return -1;
1585         }
1586
1587         backend = ao2_alloc(sizeof(*backend) + 1 + strlen(name), NULL);
1588         if (!backend) {
1589                 return -1;
1590         }
1591
1592         /* safe strcpy */
1593         strcpy(backend->name, name);
1594         backend->callback = backend_callback;
1595         ao2_link(cel_backends, backend);
1596
1597         return 0;
1598 }