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