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