lib/client.c

   1 /*
   2  * libwebsockets - small server side websockets and web server implementation
   3  *
   4  * Copyright (C) 2010-2014 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 int
  25 lws_handshake_client(struct lws *wsi, unsigned char **buf, size_t len)
  26 {
  27         int m;
  28
  29         switch (wsi->mode) {
  30         case LWSCM_WSCL_WAITING_PROXY_REPLY:
  31         case LWSCM_WSCL_ISSUE_HANDSHAKE:
  32         case LWSCM_WSCL_WAITING_SERVER_REPLY:
  33         case LWSCM_WSCL_WAITING_EXTENSION_CONNECT:
  34         case LWSCM_WS_CLIENT:
  35                 while (len) {
  36                         /*
  37                          * we were accepting input but now we stopped doing so
  38                          */
  39                         if (!(wsi->rxflow_change_to & LWS_RXFLOW_ALLOW)) {
  40                                 lwsl_debug("%s: caching %ld\n", __func__, (long)len);
  41                                 lws_rxflow_cache(wsi, *buf, 0, len);
  42                                 return 0;
  43                         }
  44                         if (wsi->u.ws.rx_draining_ext) {
  45 #if !defined(LWS_NO_CLIENT)
  46                                 if (wsi->mode == LWSCM_WS_CLIENT)
  47                                         m = lws_client_rx_sm(wsi, 0);
  48                                 else
  49 #endif
  50                                         m = lws_rx_sm(wsi, 0);
  51                                 if (m < 0)
  52                                         return -1;
  53                                 continue;
  54                         }
  55                         /* account for what we're using in rxflow buffer */
  56                         if (wsi->rxflow_buffer)
  57                                 wsi->rxflow_pos++;
  58
  59                         if (lws_client_rx_sm(wsi, *(*buf)++)) {
  60                                 lwsl_debug("client_rx_sm exited\n");
  61                                 return -1;
  62                         }
  63                         len--;
  64                 }
  65                 lwsl_debug("%s: finished with %ld\n", __func__, (long)len);
  66                 return 0;
  67         default:
  68                 break;
  69         }
  70
  71         return 0;
  72 }
  73
  74 LWS_VISIBLE LWS_EXTERN void
  75 lws_client_http_body_pending(struct lws *wsi, int something_left_to_send)
  76 {
  77         wsi->client_http_body_pending = !!something_left_to_send;
  78 }
  79
  80 int
  81 lws_client_socket_service(struct lws_context *context, struct lws *wsi,
  82                           struct lws_pollfd *pollfd)
  83 {
  84         struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
  85         char *p = (char *)&pt->serv_buf[0];
  86         const char *cce = NULL;
  87         unsigned char c;
  88         char *sb = p;
  89         int n = 0, len = 0;
  90 #if defined(LWS_WITH_SOCKS5)
  91         char conn_mode = 0, pending_timeout = 0;
  92 #endif
  93
  94         switch (wsi->mode) {
  95
  96         case LWSCM_WSCL_WAITING_CONNECT:
  97
  98                 /*
  99                  * we are under PENDING_TIMEOUT_SENT_CLIENT_HANDSHAKE
 100                  * timeout protection set in client-handshake.c
 101                  */
 102
 103                 if (!lws_client_connect_2(wsi)) {
 104                         /* closed */
 105                         lwsl_client("closed\n");
 106                         return -1;
 107                 }
 108
 109                 /* either still pending connection, or changed mode */
 110                 return 0;
 111
 112 #if defined(LWS_WITH_SOCKS5)
 113         /* SOCKS Greeting Reply */
 114         case LWSCM_WSCL_WAITING_SOCKS_GREETING_REPLY:
 115
 116                 /* handle proxy hung up on us */
 117
 118                 if (pollfd->revents & LWS_POLLHUP) {
 119
 120                         lwsl_warn("SOCKS connection %p (fd=%d) dead\n",
 121                                   (void *)wsi, pollfd->fd);
 122
 123                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 124                         return 0;
 125                 }
 126
 127                 n = recv(wsi->desc.sockfd, sb, context->pt_serv_buf_size, 0);
 128                 if (n < 0) {
 129                         if (LWS_ERRNO == LWS_EAGAIN) {
 130                                 lwsl_debug("SOCKS read returned EAGAIN..."
 131                                         "retrying\n");
 132                                 return 0;
 133                         }
 134
 135                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 136                         lwsl_err("ERROR reading from SOCKS socket\n");
 137                         return 0;
 138                 }
 139
 140                 /* processing greeting reply */
 141                 if (pt->serv_buf[0] == SOCKS_VERSION_5
 142                         && pt->serv_buf[1] == SOCKS_AUTH_NO_AUTH)
 143                 {
 144                         lwsl_client("%s\n", "SOCKS greeting reply received "
 145                                 "- No Authentication Method");
 146                         socks_generate_msg(wsi, SOCKS_MSG_CONNECT, (size_t *)&len);
 147
 148                         conn_mode = LWSCM_WSCL_WAITING_SOCKS_CONNECT_REPLY;
 149                         pending_timeout = PENDING_TIMEOUT_AWAITING_SOCKS_CONNECT_REPLY;
 150                         lwsl_client("%s\n", "Sending SOCKS connect command");
 151                 }
 152                 else if (pt->serv_buf[0] == SOCKS_VERSION_5
 153                                 && pt->serv_buf[1] == SOCKS_AUTH_USERNAME_PASSWORD)
 154                 {
 155                         lwsl_client("%s\n", "SOCKS greeting reply received "
 156                                 "- User Name Password Method");
 157                         socks_generate_msg(wsi, SOCKS_MSG_USERNAME_PASSWORD,
 158                                 (size_t *)&len);
 159
 160                         conn_mode = LWSCM_WSCL_WAITING_SOCKS_AUTH_REPLY;
 161                         pending_timeout = PENDING_TIMEOUT_AWAITING_SOCKS_AUTH_REPLY;
 162                         lwsl_client("%s\n", "Sending SOCKS user/password");
 163                 }
 164                 else
 165                 {
 166                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 167                         lwsl_err("ERROR SOCKS greeting reply failed, method "
 168                                 "code: %d\n", pt->serv_buf[1]);
 169                         return 0;
 170                 }
 171
 172                 n = send(wsi->desc.sockfd, (char *)pt->serv_buf, len,
 173                          MSG_NOSIGNAL);
 174                 if (n < 0) {
 175                         lwsl_debug("ERROR writing socks command to socks proxy "
 176                                 "socket\n");
 177                         return 0;
 178                 }
 179
 180                 lws_set_timeout(wsi, pending_timeout, AWAITING_TIMEOUT);
 181                 wsi->mode = conn_mode;
 182
 183                 break;
 184         /* SOCKS auth Reply */
 185         case LWSCM_WSCL_WAITING_SOCKS_AUTH_REPLY:
 186
 187                 /* handle proxy hung up on us */
 188
 189                 if (pollfd->revents & LWS_POLLHUP) {
 190
 191                         lwsl_warn("SOCKS connection %p (fd=%d) dead\n",
 192                                   (void *)wsi, pollfd->fd);
 193
 194                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 195                         return 0;
 196                 }
 197
 198                 n = recv(wsi->desc.sockfd, sb, context->pt_serv_buf_size, 0);
 199                 if (n < 0) {
 200                         if (LWS_ERRNO == LWS_EAGAIN) {
 201                                 lwsl_debug("SOCKS read returned EAGAIN... "
 202                                         "retrying\n");
 203                                 return 0;
 204                         }
 205
 206                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 207                         lwsl_err("ERROR reading from socks socket\n");
 208                         return 0;
 209                 }
 210
 211                 /* processing auth reply */
 212                 if (pt->serv_buf[0] == SOCKS_SUBNEGOTIATION_VERSION_1
 213                         && pt->serv_buf[1] == SOCKS_SUBNEGOTIATION_STATUS_SUCCESS)
 214                 {
 215                         lwsl_client("%s\n", "SOCKS password reply recieved - "
 216                                 "successful");
 217                         socks_generate_msg(wsi, SOCKS_MSG_CONNECT, (size_t *)&len);
 218
 219                         conn_mode = LWSCM_WSCL_WAITING_SOCKS_CONNECT_REPLY;
 220                         pending_timeout =
 221                                 PENDING_TIMEOUT_AWAITING_SOCKS_CONNECT_REPLY;
 222                         lwsl_client("%s\n", "Sending SOCKS connect command");
 223                 }
 224                 else
 225                 {
 226                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 227                         lwsl_err("ERROR : SOCKS user/password reply failed, "
 228                                 "error code: %d\n", pt->serv_buf[1]);
 229                         return 0;
 230                 }
 231
 232                 n = send(wsi->desc.sockfd, (char *)pt->serv_buf, len,
 233                          MSG_NOSIGNAL);
 234                 if (n < 0) {
 235                         lwsl_debug("ERROR writing connect command to SOCKS "
 236                                 "socket\n");
 237                         return 0;
 238                 }
 239
 240                 lws_set_timeout(wsi, pending_timeout, AWAITING_TIMEOUT);
 241                 wsi->mode = conn_mode;
 242
 243                 break;
 244
 245         /* SOCKS connect command Reply */
 246         case LWSCM_WSCL_WAITING_SOCKS_CONNECT_REPLY:
 247
 248                 /* handle proxy hung up on us */
 249
 250                 if (pollfd->revents & LWS_POLLHUP) {
 251
 252                         lwsl_warn("SOCKS connection %p (fd=%d) dead\n",
 253                                   (void *)wsi, pollfd->fd);
 254
 255                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 256                         return 0;
 257                 }
 258
 259                 n = recv(wsi->desc.sockfd, sb, context->pt_serv_buf_size, 0);
 260                 if (n < 0) {
 261                         if (LWS_ERRNO == LWS_EAGAIN) {
 262                                 lwsl_debug("SOCKS read returned EAGAIN... "
 263                                         "retrying\n");
 264                                 return 0;
 265                         }
 266
 267                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 268                         lwsl_err("ERROR reading from socks socket\n");
 269                         return 0;
 270                 }
 271
 272                 /* processing connect reply */
 273                 if (pt->serv_buf[0] == SOCKS_VERSION_5
 274                         && pt->serv_buf[1] == SOCKS_REQUEST_REPLY_SUCCESS)
 275                 {
 276                         lwsl_client("%s\n", "SOCKS connect reply recieved - "
 277                                 "successful");
 278                 }
 279                 else
 280                 {
 281                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 282                         lwsl_err("ERROR SOCKS connect reply failed, error "
 283                                 "code: %d\n", pt->serv_buf[1]);
 284                         return 0;
 285                 }
 286
 287                 /* free stash since we are done with it */
 288                 lws_free_set_NULL(wsi->u.hdr.stash);
 289
 290                 if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS,
 291                         wsi->vhost->socks_proxy_address))
 292                         goto bail3;
 293                 wsi->c_port = wsi->vhost->socks_proxy_port;
 294
 295                 /* clear his proxy connection timeout */
 296
 297                 lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
 298
 299                 goto start_ws_hanshake;
 300 #endif
 301         case LWSCM_WSCL_WAITING_PROXY_REPLY:
 302
 303                 /* handle proxy hung up on us */
 304
 305                 if (pollfd->revents & LWS_POLLHUP) {
 306
 307                         lwsl_warn("Proxy connection %p (fd=%d) dead\n",
 308                                   (void *)wsi, pollfd->fd);
 309
 310                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 311                         return 0;
 312                 }
 313
 314                 n = recv(wsi->desc.sockfd, sb, context->pt_serv_buf_size, 0);
 315                 if (n < 0) {
 316                         if (LWS_ERRNO == LWS_EAGAIN) {
 317                                 lwsl_debug("Proxy read returned EAGAIN... retrying\n");
 318                                 return 0;
 319                         }
 320
 321                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 322                         lwsl_err("ERROR reading from proxy socket\n");
 323                         return 0;
 324                 }
 325
 326                 pt->serv_buf[13] = '\0';
 327                 if (strcmp(sb, "HTTP/1.0 200 ") &&
 328                     strcmp(sb, "HTTP/1.1 200 ")) {
 329                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 330                         lwsl_err("ERROR proxy: %s\n", sb);
 331                         return 0;
 332                 }
 333
 334                 /* clear his proxy connection timeout */
 335
 336                 lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
 337
 338                 /* fallthru */
 339
 340         case LWSCM_WSCL_ISSUE_HANDSHAKE:
 341
 342                 /*
 343                  * we are under PENDING_TIMEOUT_SENT_CLIENT_HANDSHAKE
 344                  * timeout protection set in client-handshake.c
 345                  *
 346                  * take care of our lws_callback_on_writable
 347                  * happening at a time when there's no real connection yet
 348                  */
 349 #if defined(LWS_WITH_SOCKS5)
 350 start_ws_hanshake:
 351 #endif
 352                 if (lws_change_pollfd(wsi, LWS_POLLOUT, 0))
 353                         return -1;
 354
 355 #ifdef LWS_OPENSSL_SUPPORT
 356                 /* we can retry this... just cook the SSL BIO the first time */
 357
 358                 if (wsi->use_ssl && !wsi->ssl) {
 359                         if (lws_ssl_client_bio_create(wsi))
 360                                 return -1;
 361                 }
 362
 363                 if (wsi->use_ssl) {
 364                         n = lws_ssl_client_connect1(wsi);
 365                         if (!n)
 366                                 return 0;
 367                         if (n < 0) {
 368                                 cce = "lws_ssl_client_connect1 failed";
 369                                 goto bail3;
 370                         }
 371                 } else
 372                         wsi->ssl = NULL;
 373
 374                 /* fallthru */
 375
 376         case LWSCM_WSCL_WAITING_SSL:
 377
 378                 if (wsi->use_ssl) {
 379                         n = lws_ssl_client_connect2(wsi);
 380                         if (!n)
 381                                 return 0;
 382                         if (n < 0) {
 383                                 cce = "lws_ssl_client_connect2 failed";
 384                                 goto bail3;
 385                         }
 386                 } else
 387                         wsi->ssl = NULL;
 388 #endif
 389
 390                 wsi->mode = LWSCM_WSCL_ISSUE_HANDSHAKE2;
 391                 lws_set_timeout(wsi, PENDING_TIMEOUT_AWAITING_CLIENT_HS_SEND,
 392                                 context->timeout_secs);
 393
 394                 /* fallthru */
 395
 396         case LWSCM_WSCL_ISSUE_HANDSHAKE2:
 397                 p = lws_generate_client_handshake(wsi, p);
 398                 if (p == NULL) {
 399                         if (wsi->mode == LWSCM_RAW)
 400                                 return 0;
 401
 402                         lwsl_err("Failed to generate handshake for client\n");
 403                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 404                         return 0;
 405                 }
 406
 407                 /* send our request to the server */
 408
 409                 lws_latency_pre(context, wsi);
 410
 411                 n = lws_ssl_capable_write(wsi, (unsigned char *)sb, p - sb);
 412                 lws_latency(context, wsi, "send lws_issue_raw", n,
 413                             n == p - sb);
 414                 switch (n) {
 415                 case LWS_SSL_CAPABLE_ERROR:
 416                         lwsl_debug("ERROR writing to client socket\n");
 417                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 418                         return 0;
 419                 case LWS_SSL_CAPABLE_MORE_SERVICE:
 420                         lws_callback_on_writable(wsi);
 421                         break;
 422                 }
 423
 424                 if (wsi->client_http_body_pending) {
 425                         wsi->mode = LWSCM_WSCL_ISSUE_HTTP_BODY;
 426                         lws_set_timeout(wsi, PENDING_TIMEOUT_CLIENT_ISSUE_PAYLOAD,
 427                                         context->timeout_secs);
 428                         /* user code must ask for writable callback */
 429                         break;
 430                 }
 431
 432                 goto client_http_body_sent;
 433
 434         case LWSCM_WSCL_ISSUE_HTTP_BODY:
 435                 if (wsi->client_http_body_pending) {
 436                         lws_set_timeout(wsi, PENDING_TIMEOUT_CLIENT_ISSUE_PAYLOAD,
 437                                         context->timeout_secs);
 438                         /* user code must ask for writable callback */
 439                         break;
 440                 }
 441 client_http_body_sent:
 442                 wsi->u.hdr.parser_state = WSI_TOKEN_NAME_PART;
 443                 wsi->u.hdr.lextable_pos = 0;
 444                 wsi->mode = LWSCM_WSCL_WAITING_SERVER_REPLY;
 445                 lws_set_timeout(wsi, PENDING_TIMEOUT_AWAITING_SERVER_RESPONSE,
 446                                 context->timeout_secs);
 447                 break;
 448
 449         case LWSCM_WSCL_WAITING_SERVER_REPLY:
 450
 451                 /* handle server hung up on us */
 452
 453                 if (pollfd->revents & LWS_POLLHUP) {
 454
 455                         lwsl_debug("Server connection %p (fd=%d) dead\n",
 456                                 (void *)wsi, pollfd->fd);
 457                         cce = "Peer hung up";
 458                         goto bail3;
 459                 }
 460
 461                 if (!(pollfd->revents & LWS_POLLIN))
 462                         break;
 463
 464                 /* interpret the server response */
 465
 466                 /*
 467                  *  HTTP/1.1 101 Switching Protocols
 468                  *  Upgrade: websocket
 469                  *  Connection: Upgrade
 470                  *  Sec-WebSocket-Accept: me89jWimTRKTWwrS3aRrL53YZSo=
 471                  *  Sec-WebSocket-Nonce: AQIDBAUGBwgJCgsMDQ4PEC==
 472                  *  Sec-WebSocket-Protocol: chat
 473                  */
 474
 475                 /*
 476                  * we have to take some care here to only take from the
 477                  * socket bytewise.  The browser may (and has been seen to
 478                  * in the case that onopen() performs websocket traffic)
 479                  * coalesce both handshake response and websocket traffic
 480                  * in one packet, since at that point the connection is
 481                  * definitively ready from browser pov.
 482                  */
 483                 len = 1;
 484                 while (wsi->u.hdr.parser_state != WSI_PARSING_COMPLETE &&
 485                        len > 0) {
 486                         n = lws_ssl_capable_read(wsi, &c, 1);
 487                         lws_latency(context, wsi, "send lws_issue_raw", n,
 488                                     n == 1);
 489                         switch (n) {
 490                         case 0:
 491                         case LWS_SSL_CAPABLE_ERROR:
 492                                 cce = "read failed";
 493                                 goto bail3;
 494                         case LWS_SSL_CAPABLE_MORE_SERVICE:
 495                                 return 0;
 496                         }
 497
 498                         if (lws_parse(wsi, c)) {
 499                                 lwsl_warn("problems parsing header\n");
 500                                 goto bail3;
 501                         }
 502                 }
 503
 504                 /*
 505                  * hs may also be coming in multiple packets, there is a 5-sec
 506                  * libwebsocket timeout still active here too, so if parsing did
 507                  * not complete just wait for next packet coming in this state
 508                  */
 509
 510                 if (wsi->u.hdr.parser_state != WSI_PARSING_COMPLETE)
 511                         break;
 512
 513                 /*
 514                  * otherwise deal with the handshake.  If there's any
 515                  * packet traffic already arrived we'll trigger poll() again
 516                  * right away and deal with it that way
 517                  */
 518
 519                 return lws_client_interpret_server_handshake(wsi);
 520
 521 bail3:
 522                 lwsl_info("closing conn at LWS_CONNMODE...SERVER_REPLY\n");
 523                 if (cce)
 524                         lwsl_info("reason: %s\n", cce);
 525                 wsi->protocol->callback(wsi,
 526                         LWS_CALLBACK_CLIENT_CONNECTION_ERROR,
 527                         wsi->user_space, (void *)cce, cce ? strlen(cce) : 0);
 528                 wsi->already_did_cce = 1;
 529                 lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
 530                 return -1;
 531
 532         case LWSCM_WSCL_WAITING_EXTENSION_CONNECT:
 533                 lwsl_ext("LWSCM_WSCL_WAITING_EXTENSION_CONNECT\n");
 534                 break;
 535
 536         case LWSCM_WSCL_PENDING_CANDIDATE_CHILD:
 537                 lwsl_ext("LWSCM_WSCL_PENDING_CANDIDATE_CHILD\n");
 538                 break;
 539         default:
 540                 break;
 541         }
 542
 543         return 0;
 544 }
 545
 546 /*
 547  * In-place str to lower case
 548  */
 549
 550 static void
 551 strtolower(char *s)
 552 {
 553         while (*s) {
 554 #ifdef LWS_PLAT_OPTEE
 555                 int tolower_optee(int c);
 556                 *s = tolower_optee((int)*s);
 557 #else
 558                 *s = tolower((int)*s);
 559 #endif
 560                 s++;
 561         }
 562 }
 563
 564 int LWS_WARN_UNUSED_RESULT
 565 lws_http_transaction_completed_client(struct lws *wsi)
 566 {
 567         lwsl_debug("%s: wsi %p\n", __func__, wsi);
 568         /* if we can't go back to accept new headers, drop the connection */
 569         if (wsi->u.http.connection_type != HTTP_CONNECTION_KEEP_ALIVE) {
 570                 lwsl_info("%s: %p: close connection\n", __func__, wsi);
 571                 return 1;
 572         }
 573
 574         /* we don't support chained client connections yet */
 575         return 1;
 576
 577         /* otherwise set ourselves up ready to go again */
 578         wsi->state = LWSS_CLIENT_HTTP_ESTABLISHED;
 579         wsi->mode = LWSCM_HTTP_CLIENT_ACCEPTED;
 580         wsi->u.http.content_length = 0;
 581         wsi->hdr_parsing_completed = 0;
 582
 583         /* He asked for it to stay alive indefinitely */
 584         lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
 585
 586         /*
 587          * As client, nothing new is going to come until we ask for it
 588          * we can drop the ah, if any
 589          */
 590         if (wsi->u.hdr.ah) {
 591                 lws_header_table_force_to_detachable_state(wsi);
 592                 lws_header_table_detach(wsi, 0);
 593         }
 594
 595         /* If we're (re)starting on headers, need other implied init */
 596         wsi->u.hdr.ues = URIES_IDLE;
 597
 598         lwsl_info("%s: %p: keep-alive await new transaction\n", __func__, wsi);
 599
 600         return 0;
 601 }
 602
 603 LWS_VISIBLE LWS_EXTERN unsigned int
 604 lws_http_client_http_response(struct lws *wsi)
 605 {
 606         if (!wsi->u.http.ah)
 607                 return 0;
 608
 609         return wsi->u.http.ah->http_response;
 610 }
 611
 612 int
 613 lws_client_interpret_server_handshake(struct lws *wsi)
 614 {
 615         int n, len, okay = 0, port = 0, ssl = 0;
 616         int close_reason = LWS_CLOSE_STATUS_PROTOCOL_ERR;
 617         struct lws_context *context = wsi->context;
 618         const char *pc, *prot, *ads = NULL, *path, *cce = NULL;
 619         struct allocated_headers *ah = NULL;
 620         char *p, *q;
 621         char new_path[300];
 622 #ifndef LWS_NO_EXTENSIONS
 623         struct lws_context_per_thread *pt = &context->pt[(int)wsi->tsi];
 624         char *sb = (char *)&pt->serv_buf[0];
 625         const struct lws_ext_options *opts;
 626         const struct lws_extension *ext;
 627         char ext_name[128];
 628         const char *c, *a;
 629         char ignore;
 630         int more = 1;
 631         void *v;
 632 #endif
 633
 634         ah = wsi->u.hdr.ah;
 635         if (!wsi->do_ws) {
 636                 /* we are being an http client...
 637                  */
 638                 lws_union_transition(wsi, LWSCM_HTTP_CLIENT_ACCEPTED);
 639                 wsi->state = LWSS_CLIENT_HTTP_ESTABLISHED;
 640                 wsi->u.http.ah = ah;
 641                 ah->http_response = 0;
 642         }
 643
 644         /*
 645          * well, what the server sent looked reasonable for syntax.
 646          * Now let's confirm it sent all the necessary headers
 647          *
 648          * http (non-ws) client will expect something like this
 649          *
 650          * HTTP/1.0.200
 651          * server:.libwebsockets
 652          * content-type:.text/html
 653          * content-length:.17703
 654          * set-cookie:.test=LWS_1456736240_336776_COOKIE;Max-Age=360000
 655          *
 656          *
 657          *
 658          */
 659
 660         wsi->u.http.connection_type = HTTP_CONNECTION_KEEP_ALIVE;
 661         p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_HTTP);
 662         if (wsi->do_ws && !p) {
 663                 lwsl_info("no URI\n");
 664                 cce = "HS: URI missing";
 665                 goto bail3;
 666         }
 667         if (!p) {
 668                 p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_HTTP1_0);
 669                 wsi->u.http.connection_type = HTTP_CONNECTION_CLOSE;
 670         }
 671         if (!p) {
 672                 cce = "HS: URI missing";
 673                 lwsl_info("no URI\n");
 674                 goto bail3;
 675         }
 676         n = atoi(p);
 677         if (ah)
 678                 ah->http_response = n;
 679
 680         if (n == 301 || n == 302 || n == 303 || n == 307 || n == 308) {
 681                 p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_HTTP_LOCATION);
 682                 if (!p) {
 683                         cce = "HS: Redirect code but no Location";
 684                         goto bail3;
 685                 }
 686
 687                 /* Relative reference absolute path */
 688                 if (p[0] == '/')
 689                 {
 690 #ifdef LWS_OPENSSL_SUPPORT
 691                         ssl = wsi->use_ssl;
 692 #endif
 693                         ads = lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS);
 694                         port = wsi->c_port;
 695                         path = p + 1; /* +1 as lws_client_reset expects leading / to be omitted */
 696                 }
 697                 /* Absolute (Full) URI */
 698                 else if (strchr(p, ':'))
 699                 {
 700                         if (lws_parse_uri(p, &prot, &ads, &port, &path)) {
 701                                 cce = "HS: URI did not parse";
 702                                 goto bail3;
 703                         }
 704
 705                         if (!strcmp(prot, "wss") || !strcmp(prot, "https"))
 706                                 ssl = 1;
 707                 }
 708                 /* Relative reference relative path */
 709                 else
 710                 {
 711                         /* This doesn't try to calculate an absolute path, that will be left to the server */
 712 #ifdef LWS_OPENSSL_SUPPORT
 713                         ssl = wsi->use_ssl;
 714 #endif
 715                         ads = lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS);
 716                         port = wsi->c_port;
 717                         path = new_path + 1; /* +1 as lws_client_reset expects leading / to be omitted */
 718                         strncpy(new_path, lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_URI), sizeof(new_path));
 719                         new_path[sizeof(new_path) - 1] = '\0';
 720                         q = strrchr(new_path, '/');
 721                         if (q)
 722                         {
 723                                 strncpy(q + 1, p, sizeof(new_path) - (q - new_path) - 1);
 724                                 new_path[sizeof(new_path) - 1] = '\0';
 725                         }
 726                         else
 727                         {
 728                                 path = p;
 729                         }
 730                 }
 731
 732 #ifdef LWS_OPENSSL_SUPPORT
 733                 if (wsi->use_ssl && !ssl) {
 734                         cce = "HS: Redirect attempted SSL downgrade";
 735                         goto bail3;
 736                 }
 737 #endif
 738
 739                 if (!lws_client_reset(&wsi, ssl, ads, port, path, ads)) {
 740                         /* there are two ways to fail out with NULL return...
 741                          * simple, early problem where the wsi is intact, or
 742                          * we went through with the reconnect attempt and the
 743                          * wsi is already closed.  In the latter case, the wsi
 744                          * has beet set to NULL additionally.
 745                          */
 746                         lwsl_err("Redirect failed\n");
 747                         cce = "HS: Redirect failed";
 748                         if (wsi)
 749                                 goto bail3;
 750
 751                         return 1;
 752                 }
 753                 return 0;
 754         }
 755
 756         if (!wsi->do_ws) {
 757                 if (n != 200 && n != 201 && n != 304 && n != 401) {
 758                         lwsl_notice("Connection failed with code %d\n", n);
 759                         cce = "HS: Server unrecognized response code";
 760                         goto bail2;
 761                 }
 762
 763 #ifdef LWS_WITH_HTTP_PROXY
 764                 wsi->perform_rewrite = 0;
 765                 if (lws_hdr_total_length(wsi, WSI_TOKEN_HTTP_CONTENT_TYPE)) {
 766                         if (!strncmp(lws_hdr_simple_ptr(wsi, WSI_TOKEN_HTTP_CONTENT_TYPE),
 767                                      "text/html", 9))
 768                                 wsi->perform_rewrite = 1;
 769                 }
 770 #endif
 771
 772                 /* allocate the per-connection user memory (if any) */
 773                 if (lws_ensure_user_space(wsi)) {
 774                         lwsl_err("Problem allocating wsi user mem\n");
 775                         cce = "HS: OOM";
 776                         goto bail2;
 777                 }
 778
 779                 /* he may choose to send us stuff in chunked transfer-coding */
 780                 wsi->chunked = 0;
 781                 wsi->chunk_remaining = 0; /* ie, next thing is chunk size */
 782                 if (lws_hdr_total_length(wsi, WSI_TOKEN_HTTP_TRANSFER_ENCODING)) {
 783                         wsi->chunked = !strcmp(lws_hdr_simple_ptr(wsi,
 784                                                WSI_TOKEN_HTTP_TRANSFER_ENCODING),
 785                                         "chunked");
 786                         /* first thing is hex, after payload there is crlf */
 787                         wsi->chunk_parser = ELCP_HEX;
 788                 }
 789
 790                 if (lws_hdr_total_length(wsi, WSI_TOKEN_HTTP_CONTENT_LENGTH)) {
 791                         wsi->u.http.content_length =
 792                                         atoll(lws_hdr_simple_ptr(wsi,
 793                                                 WSI_TOKEN_HTTP_CONTENT_LENGTH));
 794                         lwsl_notice("%s: incoming content length %llu\n", __func__,
 795                                         (unsigned long long)wsi->u.http.content_length);
 796                         wsi->u.http.content_remain = wsi->u.http.content_length;
 797                 } else /* can't do 1.1 without a content length or chunked */
 798                         if (!wsi->chunked)
 799                                 wsi->u.http.connection_type = HTTP_CONNECTION_CLOSE;
 800
 801                 /*
 802                  * we seem to be good to go, give client last chance to check
 803                  * headers and OK it
 804                  */
 805                 if (wsi->protocol->callback(wsi, LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH,
 806                                             wsi->user_space, NULL, 0)) {
 807
 808                         cce = "HS: disallowed by client filter";
 809                         goto bail2;
 810                 }
 811
 812                 /* clear his proxy connection timeout */
 813                 lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
 814
 815                 wsi->rxflow_change_to = LWS_RXFLOW_ALLOW;
 816
 817                 /* call him back to inform him he is up */
 818                 if (wsi->protocol->callback(wsi,
 819                                             LWS_CALLBACK_ESTABLISHED_CLIENT_HTTP,
 820                                             wsi->user_space, NULL, 0)) {
 821                         cce = "HS: disallowed at ESTABLISHED";
 822                         goto bail3;
 823                 }
 824
 825                 /* free up his parsing allocations */
 826                 lws_header_table_detach(wsi, 0);
 827
 828                 lwsl_notice("%s: client connection up\n", __func__);
 829
 830                 return 0;
 831         }
 832
 833         if (lws_hdr_total_length(wsi, WSI_TOKEN_ACCEPT) == 0) {
 834                 lwsl_info("no ACCEPT\n");
 835                 cce = "HS: ACCEPT missing";
 836                 goto bail3;
 837         }
 838
 839         if (p && strncmp(p, "101", 3)) {
 840                 lwsl_warn(
 841                        "lws_client_handshake: got bad HTTP response '%s'\n", p);
 842                 cce = "HS: ws upgrade response not 101";
 843                 goto bail3;
 844         }
 845
 846         p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_UPGRADE);
 847         if (!p) {
 848                 lwsl_info("no UPGRADE\n");
 849                 cce = "HS: UPGRADE missing";
 850                 goto bail3;
 851         }
 852         strtolower(p);
 853         if (strcmp(p, "websocket")) {
 854                 lwsl_warn(
 855                       "lws_client_handshake: got bad Upgrade header '%s'\n", p);
 856                 cce = "HS: Upgrade to something other than websocket";
 857                 goto bail3;
 858         }
 859
 860         p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_CONNECTION);
 861         if (!p) {
 862                 lwsl_info("no Connection hdr\n");
 863                 cce = "HS: CONNECTION missing";
 864                 goto bail3;
 865         }
 866         strtolower(p);
 867         if (strcmp(p, "upgrade")) {
 868                 lwsl_warn("lws_client_int_s_hs: bad header %s\n", p);
 869                 cce = "HS: UPGRADE malformed";
 870                 goto bail3;
 871         }
 872
 873         pc = lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_SENT_PROTOCOLS);
 874         if (!pc) {
 875                 lwsl_parser("lws_client_int_s_hs: no protocol list\n");
 876         } else
 877                 lwsl_parser("lws_client_int_s_hs: protocol list '%s'\n", pc);
 878
 879         /*
 880          * confirm the protocol the server wants to talk was in the list
 881          * of protocols we offered
 882          */
 883
 884         len = lws_hdr_total_length(wsi, WSI_TOKEN_PROTOCOL);
 885         if (!len) {
 886                 lwsl_info("lws_client_int_s_hs: WSI_TOKEN_PROTOCOL is null\n");
 887                 /*
 888                  * no protocol name to work from,
 889                  * default to first protocol
 890                  */
 891                 n = 0;
 892                 wsi->protocol = &wsi->vhost->protocols[0];
 893                 goto check_extensions;
 894         }
 895
 896         p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_PROTOCOL);
 897         len = strlen(p);
 898
 899         while (pc && *pc && !okay) {
 900                 if (!strncmp(pc, p, len) &&
 901                     (pc[len] == ',' || pc[len] == '\0')) {
 902                         okay = 1;
 903                         continue;
 904                 }
 905                 while (*pc && *pc++ != ',')
 906                         ;
 907                 while (*pc && *pc == ' ')
 908                         pc++;
 909         }
 910
 911         if (!okay) {
 912                 lwsl_err("lws_client_int_s_hs: got bad protocol %s\n", p);
 913                 cce = "HS: PROTOCOL malformed";
 914                 goto bail2;
 915         }
 916
 917         /*
 918          * identify the selected protocol struct and set it
 919          */
 920         n = 0;
 921         wsi->protocol = NULL;
 922         while (wsi->vhost->protocols[n].callback && !wsi->protocol) {
 923                 if (strcmp(p, wsi->vhost->protocols[n].name) == 0) {
 924                         wsi->protocol = &wsi->vhost->protocols[n];
 925                         break;
 926                 }
 927                 n++;
 928         }
 929
 930         if (wsi->protocol == NULL) {
 931                 lwsl_err("lws_client_int_s_hs: fail protocol %s\n", p);
 932                 cce = "HS: Cannot match protocol";
 933                 goto bail2;
 934         }
 935
 936 check_extensions:
 937         /*
 938          * stitch protocol choice into the vh protocol linked list
 939          * We always insert ourselves at the start of the list
 940          *
 941          * X <-> B
 942          * X <-> pAn <-> pB
 943          */
 944         //lwsl_err("%s: pre insert vhost start wsi %p, that wsi prev == %p\n",
 945         //              __func__,
 946         //              wsi->vhost->same_vh_protocol_list[n],
 947         //              wsi->same_vh_protocol_prev);
 948         wsi->same_vh_protocol_prev = /* guy who points to us */
 949                 &wsi->vhost->same_vh_protocol_list[n];
 950         wsi->same_vh_protocol_next = /* old first guy is our next */
 951                         wsi->vhost->same_vh_protocol_list[n];
 952         /* we become the new first guy */
 953         wsi->vhost->same_vh_protocol_list[n] = wsi;
 954
 955         if (wsi->same_vh_protocol_next)
 956                 /* old first guy points back to us now */
 957                 wsi->same_vh_protocol_next->same_vh_protocol_prev =
 958                                 &wsi->same_vh_protocol_next;
 959
 960 #ifndef LWS_NO_EXTENSIONS
 961         /* instantiate the accepted extensions */
 962
 963         if (!lws_hdr_total_length(wsi, WSI_TOKEN_EXTENSIONS)) {
 964                 lwsl_ext("no client extensions allowed by server\n");
 965                 goto check_accept;
 966         }
 967
 968         /*
 969          * break down the list of server accepted extensions
 970          * and go through matching them or identifying bogons
 971          */
 972
 973         if (lws_hdr_copy(wsi, sb, context->pt_serv_buf_size, WSI_TOKEN_EXTENSIONS) < 0) {
 974                 lwsl_warn("ext list from server failed to copy\n");
 975                 cce = "HS: EXT: list too big";
 976                 goto bail2;
 977         }
 978
 979         c = sb;
 980         n = 0;
 981         ignore = 0;
 982         a = NULL;
 983         while (more) {
 984
 985                 if (*c && (*c != ',' && *c != '\t')) {
 986                         if (*c == ';') {
 987                                 ignore = 1;
 988                                 if (!a)
 989                                         a = c + 1;
 990                         }
 991                         if (ignore || *c == ' ') {
 992                                 c++;
 993                                 continue;
 994                         }
 995
 996                         ext_name[n] = *c++;
 997                         if (n < sizeof(ext_name) - 1)
 998                                 n++;
 999                         continue;
1000                 }
1001                 ext_name[n] = '\0';
1002                 ignore = 0;
1003                 if (!*c)
1004                         more = 0;
1005                 else {
1006                         c++;
1007                         if (!n)
1008                                 continue;
1009                 }
1010
1011                 /* check we actually support it */
1012
1013                 lwsl_notice("checking client ext %s\n", ext_name);
1014
1015                 n = 0;
1016                 ext = wsi->vhost->extensions;
1017                 while (ext && ext->callback) {
1018                         if (strcmp(ext_name, ext->name)) {
1019                                 ext++;
1020                                 continue;
1021                         }
1022
1023                         n = 1;
1024                         lwsl_notice("instantiating client ext %s\n", ext_name);
1025
1026                         /* instantiate the extension on this conn */
1027
1028                         wsi->active_extensions[wsi->count_act_ext] = ext;
1029
1030                         /* allow him to construct his ext instance */
1031
1032                         if (ext->callback(lws_get_context(wsi), ext, wsi,
1033                                       LWS_EXT_CB_CLIENT_CONSTRUCT,
1034                                       (void *)&wsi->act_ext_user[wsi->count_act_ext],
1035                                       (void *)&opts, 0)) {
1036                                 lwsl_notice(" ext %s failed construction\n", ext_name);
1037                                 ext++;
1038                                 continue;
1039                         }
1040
1041                         /*
1042                          * allow the user code to override ext defaults if it
1043                          * wants to
1044                          */
1045                         ext_name[0] = '\0';
1046                         if (user_callback_handle_rxflow(wsi->protocol->callback,
1047                                         wsi, LWS_CALLBACK_WS_EXT_DEFAULTS,
1048                                         (char *)ext->name, ext_name,
1049                                         sizeof(ext_name))) {
1050                                 cce = "HS: EXT: failed setting defaults";
1051                                 goto bail2;
1052                         }
1053
1054                         if (ext_name[0] &&
1055                             lws_ext_parse_options(ext, wsi, wsi->act_ext_user[
1056                                                   wsi->count_act_ext], opts, ext_name,
1057                                                   strlen(ext_name))) {
1058                                 lwsl_err("%s: unable to parse user defaults '%s'",
1059                                          __func__, ext_name);
1060                                 cce = "HS: EXT: failed parsing defaults";
1061                                 goto bail2;
1062                         }
1063
1064                         /*
1065                          * give the extension the server options
1066                          */
1067                         if (a && lws_ext_parse_options(ext, wsi,
1068                                         wsi->act_ext_user[wsi->count_act_ext],
1069                                         opts, a, c - a)) {
1070                                 lwsl_err("%s: unable to parse remote def '%s'",
1071                                          __func__, a);
1072                                 cce = "HS: EXT: failed parsing options";
1073                                 goto bail2;
1074                         }
1075
1076                         if (ext->callback(lws_get_context(wsi), ext, wsi,
1077                                         LWS_EXT_CB_OPTION_CONFIRM,
1078                                       wsi->act_ext_user[wsi->count_act_ext],
1079                                       NULL, 0)) {
1080                                 lwsl_err("%s: ext %s rejects server options %s",
1081                                          __func__, ext->name, a);
1082                                 cce = "HS: EXT: Rejects server options";
1083                                 goto bail2;
1084                         }
1085
1086                         wsi->count_act_ext++;
1087
1088                         ext++;
1089                 }
1090
1091                 if (n == 0) {
1092                         lwsl_warn("Unknown ext '%s'!\n", ext_name);
1093                         cce = "HS: EXT: unknown ext";
1094                         goto bail2;
1095                 }
1096
1097                 a = NULL;
1098                 n = 0;
1099         }
1100
1101 check_accept:
1102 #endif
1103
1104         /*
1105          * Confirm his accept token is the one we precomputed
1106          */
1107
1108         p = lws_hdr_simple_ptr(wsi, WSI_TOKEN_ACCEPT);
1109         if (strcmp(p, wsi->u.hdr.ah->initial_handshake_hash_base64)) {
1110                 lwsl_warn("lws_client_int_s_hs: accept '%s' wrong vs '%s'\n", p,
1111                                   wsi->u.hdr.ah->initial_handshake_hash_base64);
1112                 cce = "HS: Accept hash wrong";
1113                 goto bail2;
1114         }
1115
1116         /* allocate the per-connection user memory (if any) */
1117         if (lws_ensure_user_space(wsi)) {
1118                 lwsl_err("Problem allocating wsi user mem\n");
1119                 cce = "HS: OOM";
1120                 goto bail2;
1121         }
1122
1123         /*
1124          * we seem to be good to go, give client last chance to check
1125          * headers and OK it
1126          */
1127         if (wsi->protocol->callback(wsi, LWS_CALLBACK_CLIENT_FILTER_PRE_ESTABLISH,
1128                                     wsi->user_space, NULL, 0)) {
1129                 cce = "HS: Rejected by filter cb";
1130                 goto bail2;
1131         }
1132
1133         /* clear his proxy connection timeout */
1134         lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
1135
1136         /* free up his parsing allocations */
1137         lws_header_table_detach(wsi, 0);
1138
1139         lws_union_transition(wsi, LWSCM_WS_CLIENT);
1140         wsi->state = LWSS_ESTABLISHED;
1141         lws_restart_ws_ping_pong_timer(wsi);
1142
1143         wsi->rxflow_change_to = LWS_RXFLOW_ALLOW;
1144
1145         /*
1146          * create the frame buffer for this connection according to the
1147          * size mentioned in the protocol definition.  If 0 there, then
1148          * use a big default for compatibility
1149          */
1150         n = wsi->protocol->rx_buffer_size;
1151         if (!n)
1152                 n = context->pt_serv_buf_size;
1153         n += LWS_PRE;
1154         wsi->u.ws.rx_ubuf = lws_malloc(n + 4 /* 0x0000ffff zlib */);
1155         if (!wsi->u.ws.rx_ubuf) {
1156                 lwsl_err("Out of Mem allocating rx buffer %d\n", n);
1157                 cce = "HS: OOM";
1158                 goto bail2;
1159         }
1160        wsi->u.ws.rx_ubuf_alloc = n;
1161         lwsl_info("Allocating client RX buffer %d\n", n);
1162
1163 #if !defined(LWS_WITH_ESP32)
1164         if (setsockopt(wsi->desc.sockfd, SOL_SOCKET, SO_SNDBUF, (const char *)&n,
1165                        sizeof n)) {
1166                 lwsl_warn("Failed to set SNDBUF to %d", n);
1167                 cce = "HS: SO_SNDBUF failed";
1168                 goto bail3;
1169         }
1170 #endif
1171
1172         lwsl_debug("handshake OK for protocol %s\n", wsi->protocol->name);
1173
1174         /* call him back to inform him he is up */
1175
1176         if (wsi->protocol->callback(wsi, LWS_CALLBACK_CLIENT_ESTABLISHED,
1177                                     wsi->user_space, NULL, 0)) {
1178                 cce = "HS: Rejected at CLIENT_ESTABLISHED";
1179                 goto bail3;
1180         }
1181 #ifndef LWS_NO_EXTENSIONS
1182         /*
1183          * inform all extensions, not just active ones since they
1184          * already know
1185          */
1186         ext = wsi->vhost->extensions;
1187
1188         while (ext && ext->callback) {
1189                 v = NULL;
1190                 for (n = 0; n < wsi->count_act_ext; n++)
1191                         if (wsi->active_extensions[n] == ext)
1192                                 v = wsi->act_ext_user[n];
1193
1194                 ext->callback(context, ext, wsi,
1195                           LWS_EXT_CB_ANY_WSI_ESTABLISHED, v, NULL, 0);
1196                 ext++;
1197         }
1198 #endif
1199
1200         return 0;
1201
1202 bail3:
1203         close_reason = LWS_CLOSE_STATUS_NOSTATUS;
1204
1205 bail2:
1206         if (wsi->protocol)
1207                 wsi->protocol->callback(wsi, LWS_CALLBACK_CLIENT_CONNECTION_ERROR,
1208                                 wsi->user_space, (void *)cce,
1209                                 (unsigned int)strlen(cce));
1210         wsi->already_did_cce = 1;
1211
1212         lwsl_info("closing connection due to bail2 connection error\n");
1213
1214         /* closing will free up his parsing allocations */
1215         lws_close_free_wsi(wsi, close_reason);
1216
1217         return 1;
1218 }
1219
1220
1221 char *
1222 lws_generate_client_handshake(struct lws *wsi, char *pkt)
1223 {
1224         char buf[128], hash[20], key_b64[40], *p = pkt;
1225         struct lws_context *context = wsi->context;
1226         const char *meth;
1227         int n;
1228 #ifndef LWS_NO_EXTENSIONS
1229         const struct lws_extension *ext;
1230         int ext_count = 0;
1231 #endif
1232         const char *pp = lws_hdr_simple_ptr(wsi,
1233                                 _WSI_TOKEN_CLIENT_SENT_PROTOCOLS);
1234
1235         meth = lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_METHOD);
1236         if (!meth) {
1237                 meth = "GET";
1238                 wsi->do_ws = 1;
1239         } else {
1240                 wsi->do_ws = 0;
1241         }
1242
1243         if (!strcmp(meth, "RAW")) {
1244                 lws_set_timeout(wsi, NO_PENDING_TIMEOUT, 0);
1245                 lwsl_notice("client transition to raw\n");
1246
1247                 if (pp) {
1248                         const struct lws_protocols *pr;
1249
1250                         pr = lws_vhost_name_to_protocol(wsi->vhost, pp);
1251
1252                         if (!pr) {
1253                                 lwsl_err("protocol %s not enabled on vhost\n",
1254                                          pp);
1255                                 return NULL;
1256                         }
1257
1258                         lws_bind_protocol(wsi, pr);
1259                 }
1260
1261                 if ((wsi->protocol->callback)(wsi,
1262                                 LWS_CALLBACK_RAW_ADOPT,
1263                                 wsi->user_space, NULL, 0))
1264                         return NULL;
1265
1266                 lws_header_table_force_to_detachable_state(wsi);
1267                 lws_union_transition(wsi, LWSCM_RAW);
1268                 lws_header_table_detach(wsi, 1);
1269
1270                 return NULL;
1271         }
1272
1273         if (wsi->do_ws) {
1274                 /*
1275                  * create the random key
1276                  */
1277                 n = lws_get_random(context, hash, 16);
1278                 if (n != 16) {
1279                         lwsl_err("Unable to read from random dev %s\n",
1280                                  SYSTEM_RANDOM_FILEPATH);
1281                         lws_close_free_wsi(wsi, LWS_CLOSE_STATUS_NOSTATUS);
1282                         return NULL;
1283                 }
1284
1285                 lws_b64_encode_string(hash, 16, key_b64, sizeof(key_b64));
1286         }
1287
1288         /*
1289          * 04 example client handshake
1290          *
1291          * GET /chat HTTP/1.1
1292          * Host: server.example.com
1293          * Upgrade: websocket
1294          * Connection: Upgrade
1295          * Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
1296          * Sec-WebSocket-Origin: http://example.com
1297          * Sec-WebSocket-Protocol: chat, superchat
1298          * Sec-WebSocket-Version: 4
1299          */
1300
1301         p += sprintf(p, "%s %s HTTP/1.1\x0d\x0a", meth,
1302                      lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_URI));
1303
1304         p += sprintf(p, "Pragma: no-cache\x0d\x0a"
1305                         "Cache-Control: no-cache\x0d\x0a");
1306
1307         p += sprintf(p, "Host: %s\x0d\x0a",
1308                      lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_HOST));
1309
1310         if (lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_ORIGIN)) {
1311                 if (lws_check_opt(context->options, LWS_SERVER_OPTION_JUST_USE_RAW_ORIGIN))
1312                         p += sprintf(p, "Origin: %s\x0d\x0a",
1313                                      lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_ORIGIN));
1314                 else
1315                         p += sprintf(p, "Origin: http://%s\x0d\x0a",
1316                                      lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_ORIGIN));
1317         }
1318
1319         if (wsi->do_ws) {
1320                 p += sprintf(p, "Upgrade: websocket\x0d\x0a"
1321                                 "Connection: Upgrade\x0d\x0a"
1322                                 "Sec-WebSocket-Key: ");
1323                 strcpy(p, key_b64);
1324                 p += strlen(key_b64);
1325                 p += sprintf(p, "\x0d\x0a");
1326                 if (lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_SENT_PROTOCOLS))
1327                         p += sprintf(p, "Sec-WebSocket-Protocol: %s\x0d\x0a",
1328                              lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_SENT_PROTOCOLS));
1329
1330                 /* tell the server what extensions we could support */
1331
1332 #ifndef LWS_NO_EXTENSIONS
1333                 ext = wsi->vhost->extensions;
1334                 while (ext && ext->callback) {
1335                         n = lws_ext_cb_all_exts(context, wsi,
1336                                    LWS_EXT_CB_CHECK_OK_TO_PROPOSE_EXTENSION,
1337                                    (char *)ext->name, 0);
1338                         if (n) { /* an extension vetos us */
1339                                 lwsl_ext("ext %s vetoed\n", (char *)ext->name);
1340                                 ext++;
1341                                 continue;
1342                         }
1343                         n = wsi->vhost->protocols[0].callback(wsi,
1344                                 LWS_CALLBACK_CLIENT_CONFIRM_EXTENSION_SUPPORTED,
1345                                         wsi->user_space, (char *)ext->name, 0);
1346
1347                         /*
1348                          * zero return from callback means
1349                          * go ahead and allow the extension,
1350                          * it's what we get if the callback is
1351                          * unhandled
1352                          */
1353
1354                         if (n) {
1355                                 ext++;
1356                                 continue;
1357                         }
1358
1359                         /* apply it */
1360
1361                         if (ext_count)
1362                                 *p++ = ',';
1363                         else
1364                                 p += sprintf(p, "Sec-WebSocket-Extensions: ");
1365                         p += sprintf(p, "%s", ext->client_offer);
1366                         ext_count++;
1367
1368                         ext++;
1369                 }
1370                 if (ext_count)
1371                         p += sprintf(p, "\x0d\x0a");
1372 #endif
1373
1374                 if (wsi->ietf_spec_revision)
1375                         p += sprintf(p, "Sec-WebSocket-Version: %d\x0d\x0a",
1376                                      wsi->ietf_spec_revision);
1377
1378                 /* prepare the expected server accept response */
1379
1380                 key_b64[39] = '\0'; /* enforce composed length below buf sizeof */
1381                 n = sprintf(buf, "%s258EAFA5-E914-47DA-95CA-C5AB0DC85B11", key_b64);
1382
1383                 lws_SHA1((unsigned char *)buf, n, (unsigned char *)hash);
1384
1385                 lws_b64_encode_string(hash, 20,
1386                                       wsi->u.hdr.ah->initial_handshake_hash_base64,
1387                                       sizeof(wsi->u.hdr.ah->initial_handshake_hash_base64));
1388         }
1389
1390         /* give userland a chance to append, eg, cookies */
1391
1392         wsi->protocol->callback(wsi, LWS_CALLBACK_CLIENT_APPEND_HANDSHAKE_HEADER,
1393                                 wsi->user_space, &p, (pkt + context->pt_serv_buf_size) - p - 12);
1394
1395         p += sprintf(p, "\x0d\x0a");
1396
1397         return p;
1398 }
1399