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