net/websockets/websocket_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_stream.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/metrics/sparse_histogram.h"
  11 #include "net/base/load_flags.h"
  12 #include "net/http/http_request_headers.h"
  13 #include "net/http/http_status_code.h"
  14 #include "net/url_request/url_request.h"
  15 #include "net/url_request/url_request_context.h"
  16 #include "net/websockets/websocket_errors.h"
  17 #include "net/websockets/websocket_event_interface.h"
  18 #include "net/websockets/websocket_handshake_constants.h"
  19 #include "net/websockets/websocket_handshake_stream_base.h"
  20 #include "net/websockets/websocket_handshake_stream_create_helper.h"
  21 #include "net/websockets/websocket_test_util.h"
  22 #include "url/gurl.h"
  23 #include "url/origin.h"
  24
  25 namespace net {
  26 namespace {
  27
  28 class StreamRequestImpl;
  29
  30 class Delegate : public URLRequest::Delegate {
  31  public:
  32   enum HandshakeResult {
  33     INCOMPLETE,
  34     CONNECTED,
  35     FAILED,
  36     NUM_HANDSHAKE_RESULT_TYPES,
  37   };
  38
  39   explicit Delegate(StreamRequestImpl* owner)
  40       : owner_(owner), result_(INCOMPLETE) {}
  41   virtual ~Delegate() {
  42     UMA_HISTOGRAM_ENUMERATION(
  43         "Net.WebSocket.HandshakeResult", result_, NUM_HANDSHAKE_RESULT_TYPES);
  44   }
  45
  46   // Implementation of URLRequest::Delegate methods.
  47   virtual void OnReceivedRedirect(URLRequest* request,
  48                                   const GURL& new_url,
  49                                   bool* defer_redirect) OVERRIDE {
  50     // HTTP status codes returned by HttpStreamParser are filtered by
  51     // WebSocketBasicHandshakeStream, and only 101, 401 and 407 are permitted
  52     // back up the stack to HttpNetworkTransaction. In particular, redirect
  53     // codes are never allowed, and so URLRequest never sees a redirect on a
  54     // WebSocket request.
  55     NOTREACHED();
  56   }
  57
  58   virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
  59
  60   virtual void OnAuthRequired(URLRequest* request,
  61                               AuthChallengeInfo* auth_info) OVERRIDE;
  62
  63   virtual void OnCertificateRequested(URLRequest* request,
  64                                       SSLCertRequestInfo* cert_request_info)
  65       OVERRIDE;
  66
  67   virtual void OnSSLCertificateError(URLRequest* request,
  68                                      const SSLInfo& ssl_info,
  69                                      bool fatal) OVERRIDE;
  70
  71   virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE;
  72
  73  private:
  74   StreamRequestImpl* owner_;
  75   HandshakeResult result_;
  76 };
  77
  78 class StreamRequestImpl : public WebSocketStreamRequest {
  79  public:
  80   StreamRequestImpl(
  81       const GURL& url,
  82       const URLRequestContext* context,
  83       const url::Origin& origin,
  84       scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate,
  85       scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper)
  86       : delegate_(new Delegate(this)),
  87         url_request_(url, DEFAULT_PRIORITY, delegate_.get(), context),
  88         connect_delegate_(connect_delegate.Pass()),
  89         create_helper_(create_helper.release()) {
  90     create_helper_->set_failure_message(&failure_message_);
  91     HttpRequestHeaders headers;
  92     headers.SetHeader(websockets::kUpgrade, websockets::kWebSocketLowercase);
  93     headers.SetHeader(HttpRequestHeaders::kConnection, websockets::kUpgrade);
  94     headers.SetHeader(HttpRequestHeaders::kOrigin, origin.string());
  95     headers.SetHeader(websockets::kSecWebSocketVersion,
  96                       websockets::kSupportedVersion);
  97     url_request_.SetExtraRequestHeaders(headers);
  98
  99     // This passes the ownership of |create_helper_| to |url_request_|.
 100     url_request_.SetUserData(
 101         WebSocketHandshakeStreamBase::CreateHelper::DataKey(),
 102         create_helper_);
 103     url_request_.SetLoadFlags(LOAD_DISABLE_CACHE |
 104                               LOAD_BYPASS_CACHE |
 105                               LOAD_DO_NOT_PROMPT_FOR_LOGIN);
 106   }
 107
 108   // Destroying this object destroys the URLRequest, which cancels the request
 109   // and so terminates the handshake if it is incomplete.
 110   virtual ~StreamRequestImpl() {}
 111
 112   void Start() {
 113     url_request_.Start();
 114   }
 115
 116   void PerformUpgrade() {
 117     connect_delegate_->OnSuccess(create_helper_->Upgrade());
 118   }
 119
 120   void ReportFailure() {
 121     if (failure_message_.empty()) {
 122       switch (url_request_.status().status()) {
 123         case URLRequestStatus::SUCCESS:
 124         case URLRequestStatus::IO_PENDING:
 125           break;
 126         case URLRequestStatus::CANCELED:
 127           failure_message_ = "WebSocket opening handshake was canceled";
 128           break;
 129         case URLRequestStatus::FAILED:
 130           failure_message_ =
 131               std::string("Error in connection establishment: ") +
 132               ErrorToString(url_request_.status().error());
 133           break;
 134       }
 135     }
 136     connect_delegate_->OnFailure(failure_message_);
 137   }
 138
 139   WebSocketStream::ConnectDelegate* connect_delegate() const {
 140     return connect_delegate_.get();
 141   }
 142
 143  private:
 144   // |delegate_| needs to be declared before |url_request_| so that it gets
 145   // initialised first.
 146   scoped_ptr<Delegate> delegate_;
 147
 148   // Deleting the StreamRequestImpl object deletes this URLRequest object,
 149   // cancelling the whole connection.
 150   URLRequest url_request_;
 151
 152   scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate_;
 153
 154   // Owned by the URLRequest.
 155   WebSocketHandshakeStreamCreateHelper* create_helper_;
 156
 157   // The failure message supplied by WebSocketBasicHandshakeStream, if any.
 158   std::string failure_message_;
 159 };
 160
 161 class SSLErrorCallbacks : public WebSocketEventInterface::SSLErrorCallbacks {
 162  public:
 163   explicit SSLErrorCallbacks(URLRequest* url_request)
 164       : url_request_(url_request) {}
 165
 166   virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {
 167     if (ssl_info) {
 168       url_request_->CancelWithSSLError(error, *ssl_info);
 169     } else {
 170       url_request_->CancelWithError(error);
 171     }
 172   }
 173
 174   virtual void ContinueSSLRequest() OVERRIDE {
 175     url_request_->ContinueDespiteLastError();
 176   }
 177
 178  private:
 179   URLRequest* url_request_;
 180 };
 181
 182 void Delegate::OnResponseStarted(URLRequest* request) {
 183   // All error codes, including OK and ABORTED, as with
 184   // Net.ErrorCodesForMainFrame3
 185   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.WebSocket.ErrorCodes",
 186                               -request->status().error());
 187   if (!request->status().is_success()) {
 188     DVLOG(3) << "OnResponseStarted (request failed)";
 189     owner_->ReportFailure();
 190     return;
 191   }
 192   const int response_code = request->GetResponseCode();
 193   DVLOG(3) << "OnResponseStarted (response code " << response_code << ")";
 194   switch (response_code) {
 195     case HTTP_SWITCHING_PROTOCOLS:
 196       result_ = CONNECTED;
 197       owner_->PerformUpgrade();
 198       return;
 199
 200     case HTTP_UNAUTHORIZED:
 201     case HTTP_PROXY_AUTHENTICATION_REQUIRED:
 202       return;
 203
 204     default:
 205       result_ = FAILED;
 206       owner_->ReportFailure();
 207   }
 208 }
 209
 210 void Delegate::OnAuthRequired(URLRequest* request,
 211                               AuthChallengeInfo* auth_info) {
 212   // This should only be called if credentials are not already stored.
 213   request->CancelAuth();
 214 }
 215
 216 void Delegate::OnCertificateRequested(URLRequest* request,
 217                                       SSLCertRequestInfo* cert_request_info) {
 218   // This method is called when a client certificate is requested, and the
 219   // request context does not already contain a client certificate selection for
 220   // the endpoint. In this case, a main frame resource request would pop-up UI
 221   // to permit selection of a client certificate, but since WebSockets are
 222   // sub-resources they should not pop-up UI and so there is nothing more we can
 223   // do.
 224   request->Cancel();
 225 }
 226
 227 void Delegate::OnSSLCertificateError(URLRequest* request,
 228                                      const SSLInfo& ssl_info,
 229                                      bool fatal) {
 230   owner_->connect_delegate()->OnSSLCertificateError(
 231       scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>(
 232           new SSLErrorCallbacks(request)),
 233       ssl_info,
 234       fatal);
 235 }
 236
 237 void Delegate::OnReadCompleted(URLRequest* request, int bytes_read) {
 238   NOTREACHED();
 239 }
 240
 241 }  // namespace
 242
 243 WebSocketStreamRequest::~WebSocketStreamRequest() {}
 244
 245 WebSocketStream::WebSocketStream() {}
 246 WebSocketStream::~WebSocketStream() {}
 247
 248 WebSocketStream::ConnectDelegate::~ConnectDelegate() {}
 249
 250 scoped_ptr<WebSocketStreamRequest> WebSocketStream::CreateAndConnectStream(
 251     const GURL& socket_url,
 252     const std::vector<std::string>& requested_subprotocols,
 253     const url::Origin& origin,
 254     URLRequestContext* url_request_context,
 255     const BoundNetLog& net_log,
 256     scoped_ptr<ConnectDelegate> connect_delegate) {
 257   scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper(
 258       new WebSocketHandshakeStreamCreateHelper(connect_delegate.get(),
 259                                                requested_subprotocols));
 260   scoped_ptr<StreamRequestImpl> request(
 261       new StreamRequestImpl(socket_url,
 262                             url_request_context,
 263                             origin,
 264                             connect_delegate.Pass(),
 265                             create_helper.Pass()));
 266   request->Start();
 267   return request.PassAs<WebSocketStreamRequest>();
 268 }
 269
 270 // This is declared in websocket_test_util.h.
 271 scoped_ptr<WebSocketStreamRequest> CreateAndConnectStreamForTesting(
 272     const GURL& socket_url,
 273     scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper,
 274     const url::Origin& origin,
 275     URLRequestContext* url_request_context,
 276     const BoundNetLog& net_log,
 277     scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate) {
 278   scoped_ptr<StreamRequestImpl> request(
 279       new StreamRequestImpl(socket_url,
 280                             url_request_context,
 281                             origin,
 282                             connect_delegate.Pass(),
 283                             create_helper.Pass()));
 284   request->Start();
 285   return request.PassAs<WebSocketStreamRequest>();
 286 }
 287
 288 }  // namespace net