6f2005e61a7592065ce27868fd326a1fdd463c1c
[asterisk/asterisk.git] / res / res_ari_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 /*
20  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
21  * !!!!!                               DO NOT EDIT                        !!!!!
22  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
23  * This file is generated by a mustache template. Please see the original
24  * template in rest-api-templates/res_ari_resource.c.mustache
25  */
26
27 /*! \file
28  *
29  * \brief Channel resources
30  *
31  * \author David M. Lee, II <dlee@digium.com>
32  */
33
34 /*** MODULEINFO
35         <depend type="module">res_ari</depend>
36         <depend type="module">res_stasis</depend>
37         <support_level>core</support_level>
38  ***/
39
40 #include "asterisk.h"
41
42 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
43
44 #include "asterisk/app.h"
45 #include "asterisk/module.h"
46 #include "asterisk/stasis_app.h"
47 #include "ari/resource_channels.h"
48 #if defined(AST_DEVMODE)
49 #include "ari/ari_model_validators.h"
50 #endif
51
52 #define MAX_VALS 128
53
54 /*!
55  * \brief Parameter parsing callback for /channels.
56  * \param get_params GET parameters in the HTTP request.
57  * \param path_vars Path variables extracted from the request.
58  * \param headers HTTP headers.
59  * \param[out] response Response to the HTTP request.
60  */
61 static void ast_ari_channels_list_cb(
62         struct ast_variable *get_params, struct ast_variable *path_vars,
63         struct ast_variable *headers, struct ast_ari_response *response)
64 {
65         struct ast_ari_channels_list_args args = {};
66 #if defined(AST_DEVMODE)
67         int is_valid;
68         int code;
69 #endif /* AST_DEVMODE */
70
71         ast_ari_channels_list(headers, &args, response);
72 #if defined(AST_DEVMODE)
73         code = response->response_code;
74
75         switch (code) {
76         case 0: /* Implementation is still a stub, or the code wasn't set */
77                 is_valid = response->message == NULL;
78                 break;
79         case 500: /* Internal Server Error */
80         case 501: /* Not Implemented */
81                 is_valid = 1;
82                 break;
83         default:
84                 if (200 <= code && code <= 299) {
85                         is_valid = ast_ari_validate_list(response->message,
86                                 ast_ari_validate_channel_fn());
87                 } else {
88                         ast_log(LOG_ERROR, "Invalid error response %d for /channels\n", code);
89                         is_valid = 0;
90                 }
91         }
92
93         if (!is_valid) {
94                 ast_log(LOG_ERROR, "Response validation failed for /channels\n");
95                 ast_ari_response_error(response, 500,
96                         "Internal Server Error", "Response validation failed");
97         }
98 #endif /* AST_DEVMODE */
99
100 fin: __attribute__((unused))
101         return;
102 }
103 /*!
104  * \brief Parameter parsing callback for /channels.
105  * \param get_params GET parameters in the HTTP request.
106  * \param path_vars Path variables extracted from the request.
107  * \param headers HTTP headers.
108  * \param[out] response Response to the HTTP request.
109  */
110 static void ast_ari_channels_originate_cb(
111         struct ast_variable *get_params, struct ast_variable *path_vars,
112         struct ast_variable *headers, struct ast_ari_response *response)
113 {
114         struct ast_ari_channels_originate_args args = {};
115         struct ast_variable *i;
116 #if defined(AST_DEVMODE)
117         int is_valid;
118         int code;
119 #endif /* AST_DEVMODE */
120
121         for (i = get_params; i; i = i->next) {
122                 if (strcmp(i->name, "endpoint") == 0) {
123                         args.endpoint = (i->value);
124                 } else
125                 if (strcmp(i->name, "extension") == 0) {
126                         args.extension = (i->value);
127                 } else
128                 if (strcmp(i->name, "context") == 0) {
129                         args.context = (i->value);
130                 } else
131                 if (strcmp(i->name, "priority") == 0) {
132                         args.priority = atol(i->value);
133                 } else
134                 if (strcmp(i->name, "app") == 0) {
135                         args.app = (i->value);
136                 } else
137                 if (strcmp(i->name, "appArgs") == 0) {
138                         args.app_args = (i->value);
139                 } else
140                 if (strcmp(i->name, "callerId") == 0) {
141                         args.caller_id = (i->value);
142                 } else
143                 if (strcmp(i->name, "timeout") == 0) {
144                         args.timeout = atoi(i->value);
145                 } else
146                 {}
147         }
148         ast_ari_channels_originate(headers, &args, response);
149 #if defined(AST_DEVMODE)
150         code = response->response_code;
151
152         switch (code) {
153         case 0: /* Implementation is still a stub, or the code wasn't set */
154                 is_valid = response->message == NULL;
155                 break;
156         case 500: /* Internal Server Error */
157         case 501: /* Not Implemented */
158         case 400: /* Invalid parameters for originating a channel. */
159                 is_valid = 1;
160                 break;
161         default:
162                 if (200 <= code && code <= 299) {
163                         is_valid = ast_ari_validate_channel(
164                                 response->message);
165                 } else {
166                         ast_log(LOG_ERROR, "Invalid error response %d for /channels\n", code);
167                         is_valid = 0;
168                 }
169         }
170
171         if (!is_valid) {
172                 ast_log(LOG_ERROR, "Response validation failed for /channels\n");
173                 ast_ari_response_error(response, 500,
174                         "Internal Server Error", "Response validation failed");
175         }
176 #endif /* AST_DEVMODE */
177
178 fin: __attribute__((unused))
179         return;
180 }
181 /*!
182  * \brief Parameter parsing callback for /channels/{channelId}.
183  * \param get_params GET parameters in the HTTP request.
184  * \param path_vars Path variables extracted from the request.
185  * \param headers HTTP headers.
186  * \param[out] response Response to the HTTP request.
187  */
188 static void ast_ari_channels_get_cb(
189         struct ast_variable *get_params, struct ast_variable *path_vars,
190         struct ast_variable *headers, struct ast_ari_response *response)
191 {
192         struct ast_ari_channels_get_args args = {};
193         struct ast_variable *i;
194 #if defined(AST_DEVMODE)
195         int is_valid;
196         int code;
197 #endif /* AST_DEVMODE */
198
199         for (i = path_vars; i; i = i->next) {
200                 if (strcmp(i->name, "channelId") == 0) {
201                         args.channel_id = (i->value);
202                 } else
203                 {}
204         }
205         ast_ari_channels_get(headers, &args, response);
206 #if defined(AST_DEVMODE)
207         code = response->response_code;
208
209         switch (code) {
210         case 0: /* Implementation is still a stub, or the code wasn't set */
211                 is_valid = response->message == NULL;
212                 break;
213         case 500: /* Internal Server Error */
214         case 501: /* Not Implemented */
215         case 404: /* Channel not found */
216                 is_valid = 1;
217                 break;
218         default:
219                 if (200 <= code && code <= 299) {
220                         is_valid = ast_ari_validate_channel(
221                                 response->message);
222                 } else {
223                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}\n", code);
224                         is_valid = 0;
225                 }
226         }
227
228         if (!is_valid) {
229                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}\n");
230                 ast_ari_response_error(response, 500,
231                         "Internal Server Error", "Response validation failed");
232         }
233 #endif /* AST_DEVMODE */
234
235 fin: __attribute__((unused))
236         return;
237 }
238 /*!
239  * \brief Parameter parsing callback for /channels/{channelId}.
240  * \param get_params GET parameters in the HTTP request.
241  * \param path_vars Path variables extracted from the request.
242  * \param headers HTTP headers.
243  * \param[out] response Response to the HTTP request.
244  */
245 static void ast_ari_channels_hangup_cb(
246         struct ast_variable *get_params, struct ast_variable *path_vars,
247         struct ast_variable *headers, struct ast_ari_response *response)
248 {
249         struct ast_ari_channels_hangup_args args = {};
250         struct ast_variable *i;
251 #if defined(AST_DEVMODE)
252         int is_valid;
253         int code;
254 #endif /* AST_DEVMODE */
255
256         for (i = get_params; i; i = i->next) {
257                 if (strcmp(i->name, "reason") == 0) {
258                         args.reason = (i->value);
259                 } else
260                 {}
261         }
262         for (i = path_vars; i; i = i->next) {
263                 if (strcmp(i->name, "channelId") == 0) {
264                         args.channel_id = (i->value);
265                 } else
266                 {}
267         }
268         ast_ari_channels_hangup(headers, &args, response);
269 #if defined(AST_DEVMODE)
270         code = response->response_code;
271
272         switch (code) {
273         case 0: /* Implementation is still a stub, or the code wasn't set */
274                 is_valid = response->message == NULL;
275                 break;
276         case 500: /* Internal Server Error */
277         case 501: /* Not Implemented */
278         case 400: /* Invalid reason for hangup provided */
279         case 404: /* Channel not found */
280                 is_valid = 1;
281                 break;
282         default:
283                 if (200 <= code && code <= 299) {
284                         is_valid = ast_ari_validate_void(
285                                 response->message);
286                 } else {
287                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}\n", code);
288                         is_valid = 0;
289                 }
290         }
291
292         if (!is_valid) {
293                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}\n");
294                 ast_ari_response_error(response, 500,
295                         "Internal Server Error", "Response validation failed");
296         }
297 #endif /* AST_DEVMODE */
298
299 fin: __attribute__((unused))
300         return;
301 }
302 /*!
303  * \brief Parameter parsing callback for /channels/{channelId}/continue.
304  * \param get_params GET parameters in the HTTP request.
305  * \param path_vars Path variables extracted from the request.
306  * \param headers HTTP headers.
307  * \param[out] response Response to the HTTP request.
308  */
309 static void ast_ari_channels_continue_in_dialplan_cb(
310         struct ast_variable *get_params, struct ast_variable *path_vars,
311         struct ast_variable *headers, struct ast_ari_response *response)
312 {
313         struct ast_ari_channels_continue_in_dialplan_args args = {};
314         struct ast_variable *i;
315 #if defined(AST_DEVMODE)
316         int is_valid;
317         int code;
318 #endif /* AST_DEVMODE */
319
320         for (i = get_params; i; i = i->next) {
321                 if (strcmp(i->name, "context") == 0) {
322                         args.context = (i->value);
323                 } else
324                 if (strcmp(i->name, "extension") == 0) {
325                         args.extension = (i->value);
326                 } else
327                 if (strcmp(i->name, "priority") == 0) {
328                         args.priority = atoi(i->value);
329                 } else
330                 {}
331         }
332         for (i = path_vars; i; i = i->next) {
333                 if (strcmp(i->name, "channelId") == 0) {
334                         args.channel_id = (i->value);
335                 } else
336                 {}
337         }
338         ast_ari_channels_continue_in_dialplan(headers, &args, response);
339 #if defined(AST_DEVMODE)
340         code = response->response_code;
341
342         switch (code) {
343         case 0: /* Implementation is still a stub, or the code wasn't set */
344                 is_valid = response->message == NULL;
345                 break;
346         case 500: /* Internal Server Error */
347         case 501: /* Not Implemented */
348         case 404: /* Channel not found */
349         case 409: /* Channel not in a Stasis application */
350                 is_valid = 1;
351                 break;
352         default:
353                 if (200 <= code && code <= 299) {
354                         is_valid = ast_ari_validate_void(
355                                 response->message);
356                 } else {
357                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/continue\n", code);
358                         is_valid = 0;
359                 }
360         }
361
362         if (!is_valid) {
363                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/continue\n");
364                 ast_ari_response_error(response, 500,
365                         "Internal Server Error", "Response validation failed");
366         }
367 #endif /* AST_DEVMODE */
368
369 fin: __attribute__((unused))
370         return;
371 }
372 /*!
373  * \brief Parameter parsing callback for /channels/{channelId}/answer.
374  * \param get_params GET parameters in the HTTP request.
375  * \param path_vars Path variables extracted from the request.
376  * \param headers HTTP headers.
377  * \param[out] response Response to the HTTP request.
378  */
379 static void ast_ari_channels_answer_cb(
380         struct ast_variable *get_params, struct ast_variable *path_vars,
381         struct ast_variable *headers, struct ast_ari_response *response)
382 {
383         struct ast_ari_channels_answer_args args = {};
384         struct ast_variable *i;
385 #if defined(AST_DEVMODE)
386         int is_valid;
387         int code;
388 #endif /* AST_DEVMODE */
389
390         for (i = path_vars; i; i = i->next) {
391                 if (strcmp(i->name, "channelId") == 0) {
392                         args.channel_id = (i->value);
393                 } else
394                 {}
395         }
396         ast_ari_channels_answer(headers, &args, response);
397 #if defined(AST_DEVMODE)
398         code = response->response_code;
399
400         switch (code) {
401         case 0: /* Implementation is still a stub, or the code wasn't set */
402                 is_valid = response->message == NULL;
403                 break;
404         case 500: /* Internal Server Error */
405         case 501: /* Not Implemented */
406         case 404: /* Channel not found */
407         case 409: /* Channel not in a Stasis application */
408                 is_valid = 1;
409                 break;
410         default:
411                 if (200 <= code && code <= 299) {
412                         is_valid = ast_ari_validate_void(
413                                 response->message);
414                 } else {
415                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/answer\n", code);
416                         is_valid = 0;
417                 }
418         }
419
420         if (!is_valid) {
421                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/answer\n");
422                 ast_ari_response_error(response, 500,
423                         "Internal Server Error", "Response validation failed");
424         }
425 #endif /* AST_DEVMODE */
426
427 fin: __attribute__((unused))
428         return;
429 }
430 /*!
431  * \brief Parameter parsing callback for /channels/{channelId}/ring.
432  * \param get_params GET parameters in the HTTP request.
433  * \param path_vars Path variables extracted from the request.
434  * \param headers HTTP headers.
435  * \param[out] response Response to the HTTP request.
436  */
437 static void ast_ari_channels_ring_cb(
438         struct ast_variable *get_params, struct ast_variable *path_vars,
439         struct ast_variable *headers, struct ast_ari_response *response)
440 {
441         struct ast_ari_channels_ring_args args = {};
442         struct ast_variable *i;
443 #if defined(AST_DEVMODE)
444         int is_valid;
445         int code;
446 #endif /* AST_DEVMODE */
447
448         for (i = path_vars; i; i = i->next) {
449                 if (strcmp(i->name, "channelId") == 0) {
450                         args.channel_id = (i->value);
451                 } else
452                 {}
453         }
454         ast_ari_channels_ring(headers, &args, response);
455 #if defined(AST_DEVMODE)
456         code = response->response_code;
457
458         switch (code) {
459         case 0: /* Implementation is still a stub, or the code wasn't set */
460                 is_valid = response->message == NULL;
461                 break;
462         case 500: /* Internal Server Error */
463         case 501: /* Not Implemented */
464         case 404: /* Channel not found */
465         case 409: /* Channel not in a Stasis application */
466                 is_valid = 1;
467                 break;
468         default:
469                 if (200 <= code && code <= 299) {
470                         is_valid = ast_ari_validate_void(
471                                 response->message);
472                 } else {
473                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/ring\n", code);
474                         is_valid = 0;
475                 }
476         }
477
478         if (!is_valid) {
479                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/ring\n");
480                 ast_ari_response_error(response, 500,
481                         "Internal Server Error", "Response validation failed");
482         }
483 #endif /* AST_DEVMODE */
484
485 fin: __attribute__((unused))
486         return;
487 }
488 /*!
489  * \brief Parameter parsing callback for /channels/{channelId}/ring.
490  * \param get_params GET parameters in the HTTP request.
491  * \param path_vars Path variables extracted from the request.
492  * \param headers HTTP headers.
493  * \param[out] response Response to the HTTP request.
494  */
495 static void ast_ari_channels_ring_stop_cb(
496         struct ast_variable *get_params, struct ast_variable *path_vars,
497         struct ast_variable *headers, struct ast_ari_response *response)
498 {
499         struct ast_ari_channels_ring_stop_args args = {};
500         struct ast_variable *i;
501 #if defined(AST_DEVMODE)
502         int is_valid;
503         int code;
504 #endif /* AST_DEVMODE */
505
506         for (i = path_vars; i; i = i->next) {
507                 if (strcmp(i->name, "channelId") == 0) {
508                         args.channel_id = (i->value);
509                 } else
510                 {}
511         }
512         ast_ari_channels_ring_stop(headers, &args, response);
513 #if defined(AST_DEVMODE)
514         code = response->response_code;
515
516         switch (code) {
517         case 0: /* Implementation is still a stub, or the code wasn't set */
518                 is_valid = response->message == NULL;
519                 break;
520         case 500: /* Internal Server Error */
521         case 501: /* Not Implemented */
522         case 404: /* Channel not found */
523         case 409: /* Channel not in a Stasis application */
524                 is_valid = 1;
525                 break;
526         default:
527                 if (200 <= code && code <= 299) {
528                         is_valid = ast_ari_validate_void(
529                                 response->message);
530                 } else {
531                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/ring\n", code);
532                         is_valid = 0;
533                 }
534         }
535
536         if (!is_valid) {
537                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/ring\n");
538                 ast_ari_response_error(response, 500,
539                         "Internal Server Error", "Response validation failed");
540         }
541 #endif /* AST_DEVMODE */
542
543 fin: __attribute__((unused))
544         return;
545 }
546 /*!
547  * \brief Parameter parsing callback for /channels/{channelId}/dtmf.
548  * \param get_params GET parameters in the HTTP request.
549  * \param path_vars Path variables extracted from the request.
550  * \param headers HTTP headers.
551  * \param[out] response Response to the HTTP request.
552  */
553 static void ast_ari_channels_send_dtmf_cb(
554         struct ast_variable *get_params, struct ast_variable *path_vars,
555         struct ast_variable *headers, struct ast_ari_response *response)
556 {
557         struct ast_ari_channels_send_dtmf_args args = {};
558         struct ast_variable *i;
559 #if defined(AST_DEVMODE)
560         int is_valid;
561         int code;
562 #endif /* AST_DEVMODE */
563
564         for (i = get_params; i; i = i->next) {
565                 if (strcmp(i->name, "dtmf") == 0) {
566                         args.dtmf = (i->value);
567                 } else
568                 if (strcmp(i->name, "before") == 0) {
569                         args.before = atoi(i->value);
570                 } else
571                 if (strcmp(i->name, "between") == 0) {
572                         args.between = atoi(i->value);
573                 } else
574                 if (strcmp(i->name, "duration") == 0) {
575                         args.duration = atoi(i->value);
576                 } else
577                 if (strcmp(i->name, "after") == 0) {
578                         args.after = atoi(i->value);
579                 } else
580                 {}
581         }
582         for (i = path_vars; i; i = i->next) {
583                 if (strcmp(i->name, "channelId") == 0) {
584                         args.channel_id = (i->value);
585                 } else
586                 {}
587         }
588         ast_ari_channels_send_dtmf(headers, &args, response);
589 #if defined(AST_DEVMODE)
590         code = response->response_code;
591
592         switch (code) {
593         case 0: /* Implementation is still a stub, or the code wasn't set */
594                 is_valid = response->message == NULL;
595                 break;
596         case 500: /* Internal Server Error */
597         case 501: /* Not Implemented */
598         case 400: /* DTMF is required */
599         case 404: /* Channel not found */
600         case 409: /* Channel not in a Stasis application */
601                 is_valid = 1;
602                 break;
603         default:
604                 if (200 <= code && code <= 299) {
605                         is_valid = ast_ari_validate_void(
606                                 response->message);
607                 } else {
608                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/dtmf\n", code);
609                         is_valid = 0;
610                 }
611         }
612
613         if (!is_valid) {
614                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/dtmf\n");
615                 ast_ari_response_error(response, 500,
616                         "Internal Server Error", "Response validation failed");
617         }
618 #endif /* AST_DEVMODE */
619
620 fin: __attribute__((unused))
621         return;
622 }
623 /*!
624  * \brief Parameter parsing callback for /channels/{channelId}/mute.
625  * \param get_params GET parameters in the HTTP request.
626  * \param path_vars Path variables extracted from the request.
627  * \param headers HTTP headers.
628  * \param[out] response Response to the HTTP request.
629  */
630 static void ast_ari_channels_mute_cb(
631         struct ast_variable *get_params, struct ast_variable *path_vars,
632         struct ast_variable *headers, struct ast_ari_response *response)
633 {
634         struct ast_ari_channels_mute_args args = {};
635         struct ast_variable *i;
636 #if defined(AST_DEVMODE)
637         int is_valid;
638         int code;
639 #endif /* AST_DEVMODE */
640
641         for (i = get_params; i; i = i->next) {
642                 if (strcmp(i->name, "direction") == 0) {
643                         args.direction = (i->value);
644                 } else
645                 {}
646         }
647         for (i = path_vars; i; i = i->next) {
648                 if (strcmp(i->name, "channelId") == 0) {
649                         args.channel_id = (i->value);
650                 } else
651                 {}
652         }
653         ast_ari_channels_mute(headers, &args, response);
654 #if defined(AST_DEVMODE)
655         code = response->response_code;
656
657         switch (code) {
658         case 0: /* Implementation is still a stub, or the code wasn't set */
659                 is_valid = response->message == NULL;
660                 break;
661         case 500: /* Internal Server Error */
662         case 501: /* Not Implemented */
663         case 404: /* Channel not found */
664         case 409: /* Channel not in a Stasis application */
665                 is_valid = 1;
666                 break;
667         default:
668                 if (200 <= code && code <= 299) {
669                         is_valid = ast_ari_validate_void(
670                                 response->message);
671                 } else {
672                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/mute\n", code);
673                         is_valid = 0;
674                 }
675         }
676
677         if (!is_valid) {
678                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/mute\n");
679                 ast_ari_response_error(response, 500,
680                         "Internal Server Error", "Response validation failed");
681         }
682 #endif /* AST_DEVMODE */
683
684 fin: __attribute__((unused))
685         return;
686 }
687 /*!
688  * \brief Parameter parsing callback for /channels/{channelId}/mute.
689  * \param get_params GET parameters in the HTTP request.
690  * \param path_vars Path variables extracted from the request.
691  * \param headers HTTP headers.
692  * \param[out] response Response to the HTTP request.
693  */
694 static void ast_ari_channels_unmute_cb(
695         struct ast_variable *get_params, struct ast_variable *path_vars,
696         struct ast_variable *headers, struct ast_ari_response *response)
697 {
698         struct ast_ari_channels_unmute_args args = {};
699         struct ast_variable *i;
700 #if defined(AST_DEVMODE)
701         int is_valid;
702         int code;
703 #endif /* AST_DEVMODE */
704
705         for (i = get_params; i; i = i->next) {
706                 if (strcmp(i->name, "direction") == 0) {
707                         args.direction = (i->value);
708                 } else
709                 {}
710         }
711         for (i = path_vars; i; i = i->next) {
712                 if (strcmp(i->name, "channelId") == 0) {
713                         args.channel_id = (i->value);
714                 } else
715                 {}
716         }
717         ast_ari_channels_unmute(headers, &args, response);
718 #if defined(AST_DEVMODE)
719         code = response->response_code;
720
721         switch (code) {
722         case 0: /* Implementation is still a stub, or the code wasn't set */
723                 is_valid = response->message == NULL;
724                 break;
725         case 500: /* Internal Server Error */
726         case 501: /* Not Implemented */
727         case 404: /* Channel not found */
728         case 409: /* Channel not in a Stasis application */
729                 is_valid = 1;
730                 break;
731         default:
732                 if (200 <= code && code <= 299) {
733                         is_valid = ast_ari_validate_void(
734                                 response->message);
735                 } else {
736                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/mute\n", code);
737                         is_valid = 0;
738                 }
739         }
740
741         if (!is_valid) {
742                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/mute\n");
743                 ast_ari_response_error(response, 500,
744                         "Internal Server Error", "Response validation failed");
745         }
746 #endif /* AST_DEVMODE */
747
748 fin: __attribute__((unused))
749         return;
750 }
751 /*!
752  * \brief Parameter parsing callback for /channels/{channelId}/hold.
753  * \param get_params GET parameters in the HTTP request.
754  * \param path_vars Path variables extracted from the request.
755  * \param headers HTTP headers.
756  * \param[out] response Response to the HTTP request.
757  */
758 static void ast_ari_channels_hold_cb(
759         struct ast_variable *get_params, struct ast_variable *path_vars,
760         struct ast_variable *headers, struct ast_ari_response *response)
761 {
762         struct ast_ari_channels_hold_args args = {};
763         struct ast_variable *i;
764 #if defined(AST_DEVMODE)
765         int is_valid;
766         int code;
767 #endif /* AST_DEVMODE */
768
769         for (i = path_vars; i; i = i->next) {
770                 if (strcmp(i->name, "channelId") == 0) {
771                         args.channel_id = (i->value);
772                 } else
773                 {}
774         }
775         ast_ari_channels_hold(headers, &args, response);
776 #if defined(AST_DEVMODE)
777         code = response->response_code;
778
779         switch (code) {
780         case 0: /* Implementation is still a stub, or the code wasn't set */
781                 is_valid = response->message == NULL;
782                 break;
783         case 500: /* Internal Server Error */
784         case 501: /* Not Implemented */
785         case 404: /* Channel not found */
786         case 409: /* Channel not in a Stasis application */
787                 is_valid = 1;
788                 break;
789         default:
790                 if (200 <= code && code <= 299) {
791                         is_valid = ast_ari_validate_void(
792                                 response->message);
793                 } else {
794                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/hold\n", code);
795                         is_valid = 0;
796                 }
797         }
798
799         if (!is_valid) {
800                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/hold\n");
801                 ast_ari_response_error(response, 500,
802                         "Internal Server Error", "Response validation failed");
803         }
804 #endif /* AST_DEVMODE */
805
806 fin: __attribute__((unused))
807         return;
808 }
809 /*!
810  * \brief Parameter parsing callback for /channels/{channelId}/hold.
811  * \param get_params GET parameters in the HTTP request.
812  * \param path_vars Path variables extracted from the request.
813  * \param headers HTTP headers.
814  * \param[out] response Response to the HTTP request.
815  */
816 static void ast_ari_channels_unhold_cb(
817         struct ast_variable *get_params, struct ast_variable *path_vars,
818         struct ast_variable *headers, struct ast_ari_response *response)
819 {
820         struct ast_ari_channels_unhold_args args = {};
821         struct ast_variable *i;
822 #if defined(AST_DEVMODE)
823         int is_valid;
824         int code;
825 #endif /* AST_DEVMODE */
826
827         for (i = path_vars; i; i = i->next) {
828                 if (strcmp(i->name, "channelId") == 0) {
829                         args.channel_id = (i->value);
830                 } else
831                 {}
832         }
833         ast_ari_channels_unhold(headers, &args, response);
834 #if defined(AST_DEVMODE)
835         code = response->response_code;
836
837         switch (code) {
838         case 0: /* Implementation is still a stub, or the code wasn't set */
839                 is_valid = response->message == NULL;
840                 break;
841         case 500: /* Internal Server Error */
842         case 501: /* Not Implemented */
843         case 404: /* Channel not found */
844         case 409: /* Channel not in a Stasis application */
845                 is_valid = 1;
846                 break;
847         default:
848                 if (200 <= code && code <= 299) {
849                         is_valid = ast_ari_validate_void(
850                                 response->message);
851                 } else {
852                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/hold\n", code);
853                         is_valid = 0;
854                 }
855         }
856
857         if (!is_valid) {
858                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/hold\n");
859                 ast_ari_response_error(response, 500,
860                         "Internal Server Error", "Response validation failed");
861         }
862 #endif /* AST_DEVMODE */
863
864 fin: __attribute__((unused))
865         return;
866 }
867 /*!
868  * \brief Parameter parsing callback for /channels/{channelId}/moh.
869  * \param get_params GET parameters in the HTTP request.
870  * \param path_vars Path variables extracted from the request.
871  * \param headers HTTP headers.
872  * \param[out] response Response to the HTTP request.
873  */
874 static void ast_ari_channels_start_moh_cb(
875         struct ast_variable *get_params, struct ast_variable *path_vars,
876         struct ast_variable *headers, struct ast_ari_response *response)
877 {
878         struct ast_ari_channels_start_moh_args args = {};
879         struct ast_variable *i;
880 #if defined(AST_DEVMODE)
881         int is_valid;
882         int code;
883 #endif /* AST_DEVMODE */
884
885         for (i = get_params; i; i = i->next) {
886                 if (strcmp(i->name, "mohClass") == 0) {
887                         args.moh_class = (i->value);
888                 } else
889                 {}
890         }
891         for (i = path_vars; i; i = i->next) {
892                 if (strcmp(i->name, "channelId") == 0) {
893                         args.channel_id = (i->value);
894                 } else
895                 {}
896         }
897         ast_ari_channels_start_moh(headers, &args, response);
898 #if defined(AST_DEVMODE)
899         code = response->response_code;
900
901         switch (code) {
902         case 0: /* Implementation is still a stub, or the code wasn't set */
903                 is_valid = response->message == NULL;
904                 break;
905         case 500: /* Internal Server Error */
906         case 501: /* Not Implemented */
907         case 404: /* Channel not found */
908         case 409: /* Channel not in a Stasis application */
909                 is_valid = 1;
910                 break;
911         default:
912                 if (200 <= code && code <= 299) {
913                         is_valid = ast_ari_validate_void(
914                                 response->message);
915                 } else {
916                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/moh\n", code);
917                         is_valid = 0;
918                 }
919         }
920
921         if (!is_valid) {
922                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/moh\n");
923                 ast_ari_response_error(response, 500,
924                         "Internal Server Error", "Response validation failed");
925         }
926 #endif /* AST_DEVMODE */
927
928 fin: __attribute__((unused))
929         return;
930 }
931 /*!
932  * \brief Parameter parsing callback for /channels/{channelId}/moh.
933  * \param get_params GET parameters in the HTTP request.
934  * \param path_vars Path variables extracted from the request.
935  * \param headers HTTP headers.
936  * \param[out] response Response to the HTTP request.
937  */
938 static void ast_ari_channels_stop_moh_cb(
939         struct ast_variable *get_params, struct ast_variable *path_vars,
940         struct ast_variable *headers, struct ast_ari_response *response)
941 {
942         struct ast_ari_channels_stop_moh_args args = {};
943         struct ast_variable *i;
944 #if defined(AST_DEVMODE)
945         int is_valid;
946         int code;
947 #endif /* AST_DEVMODE */
948
949         for (i = path_vars; i; i = i->next) {
950                 if (strcmp(i->name, "channelId") == 0) {
951                         args.channel_id = (i->value);
952                 } else
953                 {}
954         }
955         ast_ari_channels_stop_moh(headers, &args, response);
956 #if defined(AST_DEVMODE)
957         code = response->response_code;
958
959         switch (code) {
960         case 0: /* Implementation is still a stub, or the code wasn't set */
961                 is_valid = response->message == NULL;
962                 break;
963         case 500: /* Internal Server Error */
964         case 501: /* Not Implemented */
965         case 404: /* Channel not found */
966         case 409: /* Channel not in a Stasis application */
967                 is_valid = 1;
968                 break;
969         default:
970                 if (200 <= code && code <= 299) {
971                         is_valid = ast_ari_validate_void(
972                                 response->message);
973                 } else {
974                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/moh\n", code);
975                         is_valid = 0;
976                 }
977         }
978
979         if (!is_valid) {
980                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/moh\n");
981                 ast_ari_response_error(response, 500,
982                         "Internal Server Error", "Response validation failed");
983         }
984 #endif /* AST_DEVMODE */
985
986 fin: __attribute__((unused))
987         return;
988 }
989 /*!
990  * \brief Parameter parsing callback for /channels/{channelId}/play.
991  * \param get_params GET parameters in the HTTP request.
992  * \param path_vars Path variables extracted from the request.
993  * \param headers HTTP headers.
994  * \param[out] response Response to the HTTP request.
995  */
996 static void ast_ari_channels_play_cb(
997         struct ast_variable *get_params, struct ast_variable *path_vars,
998         struct ast_variable *headers, struct ast_ari_response *response)
999 {
1000         struct ast_ari_channels_play_args args = {};
1001         struct ast_variable *i;
1002 #if defined(AST_DEVMODE)
1003         int is_valid;
1004         int code;
1005 #endif /* AST_DEVMODE */
1006
1007         for (i = get_params; i; i = i->next) {
1008                 if (strcmp(i->name, "media") == 0) {
1009                         args.media = (i->value);
1010                 } else
1011                 if (strcmp(i->name, "lang") == 0) {
1012                         args.lang = (i->value);
1013                 } else
1014                 if (strcmp(i->name, "offsetms") == 0) {
1015                         args.offsetms = atoi(i->value);
1016                 } else
1017                 if (strcmp(i->name, "skipms") == 0) {
1018                         args.skipms = atoi(i->value);
1019                 } else
1020                 {}
1021         }
1022         for (i = path_vars; i; i = i->next) {
1023                 if (strcmp(i->name, "channelId") == 0) {
1024                         args.channel_id = (i->value);
1025                 } else
1026                 {}
1027         }
1028         ast_ari_channels_play(headers, &args, response);
1029 #if defined(AST_DEVMODE)
1030         code = response->response_code;
1031
1032         switch (code) {
1033         case 0: /* Implementation is still a stub, or the code wasn't set */
1034                 is_valid = response->message == NULL;
1035                 break;
1036         case 500: /* Internal Server Error */
1037         case 501: /* Not Implemented */
1038         case 404: /* Channel not found */
1039         case 409: /* Channel not in a Stasis application */
1040                 is_valid = 1;
1041                 break;
1042         default:
1043                 if (200 <= code && code <= 299) {
1044                         is_valid = ast_ari_validate_playback(
1045                                 response->message);
1046                 } else {
1047                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/play\n", code);
1048                         is_valid = 0;
1049                 }
1050         }
1051
1052         if (!is_valid) {
1053                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/play\n");
1054                 ast_ari_response_error(response, 500,
1055                         "Internal Server Error", "Response validation failed");
1056         }
1057 #endif /* AST_DEVMODE */
1058
1059 fin: __attribute__((unused))
1060         return;
1061 }
1062 /*!
1063  * \brief Parameter parsing callback for /channels/{channelId}/record.
1064  * \param get_params GET parameters in the HTTP request.
1065  * \param path_vars Path variables extracted from the request.
1066  * \param headers HTTP headers.
1067  * \param[out] response Response to the HTTP request.
1068  */
1069 static void ast_ari_channels_record_cb(
1070         struct ast_variable *get_params, struct ast_variable *path_vars,
1071         struct ast_variable *headers, struct ast_ari_response *response)
1072 {
1073         struct ast_ari_channels_record_args args = {};
1074         struct ast_variable *i;
1075 #if defined(AST_DEVMODE)
1076         int is_valid;
1077         int code;
1078 #endif /* AST_DEVMODE */
1079
1080         for (i = get_params; i; i = i->next) {
1081                 if (strcmp(i->name, "name") == 0) {
1082                         args.name = (i->value);
1083                 } else
1084                 if (strcmp(i->name, "format") == 0) {
1085                         args.format = (i->value);
1086                 } else
1087                 if (strcmp(i->name, "maxDurationSeconds") == 0) {
1088                         args.max_duration_seconds = atoi(i->value);
1089                 } else
1090                 if (strcmp(i->name, "maxSilenceSeconds") == 0) {
1091                         args.max_silence_seconds = atoi(i->value);
1092                 } else
1093                 if (strcmp(i->name, "ifExists") == 0) {
1094                         args.if_exists = (i->value);
1095                 } else
1096                 if (strcmp(i->name, "beep") == 0) {
1097                         args.beep = ast_true(i->value);
1098                 } else
1099                 if (strcmp(i->name, "terminateOn") == 0) {
1100                         args.terminate_on = (i->value);
1101                 } else
1102                 {}
1103         }
1104         for (i = path_vars; i; i = i->next) {
1105                 if (strcmp(i->name, "channelId") == 0) {
1106                         args.channel_id = (i->value);
1107                 } else
1108                 {}
1109         }
1110         ast_ari_channels_record(headers, &args, response);
1111 #if defined(AST_DEVMODE)
1112         code = response->response_code;
1113
1114         switch (code) {
1115         case 0: /* Implementation is still a stub, or the code wasn't set */
1116                 is_valid = response->message == NULL;
1117                 break;
1118         case 500: /* Internal Server Error */
1119         case 501: /* Not Implemented */
1120         case 400: /* Invalid parameters */
1121         case 404: /* Channel not found */
1122         case 409: /* Channel is not in a Stasis application; the channel is currently bridged with other hcannels; A recording with the same name already exists on the system and can not be overwritten because it is in progress or ifExists=fail */
1123         case 422: /* The format specified is unknown on this system */
1124                 is_valid = 1;
1125                 break;
1126         default:
1127                 if (200 <= code && code <= 299) {
1128                         is_valid = ast_ari_validate_live_recording(
1129                                 response->message);
1130                 } else {
1131                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/record\n", code);
1132                         is_valid = 0;
1133                 }
1134         }
1135
1136         if (!is_valid) {
1137                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/record\n");
1138                 ast_ari_response_error(response, 500,
1139                         "Internal Server Error", "Response validation failed");
1140         }
1141 #endif /* AST_DEVMODE */
1142
1143 fin: __attribute__((unused))
1144         return;
1145 }
1146 /*!
1147  * \brief Parameter parsing callback for /channels/{channelId}/variable.
1148  * \param get_params GET parameters in the HTTP request.
1149  * \param path_vars Path variables extracted from the request.
1150  * \param headers HTTP headers.
1151  * \param[out] response Response to the HTTP request.
1152  */
1153 static void ast_ari_channels_get_channel_var_cb(
1154         struct ast_variable *get_params, struct ast_variable *path_vars,
1155         struct ast_variable *headers, struct ast_ari_response *response)
1156 {
1157         struct ast_ari_channels_get_channel_var_args args = {};
1158         struct ast_variable *i;
1159 #if defined(AST_DEVMODE)
1160         int is_valid;
1161         int code;
1162 #endif /* AST_DEVMODE */
1163
1164         for (i = get_params; i; i = i->next) {
1165                 if (strcmp(i->name, "variable") == 0) {
1166                         args.variable = (i->value);
1167                 } else
1168                 {}
1169         }
1170         for (i = path_vars; i; i = i->next) {
1171                 if (strcmp(i->name, "channelId") == 0) {
1172                         args.channel_id = (i->value);
1173                 } else
1174                 {}
1175         }
1176         ast_ari_channels_get_channel_var(headers, &args, response);
1177 #if defined(AST_DEVMODE)
1178         code = response->response_code;
1179
1180         switch (code) {
1181         case 0: /* Implementation is still a stub, or the code wasn't set */
1182                 is_valid = response->message == NULL;
1183                 break;
1184         case 500: /* Internal Server Error */
1185         case 501: /* Not Implemented */
1186         case 400: /* Missing variable parameter. */
1187         case 404: /* Channel not found */
1188         case 409: /* Channel not in a Stasis application */
1189                 is_valid = 1;
1190                 break;
1191         default:
1192                 if (200 <= code && code <= 299) {
1193                         is_valid = ast_ari_validate_variable(
1194                                 response->message);
1195                 } else {
1196                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/variable\n", code);
1197                         is_valid = 0;
1198                 }
1199         }
1200
1201         if (!is_valid) {
1202                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/variable\n");
1203                 ast_ari_response_error(response, 500,
1204                         "Internal Server Error", "Response validation failed");
1205         }
1206 #endif /* AST_DEVMODE */
1207
1208 fin: __attribute__((unused))
1209         return;
1210 }
1211 /*!
1212  * \brief Parameter parsing callback for /channels/{channelId}/variable.
1213  * \param get_params GET parameters in the HTTP request.
1214  * \param path_vars Path variables extracted from the request.
1215  * \param headers HTTP headers.
1216  * \param[out] response Response to the HTTP request.
1217  */
1218 static void ast_ari_channels_set_channel_var_cb(
1219         struct ast_variable *get_params, struct ast_variable *path_vars,
1220         struct ast_variable *headers, struct ast_ari_response *response)
1221 {
1222         struct ast_ari_channels_set_channel_var_args args = {};
1223         struct ast_variable *i;
1224 #if defined(AST_DEVMODE)
1225         int is_valid;
1226         int code;
1227 #endif /* AST_DEVMODE */
1228
1229         for (i = get_params; i; i = i->next) {
1230                 if (strcmp(i->name, "variable") == 0) {
1231                         args.variable = (i->value);
1232                 } else
1233                 if (strcmp(i->name, "value") == 0) {
1234                         args.value = (i->value);
1235                 } else
1236                 {}
1237         }
1238         for (i = path_vars; i; i = i->next) {
1239                 if (strcmp(i->name, "channelId") == 0) {
1240                         args.channel_id = (i->value);
1241                 } else
1242                 {}
1243         }
1244         ast_ari_channels_set_channel_var(headers, &args, response);
1245 #if defined(AST_DEVMODE)
1246         code = response->response_code;
1247
1248         switch (code) {
1249         case 0: /* Implementation is still a stub, or the code wasn't set */
1250                 is_valid = response->message == NULL;
1251                 break;
1252         case 500: /* Internal Server Error */
1253         case 501: /* Not Implemented */
1254         case 400: /* Missing variable parameter. */
1255         case 404: /* Channel not found */
1256         case 409: /* Channel not in a Stasis application */
1257                 is_valid = 1;
1258                 break;
1259         default:
1260                 if (200 <= code && code <= 299) {
1261                         is_valid = ast_ari_validate_void(
1262                                 response->message);
1263                 } else {
1264                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/variable\n", code);
1265                         is_valid = 0;
1266                 }
1267         }
1268
1269         if (!is_valid) {
1270                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/variable\n");
1271                 ast_ari_response_error(response, 500,
1272                         "Internal Server Error", "Response validation failed");
1273         }
1274 #endif /* AST_DEVMODE */
1275
1276 fin: __attribute__((unused))
1277         return;
1278 }
1279
1280 /*! \brief REST handler for /api-docs/channels.{format} */
1281 static struct stasis_rest_handlers channels_channelId_continue = {
1282         .path_segment = "continue",
1283         .callbacks = {
1284                 [AST_HTTP_POST] = ast_ari_channels_continue_in_dialplan_cb,
1285         },
1286         .num_children = 0,
1287         .children = {  }
1288 };
1289 /*! \brief REST handler for /api-docs/channels.{format} */
1290 static struct stasis_rest_handlers channels_channelId_answer = {
1291         .path_segment = "answer",
1292         .callbacks = {
1293                 [AST_HTTP_POST] = ast_ari_channels_answer_cb,
1294         },
1295         .num_children = 0,
1296         .children = {  }
1297 };
1298 /*! \brief REST handler for /api-docs/channels.{format} */
1299 static struct stasis_rest_handlers channels_channelId_ring = {
1300         .path_segment = "ring",
1301         .callbacks = {
1302                 [AST_HTTP_POST] = ast_ari_channels_ring_cb,
1303                 [AST_HTTP_DELETE] = ast_ari_channels_ring_stop_cb,
1304         },
1305         .num_children = 0,
1306         .children = {  }
1307 };
1308 /*! \brief REST handler for /api-docs/channels.{format} */
1309 static struct stasis_rest_handlers channels_channelId_dtmf = {
1310         .path_segment = "dtmf",
1311         .callbacks = {
1312                 [AST_HTTP_POST] = ast_ari_channels_send_dtmf_cb,
1313         },
1314         .num_children = 0,
1315         .children = {  }
1316 };
1317 /*! \brief REST handler for /api-docs/channels.{format} */
1318 static struct stasis_rest_handlers channels_channelId_mute = {
1319         .path_segment = "mute",
1320         .callbacks = {
1321                 [AST_HTTP_POST] = ast_ari_channels_mute_cb,
1322                 [AST_HTTP_DELETE] = ast_ari_channels_unmute_cb,
1323         },
1324         .num_children = 0,
1325         .children = {  }
1326 };
1327 /*! \brief REST handler for /api-docs/channels.{format} */
1328 static struct stasis_rest_handlers channels_channelId_hold = {
1329         .path_segment = "hold",
1330         .callbacks = {
1331                 [AST_HTTP_POST] = ast_ari_channels_hold_cb,
1332                 [AST_HTTP_DELETE] = ast_ari_channels_unhold_cb,
1333         },
1334         .num_children = 0,
1335         .children = {  }
1336 };
1337 /*! \brief REST handler for /api-docs/channels.{format} */
1338 static struct stasis_rest_handlers channels_channelId_moh = {
1339         .path_segment = "moh",
1340         .callbacks = {
1341                 [AST_HTTP_POST] = ast_ari_channels_start_moh_cb,
1342                 [AST_HTTP_DELETE] = ast_ari_channels_stop_moh_cb,
1343         },
1344         .num_children = 0,
1345         .children = {  }
1346 };
1347 /*! \brief REST handler for /api-docs/channels.{format} */
1348 static struct stasis_rest_handlers channels_channelId_play = {
1349         .path_segment = "play",
1350         .callbacks = {
1351                 [AST_HTTP_POST] = ast_ari_channels_play_cb,
1352         },
1353         .num_children = 0,
1354         .children = {  }
1355 };
1356 /*! \brief REST handler for /api-docs/channels.{format} */
1357 static struct stasis_rest_handlers channels_channelId_record = {
1358         .path_segment = "record",
1359         .callbacks = {
1360                 [AST_HTTP_POST] = ast_ari_channels_record_cb,
1361         },
1362         .num_children = 0,
1363         .children = {  }
1364 };
1365 /*! \brief REST handler for /api-docs/channels.{format} */
1366 static struct stasis_rest_handlers channels_channelId_variable = {
1367         .path_segment = "variable",
1368         .callbacks = {
1369                 [AST_HTTP_GET] = ast_ari_channels_get_channel_var_cb,
1370                 [AST_HTTP_POST] = ast_ari_channels_set_channel_var_cb,
1371         },
1372         .num_children = 0,
1373         .children = {  }
1374 };
1375 /*! \brief REST handler for /api-docs/channels.{format} */
1376 static struct stasis_rest_handlers channels_channelId = {
1377         .path_segment = "channelId",
1378         .is_wildcard = 1,
1379         .callbacks = {
1380                 [AST_HTTP_GET] = ast_ari_channels_get_cb,
1381                 [AST_HTTP_DELETE] = ast_ari_channels_hangup_cb,
1382         },
1383         .num_children = 10,
1384         .children = { &channels_channelId_continue,&channels_channelId_answer,&channels_channelId_ring,&channels_channelId_dtmf,&channels_channelId_mute,&channels_channelId_hold,&channels_channelId_moh,&channels_channelId_play,&channels_channelId_record,&channels_channelId_variable, }
1385 };
1386 /*! \brief REST handler for /api-docs/channels.{format} */
1387 static struct stasis_rest_handlers channels = {
1388         .path_segment = "channels",
1389         .callbacks = {
1390                 [AST_HTTP_GET] = ast_ari_channels_list_cb,
1391                 [AST_HTTP_POST] = ast_ari_channels_originate_cb,
1392         },
1393         .num_children = 1,
1394         .children = { &channels_channelId, }
1395 };
1396
1397 static int load_module(void)
1398 {
1399         int res = 0;
1400         stasis_app_ref();
1401         res |= ast_ari_add_handler(&channels);
1402         return res;
1403 }
1404
1405 static int unload_module(void)
1406 {
1407         ast_ari_remove_handler(&channels);
1408         stasis_app_unref();
1409         return 0;
1410 }
1411
1412 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Channel resources",
1413         .load = load_module,
1414         .unload = unload_module,
1415         .nonoptreq = "res_ari,res_stasis",
1416         );