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