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