| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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 // TODO(ukai): code is similar with http_network_transaction.cc. We should | |
| 6 // think about ways to share code, if possible. | |
| 7 | |
| 8 #include "net/socket_stream/socket_stream.h" | |
| 9 | |
| 10 #include <set> | |
| 11 #include <string> | |
| 12 #include <vector> | |
| 13 | |
| 14 #include "base/bind.h" | |
| 15 #include "base/bind_helpers.h" | |
| 16 #include "base/compiler_specific.h" | |
| 17 #include "base/logging.h" | |
| 18 #include "base/message_loop/message_loop.h" | |
| 19 #include "base/strings/string_util.h" | |
| 20 #include "base/strings/stringprintf.h" | |
| 21 #include "base/strings/utf_string_conversions.h" | |
| 22 #include "net/base/auth.h" | |
| 23 #include "net/base/io_buffer.h" | |
| 24 #include "net/base/load_flags.h" | |
| 25 #include "net/base/net_errors.h" | |
| 26 #include "net/base/net_util.h" | |
| 27 #include "net/dns/host_resolver.h" | |
| 28 #include "net/http/http_auth_controller.h" | |
| 29 #include "net/http/http_network_session.h" | |
| 30 #include "net/http/http_request_headers.h" | |
| 31 #include "net/http/http_request_info.h" | |
| 32 #include "net/http/http_response_headers.h" | |
| 33 #include "net/http/http_stream_factory.h" | |
| 34 #include "net/http/http_transaction_factory.h" | |
| 35 #include "net/http/http_util.h" | |
| 36 #include "net/socket/client_socket_factory.h" | |
| 37 #include "net/socket/client_socket_handle.h" | |
| 38 #include "net/socket/socks5_client_socket.h" | |
| 39 #include "net/socket/socks_client_socket.h" | |
| 40 #include "net/socket/ssl_client_socket.h" | |
| 41 #include "net/socket/tcp_client_socket.h" | |
| 42 #include "net/socket_stream/socket_stream_metrics.h" | |
| 43 #include "net/ssl/ssl_cert_request_info.h" | |
| 44 #include "net/ssl/ssl_info.h" | |
| 45 #include "net/url_request/url_request.h" | |
| 46 #include "net/url_request/url_request_context.h" | |
| 47 | |
| 48 static const int kMaxPendingSendAllowed = 32768; // 32 kilobytes. | |
| 49 static const int kReadBufferSize = 4096; | |
| 50 | |
| 51 namespace net { | |
| 52 | |
| 53 int SocketStream::Delegate::OnStartOpenConnection( | |
| 54 SocketStream* socket, const CompletionCallback& callback) { | |
| 55 return OK; | |
| 56 } | |
| 57 | |
| 58 void SocketStream::Delegate::OnAuthRequired(SocketStream* socket, | |
| 59 AuthChallengeInfo* auth_info) { | |
| 60 // By default, no credential is available and close the connection. | |
| 61 socket->Close(); | |
| 62 } | |
| 63 | |
| 64 void SocketStream::Delegate::OnSSLCertificateError( | |
| 65 SocketStream* socket, | |
| 66 const SSLInfo& ssl_info, | |
| 67 bool fatal) { | |
| 68 socket->CancelWithSSLError(ssl_info); | |
| 69 } | |
| 70 | |
| 71 bool SocketStream::Delegate::CanGetCookies(SocketStream* socket, | |
| 72 const GURL& url) { | |
| 73 return true; | |
| 74 } | |
| 75 | |
| 76 bool SocketStream::Delegate::CanSetCookie(SocketStream* request, | |
| 77 const GURL& url, | |
| 78 const std::string& cookie_line, | |
| 79 CookieOptions* options) { | |
| 80 return true; | |
| 81 } | |
| 82 | |
| 83 SocketStream::ResponseHeaders::ResponseHeaders() : IOBuffer() {} | |
| 84 | |
| 85 void SocketStream::ResponseHeaders::Realloc(size_t new_size) { | |
| 86 headers_.reset(static_cast<char*>(realloc(headers_.release(), new_size))); | |
| 87 } | |
| 88 | |
| 89 SocketStream::ResponseHeaders::~ResponseHeaders() { data_ = NULL; } | |
| 90 | |
| 91 SocketStream::SocketStream(const GURL& url, Delegate* delegate, | |
| 92 URLRequestContext* context, | |
| 93 CookieStore* cookie_store) | |
| 94 : delegate_(delegate), | |
| 95 url_(url), | |
| 96 max_pending_send_allowed_(kMaxPendingSendAllowed), | |
| 97 context_(context), | |
| 98 next_state_(STATE_NONE), | |
| 99 factory_(ClientSocketFactory::GetDefaultFactory()), | |
| 100 proxy_mode_(kDirectConnection), | |
| 101 proxy_url_(url), | |
| 102 pac_request_(NULL), | |
| 103 connection_(new ClientSocketHandle), | |
| 104 privacy_mode_(PRIVACY_MODE_DISABLED), | |
| 105 // Unretained() is required; without it, Bind() creates a circular | |
| 106 // dependency and the SocketStream object will not be freed. | |
| 107 io_callback_(base::Bind(&SocketStream::OnIOCompleted, | |
| 108 base::Unretained(this))), | |
| 109 read_buf_(NULL), | |
| 110 current_write_buf_(NULL), | |
| 111 waiting_for_write_completion_(false), | |
| 112 closing_(false), | |
| 113 server_closed_(false), | |
| 114 metrics_(new SocketStreamMetrics(url)), | |
| 115 cookie_store_(cookie_store) { | |
| 116 DCHECK(base::MessageLoop::current()) | |
| 117 << "The current base::MessageLoop must exist"; | |
| 118 DCHECK(base::MessageLoopForIO::IsCurrent()) | |
| 119 << "The current base::MessageLoop must be TYPE_IO"; | |
| 120 DCHECK(delegate_); | |
| 121 | |
| 122 if (context_) { | |
| 123 if (!cookie_store_.get()) | |
| 124 cookie_store_ = context_->cookie_store(); | |
| 125 | |
| 126 net_log_ = BoundNetLog::Make( | |
| 127 context->net_log(), | |
| 128 NetLog::SOURCE_SOCKET_STREAM); | |
| 129 | |
| 130 net_log_.BeginEvent(NetLog::TYPE_REQUEST_ALIVE); | |
| 131 } | |
| 132 } | |
| 133 | |
| 134 SocketStream::UserData* SocketStream::GetUserData( | |
| 135 const void* key) const { | |
| 136 UserDataMap::const_iterator found = user_data_.find(key); | |
| 137 if (found != user_data_.end()) | |
| 138 return found->second.get(); | |
| 139 return NULL; | |
| 140 } | |
| 141 | |
| 142 void SocketStream::SetUserData(const void* key, UserData* data) { | |
| 143 user_data_[key] = linked_ptr<UserData>(data); | |
| 144 } | |
| 145 | |
| 146 bool SocketStream::is_secure() const { | |
| 147 return url_.SchemeIs("wss"); | |
| 148 } | |
| 149 | |
| 150 void SocketStream::DetachContext() { | |
| 151 if (!context_) | |
| 152 return; | |
| 153 | |
| 154 if (pac_request_) { | |
| 155 context_->proxy_service()->CancelPacRequest(pac_request_); | |
| 156 pac_request_ = NULL; | |
| 157 } | |
| 158 | |
| 159 net_log_.EndEvent(NetLog::TYPE_REQUEST_ALIVE); | |
| 160 net_log_ = BoundNetLog(); | |
| 161 | |
| 162 context_ = NULL; | |
| 163 cookie_store_ = NULL; | |
| 164 } | |
| 165 | |
| 166 void SocketStream::CheckPrivacyMode() { | |
| 167 if (context_ && context_->network_delegate()) { | |
| 168 bool enable = context_->network_delegate()->CanEnablePrivacyMode(url_, | |
| 169 url_); | |
| 170 privacy_mode_ = enable ? PRIVACY_MODE_ENABLED : PRIVACY_MODE_DISABLED; | |
| 171 // Disable Channel ID if privacy mode is enabled. | |
| 172 if (enable) | |
| 173 server_ssl_config_.channel_id_enabled = false; | |
| 174 } | |
| 175 } | |
| 176 | |
| 177 void SocketStream::Connect() { | |
| 178 DCHECK(base::MessageLoop::current()) | |
| 179 << "The current base::MessageLoop must exist"; | |
| 180 DCHECK(base::MessageLoopForIO::IsCurrent()) | |
| 181 << "The current base::MessageLoop must be TYPE_IO"; | |
| 182 if (context_) { | |
| 183 context_->ssl_config_service()->GetSSLConfig(&server_ssl_config_); | |
| 184 proxy_ssl_config_ = server_ssl_config_; | |
| 185 } | |
| 186 CheckPrivacyMode(); | |
| 187 | |
| 188 DCHECK_EQ(next_state_, STATE_NONE); | |
| 189 | |
| 190 AddRef(); // Released in Finish() | |
| 191 // Open a connection asynchronously, so that delegate won't be called | |
| 192 // back before returning Connect(). | |
| 193 next_state_ = STATE_BEFORE_CONNECT; | |
| 194 net_log_.BeginEvent( | |
| 195 NetLog::TYPE_SOCKET_STREAM_CONNECT, | |
| 196 NetLog::StringCallback("url", &url_.possibly_invalid_spec())); | |
| 197 base::MessageLoop::current()->PostTask( | |
| 198 FROM_HERE, base::Bind(&SocketStream::DoLoop, this, OK)); | |
| 199 } | |
| 200 | |
| 201 size_t SocketStream::GetTotalSizeOfPendingWriteBufs() const { | |
| 202 size_t total_size = 0; | |
| 203 for (PendingDataQueue::const_iterator iter = pending_write_bufs_.begin(); | |
| 204 iter != pending_write_bufs_.end(); | |
| 205 ++iter) | |
| 206 total_size += (*iter)->size(); | |
| 207 return total_size; | |
| 208 } | |
| 209 | |
| 210 bool SocketStream::SendData(const char* data, int len) { | |
| 211 DCHECK(base::MessageLoop::current()) | |
| 212 << "The current base::MessageLoop must exist"; | |
| 213 DCHECK(base::MessageLoopForIO::IsCurrent()) | |
| 214 << "The current base::MessageLoop must be TYPE_IO"; | |
| 215 DCHECK_GT(len, 0); | |
| 216 | |
| 217 if (!connection_->socket() || | |
| 218 !connection_->socket()->IsConnected() || next_state_ == STATE_NONE) { | |
| 219 return false; | |
| 220 } | |
| 221 | |
| 222 int total_buffered_bytes = len; | |
| 223 if (current_write_buf_.get()) { | |
| 224 // Since | |
| 225 // - the purpose of this check is to limit the amount of buffer used by | |
| 226 // this instance. | |
| 227 // - the DrainableIOBuffer doesn't release consumed memory. | |
| 228 // we need to use not BytesRemaining() but size() here. | |
| 229 total_buffered_bytes += current_write_buf_->size(); | |
| 230 } | |
| 231 total_buffered_bytes += GetTotalSizeOfPendingWriteBufs(); | |
| 232 if (total_buffered_bytes > max_pending_send_allowed_) | |
| 233 return false; | |
| 234 | |
| 235 // TODO(tyoshino): Split data into smaller chunks e.g. 8KiB to free consumed | |
| 236 // buffer progressively | |
| 237 pending_write_bufs_.push_back(make_scoped_refptr( | |
| 238 new IOBufferWithSize(len))); | |
| 239 memcpy(pending_write_bufs_.back()->data(), data, len); | |
| 240 | |
| 241 // If current_write_buf_ is not NULL, it means that a) there's ongoing write | |
| 242 // operation or b) the connection is being closed. If a), the buffer we just | |
| 243 // pushed will be automatically handled when the completion callback runs | |
| 244 // the loop, and therefore we don't need to enqueue DoLoop(). If b), it's ok | |
| 245 // to do nothing. If current_write_buf_ is NULL, to make sure DoLoop() is | |
| 246 // ran soon, enequeue it. | |
| 247 if (!current_write_buf_.get()) { | |
| 248 // Send pending data asynchronously, so that delegate won't be called | |
| 249 // back before returning from SendData(). | |
| 250 base::MessageLoop::current()->PostTask( | |
| 251 FROM_HERE, base::Bind(&SocketStream::DoLoop, this, OK)); | |
| 252 } | |
| 253 | |
| 254 return true; | |
| 255 } | |
| 256 | |
| 257 void SocketStream::Close() { | |
| 258 DCHECK(base::MessageLoop::current()) | |
| 259 << "The current base::MessageLoop must exist"; | |
| 260 DCHECK(base::MessageLoopForIO::IsCurrent()) | |
| 261 << "The current base::MessageLoop must be TYPE_IO"; | |
| 262 // If next_state_ is STATE_NONE, the socket was not opened, or already | |
| 263 // closed. So, return immediately. | |
| 264 // Otherwise, it might call Finish() more than once, so breaks balance | |
| 265 // of AddRef() and Release() in Connect() and Finish(), respectively. | |
| 266 if (next_state_ == STATE_NONE) | |
| 267 return; | |
| 268 base::MessageLoop::current()->PostTask( | |
| 269 FROM_HERE, base::Bind(&SocketStream::DoClose, this)); | |
| 270 } | |
| 271 | |
| 272 void SocketStream::RestartWithAuth(const AuthCredentials& credentials) { | |
| 273 DCHECK(base::MessageLoop::current()) | |
| 274 << "The current base::MessageLoop must exist"; | |
| 275 DCHECK(base::MessageLoopForIO::IsCurrent()) | |
| 276 << "The current base::MessageLoop must be TYPE_IO"; | |
| 277 DCHECK(proxy_auth_controller_.get()); | |
| 278 if (!connection_->socket()) { | |
| 279 DVLOG(1) << "Socket is closed before restarting with auth."; | |
| 280 return; | |
| 281 } | |
| 282 | |
| 283 proxy_auth_controller_->ResetAuth(credentials); | |
| 284 | |
| 285 base::MessageLoop::current()->PostTask( | |
| 286 FROM_HERE, base::Bind(&SocketStream::DoRestartWithAuth, this)); | |
| 287 } | |
| 288 | |
| 289 void SocketStream::DetachDelegate() { | |
| 290 if (!delegate_) | |
| 291 return; | |
| 292 delegate_ = NULL; | |
| 293 // Prevent the rest of the function from executing if we are being called from | |
| 294 // within Finish(). | |
| 295 if (next_state_ == STATE_NONE) | |
| 296 return; | |
| 297 net_log_.AddEvent(NetLog::TYPE_CANCELLED); | |
| 298 // We don't need to send pending data when client detach the delegate. | |
| 299 pending_write_bufs_.clear(); | |
| 300 Close(); | |
| 301 } | |
| 302 | |
| 303 const ProxyServer& SocketStream::proxy_server() const { | |
| 304 return proxy_info_.proxy_server(); | |
| 305 } | |
| 306 | |
| 307 void SocketStream::SetClientSocketFactory( | |
| 308 ClientSocketFactory* factory) { | |
| 309 DCHECK(factory); | |
| 310 factory_ = factory; | |
| 311 } | |
| 312 | |
| 313 void SocketStream::CancelWithError(int error) { | |
| 314 base::MessageLoop::current()->PostTask( | |
| 315 FROM_HERE, base::Bind(&SocketStream::DoLoop, this, error)); | |
| 316 } | |
| 317 | |
| 318 void SocketStream::CancelWithSSLError(const SSLInfo& ssl_info) { | |
| 319 CancelWithError(MapCertStatusToNetError(ssl_info.cert_status)); | |
| 320 } | |
| 321 | |
| 322 void SocketStream::ContinueDespiteError() { | |
| 323 base::MessageLoop::current()->PostTask( | |
| 324 FROM_HERE, base::Bind(&SocketStream::DoLoop, this, OK)); | |
| 325 } | |
| 326 | |
| 327 SocketStream::~SocketStream() { | |
| 328 DetachContext(); | |
| 329 DCHECK(!delegate_); | |
| 330 DCHECK(!pac_request_); | |
| 331 } | |
| 332 | |
| 333 SocketStream::RequestHeaders::~RequestHeaders() { data_ = NULL; } | |
| 334 | |
| 335 void SocketStream::set_addresses(const AddressList& addresses) { | |
| 336 addresses_ = addresses; | |
| 337 } | |
| 338 | |
| 339 void SocketStream::DoClose() { | |
| 340 closing_ = true; | |
| 341 // If next_state_ is: | |
| 342 // - STATE_TCP_CONNECT_COMPLETE, it's waiting other socket establishing | |
| 343 // connection. | |
| 344 // - STATE_AUTH_REQUIRED, it's waiting for restarting. | |
| 345 // - STATE_RESOLVE_PROTOCOL_COMPLETE, it's waiting for delegate_ to finish | |
| 346 // OnStartOpenConnection method call | |
| 347 // In these states, we'll close the SocketStream now. | |
| 348 if (next_state_ == STATE_TCP_CONNECT_COMPLETE || | |
| 349 next_state_ == STATE_AUTH_REQUIRED || | |
| 350 next_state_ == STATE_RESOLVE_PROTOCOL_COMPLETE) { | |
| 351 DoLoop(ERR_ABORTED); | |
| 352 return; | |
| 353 } | |
| 354 // If next_state_ is STATE_READ_WRITE, we'll run DoLoop and close | |
| 355 // the SocketStream. | |
| 356 // If it's writing now, we should defer the closing after the current | |
| 357 // writing is completed. | |
| 358 if (next_state_ == STATE_READ_WRITE && !current_write_buf_.get()) | |
| 359 DoLoop(ERR_ABORTED); | |
| 360 | |
| 361 // In other next_state_, we'll wait for callback of other APIs, such as | |
| 362 // ResolveProxy(). | |
| 363 } | |
| 364 | |
| 365 void SocketStream::Finish(int result) { | |
| 366 DCHECK(base::MessageLoop::current()) | |
| 367 << "The current base::MessageLoop must exist"; | |
| 368 DCHECK(base::MessageLoopForIO::IsCurrent()) | |
| 369 << "The current base::MessageLoop must be TYPE_IO"; | |
| 370 DCHECK_LE(result, OK); | |
| 371 if (result == OK) | |
| 372 result = ERR_CONNECTION_CLOSED; | |
| 373 DCHECK_EQ(next_state_, STATE_NONE); | |
| 374 DVLOG(1) << "Finish result=" << ErrorToString(result); | |
| 375 | |
| 376 metrics_->OnClose(); | |
| 377 | |
| 378 if (result != ERR_CONNECTION_CLOSED && delegate_) | |
| 379 delegate_->OnError(this, result); | |
| 380 if (result != ERR_PROTOCOL_SWITCHED && delegate_) | |
| 381 delegate_->OnClose(this); | |
| 382 delegate_ = NULL; | |
| 383 | |
| 384 Release(); | |
| 385 } | |
| 386 | |
| 387 int SocketStream::DidEstablishConnection() { | |
| 388 if (!connection_->socket() || !connection_->socket()->IsConnected()) { | |
| 389 next_state_ = STATE_CLOSE; | |
| 390 return ERR_CONNECTION_FAILED; | |
| 391 } | |
| 392 next_state_ = STATE_READ_WRITE; | |
| 393 metrics_->OnConnected(); | |
| 394 | |
| 395 net_log_.EndEvent(NetLog::TYPE_SOCKET_STREAM_CONNECT); | |
| 396 if (delegate_) | |
| 397 delegate_->OnConnected(this, max_pending_send_allowed_); | |
| 398 | |
| 399 return OK; | |
| 400 } | |
| 401 | |
| 402 int SocketStream::DidReceiveData(int result) { | |
| 403 DCHECK(read_buf_.get()); | |
| 404 DCHECK_GT(result, 0); | |
| 405 net_log_.AddEvent(NetLog::TYPE_SOCKET_STREAM_RECEIVED); | |
| 406 int len = result; | |
| 407 metrics_->OnRead(len); | |
| 408 if (delegate_) { | |
| 409 // Notify recevied data to delegate. | |
| 410 delegate_->OnReceivedData(this, read_buf_->data(), len); | |
| 411 } | |
| 412 read_buf_ = NULL; | |
| 413 return OK; | |
| 414 } | |
| 415 | |
| 416 void SocketStream::DidSendData(int result) { | |
| 417 DCHECK_GT(result, 0); | |
| 418 DCHECK(current_write_buf_.get()); | |
| 419 net_log_.AddEvent(NetLog::TYPE_SOCKET_STREAM_SENT); | |
| 420 | |
| 421 int bytes_sent = result; | |
| 422 | |
| 423 metrics_->OnWrite(bytes_sent); | |
| 424 | |
| 425 current_write_buf_->DidConsume(result); | |
| 426 | |
| 427 if (current_write_buf_->BytesRemaining()) | |
| 428 return; | |
| 429 | |
| 430 size_t bytes_freed = current_write_buf_->size(); | |
| 431 | |
| 432 current_write_buf_ = NULL; | |
| 433 | |
| 434 // We freed current_write_buf_ and this instance is now able to accept more | |
| 435 // data via SendData() (note that DidConsume() doesn't free consumed memory). | |
| 436 // We can tell that to delegate_ by calling OnSentData(). | |
| 437 if (delegate_) | |
| 438 delegate_->OnSentData(this, bytes_freed); | |
| 439 } | |
| 440 | |
| 441 void SocketStream::OnIOCompleted(int result) { | |
| 442 DoLoop(result); | |
| 443 } | |
| 444 | |
| 445 void SocketStream::OnReadCompleted(int result) { | |
| 446 if (result == 0) { | |
| 447 // 0 indicates end-of-file, so socket was closed. | |
| 448 // Don't close the socket if it's still writing. | |
| 449 server_closed_ = true; | |
| 450 } else if (result > 0 && read_buf_.get()) { | |
| 451 result = DidReceiveData(result); | |
| 452 } | |
| 453 DoLoop(result); | |
| 454 } | |
| 455 | |
| 456 void SocketStream::OnWriteCompleted(int result) { | |
| 457 waiting_for_write_completion_ = false; | |
| 458 if (result > 0) { | |
| 459 DidSendData(result); | |
| 460 result = OK; | |
| 461 } | |
| 462 DoLoop(result); | |
| 463 } | |
| 464 | |
| 465 void SocketStream::DoLoop(int result) { | |
| 466 if (next_state_ == STATE_NONE) | |
| 467 return; | |
| 468 | |
| 469 // If context was not set, close immediately. | |
| 470 if (!context_) | |
| 471 next_state_ = STATE_CLOSE; | |
| 472 | |
| 473 do { | |
| 474 State state = next_state_; | |
| 475 next_state_ = STATE_NONE; | |
| 476 switch (state) { | |
| 477 case STATE_BEFORE_CONNECT: | |
| 478 DCHECK_EQ(OK, result); | |
| 479 result = DoBeforeConnect(); | |
| 480 break; | |
| 481 case STATE_BEFORE_CONNECT_COMPLETE: | |
| 482 result = DoBeforeConnectComplete(result); | |
| 483 break; | |
| 484 case STATE_RESOLVE_PROXY: | |
| 485 DCHECK_EQ(OK, result); | |
| 486 result = DoResolveProxy(); | |
| 487 break; | |
| 488 case STATE_RESOLVE_PROXY_COMPLETE: | |
| 489 result = DoResolveProxyComplete(result); | |
| 490 break; | |
| 491 case STATE_RESOLVE_HOST: | |
| 492 DCHECK_EQ(OK, result); | |
| 493 result = DoResolveHost(); | |
| 494 break; | |
| 495 case STATE_RESOLVE_HOST_COMPLETE: | |
| 496 result = DoResolveHostComplete(result); | |
| 497 break; | |
| 498 case STATE_RESOLVE_PROTOCOL: | |
| 499 result = DoResolveProtocol(result); | |
| 500 break; | |
| 501 case STATE_RESOLVE_PROTOCOL_COMPLETE: | |
| 502 result = DoResolveProtocolComplete(result); | |
| 503 break; | |
| 504 case STATE_TCP_CONNECT: | |
| 505 result = DoTcpConnect(result); | |
| 506 break; | |
| 507 case STATE_TCP_CONNECT_COMPLETE: | |
| 508 result = DoTcpConnectComplete(result); | |
| 509 break; | |
| 510 case STATE_GENERATE_PROXY_AUTH_TOKEN: | |
| 511 result = DoGenerateProxyAuthToken(); | |
| 512 break; | |
| 513 case STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE: | |
| 514 result = DoGenerateProxyAuthTokenComplete(result); | |
| 515 break; | |
| 516 case STATE_WRITE_TUNNEL_HEADERS: | |
| 517 DCHECK_EQ(OK, result); | |
| 518 result = DoWriteTunnelHeaders(); | |
| 519 break; | |
| 520 case STATE_WRITE_TUNNEL_HEADERS_COMPLETE: | |
| 521 result = DoWriteTunnelHeadersComplete(result); | |
| 522 break; | |
| 523 case STATE_READ_TUNNEL_HEADERS: | |
| 524 DCHECK_EQ(OK, result); | |
| 525 result = DoReadTunnelHeaders(); | |
| 526 break; | |
| 527 case STATE_READ_TUNNEL_HEADERS_COMPLETE: | |
| 528 result = DoReadTunnelHeadersComplete(result); | |
| 529 break; | |
| 530 case STATE_SOCKS_CONNECT: | |
| 531 DCHECK_EQ(OK, result); | |
| 532 result = DoSOCKSConnect(); | |
| 533 break; | |
| 534 case STATE_SOCKS_CONNECT_COMPLETE: | |
| 535 result = DoSOCKSConnectComplete(result); | |
| 536 break; | |
| 537 case STATE_SECURE_PROXY_CONNECT: | |
| 538 DCHECK_EQ(OK, result); | |
| 539 result = DoSecureProxyConnect(); | |
| 540 break; | |
| 541 case STATE_SECURE_PROXY_CONNECT_COMPLETE: | |
| 542 result = DoSecureProxyConnectComplete(result); | |
| 543 break; | |
| 544 case STATE_SECURE_PROXY_HANDLE_CERT_ERROR: | |
| 545 result = DoSecureProxyHandleCertError(result); | |
| 546 break; | |
| 547 case STATE_SECURE_PROXY_HANDLE_CERT_ERROR_COMPLETE: | |
| 548 result = DoSecureProxyHandleCertErrorComplete(result); | |
| 549 break; | |
| 550 case STATE_SSL_CONNECT: | |
| 551 DCHECK_EQ(OK, result); | |
| 552 result = DoSSLConnect(); | |
| 553 break; | |
| 554 case STATE_SSL_CONNECT_COMPLETE: | |
| 555 result = DoSSLConnectComplete(result); | |
| 556 break; | |
| 557 case STATE_SSL_HANDLE_CERT_ERROR: | |
| 558 result = DoSSLHandleCertError(result); | |
| 559 break; | |
| 560 case STATE_SSL_HANDLE_CERT_ERROR_COMPLETE: | |
| 561 result = DoSSLHandleCertErrorComplete(result); | |
| 562 break; | |
| 563 case STATE_READ_WRITE: | |
| 564 result = DoReadWrite(result); | |
| 565 break; | |
| 566 case STATE_AUTH_REQUIRED: | |
| 567 // It might be called when DoClose is called while waiting in | |
| 568 // STATE_AUTH_REQUIRED. | |
| 569 Finish(result); | |
| 570 return; | |
| 571 case STATE_CLOSE: | |
| 572 DCHECK_LE(result, OK); | |
| 573 Finish(result); | |
| 574 return; | |
| 575 default: | |
| 576 NOTREACHED() << "bad state " << state; | |
| 577 Finish(result); | |
| 578 return; | |
| 579 } | |
| 580 if (state == STATE_RESOLVE_PROTOCOL && result == ERR_PROTOCOL_SWITCHED) | |
| 581 continue; | |
| 582 // If the connection is not established yet and had actual errors, | |
| 583 // record the error. In next iteration, it will close the connection. | |
| 584 if (state != STATE_READ_WRITE && result < ERR_IO_PENDING) { | |
| 585 net_log_.EndEventWithNetErrorCode( | |
| 586 NetLog::TYPE_SOCKET_STREAM_CONNECT, result); | |
| 587 } | |
| 588 } while (result != ERR_IO_PENDING); | |
| 589 } | |
| 590 | |
| 591 int SocketStream::DoBeforeConnect() { | |
| 592 next_state_ = STATE_BEFORE_CONNECT_COMPLETE; | |
| 593 if (!context_ || !context_->network_delegate()) | |
| 594 return OK; | |
| 595 | |
| 596 int result = context_->network_delegate()->NotifyBeforeSocketStreamConnect( | |
| 597 this, io_callback_); | |
| 598 if (result != OK && result != ERR_IO_PENDING) | |
| 599 next_state_ = STATE_CLOSE; | |
| 600 | |
| 601 return result; | |
| 602 } | |
| 603 | |
| 604 int SocketStream::DoBeforeConnectComplete(int result) { | |
| 605 DCHECK_NE(ERR_IO_PENDING, result); | |
| 606 | |
| 607 if (result == OK) | |
| 608 next_state_ = STATE_RESOLVE_PROXY; | |
| 609 else | |
| 610 next_state_ = STATE_CLOSE; | |
| 611 | |
| 612 return result; | |
| 613 } | |
| 614 | |
| 615 int SocketStream::DoResolveProxy() { | |
| 616 DCHECK(context_); | |
| 617 DCHECK(!pac_request_); | |
| 618 next_state_ = STATE_RESOLVE_PROXY_COMPLETE; | |
| 619 | |
| 620 if (!proxy_url_.is_valid()) { | |
| 621 next_state_ = STATE_CLOSE; | |
| 622 return ERR_INVALID_ARGUMENT; | |
| 623 } | |
| 624 | |
| 625 // TODO(toyoshim): Check server advertisement of SPDY through the HTTP | |
| 626 // Alternate-Protocol header, then switch to SPDY if SPDY is available. | |
| 627 // Usually we already have a session to the SPDY server because JavaScript | |
| 628 // running WebSocket itself would be served by SPDY. But, in some situation | |
| 629 // (E.g. Used by Chrome Extensions or used for cross origin connection), this | |
| 630 // connection might be the first one. At that time, we should check | |
| 631 // Alternate-Protocol header here for ws:// or TLS NPN extension for wss:// . | |
| 632 | |
| 633 return context_->proxy_service()->ResolveProxy( | |
| 634 proxy_url_, net::LOAD_NORMAL, &proxy_info_, io_callback_, &pac_request_, | |
| 635 NULL, net_log_); | |
| 636 } | |
| 637 | |
| 638 int SocketStream::DoResolveProxyComplete(int result) { | |
| 639 pac_request_ = NULL; | |
| 640 if (result != OK) { | |
| 641 DVLOG(1) << "Failed to resolve proxy: " << result; | |
| 642 if (delegate_) | |
| 643 delegate_->OnError(this, result); | |
| 644 proxy_info_.UseDirect(); | |
| 645 } | |
| 646 if (proxy_info_.is_direct()) { | |
| 647 // If proxy was not found for original URL (i.e. websocket URL), | |
| 648 // try again with https URL, like Safari implementation. | |
| 649 // Note that we don't want to use http proxy, because we'll use tunnel | |
| 650 // proxy using CONNECT method, which is used by https proxy. | |
| 651 if (!proxy_url_.SchemeIs("https")) { | |
| 652 const std::string scheme = "https"; | |
| 653 GURL::Replacements repl; | |
| 654 repl.SetSchemeStr(scheme); | |
| 655 proxy_url_ = url_.ReplaceComponents(repl); | |
| 656 DVLOG(1) << "Try https proxy: " << proxy_url_; | |
| 657 next_state_ = STATE_RESOLVE_PROXY; | |
| 658 return OK; | |
| 659 } | |
| 660 } | |
| 661 | |
| 662 if (proxy_info_.is_empty()) { | |
| 663 // No proxies/direct to choose from. This happens when we don't support any | |
| 664 // of the proxies in the returned list. | |
| 665 return ERR_NO_SUPPORTED_PROXIES; | |
| 666 } | |
| 667 | |
| 668 next_state_ = STATE_RESOLVE_HOST; | |
| 669 return OK; | |
| 670 } | |
| 671 | |
| 672 int SocketStream::DoResolveHost() { | |
| 673 next_state_ = STATE_RESOLVE_HOST_COMPLETE; | |
| 674 | |
| 675 DCHECK(!proxy_info_.is_empty()); | |
| 676 if (proxy_info_.is_direct()) | |
| 677 proxy_mode_ = kDirectConnection; | |
| 678 else if (proxy_info_.proxy_server().is_socks()) | |
| 679 proxy_mode_ = kSOCKSProxy; | |
| 680 else | |
| 681 proxy_mode_ = kTunnelProxy; | |
| 682 | |
| 683 // Determine the host and port to connect to. | |
| 684 HostPortPair host_port_pair; | |
| 685 if (proxy_mode_ != kDirectConnection) { | |
| 686 host_port_pair = proxy_info_.proxy_server().host_port_pair(); | |
| 687 } else { | |
| 688 host_port_pair = HostPortPair::FromURL(url_); | |
| 689 } | |
| 690 | |
| 691 HostResolver::RequestInfo resolve_info(host_port_pair); | |
| 692 | |
| 693 DCHECK(context_->host_resolver()); | |
| 694 resolver_.reset(new SingleRequestHostResolver(context_->host_resolver())); | |
| 695 return resolver_->Resolve(resolve_info, | |
| 696 DEFAULT_PRIORITY, | |
| 697 &addresses_, | |
| 698 base::Bind(&SocketStream::OnIOCompleted, this), | |
| 699 net_log_); | |
| 700 } | |
| 701 | |
| 702 int SocketStream::DoResolveHostComplete(int result) { | |
| 703 if (result == OK) | |
| 704 next_state_ = STATE_RESOLVE_PROTOCOL; | |
| 705 else | |
| 706 next_state_ = STATE_CLOSE; | |
| 707 // TODO(ukai): if error occured, reconsider proxy after error. | |
| 708 return result; | |
| 709 } | |
| 710 | |
| 711 int SocketStream::DoResolveProtocol(int result) { | |
| 712 DCHECK_EQ(OK, result); | |
| 713 | |
| 714 if (!delegate_) { | |
| 715 next_state_ = STATE_CLOSE; | |
| 716 return result; | |
| 717 } | |
| 718 | |
| 719 next_state_ = STATE_RESOLVE_PROTOCOL_COMPLETE; | |
| 720 result = delegate_->OnStartOpenConnection(this, io_callback_); | |
| 721 if (result == ERR_IO_PENDING) | |
| 722 metrics_->OnWaitConnection(); | |
| 723 else if (result != OK && result != ERR_PROTOCOL_SWITCHED) | |
| 724 next_state_ = STATE_CLOSE; | |
| 725 return result; | |
| 726 } | |
| 727 | |
| 728 int SocketStream::DoResolveProtocolComplete(int result) { | |
| 729 DCHECK_NE(ERR_IO_PENDING, result); | |
| 730 | |
| 731 if (result == ERR_PROTOCOL_SWITCHED) { | |
| 732 next_state_ = STATE_CLOSE; | |
| 733 metrics_->OnCountWireProtocolType( | |
| 734 SocketStreamMetrics::WIRE_PROTOCOL_SPDY); | |
| 735 } else if (result == OK) { | |
| 736 next_state_ = STATE_TCP_CONNECT; | |
| 737 metrics_->OnCountWireProtocolType( | |
| 738 SocketStreamMetrics::WIRE_PROTOCOL_WEBSOCKET); | |
| 739 } else { | |
| 740 next_state_ = STATE_CLOSE; | |
| 741 } | |
| 742 return result; | |
| 743 } | |
| 744 | |
| 745 int SocketStream::DoTcpConnect(int result) { | |
| 746 if (result != OK) { | |
| 747 next_state_ = STATE_CLOSE; | |
| 748 return result; | |
| 749 } | |
| 750 next_state_ = STATE_TCP_CONNECT_COMPLETE; | |
| 751 DCHECK(factory_); | |
| 752 connection_->SetSocket( | |
| 753 factory_->CreateTransportClientSocket(addresses_, | |
| 754 net_log_.net_log(), | |
| 755 net_log_.source())); | |
| 756 metrics_->OnStartConnection(); | |
| 757 return connection_->socket()->Connect(io_callback_); | |
| 758 } | |
| 759 | |
| 760 int SocketStream::DoTcpConnectComplete(int result) { | |
| 761 // TODO(ukai): if error occured, reconsider proxy after error. | |
| 762 if (result != OK) { | |
| 763 next_state_ = STATE_CLOSE; | |
| 764 return result; | |
| 765 } | |
| 766 | |
| 767 if (proxy_mode_ == kTunnelProxy) { | |
| 768 if (proxy_info_.is_https()) | |
| 769 next_state_ = STATE_SECURE_PROXY_CONNECT; | |
| 770 else | |
| 771 next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN; | |
| 772 } else if (proxy_mode_ == kSOCKSProxy) { | |
| 773 next_state_ = STATE_SOCKS_CONNECT; | |
| 774 } else if (is_secure()) { | |
| 775 next_state_ = STATE_SSL_CONNECT; | |
| 776 } else { | |
| 777 result = DidEstablishConnection(); | |
| 778 } | |
| 779 return result; | |
| 780 } | |
| 781 | |
| 782 int SocketStream::DoGenerateProxyAuthToken() { | |
| 783 next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN_COMPLETE; | |
| 784 if (!proxy_auth_controller_.get()) { | |
| 785 DCHECK(context_); | |
| 786 DCHECK(context_->http_transaction_factory()); | |
| 787 DCHECK(context_->http_transaction_factory()->GetSession()); | |
| 788 HttpNetworkSession* session = | |
| 789 context_->http_transaction_factory()->GetSession(); | |
| 790 const char* scheme = proxy_info_.is_https() ? "https://" : "http://"; | |
| 791 GURL auth_url(scheme + | |
| 792 proxy_info_.proxy_server().host_port_pair().ToString()); | |
| 793 proxy_auth_controller_ = | |
| 794 new HttpAuthController(HttpAuth::AUTH_PROXY, | |
| 795 auth_url, | |
| 796 session->http_auth_cache(), | |
| 797 session->http_auth_handler_factory()); | |
| 798 } | |
| 799 HttpRequestInfo request_info; | |
| 800 request_info.url = url_; | |
| 801 request_info.method = "CONNECT"; | |
| 802 return proxy_auth_controller_->MaybeGenerateAuthToken( | |
| 803 &request_info, io_callback_, net_log_); | |
| 804 } | |
| 805 | |
| 806 int SocketStream::DoGenerateProxyAuthTokenComplete(int result) { | |
| 807 if (result != OK) { | |
| 808 next_state_ = STATE_CLOSE; | |
| 809 return result; | |
| 810 } | |
| 811 | |
| 812 next_state_ = STATE_WRITE_TUNNEL_HEADERS; | |
| 813 return result; | |
| 814 } | |
| 815 | |
| 816 int SocketStream::DoWriteTunnelHeaders() { | |
| 817 DCHECK_EQ(kTunnelProxy, proxy_mode_); | |
| 818 | |
| 819 next_state_ = STATE_WRITE_TUNNEL_HEADERS_COMPLETE; | |
| 820 | |
| 821 if (!tunnel_request_headers_.get()) { | |
| 822 metrics_->OnCountConnectionType(SocketStreamMetrics::TUNNEL_CONNECTION); | |
| 823 tunnel_request_headers_ = new RequestHeaders(); | |
| 824 tunnel_request_headers_bytes_sent_ = 0; | |
| 825 } | |
| 826 if (tunnel_request_headers_->headers_.empty()) { | |
| 827 HttpRequestHeaders request_headers; | |
| 828 request_headers.SetHeader("Host", GetHostAndOptionalPort(url_)); | |
| 829 request_headers.SetHeader("Proxy-Connection", "keep-alive"); | |
| 830 if (proxy_auth_controller_.get() && proxy_auth_controller_->HaveAuth()) | |
| 831 proxy_auth_controller_->AddAuthorizationHeader(&request_headers); | |
| 832 tunnel_request_headers_->headers_ = base::StringPrintf( | |
| 833 "CONNECT %s HTTP/1.1\r\n" | |
| 834 "%s", | |
| 835 GetHostAndPort(url_).c_str(), | |
| 836 request_headers.ToString().c_str()); | |
| 837 } | |
| 838 tunnel_request_headers_->SetDataOffset(tunnel_request_headers_bytes_sent_); | |
| 839 int buf_len = static_cast<int>(tunnel_request_headers_->headers_.size() - | |
| 840 tunnel_request_headers_bytes_sent_); | |
| 841 DCHECK_GT(buf_len, 0); | |
| 842 return connection_->socket()->Write( | |
| 843 tunnel_request_headers_.get(), buf_len, io_callback_); | |
| 844 } | |
| 845 | |
| 846 int SocketStream::DoWriteTunnelHeadersComplete(int result) { | |
| 847 DCHECK_EQ(kTunnelProxy, proxy_mode_); | |
| 848 | |
| 849 if (result < 0) { | |
| 850 next_state_ = STATE_CLOSE; | |
| 851 return result; | |
| 852 } | |
| 853 | |
| 854 tunnel_request_headers_bytes_sent_ += result; | |
| 855 if (tunnel_request_headers_bytes_sent_ < | |
| 856 tunnel_request_headers_->headers_.size()) { | |
| 857 next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN; | |
| 858 } else { | |
| 859 // Handling a cert error or a client cert request requires reconnection. | |
| 860 // DoWriteTunnelHeaders() will be called again. | |
| 861 // Thus |tunnel_request_headers_bytes_sent_| should be reset to 0 for | |
| 862 // sending |tunnel_request_headers_| correctly. | |
| 863 tunnel_request_headers_bytes_sent_ = 0; | |
| 864 next_state_ = STATE_READ_TUNNEL_HEADERS; | |
| 865 } | |
| 866 return OK; | |
| 867 } | |
| 868 | |
| 869 int SocketStream::DoReadTunnelHeaders() { | |
| 870 DCHECK_EQ(kTunnelProxy, proxy_mode_); | |
| 871 | |
| 872 next_state_ = STATE_READ_TUNNEL_HEADERS_COMPLETE; | |
| 873 | |
| 874 if (!tunnel_response_headers_.get()) { | |
| 875 tunnel_response_headers_ = new ResponseHeaders(); | |
| 876 tunnel_response_headers_capacity_ = kMaxTunnelResponseHeadersSize; | |
| 877 tunnel_response_headers_->Realloc(tunnel_response_headers_capacity_); | |
| 878 tunnel_response_headers_len_ = 0; | |
| 879 } | |
| 880 | |
| 881 int buf_len = tunnel_response_headers_capacity_ - | |
| 882 tunnel_response_headers_len_; | |
| 883 tunnel_response_headers_->SetDataOffset(tunnel_response_headers_len_); | |
| 884 CHECK(tunnel_response_headers_->data()); | |
| 885 | |
| 886 return connection_->socket()->Read( | |
| 887 tunnel_response_headers_.get(), buf_len, io_callback_); | |
| 888 } | |
| 889 | |
| 890 int SocketStream::DoReadTunnelHeadersComplete(int result) { | |
| 891 DCHECK_EQ(kTunnelProxy, proxy_mode_); | |
| 892 | |
| 893 if (result < 0) { | |
| 894 next_state_ = STATE_CLOSE; | |
| 895 return result; | |
| 896 } | |
| 897 | |
| 898 if (result == 0) { | |
| 899 // 0 indicates end-of-file, so socket was closed. | |
| 900 next_state_ = STATE_CLOSE; | |
| 901 return ERR_CONNECTION_CLOSED; | |
| 902 } | |
| 903 | |
| 904 tunnel_response_headers_len_ += result; | |
| 905 DCHECK(tunnel_response_headers_len_ <= tunnel_response_headers_capacity_); | |
| 906 | |
| 907 int eoh = HttpUtil::LocateEndOfHeaders( | |
| 908 tunnel_response_headers_->headers(), tunnel_response_headers_len_, 0); | |
| 909 if (eoh == -1) { | |
| 910 if (tunnel_response_headers_len_ >= kMaxTunnelResponseHeadersSize) { | |
| 911 next_state_ = STATE_CLOSE; | |
| 912 return ERR_RESPONSE_HEADERS_TOO_BIG; | |
| 913 } | |
| 914 | |
| 915 next_state_ = STATE_READ_TUNNEL_HEADERS; | |
| 916 return OK; | |
| 917 } | |
| 918 // DidReadResponseHeaders | |
| 919 scoped_refptr<HttpResponseHeaders> headers; | |
| 920 headers = new HttpResponseHeaders( | |
| 921 HttpUtil::AssembleRawHeaders(tunnel_response_headers_->headers(), eoh)); | |
| 922 if (headers->GetParsedHttpVersion() < HttpVersion(1, 0)) { | |
| 923 // Require the "HTTP/1.x" status line. | |
| 924 next_state_ = STATE_CLOSE; | |
| 925 return ERR_TUNNEL_CONNECTION_FAILED; | |
| 926 } | |
| 927 switch (headers->response_code()) { | |
| 928 case 200: // OK | |
| 929 if (is_secure()) { | |
| 930 DCHECK_EQ(eoh, tunnel_response_headers_len_); | |
| 931 next_state_ = STATE_SSL_CONNECT; | |
| 932 } else { | |
| 933 result = DidEstablishConnection(); | |
| 934 if (result < 0) { | |
| 935 next_state_ = STATE_CLOSE; | |
| 936 return result; | |
| 937 } | |
| 938 if ((eoh < tunnel_response_headers_len_) && delegate_) | |
| 939 delegate_->OnReceivedData( | |
| 940 this, tunnel_response_headers_->headers() + eoh, | |
| 941 tunnel_response_headers_len_ - eoh); | |
| 942 } | |
| 943 return OK; | |
| 944 case 407: // Proxy Authentication Required. | |
| 945 if (proxy_mode_ != kTunnelProxy) | |
| 946 return ERR_UNEXPECTED_PROXY_AUTH; | |
| 947 | |
| 948 result = proxy_auth_controller_->HandleAuthChallenge( | |
| 949 headers, false, true, net_log_); | |
| 950 if (result != OK) | |
| 951 return result; | |
| 952 DCHECK(!proxy_info_.is_empty()); | |
| 953 next_state_ = STATE_AUTH_REQUIRED; | |
| 954 if (proxy_auth_controller_->HaveAuth()) { | |
| 955 base::MessageLoop::current()->PostTask( | |
| 956 FROM_HERE, base::Bind(&SocketStream::DoRestartWithAuth, this)); | |
| 957 return ERR_IO_PENDING; | |
| 958 } | |
| 959 if (delegate_) { | |
| 960 // Wait until RestartWithAuth or Close is called. | |
| 961 base::MessageLoop::current()->PostTask( | |
| 962 FROM_HERE, base::Bind(&SocketStream::DoAuthRequired, this)); | |
| 963 return ERR_IO_PENDING; | |
| 964 } | |
| 965 break; | |
| 966 default: | |
| 967 break; | |
| 968 } | |
| 969 next_state_ = STATE_CLOSE; | |
| 970 return ERR_TUNNEL_CONNECTION_FAILED; | |
| 971 } | |
| 972 | |
| 973 int SocketStream::DoSOCKSConnect() { | |
| 974 DCHECK_EQ(kSOCKSProxy, proxy_mode_); | |
| 975 | |
| 976 next_state_ = STATE_SOCKS_CONNECT_COMPLETE; | |
| 977 | |
| 978 HostResolver::RequestInfo req_info(HostPortPair::FromURL(url_)); | |
| 979 | |
| 980 DCHECK(!proxy_info_.is_empty()); | |
| 981 scoped_ptr<StreamSocket> s; | |
| 982 if (proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_SOCKS5) { | |
| 983 s.reset(new SOCKS5ClientSocket(connection_.Pass(), req_info)); | |
| 984 } else { | |
| 985 s.reset(new SOCKSClientSocket(connection_.Pass(), | |
| 986 req_info, | |
| 987 DEFAULT_PRIORITY, | |
| 988 context_->host_resolver())); | |
| 989 } | |
| 990 connection_.reset(new ClientSocketHandle); | |
| 991 connection_->SetSocket(s.Pass()); | |
| 992 metrics_->OnCountConnectionType(SocketStreamMetrics::SOCKS_CONNECTION); | |
| 993 return connection_->socket()->Connect(io_callback_); | |
| 994 } | |
| 995 | |
| 996 int SocketStream::DoSOCKSConnectComplete(int result) { | |
| 997 DCHECK_EQ(kSOCKSProxy, proxy_mode_); | |
| 998 | |
| 999 if (result == OK) { | |
| 1000 if (is_secure()) | |
| 1001 next_state_ = STATE_SSL_CONNECT; | |
| 1002 else | |
| 1003 result = DidEstablishConnection(); | |
| 1004 } else { | |
| 1005 next_state_ = STATE_CLOSE; | |
| 1006 } | |
| 1007 return result; | |
| 1008 } | |
| 1009 | |
| 1010 int SocketStream::DoSecureProxyConnect() { | |
| 1011 DCHECK(factory_); | |
| 1012 SSLClientSocketContext ssl_context; | |
| 1013 ssl_context.cert_verifier = context_->cert_verifier(); | |
| 1014 ssl_context.transport_security_state = context_->transport_security_state(); | |
| 1015 ssl_context.channel_id_service = context_->channel_id_service(); | |
| 1016 scoped_ptr<StreamSocket> socket(factory_->CreateSSLClientSocket( | |
| 1017 connection_.Pass(), | |
| 1018 proxy_info_.proxy_server().host_port_pair(), | |
| 1019 proxy_ssl_config_, | |
| 1020 ssl_context)); | |
| 1021 connection_.reset(new ClientSocketHandle); | |
| 1022 connection_->SetSocket(socket.Pass()); | |
| 1023 next_state_ = STATE_SECURE_PROXY_CONNECT_COMPLETE; | |
| 1024 metrics_->OnCountConnectionType(SocketStreamMetrics::SECURE_PROXY_CONNECTION); | |
| 1025 return connection_->socket()->Connect(io_callback_); | |
| 1026 } | |
| 1027 | |
| 1028 int SocketStream::DoSecureProxyConnectComplete(int result) { | |
| 1029 DCHECK_EQ(STATE_NONE, next_state_); | |
| 1030 // Reconnect with client authentication. | |
| 1031 if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) | |
| 1032 return HandleCertificateRequest(result, &proxy_ssl_config_); | |
| 1033 | |
| 1034 if (IsCertificateError(result)) | |
| 1035 next_state_ = STATE_SECURE_PROXY_HANDLE_CERT_ERROR; | |
| 1036 else if (result == OK) | |
| 1037 next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN; | |
| 1038 else | |
| 1039 next_state_ = STATE_CLOSE; | |
| 1040 return result; | |
| 1041 } | |
| 1042 | |
| 1043 int SocketStream::DoSecureProxyHandleCertError(int result) { | |
| 1044 DCHECK_EQ(STATE_NONE, next_state_); | |
| 1045 DCHECK(IsCertificateError(result)); | |
| 1046 result = HandleCertificateError(result); | |
| 1047 if (result == ERR_IO_PENDING) | |
| 1048 next_state_ = STATE_SECURE_PROXY_HANDLE_CERT_ERROR_COMPLETE; | |
| 1049 else | |
| 1050 next_state_ = STATE_CLOSE; | |
| 1051 return result; | |
| 1052 } | |
| 1053 | |
| 1054 int SocketStream::DoSecureProxyHandleCertErrorComplete(int result) { | |
| 1055 DCHECK_EQ(STATE_NONE, next_state_); | |
| 1056 if (result == OK) { | |
| 1057 if (!connection_->socket()->IsConnectedAndIdle()) | |
| 1058 return AllowCertErrorForReconnection(&proxy_ssl_config_); | |
| 1059 next_state_ = STATE_GENERATE_PROXY_AUTH_TOKEN; | |
| 1060 } else { | |
| 1061 next_state_ = STATE_CLOSE; | |
| 1062 } | |
| 1063 return result; | |
| 1064 } | |
| 1065 | |
| 1066 int SocketStream::DoSSLConnect() { | |
| 1067 DCHECK(factory_); | |
| 1068 SSLClientSocketContext ssl_context; | |
| 1069 ssl_context.cert_verifier = context_->cert_verifier(); | |
| 1070 ssl_context.transport_security_state = context_->transport_security_state(); | |
| 1071 ssl_context.channel_id_service = context_->channel_id_service(); | |
| 1072 scoped_ptr<StreamSocket> socket( | |
| 1073 factory_->CreateSSLClientSocket(connection_.Pass(), | |
| 1074 HostPortPair::FromURL(url_), | |
| 1075 server_ssl_config_, | |
| 1076 ssl_context)); | |
| 1077 connection_.reset(new ClientSocketHandle); | |
| 1078 connection_->SetSocket(socket.Pass()); | |
| 1079 next_state_ = STATE_SSL_CONNECT_COMPLETE; | |
| 1080 metrics_->OnCountConnectionType(SocketStreamMetrics::SSL_CONNECTION); | |
| 1081 return connection_->socket()->Connect(io_callback_); | |
| 1082 } | |
| 1083 | |
| 1084 int SocketStream::DoSSLConnectComplete(int result) { | |
| 1085 DCHECK_EQ(STATE_NONE, next_state_); | |
| 1086 // Reconnect with client authentication. | |
| 1087 if (result == ERR_SSL_CLIENT_AUTH_CERT_NEEDED) | |
| 1088 return HandleCertificateRequest(result, &server_ssl_config_); | |
| 1089 | |
| 1090 if (IsCertificateError(result)) | |
| 1091 next_state_ = STATE_SSL_HANDLE_CERT_ERROR; | |
| 1092 else if (result == OK) | |
| 1093 result = DidEstablishConnection(); | |
| 1094 else | |
| 1095 next_state_ = STATE_CLOSE; | |
| 1096 return result; | |
| 1097 } | |
| 1098 | |
| 1099 int SocketStream::DoSSLHandleCertError(int result) { | |
| 1100 DCHECK_EQ(STATE_NONE, next_state_); | |
| 1101 DCHECK(IsCertificateError(result)); | |
| 1102 result = HandleCertificateError(result); | |
| 1103 if (result == OK || result == ERR_IO_PENDING) | |
| 1104 next_state_ = STATE_SSL_HANDLE_CERT_ERROR_COMPLETE; | |
| 1105 else | |
| 1106 next_state_ = STATE_CLOSE; | |
| 1107 return result; | |
| 1108 } | |
| 1109 | |
| 1110 int SocketStream::DoSSLHandleCertErrorComplete(int result) { | |
| 1111 DCHECK_EQ(STATE_NONE, next_state_); | |
| 1112 // TODO(toyoshim): Upgrade to SPDY through TLS NPN extension if possible. | |
| 1113 // If we use HTTPS and this is the first connection to the SPDY server, | |
| 1114 // we should take care of TLS NPN extension here. | |
| 1115 | |
| 1116 if (result == OK) { | |
| 1117 if (!connection_->socket()->IsConnectedAndIdle()) | |
| 1118 return AllowCertErrorForReconnection(&server_ssl_config_); | |
| 1119 result = DidEstablishConnection(); | |
| 1120 } else { | |
| 1121 next_state_ = STATE_CLOSE; | |
| 1122 } | |
| 1123 return result; | |
| 1124 } | |
| 1125 | |
| 1126 int SocketStream::DoReadWrite(int result) { | |
| 1127 if (result < OK) { | |
| 1128 next_state_ = STATE_CLOSE; | |
| 1129 return result; | |
| 1130 } | |
| 1131 if (!connection_->socket() || !connection_->socket()->IsConnected()) { | |
| 1132 next_state_ = STATE_CLOSE; | |
| 1133 return ERR_CONNECTION_CLOSED; | |
| 1134 } | |
| 1135 | |
| 1136 // If client has requested close(), and there's nothing to write, then | |
| 1137 // let's close the socket. | |
| 1138 // We don't care about receiving data after the socket is closed. | |
| 1139 if (closing_ && !current_write_buf_.get() && pending_write_bufs_.empty()) { | |
| 1140 connection_->socket()->Disconnect(); | |
| 1141 next_state_ = STATE_CLOSE; | |
| 1142 return OK; | |
| 1143 } | |
| 1144 | |
| 1145 next_state_ = STATE_READ_WRITE; | |
| 1146 | |
| 1147 // If server already closed the socket, we don't try to read. | |
| 1148 if (!server_closed_) { | |
| 1149 if (!read_buf_.get()) { | |
| 1150 // No read pending and server didn't close the socket. | |
| 1151 read_buf_ = new IOBuffer(kReadBufferSize); | |
| 1152 result = connection_->socket()->Read( | |
| 1153 read_buf_.get(), | |
| 1154 kReadBufferSize, | |
| 1155 base::Bind(&SocketStream::OnReadCompleted, base::Unretained(this))); | |
| 1156 if (result > 0) { | |
| 1157 return DidReceiveData(result); | |
| 1158 } else if (result == 0) { | |
| 1159 // 0 indicates end-of-file, so socket was closed. | |
| 1160 next_state_ = STATE_CLOSE; | |
| 1161 server_closed_ = true; | |
| 1162 return ERR_CONNECTION_CLOSED; | |
| 1163 } | |
| 1164 // If read is pending, try write as well. | |
| 1165 // Otherwise, return the result and do next loop (to close the | |
| 1166 // connection). | |
| 1167 if (result != ERR_IO_PENDING) { | |
| 1168 next_state_ = STATE_CLOSE; | |
| 1169 server_closed_ = true; | |
| 1170 return result; | |
| 1171 } | |
| 1172 } | |
| 1173 // Read is pending. | |
| 1174 DCHECK(read_buf_.get()); | |
| 1175 } | |
| 1176 | |
| 1177 if (waiting_for_write_completion_) | |
| 1178 return ERR_IO_PENDING; | |
| 1179 | |
| 1180 if (!current_write_buf_.get()) { | |
| 1181 if (pending_write_bufs_.empty()) { | |
| 1182 // Nothing buffered for send. | |
| 1183 return ERR_IO_PENDING; | |
| 1184 } | |
| 1185 | |
| 1186 current_write_buf_ = new DrainableIOBuffer( | |
| 1187 pending_write_bufs_.front().get(), pending_write_bufs_.front()->size()); | |
| 1188 pending_write_bufs_.pop_front(); | |
| 1189 } | |
| 1190 | |
| 1191 result = connection_->socket()->Write( | |
| 1192 current_write_buf_.get(), | |
| 1193 current_write_buf_->BytesRemaining(), | |
| 1194 base::Bind(&SocketStream::OnWriteCompleted, base::Unretained(this))); | |
| 1195 | |
| 1196 if (result == ERR_IO_PENDING) { | |
| 1197 waiting_for_write_completion_ = true; | |
| 1198 } else if (result < 0) { | |
| 1199 // Shortcut. Enter STATE_CLOSE now by changing next_state_ here than by | |
| 1200 // calling DoReadWrite() again with the error code. | |
| 1201 next_state_ = STATE_CLOSE; | |
| 1202 } else if (result > 0) { | |
| 1203 // Write is not pending. Return OK and do next loop. | |
| 1204 DidSendData(result); | |
| 1205 result = OK; | |
| 1206 } | |
| 1207 | |
| 1208 return result; | |
| 1209 } | |
| 1210 | |
| 1211 GURL SocketStream::ProxyAuthOrigin() const { | |
| 1212 DCHECK(!proxy_info_.is_empty()); | |
| 1213 return GURL("http://" + | |
| 1214 proxy_info_.proxy_server().host_port_pair().ToString()); | |
| 1215 } | |
| 1216 | |
| 1217 int SocketStream::HandleCertificateRequest(int result, SSLConfig* ssl_config) { | |
| 1218 if (ssl_config->send_client_cert) { | |
| 1219 // We already have performed SSL client authentication once and failed. | |
| 1220 return result; | |
| 1221 } | |
| 1222 | |
| 1223 DCHECK(connection_->socket()); | |
| 1224 scoped_refptr<SSLCertRequestInfo> cert_request_info = new SSLCertRequestInfo; | |
| 1225 SSLClientSocket* ssl_socket = | |
| 1226 static_cast<SSLClientSocket*>(connection_->socket()); | |
| 1227 ssl_socket->GetSSLCertRequestInfo(cert_request_info.get()); | |
| 1228 | |
| 1229 HttpTransactionFactory* factory = context_->http_transaction_factory(); | |
| 1230 if (!factory) | |
| 1231 return result; | |
| 1232 scoped_refptr<HttpNetworkSession> session = factory->GetSession(); | |
| 1233 if (!session.get()) | |
| 1234 return result; | |
| 1235 | |
| 1236 // If the user selected one of the certificates in client_certs or declined | |
| 1237 // to provide one for this server before, use the past decision | |
| 1238 // automatically. | |
| 1239 scoped_refptr<X509Certificate> client_cert; | |
| 1240 if (!session->ssl_client_auth_cache()->Lookup( | |
| 1241 cert_request_info->host_and_port, &client_cert)) { | |
| 1242 return result; | |
| 1243 } | |
| 1244 | |
| 1245 // Note: |client_cert| may be NULL, indicating that the caller | |
| 1246 // wishes to proceed anonymously (eg: continue the handshake | |
| 1247 // without sending a client cert) | |
| 1248 // | |
| 1249 // Check that the certificate selected is still a certificate the server | |
| 1250 // is likely to accept, based on the criteria supplied in the | |
| 1251 // CertificateRequest message. | |
| 1252 const std::vector<std::string>& cert_authorities = | |
| 1253 cert_request_info->cert_authorities; | |
| 1254 if (client_cert.get() && !cert_authorities.empty() && | |
| 1255 !client_cert->IsIssuedByEncoded(cert_authorities)) { | |
| 1256 return result; | |
| 1257 } | |
| 1258 | |
| 1259 ssl_config->send_client_cert = true; | |
| 1260 ssl_config->client_cert = client_cert; | |
| 1261 next_state_ = STATE_TCP_CONNECT; | |
| 1262 return OK; | |
| 1263 } | |
| 1264 | |
| 1265 int SocketStream::AllowCertErrorForReconnection(SSLConfig* ssl_config) { | |
| 1266 DCHECK(ssl_config); | |
| 1267 // The SSL handshake didn't finish, or the server closed the SSL connection. | |
| 1268 // So, we should restart establishing connection with the certificate in | |
| 1269 // allowed bad certificates in |ssl_config|. | |
| 1270 // See also net/http/http_network_transaction.cc HandleCertificateError() and | |
| 1271 // RestartIgnoringLastError(). | |
| 1272 SSLClientSocket* ssl_socket = | |
| 1273 static_cast<SSLClientSocket*>(connection_->socket()); | |
| 1274 SSLInfo ssl_info; | |
| 1275 ssl_socket->GetSSLInfo(&ssl_info); | |
| 1276 if (ssl_info.cert.get() == NULL || | |
| 1277 ssl_config->IsAllowedBadCert(ssl_info.cert.get(), NULL)) { | |
| 1278 // If we already have the certificate in the set of allowed bad | |
| 1279 // certificates, we did try it and failed again, so we should not | |
| 1280 // retry again: the connection should fail at last. | |
| 1281 next_state_ = STATE_CLOSE; | |
| 1282 return ERR_UNEXPECTED; | |
| 1283 } | |
| 1284 // Add the bad certificate to the set of allowed certificates in the | |
| 1285 // SSL config object. | |
| 1286 SSLConfig::CertAndStatus bad_cert; | |
| 1287 if (!X509Certificate::GetDEREncoded(ssl_info.cert->os_cert_handle(), | |
| 1288 &bad_cert.der_cert)) { | |
| 1289 next_state_ = STATE_CLOSE; | |
| 1290 return ERR_UNEXPECTED; | |
| 1291 } | |
| 1292 bad_cert.cert_status = ssl_info.cert_status; | |
| 1293 ssl_config->allowed_bad_certs.push_back(bad_cert); | |
| 1294 // Restart connection ignoring the bad certificate. | |
| 1295 connection_->socket()->Disconnect(); | |
| 1296 connection_->SetSocket(scoped_ptr<StreamSocket>()); | |
| 1297 next_state_ = STATE_TCP_CONNECT; | |
| 1298 return OK; | |
| 1299 } | |
| 1300 | |
| 1301 void SocketStream::DoAuthRequired() { | |
| 1302 if (delegate_ && proxy_auth_controller_.get()) | |
| 1303 delegate_->OnAuthRequired(this, proxy_auth_controller_->auth_info().get()); | |
| 1304 else | |
| 1305 DoLoop(ERR_UNEXPECTED); | |
| 1306 } | |
| 1307 | |
| 1308 void SocketStream::DoRestartWithAuth() { | |
| 1309 DCHECK_EQ(next_state_, STATE_AUTH_REQUIRED); | |
| 1310 tunnel_request_headers_ = NULL; | |
| 1311 tunnel_request_headers_bytes_sent_ = 0; | |
| 1312 tunnel_response_headers_ = NULL; | |
| 1313 tunnel_response_headers_capacity_ = 0; | |
| 1314 tunnel_response_headers_len_ = 0; | |
| 1315 | |
| 1316 next_state_ = STATE_TCP_CONNECT; | |
| 1317 DoLoop(OK); | |
| 1318 } | |
| 1319 | |
| 1320 int SocketStream::HandleCertificateError(int result) { | |
| 1321 DCHECK(IsCertificateError(result)); | |
| 1322 SSLClientSocket* ssl_socket = | |
| 1323 static_cast<SSLClientSocket*>(connection_->socket()); | |
| 1324 DCHECK(ssl_socket); | |
| 1325 | |
| 1326 if (!context_) | |
| 1327 return result; | |
| 1328 | |
| 1329 if (SSLClientSocket::IgnoreCertError(result, LOAD_IGNORE_ALL_CERT_ERRORS)) { | |
| 1330 const HttpNetworkSession::Params* session_params = | |
| 1331 context_->GetNetworkSessionParams(); | |
| 1332 if (session_params && session_params->ignore_certificate_errors) | |
| 1333 return OK; | |
| 1334 } | |
| 1335 | |
| 1336 if (!delegate_) | |
| 1337 return result; | |
| 1338 | |
| 1339 SSLInfo ssl_info; | |
| 1340 ssl_socket->GetSSLInfo(&ssl_info); | |
| 1341 | |
| 1342 TransportSecurityState* state = context_->transport_security_state(); | |
| 1343 const bool fatal = state && state->ShouldSSLErrorsBeFatal(url_.host()); | |
| 1344 | |
| 1345 delegate_->OnSSLCertificateError(this, ssl_info, fatal); | |
| 1346 return ERR_IO_PENDING; | |
| 1347 } | |
| 1348 | |
| 1349 CookieStore* SocketStream::cookie_store() const { | |
| 1350 return cookie_store_.get(); | |
| 1351 } | |
| 1352 | |
| 1353 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 723343002:
Update from https://crrev.com/304121 (Closed)
Base URL: git@github.com:domokit/mojo.git@master