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