res_stasis: Add ability to switch applications.
[asterisk/asterisk.git] / res / stasis / control.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * David M. Lee, II <dlee@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  *
21  * \brief Stasis application control support.
22  *
23  * \author David M. Lee, II <dlee@digium.com>
24  */
25
26 #include "asterisk.h"
27
28 #include "asterisk/stasis_channels.h"
29 #include "asterisk/stasis_app.h"
30
31 #include "command.h"
32 #include "control.h"
33 #include "app.h"
34 #include "asterisk/dial.h"
35 #include "asterisk/bridge.h"
36 #include "asterisk/bridge_after.h"
37 #include "asterisk/bridge_basic.h"
38 #include "asterisk/bridge_features.h"
39 #include "asterisk/frame.h"
40 #include "asterisk/pbx.h"
41 #include "asterisk/musiconhold.h"
42 #include "asterisk/app.h"
43
44 AST_LIST_HEAD(app_control_rules, stasis_app_control_rule);
45
46 /*!
47  * \brief Indicates if the Stasis app internals are being shut down
48  */
49 static int shutting_down;
50
51 struct stasis_app_control {
52         ast_cond_t wait_cond;
53         /*! Queue of commands to dispatch on the channel */
54         struct ao2_container *command_queue;
55         /*!
56          * The associated channel.
57          * Be very careful with the threading associated w/ manipulating
58          * the channel.
59          */
60         struct ast_channel *channel;
61         /*!
62          * When a channel is in a bridge, the bridge that it is in.
63          */
64         struct ast_bridge *bridge;
65         /*!
66          * Bridge features which should be applied to the channel when it enters the next bridge.  These only apply to the next bridge and will be emptied thereafter.
67          */
68         struct ast_bridge_features *bridge_features;
69         /*!
70          * Holding place for channel's PBX while imparted to a bridge.
71          */
72         struct ast_pbx *pbx;
73         /*!
74          * A list of rules to check before adding a channel to a bridge.
75          */
76         struct app_control_rules add_rules;
77         /*!
78          * A list of rules to check before removing a channel from a bridge.
79          */
80         struct app_control_rules remove_rules;
81         /*!
82          * Silence generator, when silence is being generated.
83          */
84         struct ast_silence_generator *silgen;
85         /*!
86          * The app for which this control is currently controlling.
87          * This can change through the use of the /channels/{channelId}/move
88          * command.
89          */
90         struct stasis_app *app;
91         /*!
92          * The name of the next Stasis application to move to.
93          */
94         char *next_app;
95         /*!
96          * The list of arguments to pass to StasisStart when moving to another app.
97          */
98         AST_VECTOR(, char *) next_app_args;
99         /*!
100          * When set, /c app_stasis should exit and continue in the dialplan.
101          */
102         int is_done:1;
103 };
104
105 static void control_dtor(void *obj)
106 {
107         struct stasis_app_control *control = obj;
108
109         ao2_cleanup(control->command_queue);
110
111         ast_channel_cleanup(control->channel);
112         ao2_cleanup(control->app);
113
114         control_move_cleanup(control);
115
116         ast_cond_destroy(&control->wait_cond);
117         AST_LIST_HEAD_DESTROY(&control->add_rules);
118         AST_LIST_HEAD_DESTROY(&control->remove_rules);
119         ast_bridge_features_destroy(control->bridge_features);
120
121 }
122
123 struct stasis_app_control *control_create(struct ast_channel *channel, struct stasis_app *app)
124 {
125         struct stasis_app_control *control;
126         int res;
127
128         control = ao2_alloc(sizeof(*control), control_dtor);
129         if (!control) {
130                 return NULL;
131         }
132
133         AST_LIST_HEAD_INIT(&control->add_rules);
134         AST_LIST_HEAD_INIT(&control->remove_rules);
135
136         res = ast_cond_init(&control->wait_cond, NULL);
137         if (res != 0) {
138                 ast_log(LOG_ERROR, "Error initializing ast_cond_t: %s\n",
139                         strerror(errno));
140                 ao2_ref(control, -1);
141                 return NULL;
142         }
143
144         control->app = ao2_bump(app);
145
146         ast_channel_ref(channel);
147         control->channel = channel;
148
149         control->command_queue = ao2_container_alloc_list(
150                 AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
151         if (!control->command_queue) {
152                 ao2_ref(control, -1);
153                 return NULL;
154         }
155
156         control->next_app = NULL;
157         AST_VECTOR_INIT(&control->next_app_args, 0);
158
159         return control;
160 }
161
162 static void app_control_register_rule(
163         struct stasis_app_control *control,
164         struct app_control_rules *list, struct stasis_app_control_rule *obj)
165 {
166         ao2_lock(control->command_queue);
167         AST_LIST_INSERT_TAIL(list, obj, next);
168         ao2_unlock(control->command_queue);
169 }
170
171 static void app_control_unregister_rule(
172         struct stasis_app_control *control,
173         struct app_control_rules *list, struct stasis_app_control_rule *obj)
174 {
175         struct stasis_app_control_rule *rule;
176
177         ao2_lock(control->command_queue);
178         AST_RWLIST_TRAVERSE_SAFE_BEGIN(list, rule, next) {
179                 if (rule == obj) {
180                         AST_RWLIST_REMOVE_CURRENT(next);
181                         break;
182                 }
183         }
184         AST_RWLIST_TRAVERSE_SAFE_END;
185         ao2_unlock(control->command_queue);
186 }
187
188 /*!
189  * \internal
190  * \brief Checks to make sure each rule in the given list passes.
191  *
192  * \details Loops over a list of rules checking for rejections or failures.
193  *          If one rule fails its resulting error code is returned.
194  *
195  * \note Command queue should be locked before calling this function.
196  *
197  * \param control The stasis application control
198  * \param list The list of rules to check
199  *
200  * \retval 0 if all rules pass
201  * \retval non-zero error code if a rule fails
202  */
203 static enum stasis_app_control_channel_result app_control_check_rules(
204         const struct stasis_app_control *control,
205         struct app_control_rules *list)
206 {
207         int res = 0;
208         struct stasis_app_control_rule *rule;
209         AST_LIST_TRAVERSE(list, rule, next) {
210                 if ((res = rule->check_rule(control))) {
211                         return res;
212                 }
213         }
214         return res;
215 }
216
217 void stasis_app_control_register_add_rule(
218         struct stasis_app_control *control,
219         struct stasis_app_control_rule *rule)
220 {
221         return app_control_register_rule(control, &control->add_rules, rule);
222 }
223
224 void stasis_app_control_unregister_add_rule(
225         struct stasis_app_control *control,
226         struct stasis_app_control_rule *rule)
227 {
228         app_control_unregister_rule(control, &control->add_rules, rule);
229 }
230
231 void stasis_app_control_register_remove_rule(
232         struct stasis_app_control *control,
233         struct stasis_app_control_rule *rule)
234 {
235         return app_control_register_rule(control, &control->remove_rules, rule);
236 }
237
238 void stasis_app_control_unregister_remove_rule(
239         struct stasis_app_control *control,
240         struct stasis_app_control_rule *rule)
241 {
242         app_control_unregister_rule(control, &control->remove_rules, rule);
243 }
244
245 static int app_control_can_add_channel_to_bridge(
246         struct stasis_app_control *control)
247 {
248         return app_control_check_rules(control, &control->add_rules);
249 }
250
251 static int app_control_can_remove_channel_from_bridge(
252         struct stasis_app_control *control)
253 {
254         return app_control_check_rules(control, &control->remove_rules);
255 }
256
257 static int noop_cb(struct stasis_app_control *control,
258         struct ast_channel *chan, void *data)
259 {
260         return 0;
261 }
262
263 /*! Callback type to see if the command can execute
264     note: command_queue is locked during callback */
265 typedef int (*app_command_can_exec_cb)(struct stasis_app_control *control);
266
267 static struct stasis_app_command *exec_command_on_condition(
268         struct stasis_app_control *control, stasis_app_command_cb command_fn,
269         void *data, command_data_destructor_fn data_destructor,
270         app_command_can_exec_cb can_exec_fn)
271 {
272         int retval;
273         struct stasis_app_command *command;
274
275         command_fn = command_fn ? : noop_cb;
276
277         command = command_create(command_fn, data, data_destructor);
278         if (!command) {
279                 return NULL;
280         }
281
282         ao2_lock(control->command_queue);
283         if (control->is_done) {
284                 ao2_unlock(control->command_queue);
285                 ao2_ref(command, -1);
286                 return NULL;
287         }
288         if (can_exec_fn && (retval = can_exec_fn(control))) {
289                 ao2_unlock(control->command_queue);
290                 command_complete(command, retval);
291                 return command;
292         }
293
294         ao2_link_flags(control->command_queue, command, OBJ_NOLOCK);
295         ast_cond_signal(&control->wait_cond);
296         ao2_unlock(control->command_queue);
297
298         return command;
299 }
300
301 static struct stasis_app_command *exec_command(
302         struct stasis_app_control *control, stasis_app_command_cb command_fn,
303         void *data, command_data_destructor_fn data_destructor)
304 {
305         return exec_command_on_condition(control, command_fn, data, data_destructor, NULL);
306 }
307
308 static int app_control_add_role(struct stasis_app_control *control,
309                 struct ast_channel *chan, void *data)
310 {
311         char *role = data;
312
313         return ast_channel_add_bridge_role(chan, role);
314 }
315
316 int stasis_app_control_add_role(struct stasis_app_control *control, const char *role)
317 {
318         char *role_dup;
319
320         role_dup = ast_strdup(role);
321         if (!role_dup) {
322                 return -1;
323         }
324
325         stasis_app_send_command_async(control, app_control_add_role, role_dup, ast_free_ptr);
326
327         return 0;
328 }
329
330 static int app_control_clear_roles(struct stasis_app_control *control,
331                 struct ast_channel *chan, void *data)
332 {
333         ast_channel_clear_bridge_roles(chan);
334
335         return 0;
336 }
337
338 void stasis_app_control_clear_roles(struct stasis_app_control *control)
339 {
340         stasis_app_send_command_async(control, app_control_clear_roles, NULL, NULL);
341 }
342
343 int control_command_count(struct stasis_app_control *control)
344 {
345         return ao2_container_count(control->command_queue);
346 }
347
348 int control_is_done(struct stasis_app_control *control)
349 {
350         /* Called from stasis_app_exec thread; no lock needed */
351         return control->is_done;
352 }
353
354 void control_mark_done(struct stasis_app_control *control)
355 {
356         /* Locking necessary to sync with other threads adding commands to the queue. */
357         ao2_lock(control->command_queue);
358         control->is_done = 1;
359         ao2_unlock(control->command_queue);
360 }
361
362 struct stasis_app_control_continue_data {
363         char context[AST_MAX_CONTEXT];
364         char extension[AST_MAX_EXTENSION];
365         int priority;
366 };
367
368 static int app_control_continue(struct stasis_app_control *control,
369         struct ast_channel *chan, void *data)
370 {
371         struct stasis_app_control_continue_data *continue_data = data;
372
373         ast_assert(control->channel != NULL);
374
375         /* If we're in a Stasis bridge, depart it before going back to the
376          * dialplan */
377         if (stasis_app_get_bridge(control)) {
378                 ast_bridge_depart(control->channel);
379         }
380
381         /* Called from stasis_app_exec thread; no lock needed */
382         ast_explicit_goto(control->channel, continue_data->context, continue_data->extension, continue_data->priority);
383
384         control_mark_done(control);
385
386         return 0;
387 }
388
389 int stasis_app_control_continue(struct stasis_app_control *control, const char *context, const char *extension, int priority)
390 {
391         struct stasis_app_control_continue_data *continue_data;
392
393         if (!(continue_data = ast_calloc(1, sizeof(*continue_data)))) {
394                 return -1;
395         }
396         ast_copy_string(continue_data->context, S_OR(context, ""), sizeof(continue_data->context));
397         ast_copy_string(continue_data->extension, S_OR(extension, ""), sizeof(continue_data->extension));
398         if (priority > 0) {
399                 continue_data->priority = priority;
400         } else {
401                 continue_data->priority = -1;
402         }
403
404         stasis_app_send_command_async(control, app_control_continue, continue_data, ast_free_ptr);
405
406         return 0;
407 }
408
409 struct stasis_app_control_move_data {
410         char *app_name;
411         char *app_args;
412 };
413
414 static int app_control_move(struct stasis_app_control *control,
415         struct ast_channel *chan, void *data)
416 {
417         struct stasis_app_control_move_data *move_data = data;
418
419         control->next_app = ast_strdup(move_data->app_name);
420         if (!control->next_app) {
421                 ast_log(LOG_ERROR, "Allocation failed for next app\n");
422                 return -1;
423         }
424
425         if (move_data->app_args) {
426                 char *token;
427
428                 while ((token = strtok_r(move_data->app_args, ",", &move_data->app_args))) {
429                         int res;
430                         char *arg;
431
432                         if (!(arg = ast_strdup(token))) {
433                                 ast_log(LOG_ERROR, "Allocation failed for next app arg\n");
434                                 control_move_cleanup(control);
435                                 return -1;
436                         }
437
438                         res = AST_VECTOR_APPEND(&control->next_app_args, arg);
439                         if (res) {
440                                 ast_log(LOG_ERROR, "Failed to append arg to next app args\n");
441                                 ast_free(arg);
442                                 control_move_cleanup(control);
443                                 return -1;
444                         }
445                 }
446         }
447
448         return 0;
449 }
450
451 int stasis_app_control_move(struct stasis_app_control *control, const char *app_name, const char *app_args)
452 {
453         struct stasis_app_control_move_data *move_data;
454         size_t size;
455
456         size = sizeof(*move_data) + strlen(app_name) + strlen(app_args) + 2;
457         if (!(move_data = ast_calloc(1, size))) {
458                 return -1;
459         }
460
461         move_data->app_name = (char *)move_data + sizeof(*move_data);
462         move_data->app_args = move_data->app_name + strlen(app_name) + 1;
463
464         strcpy(move_data->app_name, app_name); /* Safe */
465         if (app_args) {
466                 strcpy(move_data->app_args, app_args); /* Safe */
467         } else {
468                 move_data->app_args = NULL;
469         }
470
471         stasis_app_send_command_async(control, app_control_move, move_data, ast_free_ptr);
472
473         return 0;
474 }
475
476 static int app_control_redirect(struct stasis_app_control *control,
477         struct ast_channel *chan, void *data)
478 {
479         char *endpoint = data;
480         int res;
481
482         ast_assert(control->channel != NULL);
483         ast_assert(endpoint != NULL);
484
485         res = ast_transfer(control->channel, endpoint);
486         if (!res) {
487                 ast_log(LOG_NOTICE, "Unsupported transfer requested on channel '%s'\n",
488                         ast_channel_name(control->channel));
489                 return 0;
490         }
491
492         return 0;
493 }
494
495 int stasis_app_control_redirect(struct stasis_app_control *control, const char *endpoint)
496 {
497         char *endpoint_data = ast_strdup(endpoint);
498
499         if (!endpoint_data) {
500                 return -1;
501         }
502
503         stasis_app_send_command_async(control, app_control_redirect, endpoint_data, ast_free_ptr);
504
505         return 0;
506 }
507
508 struct stasis_app_control_dtmf_data {
509         int before;
510         int between;
511         unsigned int duration;
512         int after;
513         char dtmf[];
514 };
515
516 static void dtmf_in_bridge(struct ast_channel *chan, struct stasis_app_control_dtmf_data *dtmf_data)
517 {
518         if (dtmf_data->before) {
519                 usleep(dtmf_data->before * 1000);
520         }
521
522         ast_dtmf_stream_external(chan, dtmf_data->dtmf, dtmf_data->between, dtmf_data->duration);
523
524         if (dtmf_data->after) {
525                 usleep(dtmf_data->after * 1000);
526         }
527 }
528
529 static void dtmf_no_bridge(struct ast_channel *chan, struct stasis_app_control_dtmf_data *dtmf_data)
530 {
531         if (dtmf_data->before) {
532                 ast_safe_sleep(chan, dtmf_data->before);
533         }
534
535         ast_dtmf_stream(chan, NULL, dtmf_data->dtmf, dtmf_data->between, dtmf_data->duration);
536
537         if (dtmf_data->after) {
538                 ast_safe_sleep(chan, dtmf_data->after);
539         }
540 }
541
542 static int app_control_dtmf(struct stasis_app_control *control,
543         struct ast_channel *chan, void *data)
544 {
545         struct stasis_app_control_dtmf_data *dtmf_data = data;
546
547         if (ast_channel_state(chan) != AST_STATE_UP) {
548                 ast_indicate(chan, AST_CONTROL_PROGRESS);
549         }
550
551         if (stasis_app_get_bridge(control)) {
552                 dtmf_in_bridge(chan, dtmf_data);
553         } else {
554                 dtmf_no_bridge(chan, dtmf_data);
555         }
556
557         return 0;
558 }
559
560 int stasis_app_control_dtmf(struct stasis_app_control *control, const char *dtmf, int before, int between, unsigned int duration, int after)
561 {
562         struct stasis_app_control_dtmf_data *dtmf_data;
563
564         if (!(dtmf_data = ast_calloc(1, sizeof(*dtmf_data) + strlen(dtmf) + 1))) {
565                 return -1;
566         }
567
568         dtmf_data->before = before;
569         dtmf_data->between = between;
570         dtmf_data->duration = duration;
571         dtmf_data->after = after;
572         strcpy(dtmf_data->dtmf, dtmf);
573
574         stasis_app_send_command_async(control, app_control_dtmf, dtmf_data, ast_free_ptr);
575
576         return 0;
577 }
578
579 static int app_control_ring(struct stasis_app_control *control,
580         struct ast_channel *chan, void *data)
581 {
582         ast_indicate(control->channel, AST_CONTROL_RINGING);
583
584         return 0;
585 }
586
587 int stasis_app_control_ring(struct stasis_app_control *control)
588 {
589         stasis_app_send_command_async(control, app_control_ring, NULL, NULL);
590
591         return 0;
592 }
593
594 static int app_control_ring_stop(struct stasis_app_control *control,
595         struct ast_channel *chan, void *data)
596 {
597         ast_indicate(control->channel, -1);
598
599         return 0;
600 }
601
602 int stasis_app_control_ring_stop(struct stasis_app_control *control)
603 {
604         stasis_app_send_command_async(control, app_control_ring_stop, NULL, NULL);
605
606         return 0;
607 }
608
609 struct stasis_app_control_mute_data {
610         enum ast_frame_type frametype;
611         unsigned int direction;
612 };
613
614 static int app_control_mute(struct stasis_app_control *control,
615         struct ast_channel *chan, void *data)
616 {
617         struct stasis_app_control_mute_data *mute_data = data;
618
619         ast_channel_lock(chan);
620         ast_channel_suppress(control->channel, mute_data->direction, mute_data->frametype);
621         ast_channel_unlock(chan);
622
623         return 0;
624 }
625
626 int stasis_app_control_mute(struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
627 {
628         struct stasis_app_control_mute_data *mute_data;
629
630         if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
631                 return -1;
632         }
633
634         mute_data->direction = direction;
635         mute_data->frametype = frametype;
636
637         stasis_app_send_command_async(control, app_control_mute, mute_data, ast_free_ptr);
638
639         return 0;
640 }
641
642 static int app_control_unmute(struct stasis_app_control *control,
643         struct ast_channel *chan, void *data)
644 {
645         struct stasis_app_control_mute_data *mute_data = data;
646
647         ast_channel_lock(chan);
648         ast_channel_unsuppress(control->channel, mute_data->direction, mute_data->frametype);
649         ast_channel_unlock(chan);
650
651         return 0;
652 }
653
654 int stasis_app_control_unmute(struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
655 {
656         struct stasis_app_control_mute_data *mute_data;
657
658         if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
659                 return -1;
660         }
661
662         mute_data->direction = direction;
663         mute_data->frametype = frametype;
664
665         stasis_app_send_command_async(control, app_control_unmute, mute_data, ast_free_ptr);
666
667         return 0;
668 }
669
670 /*!
671  * \brief structure for queuing ARI channel variable setting
672  *
673  * It may seem weird to define this custom structure given that we already have
674  * ast_var_t and ast_variable defined elsewhere. The problem with those is that
675  * they are not tolerant of NULL channel variable value pointers. In fact, in both
676  * cases, the best they could do is to have a zero-length variable value. However,
677  * when un-setting a channel variable, it is important to pass a NULL value, not
678  * a zero-length string.
679  */
680 struct chanvar {
681         /*! Name of variable to set/unset */
682         char *name;
683         /*! Value of variable to set. If unsetting, this will be NULL */
684         char *value;
685 };
686
687 static void free_chanvar(void *data)
688 {
689         struct chanvar *var = data;
690
691         ast_free(var->name);
692         ast_free(var->value);
693         ast_free(var);
694 }
695
696 static int app_control_set_channel_var(struct stasis_app_control *control,
697         struct ast_channel *chan, void *data)
698 {
699         struct chanvar *var = data;
700
701         pbx_builtin_setvar_helper(control->channel, var->name, var->value);
702
703         return 0;
704 }
705
706 int stasis_app_control_set_channel_var(struct stasis_app_control *control, const char *variable, const char *value)
707 {
708         struct chanvar *var;
709
710         var = ast_calloc(1, sizeof(*var));
711         if (!var) {
712                 return -1;
713         }
714
715         var->name = ast_strdup(variable);
716         if (!var->name) {
717                 free_chanvar(var);
718                 return -1;
719         }
720
721         /* It's kosher for value to be NULL. It means the variable is being unset */
722         if (value) {
723                 var->value = ast_strdup(value);
724                 if (!var->value) {
725                         free_chanvar(var);
726                         return -1;
727                 }
728         }
729
730         stasis_app_send_command_async(control, app_control_set_channel_var, var, free_chanvar);
731
732         return 0;
733 }
734
735 static int app_control_hold(struct stasis_app_control *control,
736         struct ast_channel *chan, void *data)
737 {
738         ast_indicate(control->channel, AST_CONTROL_HOLD);
739
740         return 0;
741 }
742
743 void stasis_app_control_hold(struct stasis_app_control *control)
744 {
745         stasis_app_send_command_async(control, app_control_hold, NULL, NULL);
746 }
747
748 static int app_control_unhold(struct stasis_app_control *control,
749         struct ast_channel *chan, void *data)
750 {
751         ast_indicate(control->channel, AST_CONTROL_UNHOLD);
752
753         return 0;
754 }
755
756 void stasis_app_control_unhold(struct stasis_app_control *control)
757 {
758         stasis_app_send_command_async(control, app_control_unhold, NULL, NULL);
759 }
760
761 static int app_control_moh_start(struct stasis_app_control *control,
762         struct ast_channel *chan, void *data)
763 {
764         char *moh_class = data;
765
766         if (ast_channel_state(chan) != AST_STATE_UP) {
767                 ast_indicate(chan, AST_CONTROL_PROGRESS);
768         }
769
770         ast_moh_start(chan, moh_class, NULL);
771
772         return 0;
773 }
774
775 void stasis_app_control_moh_start(struct stasis_app_control *control, const char *moh_class)
776 {
777         char *data = NULL;
778
779         if (!ast_strlen_zero(moh_class)) {
780                 data = ast_strdup(moh_class);
781         }
782
783         stasis_app_send_command_async(control, app_control_moh_start, data, ast_free_ptr);
784 }
785
786 static int app_control_moh_stop(struct stasis_app_control *control,
787         struct ast_channel *chan, void *data)
788 {
789         ast_moh_stop(chan);
790         return 0;
791 }
792
793 void stasis_app_control_moh_stop(struct stasis_app_control *control)
794 {
795         stasis_app_send_command_async(control, app_control_moh_stop, NULL, NULL);
796 }
797
798 static int app_control_silence_start(struct stasis_app_control *control,
799         struct ast_channel *chan, void *data)
800 {
801         if (ast_channel_state(chan) != AST_STATE_UP) {
802                 ast_indicate(chan, AST_CONTROL_PROGRESS);
803         }
804
805         if (control->silgen) {
806                 /* We have a silence generator, but it may have been implicitly
807                  * disabled by media actions (music on hold, playing media,
808                  * etc.) Just stop it and restart a new one.
809                  */
810                 ast_channel_stop_silence_generator(
811                         control->channel, control->silgen);
812         }
813
814         ast_debug(3, "%s: Starting silence generator\n",
815                 stasis_app_control_get_channel_id(control));
816         control->silgen = ast_channel_start_silence_generator(control->channel);
817
818         if (!control->silgen) {
819                 ast_log(LOG_WARNING,
820                         "%s: Failed to start silence generator.\n",
821                         stasis_app_control_get_channel_id(control));
822         }
823
824         return 0;
825 }
826
827 void stasis_app_control_silence_start(struct stasis_app_control *control)
828 {
829         stasis_app_send_command_async(control, app_control_silence_start, NULL, NULL);
830 }
831
832 void control_silence_stop_now(struct stasis_app_control *control)
833 {
834         if (control->silgen) {
835                 ast_debug(3, "%s: Stopping silence generator\n",
836                         stasis_app_control_get_channel_id(control));
837                 ast_channel_stop_silence_generator(
838                         control->channel, control->silgen);
839                 control->silgen = NULL;
840         }
841 }
842
843 static int app_control_silence_stop(struct stasis_app_control *control,
844         struct ast_channel *chan, void *data)
845 {
846         control_silence_stop_now(control);
847         return 0;
848 }
849
850 void stasis_app_control_silence_stop(struct stasis_app_control *control)
851 {
852         stasis_app_send_command_async(control, app_control_silence_stop, NULL, NULL);
853 }
854
855 struct ast_channel_snapshot *stasis_app_control_get_snapshot(
856         const struct stasis_app_control *control)
857 {
858         return ast_channel_snapshot_get_latest(stasis_app_control_get_channel_id(control));
859 }
860
861 static int app_send_command_on_condition(struct stasis_app_control *control,
862                                          stasis_app_command_cb command_fn, void *data,
863                                          command_data_destructor_fn data_destructor,
864                                          app_command_can_exec_cb can_exec_fn)
865 {
866         int ret;
867         struct stasis_app_command *command;
868
869         if (control == NULL || control->is_done) {
870                 /* If exec_command_on_condition fails, it calls the data_destructor.
871                  * In order to provide consistent behavior, we'll also call the data_destructor
872                  * on this error path. This way, callers never have to call the
873                  * data_destructor themselves.
874                  */
875                 if (data_destructor) {
876                         data_destructor(data);
877                 }
878                 return -1;
879         }
880
881         command = exec_command_on_condition(
882                 control, command_fn, data, data_destructor, can_exec_fn);
883         if (!command) {
884                 return -1;
885         }
886
887         ret = command_join(command);
888         ao2_ref(command, -1);
889
890         return ret;
891 }
892
893 int stasis_app_send_command(struct stasis_app_control *control,
894         stasis_app_command_cb command_fn, void *data, command_data_destructor_fn data_destructor)
895 {
896         return app_send_command_on_condition(control, command_fn, data, data_destructor, NULL);
897 }
898
899 int stasis_app_send_command_async(struct stasis_app_control *control,
900         stasis_app_command_cb command_fn, void *data,
901         command_data_destructor_fn data_destructor)
902 {
903         struct stasis_app_command *command;
904
905         if (control == NULL || control->is_done) {
906                 /* If exec_command fails, it calls the data_destructor. In order to
907                  * provide consistent behavior, we'll also call the data_destructor
908                  * on this error path. This way, callers never have to call the
909                  * data_destructor themselves.
910                  */
911                 if (data_destructor) {
912                         data_destructor(data);
913                 }
914                 return -1;
915         }
916
917         command = exec_command(control, command_fn, data, data_destructor);
918         if (!command) {
919                 return -1;
920         }
921         ao2_ref(command, -1);
922
923         return 0;
924 }
925
926 struct ast_bridge *stasis_app_get_bridge(struct stasis_app_control *control)
927 {
928         struct ast_bridge *ret;
929
930         if (!control) {
931                 return NULL;
932         }
933
934         ao2_lock(control);
935         ret = control->bridge;
936         ao2_unlock(control);
937
938         return ret;
939 }
940
941 /*!
942  * \brief Singleton dial bridge
943  *
944  * The dial bridge is a holding bridge used to hold all
945  * outbound dialed channels that are not in any "real" ARI-created
946  * bridge. The dial bridge is invisible, meaning that it does not
947  * show up in channel snapshots, AMI or ARI output, and no events
948  * get raised for it.
949  *
950  * This is used to keep dialed channels confined to the bridging system
951  * and unify the threading model used for dialing outbound channels.
952  */
953 static struct ast_bridge *dial_bridge;
954 AST_MUTEX_DEFINE_STATIC(dial_bridge_lock);
955
956 /*!
957  * \brief Retrieve a reference to the dial bridge.
958  *
959  * If the dial bridge has not been created yet, it will
960  * be created, otherwise, a reference to the existing bridge
961  * will be returned.
962  *
963  * The caller will need to unreference the dial bridge once
964  * they are finished with it.
965  *
966  * \retval NULL Unable to find/create the dial bridge
967  * \retval non-NULL A reference to the dial bridge
968  */
969 static struct ast_bridge *get_dial_bridge(void)
970 {
971         struct ast_bridge *ret_bridge = NULL;
972
973         ast_mutex_lock(&dial_bridge_lock);
974
975         if (shutting_down) {
976                 goto end;
977         }
978
979         if (dial_bridge) {
980                 ret_bridge = ao2_bump(dial_bridge);
981                 goto end;
982         }
983
984         dial_bridge = stasis_app_bridge_create_invisible("holding", "dial_bridge", NULL);
985         if (!dial_bridge) {
986                 goto end;
987         }
988         ret_bridge = ao2_bump(dial_bridge);
989
990 end:
991         ast_mutex_unlock(&dial_bridge_lock);
992         return ret_bridge;
993 }
994
995 static int bridge_channel_depart(struct stasis_app_control *control,
996         struct ast_channel *chan, void *data);
997
998 /*!
999  * \brief after bridge callback for the dial bridge
1000  *
1001  * The only purpose of this callback is to ensure that the control structure's
1002  * bridge pointer is NULLed
1003  */
1004 static void dial_bridge_after_cb(struct ast_channel *chan, void *data)
1005 {
1006         struct stasis_app_control *control = data;
1007         struct ast_bridge_channel *bridge_channel;
1008
1009         ast_channel_lock(chan);
1010         bridge_channel = ast_channel_get_bridge_channel(chan);
1011         ast_channel_unlock(chan);
1012
1013         ast_debug(3, "Channel: <%s>  Reason: %d\n", ast_channel_name(control->channel), ast_channel_hangupcause(chan));
1014
1015         stasis_app_send_command_async(control, bridge_channel_depart, bridge_channel, __ao2_cleanup);
1016
1017         control->bridge = NULL;
1018 }
1019
1020 static void dial_bridge_after_cb_failed(enum ast_bridge_after_cb_reason reason, void *data)
1021 {
1022         struct stasis_app_control *control = data;
1023
1024         ast_debug(3, "Channel: <%s>  Reason: %d\n", ast_channel_name(control->channel), reason);
1025         dial_bridge_after_cb(control->channel, data);
1026 }
1027
1028 /*!
1029  * \brief Add a channel to the singleton dial bridge.
1030  *
1031  * \param control The Stasis control structure
1032  * \param chan The channel to add to the bridge
1033  * \retval -1 Failed
1034  * \retval 0 Success
1035  */
1036 static int add_to_dial_bridge(struct stasis_app_control *control, struct ast_channel *chan)
1037 {
1038         struct ast_bridge *bridge;
1039
1040         bridge = get_dial_bridge();
1041         if (!bridge) {
1042                 return -1;
1043         }
1044
1045         control->bridge = bridge;
1046         ast_bridge_set_after_callback(chan, dial_bridge_after_cb, dial_bridge_after_cb_failed, control);
1047         if (ast_bridge_impart(bridge, chan, NULL, NULL, AST_BRIDGE_IMPART_CHAN_DEPARTABLE)) {
1048                 control->bridge = NULL;
1049                 ao2_ref(bridge, -1);
1050                 return -1;
1051         }
1052
1053         ao2_ref(bridge, -1);
1054
1055         return 0;
1056 }
1057
1058 /*!
1059  * \brief Depart a channel from a bridge, and potentially add it back to the dial bridge
1060  *
1061  * \param control Take a guess
1062  * \param chan Take another guess
1063  */
1064 static int depart_channel(struct stasis_app_control *control, struct ast_channel *chan)
1065 {
1066         ast_bridge_depart(chan);
1067
1068         if (!ast_check_hangup(chan) && ast_channel_state(chan) != AST_STATE_UP) {
1069                 /* Channel is still being dialed, so put it back in the dialing bridge */
1070                 add_to_dial_bridge(control, chan);
1071         }
1072
1073         return 0;
1074 }
1075
1076 static int bridge_channel_depart(struct stasis_app_control *control,
1077         struct ast_channel *chan, void *data)
1078 {
1079         struct ast_bridge_channel *bridge_channel;
1080
1081         ast_channel_lock(chan);
1082         bridge_channel = ast_channel_internal_bridge_channel(chan);
1083         ast_channel_unlock(chan);
1084
1085         if (bridge_channel != data) {
1086                 ast_debug(3, "%s: Channel is no longer in departable state\n",
1087                         ast_channel_uniqueid(chan));
1088                 return -1;
1089         }
1090
1091         ast_debug(3, "%s: Channel departing bridge\n",
1092                 ast_channel_uniqueid(chan));
1093
1094         depart_channel(control, chan);
1095
1096         return 0;
1097 }
1098
1099 static void internal_bridge_after_cb(struct ast_channel *chan, void *data,
1100         enum ast_bridge_after_cb_reason reason)
1101 {
1102         struct stasis_app_control *control = data;
1103         struct ast_bridge_channel *bridge_channel;
1104
1105         ao2_lock(control);
1106         ast_debug(3, "%s, %s: %s\n",
1107                 ast_channel_uniqueid(chan), control->bridge ? control->bridge->uniqueid : "unknown",
1108                         ast_bridge_after_cb_reason_string(reason));
1109
1110         if (reason == AST_BRIDGE_AFTER_CB_REASON_IMPART_FAILED) {
1111                 /* The impart actually failed so control->bridge isn't valid. */
1112                 control->bridge = NULL;
1113         }
1114
1115         ast_assert(chan == control->channel);
1116
1117         /* Restore the channel's PBX */
1118         ast_channel_pbx_set(control->channel, control->pbx);
1119         control->pbx = NULL;
1120
1121         if (control->bridge) {
1122                 app_unsubscribe_bridge(control->app, control->bridge);
1123
1124                 /* No longer in the bridge */
1125                 control->bridge = NULL;
1126
1127                 /* Get the bridge channel so we don't depart from the wrong bridge */
1128                 ast_channel_lock(chan);
1129                 bridge_channel = ast_channel_get_bridge_channel(chan);
1130                 ast_channel_unlock(chan);
1131
1132                 /* Depart this channel from the bridge using the command queue if possible */
1133                 stasis_app_send_command_async(control, bridge_channel_depart, bridge_channel, __ao2_cleanup);
1134         }
1135
1136         if (stasis_app_channel_is_stasis_end_published(chan)) {
1137                 /* The channel has had a StasisEnd published on it, but until now had remained in
1138                  * the bridging system. This means that the channel moved from a Stasis bridge to a
1139                  * non-Stasis bridge and is now exiting the bridging system. Because of this, the
1140                  * channel needs to exit the Stasis application and go to wherever the non-Stasis
1141                  * bridge has directed it to go. If the non-Stasis bridge has not set up an after
1142                  * bridge destination, then the channel should be hung up.
1143                  */
1144                 int hangup_flag;
1145
1146                 hangup_flag = ast_bridge_setup_after_goto(chan) ? AST_SOFTHANGUP_DEV : AST_SOFTHANGUP_ASYNCGOTO;
1147                 ast_channel_lock(chan);
1148                 ast_softhangup_nolock(chan, hangup_flag);
1149                 ast_channel_unlock(chan);
1150         }
1151         ao2_unlock(control);
1152 }
1153
1154 static void bridge_after_cb(struct ast_channel *chan, void *data)
1155 {
1156         struct stasis_app_control *control = data;
1157
1158         internal_bridge_after_cb(control->channel, data, AST_BRIDGE_AFTER_CB_REASON_DEPART);
1159 }
1160
1161 static void bridge_after_cb_failed(enum ast_bridge_after_cb_reason reason,
1162         void *data)
1163 {
1164         struct stasis_app_control *control = data;
1165
1166         internal_bridge_after_cb(control->channel, data, reason);
1167
1168         ast_debug(3, "  reason: %s\n",
1169                 ast_bridge_after_cb_reason_string(reason));
1170 }
1171
1172 /*!
1173  * \brief Dial timeout datastore
1174  *
1175  * A datastore is used because a channel may change
1176  * bridges during the course of a dial attempt. This
1177  * may be because the channel changes from the dial bridge
1178  * to a standard bridge, or it may move between standard
1179  * bridges. In order to keep the dial timeout, we need
1180  * to keep the timeout information local to the channel.
1181  * That is what this datastore is for
1182  */
1183 struct ast_datastore_info timeout_datastore = {
1184         .type = "ARI dial timeout",
1185 };
1186
1187 static int hangup_channel(struct stasis_app_control *control,
1188         struct ast_channel *chan, void *data)
1189 {
1190         ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
1191         return 0;
1192 }
1193
1194 /*!
1195  * \brief Dial timeout
1196  *
1197  * This is a bridge interval hook callback. The interval hook triggering
1198  * means that the dial timeout has been reached. If the channel has not
1199  * been answered by the time this callback is called, then the channel
1200  * is hung up
1201  *
1202  * \param bridge_channel Bridge channel on which interval hook has been called
1203  * \param ignore Ignored
1204  * \return -1 (i.e. remove the interval hook)
1205  */
1206 static int bridge_timeout(struct ast_bridge_channel *bridge_channel, void *ignore)
1207 {
1208         struct ast_datastore *datastore;
1209         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
1210
1211         control = stasis_app_control_find_by_channel(bridge_channel->chan);
1212
1213         ast_channel_lock(bridge_channel->chan);
1214         if (ast_channel_state(bridge_channel->chan) != AST_STATE_UP) {
1215                 /* Don't bother removing the datastore because it will happen when the channel is hung up */
1216                 ast_channel_unlock(bridge_channel->chan);
1217                 stasis_app_send_command_async(control, hangup_channel, NULL, NULL);
1218                 return -1;
1219         }
1220
1221         datastore = ast_channel_datastore_find(bridge_channel->chan, &timeout_datastore, NULL);
1222         if (!datastore) {
1223                 ast_channel_unlock(bridge_channel->chan);
1224                 return -1;
1225         }
1226         ast_channel_datastore_remove(bridge_channel->chan, datastore);
1227         ast_channel_unlock(bridge_channel->chan);
1228         ast_datastore_free(datastore);
1229
1230         return -1;
1231 }
1232
1233 /*!
1234  * \brief Set a dial timeout interval hook on the channel.
1235  *
1236  * The absolute time that the timeout should occur is stored on
1237  * a datastore on the channel. This time is converted into a relative
1238  * number of milliseconds in the future. Then an interval hook is set
1239  * to trigger in that number of milliseconds.
1240  *
1241  * \pre chan is locked
1242  *
1243  * \param chan The channel on which to set the interval hook
1244  */
1245 static void set_interval_hook(struct ast_channel *chan)
1246 {
1247         struct ast_datastore *datastore;
1248         struct timeval *hangup_time;
1249         int64_t ms;
1250         struct ast_bridge_channel *bridge_channel;
1251
1252         datastore = ast_channel_datastore_find(chan, &timeout_datastore, NULL);
1253         if (!datastore) {
1254                 return;
1255         }
1256
1257         hangup_time = datastore->data;
1258
1259         ms = ast_tvdiff_ms(*hangup_time, ast_tvnow());
1260         bridge_channel = ast_channel_get_bridge_channel(chan);
1261         if (!bridge_channel) {
1262                 return;
1263         }
1264
1265         if (ast_bridge_interval_hook(bridge_channel->features, 0, ms > 0 ? ms : 1,
1266                         bridge_timeout, NULL, NULL, 0)) {
1267                 ao2_ref(bridge_channel, -1);
1268                 return;
1269         }
1270
1271         ast_queue_frame(bridge_channel->chan, &ast_null_frame);
1272         ao2_ref(bridge_channel, -1);
1273 }
1274
1275 int control_swap_channel_in_bridge(struct stasis_app_control *control, struct ast_bridge *bridge, struct ast_channel *chan, struct ast_channel *swap)
1276 {
1277         int res;
1278         struct ast_bridge_features *features;
1279
1280         if (!control || !bridge) {
1281                 return -1;
1282         }
1283
1284         ast_debug(3, "%s: Adding to bridge %s\n",
1285                 stasis_app_control_get_channel_id(control),
1286                 bridge->uniqueid);
1287
1288         ast_assert(chan != NULL);
1289
1290         /* Depart whatever Stasis bridge we're currently in. */
1291         if (stasis_app_get_bridge(control)) {
1292                 /* Note that it looks like there's a race condition here, since
1293                  * we don't have control locked. But this happens from the
1294                  * control callback thread, so there won't be any other
1295                  * concurrent attempts to bridge.
1296                  */
1297                 ast_bridge_depart(chan);
1298         }
1299
1300
1301         res = ast_bridge_set_after_callback(chan, bridge_after_cb,
1302                 bridge_after_cb_failed, control);
1303         if (res != 0) {
1304                 ast_log(LOG_ERROR, "Error setting after-bridge callback\n");
1305                 return -1;
1306         }
1307
1308         ao2_lock(control);
1309
1310         /* Ensure the controlling application is subscribed early enough
1311          * to receive the ChannelEnteredBridge message. This works in concert
1312          * with the subscription handled in the Stasis application execution
1313          * loop */
1314         app_subscribe_bridge(control->app, bridge);
1315
1316         /* Save off the channel's PBX */
1317         ast_assert(control->pbx == NULL);
1318         if (!control->pbx) {
1319                 control->pbx = ast_channel_pbx(chan);
1320                 ast_channel_pbx_set(chan, NULL);
1321         }
1322
1323         /* Pull bridge features from the control */
1324         features = control->bridge_features;
1325         control->bridge_features = NULL;
1326
1327         ast_assert(stasis_app_get_bridge(control) == NULL);
1328         /* We need to set control->bridge here since bridge_after_cb may be run
1329          * before ast_bridge_impart returns.  bridge_after_cb gets a reason
1330          * code so it can tell if the bridge is actually valid or not.
1331          */
1332         control->bridge = bridge;
1333
1334         /* We can't be holding the control lock while impart is running
1335          * or we could create a deadlock with bridge_after_cb which also
1336          * tries to lock control.
1337          */
1338         ao2_unlock(control);
1339         res = ast_bridge_impart(bridge,
1340                 chan,
1341                 swap,
1342                 features, /* features */
1343                 AST_BRIDGE_IMPART_CHAN_DEPARTABLE);
1344         if (res != 0) {
1345                 /* ast_bridge_impart failed before it could spawn the depart
1346                  * thread.  The callbacks aren't called in this case.
1347                  * The impart could still fail even if ast_bridge_impart returned
1348                  * ok but that's handled by bridge_after_cb.
1349                  */
1350                 ast_log(LOG_ERROR, "Error adding channel to bridge\n");
1351                 ao2_lock(control);
1352                 ast_channel_pbx_set(chan, control->pbx);
1353                 control->pbx = NULL;
1354                 control->bridge = NULL;
1355                 ao2_unlock(control);
1356         } else {
1357                 ast_channel_lock(chan);
1358                 set_interval_hook(chan);
1359                 ast_channel_unlock(chan);
1360         }
1361
1362         return res;
1363 }
1364
1365 int control_add_channel_to_bridge(struct stasis_app_control *control, struct ast_channel *chan, void *data)
1366 {
1367         return control_swap_channel_in_bridge(control, data, chan, NULL);
1368 }
1369
1370 int stasis_app_control_add_channel_to_bridge(
1371         struct stasis_app_control *control, struct ast_bridge *bridge)
1372 {
1373         ast_debug(3, "%s: Sending channel add_to_bridge command\n",
1374                         stasis_app_control_get_channel_id(control));
1375
1376         return app_send_command_on_condition(
1377                 control, control_add_channel_to_bridge, bridge, NULL,
1378                 app_control_can_add_channel_to_bridge);
1379 }
1380
1381 static int app_control_remove_channel_from_bridge(
1382         struct stasis_app_control *control,
1383         struct ast_channel *chan, void *data)
1384 {
1385         struct ast_bridge *bridge = data;
1386
1387         if (!control) {
1388                 return -1;
1389         }
1390
1391         /* We should only depart from our own bridge */
1392         ast_debug(3, "%s: Departing bridge %s\n",
1393                 stasis_app_control_get_channel_id(control),
1394                 bridge->uniqueid);
1395
1396         if (bridge != stasis_app_get_bridge(control)) {
1397                 ast_log(LOG_WARNING, "%s: Not in bridge %s; not removing\n",
1398                         stasis_app_control_get_channel_id(control),
1399                         bridge->uniqueid);
1400                 return -1;
1401         }
1402
1403         depart_channel(control, chan);
1404         return 0;
1405 }
1406
1407 int stasis_app_control_remove_channel_from_bridge(
1408         struct stasis_app_control *control, struct ast_bridge *bridge)
1409 {
1410         ast_debug(3, "%s: Sending channel remove_from_bridge command\n",
1411                         stasis_app_control_get_channel_id(control));
1412         return app_send_command_on_condition(
1413                 control, app_control_remove_channel_from_bridge, bridge, NULL,
1414                 app_control_can_remove_channel_from_bridge);
1415 }
1416
1417 const char *stasis_app_control_get_channel_id(
1418         const struct stasis_app_control *control)
1419 {
1420         return ast_channel_uniqueid(control->channel);
1421 }
1422
1423 void stasis_app_control_publish(
1424         struct stasis_app_control *control, struct stasis_message *message)
1425 {
1426         if (!control || !control->channel || !message) {
1427                 return;
1428         }
1429         stasis_publish(ast_channel_topic(control->channel), message);
1430 }
1431
1432 int stasis_app_control_queue_control(struct stasis_app_control *control,
1433         enum ast_control_frame_type frame_type)
1434 {
1435         return ast_queue_control(control->channel, frame_type);
1436 }
1437
1438 int stasis_app_control_bridge_features_init(
1439         struct stasis_app_control *control)
1440 {
1441         struct ast_bridge_features *features;
1442
1443         features = ast_bridge_features_new();
1444         if (!features) {
1445                 return 1;
1446         }
1447         control->bridge_features = features;
1448         return 0;
1449 }
1450
1451 void stasis_app_control_absorb_dtmf_in_bridge(
1452         struct stasis_app_control *control, int absorb)
1453 {
1454         control->bridge_features->dtmf_passthrough = !absorb;
1455 }
1456
1457 void stasis_app_control_mute_in_bridge(
1458         struct stasis_app_control *control, int mute)
1459 {
1460         control->bridge_features->mute = mute;
1461 }
1462
1463 void control_flush_queue(struct stasis_app_control *control)
1464 {
1465         struct ao2_iterator iter;
1466         struct stasis_app_command *command;
1467
1468         iter = ao2_iterator_init(control->command_queue, AO2_ITERATOR_UNLINK);
1469         while ((command = ao2_iterator_next(&iter))) {
1470                 command_complete(command, -1);
1471                 ao2_ref(command, -1);
1472         }
1473         ao2_iterator_destroy(&iter);
1474 }
1475
1476 int control_dispatch_all(struct stasis_app_control *control,
1477         struct ast_channel *chan)
1478 {
1479         int count = 0;
1480         struct ao2_iterator iter;
1481         struct stasis_app_command *command;
1482
1483         ast_assert(control->channel == chan);
1484
1485         iter = ao2_iterator_init(control->command_queue, AO2_ITERATOR_UNLINK);
1486         while ((command = ao2_iterator_next(&iter))) {
1487                 command_invoke(command, control, chan);
1488                 ao2_ref(command, -1);
1489                 ++count;
1490         }
1491         ao2_iterator_destroy(&iter);
1492
1493         return count;
1494 }
1495
1496 void control_wait(struct stasis_app_control *control)
1497 {
1498         if (!control) {
1499                 return;
1500         }
1501
1502         ast_assert(control->command_queue != NULL);
1503
1504         ao2_lock(control->command_queue);
1505         while (ao2_container_count(control->command_queue) == 0) {
1506                 int res = ast_cond_wait(&control->wait_cond,
1507                         ao2_object_get_lockaddr(control->command_queue));
1508                 if (res < 0) {
1509                         ast_log(LOG_ERROR, "Error waiting on command queue\n");
1510                         break;
1511                 }
1512         }
1513         ao2_unlock(control->command_queue);
1514 }
1515
1516 int control_prestart_dispatch_all(struct stasis_app_control *control,
1517         struct ast_channel *chan)
1518 {
1519         struct ao2_container *command_queue;
1520         int count = 0;
1521         struct ao2_iterator iter;
1522         struct stasis_app_command *command;
1523
1524         ast_channel_lock(chan);
1525         command_queue = command_prestart_get_container(chan);
1526         ast_channel_unlock(chan);
1527         if (!command_queue) {
1528                 return 0;
1529         }
1530
1531         iter = ao2_iterator_init(command_queue, AO2_ITERATOR_UNLINK);
1532
1533         while ((command = ao2_iterator_next(&iter))) {
1534                 command_invoke(command, control, chan);
1535                 ao2_cleanup(command);
1536                 ++count;
1537         }
1538
1539         ao2_iterator_destroy(&iter);
1540         ao2_cleanup(command_queue);
1541         return count;
1542 }
1543
1544 struct stasis_app *control_app(struct stasis_app_control *control)
1545 {
1546         return control->app;
1547 }
1548
1549 struct control_dial_args {
1550         unsigned int timeout;
1551         char dialstring[0];
1552 };
1553
1554 static struct control_dial_args *control_dial_args_alloc(const char *dialstring,
1555         unsigned int timeout)
1556 {
1557         struct control_dial_args *args;
1558
1559         args = ast_malloc(sizeof(*args) + strlen(dialstring) + 1);
1560         if (!args) {
1561                 return NULL;
1562         }
1563
1564         args->timeout = timeout;
1565         /* Safe */
1566         strcpy(args->dialstring, dialstring);
1567
1568         return args;
1569 }
1570
1571 static void control_dial_args_destroy(void *data)
1572 {
1573         struct control_dial_args *args = data;
1574
1575         ast_free(args);
1576 }
1577
1578 /*!
1579  * \brief Set dial timeout on a channel to be dialed.
1580  *
1581  * \param chan The channel on which to set the dial timeout
1582  * \param timeout The timeout in seconds
1583  */
1584 static int set_timeout(struct ast_channel *chan, unsigned int timeout)
1585 {
1586         struct ast_datastore *datastore;
1587         struct timeval *hangup_time;
1588
1589         hangup_time = ast_malloc(sizeof(struct timeval));
1590
1591         datastore = ast_datastore_alloc(&timeout_datastore, NULL);
1592         if (!datastore) {
1593                 return -1;
1594         }
1595         *hangup_time = ast_tvadd(ast_tvnow(), ast_samp2tv(timeout, 1));
1596         datastore->data = hangup_time;
1597
1598         ast_channel_lock(chan);
1599         ast_channel_datastore_add(chan, datastore);
1600
1601         if (ast_channel_is_bridged(chan)) {
1602                 set_interval_hook(chan);
1603         }
1604         ast_channel_unlock(chan);
1605
1606         return 0;
1607 }
1608
1609 static int app_control_dial(struct stasis_app_control *control,
1610         struct ast_channel *chan, void *data)
1611 {
1612         struct control_dial_args *args = data;
1613         int bridged;
1614
1615         ast_channel_lock(chan);
1616         bridged = ast_channel_is_bridged(chan);
1617         ast_channel_unlock(chan);
1618
1619         if (!bridged && add_to_dial_bridge(control, chan)) {
1620                 return -1;
1621         }
1622
1623         if (args->timeout && set_timeout(chan, args->timeout)) {
1624                 return -1;
1625         }
1626
1627         if (ast_call(chan, args->dialstring, 0)) {
1628                 return -1;
1629         }
1630
1631         ast_channel_publish_dial(NULL, chan, args->dialstring, NULL);
1632
1633         return 0;
1634 }
1635
1636 int stasis_app_control_dial(struct stasis_app_control *control,
1637                 const char *dialstring, unsigned int timeout)
1638 {
1639         struct control_dial_args *args;
1640
1641         args = control_dial_args_alloc(dialstring, timeout);
1642         if (!args) {
1643                 return -1;
1644         }
1645
1646         return stasis_app_send_command_async(control, app_control_dial,
1647                 args, control_dial_args_destroy);
1648 }
1649
1650 void stasis_app_control_shutdown(void)
1651 {
1652         ast_mutex_lock(&dial_bridge_lock);
1653         shutting_down = 1;
1654         if (dial_bridge) {
1655                 ast_bridge_destroy(dial_bridge, 0);
1656                 dial_bridge = NULL;
1657         }
1658         ast_mutex_unlock(&dial_bridge_lock);
1659 }
1660
1661 void control_set_app(struct stasis_app_control *control, struct stasis_app *app)
1662 {
1663         ao2_cleanup(control->app);
1664         control->app = ao2_bump(app);
1665 }
1666
1667 char *control_next_app(struct stasis_app_control *control)
1668 {
1669         return control->next_app;
1670 }
1671
1672 void control_move_cleanup(struct stasis_app_control *control)
1673 {
1674         ast_free(control->next_app);
1675         control->next_app = NULL;
1676
1677         AST_VECTOR_RESET(&control->next_app_args, ast_free_ptr);
1678 }
1679
1680 char **control_next_app_args(struct stasis_app_control *control)
1681 {
1682         return AST_VECTOR_STEAL_ELEMENTS(&control->next_app_args);
1683 }
1684
1685 int control_next_app_args_size(struct stasis_app_control *control)
1686 {
1687         return AST_VECTOR_SIZE(&control->next_app_args);
1688 }