Remove ASTERISK_REGISTER_FILE.
[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_ari_model</depend>
37         <depend type="module">res_stasis</depend>
38         <support_level>core</support_level>
39  ***/
40
41 #include "asterisk.h"
42
43 #include "asterisk/app.h"
44 #include "asterisk/module.h"
45 #include "asterisk/stasis_app.h"
46 #include "ari/resource_recordings.h"
47 #if defined(AST_DEVMODE)
48 #include "ari/ari_model_validators.h"
49 #endif
50
51 #define MAX_VALS 128
52
53 /*!
54  * \brief Parameter parsing callback for /recordings/stored.
55  * \param get_params GET parameters in the HTTP request.
56  * \param path_vars Path variables extracted from the request.
57  * \param headers HTTP headers.
58  * \param[out] response Response to the HTTP request.
59  */
60 static void ast_ari_recordings_list_stored_cb(
61         struct ast_tcptls_session_instance *ser,
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_recordings_list_stored_args args = {};
66         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
67 #if defined(AST_DEVMODE)
68         int is_valid;
69         int code;
70 #endif /* AST_DEVMODE */
71
72         ast_ari_recordings_list_stored(headers, &args, response);
73 #if defined(AST_DEVMODE)
74         code = response->response_code;
75
76         switch (code) {
77         case 0: /* Implementation is still a stub, or the code wasn't set */
78                 is_valid = response->message == NULL;
79                 break;
80         case 500: /* Internal Server Error */
81         case 501: /* Not Implemented */
82                 is_valid = 1;
83                 break;
84         default:
85                 if (200 <= code && code <= 299) {
86                         is_valid = ast_ari_validate_list(response->message,
87                                 ast_ari_validate_stored_recording_fn());
88                 } else {
89                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored\n", code);
90                         is_valid = 0;
91                 }
92         }
93
94         if (!is_valid) {
95                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored\n");
96                 ast_ari_response_error(response, 500,
97                         "Internal Server Error", "Response validation failed");
98         }
99 #endif /* AST_DEVMODE */
100
101 fin: __attribute__((unused))
102         return;
103 }
104 /*!
105  * \brief Parameter parsing callback for /recordings/stored/{recordingName}.
106  * \param get_params GET parameters in the HTTP request.
107  * \param path_vars Path variables extracted from the request.
108  * \param headers HTTP headers.
109  * \param[out] response Response to the HTTP request.
110  */
111 static void ast_ari_recordings_get_stored_cb(
112         struct ast_tcptls_session_instance *ser,
113         struct ast_variable *get_params, struct ast_variable *path_vars,
114         struct ast_variable *headers, struct ast_ari_response *response)
115 {
116         struct ast_ari_recordings_get_stored_args args = {};
117         struct ast_variable *i;
118         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
119 #if defined(AST_DEVMODE)
120         int is_valid;
121         int code;
122 #endif /* AST_DEVMODE */
123
124         for (i = path_vars; i; i = i->next) {
125                 if (strcmp(i->name, "recordingName") == 0) {
126                         args.recording_name = (i->value);
127                 } else
128                 {}
129         }
130         ast_ari_recordings_get_stored(headers, &args, response);
131 #if defined(AST_DEVMODE)
132         code = response->response_code;
133
134         switch (code) {
135         case 0: /* Implementation is still a stub, or the code wasn't set */
136                 is_valid = response->message == NULL;
137                 break;
138         case 500: /* Internal Server Error */
139         case 501: /* Not Implemented */
140         case 404: /* Recording not found */
141                 is_valid = 1;
142                 break;
143         default:
144                 if (200 <= code && code <= 299) {
145                         is_valid = ast_ari_validate_stored_recording(
146                                 response->message);
147                 } else {
148                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
149                         is_valid = 0;
150                 }
151         }
152
153         if (!is_valid) {
154                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
155                 ast_ari_response_error(response, 500,
156                         "Internal Server Error", "Response validation failed");
157         }
158 #endif /* AST_DEVMODE */
159
160 fin: __attribute__((unused))
161         return;
162 }
163 /*!
164  * \brief Parameter parsing callback for /recordings/stored/{recordingName}.
165  * \param get_params GET parameters in the HTTP request.
166  * \param path_vars Path variables extracted from the request.
167  * \param headers HTTP headers.
168  * \param[out] response Response to the HTTP request.
169  */
170 static void ast_ari_recordings_delete_stored_cb(
171         struct ast_tcptls_session_instance *ser,
172         struct ast_variable *get_params, struct ast_variable *path_vars,
173         struct ast_variable *headers, struct ast_ari_response *response)
174 {
175         struct ast_ari_recordings_delete_stored_args args = {};
176         struct ast_variable *i;
177         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
178 #if defined(AST_DEVMODE)
179         int is_valid;
180         int code;
181 #endif /* AST_DEVMODE */
182
183         for (i = path_vars; i; i = i->next) {
184                 if (strcmp(i->name, "recordingName") == 0) {
185                         args.recording_name = (i->value);
186                 } else
187                 {}
188         }
189         ast_ari_recordings_delete_stored(headers, &args, response);
190 #if defined(AST_DEVMODE)
191         code = response->response_code;
192
193         switch (code) {
194         case 0: /* Implementation is still a stub, or the code wasn't set */
195                 is_valid = response->message == NULL;
196                 break;
197         case 500: /* Internal Server Error */
198         case 501: /* Not Implemented */
199         case 404: /* Recording not found */
200                 is_valid = 1;
201                 break;
202         default:
203                 if (200 <= code && code <= 299) {
204                         is_valid = ast_ari_validate_void(
205                                 response->message);
206                 } else {
207                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}\n", code);
208                         is_valid = 0;
209                 }
210         }
211
212         if (!is_valid) {
213                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}\n");
214                 ast_ari_response_error(response, 500,
215                         "Internal Server Error", "Response validation failed");
216         }
217 #endif /* AST_DEVMODE */
218
219 fin: __attribute__((unused))
220         return;
221 }
222 /*!
223  * \brief Parameter parsing callback for /recordings/stored/{recordingName}/file.
224  * \param get_params GET parameters in the HTTP request.
225  * \param path_vars Path variables extracted from the request.
226  * \param headers HTTP headers.
227  * \param[out] response Response to the HTTP request.
228  */
229 static void ast_ari_recordings_get_stored_file_cb(
230         struct ast_tcptls_session_instance *ser,
231         struct ast_variable *get_params, struct ast_variable *path_vars,
232         struct ast_variable *headers, struct ast_ari_response *response)
233 {
234         struct ast_ari_recordings_get_stored_file_args args = {};
235         struct ast_variable *i;
236         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
237 #if defined(AST_DEVMODE)
238         int is_valid;
239         int code;
240 #endif /* AST_DEVMODE */
241
242         for (i = path_vars; i; i = i->next) {
243                 if (strcmp(i->name, "recordingName") == 0) {
244                         args.recording_name = (i->value);
245                 } else
246                 {}
247         }
248         ast_ari_recordings_get_stored_file(ser, headers, &args, response);
249 #if defined(AST_DEVMODE)
250         code = response->response_code;
251
252         switch (code) {
253         case 0: /* Implementation is still a stub, or the code wasn't set */
254                 is_valid = response->message == NULL;
255                 break;
256         case 500: /* Internal Server Error */
257         case 501: /* Not Implemented */
258         case 403: /* The recording file could not be opened */
259         case 404: /* Recording not found */
260                 is_valid = 1;
261                 break;
262         default:
263                 if (200 <= code && code <= 299) {
264                         /* No validation on a raw binary response */
265                         is_valid = 1;
266                 } else {
267                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}/file\n", code);
268                         is_valid = 0;
269                 }
270         }
271
272         if (!is_valid) {
273                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}/file\n");
274                 ast_ari_response_error(response, 500,
275                         "Internal Server Error", "Response validation failed");
276         }
277 #endif /* AST_DEVMODE */
278
279 fin: __attribute__((unused))
280         return;
281 }
282 int ast_ari_recordings_copy_stored_parse_body(
283         struct ast_json *body,
284         struct ast_ari_recordings_copy_stored_args *args)
285 {
286         struct ast_json *field;
287         /* Parse query parameters out of it */
288         field = ast_json_object_get(body, "destinationRecordingName");
289         if (field) {
290                 args->destination_recording_name = ast_json_string_get(field);
291         }
292         return 0;
293 }
294
295 /*!
296  * \brief Parameter parsing callback for /recordings/stored/{recordingName}/copy.
297  * \param get_params GET parameters in the HTTP request.
298  * \param path_vars Path variables extracted from the request.
299  * \param headers HTTP headers.
300  * \param[out] response Response to the HTTP request.
301  */
302 static void ast_ari_recordings_copy_stored_cb(
303         struct ast_tcptls_session_instance *ser,
304         struct ast_variable *get_params, struct ast_variable *path_vars,
305         struct ast_variable *headers, struct ast_ari_response *response)
306 {
307         struct ast_ari_recordings_copy_stored_args args = {};
308         struct ast_variable *i;
309         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
310 #if defined(AST_DEVMODE)
311         int is_valid;
312         int code;
313 #endif /* AST_DEVMODE */
314
315         for (i = get_params; i; i = i->next) {
316                 if (strcmp(i->name, "destinationRecordingName") == 0) {
317                         args.destination_recording_name = (i->value);
318                 } else
319                 {}
320         }
321         for (i = path_vars; i; i = i->next) {
322                 if (strcmp(i->name, "recordingName") == 0) {
323                         args.recording_name = (i->value);
324                 } else
325                 {}
326         }
327         /* Look for a JSON request entity */
328         body = ast_http_get_json(ser, headers);
329         if (!body) {
330                 switch (errno) {
331                 case EFBIG:
332                         ast_ari_response_error(response, 413, "Request Entity Too Large", "Request body too large");
333                         goto fin;
334                 case ENOMEM:
335                         ast_ari_response_error(response, 500, "Internal Server Error", "Error processing request");
336                         goto fin;
337                 case EIO:
338                         ast_ari_response_error(response, 400, "Bad Request", "Error parsing request body");
339                         goto fin;
340                 }
341         }
342         if (ast_ari_recordings_copy_stored_parse_body(body, &args)) {
343                 ast_ari_response_alloc_failed(response);
344                 goto fin;
345         }
346         ast_ari_recordings_copy_stored(headers, &args, response);
347 #if defined(AST_DEVMODE)
348         code = response->response_code;
349
350         switch (code) {
351         case 0: /* Implementation is still a stub, or the code wasn't set */
352                 is_valid = response->message == NULL;
353                 break;
354         case 500: /* Internal Server Error */
355         case 501: /* Not Implemented */
356         case 404: /* Recording not found */
357         case 409: /* A recording with the same name already exists on the system */
358                 is_valid = 1;
359                 break;
360         default:
361                 if (200 <= code && code <= 299) {
362                         is_valid = ast_ari_validate_stored_recording(
363                                 response->message);
364                 } else {
365                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/stored/{recordingName}/copy\n", code);
366                         is_valid = 0;
367                 }
368         }
369
370         if (!is_valid) {
371                 ast_log(LOG_ERROR, "Response validation failed for /recordings/stored/{recordingName}/copy\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_get_live_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_get_live_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_get_live(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_live_recording(
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}.
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_cancel_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_cancel_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_cancel(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}\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}\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}/stop.
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_stop_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_stop_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_stop(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                 is_valid = 1;
536                 break;
537         default:
538                 if (200 <= code && code <= 299) {
539                         is_valid = ast_ari_validate_void(
540                                 response->message);
541                 } else {
542                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/stop\n", code);
543                         is_valid = 0;
544                 }
545         }
546
547         if (!is_valid) {
548                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/stop\n");
549                 ast_ari_response_error(response, 500,
550                         "Internal Server Error", "Response validation failed");
551         }
552 #endif /* AST_DEVMODE */
553
554 fin: __attribute__((unused))
555         return;
556 }
557 /*!
558  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
559  * \param get_params GET parameters in the HTTP request.
560  * \param path_vars Path variables extracted from the request.
561  * \param headers HTTP headers.
562  * \param[out] response Response to the HTTP request.
563  */
564 static void ast_ari_recordings_pause_cb(
565         struct ast_tcptls_session_instance *ser,
566         struct ast_variable *get_params, struct ast_variable *path_vars,
567         struct ast_variable *headers, struct ast_ari_response *response)
568 {
569         struct ast_ari_recordings_pause_args args = {};
570         struct ast_variable *i;
571         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
572 #if defined(AST_DEVMODE)
573         int is_valid;
574         int code;
575 #endif /* AST_DEVMODE */
576
577         for (i = path_vars; i; i = i->next) {
578                 if (strcmp(i->name, "recordingName") == 0) {
579                         args.recording_name = (i->value);
580                 } else
581                 {}
582         }
583         ast_ari_recordings_pause(headers, &args, response);
584 #if defined(AST_DEVMODE)
585         code = response->response_code;
586
587         switch (code) {
588         case 0: /* Implementation is still a stub, or the code wasn't set */
589                 is_valid = response->message == NULL;
590                 break;
591         case 500: /* Internal Server Error */
592         case 501: /* Not Implemented */
593         case 404: /* Recording not found */
594         case 409: /* Recording not in session */
595                 is_valid = 1;
596                 break;
597         default:
598                 if (200 <= code && code <= 299) {
599                         is_valid = ast_ari_validate_void(
600                                 response->message);
601                 } else {
602                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
603                         is_valid = 0;
604                 }
605         }
606
607         if (!is_valid) {
608                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
609                 ast_ari_response_error(response, 500,
610                         "Internal Server Error", "Response validation failed");
611         }
612 #endif /* AST_DEVMODE */
613
614 fin: __attribute__((unused))
615         return;
616 }
617 /*!
618  * \brief Parameter parsing callback for /recordings/live/{recordingName}/pause.
619  * \param get_params GET parameters in the HTTP request.
620  * \param path_vars Path variables extracted from the request.
621  * \param headers HTTP headers.
622  * \param[out] response Response to the HTTP request.
623  */
624 static void ast_ari_recordings_unpause_cb(
625         struct ast_tcptls_session_instance *ser,
626         struct ast_variable *get_params, struct ast_variable *path_vars,
627         struct ast_variable *headers, struct ast_ari_response *response)
628 {
629         struct ast_ari_recordings_unpause_args args = {};
630         struct ast_variable *i;
631         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
632 #if defined(AST_DEVMODE)
633         int is_valid;
634         int code;
635 #endif /* AST_DEVMODE */
636
637         for (i = path_vars; i; i = i->next) {
638                 if (strcmp(i->name, "recordingName") == 0) {
639                         args.recording_name = (i->value);
640                 } else
641                 {}
642         }
643         ast_ari_recordings_unpause(headers, &args, response);
644 #if defined(AST_DEVMODE)
645         code = response->response_code;
646
647         switch (code) {
648         case 0: /* Implementation is still a stub, or the code wasn't set */
649                 is_valid = response->message == NULL;
650                 break;
651         case 500: /* Internal Server Error */
652         case 501: /* Not Implemented */
653         case 404: /* Recording not found */
654         case 409: /* Recording not in session */
655                 is_valid = 1;
656                 break;
657         default:
658                 if (200 <= code && code <= 299) {
659                         is_valid = ast_ari_validate_void(
660                                 response->message);
661                 } else {
662                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/pause\n", code);
663                         is_valid = 0;
664                 }
665         }
666
667         if (!is_valid) {
668                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/pause\n");
669                 ast_ari_response_error(response, 500,
670                         "Internal Server Error", "Response validation failed");
671         }
672 #endif /* AST_DEVMODE */
673
674 fin: __attribute__((unused))
675         return;
676 }
677 /*!
678  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
679  * \param get_params GET parameters in the HTTP request.
680  * \param path_vars Path variables extracted from the request.
681  * \param headers HTTP headers.
682  * \param[out] response Response to the HTTP request.
683  */
684 static void ast_ari_recordings_mute_cb(
685         struct ast_tcptls_session_instance *ser,
686         struct ast_variable *get_params, struct ast_variable *path_vars,
687         struct ast_variable *headers, struct ast_ari_response *response)
688 {
689         struct ast_ari_recordings_mute_args args = {};
690         struct ast_variable *i;
691         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
692 #if defined(AST_DEVMODE)
693         int is_valid;
694         int code;
695 #endif /* AST_DEVMODE */
696
697         for (i = path_vars; i; i = i->next) {
698                 if (strcmp(i->name, "recordingName") == 0) {
699                         args.recording_name = (i->value);
700                 } else
701                 {}
702         }
703         ast_ari_recordings_mute(headers, &args, response);
704 #if defined(AST_DEVMODE)
705         code = response->response_code;
706
707         switch (code) {
708         case 0: /* Implementation is still a stub, or the code wasn't set */
709                 is_valid = response->message == NULL;
710                 break;
711         case 500: /* Internal Server Error */
712         case 501: /* Not Implemented */
713         case 404: /* Recording not found */
714         case 409: /* Recording not in session */
715                 is_valid = 1;
716                 break;
717         default:
718                 if (200 <= code && code <= 299) {
719                         is_valid = ast_ari_validate_void(
720                                 response->message);
721                 } else {
722                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
723                         is_valid = 0;
724                 }
725         }
726
727         if (!is_valid) {
728                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
729                 ast_ari_response_error(response, 500,
730                         "Internal Server Error", "Response validation failed");
731         }
732 #endif /* AST_DEVMODE */
733
734 fin: __attribute__((unused))
735         return;
736 }
737 /*!
738  * \brief Parameter parsing callback for /recordings/live/{recordingName}/mute.
739  * \param get_params GET parameters in the HTTP request.
740  * \param path_vars Path variables extracted from the request.
741  * \param headers HTTP headers.
742  * \param[out] response Response to the HTTP request.
743  */
744 static void ast_ari_recordings_unmute_cb(
745         struct ast_tcptls_session_instance *ser,
746         struct ast_variable *get_params, struct ast_variable *path_vars,
747         struct ast_variable *headers, struct ast_ari_response *response)
748 {
749         struct ast_ari_recordings_unmute_args args = {};
750         struct ast_variable *i;
751         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
752 #if defined(AST_DEVMODE)
753         int is_valid;
754         int code;
755 #endif /* AST_DEVMODE */
756
757         for (i = path_vars; i; i = i->next) {
758                 if (strcmp(i->name, "recordingName") == 0) {
759                         args.recording_name = (i->value);
760                 } else
761                 {}
762         }
763         ast_ari_recordings_unmute(headers, &args, response);
764 #if defined(AST_DEVMODE)
765         code = response->response_code;
766
767         switch (code) {
768         case 0: /* Implementation is still a stub, or the code wasn't set */
769                 is_valid = response->message == NULL;
770                 break;
771         case 500: /* Internal Server Error */
772         case 501: /* Not Implemented */
773         case 404: /* Recording not found */
774         case 409: /* Recording not in session */
775                 is_valid = 1;
776                 break;
777         default:
778                 if (200 <= code && code <= 299) {
779                         is_valid = ast_ari_validate_void(
780                                 response->message);
781                 } else {
782                         ast_log(LOG_ERROR, "Invalid error response %d for /recordings/live/{recordingName}/mute\n", code);
783                         is_valid = 0;
784                 }
785         }
786
787         if (!is_valid) {
788                 ast_log(LOG_ERROR, "Response validation failed for /recordings/live/{recordingName}/mute\n");
789                 ast_ari_response_error(response, 500,
790                         "Internal Server Error", "Response validation failed");
791         }
792 #endif /* AST_DEVMODE */
793
794 fin: __attribute__((unused))
795         return;
796 }
797
798 /*! \brief REST handler for /api-docs/recordings.json */
799 static struct stasis_rest_handlers recordings_stored_recordingName_file = {
800         .path_segment = "file",
801         .callbacks = {
802                 [AST_HTTP_GET] = ast_ari_recordings_get_stored_file_cb,
803         },
804         .num_children = 0,
805         .children = {  }
806 };
807 /*! \brief REST handler for /api-docs/recordings.json */
808 static struct stasis_rest_handlers recordings_stored_recordingName_copy = {
809         .path_segment = "copy",
810         .callbacks = {
811                 [AST_HTTP_POST] = ast_ari_recordings_copy_stored_cb,
812         },
813         .num_children = 0,
814         .children = {  }
815 };
816 /*! \brief REST handler for /api-docs/recordings.json */
817 static struct stasis_rest_handlers recordings_stored_recordingName = {
818         .path_segment = "recordingName",
819         .is_wildcard = 1,
820         .callbacks = {
821                 [AST_HTTP_GET] = ast_ari_recordings_get_stored_cb,
822                 [AST_HTTP_DELETE] = ast_ari_recordings_delete_stored_cb,
823         },
824         .num_children = 2,
825         .children = { &recordings_stored_recordingName_file,&recordings_stored_recordingName_copy, }
826 };
827 /*! \brief REST handler for /api-docs/recordings.json */
828 static struct stasis_rest_handlers recordings_stored = {
829         .path_segment = "stored",
830         .callbacks = {
831                 [AST_HTTP_GET] = ast_ari_recordings_list_stored_cb,
832         },
833         .num_children = 1,
834         .children = { &recordings_stored_recordingName, }
835 };
836 /*! \brief REST handler for /api-docs/recordings.json */
837 static struct stasis_rest_handlers recordings_live_recordingName_stop = {
838         .path_segment = "stop",
839         .callbacks = {
840                 [AST_HTTP_POST] = ast_ari_recordings_stop_cb,
841         },
842         .num_children = 0,
843         .children = {  }
844 };
845 /*! \brief REST handler for /api-docs/recordings.json */
846 static struct stasis_rest_handlers recordings_live_recordingName_pause = {
847         .path_segment = "pause",
848         .callbacks = {
849                 [AST_HTTP_POST] = ast_ari_recordings_pause_cb,
850                 [AST_HTTP_DELETE] = ast_ari_recordings_unpause_cb,
851         },
852         .num_children = 0,
853         .children = {  }
854 };
855 /*! \brief REST handler for /api-docs/recordings.json */
856 static struct stasis_rest_handlers recordings_live_recordingName_mute = {
857         .path_segment = "mute",
858         .callbacks = {
859                 [AST_HTTP_POST] = ast_ari_recordings_mute_cb,
860                 [AST_HTTP_DELETE] = ast_ari_recordings_unmute_cb,
861         },
862         .num_children = 0,
863         .children = {  }
864 };
865 /*! \brief REST handler for /api-docs/recordings.json */
866 static struct stasis_rest_handlers recordings_live_recordingName = {
867         .path_segment = "recordingName",
868         .is_wildcard = 1,
869         .callbacks = {
870                 [AST_HTTP_GET] = ast_ari_recordings_get_live_cb,
871                 [AST_HTTP_DELETE] = ast_ari_recordings_cancel_cb,
872         },
873         .num_children = 3,
874         .children = { &recordings_live_recordingName_stop,&recordings_live_recordingName_pause,&recordings_live_recordingName_mute, }
875 };
876 /*! \brief REST handler for /api-docs/recordings.json */
877 static struct stasis_rest_handlers recordings_live = {
878         .path_segment = "live",
879         .callbacks = {
880         },
881         .num_children = 1,
882         .children = { &recordings_live_recordingName, }
883 };
884 /*! \brief REST handler for /api-docs/recordings.json */
885 static struct stasis_rest_handlers recordings = {
886         .path_segment = "recordings",
887         .callbacks = {
888         },
889         .num_children = 2,
890         .children = { &recordings_stored,&recordings_live, }
891 };
892
893 static int load_module(void)
894 {
895         int res = 0;
896         stasis_app_ref();
897         res |= ast_ari_add_handler(&recordings);
898         return res;
899 }
900
901 static int unload_module(void)
902 {
903         ast_ari_remove_handler(&recordings);
904         stasis_app_unref();
905         return 0;
906 }
907
908 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Recording resources",
909         .support_level = AST_MODULE_SUPPORT_CORE,
910         .load = load_module,
911         .unload = unload_module,
912         .nonoptreq = "res_ari,res_stasis",
913 );