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