Don't attempt a websocket protocol removal if res_http_websocket isn't there
[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 Structure definition for session */
62 struct ast_websocket {
63         FILE *f;                          /*!< Pointer to the file instance used for writing and reading */
64         int fd;                           /*!< File descriptor for the session, only used for polling */
65         struct ast_sockaddr address;      /*!< Address of the remote client */
66         enum ast_websocket_opcode opcode; /*!< Cached opcode for multi-frame messages */
67         size_t payload_len;               /*!< Length of the payload */
68         char *payload;                    /*!< Pointer to the payload */
69         size_t reconstruct;               /*!< Number of bytes before a reconstructed payload will be returned and a new one started */
70         unsigned int secure:1;            /*!< Bit to indicate that the transport is secure */
71         unsigned int closing:1;           /*!< Bit to indicate that the session is in the process of being closed */
72 };
73
74 /*! \brief Structure definition for protocols */
75 struct websocket_protocol {
76         char *name;                      /*!< Name of the protocol */
77         ast_websocket_callback callback; /*!< Callback called when a new session is established */
78 };
79
80 /*! \brief Container for registered protocols */
81 static struct ao2_container *protocols;
82
83 /*! \brief Hashing function for protocols */
84 static int protocol_hash_fn(const void *obj, const int flags)
85 {
86         const struct websocket_protocol *protocol = obj;
87         const char *name = obj;
88
89         return ast_str_case_hash(flags & OBJ_KEY ? name : protocol->name);
90 }
91
92 /*! \brief Comparison function for protocols */
93 static int protocol_cmp_fn(void *obj, void *arg, int flags)
94 {
95         const struct websocket_protocol *protocol1 = obj, *protocol2 = arg;
96         const char *protocol = arg;
97
98         return !strcasecmp(protocol1->name, flags & OBJ_KEY ? protocol : protocol2->name) ? CMP_MATCH | CMP_STOP : 0;
99 }
100
101 /*! \brief Destructor function for protocols */
102 static void protocol_destroy_fn(void *obj)
103 {
104         struct websocket_protocol *protocol = obj;
105         ast_free(protocol->name);
106 }
107
108 /*! \brief Destructor function for sessions */
109 static void session_destroy_fn(void *obj)
110 {
111         struct ast_websocket *session = obj;
112
113         if (session->f) {
114                 fclose(session->f);
115                 ast_verb(2, "WebSocket connection from '%s' closed\n", ast_sockaddr_stringify(&session->address));
116         }
117
118         ast_free(session->payload);
119 }
120
121 int AST_OPTIONAL_API_NAME(ast_websocket_add_protocol)(const char *name, ast_websocket_callback callback)
122 {
123         struct websocket_protocol *protocol;
124
125         if (!protocols) {
126                 return -1;
127         }
128
129         ao2_lock(protocols);
130
131         /* Ensure a second protocol handler is not registered for the same protocol */
132         if ((protocol = ao2_find(protocols, name, OBJ_KEY | OBJ_NOLOCK))) {
133                 ao2_ref(protocol, -1);
134                 ao2_unlock(protocols);
135                 return -1;
136         }
137
138         if (!(protocol = ao2_alloc(sizeof(*protocol), protocol_destroy_fn))) {
139                 ao2_unlock(protocols);
140                 return -1;
141         }
142
143         if (!(protocol->name = ast_strdup(name))) {
144                 ao2_ref(protocol, -1);
145                 ao2_unlock(protocols);
146                 return -1;
147         }
148
149         protocol->callback = callback;
150
151         ao2_link_flags(protocols, protocol, OBJ_NOLOCK);
152         ao2_unlock(protocols);
153         ao2_ref(protocol, -1);
154
155         ast_verb(2, "WebSocket registered sub-protocol '%s'\n", name);
156
157         return 0;
158 }
159
160 int AST_OPTIONAL_API_NAME(ast_websocket_remove_protocol)(const char *name, ast_websocket_callback callback)
161 {
162         struct websocket_protocol *protocol;
163
164         if (!protocols) {
165                 return -1;
166         }
167
168         if (!(protocol = ao2_find(protocols, name, OBJ_KEY))) {
169                 return -1;
170         }
171
172         if (protocol->callback != callback) {
173                 ao2_ref(protocol, -1);
174                 return -1;
175         }
176
177         ao2_unlink(protocols, protocol);
178         ao2_ref(protocol, -1);
179
180         ast_verb(2, "WebSocket unregistered sub-protocol '%s'\n", name);
181
182         return 0;
183 }
184
185 /*! \brief Close function for websocket session */
186 int AST_OPTIONAL_API_NAME(ast_websocket_close)(struct ast_websocket *session, uint16_t reason)
187 {
188         char frame[4] = { 0, }; /* The header is 2 bytes and the reason code takes up another 2 bytes */
189
190         frame[0] = AST_WEBSOCKET_OPCODE_CLOSE | 0x80;
191         frame[1] = 2; /* The reason code is always 2 bytes */
192
193         /* If no reason has been specified assume 1000 which is normal closure */
194         put_unaligned_uint16(&frame[2], htons(reason ? reason : 1000));
195
196         session->closing = 1;
197
198         return (fwrite(frame, 1, 4, session->f) == 4) ? 0 : -1;
199 }
200
201
202 /*! \brief Write function for websocket traffic */
203 int AST_OPTIONAL_API_NAME(ast_websocket_write)(struct ast_websocket *session, enum ast_websocket_opcode opcode, char *payload, uint64_t actual_length)
204 {
205         size_t header_size = 2; /* The minimum size of a websocket frame is 2 bytes */
206         char *frame;
207         uint64_t length = 0;
208
209         if (actual_length < 126) {
210                 length = actual_length;
211         } else if (actual_length < (1 << 16)) {
212                 length = 126;
213                 /* We need an additional 2 bytes to store the extended length */
214                 header_size += 2;
215         } else {
216                 length = 127;
217                 /* We need an additional 8 bytes to store the really really extended length */
218                 header_size += 8;
219         }
220
221         frame = ast_alloca(header_size);
222         memset(frame, 0, sizeof(*frame));
223
224         frame[0] = opcode | 0x80;
225         frame[1] = length;
226
227         /* Use the additional available bytes to store the length */
228         if (length == 126) {
229                 put_unaligned_uint16(&frame[2], htons(actual_length));
230         } else if (length == 127) {
231                 put_unaligned_uint64(&frame[2], htonl(actual_length));
232         }
233
234         if (fwrite(frame, 1, header_size, session->f) != header_size) {
235                 return -1;
236         }
237
238         if (fwrite(payload, 1, actual_length, session->f) != actual_length) {
239                 return -1;
240         }
241
242         return 0;
243 }
244
245 void AST_OPTIONAL_API_NAME(ast_websocket_reconstruct_enable)(struct ast_websocket *session, size_t bytes)
246 {
247         session->reconstruct = MIN(bytes, MAXIMUM_RECONSTRUCTION_CEILING);
248 }
249
250 void AST_OPTIONAL_API_NAME(ast_websocket_reconstruct_disable)(struct ast_websocket *session)
251 {
252         session->reconstruct = 0;
253 }
254
255 void AST_OPTIONAL_API_NAME(ast_websocket_ref)(struct ast_websocket *session)
256 {
257         ao2_ref(session, +1);
258 }
259
260 void AST_OPTIONAL_API_NAME(ast_websocket_unref)(struct ast_websocket *session)
261 {
262         ao2_ref(session, -1);
263 }
264
265 int AST_OPTIONAL_API_NAME(ast_websocket_fd)(struct ast_websocket *session)
266 {
267         return session->closing ? -1 : session->fd;
268 }
269
270 struct ast_sockaddr * AST_OPTIONAL_API_NAME(ast_websocket_remote_address)(struct ast_websocket *session)
271 {
272         return &session->address;
273 }
274
275 int AST_OPTIONAL_API_NAME(ast_websocket_is_secure)(struct ast_websocket *session)
276 {
277         return session->secure;
278 }
279
280 int AST_OPTIONAL_API_NAME(ast_websocket_set_nonblock)(struct ast_websocket *session)
281 {
282         int flags;
283
284         if ((flags = fcntl(session->fd, F_GETFL)) == -1) {
285                 return -1;
286         }
287
288         flags |= O_NONBLOCK;
289
290         if ((flags = fcntl(session->fd, F_SETFL, flags)) == -1) {
291                 return -1;
292         }
293
294         return 0;
295 }
296
297 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)
298 {
299         char buf[MAXIMUM_FRAME_SIZE] = "";
300         size_t frame_size, expected = 2;
301
302         *payload = NULL;
303         *payload_len = 0;
304         *fragmented = 0;
305
306         /* We try to read in 14 bytes, which is the largest possible WebSocket header */
307         if ((frame_size = fread(&buf, 1, 14, session->f)) < 1) {
308                 return -1;
309         }
310
311         /* The minimum size for a WebSocket frame is 2 bytes */
312         if (frame_size < expected) {
313                 return -1;
314         }
315
316         *opcode = buf[0] & 0xf;
317
318         if (*opcode == AST_WEBSOCKET_OPCODE_TEXT || *opcode == AST_WEBSOCKET_OPCODE_BINARY || *opcode == AST_WEBSOCKET_OPCODE_CONTINUATION ||
319             *opcode == AST_WEBSOCKET_OPCODE_PING || *opcode == AST_WEBSOCKET_OPCODE_PONG) {
320                 int fin = (buf[0] >> 7) & 1;
321                 int mask_present = (buf[1] >> 7) & 1;
322                 char *mask = NULL, *new_payload;
323                 size_t remaining;
324
325                 if (mask_present) {
326                         /* The mask should take up 4 bytes */
327                         expected += 4;
328
329                         if (frame_size < expected) {
330                                 /* Per the RFC 1009 means we received a message that was too large for us to process */
331                                 ast_websocket_close(session, 1009);
332                                 return 0;
333                         }
334                 }
335
336                 /* Assume no extended length and no masking at the beginning */
337                 *payload_len = buf[1] & 0x7f;
338                 *payload = &buf[2];
339
340                 /* Determine if extended length is being used */
341                 if (*payload_len == 126) {
342                         /* Use the next 2 bytes to get a uint16_t */
343                         expected += 2;
344                         *payload += 2;
345
346                         if (frame_size < expected) {
347                                 ast_websocket_close(session, 1009);
348                                 return 0;
349                         }
350
351                         *payload_len = ntohs(get_unaligned_uint16(&buf[2]));
352                 } else if (*payload_len == 127) {
353                         /* Use the next 8 bytes to get a uint64_t */
354                         expected += 8;
355                         *payload += 8;
356
357                         if (frame_size < expected) {
358                                 ast_websocket_close(session, 1009);
359                                 return 0;
360                         }
361
362                         *payload_len = ntohl(get_unaligned_uint64(&buf[2]));
363                 }
364
365                 /* If masking is present the payload currently points to the mask, so move it over 4 bytes to the actual payload */
366                 if (mask_present) {
367                         mask = *payload;
368                         *payload += 4;
369                 }
370
371                 /* Determine how much payload we need to read in as we may have already read some in */
372                 remaining = *payload_len - (frame_size - expected);
373
374                 /* If how much payload they want us to read in exceeds what we are capable of close the session, things
375                  * will fail no matter what most likely */
376                 if (remaining > (MAXIMUM_FRAME_SIZE - frame_size)) {
377                         ast_websocket_close(session, 1009);
378                         return 0;
379                 }
380
381                 new_payload = *payload + (frame_size - expected);
382
383                 /* Read in the remaining payload */
384                 while (remaining > 0) {
385                         size_t payload_read;
386
387                         /* Wait for data to come in */
388                         if (ast_wait_for_input(session->fd, -1) <= 0) {
389                                 *opcode = AST_WEBSOCKET_OPCODE_CLOSE;
390                                 *payload = NULL;
391                                 session->closing = 1;
392                                 return 0;
393                         }
394
395                         /* If some sort of failure occurs notify the caller */
396                         if ((payload_read = fread(new_payload, 1, remaining, session->f)) < 1) {
397                                 return -1;
398                         }
399
400                         remaining -= payload_read;
401                         new_payload += payload_read;
402                 }
403
404                 /* If a mask is present unmask the payload */
405                 if (mask_present) {
406                         unsigned int pos;
407                         for (pos = 0; pos < *payload_len; pos++) {
408                                 (*payload)[pos] ^= mask[pos % 4];
409                         }
410                 }
411
412                 if (!(new_payload = ast_realloc(session->payload, session->payload_len + *payload_len))) {
413                         *payload_len = 0;
414                         ast_websocket_close(session, 1009);
415                         return 0;
416                 }
417
418                 /* Per the RFC for PING we need to send back an opcode with the application data as received */
419                 if (*opcode == AST_WEBSOCKET_OPCODE_PING) {
420                         ast_websocket_write(session, AST_WEBSOCKET_OPCODE_PONG, *payload, *payload_len);
421                 }
422
423                 session->payload = new_payload;
424                 memcpy(session->payload + session->payload_len, *payload, *payload_len);
425                 session->payload_len += *payload_len;
426
427                 if (!fin && session->reconstruct && (session->payload_len < session->reconstruct)) {
428                         /* If this is not a final message we need to defer returning it until later */
429                         if (*opcode != AST_WEBSOCKET_OPCODE_CONTINUATION) {
430                                 session->opcode = *opcode;
431                         }
432                         *opcode = AST_WEBSOCKET_OPCODE_CONTINUATION;
433                         *payload_len = 0;
434                         *payload = NULL;
435                 } else {
436                         if (*opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
437                                 if (!fin) {
438                                         /* If this was not actually the final message tell the user it is fragmented so they can deal with it accordingly */
439                                         *fragmented = 1;
440                                 } else {
441                                         /* Final frame in multi-frame so push up the actual opcode */
442                                         *opcode = session->opcode;
443                                 }
444                         }
445                         *payload_len = session->payload_len;
446                         *payload = session->payload;
447                         session->payload_len = 0;
448                 }
449         } else if (*opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
450                 char *new_payload;
451
452                 *payload_len = buf[1] & 0x7f;
453
454                 /* Make the payload available so the user can look at the reason code if they so desire */
455                 if ((*payload_len) && (new_payload = ast_realloc(session->payload, *payload_len))) {
456                         session->payload = new_payload;
457                         memcpy(session->payload, &buf[2], *payload_len);
458                         *payload = session->payload;
459                 }
460
461                 if (!session->closing) {
462                         ast_websocket_close(session, 0);
463                 }
464
465                 fclose(session->f);
466                 session->f = NULL;
467                 ast_verb(2, "WebSocket connection from '%s' closed\n", ast_sockaddr_stringify(&session->address));
468         } else {
469                 /* 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
470                  * fit that, I think. */
471                 ast_websocket_close(session, 1003);
472         }
473
474         return 0;
475 }
476
477 /*! \brief Callback that is executed everytime an HTTP request is received by this module */
478 static int websocket_callback(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)
479 {
480         struct ast_variable *v;
481         char *upgrade = NULL, *key = NULL, *key1 = NULL, *key2 = NULL, *protos = NULL, *requested_protocols = NULL, *protocol = NULL;
482         int version = 0, flags = 1;
483         struct websocket_protocol *protocol_handler = NULL;
484         struct ast_websocket *session;
485
486         /* Upgrade requests are only permitted on GET methods */
487         if (method != AST_HTTP_GET) {
488                 ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
489                 return -1;
490         }
491
492         /* Get the minimum headers required to satisfy our needs */
493         for (v = headers; v; v = v->next) {
494                 if (!strcasecmp(v->name, "Upgrade")) {
495                         upgrade = ast_strip(ast_strdupa(v->value));
496                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key")) {
497                         key = ast_strip(ast_strdupa(v->value));
498                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key1")) {
499                         key1 = ast_strip(ast_strdupa(v->value));
500                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key2")) {
501                         key2 = ast_strip(ast_strdupa(v->value));
502                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Protocol")) {
503                         requested_protocols = ast_strip(ast_strdupa(v->value));
504                         protos = ast_strdupa(requested_protocols);
505                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Version")) {
506                         if (sscanf(v->value, "%30d", &version) != 1) {
507                                 version = 0;
508                         }
509                 }
510         }
511
512         /* If this is not a websocket upgrade abort */
513         if (!upgrade || strcasecmp(upgrade, "websocket")) {
514                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - did not request WebSocket\n",
515                         ast_sockaddr_stringify(&ser->remote_address));
516                 ast_http_error(ser, 426, "Upgrade Required", NULL);
517                 return -1;
518         } else if (ast_strlen_zero(requested_protocols)) {
519                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols requested\n",
520                         ast_sockaddr_stringify(&ser->remote_address));
521                 fputs("HTTP/1.1 400 Bad Request\r\n"
522                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
523                 return -1;
524         } else if (key1 && key2) {
525                 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 and
526                  * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00 -- not currently supported*/
527                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '00/76' chosen\n",
528                         ast_sockaddr_stringify(&ser->remote_address));
529                 fputs("HTTP/1.1 400 Bad Request\r\n"
530                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
531                 return 0;
532         }
533
534         /* Iterate through the requested protocols trying to find one that we have a handler for */
535         while ((protocol = strsep(&requested_protocols, ","))) {
536                 if ((protocol_handler = ao2_find(protocols, ast_strip(protocol), OBJ_KEY))) {
537                         break;
538                 }
539         }
540
541         /* If no protocol handler exists bump this back to the requester */
542         if (!protocol_handler) {
543                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols out of '%s' supported\n",
544                         ast_sockaddr_stringify(&ser->remote_address), protos);
545                 fputs("HTTP/1.1 400 Bad Request\r\n"
546                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
547                 return 0;
548         }
549
550         /* Determine how to respond depending on the version */
551         if (version == 7 || version == 8 || version == 13) {
552                 /* Version 7 defined in specification http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-07 */
553                 /* Version 8 defined in specification http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-10 */
554                 /* Version 13 defined in specification http://tools.ietf.org/html/rfc6455 */
555                 char combined[strlen(key) + strlen(WEBSOCKET_GUID) + 1], base64[64];
556                 uint8_t sha[20];
557
558                 if (!(session = ao2_alloc(sizeof(*session), session_destroy_fn))) {
559                         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted\n",
560                                 ast_sockaddr_stringify(&ser->remote_address));
561                         fputs("HTTP/1.1 400 Bad Request\r\n"
562                               "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
563                         ao2_ref(protocol_handler, -1);
564                         return 0;
565                 }
566
567                 snprintf(combined, sizeof(combined), "%s%s", key, WEBSOCKET_GUID);
568                 ast_sha1_hash_uint(sha, combined);
569                 ast_base64encode(base64, (const unsigned char*)sha, 20, sizeof(base64));
570
571                 fprintf(ser->f, "HTTP/1.1 101 Switching Protocols\r\n"
572                         "Upgrade: %s\r\n"
573                         "Connection: Upgrade\r\n"
574                         "Sec-WebSocket-Accept: %s\r\n"
575                         "Sec-WebSocket-Protocol: %s\r\n\r\n",
576                         upgrade,
577                         base64,
578                         protocol);
579         } else {
580
581                 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 or completely unknown */
582                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '%d' chosen\n",
583                         ast_sockaddr_stringify(&ser->remote_address), version ? version : 75);
584                 fputs("HTTP/1.1 400 Bad Request\r\n"
585                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
586                 ao2_ref(protocol_handler, -1);
587                 return 0;
588         }
589
590         /* Enable keepalive on all sessions so the underlying user does not have to */
591         if (setsockopt(ser->fd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags))) {
592                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to enable keepalive\n",
593                         ast_sockaddr_stringify(&ser->remote_address));
594                 fputs("HTTP/1.1 400 Bad Request\r\n"
595                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
596                 ao2_ref(session, -1);
597                 ao2_ref(protocol_handler, -1);
598                 return 0;
599         }
600
601         ast_verb(2, "WebSocket connection from '%s' for protocol '%s' accepted using version '%d'\n", ast_sockaddr_stringify(&ser->remote_address), protocol, version);
602
603         /* Populate the session with all the needed details */
604         session->f = ser->f;
605         session->fd = ser->fd;
606         ast_sockaddr_copy(&session->address, &ser->remote_address);
607         session->opcode = -1;
608         session->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
609         session->secure = ser->ssl ? 1 : 0;
610
611         /* Give up ownership of the socket and pass it to the protocol handler */
612         protocol_handler->callback(session, get_vars, headers);
613         ao2_ref(protocol_handler, -1);
614
615         /* By dropping the FILE* from the session it won't get closed when the HTTP server cleans up */
616         ser->f = NULL;
617
618         return 0;
619 }
620
621 static struct ast_http_uri websocketuri = {
622         .callback = websocket_callback,
623         .description = "Asterisk HTTP WebSocket",
624         .uri = "ws",
625         .has_subtree = 0,
626         .data = NULL,
627         .key = __FILE__,
628 };
629
630 /*! \brief Simple echo implementation which echoes received text and binary frames */
631 static void websocket_echo_callback(struct ast_websocket *session, struct ast_variable *parameters, struct ast_variable *headers)
632 {
633         int flags, res;
634
635         if ((flags = fcntl(ast_websocket_fd(session), F_GETFL)) == -1) {
636                 goto end;
637         }
638
639         flags |= O_NONBLOCK;
640
641         if (fcntl(ast_websocket_fd(session), F_SETFL, flags) == -1) {
642                 goto end;
643         }
644
645         while ((res = ast_wait_for_input(ast_websocket_fd(session), -1)) > 0) {
646                 char *payload;
647                 uint64_t payload_len;
648                 enum ast_websocket_opcode opcode;
649                 int fragmented;
650
651                 if (ast_websocket_read(session, &payload, &payload_len, &opcode, &fragmented)) {
652                         /* We err on the side of caution and terminate the session if any error occurs */
653                         break;
654                 }
655
656                 if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
657                         ast_websocket_write(session, opcode, payload, payload_len);
658                 } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
659                         break;
660                 }
661         }
662
663 end:
664         ast_websocket_unref(session);
665 }
666
667 static int load_module(void)
668 {
669         protocols = ao2_container_alloc(MAX_PROTOCOL_BUCKETS, protocol_hash_fn, protocol_cmp_fn);
670         ast_http_uri_link(&websocketuri);
671         ast_websocket_add_protocol("echo", websocket_echo_callback);
672
673         return 0;
674 }
675
676 static int unload_module(void)
677 {
678         ast_websocket_remove_protocol("echo", websocket_echo_callback);
679         ast_http_uri_unlink(&websocketuri);
680         ao2_ref(protocols, -1);
681         protocols = NULL;
682
683         return 0;
684 }
685
686 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "HTTP WebSocket Support",
687                 .load = load_module,
688                 .unload = unload_module,
689                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
690         );