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.
5 #include "net/websockets/websocket_stream.h"
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 "base/time/time.h"
12 #include "base/timer/timer.h"
13 #include "net/base/load_flags.h"
14 #include "net/http/http_request_headers.h"
15 #include "net/http/http_response_headers.h"
16 #include "net/http/http_status_code.h"
17 #include "net/url_request/redirect_info.h"
18 #include "net/url_request/url_request.h"
19 #include "net/url_request/url_request_context.h"
20 #include "net/websockets/websocket_errors.h"
21 #include "net/websockets/websocket_event_interface.h"
22 #include "net/websockets/websocket_handshake_constants.h"
23 #include "net/websockets/websocket_handshake_stream_base.h"
24 #include "net/websockets/websocket_handshake_stream_create_helper.h"
25 #include "net/websockets/websocket_test_util.h"
27 #include "url/origin.h"
32 // The timeout duration of WebSocket handshake.
33 // It is defined as the same value as the TCP connection timeout value in
34 // net/socket/websocket_transport_client_socket_pool.cc to make it hard for
35 // JavaScript programs to recognize the timeout cause.
36 const int kHandshakeTimeoutIntervalInSeconds = 240;
38 class StreamRequestImpl;
40 class Delegate : public URLRequest::Delegate {
42 enum HandshakeResult {
46 NUM_HANDSHAKE_RESULT_TYPES,
49 explicit Delegate(StreamRequestImpl* owner)
50 : owner_(owner), result_(INCOMPLETE) {}
52 UMA_HISTOGRAM_ENUMERATION(
53 "Net.WebSocket.HandshakeResult", result_, NUM_HANDSHAKE_RESULT_TYPES);
56 // Implementation of URLRequest::Delegate methods.
57 virtual void OnReceivedRedirect(URLRequest* request,
58 const RedirectInfo& redirect_info,
59 bool* defer_redirect) OVERRIDE {
60 // HTTP status codes returned by HttpStreamParser are filtered by
61 // WebSocketBasicHandshakeStream, and only 101, 401 and 407 are permitted
62 // back up the stack to HttpNetworkTransaction. In particular, redirect
63 // codes are never allowed, and so URLRequest never sees a redirect on a
68 virtual void OnResponseStarted(URLRequest* request) OVERRIDE;
70 virtual void OnAuthRequired(URLRequest* request,
71 AuthChallengeInfo* auth_info) OVERRIDE;
73 virtual void OnCertificateRequested(URLRequest* request,
74 SSLCertRequestInfo* cert_request_info)
77 virtual void OnSSLCertificateError(URLRequest* request,
78 const SSLInfo& ssl_info,
81 virtual void OnReadCompleted(URLRequest* request, int bytes_read) OVERRIDE;
84 StreamRequestImpl* owner_;
85 HandshakeResult result_;
88 class StreamRequestImpl : public WebSocketStreamRequest {
92 const URLRequestContext* context,
93 const url::Origin& origin,
94 scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate,
95 scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper)
96 : delegate_(new Delegate(this)),
97 url_request_(context->CreateRequest(url, DEFAULT_PRIORITY,
98 delegate_.get(), NULL)),
99 connect_delegate_(connect_delegate.Pass()),
100 create_helper_(create_helper.release()) {
101 create_helper_->set_failure_message(&failure_message_);
102 HttpRequestHeaders headers;
103 headers.SetHeader(websockets::kUpgrade, websockets::kWebSocketLowercase);
104 headers.SetHeader(HttpRequestHeaders::kConnection, websockets::kUpgrade);
105 headers.SetHeader(HttpRequestHeaders::kOrigin, origin.string());
106 headers.SetHeader(websockets::kSecWebSocketVersion,
107 websockets::kSupportedVersion);
108 url_request_->SetExtraRequestHeaders(headers);
110 // This passes the ownership of |create_helper_| to |url_request_|.
111 url_request_->SetUserData(
112 WebSocketHandshakeStreamBase::CreateHelper::DataKey(),
114 url_request_->SetLoadFlags(LOAD_DISABLE_CACHE |
116 LOAD_DO_NOT_PROMPT_FOR_LOGIN);
119 // Destroying this object destroys the URLRequest, which cancels the request
120 // and so terminates the handshake if it is incomplete.
121 virtual ~StreamRequestImpl() {}
123 void Start(scoped_ptr<base::Timer> timer) {
125 TimeDelta timeout(TimeDelta::FromSeconds(
126 kHandshakeTimeoutIntervalInSeconds));
127 timer_ = timer.Pass();
128 timer_->Start(FROM_HERE, timeout,
129 base::Bind(&StreamRequestImpl::OnTimeout,
130 base::Unretained(this)));
131 url_request_->Start();
134 void PerformUpgrade() {
137 connect_delegate_->OnSuccess(create_helper_->Upgrade());
140 void ReportFailure() {
143 if (failure_message_.empty()) {
144 switch (url_request_->status().status()) {
145 case URLRequestStatus::SUCCESS:
146 case URLRequestStatus::IO_PENDING:
148 case URLRequestStatus::CANCELED:
149 if (url_request_->status().error() == ERR_TIMED_OUT)
150 failure_message_ = "WebSocket opening handshake timed out";
152 failure_message_ = "WebSocket opening handshake was canceled";
154 case URLRequestStatus::FAILED:
156 std::string("Error in connection establishment: ") +
157 ErrorToString(url_request_->status().error());
161 ReportFailureWithMessage(failure_message_);
164 void ReportFailureWithMessage(const std::string& failure_message) {
165 connect_delegate_->OnFailure(failure_message);
168 void OnFinishOpeningHandshake() {
169 WebSocketDispatchOnFinishOpeningHandshake(connect_delegate(),
171 url_request_->response_headers(),
172 url_request_->response_time());
175 WebSocketStream::ConnectDelegate* connect_delegate() const {
176 return connect_delegate_.get();
180 url_request_->CancelWithError(ERR_TIMED_OUT);
184 // |delegate_| needs to be declared before |url_request_| so that it gets
185 // initialised first.
186 scoped_ptr<Delegate> delegate_;
188 // Deleting the StreamRequestImpl object deletes this URLRequest object,
189 // cancelling the whole connection.
190 scoped_ptr<URLRequest> url_request_;
192 scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate_;
194 // Owned by the URLRequest.
195 WebSocketHandshakeStreamCreateHelper* create_helper_;
197 // The failure message supplied by WebSocketBasicHandshakeStream, if any.
198 std::string failure_message_;
200 // A timer for handshake timeout.
201 scoped_ptr<base::Timer> timer_;
204 class SSLErrorCallbacks : public WebSocketEventInterface::SSLErrorCallbacks {
206 explicit SSLErrorCallbacks(URLRequest* url_request)
207 : url_request_(url_request) {}
209 virtual void CancelSSLRequest(int error, const SSLInfo* ssl_info) OVERRIDE {
211 url_request_->CancelWithSSLError(error, *ssl_info);
213 url_request_->CancelWithError(error);
217 virtual void ContinueSSLRequest() OVERRIDE {
218 url_request_->ContinueDespiteLastError();
222 URLRequest* url_request_;
225 void Delegate::OnResponseStarted(URLRequest* request) {
226 // All error codes, including OK and ABORTED, as with
227 // Net.ErrorCodesForMainFrame3
228 UMA_HISTOGRAM_SPARSE_SLOWLY("Net.WebSocket.ErrorCodes",
229 -request->status().error());
230 if (!request->status().is_success()) {
231 DVLOG(3) << "OnResponseStarted (request failed)";
232 owner_->ReportFailure();
235 const int response_code = request->GetResponseCode();
236 DVLOG(3) << "OnResponseStarted (response code " << response_code << ")";
237 switch (response_code) {
238 case HTTP_SWITCHING_PROTOCOLS:
240 owner_->PerformUpgrade();
243 case HTTP_UNAUTHORIZED:
245 owner_->OnFinishOpeningHandshake();
246 owner_->ReportFailureWithMessage(
247 "HTTP Authentication failed; no valid credentials available");
250 case HTTP_PROXY_AUTHENTICATION_REQUIRED:
252 owner_->OnFinishOpeningHandshake();
253 owner_->ReportFailureWithMessage("Proxy authentication failed");
258 owner_->ReportFailure();
262 void Delegate::OnAuthRequired(URLRequest* request,
263 AuthChallengeInfo* auth_info) {
264 // This should only be called if credentials are not already stored.
265 request->CancelAuth();
268 void Delegate::OnCertificateRequested(URLRequest* request,
269 SSLCertRequestInfo* cert_request_info) {
270 // This method is called when a client certificate is requested, and the
271 // request context does not already contain a client certificate selection for
272 // the endpoint. In this case, a main frame resource request would pop-up UI
273 // to permit selection of a client certificate, but since WebSockets are
274 // sub-resources they should not pop-up UI and so there is nothing more we can
279 void Delegate::OnSSLCertificateError(URLRequest* request,
280 const SSLInfo& ssl_info,
282 owner_->connect_delegate()->OnSSLCertificateError(
283 scoped_ptr<WebSocketEventInterface::SSLErrorCallbacks>(
284 new SSLErrorCallbacks(request)),
289 void Delegate::OnReadCompleted(URLRequest* request, int bytes_read) {
295 WebSocketStreamRequest::~WebSocketStreamRequest() {}
297 WebSocketStream::WebSocketStream() {}
298 WebSocketStream::~WebSocketStream() {}
300 WebSocketStream::ConnectDelegate::~ConnectDelegate() {}
302 scoped_ptr<WebSocketStreamRequest> WebSocketStream::CreateAndConnectStream(
303 const GURL& socket_url,
304 const std::vector<std::string>& requested_subprotocols,
305 const url::Origin& origin,
306 URLRequestContext* url_request_context,
307 const BoundNetLog& net_log,
308 scoped_ptr<ConnectDelegate> connect_delegate) {
309 scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper(
310 new WebSocketHandshakeStreamCreateHelper(connect_delegate.get(),
311 requested_subprotocols));
312 scoped_ptr<StreamRequestImpl> request(
313 new StreamRequestImpl(socket_url,
316 connect_delegate.Pass(),
317 create_helper.Pass()));
318 request->Start(scoped_ptr<base::Timer>(new base::Timer(false, false)));
319 return request.PassAs<WebSocketStreamRequest>();
322 // This is declared in websocket_test_util.h.
323 scoped_ptr<WebSocketStreamRequest> CreateAndConnectStreamForTesting(
324 const GURL& socket_url,
325 scoped_ptr<WebSocketHandshakeStreamCreateHelper> create_helper,
326 const url::Origin& origin,
327 URLRequestContext* url_request_context,
328 const BoundNetLog& net_log,
329 scoped_ptr<WebSocketStream::ConnectDelegate> connect_delegate,
330 scoped_ptr<base::Timer> timer) {
331 scoped_ptr<StreamRequestImpl> request(
332 new StreamRequestImpl(socket_url,
335 connect_delegate.Pass(),
336 create_helper.Pass()));
337 request->Start(timer.Pass());
338 return request.PassAs<WebSocketStreamRequest>();
341 void WebSocketDispatchOnFinishOpeningHandshake(
342 WebSocketStream::ConnectDelegate* connect_delegate,
344 const scoped_refptr<HttpResponseHeaders>& headers,
345 base::Time response_time) {
346 DCHECK(connect_delegate);
348 connect_delegate->OnFinishOpeningHandshake(make_scoped_ptr(
349 new WebSocketHandshakeResponseInfo(url,
350 headers->response_code(),
351 headers->GetStatusText(),