Restore Dial, Queue, and FollowMe 'I' option support.
[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 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
29
30 #include "asterisk/stasis_channels.h"
31
32 #include "command.h"
33 #include "control.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
42 struct stasis_app_control {
43         ast_cond_t wait_cond;
44         /*! Queue of commands to dispatch on the channel */
45         struct ao2_container *command_queue;
46         /*!
47          * The associated channel.
48          * Be very careful with the threading associated w/ manipulating
49          * the channel.
50          */
51         struct ast_channel *channel;
52         /*!
53          * When a channel is in a bridge, the bridge that it is in.
54          */
55         struct ast_bridge *bridge;
56         /*!
57          * Holding place for channel's PBX while imparted to a bridge.
58          */
59         struct ast_pbx *pbx;
60         /*!
61          * When set, /c app_stasis should exit and continue in the dialplan.
62          */
63         int is_done:1;
64 };
65
66 static void control_dtor(void *obj)
67 {
68         struct stasis_app_control *control = obj;
69
70         ao2_cleanup(control->command_queue);
71         ast_cond_destroy(&control->wait_cond);
72 }
73
74 struct stasis_app_control *control_create(struct ast_channel *channel)
75 {
76         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
77         int res;
78
79         control = ao2_alloc(sizeof(*control), control_dtor);
80         if (!control) {
81                 return NULL;
82         }
83
84         res = ast_cond_init(&control->wait_cond, NULL);
85         if (res != 0) {
86                 ast_log(LOG_ERROR, "Error initializing ast_cond_t: %s\n",
87                         strerror(errno));
88                 return NULL;
89         }
90
91         control->command_queue = ao2_container_alloc_list(
92                 AO2_ALLOC_OPT_LOCK_MUTEX, 0, NULL, NULL);
93
94         if (!control->command_queue) {
95                 return NULL;
96         }
97
98         control->channel = channel;
99
100         ao2_ref(control, +1);
101         return control;
102 }
103
104 static void *noop_cb(struct stasis_app_control *control,
105         struct ast_channel *chan, void *data)
106 {
107         return NULL;
108 }
109
110
111 static struct stasis_app_command *exec_command(
112         struct stasis_app_control *control, stasis_app_command_cb command_fn,
113         void *data)
114 {
115         RAII_VAR(struct stasis_app_command *, command, NULL, ao2_cleanup);
116
117         command_fn = command_fn ? : noop_cb;
118
119         command = command_create(command_fn, data);
120         if (!command) {
121                 return NULL;
122         }
123
124         ao2_lock(control->command_queue);
125         ao2_link_flags(control->command_queue, command, OBJ_NOLOCK);
126         ast_cond_signal(&control->wait_cond);
127         ao2_unlock(control->command_queue);
128
129         ao2_ref(command, +1);
130         return command;
131 }
132
133 struct stasis_app_control_dial_data {
134         char endpoint[AST_CHANNEL_NAME];
135         int timeout;
136 };
137
138 static void *app_control_dial(struct stasis_app_control *control,
139         struct ast_channel *chan, void *data)
140 {
141         RAII_VAR(struct ast_dial *, dial, ast_dial_create(), ast_dial_destroy);
142         RAII_VAR(struct stasis_app_control_dial_data *, dial_data, data, ast_free);
143         enum ast_dial_result res;
144         char *tech, *resource;
145
146         struct ast_channel *new_chan;
147         struct ast_bridge *bridge;
148
149         tech = dial_data->endpoint;
150         if (!(resource = strchr(tech, '/'))) {
151                 return NULL;
152         }
153         *resource++ = '\0';
154
155         if (!dial) {
156                 ast_log(LOG_ERROR, "Failed to create dialing structure.\n");
157                 return NULL;
158         }
159
160         if (ast_dial_append(dial, tech, resource) < 0) {
161                 ast_log(LOG_ERROR, "Failed to add %s/%s to dialing structure.\n", tech, resource);
162                 return NULL;
163         }
164
165         ast_dial_set_global_timeout(dial, dial_data->timeout);
166
167         res = ast_dial_run(dial, NULL, 0);
168         if (res != AST_DIAL_RESULT_ANSWERED || !(new_chan = ast_dial_answered_steal(dial))) {
169                 return NULL;
170         }
171
172         if (!(bridge = ast_bridge_basic_new())) {
173                 ast_log(LOG_ERROR, "Failed to create basic bridge.\n");
174                 return NULL;
175         }
176
177         if (ast_bridge_impart(bridge, new_chan, NULL, NULL,
178                 AST_BRIDGE_IMPART_CHAN_INDEPENDENT)) {
179                 ast_hangup(new_chan);
180         } else {
181                 stasis_app_control_add_channel_to_bridge(control, bridge);
182         }
183
184         return NULL;
185 }
186
187 int stasis_app_control_dial(struct stasis_app_control *control, const char *endpoint, int timeout)
188 {
189         struct stasis_app_control_dial_data *dial_data;
190
191         if (!(dial_data = ast_calloc(1, sizeof(*dial_data)))) {
192                 return -1;
193         }
194
195         ast_copy_string(dial_data->endpoint, endpoint, sizeof(dial_data->endpoint));
196
197         if (timeout > 0) {
198                 dial_data->timeout = timeout * 1000;
199         } else if (timeout == -1) {
200                 dial_data->timeout = -1;
201         } else {
202                 dial_data->timeout = 30000;
203         }
204
205         stasis_app_send_command_async(control, app_control_dial, dial_data);
206
207         return 0;
208 }
209
210 int stasis_app_control_add_role(struct stasis_app_control *control, const char *role)
211 {
212         return ast_channel_add_bridge_role(control->channel, role);
213 }
214
215 void stasis_app_control_clear_roles(struct stasis_app_control *control)
216 {
217         ast_channel_clear_bridge_roles(control->channel);
218 }
219
220 int control_is_done(struct stasis_app_control *control)
221 {
222         /* Called from stasis_app_exec thread; no lock needed */
223         return control->is_done;
224 }
225
226 struct stasis_app_control_continue_data {
227         char context[AST_MAX_CONTEXT];
228         char extension[AST_MAX_EXTENSION];
229         int priority;
230 };
231
232 static void *app_control_continue(struct stasis_app_control *control,
233         struct ast_channel *chan, void *data)
234 {
235         RAII_VAR(struct stasis_app_control_continue_data *, continue_data, data, ast_free);
236
237         ast_assert(control->channel != NULL);
238
239         /* If we're in a Stasis bridge, depart it before going back to the
240          * dialplan */
241         if (stasis_app_get_bridge(control)) {
242                 ast_bridge_depart(control->channel);
243         }
244
245         /* Called from stasis_app_exec thread; no lock needed */
246         ast_explicit_goto(control->channel, continue_data->context, continue_data->extension, continue_data->priority);
247
248         control->is_done = 1;
249
250         return NULL;
251 }
252
253 int stasis_app_control_continue(struct stasis_app_control *control, const char *context, const char *extension, int priority)
254 {
255         struct stasis_app_control_continue_data *continue_data;
256
257         if (!(continue_data = ast_calloc(1, sizeof(*continue_data)))) {
258                 return -1;
259         }
260         ast_copy_string(continue_data->context, S_OR(context, ""), sizeof(continue_data->context));
261         ast_copy_string(continue_data->extension, S_OR(extension, ""), sizeof(continue_data->extension));
262         if (priority > 0) {
263                 continue_data->priority = priority;
264         } else {
265                 continue_data->priority = -1;
266         }
267
268         stasis_app_send_command_async(control, app_control_continue, continue_data);
269
270         return 0;
271 }
272
273 struct stasis_app_control_mute_data {
274         enum ast_frame_type frametype;
275         unsigned int direction;
276 };
277
278 static void *app_control_mute(struct stasis_app_control *control,
279         struct ast_channel *chan, void *data)
280 {
281         RAII_VAR(struct stasis_app_control_mute_data *, mute_data, data, ast_free);
282         SCOPED_CHANNELLOCK(lockvar, chan);
283
284         ast_channel_suppress(control->channel, mute_data->direction, mute_data->frametype);
285
286         return NULL;
287 }
288
289 int stasis_app_control_mute(struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
290 {
291         struct stasis_app_control_mute_data *mute_data;
292
293         if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
294                 return -1;
295         }
296
297         mute_data->direction = direction;
298         mute_data->frametype = frametype;
299
300         stasis_app_send_command_async(control, app_control_mute, mute_data);
301
302         return 0;
303 }
304
305 static void *app_control_unmute(struct stasis_app_control *control,
306         struct ast_channel *chan, void *data)
307 {
308         RAII_VAR(struct stasis_app_control_mute_data *, mute_data, data, ast_free);
309         SCOPED_CHANNELLOCK(lockvar, chan);
310
311         ast_channel_unsuppress(control->channel, mute_data->direction, mute_data->frametype);
312
313         return NULL;
314 }
315
316 int stasis_app_control_unmute(struct stasis_app_control *control, unsigned int direction, enum ast_frame_type frametype)
317 {
318         struct stasis_app_control_mute_data *mute_data;
319
320         if (!(mute_data = ast_calloc(1, sizeof(*mute_data)))) {
321                 return -1;
322         }
323
324         mute_data->direction = direction;
325         mute_data->frametype = frametype;
326
327         stasis_app_send_command_async(control, app_control_unmute, mute_data);
328
329         return 0;
330 }
331
332 char *stasis_app_control_get_channel_var(struct stasis_app_control *control, const char *variable)
333 {
334         RAII_VAR(struct ast_str *, tmp, ast_str_create(32), ast_free);
335         SCOPED_CHANNELLOCK(lockvar, control->channel);
336
337         if (!tmp) {
338                 return NULL;
339         }
340
341         if (variable[strlen(variable) - 1] == ')') {
342                 if (ast_func_read2(control->channel, variable, &tmp, 0)) {
343                         return NULL;
344                 }
345         } else {
346                 if (!ast_str_retrieve_variable(&tmp, 0, control->channel, NULL, variable)) {
347                         return NULL;
348                 }
349         }
350
351         return ast_strdup(ast_str_buffer(tmp));
352 }
353
354 int stasis_app_control_set_channel_var(struct stasis_app_control *control, const char *variable, const char *value)
355 {
356         return pbx_builtin_setvar_helper(control->channel, variable, value);
357 }
358
359 static void *app_control_hold(struct stasis_app_control *control,
360         struct ast_channel *chan, void *data)
361 {
362         ast_indicate(control->channel, AST_CONTROL_HOLD);
363
364         return NULL;
365 }
366
367 void stasis_app_control_hold(struct stasis_app_control *control)
368 {
369         stasis_app_send_command_async(control, app_control_hold, NULL);
370 }
371
372 static void *app_control_unhold(struct stasis_app_control *control,
373         struct ast_channel *chan, void *data)
374 {
375         ast_indicate(control->channel, AST_CONTROL_UNHOLD);
376
377         return NULL;
378 }
379
380 void stasis_app_control_unhold(struct stasis_app_control *control)
381 {
382         stasis_app_send_command_async(control, app_control_unhold, NULL);
383 }
384
385 static void *app_control_moh_start(struct stasis_app_control *control,
386         struct ast_channel *chan, void *data)
387 {
388         char *moh_class = data;
389
390         ast_moh_start(chan, moh_class, NULL);
391
392         ast_free(moh_class);
393         return NULL;
394 }
395
396 void stasis_app_control_moh_start(struct stasis_app_control *control, const char *moh_class)
397 {
398         char *data = NULL;
399
400         if (!ast_strlen_zero(moh_class)) {
401                 data = ast_strdup(moh_class);
402         }
403
404         stasis_app_send_command_async(control, app_control_moh_start, data);
405 }
406
407 static void *app_control_moh_stop(struct stasis_app_control *control,
408         struct ast_channel *chan, void *data)
409 {
410         ast_moh_stop(chan);
411         return NULL;
412 }
413
414 void stasis_app_control_moh_stop(struct stasis_app_control *control)
415 {
416         stasis_app_send_command_async(control, app_control_moh_stop, NULL);
417 }
418
419 struct ast_channel_snapshot *stasis_app_control_get_snapshot(
420         const struct stasis_app_control *control)
421 {
422         RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
423         struct ast_channel_snapshot *snapshot;
424
425         msg = stasis_cache_get(ast_channel_cache(), ast_channel_snapshot_type(),
426                 stasis_app_control_get_channel_id(control));
427         if (!msg) {
428                 return NULL;
429         }
430
431         snapshot = stasis_message_data(msg);
432         ast_assert(snapshot != NULL);
433
434         ao2_ref(snapshot, +1);
435         return snapshot;
436 }
437
438 void *stasis_app_send_command(struct stasis_app_control *control,
439         stasis_app_command_cb command_fn, void *data)
440 {
441         RAII_VAR(struct stasis_app_command *, command, NULL, ao2_cleanup);
442
443         if (control == NULL) {
444                 return NULL;
445         }
446
447         command = exec_command(control, command_fn, data);
448         if (!command) {
449                 return NULL;
450         }
451
452         return command_join(command);
453 }
454
455 int stasis_app_send_command_async(struct stasis_app_control *control,
456         stasis_app_command_cb command_fn, void *data)
457 {
458         RAII_VAR(struct stasis_app_command *, command, NULL, ao2_cleanup);
459
460         if (control == NULL) {
461                 return -1;
462         }
463
464         command = exec_command(control, command_fn, data);
465         if (!command) {
466                 return -1;
467         }
468
469         return 0;
470 }
471
472 struct ast_bridge *stasis_app_get_bridge(struct stasis_app_control *control)
473 {
474         if (!control) {
475                 return NULL;
476         } else {
477                 SCOPED_AO2LOCK(lock, control);
478                 return control->bridge;
479         }
480 }
481
482
483 static void bridge_after_cb(struct ast_channel *chan, void *data)
484 {
485         struct stasis_app_control *control = data;
486         SCOPED_AO2LOCK(lock, control);
487
488         ast_debug(3, "%s, %s: Channel leaving bridge\n",
489                 ast_channel_uniqueid(chan), control->bridge->uniqueid);
490
491         ast_assert(chan == control->channel);
492
493         /* Restore the channel's PBX */
494         ast_channel_pbx_set(control->channel, control->pbx);
495         control->pbx = NULL;
496
497         /* No longer in the bridge */
498         control->bridge = NULL;
499
500         /* Wakeup the command_queue loop */
501         exec_command(control, NULL, NULL);
502 }
503
504 static void bridge_after_cb_failed(enum ast_bridge_after_cb_reason reason,
505         void *data)
506 {
507         struct stasis_app_control *control = data;
508
509         bridge_after_cb(control->channel, data);
510
511         ast_debug(3, "  reason: %s\n",
512                 ast_bridge_after_cb_reason_string(reason));
513 }
514
515 static int OK = 0;
516 static int FAIL = -1;
517
518 static void *app_control_add_channel_to_bridge(
519         struct stasis_app_control *control,
520         struct ast_channel *chan, void *data)
521 {
522         struct ast_bridge *bridge = data;
523         int res;
524
525         if (!control || !bridge) {
526                 return NULL;
527         }
528
529         ast_debug(3, "%s: Adding to bridge %s\n",
530                 stasis_app_control_get_channel_id(control),
531                 bridge->uniqueid);
532
533         ast_assert(chan != NULL);
534
535         /* Depart whatever Stasis bridge we're currently in. */
536         if (stasis_app_get_bridge(control)) {
537                 /* Note that it looks like there's a race condition here, since
538                  * we don't have control locked. But this happens from the
539                  * control callback thread, so there won't be any other
540                  * concurrent attempts to bridge.
541                  */
542                 ast_bridge_depart(chan);
543         }
544
545
546         res = ast_bridge_set_after_callback(chan, bridge_after_cb,
547                 bridge_after_cb_failed, control);
548         if (res != 0) {
549                 ast_log(LOG_ERROR, "Error setting after-bridge callback\n");
550                 return &FAIL;
551         }
552
553         {
554                 /* pbx and bridge are modified by the bridging impart thread.
555                  * It shouldn't happen concurrently, but we still need to lock
556                  * for the memory fence.
557                  */
558                 SCOPED_AO2LOCK(lock, control);
559
560                 /* Save off the channel's PBX */
561                 ast_assert(control->pbx == NULL);
562                 if (!control->pbx) {
563                         control->pbx = ast_channel_pbx(chan);
564                         ast_channel_pbx_set(chan, NULL);
565                 }
566
567                 res = ast_bridge_impart(bridge,
568                         chan,
569                         NULL, /* swap channel */
570                         NULL, /* features */
571                         AST_BRIDGE_IMPART_CHAN_DEPARTABLE);
572                 if (res != 0) {
573                         ast_log(LOG_ERROR, "Error adding channel to bridge\n");
574                         ast_channel_pbx_set(chan, control->pbx);
575                         control->pbx = NULL;
576                         return &FAIL;
577                 }
578
579                 ast_assert(stasis_app_get_bridge(control) == NULL);
580                 control->bridge = bridge;
581         }
582         return &OK;
583 }
584
585 int stasis_app_control_add_channel_to_bridge(
586         struct stasis_app_control *control, struct ast_bridge *bridge)
587 {
588         int *res;
589         ast_debug(3, "%s: Sending channel add_to_bridge command\n",
590                         stasis_app_control_get_channel_id(control));
591         res = stasis_app_send_command(control,
592                 app_control_add_channel_to_bridge, bridge);
593         return *res;
594 }
595
596 static void *app_control_remove_channel_from_bridge(
597         struct stasis_app_control *control,
598         struct ast_channel *chan, void *data)
599 {
600         struct ast_bridge *bridge = data;
601
602         if (!control) {
603                 return &FAIL;
604         }
605
606         /* We should only depart from our own bridge */
607         ast_debug(3, "%s: Departing bridge %s\n",
608                 stasis_app_control_get_channel_id(control),
609                 bridge->uniqueid);
610
611         if (bridge != stasis_app_get_bridge(control)) {
612                 ast_log(LOG_WARNING, "%s: Not in bridge %s; not removing\n",
613                         stasis_app_control_get_channel_id(control),
614                         bridge->uniqueid);
615                 return &FAIL;
616         }
617
618         ast_bridge_depart(chan);
619         return &OK;
620 }
621
622 int stasis_app_control_remove_channel_from_bridge(
623         struct stasis_app_control *control, struct ast_bridge *bridge)
624 {
625         int *res;
626         ast_debug(3, "%s: Sending channel remove_from_bridge command\n",
627                         stasis_app_control_get_channel_id(control));
628         res = stasis_app_send_command(control,
629                 app_control_remove_channel_from_bridge, bridge);
630         return *res;
631 }
632
633 const char *stasis_app_control_get_channel_id(
634         const struct stasis_app_control *control)
635 {
636         return ast_channel_uniqueid(control->channel);
637 }
638
639 void stasis_app_control_publish(
640         struct stasis_app_control *control, struct stasis_message *message)
641 {
642         if (!control || !control->channel || !message) {
643                 return;
644         }
645         stasis_publish(ast_channel_topic(control->channel), message);
646 }
647
648 int stasis_app_control_queue_control(struct stasis_app_control *control,
649         enum ast_control_frame_type frame_type)
650 {
651         return ast_queue_control(control->channel, frame_type);
652 }
653
654 int control_dispatch_all(struct stasis_app_control *control,
655         struct ast_channel *chan)
656 {
657         int count = 0;
658         struct ao2_iterator i;
659         void *obj;
660
661         ast_assert(control->channel == chan);
662
663         i = ao2_iterator_init(control->command_queue, AO2_ITERATOR_UNLINK);
664
665         while ((obj = ao2_iterator_next(&i))) {
666                 RAII_VAR(struct stasis_app_command *, command, obj, ao2_cleanup);
667                 command_invoke(command, control, chan);
668                 ++count;
669         }
670
671         ao2_iterator_destroy(&i);
672         return count;
673 }
674
675 void control_wait(struct stasis_app_control *control)
676 {
677         if (!control) {
678                 return;
679         }
680
681         ast_assert(control->command_queue != NULL);
682
683         ao2_lock(control->command_queue);
684         while (ao2_container_count(control->command_queue) == 0) {
685                 int res = ast_cond_wait(&control->wait_cond,
686                         ao2_object_get_lockaddr(control->command_queue));
687                 if (res < 0) {
688                         ast_log(LOG_ERROR, "Error waiting on command queue\n");
689                         break;
690                 }
691         }
692         ao2_unlock(control->command_queue);
693 }