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