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