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