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