AST-2014-007: Fix DOS by consuming the number of allowed HTTP connections.
[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 #include "asterisk/uri.h"
41
42 #define AST_API_MODULE
43 #include "asterisk/http_websocket.h"
44
45 /*! \brief GUID used to compute the accept key, defined in the specifications */
46 #define WEBSOCKET_GUID "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
47
48 /*! \brief Length of a websocket's client key */
49 #define CLIENT_KEY_SIZE 16
50
51 /*! \brief Number of buckets for registered protocols */
52 #define MAX_PROTOCOL_BUCKETS 7
53
54 /*! \brief Size of the pre-determined buffer for WebSocket frames */
55 #define MAXIMUM_FRAME_SIZE 8192
56
57 /*! \brief Default reconstruction size for multi-frame payload reconstruction. If exceeded the next frame will start a
58  *         payload.
59  */
60 #define DEFAULT_RECONSTRUCTION_CEILING 16384
61
62 /*! \brief Maximum reconstruction size for multi-frame payload reconstruction. */
63 #define MAXIMUM_RECONSTRUCTION_CEILING 16384
64
65 /*! \brief Maximum size of a websocket frame header
66  * 1 byte flags and opcode
67  * 1 byte mask flag + payload len
68  * 8 bytes max extended length
69  * 4 bytes optional masking key
70  * ... payload follows ...
71  * */
72 #define MAX_WS_HDR_SZ 14
73 #define MIN_WS_HDR_SZ 2
74
75 /*! \brief Structure definition for session */
76 struct ast_websocket {
77         FILE *f;                          /*!< Pointer to the file instance used for writing and reading */
78         int fd;                           /*!< File descriptor for the session, only used for polling */
79         struct ast_sockaddr address;      /*!< Address of the remote client */
80         enum ast_websocket_opcode opcode; /*!< Cached opcode for multi-frame messages */
81         size_t payload_len;               /*!< Length of the payload */
82         char *payload;                    /*!< Pointer to the payload */
83         size_t reconstruct;               /*!< Number of bytes before a reconstructed payload will be returned and a new one started */
84         unsigned int secure:1;            /*!< Bit to indicate that the transport is secure */
85         unsigned int closing:1;           /*!< Bit to indicate that the session is in the process of being closed */
86         unsigned int close_sent:1;        /*!< Bit to indicate that the session close opcode has been sent and no further data will be sent */
87         struct websocket_client *client;  /*!< Client object when connected as a client websocket */
88 };
89
90 /*! \brief Structure definition for protocols */
91 struct websocket_protocol {
92         char *name;                      /*!< Name of the protocol */
93         ast_websocket_callback callback; /*!< Callback called when a new session is established */
94 };
95
96 /*! \brief Hashing function for protocols */
97 static int protocol_hash_fn(const void *obj, const int flags)
98 {
99         const struct websocket_protocol *protocol = obj;
100         const char *name = obj;
101
102         return ast_str_case_hash(flags & OBJ_KEY ? name : protocol->name);
103 }
104
105 /*! \brief Comparison function for protocols */
106 static int protocol_cmp_fn(void *obj, void *arg, int flags)
107 {
108         const struct websocket_protocol *protocol1 = obj, *protocol2 = arg;
109         const char *protocol = arg;
110
111         return !strcasecmp(protocol1->name, flags & OBJ_KEY ? protocol : protocol2->name) ? CMP_MATCH | CMP_STOP : 0;
112 }
113
114 /*! \brief Destructor function for protocols */
115 static void protocol_destroy_fn(void *obj)
116 {
117         struct websocket_protocol *protocol = obj;
118         ast_free(protocol->name);
119 }
120
121 /*! \brief Structure for a WebSocket server */
122 struct ast_websocket_server {
123         struct ao2_container *protocols; /*!< Container for registered protocols */
124 };
125
126 static void websocket_server_internal_dtor(void *obj)
127 {
128         struct ast_websocket_server *server = obj;
129         ao2_cleanup(server->protocols);
130         server->protocols = NULL;
131 }
132
133 static void websocket_server_dtor(void *obj)
134 {
135         websocket_server_internal_dtor(obj);
136         ast_module_unref(ast_module_info->self);
137 }
138
139 static struct ast_websocket_server *websocket_server_create_impl(void (*dtor)(void *))
140 {
141         RAII_VAR(struct ast_websocket_server *, server, NULL, ao2_cleanup);
142
143         server = ao2_alloc(sizeof(*server), dtor);
144         if (!server) {
145                 return NULL;
146         }
147
148         server->protocols = ao2_container_alloc(MAX_PROTOCOL_BUCKETS, protocol_hash_fn, protocol_cmp_fn);
149         if (!server->protocols) {
150                 return NULL;
151         }
152
153         ao2_ref(server, +1);
154         return server;
155 }
156
157 static struct ast_websocket_server *websocket_server_internal_create(void)
158 {
159         return websocket_server_create_impl(websocket_server_internal_dtor);
160 }
161
162 struct ast_websocket_server *AST_OPTIONAL_API_NAME(ast_websocket_server_create)(void)
163 {
164         ast_module_ref(ast_module_info->self);
165         return websocket_server_create_impl(websocket_server_dtor);
166 }
167
168 /*! \brief Destructor function for sessions */
169 static void session_destroy_fn(void *obj)
170 {
171         struct ast_websocket *session = obj;
172
173         if (session->f) {
174                 ast_websocket_close(session, 0);
175                 fclose(session->f);
176                 ast_verb(2, "WebSocket connection from '%s' closed\n", ast_sockaddr_stringify(&session->address));
177         }
178
179         ao2_cleanup(session->client);
180         ast_free(session->payload);
181 }
182
183 int AST_OPTIONAL_API_NAME(ast_websocket_server_add_protocol)(struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
184 {
185         struct websocket_protocol *protocol;
186
187         if (!server->protocols) {
188                 return -1;
189         }
190
191         ao2_lock(server->protocols);
192
193         /* Ensure a second protocol handler is not registered for the same protocol */
194         if ((protocol = ao2_find(server->protocols, name, OBJ_KEY | OBJ_NOLOCK))) {
195                 ao2_ref(protocol, -1);
196                 ao2_unlock(server->protocols);
197                 return -1;
198         }
199
200         if (!(protocol = ao2_alloc(sizeof(*protocol), protocol_destroy_fn))) {
201                 ao2_unlock(server->protocols);
202                 return -1;
203         }
204
205         if (!(protocol->name = ast_strdup(name))) {
206                 ao2_ref(protocol, -1);
207                 ao2_unlock(server->protocols);
208                 return -1;
209         }
210
211         protocol->callback = callback;
212
213         ao2_link_flags(server->protocols, protocol, OBJ_NOLOCK);
214         ao2_unlock(server->protocols);
215         ao2_ref(protocol, -1);
216
217         ast_verb(2, "WebSocket registered sub-protocol '%s'\n", name);
218
219         return 0;
220 }
221
222 int AST_OPTIONAL_API_NAME(ast_websocket_server_remove_protocol)(struct ast_websocket_server *server, const char *name, ast_websocket_callback callback)
223 {
224         struct websocket_protocol *protocol;
225
226         if (!(protocol = ao2_find(server->protocols, name, OBJ_KEY))) {
227                 return -1;
228         }
229
230         if (protocol->callback != callback) {
231                 ao2_ref(protocol, -1);
232                 return -1;
233         }
234
235         ao2_unlink(server->protocols, protocol);
236         ao2_ref(protocol, -1);
237
238         ast_verb(2, "WebSocket unregistered sub-protocol '%s'\n", name);
239
240         return 0;
241 }
242
243 /*! \brief Close function for websocket session */
244 int AST_OPTIONAL_API_NAME(ast_websocket_close)(struct ast_websocket *session, uint16_t reason)
245 {
246         char frame[4] = { 0, }; /* The header is 2 bytes and the reason code takes up another 2 bytes */
247         int res;
248
249         if (session->close_sent) {
250                 return 0;
251         }
252
253         frame[0] = AST_WEBSOCKET_OPCODE_CLOSE | 0x80;
254         frame[1] = 2; /* The reason code is always 2 bytes */
255
256         /* If no reason has been specified assume 1000 which is normal closure */
257         put_unaligned_uint16(&frame[2], htons(reason ? reason : 1000));
258
259         session->closing = 1;
260         session->close_sent = 1;
261
262         ao2_lock(session);
263         res = (fwrite(frame, 1, 4, session->f) == 4) ? 0 : -1;
264         ao2_unlock(session);
265         return res;
266 }
267
268
269 /*! \brief Write function for websocket traffic */
270 int AST_OPTIONAL_API_NAME(ast_websocket_write)(struct ast_websocket *session, enum ast_websocket_opcode opcode, char *payload, uint64_t actual_length)
271 {
272         size_t header_size = 2; /* The minimum size of a websocket frame is 2 bytes */
273         char *frame;
274         uint64_t length = 0;
275
276         if (actual_length < 126) {
277                 length = actual_length;
278         } else if (actual_length < (1 << 16)) {
279                 length = 126;
280                 /* We need an additional 2 bytes to store the extended length */
281                 header_size += 2;
282         } else {
283                 length = 127;
284                 /* We need an additional 8 bytes to store the really really extended length */
285                 header_size += 8;
286         }
287
288         frame = ast_alloca(header_size);
289         memset(frame, 0, sizeof(*frame));
290
291         frame[0] = opcode | 0x80;
292         frame[1] = length;
293
294         /* Use the additional available bytes to store the length */
295         if (length == 126) {
296                 put_unaligned_uint16(&frame[2], htons(actual_length));
297         } else if (length == 127) {
298                 put_unaligned_uint64(&frame[2], htonl(actual_length));
299         }
300
301         ao2_lock(session);
302         if (session->closing) {
303                 ao2_unlock(session);
304                 return -1;
305         }
306
307         if (fwrite(frame, 1, header_size, session->f) != header_size) {
308                 ao2_unlock(session);
309                 return -1;
310         }
311
312         if (fwrite(payload, 1, actual_length, session->f) != actual_length) {
313                 ao2_unlock(session);
314                 return -1;
315         }
316         fflush(session->f);
317         ao2_unlock(session);
318
319         return 0;
320 }
321
322 void AST_OPTIONAL_API_NAME(ast_websocket_reconstruct_enable)(struct ast_websocket *session, size_t bytes)
323 {
324         session->reconstruct = MIN(bytes, MAXIMUM_RECONSTRUCTION_CEILING);
325 }
326
327 void AST_OPTIONAL_API_NAME(ast_websocket_reconstruct_disable)(struct ast_websocket *session)
328 {
329         session->reconstruct = 0;
330 }
331
332 void AST_OPTIONAL_API_NAME(ast_websocket_ref)(struct ast_websocket *session)
333 {
334         ao2_ref(session, +1);
335 }
336
337 void AST_OPTIONAL_API_NAME(ast_websocket_unref)(struct ast_websocket *session)
338 {
339         ao2_cleanup(session);
340 }
341
342 int AST_OPTIONAL_API_NAME(ast_websocket_fd)(struct ast_websocket *session)
343 {
344         return session->closing ? -1 : session->fd;
345 }
346
347 struct ast_sockaddr * AST_OPTIONAL_API_NAME(ast_websocket_remote_address)(struct ast_websocket *session)
348 {
349         return &session->address;
350 }
351
352 int AST_OPTIONAL_API_NAME(ast_websocket_is_secure)(struct ast_websocket *session)
353 {
354         return session->secure;
355 }
356
357 int AST_OPTIONAL_API_NAME(ast_websocket_set_nonblock)(struct ast_websocket *session)
358 {
359         int flags;
360
361         if ((flags = fcntl(session->fd, F_GETFL)) == -1) {
362                 return -1;
363         }
364
365         flags |= O_NONBLOCK;
366
367         if ((flags = fcntl(session->fd, F_SETFL, flags)) == -1) {
368                 return -1;
369         }
370
371         return 0;
372 }
373
374 /* MAINTENANCE WARNING on ast_websocket_read()!
375  *
376  * We have to keep in mind during this function that the fact that session->fd seems ready
377  * (via poll) does not necessarily mean we have application data ready, because in the case
378  * of an SSL socket, there is some encryption data overhead that needs to be read from the
379  * TCP socket, so poll() may say there are bytes to be read, but whether it is just 1 byte
380  * or N bytes we do not know that, and we do not know how many of those bytes (if any) are
381  * for application data (for us) and not just for the SSL protocol consumption
382  *
383  * There used to be a couple of nasty bugs here that were fixed in last refactoring but I
384  * want to document them so the constraints are clear and we do not re-introduce them:
385  *
386  * - This function would incorrectly assume that fread() would necessarily return more than
387  *   1 byte of data, just because a websocket frame is always >= 2 bytes, but the thing
388  *   is we're dealing with a TCP bitstream here, we could read just one byte and that's normal.
389  *   The problem before was that if just one byte was read, the function bailed out and returned
390  *   an error, effectively dropping the first byte of a websocket frame header!
391  *
392  * - Another subtle bug was that it would just read up to MAX_WS_HDR_SZ (14 bytes) via fread()
393  *   then assume that executing poll() would tell you if there is more to read, but since
394  *   we're dealing with a buffered stream (session->f is a FILE*), poll would say there is
395  *   nothing else to read (in the real tcp socket session->fd) and we would get stuck here
396  *   without processing the rest of the data in session->f internal buffers until another packet
397  *   came on the network to unblock us!
398  *
399  * Note during the header parsing stage we try to read in small chunks just what we need, this
400  * is buffered data anyways, no expensive syscall required most of the time ...
401  */
402 static inline int ws_safe_read(struct ast_websocket *session, char *buf, int len, enum ast_websocket_opcode *opcode)
403 {
404         int sanity;
405         size_t rlen;
406         int xlen = len;
407         char *rbuf = buf;
408         for (sanity = 10; sanity; sanity--) {
409                 clearerr(session->f);
410                 rlen = fread(rbuf, 1, xlen, session->f);
411                 if (0 == rlen && ferror(session->f) && errno != EAGAIN) {
412                         ast_log(LOG_ERROR, "Error reading from web socket: %s\n", strerror(errno));
413                         (*opcode) = AST_WEBSOCKET_OPCODE_CLOSE;
414                         session->closing = 1;
415                         return -1;
416                 }
417                 xlen = (xlen - rlen);
418                 rbuf = rbuf + rlen;
419                 if (0 == xlen) {
420                         break;
421                 }
422                 if (ast_wait_for_input(session->fd, 1000) < 0) {
423                         ast_log(LOG_ERROR, "ast_wait_for_input returned err: %s\n", strerror(errno));
424                         (*opcode) = AST_WEBSOCKET_OPCODE_CLOSE;
425                         session->closing = 1;
426                         return -1;
427                 }
428         }
429         if (!sanity) {
430                 ast_log(LOG_WARNING, "Websocket seems unresponsive, disconnecting ...\n");
431                 (*opcode) = AST_WEBSOCKET_OPCODE_CLOSE;
432                 session->closing = 1;
433                 return -1;
434         }
435         return 0;
436 }
437
438 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)
439 {
440         char buf[MAXIMUM_FRAME_SIZE] = "";
441         int fin = 0;
442         int mask_present = 0;
443         char *mask = NULL, *new_payload = NULL;
444         size_t options_len = 0, frame_size = 0;
445
446         *payload = NULL;
447         *payload_len = 0;
448         *fragmented = 0;
449
450         if (ws_safe_read(session, &buf[0], MIN_WS_HDR_SZ, opcode)) {
451                 return 0;
452         }
453         frame_size += MIN_WS_HDR_SZ;
454
455         /* 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) */
456         *opcode = buf[0] & 0xf;
457         *payload_len = buf[1] & 0x7f;
458         if (*opcode == AST_WEBSOCKET_OPCODE_TEXT || *opcode == AST_WEBSOCKET_OPCODE_BINARY || *opcode == AST_WEBSOCKET_OPCODE_CONTINUATION ||
459             *opcode == AST_WEBSOCKET_OPCODE_PING || *opcode == AST_WEBSOCKET_OPCODE_PONG) {
460                 fin = (buf[0] >> 7) & 1;
461                 mask_present = (buf[1] >> 7) & 1;
462
463                 /* Based on the mask flag and payload length, determine how much more we need to read before start parsing the rest of the header */
464                 options_len += mask_present ? 4 : 0;
465                 options_len += (*payload_len == 126) ? 2 : (*payload_len == 127) ? 8 : 0;
466                 if (options_len) {
467                         /* read the rest of the header options */
468                         if (ws_safe_read(session, &buf[frame_size], options_len, opcode)) {
469                                 return 0;
470                         }
471                         frame_size += options_len;
472                 }
473
474                 if (*payload_len == 126) {
475                         /* Grab the 2-byte payload length  */
476                         *payload_len = ntohs(get_unaligned_uint16(&buf[2]));
477                         mask = &buf[4];
478                 } else if (*payload_len == 127) {
479                         /* Grab the 8-byte payload length  */
480                         *payload_len = ntohl(get_unaligned_uint64(&buf[2]));
481                         mask = &buf[10];
482                 } else {
483                         /* Just set the mask after the small 2-byte header */
484                         mask = &buf[2];
485                 }
486
487                 /* Now read the rest of the payload */
488                 *payload = &buf[frame_size]; /* payload will start here, at the end of the options, if any */
489                 frame_size = frame_size + (*payload_len); /* final frame size is header + optional headers + payload data */
490                 if (frame_size > MAXIMUM_FRAME_SIZE) {
491                         ast_log(LOG_WARNING, "Cannot fit huge websocket frame of %zu bytes\n", frame_size);
492                         /* The frame won't fit :-( */
493                         ast_websocket_close(session, 1009);
494                         return -1;
495                 }
496
497                 if (ws_safe_read(session, (*payload), (*payload_len), opcode)) {
498                         return 0;
499                 }
500
501                 /* If a mask is present unmask the payload */
502                 if (mask_present) {
503                         unsigned int pos;
504                         for (pos = 0; pos < *payload_len; pos++) {
505                                 (*payload)[pos] ^= mask[pos % 4];
506                         }
507                 }
508
509                 if (!(new_payload = ast_realloc(session->payload, (session->payload_len + *payload_len)))) {
510                         ast_log(LOG_WARNING, "Failed allocation: %p, %zu, %"PRIu64"\n",
511                                 session->payload, session->payload_len, *payload_len);
512                         *payload_len = 0;
513                         ast_websocket_close(session, 1009);
514                         return 0;
515                 }
516
517                 /* Per the RFC for PING we need to send back an opcode with the application data as received */
518                 if (*opcode == AST_WEBSOCKET_OPCODE_PING) {
519                         ast_websocket_write(session, AST_WEBSOCKET_OPCODE_PONG, *payload, *payload_len);
520                 }
521
522                 session->payload = new_payload;
523                 memcpy((session->payload + session->payload_len), (*payload), (*payload_len));
524                 session->payload_len += *payload_len;
525
526                 if (!fin && session->reconstruct && (session->payload_len < session->reconstruct)) {
527                         /* If this is not a final message we need to defer returning it until later */
528                         if (*opcode != AST_WEBSOCKET_OPCODE_CONTINUATION) {
529                                 session->opcode = *opcode;
530                         }
531                         *opcode = AST_WEBSOCKET_OPCODE_CONTINUATION;
532                         *payload_len = 0;
533                         *payload = NULL;
534                 } else {
535                         if (*opcode == AST_WEBSOCKET_OPCODE_CONTINUATION) {
536                                 if (!fin) {
537                                         /* If this was not actually the final message tell the user it is fragmented so they can deal with it accordingly */
538                                         *fragmented = 1;
539                                 } else {
540                                         /* Final frame in multi-frame so push up the actual opcode */
541                                         *opcode = session->opcode;
542                                 }
543                         }
544                         *payload_len = session->payload_len;
545                         *payload = session->payload;
546                         session->payload_len = 0;
547                 }
548         } else if (*opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
549                 /* Make the payload available so the user can look at the reason code if they so desire */
550                 if ((*payload_len) && (new_payload = ast_realloc(session->payload, *payload_len))) {
551                         if (ws_safe_read(session, &buf[frame_size], (*payload_len), opcode)) {
552                                 return 0;
553                         }
554                         session->payload = new_payload;
555                         memcpy(session->payload, &buf[frame_size], *payload_len);
556                         *payload = session->payload;
557                         frame_size += (*payload_len);
558                 }
559
560                 session->closing = 1;
561         } else {
562                 ast_log(LOG_WARNING, "WebSocket unknown opcode %u\n", *opcode);
563                 /* 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
564                  * fit that, I think. */
565                 ast_websocket_close(session, 1003);
566         }
567
568         return 0;
569 }
570
571 /*!
572  * \brief If the server has exactly one configured protocol, return it.
573  */
574 static struct websocket_protocol *one_protocol(
575         struct ast_websocket_server *server)
576 {
577         SCOPED_AO2LOCK(lock, server->protocols);
578
579         if (ao2_container_count(server->protocols) != 1) {
580                 return NULL;
581         }
582
583         return ao2_callback(server->protocols, OBJ_NOLOCK, NULL, NULL);
584 }
585
586 static char *websocket_combine_key(const char *key, char *res, int res_size)
587 {
588         char *combined;
589         unsigned combined_length = strlen(key) + strlen(WEBSOCKET_GUID) + 1;
590         uint8_t sha[20];
591
592         combined = ast_alloca(combined_length);
593         snprintf(combined, combined_length, "%s%s", key, WEBSOCKET_GUID);
594         ast_sha1_hash_uint(sha, combined);
595         ast_base64encode(res, (const unsigned char*)sha, 20, res_size);
596         return res;
597 }
598
599 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)
600 {
601         struct ast_variable *v;
602         char *upgrade = NULL, *key = NULL, *key1 = NULL, *key2 = NULL, *protos = NULL, *requested_protocols = NULL, *protocol = NULL;
603         int version = 0, flags = 1;
604         struct websocket_protocol *protocol_handler = NULL;
605         struct ast_websocket *session;
606         struct ast_websocket_server *server;
607
608         SCOPED_MODULE_USE(ast_module_info->self);
609
610         /* Upgrade requests are only permitted on GET methods */
611         if (method != AST_HTTP_GET) {
612                 ast_http_error(ser, 501, "Not Implemented", "Attempt to use unimplemented / unsupported method");
613                 return -1;
614         }
615
616         server = urih->data;
617
618         /* Get the minimum headers required to satisfy our needs */
619         for (v = headers; v; v = v->next) {
620                 if (!strcasecmp(v->name, "Upgrade")) {
621                         upgrade = ast_strip(ast_strdupa(v->value));
622                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key")) {
623                         key = ast_strip(ast_strdupa(v->value));
624                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key1")) {
625                         key1 = ast_strip(ast_strdupa(v->value));
626                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Key2")) {
627                         key2 = ast_strip(ast_strdupa(v->value));
628                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Protocol")) {
629                         requested_protocols = ast_strip(ast_strdupa(v->value));
630                         protos = ast_strdupa(requested_protocols);
631                 } else if (!strcasecmp(v->name, "Sec-WebSocket-Version")) {
632                         if (sscanf(v->value, "%30d", &version) != 1) {
633                                 version = 0;
634                         }
635                 }
636         }
637
638         /* If this is not a websocket upgrade abort */
639         if (!upgrade || strcasecmp(upgrade, "websocket")) {
640                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - did not request WebSocket\n",
641                         ast_sockaddr_stringify(&ser->remote_address));
642                 ast_http_error(ser, 426, "Upgrade Required", NULL);
643                 return -1;
644         } else if (ast_strlen_zero(requested_protocols)) {
645                 /* If there's only a single protocol registered, and the
646                  * client doesn't specify what protocol it's using, go ahead
647                  * and accept the connection */
648                 protocol_handler = one_protocol(server);
649                 if (!protocol_handler) {
650                         /* Multiple registered subprotocols; client must specify */
651                         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols requested\n",
652                                 ast_sockaddr_stringify(&ser->remote_address));
653                         fputs("HTTP/1.1 400 Bad Request\r\n"
654                                 "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
655                         return -1;
656                 }
657         } else if (key1 && key2) {
658                 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76 and
659                  * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-00 -- not currently supported*/
660                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '00/76' chosen\n",
661                         ast_sockaddr_stringify(&ser->remote_address));
662                 fputs("HTTP/1.1 400 Bad Request\r\n"
663                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
664                 return 0;
665         }
666
667         /* Iterate through the requested protocols trying to find one that we have a handler for */
668         while (!protocol_handler && (protocol = strsep(&requested_protocols, ","))) {
669                 protocol_handler = ao2_find(server->protocols, ast_strip(protocol), OBJ_KEY);
670         }
671
672         /* If no protocol handler exists bump this back to the requester */
673         if (!protocol_handler) {
674                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - no protocols out of '%s' supported\n",
675                         ast_sockaddr_stringify(&ser->remote_address), protos);
676                 fputs("HTTP/1.1 400 Bad Request\r\n"
677                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
678                 return 0;
679         }
680
681         /* Determine how to respond depending on the version */
682         if (version == 7 || version == 8 || version == 13) {
683                 char base64[64];
684
685                 if (!key || strlen(key) + strlen(WEBSOCKET_GUID) + 1 > 8192) { /* no stack overflows please */
686                         fputs("HTTP/1.1 400 Bad Request\r\n"
687                               "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
688                         ao2_ref(protocol_handler, -1);
689                         return 0;
690                 }
691
692                 if (!(session = ao2_alloc(sizeof(*session), session_destroy_fn))) {
693                         ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted\n",
694                                 ast_sockaddr_stringify(&ser->remote_address));
695                         fputs("HTTP/1.1 400 Bad Request\r\n"
696                               "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
697                         ao2_ref(protocol_handler, -1);
698                         return 0;
699                 }
700
701                 fprintf(ser->f, "HTTP/1.1 101 Switching Protocols\r\n"
702                         "Upgrade: %s\r\n"
703                         "Connection: Upgrade\r\n"
704                         "Sec-WebSocket-Accept: %s\r\n",
705                         upgrade,
706                         websocket_combine_key(key, base64, sizeof(base64)));
707
708                 /* RFC 6455, Section 4.1:
709                  *
710                  * 6. If the response includes a |Sec-WebSocket-Protocol| header
711                  *    field and this header field indicates the use of a
712                  *    subprotocol that was not present in the client's handshake
713                  *    (the server has indicated a subprotocol not requested by
714                  *    the client), the client MUST _Fail the WebSocket
715                  *    Connection_.
716                  */
717                 if (protocol) {
718                         fprintf(ser->f, "Sec-WebSocket-Protocol: %s\r\n",
719                                 protocol);
720                 }
721
722                 fprintf(ser->f, "\r\n");
723                 fflush(ser->f);
724         } else {
725
726                 /* Specification defined in http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75 or completely unknown */
727                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - unsupported version '%d' chosen\n",
728                         ast_sockaddr_stringify(&ser->remote_address), version ? version : 75);
729                 fputs("HTTP/1.1 400 Bad Request\r\n"
730                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
731                 ao2_ref(protocol_handler, -1);
732                 return 0;
733         }
734
735         /* Enable keepalive on all sessions so the underlying user does not have to */
736         if (setsockopt(ser->fd, SOL_SOCKET, SO_KEEPALIVE, &flags, sizeof(flags))) {
737                 ast_log(LOG_WARNING, "WebSocket connection from '%s' could not be accepted - failed to enable keepalive\n",
738                         ast_sockaddr_stringify(&ser->remote_address));
739                 fputs("HTTP/1.1 400 Bad Request\r\n"
740                       "Sec-WebSocket-Version: 7, 8, 13\r\n\r\n", ser->f);
741                 ao2_ref(session, -1);
742                 ao2_ref(protocol_handler, -1);
743                 return 0;
744         }
745
746         ast_verb(2, "WebSocket connection from '%s' for protocol '%s' accepted using version '%d'\n", ast_sockaddr_stringify(&ser->remote_address), protocol ? : "", version);
747
748         /* Populate the session with all the needed details */
749         session->f = ser->f;
750         session->fd = ser->fd;
751         ast_sockaddr_copy(&session->address, &ser->remote_address);
752         session->opcode = -1;
753         session->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
754         session->secure = ser->ssl ? 1 : 0;
755
756         /* Give up ownership of the socket and pass it to the protocol handler */
757         protocol_handler->callback(session, get_vars, headers);
758         ao2_ref(protocol_handler, -1);
759
760         /*
761          * By dropping the FILE* and fd from the session the connection
762          * won't get closed when the HTTP server cleans up because we
763          * passed the connection to the protocol handler.
764          */
765         ser->f = NULL;
766         ser->fd = -1;
767
768         return 0;
769 }
770
771 static struct ast_http_uri websocketuri = {
772         .callback = AST_OPTIONAL_API_NAME(ast_websocket_uri_cb),
773         .description = "Asterisk HTTP WebSocket",
774         .uri = "ws",
775         .has_subtree = 0,
776         .data = NULL,
777         .key = __FILE__,
778 };
779
780 /*! \brief Simple echo implementation which echoes received text and binary frames */
781 static void websocket_echo_callback(struct ast_websocket *session, struct ast_variable *parameters, struct ast_variable *headers)
782 {
783         int flags, res;
784
785         ast_debug(1, "Entering WebSocket echo loop\n");
786
787         if ((flags = fcntl(ast_websocket_fd(session), F_GETFL)) == -1) {
788                 goto end;
789         }
790
791         flags |= O_NONBLOCK;
792
793         if (fcntl(ast_websocket_fd(session), F_SETFL, flags) == -1) {
794                 goto end;
795         }
796
797         while ((res = ast_wait_for_input(ast_websocket_fd(session), -1)) > 0) {
798                 char *payload;
799                 uint64_t payload_len;
800                 enum ast_websocket_opcode opcode;
801                 int fragmented;
802
803                 if (ast_websocket_read(session, &payload, &payload_len, &opcode, &fragmented)) {
804                         /* We err on the side of caution and terminate the session if any error occurs */
805                         ast_log(LOG_WARNING, "Read failure during WebSocket echo loop\n");
806                         break;
807                 }
808
809                 if (opcode == AST_WEBSOCKET_OPCODE_TEXT || opcode == AST_WEBSOCKET_OPCODE_BINARY) {
810                         ast_websocket_write(session, opcode, payload, payload_len);
811                 } else if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
812                         break;
813                 } else {
814                         ast_debug(1, "Ignored WebSocket opcode %u\n", opcode);
815                 }
816         }
817
818 end:
819         ast_debug(1, "Exitting WebSocket echo loop\n");
820         ast_websocket_unref(session);
821 }
822
823 static int websocket_add_protocol_internal(const char *name, ast_websocket_callback callback)
824 {
825         struct ast_websocket_server *ws_server = websocketuri.data;
826         if (!ws_server) {
827                 return -1;
828         }
829         return ast_websocket_server_add_protocol(ws_server, name, callback);
830 }
831
832 int AST_OPTIONAL_API_NAME(ast_websocket_add_protocol)(const char *name, ast_websocket_callback callback)
833 {
834         int res = websocket_add_protocol_internal(name, callback);
835         if (res == 0) {
836                 ast_module_ref(ast_module_info->self);
837         }
838         return res;
839 }
840
841 static int websocket_remove_protocol_internal(const char *name, ast_websocket_callback callback)
842 {
843         struct ast_websocket_server *ws_server = websocketuri.data;
844         if (!ws_server) {
845                 return -1;
846         }
847         return ast_websocket_server_remove_protocol(ws_server, name, callback);
848 }
849
850 int AST_OPTIONAL_API_NAME(ast_websocket_remove_protocol)(const char *name, ast_websocket_callback callback)
851 {
852         int res = websocket_remove_protocol_internal(name, callback);
853         if (res == 0) {
854                 ast_module_unref(ast_module_info->self);
855         }
856         return res;
857 }
858
859 /*! \brief Parse the given uri into a path and remote address.
860  *
861  * Expected uri form: [ws[s]]://<host>[:port][/<path>]
862  *
863  * The returned host will contain the address and optional port while
864  * path will contain everything after the address/port if included.
865  */
866 static int websocket_client_parse_uri(const char *uri, char **host, char **path)
867 {
868         struct ast_uri *parsed_uri = ast_uri_parse_websocket(uri);
869
870         if (!parsed_uri) {
871                 return -1;
872         }
873
874         *host = ast_uri_make_host_with_port(parsed_uri);
875
876         if (ast_uri_path(parsed_uri) && !(*path = ast_strdup(ast_uri_path(parsed_uri)))) {
877                 ao2_ref(parsed_uri, -1);
878                 return -1;
879         }
880
881         ao2_ref(parsed_uri, -1);
882         return 0;
883 }
884
885 static void websocket_client_args_destroy(void *obj)
886 {
887         struct ast_tcptls_session_args *args = obj;
888
889         if (args->tls_cfg) {
890                 ast_free(args->tls_cfg->certfile);
891                 ast_free(args->tls_cfg->pvtfile);
892                 ast_free(args->tls_cfg->cipher);
893                 ast_free(args->tls_cfg->cafile);
894                 ast_free(args->tls_cfg->capath);
895
896                 ast_ssl_teardown(args->tls_cfg);
897         }
898         ast_free(args->tls_cfg);
899 }
900
901 static struct ast_tcptls_session_args *websocket_client_args_create(
902         const char *host, struct ast_tls_config *tls_cfg,
903         enum ast_websocket_result *result)
904 {
905         struct ast_sockaddr *addr;
906         struct ast_tcptls_session_args *args = ao2_alloc(
907                 sizeof(*args), websocket_client_args_destroy);
908
909         if (!args) {
910                 *result = WS_ALLOCATE_ERROR;
911                 return NULL;
912         }
913
914         args->accept_fd = -1;
915         args->tls_cfg = tls_cfg;
916         args->name = "websocket client";
917
918         if (!ast_sockaddr_resolve(&addr, host, 0, 0)) {
919                 ast_log(LOG_ERROR, "Unable to resolve address %s\n",
920                         host);
921                 ao2_ref(args, -1);
922                 *result = WS_URI_RESOLVE_ERROR;
923                 return NULL;
924         }
925         ast_sockaddr_copy(&args->remote_address, addr);
926         ast_free(addr);
927         return args;
928 }
929
930 static char *websocket_client_create_key(void)
931 {
932         static int encoded_size = CLIENT_KEY_SIZE * 2 * sizeof(char) + 1;
933         /* key is randomly selected 16-byte base64 encoded value */
934         unsigned char key[CLIENT_KEY_SIZE + sizeof(long) - 1];
935         char *encoded = ast_malloc(encoded_size);
936         long i = 0;
937
938         if (!encoded) {
939                 ast_log(LOG_ERROR, "Unable to allocate client websocket key\n");
940                 return NULL;
941         }
942
943         while (i < CLIENT_KEY_SIZE) {
944                 long num = ast_random();
945                 memcpy(key + i, &num, sizeof(long));
946                 i += sizeof(long);
947         }
948
949         ast_base64encode(encoded, key, CLIENT_KEY_SIZE, encoded_size);
950         return encoded;
951 }
952
953 struct websocket_client {
954         /*! host portion of client uri */
955         char *host;
956         /*! path for logical websocket connection */
957         char *resource_name;
958         /*! unique key used during server handshaking */
959         char *key;
960         /*! container for registered protocols */
961         char *protocols;
962         /*! the protocol accepted by the server */
963         char *accept_protocol;
964         /*! websocket protocol version */
965         int version;
966         /*! tcptls connection arguments */
967         struct ast_tcptls_session_args *args;
968         /*! tcptls connection instance */
969         struct ast_tcptls_session_instance *ser;
970 };
971
972 static void websocket_client_destroy(void *obj)
973 {
974         struct websocket_client *client = obj;
975
976         ao2_cleanup(client->ser);
977         ao2_cleanup(client->args);
978
979         ast_free(client->accept_protocol);
980         ast_free(client->protocols);
981         ast_free(client->key);
982         ast_free(client->resource_name);
983         ast_free(client->host);
984 }
985
986 static struct ast_websocket * websocket_client_create(
987         const char *uri, const char *protocols, struct ast_tls_config *tls_cfg,
988         enum ast_websocket_result *result)
989 {
990         struct ast_websocket *ws = ao2_alloc(sizeof(*ws), session_destroy_fn);
991
992         if (!ws) {
993                 ast_log(LOG_ERROR, "Unable to allocate websocket\n");
994                 *result = WS_ALLOCATE_ERROR;
995                 return NULL;
996         }
997
998         if (!(ws->client = ao2_alloc(
999                       sizeof(*ws->client), websocket_client_destroy))) {
1000                 ast_log(LOG_ERROR, "Unable to allocate websocket client\n");
1001                 *result = WS_ALLOCATE_ERROR;
1002                 return NULL;
1003         }
1004
1005         if (!(ws->client->key = websocket_client_create_key())) {
1006                 ao2_ref(ws, -1);
1007                 *result = WS_KEY_ERROR;
1008                 return NULL;
1009         }
1010
1011         if (websocket_client_parse_uri(
1012                     uri, &ws->client->host, &ws->client->resource_name)) {
1013                 ao2_ref(ws, -1);
1014                 *result = WS_URI_PARSE_ERROR;
1015                 return NULL;
1016         }
1017
1018         if (!(ws->client->args = websocket_client_args_create(
1019                       ws->client->host, tls_cfg, result))) {
1020                 ao2_ref(ws, -1);
1021                 return NULL;
1022         }
1023         ws->client->protocols = ast_strdup(protocols);
1024
1025         ws->client->version = 13;
1026         ws->opcode = -1;
1027         ws->reconstruct = DEFAULT_RECONSTRUCTION_CEILING;
1028         return ws;
1029 }
1030
1031 const char * AST_OPTIONAL_API_NAME(
1032         ast_websocket_client_accept_protocol)(struct ast_websocket *ws)
1033 {
1034         return ws->client->accept_protocol;
1035 }
1036
1037 static enum ast_websocket_result websocket_client_handle_response_code(
1038         struct websocket_client *client, int response_code)
1039 {
1040         if (response_code <= 0) {
1041                 return WS_INVALID_RESPONSE;
1042         }
1043
1044         switch (response_code) {
1045         case 101:
1046                 return 0;
1047         case 400:
1048                 ast_log(LOG_ERROR, "Received response 400 - Bad Request "
1049                         "- from %s\n", client->host);
1050                 return WS_BAD_REQUEST;
1051         case 404:
1052                 ast_log(LOG_ERROR, "Received response 404 - Request URL not "
1053                         "found - from %s\n", client->host);
1054                 return WS_URL_NOT_FOUND;
1055         }
1056
1057         ast_log(LOG_ERROR, "Invalid HTTP response code %d from %s\n",
1058                 response_code, client->host);
1059         return WS_INVALID_RESPONSE;
1060 }
1061
1062 static enum ast_websocket_result websocket_client_handshake_get_response(
1063         struct websocket_client *client)
1064 {
1065         enum ast_websocket_result res;
1066         char buf[4096];
1067         char base64[64];
1068         int has_upgrade = 0;
1069         int has_connection = 0;
1070         int has_accept = 0;
1071         int has_protocol = 0;
1072
1073         if (!fgets(buf, sizeof(buf), client->ser->f)) {
1074                 ast_log(LOG_ERROR, "Unable to retrieve HTTP status line.");
1075                 return WS_BAD_STATUS;
1076         }
1077
1078         if ((res = websocket_client_handle_response_code(client,
1079                     ast_http_response_status_line(
1080                             buf, "HTTP/1.1", 101))) != WS_OK) {
1081                 return res;
1082         }
1083
1084         /* Ignoring line folding - assuming header field values are contained
1085            within a single line */
1086         while (fgets(buf, sizeof(buf), client->ser->f)) {
1087                 char *name, *value;
1088                 int parsed = ast_http_header_parse(buf, &name, &value);
1089
1090                 if (parsed < 0) {
1091                         break;
1092                 }
1093
1094                 if (parsed > 0) {
1095                         continue;
1096                 }
1097
1098                 if (!has_upgrade &&
1099                     (has_upgrade = ast_http_header_match(
1100                             name, "upgrade", value, "websocket")) < 0) {
1101                         return WS_HEADER_MISMATCH;
1102                 } else if (!has_connection &&
1103                            (has_connection = ast_http_header_match(
1104                                    name, "connection", value, "upgrade")) < 0) {
1105                         return WS_HEADER_MISMATCH;
1106                 } else if (!has_accept &&
1107                            (has_accept = ast_http_header_match(
1108                                    name, "sec-websocket-accept", value,
1109                             websocket_combine_key(
1110                                     client->key, base64, sizeof(base64)))) < 0) {
1111                         return WS_HEADER_MISMATCH;
1112                 } else if (!has_protocol &&
1113                            (has_protocol = ast_http_header_match_in(
1114                                    name, "sec-websocket-protocol", value, client->protocols))) {
1115                         if (has_protocol < 0) {
1116                                 return WS_HEADER_MISMATCH;
1117                         }
1118                         client->accept_protocol = ast_strdup(value);
1119                 } else if (!strcasecmp(name, "sec-websocket-extensions")) {
1120                         ast_log(LOG_ERROR, "Extensions received, but not "
1121                                 "supported by client\n");
1122                         return WS_NOT_SUPPORTED;
1123                 }
1124         }
1125         return has_upgrade && has_connection && has_accept ?
1126                 WS_OK : WS_HEADER_MISSING;
1127 }
1128
1129 static enum ast_websocket_result websocket_client_handshake(
1130         struct websocket_client *client)
1131 {
1132         char protocols[100] = "";
1133
1134         if (!ast_strlen_zero(client->protocols)) {
1135                 sprintf(protocols, "Sec-WebSocket-Protocol: %s\r\n",
1136                         client->protocols);
1137         }
1138
1139         if (fprintf(client->ser->f,
1140                     "GET /%s HTTP/1.1\r\n"
1141                     "Sec-WebSocket-Version: %d\r\n"
1142                     "Upgrade: websocket\r\n"
1143                     "Connection: Upgrade\r\n"
1144                     "Host: %s\r\n"
1145                     "Sec-WebSocket-Key: %s\r\n"
1146                     "%s\r\n",
1147                     client->resource_name,
1148                     client->version,
1149                     client->host,
1150                     client->key,
1151                     protocols) < 0) {
1152                 ast_log(LOG_ERROR, "Failed to send handshake.\n");
1153                 return WS_WRITE_ERROR;
1154         }
1155         /* wait for a response before doing anything else */
1156         return websocket_client_handshake_get_response(client);
1157 }
1158
1159 static enum ast_websocket_result websocket_client_connect(struct ast_websocket *ws)
1160 {
1161         enum ast_websocket_result res;
1162         /* create and connect the client - note client_start
1163            releases the session instance on failure */
1164         if (!(ws->client->ser = ast_tcptls_client_start(
1165                       ast_tcptls_client_create(ws->client->args)))) {
1166                 return WS_CLIENT_START_ERROR;
1167         }
1168
1169         if ((res = websocket_client_handshake(ws->client)) != WS_OK) {
1170                 ao2_ref(ws->client->ser, -1);
1171                 ws->client->ser = NULL;
1172                 return res;
1173         }
1174
1175         ws->f = ws->client->ser->f;
1176         ws->fd = ws->client->ser->fd;
1177         ws->secure = ws->client->ser->ssl ? 1 : 0;
1178         ast_sockaddr_copy(&ws->address, &ws->client->ser->remote_address);
1179         return WS_OK;
1180 }
1181
1182 struct ast_websocket *AST_OPTIONAL_API_NAME(ast_websocket_client_create)
1183         (const char *uri, const char *protocols, struct ast_tls_config *tls_cfg,
1184          enum ast_websocket_result *result)
1185 {
1186         struct ast_websocket *ws = websocket_client_create(
1187                 uri, protocols, tls_cfg, result);
1188
1189         if (!ws) {
1190                 return NULL;
1191         }
1192
1193         if ((*result = websocket_client_connect(ws)) != WS_OK) {
1194                 ao2_ref(ws, -1);
1195                 return NULL;
1196         }
1197
1198         return ws;
1199 }
1200
1201 int AST_OPTIONAL_API_NAME(ast_websocket_read_string)
1202         (struct ast_websocket *ws, struct ast_str **buf)
1203 {
1204         char *payload;
1205         uint64_t payload_len;
1206         enum ast_websocket_opcode opcode;
1207         int fragmented = 1;
1208
1209         if (!*buf && !(*buf = ast_str_create(512))) {
1210                 ast_log(LOG_ERROR, "Client Websocket string read - "
1211                         "Unable to allocate string buffer");
1212                 return -1;
1213         }
1214
1215         while (fragmented) {
1216                 if (ast_websocket_read(ws, &payload, &payload_len,
1217                                        &opcode, &fragmented)) {
1218                         ast_log(LOG_ERROR, "Client WebSocket string read - "
1219                                 "error reading string data\n");
1220                         return -1;
1221                 }
1222
1223                 if (opcode == AST_WEBSOCKET_OPCODE_CLOSE) {
1224                         return -1;
1225                 }
1226
1227                 if (opcode != AST_WEBSOCKET_OPCODE_TEXT) {
1228                         ast_log(LOG_ERROR, "Client WebSocket string read - "
1229                                 "non string data received\n");
1230                         return -1;
1231                 }
1232
1233                 ast_str_append(buf, 0, "%s", payload);
1234         }
1235         return ast_str_size(*buf);
1236 }
1237
1238 int AST_OPTIONAL_API_NAME(ast_websocket_write_string)
1239         (struct ast_websocket *ws, const struct ast_str *buf)
1240 {
1241         return ast_websocket_write(ws, AST_WEBSOCKET_OPCODE_TEXT,
1242                                    ast_str_buffer(buf), ast_str_strlen(buf));
1243 }
1244
1245 static int load_module(void)
1246 {
1247         websocketuri.data = websocket_server_internal_create();
1248         if (!websocketuri.data) {
1249                 return AST_MODULE_LOAD_FAILURE;
1250         }
1251         ast_http_uri_link(&websocketuri);
1252         websocket_add_protocol_internal("echo", websocket_echo_callback);
1253
1254         return 0;
1255 }
1256
1257 static int unload_module(void)
1258 {
1259         ast_websocket_remove_protocol("echo", websocket_echo_callback);
1260         ast_http_uri_unlink(&websocketuri);
1261         ao2_ref(websocketuri.data, -1);
1262         websocketuri.data = NULL;
1263
1264         return 0;
1265 }
1266
1267 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_GLOBAL_SYMBOLS | AST_MODFLAG_LOAD_ORDER, "HTTP WebSocket Support",
1268                 .load = load_module,
1269                 .unload = unload_module,
1270                 .load_pri = AST_MODPRI_CHANNEL_DEPEND,
1271         );