Add two more unit tests for SOCKS5:...

net/socket/socks5_client_socket.cc

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/socket/socks5_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/trace_event.h"
 #include "net/base/io_buffer.h"
@@ skipping 67 matching lines @@
   return completed_handshake_ && transport_->IsConnected();
 }
 
 bool SOCKS5ClientSocket::IsConnectedAndIdle() const {
   return completed_handshake_ && transport_->IsConnectedAndIdle();
 }
 
 // Read is called by the transport layer above to read. This can only be done
 // if the SOCKS handshake is complete.
 int SOCKS5ClientSocket::Read(IOBuffer* buf, int buf_len,
-                            CompletionCallback* callback) {
+                             CompletionCallback* callback) {
   DCHECK(completed_handshake_);
   DCHECK_EQ(STATE_NONE, next_state_);
   DCHECK(!user_callback_);
 
   return transport_->Read(buf, buf_len, callback);
 }
 
 // Write is called by the transport layer. This can only be done if the
 // SOCKS handshake is complete.
 int SOCKS5ClientSocket::Write(IOBuffer* buf, int buf_len,
@@ skipping 76 matching lines @@
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
   return rv;
 }
 
 const char kSOCKS5GreetWriteData[] = { 0x05, 0x01, 0x00 };  // no authentication
 const char kSOCKS5GreetReadData[] = { 0x05, 0x00 };
 
 int SOCKS5ClientSocket::DoGreetWrite() {
+  // Since we only have 1 byte to send the hostname length in, if the
+  // URL has a hostname longer than 255 characters we can't send it.
+  if (0xFF < host_request_info_.hostname().size())
+    return ERR_INVALID_URL;
+
   if (buffer_.empty()) {
     buffer_ = std::string(kSOCKS5GreetWriteData,
                           arraysize(kSOCKS5GreetWriteData));
     bytes_sent_ = 0;
   }
 
   next_state_ = STATE_GREET_WRITE_COMPLETE;
   size_t handshake_buf_len = buffer_.size() - bytes_sent_;
   handshake_buf_ = new IOBuffer(handshake_buf_len);
   memcpy(handshake_buf_->data(), &buffer_.data()[bytes_sent_],
@@ skipping 49 matching lines @@
 int SOCKS5ClientSocket::BuildHandshakeWriteBuffer(std::string* handshake)
     const {
   DCHECK(handshake->empty());
 
   handshake->push_back(kSOCKS5Version);
   handshake->push_back(kTunnelCommand);  // Connect command
   handshake->push_back(kNullByte);  // Reserved null
 
   handshake->push_back(kEndPointDomain);  // The type of the address.
 
-  // We only have 1 byte to send the length in, so if the hostname is
-  // longer than this we can't send it!
-  if(256 <= host_request_info_.hostname().size())
-    return ERR_INVALID_URL;
+  DCHECK_GE(static_cast<size_t>(0xFF), host_request_info_.hostname().size());
 
   // First add the size of the hostname, followed by the hostname.
   handshake->push_back(static_cast<unsigned char>(
       host_request_info_.hostname().size()));
   handshake->append(host_request_info_.hostname());
 
   uint16 nw_port = htons(host_request_info_.port());
   handshake->append(reinterpret_cast<char*>(&nw_port), sizeof(nw_port));
   return OK;
 }
@@ skipping 106 matching lines @@
 }
 
 #if defined(OS_LINUX)
 int SOCKS5ClientSocket::GetPeerName(struct sockaddr* name,
                                     socklen_t* namelen) {
   return transport_->GetPeerName(name, namelen);
 }
 #endif
 
 }  // namespace net