2 * libwebsockets - small server side websockets and web server implementation
4 * Copyright (C) 2010 Andy Green <andy@warmcat.com>
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation:
9 * version 2.1 of the License.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
22 #include "private-libwebsockets.h"
24 #define LWS_CPYAPP(ptr, str) { strcpy(ptr, str); ptr += strlen(str); }
25 #define LWS_CPYAPP_TOKEN(ptr, tok) { strcpy(p, wsi->utf8_token[tok].token); \
26 p += wsi->utf8_token[tok].token_len; }
29 interpret_key(const char *key, unsigned long *result)
34 unsigned int spaces = 0;
35 unsigned long acc = 0;
43 if (digit_pos == sizeof(digits) - 1)
45 digits[digit_pos++] = *p++;
47 digits[digit_pos] = '\0';
62 rem = (rem * 10) + ((*p++) - '0');
63 acc = (acc * 10) + (rem / spaces);
64 rem -= (rem / spaces) * spaces;
68 lwsl_warn("nonzero handshake remainder\n");
79 handshake_00(struct libwebsocket_context *context, struct libwebsocket *wsi)
81 unsigned long key1, key2;
82 unsigned char sum[16];
87 /* Confirm we have all the necessary pieces */
89 if (!wsi->utf8_token[WSI_TOKEN_ORIGIN].token_len ||
90 !wsi->utf8_token[WSI_TOKEN_HOST].token_len ||
91 !wsi->utf8_token[WSI_TOKEN_CHALLENGE].token_len ||
92 !wsi->utf8_token[WSI_TOKEN_KEY1].token_len ||
93 !wsi->utf8_token[WSI_TOKEN_KEY2].token_len)
94 /* completed header processing, but missing some bits */
97 /* allocate the per-connection user memory (if any) */
98 if (wsi->protocol->per_session_data_size &&
99 !libwebsocket_ensure_user_space(wsi))
102 /* create the response packet */
104 /* make a buffer big enough for everything */
106 response = (char *)malloc(256 +
107 wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len +
108 wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len +
109 wsi->utf8_token[WSI_TOKEN_HOST].token_len +
110 wsi->utf8_token[WSI_TOKEN_ORIGIN].token_len +
111 wsi->utf8_token[WSI_TOKEN_GET_URI].token_len +
112 wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len);
114 lwsl_err("Out of memory for response buffer\n");
119 LWS_CPYAPP(p, "HTTP/1.1 101 WebSocket Protocol Handshake\x0d\x0a"
120 "Upgrade: WebSocket\x0d\x0a"
121 "Connection: Upgrade\x0d\x0a"
122 "Sec-WebSocket-Origin: ");
123 strcpy(p, wsi->utf8_token[WSI_TOKEN_ORIGIN].token);
124 p += wsi->utf8_token[WSI_TOKEN_ORIGIN].token_len;
125 #ifdef LWS_OPENSSL_SUPPORT
127 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Location: wss://");
129 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Location: ws://");
132 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Location: ws://");
135 LWS_CPYAPP_TOKEN(p, WSI_TOKEN_HOST);
136 LWS_CPYAPP_TOKEN(p, WSI_TOKEN_GET_URI);
138 if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token) {
139 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Protocol: ");
140 LWS_CPYAPP_TOKEN(p, WSI_TOKEN_PROTOCOL);
143 LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a");
145 /* convert the two keys into 32-bit integers */
147 if (interpret_key(wsi->utf8_token[WSI_TOKEN_KEY1].token, &key1))
149 if (interpret_key(wsi->utf8_token[WSI_TOKEN_KEY2].token, &key2))
152 /* lay them out in network byte order (MSB first */
154 sum[0] = (unsigned char)(key1 >> 24);
155 sum[1] = (unsigned char)(key1 >> 16);
156 sum[2] = (unsigned char)(key1 >> 8);
157 sum[3] = (unsigned char)(key1);
158 sum[4] = (unsigned char)(key2 >> 24);
159 sum[5] = (unsigned char)(key2 >> 16);
160 sum[6] = (unsigned char)(key2 >> 8);
161 sum[7] = (unsigned char)(key2);
163 /* follow them with the challenge token we were sent */
165 memcpy(&sum[8], wsi->utf8_token[WSI_TOKEN_CHALLENGE].token, 8);
168 * compute the md5sum of that 16-byte series and use as our
169 * payload after our headers
172 MD5(sum, 16, (unsigned char *)p);
175 /* it's complete: go ahead and send it */
177 lwsl_parser("issuing response packet %d len\n", (int)(p - response));
179 fwrite(response, 1, p - response, stderr);
181 n = libwebsocket_write(wsi, (unsigned char *)response,
182 p - response, LWS_WRITE_HTTP);
184 lwsl_debug("handshake_00: ERROR writing to socket\n");
188 /* alright clean up and set ourselves into established state */
191 wsi->state = WSI_STATE_ESTABLISHED;
192 wsi->lws_rx_parse_state = LWS_RXPS_NEW;
194 /* notify user code that we're ready to roll */
196 if (wsi->protocol->callback)
197 wsi->protocol->callback(wsi->protocol->owning_server,
198 wsi, LWS_CALLBACK_ESTABLISHED,
199 wsi->user_space, NULL, 0);
208 * Perform the newer BASE64-encoded handshake scheme
212 handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi)
214 static const char *websocket_magic_guid_04 =
215 "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
216 static const char *websocket_magic_guid_04_masking =
217 "61AC5F19-FBBA-4540-B96F-6561F1AB40A8";
218 char accept_buf[MAX_WEBSOCKET_04_KEY_LEN + 37];
220 char mask_summing_buf[256 + MAX_WEBSOCKET_04_KEY_LEN + 37];
221 unsigned char hash[20];
225 char *m = mask_summing_buf;
230 struct libwebsocket_extension *ext;
234 if (!wsi->utf8_token[WSI_TOKEN_HOST].token_len ||
235 !wsi->utf8_token[WSI_TOKEN_KEY].token_len) {
236 lwsl_parser("handshake_04 missing pieces\n");
237 /* completed header processing, but missing some bits */
241 if (wsi->utf8_token[WSI_TOKEN_KEY].token_len >=
242 MAX_WEBSOCKET_04_KEY_LEN) {
243 lwsl_warn("Client sent handshake key longer "
244 "than max supported %d\n", MAX_WEBSOCKET_04_KEY_LEN);
248 strcpy(accept_buf, wsi->utf8_token[WSI_TOKEN_KEY].token);
249 strcpy(accept_buf + wsi->utf8_token[WSI_TOKEN_KEY].token_len,
250 websocket_magic_guid_04);
252 SHA1((unsigned char *)accept_buf,
253 wsi->utf8_token[WSI_TOKEN_KEY].token_len +
254 strlen(websocket_magic_guid_04), hash);
256 accept_len = lws_b64_encode_string((char *)hash, 20, accept_buf,
258 if (accept_len < 0) {
259 lwsl_warn("Base64 encoded hash too long\n");
263 /* allocate the per-connection user memory (if any) */
264 if (wsi->protocol->per_session_data_size &&
265 !libwebsocket_ensure_user_space(wsi))
268 /* create the response packet */
270 /* make a buffer big enough for everything */
272 response = (char *)malloc(256 +
273 wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len +
274 wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len +
275 wsi->utf8_token[WSI_TOKEN_PROTOCOL].token_len);
277 lwsl_err("Out of memory for response buffer\n");
282 LWS_CPYAPP(p, "HTTP/1.1 101 Switching Protocols\x0d\x0a"
283 "Upgrade: WebSocket\x0d\x0a"
284 "Connection: Upgrade\x0d\x0a"
285 "Sec-WebSocket-Accept: ");
286 strcpy(p, accept_buf);
289 if (wsi->ietf_spec_revision == 4) {
290 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Nonce: ");
292 /* select the nonce */
294 n = libwebsockets_get_random(wsi->protocol->owning_server,
297 lwsl_err("Unable to read random device %s %d\n",
298 SYSTEM_RANDOM_FILEPATH, n);
300 free(wsi->user_space);
304 /* encode the nonce */
306 nonce_len = lws_b64_encode_string((const char *)hash, 16,
307 nonce_buf, sizeof nonce_buf);
309 lwsl_err("Failed to base 64 encode the nonce\n");
311 free(wsi->user_space);
315 /* apply the nonce */
317 strcpy(p, nonce_buf);
321 if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token) {
322 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Protocol: ");
323 LWS_CPYAPP_TOKEN(p, WSI_TOKEN_PROTOCOL);
327 * Figure out which extensions the client has that we want to
328 * enable on this connection, and give him back the list
331 if (wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token_len) {
334 * break down the list of client extensions
335 * and go through them
338 c = wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token;
339 lwsl_parser("wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token = %s\n",
340 wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token);
341 wsi->count_active_extensions = 0;
345 if (*c && (*c != ',' && *c != ' ' && *c != '\t')) {
347 if (n < sizeof(ext_name) - 1)
360 /* check a client's extension against our support */
362 ext = wsi->protocol->owning_server->extensions;
364 while (ext && ext->callback) {
366 if (strcmp(ext_name, ext->name)) {
372 * oh, we do support this one he
373 * asked for... but let's ask user
374 * code if it's OK to apply it on this
375 * particular connection + protocol
378 n = wsi->protocol->owning_server->
379 protocols[0].callback(
380 wsi->protocol->owning_server,
382 LWS_CALLBACK_CONFIRM_EXTENSION_OKAY,
383 wsi->user_space, ext_name, 0);
386 * zero return from callback means
387 * go ahead and allow the extension,
388 * it's what we get if the callback is
403 "\x0d\x0aSec-WebSocket-Extensions: ");
404 p += sprintf(p, "%s", ext_name);
407 /* instantiate the extension on this conn */
409 wsi->active_extensions_user[
410 wsi->count_active_extensions] =
411 malloc(ext->per_session_data_size);
412 if (wsi->active_extensions_user[
413 wsi->count_active_extensions] == NULL) {
414 lwsl_err("Out of mem\n");
418 memset(wsi->active_extensions_user[
419 wsi->count_active_extensions], 0,
420 ext->per_session_data_size);
422 wsi->active_extensions[
423 wsi->count_active_extensions] = ext;
425 /* allow him to construct his context */
427 ext->callback(wsi->protocol->owning_server,
429 LWS_EXT_CALLBACK_CONSTRUCT,
430 wsi->active_extensions_user[
431 wsi->count_active_extensions], NULL, 0);
433 wsi->count_active_extensions++;
434 lwsl_parser("wsi->count_active_extensions <- %d\n",
435 wsi->count_active_extensions);
444 /* end of response packet */
446 LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a");
448 if (wsi->ietf_spec_revision == 4) {
451 * precompute the masking key the client will use from the SHA1
452 * hash of ( base 64 client key we were sent, concatenated with
453 * the bse 64 nonce we sent, concatenated with a magic constant
454 * guid specified by the 04 standard )
456 * We store the hash in the connection's wsi ready to use with
457 * undoing the masking the client has done on framed data it
458 * sends (we send our data to the client in clear).
461 strcpy(mask_summing_buf, wsi->utf8_token[WSI_TOKEN_KEY].token);
462 m += wsi->utf8_token[WSI_TOKEN_KEY].token_len;
463 strcpy(m, nonce_buf);
465 strcpy(m, websocket_magic_guid_04_masking);
466 m += strlen(websocket_magic_guid_04_masking);
468 SHA1((unsigned char *)mask_summing_buf, m - mask_summing_buf,
469 wsi->masking_key_04);
472 if (!lws_any_extension_handled(context, wsi,
473 LWS_EXT_CALLBACK_HANDSHAKE_REPLY_TX,
474 response, p - response)) {
476 /* okay send the handshake response accepting the connection */
478 lwsl_parser("issuing response packet %d len\n", (int)(p - response));
480 fwrite(response, 1, p - response, stderr);
482 n = libwebsocket_write(wsi, (unsigned char *)response,
483 p - response, LWS_WRITE_HTTP);
485 lwsl_debug("handshake_0405: ERROR writing to socket\n");
491 /* alright clean up and set ourselves into established state */
494 wsi->state = WSI_STATE_ESTABLISHED;
495 wsi->lws_rx_parse_state = LWS_RXPS_NEW;
496 wsi->rx_packet_length = 0;
498 /* notify user code that we're ready to roll */
500 if (wsi->protocol->callback)
501 wsi->protocol->callback(wsi->protocol->owning_server,
502 wsi, LWS_CALLBACK_ESTABLISHED,
503 wsi->user_space, NULL, 0);
514 * -04 of the protocol (actually the 80th version) has a radically different
515 * handshake. The 04 spec gives the following idea
517 * The handshake from the client looks as follows:
520 * Host: server.example.com
522 * Connection: Upgrade
523 * Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
524 * Sec-WebSocket-Origin: http://example.com
525 * Sec-WebSocket-Protocol: chat, superchat
526 * Sec-WebSocket-Version: 4
528 * The handshake from the server looks as follows:
530 * HTTP/1.1 101 Switching Protocols
532 * Connection: Upgrade
533 * Sec-WebSocket-Accept: me89jWimTRKTWwrS3aRrL53YZSo=
534 * Sec-WebSocket-Nonce: AQIDBAUGBwgJCgsMDQ4PEC==
535 * Sec-WebSocket-Protocol: chat
539 * We have to take care about parsing because the headers may be split
540 * into multiple fragments. They may contain unknown headers with arbitrary
541 * argument lengths. So, we parse using a single-character at a time state
542 * machine that is completely independent of packet size.
546 libwebsocket_read(struct libwebsocket_context *context,
547 struct libwebsocket *wsi, unsigned char * buf, size_t len)
551 switch (wsi->state) {
552 case WSI_STATE_HTTP_ISSUING_FILE:
554 wsi->state = WSI_STATE_HTTP_HEADERS;
555 wsi->parser_state = WSI_TOKEN_NAME_PART;
557 case WSI_STATE_HTTP_HEADERS:
559 lwsl_parser("issuing %d bytes to parser\n", (int)len);
561 //fwrite(buf, 1, len, stderr);
564 #ifndef LWS_NO_CLIENT
566 case LWS_CONNMODE_WS_CLIENT_WAITING_PROXY_REPLY:
567 case LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE:
568 case LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY:
569 case LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT:
570 case LWS_CONNMODE_WS_CLIENT:
571 for (n = 0; n < len; n++)
572 libwebsocket_client_rx_sm(wsi, *buf++);
579 /* LWS_CONNMODE_WS_SERVING */
581 for (n = 0; n < len; n++)
582 libwebsocket_parse(wsi, *buf++);
584 if (wsi->parser_state != WSI_PARSING_COMPLETE)
587 lwsl_parser("seem to be serving, mode is %d\n", wsi->mode);
589 lwsl_parser("libwebsocket_parse sees parsing complete\n");
591 /* is this websocket protocol or normal http 1.0? */
593 if (!wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len ||
594 !wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len) {
595 wsi->state = WSI_STATE_HTTP;
596 if (wsi->protocol->callback)
597 if (wsi->protocol->callback(context, wsi,
598 LWS_CALLBACK_HTTP, wsi->user_space,
599 wsi->utf8_token[WSI_TOKEN_GET_URI].token,
600 wsi->utf8_token[WSI_TOKEN_GET_URI].token_len))
606 lwsl_err("NULL protocol at libwebsocket_read\n");
611 * Make sure user side is happy about protocol
614 while (wsi->protocol->callback) {
616 if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token == NULL) {
617 if (wsi->protocol->name == NULL)
620 if (wsi->protocol->name && strcmp(
621 wsi->utf8_token[WSI_TOKEN_PROTOCOL].token,
622 wsi->protocol->name) == 0)
628 /* we didn't find a protocol he wanted? */
630 if (wsi->protocol->callback == NULL) {
631 if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token == NULL)
632 lwsl_err("[no protocol] "
633 "not supported (use NULL .name)\n");
635 lwsl_err("Requested protocol %s "
637 wsi->utf8_token[WSI_TOKEN_PROTOCOL].token);
642 * find out which spec version the client is using
643 * if this header is not given, we default to 00 (aka 76)
646 if (wsi->utf8_token[WSI_TOKEN_VERSION].token_len)
647 wsi->ietf_spec_revision =
648 atoi(wsi->utf8_token[WSI_TOKEN_VERSION].token);
651 * Give the user code a chance to study the request and
652 * have the opportunity to deny it
655 if ((wsi->protocol->callback)(wsi->protocol->owning_server, wsi,
656 LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION,
657 &wsi->utf8_token[0], NULL, 0)) {
658 lwsl_warn("User code denied connection\n");
664 * Perform the handshake according to the protocol version the
668 switch (wsi->ietf_spec_revision) {
669 case 0: /* applies to 76 and 00 */
670 wsi->xor_mask = xor_no_mask;
671 if (handshake_00(context, wsi))
675 wsi->xor_mask = xor_mask_04;
676 lwsl_parser("libwebsocket_parse calling handshake_04\n");
677 if (handshake_0405(context, wsi))
685 wsi->xor_mask = xor_mask_05;
686 lwsl_parser("libwebsocket_parse calling handshake_04\n");
687 if (handshake_0405(context, wsi))
692 lwsl_warn("Unknown client spec version %d\n",
693 wsi->ietf_spec_revision);
697 wsi->mode = LWS_CONNMODE_WS_SERVING;
699 lwsl_parser("accepted v%02d connection\n",
700 wsi->ietf_spec_revision);
704 case WSI_STATE_AWAITING_CLOSE_ACK:
705 case WSI_STATE_ESTABLISHED:
706 #ifndef LWS_NO_CLIENT
708 case LWS_CONNMODE_WS_CLIENT:
709 for (n = 0; n < len; n++)
710 if (libwebsocket_client_rx_sm(wsi, *buf++) < 0)
718 /* LWS_CONNMODE_WS_SERVING */
720 if (libwebsocket_interpret_incoming_packet(wsi, buf, len) < 0)
725 lwsl_err("libwebsocket_read: Unhandled state\n");
732 libwebsocket_close_and_free_session(context, wsi,
733 LWS_CLOSE_STATUS_NOSTATUS);