net/socket/socks_client_socket.cc

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