Convert CCSS manager events to stasis.
[asterisk/asterisk.git] / main / ccss.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2010, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@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  * \brief Call Completion Supplementary Services implementation
21  * \author Mark Michelson <mmichelson@digium.com>
22  */
23
24 /*! \li \ref ccss.c uses the configuration file \ref ccss.conf
25  * \addtogroup configuration_file Configuration Files
26  */
27
28 /*!
29  * \page ccss.conf ccss.conf
30  * \verbinclude ccss.conf.sample
31  */
32
33 /*** MODULEINFO
34         <support_level>core</support_level>
35  ***/
36
37 #include "asterisk.h"
38
39 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
40
41 #include "asterisk/astobj2.h"
42 #include "asterisk/strings.h"
43 #include "asterisk/ccss.h"
44 #include "asterisk/channel.h"
45 #include "asterisk/pbx.h"
46 #include "asterisk/utils.h"
47 #include "asterisk/taskprocessor.h"
48 #include "asterisk/event.h"
49 #include "asterisk/devicestate.h"
50 #include "asterisk/module.h"
51 #include "asterisk/app.h"
52 #include "asterisk/cli.h"
53 #include "asterisk/manager.h"
54 #include "asterisk/causes.h"
55 #include "asterisk/stasis_system.h"
56
57 /*** DOCUMENTATION
58         <application name="CallCompletionRequest" language="en_US">
59                 <synopsis>
60                         Request call completion service for previous call
61                 </synopsis>
62                 <syntax />
63                 <description>
64                         <para>Request call completion service for a previously failed
65                         call attempt.</para>
66                         <para>This application sets the following channel variables:</para>
67                         <variablelist>
68                                 <variable name="CC_REQUEST_RESULT">
69                                         <para>This is the returned status of the request.</para>
70                                         <value name="SUCCESS" />
71                                         <value name="FAIL" />
72                                 </variable>
73                                 <variable name="CC_REQUEST_REASON">
74                                         <para>This is the reason the request failed.</para>
75                                         <value name="NO_CORE_INSTANCE" />
76                                         <value name="NOT_GENERIC" />
77                                         <value name="TOO_MANY_REQUESTS" />
78                                         <value name="UNSPECIFIED" />
79                                 </variable>
80                         </variablelist>
81                 </description>
82         </application>
83         <application name="CallCompletionCancel" language="en_US">
84                 <synopsis>
85                         Cancel call completion service
86                 </synopsis>
87                 <syntax />
88                 <description>
89                         <para>Cancel a Call Completion Request.</para>
90                         <para>This application sets the following channel variables:</para>
91                         <variablelist>
92                                 <variable name="CC_CANCEL_RESULT">
93                                         <para>This is the returned status of the cancel.</para>
94                                         <value name="SUCCESS" />
95                                         <value name="FAIL" />
96                                 </variable>
97                                 <variable name="CC_CANCEL_REASON">
98                                         <para>This is the reason the cancel failed.</para>
99                                         <value name="NO_CORE_INSTANCE" />
100                                         <value name="NOT_GENERIC" />
101                                         <value name="UNSPECIFIED" />
102                                 </variable>
103                         </variablelist>
104                 </description>
105         </application>
106  ***/
107
108 /* These are some file-scoped variables. It would be
109  * nice to define them closer to their first usage, but since
110  * they are used in many places throughout the file, defining
111  * them here at the top is easiest.
112  */
113
114 /*!
115  * The ast_sched_context used for all generic CC timeouts
116  */
117 static struct ast_sched_context *cc_sched_context;
118 /*!
119  * Counter used to create core IDs for CC calls. Each new
120  * core ID is created by atomically adding 1 to the core_id_counter
121  */
122 static int core_id_counter;
123 /*!
124  * Taskprocessor from which all CC agent and monitor callbacks
125  * are called.
126  */
127 static struct ast_taskprocessor *cc_core_taskprocessor;
128 /*!
129  * Name printed on all CC log messages.
130  */
131 static const char *CC_LOGGER_LEVEL_NAME = "CC";
132 /*!
133  * Logger level registered by the CC core.
134  */
135 static int cc_logger_level;
136 /*!
137  * Parsed configuration value for cc_max_requests
138  */
139 static unsigned int global_cc_max_requests;
140 /*!
141  * The current number of CC requests in the system
142  */
143 static int cc_request_count;
144
145 static inline void *cc_ref(void *obj, const char *debug)
146 {
147         ao2_t_ref(obj, +1, debug);
148         return obj;
149 }
150
151 static inline void *cc_unref(void *obj, const char *debug)
152 {
153         ao2_t_ref(obj, -1, debug);
154         return NULL;
155 }
156
157 /*!
158  * \since 1.8
159  * \internal
160  * \brief A structure for holding the configuration parameters
161  * relating to CCSS
162  */
163 struct ast_cc_config_params {
164         enum ast_cc_agent_policies cc_agent_policy;
165         enum ast_cc_monitor_policies cc_monitor_policy;
166         unsigned int cc_offer_timer;
167         unsigned int ccnr_available_timer;
168         unsigned int ccbs_available_timer;
169         unsigned int cc_recall_timer;
170         unsigned int cc_max_agents;
171         unsigned int cc_max_monitors;
172         char cc_callback_macro[AST_MAX_EXTENSION];
173         char cc_callback_sub[AST_MAX_EXTENSION];
174         char cc_agent_dialstring[AST_MAX_EXTENSION];
175 };
176
177 /*!
178  * \since 1.8
179  * \brief The states used in the CCSS core state machine
180  *
181  * For more information, see doc/CCSS_architecture.pdf
182  */
183 enum cc_state {
184         /*! Entered when it is determined that CCSS may be used for the call */
185         CC_AVAILABLE,
186         /*! Entered when a CCSS agent has offered CCSS to a caller */
187         CC_CALLER_OFFERED,
188         /*! Entered when a CCSS agent confirms that a caller has
189          * requested CCSS */
190         CC_CALLER_REQUESTED,
191         /*! Entered when a CCSS monitor confirms acknowledgment of an
192          * outbound CCSS request */
193         CC_ACTIVE,
194         /*! Entered when a CCSS monitor alerts the core that the called party
195          * has become available */
196         CC_CALLEE_READY,
197         /*! Entered when a CCSS agent alerts the core that the calling party
198          * may not be recalled because he is unavailable
199          */
200         CC_CALLER_BUSY,
201         /*! Entered when a CCSS agent alerts the core that the calling party
202          * is attempting to recall the called party
203          */
204         CC_RECALLING,
205         /*! Entered when an application alerts the core that the calling party's
206          * recall attempt has had a call progress response indicated
207          */
208         CC_COMPLETE,
209         /*! Entered any time that something goes wrong during the process, thus
210          * resulting in the failure of the attempted CCSS transaction. Note also
211          * that cancellations of CC are treated as failures.
212          */
213         CC_FAILED,
214 };
215
216 /*!
217  * \brief The payload for an AST_CONTROL_CC frame
218  *
219  * \details
220  * This contains all the necessary data regarding
221  * a called device so that the CC core will be able
222  * to allocate the proper monitoring resources.
223  */
224 struct cc_control_payload {
225         /*!
226          * \brief The type of monitor to allocate.
227          *
228          * \details
229          * The type of monitor to allocate. This is a string which corresponds
230          * to a set of monitor callbacks registered. Examples include "generic"
231          * and "SIP"
232          *
233          * \note This really should be an array of characters in case this payload
234          * is sent accross an IAX2 link.  However, this would not make too much sense
235          * given this type may not be recognized by the other end.
236          * Protection may be necessary to prevent it from being transmitted.
237          *
238          * In addition the following other problems are also possible:
239          * 1) Endian issues with the integers/enums stored in the config_params.
240          * 2) Alignment padding issues for the element types.
241          */
242         const char *monitor_type;
243         /*!
244          * \brief Private data allocated by the callee
245          *
246          * \details
247          * All channel drivers that monitor endpoints will need to allocate
248          * data that is not usable by the CC core. In most cases, some or all
249          * of this data is allocated at the time that the channel driver offers
250          * CC to the caller. There are many opportunities for failures to occur
251          * between when a channel driver offers CC and when a monitor is actually
252          * allocated to watch the endpoint. For this reason, the channel driver
253          * must give the core a pointer to the private data that was allocated so
254          * that the core can call back into the channel driver to destroy it if
255          * a failure occurs. If no private data has been allocated at the time that
256          * CC is offered, then it is perfectly acceptable to pass NULL for this
257          * field.
258          */
259         void *private_data;
260         /*!
261          * \brief Service offered by the endpoint
262          *
263          * \details
264          * This indicates the type of call completion service offered by the
265          * endpoint. This data is not crucial to the machinations of the CC core,
266          * but it is helpful for debugging purposes.
267          */
268         enum ast_cc_service_type service;
269         /*!
270          * \brief Configuration parameters used by this endpoint
271          *
272          * \details
273          * Each time an endpoint offers call completion, it must provide its call
274          * completion configuration parameters. This is because settings may be different
275          * depending on the circumstances.
276          */
277         struct ast_cc_config_params config_params;
278         /*!
279          * \brief ID of parent extension
280          *
281          * \details
282          * This is the only datum that the CC core derives on its own and is not
283          * provided by the offerer of CC. This provides the core with information on
284          * which extension monitor is the most immediate parent of this device.
285          */
286         int parent_interface_id;
287         /*!
288          * \brief Name of device to be monitored
289          *
290          * \details
291          * The device name by which this monitored endpoint will be referred in the
292          * CC core. It is highly recommended that this device name is derived by using
293          * the function ast_channel_get_device_name.
294          */
295         char device_name[AST_CHANNEL_NAME];
296         /*!
297          * \brief Recall dialstring
298          *
299          * \details
300          * Certain channel drivers (DAHDI in particular) will require that a special
301          * dialstring be used to indicate that the outgoing call is to interpreted as
302          * a CC recall. If the channel driver has such a requirement, then this is
303          * where that special recall dialstring is placed. If no special dialstring
304          * is to be used, then the channel driver must provide the original dialstring
305          * used to call this endpoint.
306          */
307         char dialstring[AST_CHANNEL_NAME];
308 };
309
310 /*!
311  * \brief The "tree" of interfaces that is dialed.
312  *
313  * \details
314  * Though this is a linked list, it is logically treated
315  * as a tree of monitors. Each monitor has an id and a parent_id
316  * associated with it. The id is a unique ID for that monitor, and
317  * the parent_id is the unique ID of the monitor's parent in the
318  * tree. The tree is structured such that all of a parent's children
319  * will appear after the parent in the tree. However, it cannot be
320  * guaranteed exactly where after the parent the children are.
321  *
322  * The tree is reference counted since several threads may need
323  * to use it, and it may last beyond the lifetime of a single
324  * thread.
325  */
326 AST_LIST_HEAD(cc_monitor_tree, ast_cc_monitor);
327
328 static const int CC_CORE_INSTANCES_BUCKETS = 17;
329 static struct ao2_container *cc_core_instances;
330
331 struct cc_core_instance {
332         /*!
333          * Unique identifier for this instance of the CC core.
334          */
335         int core_id;
336         /*!
337          * The current state for this instance of the CC core.
338          */
339         enum cc_state current_state;
340         /*!
341          * The CC agent in use for this call
342          */
343         struct ast_cc_agent *agent;
344         /*!
345          * Reference to the monitor tree formed during the initial call
346          */
347         struct cc_monitor_tree *monitors;
348 };
349
350 /*!
351  * \internal
352  * \brief Request that the core change states
353  * \param state The state to which we wish to change
354  * \param core_id The unique identifier for this instance of the CCSS core state machine
355  * \param debug Optional message explaining the reason for the state change
356  * \param ap varargs list
357  * \retval 0 State change successfully queued
358  * \retval -1 Unable to queue state change request
359  */
360 static int __attribute__((format(printf, 3, 0))) cc_request_state_change(enum cc_state state, const int core_id, const char *debug, va_list ap);
361
362 /*!
363  * \internal
364  * \brief create a new instance of the CC core and an agent for the calling channel
365  *
366  * This function will check to make sure that the incoming channel
367  * is allowed to request CC by making sure that the incoming channel
368  * has not exceeded its maximum number of allowed agents.
369  *
370  * Should that check pass, the core instance is created, and then the
371  * agent for the channel.
372  *
373  * \param caller_chan The incoming channel for this particular call
374  * \param called_tree A reference to the tree of called devices. The agent
375  * will gain a reference to this tree as well
376  * \param core_id The core_id that this core_instance will assume
377  * \retval NULL Failed to create the core instance either due to memory allocation
378  * errors or due to the agent count for the caller being too high
379  * \retval non-NULL A reference to the newly created cc_core_instance
380  */
381 static struct cc_core_instance *cc_core_init_instance(struct ast_channel *caller_chan,
382                 struct cc_monitor_tree *called_tree, const int core_id, struct cc_control_payload *cc_data);
383
384 static const struct {
385         enum ast_cc_service_type service;
386         const char *service_string;
387 } cc_service_to_string_map[] = {
388         {AST_CC_NONE, "NONE"},
389         {AST_CC_CCBS, "CCBS"},
390         {AST_CC_CCNR, "CCNR"},
391         {AST_CC_CCNL, "CCNL"},
392 };
393
394 static const struct {
395         enum cc_state state;
396         const char *state_string;
397 } cc_state_to_string_map[] = {
398         {CC_AVAILABLE,          "CC is available"},
399         {CC_CALLER_OFFERED,     "CC offered to caller"},
400         {CC_CALLER_REQUESTED,   "CC requested by caller"},
401         {CC_ACTIVE,             "CC accepted by callee"},
402         {CC_CALLEE_READY,       "Callee has become available"},
403         {CC_CALLER_BUSY,        "Callee was ready, but caller is now unavailable"},
404         {CC_RECALLING,          "Caller is attempting to recall"},
405         {CC_COMPLETE,           "Recall complete"},
406         {CC_FAILED,             "CC has failed"},
407 };
408
409 static const char *cc_state_to_string(enum cc_state state)
410 {
411         return cc_state_to_string_map[state].state_string;
412 }
413
414 static const char *cc_service_to_string(enum ast_cc_service_type service)
415 {
416         return cc_service_to_string_map[service].service_string;
417 }
418
419 static int cc_core_instance_hash_fn(const void *obj, const int flags)
420 {
421         const struct cc_core_instance *core_instance = obj;
422         return core_instance->core_id;
423 }
424
425 static int cc_core_instance_cmp_fn(void *obj, void *arg, int flags)
426 {
427         struct cc_core_instance *core_instance1 = obj;
428         struct cc_core_instance *core_instance2 = arg;
429
430         return core_instance1->core_id == core_instance2->core_id ? CMP_MATCH | CMP_STOP : 0;
431 }
432
433 static struct cc_core_instance *find_cc_core_instance(const int core_id)
434 {
435         struct cc_core_instance finder = {.core_id = core_id,};
436
437         return ao2_t_find(cc_core_instances, &finder, OBJ_POINTER, "Finding a core_instance");
438 }
439
440 struct cc_callback_helper {
441         ao2_callback_fn *function;
442         void *args;
443         const char *type;
444 };
445
446 static int cc_agent_callback_helper(void *obj, void *args, int flags)
447 {
448         struct cc_core_instance *core_instance = obj;
449         struct cc_callback_helper *helper = args;
450
451         if (strcmp(core_instance->agent->callbacks->type, helper->type)) {
452                 return 0;
453         }
454
455         return helper->function(core_instance->agent, helper->args, flags);
456 }
457
458 struct ast_cc_agent *ast_cc_agent_callback(int flags, ao2_callback_fn *function, void *args, const char * const type)
459 {
460         struct cc_callback_helper helper = {.function = function, .args = args, .type = type};
461         struct cc_core_instance *core_instance;
462         if ((core_instance = ao2_t_callback(cc_core_instances, flags, cc_agent_callback_helper, &helper,
463                                         "Calling provided agent callback function"))) {
464                 struct ast_cc_agent *agent = cc_ref(core_instance->agent, "An outside entity needs the agent");
465                 cc_unref(core_instance, "agent callback done with the core_instance");
466                 return agent;
467         }
468         return NULL;
469 }
470
471 enum match_flags {
472         /* Only match agents that have not yet
473          * made a CC request
474          */
475         MATCH_NO_REQUEST = (1 << 0),
476         /* Only match agents that have made
477          * a CC request
478          */
479         MATCH_REQUEST = (1 << 1),
480 };
481
482 /* ao2_callbacks for cc_core_instances */
483
484 /*!
485  * \internal
486  * \brief find a core instance based on its agent
487  *
488  * The match flags tell whether we wish to find core instances
489  * that have a monitor or core instances that do not. Core instances
490  * with no monitor are core instances for which a caller has not yet
491  * requested CC. Core instances with a monitor are ones for which the
492  * caller has requested CC.
493  */
494 static int match_agent(void *obj, void *arg, void *data, int flags)
495 {
496         struct cc_core_instance *core_instance = obj;
497         const char *name = arg;
498         unsigned long match_flags = *(unsigned long *)data;
499         int possible_match = 0;
500
501         if ((match_flags & MATCH_NO_REQUEST) && core_instance->current_state < CC_CALLER_REQUESTED) {
502                 possible_match = 1;
503         }
504
505         if ((match_flags & MATCH_REQUEST) && core_instance->current_state >= CC_CALLER_REQUESTED) {
506                 possible_match = 1;
507         }
508
509         if (!possible_match) {
510                 return 0;
511         }
512
513         if (!strcmp(core_instance->agent->device_name, name)) {
514                 return CMP_MATCH | CMP_STOP;
515         }
516         return 0;
517 }
518
519 struct count_agents_cb_data {
520         int count;
521         int core_id_exception;
522 };
523
524 /*!
525  * \internal
526  * \brief Count the number of agents a specific interface is using
527  *
528  * We're only concerned with the number of agents that have requested
529  * CC, so we restrict our search to core instances which have a non-NULL
530  * monitor pointer
531  */
532 static int count_agents_cb(void *obj, void *arg, void *data, int flags)
533 {
534         struct cc_core_instance *core_instance = obj;
535         const char *name = arg;
536         struct count_agents_cb_data *cb_data = data;
537
538         if (cb_data->core_id_exception == core_instance->core_id) {
539                 ast_log_dynamic_level(cc_logger_level, "Found agent with core_id %d but not counting it toward total\n", core_instance->core_id);
540                 return 0;
541         }
542
543         if (core_instance->current_state >= CC_CALLER_REQUESTED && !strcmp(core_instance->agent->device_name, name)) {
544                 cb_data->count++;
545         }
546         return 0;
547 }
548
549 /* default values mapping from cc_state to ast_dev_state */
550
551 #define CC_AVAILABLE_DEVSTATE_DEFAULT        AST_DEVICE_NOT_INUSE
552 #define CC_CALLER_OFFERED_DEVSTATE_DEFAULT   AST_DEVICE_NOT_INUSE
553 #define CC_CALLER_REQUESTED_DEVSTATE_DEFAULT AST_DEVICE_NOT_INUSE
554 #define CC_ACTIVE_DEVSTATE_DEFAULT           AST_DEVICE_INUSE
555 #define CC_CALLEE_READY_DEVSTATE_DEFAULT     AST_DEVICE_RINGING
556 #define CC_CALLER_BUSY_DEVSTATE_DEFAULT      AST_DEVICE_ONHOLD
557 #define CC_RECALLING_DEVSTATE_DEFAULT        AST_DEVICE_RINGING
558 #define CC_COMPLETE_DEVSTATE_DEFAULT         AST_DEVICE_NOT_INUSE
559 #define CC_FAILED_DEVSTATE_DEFAULT           AST_DEVICE_NOT_INUSE
560
561 /*!
562  * \internal
563  * \brief initialization of defaults for CC_STATE to DEVICE_STATE map
564  */
565 static enum ast_device_state cc_state_to_devstate_map[] = {
566         [CC_AVAILABLE] =        CC_AVAILABLE_DEVSTATE_DEFAULT,
567         [CC_CALLER_OFFERED] =   CC_CALLER_OFFERED_DEVSTATE_DEFAULT,
568         [CC_CALLER_REQUESTED] = CC_CALLER_REQUESTED_DEVSTATE_DEFAULT,
569         [CC_ACTIVE] =           CC_ACTIVE_DEVSTATE_DEFAULT,
570         [CC_CALLEE_READY] =     CC_CALLEE_READY_DEVSTATE_DEFAULT,
571         [CC_CALLER_BUSY] =      CC_CALLER_BUSY_DEVSTATE_DEFAULT,
572         [CC_RECALLING] =        CC_RECALLING_DEVSTATE_DEFAULT,
573         [CC_COMPLETE] =         CC_COMPLETE_DEVSTATE_DEFAULT,
574         [CC_FAILED] =           CC_FAILED_DEVSTATE_DEFAULT,
575 };
576
577 /*!
578  * \internal
579  * \brief lookup the ast_device_state mapped to cc_state
580  *
581  * \param state
582  *
583  * \return the correponding DEVICE STATE from the cc_state_to_devstate_map
584  * when passed an internal state.
585  */
586 static enum ast_device_state cc_state_to_devstate(enum cc_state state)
587 {
588         return cc_state_to_devstate_map[state];
589 }
590
591 /*!
592  * \internal
593  * \brief Callback for devicestate providers
594  *
595  * \details
596  * Initialize with ast_devstate_prov_add() and returns the corresponding
597  * DEVICE STATE based on the current CC_STATE state machine if the requested
598  * device is found and is a generic device. Returns the equivalent of
599  * CC_FAILED, which defaults to NOT_INUSE, if no device is found.  NOT_INUSE would
600  * indicate that there is no presence of any pending call back.
601  */
602 static enum ast_device_state ccss_device_state(const char *device_name)
603 {
604         struct cc_core_instance *core_instance;
605         unsigned long match_flags;
606         enum ast_device_state cc_current_state;
607
608         match_flags = MATCH_NO_REQUEST;
609         core_instance = ao2_t_callback_data(cc_core_instances, 0, match_agent,
610                 (char *) device_name, &match_flags,
611                 "Find Core Instance for ccss_device_state reqeust.");
612         if (!core_instance) {
613                 ast_log_dynamic_level(cc_logger_level,
614                         "Couldn't find a core instance for caller %s\n", device_name);
615                 return cc_state_to_devstate(CC_FAILED);
616         }
617
618         ast_log_dynamic_level(cc_logger_level,
619                 "Core %d: Found core_instance for caller %s in state %s\n",
620                 core_instance->core_id, device_name, cc_state_to_string(core_instance->current_state));
621
622         if (strcmp(core_instance->agent->callbacks->type, "generic")) {
623                 ast_log_dynamic_level(cc_logger_level,
624                         "Core %d: Device State is only for generic agent types.\n",
625                         core_instance->core_id);
626                 cc_unref(core_instance, "Unref core_instance since ccss_device_state was called with native agent");
627                 return cc_state_to_devstate(CC_FAILED);
628         }
629         cc_current_state = cc_state_to_devstate(core_instance->current_state);
630         cc_unref(core_instance, "Unref core_instance done with ccss_device_state");
631         return cc_current_state;
632 }
633
634 /*!
635  * \internal
636  * \brief Notify Device State Changes from CC STATE MACHINE
637  *
638  * \details
639  * Any time a state is changed, we call this function to notify the DEVICE STATE
640  * subsystem of the change so that subscribed phones to any corresponding hints that
641  * are using that state are updated.
642  */
643 static void ccss_notify_device_state_change(const char *device, enum cc_state state)
644 {
645         enum ast_device_state devstate;
646
647         devstate = cc_state_to_devstate(state);
648
649         ast_log_dynamic_level(cc_logger_level,
650                 "Notification of CCSS state change to '%s', device state '%s' for device '%s'\n",
651                 cc_state_to_string(state), ast_devstate2str(devstate), device);
652
653         ast_devstate_changed(devstate, AST_DEVSTATE_CACHABLE, "ccss:%s", device);
654 }
655
656 #define CC_OFFER_TIMER_DEFAULT                  20              /* Seconds */
657 #define CCNR_AVAILABLE_TIMER_DEFAULT    7200    /* Seconds */
658 #define CCBS_AVAILABLE_TIMER_DEFAULT    4800    /* Seconds */
659 #define CC_RECALL_TIMER_DEFAULT                 20              /* Seconds */
660 #define CC_MAX_AGENTS_DEFAULT                   5
661 #define CC_MAX_MONITORS_DEFAULT                 5
662 #define GLOBAL_CC_MAX_REQUESTS_DEFAULT  20
663
664 static const struct ast_cc_config_params cc_default_params = {
665         .cc_agent_policy = AST_CC_AGENT_NEVER,
666         .cc_monitor_policy = AST_CC_MONITOR_NEVER,
667         .cc_offer_timer = CC_OFFER_TIMER_DEFAULT,
668         .ccnr_available_timer = CCNR_AVAILABLE_TIMER_DEFAULT,
669         .ccbs_available_timer = CCBS_AVAILABLE_TIMER_DEFAULT,
670         .cc_recall_timer = CC_RECALL_TIMER_DEFAULT,
671         .cc_max_agents = CC_MAX_AGENTS_DEFAULT,
672         .cc_max_monitors = CC_MAX_MONITORS_DEFAULT,
673         .cc_callback_macro = "",
674         .cc_callback_sub = "",
675         .cc_agent_dialstring = "",
676 };
677
678 void ast_cc_default_config_params(struct ast_cc_config_params *params)
679 {
680         *params = cc_default_params;
681 }
682
683 struct ast_cc_config_params *__ast_cc_config_params_init(const char *file, int line, const char *function)
684 {
685 #if defined(__AST_DEBUG_MALLOC)
686         struct ast_cc_config_params *params = __ast_malloc(sizeof(*params), file, line, function);
687 #else
688         struct ast_cc_config_params *params = ast_malloc(sizeof(*params));
689 #endif
690
691         if (!params) {
692                 return NULL;
693         }
694
695         ast_cc_default_config_params(params);
696         return params;
697 }
698
699 void ast_cc_config_params_destroy(struct ast_cc_config_params *params)
700 {
701         ast_free(params);
702 }
703
704 static enum ast_cc_agent_policies str_to_agent_policy(const char * const value)
705 {
706         if (!strcasecmp(value, "never")) {
707                 return AST_CC_AGENT_NEVER;
708         } else if (!strcasecmp(value, "native")) {
709                 return AST_CC_AGENT_NATIVE;
710         } else if (!strcasecmp(value, "generic")) {
711                 return AST_CC_AGENT_GENERIC;
712         } else {
713                 ast_log(LOG_WARNING, "%s is an invalid value for cc_agent_policy. Switching to 'never'\n", value);
714                 return AST_CC_AGENT_NEVER;
715         }
716 }
717
718 static enum ast_cc_monitor_policies str_to_monitor_policy(const char * const value)
719 {
720         if (!strcasecmp(value, "never")) {
721                 return AST_CC_MONITOR_NEVER;
722         } else if (!strcasecmp(value, "native")) {
723                 return AST_CC_MONITOR_NATIVE;
724         } else if (!strcasecmp(value, "generic")) {
725                 return AST_CC_MONITOR_GENERIC;
726         } else if (!strcasecmp(value, "always")) {
727                 return AST_CC_MONITOR_ALWAYS;
728         } else {
729                 ast_log(LOG_WARNING, "%s is an invalid value for cc_monitor_policy. Switching to 'never'\n", value);
730                 return AST_CC_MONITOR_NEVER;
731         }
732 }
733
734 static const char *agent_policy_to_str(enum ast_cc_agent_policies policy)
735 {
736         switch (policy) {
737         case AST_CC_AGENT_NEVER:
738                 return "never";
739         case AST_CC_AGENT_NATIVE:
740                 return "native";
741         case AST_CC_AGENT_GENERIC:
742                 return "generic";
743         default:
744                 /* This should never happen... */
745                 return "";
746         }
747 }
748
749 static const char *monitor_policy_to_str(enum ast_cc_monitor_policies policy)
750 {
751         switch (policy) {
752         case AST_CC_MONITOR_NEVER:
753                 return "never";
754         case AST_CC_MONITOR_NATIVE:
755                 return "native";
756         case AST_CC_MONITOR_GENERIC:
757                 return "generic";
758         case AST_CC_MONITOR_ALWAYS:
759                 return "always";
760         default:
761                 /* This should never happen... */
762                 return "";
763         }
764 }
765 int ast_cc_get_param(struct ast_cc_config_params *params, const char * const name,
766                 char *buf, size_t buf_len)
767 {
768         const char *value = NULL;
769
770         if (!strcasecmp(name, "cc_callback_macro")) {
771                 value = ast_get_cc_callback_macro(params);
772         } else if (!strcasecmp(name, "cc_callback_sub")) {
773                 value = ast_get_cc_callback_sub(params);
774         } else if (!strcasecmp(name, "cc_agent_policy")) {
775                 value = agent_policy_to_str(ast_get_cc_agent_policy(params));
776         } else if (!strcasecmp(name, "cc_monitor_policy")) {
777                 value = monitor_policy_to_str(ast_get_cc_monitor_policy(params));
778         } else if (!strcasecmp(name, "cc_agent_dialstring")) {
779                 value = ast_get_cc_agent_dialstring(params);
780         }
781         if (value) {
782                 ast_copy_string(buf, value, buf_len);
783                 return 0;
784         }
785
786         /* The rest of these are all ints of some sort and require some
787          * snprintf-itude
788          */
789
790         if (!strcasecmp(name, "cc_offer_timer")) {
791                 snprintf(buf, buf_len, "%u", ast_get_cc_offer_timer(params));
792         } else if (!strcasecmp(name, "ccnr_available_timer")) {
793                 snprintf(buf, buf_len, "%u", ast_get_ccnr_available_timer(params));
794         } else if (!strcasecmp(name, "ccbs_available_timer")) {
795                 snprintf(buf, buf_len, "%u", ast_get_ccbs_available_timer(params));
796         } else if (!strcasecmp(name, "cc_max_agents")) {
797                 snprintf(buf, buf_len, "%u", ast_get_cc_max_agents(params));
798         } else if (!strcasecmp(name, "cc_max_monitors")) {
799                 snprintf(buf, buf_len, "%u", ast_get_cc_max_monitors(params));
800         } else if (!strcasecmp(name, "cc_recall_timer")) {
801                 snprintf(buf, buf_len, "%u", ast_get_cc_recall_timer(params));
802         } else {
803                 ast_log(LOG_WARNING, "%s is not a valid CC parameter. Ignoring.\n", name);
804                 return -1;
805         }
806
807         return 0;
808 }
809
810 int ast_cc_set_param(struct ast_cc_config_params *params, const char * const name,
811                 const char * const value)
812 {
813         unsigned int value_as_uint;
814         if (!strcasecmp(name, "cc_agent_policy")) {
815                 return ast_set_cc_agent_policy(params, str_to_agent_policy(value));
816         } else if (!strcasecmp(name, "cc_monitor_policy")) {
817                 return ast_set_cc_monitor_policy(params, str_to_monitor_policy(value));
818         } else if (!strcasecmp(name, "cc_agent_dialstring")) {
819                 ast_set_cc_agent_dialstring(params, value);
820         } else if (!strcasecmp(name, "cc_callback_macro")) {
821                 ast_set_cc_callback_macro(params, value);
822                 return 0;
823         } else if (!strcasecmp(name, "cc_callback_sub")) {
824                 ast_set_cc_callback_sub(params, value);
825                 return 0;
826         }
827
828         if (!sscanf(value, "%30u", &value_as_uint) == 1) {
829                 return -1;
830         }
831
832         if (!strcasecmp(name, "cc_offer_timer")) {
833                 ast_set_cc_offer_timer(params, value_as_uint);
834         } else if (!strcasecmp(name, "ccnr_available_timer")) {
835                 ast_set_ccnr_available_timer(params, value_as_uint);
836         } else if (!strcasecmp(name, "ccbs_available_timer")) {
837                 ast_set_ccbs_available_timer(params, value_as_uint);
838         } else if (!strcasecmp(name, "cc_max_agents")) {
839                 ast_set_cc_max_agents(params, value_as_uint);
840         } else if (!strcasecmp(name, "cc_max_monitors")) {
841                 ast_set_cc_max_monitors(params, value_as_uint);
842         } else if (!strcasecmp(name, "cc_recall_timer")) {
843                 ast_set_cc_recall_timer(params, value_as_uint);
844         } else {
845                 ast_log(LOG_WARNING, "%s is not a valid CC parameter. Ignoring.\n", name);
846                 return -1;
847         }
848
849         return 0;
850 }
851
852 int ast_cc_is_config_param(const char * const name)
853 {
854         return (!strcasecmp(name, "cc_agent_policy") ||
855                                 !strcasecmp(name, "cc_monitor_policy") ||
856                                 !strcasecmp(name, "cc_offer_timer") ||
857                                 !strcasecmp(name, "ccnr_available_timer") ||
858                                 !strcasecmp(name, "ccbs_available_timer") ||
859                                 !strcasecmp(name, "cc_max_agents") ||
860                                 !strcasecmp(name, "cc_max_monitors") ||
861                                 !strcasecmp(name, "cc_callback_macro") ||
862                                 !strcasecmp(name, "cc_callback_sub") ||
863                                 !strcasecmp(name, "cc_agent_dialstring") ||
864                                 !strcasecmp(name, "cc_recall_timer"));
865 }
866
867 void ast_cc_copy_config_params(struct ast_cc_config_params *dest, const struct ast_cc_config_params *src)
868 {
869         *dest = *src;
870 }
871
872 enum ast_cc_agent_policies ast_get_cc_agent_policy(struct ast_cc_config_params *config)
873 {
874         return config->cc_agent_policy;
875 }
876
877 int ast_set_cc_agent_policy(struct ast_cc_config_params *config, enum ast_cc_agent_policies value)
878 {
879         /* Screw C and its weak type checking for making me have to do this
880          * validation at runtime.
881          */
882         if (value < AST_CC_AGENT_NEVER || value > AST_CC_AGENT_GENERIC) {
883                 return -1;
884         }
885         config->cc_agent_policy = value;
886         return 0;
887 }
888
889 enum ast_cc_monitor_policies ast_get_cc_monitor_policy(struct ast_cc_config_params *config)
890 {
891         return config->cc_monitor_policy;
892 }
893
894 int ast_set_cc_monitor_policy(struct ast_cc_config_params *config, enum ast_cc_monitor_policies value)
895 {
896         /* Screw C and its weak type checking for making me have to do this
897          * validation at runtime.
898          */
899         if (value < AST_CC_MONITOR_NEVER || value > AST_CC_MONITOR_ALWAYS) {
900                 return -1;
901         }
902         config->cc_monitor_policy = value;
903         return 0;
904 }
905
906 unsigned int ast_get_cc_offer_timer(struct ast_cc_config_params *config)
907 {
908         return config->cc_offer_timer;
909 }
910
911 void ast_set_cc_offer_timer(struct ast_cc_config_params *config, unsigned int value)
912 {
913         /* 0 is an unreasonable value for any timer. Stick with the default */
914         if (value == 0) {
915                 ast_log(LOG_WARNING, "0 is an invalid value for cc_offer_timer. Retaining value as %u\n", config->cc_offer_timer);
916                 return;
917         }
918         config->cc_offer_timer = value;
919 }
920
921 unsigned int ast_get_ccnr_available_timer(struct ast_cc_config_params *config)
922 {
923         return config->ccnr_available_timer;
924 }
925
926 void ast_set_ccnr_available_timer(struct ast_cc_config_params *config, unsigned int value)
927 {
928         /* 0 is an unreasonable value for any timer. Stick with the default */
929         if (value == 0) {
930                 ast_log(LOG_WARNING, "0 is an invalid value for ccnr_available_timer. Retaining value as %u\n", config->ccnr_available_timer);
931                 return;
932         }
933         config->ccnr_available_timer = value;
934 }
935
936 unsigned int ast_get_cc_recall_timer(struct ast_cc_config_params *config)
937 {
938         return config->cc_recall_timer;
939 }
940
941 void ast_set_cc_recall_timer(struct ast_cc_config_params *config, unsigned int value)
942 {
943         /* 0 is an unreasonable value for any timer. Stick with the default */
944         if (value == 0) {
945                 ast_log(LOG_WARNING, "0 is an invalid value for ccnr_available_timer. Retaining value as %u\n", config->cc_recall_timer);
946                 return;
947         }
948         config->cc_recall_timer = value;
949 }
950
951 unsigned int ast_get_ccbs_available_timer(struct ast_cc_config_params *config)
952 {
953         return config->ccbs_available_timer;
954 }
955
956 void ast_set_ccbs_available_timer(struct ast_cc_config_params *config, unsigned int value)
957 {
958         /* 0 is an unreasonable value for any timer. Stick with the default */
959         if (value == 0) {
960                 ast_log(LOG_WARNING, "0 is an invalid value for ccbs_available_timer. Retaining value as %u\n", config->ccbs_available_timer);
961                 return;
962         }
963         config->ccbs_available_timer = value;
964 }
965
966 const char *ast_get_cc_agent_dialstring(struct ast_cc_config_params *config)
967 {
968         return config->cc_agent_dialstring;
969 }
970
971 void ast_set_cc_agent_dialstring(struct ast_cc_config_params *config, const char *const value)
972 {
973         if (ast_strlen_zero(value)) {
974                 config->cc_agent_dialstring[0] = '\0';
975         } else {
976                 ast_copy_string(config->cc_agent_dialstring, value, sizeof(config->cc_agent_dialstring));
977         }
978 }
979
980 unsigned int ast_get_cc_max_agents(struct ast_cc_config_params *config)
981 {
982         return config->cc_max_agents;
983 }
984
985 void ast_set_cc_max_agents(struct ast_cc_config_params *config, unsigned int value)
986 {
987         config->cc_max_agents = value;
988 }
989
990 unsigned int ast_get_cc_max_monitors(struct ast_cc_config_params *config)
991 {
992         return config->cc_max_monitors;
993 }
994
995 void ast_set_cc_max_monitors(struct ast_cc_config_params *config, unsigned int value)
996 {
997         config->cc_max_monitors = value;
998 }
999
1000 const char *ast_get_cc_callback_macro(struct ast_cc_config_params *config)
1001 {
1002         return config->cc_callback_macro;
1003 }
1004
1005 const char *ast_get_cc_callback_sub(struct ast_cc_config_params *config)
1006 {
1007         return config->cc_callback_sub;
1008 }
1009
1010 void ast_set_cc_callback_macro(struct ast_cc_config_params *config, const char * const value)
1011 {
1012         ast_log(LOG_WARNING, "Usage of cc_callback_macro is deprecated.  Please use cc_callback_sub instead.\n");
1013         if (ast_strlen_zero(value)) {
1014                 config->cc_callback_macro[0] = '\0';
1015         } else {
1016                 ast_copy_string(config->cc_callback_macro, value, sizeof(config->cc_callback_macro));
1017         }
1018 }
1019
1020 void ast_set_cc_callback_sub(struct ast_cc_config_params *config, const char * const value)
1021 {
1022         if (ast_strlen_zero(value)) {
1023                 config->cc_callback_sub[0] = '\0';
1024         } else {
1025                 ast_copy_string(config->cc_callback_sub, value, sizeof(config->cc_callback_sub));
1026         }
1027 }
1028
1029 static int cc_publish(struct stasis_message_type *message_type, int core_id, struct ast_json *extras)
1030 {
1031         RAII_VAR(struct ast_json *, blob, NULL, ast_json_unref);
1032         RAII_VAR(struct ast_json_payload *, payload, NULL, ao2_cleanup);
1033         RAII_VAR(struct stasis_message *, message, NULL, ao2_cleanup);
1034
1035         blob = ast_json_pack("{s: i}",
1036                 "core_id", core_id);
1037
1038         if (extras) {
1039                 ast_json_object_update(blob, extras);
1040         }
1041
1042         if (!(payload = ast_json_payload_create(blob))) {
1043                 return -1;
1044         }
1045
1046         if (!(message = stasis_message_create(message_type, payload))) {
1047                 return -1;
1048         }
1049
1050         stasis_publish(ast_system_topic(), message);
1051
1052         return 0;
1053 }
1054
1055 static void cc_publish_available(int core_id, const char *callee, const char *service)
1056 {
1057         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1058
1059         extras = ast_json_pack("{s: s, s: s}",
1060                 "callee", callee,
1061                 "service", service);
1062
1063         cc_publish(ast_cc_available_type(), core_id, extras);
1064 }
1065
1066 static void cc_publish_offertimerstart(int core_id, const char *caller, unsigned int expires)
1067 {
1068         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1069
1070         extras = ast_json_pack("{s: s, s: i}",
1071                 "caller", caller,
1072                 "expires", expires);
1073
1074         cc_publish(ast_cc_offertimerstart_type(), core_id, extras);
1075 }
1076
1077 static void cc_publish_requested(int core_id, const char *caller, const char *callee)
1078 {
1079         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1080
1081         extras = ast_json_pack("{s: s, s: s}",
1082                 "caller", caller,
1083                 "callee", callee);
1084
1085         cc_publish(ast_cc_requested_type(), core_id, extras);
1086 }
1087
1088 static void cc_publish_requestacknowledged(int core_id, const char *caller)
1089 {
1090         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1091
1092         extras = ast_json_pack("{s: s}",
1093                 "caller", caller);
1094
1095         cc_publish(ast_cc_requestacknowledged_type(), core_id, extras);
1096 }
1097
1098 static void cc_publish_callerstopmonitoring(int core_id, const char *caller)
1099 {
1100         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1101
1102         extras = ast_json_pack("{s: s}",
1103                 "caller", caller);
1104
1105         cc_publish(ast_cc_callerstopmonitoring_type(), core_id, extras);
1106 }
1107
1108 static void cc_publish_callerstartmonitoring(int core_id, const char *caller)
1109 {
1110         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1111
1112         extras = ast_json_pack("{s: s}",
1113                 "caller", caller);
1114
1115         cc_publish(ast_cc_callerstartmonitoring_type(), core_id, extras);
1116 }
1117
1118 static void cc_publish_callerrecalling(int core_id, const char *caller)
1119 {
1120         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1121
1122         extras = ast_json_pack("{s: s}",
1123                 "caller", caller);
1124
1125         cc_publish(ast_cc_callerrecalling_type(), core_id, extras);
1126 }
1127
1128 static void cc_publish_recallcomplete(int core_id, const char *caller)
1129 {
1130         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1131
1132         extras = ast_json_pack("{s: s}",
1133                 "caller", caller);
1134
1135         cc_publish(ast_cc_recallcomplete_type(), core_id, extras);
1136 }
1137
1138 static void cc_publish_failure(int core_id, const char *caller, const char *reason)
1139 {
1140         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1141
1142         extras = ast_json_pack("{s: s, s: s}",
1143                 "caller", caller,
1144                 "reason", reason);
1145
1146         cc_publish(ast_cc_failure_type(), core_id, extras);
1147 }
1148
1149 static void cc_publish_monitorfailed(int core_id, const char *callee)
1150 {
1151         RAII_VAR(struct ast_json *, extras, NULL, ast_json_unref);
1152
1153         extras = ast_json_pack("{s: s}",
1154                 "callee", callee);
1155
1156         cc_publish(ast_cc_monitorfailed_type(), core_id, extras);
1157 }
1158
1159 struct cc_monitor_backend {
1160         AST_LIST_ENTRY(cc_monitor_backend) next;
1161         const struct ast_cc_monitor_callbacks *callbacks;
1162 };
1163
1164 AST_RWLIST_HEAD_STATIC(cc_monitor_backends, cc_monitor_backend);
1165
1166 int ast_cc_monitor_register(const struct ast_cc_monitor_callbacks *callbacks)
1167 {
1168         struct cc_monitor_backend *backend = ast_calloc(1, sizeof(*backend));
1169
1170         if (!backend) {
1171                 return -1;
1172         }
1173
1174         backend->callbacks = callbacks;
1175
1176         AST_RWLIST_WRLOCK(&cc_monitor_backends);
1177         AST_RWLIST_INSERT_TAIL(&cc_monitor_backends, backend, next);
1178         AST_RWLIST_UNLOCK(&cc_monitor_backends);
1179         return 0;
1180 }
1181
1182 static const struct ast_cc_monitor_callbacks *find_monitor_callbacks(const char * const type)
1183 {
1184         struct cc_monitor_backend *backend;
1185         const struct ast_cc_monitor_callbacks *callbacks = NULL;
1186
1187         AST_RWLIST_RDLOCK(&cc_monitor_backends);
1188         AST_RWLIST_TRAVERSE(&cc_monitor_backends, backend, next) {
1189                 if (!strcmp(backend->callbacks->type, type)) {
1190                         ast_log_dynamic_level(cc_logger_level, "Returning monitor backend %s\n", backend->callbacks->type);
1191                         callbacks = backend->callbacks;
1192                         break;
1193                 }
1194         }
1195         AST_RWLIST_UNLOCK(&cc_monitor_backends);
1196         return callbacks;
1197 }
1198
1199 void ast_cc_monitor_unregister(const struct ast_cc_monitor_callbacks *callbacks)
1200 {
1201         struct cc_monitor_backend *backend;
1202         AST_RWLIST_WRLOCK(&cc_monitor_backends);
1203         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&cc_monitor_backends, backend, next) {
1204                 if (backend->callbacks == callbacks) {
1205                         AST_RWLIST_REMOVE_CURRENT(next);
1206                         ast_free(backend);
1207                         break;
1208                 }
1209         }
1210         AST_RWLIST_TRAVERSE_SAFE_END;
1211         AST_RWLIST_UNLOCK(&cc_monitor_backends);
1212 }
1213
1214 struct cc_agent_backend {
1215         AST_LIST_ENTRY(cc_agent_backend) next;
1216         const struct ast_cc_agent_callbacks *callbacks;
1217 };
1218
1219 AST_RWLIST_HEAD_STATIC(cc_agent_backends, cc_agent_backend);
1220
1221 int ast_cc_agent_register(const struct ast_cc_agent_callbacks *callbacks)
1222 {
1223         struct cc_agent_backend *backend = ast_calloc(1, sizeof(*backend));
1224
1225         if (!backend) {
1226                 return -1;
1227         }
1228
1229         backend->callbacks = callbacks;
1230         AST_RWLIST_WRLOCK(&cc_agent_backends);
1231         AST_RWLIST_INSERT_TAIL(&cc_agent_backends, backend, next);
1232         AST_RWLIST_UNLOCK(&cc_agent_backends);
1233         return 0;
1234 }
1235
1236 void ast_cc_agent_unregister(const struct ast_cc_agent_callbacks *callbacks)
1237 {
1238         struct cc_agent_backend *backend;
1239         AST_RWLIST_WRLOCK(&cc_agent_backends);
1240         AST_RWLIST_TRAVERSE_SAFE_BEGIN(&cc_agent_backends, backend, next) {
1241                 if (backend->callbacks == callbacks) {
1242                         AST_RWLIST_REMOVE_CURRENT(next);
1243                         ast_free(backend);
1244                         break;
1245                 }
1246         }
1247         AST_RWLIST_TRAVERSE_SAFE_END;
1248         AST_RWLIST_UNLOCK(&cc_agent_backends);
1249 }
1250
1251 static const struct ast_cc_agent_callbacks *find_agent_callbacks(struct ast_channel *chan)
1252 {
1253         struct cc_agent_backend *backend;
1254         const struct ast_cc_agent_callbacks *callbacks = NULL;
1255         struct ast_cc_config_params *cc_params;
1256         char type[32];
1257
1258         cc_params = ast_channel_get_cc_config_params(chan);
1259         if (!cc_params) {
1260                 return NULL;
1261         }
1262         switch (ast_get_cc_agent_policy(cc_params)) {
1263         case AST_CC_AGENT_GENERIC:
1264                 ast_copy_string(type, "generic", sizeof(type));
1265                 break;
1266         case AST_CC_AGENT_NATIVE:
1267                 ast_channel_get_cc_agent_type(chan, type, sizeof(type));
1268                 break;
1269         default:
1270                 ast_log_dynamic_level(cc_logger_level, "Not returning agent callbacks since this channel is configured not to have a CC agent\n");
1271                 return NULL;
1272         }
1273
1274         AST_RWLIST_RDLOCK(&cc_agent_backends);
1275         AST_RWLIST_TRAVERSE(&cc_agent_backends, backend, next) {
1276                 if (!strcmp(backend->callbacks->type, type)) {
1277                         ast_log_dynamic_level(cc_logger_level, "Returning agent backend %s\n", backend->callbacks->type);
1278                         callbacks = backend->callbacks;
1279                         break;
1280                 }
1281         }
1282         AST_RWLIST_UNLOCK(&cc_agent_backends);
1283         return callbacks;
1284 }
1285
1286 /*!
1287  * \internal
1288  * \brief Determine if the given device state is considered available by generic CCSS.
1289  * \since 1.8
1290  *
1291  * \param state Device state to test.
1292  *
1293  * \return TRUE if the given device state is considered available by generic CCSS.
1294  */
1295 static int cc_generic_is_device_available(enum ast_device_state state)
1296 {
1297         return state == AST_DEVICE_NOT_INUSE || state == AST_DEVICE_UNKNOWN;
1298 }
1299
1300 static int cc_generic_monitor_request_cc(struct ast_cc_monitor *monitor, int *available_timer_id);
1301 static int cc_generic_monitor_suspend(struct ast_cc_monitor *monitor);
1302 static int cc_generic_monitor_unsuspend(struct ast_cc_monitor *monitor);
1303 static int cc_generic_monitor_cancel_available_timer(struct ast_cc_monitor *monitor, int *sched_id);
1304 static void cc_generic_monitor_destructor(void *private_data);
1305
1306 static struct ast_cc_monitor_callbacks generic_monitor_cbs = {
1307         .type = "generic",
1308         .request_cc = cc_generic_monitor_request_cc,
1309         .suspend = cc_generic_monitor_suspend,
1310         .unsuspend = cc_generic_monitor_unsuspend,
1311         .cancel_available_timer = cc_generic_monitor_cancel_available_timer,
1312         .destructor = cc_generic_monitor_destructor,
1313 };
1314
1315 struct ao2_container *generic_monitors;
1316
1317 struct generic_monitor_instance {
1318         int core_id;
1319         int is_suspended;
1320         int monitoring;
1321         AST_LIST_ENTRY(generic_monitor_instance) next;
1322 };
1323
1324 struct generic_monitor_instance_list {
1325         const char *device_name;
1326         enum ast_device_state current_state;
1327         /* If there are multiple instances monitoring the
1328          * same device and one should fail, we need to know
1329          * whether to signal that the device can be recalled.
1330          * The problem is that the device state is not enough
1331          * to check. If a caller has requested CCNR, then the
1332          * fact that the device is available does not indicate
1333          * that the device is ready to be recalled. Instead, as
1334          * soon as one instance of the monitor becomes available
1335          * for a recall, we mark the entire list as being fit
1336          * for recall. If a CCNR request comes in, then we will
1337          * have to mark the list as unfit for recall since this
1338          * is a clear indicator that the person at the monitored
1339          * device has gone away and is actuall not fit to be
1340          * recalled
1341          */
1342         int fit_for_recall;
1343         struct stasis_subscription *sub;
1344         AST_LIST_HEAD_NOLOCK(, generic_monitor_instance) list;
1345 };
1346
1347 /*!
1348  * \brief private data for generic device monitor
1349  */
1350 struct generic_monitor_pvt {
1351         /*!
1352          * We need the device name during destruction so we
1353          * can find the appropriate item to destroy.
1354          */
1355         const char *device_name;
1356         /*!
1357          * We need the core ID for similar reasons. Once we
1358          * find the appropriate item in our ao2_container, we
1359          * need to remove the appropriate cc_monitor from the
1360          * list of monitors.
1361          */
1362         int core_id;
1363 };
1364
1365 static int generic_monitor_hash_fn(const void *obj, const int flags)
1366 {
1367         const struct generic_monitor_instance_list *generic_list = obj;
1368         return ast_str_hash(generic_list->device_name);
1369 }
1370
1371 static int generic_monitor_cmp_fn(void *obj, void *arg, int flags)
1372 {
1373         const struct generic_monitor_instance_list *generic_list1 = obj;
1374         const struct generic_monitor_instance_list *generic_list2 = arg;
1375
1376         return !strcmp(generic_list1->device_name, generic_list2->device_name) ? CMP_MATCH | CMP_STOP : 0;
1377 }
1378
1379 static struct generic_monitor_instance_list *find_generic_monitor_instance_list(const char * const device_name)
1380 {
1381         struct generic_monitor_instance_list finder = {0};
1382         char *uppertech = ast_strdupa(device_name);
1383         ast_tech_to_upper(uppertech);
1384         finder.device_name = uppertech;
1385
1386         return ao2_t_find(generic_monitors, &finder, OBJ_POINTER, "Finding generic monitor instance list");
1387 }
1388
1389 static void generic_monitor_instance_list_destructor(void *obj)
1390 {
1391         struct generic_monitor_instance_list *generic_list = obj;
1392         struct generic_monitor_instance *generic_instance;
1393
1394         generic_list->sub = stasis_unsubscribe(generic_list->sub);
1395         while ((generic_instance = AST_LIST_REMOVE_HEAD(&generic_list->list, next))) {
1396                 ast_free(generic_instance);
1397         }
1398         ast_free((char *)generic_list->device_name);
1399 }
1400
1401 static void generic_monitor_devstate_cb(void *userdata, struct stasis_subscription *sub, struct stasis_topic *topic, struct stasis_message *msg);
1402 static struct generic_monitor_instance_list *create_new_generic_list(struct ast_cc_monitor *monitor)
1403 {
1404         struct generic_monitor_instance_list *generic_list = ao2_t_alloc(sizeof(*generic_list),
1405                         generic_monitor_instance_list_destructor, "allocate generic monitor instance list");
1406         char * device_name;
1407         struct stasis_topic *device_specific_topic;
1408
1409         if (!generic_list) {
1410                 return NULL;
1411         }
1412
1413         if (!(device_name = ast_strdup(monitor->interface->device_name))) {
1414                 cc_unref(generic_list, "Failed to strdup the monitor's device name");
1415                 return NULL;
1416         }
1417         ast_tech_to_upper(device_name);
1418         generic_list->device_name = device_name;
1419
1420         device_specific_topic = ast_device_state_topic(device_name);
1421         if (!device_specific_topic) {
1422                 return NULL;
1423         }
1424
1425         if (!(generic_list->sub = stasis_subscribe(device_specific_topic, generic_monitor_devstate_cb, NULL))) {
1426                 cc_unref(generic_list, "Failed to subscribe to device state");
1427                 return NULL;
1428         }
1429         generic_list->current_state = ast_device_state(monitor->interface->device_name);
1430         ao2_t_link(generic_monitors, generic_list, "linking new generic monitor instance list");
1431         return generic_list;
1432 }
1433
1434 static int generic_monitor_devstate_tp_cb(void *data)
1435 {
1436         RAII_VAR(struct ast_device_state_message *, dev_state, data, ao2_cleanup);
1437         enum ast_device_state new_state = dev_state->state;
1438         enum ast_device_state previous_state;
1439         struct generic_monitor_instance_list *generic_list;
1440         struct generic_monitor_instance *generic_instance;
1441
1442         if (!(generic_list = find_generic_monitor_instance_list(dev_state->device))) {
1443                 /* The most likely cause for this is that we destroyed the monitor in the
1444                  * time between subscribing to its device state and the time this executes.
1445                  * Not really a big deal.
1446                  */
1447                 return 0;
1448         }
1449
1450         if (generic_list->current_state == new_state) {
1451                 /* The device state hasn't actually changed, so we don't really care */
1452                 cc_unref(generic_list, "Kill reference of generic list in devstate taskprocessor callback");
1453                 return 0;
1454         }
1455
1456         previous_state = generic_list->current_state;
1457         generic_list->current_state = new_state;
1458
1459         if (cc_generic_is_device_available(new_state) &&
1460                         (previous_state == AST_DEVICE_INUSE || previous_state == AST_DEVICE_UNAVAILABLE ||
1461                          previous_state == AST_DEVICE_BUSY)) {
1462                 AST_LIST_TRAVERSE(&generic_list->list, generic_instance, next) {
1463                         if (!generic_instance->is_suspended && generic_instance->monitoring) {
1464                                 generic_instance->monitoring = 0;
1465                                 generic_list->fit_for_recall = 1;
1466                                 ast_cc_monitor_callee_available(generic_instance->core_id, "Generic monitored party has become available");
1467                                 break;
1468                         }
1469                 }
1470         }
1471         cc_unref(generic_list, "Kill reference of generic list in devstate taskprocessor callback");
1472         return 0;
1473 }
1474
1475 static void generic_monitor_devstate_cb(void *userdata, struct stasis_subscription *sub, struct stasis_topic *topic, struct stasis_message *msg)
1476 {
1477         /* Wow, it's cool that we've picked up on a state change, but we really want
1478          * the actual work to be done in the core's taskprocessor execution thread
1479          * so that all monitor operations can be serialized. Locks?! We don't need
1480          * no steenkin' locks!
1481          */
1482         struct ast_device_state_message *dev_state;
1483         if (ast_device_state_message_type() != stasis_message_type(msg)) {
1484                 return;
1485         }
1486
1487         dev_state = stasis_message_data(msg);
1488         if (dev_state->eid) {
1489                 /* ignore non-aggregate states */
1490                 return;
1491         }
1492
1493         ao2_t_ref(dev_state, +1, "Bumping dev_state ref for cc_core_taskprocessor");
1494         if (ast_taskprocessor_push(cc_core_taskprocessor, generic_monitor_devstate_tp_cb, dev_state)) {
1495                 ao2_cleanup(dev_state);
1496                 return;
1497         }
1498 }
1499
1500 int ast_cc_available_timer_expire(const void *data)
1501 {
1502         struct ast_cc_monitor *monitor = (struct ast_cc_monitor *) data;
1503         int res;
1504         monitor->available_timer_id = -1;
1505         res = ast_cc_monitor_failed(monitor->core_id, monitor->interface->device_name, "Available timer expired for monitor");
1506         cc_unref(monitor, "Unref reference from scheduler\n");
1507         return res;
1508 }
1509
1510 static int cc_generic_monitor_request_cc(struct ast_cc_monitor *monitor, int *available_timer_id)
1511 {
1512         struct generic_monitor_instance_list *generic_list;
1513         struct generic_monitor_instance *generic_instance;
1514         struct generic_monitor_pvt *gen_mon_pvt;
1515         enum ast_cc_service_type service = monitor->service_offered;
1516         int when;
1517
1518         /* First things first. Native channel drivers will have their private data allocated
1519          * at the time that they tell the core that they can offer CC. Generic is quite a bit
1520          * different, and we wait until this point to allocate our private data.
1521          */
1522         if (!(gen_mon_pvt = ast_calloc(1, sizeof(*gen_mon_pvt)))) {
1523                 return -1;
1524         }
1525
1526         if (!(gen_mon_pvt->device_name = ast_strdup(monitor->interface->device_name))) {
1527                 ast_free(gen_mon_pvt);
1528                 return -1;
1529         }
1530
1531         gen_mon_pvt->core_id = monitor->core_id;
1532
1533         monitor->private_data = gen_mon_pvt;
1534
1535         if (!(generic_list = find_generic_monitor_instance_list(monitor->interface->device_name))) {
1536                 if (!(generic_list = create_new_generic_list(monitor))) {
1537                         return -1;
1538                 }
1539         }
1540
1541         if (!(generic_instance = ast_calloc(1, sizeof(*generic_instance)))) {
1542                 /* The generic monitor destructor will take care of the appropriate
1543                  * deallocations
1544                  */
1545                 cc_unref(generic_list, "Generic monitor instance failed to allocate");
1546                 return -1;
1547         }
1548         generic_instance->core_id = monitor->core_id;
1549         generic_instance->monitoring = 1;
1550         AST_LIST_INSERT_TAIL(&generic_list->list, generic_instance, next);
1551         when = service == AST_CC_CCBS ? ast_get_ccbs_available_timer(monitor->interface->config_params) :
1552                 ast_get_ccnr_available_timer(monitor->interface->config_params);
1553
1554         *available_timer_id = ast_sched_add(cc_sched_context, when * 1000,
1555                         ast_cc_available_timer_expire, cc_ref(monitor, "Give the scheduler a monitor reference"));
1556         if (*available_timer_id == -1) {
1557                 cc_unref(monitor, "Failed to schedule available timer. (monitor)");
1558                 cc_unref(generic_list, "Failed to schedule available timer. (generic_list)");
1559                 return -1;
1560         }
1561         /* If the new instance was created as CCNR, then that means this device is not currently
1562          * fit for recall even if it previously was.
1563          */
1564         if (service == AST_CC_CCNR || service == AST_CC_CCNL) {
1565                 generic_list->fit_for_recall = 0;
1566         }
1567         ast_cc_monitor_request_acked(monitor->core_id, "Generic monitor for %s subscribed to device state.",
1568                         monitor->interface->device_name);
1569         cc_unref(generic_list, "Finished with monitor instance reference in request cc callback");
1570         return 0;
1571 }
1572
1573 static int cc_generic_monitor_suspend(struct ast_cc_monitor *monitor)
1574 {
1575         struct generic_monitor_instance_list *generic_list;
1576         struct generic_monitor_instance *generic_instance;
1577         enum ast_device_state state = ast_device_state(monitor->interface->device_name);
1578
1579         if (!(generic_list = find_generic_monitor_instance_list(monitor->interface->device_name))) {
1580                 return -1;
1581         }
1582
1583         /* First we need to mark this particular monitor as being suspended. */
1584         AST_LIST_TRAVERSE(&generic_list->list, generic_instance, next) {
1585                 if (generic_instance->core_id == monitor->core_id) {
1586                         generic_instance->is_suspended = 1;
1587                         break;
1588                 }
1589         }
1590
1591         /* If the device being suspended is currently in use, then we don't need to
1592          * take any further actions
1593          */
1594         if (!cc_generic_is_device_available(state)) {
1595                 cc_unref(generic_list, "Device is in use. Nothing to do. Unref generic list.");
1596                 return 0;
1597         }
1598
1599         /* If the device is not in use, though, then it may be possible to report the
1600          * device's availability using a different monitor which is monitoring the
1601          * same device
1602          */
1603
1604         AST_LIST_TRAVERSE(&generic_list->list, generic_instance, next) {
1605                 if (!generic_instance->is_suspended) {
1606                         ast_cc_monitor_callee_available(generic_instance->core_id, "Generic monitored party has become available");
1607                         break;
1608                 }
1609         }
1610         cc_unref(generic_list, "Done with generic list in suspend callback");
1611         return 0;
1612 }
1613
1614 static int cc_generic_monitor_unsuspend(struct ast_cc_monitor *monitor)
1615 {
1616         struct generic_monitor_instance *generic_instance;
1617         struct generic_monitor_instance_list *generic_list = find_generic_monitor_instance_list(monitor->interface->device_name);
1618         enum ast_device_state state = ast_device_state(monitor->interface->device_name);
1619
1620         if (!generic_list) {
1621                 return -1;
1622         }
1623         /* If the device is currently available, we can immediately announce
1624          * its availability
1625          */
1626         if (cc_generic_is_device_available(state)) {
1627                 ast_cc_monitor_callee_available(monitor->core_id, "Generic monitored party has become available");
1628         }
1629
1630         /* In addition, we need to mark this generic_monitor_instance as not being suspended anymore */
1631         AST_LIST_TRAVERSE(&generic_list->list, generic_instance, next) {
1632                 if (generic_instance->core_id == monitor->core_id) {
1633                         generic_instance->is_suspended = 0;
1634                         generic_instance->monitoring = 1;
1635                         break;
1636                 }
1637         }
1638         cc_unref(generic_list, "Done with generic list in cc_generic_monitor_unsuspend");
1639         return 0;
1640 }
1641
1642 static int cc_generic_monitor_cancel_available_timer(struct ast_cc_monitor *monitor, int *sched_id)
1643 {
1644         ast_assert(sched_id != NULL);
1645
1646         if (*sched_id == -1) {
1647                 return 0;
1648         }
1649
1650         ast_log_dynamic_level(cc_logger_level, "Core %d: Canceling generic monitor available timer for monitor %s\n",
1651                         monitor->core_id, monitor->interface->device_name);
1652         if (!ast_sched_del(cc_sched_context, *sched_id)) {
1653                 cc_unref(monitor, "Remove scheduler's reference to the monitor");
1654         }
1655         *sched_id = -1;
1656         return 0;
1657 }
1658
1659 static void cc_generic_monitor_destructor(void *private_data)
1660 {
1661         struct generic_monitor_pvt *gen_mon_pvt = private_data;
1662         struct generic_monitor_instance_list *generic_list;
1663         struct generic_monitor_instance *generic_instance;
1664
1665         if (!private_data) {
1666                 /* If the private data is NULL, that means that the monitor hasn't even
1667                  * been created yet, but that the destructor was called. While this sort
1668                  * of behavior is useful for native monitors, with a generic one, there is
1669                  * nothing in particular to do.
1670                  */
1671                 return;
1672         }
1673
1674         ast_log_dynamic_level(cc_logger_level, "Core %d: Destroying generic monitor %s\n",
1675                         gen_mon_pvt->core_id, gen_mon_pvt->device_name);
1676
1677         if (!(generic_list = find_generic_monitor_instance_list(gen_mon_pvt->device_name))) {
1678                 /* If there's no generic list, that means that the monitor is being destroyed
1679                  * before we actually got to request CC. Not a biggie. Same in the situation
1680                  * below if the list traversal should complete without finding an entry.
1681                  */
1682                 ast_free((char *)gen_mon_pvt->device_name);
1683                 ast_free(gen_mon_pvt);
1684                 return;
1685         }
1686
1687         AST_LIST_TRAVERSE_SAFE_BEGIN(&generic_list->list, generic_instance, next) {
1688                 if (generic_instance->core_id == gen_mon_pvt->core_id) {
1689                         AST_LIST_REMOVE_CURRENT(next);
1690                         ast_free(generic_instance);
1691                         break;
1692                 }
1693         }
1694         AST_LIST_TRAVERSE_SAFE_END;
1695
1696         if (AST_LIST_EMPTY(&generic_list->list)) {
1697                 /* No more monitors with this device name exist. Time to unlink this
1698                  * list from the container
1699                  */
1700                 ao2_t_unlink(generic_monitors, generic_list, "Generic list is empty. Unlink it from the container");
1701         } else {
1702                 /* There are still instances for this particular device. The situation
1703                  * may be that we were attempting a CC recall and a failure occurred, perhaps
1704                  * on the agent side. If a failure happens here and the device being monitored
1705                  * is available, then we need to signal on the first unsuspended instance that
1706                  * the device is available for recall.
1707                  */
1708
1709                 /* First things first. We don't even want to consider this action if
1710                  * the device in question isn't available right now.
1711                  */
1712                 if (generic_list->fit_for_recall
1713                         && cc_generic_is_device_available(generic_list->current_state)) {
1714                         AST_LIST_TRAVERSE(&generic_list->list, generic_instance, next) {
1715                                 if (!generic_instance->is_suspended && generic_instance->monitoring) {
1716                                         ast_cc_monitor_callee_available(generic_instance->core_id, "Signaling generic monitor "
1717                                                         "availability due to other instance's failure.");
1718                                         break;
1719                                 }
1720                         }
1721                 }
1722         }
1723         cc_unref(generic_list, "Done with generic list in generic monitor destructor");
1724         ast_free((char *)gen_mon_pvt->device_name);
1725         ast_free(gen_mon_pvt);
1726 }
1727
1728 static void cc_interface_destroy(void *data)
1729 {
1730         struct ast_cc_interface *interface = data;
1731         ast_log_dynamic_level(cc_logger_level, "Destroying cc interface %s\n", interface->device_name);
1732         ast_cc_config_params_destroy(interface->config_params);
1733 }
1734
1735 /*!
1736  * \brief Data regarding an extension monitor's child's dialstrings
1737  *
1738  * \details
1739  * In developing CCSS, we had most aspects of its operation finished,
1740  * but there was one looming problem that we had failed to get right.
1741  * In our design document, we stated that when a CC recall occurs, all
1742  * endpoints that had been dialed originally would be called back.
1743  * Unfortunately, our implementation only allowed for devices which had
1744  * active monitors to inhabit the CC_INTERFACES channel variable, thus
1745  * making the automated recall only call monitored devices.
1746  *
1747  * Devices that were not CC-capable, or devices which failed CC at some
1748  * point during the process would not make it into the CC_INTERFACES
1749  * channel variable. This struct is meant as a remedy for the problem.
1750  */
1751 struct extension_child_dialstring {
1752         /*!
1753          * \brief the original dialstring used to call a particular device
1754          *
1755          * \details
1756          * When someone dials a particular endpoint, the dialstring used in
1757          * the dialplan is copied into this buffer. What's important here is
1758          * that this is the ORIGINAL dialstring, not the dialstring saved on
1759          * a device monitor. The dialstring on a device monitor is what should
1760          * be used when recalling that device. The two dialstrings may not be
1761          * the same.
1762          *
1763          * By keeping a copy of the original dialstring used, we can fall back
1764          * to using it if the device either does not ever offer CC or if the
1765          * device at some point fails for some reason, such as a timer expiration.
1766          */
1767         char original_dialstring[AST_CHANNEL_NAME];
1768         /*!
1769          * \brief The name of the device being dialed
1770          *
1771          * \details
1772          * This serves mainly as a key when searching for a particular dialstring.
1773          * For instance, let's say that we have called device SIP/400\@somepeer. This
1774          * device offers call completion, but then due to some unforeseen circumstance,
1775          * this device backs out and makes CC unavailable. When that happens, we need
1776          * to find the dialstring that corresponds to that device, and we use the
1777          * stored device name as a way to find it.
1778          *
1779          * \note There is one particular case where the device name stored here
1780          * will be empty. This is the case where we fail to request a channel, but we
1781          * still can make use of generic call completion. In such a case, since we never
1782          * were able to request the channel, we can't find what its device name is. In
1783          * this case, however, it is not important because the dialstring is guaranteed
1784          * to be the same both here and in the device monitor.
1785          */
1786         char device_name[AST_CHANNEL_NAME];
1787         /*!
1788          * \brief Is this structure valid for use in CC_INTERFACES?
1789          *
1790          * \details
1791          * When this structure is first created, all information stored here is planned
1792          * to be used, so we set the is_valid flag. However, if a device offers call
1793          * completion, it will potentially have its own dialstring to use for the recall,
1794          * so we find this structure and clear the is_valid flag. By clearing the is_valid
1795          * flag, we won't try to populate the CC_INTERFACES variable with the dialstring
1796          * stored in this struct. Now, if later, the device which had offered CC should fail,
1797          * perhaps due to a timer expiration, then we need to re-set the is_valid flag. This
1798          * way, we still will end up placing a call to the device again, and the dialstring
1799          * used will be the same as was originally used.
1800          */
1801         int is_valid;
1802         AST_LIST_ENTRY(extension_child_dialstring) next;
1803 };
1804
1805 /*!
1806  * \brief Private data for an extension monitor
1807  */
1808 struct extension_monitor_pvt {
1809         AST_LIST_HEAD_NOLOCK(, extension_child_dialstring) child_dialstrings;
1810 };
1811
1812 static void cc_extension_monitor_destructor(void *private_data)
1813 {
1814         struct extension_monitor_pvt *extension_pvt = private_data;
1815         struct extension_child_dialstring *child_dialstring;
1816
1817         /* This shouldn't be possible, but I'm paranoid */
1818         if (!extension_pvt) {
1819                 return;
1820         }
1821
1822         while ((child_dialstring = AST_LIST_REMOVE_HEAD(&extension_pvt->child_dialstrings, next))) {
1823                 ast_free(child_dialstring);
1824         }
1825         ast_free(extension_pvt);
1826 }
1827
1828 static void cc_monitor_destroy(void *data)
1829 {
1830         struct ast_cc_monitor *monitor = data;
1831         /* During the monitor creation process, it is possible for this
1832          * function to be called prior to when callbacks are assigned
1833          * to the monitor. Also, extension monitors do not have callbacks
1834          * assigned to them, so we wouldn't want to segfault when we try
1835          * to destroy one of them.
1836          */
1837         ast_log_dynamic_level(cc_logger_level, "Core %d: Calling destructor for monitor %s\n",
1838                         monitor->core_id, monitor->interface->device_name);
1839         if (monitor->interface->monitor_class == AST_CC_EXTENSION_MONITOR) {
1840                 cc_extension_monitor_destructor(monitor->private_data);
1841         }
1842         if (monitor->callbacks) {
1843                 monitor->callbacks->destructor(monitor->private_data);
1844         }
1845         cc_unref(monitor->interface, "Unreffing tree's reference to interface");
1846         ast_free(monitor->dialstring);
1847 }
1848
1849 static void cc_interface_tree_destroy(void *data)
1850 {
1851         struct cc_monitor_tree *cc_interface_tree = data;
1852         struct ast_cc_monitor *monitor;
1853         while ((monitor = AST_LIST_REMOVE_HEAD(cc_interface_tree, next))) {
1854                 if (monitor->callbacks) {
1855                         monitor->callbacks->cancel_available_timer(monitor, &monitor->available_timer_id);
1856                 }
1857                 cc_unref(monitor, "Destroying all monitors");
1858         }
1859         AST_LIST_HEAD_DESTROY(cc_interface_tree);
1860 }
1861
1862 /*!
1863  * This counter is used for assigning unique ids
1864  * to CC-enabled dialed interfaces.
1865  */
1866 static int dialed_cc_interface_counter;
1867
1868 /*!
1869  * \internal
1870  * \brief data stored in CC datastore
1871  *
1872  * The datastore creates a list of interfaces that were
1873  * dialed, including both extensions and devices. In addition
1874  * to the intrinsic data of the tree, some extra information
1875  * is needed for use by app_dial.
1876  */
1877 struct dialed_cc_interfaces {
1878         /*!
1879          * This value serves a dual-purpose. When dial starts, if the
1880          * dialed_cc_interfaces datastore currently exists on the calling
1881          * channel, then the dial_parent_id will serve as a means of
1882          * letting the new extension cc_monitor we create know
1883          * who his parent is. This value will be the extension
1884          * cc_monitor that dialed the local channel that resulted
1885          * in the new Dial app being called.
1886          *
1887          * In addition, once an extension cc_monitor is created,
1888          * the dial_parent_id will be changed to the id of that newly
1889          * created interface. This way, device interfaces created from
1890          * receiving AST_CONTROL_CC frames can use this field to determine
1891          * who their parent extension interface should be.
1892          */
1893         unsigned int dial_parent_id;
1894         /*!
1895          * Identifier for the potential CC request that may be made
1896          * based on this call. Even though an instance of the core may
1897          * not be made (since the caller may not request CC), we allocate
1898          * a new core_id at the beginning of the call so that recipient
1899          * channel drivers can have the information handy just in case
1900          * the caller does end up requesting CC.
1901          */
1902         int core_id;
1903         /*!
1904          * When a new Dial application is started, and the datastore
1905          * already exists on the channel, we can determine if we
1906          * should be adding any new interface information to tree.
1907          */
1908         char ignore;
1909         /*!
1910          * When it comes time to offer CC to the caller, we only want to offer
1911          * it to the original incoming channel. For nested Dials and outbound
1912          * channels, it is incorrect to attempt such a thing. This flag indicates
1913          * if the channel to which this datastore is attached may be legally
1914          * offered CC when the call is finished.
1915          */
1916         char is_original_caller;
1917         /*!
1918          * Reference-counted "tree" of interfaces.
1919          */
1920         struct cc_monitor_tree *interface_tree;
1921 };
1922
1923 /*!
1924  * \internal
1925  * \brief Destructor function for cc_interfaces datastore
1926  *
1927  * This function will free the actual datastore and drop
1928  * the refcount for the monitor tree by one. In cases
1929  * where CC can actually be used, this unref will not
1930  * result in the destruction of the monitor tree, because
1931  * the CC core will still have a reference.
1932  *
1933  * \param data The dialed_cc_interfaces struct to destroy
1934  */
1935 static void dialed_cc_interfaces_destroy(void *data)
1936 {
1937         struct dialed_cc_interfaces *cc_interfaces = data;
1938         cc_unref(cc_interfaces->interface_tree, "Unref dial's ref to monitor tree");
1939         ast_free(cc_interfaces);
1940 }
1941
1942 /*!
1943  * \internal
1944  * \brief Duplicate callback for cc_interfaces datastore
1945  *
1946  * Integers are copied by value, but the monitor tree
1947  * is done via a shallow copy and a bump of the refcount.
1948  * This way, sub-Dials will be appending interfaces onto
1949  * the same list as this call to Dial.
1950  *
1951  * \param data The old dialed_cc_interfaces we want to copy
1952  * \retval NULL Could not allocate memory for new dialed_cc_interfaces
1953  * \retval non-NULL The new copy of the dialed_cc_interfaces
1954  */
1955 static void *dialed_cc_interfaces_duplicate(void *data)
1956 {
1957         struct dialed_cc_interfaces *old_cc_interfaces = data;
1958         struct dialed_cc_interfaces *new_cc_interfaces = ast_calloc(1, sizeof(*new_cc_interfaces));
1959         if (!new_cc_interfaces) {
1960                 return NULL;
1961         }
1962         new_cc_interfaces->ignore = old_cc_interfaces->ignore;
1963         new_cc_interfaces->dial_parent_id = old_cc_interfaces->dial_parent_id;
1964         new_cc_interfaces->is_original_caller = 0;
1965         cc_ref(old_cc_interfaces->interface_tree, "New ref due to duplication of monitor tree");
1966         new_cc_interfaces->core_id = old_cc_interfaces->core_id;
1967         new_cc_interfaces->interface_tree = old_cc_interfaces->interface_tree;
1968         return new_cc_interfaces;
1969 }
1970
1971 /*!
1972  * \internal
1973  * \brief information regarding the dialed_cc_interfaces datastore
1974  *
1975  * The dialed_cc_interfaces datastore is responsible for keeping track
1976  * of what CC-enabled interfaces have been dialed by the caller. For
1977  * more information regarding the actual structure of the tree, see
1978  * the documentation provided in include/asterisk/ccss.h
1979  */
1980 static const struct ast_datastore_info dialed_cc_interfaces_info = {
1981         .type = "Dial CC Interfaces",
1982         .duplicate = dialed_cc_interfaces_duplicate,
1983         .destroy = dialed_cc_interfaces_destroy,
1984 };
1985
1986 static struct extension_monitor_pvt *extension_monitor_pvt_init(void)
1987 {
1988         struct extension_monitor_pvt *ext_pvt = ast_calloc(1, sizeof(*ext_pvt));
1989         if (!ext_pvt) {
1990                 return NULL;
1991         }
1992         AST_LIST_HEAD_INIT_NOLOCK(&ext_pvt->child_dialstrings);
1993         return ext_pvt;
1994 }
1995
1996 void ast_cc_extension_monitor_add_dialstring(struct ast_channel *incoming, const char * const dialstring, const char * const device_name)
1997 {
1998         struct ast_datastore *cc_datastore;
1999         struct dialed_cc_interfaces *cc_interfaces;
2000         struct ast_cc_monitor *monitor;
2001         struct extension_monitor_pvt *extension_pvt;
2002         struct extension_child_dialstring *child_dialstring;
2003         struct cc_monitor_tree *interface_tree;
2004         int id;
2005
2006         ast_channel_lock(incoming);
2007         if (!(cc_datastore = ast_channel_datastore_find(incoming, &dialed_cc_interfaces_info, NULL))) {
2008                 ast_channel_unlock(incoming);
2009                 return;
2010         }
2011
2012         cc_interfaces = cc_datastore->data;
2013         interface_tree = cc_interfaces->interface_tree;
2014         id = cc_interfaces->dial_parent_id;
2015         ast_channel_unlock(incoming);
2016
2017         AST_LIST_LOCK(interface_tree);
2018         AST_LIST_TRAVERSE(interface_tree, monitor, next) {
2019                 if (monitor->id == id) {
2020                         break;
2021                 }
2022         }
2023
2024         if (!monitor) {
2025                 AST_LIST_UNLOCK(interface_tree);
2026                 return;
2027         }
2028
2029         extension_pvt = monitor->private_data;
2030         if (!(child_dialstring = ast_calloc(1, sizeof(*child_dialstring)))) {
2031                 AST_LIST_UNLOCK(interface_tree);
2032                 return;
2033         }
2034         ast_copy_string(child_dialstring->original_dialstring, dialstring, sizeof(child_dialstring->original_dialstring));
2035         ast_copy_string(child_dialstring->device_name, device_name, sizeof(child_dialstring->device_name));
2036         child_dialstring->is_valid = 1;
2037         AST_LIST_INSERT_TAIL(&extension_pvt->child_dialstrings, child_dialstring, next);
2038         AST_LIST_UNLOCK(interface_tree);
2039 }
2040
2041 static void cc_extension_monitor_change_is_valid(struct cc_core_instance *core_instance, unsigned int parent_id, const char * const device_name, int is_valid)
2042 {
2043         struct ast_cc_monitor *monitor_iter;
2044         struct extension_monitor_pvt *extension_pvt;
2045         struct extension_child_dialstring *child_dialstring;
2046
2047         AST_LIST_TRAVERSE(core_instance->monitors, monitor_iter, next) {
2048                 if (monitor_iter->id == parent_id) {
2049                         break;
2050                 }
2051         }
2052
2053         if (!monitor_iter) {
2054                 return;
2055         }
2056         extension_pvt = monitor_iter->private_data;
2057
2058         AST_LIST_TRAVERSE(&extension_pvt->child_dialstrings, child_dialstring, next) {
2059                 if (!strcmp(child_dialstring->device_name, device_name)) {
2060                         child_dialstring->is_valid = is_valid;
2061                         break;
2062                 }
2063         }
2064 }
2065
2066 /*!
2067  * \internal
2068  * \brief Allocate and initialize an "extension" interface for CC purposes
2069  *
2070  * When app_dial starts, this function is called in order to set up the
2071  * information about the extension in which this Dial is occurring. Any
2072  * devices dialed will have this particular cc_monitor as a parent.
2073  *
2074  * \param exten Extension from which Dial is occurring
2075  * \param context Context to which exten belongs
2076  * \param parent_id What should we set the parent_id of this interface to?
2077  * \retval NULL Memory allocation failure
2078  * \retval non-NULL The newly-created cc_monitor for the extension
2079  */
2080 static struct ast_cc_monitor *cc_extension_monitor_init(const char * const exten, const char * const context, const unsigned int parent_id)
2081 {
2082         struct ast_str *str = ast_str_alloca(2 * AST_MAX_EXTENSION);
2083         struct ast_cc_interface *cc_interface;
2084         struct ast_cc_monitor *monitor;
2085
2086         ast_str_set(&str, 0, "%s@%s", exten, context);
2087
2088         if (!(cc_interface = ao2_t_alloc(sizeof(*cc_interface) + ast_str_strlen(str), cc_interface_destroy,
2089                                         "Allocating new ast_cc_interface"))) {
2090                 return NULL;
2091         }
2092
2093         if (!(monitor = ao2_t_alloc(sizeof(*monitor), cc_monitor_destroy, "Allocating new ast_cc_monitor"))) {
2094                 cc_unref(cc_interface, "failed to allocate the monitor, so unref the interface");
2095                 return NULL;
2096         }
2097
2098         if (!(monitor->private_data = extension_monitor_pvt_init())) {
2099                 cc_unref(monitor, "Failed to initialize extension monitor private data. uref monitor");
2100                 cc_unref(cc_interface, "Failed to initialize extension monitor private data. unref cc_interface");
2101         }
2102
2103         monitor->id = ast_atomic_fetchadd_int(&dialed_cc_interface_counter, +1);
2104         monitor->parent_id = parent_id;
2105         cc_interface->monitor_type = "extension";
2106         cc_interface->monitor_class = AST_CC_EXTENSION_MONITOR;
2107         strcpy(cc_interface->device_name, ast_str_buffer(str));
2108         monitor->interface = cc_interface;
2109         ast_log_dynamic_level(cc_logger_level, "Created an extension cc interface for '%s' with id %d and parent %d\n", cc_interface->device_name, monitor->id, monitor->parent_id);
2110         return monitor;
2111 }
2112
2113 /*!
2114  * \internal
2115  * \brief allocate dialed_cc_interfaces datastore and initialize fields
2116  *
2117  * This function is called when Situation 1 occurs in ast_cc_call_init.
2118  * See that function for more information on what Situation 1 is.
2119  *
2120  * In this particular case, we have to do a lot of memory allocation in order
2121  * to create the datastore, the data for the datastore, the tree of interfaces
2122  * that we'll be adding to, and the initial extension interface for this Dial
2123  * attempt.
2124  *
2125  * \param chan The channel onto which the datastore should be added.
2126  * \retval -1 An error occurred
2127  * \retval 0 Success
2128  */
2129 static int cc_interfaces_datastore_init(struct ast_channel *chan) {
2130         struct dialed_cc_interfaces *interfaces;
2131         struct ast_cc_monitor *monitor;
2132         struct ast_datastore *dial_cc_datastore;
2133
2134         /*XXX This may be a bit controversial. In an attempt to not allocate
2135          * extra resources, I make sure that a future request will be within
2136          * limits. The problem here is that it is reasonable to think that
2137          * even if we're not within the limits at this point, we may be by
2138          * the time the requestor will have made his request. This may be
2139          * deleted at some point.
2140          */
2141         if (!ast_cc_request_is_within_limits()) {
2142                 return 0;
2143         }
2144
2145         if (!(interfaces = ast_calloc(1, sizeof(*interfaces)))) {
2146                 return -1;
2147         }
2148
2149         if (!(monitor = cc_extension_monitor_init(S_OR(ast_channel_macroexten(chan), ast_channel_exten(chan)), S_OR(ast_channel_macrocontext(chan), ast_channel_context(chan)), 0))) {
2150                 ast_free(interfaces);
2151                 return -1;
2152         }
2153
2154         if (!(dial_cc_datastore = ast_datastore_alloc(&dialed_cc_interfaces_info, NULL))) {
2155                 cc_unref(monitor, "Could not allocate the dialed interfaces datastore. Unreffing monitor");
2156                 ast_free(interfaces);
2157                 return -1;
2158         }
2159
2160         if (!(interfaces->interface_tree = ao2_t_alloc(sizeof(*interfaces->interface_tree), cc_interface_tree_destroy,
2161                                         "Allocate monitor tree"))) {
2162                 ast_datastore_free(dial_cc_datastore);
2163                 cc_unref(monitor, "Could not allocate monitor tree on dialed interfaces datastore. Unreffing monitor");
2164                 ast_free(interfaces);
2165                 return -1;
2166         }
2167
2168         /* Finally, all that allocation is done... */
2169         AST_LIST_HEAD_INIT(interfaces->interface_tree);
2170         AST_LIST_INSERT_TAIL(interfaces->interface_tree, monitor, next);
2171         cc_ref(monitor, "List's reference to extension monitor");
2172         dial_cc_datastore->data = interfaces;
2173         dial_cc_datastore->inheritance = DATASTORE_INHERIT_FOREVER;
2174         interfaces->dial_parent_id = monitor->id;
2175         interfaces->core_id = monitor->core_id = ast_atomic_fetchadd_int(&core_id_counter, +1);
2176         interfaces->is_original_caller = 1;
2177         ast_channel_lock(chan);
2178         ast_channel_datastore_add(chan, dial_cc_datastore);
2179         ast_channel_unlock(chan);
2180         cc_unref(monitor, "Unreffing allocation's reference");
2181         return 0;
2182 }
2183
2184 /*!
2185  * \internal
2186  * \brief  Call a monitor's destructor before the monitor has been allocated
2187  * \since 1.8
2188  *
2189  * \param monitor_type The type of monitor callbacks to use when calling the destructor
2190  * \param private_data Data allocated by a channel driver that must be freed
2191  *
2192  * \details
2193  * I'll admit, this is a bit evil.
2194  *
2195  * When a channel driver determines that it can offer a call completion service to
2196  * a caller, it is very likely that the channel driver will need to allocate some
2197  * data so that when the time comes to request CC, the channel driver will have the
2198  * necessary data at hand.
2199  *
2200  * The problem is that there are many places where failures may occur before the monitor
2201  * has been properly allocated and had its callbacks assigned to it. If one of these
2202  * failures should occur, then we still need to let the channel driver know that it
2203  * must destroy the data that it allocated.
2204  *
2205  * \return Nothing
2206  */
2207 static void call_destructor_with_no_monitor(const char * const monitor_type, void *private_data)
2208 {
2209         const struct ast_cc_monitor_callbacks *monitor_callbacks = find_monitor_callbacks(monitor_type);
2210
2211         if (!monitor_callbacks) {
2212                 return;
2213         }
2214
2215         monitor_callbacks->destructor(private_data);
2216 }
2217
2218 /*!
2219  * \internal
2220  * \brief Allocate and intitialize a device cc_monitor
2221  *
2222  * For all intents and purposes, this is the same as
2223  * cc_extension_monitor_init, except that there is only
2224  * a single parameter used for naming the interface.
2225  *
2226  * This function is called when handling AST_CONTROL_CC frames.
2227  * The device has reported that CC is possible, so we add it
2228  * to the interface_tree.
2229  *
2230  * Note that it is not necessarily erroneous to add the same
2231  * device to the tree twice. If the same device is called by
2232  * two different extension during the same call, then
2233  * that is a legitimate situation. Of course, I'm pretty sure
2234  * the dialed_interfaces global datastore will not allow that
2235  * to happen anyway.
2236  *
2237  * \param device_name The name of the device being added to the tree
2238  * \param dialstring The dialstring used to dial the device being added
2239  * \param parent_id The parent of this new tree node.
2240  * \retval NULL Memory allocation failure
2241  * \retval non-NULL The new ast_cc_interface created.
2242  */
2243 static struct ast_cc_monitor *cc_device_monitor_init(const char * const device_name, const char * const dialstring, const struct cc_control_payload *cc_data, int core_id)
2244 {
2245         struct ast_cc_interface *cc_interface;
2246         struct ast_cc_monitor *monitor;
2247         size_t device_name_len = strlen(device_name);
2248         int parent_id = cc_data->parent_interface_id;
2249
2250         if (!(cc_interface = ao2_t_alloc(sizeof(*cc_interface) + device_name_len, cc_interface_destroy,
2251                                         "Allocating new ast_cc_interface"))) {
2252                 return NULL;
2253         }
2254
2255         if (!(cc_interface->config_params = ast_cc_config_params_init())) {
2256                 cc_unref(cc_interface, "Failed to allocate config params, unref interface");
2257                 return NULL;
2258         }
2259
2260         if (!(monitor = ao2_t_alloc(sizeof(*monitor), cc_monitor_destroy, "Allocating new ast_cc_monitor"))) {
2261                 cc_unref(cc_interface, "Failed to allocate monitor, unref interface");
2262                 return NULL;
2263         }
2264
2265         if (!(monitor->dialstring = ast_strdup(dialstring))) {
2266                 cc_unref(monitor, "Failed to copy dialable name. Unref monitor");
2267                 cc_unref(cc_interface, "Failed to copy dialable name");
2268                 return NULL;
2269         }
2270
2271         if (!(monitor->callbacks = find_monitor_callbacks(cc_data->monitor_type))) {
2272                 cc_unref(monitor, "Failed to find monitor callbacks. Unref monitor");
2273                 cc_unref(cc_interface, "Failed to find monitor callbacks");
2274                 return NULL;
2275         }
2276
2277         strcpy(cc_interface->device_name, device_name);
2278         monitor->id = ast_atomic_fetchadd_int(&dialed_cc_interface_counter, +1);
2279         monitor->parent_id = parent_id;
2280         monitor->core_id = core_id;
2281         monitor->service_offered = cc_data->service;
2282         monitor->private_data = cc_data->private_data;
2283         cc_interface->monitor_type = cc_data->monitor_type;
2284         cc_interface->monitor_class = AST_CC_DEVICE_MONITOR;
2285         monitor->interface = cc_interface;
2286         monitor->available_timer_id = -1;
2287         ast_cc_copy_config_params(cc_interface->config_params, &cc_data->config_params);
2288         ast_log_dynamic_level(cc_logger_level, "Core %d: Created a device cc interface for '%s' with id %d and parent %d\n",
2289                         monitor->core_id, cc_interface->device_name, monitor->id, monitor->parent_id);
2290         return monitor;
2291 }
2292
2293 /*!
2294  * \details
2295  * Unless we are ignoring CC for some reason, we will always
2296  * call this function when we read an AST_CONTROL_CC frame
2297  * from an outbound channel.
2298  *
2299  * This function will call cc_device_monitor_init to
2300  * create the new cc_monitor for the device from which
2301  * we read the frame. In addition, the new device will be added
2302  * to the monitor tree on the dialed_cc_interfaces datastore
2303  * on the inbound channel.
2304  *
2305  * If this is the first AST_CONTROL_CC frame that we have handled
2306  * for this call, then we will also initialize the CC core for
2307  * this call.
2308  */
2309 void ast_handle_cc_control_frame(struct ast_channel *inbound, struct ast_channel *outbound, void *frame_data)
2310 {
2311         char *device_name;
2312         char *dialstring;
2313         struct ast_cc_monitor *monitor;
2314         struct ast_datastore *cc_datastore;
2315         struct dialed_cc_interfaces *cc_interfaces;
2316         struct cc_control_payload *cc_data = frame_data;
2317         struct cc_core_instance *core_instance;
2318
2319         device_name = cc_data->device_name;
2320         dialstring = cc_data->dialstring;
2321
2322         ast_channel_lock(inbound);
2323         if (!(cc_datastore = ast_channel_datastore_find(inbound, &dialed_cc_interfaces_info, NULL))) {
2324                 ast_log(LOG_WARNING, "Unable to retrieve CC datastore while processing CC frame from '%s'. CC services will be unavailable.\n", device_name);
2325                 ast_channel_unlock(inbound);
2326                 call_destructor_with_no_monitor(cc_data->monitor_type, cc_data->private_data);
2327                 return;
2328         }
2329
2330         cc_interfaces = cc_datastore->data;
2331
2332         if (cc_interfaces->ignore) {
2333                 ast_channel_unlock(inbound);
2334                 call_destructor_with_no_monitor(cc_data->monitor_type, cc_data->private_data);
2335                 return;
2336         }
2337
2338         if (!cc_interfaces->is_original_caller) {
2339                 /* If the is_original_caller is not set on the *inbound* channel, then
2340                  * it must be a local channel. As such, we do not want to create a core instance
2341                  * or an agent for the local channel. Instead, we want to pass this along to the
2342                  * other side of the local channel so that the original caller can benefit.
2343                  */
2344                 ast_channel_unlock(inbound);
2345                 ast_indicate_data(inbound, AST_CONTROL_CC, cc_data, sizeof(*cc_data));
2346                 return;
2347         }
2348
2349         core_instance = find_cc_core_instance(cc_interfaces->core_id);
2350         if (!core_instance) {
2351                 core_instance = cc_core_init_instance(inbound, cc_interfaces->interface_tree,
2352                         cc_interfaces->core_id, cc_data);
2353                 if (!core_instance) {
2354                         cc_interfaces->ignore = 1;
2355                         ast_channel_unlock(inbound);
2356                         call_destructor_with_no_monitor(cc_data->monitor_type, cc_data->private_data);
2357                         return;
2358                 }
2359         }
2360
2361         ast_channel_unlock(inbound);
2362
2363         /* Yeah this kind of sucks, but luckily most people
2364          * aren't dialing thousands of interfaces on every call
2365          *
2366          * This traversal helps us to not create duplicate monitors in
2367          * case a device queues multiple CC control frames.
2368          */
2369         AST_LIST_LOCK(cc_interfaces->interface_tree);
2370         AST_LIST_TRAVERSE(cc_interfaces->interface_tree, monitor, next) {
2371                 if (!strcmp(monitor->interface->device_name, device_name)) {
2372                         ast_log_dynamic_level(cc_logger_level, "Core %d: Device %s sent us multiple CC control frames. Ignoring those beyond the first.\n",
2373                                         core_instance->core_id, device_name);
2374                         AST_LIST_UNLOCK(cc_interfaces->interface_tree);
2375                         cc_unref(core_instance, "Returning early from ast_handle_cc_control_frame. Unref core_instance");
2376                         call_destructor_with_no_monitor(cc_data->monitor_type, cc_data->private_data);
2377                         return;
2378                 }
2379         }
2380         AST_LIST_UNLOCK(cc_interfaces->interface_tree);
2381
2382         if (!(monitor = cc_device_monitor_init(device_name, dialstring, cc_data, core_instance->core_id))) {
2383                 ast_log(LOG_WARNING, "Unable to create CC device interface for '%s'. CC services will be unavailable on this interface.\n", device_name);
2384                 cc_unref(core_instance, "Returning early from ast_handle_cc_control_frame. Unref core_instance");
2385                 call_destructor_with_no_monitor(cc_data->monitor_type, cc_data->private_data);
2386                 return;
2387         }
2388
2389         AST_LIST_LOCK(cc_interfaces->interface_tree);
2390         cc_ref(monitor, "monitor tree's reference to the monitor");
2391         AST_LIST_INSERT_TAIL(cc_interfaces->interface_tree, monitor, next);
2392         AST_LIST_UNLOCK(cc_interfaces->interface_tree);
2393
2394         cc_extension_monitor_change_is_valid(core_instance, monitor->parent_id, monitor->interface->device_name, 0);
2395
2396         cc_publish_available(cc_interfaces->core_id, device_name, cc_service_to_string(cc_data->service));
2397
2398         cc_unref(core_instance, "Done with core_instance after handling CC control frame");
2399         cc_unref(monitor, "Unref reference from allocating monitor");
2400 }
2401
2402 int ast_cc_call_init(struct ast_channel *chan, int *ignore_cc)
2403 {
2404         /* There are three situations to deal with here:
2405          *
2406          * 1. The channel does not have a dialed_cc_interfaces datastore on
2407          * it. This means that this is the first time that Dial has
2408          * been called. We need to create/initialize the datastore.
2409          *
2410          * 2. The channel does have a cc_interface datastore on it and
2411          * the "ignore" indicator is 0. This means that a Local channel
2412          * was called by a "parent" dial. We can check the datastore's
2413          * parent field to see who the root of this particular dial tree
2414          * is.
2415          *
2416          * 3. The channel does have a cc_interface datastore on it and
2417          * the "ignore" indicator is 1. This means that a second Dial call
2418          * is being made from an extension. In this case, we do not
2419          * want to make any additions/modifications to the datastore. We
2420          * will instead set a flag to indicate that CCSS is completely
2421          * disabled for this Dial attempt.
2422          */
2423
2424         struct ast_datastore *cc_interfaces_datastore;
2425         struct dialed_cc_interfaces *interfaces;
2426         struct ast_cc_monitor *monitor;
2427         struct ast_cc_config_params *cc_params;
2428
2429         ast_channel_lock(chan);
2430
2431         cc_params = ast_channel_get_cc_config_params(chan);
2432         if (!cc_params) {
2433                 ast_channel_unlock(chan);
2434                 return -1;
2435         }
2436         if (ast_get_cc_agent_policy(cc_params) == AST_CC_AGENT_NEVER) {
2437                 /* We can't offer CC to this caller anyway, so don't bother with CC on this call
2438                  */
2439                 *ignore_cc = 1;
2440                 ast_channel_unlock(chan);
2441                 ast_log_dynamic_level(cc_logger_level, "Agent policy for %s is 'never'. CC not possible\n", ast_channel_name(chan));
2442                 return 0;
2443         }
2444
2445         if (!(cc_interfaces_datastore = ast_channel_datastore_find(chan, &dialed_cc_interfaces_info, NULL))) {
2446                 /* Situation 1 has occurred */
2447                 ast_channel_unlock(chan);
2448                 return cc_interfaces_datastore_init(chan);
2449         }
2450         interfaces = cc_interfaces_datastore->data;
2451         ast_channel_unlock(chan);
2452
2453         if (interfaces->ignore) {
2454                 /* Situation 3 has occurred */
2455                 *ignore_cc = 1;
2456                 ast_log_dynamic_level(cc_logger_level, "Datastore is present with ignore flag set. Ignoring CC offers on this call\n");
2457                 return 0;
2458         }
2459
2460         /* Situation 2 has occurred */
2461         if (!(monitor = cc_extension_monitor_init(S_OR(ast_channel_macroexten(chan), ast_channel_exten(chan)),
2462                         S_OR(ast_channel_macrocontext(chan), ast_channel_context(chan)), interfaces->dial_parent_id))) {
2463                 return -1;
2464         }
2465         monitor->core_id = interfaces->core_id;
2466         AST_LIST_LOCK(interfaces->interface_tree);
2467         cc_ref(monitor, "monitor tree's reference to the monitor");
2468         AST_LIST_INSERT_TAIL(interfaces->interface_tree, monitor, next);
2469         AST_LIST_UNLOCK(interfaces->interface_tree);
2470         interfaces->dial_parent_id = monitor->id;
2471         cc_unref(monitor, "Unref monitor's allocation reference");
2472         return 0;
2473 }
2474
2475 int ast_cc_request_is_within_limits(void)
2476 {
2477         return cc_request_count < global_cc_max_requests;
2478 }
2479
2480 int ast_cc_get_current_core_id(struct ast_channel *chan)
2481 {
2482         struct ast_datastore *datastore;
2483         struct dialed_cc_interfaces *cc_interfaces;
2484         int core_id_return;
2485
2486         ast_channel_lock(chan);
2487         if (!(datastore = ast_channel_datastore_find(chan, &dialed_cc_interfaces_info, NULL))) {
2488                 ast_channel_unlock(chan);
2489                 return -1;
2490         }
2491
2492         cc_interfaces = datastore->data;
2493         core_id_return = cc_interfaces->ignore ? -1 : cc_interfaces->core_id;
2494         ast_channel_unlock(chan);
2495         return core_id_return;
2496
2497 }
2498
2499 static long count_agents(const char * const caller, const int core_id_exception)
2500 {
2501         struct count_agents_cb_data data = {.core_id_exception = core_id_exception,};
2502
2503         ao2_t_callback_data(cc_core_instances, OBJ_NODATA, count_agents_cb, (char *)caller, &data, "Counting agents");
2504         ast_log_dynamic_level(cc_logger_level, "Counted %d agents\n", data.count);
2505         return data.count;
2506 }
2507
2508 static void kill_duplicate_offers(char *caller)
2509 {
2510         unsigned long match_flags = MATCH_NO_REQUEST;
2511         struct ao2_iterator *dups_iter;
2512
2513         /*
2514          * Must remove the ref that was in cc_core_instances outside of
2515          * the container lock to prevent deadlock.
2516          */
2517         dups_iter = ao2_t_callback_data(cc_core_instances, OBJ_MULTIPLE | OBJ_UNLINK,
2518                 match_agent, caller, &match_flags, "Killing duplicate offers");
2519         if (dups_iter) {
2520                 /* Now actually unref any duplicate offers by simply destroying the iterator. */
2521                 ao2_iterator_destroy(dups_iter);
2522         }
2523 }
2524
2525 static void check_callback_sanity(const struct ast_cc_agent_callbacks *callbacks)
2526 {
2527         ast_assert(callbacks->init != NULL);
2528         ast_assert(callbacks->start_offer_timer != NULL);
2529         ast_assert(callbacks->stop_offer_timer != NULL);
2530         ast_assert(callbacks->respond != NULL);
2531         ast_assert(callbacks->status_request != NULL);
2532         ast_assert(callbacks->start_monitoring != NULL);
2533         ast_assert(callbacks->callee_available != NULL);
2534         ast_assert(callbacks->destructor != NULL);
2535 }
2536
2537 static void agent_destroy(void *data)
2538 {
2539         struct ast_cc_agent *agent = data;
2540
2541         if (agent->callbacks) {
2542                 agent->callbacks->destructor(agent);
2543         }
2544         ast_cc_config_params_destroy(agent->cc_params);
2545 }
2546
2547 static struct ast_cc_agent *cc_agent_init(struct ast_channel *caller_chan,
2548                 const char * const caller_name, const int core_id,
2549                 struct cc_monitor_tree *interface_tree)
2550 {
2551         struct ast_cc_agent *agent;
2552         struct ast_cc_config_params *cc_params;
2553
2554         if (!(agent = ao2_t_alloc(sizeof(*agent) + strlen(caller_name), agent_destroy,
2555                                         "Allocating new ast_cc_agent"))) {
2556                 return NULL;
2557         }
2558
2559         agent->core_id = core_id;
2560         strcpy(agent->device_name, caller_name);
2561
2562         cc_params = ast_channel_get_cc_config_params(caller_chan);
2563         if (!cc_params) {
2564                 cc_unref(agent, "Could not get channel config params.");
2565                 return NULL;
2566         }
2567         if (!(agent->cc_params = ast_cc_config_params_init())) {
2568                 cc_unref(agent, "Could not init agent config params.");
2569                 return NULL;
2570         }
2571         ast_cc_copy_config_params(agent->cc_params, cc_params);
2572
2573         if (!(agent->callbacks = find_agent_callbacks(caller_chan))) {
2574                 cc_unref(agent, "Could not find agent callbacks.");
2575                 return NULL;
2576         }
2577         check_callback_sanity(agent->callbacks);
2578
2579         if (agent->callbacks->init(agent, caller_chan)) {
2580                 cc_unref(agent, "Agent init callback failed.");
2581                 return NULL;
2582         }
2583         ast_log_dynamic_level(cc_logger_level, "Core %d: Created an agent for caller %s\n",
2584                         agent->core_id, agent->device_name);
2585         return agent;
2586 }
2587
2588 /* Generic agent callbacks */
2589 static int cc_generic_agent_init(struct ast_cc_agent *agent, struct ast_channel *chan);
2590 static int cc_generic_agent_start_offer_timer(struct ast_cc_agent *agent);
2591 static int cc_generic_agent_stop_offer_timer(struct ast_cc_agent *agent);
2592 static void cc_generic_agent_respond(struct ast_cc_agent *agent, enum ast_cc_agent_response_reason reason);
2593 static int cc_generic_agent_status_request(struct ast_cc_agent *agent);
2594 static int cc_generic_agent_stop_ringing(struct ast_cc_agent *agent);
2595 static int cc_generic_agent_start_monitoring(struct ast_cc_agent *agent);
2596 static int cc_generic_agent_recall(struct ast_cc_agent *agent);
2597 static void cc_generic_agent_destructor(struct ast_cc_agent *agent);
2598
2599 static struct ast_cc_agent_callbacks generic_agent_callbacks = {
2600         .type = "generic",
2601         .init = cc_generic_agent_init,
2602         .start_offer_timer = cc_generic_agent_start_offer_timer,
2603         .stop_offer_timer = cc_generic_agent_stop_offer_timer,
2604         .respond = cc_generic_agent_respond,
2605         .status_request = cc_generic_agent_status_request,
2606         .stop_ringing = cc_generic_agent_stop_ringing,
2607         .start_monitoring = cc_generic_agent_start_monitoring,
2608         .callee_available = cc_generic_agent_recall,
2609         .destructor = cc_generic_agent_destructor,
2610 };
2611
2612 struct cc_generic_agent_pvt {
2613         /*!
2614          * Subscription to device state
2615          *
2616          * Used in the CC_CALLER_BUSY state. The
2617          * generic agent will subscribe to the
2618          * device state of the caller in order to
2619          * determine when we may move on
2620          */
2621         struct stasis_subscription *sub;
2622         /*!
2623          * Scheduler id of offer timer.
2624          */
2625         int offer_timer_id;
2626         /*!
2627          * Caller ID number
2628          *
2629          * When we re-call the caller, we need
2630          * to provide this information to
2631          * ast_request_and_dial so that the
2632          * information will be present in the
2633          * call to the callee
2634          */
2635         char cid_num[AST_CHANNEL_NAME];
2636         /*!
2637          * Caller ID name
2638          *
2639          * See the description of cid_num.
2640          * The same applies here, except this
2641          * is the caller's name.
2642          */
2643         char cid_name[AST_CHANNEL_NAME];
2644         /*!
2645          * Extension dialed
2646          *
2647          * The original extension dialed. This is used
2648          * so that when performing a recall, we can
2649          * call the proper extension.
2650          */
2651         char exten[AST_CHANNEL_NAME];
2652         /*!
2653          * Context dialed
2654          *
2655          * The original context dialed. This is used
2656          * so that when performaing a recall, we can
2657          * call into the proper context
2658          */
2659         char context[AST_CHANNEL_NAME];
2660 };
2661
2662 static int cc_generic_agent_init(struct ast_cc_agent *agent, struct ast_channel *chan)
2663 {
2664         struct cc_generic_agent_pvt *generic_pvt = ast_calloc(1, sizeof(*generic_pvt));
2665
2666         if (!generic_pvt) {
2667                 return -1;
2668         }
2669
2670         generic_pvt->offer_timer_id = -1;
2671         if (ast_channel_caller(chan)->id.number.valid && ast_channel_caller(chan)->id.number.str) {
2672                 ast_copy_string(generic_pvt->cid_num, ast_channel_caller(chan)->id.number.str, sizeof(generic_pvt->cid_num));
2673         }
2674         if (ast_channel_caller(chan)->id.name.valid && ast_channel_caller(chan)->id.name.str) {
2675                 ast_copy_string(generic_pvt->cid_name, ast_channel_caller(chan)->id.name.str, sizeof(generic_pvt->cid_name));
2676         }
2677         ast_copy_string(generic_pvt->exten, S_OR(ast_channel_macroexten(chan), ast_channel_exten(chan)), sizeof(generic_pvt->exten));
2678         ast_copy_string(generic_pvt->context, S_OR(ast_channel_macrocontext(chan), ast_channel_context(chan)), sizeof(generic_pvt->context));
2679         agent->private_data = generic_pvt;
2680         ast_set_flag(agent, AST_CC_AGENT_SKIP_OFFER);
2681         return 0;
2682 }
2683
2684 static int offer_timer_expire(const void *data)
2685 {
2686         struct ast_cc_agent *agent = (struct ast_cc_agent *) data;
2687         struct cc_generic_agent_pvt *agent_pvt = agent->private_data;
2688         ast_log_dynamic_level(cc_logger_level, "Core %d: Queuing change request because offer timer has expired.\n",
2689                         agent->core_id);
2690         agent_pvt->offer_timer_id = -1;
2691         ast_cc_failed(agent->core_id, "Generic agent %s offer timer expired", agent->device_name);
2692         cc_unref(agent, "Remove scheduler's reference to the agent");
2693         return 0;
2694 }
2695
2696 static int cc_generic_agent_start_offer_timer(struct ast_cc_agent *agent)
2697 {
2698         int when;
2699         int sched_id;
2700         struct cc_generic_agent_pvt *generic_pvt = agent->private_data;
2701
2702         ast_assert(cc_sched_context != NULL);
2703         ast_assert(agent->cc_params != NULL);
2704
2705         when = ast_get_cc_offer_timer(agent->cc_params) * 1000;
2706         ast_log_dynamic_level(cc_logger_level, "Core %d: About to schedule offer timer expiration for %d ms\n",
2707                         agent->core_id, when);
2708         if ((sched_id = ast_sched_add(cc_sched_context, when, offer_timer_expire, cc_ref(agent, "Give scheduler an agent ref"))) == -1) {
2709                 return -1;
2710         }
2711         generic_pvt->offer_timer_id = sched_id;
2712         return 0;
2713 }
2714
2715 static int cc_generic_agent_stop_offer_timer(struct ast_cc_agent *agent)
2716 {
2717         struct cc_generic_agent_pvt *generic_pvt = agent->private_data;
2718
2719         if (generic_pvt->offer_timer_id != -1) {
2720                 if (!ast_sched_del(cc_sched_context, generic_pvt->offer_timer_id)) {
2721                         cc_unref(agent, "Remove scheduler's reference to the agent");
2722                 }
2723                 generic_pvt->offer_timer_id = -1;
2724         }
2725         return 0;
2726 }
2727
2728 static void cc_generic_agent_respond(struct ast_cc_agent *agent, enum ast_cc_agent_response_reason reason)
2729 {
2730         /* The generic agent doesn't have to do anything special to
2731          * acknowledge a CC request. Just return.
2732          */
2733         return;
2734 }
2735
2736 static int cc_generic_agent_status_request(struct ast_cc_agent *agent)
2737 {
2738         ast_cc_agent_status_response(agent->core_id, ast_device_state(agent->device_name));
2739         return 0;
2740 }
2741
2742 static int cc_generic_agent_stop_ringing(struct ast_cc_agent *agent)
2743 {
2744         struct ast_channel *recall_chan = ast_channel_get_by_name_prefix(agent->device_name, strlen(agent->device_name));
2745
2746         if (!recall_chan) {
2747                 return 0;
2748         }
2749
2750         ast_softhangup(recall_chan, AST_SOFTHANGUP_EXPLICIT);
2751         return 0;
2752 }
2753
2754 static void generic_agent_devstate_cb(void *userdata, struct stasis_subscription *sub, struct stasis_topic *topic, struct stasis_message *msg)
2755 {
2756         struct ast_cc_agent *agent = userdata;
2757         enum ast_device_state new_state;
2758         struct ast_device_state_message *dev_state;
2759         struct cc_generic_agent_pvt *generic_pvt = agent->private_data;
2760
2761         if (stasis_subscription_final_message(sub, msg)) {
2762                 cc_unref(agent, "Done holding ref for subscription");
2763                 return;
2764         } else if (ast_device_state_message_type() != stasis_message_type(msg)) {
2765                 return;
2766         }
2767
2768         dev_state = stasis_message_data(msg);
2769         if (dev_state->eid) {
2770                 /* ignore non-aggregate states */
2771                 return;
2772         }
2773
2774         new_state = dev_state->state;
2775         if (!cc_generic_is_device_available(new_state)) {
2776                 /* Not interested in this new state of the device.  It is still busy. */
2777                 return;
2778         }
2779
2780         generic_pvt->sub = stasis_unsubscribe(sub);
2781         ast_cc_agent_caller_available(agent->core_id, "%s is no longer busy", agent->device_name);
2782 }
2783
2784 static int cc_generic_agent_start_monitoring(struct ast_cc_agent *agent)
2785 {
2786         struct cc_generic_agent_pvt *generic_pvt = agent->private_data;
2787         struct ast_str *str = ast_str_alloca(128);
2788         struct stasis_topic *device_specific_topic;
2789
2790         ast_assert(generic_pvt->sub == NULL);
2791         ast_str_set(&str, 0, "Agent monitoring %s device state since it is busy\n",
2792                 agent->device_name);
2793
2794         device_specific_topic = ast_device_state_topic(agent->device_name);
2795         if (!device_specific_topic) {
2796                 return -1;
2797         }
2798
2799         if (!(generic_pvt->sub = stasis_subscribe(device_specific_topic, generic_agent_devstate_cb, agent))) {
2800                 return -1;
2801         }
2802         cc_ref(agent, "Ref agent for subscription");
2803         return 0;
2804 }
2805
2806 static void *generic_recall(void *data)
2807 {
2808         struct ast_cc_agent *agent = data;
2809         struct cc_generic_agent_pvt *generic_pvt = agent->private_data;
2810         const char *interface = S_OR(ast_get_cc_agent_dialstring(agent->cc_params), ast_strdupa(agent->device_name));
2811         const char *tech;
2812         char *target;
2813         int reason;
2814         struct ast_channel *chan;
2815         const char *callback_macro = ast_get_cc_callback_macro(agent->cc_params);
2816         const char *callback_sub = ast_get_cc_callback_sub(agent->cc_params);
2817         unsigned int recall_timer = ast_get_cc_recall_timer(agent->cc_params) * 1000;
2818         struct ast_format tmp_fmt;
2819         struct ast_format_cap *tmp_cap = ast_format_cap_alloc_nolock();
2820
2821         if (!tmp_cap) {
2822                 return NULL;
2823         }
2824
2825         tech = interface;
2826         if ((target = strchr(interface, '/'))) {
2827                 *target++ = '\0';
2828         }
2829
2830         ast_format_cap_add(tmp_cap, ast_format_set(&tmp_fmt, AST_FORMAT_SLINEAR, 0));
2831         if (!(chan = ast_request_and_dial(tech, tmp_cap, NULL, target, recall_timer, &reason, generic_pvt->cid_num, generic_pvt->cid_name))) {
2832                 /* Hmm, no channel. Sucks for you, bud.
2833                  */
2834                 ast_log_dynamic_level(cc_logger_level, "Core %d: Failed to call back %s for reason %d\n",
2835                                 agent->core_id, agent->device_name, reason);
2836                 ast_cc_failed(agent->core_id, "Failed to call back device %s/%s", tech, target);
2837                 ast_format_cap_destroy(tmp_cap);
2838                 return NULL;
2839         }
2840         ast_format_cap_destroy(tmp_cap);
2841         
2842         /* We have a channel. It's time now to set up the datastore of recalled CC interfaces.
2843          * This will be a common task for all recall functions. If it were possible, I'd have
2844          * the core do it automatically, but alas I cannot. Instead, I will provide a public
2845          * function to do so.
2846          */
2847         ast_setup_cc_recall_datastore(chan, agent->core_id);
2848         ast_cc_agent_set_interfaces_chanvar(chan);
2849
2850         ast_channel_exten_set(chan, generic_pvt->exten);
2851         ast_channel_context_set(chan, generic_pvt->context);
2852         ast_channel_priority_set(chan, 1);
2853
2854         pbx_builtin_setvar_helper(chan, "CC_EXTEN", generic_pvt->exten);
2855         pbx_builtin_setvar_helper(chan, "CC_CONTEXT", generic_pvt->context);
2856
2857         if (!ast_strlen_zero(callback_macro)) {
2858                 ast_log_dynamic_level(cc_logger_level, "Core %d: There's a callback macro configured for agent %s\n",
2859                                 agent->core_id, agent->device_name);
2860                 if (ast_app_exec_macro(NULL, chan, callback_macro)) {
2861                         ast_cc_failed(agent->core_id, "Callback macro to %s failed. Maybe a hangup?", agent->device_name);
2862                         ast_hangup(chan);
2863                         return NULL;
2864                 }
2865         }
2866
2867         if (!ast_strlen_zero(callback_sub)) {
2868                 ast_log_dynamic_level(cc_logger_level, "Core %d: There's a callback subroutine configured for agent %s\n",
2869                                 agent->core_id, agent->device_name);
2870                 if (ast_app_exec_sub(NULL, chan, callback_sub, 0)) {
2871                         ast_cc_failed(agent->core_id, "Callback subroutine to %s failed. Maybe a hangup?", agent->device_name);
2872                         ast_hangup(chan);
2873                         return NULL;
2874                 }
2875         }
2876         if (ast_pbx_start(chan)) {
2877                 ast_cc_failed(agent->core_id, "PBX failed to start for %s.", agent->device_name);
2878                 ast_hangup(chan);
2879                 return NULL;
2880         }
2881         ast_cc_agent_recalling(agent->core_id, "Generic agent %s is recalling",
2882                 agent->device_name);
2883         return NULL;
2884 }
2885
2886 static int cc_generic_agent_recall(struct ast_cc_agent *agent)
2887 {
2888         pthread_t clotho;
2889         enum ast_device_state current_state = ast_device_state(agent->device_name);
2890
2891         if (!cc_generic_is_device_available(current_state)) {
2892                 /* We can't try to contact the device right now because he's not available
2893                  * Let the core know he's busy.
2894                  */
2895                 ast_cc_agent_caller_busy(agent->core_id, "Generic agent caller %s is busy", agent->device_name);
2896                 return 0;
2897         }
2898         ast_pthread_create_detached_background(&clotho, NULL, generic_recall, agent);
2899         return 0;
2900 }
2901
2902 static void cc_generic_agent_destructor(struct ast_cc_agent *agent)
2903 {
2904         struct cc_generic_agent_pvt *agent_pvt = agent->private_data;
2905
2906         if (!agent_pvt) {
2907                 /* The agent constructor probably failed. */
2908                 return;
2909         }
2910
2911         cc_generic_agent_stop_offer_timer(agent);
2912         if (agent_pvt->sub) {
2913                 agent_pvt->sub = stasis_unsubscribe(agent_pvt->sub);
2914         }
2915
2916         ast_free(agent_pvt);
2917 }
2918
2919 static void cc_core_instance_destructor(void *data)
2920 {
2921         struct cc_core_instance *core_instance = data;
2922         ast_log_dynamic_level(cc_logger_level, "Core %d: Destroying core instance\n", core_instance->core_id);
2923         if (core_instance->agent) {
2924                 cc_unref(core_instance->agent, "Core instance is done with the agent now");
2925         }
2926         if (core_instance->monitors) {
2927                 core_instance->monitors = cc_unref(core_instance->monitors, "Core instance is done with interface list");
2928         }
2929 }
2930
2931 static struct cc_core_instance *cc_core_init_instance(struct ast_channel *caller_chan,
2932                 struct cc_monitor_tree *called_tree, const int core_id, struct cc_control_payload *cc_data)
2933 {
2934         char caller[AST_CHANNEL_NAME];
2935         struct cc_core_instance *core_instance;
2936         struct ast_cc_config_params *cc_params;
2937         long agent_count;
2938         int recall_core_id;
2939
2940         ast_channel_get_device_name(caller_chan, caller, sizeof(caller));
2941         cc_params = ast_channel_get_cc_config_params(caller_chan);
2942         if (!cc_params) {
2943                 ast_log_dynamic_level(cc_logger_level, "Could not get CC parameters for %s\n",
2944                         caller);
2945                 return NULL;
2946         }
2947         /* First, we need to kill off other pending CC offers from caller. If the caller is going
2948          * to request a CC service, it may only be for the latest call he made.
2949          */
2950         if (ast_get_cc_agent_policy(cc_params) == AST_CC_AGENT_GENERIC) {
2951                 kill_duplicate_offers(caller);
2952         }
2953
2954         ast_cc_is_recall(caller_chan, &recall_core_id, NULL);
2955         agent_count = count_agents(caller, recall_core_id);
2956         if (agent_count >= ast_get_cc_max_agents(cc_params)) {
2957                 ast_log_dynamic_level(cc_logger_level, "Caller %s already has the maximum number of agents configured\n", caller);
2958                 return NULL;
2959         }
2960
2961         /* Generic agents can only have a single outstanding CC request per caller. */
2962         if (agent_count > 0 && ast_get_cc_agent_policy(cc_params) == AST_CC_AGENT_GENERIC) {
2963                 ast_log_dynamic_level(cc_logger_level, "Generic agents can only have a single outstanding request\n");
2964                 return NULL;
2965         }
2966
2967         /* Next, we need to create the core instance for this call */
2968         if (!(core_instance = ao2_t_alloc(sizeof(*core_instance), cc_core_instance_destructor, "Creating core instance for CC"))) {
2969                 return NULL;
2970         }
2971
2972         core_instance->core_id = core_id;
2973         if (!(core_instance->agent = cc_agent_init(caller_chan, caller, core_instance->core_id, called_tree))) {
2974                 cc_unref(core_instance, "Couldn't allocate agent, unref core_instance");
2975                 return NULL;
2976         }
2977
2978         core_instance->monitors = cc_ref(called_tree, "Core instance getting ref to monitor tree");
2979
2980         ao2_t_link(cc_core_instances, core_instance, "Link core instance into container");
2981
2982         return core_instance;
2983 }
2984
2985 struct cc_state_change_args {
2986         struct cc_core_instance *core_instance;/*!< Holds reference to core instance. */
2987         enum cc_state state;
2988         int core_id;
2989         char debug[1];
2990 };
2991
2992 static int is_state_change_valid(enum cc_state current_state, const enum cc_state new_state, struct ast_cc_agent *agent)
2993 {
2994         int is_valid = 0;
2995         switch (new_state) {
2996         case CC_AVAILABLE:
2997                 ast_log_dynamic_level(cc_logger_level, "Core %d: Asked to change to state %d? That should never happen.\n",
2998                                 agent->core_id, new_state);
2999                 break;
3000         case CC_CALLER_OFFERED:
3001                 if (current_state == CC_AVAILABLE) {
3002                         is_valid = 1;
3003                 }
3004                 break;
3005         case CC_CALLER_REQUESTED:
3006                 if (current_state == CC_CALLER_OFFERED ||
3007                                 (current_state == CC_AVAILABLE && ast_test_flag(agent, AST_CC_AGENT_SKIP_OFFER))) {
3008                         is_valid = 1;
3009                 }
3010                 break;
3011         case CC_ACTIVE:
3012                 if (current_state == CC_CALLER_REQUESTED || current_state == CC_CALLER_BUSY) {
3013                         is_valid = 1;
3014                 }
3015                 break;
3016         case CC_CALLEE_READY:
3017                 if (current_state == CC_ACTIVE) {
3018                         is_valid = 1;
3019                 }
3020                 break;
3021         case CC_CALLER_BUSY:
3022                 if (current_state == CC_CALLEE_READY) {
3023                         is_valid = 1;
3024                 }
3025                 break;
3026         case CC_RECALLING:
3027                 if (current_state == CC_CALLEE_READY) {
3028                         is_valid = 1;
3029                 }
3030                 break;
3031         case CC_COMPLETE:
3032                 if (current_state == CC_RECALLING) {
3033                         is_valid = 1;
3034                 }
3035                 break;
3036         case CC_FAILED:
3037                 is_valid = 1;
3038                 break;
3039         default:
3040                 ast_log_dynamic_level(cc_logger_level, "Core %d: Asked to change to unknown state %d\n",
3041                                 agent->core_id, new_state);
3042                 break;
3043         }
3044
3045         return is_valid;
3046 }
3047
3048 static int cc_available(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3049 {
3050         /* This should never happen... */
3051         ast_log(LOG_WARNING, "Someone requested to change to CC_AVAILABLE? Ignoring.\n");
3052         return -1;
3053 }
3054
3055 static int cc_caller_offered(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3056 {
3057         if (core_instance->agent->callbacks->start_offer_timer(core_instance->agent)) {
3058                 ast_cc_failed(core_instance->core_id, "Failed to start the offer timer for %s\n",
3059                                 core_instance->agent->device_name);
3060                 return -1;
3061         }
3062         cc_publish_offertimerstart(core_instance->core_id, core_instance->agent->device_name, core_instance->agent->cc_params->cc_offer_timer);
3063         ast_log_dynamic_level(cc_logger_level, "Core %d: Started the offer timer for the agent %s!\n",
3064                         core_instance->core_id, core_instance->agent->device_name);
3065         return 0;
3066 }
3067
3068 /*!
3069  * \brief check if the core instance has any device monitors
3070  *
3071  * In any case where we end up removing a device monitor from the
3072  * list of device monitors, it is important to see what the state
3073  * of the list is afterwards. If we find that we only have extension
3074  * monitors left, then no devices are actually being monitored.
3075  * In such a case, we need to declare that CC has failed for this
3076  * call. This function helps those cases to determine if they should
3077  * declare failure.
3078  *
3079  * \param core_instance The core instance we are checking for the existence
3080  * of device monitors
3081  * \retval 0 No device monitors exist on this core_instance
3082  * \retval 1 There is still at least 1 device monitor remaining
3083  */
3084 static int has_device_monitors(struct cc_core_instance *core_instance)
3085 {
3086         struct ast_cc_monitor *iter;
3087         int res = 0;
3088
3089         AST_LIST_TRAVERSE(core_instance->monitors, iter, next) {
3090                 if (iter->interface->monitor_class == AST_CC_DEVICE_MONITOR) {
3091                         res = 1;
3092                         break;
3093                 }
3094         }
3095
3096         return res;
3097 }
3098
3099 static void request_cc(struct cc_core_instance *core_instance)
3100 {
3101         struct ast_cc_monitor *monitor_iter;
3102         AST_LIST_LOCK(core_instance->monitors);
3103         AST_LIST_TRAVERSE_SAFE_BEGIN(core_instance->monitors, monitor_iter, next) {
3104                 if (monitor_iter->interface->monitor_class == AST_CC_DEVICE_MONITOR) {
3105                         if (monitor_iter->callbacks->request_cc(monitor_iter, &monitor_iter->available_timer_id)) {
3106                                 AST_LIST_REMOVE_CURRENT(next);
3107                                 cc_extension_monitor_change_is_valid(core_instance, monitor_iter->parent_id,
3108                                                 monitor_iter->interface->device_name, 1);
3109                                 cc_unref(monitor_iter, "request_cc failed. Unref list's reference to monitor");
3110                         } else {
3111                                 cc_publish_requested(core_instance->core_id, core_instance->agent->device_name, monitor_iter->interface->device_name);
3112                         }
3113                 }
3114         }
3115         AST_LIST_TRAVERSE_SAFE_END;
3116
3117         if (!has_device_monitors(core_instance)) {
3118                 ast_cc_failed(core_instance->core_id, "All device monitors failed to request CC");
3119         }
3120         AST_LIST_UNLOCK(core_instance->monitors);
3121 }
3122
3123 static int cc_caller_requested(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3124 {
3125         if (!ast_cc_request_is_within_limits()) {
3126                 ast_log(LOG_WARNING, "Cannot request CC since there is no more room for requests\n");
3127                 core_instance->agent->callbacks->respond(core_instance->agent,
3128                         AST_CC_AGENT_RESPONSE_FAILURE_TOO_MANY);
3129                 ast_cc_failed(core_instance->core_id, "Too many requests in the system");
3130                 return -1;
3131         }
3132         core_instance->agent->callbacks->stop_offer_timer(core_instance->agent);
3133         request_cc(core_instance);
3134         return 0;
3135 }
3136
3137 static void unsuspend(struct cc_core_instance *core_instance)
3138 {
3139         struct ast_cc_monitor *monitor_iter;
3140         AST_LIST_LOCK(core_instance->monitors);
3141         AST_LIST_TRAVERSE_SAFE_BEGIN(core_instance->monitors, monitor_iter, next) {
3142                 if (monitor_iter->interface->monitor_class == AST_CC_DEVICE_MONITOR) {
3143                         if (monitor_iter->callbacks->unsuspend(monitor_iter)) {
3144                                 AST_LIST_REMOVE_CURRENT(next);
3145                                 cc_extension_monitor_change_is_valid(core_instance, monitor_iter->parent_id,
3146                                                 monitor_iter->interface->device_name, 1);
3147                                 cc_unref(monitor_iter, "unsuspend failed. Unref list's reference to monitor");
3148                         }
3149                 }
3150         }
3151         AST_LIST_TRAVERSE_SAFE_END;
3152
3153         if (!has_device_monitors(core_instance)) {
3154                 ast_cc_failed(core_instance->core_id, "All device monitors failed to unsuspend CC");
3155         }
3156         AST_LIST_UNLOCK(core_instance->monitors);
3157 }
3158
3159 static int cc_active(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3160 {
3161         /* Either
3162          * 1. Callee accepted CC request, call agent's ack callback.
3163          * 2. Caller became available, call agent's stop_monitoring callback and
3164          *    call monitor's unsuspend callback.
3165          */
3166         if (previous_state == CC_CALLER_REQUESTED) {
3167                 core_instance->agent->callbacks->respond(core_instance->agent,
3168                         AST_CC_AGENT_RESPONSE_SUCCESS);
3169                 cc_publish_requestacknowledged(core_instance->core_id, core_instance->agent->device_name);
3170         } else if (previous_state == CC_CALLER_BUSY) {
3171                 cc_publish_callerstopmonitoring(core_instance->core_id, core_instance->agent->device_name);
3172                 unsuspend(core_instance);
3173         }
3174         /* Not possible for previous_state to be anything else due to the is_state_change_valid check at the beginning */
3175         return 0;
3176 }
3177
3178 static int cc_callee_ready(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3179 {
3180         core_instance->agent->callbacks->callee_available(core_instance->agent);
3181         return 0;
3182 }
3183
3184 static void suspend(struct cc_core_instance *core_instance)
3185 {
3186         struct ast_cc_monitor *monitor_iter;
3187         AST_LIST_LOCK(core_instance->monitors);
3188         AST_LIST_TRAVERSE_SAFE_BEGIN(core_instance->monitors, monitor_iter, next) {
3189                 if (monitor_iter->interface->monitor_class == AST_CC_DEVICE_MONITOR) {
3190                         if (monitor_iter->callbacks->suspend(monitor_iter)) {
3191                                 AST_LIST_REMOVE_CURRENT(next);
3192                                 cc_extension_monitor_change_is_valid(core_instance, monitor_iter->parent_id,
3193                                                 monitor_iter->interface->device_name, 1);
3194                                 cc_unref(monitor_iter, "suspend failed. Unref list's reference to monitor");
3195                         }
3196                 }
3197         }
3198         AST_LIST_TRAVERSE_SAFE_END;
3199
3200         if (!has_device_monitors(core_instance)) {
3201                 ast_cc_failed(core_instance->core_id, "All device monitors failed to suspend CC");
3202         }
3203         AST_LIST_UNLOCK(core_instance->monitors);
3204 }
3205
3206 static int cc_caller_busy(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3207 {
3208         /* Callee was available, but caller was busy, call agent's begin_monitoring callback
3209          * and call monitor's suspend callback.
3210          */
3211         suspend(core_instance);
3212         core_instance->agent->callbacks->start_monitoring(core_instance->agent);
3213         cc_publish_callerstartmonitoring(core_instance->core_id, core_instance->agent->device_name);
3214         return 0;
3215 }
3216
3217 static void cancel_available_timer(struct cc_core_instance *core_instance)
3218 {
3219         struct ast_cc_monitor *monitor_iter;
3220         AST_LIST_LOCK(core_instance->monitors);
3221         AST_LIST_TRAVERSE_SAFE_BEGIN(core_instance->monitors, monitor_iter, next) {
3222                 if (monitor_iter->interface->monitor_class == AST_CC_DEVICE_MONITOR) {
3223                         if (monitor_iter->callbacks->cancel_available_timer(monitor_iter, &monitor_iter->available_timer_id)) {
3224                                 AST_LIST_REMOVE_CURRENT(next);
3225                                 cc_extension_monitor_change_is_valid(core_instance, monitor_iter->parent_id,
3226                                                 monitor_iter->interface->device_name, 1);
3227                                 cc_unref(monitor_iter, "cancel_available_timer failed. Unref list's reference to monitor");
3228                         }
3229                 }
3230         }
3231         AST_LIST_TRAVERSE_SAFE_END;
3232
3233         if (!has_device_monitors(core_instance)) {
3234                 ast_cc_failed(core_instance->core_id, "All device monitors failed to cancel their available timers");
3235         }
3236         AST_LIST_UNLOCK(core_instance->monitors);
3237 }
3238
3239 static int cc_recalling(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3240 {
3241         /* Both caller and callee are available, call agent's recall callback
3242          */
3243         cancel_available_timer(core_instance);
3244         cc_publish_callerrecalling(core_instance->core_id, core_instance->agent->device_name);
3245         return 0;
3246 }
3247
3248 static int cc_complete(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3249 {
3250         /* Recall has made progress, call agent and monitor destructor functions
3251          */
3252         cc_publish_recallcomplete(core_instance->core_id, core_instance->agent->device_name);
3253         ao2_t_unlink(cc_core_instances, core_instance, "Unlink core instance since CC recall has completed");
3254         return 0;
3255 }
3256
3257 static int cc_failed(struct cc_core_instance *core_instance, struct cc_state_change_args *args, enum cc_state previous_state)
3258 {
3259         cc_publish_failure(core_instance->core_id, core_instance->agent->device_name, args->debug);
3260         ao2_t_unlink(cc_core_instances, core_instance, "Unlink core instance since CC failed");
3261         return 0;
3262 }
3263
3264 static int (* const state_change_funcs [])(struct cc_core_instance *, struct cc_state_change_args *, enum cc_state previous_state) = {
3265         [CC_AVAILABLE] = cc_available,
3266         [CC_CALLER_OFFERED] = cc_caller_offered,
3267         [CC_CALLER_REQUESTED] = cc_caller_requested,
3268         [CC_ACTIVE] = cc_active,
3269         [CC_CALLEE_READY] = cc_callee_ready,
3270         [CC_CALLER_BUSY] = cc_caller_busy,
3271         [CC_RECALLING] = cc_recalling,
3272         [CC_COMPLETE] = cc_complete,
3273         [CC_FAILED] = cc_failed,
3274 };
3275
3276 static int cc_do_state_change(void *datap)
3277 {
3278         struct cc_state_change_args *args = datap;
3279         struct cc_core_instance *core_instance;
3280         enum cc_state previous_state;
3281         int res;
3282
3283         ast_log_dynamic_level(cc_logger_level, "Core %d: State change to %d requested. Reason: %s\n",
3284                         args->core_id, args->state, args->debug);
3285
3286         core_instance = args->core_instance;
3287
3288         if (!is_state_change_valid(core_instance->current_state, args->state, core_instance->agent)) {
3289                 ast_log_dynamic_level(cc_logger_level, "Core %d: Invalid state change requested. Cannot go from %s to %s\n",
3290                                 args->core_id, cc_state_to_string(core_instance->current_state), cc_state_to_string(args->state));
3291                 if (args->state == CC_CALLER_REQUESTED) {
3292                         /*
3293                          * For out-of-order requests, we need to let the requester know that
3294                          * we can't handle the request now.
3295                          */
3296                         core_instance->agent->callbacks->respond(core_instance->agent,
3297                                 AST_CC_AGENT_RESPONSE_FAILURE_INVALID);
3298                 }
3299                 ast_free(args);
3300                 cc_unref(core_instance, "Unref core instance from when it was found earlier");
3301                 return -1;
3302         }
3303
3304         /* We can change to the new state now. */
3305         previous_state = core_instance->current_state;
3306         core_instance->current_state = args->state;
3307         res = state_change_funcs[core_instance->current_state](core_instance, args, previous_state);
3308
3309         /* If state change successful then notify any device state watchers of the change */
3310         if (!res && !strcmp(core_instance->agent->callbacks->type, "generic")) {
3311                 ccss_notify_device_state_change(core_instance->agent->device_name, core_instance->current_state);
3312         }
3313
3314         ast_free(args);
3315         cc_unref(core_instance, "Unref since state change has completed"); /* From ao2_find */
3316         return res;
3317 }
3318
3319 static int cc_request_state_change(enum cc_state state, const int core_id, const char *debug, va_list ap)
3320 {
3321         int res;
3322         int debuglen;
3323         char dummy[1];
3324         va_list aq;
3325         struct cc_core_instance *core_instance;
3326         struct cc_state_change_args *args;
3327         /* This initial call to vsnprintf is simply to find what the
3328          * size of the string needs to be
3329          */
3330         va_copy(aq, ap);
3331         /* We add 1 to the result since vsnprintf's return does not
3332          * include the terminating null byte
3333          */
3334         debuglen = vsnprintf(dummy, sizeof(dummy), debug, aq) + 1;
3335         va_end(aq);
3336
3337         if (!(args = ast_calloc(1, sizeof(*args) + debuglen))) {
3338                 return -1;
3339         }
3340
3341         core_instance = find_cc_core_instance(core_id);
3342         if (!core_instance) {
3343                 ast_log_dynamic_level(cc_logger_level, "Core %d: Unable to find core instance.\n",
3344                         core_id);
3345                 ast_free(args);
3346                 return -1;
3347         }
3348
3349         args->core_instance = core_instance;
3350         args->state = state;
3351         args->core_id = core_id;
3352         vsnprintf(args->debug, debuglen, debug, ap);
3353
3354         res = ast_taskprocessor_push(cc_core_taskprocessor, cc_do_state_change, args);
3355         if (res) {
3356                 cc_unref(core_instance, "Unref core instance. ast_taskprocessor_push failed");
3357                 ast_free(args);
3358         }
3359         return res;
3360 }
3361
3362 struct cc_recall_ds_data {
3363         int core_id;
3364         char ignore;
3365         char nested;
3366         struct cc_monitor_tree *interface_tree;
3367 };
3368
3369 static void *cc_recall_ds_duplicate(void *data)
3370 {
3371         struct cc_recall_ds_data *old_data = data;
3372         struct cc_recall_ds_data *new_data = ast_calloc(1, sizeof(*new_data));
3373
3374         if (!new_data) {
3375                 return NULL;
3376         }
3377         new_data->interface_tree = cc_ref(old_data->interface_tree, "Bump refcount of monitor tree for recall datastore duplicate");
3378         new_data->core_id = old_data->core_id;
3379         new_data->nested = 1;
3380         return new_data;
3381 }
3382
3383 static void cc_recall_ds_destroy(void *data)
3384 {
3385         struct cc_recall_ds_data *recall_data = data;
3386         recall_data->interface_tree = cc_unref(recall_data->interface_tree, "Unref recall monitor tree");
3387         ast_free(recall_data);
3388 }
3389
3390 static const struct ast_datastore_info recall_ds_info = {
3391         .type = "cc_recall",
3392         .duplicate = cc_recall_ds_duplicate,
3393         .destroy = cc_recall_ds_destroy,
3394 };
3395
3396 int ast_setup_cc_recall_datastore(struct ast_channel *chan, const int core_id)
3397 {
3398         struct ast_datastore *recall_datastore = ast_datastore_alloc(&recall_ds_info, NULL);
3399         struct cc_recall_ds_data *recall_data;
3400         struct cc_core_instance *core_instance;
3401
3402         if (!recall_datastore) {
3403                 return -1;
3404         }
3405
3406         if (!(recall_data = ast_calloc(1, sizeof(*recall_data)))) {
3407                 ast_datastore_free(recall_datastore);
3408                 return -1;
3409         }
3410
3411         if (!(core_instance = find_cc_core_instance(core_id))) {
3412                 ast_free(recall_data);
3413                 ast_datastore_free(recall_datastore);
3414                 return -1;
3415         }
3416
3417         recall_data->interface_tree = cc_ref(core_instance->monitors,
3418                         "Bump refcount for monitor tree for recall datastore");
3419         recall_data->core_id = core_id;
3420         recall_datastore->data = recall_data;
3421         recall_datastore->inheritance = DATASTORE_INHERIT_FOREVER;
3422         ast_channel_lock(chan);
3423         ast_channel_datastore_add(chan, recall_datastore);
3424         ast_channel_unlock(chan);
3425         cc_unref(core_instance, "Recall datastore set up. No need for core_instance ref");
3426         return 0;
3427 }
3428
3429 int ast_cc_is_recall(struct ast_channel *chan, int *core_id, const char * const monitor_type)
3430 {
3431         struct ast_datastore *recall_datastore;
3432         struct cc_recall_ds_data *recall_data;
3433         struct cc_monitor_tree *interface_tree;
3434         char device_name[AST_CHANNEL_NAME];
3435         struct ast_cc_monitor *device_monitor;
3436         int core_id_candidate;
3437
3438         ast_assert(core_id != NULL);
3439
3440         *core_id = -1;
3441
3442         ast_channel_lock(chan);
3443         if (!(recall_datastore = ast_channel_datastore_find(chan, &recall_ds_info, NULL))) {
3444                 /* Obviously not a recall if the datastore isn't present */
3445                 ast_channel_unlock(chan);
3446                 return 0;
3447         }
3448
3449         recall_data = recall_datastore->data;
3450
3451         if (recall_data->ignore) {
3452                 /* Though this is a recall, the call to this particular interface is not part of the
3453                  * recall either because this is a call forward or because this is not the first
3454                  * invocation of Dial during this call
3455                  */
3456                 ast_channel_unlock(chan);
3457                 return 0;
3458         }
3459
3460         if (!recall_data->nested) {
3461                 /* If the nested flag is not set, then this means that
3462                  * the channel passed to this function is the caller making
3463                  * the recall. This means that we shouldn't look through
3464                  * the monitor tree for the channel because it shouldn't be
3465                  * there. However, this is a recall though, so return true.
3466                  */
3467                 *core_id = recall_data->core_id;
3468                 ast_channel_unlock(chan);
3469                 return 1;
3470         }
3471
3472         if (ast_strlen_zero(monitor_type)) {
3473                 /* If someone passed a NULL or empty monitor type, then it is clear
3474                  * the channel they passed in was an incoming channel, and so searching
3475                  * the list of dialed interfaces is not going to be helpful. Just return
3476                  * false immediately.
3477                  */
3478                 ast_channel_unlock(chan);
3479                 return 0;
3480         }
3481
3482         interface_tree = recall_data->interface_tree;
3483         ast_channel_get_device_name(chan, device_name, sizeof(device_name));
3484         /* We grab the value of the recall_data->core_id so that we
3485          * can unlock the channel before we start looking through the
3486          * interface list. That way we don't have to worry about a possible
3487          * clash between the channel lock and the monitor tree lock.
3488          */
3489         core_id_candidate = recall_data->core_id;
3490         ast_channel_unlock(chan);
3491
3492         /*
3493          * Now we need to find out if the channel device name
3494          * is in the list of interfaces in the called tree.
3495          */
3496         AST_LIST_LOCK(interface_tree);
3497         AST_LIST_TRAVERSE(interface_tree, device_monitor, next) {
3498                 if (!strcmp(device_monitor->interface->device_name, device_name) &&
3499                                 !strcmp(device_monitor->interface->monitor_type, monitor_type)) {
3500                         /* BOOM! Device is in the tree! We have a winner! */
3501                         *core_id = core_id_candidate;
3502                         AST_LIST_UNLOCK(interface_tree);
3503                         return 1;
3504                 }
3505         }
3506         AST_LIST_UNLOCK(interface_tree);
3507         return 0;
3508 }
3509
3510 struct ast_cc_monitor *ast_cc_get_monitor_by_recall_core_id(const int core_id, const char * const device_name)
3511 {
3512         struct cc_core_instance *core_instance = find_cc_core_instance(core_id);
3513         struct ast_cc_monitor *monitor_iter;
3514
3515         if (!core_instance) {
3516                 return NULL;
3517         }
3518
3519         AST_LIST_LOCK(core_instance->monitors);
3520         AST_LIST_TRAVERSE(core_instance->monitors, monitor_iter, next) {
3521                 if (!strcmp(monitor_iter->interface->device_name, device_name)) {
3522                         /* Found a monitor. */
3523                         cc_ref(monitor_iter, "Hand the requester of the monitor a reference");
3524                         break;
3525                 }
3526         }
3527         AST_LIST_UNLOCK(core_instance->monitors);
3528         cc_unref(core_instance, "Done with core instance ref in ast_cc_get_monitor_by_recall_core_id");
3529         return monitor_iter;
3530 }
3531
3532 /*!
3533  * \internal
3534  * \brief uniquely append a dialstring to our CC_INTERFACES chanvar string.
3535  *
3536  * We will only append a string if it has not already appeared in our channel
3537  * variable earlier. We ensure that we don't erroneously match substrings by
3538  * adding an ampersand to the end of our potential dialstring and searching for
3539  * it plus the ampersand in our variable.
3540  *
3541  * It's important to note that once we have built the full CC_INTERFACES string,
3542  * there will be an extra ampersand at the end which must be stripped off by
3543  * the caller of this function.
3544  *
3545  * \param str An ast_str holding what we will add to CC_INTERFACES
3546  * \param dialstring A new dialstring to add
3547  * \retval void
3548  */
3549 static void cc_unique_append(struct ast_str **str, const char *dialstring)
3550 {
3551         char dialstring_search[AST_CHANNEL_NAME];
3552
3553         if (ast_strlen_zero(dialstring)) {
3554                 /* No dialstring to append. */
3555                 return;
3556         }
3557         snprintf(dialstring_search, sizeof(dialstring_search), "%s%c", dialstring, '&');
3558         if (strstr(ast_str_buffer(*str), dialstring_search)) {
3559                 return;
3560         }
3561         ast_str_append(str, 0, "%s", dialstring_search);
3562 }
3563
3564 /*!
3565  * \internal
3566  * \brief Build the CC_INTERFACES channel variable
3567  *
3568  * The method used is to traverse the child dialstrings in the
3569  * passed-in extension monitor, adding any that have the is_valid
3570  * flag set. Then, traverse the monitors, finding all children
3571  * of the starting extension monitor and adding their dialstrings
3572  * as well.
3573  *
3574  * \param starting_point The extension monitor that is the parent to all
3575  * monitors whose dialstrings should be added to CC_INTERFACES
3576  * \param str Where we will store CC_INTERFACES
3577  * \retval void
3578  */
3579 static void build_cc_interfaces_chanvar(struct ast_cc_monitor *starting_point, struct ast_str **str)
3580 {
3581         struct extension_monitor_pvt *extension_pvt;
3582         struct extension_child_dialstring *child_dialstring;
3583         struct ast_cc_monitor *monitor_iter = starting_point;
3584         int top_level_id = starting_point->id;
3585         size_t length;
3586
3587         /* Init to an empty string. */
3588         ast_str_truncate(*str, 0);
3589
3590         /* First we need to take all of the is_valid child_dialstrings from
3591          * the extension monitor we found and add them to the CC_INTERFACES
3592          * chanvar
3593          */
3594         extension_pvt = starting_point->private_data;
3595         AST_LIST_TRAVERSE(&extension_pvt->child_dialstrings, child_dialstring, next) {
3596                 if (child_dialstring->is_valid) {
3597                         cc_unique_append(str, child_dialstring->original_dialstring);
3598                 }
3599         }
3600
3601         /* And now we get the dialstrings from each of the device monitors */
3602         while ((monitor_iter = AST_LIST_NEXT(monitor_iter, next))) {
3603                 if (monitor_iter->parent_id == top_level_id) {
3604                         cc_unique_append(str, monitor_iter->dialstring);
3605                 }
3606         }
3607
3608         /* str will have an extra '&' tacked onto the end of it, so we need
3609          * to get rid of that.
3610          */
3611         length = ast_str_strlen(*str);
3612         if (length) {
3613                 ast_str_truncate(*str, length - 1);
3614         }
3615         if (length <= 1) {
3616                 /* Nothing to recall?  This should not happen. */
3617                 ast_log(LOG_ERROR, "CC_INTERFACES is empty. starting device_name:'%s'\n",
3618                         starting_point->interface->device_name);
3619         }
3620 }
3621
3622 int ast_cc_agent_set_interfaces_chanvar(struct ast_channel *chan)
3623 {
3624         struct ast_datastore *recall_datastore;
3625         struct cc_monitor_tree *interface_tree;
3626         struct ast_cc_monitor *monitor;
3627         struct cc_recall_ds_data *recall_data;
3628         struct ast_str *str = ast_str_create(64);
3629         int core_id;
3630
3631         if (!str) {
3632                 return -1;
3633         }
3634
3635         ast_channel_lock(chan);
3636         if (!(recall_datastore = ast_channel_datastore_find(chan, &recall_ds_info, NULL))) {
3637                 ast_channel_unlock(chan);
3638                 ast_free(str);
3639                 return -1;
3640         }
3641         recall_data = recall_datastore->data;
3642         interface_tree = recall_data->interface_tree;
3643         core_id = recall_data->core_id;
3644         ast_channel_unlock(chan);
3645
3646         AST_LIST_LOCK(interface_tree);
3647         monitor = AST_LIST_FIRST(interface_tree);
3648         build_cc_interfaces_chanvar(monitor, &str);
3649         AST_LIST_UNLOCK(interface_tree);
3650
3651         pbx_builtin_setvar_helper(chan, "CC_INTERFACES", ast_str_buffer(str));
3652         ast_log_dynamic_level(cc_logger_level, "Core %d: CC_INTERFACES set to %s\n",
3653                         core_id, ast_str_buffer(str));
3654
3655         ast_free(str);
3656         return 0;
3657 }
3658
3659 int ast_set_cc_interfaces_chanvar(struct ast_channel *chan, const char * const extension)
3660 {
3661         struct ast_datastore *recall_datastore;
3662         struct cc_monitor_tree *interface_tree;
3663         struct ast_cc_monitor *monitor_iter;
3664         struct cc_recall_ds_data *recall_data;
3665         struct ast_str *str = ast_str_create(64);
3666         int core_id;
3667
3668         if (!str) {
3669                 return -1;
3670         }
3671
3672         ast_channel_lock(chan);
3673         if (!(recall_datastore = ast_channel_datastore_find(chan, &recall_ds_info, NULL))) {
3674                 ast_channel_unlock(chan);
3675                 ast_free(str);
3676                 return -1;
3677         }
3678         recall_data = recall_datastore->data;
3679         interface_tree = recall_data->interface_tree;
3680         core_id = recall_data->core_id;
3681         ast_channel_unlock(chan);
3682
3683         AST_LIST_LOCK(interface_tree);
3684         AST_LIST_TRAVERSE(interface_tree, monitor_iter, next) {
3685                 if (!strcmp(monitor_iter->interface->device_name, extension)) {
3686                         break;
3687                 }
3688         }
3689
3690         if (!monitor_iter) {
3691                 /* We couldn't find this extension. This may be because
3692                  * we have been directed into an unexpected extension because
3693                  * the admin has changed a CC_INTERFACES variable at some point.
3694                  */
3695                 AST_LIST_UNLOCK(interface_tree);
3696                 ast_free(str);
3697                 return -1;
3698         }
3699
3700         build_cc_interfaces_chanvar(monitor_iter, &str);
3701         AST_LIST_UNLOCK(interface_tree);
3702
3703         pbx_builtin_setvar_helper(chan, "CC_INTERFACES", ast_str_buffer(str));
3704         ast_log_dynamic_level(cc_logger_level, "Core %d: CC_INTERFACES set to %s\n",
3705                         core_id, ast_str_buffer(str));
3706
3707         ast_free(str);
3708         return 0;
3709 }
3710
3711 void ast_ignore_cc(struct ast_channel *chan)
3712 {
3713         struct ast_datastore *cc_datastore;
3714         struct ast_datastore *cc_recall_datastore;
3715         struct dialed_cc_interfaces *cc_interfaces;
3716         struct cc_recall_ds_data *recall_cc_data;
3717
3718         ast_channel_lock(chan);
3719         if ((cc_datastore = ast_channel_datastore_find(chan, &dialed_cc_interfaces_info, NULL))) {
3720                 cc_interfaces = cc_datastore->data;
3721                 cc_interfaces->ignore = 1;
3722         }
3723
3724         if ((cc_recall_datastore = ast_channel_datastore_find(chan, &recall_ds_info, NULL))) {
3725                 recall_cc_data = cc_recall_datastore->data;
3726                 recall_cc_data->ignore = 1;
3727         }
3728         ast_channel_unlock(chan);
3729 }
3730
3731 static __attribute__((format(printf, 2, 3))) int cc_offer(const int core_id, const char * const debug, ...)
3732 {
3733         va_list ap;
3734         int res;
3735
3736         va_start(ap, debug);
3737         res = cc_request_state_change(CC_CALLER_OFFERED, core_id, debug, ap);
3738         va_end(ap);
3739         return res;
3740 }
3741
3742 int ast_cc_offer(struct ast_channel *caller_chan)
3743 {
3744         int core_id;
3745         int res = -1;
3746         struct ast_datastore *datastore;
3747         struct dialed_cc_interfaces *cc_interfaces;
3748         char cc_is_offerable;
3749
3750         ast_channel_lock(caller_chan);
3751         if (!(datastore = ast_channel_datastore_find(caller_chan, &dialed_cc_interfaces_info, NULL))) {
3752                 ast_channel_unlock(caller_chan);
3753                 return res;
3754         }
3755
3756         cc_interfaces = datastore->data;
3757         cc_is_offerable = cc_interfaces->is_original_caller;
3758         core_id = cc_interfaces->core_id;
3759         ast_channel_unlock(caller_chan);
3760
3761         if (cc_is_offerable) {
3762                 res = cc_offer(core_id, "CC offered to caller %s", ast_channel_name(caller_chan));
3763         }
3764         return res;
3765 }
3766
3767 int ast_cc_agent_accept_request(int core_id, const char * const debug, ...)
3768 {
3769         va_list ap;
3770         int res;
3771
3772         va_start(ap, debug);
3773         res = cc_request_state_change(CC_CALLER_REQUESTED, core_id, debug, ap);
3774         va_end(ap);
3775         return res;
3776 }
3777
3778 int ast_cc_monitor_request_acked(int core_id, const char * const debug, ...)
3779 {
3780         va_list ap;
3781         int res;
3782
3783         va_start(ap, debug);
3784         res = cc_request_state_change(CC_ACTIVE, core_id, debug, ap);
3785         va_end(ap);
3786         return res;
3787 }
3788
3789 int ast_cc_monitor_callee_available(const int core_id, const char * const debug, ...)
3790 {
3791         va_list ap;
3792         int res;
3793
3794         va_start(ap, debug);
3795         res = cc_request_state_change(CC_CALLEE_READY, core_id, debug, ap);
3796         va_end(ap);
3797         return res;
3798 }
3799
3800 int ast_cc_agent_caller_busy(int core_id, const char * debug, ...)
3801 {
3802         va_list ap;
3803         int res;
3804
3805         va_start(ap, debug);
3806         res = cc_request_state_change(CC_CALLER_BUSY, core_id, debug, ap);
3807         va_end(ap);
3808         return res;
3809 }
3810
3811 int ast_cc_agent_caller_available(int core_id, const char * const debug, ...)
3812 {
3813         va_list ap;
3814         int res;
3815
3816         va_start(ap, debug);
3817         res = cc_request_state_change(CC_ACTIVE, core_id, debug, ap);
3818         va_end(ap);
3819         return res;
3820 }
3821
3822 int ast_cc_agent_recalling(int core_id, const char * const debug, ...)
3823 {
3824         va_list ap;
3825         int res;
3826
3827         va_start(ap, debug);
3828         res = cc_request_state_change(CC_RECALLING, core_id, debug, ap);
3829         va_end(ap);
3830         return res;
3831 }
3832
3833 int ast_cc_completed(struct ast_channel *chan, const char * const debug, ...)
3834 {
3835         struct ast_datastore *recall_datastore;
3836         struct cc_recall_ds_data *recall_data;
3837         int core_id;
3838         va_list ap;
3839         int res;
3840
3841         ast_channel_lock(chan);
3842         if (!(recall_datastore = ast_channel_datastore_find(chan, &recall_ds_info, NULL))) {
3843                 /* Silly! Why did you call this function if there's no recall DS? */
3844                 ast_channel_unlock(chan);
3845                 return -1;
3846         }
3847         recall_data = recall_datastore->data;
3848         if (recall_data->nested || recall_data->ignore) {
3849                 /* If this is being called from a nested Dial, it is too
3850                  * early to determine if the recall has actually completed.
3851                  * The outermost dial is the only one with the authority to
3852                  * declare the recall to be complete.
3853                  *
3854                  * Similarly, if this function has been called when the
3855                  * recall has progressed beyond the first dial, this is not
3856                  * a legitimate time to declare the recall to be done. In fact,
3857                  * that should have been done already.
3858                  */
3859                 ast_channel_unlock(chan);
3860                 return -1;
3861         }
3862         core_id = recall_data->core_id;
3863         ast_channel_unlock(chan);
3864         va_start(ap, debug);
3865         res = cc_request_state_change(CC_COMPLETE, core_id, debug, ap);
3866         va_end(ap);
3867         return res;
3868 }
3869
3870 int ast_cc_failed(int core_id, const char * const debug, ...)
3871 {
3872         va_list ap;
3873         int res;
3874
3875         va_start(ap, debug);
3876         res = cc_request_state_change(CC_FAILED, core_id, debug, ap);
3877         va_end(ap);
3878         return res;
3879 }
3880
3881 struct ast_cc_monitor_failure_data {
3882         const char *device_name;
3883         char *debug;
3884         int core_id;
3885 };
3886
3887 static int cc_monitor_failed(void *data)
3888 {
3889         struct ast_cc_monitor_failure_data *failure_data = data;
3890         struct cc_core_instance *core_instance;
3891         struct ast_cc_monitor *monitor_iter;
3892
3893         core_instance = find_cc_core_instance(failure_data->core_id);
3894         if (!core_instance) {
3895                 /* Core instance no longer exists or invalid core_id. */
3896                 ast_log_dynamic_level(cc_logger_level,
3897                         "Core %d: Could not find core instance for device %s '%s'\n",
3898                         failure_data->core_id, failure_data->device_name, failure_data->debug);
3899                 ast_free((char *) failure_data->device_name);
3900                 ast_free((char *) failure_data->debug);
3901                 ast_free(failure_data);
3902                 return -1;
3903         }
3904
3905         AST_LIST_LOCK(core_instance->monitors);
3906         AST_LIST_TRAVERSE_SAFE_BEGIN(core_instance->monitors, monitor_iter, next) {
3907                 if (monitor_iter->interface->monitor_class == AST_CC_DEVICE_MONITOR) {
3908                         if (!strcmp(monitor_iter->interface->device_name, failure_data->device_name)) {
3909                                 AST_LIST_REMOVE_CURRENT(next);
3910                                 cc_extension_monitor_change_is_valid(core_instance, monitor_iter->parent_id,
3911                                                 monitor_iter->interface->device_name, 1);
3912                                 monitor_iter->callbacks->cancel_available_timer(monitor_iter, &monitor_iter->available_timer_id);
3913                                 cc_publish_monitorfailed(monitor_iter->core_id, monitor_iter->interface->device_name);
3914                                 cc_unref(monitor_iter, "Monitor reported failure. Unref list's reference.");
3915                         }
3916                 }
3917         }
3918         AST_LIST_TRAVERSE_SAFE_END;
3919
3920         if (!has_device_monitors(core_instance)) {
3921                 ast_cc_failed(core_instance->core_id, "All monitors have failed\n");
3922         }
3923         AST_LIST_UNLOCK(core_instance->monitors);
3924         cc_unref(core_instance, "Finished with core_instance in cc_monitor_failed\n");
3925
3926         ast_free((char *) failure_data->device_name);
3927         ast_free((char *) failure_data->debug);
3928         ast_free(failure_data);
3929         return 0;
3930 }
3931
3932 int ast_cc_monitor_failed(int core_id, const char *const monitor_name, const char * const debug, ...)
3933 {
3934         struct ast_cc_monitor_failure_data *failure_data;
3935         int res;
3936         va_list ap;
3937
3938         if (!(failure_data = ast_calloc(1, sizeof(*failure_data)))) {
3939                 return -1;
3940         }
3941
3942         if (!(failure_data->device_name = ast_strdup(monitor_name))) {
3943                 ast_free(failure_data);
3944                 return -1;
3945         }
3946
3947         va_start(ap, debug);
3948