ari:Add application/json parameter support
[asterisk/asterisk.git] / res / res_ari_applications.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 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 Stasis application 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_applications.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 /applications.
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_applications_list_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_applications_list_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_applications_list(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_application_fn());
89                 } else {
90                         ast_log(LOG_ERROR, "Invalid error response %d for /applications\n", code);
91                         is_valid = 0;
92                 }
93         }
94
95         if (!is_valid) {
96                 ast_log(LOG_ERROR, "Response validation failed for /applications\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 /applications/{applicationName}.
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_applications_get_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_applications_get_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, "applicationName") == 0) {
127                         args.application_name = (i->value);
128                 } else
129                 {}
130         }
131         ast_ari_applications_get(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: /* Application does not exist. */
142                 is_valid = 1;
143                 break;
144         default:
145                 if (200 <= code && code <= 299) {
146                         is_valid = ast_ari_validate_application(
147                                 response->message);
148                 } else {
149                         ast_log(LOG_ERROR, "Invalid error response %d for /applications/{applicationName}\n", code);
150                         is_valid = 0;
151                 }
152         }
153
154         if (!is_valid) {
155                 ast_log(LOG_ERROR, "Response validation failed for /applications/{applicationName}\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 /applications/{applicationName}/subscription.
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_applications_subscribe_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_applications_subscribe_args args = {};
177         struct ast_variable *i;
178         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
179         struct ast_json *field;
180 #if defined(AST_DEVMODE)
181         int is_valid;
182         int code;
183 #endif /* AST_DEVMODE */
184
185         for (i = get_params; i; i = i->next) {
186                 if (strcmp(i->name, "eventSource") == 0) {
187                         /* Parse comma separated list */
188                         char *vals[MAX_VALS];
189                         size_t j;
190
191                         args.event_source_parse = ast_strdup(i->value);
192                         if (!args.event_source_parse) {
193                                 ast_ari_response_alloc_failed(response);
194                                 goto fin;
195                         }
196
197                         if (strlen(args.event_source_parse) == 0) {
198                                 /* ast_app_separate_args can't handle "" */
199                                 args.event_source_count = 1;
200                                 vals[0] = args.event_source_parse;
201                         } else {
202                                 args.event_source_count = ast_app_separate_args(
203                                         args.event_source_parse, ',', vals,
204                                         ARRAY_LEN(vals));
205                         }
206
207                         if (args.event_source_count == 0) {
208                                 ast_ari_response_alloc_failed(response);
209                                 goto fin;
210                         }
211
212                         if (args.event_source_count >= MAX_VALS) {
213                                 ast_ari_response_error(response, 400,
214                                         "Bad Request",
215                                         "Too many values for event_source");
216                                 goto fin;
217                         }
218
219                         args.event_source = ast_malloc(sizeof(*args.event_source) * args.event_source_count);
220                         if (!args.event_source) {
221                                 ast_ari_response_alloc_failed(response);
222                                 goto fin;
223                         }
224
225                         for (j = 0; j < args.event_source_count; ++j) {
226                                 args.event_source[j] = (vals[j]);
227                         }
228                 } else
229                 {}
230         }
231         for (i = path_vars; i; i = i->next) {
232                 if (strcmp(i->name, "applicationName") == 0) {
233                         args.application_name = (i->value);
234                 } else
235                 {}
236         }
237         /* Look for a JSON request entity */
238         body = ast_http_get_json(ser, headers);
239         if (!body) {
240                 switch (errno) {
241                 case EFBIG:
242                         ast_ari_response_error(response, 413, "Request Entity Too Large", "Request body too large");
243                         goto fin;
244                 case ENOMEM:
245                         ast_ari_response_error(response, 500, "Internal Server Error", "Error processing request");
246                         goto fin;
247                 case EIO:
248                         ast_ari_response_error(response, 400, "Bad Request", "Error parsing request body");
249                         goto fin;
250                 }
251         }
252         /* Parse query parameters out of it */
253         field = ast_json_object_get(body, "eventSource");
254         if (field) {
255                 /* If they were silly enough to both pass in a query param and a
256                  * JSON body, free up the query value.
257                  */
258                 ast_free(args.event_source);
259                 if (ast_json_typeof(field) == AST_JSON_ARRAY) {
260                         /* Multiple param passed as array */
261                         size_t i;
262                         args.event_source_count = ast_json_array_size(field);
263                         args.event_source = ast_malloc(sizeof(*args.event_source) * args.event_source_count);
264
265                         if (!args.event_source) {
266                                 ast_ari_response_alloc_failed(response);
267                                 goto fin;
268                         }
269
270                         for (i = 0; i < args.event_source_count; ++i) {
271                                 args.event_source[i] = ast_json_string_get(ast_json_array_get(field, i));
272                         }
273                 } else {
274                         /* Multiple param passed as single value */
275                         args.event_source_count = 1;
276                         args.event_source = ast_malloc(sizeof(*args.event_source) * args.event_source_count);
277                         if (!args.event_source) {
278                                 ast_ari_response_alloc_failed(response);
279                                 goto fin;
280                         }
281                         args.event_source[0] = ast_json_string_get(field);
282                 }
283         }
284         ast_ari_applications_subscribe(headers, &args, response);
285 #if defined(AST_DEVMODE)
286         code = response->response_code;
287
288         switch (code) {
289         case 0: /* Implementation is still a stub, or the code wasn't set */
290                 is_valid = response->message == NULL;
291                 break;
292         case 500: /* Internal Server Error */
293         case 501: /* Not Implemented */
294         case 400: /* Missing parameter. */
295         case 404: /* Application does not exist. */
296         case 422: /* Event source does not exist. */
297                 is_valid = 1;
298                 break;
299         default:
300                 if (200 <= code && code <= 299) {
301                         is_valid = ast_ari_validate_application(
302                                 response->message);
303                 } else {
304                         ast_log(LOG_ERROR, "Invalid error response %d for /applications/{applicationName}/subscription\n", code);
305                         is_valid = 0;
306                 }
307         }
308
309         if (!is_valid) {
310                 ast_log(LOG_ERROR, "Response validation failed for /applications/{applicationName}/subscription\n");
311                 ast_ari_response_error(response, 500,
312                         "Internal Server Error", "Response validation failed");
313         }
314 #endif /* AST_DEVMODE */
315
316 fin: __attribute__((unused))
317         ast_free(args.event_source_parse);
318         ast_free(args.event_source);
319         return;
320 }
321 /*!
322  * \brief Parameter parsing callback for /applications/{applicationName}/subscription.
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_applications_unsubscribe_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_applications_unsubscribe_args args = {};
334         struct ast_variable *i;
335         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
336         struct ast_json *field;
337 #if defined(AST_DEVMODE)
338         int is_valid;
339         int code;
340 #endif /* AST_DEVMODE */
341
342         for (i = get_params; i; i = i->next) {
343                 if (strcmp(i->name, "eventSource") == 0) {
344                         /* Parse comma separated list */
345                         char *vals[MAX_VALS];
346                         size_t j;
347
348                         args.event_source_parse = ast_strdup(i->value);
349                         if (!args.event_source_parse) {
350                                 ast_ari_response_alloc_failed(response);
351                                 goto fin;
352                         }
353
354                         if (strlen(args.event_source_parse) == 0) {
355                                 /* ast_app_separate_args can't handle "" */
356                                 args.event_source_count = 1;
357                                 vals[0] = args.event_source_parse;
358                         } else {
359                                 args.event_source_count = ast_app_separate_args(
360                                         args.event_source_parse, ',', vals,
361                                         ARRAY_LEN(vals));
362                         }
363
364                         if (args.event_source_count == 0) {
365                                 ast_ari_response_alloc_failed(response);
366                                 goto fin;
367                         }
368
369                         if (args.event_source_count >= MAX_VALS) {
370                                 ast_ari_response_error(response, 400,
371                                         "Bad Request",
372                                         "Too many values for event_source");
373                                 goto fin;
374                         }
375
376                         args.event_source = ast_malloc(sizeof(*args.event_source) * args.event_source_count);
377                         if (!args.event_source) {
378                                 ast_ari_response_alloc_failed(response);
379                                 goto fin;
380                         }
381
382                         for (j = 0; j < args.event_source_count; ++j) {
383                                 args.event_source[j] = (vals[j]);
384                         }
385                 } else
386                 {}
387         }
388         for (i = path_vars; i; i = i->next) {
389                 if (strcmp(i->name, "applicationName") == 0) {
390                         args.application_name = (i->value);
391                 } else
392                 {}
393         }
394         /* Look for a JSON request entity */
395         body = ast_http_get_json(ser, headers);
396         if (!body) {
397                 switch (errno) {
398                 case EFBIG:
399                         ast_ari_response_error(response, 413, "Request Entity Too Large", "Request body too large");
400                         goto fin;
401                 case ENOMEM:
402                         ast_ari_response_error(response, 500, "Internal Server Error", "Error processing request");
403                         goto fin;
404                 case EIO:
405                         ast_ari_response_error(response, 400, "Bad Request", "Error parsing request body");
406                         goto fin;
407                 }
408         }
409         /* Parse query parameters out of it */
410         field = ast_json_object_get(body, "eventSource");
411         if (field) {
412                 /* If they were silly enough to both pass in a query param and a
413                  * JSON body, free up the query value.
414                  */
415                 ast_free(args.event_source);
416                 if (ast_json_typeof(field) == AST_JSON_ARRAY) {
417                         /* Multiple param passed as array */
418                         size_t i;
419                         args.event_source_count = ast_json_array_size(field);
420                         args.event_source = ast_malloc(sizeof(*args.event_source) * args.event_source_count);
421
422                         if (!args.event_source) {
423                                 ast_ari_response_alloc_failed(response);
424                                 goto fin;
425                         }
426
427                         for (i = 0; i < args.event_source_count; ++i) {
428                                 args.event_source[i] = ast_json_string_get(ast_json_array_get(field, i));
429                         }
430                 } else {
431                         /* Multiple param passed as single value */
432                         args.event_source_count = 1;
433                         args.event_source = ast_malloc(sizeof(*args.event_source) * args.event_source_count);
434                         if (!args.event_source) {
435                                 ast_ari_response_alloc_failed(response);
436                                 goto fin;
437                         }
438                         args.event_source[0] = ast_json_string_get(field);
439                 }
440         }
441         ast_ari_applications_unsubscribe(headers, &args, response);
442 #if defined(AST_DEVMODE)
443         code = response->response_code;
444
445         switch (code) {
446         case 0: /* Implementation is still a stub, or the code wasn't set */
447                 is_valid = response->message == NULL;
448                 break;
449         case 500: /* Internal Server Error */
450         case 501: /* Not Implemented */
451         case 400: /* Missing parameter; event source scheme not recognized. */
452         case 404: /* Application does not exist. */
453         case 409: /* Application not subscribed to event source. */
454         case 422: /* Event source does not exist. */
455                 is_valid = 1;
456                 break;
457         default:
458                 if (200 <= code && code <= 299) {
459                         is_valid = ast_ari_validate_application(
460                                 response->message);
461                 } else {
462                         ast_log(LOG_ERROR, "Invalid error response %d for /applications/{applicationName}/subscription\n", code);
463                         is_valid = 0;
464                 }
465         }
466
467         if (!is_valid) {
468                 ast_log(LOG_ERROR, "Response validation failed for /applications/{applicationName}/subscription\n");
469                 ast_ari_response_error(response, 500,
470                         "Internal Server Error", "Response validation failed");
471         }
472 #endif /* AST_DEVMODE */
473
474 fin: __attribute__((unused))
475         ast_free(args.event_source_parse);
476         ast_free(args.event_source);
477         return;
478 }
479
480 /*! \brief REST handler for /api-docs/applications.{format} */
481 static struct stasis_rest_handlers applications_applicationName_subscription = {
482         .path_segment = "subscription",
483         .callbacks = {
484                 [AST_HTTP_POST] = ast_ari_applications_subscribe_cb,
485                 [AST_HTTP_DELETE] = ast_ari_applications_unsubscribe_cb,
486         },
487         .num_children = 0,
488         .children = {  }
489 };
490 /*! \brief REST handler for /api-docs/applications.{format} */
491 static struct stasis_rest_handlers applications_applicationName = {
492         .path_segment = "applicationName",
493         .is_wildcard = 1,
494         .callbacks = {
495                 [AST_HTTP_GET] = ast_ari_applications_get_cb,
496         },
497         .num_children = 1,
498         .children = { &applications_applicationName_subscription, }
499 };
500 /*! \brief REST handler for /api-docs/applications.{format} */
501 static struct stasis_rest_handlers applications = {
502         .path_segment = "applications",
503         .callbacks = {
504                 [AST_HTTP_GET] = ast_ari_applications_list_cb,
505         },
506         .num_children = 1,
507         .children = { &applications_applicationName, }
508 };
509
510 static int load_module(void)
511 {
512         int res = 0;
513         stasis_app_ref();
514         res |= ast_ari_add_handler(&applications);
515         return res;
516 }
517
518 static int unload_module(void)
519 {
520         ast_ari_remove_handler(&applications);
521         stasis_app_unref();
522         return 0;
523 }
524
525 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - Stasis application resources",
526         .load = load_module,
527         .unload = unload_module,
528         .nonoptreq = "res_ari,res_stasis",
529         );