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