0657fa31156b2cdc97927ee3ea353cb1be6aacf1
[asterisk/asterisk.git] / res / res_ari_recordings.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 Recording 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_recordings.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 /recordings/stored.
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_recordings_list_stored_cb(
62         struct ast_tcptls_session_instance *ser,
63         struct ast_variable *get_params, struct ast_variable *path_vars,
64         struct ast_variable *headers, struct ast_ari_response *response)
65 {
66         struct ast_ari_recordings_list_stored_args args = {};
67         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
68 #if defined(AST_DEVMODE)
69         int is_valid;
70         int code;
71 #endif /* AST_DEVMODE */
72
73         ast_ari_recordings_list_stored(headers, &args, response);
74 #if defined(AST_DEVMODE)
75         code = response->response_code;
76
77         switch (code) {
78         case 0: /* Implementation is still a stub, or the code wasn't set */
79                 is_valid = response->message == NULL;
80                 break;
81         case 500: /* Internal Server Error */
82         case 501: /* Not Implemented */
83                 is_valid = 1;
84                 break;
85         default:
86                 if (200 <= code && code <= 299) {
87                         is_valid = ast_ari_validate_list(response->message,
88                                 ast_ari_validate_stored_recording_fn());
89                 } else {
90                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored\n", code);
91                         is_valid = 0;
92                 }
93         }
94
95         if (!is_valid) {
96                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored\n");
97                 ast_ari_response_error(response, 500,
98                         "Internal Server Error", "Response validation failed");
99         }
100 #endif /* AST_DEVMODE */
101
102 fin: __attribute__((unused))
103         return;
104 }
105 /*!
106  * \brief Parameter parsing callback for /recordings/stored/{recordingName}.
107  * \param get_params GET parameters in the HTTP request.
108  * \param path_vars Path variables extracted from the request.
109  * \param headers HTTP headers.
110  * \param[out] response Response to the HTTP request.
111  */
112 static void ast_ari_recordings_get_stored_cb(
113         struct ast_tcptls_session_instance *ser,
114         struct ast_variable *get_params, struct ast_variable *path_vars,
115         struct ast_variable *headers, struct ast_ari_response *response)
116 {
117         struct ast_ari_recordings_get_stored_args args = {};
118         struct ast_variable *i;
119         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
120 #if defined(AST_DEVMODE)
121         int is_valid;
122         int code;
123 #endif /* AST_DEVMODE */
124
125         for (i = path_vars; i; i = i->next) {
126                 if (strcmp(i->name, "recordingName") == 0) {
127                         args.recording_name = (i->value);
128                 } else
129                 {}
130         }
131         ast_ari_recordings_get_stored(headers, &args, response);
132 #if defined(AST_DEVMODE)
133         code = response->response_code;
134
135         switch (code) {
136         case 0: /* Implementation is still a stub, or the code wasn't set */
137                 is_valid = response->message == NULL;
138                 break;
139         case 500: /* Internal Server Error */
140         case 501: /* Not Implemented */
141         case 404: /* Recording not found */
142                 is_valid = 1;
143                 break;
144         default:
145                 if (200 <= code && code <= 299) {
146                         is_valid = ast_ari_validate_stored_recording(
147                                 response->message);
148                 } else {
149                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
150                         is_valid = 0;
151                 }
152         }
153
154         if (!is_valid) {
155                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
156                 ast_ari_response_error(response, 500,
157                         "Internal Server Error", "Response validation failed");
158         }
159 #endif /* AST_DEVMODE */
160
161 fin: __attribute__((unused))
162         return;
163 }
164 /*!
165  * \brief Parameter parsing callback for /recordings/stored/{recordingName}.
166  * \param get_params GET parameters in the HTTP request.
167  * \param path_vars Path variables extracted from the request.
168  * \param headers HTTP headers.
169  * \param[out] response Response to the HTTP request.
170  */
171 static void ast_ari_recordings_delete_stored_cb(
172         struct ast_tcptls_session_instance *ser,
173         struct ast_variable *get_params, struct ast_variable *path_vars,
174         struct ast_variable *headers, struct ast_ari_response *response)
175 {
176         struct ast_ari_recordings_delete_stored_args args = {};
177         struct ast_variable *i;
178         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
179 #if defined(AST_DEVMODE)
180         int is_valid;
181         int code;
182 #endif /* AST_DEVMODE */
183
184         for (i = path_vars; i; i = i->next) {
185                 if (strcmp(i->name, "recordingName") == 0) {
186                         args.recording_name = (i->value);
187                 } else
188                 {}
189         }
190         ast_ari_recordings_delete_stored(headers, &args, response);
191 #if defined(AST_DEVMODE)
192         code = response->response_code;
193
194         switch (code) {
195         case 0: /* Implementation is still a stub, or the code wasn't set */
196                 is_valid = response->message == NULL;
197                 break;
198         case 500: /* Internal Server Error */
199         case 501: /* Not Implemented */
200         case 404: /* Recording not found */
201                 is_valid = 1;
202                 break;
203         default:
204                 if (200 <= code && code <= 299) {
205                         is_valid = ast_ari_validate_void(
206                                 response->message);
207                 } else {
208                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
209                         is_valid = 0;
210                 }
211         }
212
213         if (!is_valid) {
214                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
215                 ast_ari_response_error(response, 500,
216                         "Internal Server Error", "Response validation failed");
217         }
218 #endif /* AST_DEVMODE */
219
220 fin: __attribute__((unused))
221         return;
222 }
223 int ast_ari_recordings_copy_stored_parse_body(
224         struct ast_json *body,
225         struct ast_ari_recordings_copy_stored_args *args)
226 {
227         struct ast_json *field;
228         /* Parse query parameters out of it */
229         field = ast_json_object_get(body, "destinationRecordingName");
230         if (field) {
231                 args->destination_recording_name = ast_json_string_get(field);
232         }
233         return 0;
234 }
235
236 /*!
237  * \brief Parameter parsing callback for /recordings/stored/{recordingName}/copy.
238  * \param get_params GET parameters in the HTTP request.
239  * \param path_vars Path variables extracted from the request.
240  * \param headers HTTP headers.
241  * \param[out] response Response to the HTTP request.
242  */
243 static void ast_ari_recordings_copy_stored_cb(
244         struct ast_tcptls_session_instance *ser,
245         struct ast_variable *get_params, struct ast_variable *path_vars,
246         struct ast_variable *headers, struct ast_ari_response *response)
247 {
248         struct ast_ari_recordings_copy_stored_args args = {};
249         struct ast_variable *i;
250         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
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, "destinationRecordingName") == 0) {
258                         args.destination_recording_name = (i->value);
259                 } else
260                 {}
261         }
262         for (i = path_vars; i; i = i->next) {
263                 if (strcmp(i->name, "recordingName") == 0) {
264                         args.recording_name = (i->value);
265                 } else
266                 {}
267         }
268         /* Look for a JSON request entity */
269         body = ast_http_get_json(ser, headers);
270         if (!body) {
271                 switch (errno) {
272                 case EFBIG:
273                         ast_ari_response_error(response, 413, "Request Entity Too Large", "Request body too large");
274                         goto fin;
275                 case ENOMEM:
276                         ast_ari_response_error(response, 500, "Internal Server Error", "Error processing request");
277                         goto fin;
278                 case EIO:
279                         ast_ari_response_error(response, 400, "Bad Request", "Error parsing request body");
280                         goto fin;
281                 }
282         }
283         if (ast_ari_recordings_copy_stored_parse_body(body, &args)) {
284                 ast_ari_response_alloc_failed(response);
285                 goto fin;
286         }
287         ast_ari_recordings_copy_stored(headers, &args, response);
288 #if defined(AST_DEVMODE)
289         code = response->response_code;
290
291         switch (code) {
292         case 0: /* Implementation is still a stub, or the code wasn't set */
293                 is_valid = response->message == NULL;
294                 break;
295         case 500: /* Internal Server Error */
296         case 501: /* Not Implemented */
297         case 404: /* Recording not found */
298         case 409: /* A recording with the same name already exists on the system */
299                 is_valid = 1;
300                 break;
301         default:
302                 if (200 <= code && code <= 299) {
303                         is_valid = ast_ari_validate_stored_recording(
304                                 response->message);
305                 } else {
306                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}/copy\n", code);
307                         is_valid = 0;
308                 }
309         }
310
311         if (!is_valid) {
312                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}/copy\n");
313                 ast_ari_response_error(response, 500,
314                         "Internal Server Error", "Response validation failed");
315         }
316 #endif /* AST_DEVMODE */
317
318 fin: __attribute__((unused))
319         return;
320 }
321 /*!
322  * \brief Parameter parsing callback for /recordings/live/{recordingName}.
323  * \param get_params GET parameters in the HTTP request.
324  * \param path_vars Path variables extracted from the request.
325  * \param headers HTTP headers.
326  * \param[out] response Response to the HTTP request.
327  */
328 static void ast_ari_recordings_get_live_cb(
329         struct ast_tcptls_session_instance *ser,
330         struct ast_variable *get_params, struct ast_variable *path_vars,
331         struct ast_variable *headers, struct ast_ari_response *response)
332 {
333         struct ast_ari_recordings_get_live_args args = {};
334         struct ast_variable *i;
335         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
336 #if defined(AST_DEVMODE)
337         int is_valid;
338         int code;
339 #endif /* AST_DEVMODE */
340
341         for (i = path_vars; i; i = i->next) {
342                 if (strcmp(i->name, "recordingName") == 0) {
343                         args.recording_name = (i->value);
344                 } else
345                 {}
346         }
347         ast_ari_recordings_get_live(headers, &args, response);
348 #if defined(AST_DEVMODE)
349         code = response->response_code;
350
351         switch (code) {
352         case 0: /* Implementation is still a stub, or the code wasn't set */
353                 is_valid = response->message == NULL;
354                 break;
355         case 500: /* Internal Server Error */
356         case 501: /* Not Implemented */
357         case 404: /* Recording not found */
358                 is_valid = 1;
359                 break;
360         default:
361                 if (200 <= code && code <= 299) {
362                         is_valid = ast_ari_validate_live_recording(
363                                 response->message);
364                 } else {
365                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
366                         is_valid = 0;
367                 }
368         }
369
370         if (!is_valid) {
371                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
372                 ast_ari_response_error(response, 500,
373                         "Internal Server Error", "Response validation failed");
374         }
375 #endif /* AST_DEVMODE */
376
377 fin: __attribute__((unused))
378         return;
379 }
380 /*!
381  * \brief Parameter parsing callback for /recordings/live/{recordingName}.
382  * \param get_params GET parameters in the HTTP request.
383  * \param path_vars Path variables extracted from the request.
384  * \param headers HTTP headers.
385  * \param[out] response Response to the HTTP request.
386  */
387 static void ast_ari_recordings_cancel_cb(
388         struct ast_tcptls_session_instance *ser,
389         struct ast_variable *get_params, struct ast_variable *path_vars,
390         struct ast_variable *headers, struct ast_ari_response *response)
391 {
392         struct ast_ari_recordings_cancel_args args = {};
393         struct ast_variable *i;
394         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
395 #if defined(AST_DEVMODE)
396         int is_valid;
397         int code;
398 #endif /* AST_DEVMODE */
399
400         for (i = path_vars; i; i = i->next) {
401                 if (strcmp(i->name, "recordingName") == 0) {
402                         args.recording_name = (i->value);
403                 } else
404                 {}
405         }
406         ast_ari_recordings_cancel(headers, &args, response);
407 #if defined(AST_DEVMODE)
408         code = response->response_code;
409
410         switch (code) {
411         case 0: /* Implementation is still a stub, or the code wasn't set */
412                 is_valid = response->message == NULL;
413                 break;
414         case 500: /* Internal Server Error */
415         case 501: /* Not Implemented */
416         case 404: /* Recording not found */
417                 is_valid = 1;
418                 break;
419         default:
420                 if (200 <= code && code <= 299) {
421                         is_valid = ast_ari_validate_void(
422                                 response->message);
423                 } else {
424                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}\n", code);
425                         is_valid = 0;
426                 }
427         }
428
429         if (!is_valid) {
430                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}\n");
431                 ast_ari_response_error(response, 500,
432                         "Internal Server Error", "Response validation failed");
433         }
434 #endif /* AST_DEVMODE */
435
436 fin: __attribute__((unused))
437         return;
438 }
439 /*!
440  * \brief Parameter parsing callback for /recordings/live/{recordingName}/stop.
441  * \param get_params GET parameters in the HTTP request.
442  * \param path_vars Path variables extracted from the request.
443  * \param headers HTTP headers.
444  * \param[out] response Response to the HTTP request.
445  */
446 static void ast_ari_recordings_stop_cb(
447         struct ast_tcptls_session_instance *ser,
448         struct ast_variable *get_params, struct ast_variable *path_vars,
449         struct ast_variable *headers, struct ast_ari_response *response)
450 {
451         struct ast_ari_recordings_stop_args args = {};
452         struct ast_variable *i;
453         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
454 #if defined(AST_DEVMODE)
455         int is_valid;
456         int code;
457 #endif /* AST_DEVMODE */
458
459         for (i = path_vars; i; i = i->next) {
460                 if (strcmp(i->name, "recordingName") == 0) {
461                         args.recording_name = (i->value);
462                 } else
463                 {}
464         }
465         ast_ari_recordings_stop(headers, &args, response);
466 #if defined(AST_DEVMODE)
467         code = response->response_code;
468
469         switch (code) {
470         case 0: /* Implementation is still a stub, or the code wasn't set */
471                 is_valid = response->message == NULL;
472                 break;
473         case 500: /* Internal Server Error */
474         case 501: /* Not Implemented */
475         case 404: /* Recording not found */
476                 is_valid = 1;
477                 break;
478         default:
479                 if (200 <= code && code <= 299) {
480                         is_valid = ast_ari_validate_void(
481                                 response->message);
482                 } else {
483                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/stop\n", code);
484                         is_valid = 0;
485                 }
486         }
487
488         if (!is_valid) {
489                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/stop\n");
490                 ast_ari_response_error(response, 500,
491                         "Internal Server Error", "Response validation failed");
492         }
493 #endif /* AST_DEVMODE */
494
495 fin: __attribute__((unused))
496         return;
497 }
498 /*!
499  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
500  * \param get_params GET parameters in the HTTP request.
501  * \param path_vars Path variables extracted from the request.
502  * \param headers HTTP headers.
503  * \param[out] response Response to the HTTP request.
504  */
505 static void ast_ari_recordings_pause_cb(
506         struct ast_tcptls_session_instance *ser,
507         struct ast_variable *get_params, struct ast_variable *path_vars,
508         struct ast_variable *headers, struct ast_ari_response *response)
509 {
510         struct ast_ari_recordings_pause_args args = {};
511         struct ast_variable *i;
512         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
513 #if defined(AST_DEVMODE)
514         int is_valid;
515         int code;
516 #endif /* AST_DEVMODE */
517
518         for (i = path_vars; i; i = i->next) {
519                 if (strcmp(i->name, "recordingName") == 0) {
520                         args.recording_name = (i->value);
521                 } else
522                 {}
523         }
524         ast_ari_recordings_pause(headers, &args, response);
525 #if defined(AST_DEVMODE)
526         code = response->response_code;
527
528         switch (code) {
529         case 0: /* Implementation is still a stub, or the code wasn't set */
530                 is_valid = response->message == NULL;
531                 break;
532         case 500: /* Internal Server Error */
533         case 501: /* Not Implemented */
534         case 404: /* Recording not found */
535         case 409: /* Recording not in session */
536                 is_valid = 1;
537                 break;
538         default:
539                 if (200 <= code && code <= 299) {
540                         is_valid = ast_ari_validate_void(
541                                 response->message);
542                 } else {
543                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
544                         is_valid = 0;
545                 }
546         }
547
548         if (!is_valid) {
549                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
550                 ast_ari_response_error(response, 500,
551                         "Internal Server Error", "Response validation failed");
552         }
553 #endif /* AST_DEVMODE */
554
555 fin: __attribute__((unused))
556         return;
557 }
558 /*!
559  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
560  * \param get_params GET parameters in the HTTP request.
561  * \param path_vars Path variables extracted from the request.
562  * \param headers HTTP headers.
563  * \param[out] response Response to the HTTP request.
564  */
565 static void ast_ari_recordings_unpause_cb(
566         struct ast_tcptls_session_instance *ser,
567         struct ast_variable *get_params, struct ast_variable *path_vars,
568         struct ast_variable *headers, struct ast_ari_response *response)
569 {
570         struct ast_ari_recordings_unpause_args args = {};
571         struct ast_variable *i;
572         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
573 #if defined(AST_DEVMODE)
574         int is_valid;
575         int code;
576 #endif /* AST_DEVMODE */
577
578         for (i = path_vars; i; i = i->next) {
579                 if (strcmp(i->name, "recordingName") == 0) {
580                         args.recording_name = (i->value);
581                 } else
582                 {}
583         }
584         ast_ari_recordings_unpause(headers, &args, response);
585 #if defined(AST_DEVMODE)
586         code = response->response_code;
587
588         switch (code) {
589         case 0: /* Implementation is still a stub, or the code wasn't set */
590                 is_valid = response->message == NULL;
591                 break;
592         case 500: /* Internal Server Error */
593         case 501: /* Not Implemented */
594         case 404: /* Recording not found */
595         case 409: /* Recording not in session */
596                 is_valid = 1;
597                 break;
598         default:
599                 if (200 <= code && code <= 299) {
600                         is_valid = ast_ari_validate_void(
601                                 response->message);
602                 } else {
603                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
604                         is_valid = 0;
605                 }
606         }
607
608         if (!is_valid) {
609                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
610                 ast_ari_response_error(response, 500,
611                         "Internal Server Error", "Response validation failed");
612         }
613 #endif /* AST_DEVMODE */
614
615 fin: __attribute__((unused))
616         return;
617 }
618 /*!
619  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
620  * \param get_params GET parameters in the HTTP request.
621  * \param path_vars Path variables extracted from the request.
622  * \param headers HTTP headers.
623  * \param[out] response Response to the HTTP request.
624  */
625 static void ast_ari_recordings_mute_cb(
626         struct ast_tcptls_session_instance *ser,
627         struct ast_variable *get_params, struct ast_variable *path_vars,
628         struct ast_variable *headers, struct ast_ari_response *response)
629 {
630         struct ast_ari_recordings_mute_args args = {};
631         struct ast_variable *i;
632         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
633 #if defined(AST_DEVMODE)
634         int is_valid;
635         int code;
636 #endif /* AST_DEVMODE */
637
638         for (i = path_vars; i; i = i->next) {
639                 if (strcmp(i->name, "recordingName") == 0) {
640                         args.recording_name = (i->value);
641                 } else
642                 {}
643         }
644         ast_ari_recordings_mute(headers, &args, response);
645 #if defined(AST_DEVMODE)
646         code = response->response_code;
647
648         switch (code) {
649         case 0: /* Implementation is still a stub, or the code wasn't set */
650                 is_valid = response->message == NULL;
651                 break;
652         case 500: /* Internal Server Error */
653         case 501: /* Not Implemented */
654         case 404: /* Recording not found */
655         case 409: /* Recording not in session */
656                 is_valid = 1;
657                 break;
658         default:
659                 if (200 <= code && code <= 299) {
660                         is_valid = ast_ari_validate_void(
661                                 response->message);
662                 } else {
663                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
664                         is_valid = 0;
665                 }
666         }
667
668         if (!is_valid) {
669                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
670                 ast_ari_response_error(response, 500,
671                         "Internal Server Error", "Response validation failed");
672         }
673 #endif /* AST_DEVMODE */
674
675 fin: __attribute__((unused))
676         return;
677 }
678 /*!
679  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
680  * \param get_params GET parameters in the HTTP request.
681  * \param path_vars Path variables extracted from the request.
682  * \param headers HTTP headers.
683  * \param[out] response Response to the HTTP request.
684  */
685 static void ast_ari_recordings_unmute_cb(
686         struct ast_tcptls_session_instance *ser,
687         struct ast_variable *get_params, struct ast_variable *path_vars,
688         struct ast_variable *headers, struct ast_ari_response *response)
689 {
690         struct ast_ari_recordings_unmute_args args = {};
691         struct ast_variable *i;
692         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
693 #if defined(AST_DEVMODE)
694         int is_valid;
695         int code;
696 #endif /* AST_DEVMODE */
697
698         for (i = path_vars; i; i = i->next) {
699                 if (strcmp(i->name, "recordingName") == 0) {
700                         args.recording_name = (i->value);
701                 } else
702                 {}
703         }
704         ast_ari_recordings_unmute(headers, &args, response);
705 #if defined(AST_DEVMODE)
706         code = response->response_code;
707
708         switch (code) {
709         case 0: /* Implementation is still a stub, or the code wasn't set */
710                 is_valid = response->message == NULL;
711                 break;
712         case 500: /* Internal Server Error */
713         case 501: /* Not Implemented */
714         case 404: /* Recording not found */
715         case 409: /* Recording not in session */
716                 is_valid = 1;
717                 break;
718         default:
719                 if (200 <= code && code <= 299) {
720                         is_valid = ast_ari_validate_void(
721                                 response->message);
722                 } else {
723                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
724                         is_valid = 0;
725                 }
726         }
727
728         if (!is_valid) {
729                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
730                 ast_ari_response_error(response, 500,
731                         "Internal Server Error", "Response validation failed");
732         }
733 #endif /* AST_DEVMODE */
734
735 fin: __attribute__((unused))
736         return;
737 }
738
739 /*! \brief REST handler for /api-docs/recordings.{format} */
740 static struct stasis_rest_handlers recordings_stored_recordingName_copy = {
741         .path_segment = "copy",
742         .callbacks = {
743                 [AST_HTTP_POST] = ast_ari_recordings_copy_stored_cb,
744         },
745         .num_children = 0,
746         .children = {  }
747 };
748 /*! \brief REST handler for /api-docs/recordings.{format} */
749 static struct stasis_rest_handlers recordings_stored_recordingName = {
750         .path_segment = "recordingName",
751         .is_wildcard = 1,
752         .callbacks = {
753                 [AST_HTTP_GET] = ast_ari_recordings_get_stored_cb,
754                 [AST_HTTP_DELETE] = ast_ari_recordings_delete_stored_cb,
755         },
756         .num_children = 1,
757         .children = { &recordings_stored_recordingName_copy, }
758 };
759 /*! \brief REST handler for /api-docs/recordings.{format} */
760 static struct stasis_rest_handlers recordings_stored = {
761         .path_segment = "stored",
762         .callbacks = {
763                 [AST_HTTP_GET] = ast_ari_recordings_list_stored_cb,
764         },
765         .num_children = 1,
766         .children = { &recordings_stored_recordingName, }
767 };
768 /*! \brief REST handler for /api-docs/recordings.{format} */
769 static struct stasis_rest_handlers recordings_live_recordingName_stop = {
770         .path_segment = "stop",
771         .callbacks = {
772                 [AST_HTTP_POST] = ast_ari_recordings_stop_cb,
773         },
774         .num_children = 0,
775         .children = {  }
776 };
777 /*! \brief REST handler for /api-docs/recordings.{format} */
778 static struct stasis_rest_handlers recordings_live_recordingName_pause = {
779         .path_segment = "pause",
780         .callbacks = {
781                 [AST_HTTP_POST] = ast_ari_recordings_pause_cb,
782                 [AST_HTTP_DELETE] = ast_ari_recordings_unpause_cb,
783         },
784         .num_children = 0,
785         .children = {  }
786 };
787 /*! \brief REST handler for /api-docs/recordings.{format} */
788 static struct stasis_rest_handlers recordings_live_recordingName_mute = {
789         .path_segment = "mute",
790         .callbacks = {
791                 [AST_HTTP_POST] = ast_ari_recordings_mute_cb,
792                 [AST_HTTP_DELETE] = ast_ari_recordings_unmute_cb,
793         },
794         .num_children = 0,
795         .children = {  }
796 };
797 /*! \brief REST handler for /api-docs/recordings.{format} */
798 static struct stasis_rest_handlers recordings_live_recordingName = {
799         .path_segment = "recordingName",
800         .is_wildcard = 1,
801         .callbacks = {
802                 [AST_HTTP_GET] = ast_ari_recordings_get_live_cb,
803                 [AST_HTTP_DELETE] = ast_ari_recordings_cancel_cb,
804         },
805         .num_children = 3,
806         .children = { &recordings_live_recordingName_stop,&recordings_live_recordingName_pause,&recordings_live_recordingName_mute, }
807 };
808 /*! \brief REST handler for /api-docs/recordings.{format} */
809 static struct stasis_rest_handlers recordings_live = {
810         .path_segment = "live",
811         .callbacks = {
812         },
813         .num_children = 1,
814         .children = { &recordings_live_recordingName, }
815 };
816 /*! \brief REST handler for /api-docs/recordings.{format} */
817 static struct stasis_rest_handlers recordings = {
818         .path_segment = "recordings",
819         .callbacks = {
820         },
821         .num_children = 2,
822         .children = { &recordings_stored,&recordings_live, }
823 };
824
825 static int load_module(void)
826 {
827         int res = 0;
828         stasis_app_ref();
829         res |= ast_ari_add_handler(&recordings);
830         return res;
831 }
832
833 static int unload_module(void)
834 {
835         ast_ari_remove_handler(&recordings);
836         stasis_app_unref();
837         return 0;
838 }
839
840 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Recording resources",
841         .support_level = AST_MODULE_SUPPORT_CORE,
842         .load = load_module,
843         .unload = unload_module,
844         .nonoptreq = "res_ari,res_stasis",
845         );