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