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