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