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