lib/handshake.c

   1 /*
   2  * libwebsockets - small server side websockets and web server implementation
   3  *
   4  * Copyright (C) 2010 Andy Green <andy@warmcat.com>
   5  *
   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.
  10  *
  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.
  15  *
  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,
  19  *  MA  02110-1301  USA
  20  */
  21
  22 #include "private-libwebsockets.h"
  23
  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; }
  27
  28 static int
  29 interpret_key(const char *key, unsigned long *result)
  30 {
  31         char digits[20];
  32         int digit_pos = 0;
  33         const char *p = key;
  34         unsigned int spaces = 0;
  35         unsigned long acc = 0;
  36         int rem = 0;
  37
  38         while (*p) {
  39                 if (!isdigit(*p)) {
  40                         p++;
  41                         continue;
  42                 }
  43                 if (digit_pos == sizeof(digits) - 1)
  44                         return -1;
  45                 digits[digit_pos++] = *p++;
  46         }
  47         digits[digit_pos] = '\0';
  48         if (!digit_pos)
  49                 return -2;
  50
  51         while (*key) {
  52                 if (*key == ' ')
  53                         spaces++;
  54                 key++;
  55         }
  56
  57         if (!spaces)
  58                 return -3;
  59
  60         p = &digits[0];
  61         while (*p) {
  62                 rem = (rem * 10) + ((*p++) - '0');
  63                 acc = (acc * 10) + (rem / spaces);
  64                 rem -= (rem / spaces) * spaces;
  65         }
  66
  67         if (rem) {
  68                 fprintf(stderr, "nonzero handshake remainder\n");
  69                 return -1;
  70         }
  71
  72         *result = acc;
  73
  74         return 0;
  75 }
  76
  77
  78 static int
  79 handshake_00(struct libwebsocket_context *context, struct libwebsocket *wsi)
  80 {
  81         unsigned long key1, key2;
  82         unsigned char sum[16];
  83         char *response;
  84         char *p;
  85         int n;
  86
  87         /* Confirm we have all the necessary pieces */
  88
  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 */
  95                 goto bail;
  96
  97         /* allocate the per-connection user memory (if any) */
  98         if (wsi->protocol->per_session_data_size &&
  99                                           !libwebsocket_ensure_user_space(wsi))
 100                 goto bail;
 101
 102         /* create the response packet */
 103
 104         /* make a buffer big enough for everything */
 105
 106         response = 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);
 113         if (!response) {
 114                 fprintf(stderr, "Out of memory for response buffer\n");
 115                 goto bail;
 116         }
 117
 118         p = response;
 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
 126         if (wsi->ssl) {
 127                 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Location: wss://");
 128         } else {
 129                 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Location: ws://");
 130         }
 131 #else
 132         LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Location: ws://");
 133 #endif
 134
 135         LWS_CPYAPP_TOKEN(p, WSI_TOKEN_HOST);
 136         LWS_CPYAPP_TOKEN(p, WSI_TOKEN_GET_URI);
 137
 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);
 141         }
 142
 143         LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a");
 144
 145         /* convert the two keys into 32-bit integers */
 146
 147         if (interpret_key(wsi->utf8_token[WSI_TOKEN_KEY1].token, &key1))
 148                 goto bail;
 149         if (interpret_key(wsi->utf8_token[WSI_TOKEN_KEY2].token, &key2))
 150                 goto bail;
 151
 152         /* lay them out in network byte order (MSB first */
 153
 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);
 162
 163         /* follow them with the challenge token we were sent */
 164
 165         memcpy(&sum[8], wsi->utf8_token[WSI_TOKEN_CHALLENGE].token, 8);
 166
 167         /*
 168          * compute the md5sum of that 16-byte series and use as our
 169          * payload after our headers
 170          */
 171
 172         MD5(sum, 16, (unsigned char *)p);
 173         p += 16;
 174
 175         /* it's complete: go ahead and send it */
 176
 177         debug("issuing response packet %d len\n", (int)(p - response));
 178 #ifdef DEBUG
 179         fwrite(response, 1,  p - response, stderr);
 180 #endif
 181         n = libwebsocket_write(wsi, (unsigned char *)response,
 182                                           p - response, LWS_WRITE_HTTP);
 183         if (n < 0) {
 184                 fprintf(stderr, "ERROR writing to socket");
 185                 goto bail;
 186         }
 187
 188         /* alright clean up and set ourselves into established state */
 189
 190         free(response);
 191         wsi->state = WSI_STATE_ESTABLISHED;
 192         wsi->lws_rx_parse_state = LWS_RXPS_NEW;
 193
 194         /* notify user code that we're ready to roll */
 195
 196         if (wsi->protocol->callback)
 197                 wsi->protocol->callback(wsi->protocol->owning_server,
 198                                 wsi, LWS_CALLBACK_ESTABLISHED,
 199                                           wsi->user_space, NULL, 0);
 200
 201         return 0;
 202
 203 bail:
 204         return -1;
 205 }
 206
 207 /*
 208  * Perform the newer BASE64-encoded handshake scheme
 209  */
 210
 211 static int
 212 handshake_0405(struct libwebsocket_context *context, struct libwebsocket *wsi)
 213 {
 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];
 219         char nonce_buf[256];
 220         char mask_summing_buf[256 + MAX_WEBSOCKET_04_KEY_LEN + 37];
 221         unsigned char hash[20];
 222         int n;
 223         char *response;
 224         char *p;
 225         char *m = mask_summing_buf;
 226         int nonce_len = 0;
 227         int accept_len;
 228         char *c;
 229         char ext_name[128];
 230         struct libwebsocket_extension *ext;
 231         int ext_count = 0;
 232         int more = 1;
 233
 234         if (!wsi->utf8_token[WSI_TOKEN_HOST].token_len ||
 235             !wsi->utf8_token[WSI_TOKEN_KEY].token_len) {
 236                 debug("handshake_04 missing pieces\n");
 237                 /* completed header processing, but missing some bits */
 238                 goto bail;
 239         }
 240
 241         if (wsi->utf8_token[WSI_TOKEN_KEY].token_len >=
 242                                                      MAX_WEBSOCKET_04_KEY_LEN) {
 243                 fprintf(stderr, "Client sent handshake key longer "
 244                            "than max supported %d\n", MAX_WEBSOCKET_04_KEY_LEN);
 245                 goto bail;
 246         }
 247
 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);
 251
 252         SHA1((unsigned char *)accept_buf,
 253                         wsi->utf8_token[WSI_TOKEN_KEY].token_len +
 254                                          strlen(websocket_magic_guid_04), hash);
 255
 256         accept_len = lws_b64_encode_string((char *)hash, 20, accept_buf,
 257                                                              sizeof accept_buf);
 258         if (accept_len < 0) {
 259                 fprintf(stderr, "Base64 encoded hash too long\n");
 260                 goto bail;
 261         }
 262
 263         /* allocate the per-connection user memory (if any) */
 264         if (wsi->protocol->per_session_data_size &&
 265                                           !libwebsocket_ensure_user_space(wsi))
 266                 goto bail;
 267
 268         /* create the response packet */
 269
 270         /* make a buffer big enough for everything */
 271
 272         response = 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);
 276         if (!response) {
 277                 fprintf(stderr, "Out of memory for response buffer\n");
 278                 goto bail;
 279         }
 280
 281         p = response;
 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);
 287         p += accept_len;
 288
 289         if (wsi->ietf_spec_revision == 4) {
 290                 LWS_CPYAPP(p, "\x0d\x0aSec-WebSocket-Nonce: ");
 291
 292                 /* select the nonce */
 293
 294                 n = libwebsockets_get_random(wsi->protocol->owning_server,
 295                                                                       hash, 16);
 296                 if (n != 16) {
 297                         fprintf(stderr, "Unable to read random device %s %d\n",
 298                                                      SYSTEM_RANDOM_FILEPATH, n);
 299                         if (wsi->user_space)
 300                                 free(wsi->user_space);
 301                         goto bail;
 302                 }
 303
 304                 /* encode the nonce */
 305
 306                 nonce_len = lws_b64_encode_string((const char *)hash, 16,
 307                                                    nonce_buf, sizeof nonce_buf);
 308                 if (nonce_len < 0) {
 309                         fprintf(stderr, "Failed to base 64 encode the nonce\n");
 310                         if (wsi->user_space)
 311                                 free(wsi->user_space);
 312                         goto bail;
 313                 }
 314
 315                 /* apply the nonce */
 316
 317                 strcpy(p, nonce_buf);
 318                 p += nonce_len;
 319         }
 320
 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);
 324         }
 325
 326         /*
 327          * Figure out which extensions the client has that we want to
 328          * enable on this connection, and give him back the list
 329          */
 330
 331         if (wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token_len) {
 332
 333                 /*
 334                  * break down the list of client extensions
 335                  * and go through them
 336                  */
 337
 338                 c = wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token;
 339                 debug("wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token = %s\n",
 340                                   wsi->utf8_token[WSI_TOKEN_EXTENSIONS].token);
 341                 wsi->count_active_extensions = 0;
 342                 n = 0;
 343                 while (more) {
 344
 345                         if (*c && (*c != ',' && *c != ' ' && *c != '\t')) {
 346                                 ext_name[n] = *c++;
 347                                 if (n < sizeof(ext_name) - 1)
 348                                         n++;
 349                                 continue;
 350                         }
 351                         ext_name[n] = '\0';
 352                         if (!*c)
 353                                 more = 0;
 354                         else {
 355                                 c++;
 356                                 if (!n)
 357                                         continue;
 358                         }
 359
 360                         /* check a client's extension against our support */
 361
 362                         ext = wsi->protocol->owning_server->extensions;
 363
 364                         while (ext && ext->callback) {
 365
 366                                 if (strcmp(ext_name, ext->name)) {
 367                                         ext++;
 368                                         continue;
 369                                 }
 370
 371                                 /*
 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
 376                                  */
 377
 378                                 n = wsi->protocol->owning_server->
 379                                         protocols[0].callback(
 380                                                 wsi->protocol->owning_server,
 381                                                 wsi,
 382                                           LWS_CALLBACK_CONFIRM_EXTENSION_OKAY,
 383                                                   wsi->user_space, ext_name, 0);
 384
 385                                 /*
 386                                  * zero return from callback means
 387                                  * go ahead and allow the extension,
 388                                  * it's what we get if the callback is
 389                                  * unhandled
 390                                  */
 391
 392                                 if (n) {
 393                                         ext++;
 394                                         continue;
 395                                 }
 396
 397                                 /* apply it */
 398
 399                                 if (ext_count)
 400                                         *p++ = ',';
 401                                 else
 402                                         LWS_CPYAPP(p,
 403                                          "\x0d\x0aSec-WebSocket-Extensions: ");
 404                                 p += sprintf(p, "%s", ext_name);
 405                                 ext_count++;
 406
 407                                 /* instantiate the extension on this conn */
 408
 409                                 wsi->active_extensions_user[
 410                                         wsi->count_active_extensions] =
 411                                              malloc(ext->per_session_data_size);
 412                                 memset(wsi->active_extensions_user[
 413                                         wsi->count_active_extensions], 0,
 414                                                     ext->per_session_data_size);
 415
 416                                 wsi->active_extensions[
 417                                           wsi->count_active_extensions] = ext;
 418
 419                                 /* allow him to construct his context */
 420
 421                                 ext->callback(wsi->protocol->owning_server,
 422                                                 ext, wsi,
 423                                                 LWS_EXT_CALLBACK_CONSTRUCT,
 424                                                 wsi->active_extensions_user[
 425                                         wsi->count_active_extensions], NULL, 0);
 426
 427                                 wsi->count_active_extensions++;
 428                                 debug("wsi->count_active_extensions <- %d",
 429                                                   wsi->count_active_extensions);
 430
 431                                 ext++;
 432                         }
 433
 434                         n = 0;
 435                 }
 436         }
 437
 438         /* end of response packet */
 439
 440         LWS_CPYAPP(p, "\x0d\x0a\x0d\x0a");
 441
 442         if (wsi->ietf_spec_revision == 4) {
 443
 444                 /*
 445                  * precompute the masking key the client will use from the SHA1
 446                  * hash of ( base 64 client key we were sent, concatenated with
 447                  * the bse 64 nonce we sent, concatenated with a magic constant
 448                  * guid specified by the 04 standard )
 449                  *
 450                  * We store the hash in the connection's wsi ready to use with
 451                  * undoing the masking the client has done on framed data it
 452                  * sends (we send our data to the client in clear).
 453                  */
 454
 455                 strcpy(mask_summing_buf, wsi->utf8_token[WSI_TOKEN_KEY].token);
 456                 m += wsi->utf8_token[WSI_TOKEN_KEY].token_len;
 457                 strcpy(m, nonce_buf);
 458                 m += nonce_len;
 459                 strcpy(m, websocket_magic_guid_04_masking);
 460                 m += strlen(websocket_magic_guid_04_masking);
 461
 462                 SHA1((unsigned char *)mask_summing_buf, m - mask_summing_buf,
 463                                                            wsi->masking_key_04);
 464         }
 465
 466         if (!lws_any_extension_handled(context, wsi,
 467                         LWS_EXT_CALLBACK_HANDSHAKE_REPLY_TX,
 468                                                      response, p - response)) {
 469
 470                 /* okay send the handshake response accepting the connection */
 471
 472                 debug("issuing response packet %d len\n", (int)(p - response));
 473         #ifdef DEBUG
 474                 fwrite(response, 1,  p - response, stderr);
 475         #endif
 476                 n = libwebsocket_write(wsi, (unsigned char *)response,
 477                                                   p - response, LWS_WRITE_HTTP);
 478                 if (n < 0) {
 479                         fprintf(stderr, "ERROR writing to socket");
 480                         goto bail;
 481                 }
 482
 483         }
 484
 485         /* alright clean up and set ourselves into established state */
 486
 487         free(response);
 488         wsi->state = WSI_STATE_ESTABLISHED;
 489         wsi->lws_rx_parse_state = LWS_RXPS_NEW;
 490         wsi->rx_packet_length = 0;
 491
 492         /* notify user code that we're ready to roll */
 493
 494         if (wsi->protocol->callback)
 495                 wsi->protocol->callback(wsi->protocol->owning_server,
 496                                 wsi, LWS_CALLBACK_ESTABLISHED,
 497                                           wsi->user_space, NULL, 0);
 498
 499         return 0;
 500
 501
 502 bail:
 503         return -1;
 504 }
 505
 506
 507 /*
 508  * -04 of the protocol (actually the 80th version) has a radically different
 509  * handshake.  The 04 spec gives the following idea
 510  *
 511  *    The handshake from the client looks as follows:
 512  *
 513  *      GET /chat HTTP/1.1
 514  *      Host: server.example.com
 515  *      Upgrade: websocket
 516  *      Connection: Upgrade
 517  *      Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
 518  *      Sec-WebSocket-Origin: http://example.com
 519  *      Sec-WebSocket-Protocol: chat, superchat
 520  *      Sec-WebSocket-Version: 4
 521  *
 522  *  The handshake from the server looks as follows:
 523  *
 524  *       HTTP/1.1 101 Switching Protocols
 525  *       Upgrade: websocket
 526  *       Connection: Upgrade
 527  *       Sec-WebSocket-Accept: me89jWimTRKTWwrS3aRrL53YZSo=
 528  *       Sec-WebSocket-Nonce: AQIDBAUGBwgJCgsMDQ4PEC==
 529  *       Sec-WebSocket-Protocol: chat
 530  */
 531
 532 /*
 533  * We have to take care about parsing because the headers may be split
 534  * into multiple fragments.  They may contain unknown headers with arbitrary
 535  * argument lengths.  So, we parse using a single-character at a time state
 536  * machine that is completely independent of packet size.
 537  */
 538
 539 int
 540 libwebsocket_read(struct libwebsocket_context *context,
 541                      struct libwebsocket *wsi, unsigned char * buf, size_t len)
 542 {
 543         size_t n;
 544
 545         switch (wsi->state) {
 546         case WSI_STATE_HTTP:
 547                 wsi->state = WSI_STATE_HTTP_HEADERS;
 548                 wsi->parser_state = WSI_TOKEN_NAME_PART;
 549                 /* fallthru */
 550         case WSI_STATE_HTTP_HEADERS:
 551
 552                 debug("issuing %d bytes to parser\n", (int)len);
 553 #ifdef DEBUG
 554                 fwrite(buf, 1, len, stderr);
 555 #endif
 556
 557                 switch (wsi->mode) {
 558                 case LWS_CONNMODE_WS_CLIENT_WAITING_PROXY_REPLY:
 559                 case LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE:
 560                 case LWS_CONNMODE_WS_CLIENT_WAITING_SERVER_REPLY:
 561                 case LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT:
 562                 case LWS_CONNMODE_WS_CLIENT:
 563                         for (n = 0; n < len; n++)
 564                                 libwebsocket_client_rx_sm(wsi, *buf++);
 565
 566                         return 0;
 567                 default:
 568                         break;
 569                 }
 570
 571                 /* LWS_CONNMODE_WS_SERVING */
 572
 573                 for (n = 0; n < len; n++)
 574                         libwebsocket_parse(wsi, *buf++);
 575
 576                 if (wsi->parser_state != WSI_PARSING_COMPLETE)
 577                         break;
 578
 579                 debug("seem to be serving, mode is %d\n", wsi->mode);
 580
 581                 debug("libwebsocket_parse sees parsing complete\n");
 582
 583                 /* is this websocket protocol or normal http 1.0? */
 584
 585                 if (!wsi->utf8_token[WSI_TOKEN_UPGRADE].token_len ||
 586                              !wsi->utf8_token[WSI_TOKEN_CONNECTION].token_len) {
 587                         wsi->state = WSI_STATE_HTTP;
 588                         if (wsi->protocol->callback)
 589                                 (wsi->protocol->callback)(context, wsi,
 590                                    LWS_CALLBACK_HTTP, wsi->user_space,
 591                                    wsi->utf8_token[WSI_TOKEN_GET_URI].token,
 592                                    wsi->utf8_token[WSI_TOKEN_GET_URI].token_len);
 593                         return 0;
 594                 }
 595
 596                 if (!wsi->protocol)
 597                         fprintf(stderr, "NULL protocol at libwebsocket_read\n");
 598
 599                 /*
 600                  * It's websocket
 601                  *
 602                  * Make sure user side is happy about protocol
 603                  */
 604
 605                 while (wsi->protocol->callback) {
 606
 607                         if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token == NULL) {
 608                                 if (wsi->protocol->name == NULL)
 609                                         break;
 610                         } else
 611                                 if (wsi->protocol->name && strcmp(
 612                                      wsi->utf8_token[WSI_TOKEN_PROTOCOL].token,
 613                                                       wsi->protocol->name) == 0)
 614                                         break;
 615
 616                         wsi->protocol++;
 617                 }
 618
 619                 /* we didn't find a protocol he wanted? */
 620
 621                 if (wsi->protocol->callback == NULL) {
 622                         if (wsi->utf8_token[WSI_TOKEN_PROTOCOL].token == NULL)
 623                                 fprintf(stderr, "[no protocol] "
 624                                         "not supported (use NULL .name)\n");
 625                         else
 626                                 fprintf(stderr, "Requested protocol %s "
 627                                                 "not supported\n",
 628                                      wsi->utf8_token[WSI_TOKEN_PROTOCOL].token);
 629                         goto bail;
 630                 }
 631
 632                 /*
 633                  * find out which spec version the client is using
 634                  * if this header is not given, we default to 00 (aka 76)
 635                  */
 636
 637                 if (wsi->utf8_token[WSI_TOKEN_VERSION].token_len)
 638                         wsi->ietf_spec_revision =
 639                                  atoi(wsi->utf8_token[WSI_TOKEN_VERSION].token);
 640
 641                 /*
 642                  * Give the user code a chance to study the request and
 643                  * have the opportunity to deny it
 644                  */
 645
 646                 if ((wsi->protocol->callback)(wsi->protocol->owning_server, wsi,
 647                                 LWS_CALLBACK_FILTER_PROTOCOL_CONNECTION,
 648                                                 &wsi->utf8_token[0], NULL, 0)) {
 649                         fprintf(stderr, "User code denied connection\n");
 650                         goto bail;
 651                 }
 652
 653
 654                 /*
 655                  * Perform the handshake according to the protocol version the
 656                  * client announced
 657                  */
 658
 659                 switch (wsi->ietf_spec_revision) {
 660                 case 0: /* applies to 76 and 00 */
 661                         wsi->xor_mask = xor_no_mask;
 662                         if (handshake_00(context, wsi))
 663                                 goto bail;
 664                         break;
 665                 case 4: /* 04 */
 666                         wsi->xor_mask = xor_mask_04;
 667                         debug("libwebsocket_parse calling handshake_04\n");
 668                         if (handshake_0405(context, wsi))
 669                                 goto bail;
 670                         break;
 671                 case 5:
 672                 case 6:
 673                 case 7:
 674                 case 8:
 675                 case 13:
 676                         wsi->xor_mask = xor_mask_05;
 677                         debug("libwebsocket_parse calling handshake_04\n");
 678                         if (handshake_0405(context, wsi))
 679                                 goto bail;
 680                         break;
 681
 682                 default:
 683                         fprintf(stderr, "Unknown client spec version %d\n",
 684                                                        wsi->ietf_spec_revision);
 685                         goto bail;
 686                 }
 687
 688                 debug("accepted v%02d connection\n",
 689                                                        wsi->ietf_spec_revision);
 690
 691                 break;
 692
 693         case WSI_STATE_AWAITING_CLOSE_ACK:
 694         case WSI_STATE_ESTABLISHED:
 695                 switch (wsi->mode) {
 696                 case LWS_CONNMODE_WS_CLIENT:
 697                         for (n = 0; n < len; n++)
 698                                 if (libwebsocket_client_rx_sm(wsi, *buf++) < 0)
 699                                         goto bail;
 700
 701                         return 0;
 702                 default:
 703                         break;
 704                 }
 705
 706                 /* LWS_CONNMODE_WS_SERVING */
 707
 708                 if (libwebsocket_interpret_incoming_packet(wsi, buf, len) < 0)
 709                         goto bail;
 710
 711                 break;
 712         default:
 713                 break;
 714         }
 715
 716         return 0;
 717
 718 bail:
 719         libwebsocket_close_and_free_session(context, wsi,
 720                                                      LWS_CLOSE_STATUS_NOSTATUS);
 721
 722         return -1;
 723 }