ari: Add Snoop operation for spying/whispering on channels.
[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}/silence.
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_start_silence_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_start_silence_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 = path_vars; i; i = i->next) {
1008                 if (strcmp(i->name, "channelId") == 0) {
1009                         args.channel_id = (i->value);
1010                 } else
1011                 {}
1012         }
1013         ast_ari_channels_start_silence(headers, &args, response);
1014 #if defined(AST_DEVMODE)
1015         code = response->response_code;
1016
1017         switch (code) {
1018         case 0: /* Implementation is still a stub, or the code wasn't set */
1019                 is_valid = response->message == NULL;
1020                 break;
1021         case 500: /* Internal Server Error */
1022         case 501: /* Not Implemented */
1023         case 404: /* Channel not found */
1024         case 409: /* Channel not in a Stasis application */
1025                 is_valid = 1;
1026                 break;
1027         default:
1028                 if (200 <= code && code <= 299) {
1029                         is_valid = ast_ari_validate_void(
1030                                 response->message);
1031                 } else {
1032                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/silence\n", code);
1033                         is_valid = 0;
1034                 }
1035         }
1036
1037         if (!is_valid) {
1038                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/silence\n");
1039                 ast_ari_response_error(response, 500,
1040                         "Internal Server Error", "Response validation failed");
1041         }
1042 #endif /* AST_DEVMODE */
1043
1044 fin: __attribute__((unused))
1045         return;
1046 }
1047 /*!
1048  * \brief Parameter parsing callback for /channels/{channelId}/silence.
1049  * \param get_params GET parameters in the HTTP request.
1050  * \param path_vars Path variables extracted from the request.
1051  * \param headers HTTP headers.
1052  * \param[out] response Response to the HTTP request.
1053  */
1054 static void ast_ari_channels_stop_silence_cb(
1055         struct ast_variable *get_params, struct ast_variable *path_vars,
1056         struct ast_variable *headers, struct ast_ari_response *response)
1057 {
1058         struct ast_ari_channels_stop_silence_args args = {};
1059         struct ast_variable *i;
1060 #if defined(AST_DEVMODE)
1061         int is_valid;
1062         int code;
1063 #endif /* AST_DEVMODE */
1064
1065         for (i = path_vars; i; i = i->next) {
1066                 if (strcmp(i->name, "channelId") == 0) {
1067                         args.channel_id = (i->value);
1068                 } else
1069                 {}
1070         }
1071         ast_ari_channels_stop_silence(headers, &args, response);
1072 #if defined(AST_DEVMODE)
1073         code = response->response_code;
1074
1075         switch (code) {
1076         case 0: /* Implementation is still a stub, or the code wasn't set */
1077                 is_valid = response->message == NULL;
1078                 break;
1079         case 500: /* Internal Server Error */
1080         case 501: /* Not Implemented */
1081         case 404: /* Channel not found */
1082         case 409: /* Channel not in a Stasis application */
1083                 is_valid = 1;
1084                 break;
1085         default:
1086                 if (200 <= code && code <= 299) {
1087                         is_valid = ast_ari_validate_void(
1088                                 response->message);
1089                 } else {
1090                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/silence\n", code);
1091                         is_valid = 0;
1092                 }
1093         }
1094
1095         if (!is_valid) {
1096                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/silence\n");
1097                 ast_ari_response_error(response, 500,
1098                         "Internal Server Error", "Response validation failed");
1099         }
1100 #endif /* AST_DEVMODE */
1101
1102 fin: __attribute__((unused))
1103         return;
1104 }
1105 /*!
1106  * \brief Parameter parsing callback for /channels/{channelId}/play.
1107  * \param get_params GET parameters in the HTTP request.
1108  * \param path_vars Path variables extracted from the request.
1109  * \param headers HTTP headers.
1110  * \param[out] response Response to the HTTP request.
1111  */
1112 static void ast_ari_channels_play_cb(
1113         struct ast_variable *get_params, struct ast_variable *path_vars,
1114         struct ast_variable *headers, struct ast_ari_response *response)
1115 {
1116         struct ast_ari_channels_play_args args = {};
1117         struct ast_variable *i;
1118 #if defined(AST_DEVMODE)
1119         int is_valid;
1120         int code;
1121 #endif /* AST_DEVMODE */
1122
1123         for (i = get_params; i; i = i->next) {
1124                 if (strcmp(i->name, "media") == 0) {
1125                         args.media = (i->value);
1126                 } else
1127                 if (strcmp(i->name, "lang") == 0) {
1128                         args.lang = (i->value);
1129                 } else
1130                 if (strcmp(i->name, "offsetms") == 0) {
1131                         args.offsetms = atoi(i->value);
1132                 } else
1133                 if (strcmp(i->name, "skipms") == 0) {
1134                         args.skipms = atoi(i->value);
1135                 } else
1136                 {}
1137         }
1138         for (i = path_vars; i; i = i->next) {
1139                 if (strcmp(i->name, "channelId") == 0) {
1140                         args.channel_id = (i->value);
1141                 } else
1142                 {}
1143         }
1144         ast_ari_channels_play(headers, &args, response);
1145 #if defined(AST_DEVMODE)
1146         code = response->response_code;
1147
1148         switch (code) {
1149         case 0: /* Implementation is still a stub, or the code wasn't set */
1150                 is_valid = response->message == NULL;
1151                 break;
1152         case 500: /* Internal Server Error */
1153         case 501: /* Not Implemented */
1154         case 404: /* Channel not found */
1155         case 409: /* Channel not in a Stasis application */
1156                 is_valid = 1;
1157                 break;
1158         default:
1159                 if (200 <= code && code <= 299) {
1160                         is_valid = ast_ari_validate_playback(
1161                                 response->message);
1162                 } else {
1163                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/play\n", code);
1164                         is_valid = 0;
1165                 }
1166         }
1167
1168         if (!is_valid) {
1169                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/play\n");
1170                 ast_ari_response_error(response, 500,
1171                         "Internal Server Error", "Response validation failed");
1172         }
1173 #endif /* AST_DEVMODE */
1174
1175 fin: __attribute__((unused))
1176         return;
1177 }
1178 /*!
1179  * \brief Parameter parsing callback for /channels/{channelId}/record.
1180  * \param get_params GET parameters in the HTTP request.
1181  * \param path_vars Path variables extracted from the request.
1182  * \param headers HTTP headers.
1183  * \param[out] response Response to the HTTP request.
1184  */
1185 static void ast_ari_channels_record_cb(
1186         struct ast_variable *get_params, struct ast_variable *path_vars,
1187         struct ast_variable *headers, struct ast_ari_response *response)
1188 {
1189         struct ast_ari_channels_record_args args = {};
1190         struct ast_variable *i;
1191 #if defined(AST_DEVMODE)
1192         int is_valid;
1193         int code;
1194 #endif /* AST_DEVMODE */
1195
1196         for (i = get_params; i; i = i->next) {
1197                 if (strcmp(i->name, "name") == 0) {
1198                         args.name = (i->value);
1199                 } else
1200                 if (strcmp(i->name, "format") == 0) {
1201                         args.format = (i->value);
1202                 } else
1203                 if (strcmp(i->name, "maxDurationSeconds") == 0) {
1204                         args.max_duration_seconds = atoi(i->value);
1205                 } else
1206                 if (strcmp(i->name, "maxSilenceSeconds") == 0) {
1207                         args.max_silence_seconds = atoi(i->value);
1208                 } else
1209                 if (strcmp(i->name, "ifExists") == 0) {
1210                         args.if_exists = (i->value);
1211                 } else
1212                 if (strcmp(i->name, "beep") == 0) {
1213                         args.beep = ast_true(i->value);
1214                 } else
1215                 if (strcmp(i->name, "terminateOn") == 0) {
1216                         args.terminate_on = (i->value);
1217                 } else
1218                 {}
1219         }
1220         for (i = path_vars; i; i = i->next) {
1221                 if (strcmp(i->name, "channelId") == 0) {
1222                         args.channel_id = (i->value);
1223                 } else
1224                 {}
1225         }
1226         ast_ari_channels_record(headers, &args, response);
1227 #if defined(AST_DEVMODE)
1228         code = response->response_code;
1229
1230         switch (code) {
1231         case 0: /* Implementation is still a stub, or the code wasn't set */
1232                 is_valid = response->message == NULL;
1233                 break;
1234         case 500: /* Internal Server Error */
1235         case 501: /* Not Implemented */
1236         case 400: /* Invalid parameters */
1237         case 404: /* Channel not found */
1238         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 */
1239         case 422: /* The format specified is unknown on this system */
1240                 is_valid = 1;
1241                 break;
1242         default:
1243                 if (200 <= code && code <= 299) {
1244                         is_valid = ast_ari_validate_live_recording(
1245                                 response->message);
1246                 } else {
1247                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/record\n", code);
1248                         is_valid = 0;
1249                 }
1250         }
1251
1252         if (!is_valid) {
1253                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/record\n");
1254                 ast_ari_response_error(response, 500,
1255                         "Internal Server Error", "Response validation failed");
1256         }
1257 #endif /* AST_DEVMODE */
1258
1259 fin: __attribute__((unused))
1260         return;
1261 }
1262 /*!
1263  * \brief Parameter parsing callback for /channels/{channelId}/variable.
1264  * \param get_params GET parameters in the HTTP request.
1265  * \param path_vars Path variables extracted from the request.
1266  * \param headers HTTP headers.
1267  * \param[out] response Response to the HTTP request.
1268  */
1269 static void ast_ari_channels_get_channel_var_cb(
1270         struct ast_variable *get_params, struct ast_variable *path_vars,
1271         struct ast_variable *headers, struct ast_ari_response *response)
1272 {
1273         struct ast_ari_channels_get_channel_var_args args = {};
1274         struct ast_variable *i;
1275 #if defined(AST_DEVMODE)
1276         int is_valid;
1277         int code;
1278 #endif /* AST_DEVMODE */
1279
1280         for (i = get_params; i; i = i->next) {
1281                 if (strcmp(i->name, "variable") == 0) {
1282                         args.variable = (i->value);
1283                 } else
1284                 {}
1285         }
1286         for (i = path_vars; i; i = i->next) {
1287                 if (strcmp(i->name, "channelId") == 0) {
1288                         args.channel_id = (i->value);
1289                 } else
1290                 {}
1291         }
1292         ast_ari_channels_get_channel_var(headers, &args, response);
1293 #if defined(AST_DEVMODE)
1294         code = response->response_code;
1295
1296         switch (code) {
1297         case 0: /* Implementation is still a stub, or the code wasn't set */
1298                 is_valid = response->message == NULL;
1299                 break;
1300         case 500: /* Internal Server Error */
1301         case 501: /* Not Implemented */
1302         case 400: /* Missing variable parameter. */
1303         case 404: /* Channel not found */
1304         case 409: /* Channel not in a Stasis application */
1305                 is_valid = 1;
1306                 break;
1307         default:
1308                 if (200 <= code && code <= 299) {
1309                         is_valid = ast_ari_validate_variable(
1310                                 response->message);
1311                 } else {
1312                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/variable\n", code);
1313                         is_valid = 0;
1314                 }
1315         }
1316
1317         if (!is_valid) {
1318                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/variable\n");
1319                 ast_ari_response_error(response, 500,
1320                         "Internal Server Error", "Response validation failed");
1321         }
1322 #endif /* AST_DEVMODE */
1323
1324 fin: __attribute__((unused))
1325         return;
1326 }
1327 /*!
1328  * \brief Parameter parsing callback for /channels/{channelId}/variable.
1329  * \param get_params GET parameters in the HTTP request.
1330  * \param path_vars Path variables extracted from the request.
1331  * \param headers HTTP headers.
1332  * \param[out] response Response to the HTTP request.
1333  */
1334 static void ast_ari_channels_set_channel_var_cb(
1335         struct ast_variable *get_params, struct ast_variable *path_vars,
1336         struct ast_variable *headers, struct ast_ari_response *response)
1337 {
1338         struct ast_ari_channels_set_channel_var_args args = {};
1339         struct ast_variable *i;
1340 #if defined(AST_DEVMODE)
1341         int is_valid;
1342         int code;
1343 #endif /* AST_DEVMODE */
1344
1345         for (i = get_params; i; i = i->next) {
1346                 if (strcmp(i->name, "variable") == 0) {
1347                         args.variable = (i->value);
1348                 } else
1349                 if (strcmp(i->name, "value") == 0) {
1350                         args.value = (i->value);
1351                 } else
1352                 {}
1353         }
1354         for (i = path_vars; i; i = i->next) {
1355                 if (strcmp(i->name, "channelId") == 0) {
1356                         args.channel_id = (i->value);
1357                 } else
1358                 {}
1359         }
1360         ast_ari_channels_set_channel_var(headers, &args, response);
1361 #if defined(AST_DEVMODE)
1362         code = response->response_code;
1363
1364         switch (code) {
1365         case 0: /* Implementation is still a stub, or the code wasn't set */
1366                 is_valid = response->message == NULL;
1367                 break;
1368         case 500: /* Internal Server Error */
1369         case 501: /* Not Implemented */
1370         case 400: /* Missing variable parameter. */
1371         case 404: /* Channel not found */
1372         case 409: /* Channel not in a Stasis application */
1373                 is_valid = 1;
1374                 break;
1375         default:
1376                 if (200 <= code && code <= 299) {
1377                         is_valid = ast_ari_validate_void(
1378                                 response->message);
1379                 } else {
1380                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/variable\n", code);
1381                         is_valid = 0;
1382                 }
1383         }
1384
1385         if (!is_valid) {
1386                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/variable\n");
1387                 ast_ari_response_error(response, 500,
1388                         "Internal Server Error", "Response validation failed");
1389         }
1390 #endif /* AST_DEVMODE */
1391
1392 fin: __attribute__((unused))
1393         return;
1394 }
1395 /*!
1396  * \brief Parameter parsing callback for /channels/{channelId}/snoop.
1397  * \param get_params GET parameters in the HTTP request.
1398  * \param path_vars Path variables extracted from the request.
1399  * \param headers HTTP headers.
1400  * \param[out] response Response to the HTTP request.
1401  */
1402 static void ast_ari_channels_snoop_channel_cb(
1403         struct ast_variable *get_params, struct ast_variable *path_vars,
1404         struct ast_variable *headers, struct ast_ari_response *response)
1405 {
1406         struct ast_ari_channels_snoop_channel_args args = {};
1407         struct ast_variable *i;
1408 #if defined(AST_DEVMODE)
1409         int is_valid;
1410         int code;
1411 #endif /* AST_DEVMODE */
1412
1413         for (i = get_params; i; i = i->next) {
1414                 if (strcmp(i->name, "spy") == 0) {
1415                         args.spy = (i->value);
1416                 } else
1417                 if (strcmp(i->name, "whisper") == 0) {
1418                         args.whisper = (i->value);
1419                 } else
1420                 if (strcmp(i->name, "app") == 0) {
1421                         args.app = (i->value);
1422                 } else
1423                 if (strcmp(i->name, "appArgs") == 0) {
1424                         args.app_args = (i->value);
1425                 } else
1426                 {}
1427         }
1428         for (i = path_vars; i; i = i->next) {
1429                 if (strcmp(i->name, "channelId") == 0) {
1430                         args.channel_id = (i->value);
1431                 } else
1432                 {}
1433         }
1434         ast_ari_channels_snoop_channel(headers, &args, response);
1435 #if defined(AST_DEVMODE)
1436         code = response->response_code;
1437
1438         switch (code) {
1439         case 0: /* Implementation is still a stub, or the code wasn't set */
1440                 is_valid = response->message == NULL;
1441                 break;
1442         case 500: /* Internal Server Error */
1443         case 501: /* Not Implemented */
1444         case 400: /* Invalid parameters */
1445         case 404: /* Channel not found */
1446                 is_valid = 1;
1447                 break;
1448         default:
1449                 if (200 <= code && code <= 299) {
1450                         is_valid = ast_ari_validate_channel(
1451                                 response->message);
1452                 } else {
1453                         ast_log(LOG_ERROR, "Invalid error response %d for /channels/{channelId}/snoop\n", code);
1454                         is_valid = 0;
1455                 }
1456         }
1457
1458         if (!is_valid) {
1459                 ast_log(LOG_ERROR, "Response validation failed for /channels/{channelId}/snoop\n");
1460                 ast_ari_response_error(response, 500,
1461                         "Internal Server Error", "Response validation failed");
1462         }
1463 #endif /* AST_DEVMODE */
1464
1465 fin: __attribute__((unused))
1466         return;
1467 }
1468
1469 /*! \brief REST handler for /api-docs/channels.{format} */
1470 static struct stasis_rest_handlers channels_channelId_continue = {
1471         .path_segment = "continue",
1472         .callbacks = {
1473                 [AST_HTTP_POST] = ast_ari_channels_continue_in_dialplan_cb,
1474         },
1475         .num_children = 0,
1476         .children = {  }
1477 };
1478 /*! \brief REST handler for /api-docs/channels.{format} */
1479 static struct stasis_rest_handlers channels_channelId_answer = {
1480         .path_segment = "answer",
1481         .callbacks = {
1482                 [AST_HTTP_POST] = ast_ari_channels_answer_cb,
1483         },
1484         .num_children = 0,
1485         .children = {  }
1486 };
1487 /*! \brief REST handler for /api-docs/channels.{format} */
1488 static struct stasis_rest_handlers channels_channelId_ring = {
1489         .path_segment = "ring",
1490         .callbacks = {
1491                 [AST_HTTP_POST] = ast_ari_channels_ring_cb,
1492                 [AST_HTTP_DELETE] = ast_ari_channels_ring_stop_cb,
1493         },
1494         .num_children = 0,
1495         .children = {  }
1496 };
1497 /*! \brief REST handler for /api-docs/channels.{format} */
1498 static struct stasis_rest_handlers channels_channelId_dtmf = {
1499         .path_segment = "dtmf",
1500         .callbacks = {
1501                 [AST_HTTP_POST] = ast_ari_channels_send_dtmf_cb,
1502         },
1503         .num_children = 0,
1504         .children = {  }
1505 };
1506 /*! \brief REST handler for /api-docs/channels.{format} */
1507 static struct stasis_rest_handlers channels_channelId_mute = {
1508         .path_segment = "mute",
1509         .callbacks = {
1510                 [AST_HTTP_POST] = ast_ari_channels_mute_cb,
1511                 [AST_HTTP_DELETE] = ast_ari_channels_unmute_cb,
1512         },
1513         .num_children = 0,
1514         .children = {  }
1515 };
1516 /*! \brief REST handler for /api-docs/channels.{format} */
1517 static struct stasis_rest_handlers channels_channelId_hold = {
1518         .path_segment = "hold",
1519         .callbacks = {
1520                 [AST_HTTP_POST] = ast_ari_channels_hold_cb,
1521                 [AST_HTTP_DELETE] = ast_ari_channels_unhold_cb,
1522         },
1523         .num_children = 0,
1524         .children = {  }
1525 };
1526 /*! \brief REST handler for /api-docs/channels.{format} */
1527 static struct stasis_rest_handlers channels_channelId_moh = {
1528         .path_segment = "moh",
1529         .callbacks = {
1530                 [AST_HTTP_POST] = ast_ari_channels_start_moh_cb,
1531                 [AST_HTTP_DELETE] = ast_ari_channels_stop_moh_cb,
1532         },
1533         .num_children = 0,
1534         .children = {  }
1535 };
1536 /*! \brief REST handler for /api-docs/channels.{format} */
1537 static struct stasis_rest_handlers channels_channelId_silence = {
1538         .path_segment = "silence",
1539         .callbacks = {
1540                 [AST_HTTP_POST] = ast_ari_channels_start_silence_cb,
1541                 [AST_HTTP_DELETE] = ast_ari_channels_stop_silence_cb,
1542         },
1543         .num_children = 0,
1544         .children = {  }
1545 };
1546 /*! \brief REST handler for /api-docs/channels.{format} */
1547 static struct stasis_rest_handlers channels_channelId_play = {
1548         .path_segment = "play",
1549         .callbacks = {
1550                 [AST_HTTP_POST] = ast_ari_channels_play_cb,
1551         },
1552         .num_children = 0,
1553         .children = {  }
1554 };
1555 /*! \brief REST handler for /api-docs/channels.{format} */
1556 static struct stasis_rest_handlers channels_channelId_record = {
1557         .path_segment = "record",
1558         .callbacks = {
1559                 [AST_HTTP_POST] = ast_ari_channels_record_cb,
1560         },
1561         .num_children = 0,
1562         .children = {  }
1563 };
1564 /*! \brief REST handler for /api-docs/channels.{format} */
1565 static struct stasis_rest_handlers channels_channelId_variable = {
1566         .path_segment = "variable",
1567         .callbacks = {
1568                 [AST_HTTP_GET] = ast_ari_channels_get_channel_var_cb,
1569                 [AST_HTTP_POST] = ast_ari_channels_set_channel_var_cb,
1570         },
1571         .num_children = 0,
1572         .children = {  }
1573 };
1574 /*! \brief REST handler for /api-docs/channels.{format} */
1575 static struct stasis_rest_handlers channels_channelId_snoop = {
1576         .path_segment = "snoop",
1577         .callbacks = {
1578                 [AST_HTTP_POST] = ast_ari_channels_snoop_channel_cb,
1579         },
1580         .num_children = 0,
1581         .children = {  }
1582 };
1583 /*! \brief REST handler for /api-docs/channels.{format} */
1584 static struct stasis_rest_handlers channels_channelId = {
1585         .path_segment = "channelId",
1586         .is_wildcard = 1,
1587         .callbacks = {
1588                 [AST_HTTP_GET] = ast_ari_channels_get_cb,
1589                 [AST_HTTP_DELETE] = ast_ari_channels_hangup_cb,
1590         },
1591         .num_children = 12,
1592         .children = { &channels_channelId_continue,&channels_channelId_answer,&channels_channelId_ring,&channels_channelId_dtmf,&channels_channelId_mute,&channels_channelId_hold,&channels_channelId_moh,&channels_channelId_silence,&channels_channelId_play,&channels_channelId_record,&channels_channelId_variable,&channels_channelId_snoop, }
1593 };
1594 /*! \brief REST handler for /api-docs/channels.{format} */
1595 static struct stasis_rest_handlers channels = {
1596         .path_segment = "channels",
1597         .callbacks = {
1598                 [AST_HTTP_GET] = ast_ari_channels_list_cb,
1599                 [AST_HTTP_POST] = ast_ari_channels_originate_cb,
1600         },
1601         .num_children = 1,
1602         .children = { &channels_channelId, }
1603 };
1604
1605 static int load_module(void)
1606 {
1607         int res = 0;
1608         stasis_app_ref();
1609         res |= ast_ari_add_handler(&channels);
1610         return res;
1611 }
1612
1613 static int unload_module(void)
1614 {
1615         ast_ari_remove_handler(&channels);
1616         stasis_app_unref();
1617         return 0;
1618 }
1619
1620 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Channel resources",
1621         .load = load_module,
1622         .unload = unload_module,
1623         .nonoptreq = "res_ari,res_stasis",
1624         );