res_fax.c: Add chan locked precondition comments.
[asterisk/asterisk.git] / res / res_ari_events.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 WebSocket resource
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_events.h"
49 #if defined(AST_DEVMODE)
50 #include "ari/ari_model_validators.h"
51 #endif
52 #include "asterisk/http_websocket.h"
53
54 #define MAX_VALS 128
55
56 static int ast_ari_events_event_websocket_ws_attempted_cb(struct ast_tcptls_session_instance *ser,
57         struct ast_variable *get_params, struct ast_variable *headers, const char *session_id)
58 {
59         struct ast_ari_events_event_websocket_args args = {};
60         int res = 0;
61         RAII_VAR(struct ast_ari_response *, response, NULL, ast_free);
62         struct ast_variable *i;
63
64         response = ast_calloc(1, sizeof(*response));
65         if (!response) {
66                 ast_log(LOG_ERROR, "Failed to create response.\n");
67                 goto fin;
68         }
69
70         for (i = get_params; i; i = i->next) {
71                 if (strcmp(i->name, "app") == 0) {
72                         /* Parse comma separated list */
73                         char *vals[MAX_VALS];
74                         size_t j;
75
76                         args.app_parse = ast_strdup(i->value);
77                         if (!args.app_parse) {
78                                 ast_ari_response_alloc_failed(response);
79                                 goto fin;
80                         }
81
82                         if (strlen(args.app_parse) == 0) {
83                                 /* ast_app_separate_args can't handle "" */
84                                 args.app_count = 1;
85                                 vals[0] = args.app_parse;
86                         } else {
87                                 args.app_count = ast_app_separate_args(
88                                         args.app_parse, ',', vals,
89                                         ARRAY_LEN(vals));
90                         }
91
92                         if (args.app_count == 0) {
93                                 ast_ari_response_alloc_failed(response);
94                                 goto fin;
95                         }
96
97                         if (args.app_count >= MAX_VALS) {
98                                 ast_ari_response_error(response, 400,
99                                         "Bad Request",
100                                         "Too many values for app");
101                                 goto fin;
102                         }
103
104                         args.app = ast_malloc(sizeof(*args.app) * args.app_count);
105                         if (!args.app) {
106                                 ast_ari_response_alloc_failed(response);
107                                 goto fin;
108                         }
109
110                         for (j = 0; j < args.app_count; ++j) {
111                                 args.app[j] = (vals[j]);
112                         }
113                 } else
114                 if (strcmp(i->name, "subscribeAll") == 0) {
115                         args.subscribe_all = ast_true(i->value);
116                 } else
117                 {}
118         }
119
120         res = ast_ari_websocket_events_event_websocket_attempted(ser, headers, &args, session_id);
121
122 fin: __attribute__((unused))
123         if (!response) {
124                 ast_http_error(ser, 500, "Server Error", "Memory allocation error");
125                 res = -1;
126         } else if (response->response_code != 0) {
127                 /* Param parsing failure */
128                 RAII_VAR(char *, msg, NULL, ast_json_free);
129                 if (response->message) {
130                         msg = ast_json_dump_string(response->message);
131                 } else {
132                         ast_log(LOG_ERROR, "Missing response message\n");
133                 }
134
135                 if (msg) {
136                         ast_http_error(ser, response->response_code, response->response_text, msg);
137                 }
138                 res = -1;
139         }
140         ast_free(args.app_parse);
141         ast_free(args.app);
142         return res;
143 }
144
145 static void ast_ari_events_event_websocket_ws_established_cb(struct ast_websocket *ws_session,
146         struct ast_variable *get_params, struct ast_variable *headers)
147 {
148         struct ast_ari_events_event_websocket_args args = {};
149         RAII_VAR(struct ast_ari_response *, response, NULL, ast_free);
150         struct ast_variable *i;
151         RAII_VAR(struct ast_websocket *, s, ws_session, ast_websocket_unref);
152         RAII_VAR(struct ast_ari_websocket_session *, session, NULL, ao2_cleanup);
153
154         response = ast_calloc(1, sizeof(*response));
155         if (!response) {
156                 ast_log(LOG_ERROR, "Failed to create response.\n");
157                 goto fin;
158         }
159
160 #if defined(AST_DEVMODE)
161         session = ast_ari_websocket_session_create(ws_session,
162                 ast_ari_validate_message_fn());
163 #else
164         session = ast_ari_websocket_session_create(ws_session, NULL);
165 #endif
166         if (!session) {
167                 ast_log(LOG_ERROR, "Failed to create ARI session\n");
168                 goto fin;
169         }
170
171         for (i = get_params; i; i = i->next) {
172                 if (strcmp(i->name, "app") == 0) {
173                         /* Parse comma separated list */
174                         char *vals[MAX_VALS];
175                         size_t j;
176
177                         args.app_parse = ast_strdup(i->value);
178                         if (!args.app_parse) {
179                                 ast_ari_response_alloc_failed(response);
180                                 goto fin;
181                         }
182
183                         if (strlen(args.app_parse) == 0) {
184                                 /* ast_app_separate_args can't handle "" */
185                                 args.app_count = 1;
186                                 vals[0] = args.app_parse;
187                         } else {
188                                 args.app_count = ast_app_separate_args(
189                                         args.app_parse, ',', vals,
190                                         ARRAY_LEN(vals));
191                         }
192
193                         if (args.app_count == 0) {
194                                 ast_ari_response_alloc_failed(response);
195                                 goto fin;
196                         }
197
198                         if (args.app_count >= MAX_VALS) {
199                                 ast_ari_response_error(response, 400,
200                                         "Bad Request",
201                                         "Too many values for app");
202                                 goto fin;
203                         }
204
205                         args.app = ast_malloc(sizeof(*args.app) * args.app_count);
206                         if (!args.app) {
207                                 ast_ari_response_alloc_failed(response);
208                                 goto fin;
209                         }
210
211                         for (j = 0; j < args.app_count; ++j) {
212                                 args.app[j] = (vals[j]);
213                         }
214                 } else
215                 if (strcmp(i->name, "subscribeAll") == 0) {
216                         args.subscribe_all = ast_true(i->value);
217                 } else
218                 {}
219         }
220
221         ast_ari_websocket_events_event_websocket_established(session, headers, &args);
222
223 fin: __attribute__((unused))
224         if (response && response->response_code != 0) {
225                 /* Param parsing failure */
226                 RAII_VAR(char *, msg, NULL, ast_json_free);
227                 if (response->message) {
228                         msg = ast_json_dump_string(response->message);
229                 } else {
230                         ast_log(LOG_ERROR, "Missing response message\n");
231                 }
232                 if (msg) {
233                         ast_websocket_write(ws_session,
234                                 AST_WEBSOCKET_OPCODE_TEXT, msg, strlen(msg));
235                 }
236         }
237         ast_free(args.app_parse);
238         ast_free(args.app);
239 }
240 int ast_ari_events_user_event_parse_body(
241         struct ast_json *body,
242         struct ast_ari_events_user_event_args *args)
243 {
244         struct ast_json *field;
245         /* Parse query parameters out of it */
246         field = ast_json_object_get(body, "application");
247         if (field) {
248                 args->application = ast_json_string_get(field);
249         }
250         field = ast_json_object_get(body, "source");
251         if (field) {
252                 /* If they were silly enough to both pass in a query param and a
253                  * JSON body, free up the query value.
254                  */
255                 ast_free(args->source);
256                 if (ast_json_typeof(field) == AST_JSON_ARRAY) {
257                         /* Multiple param passed as array */
258                         size_t i;
259                         args->source_count = ast_json_array_size(field);
260                         args->source = ast_malloc(sizeof(*args->source) * args->source_count);
261
262                         if (!args->source) {
263                                 return -1;
264                         }
265
266                         for (i = 0; i < args->source_count; ++i) {
267                                 args->source[i] = ast_json_string_get(ast_json_array_get(field, i));
268                         }
269                 } else {
270                         /* Multiple param passed as single value */
271                         args->source_count = 1;
272                         args->source = ast_malloc(sizeof(*args->source) * args->source_count);
273                         if (!args->source) {
274                                 return -1;
275                         }
276                         args->source[0] = ast_json_string_get(field);
277                 }
278         }
279         return 0;
280 }
281
282 /*!
283  * \brief Parameter parsing callback for /events/user/{eventName}.
284  * \param get_params GET parameters in the HTTP request.
285  * \param path_vars Path variables extracted from the request.
286  * \param headers HTTP headers.
287  * \param[out] response Response to the HTTP request.
288  */
289 static void ast_ari_events_user_event_cb(
290         struct ast_tcptls_session_instance *ser,
291         struct ast_variable *get_params, struct ast_variable *path_vars,
292         struct ast_variable *headers, struct ast_ari_response *response)
293 {
294         struct ast_ari_events_user_event_args args = {};
295         struct ast_variable *i;
296         RAII_VAR(struct ast_json *, body, NULL, ast_json_unref);
297 #if defined(AST_DEVMODE)
298         int is_valid;
299         int code;
300 #endif /* AST_DEVMODE */
301
302         for (i = get_params; i; i = i->next) {
303                 if (strcmp(i->name, "application") == 0) {
304                         args.application = (i->value);
305                 } else
306                 if (strcmp(i->name, "source") == 0) {
307                         /* Parse comma separated list */
308                         char *vals[MAX_VALS];
309                         size_t j;
310
311                         args.source_parse = ast_strdup(i->value);
312                         if (!args.source_parse) {
313                                 ast_ari_response_alloc_failed(response);
314                                 goto fin;
315                         }
316
317                         if (strlen(args.source_parse) == 0) {
318                                 /* ast_app_separate_args can't handle "" */
319                                 args.source_count = 1;
320                                 vals[0] = args.source_parse;
321                         } else {
322                                 args.source_count = ast_app_separate_args(
323                                         args.source_parse, ',', vals,
324                                         ARRAY_LEN(vals));
325                         }
326
327                         if (args.source_count == 0) {
328                                 ast_ari_response_alloc_failed(response);
329                                 goto fin;
330                         }
331
332                         if (args.source_count >= MAX_VALS) {
333                                 ast_ari_response_error(response, 400,
334                                         "Bad Request",
335                                         "Too many values for source");
336                                 goto fin;
337                         }
338
339                         args.source = ast_malloc(sizeof(*args.source) * args.source_count);
340                         if (!args.source) {
341                                 ast_ari_response_alloc_failed(response);
342                                 goto fin;
343                         }
344
345                         for (j = 0; j < args.source_count; ++j) {
346                                 args.source[j] = (vals[j]);
347                         }
348                 } else
349                 {}
350         }
351         for (i = path_vars; i; i = i->next) {
352                 if (strcmp(i->name, "eventName") == 0) {
353                         args.event_name = (i->value);
354                 } else
355                 {}
356         }
357         /* Look for a JSON request entity */
358         body = ast_http_get_json(ser, headers);
359         if (!body) {
360                 switch (errno) {
361                 case EFBIG:
362                         ast_ari_response_error(response, 413, "Request Entity Too Large", "Request body too large");
363                         goto fin;
364                 case ENOMEM:
365                         ast_ari_response_error(response, 500, "Internal Server Error", "Error processing request");
366                         goto fin;
367                 case EIO:
368                         ast_ari_response_error(response, 400, "Bad Request", "Error parsing request body");
369                         goto fin;
370                 }
371         }
372         args.variables = body;
373         ast_ari_events_user_event(headers, &args, response);
374 #if defined(AST_DEVMODE)
375         code = response->response_code;
376
377         switch (code) {
378         case 0: /* Implementation is still a stub, or the code wasn't set */
379                 is_valid = response->message == NULL;
380                 break;
381         case 500: /* Internal Server Error */
382         case 501: /* Not Implemented */
383         case 404: /* Application does not exist. */
384         case 422: /* Event source not found. */
385         case 400: /* Invalid even tsource URI or userevent data. */
386                 is_valid = 1;
387                 break;
388         default:
389                 if (200 <= code && code <= 299) {
390                         is_valid = ast_ari_validate_void(
391                                 response->message);
392                 } else {
393                         ast_log(LOG_ERROR, "Invalid error response %d for /events/user/{eventName}\n", code);
394                         is_valid = 0;
395                 }
396         }
397
398         if (!is_valid) {
399                 ast_log(LOG_ERROR, "Response validation failed for /events/user/{eventName}\n");
400                 ast_ari_response_error(response, 500,
401                         "Internal Server Error", "Response validation failed");
402         }
403 #endif /* AST_DEVMODE */
404
405 fin: __attribute__((unused))
406         ast_free(args.source_parse);
407         ast_free(args.source);
408         return;
409 }
410
411 /*! \brief REST handler for /api-docs/events.json */
412 static struct stasis_rest_handlers events_user_eventName = {
413         .path_segment = "eventName",
414         .is_wildcard = 1,
415         .callbacks = {
416                 [AST_HTTP_POST] = ast_ari_events_user_event_cb,
417         },
418         .num_children = 0,
419         .children = {  }
420 };
421 /*! \brief REST handler for /api-docs/events.json */
422 static struct stasis_rest_handlers events_user = {
423         .path_segment = "user",
424         .callbacks = {
425         },
426         .num_children = 1,
427         .children = { &events_user_eventName, }
428 };
429 /*! \brief REST handler for /api-docs/events.json */
430 static struct stasis_rest_handlers events = {
431         .path_segment = "events",
432         .callbacks = {
433         },
434         .num_children = 1,
435         .children = { &events_user, }
436 };
437
438 static int load_module(void)
439 {
440         int res = 0;
441         struct ast_websocket_protocol *protocol;
442
443         if (ast_ari_websocket_events_event_websocket_init() == -1) {
444                 return AST_MODULE_LOAD_FAILURE;
445         }
446
447         events.ws_server = ast_websocket_server_create();
448         if (!events.ws_server) {
449                 return AST_MODULE_LOAD_FAILURE;
450         }
451
452         protocol = ast_websocket_sub_protocol_alloc("ari");
453         if (!protocol) {
454                 ao2_ref(events.ws_server, -1);
455                 events.ws_server = NULL;
456                 return AST_MODULE_LOAD_FAILURE;
457         }
458         protocol->session_attempted = ast_ari_events_event_websocket_ws_attempted_cb;
459         protocol->session_established = ast_ari_events_event_websocket_ws_established_cb;
460         res |= ast_websocket_server_add_protocol2(events.ws_server, protocol);
461         stasis_app_ref();
462         res |= ast_ari_add_handler(&events);
463         return res;
464 }
465
466 static int unload_module(void)
467 {
468         ast_ari_remove_handler(&events);
469         ao2_cleanup(events.ws_server);
470         events.ws_server = NULL;
471         ast_ari_websocket_events_event_websocket_dtor();
472         stasis_app_unref();
473         return 0;
474 }
475
476 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "RESTful API module - WebSocket resource",
477         .support_level = AST_MODULE_SUPPORT_CORE,
478         .load = load_module,
479         .unload = unload_module,
480         .nonoptreq = "res_ari,res_stasis",
481 );