src/net/websockets/websocket_basic_handshake_stream.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/websockets/websocket_basic_handshake_stream.h"
   6
   7 #include <algorithm>
   8 #include <iterator>
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/base64.h"
  14 #include "base/basictypes.h"
  15 #include "base/bind.h"
  16 #include "base/compiler_specific.h"
  17 #include "base/containers/hash_tables.h"
  18 #include "base/logging.h"
  19 #include "base/metrics/histogram.h"
  20 #include "base/metrics/sparse_histogram.h"
  21 #include "base/stl_util.h"
  22 #include "base/strings/string_number_conversions.h"
  23 #include "base/strings/string_piece.h"
  24 #include "base/strings/string_util.h"
  25 #include "base/strings/stringprintf.h"
  26 #include "base/time/time.h"
  27 #include "crypto/random.h"
  28 #include "net/http/http_request_headers.h"
  29 #include "net/http/http_request_info.h"
  30 #include "net/http/http_response_body_drainer.h"
  31 #include "net/http/http_response_headers.h"
  32 #include "net/http/http_status_code.h"
  33 #include "net/http/http_stream_parser.h"
  34 #include "net/socket/client_socket_handle.h"
  35 #include "net/socket/websocket_transport_client_socket_pool.h"
  36 #include "net/websockets/websocket_basic_stream.h"
  37 #include "net/websockets/websocket_deflate_predictor.h"
  38 #include "net/websockets/websocket_deflate_predictor_impl.h"
  39 #include "net/websockets/websocket_deflate_stream.h"
  40 #include "net/websockets/websocket_deflater.h"
  41 #include "net/websockets/websocket_extension_parser.h"
  42 #include "net/websockets/websocket_handshake_constants.h"
  43 #include "net/websockets/websocket_handshake_handler.h"
  44 #include "net/websockets/websocket_handshake_request_info.h"
  45 #include "net/websockets/websocket_handshake_response_info.h"
  46 #include "net/websockets/websocket_stream.h"
  47
  48 namespace net {
  49
  50 namespace {
  51
  52 // TODO(yhirano): Remove these functions once http://crbug.com/399535 is fixed.
  53 NOINLINE void RunCallbackWithOk(const CompletionCallback& callback,
  54                                 int result) {
  55   DCHECK_EQ(result, OK);
  56   callback.Run(OK);
  57 }
  58
  59 NOINLINE void RunCallbackWithInvalidResponseCausedByRedirect(
  60     const CompletionCallback& callback,
  61     int result) {
  62   DCHECK_EQ(result, ERR_INVALID_RESPONSE);
  63   callback.Run(ERR_INVALID_RESPONSE);
  64 }
  65
  66 NOINLINE void RunCallbackWithInvalidResponse(
  67     const CompletionCallback& callback,
  68     int result) {
  69   DCHECK_EQ(result, ERR_INVALID_RESPONSE);
  70   callback.Run(ERR_INVALID_RESPONSE);
  71 }
  72
  73 NOINLINE void RunCallback(const CompletionCallback& callback, int result) {
  74   callback.Run(result);
  75 }
  76
  77 }  // namespace
  78
  79 // TODO(ricea): If more extensions are added, replace this with a more general
  80 // mechanism.
  81 struct WebSocketExtensionParams {
  82   WebSocketExtensionParams()
  83       : deflate_enabled(false),
  84         client_window_bits(15),
  85         deflate_mode(WebSocketDeflater::TAKE_OVER_CONTEXT) {}
  86
  87   bool deflate_enabled;
  88   int client_window_bits;
  89   WebSocketDeflater::ContextTakeOverMode deflate_mode;
  90 };
  91
  92 namespace {
  93
  94 enum GetHeaderResult {
  95   GET_HEADER_OK,
  96   GET_HEADER_MISSING,
  97   GET_HEADER_MULTIPLE,
  98 };
  99
 100 std::string MissingHeaderMessage(const std::string& header_name) {
 101   return std::string("'") + header_name + "' header is missing";
 102 }
 103
 104 std::string MultipleHeaderValuesMessage(const std::string& header_name) {
 105   return
 106       std::string("'") +
 107       header_name +
 108       "' header must not appear more than once in a response";
 109 }
 110
 111 std::string GenerateHandshakeChallenge() {
 112   std::string raw_challenge(websockets::kRawChallengeLength, '\0');
 113   crypto::RandBytes(string_as_array(&raw_challenge), raw_challenge.length());
 114   std::string encoded_challenge;
 115   base::Base64Encode(raw_challenge, &encoded_challenge);
 116   return encoded_challenge;
 117 }
 118
 119 void AddVectorHeaderIfNonEmpty(const char* name,
 120                                const std::vector<std::string>& value,
 121                                HttpRequestHeaders* headers) {
 122   if (value.empty())
 123     return;
 124   headers->SetHeader(name, JoinString(value, ", "));
 125 }
 126
 127 GetHeaderResult GetSingleHeaderValue(const HttpResponseHeaders* headers,
 128                                      const base::StringPiece& name,
 129                                      std::string* value) {
 130   void* state = nullptr;
 131   size_t num_values = 0;
 132   std::string temp_value;
 133   while (headers->EnumerateHeader(&state, name, &temp_value)) {
 134     if (++num_values > 1)
 135       return GET_HEADER_MULTIPLE;
 136     *value = temp_value;
 137   }
 138   return num_values > 0 ? GET_HEADER_OK : GET_HEADER_MISSING;
 139 }
 140
 141 bool ValidateHeaderHasSingleValue(GetHeaderResult result,
 142                                   const std::string& header_name,
 143                                   std::string* failure_message) {
 144   if (result == GET_HEADER_MISSING) {
 145     *failure_message = MissingHeaderMessage(header_name);
 146     return false;
 147   }
 148   if (result == GET_HEADER_MULTIPLE) {
 149     *failure_message = MultipleHeaderValuesMessage(header_name);
 150     return false;
 151   }
 152   DCHECK_EQ(result, GET_HEADER_OK);
 153   return true;
 154 }
 155
 156 bool ValidateUpgrade(const HttpResponseHeaders* headers,
 157                      std::string* failure_message) {
 158   std::string value;
 159   GetHeaderResult result =
 160       GetSingleHeaderValue(headers, websockets::kUpgrade, &value);
 161   if (!ValidateHeaderHasSingleValue(result,
 162                                     websockets::kUpgrade,
 163                                     failure_message)) {
 164     return false;
 165   }
 166
 167   if (!LowerCaseEqualsASCII(value, websockets::kWebSocketLowercase)) {
 168     *failure_message =
 169         "'Upgrade' header value is not 'WebSocket': " + value;
 170     return false;
 171   }
 172   return true;
 173 }
 174
 175 bool ValidateSecWebSocketAccept(const HttpResponseHeaders* headers,
 176                                 const std::string& expected,
 177                                 std::string* failure_message) {
 178   std::string actual;
 179   GetHeaderResult result =
 180       GetSingleHeaderValue(headers, websockets::kSecWebSocketAccept, &actual);
 181   if (!ValidateHeaderHasSingleValue(result,
 182                                     websockets::kSecWebSocketAccept,
 183                                     failure_message)) {
 184     return false;
 185   }
 186
 187   if (expected != actual) {
 188     *failure_message = "Incorrect 'Sec-WebSocket-Accept' header value";
 189     return false;
 190   }
 191   return true;
 192 }
 193
 194 bool ValidateConnection(const HttpResponseHeaders* headers,
 195                         std::string* failure_message) {
 196   // Connection header is permitted to contain other tokens.
 197   if (!headers->HasHeader(HttpRequestHeaders::kConnection)) {
 198     *failure_message = MissingHeaderMessage(HttpRequestHeaders::kConnection);
 199     return false;
 200   }
 201   if (!headers->HasHeaderValue(HttpRequestHeaders::kConnection,
 202                                websockets::kUpgrade)) {
 203     *failure_message = "'Connection' header value must contain 'Upgrade'";
 204     return false;
 205   }
 206   return true;
 207 }
 208
 209 bool ValidateSubProtocol(
 210     const HttpResponseHeaders* headers,
 211     const std::vector<std::string>& requested_sub_protocols,
 212     std::string* sub_protocol,
 213     std::string* failure_message) {
 214   void* state = nullptr;
 215   std::string value;
 216   base::hash_set<std::string> requested_set(requested_sub_protocols.begin(),
 217                                             requested_sub_protocols.end());
 218   int count = 0;
 219   bool has_multiple_protocols = false;
 220   bool has_invalid_protocol = false;
 221
 222   while (!has_invalid_protocol || !has_multiple_protocols) {
 223     std::string temp_value;
 224     if (!headers->EnumerateHeader(
 225             &state, websockets::kSecWebSocketProtocol, &temp_value))
 226       break;
 227     value = temp_value;
 228     if (requested_set.count(value) == 0)
 229       has_invalid_protocol = true;
 230     if (++count > 1)
 231       has_multiple_protocols = true;
 232   }
 233
 234   if (has_multiple_protocols) {
 235     *failure_message =
 236         MultipleHeaderValuesMessage(websockets::kSecWebSocketProtocol);
 237     return false;
 238   } else if (count > 0 && requested_sub_protocols.size() == 0) {
 239     *failure_message =
 240         std::string("Response must not include 'Sec-WebSocket-Protocol' "
 241                     "header if not present in request: ")
 242         + value;
 243     return false;
 244   } else if (has_invalid_protocol) {
 245     *failure_message =
 246         "'Sec-WebSocket-Protocol' header value '" +
 247         value +
 248         "' in response does not match any of sent values";
 249     return false;
 250   } else if (requested_sub_protocols.size() > 0 && count == 0) {
 251     *failure_message =
 252         "Sent non-empty 'Sec-WebSocket-Protocol' header "
 253         "but no response was received";
 254     return false;
 255   }
 256   *sub_protocol = value;
 257   return true;
 258 }
 259
 260 bool DeflateError(std::string* message, const base::StringPiece& piece) {
 261   *message = "Error in permessage-deflate: ";
 262   piece.AppendToString(message);
 263   return false;
 264 }
 265
 266 bool ValidatePerMessageDeflateExtension(const WebSocketExtension& extension,
 267                                         std::string* failure_message,
 268                                         WebSocketExtensionParams* params) {
 269   static const char kClientPrefix[] = "client_";
 270   static const char kServerPrefix[] = "server_";
 271   static const char kNoContextTakeover[] = "no_context_takeover";
 272   static const char kMaxWindowBits[] = "max_window_bits";
 273   const size_t kPrefixLen = arraysize(kClientPrefix) - 1;
 274   COMPILE_ASSERT(kPrefixLen == arraysize(kServerPrefix) - 1,
 275                  the_strings_server_and_client_must_be_the_same_length);
 276   typedef std::vector<WebSocketExtension::Parameter> ParameterVector;
 277
 278   DCHECK_EQ("permessage-deflate", extension.name());
 279   const ParameterVector& parameters = extension.parameters();
 280   std::set<std::string> seen_names;
 281   for (ParameterVector::const_iterator it = parameters.begin();
 282        it != parameters.end(); ++it) {
 283     const std::string& name = it->name();
 284     if (seen_names.count(name) != 0) {
 285       return DeflateError(
 286           failure_message,
 287           "Received duplicate permessage-deflate extension parameter " + name);
 288     }
 289     seen_names.insert(name);
 290     const std::string client_or_server(name, 0, kPrefixLen);
 291     const bool is_client = (client_or_server == kClientPrefix);
 292     if (!is_client && client_or_server != kServerPrefix) {
 293       return DeflateError(
 294           failure_message,
 295           "Received an unexpected permessage-deflate extension parameter");
 296     }
 297     const std::string rest(name, kPrefixLen);
 298     if (rest == kNoContextTakeover) {
 299       if (it->HasValue()) {
 300         return DeflateError(failure_message,
 301                             "Received invalid " + name + " parameter");
 302       }
 303       if (is_client)
 304         params->deflate_mode = WebSocketDeflater::DO_NOT_TAKE_OVER_CONTEXT;
 305     } else if (rest == kMaxWindowBits) {
 306       if (!it->HasValue())
 307         return DeflateError(failure_message, name + " must have value");
 308       int bits = 0;
 309       if (!base::StringToInt(it->value(), &bits) || bits < 8 || bits > 15 ||
 310           it->value()[0] == '0' ||
 311           it->value().find_first_not_of("0123456789") != std::string::npos) {
 312         return DeflateError(failure_message,
 313                             "Received invalid " + name + " parameter");
 314       }
 315       if (is_client)
 316         params->client_window_bits = bits;
 317     } else {
 318       return DeflateError(
 319           failure_message,
 320           "Received an unexpected permessage-deflate extension parameter");
 321     }
 322   }
 323   params->deflate_enabled = true;
 324   return true;
 325 }
 326
 327 bool ValidateExtensions(const HttpResponseHeaders* headers,
 328                         const std::vector<std::string>& requested_extensions,
 329                         std::string* extensions,
 330                         std::string* failure_message,
 331                         WebSocketExtensionParams* params) {
 332   void* state = nullptr;
 333   std::string value;
 334   std::vector<std::string> accepted_extensions;
 335   // TODO(ricea): If adding support for additional extensions, generalise this
 336   // code.
 337   bool seen_permessage_deflate = false;
 338   while (headers->EnumerateHeader(
 339              &state, websockets::kSecWebSocketExtensions, &value)) {
 340     WebSocketExtensionParser parser;
 341     parser.Parse(value);
 342     if (parser.has_error()) {
 343       // TODO(yhirano) Set appropriate failure message.
 344       *failure_message =
 345           "'Sec-WebSocket-Extensions' header value is "
 346           "rejected by the parser: " +
 347           value;
 348       return false;
 349     }
 350     if (parser.extension().name() == "permessage-deflate") {
 351       if (seen_permessage_deflate) {
 352         *failure_message = "Received duplicate permessage-deflate response";
 353         return false;
 354       }
 355       seen_permessage_deflate = true;
 356       if (!ValidatePerMessageDeflateExtension(
 357               parser.extension(), failure_message, params))
 358         return false;
 359     } else {
 360       *failure_message =
 361           "Found an unsupported extension '" +
 362           parser.extension().name() +
 363           "' in 'Sec-WebSocket-Extensions' header";
 364       return false;
 365     }
 366     accepted_extensions.push_back(value);
 367   }
 368   *extensions = JoinString(accepted_extensions, ", ");
 369   return true;
 370 }
 371
 372 }  // namespace
 373
 374 WebSocketBasicHandshakeStream::WebSocketBasicHandshakeStream(
 375     scoped_ptr<ClientSocketHandle> connection,
 376     WebSocketStream::ConnectDelegate* connect_delegate,
 377     bool using_proxy,
 378     std::vector<std::string> requested_sub_protocols,
 379     std::vector<std::string> requested_extensions,
 380     std::string* failure_message)
 381     : state_(connection.release(), using_proxy),
 382       connect_delegate_(connect_delegate),
 383       http_response_info_(nullptr),
 384       requested_sub_protocols_(requested_sub_protocols),
 385       requested_extensions_(requested_extensions),
 386       failure_message_(failure_message) {
 387   DCHECK(connect_delegate);
 388   DCHECK(failure_message);
 389 }
 390
 391 WebSocketBasicHandshakeStream::~WebSocketBasicHandshakeStream() {}
 392
 393 int WebSocketBasicHandshakeStream::InitializeStream(
 394     const HttpRequestInfo* request_info,
 395     RequestPriority priority,
 396     const BoundNetLog& net_log,
 397     const CompletionCallback& callback) {
 398   url_ = request_info->url;
 399   state_.Initialize(request_info, priority, net_log, callback);
 400   return OK;
 401 }
 402
 403 int WebSocketBasicHandshakeStream::SendRequest(
 404     const HttpRequestHeaders& headers,
 405     HttpResponseInfo* response,
 406     const CompletionCallback& callback) {
 407   DCHECK(!headers.HasHeader(websockets::kSecWebSocketKey));
 408   DCHECK(!headers.HasHeader(websockets::kSecWebSocketProtocol));
 409   DCHECK(!headers.HasHeader(websockets::kSecWebSocketExtensions));
 410   DCHECK(headers.HasHeader(HttpRequestHeaders::kOrigin));
 411   DCHECK(headers.HasHeader(websockets::kUpgrade));
 412   DCHECK(headers.HasHeader(HttpRequestHeaders::kConnection));
 413   DCHECK(headers.HasHeader(websockets::kSecWebSocketVersion));
 414   DCHECK(parser());
 415
 416   http_response_info_ = response;
 417
 418   // Create a copy of the headers object, so that we can add the
 419   // Sec-WebSockey-Key header.
 420   HttpRequestHeaders enriched_headers;
 421   enriched_headers.CopyFrom(headers);
 422   std::string handshake_challenge;
 423   if (handshake_challenge_for_testing_) {
 424     handshake_challenge = *handshake_challenge_for_testing_;
 425     handshake_challenge_for_testing_.reset();
 426   } else {
 427     handshake_challenge = GenerateHandshakeChallenge();
 428   }
 429   enriched_headers.SetHeader(websockets::kSecWebSocketKey, handshake_challenge);
 430
 431   AddVectorHeaderIfNonEmpty(websockets::kSecWebSocketExtensions,
 432                             requested_extensions_,
 433                             &enriched_headers);
 434   AddVectorHeaderIfNonEmpty(websockets::kSecWebSocketProtocol,
 435                             requested_sub_protocols_,
 436                             &enriched_headers);
 437
 438   ComputeSecWebSocketAccept(handshake_challenge,
 439                             &handshake_challenge_response_);
 440
 441   DCHECK(connect_delegate_);
 442   scoped_ptr<WebSocketHandshakeRequestInfo> request(
 443       new WebSocketHandshakeRequestInfo(url_, base::Time::Now()));
 444   request->headers.CopyFrom(enriched_headers);
 445   connect_delegate_->OnStartOpeningHandshake(request.Pass());
 446
 447   return parser()->SendRequest(
 448       state_.GenerateRequestLine(), enriched_headers, response, callback);
 449 }
 450
 451 int WebSocketBasicHandshakeStream::ReadResponseHeaders(
 452     const CompletionCallback& callback) {
 453   // HttpStreamParser uses a weak pointer when reading from the
 454   // socket, so it won't be called back after being destroyed. The
 455   // HttpStreamParser is owned by HttpBasicState which is owned by this object,
 456   // so this use of base::Unretained() is safe.
 457   int rv = parser()->ReadResponseHeaders(
 458       base::Bind(&WebSocketBasicHandshakeStream::ReadResponseHeadersCallback,
 459                  base::Unretained(this),
 460                  callback));
 461   if (rv == ERR_IO_PENDING)
 462     return rv;
 463   bool is_redirect = false;
 464   return ValidateResponse(rv, &is_redirect);
 465 }
 466
 467 int WebSocketBasicHandshakeStream::ReadResponseBody(
 468     IOBuffer* buf,
 469     int buf_len,
 470     const CompletionCallback& callback) {
 471   return parser()->ReadResponseBody(buf, buf_len, callback);
 472 }
 473
 474 void WebSocketBasicHandshakeStream::Close(bool not_reusable) {
 475   // This class ignores the value of |not_reusable| and never lets the socket be
 476   // re-used.
 477   if (parser())
 478     parser()->Close(true);
 479 }
 480
 481 bool WebSocketBasicHandshakeStream::IsResponseBodyComplete() const {
 482   return parser()->IsResponseBodyComplete();
 483 }
 484
 485 bool WebSocketBasicHandshakeStream::CanFindEndOfResponse() const {
 486   return parser() && parser()->CanFindEndOfResponse();
 487 }
 488
 489 bool WebSocketBasicHandshakeStream::IsConnectionReused() const {
 490   return parser()->IsConnectionReused();
 491 }
 492
 493 void WebSocketBasicHandshakeStream::SetConnectionReused() {
 494   parser()->SetConnectionReused();
 495 }
 496
 497 bool WebSocketBasicHandshakeStream::IsConnectionReusable() const {
 498   return false;
 499 }
 500
 501 int64 WebSocketBasicHandshakeStream::GetTotalReceivedBytes() const {
 502   return 0;
 503 }
 504
 505 bool WebSocketBasicHandshakeStream::GetLoadTimingInfo(
 506     LoadTimingInfo* load_timing_info) const {
 507   return state_.connection()->GetLoadTimingInfo(IsConnectionReused(),
 508                                                 load_timing_info);
 509 }
 510
 511 void WebSocketBasicHandshakeStream::GetSSLInfo(SSLInfo* ssl_info) {
 512   parser()->GetSSLInfo(ssl_info);
 513 }
 514
 515 void WebSocketBasicHandshakeStream::GetSSLCertRequestInfo(
 516     SSLCertRequestInfo* cert_request_info) {
 517   parser()->GetSSLCertRequestInfo(cert_request_info);
 518 }
 519
 520 bool WebSocketBasicHandshakeStream::IsSpdyHttpStream() const { return false; }
 521
 522 void WebSocketBasicHandshakeStream::Drain(HttpNetworkSession* session) {
 523   HttpResponseBodyDrainer* drainer = new HttpResponseBodyDrainer(this);
 524   drainer->Start(session);
 525   // |drainer| will delete itself.
 526 }
 527
 528 void WebSocketBasicHandshakeStream::SetPriority(RequestPriority priority) {
 529   // TODO(ricea): See TODO comment in HttpBasicStream::SetPriority(). If it is
 530   // gone, then copy whatever has happened there over here.
 531 }
 532
 533 UploadProgress WebSocketBasicHandshakeStream::GetUploadProgress() const {
 534   return UploadProgress();
 535 }
 536
 537 HttpStream* WebSocketBasicHandshakeStream::RenewStreamForAuth() {
 538   // Return null because we don't support renewing the stream.
 539   return nullptr;
 540 }
 541
 542 scoped_ptr<WebSocketStream> WebSocketBasicHandshakeStream::Upgrade() {
 543   // The HttpStreamParser object has a pointer to our ClientSocketHandle. Make
 544   // sure it does not touch it again before it is destroyed.
 545   state_.DeleteParser();
 546   WebSocketTransportClientSocketPool::UnlockEndpoint(state_.connection());
 547   scoped_ptr<WebSocketStream> basic_stream(
 548       new WebSocketBasicStream(state_.ReleaseConnection(),
 549                                state_.read_buf(),
 550                                sub_protocol_,
 551                                extensions_));
 552   DCHECK(extension_params_.get());
 553   if (extension_params_->deflate_enabled) {
 554     UMA_HISTOGRAM_ENUMERATION(
 555         "Net.WebSocket.DeflateMode",
 556         extension_params_->deflate_mode,
 557         WebSocketDeflater::NUM_CONTEXT_TAKEOVER_MODE_TYPES);
 558
 559     return scoped_ptr<WebSocketStream>(
 560         new WebSocketDeflateStream(basic_stream.Pass(),
 561                                    extension_params_->deflate_mode,
 562                                    extension_params_->client_window_bits,
 563                                    scoped_ptr<WebSocketDeflatePredictor>(
 564                                        new WebSocketDeflatePredictorImpl)));
 565   } else {
 566     return basic_stream.Pass();
 567   }
 568 }
 569
 570 void WebSocketBasicHandshakeStream::SetWebSocketKeyForTesting(
 571     const std::string& key) {
 572   handshake_challenge_for_testing_.reset(new std::string(key));
 573 }
 574
 575 void WebSocketBasicHandshakeStream::ReadResponseHeadersCallback(
 576     const CompletionCallback& callback,
 577     int result) {
 578   bool is_redirect = false;
 579   int rv = ValidateResponse(result, &is_redirect);
 580
 581   // TODO(yhirano): Simplify this statement once http://crbug.com/399535 is
 582   // fixed.
 583   switch (rv) {
 584     case OK:
 585       RunCallbackWithOk(callback, rv);
 586       break;
 587     case ERR_INVALID_RESPONSE:
 588       if (is_redirect)
 589         RunCallbackWithInvalidResponseCausedByRedirect(callback, rv);
 590       else
 591         RunCallbackWithInvalidResponse(callback, rv);
 592       break;
 593     default:
 594       RunCallback(callback, rv);
 595       break;
 596   }
 597 }
 598
 599 void WebSocketBasicHandshakeStream::OnFinishOpeningHandshake() {
 600   DCHECK(http_response_info_);
 601   WebSocketDispatchOnFinishOpeningHandshake(connect_delegate_,
 602                                             url_,
 603                                             http_response_info_->headers,
 604                                             http_response_info_->response_time);
 605 }
 606
 607 int WebSocketBasicHandshakeStream::ValidateResponse(int rv,
 608                                                     bool* is_redirect) {
 609   DCHECK(http_response_info_);
 610   *is_redirect = false;
 611   // Most net errors happen during connection, so they are not seen by this
 612   // method. The histogram for error codes is created in
 613   // Delegate::OnResponseStarted in websocket_stream.cc instead.
 614   if (rv >= 0) {
 615     const HttpResponseHeaders* headers = http_response_info_->headers.get();
 616     const int response_code = headers->response_code();
 617     *is_redirect = HttpResponseHeaders::IsRedirectResponseCode(response_code);
 618     UMA_HISTOGRAM_SPARSE_SLOWLY("Net.WebSocket.ResponseCode", response_code);
 619     switch (response_code) {
 620       case HTTP_SWITCHING_PROTOCOLS:
 621         OnFinishOpeningHandshake();
 622         return ValidateUpgradeResponse(headers);
 623
 624       // We need to pass these through for authentication to work.
 625       case HTTP_UNAUTHORIZED:
 626       case HTTP_PROXY_AUTHENTICATION_REQUIRED:
 627         return OK;
 628
 629       // Other status codes are potentially risky (see the warnings in the
 630       // WHATWG WebSocket API spec) and so are dropped by default.
 631       default:
 632         // A WebSocket server cannot be using HTTP/0.9, so if we see version
 633         // 0.9, it means the response was garbage.
 634         // Reporting "Unexpected response code: 200" in this case is not
 635         // helpful, so use a different error message.
 636         if (headers->GetHttpVersion() == HttpVersion(0, 9)) {
 637           set_failure_message(
 638               "Error during WebSocket handshake: Invalid status line");
 639         } else {
 640           set_failure_message(base::StringPrintf(
 641               "Error during WebSocket handshake: Unexpected response code: %d",
 642               headers->response_code()));
 643         }
 644         OnFinishOpeningHandshake();
 645         return ERR_INVALID_RESPONSE;
 646     }
 647   } else {
 648     if (rv == ERR_EMPTY_RESPONSE) {
 649       set_failure_message(
 650           "Connection closed before receiving a handshake response");
 651       return rv;
 652     }
 653     set_failure_message(std::string("Error during WebSocket handshake: ") +
 654                         ErrorToString(rv));
 655     OnFinishOpeningHandshake();
 656     return rv;
 657   }
 658 }
 659
 660 int WebSocketBasicHandshakeStream::ValidateUpgradeResponse(
 661     const HttpResponseHeaders* headers) {
 662   extension_params_.reset(new WebSocketExtensionParams);
 663   std::string failure_message;
 664   if (ValidateUpgrade(headers, &failure_message) &&
 665       ValidateSecWebSocketAccept(
 666           headers, handshake_challenge_response_, &failure_message) &&
 667       ValidateConnection(headers, &failure_message) &&
 668       ValidateSubProtocol(headers,
 669                           requested_sub_protocols_,
 670                           &sub_protocol_,
 671                           &failure_message) &&
 672       ValidateExtensions(headers,
 673                          requested_extensions_,
 674                          &extensions_,
 675                          &failure_message,
 676                          extension_params_.get())) {
 677     return OK;
 678   }
 679   set_failure_message("Error during WebSocket handshake: " + failure_message);
 680   return ERR_INVALID_RESPONSE;
 681 }
 682
 683 void WebSocketBasicHandshakeStream::set_failure_message(
 684     const std::string& failure_message) {
 685   *failure_message_ = failure_message;
 686 }
 687
 688 }  // namespace net