Fix res/res_http_websocket.c build failure in 32bit due to incorrect print format...
[asterisk/asterisk.git] / res / res_http_websocket.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2012, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@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 /*! \file
20  *
21  * \brief WebSocket support for the Asterisk internal HTTP server
22  *
23  * \author Joshua Colp <jcolp@digium.com>
24  */
25
26 /*** MODULEINFO
27         <support_level>extended</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include "asterisk/module.h"
35 #include "asterisk/http.h"
36 #include "asterisk/astobj2.h"
37 #include "asterisk/strings.h"
38 #include "asterisk/file.h"
39 #include "asterisk/unaligned.h"
40
41 #define AST_API_MODULE
42 #include "asterisk/http_websocket.h"
43
44 /*! \brief GUID used to compute the accept key, defined in the specifications */
45 #define WEBSOCKET_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
46
47 /*! \brief Number of buckets for registered protocols */
48 #define MAX_PROTOCOL_BUCKETS 7
49
50 /*! \brief Size of the pre-determined buffer for WebSocket frames */
51 #define MAXIMUM_FRAME_SIZE 8192
52
53 /*! \brief Default reconstruction size for multi-frame payload reconstruction. If exceeded the next frame will start a
54  *         payload.
55  */
56 #define DEFAULT_RECONSTRUCTION_CEILING 16384
57
58 /*! \brief Maximum reconstruction size for multi-frame payload reconstruction. */
59 #define MAXIMUM_RECONSTRUCTION_CEILING 16384
60
61 /*! \brief Maximum size of a websocket frame header
62  * 1 byte flags and opcode
63  * 1 byte mask flag + payload len
64  * 8 bytes max extended length
65  * 4 bytes optional masking key
66  * ... payload follows ...
67  * */
68 #define MAX_WS_HDR_SZ 14
69 #define MIN_WS_HDR_SZ 2
70
71 /*! \brief Structure definition for session */
72 struct ast_websocket {
73         FILE *f;                          /*!< Pointer to the file instance used for writing and reading */
74         int fd;                           /*!< File descriptor for the session, only used for polling */
75         struct ast_sockaddr address;      /*!< Address of the remote client */
76         enum ast_websocket_opcode opcode; /*!< Cached opcode for multi-frame messages */
77         size_t payload_len;               /*!< Length of the payload */
78         char *payload;                    /*!< Pointer to the payload */
79         size_t reconstruct;               /*!< Number of bytes before a reconstructed payload will be returned and a new one started */
80         unsigned int secure:1;            /*!< Bit to indicate that the transport is secure */
81         unsigned int closing:1;           /*!< Bit to indicate that the session is in the process of being closed */
82 };
83
84 /*! \brief Structure definition for protocols */
85 struct websocket_protocol {
86         char *name;                      /*!< Name of the protocol */
87         ast_websocket_callback callback; /*!< Callback called when a new session is established */
88 };
89
90 /*! \brief Hashing function for protocols */
91 static int protocol_hash_fn(const void *obj, const int flags)
92 {
93         const struct websocket_protocol *protocol = obj;
94         const char *name = obj;
95
96         return ast_str_case_hash(flags & OBJ_KEY ? name : protocol->name);
97 }
98
99 /*! \brief Comparison function for protocols */
100 static int protocol_cmp_fn(void *obj, void *arg, int flags)
101 {
102         const struct websocket_protocol *protocol1 = obj, *protocol2 = arg;
103         const char *protocol = arg;
104
105         return !strcasecmp(protocol1->name, flags & OBJ_KEY ? protocol : protocol2->name) ? CMP_MATCH | CMP_STOP : 0;
106 }
107
108 /*! \brief Destructor function for protocols */
109 static void protocol_destroy_fn(void *obj)
110 {
111         struct websocket_protocol *protocol = obj;
112         ast_free(protocol->name);
113 }
114
115 /*! \brief Structure for a WebSocket server */
116 struct ast_websocket_server {
117         struct ao2_container *protocols; /*!< Container for registered protocols */
118 };
119
120 static void websocket_server_internal_dtor(void *obj)
121 {
122         struct ast_websocket_server *server = obj;
123         ao2_cleanup(server->protocols);
124         server->protocols = NULL;
125 }
126
127 static void websocket_server_dtor(void *obj)
128 {
129         websocket_server_internal_dtor(obj);
130         ast_module_unref(ast_module_info->self);
131 }
132
133 static struct ast_websocket_server *websocket_server_create_impl(void (*dtor)(void *))
134 {
135         RAII_VAR(struct ast_websocket_server *, server, NULL, ao2_cleanup);
136
137         server = ao2_alloc(sizeof(*server), dtor);
138         if (!server) {
139                 return NULL;
140         }
141
142         server->protocols = ao2_container_alloc(MAX_PROTOCOL_BUCKETS, protocol_hash_fn, protocol_cmp_fn);
143         if (!server->protocols) {
144                 return NULL;
145         }
146
147         ao2_ref(server, +1);
148         return server;
149 }
150
151 static struct ast_websocket_server *websocket_server_internal_create(void)
152 {
153         return websocket_server_create_impl(websocket_server_internal_dtor);
154 }
155
156 struct ast_websocket_server *AST_OPTIONAL_API_NAME(ast_websocket_server_create)(void)
157 {
158         ast_module_ref(ast_module_info->self);
159         return websocket_server_create_impl(websocket_server_dtor);
160 }
161
162 /*! \brief Destructor function for sessions */
163 static void session_destroy_fn(void *obj)
164 {
165         struct ast_websocket *session = obj;
166
167         if (session->f) {
168                 fclose(session->f);
169                 ast_verb(2, "WebSocket connection from '%s' closed\n", ast_sockaddr_stringify(&session->address));
170         }
171
172         ast_free(session->payload);
173 }
174
175 int AST_OPTIONAL_API_NAME(ast_websocket_server_add_protocol)(struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
176 {
177         struct websocket_protocol *protocol;
178
179         if (!server->protocols) {
180                 return -1;
181         }
182
183         ao2_lock(server->protocols);
184
185         /* Ensure a second protocol handler is not registered for the same protocol */
186         if ((protocol = ao2_find(server->protocols, name, OBJ_KEY | OBJ_NOLOCK))) {
187                 ao2_ref(protocol, -1);
188                 ao2_unlock(server->protocols);
189                 return -1;
190         }
191
192         if (!(protocol = ao2_alloc(sizeof(*protocol), protocol_destroy_fn))) {
193                 ao2_unlock(server->protocols);
194                 return -1;
195         }
196
197         if (!(protocol->name = ast_strdup(name))) {
198                 ao2_ref(protocol, -1);
199                 ao2_unlock(server->protocols);
200                 return -1;
201         }
202
203         protocol->callback = callback;
204
205         ao2_link_flags(server->protocols, protocol, OBJ_NOLOCK);
206         ao2_unlock(server->protocols);
207         ao2_ref(protocol, -1);
208
209         ast_verb(2, "WebSocket registered sub-protocol '%s'\n", name);
210
211         return 0;
212 }
213
214 int AST_OPTIONAL_API_NAME(ast_websocket_server_remove_protocol)(struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
215 {
216         struct websocket_protocol *protocol;
217
218         if (!(protocol = ao2_find(server->protocols, name, OBJ_KEY))) {
219                 return -1;
220         }
221
222         if (protocol->callback != callback) {
223                 ao2_ref(protocol, -1);
224                 return -1;
225         }
226
227         ao2_unlink(server->protocols, protocol);
228         ao2_ref(protocol, -1);
229
230         ast_verb(2, "WebSocket unregistered sub-protocol '%s'\n", name);
231
232         return 0;
233 }
234
235 /*! \brief Close function for websocket session */
236 int AST_OPTIONAL_API_NAME(ast_websocket_close)(struct ast_websocket *session, uint16_t reason)
237 {
238         char frame[4] = { 0, }; /* The header is 2 bytes and the reason code takes up another 2 bytes */
239
240         frame[0] = AST_WEBSOCKET_OPCODE_CLOSE | 0x80;
241         frame[1] = 2; /* The reason code is always 2 bytes */
242
243         /* If no reason has been specified assume 1000 which is normal closure */
244         put_unaligned_uint16(&frame[2], htons(reason ? reason : 1000));
245
246         session->closing = 1;
247
248         return (fwrite(frame, 1, 4, session->f) == 4) ? 0 : -1;
249 }
250
251
252 /*! \brief Write function for websocket traffic */
253 int AST_OPTIONAL_API_NAME(ast_websocket_write)(struct ast_websocket *session, enum ast_websocket_opcode opcode, char *payload, uint64_t actual_length)
254 {
255         size_t header_size = 2; /* The minimum size of a websocket frame is 2 bytes */
256         char *frame;
257         uint64_t length = 0;
258
259         if (actual_length < 126) {
260                 length = actual_length;
261         } else if (actual_length < (1 << 16)) {
262                 length = 126;
263                 /* We need an additional 2 bytes to store the extended length */
264                 header_size += 2;
265         } else {
266                 length = 127;
267                 /* We need an additional 8 bytes to store the really really extended length */
268                 header_size += 8;
269         }
270
271         frame = ast_alloca(header_size);
272         memset(frame, 0, sizeof(*frame));
273
274         frame[0] = opcode | 0x80;
275         frame[1] = length;
276
277         /* Use the additional available bytes to store the length */
278         if (length == 126) {
279                 put_unaligned_uint16(&frame[2], htons(actual_length));
280         } else if (length == 127) {
281                 put_unaligned_uint64(&frame[2], htonl(actual_length));
282         }
283
284         if (fwrite(frame, 1, header_size, session->f) != header_size) {
285                 return -1;
286         }
287
288         if (fwrite(payload, 1, actual_length, session->f) != actual_length) {
289                 return -1;
290         }
291         fflush(session->f);
292
293         return 0;
294 }
295
296 void AST_OPTIONAL_API_NAME(ast_websocket_reconstruct_enable)(struct ast_websocket *session, size_t bytes)
297 {
298         session->reconstruct = MIN(bytes, MAXIMUM_RECONSTRUCTION_CEILING);
299 }
300
301 void AST_OPTIONAL_API_NAME(ast_websocket_reconstruct_disable)(struct ast_websocket *session)
302 {
303         session->reconstruct = 0;
304 }
305
306 void AST_OPTIONAL_API_NAME(ast_websocket_ref)(struct ast_websocket *session)
307 {
308         ao2_ref(session, +1);
309 }
310
311 void AST_OPTIONAL_API_NAME(ast_websocket_unref)(struct ast_websocket *session)
312 {
313         ao2_cleanup(session);
314 }
315
316 int AST_OPTIONAL_API_NAME(ast_websocket_fd)(struct ast_websocket *session)
317 {
318         return session->closing ? -1 : session->fd;
319 }
320
321 struct ast_sockaddr * AST_OPTIONAL_API_NAME(ast_websocket_remote_address)(struct ast_websocket *session)
322 {
323         return &session->address;
324 }
325
326 int AST_OPTIONAL_API_NAME(ast_websocket_is_secure)(struct ast_websocket *session)
327 {
328         return session->secure;
329 }
330
331 int AST_OPTIONAL_API_NAME(ast_websocket_set_nonblock)(struct ast_websocket *session)
332 {
333         int flags;
334
335         if ((flags = fcntl(session->fd, F_GETFL)) == -1) {
336                 return -1;
337         }
338
339         flags |= O_NONBLOCK;
340
341         if ((flags = fcntl(session->fd, F_SETFL, flags)) == -1) {
342                 return -1;
343         }
344
345         return 0;
346 }
347
348 /* MAINTENANCE WARNING on ast_websocket_read()!
349  *
350  * We have to keep in mind during this function that the fact that session->fd seems ready
351  * (via poll) does not necessarily mean we have application data ready, because in the case
352  * of an SSL socket, there is some encryption data overhead that needs to be read from the
353  * TCP socket, so poll() may say there are bytes to be read, but whether it is just 1 byte
354  * or N bytes we do not know that, and we do not know how many of those bytes (if any) are
355  * for application data (for us) and not just for the SSL protocol consumption
356  *
357  * There used to be a couple of nasty bugs here that were fixed in last refactoring but I
358  * want to document them so the constraints are clear and we do not re-introduce them:
359  *
360  * - This function would incorrectly assume that fread() would necessarily return more than
361  *   1 byte of data, just because a websocket frame is always >= 2 bytes, but the thing
362  *   is we're dealing with a TCP bitstream here, we could read just one byte and that's normal.
363  *   The problem before was that if just one byte was read, the function bailed out and returned
364  *   an error, effectively dropping the first byte of a websocket frame header!
365  *
366  * - Another subtle bug was that it would just read up to MAX_WS_HDR_SZ (14 bytes) via fread()
367  *   then assume that executing poll() would tell you if there is more to read, but since
368  *   we're dealing with a buffered stream (session->f is a FILE*), poll would say there is
369  *   nothing else to read (in the real tcp socket session->fd) and we would get stuck here
370  *   without processing the rest of the data in session->f internal buffers until another packet
371  *   came on the network to unblock us!
372  *
373  * Note during the header parsing stage we try to read in small chunks just what we need, this
374  * is buffered data anyways, no expensive syscall required most of the time ...
375  */
376 static inline int ws_safe_read(struct ast_websocket *session, char *buf, int len, enum ast_websocket_opcode *opcode)
377 {
378         int sanity;
379         size_t rlen;
380         int xlen = len;
381         char *rbuf = buf;
382         for (sanity = 10; sanity; sanity--) {
383                 clearerr(session->f);
384                 rlen = fread(rbuf, 1, xlen, session->f);
385                 if (0 == rlen && ferror(session->f) && errno != EAGAIN) {
386                         ast_log(LOG_ERROR, "Error reading from web socket: %s\n", strerror(errno));
387                         (*opcode) = AST_WEBSOCKET_OPCODE_CLOSE;
388                         session->closing = 1;
389                         return -1;
390                 }
391                 xlen = (xlen - rlen);
392                 rbuf = rbuf + rlen;
393                 if (0 == xlen) {
394                         break;
395                 }
396                 if (ast_wait_for_input(session->fd, 1000) < 0) {
397                         ast_log(LOG_ERROR, "ast_wait_for_input returned err: %s\n", strerror(errno));
398                         (*opcode) = AST_WEBSOCKET_OPCODE_CLOSE;
399                         session->closing = 1;
400                         return -1;
401                 }
402         }
403         if (!sanity) {
404                 ast_log(LOG_WARNING, "Websocket seems unresponsive, disconnecting ...\n");
405                 (*opcode) = AST_WEBSOCKET_OPCODE_CLOSE;
406                 session->closing = 1;
407                 return -1;
408         }
409         return 0;
410 }
411
412 int AST_OPTIONAL_API_NAME(ast_websocket_read)(struct ast_websocket *session, char **payload, uint64_t *payload_len, enum ast_websocket_opcode *opcode, int *fragmented)
413 {
414         char buf[MAXIMUM_FRAME_SIZE] = "";
415         int fin = 0;
416         int mask_present = 0;
417         char *mask = NULL, *new_payload = NULL;
418         size_t options_len = 0, frame_size = 0;
419
420         *payload = NULL;
421         *payload_len = 0;
422         *fragmented = 0;
423
424         if (ws_safe_read(session, &buf[0], MIN_WS_HDR_SZ, opcode)) {
425                 return 0;
426         }
427         frame_size += MIN_WS_HDR_SZ;
428
429         /* ok, now we have the first 2 bytes, so we know some flags, opcode and payload length (or whether payload length extension will be required) */
430         *opcode = buf[0] & 0xf;
431         *payload_len = buf[1] & 0x7f;
432         if (*opcode == AST_WEBSOCKET_OPCODE_TEXT || *opcode == AST_WEBSOCKET_OPCODE_BINARY || *opcode == AST_WEBSOCKET_OPCODE_CONTINUATION ||
433             *opcode == AST_WEBSOCKET_OPCODE_PING || *opcode == AST_WEBSOCKET_OPCODE_PONG) {
434                 fin = (buf[0] >> 7) & 1;
435                 mask_present = (buf[1] >> 7) & 1;
436
437                 /* Based on the mask flag and payload length, determine how much more we need to read before start parsing the rest of the header */
438                 options_len += mask_present ? 4 : 0;
439                 options_len += (*payload_len == 126) ? 2 : (*payload_len == 127) ? 8 : 0;
440                 if (options_len) {
441                         /* read the rest of the header options */
442                         if (ws_safe_read(session, &buf[frame_size], options_len, opcode)) {
443                                 return 0;
444                         }
445                         frame_size += options_len;
446                 }
447
448                 if (*payload_len == 126) {
449                         /* Grab the 2-byte payload length  */
450                         *payload_len = ntohs(get_unaligned_uint16(&buf[2]));
451                         mask = &buf[4];
452                 } else if (*payload_len == 127) {
453                         /* Grab the 8-byte payload length  */
454                         *payload_len = ntohl(get_unaligned_uint64(&buf[2]));
455                         mask = &buf[10];
456                 } else {
457                         /* Just set the mask after the small 2-byte header */
458                         mask = &buf[2];
459                 }
460
461                 /* Now read the rest of the payload */
462                 *payload = &buf[frame_size]; /* payload will start here, at the end of the options, if any */
463                 frame_size = frame_size + (*payload_len); /* final frame size is header + optional headers + payload data */
464                 if (frame_size > MAXIMUM_FRAME_SIZE) {
465                         ast_log(LOG_WARNING, "Cannot fit huge websocket frame of %zd bytes\n", frame_size);
466                         /* The frame won't fit :-( */
467                         ast_websocket_close(session, 1009);
468                         return -1;
469                 }
470
471                 if (ws_safe_read(session, (*payload), (*payload_len), opcode)) {
472                         return 0;
473                 }
474
475                 /* If a mask is present unmask the payload */
476                 if (mask_present) {
477                         unsigned int pos;
478                         for (pos = 0; pos < *payload_len; pos++) {
479                                 (*payload)[pos] ^= mask[pos % 4];
480                         }
481                 }
482
483                 if (!(new_payload = ast_realloc(session->payload, (session->payload_len + *payload_len)))) {
484                         ast_log(LOG_WARNING, "Failed allocation: %p, %zd, %"PRIu64"\n",
485                                 session->payload, session->payload_len, *payload_len);
486                         *payload_len = 0;
487                         ast_websocket_close(session, 1009);
488                         return 0;
489                 }
490
491                 /* Per the RFC for PING we need to send back an opcode with the application data as received */
492                 if (*opcode == AST_WEBSOCKET_OPCODE_PING) {
493                         ast_websocket_write(session, AST_WEBSOCKET_OPCODE_PONG, *payload, *payload_len);
494                 }
495
496                 session->payload = new_payload;
497                 memcpy((session->payload + session->payload_len), (*payload), (*payload_len));
498                 session->payload_len += *payload_len;
499
500                 if (!fin && session->reconstruct && (session->payload_len < session->reconstruct)) {
501                         /* If this is not a final message we need to defer returning it until later */
502                         if (*opcode != AST_WEBSOCKET_OPCODE_CONTINUATION) {
503                                 session->opcode = *opcode;
504                         }
505                         *opcode = AST_WEBSOCKET_OPCODE_CONTINUATION;
506                         *payload_len = 0;
507                         *payload = NULL;
508                 } else {
509                         if (*opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
510                                 if (!fin) {
511                                         /* If this was not actually the final message tell the user it is fragmented so they can deal with it accordingly */
512                                         *fragmented = 1;
513                                 } else {
514                                         /* Final frame in multi-frame so push up the actual opcode */
515                                         *opcode = session->opcode;
516                                 }
517                         }
518                         *payload_len = session->payload_len;
519                         *payload = session->payload;
520                         session->payload_len = 0;
521                 }
522         } else if (*opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
523                 /* Make the payload available so the user can look at the reason code if they so desire */
524                 if ((*payload_len) && (new_payload = ast_realloc(session->payload, *payload_len))) {
525                         if (ws_safe_read(session, &buf[frame_size], (*payload_len), opcode)) {
526                                 return 0;
527                         }
528                         session->payload = new_payload;
529                         memcpy(session->payload, &buf[frame_size], *payload_len);
530                         *payload = session->payload;
531                         frame_size += (*payload_len);
532                 }
533
534                 if (!session->closing) {
535                         ast_websocket_close(session, 0);
536                 }
537
538                 fclose(session->f);
539                 session->f = NULL;
540                 ast_verb(2, "WebSocket connection from '%s' closed\n", ast_sockaddr_stringify(&session->address));
541         } else {
542                 ast_log(LOG_WARNING, "WebSocket unknown opcode %d\n", *opcode);
543                 /* We received an opcode that we don't understand, the RFC states that 1003 is for a type of data that can't be accepted... opcodes
544                  * fit that, I think. */
545                 ast_websocket_close(session, 1003);
546         }
547
548         return 0;
549 }
550
551 /*!
552  * \brief If the server has exactly one configured protocol, return it.
553  */
554 static struct websocket_protocol *one_protocol(
555         struct ast_websocket_server *server)
556 {
557         SCOPED_AO2LOCK(lock, server->protocols);
558
559         if (ao2_container_count(server->protocols) != 1) {
560                 return NULL;
561         }
562
563         return ao2_callback(server->protocols, OBJ_NOLOCK, NULL, NULL);
564 }
565
566 int AST_OPTIONAL_API_NAME(ast_websocket_uri_cb)(struct ast_tcptls_session_instance *ser, const struct ast_http_uri *urih, const char *uri, enum ast_http_method method, struct ast_variable *get_vars, struct ast_variable *headers)
567 {
568         struct ast_variable *v;
569         char *upgrade = NULL, *key = NULL, *key1 = NULL, *key2 = NULL, *protos = NULL, *requested_protocols = NULL, *protocol = NULL;
570         int version = 0, flags = 1;
571         struct websocket_protocol *protocol_handler = NULL;
572         struct ast_websocket *session;
573         struct ast_websocket_server *server;
574
575         SCOPED_MODULE_USE(ast_module_info->self);
576
577         /* Upgrade requests are only permitted on GET methods */
578         if (method != AST_HTTP_GET) {
579                 ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
580                 return -1;
581         }
582
583         server = urih->data;
584
585         /* Get the minimum headers required to satisfy our needs */
586         for (v = headers; v; v = v->next) {
587                 if (!strcasecmp(v->name, "Upgrade")) {
588                         upgrade = ast_strip(ast_strdupa(v->value));
589                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key")) {
590                         key = ast_strip(ast_strdupa(v->value));
591                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key1")) {
592                         key1 = ast_strip(ast_strdupa(v->value));
593                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key2")) {
594                         key2 = ast_strip(ast_strdupa(v->value));
595                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Protocol")) {
596                         requested_protocols = ast_strip(ast_strdupa(v->value));
597                         protos = ast_strdupa(requested_protocols);
598                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Version")) {
599                         if (sscanf(v->value, "%30d", &version) != 1) {
600                                 version = 0;
601                         }
602                 }
603         }
604
605         /* If this is not a websocket upgrade abort */
606         if (!upgrade || strcasecmp(upgrade, "websocket")) {
607                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - did not request WebSocket\n",
608                         ast_sockaddr_stringify(&ser->remote_address));
609                 ast_http_error(ser, 426, "Upgrade Required", NULL);
610                 return -1;
611         } else if (ast_strlen_zero(requested_protocols)) {
612                 /* If there's only a single protocol registered, and the
613                  * client doesn't specify what protocol it's using, go ahead
614                  * and accept the connection */
615                 protocol_handler = one_protocol(server);
616                 if (!protocol_handler) {
617                         /* Multiple registered subprotocols; client must specify */
618                         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols requested\n",
619                                 ast_sockaddr_stringify(&ser->remote_address));
620                         fputs("HTTP/1.1 400 Bad Request\r\n"
621                                 "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
622                         return -1;
623                 }
624         } else if (key1 && key2) {
625                 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 and
626                  * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00 -- not currently supported*/
627                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '00/76' chosen\n",
628                         ast_sockaddr_stringify(&ser->remote_address));
629                 fputs("HTTP/1.1 400 Bad Request\r\n"
630                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
631                 return 0;
632         }
633
634         /* Iterate through the requested protocols trying to find one that we have a handler for */
635         while (!protocol_handler && (protocol = strsep(&requested_protocols, ","))) {
636                 protocol_handler = ao2_find(server->protocols, ast_strip(protocol), OBJ_KEY);
637         }
638
639         /* If no protocol handler exists bump this back to the requester */
640         if (!protocol_handler) {
641                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols out of '%s' supported\n",
642                         ast_sockaddr_stringify(&ser->remote_address), protos);
643                 fputs("HTTP/1.1 400 Bad Request\r\n"
644                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
645                 return 0;
646         }
647
648         /* Determine how to respond depending on the version */
649         if (version == 7 || version == 8 || version == 13) {
650                 /* Version 7 defined in specification http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07 */
651                 /* Version 8 defined in specification http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10 */
652                 /* Version 13 defined in specification http://tools.ietf.org/html/rfc6455 */
653                 char *combined, base64[64];
654                 unsigned combined_length;
655                 uint8_t sha[20];
656
657                 combined_length = (key ? strlen(key) : 0) + strlen(WEBSOCKET_GUID) + 1;
658                 if (!key || combined_length > 8192) { /* no stack overflows please */
659                         fputs("HTTP/1.1 400 Bad Request\r\n"
660                               "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
661                         ao2_ref(protocol_handler, -1);
662                         return 0;
663                 }
664
665                 if (!(session = ao2_alloc(sizeof(*session), session_destroy_fn))) {
666                         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted\n",
667                                 ast_sockaddr_stringify(&ser->remote_address));
668                         fputs("HTTP/1.1 400 Bad Request\r\n"
669                               "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
670                         ao2_ref(protocol_handler, -1);
671                         return 0;
672                 }
673
674                 combined = ast_alloca(combined_length);
675                 snprintf(combined, combined_length, "%s%s", key, WEBSOCKET_GUID);
676                 ast_sha1_hash_uint(sha, combined);
677                 ast_base64encode(base64, (const unsigned char*)sha, 20, sizeof(base64));
678
679                 fprintf(ser->f, "HTTP/1.1 101 Switching Protocols\r\n"
680                         "Upgrade: %s\r\n"
681                         "Connection: Upgrade\r\n"
682                         "Sec-WebSocket-Accept: %s\r\n",
683                         upgrade,
684                         base64);
685
686                 /* RFC 6455, Section 4.1:
687                  *
688                  * 6. If the response includes a |Sec-WebSocket-Protocol| header
689                  *    field and this header field indicates the use of a
690                  *    subprotocol that was not present in the client's handshake
691                  *    (the server has indicated a subprotocol not requested by
692                  *    the client), the client MUST _Fail the WebSocket
693                  *    Connection_.
694                  */
695                 if (protocol) {
696                         fprintf(ser->f, "Sec-WebSocket-Protocol: %s\r\n",
697                                 protocol);
698                 }
699
700                 fprintf(ser->f, "\r\n");
701                 fflush(ser->f);
702         } else {
703
704                 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 or completely unknown */
705                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '%d' chosen\n",
706                         ast_sockaddr_stringify(&ser->remote_address), version ? version : 75);
707                 fputs("HTTP/1.1 400 Bad Request\r\n"
708                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
709                 ao2_ref(protocol_handler, -1);
710                 return 0;
711         }
712
713         /* Enable keepalive on all sessions so the underlying user does not have to */
714         if (setsockopt(ser->fd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags))) {
715                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to enable keepalive\n",
716                         ast_sockaddr_stringify(&ser->remote_address));
717                 fputs("HTTP/1.1 400 Bad Request\r\n"
718                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
719                 ao2_ref(session, -1);
720                 ao2_ref(protocol_handler, -1);
721                 return 0;
722         }
723
724         ast_verb(2, "WebSocket connection from '%s' for protocol '%s' accepted using version '%d'\n", ast_sockaddr_stringify(&ser->remote_address), protocol ? : "", version);
725
726         /* Populate the session with all the needed details */
727         session->f = ser->f;
728         session->fd = ser->fd;
729         ast_sockaddr_copy(&session->address, &ser->remote_address);
730         session->opcode = -1;
731         session->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
732         session->secure = ser->ssl ? 1 : 0;
733
734         /* Give up ownership of the socket and pass it to the protocol handler */
735         protocol_handler->callback(session, get_vars, headers);
736         ao2_ref(protocol_handler, -1);
737
738         /* By dropping the FILE* from the session it won't get closed when the HTTP server cleans up */
739         ser->f = NULL;
740
741         return 0;
742 }
743
744 static struct ast_http_uri websocketuri = {
745         .callback = AST_OPTIONAL_API_NAME(ast_websocket_uri_cb),
746         .description = "Asterisk HTTP WebSocket",
747         .uri = "ws",
748         .has_subtree = 0,
749         .data = NULL,
750         .key = __FILE__,
751 };
752
753 /*! \brief Simple echo implementation which echoes received text and binary frames */
754 static void websocket_echo_callback(struct ast_websocket *session, struct ast_variable *parameters, struct ast_variable *headers)
755 {
756         int flags, res;
757
758         ast_debug(1, "Entering WebSocket echo loop\n");
759
760         if ((flags = fcntl(ast_websocket_fd(session), F_GETFL)) == -1) {
761                 goto end;
762         }
763
764         flags |= O_NONBLOCK;
765
766         if (fcntl(ast_websocket_fd(session), F_SETFL, flags) == -1) {
767                 goto end;
768         }
769
770         while ((res = ast_wait_for_input(ast_websocket_fd(session), -1)) > 0) {
771                 char *payload;
772                 uint64_t payload_len;
773                 enum ast_websocket_opcode opcode;
774                 int fragmented;
775
776                 if (ast_websocket_read(session, &payload, &payload_len, &opcode, &fragmented)) {
777                         /* We err on the side of caution and terminate the session if any error occurs */
778                         ast_log(LOG_WARNING, "Read failure during WebSocket echo loop\n");
779                         break;
780                 }
781
782                 if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
783                         ast_websocket_write(session, opcode, payload, payload_len);
784                 } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
785                         break;
786                 } else {
787                         ast_debug(1, "Ignored WebSocket opcode %d\n", opcode);
788                 }
789         }
790
791 end:
792         ast_debug(1, "Exitting WebSocket echo loop\n");
793         ast_websocket_unref(session);
794 }
795
796 static int websocket_add_protocol_internal(const char *name, ast_websocket_callback callback)
797 {
798         struct ast_websocket_server *ws_server = websocketuri.data;
799         if (!ws_server) {
800                 return -1;
801         }
802         return ast_websocket_server_add_protocol(ws_server, name, callback);
803 }
804
805 int AST_OPTIONAL_API_NAME(ast_websocket_add_protocol)(const char *name, ast_websocket_callback callback)
806 {
807         int res = websocket_add_protocol_internal(name, callback);
808         if (res == 0) {
809                 ast_module_ref(ast_module_info->self);
810         }
811         return res;
812 }
813
814 static int websocket_remove_protocol_internal(const char *name, ast_websocket_callback callback)
815 {
816         struct ast_websocket_server *ws_server = websocketuri.data;
817         if (!ws_server) {
818                 return -1;
819         }
820         return ast_websocket_server_remove_protocol(ws_server, name, callback);
821 }
822
823 int AST_OPTIONAL_API_NAME(ast_websocket_remove_protocol)(const char *name, ast_websocket_callback callback)
824 {
825         int res = websocket_remove_protocol_internal(name, callback);
826         if (res == 0) {
827                 ast_module_unref(ast_module_info->self);
828         }
829         return res;
830 }
831
832 static int load_module(void)
833 {
834         websocketuri.data = websocket_server_internal_create();
835         if (!websocketuri.data) {
836                 return AST_MODULE_LOAD_FAILURE;
837         }
838         ast_http_uri_link(&websocketuri);
839         websocket_add_protocol_internal("echo", websocket_echo_callback);
840
841         return 0;
842 }
843
844 static int unload_module(void)
845 {
846         ast_websocket_remove_protocol("echo", websocket_echo_callback);
847         ast_http_uri_unlink(&websocketuri);
848         ao2_ref(websocketuri.data, -1);
849         websocketuri.data = NULL;
850
851         return 0;
852 }
853
854 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "HTTP WebSocket Support",
855                 .load = load_module,
856                 .unload = unload_module,
857                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
858         );