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