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