ari: User better nicknames for ARI operations
[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_mute(struct ast_variable *headers,
144         struct ast_ari_channels_mute_args *args,
145         struct ast_ari_response *response)
146 {
147         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
148         unsigned int direction = 0;
149         enum ast_frame_type frametype = AST_FRAME_VOICE;
150
151         control = find_control(response, args->channel_id);
152         if (control == NULL) {
153                 return;
154         }
155
156         if (ast_strlen_zero(args->direction)) {
157                 ast_ari_response_error(
158                         response, 400, "Bad Request",
159                         "Direction is required");
160                 return;
161         }
162
163         if (!strcmp(args->direction, "in")) {
164                 direction = AST_MUTE_DIRECTION_READ;
165         } else if (!strcmp(args->direction, "out")) {
166                 direction = AST_MUTE_DIRECTION_WRITE;
167         } else if (!strcmp(args->direction, "both")) {
168                 direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
169         } else {
170                 ast_ari_response_error(
171                         response, 400, "Bad Request",
172                         "Invalid direction specified");
173                 return;
174         }
175
176         stasis_app_control_mute(control, direction, frametype);
177
178         ast_ari_response_no_content(response);
179 }
180
181 void ast_ari_channels_unmute(struct ast_variable *headers,
182         struct ast_ari_channels_unmute_args *args,
183         struct ast_ari_response *response)
184 {
185         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
186         unsigned int direction = 0;
187         enum ast_frame_type frametype = AST_FRAME_VOICE;
188
189         control = find_control(response, args->channel_id);
190         if (control == NULL) {
191                 return;
192         }
193
194         if (ast_strlen_zero(args->direction)) {
195                 ast_ari_response_error(
196                         response, 400, "Bad Request",
197                         "Direction is required");
198                 return;
199         }
200
201         if (!strcmp(args->direction, "in")) {
202                 direction = AST_MUTE_DIRECTION_READ;
203         } else if (!strcmp(args->direction, "out")) {
204                 direction = AST_MUTE_DIRECTION_WRITE;
205         } else if (!strcmp(args->direction, "both")) {
206                 direction = AST_MUTE_DIRECTION_READ | AST_MUTE_DIRECTION_WRITE;
207         } else {
208                 ast_ari_response_error(
209                         response, 400, "Bad Request",
210                         "Invalid direction specified");
211                 return;
212         }
213
214         stasis_app_control_unmute(control, direction, frametype);
215
216         ast_ari_response_no_content(response);
217 }
218
219 void ast_ari_channels_send_dtmf(struct ast_variable *headers,
220         struct ast_ari_channels_send_dtmf_args *args,
221         struct ast_ari_response *response)
222 {
223         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
224
225         control = find_control(response, args->channel_id);
226         if (control == NULL) {
227                 return;
228         }
229
230         if (ast_strlen_zero(args->dtmf)) {
231                 ast_ari_response_error(
232                         response, 400, "Bad Request",
233                         "DTMF is required");
234                 return;
235         }
236
237         stasis_app_control_dtmf(control, args->dtmf, args->before, args->between, args->duration, args->after);
238
239         ast_ari_response_no_content(response);
240 }
241
242 void ast_ari_channels_hold(struct ast_variable *headers,
243         struct ast_ari_channels_hold_args *args,
244         struct ast_ari_response *response)
245 {
246         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
247
248         control = find_control(response, args->channel_id);
249         if (control == NULL) {
250                 /* Response filled in by find_control */
251                 return;
252         }
253
254         stasis_app_control_hold(control);
255
256         ast_ari_response_no_content(response);
257 }
258
259 void ast_ari_channels_unhold(struct ast_variable *headers,
260         struct ast_ari_channels_unhold_args *args,
261         struct ast_ari_response *response)
262 {
263         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
264
265         control = find_control(response, args->channel_id);
266         if (control == NULL) {
267                 /* Response filled in by find_control */
268                 return;
269         }
270
271         stasis_app_control_unhold(control);
272
273         ast_ari_response_no_content(response);
274 }
275
276 void ast_ari_channels_start_moh(struct ast_variable *headers,
277         struct ast_ari_channels_start_moh_args *args,
278         struct ast_ari_response *response)
279 {
280         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
281
282         control = find_control(response, args->channel_id);
283         if (control == NULL) {
284                 /* Response filled in by find_control */
285                 return;
286         }
287
288         stasis_app_control_moh_start(control, args->moh_class);
289         ast_ari_response_no_content(response);
290 }
291
292 void ast_ari_channels_stop_moh(struct ast_variable *headers,
293         struct ast_ari_channels_stop_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_stop(control);
305         ast_ari_response_no_content(response);
306 }
307
308 void ast_ari_channels_play(struct ast_variable *headers,
309         struct ast_ari_channels_play_args *args,
310         struct ast_ari_response *response)
311 {
312         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
313         RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
314         RAII_VAR(struct stasis_app_playback *, playback, NULL, ao2_cleanup);
315         RAII_VAR(char *, playback_url, NULL, ast_free);
316         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
317         const char *language;
318
319         ast_assert(response != NULL);
320
321         control = find_control(response, args->channel_id);
322         if (control == NULL) {
323                 /* Response filled in by find_control */
324                 return;
325         }
326
327         snapshot = stasis_app_control_get_snapshot(control);
328         if (!snapshot) {
329                 ast_ari_response_error(
330                         response, 404, "Not Found",
331                         "Channel not found");
332                 return;
333         }
334
335         if (args->skipms < 0) {
336                 ast_ari_response_error(
337                         response, 400, "Bad Request",
338                         "skipms cannot be negative");
339                 return;
340         }
341
342         if (args->offsetms < 0) {
343                 ast_ari_response_error(
344                         response, 400, "Bad Request",
345                         "offsetms cannot be negative");
346                 return;
347         }
348
349         language = S_OR(args->lang, snapshot->language);
350
351         playback = stasis_app_control_play_uri(control, args->media, language,
352                 args->channel_id, STASIS_PLAYBACK_TARGET_CHANNEL, args->skipms, args->offsetms);
353         if (!playback) {
354                 ast_ari_response_error(
355                         response, 500, "Internal Server Error",
356                         "Failed to queue media for playback");
357                 return;
358         }
359
360         ast_asprintf(&playback_url, "/playback/%s",
361                 stasis_app_playback_get_id(playback));
362         if (!playback_url) {
363                 ast_ari_response_error(
364                         response, 500, "Internal Server Error",
365                         "Out of memory");
366                 return;
367         }
368
369         json = stasis_app_playback_to_json(playback);
370         if (!json) {
371                 ast_ari_response_error(
372                         response, 500, "Internal Server Error",
373                         "Out of memory");
374                 return;
375         }
376
377         ast_ari_response_created(response, playback_url, json);
378 }
379
380 void ast_ari_channels_record(struct ast_variable *headers,
381         struct ast_ari_channels_record_args *args,
382         struct ast_ari_response *response)
383 {
384         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
385         RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
386         RAII_VAR(struct stasis_app_recording *, recording, NULL, ao2_cleanup);
387         RAII_VAR(char *, recording_url, NULL, ast_free);
388         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
389         RAII_VAR(struct stasis_app_recording_options *, options, NULL,
390                 ao2_cleanup);
391         RAII_VAR(char *, uri_encoded_name, NULL, ast_free);
392         size_t uri_name_maxlen;
393
394         ast_assert(response != NULL);
395
396         if (args->max_duration_seconds < 0) {
397                 ast_ari_response_error(
398                         response, 400, "Bad Request",
399                         "max_duration_seconds cannot be negative");
400                 return;
401         }
402
403         if (args->max_silence_seconds < 0) {
404                 ast_ari_response_error(
405                         response, 400, "Bad Request",
406                         "max_silence_seconds cannot be negative");
407                 return;
408         }
409
410         control = find_control(response, args->channel_id);
411         if (control == NULL) {
412                 /* Response filled in by find_control */
413                 return;
414         }
415
416         options = stasis_app_recording_options_create(args->name, args->format);
417         if (options == NULL) {
418                 ast_ari_response_error(
419                         response, 500, "Internal Server Error",
420                         "Out of memory");
421         }
422         options->max_silence_seconds = args->max_silence_seconds;
423         options->max_duration_seconds = args->max_duration_seconds;
424         options->terminate_on =
425                 stasis_app_recording_termination_parse(args->terminate_on);
426         options->if_exists =
427                 stasis_app_recording_if_exists_parse(args->if_exists);
428         options->beep = args->beep;
429
430         if (options->terminate_on == STASIS_APP_RECORDING_TERMINATE_INVALID) {
431                 ast_ari_response_error(
432                         response, 400, "Bad Request",
433                         "terminateOn invalid");
434                 return;
435         }
436
437         if (options->if_exists == -1) {
438                 ast_ari_response_error(
439                         response, 400, "Bad Request",
440                         "ifExists invalid");
441                 return;
442         }
443
444         if (!ast_get_format_for_file_ext(options->format)) {
445                 ast_ari_response_error(
446                         response, 422, "Unprocessable Entity",
447                         "specified format is unknown on this system");
448                 return;
449         }
450
451         recording = stasis_app_control_record(control, options);
452         if (recording == NULL) {
453                 switch(errno) {
454                 case EINVAL:
455                         /* While the arguments are invalid, we should have
456                          * caught them prior to calling record.
457                          */
458                         ast_ari_response_error(
459                                 response, 500, "Internal Server Error",
460                                 "Error parsing request");
461                         break;
462                 case EEXIST:
463                         ast_ari_response_error(response, 409, "Conflict",
464                                 "Recording '%s' already exists and can not be overwritten",
465                                 args->name);
466                         break;
467                 case ENOMEM:
468                         ast_ari_response_error(
469                                 response, 500, "Internal Server Error",
470                                 "Out of memory");
471                         break;
472                 case EPERM:
473                         ast_ari_response_error(
474                                 response, 400, "Bad Request",
475                                 "Recording name invalid");
476                         break;
477                 default:
478                         ast_log(LOG_WARNING,
479                                 "Unrecognized recording error: %s\n",
480                                 strerror(errno));
481                         ast_ari_response_error(
482                                 response, 500, "Internal Server Error",
483                                 "Internal Server Error");
484                         break;
485                 }
486                 return;
487         }
488
489         uri_name_maxlen = strlen(args->name) * 3;
490         uri_encoded_name = ast_malloc(uri_name_maxlen);
491         if (!uri_encoded_name) {
492                 ast_ari_response_error(
493                         response, 500, "Internal Server Error",
494                         "Out of memory");
495                 return;
496         }
497         ast_uri_encode(args->name, uri_encoded_name, uri_name_maxlen,
498                 ast_uri_http);
499
500         ast_asprintf(&recording_url, "/recordings/live/%s", uri_encoded_name);
501         if (!recording_url) {
502                 ast_ari_response_error(
503                         response, 500, "Internal Server Error",
504                         "Out of memory");
505                 return;
506         }
507
508         json = stasis_app_recording_to_json(recording);
509         if (!json) {
510                 ast_ari_response_error(
511                         response, 500, "Internal Server Error",
512                         "Out of memory");
513                 return;
514         }
515
516         ast_ari_response_created(response, recording_url, json);
517 }
518
519 void ast_ari_channels_get(struct ast_variable *headers,
520         struct ast_ari_channels_get_args *args,
521         struct ast_ari_response *response)
522 {
523         RAII_VAR(struct stasis_message *, msg, NULL, ao2_cleanup);
524         struct stasis_cache *cache;
525         struct ast_channel_snapshot *snapshot;
526
527         cache = ast_channel_cache();
528         if (!cache) {
529                 ast_ari_response_error(
530                         response, 500, "Internal Server Error",
531                         "Message bus not initialized");
532                 return;
533         }
534
535         msg = stasis_cache_get(cache, ast_channel_snapshot_type(),
536                                args->channel_id);
537         if (!msg) {
538                 ast_ari_response_error(
539                         response, 404, "Not Found",
540                         "Channel not found");
541                 return;
542         }
543
544         snapshot = stasis_message_data(msg);
545         ast_assert(snapshot != NULL);
546
547         ast_ari_response_ok(response,
548                                 ast_channel_snapshot_to_json(snapshot));
549 }
550
551 void ast_ari_channels_hangup(struct ast_variable *headers,
552         struct ast_ari_channels_hangup_args *args,
553         struct ast_ari_response *response)
554 {
555         RAII_VAR(struct ast_channel *, chan, NULL, ao2_cleanup);
556         int cause;
557
558         chan = ast_channel_get_by_name(args->channel_id);
559         if (chan == NULL) {
560                 ast_ari_response_error(
561                         response, 404, "Not Found",
562                         "Channel not found");
563                 return;
564         }
565
566         if (ast_strlen_zero(args->reason) || !strcmp(args->reason, "normal")) {
567                 cause = AST_CAUSE_NORMAL;
568         } else if (!strcmp(args->reason, "busy")) {
569                 cause = AST_CAUSE_BUSY;
570         } else if (!strcmp(args->reason, "congestion")) {
571                 cause = AST_CAUSE_CONGESTION;
572         } else {
573                 ast_ari_response_error(
574                         response, 400, "Invalid Reason",
575                         "Invalid reason for hangup provided");
576                 return;
577         }
578
579         ast_channel_hangupcause_set(chan, cause);
580         ast_softhangup(chan, AST_SOFTHANGUP_EXPLICIT);
581
582         ast_ari_response_no_content(response);
583 }
584
585 void ast_ari_channels_list(struct ast_variable *headers,
586         struct ast_ari_channels_list_args *args,
587         struct ast_ari_response *response)
588 {
589         RAII_VAR(struct stasis_cache *, cache, NULL, ao2_cleanup);
590         RAII_VAR(struct ao2_container *, snapshots, NULL, ao2_cleanup);
591         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
592         struct ao2_iterator i;
593         void *obj;
594
595         cache = ast_channel_cache();
596         if (!cache) {
597                 ast_ari_response_error(
598                         response, 500, "Internal Server Error",
599                         "Message bus not initialized");
600                 return;
601         }
602         ao2_ref(cache, +1);
603
604         snapshots = stasis_cache_dump(cache, ast_channel_snapshot_type());
605         if (!snapshots) {
606                 ast_ari_response_alloc_failed(response);
607                 return;
608         }
609
610         json = ast_json_array_create();
611         if (!json) {
612                 ast_ari_response_alloc_failed(response);
613                 return;
614         }
615
616         i = ao2_iterator_init(snapshots, 0);
617         while ((obj = ao2_iterator_next(&i))) {
618                 RAII_VAR(struct stasis_message *, msg, obj, ao2_cleanup);
619                 struct ast_channel_snapshot *snapshot = stasis_message_data(msg);
620                 int r = ast_json_array_append(
621                         json, ast_channel_snapshot_to_json(snapshot));
622                 if (r != 0) {
623                         ast_ari_response_alloc_failed(response);
624                         return;
625                 }
626         }
627         ao2_iterator_destroy(&i);
628
629         ast_ari_response_ok(response, ast_json_ref(json));
630 }
631
632 void ast_ari_channels_originate(struct ast_variable *headers,
633         struct ast_ari_channels_originate_args *args,
634         struct ast_ari_response *response)
635 {
636         char *dialtech;
637         char dialdevice[AST_CHANNEL_NAME];
638         char *caller_id = NULL;
639         char *cid_num = NULL;
640         char *cid_name = NULL;
641         int timeout = 30000;
642
643         char *stuff;
644         struct ast_channel *chan;
645         RAII_VAR(struct ast_channel_snapshot *, snapshot, NULL, ao2_cleanup);
646
647         if (ast_strlen_zero(args->endpoint)) {
648                 ast_ari_response_error(response, 400, "Bad Request",
649                         "Endpoint must be specified");
650                 return;
651         }
652
653         dialtech = ast_strdupa(args->endpoint);
654         if ((stuff = strchr(dialtech, '/'))) {
655                 *stuff++ = '\0';
656                 ast_copy_string(dialdevice, stuff, sizeof(dialdevice));
657         }
658
659         if (ast_strlen_zero(dialtech) || ast_strlen_zero(dialdevice)) {
660                 ast_ari_response_error(response, 400, "Bad Request",
661                         "Invalid endpoint specified");
662                 return;
663         }
664
665         if (args->timeout > 0) {
666                 timeout = args->timeout * 1000;
667         } else if (args->timeout == -1) {
668                 timeout = -1;
669         }
670
671         if (!ast_strlen_zero(args->caller_id)) {
672                 caller_id = ast_strdupa(args->caller_id);
673                 ast_callerid_parse(caller_id, &cid_name, &cid_num);
674
675                 if (ast_is_shrinkable_phonenumber(cid_num)) {
676                         ast_shrink_phone_number(cid_num);
677                 }
678         }
679
680         if (!ast_strlen_zero(args->app)) {
681                 const char *app = "Stasis";
682
683                 RAII_VAR(struct ast_str *, appdata, ast_str_create(64), ast_free);
684
685                 if (!appdata) {
686                         ast_ari_response_alloc_failed(response);
687                         return;
688                 }
689
690                 ast_str_set(&appdata, 0, "%s", args->app);
691                 if (!ast_strlen_zero(args->app_args)) {
692                         ast_str_append(&appdata, 0, ",%s", args->app_args);
693                 }
694
695                 /* originate a channel, putting it into an application */
696                 if (ast_pbx_outgoing_app(dialtech, NULL, dialdevice, timeout, app, ast_str_buffer(appdata), NULL, 0, cid_num, cid_name, NULL, NULL, &chan)) {
697                         ast_ari_response_alloc_failed(response);
698                         return;
699                 }
700         } else if (!ast_strlen_zero(args->extension)) {
701                 /* originate a channel, sending it to an extension */
702                 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)) {
703                         ast_ari_response_alloc_failed(response);
704                         return;
705                 }
706         } else {
707                 ast_ari_response_error(response, 400, "Bad Request",
708                         "Application or extension must be specified");
709                 return;
710         }
711
712         snapshot = ast_channel_snapshot_create(chan);
713         ast_channel_unlock(chan);
714
715         if (!ast_strlen_zero(args->app)) {
716                 /* channel: + channel ID + null terminator */
717                 char uri[9 + strlen(ast_channel_uniqueid(chan))];
718                 const char *uris[1] = { uri, };
719
720                 sprintf(uri, "channel:%s", ast_channel_uniqueid(chan));
721                 stasis_app_subscribe(args->app, uris, 1, NULL);
722         }
723
724         ast_ari_response_ok(response, ast_channel_snapshot_to_json(snapshot));
725         ast_channel_unref(chan);
726 }
727
728 void ast_ari_channels_get_channel_var(struct ast_variable *headers,
729         struct ast_ari_channels_get_channel_var_args *args,
730         struct ast_ari_response *response)
731 {
732         RAII_VAR(struct ast_json *, json, NULL, ast_json_unref);
733         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
734         RAII_VAR(char *, value, NULL, ast_free);
735
736         ast_assert(response != NULL);
737
738         if (ast_strlen_zero(args->variable)) {
739                 ast_ari_response_error(
740                         response, 400, "Bad Request",
741                         "Variable name is required");
742                 return;
743         }
744
745         control = find_control(response, args->channel_id);
746         if (control == NULL) {
747                 /* response filled in by find_control */
748                 return;
749         }
750
751         value = stasis_app_control_get_channel_var(control, args->variable);
752
753         if (!(json = ast_json_pack("{s: s}", "value", S_OR(value, "")))) {
754                 ast_ari_response_alloc_failed(response);
755                 return;
756         }
757
758         ast_ari_response_ok(response, ast_json_ref(json));
759 }
760
761 void ast_ari_channels_set_channel_var(struct ast_variable *headers,
762         struct ast_ari_channels_set_channel_var_args *args,
763         struct ast_ari_response *response)
764 {
765         RAII_VAR(struct stasis_app_control *, control, NULL, ao2_cleanup);
766
767         ast_assert(response != NULL);
768
769         if (ast_strlen_zero(args->variable)) {
770                 ast_ari_response_error(
771                         response, 400, "Bad Request",
772                         "Variable name is required");
773                 return;
774         }
775
776         control = find_control(response, args->channel_id);
777         if (control == NULL) {
778                 /* response filled in by find_control */
779                 return;
780         }
781
782         if (stasis_app_control_set_channel_var(control, args->variable, args->value)) {
783                 ast_ari_response_error(
784                         response, 400, "Bad Request",
785                         "Failed to execute function");
786                 return;
787         }
788
789         ast_ari_response_no_content(response);
790 }
791