res_ari_channels: Add the ability to stop locally generated ringing on a channel.
[asterisk/asterisk.git] / res / ari / resource_channels.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012 - 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 Implementation for ARI stubs.
22  *
23  * \author David M. Lee, II <dlee@digium.com>
24  */
25
26 /*** MODULEINFO
27         <depend type="module">res_stasis_app_playback</depend>
28         <support_level>core</support_level>
29  ***/
30
31 #include "asterisk.h"
32
33 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
34
35 #include "asterisk/file.h"
36 #include "asterisk/pbx.h"
37 #include "asterisk/bridge.h"
38 #include "asterisk/callerid.h"
39 #include "asterisk/stasis_app.h"
40 #include "asterisk/stasis_app_playback.h"
41 #include "asterisk/stasis_app_recording.h"
42 #include "asterisk/stasis_channels.h"
43 #include "asterisk/causes.h"
44 #include "resource_channels.h"
45
46 #include <limits.h>
47
48 /*!
49  * \brief Finds the control object for a channel, filling the response with an
50  * error, if appropriate.
51  * \param[out] response Response to fill with an error if control is not found.
52  * \param channel_id ID of the channel to lookup.
53  * \return Channel control object.
54  * \return \c NULL if control object does not exist.
55  */
56 static struct stasis_app_control *find_control(
57         struct ast_ari_response *response,
58         const char *channel_id)
59 {
60         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
61
62         ast_assert(response != NULL);
63
64         control = stasis_app_control_find_by_channel_id(channel_id);
65         if (control == NULL) {
66                 /* Distinguish between 404 and 409 errors */
67                 RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
68                 chan = ast_channel_get_by_name(channel_id);
69                 if (chan == NULL) {
70                         ast_ari_response_error(response, 404, "Not Found",
71                                    "Channel not found");
72                         return NULL;
73                 }
74
75                 ast_ari_response_error(response, 409, "Conflict",
76                            "Channel not in Stasis application");
77                 return NULL;
78         }
79
80         ao2_ref(control, +1);
81         return control;
82 }
83
84 void ast_ari_channels_continue_in_dialplan(
85         struct ast_variable *headers,
86         struct ast_ari_channels_continue_in_dialplan_args *args,
87         struct ast_ari_response *response)
88 {
89         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
90
91         ast_assert(response != NULL);
92
93         control = find_control(response, args->channel_id);
94         if (control == NULL) {
95                 return;
96         }
97
98         if (stasis_app_control_continue(control, args->context, args->extension, args->priority)) {
99                 ast_ari_response_alloc_failed(response);
100                 return;
101         }
102
103         ast_ari_response_no_content(response);
104 }
105
106 void ast_ari_channels_answer(struct ast_variable *headers,
107         struct ast_ari_channels_answer_args *args,
108         struct ast_ari_response *response)
109 {
110         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
111
112         control = find_control(response, args->channel_id);
113         if (control == NULL) {
114                 return;
115         }
116
117         if (stasis_app_control_answer(control) != 0) {
118                 ast_ari_response_error(
119                         response, 500, "Internal Server Error",
120                         "Failed to answer channel");
121                 return;
122         }
123
124         ast_ari_response_no_content(response);
125 }
126
127 void ast_ari_channels_ring(struct ast_variable *headers,
128         struct ast_ari_channels_ring_args *args,
129         struct ast_ari_response *response)
130 {
131         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
132
133         control = find_control(response, args->channel_id);
134         if (control == NULL) {
135                 return;
136         }
137
138         stasis_app_control_ring(control);
139
140         ast_ari_response_no_content(response);
141 }
142
143 void ast_ari_channels_ring_stop(struct ast_variable *headers,
144         struct ast_ari_channels_ring_stop_args *args,
145         struct ast_ari_response *response)
146 {
147         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
148
149         control = find_control(response, args->channel_id);
150         if (control == NULL) {
151                 return;
152         }
153
154         stasis_app_control_ring_stop(control);
155
156         ast_ari_response_no_content(response);
157 }
158
159 void ast_ari_channels_mute(struct ast_variable *headers,
160         struct ast_ari_channels_mute_args *args,
161         struct ast_ari_response *response)
162 {
163         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
164         unsigned int direction = 0;
165         enum ast_frame_type frametype = AST_FRAME_VOICE;
166
167         control = find_control(response, args->channel_id);
168         if (control == NULL) {
169                 return;
170         }
171
172         if (ast_strlen_zero(args->direction)) {
173                 ast_ari_response_error(
174                         response, 400, "Bad Request",
175                         "Direction is required");
176                 return;
177         }
178
179         if (!strcmp(args->direction, "in")) {
180                 direction = AST_MUTE_DIRECTION_READ;
181         } else if (!strcmp(args->direction, "out")) {
182                 direction = AST_MUTE_DIRECTION_WRITE;
183         } else if (!strcmp(args->direction, "both")) {
184                 direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
185         } else {
186                 ast_ari_response_error(
187                         response, 400, "Bad Request",
188                         "Invalid direction specified");
189                 return;
190         }
191
192         stasis_app_control_mute(control, direction, frametype);
193
194         ast_ari_response_no_content(response);
195 }
196
197 void ast_ari_channels_unmute(struct ast_variable *headers,
198         struct ast_ari_channels_unmute_args *args,
199         struct ast_ari_response *response)
200 {
201         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
202         unsigned int direction = 0;
203         enum ast_frame_type frametype = AST_FRAME_VOICE;
204
205         control = find_control(response, args->channel_id);
206         if (control == NULL) {
207                 return;
208         }
209
210         if (ast_strlen_zero(args->direction)) {
211                 ast_ari_response_error(
212                         response, 400, "Bad Request",
213                         "Direction is required");
214                 return;
215         }
216
217         if (!strcmp(args->direction, "in")) {
218                 direction = AST_MUTE_DIRECTION_READ;
219         } else if (!strcmp(args->direction, "out")) {
220                 direction = AST_MUTE_DIRECTION_WRITE;
221         } else if (!strcmp(args->direction, "both")) {
222                 direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
223         } else {
224                 ast_ari_response_error(
225                         response, 400, "Bad Request",
226                         "Invalid direction specified");
227                 return;
228         }
229
230         stasis_app_control_unmute(control, direction, frametype);
231
232         ast_ari_response_no_content(response);
233 }
234
235 void ast_ari_channels_send_dtmf(struct ast_variable *headers,
236         struct ast_ari_channels_send_dtmf_args *args,
237         struct ast_ari_response *response)
238 {
239         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
240
241         control = find_control(response, args->channel_id);
242         if (control == NULL) {
243                 return;
244         }
245
246         if (ast_strlen_zero(args->dtmf)) {
247                 ast_ari_response_error(
248                         response, 400, "Bad Request",
249                         "DTMF is required");
250                 return;
251         }
252
253         stasis_app_control_dtmf(control, args->dtmf, args->before, args->between, args->duration, args->after);
254
255         ast_ari_response_no_content(response);
256 }
257
258 void ast_ari_channels_hold(struct ast_variable *headers,
259         struct ast_ari_channels_hold_args *args,
260         struct ast_ari_response *response)
261 {
262         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
263
264         control = find_control(response, args->channel_id);
265         if (control == NULL) {
266                 /* Response filled in by find_control */
267                 return;
268         }
269
270         stasis_app_control_hold(control);
271
272         ast_ari_response_no_content(response);
273 }
274
275 void ast_ari_channels_unhold(struct ast_variable *headers,
276         struct ast_ari_channels_unhold_args *args,
277         struct ast_ari_response *response)
278 {
279         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
280
281         control = find_control(response, args->channel_id);
282         if (control == NULL) {
283                 /* Response filled in by find_control */
284                 return;
285         }
286
287         stasis_app_control_unhold(control);
288
289         ast_ari_response_no_content(response);
290 }
291
292 void ast_ari_channels_start_moh(struct ast_variable *headers,
293         struct ast_ari_channels_start_moh_args *args,
294         struct ast_ari_response *response)
295 {
296         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
297
298         control = find_control(response, args->channel_id);
299         if (control == NULL) {
300                 /* Response filled in by find_control */
301                 return;
302         }
303
304         stasis_app_control_moh_start(control, args->moh_class);
305         ast_ari_response_no_content(response);
306 }
307
308 void ast_ari_channels_stop_moh(struct ast_variable *headers,
309         struct ast_ari_channels_stop_moh_args *args,
310         struct ast_ari_response *response)
311 {
312         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
313
314         control = find_control(response, args->channel_id);
315         if (control == NULL) {
316                 /* Response filled in by find_control */
317                 return;
318         }
319
320         stasis_app_control_moh_stop(control);
321         ast_ari_response_no_content(response);
322 }
323
324 void ast_ari_channels_play(struct ast_variable *headers,
325         struct ast_ari_channels_play_args *args,
326         struct ast_ari_response *response)
327 {
328         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
329         RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
330         RAII_VAR(struct stasis_app_playback *, playback, NULL, ao2_cleanup);
331         RAII_VAR(char *, playback_url, NULL, ast_free);
332         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
333         const char *language;
334
335         ast_assert(response != NULL);
336
337         control = find_control(response, args->channel_id);
338         if (control == NULL) {
339                 /* Response filled in by find_control */
340                 return;
341         }
342
343         snapshot = stasis_app_control_get_snapshot(control);
344         if (!snapshot) {
345                 ast_ari_response_error(
346                         response, 404, "Not Found",
347                         "Channel not found");
348                 return;
349         }
350
351         if (args->skipms < 0) {
352                 ast_ari_response_error(
353                         response, 400, "Bad Request",
354                         "skipms cannot be negative");
355                 return;
356         }
357
358         if (args->offsetms < 0) {
359                 ast_ari_response_error(
360                         response, 400, "Bad Request",
361                         "offsetms cannot be negative");
362                 return;
363         }
364
365         language = S_OR(args->lang, snapshot->language);
366
367         playback = stasis_app_control_play_uri(control, args->media, language,
368                 args->channel_id, STASIS_PLAYBACK_TARGET_CHANNEL, args->skipms, args->offsetms);
369         if (!playback) {
370                 ast_ari_response_error(
371                         response, 500, "Internal Server Error",
372                         "Failed to queue media for playback");
373                 return;
374         }
375
376         ast_asprintf(&playback_url, "/playback/%s",
377                 stasis_app_playback_get_id(playback));
378         if (!playback_url) {
379                 ast_ari_response_error(
380                         response, 500, "Internal Server Error",
381                         "Out of memory");
382                 return;
383         }
384
385         json = stasis_app_playback_to_json(playback);
386         if (!json) {
387                 ast_ari_response_error(
388                         response, 500, "Internal Server Error",
389                         "Out of memory");
390                 return;
391         }
392
393         ast_ari_response_created(response, playback_url, json);
394 }
395
396 void ast_ari_channels_record(struct ast_variable *headers,
397         struct ast_ari_channels_record_args *args,
398         struct ast_ari_response *response)
399 {
400         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
401         RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
402         RAII_VAR(struct stasis_app_recording *, recording, NULL, ao2_cleanup);
403         RAII_VAR(char *, recording_url, NULL, ast_free);
404         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
405         RAII_VAR(struct stasis_app_recording_options *, options, NULL,
406                 ao2_cleanup);
407         RAII_VAR(char *, uri_encoded_name, NULL, ast_free);
408         size_t uri_name_maxlen;
409
410         ast_assert(response != NULL);
411
412         if (args->max_duration_seconds < 0) {
413                 ast_ari_response_error(
414                         response, 400, "Bad Request",
415                         "max_duration_seconds cannot be negative");
416                 return;
417         }
418
419         if (args->max_silence_seconds < 0) {
420                 ast_ari_response_error(
421                         response, 400, "Bad Request",
422                         "max_silence_seconds cannot be negative");
423                 return;
424         }
425
426         control = find_control(response, args->channel_id);
427         if (control == NULL) {
428                 /* Response filled in by find_control */
429                 return;
430         }
431
432         options = stasis_app_recording_options_create(args->name, args->format);
433         if (options == NULL) {
434                 ast_ari_response_error(
435                         response, 500, "Internal Server Error",
436                         "Out of memory");
437         }
438         options->max_silence_seconds = args->max_silence_seconds;
439         options->max_duration_seconds = args->max_duration_seconds;
440         options->terminate_on =
441                 stasis_app_recording_termination_parse(args->terminate_on);
442         options->if_exists =
443                 stasis_app_recording_if_exists_parse(args->if_exists);
444         options->beep = args->beep;
445
446         if (options->terminate_on == STASIS_APP_RECORDING_TERMINATE_INVALID) {
447                 ast_ari_response_error(
448                         response, 400, "Bad Request",
449                         "terminateOn invalid");
450                 return;
451         }
452
453         if (options->if_exists == -1) {
454                 ast_ari_response_error(
455                         response, 400, "Bad Request",
456                         "ifExists invalid");
457                 return;
458         }
459
460         if (!ast_get_format_for_file_ext(options->format)) {
461                 ast_ari_response_error(
462                         response, 422, "Unprocessable Entity",
463                         "specified format is unknown on this system");
464                 return;
465         }
466
467         recording = stasis_app_control_record(control, options);
468         if (recording == NULL) {
469                 switch(errno) {
470                 case EINVAL:
471                         /* While the arguments are invalid, we should have
472                          * caught them prior to calling record.
473                          */
474                         ast_ari_response_error(
475                                 response, 500, "Internal Server Error",
476                                 "Error parsing request");
477                         break;
478                 case EEXIST:
479                         ast_ari_response_error(response, 409, "Conflict",
480                                 "Recording '%s' already exists and can not be overwritten",
481                                 args->name);
482                         break;
483                 case ENOMEM:
484                         ast_ari_response_error(
485                                 response, 500, "Internal Server Error",
486                                 "Out of memory");
487                         break;
488                 case EPERM:
489                         ast_ari_response_error(
490                                 response, 400, "Bad Request",
491                                 "Recording name invalid");
492                         break;
493                 default:
494                         ast_log(LOG_WARNING,
495                                 "Unrecognized recording error: %s\n",
496                                 strerror(errno));
497                         ast_ari_response_error(
498                                 response, 500, "Internal Server Error",
499                                 "Internal Server Error");
500                         break;
501                 }
502                 return;
503         }
504
505         uri_name_maxlen = strlen(args->name) * 3;
506         uri_encoded_name = ast_malloc(uri_name_maxlen);
507         if (!uri_encoded_name) {
508                 ast_ari_response_error(
509                         response, 500, "Internal Server Error",
510                         "Out of memory");
511                 return;
512         }
513         ast_uri_encode(args->name, uri_encoded_name, uri_name_maxlen,
514                 ast_uri_http);
515
516         ast_asprintf(&recording_url, "/recordings/live/%s", uri_encoded_name);
517         if (!recording_url) {
518                 ast_ari_response_error(
519                         response, 500, "Internal Server Error",
520                         "Out of memory");
521                 return;
522         }
523
524         json = stasis_app_recording_to_json(recording);
525         if (!json) {
526                 ast_ari_response_error(
527                         response, 500, "Internal Server Error",
528                         "Out of memory");
529                 return;
530         }
531
532         ast_ari_response_created(response, recording_url, json);
533 }
534
535 void ast_ari_channels_get(struct ast_variable *headers,
536         struct ast_ari_channels_get_args *args,
537         struct ast_ari_response *response)
538 {
539         RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
540         struct stasis_cache *cache;
541         struct ast_channel_snapshot *snapshot;
542
543         cache = ast_channel_cache();
544         if (!cache) {
545                 ast_ari_response_error(
546                         response, 500, "Internal Server Error",
547                         "Message bus not initialized");
548                 return;
549         }
550
551         msg = stasis_cache_get(cache, ast_channel_snapshot_type(),
552                                args->channel_id);
553         if (!msg) {
554                 ast_ari_response_error(
555                         response, 404, "Not Found",
556                         "Channel not found");
557                 return;
558         }
559
560         snapshot = stasis_message_data(msg);
561         ast_assert(snapshot != NULL);
562
563         ast_ari_response_ok(response,
564                                 ast_channel_snapshot_to_json(snapshot));
565 }
566
567 void ast_ari_channels_hangup(struct ast_variable *headers,
568         struct ast_ari_channels_hangup_args *args,
569         struct ast_ari_response *response)
570 {
571         RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
572         int cause;
573
574         chan = ast_channel_get_by_name(args->channel_id);
575         if (chan == NULL) {
576                 ast_ari_response_error(
577                         response, 404, "Not Found",
578                         "Channel not found");
579                 return;
580         }
581
582         if (ast_strlen_zero(args->reason) || !strcmp(args->reason, "normal")) {
583                 cause = AST_CAUSE_NORMAL;
584         } else if (!strcmp(args->reason, "busy")) {
585                 cause = AST_CAUSE_BUSY;
586         } else if (!strcmp(args->reason, "congestion")) {
587                 cause = AST_CAUSE_CONGESTION;
588         } else {
589                 ast_ari_response_error(
590                         response, 400, "Invalid Reason",
591                         "Invalid reason for hangup provided");
592                 return;
593         }
594
595         ast_channel_hangupcause_set(chan, cause);
596         ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
597
598         ast_ari_response_no_content(response);
599 }
600
601 void ast_ari_channels_list(struct ast_variable *headers,
602         struct ast_ari_channels_list_args *args,
603         struct ast_ari_response *response)
604 {
605         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
606         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
607         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
608         struct ao2_iterator i;
609         void *obj;
610
611         cache = ast_channel_cache();
612         if (!cache) {
613                 ast_ari_response_error(
614                         response, 500, "Internal Server Error",
615                         "Message bus not initialized");
616                 return;
617         }
618         ao2_ref(cache, +1);
619
620         snapshots = stasis_cache_dump(cache, ast_channel_snapshot_type());
621         if (!snapshots) {
622                 ast_ari_response_alloc_failed(response);
623                 return;
624         }
625
626         json = ast_json_array_create();
627         if (!json) {
628                 ast_ari_response_alloc_failed(response);
629                 return;
630         }
631
632         i = ao2_iterator_init(snapshots, 0);
633         while ((obj = ao2_iterator_next(&i))) {
634                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
635                 struct ast_channel_snapshot *snapshot = stasis_message_data(msg);
636                 int r = ast_json_array_append(
637                         json, ast_channel_snapshot_to_json(snapshot));
638                 if (r != 0) {
639                         ast_ari_response_alloc_failed(response);
640                         return;
641                 }
642         }
643         ao2_iterator_destroy(&i);
644
645         ast_ari_response_ok(response, ast_json_ref(json));
646 }
647
648 void ast_ari_channels_originate(struct ast_variable *headers,
649         struct ast_ari_channels_originate_args *args,
650         struct ast_ari_response *response)
651 {
652         char *dialtech;
653         char dialdevice[AST_CHANNEL_NAME];
654         char *caller_id = NULL;
655         char *cid_num = NULL;
656         char *cid_name = NULL;
657         int timeout = 30000;
658
659         char *stuff;
660         struct ast_channel *chan;
661         RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
662
663         if (ast_strlen_zero(args->endpoint)) {
664                 ast_ari_response_error(response, 400, "Bad Request",
665                         "Endpoint must be specified");
666                 return;
667         }
668
669         dialtech = ast_strdupa(args->endpoint);
670         if ((stuff = strchr(dialtech, '/'))) {
671                 *stuff++ = '\0';
672                 ast_copy_string(dialdevice, stuff, sizeof(dialdevice));
673         }
674
675         if (ast_strlen_zero(dialtech) || ast_strlen_zero(dialdevice)) {
676                 ast_ari_response_error(response, 400, "Bad Request",
677                         "Invalid endpoint specified");
678                 return;
679         }
680
681         if (args->timeout > 0) {
682                 timeout = args->timeout * 1000;
683         } else if (args->timeout == -1) {
684                 timeout = -1;
685         }
686
687         if (!ast_strlen_zero(args->caller_id)) {
688                 caller_id = ast_strdupa(args->caller_id);
689                 ast_callerid_parse(caller_id, &cid_name, &cid_num);
690
691                 if (ast_is_shrinkable_phonenumber(cid_num)) {
692                         ast_shrink_phone_number(cid_num);
693                 }
694         }
695
696         if (!ast_strlen_zero(args->app)) {
697                 const char *app = "Stasis";
698
699                 RAII_VAR(struct ast_str *, appdata, ast_str_create(64), ast_free);
700
701                 if (!appdata) {
702                         ast_ari_response_alloc_failed(response);
703                         return;
704                 }
705
706                 ast_str_set(&appdata, 0, "%s", args->app);
707                 if (!ast_strlen_zero(args->app_args)) {
708                         ast_str_append(&appdata, 0, ",%s", args->app_args);
709                 }
710
711                 /* originate a channel, putting it into an application */
712                 if (ast_pbx_outgoing_app(dialtech, NULL, dialdevice, timeout, app, ast_str_buffer(appdata), NULL, 0, cid_num, cid_name, NULL, NULL, &chan)) {
713                         ast_ari_response_alloc_failed(response);
714                         return;
715                 }
716         } else if (!ast_strlen_zero(args->extension)) {
717                 /* originate a channel, sending it to an extension */
718                 if (ast_pbx_outgoing_exten(dialtech, NULL, dialdevice, timeout, S_OR(args->context, "default"), args->extension, args->priority ? args->priority : 1, NULL, 0, cid_num, cid_name, NULL, NULL, &chan, 0)) {
719                         ast_ari_response_alloc_failed(response);
720                         return;
721                 }
722         } else {
723                 ast_ari_response_error(response, 400, "Bad Request",
724                         "Application or extension must be specified");
725                 return;
726         }
727
728         snapshot = ast_channel_snapshot_create(chan);
729         ast_channel_unlock(chan);
730
731         if (!ast_strlen_zero(args->app)) {
732                 /* channel: + channel ID + null terminator */
733                 char uri[9 + strlen(ast_channel_uniqueid(chan))];
734                 const char *uris[1] = { uri, };
735
736                 sprintf(uri, "channel:%s", ast_channel_uniqueid(chan));
737                 stasis_app_subscribe(args->app, uris, 1, NULL);
738         }
739
740         ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot));
741         ast_channel_unref(chan);
742 }
743
744 void ast_ari_channels_get_channel_var(struct ast_variable *headers,
745         struct ast_ari_channels_get_channel_var_args *args,
746         struct ast_ari_response *response)
747 {
748         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
749         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
750         RAII_VAR(char *, value, NULL, ast_free);
751
752         ast_assert(response != NULL);
753
754         if (ast_strlen_zero(args->variable)) {
755                 ast_ari_response_error(
756                         response, 400, "Bad Request",
757                         "Variable name is required");
758                 return;
759         }
760
761         control = find_control(response, args->channel_id);
762         if (control == NULL) {
763                 /* response filled in by find_control */
764                 return;
765         }
766
767         value = stasis_app_control_get_channel_var(control, args->variable);
768
769         if (!(json = ast_json_pack("{s: s}", "value", S_OR(value, "")))) {
770                 ast_ari_response_alloc_failed(response);
771                 return;
772         }
773
774         ast_ari_response_ok(response, ast_json_ref(json));
775 }
776
777 void ast_ari_channels_set_channel_var(struct ast_variable *headers,
778         struct ast_ari_channels_set_channel_var_args *args,
779         struct ast_ari_response *response)
780 {
781         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
782
783         ast_assert(response != NULL);
784
785         if (ast_strlen_zero(args->variable)) {
786                 ast_ari_response_error(
787                         response, 400, "Bad Request",
788                         "Variable name is required");
789                 return;
790         }
791
792         control = find_control(response, args->channel_id);
793         if (control == NULL) {
794                 /* response filled in by find_control */
795                 return;
796         }
797
798         if (stasis_app_control_set_channel_var(control, args->variable, args->value)) {
799                 ast_ari_response_error(
800                         response, 400, "Bad Request",
801                         "Failed to execute function");
802                 return;
803         }
804
805         ast_ari_response_no_content(response);
806 }
807