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