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