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