| 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 #include "net/socket/socks_client_socket.h" | |
| 6 | |
| 7 #include "base/basictypes.h" | |
| 8 #include "base/bind.h" | |
| 9 #include "base/callback_helpers.h" | |
| 10 #include "base/compiler_specific.h" | |
| 11 #include "base/profiler/scoped_tracker.h" | |
| 12 #include "base/sys_byteorder.h" | |
| 13 #include "net/base/io_buffer.h" | |
| 14 #include "net/base/net_log.h" | |
| 15 #include "net/base/net_util.h" | |
| 16 #include "net/socket/client_socket_handle.h" | |
| 17 | |
| 18 namespace net { | |
| 19 | |
| 20 // Every SOCKS server requests a user-id from the client. It is optional | |
| 21 // and we send an empty string. | |
| 22 static const char kEmptyUserId[] = ""; | |
| 23 | |
| 24 // For SOCKS4, the client sends 8 bytes plus the size of the user-id. | |
| 25 static const unsigned int kWriteHeaderSize = 8; | |
| 26 | |
| 27 // For SOCKS4 the server sends 8 bytes for acknowledgement. | |
| 28 static const unsigned int kReadHeaderSize = 8; | |
| 29 | |
| 30 // Server Response codes for SOCKS. | |
| 31 static const uint8 kServerResponseOk = 0x5A; | |
| 32 static const uint8 kServerResponseRejected = 0x5B; | |
| 33 static const uint8 kServerResponseNotReachable = 0x5C; | |
| 34 static const uint8 kServerResponseMismatchedUserId = 0x5D; | |
| 35 | |
| 36 static const uint8 kSOCKSVersion4 = 0x04; | |
| 37 static const uint8 kSOCKSStreamRequest = 0x01; | |
| 38 | |
| 39 // A struct holding the essential details of the SOCKS4 Server Request. | |
| 40 // The port in the header is stored in network byte order. | |
| 41 struct SOCKS4ServerRequest { | |
| 42 uint8 version; | |
| 43 uint8 command; | |
| 44 uint16 nw_port; | |
| 45 uint8 ip[4]; | |
| 46 }; | |
| 47 static_assert(sizeof(SOCKS4ServerRequest) == kWriteHeaderSize, | |
| 48 "socks4 server request struct has incorrect size"); | |
| 49 | |
| 50 // A struct holding details of the SOCKS4 Server Response. | |
| 51 struct SOCKS4ServerResponse { | |
| 52 uint8 reserved_null; | |
| 53 uint8 code; | |
| 54 uint16 port; | |
| 55 uint8 ip[4]; | |
| 56 }; | |
| 57 static_assert(sizeof(SOCKS4ServerResponse) == kReadHeaderSize, | |
| 58 "socks4 server response struct has incorrect size"); | |
| 59 | |
| 60 SOCKSClientSocket::SOCKSClientSocket( | |
| 61 scoped_ptr<ClientSocketHandle> transport_socket, | |
| 62 const HostResolver::RequestInfo& req_info, | |
| 63 RequestPriority priority, | |
| 64 HostResolver* host_resolver) | |
| 65 : transport_(transport_socket.Pass()), | |
| 66 next_state_(STATE_NONE), | |
| 67 completed_handshake_(false), | |
| 68 bytes_sent_(0), | |
| 69 bytes_received_(0), | |
| 70 was_ever_used_(false), | |
| 71 host_resolver_(host_resolver), | |
| 72 host_request_info_(req_info), | |
| 73 priority_(priority), | |
| 74 net_log_(transport_->socket()->NetLog()) {} | |
| 75 | |
| 76 SOCKSClientSocket::~SOCKSClientSocket() { | |
| 77 Disconnect(); | |
| 78 } | |
| 79 | |
| 80 int SOCKSClientSocket::Connect(const CompletionCallback& callback) { | |
| 81 DCHECK(transport_.get()); | |
| 82 DCHECK(transport_->socket()); | |
| 83 DCHECK_EQ(STATE_NONE, next_state_); | |
| 84 DCHECK(user_callback_.is_null()); | |
| 85 | |
| 86 // If already connected, then just return OK. | |
| 87 if (completed_handshake_) | |
| 88 return OK; | |
| 89 | |
| 90 next_state_ = STATE_RESOLVE_HOST; | |
| 91 | |
| 92 net_log_.BeginEvent(NetLog::TYPE_SOCKS_CONNECT); | |
| 93 | |
| 94 int rv = DoLoop(OK); | |
| 95 if (rv == ERR_IO_PENDING) { | |
| 96 user_callback_ = callback; | |
| 97 } else { | |
| 98 net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SOCKS_CONNECT, rv); | |
| 99 } | |
| 100 return rv; | |
| 101 } | |
| 102 | |
| 103 void SOCKSClientSocket::Disconnect() { | |
| 104 completed_handshake_ = false; | |
| 105 host_resolver_.Cancel(); | |
| 106 transport_->socket()->Disconnect(); | |
| 107 | |
| 108 // Reset other states to make sure they aren't mistakenly used later. | |
| 109 // These are the states initialized by Connect(). | |
| 110 next_state_ = STATE_NONE; | |
| 111 user_callback_.Reset(); | |
| 112 } | |
| 113 | |
| 114 bool SOCKSClientSocket::IsConnected() const { | |
| 115 return completed_handshake_ && transport_->socket()->IsConnected(); | |
| 116 } | |
| 117 | |
| 118 bool SOCKSClientSocket::IsConnectedAndIdle() const { | |
| 119 return completed_handshake_ && transport_->socket()->IsConnectedAndIdle(); | |
| 120 } | |
| 121 | |
| 122 const BoundNetLog& SOCKSClientSocket::NetLog() const { | |
| 123 return net_log_; | |
| 124 } | |
| 125 | |
| 126 void SOCKSClientSocket::SetSubresourceSpeculation() { | |
| 127 if (transport_.get() && transport_->socket()) { | |
| 128 transport_->socket()->SetSubresourceSpeculation(); | |
| 129 } else { | |
| 130 NOTREACHED(); | |
| 131 } | |
| 132 } | |
| 133 | |
| 134 void SOCKSClientSocket::SetOmniboxSpeculation() { | |
| 135 if (transport_.get() && transport_->socket()) { | |
| 136 transport_->socket()->SetOmniboxSpeculation(); | |
| 137 } else { | |
| 138 NOTREACHED(); | |
| 139 } | |
| 140 } | |
| 141 | |
| 142 bool SOCKSClientSocket::WasEverUsed() const { | |
| 143 return was_ever_used_; | |
| 144 } | |
| 145 | |
| 146 bool SOCKSClientSocket::UsingTCPFastOpen() const { | |
| 147 if (transport_.get() && transport_->socket()) { | |
| 148 return transport_->socket()->UsingTCPFastOpen(); | |
| 149 } | |
| 150 NOTREACHED(); | |
| 151 return false; | |
| 152 } | |
| 153 | |
| 154 bool SOCKSClientSocket::WasNpnNegotiated() const { | |
| 155 if (transport_.get() && transport_->socket()) { | |
| 156 return transport_->socket()->WasNpnNegotiated(); | |
| 157 } | |
| 158 NOTREACHED(); | |
| 159 return false; | |
| 160 } | |
| 161 | |
| 162 NextProto SOCKSClientSocket::GetNegotiatedProtocol() const { | |
| 163 if (transport_.get() && transport_->socket()) { | |
| 164 return transport_->socket()->GetNegotiatedProtocol(); | |
| 165 } | |
| 166 NOTREACHED(); | |
| 167 return kProtoUnknown; | |
| 168 } | |
| 169 | |
| 170 bool SOCKSClientSocket::GetSSLInfo(SSLInfo* ssl_info) { | |
| 171 if (transport_.get() && transport_->socket()) { | |
| 172 return transport_->socket()->GetSSLInfo(ssl_info); | |
| 173 } | |
| 174 NOTREACHED(); | |
| 175 return false; | |
| 176 | |
| 177 } | |
| 178 | |
| 179 // Read is called by the transport layer above to read. This can only be done | |
| 180 // if the SOCKS handshake is complete. | |
| 181 int SOCKSClientSocket::Read(IOBuffer* buf, int buf_len, | |
| 182 const CompletionCallback& callback) { | |
| 183 DCHECK(completed_handshake_); | |
| 184 DCHECK_EQ(STATE_NONE, next_state_); | |
| 185 DCHECK(user_callback_.is_null()); | |
| 186 DCHECK(!callback.is_null()); | |
| 187 | |
| 188 int rv = transport_->socket()->Read( | |
| 189 buf, buf_len, | |
| 190 base::Bind(&SOCKSClientSocket::OnReadWriteComplete, | |
| 191 base::Unretained(this), callback)); | |
| 192 if (rv > 0) | |
| 193 was_ever_used_ = true; | |
| 194 return rv; | |
| 195 } | |
| 196 | |
| 197 // Write is called by the transport layer. This can only be done if the | |
| 198 // SOCKS handshake is complete. | |
| 199 int SOCKSClientSocket::Write(IOBuffer* buf, int buf_len, | |
| 200 const CompletionCallback& callback) { | |
| 201 DCHECK(completed_handshake_); | |
| 202 DCHECK_EQ(STATE_NONE, next_state_); | |
| 203 DCHECK(user_callback_.is_null()); | |
| 204 DCHECK(!callback.is_null()); | |
| 205 | |
| 206 int rv = transport_->socket()->Write( | |
| 207 buf, buf_len, | |
| 208 base::Bind(&SOCKSClientSocket::OnReadWriteComplete, | |
| 209 base::Unretained(this), callback)); | |
| 210 if (rv > 0) | |
| 211 was_ever_used_ = true; | |
| 212 return rv; | |
| 213 } | |
| 214 | |
| 215 int SOCKSClientSocket::SetReceiveBufferSize(int32 size) { | |
| 216 return transport_->socket()->SetReceiveBufferSize(size); | |
| 217 } | |
| 218 | |
| 219 int SOCKSClientSocket::SetSendBufferSize(int32 size) { | |
| 220 return transport_->socket()->SetSendBufferSize(size); | |
| 221 } | |
| 222 | |
| 223 void SOCKSClientSocket::DoCallback(int result) { | |
| 224 DCHECK_NE(ERR_IO_PENDING, result); | |
| 225 DCHECK(!user_callback_.is_null()); | |
| 226 | |
| 227 // Since Run() may result in Read being called, | |
| 228 // clear user_callback_ up front. | |
| 229 DVLOG(1) << "Finished setting up SOCKS handshake"; | |
| 230 base::ResetAndReturn(&user_callback_).Run(result); | |
| 231 } | |
| 232 | |
| 233 void SOCKSClientSocket::OnIOComplete(int result) { | |
| 234 // TODO(vadimt): Remove ScopedTracker below once crbug.com/436634 is fixed. | |
| 235 tracked_objects::ScopedTracker tracking_profile( | |
| 236 FROM_HERE_WITH_EXPLICIT_FUNCTION( | |
| 237 "436634 SOCKSClientSocket::OnIOComplete")); | |
| 238 | |
| 239 DCHECK_NE(STATE_NONE, next_state_); | |
| 240 int rv = DoLoop(result); | |
| 241 if (rv != ERR_IO_PENDING) { | |
| 242 net_log_.EndEventWithNetErrorCode(NetLog::TYPE_SOCKS_CONNECT, rv); | |
| 243 DoCallback(rv); | |
| 244 } | |
| 245 } | |
| 246 | |
| 247 void SOCKSClientSocket::OnReadWriteComplete(const CompletionCallback& callback, | |
| 248 int result) { | |
| 249 DCHECK_NE(ERR_IO_PENDING, result); | |
| 250 DCHECK(!callback.is_null()); | |
| 251 | |
| 252 if (result > 0) | |
| 253 was_ever_used_ = true; | |
| 254 callback.Run(result); | |
| 255 } | |
| 256 | |
| 257 int SOCKSClientSocket::DoLoop(int last_io_result) { | |
| 258 DCHECK_NE(next_state_, STATE_NONE); | |
| 259 int rv = last_io_result; | |
| 260 do { | |
| 261 State state = next_state_; | |
| 262 next_state_ = STATE_NONE; | |
| 263 switch (state) { | |
| 264 case STATE_RESOLVE_HOST: | |
| 265 DCHECK_EQ(OK, rv); | |
| 266 rv = DoResolveHost(); | |
| 267 break; | |
| 268 case STATE_RESOLVE_HOST_COMPLETE: | |
| 269 rv = DoResolveHostComplete(rv); | |
| 270 break; | |
| 271 case STATE_HANDSHAKE_WRITE: | |
| 272 DCHECK_EQ(OK, rv); | |
| 273 rv = DoHandshakeWrite(); | |
| 274 break; | |
| 275 case STATE_HANDSHAKE_WRITE_COMPLETE: | |
| 276 rv = DoHandshakeWriteComplete(rv); | |
| 277 break; | |
| 278 case STATE_HANDSHAKE_READ: | |
| 279 DCHECK_EQ(OK, rv); | |
| 280 rv = DoHandshakeRead(); | |
| 281 break; | |
| 282 case STATE_HANDSHAKE_READ_COMPLETE: | |
| 283 rv = DoHandshakeReadComplete(rv); | |
| 284 break; | |
| 285 default: | |
| 286 NOTREACHED() << "bad state"; | |
| 287 rv = ERR_UNEXPECTED; | |
| 288 break; | |
| 289 } | |
| 290 } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE); | |
| 291 return rv; | |
| 292 } | |
| 293 | |
| 294 int SOCKSClientSocket::DoResolveHost() { | |
| 295 next_state_ = STATE_RESOLVE_HOST_COMPLETE; | |
| 296 // SOCKS4 only supports IPv4 addresses, so only try getting the IPv4 | |
| 297 // addresses for the target host. | |
| 298 host_request_info_.set_address_family(ADDRESS_FAMILY_IPV4); | |
| 299 return host_resolver_.Resolve( | |
| 300 host_request_info_, | |
| 301 priority_, | |
| 302 &addresses_, | |
| 303 base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this)), | |
| 304 net_log_); | |
| 305 } | |
| 306 | |
| 307 int SOCKSClientSocket::DoResolveHostComplete(int result) { | |
| 308 if (result != OK) { | |
| 309 // Resolving the hostname failed; fail the request rather than automatically | |
| 310 // falling back to SOCKS4a (since it can be confusing to see invalid IP | |
| 311 // addresses being sent to the SOCKS4 server when it doesn't support 4A.) | |
| 312 return result; | |
| 313 } | |
| 314 | |
| 315 next_state_ = STATE_HANDSHAKE_WRITE; | |
| 316 return OK; | |
| 317 } | |
| 318 | |
| 319 // Builds the buffer that is to be sent to the server. | |
| 320 const std::string SOCKSClientSocket::BuildHandshakeWriteBuffer() const { | |
| 321 SOCKS4ServerRequest request; | |
| 322 request.version = kSOCKSVersion4; | |
| 323 request.command = kSOCKSStreamRequest; | |
| 324 request.nw_port = base::HostToNet16(host_request_info_.port()); | |
| 325 | |
| 326 DCHECK(!addresses_.empty()); | |
| 327 const IPEndPoint& endpoint = addresses_.front(); | |
| 328 | |
| 329 // We disabled IPv6 results when resolving the hostname, so none of the | |
| 330 // results in the list will be IPv6. | |
| 331 // TODO(eroman): we only ever use the first address in the list. It would be | |
| 332 // more robust to try all the IP addresses we have before | |
| 333 // failing the connect attempt. | |
| 334 CHECK_EQ(ADDRESS_FAMILY_IPV4, endpoint.GetFamily()); | |
| 335 CHECK_LE(endpoint.address().size(), sizeof(request.ip)); | |
| 336 memcpy(&request.ip, &endpoint.address()[0], endpoint.address().size()); | |
| 337 | |
| 338 DVLOG(1) << "Resolved Host is : " << endpoint.ToStringWithoutPort(); | |
| 339 | |
| 340 std::string handshake_data(reinterpret_cast<char*>(&request), | |
| 341 sizeof(request)); | |
| 342 handshake_data.append(kEmptyUserId, arraysize(kEmptyUserId)); | |
| 343 | |
| 344 return handshake_data; | |
| 345 } | |
| 346 | |
| 347 // Writes the SOCKS handshake data to the underlying socket connection. | |
| 348 int SOCKSClientSocket::DoHandshakeWrite() { | |
| 349 next_state_ = STATE_HANDSHAKE_WRITE_COMPLETE; | |
| 350 | |
| 351 if (buffer_.empty()) { | |
| 352 buffer_ = BuildHandshakeWriteBuffer(); | |
| 353 bytes_sent_ = 0; | |
| 354 } | |
| 355 | |
| 356 int handshake_buf_len = buffer_.size() - bytes_sent_; | |
| 357 DCHECK_GT(handshake_buf_len, 0); | |
| 358 handshake_buf_ = new IOBuffer(handshake_buf_len); | |
| 359 memcpy(handshake_buf_->data(), &buffer_[bytes_sent_], | |
| 360 handshake_buf_len); | |
| 361 return transport_->socket()->Write( | |
| 362 handshake_buf_.get(), | |
| 363 handshake_buf_len, | |
| 364 base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this))); | |
| 365 } | |
| 366 | |
| 367 int SOCKSClientSocket::DoHandshakeWriteComplete(int result) { | |
| 368 if (result < 0) | |
| 369 return result; | |
| 370 | |
| 371 // We ignore the case when result is 0, since the underlying Write | |
| 372 // may return spurious writes while waiting on the socket. | |
| 373 | |
| 374 bytes_sent_ += result; | |
| 375 if (bytes_sent_ == buffer_.size()) { | |
| 376 next_state_ = STATE_HANDSHAKE_READ; | |
| 377 buffer_.clear(); | |
| 378 } else if (bytes_sent_ < buffer_.size()) { | |
| 379 next_state_ = STATE_HANDSHAKE_WRITE; | |
| 380 } else { | |
| 381 return ERR_UNEXPECTED; | |
| 382 } | |
| 383 | |
| 384 return OK; | |
| 385 } | |
| 386 | |
| 387 int SOCKSClientSocket::DoHandshakeRead() { | |
| 388 next_state_ = STATE_HANDSHAKE_READ_COMPLETE; | |
| 389 | |
| 390 if (buffer_.empty()) { | |
| 391 bytes_received_ = 0; | |
| 392 } | |
| 393 | |
| 394 int handshake_buf_len = kReadHeaderSize - bytes_received_; | |
| 395 handshake_buf_ = new IOBuffer(handshake_buf_len); | |
| 396 return transport_->socket()->Read( | |
| 397 handshake_buf_.get(), | |
| 398 handshake_buf_len, | |
| 399 base::Bind(&SOCKSClientSocket::OnIOComplete, base::Unretained(this))); | |
| 400 } | |
| 401 | |
| 402 int SOCKSClientSocket::DoHandshakeReadComplete(int result) { | |
| 403 if (result < 0) | |
| 404 return result; | |
| 405 | |
| 406 // The underlying socket closed unexpectedly. | |
| 407 if (result == 0) | |
| 408 return ERR_CONNECTION_CLOSED; | |
| 409 | |
| 410 if (bytes_received_ + result > kReadHeaderSize) { | |
| 411 // TODO(eroman): Describe failure in NetLog. | |
| 412 return ERR_SOCKS_CONNECTION_FAILED; | |
| 413 } | |
| 414 | |
| 415 buffer_.append(handshake_buf_->data(), result); | |
| 416 bytes_received_ += result; | |
| 417 if (bytes_received_ < kReadHeaderSize) { | |
| 418 next_state_ = STATE_HANDSHAKE_READ; | |
| 419 return OK; | |
| 420 } | |
| 421 | |
| 422 const SOCKS4ServerResponse* response = | |
| 423 reinterpret_cast<const SOCKS4ServerResponse*>(buffer_.data()); | |
| 424 | |
| 425 if (response->reserved_null != 0x00) { | |
| 426 LOG(ERROR) << "Unknown response from SOCKS server."; | |
| 427 return ERR_SOCKS_CONNECTION_FAILED; | |
| 428 } | |
| 429 | |
| 430 switch (response->code) { | |
| 431 case kServerResponseOk: | |
| 432 completed_handshake_ = true; | |
| 433 return OK; | |
| 434 case kServerResponseRejected: | |
| 435 LOG(ERROR) << "SOCKS request rejected or failed"; | |
| 436 return ERR_SOCKS_CONNECTION_FAILED; | |
| 437 case kServerResponseNotReachable: | |
| 438 LOG(ERROR) << "SOCKS request failed because client is not running " | |
| 439 << "identd (or not reachable from the server)"; | |
| 440 return ERR_SOCKS_CONNECTION_HOST_UNREACHABLE; | |
| 441 case kServerResponseMismatchedUserId: | |
| 442 LOG(ERROR) << "SOCKS request failed because client's identd could " | |
| 443 << "not confirm the user ID string in the request"; | |
| 444 return ERR_SOCKS_CONNECTION_FAILED; | |
| 445 default: | |
| 446 LOG(ERROR) << "SOCKS server sent unknown response"; | |
| 447 return ERR_SOCKS_CONNECTION_FAILED; | |
| 448 } | |
| 449 | |
| 450 // Note: we ignore the last 6 bytes as specified by the SOCKS protocol | |
| 451 } | |
| 452 | |
| 453 int SOCKSClientSocket::GetPeerAddress(IPEndPoint* address) const { | |
| 454 return transport_->socket()->GetPeerAddress(address); | |
| 455 } | |
| 456 | |
| 457 int SOCKSClientSocket::GetLocalAddress(IPEndPoint* address) const { | |
| 458 return transport_->socket()->GetLocalAddress(address); | |
| 459 } | |
| 460 | |
| 461 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master