Adding socks4 support for chromium. tested for windows and linux....

net/http/http_network_transaction.cc

 // Copyright (c) 2006-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/http/http_network_transaction.h"
 
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "build/build_config.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/ssl_cert_request_info.h"
 #include "net/base/upload_data_stream.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_basic_stream.h"
 #include "net/http/http_chunked_decoder.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/socket/client_socket_factory.h"
+#include "net/socket/socks_client_socket.h"
 #include "net/socket/ssl_client_socket.h"
 
 using base::Time;
 
 namespace net {
 
 void HttpNetworkTransaction::ResponseHeaders::Realloc(size_t new_size) {
   headers_.reset(static_cast<char*>(realloc(headers_.release(), new_size)));
 }
 
@@ skipping 95 matching lines @@
       user_callback_(NULL),
       session_(session),
       request_(NULL),
       pac_request_(NULL),
       socket_factory_(csf),
       connection_(session->connection_pool()),
       reused_socket_(false),
       using_ssl_(false),
       using_proxy_(false),
       using_tunnel_(false),
+      using_socks_proxy_(false),
       establishing_tunnel_(false),
       reading_body_from_socket_(false),
       request_headers_(new RequestHeaders()),
       request_headers_bytes_sent_(0),
       header_buf_(new ResponseHeaders()),
       header_buf_capacity_(0),
       header_buf_len_(0),
       header_buf_body_offset_(-1),
       header_buf_http_offset_(-1),
       response_body_length_(-1),  // -1 means unspecified.
@@ skipping 287 matching lines @@
         break;
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.init_conn", request_, request_->url.spec());
         rv = DoInitConnection();
         break;
       case STATE_INIT_CONNECTION_COMPLETE:
         rv = DoInitConnectionComplete(rv);
         TRACE_EVENT_END("http.init_conn", request_, request_->url.spec());
         break;
+      case STATE_SOCKS_CONNECT:
+        DCHECK_EQ(OK, rv);
+        TRACE_EVENT_BEGIN("http.socks_connect", request_, request_->url.spec());
+        rv = DoSOCKSConnect();
+        break;
+      case STATE_SOCKS_CONNECT_COMPLETE:
+        rv = DoSOCKSConnectComplete(rv);
+        TRACE_EVENT_END("http.socks_connect", request_, request_->url.spec());
+        break;
       case STATE_SSL_CONNECT:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.ssl_connect", request_, request_->url.spec());
         rv = DoSSLConnect();
         break;
       case STATE_SSL_CONNECT_COMPLETE:
         rv = DoSSLConnectComplete(rv);
         TRACE_EVENT_END("http.ssl_connect", request_, request_->url.spec());
         break;
       case STATE_WRITE_HEADERS:
@@ skipping 63 matching lines @@
     return OK;
   }
 
   return session_->proxy_service()->ResolveProxy(
       request_->url, &proxy_info_, &io_callback_, &pac_request_);
 }
 
 int HttpNetworkTransaction::DoResolveProxyComplete(int result) {
   next_state_ = STATE_INIT_CONNECTION;
 
-  // Since we only support HTTP proxies or DIRECT connections, remove
-  // any other type of proxy from the list (i.e. SOCKS).
-  // Supporting SOCKS is issue http://crbug.com/469.
+  // Remove unsupported proxies (like SOCKS5) from the list.
   proxy_info_.RemoveProxiesWithoutScheme(
-      ProxyServer::SCHEME_DIRECT | ProxyServer::SCHEME_HTTP);
+      ProxyServer::SCHEME_DIRECT | ProxyServer::SCHEME_HTTP |
+      ProxyServer::SCHEME_SOCKS4);
 
   pac_request_ = NULL;
 
   if (result != OK) {
     DLOG(ERROR) << "Failed to resolve proxy: " << result;
     proxy_info_.UseDirect();
   }
   return OK;
 }
 
 int HttpNetworkTransaction::DoInitConnection() {
   DCHECK(!connection_.is_initialized());
 
   next_state_ = STATE_INIT_CONNECTION_COMPLETE;
 
   using_ssl_ = request_->url.SchemeIs("https");
-  using_proxy_ = !proxy_info_.is_direct() && !using_ssl_;
-  using_tunnel_ = !proxy_info_.is_direct() && using_ssl_;
+  using_socks_proxy_ = !proxy_info_.is_direct() &&
+      proxy_info_.proxy_server().is_socks();
+  using_proxy_ = !proxy_info_.is_direct() && !using_ssl_ && !using_socks_proxy_;
+  using_tunnel_ = !proxy_info_.is_direct() && using_ssl_ && !using_socks_proxy_;
 
   // Build the string used to uniquely identify connections of this type.
   // Determine the host and port to connect to.
   std::string connection_group;
   std::string host;
   int port;
-  if (using_proxy_ || using_tunnel_) {
+  if (using_proxy_ || using_tunnel_ || using_socks_proxy_) {
     ProxyServer proxy_server = proxy_info_.proxy_server();
     connection_group = "proxy/" + proxy_server.ToURI() + "/";
     host = proxy_server.HostNoBrackets();
     port = proxy_server.port();
   } else {
     host = request_->url.HostNoBrackets();
     port = request_->url.EffectiveIntPort();
   }
-  if (!using_proxy_)
+  if (!using_proxy_ && !using_socks_proxy_)
     connection_group.append(request_->url.GetOrigin().spec());
 
   DCHECK(!connection_group.empty());
 
   HostResolver::RequestInfo resolve_info(host, port);
 
   // The referrer is used by the DNS prefetch system to corellate resolutions
   // with the page that triggered them. It doesn't impact the actual addresses
   // that we resolve to.
   resolve_info.set_referrer(request_->referrer);
@@ skipping 18 matching lines @@
   // Set the reused_socket_ flag to indicate that we are using a keep-alive
   // connection.  This flag is used to handle errors that occur while we are
   // trying to reuse a keep-alive connection.
   reused_socket_ = connection_.is_reused();
   if (reused_socket_) {
     next_state_ = STATE_WRITE_HEADERS;
   } else {
     // Now we have a TCP connected socket.  Perform other connection setup as
     // needed.
     LogTCPConnectedMetrics();
-    if (using_ssl_ && !using_tunnel_) {
+    if (using_socks_proxy_)
+      next_state_ = STATE_SOCKS_CONNECT;
+    else if (using_ssl_ && !using_tunnel_) {
       next_state_ = STATE_SSL_CONNECT;
     } else {
       next_state_ = STATE_WRITE_HEADERS;
       if (using_tunnel_)
         establishing_tunnel_ = true;
     }
   }
   http_stream_.reset(new HttpBasicStream(&connection_));
   return OK;
 }
 
+int HttpNetworkTransaction::DoSOCKSConnect() {
+  DCHECK(using_socks_proxy_);
+  DCHECK(!using_proxy_);
+  DCHECK(!using_tunnel_);
+
+  next_state_ = STATE_SOCKS_CONNECT_COMPLETE;
+
+  // Add a SOCKS connection on top of our existing transport socket.
+  ClientSocket* s = connection_.release_socket();
+  HostResolver::RequestInfo req_info(request_->url.HostNoBrackets(),
+                                     request_->url.EffectiveIntPort());
+  req_info.set_referrer(request_->referrer);
+
+  s = new SOCKSClientSocket(s, req_info, session_->host_resolver());
+  connection_.set_socket(s);
+  return connection_.socket()->Connect(&io_callback_);
+}
+
+int HttpNetworkTransaction::DoSOCKSConnectComplete(int result) {
+  DCHECK(using_socks_proxy_);
+  DCHECK(!using_proxy_);
+  DCHECK(!using_tunnel_);
+
+  if (result == OK) {
+    if (using_ssl_) {
+      next_state_ = STATE_SSL_CONNECT;
+    } else {
+      next_state_ = STATE_WRITE_HEADERS;
+    }
+  } else {
+    result = ReconsiderProxyAfterError(result);
+  }
+  return result;
+}
+
 int HttpNetworkTransaction::DoSSLConnect() {
   next_state_ = STATE_SSL_CONNECT_COMPLETE;
 
   // Add a SSL socket on top of our existing transport socket.
   ClientSocket* s = connection_.release_socket();
   s = socket_factory_->CreateSSLClientSocket(
       s, request_->url.HostNoBrackets(), ssl_config_);
   connection_.set_socket(s);
   return connection_.socket()->Connect(&io_callback_);
 }
@@ skipping 1074 matching lines @@
     host_and_port = proxy_info_.proxy_server().host_and_port();
   } else {
     DCHECK(target == HttpAuth::AUTH_SERVER);
     host_and_port = GetHostAndPort(request_->url);
   }
   auth_info->host_and_port = ASCIIToWide(host_and_port);
   response_.auth_challenge = auth_info;
 }
 
 }  // namespace net