net/proxy/proxy_server.cc

   1 // Copyright (c) 2010 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/proxy/proxy_server.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/strings/string_util.h"
  10 #include "net/base/net_util.h"
  11 #include "net/http/http_util.h"
  12
  13 namespace net {
  14
  15 namespace {
  16
  17 // Parses the proxy type from a PAC string, to a ProxyServer::Scheme.
  18 // This mapping is case-insensitive. If no type could be matched
  19 // returns SCHEME_INVALID.
  20 ProxyServer::Scheme GetSchemeFromPacTypeInternal(
  21     std::string::const_iterator begin,
  22     std::string::const_iterator end) {
  23   if (LowerCaseEqualsASCII(begin, end, "proxy"))
  24     return ProxyServer::SCHEME_HTTP;
  25   if (LowerCaseEqualsASCII(begin, end, "socks")) {
  26     // Default to v4 for compatibility. This is because the SOCKS4 vs SOCKS5
  27     // notation didn't originally exist, so if a client returns SOCKS they
  28     // really meant SOCKS4.
  29     return ProxyServer::SCHEME_SOCKS4;
  30   }
  31   if (LowerCaseEqualsASCII(begin, end, "socks4"))
  32     return ProxyServer::SCHEME_SOCKS4;
  33   if (LowerCaseEqualsASCII(begin, end, "socks5"))
  34     return ProxyServer::SCHEME_SOCKS5;
  35   if (LowerCaseEqualsASCII(begin, end, "direct"))
  36     return ProxyServer::SCHEME_DIRECT;
  37   if (LowerCaseEqualsASCII(begin, end, "https"))
  38     return ProxyServer::SCHEME_HTTPS;
  39   if (LowerCaseEqualsASCII(begin, end, "quic"))
  40     return ProxyServer::SCHEME_QUIC;
  41
  42   return ProxyServer::SCHEME_INVALID;
  43 }
  44
  45 // Parses the proxy scheme from a URL-like representation, to a
  46 // ProxyServer::Scheme. This corresponds with the values used in
  47 // ProxyServer::ToURI(). If no type could be matched, returns SCHEME_INVALID.
  48 ProxyServer::Scheme GetSchemeFromURIInternal(std::string::const_iterator begin,
  49                                              std::string::const_iterator end) {
  50   if (LowerCaseEqualsASCII(begin, end, "http"))
  51     return ProxyServer::SCHEME_HTTP;
  52   if (LowerCaseEqualsASCII(begin, end, "socks4"))
  53     return ProxyServer::SCHEME_SOCKS4;
  54   if (LowerCaseEqualsASCII(begin, end, "socks"))
  55     return ProxyServer::SCHEME_SOCKS5;
  56   if (LowerCaseEqualsASCII(begin, end, "socks5"))
  57     return ProxyServer::SCHEME_SOCKS5;
  58   if (LowerCaseEqualsASCII(begin, end, "direct"))
  59     return ProxyServer::SCHEME_DIRECT;
  60   if (LowerCaseEqualsASCII(begin, end, "https"))
  61     return ProxyServer::SCHEME_HTTPS;
  62   if (LowerCaseEqualsASCII(begin, end, "quic"))
  63     return ProxyServer::SCHEME_QUIC;
  64   return ProxyServer::SCHEME_INVALID;
  65 }
  66
  67 std::string HostNoBrackets(const std::string& host) {
  68   // Remove brackets from an RFC 2732-style IPv6 literal address.
  69   const std::string::size_type len = host.size();
  70   if (len >= 2 && host[0] == '[' && host[len - 1] == ']')
  71     return host.substr(1, len - 2);
  72   return host;
  73 }
  74
  75 }  // namespace
  76
  77 ProxyServer::ProxyServer(Scheme scheme, const HostPortPair& host_port_pair)
  78       : scheme_(scheme), host_port_pair_(host_port_pair) {
  79   if (scheme_ == SCHEME_DIRECT || scheme_ == SCHEME_INVALID) {
  80     // |host_port_pair| isn't relevant for these special schemes, so none should
  81     // have been specified. It is important for this to be consistent since we
  82     // do raw field comparisons in the equality and comparison functions.
  83     DCHECK(host_port_pair.Equals(HostPortPair()));
  84     host_port_pair_ = HostPortPair();
  85   }
  86 }
  87
  88 const HostPortPair& ProxyServer::host_port_pair() const {
  89   // Doesn't make sense to call this if the URI scheme doesn't
  90   // have concept of a host.
  91   DCHECK(is_valid() && !is_direct());
  92   return host_port_pair_;
  93 }
  94
  95 // static
  96 ProxyServer ProxyServer::FromURI(const std::string& uri,
  97                                  Scheme default_scheme) {
  98   return FromURI(uri.begin(), uri.end(), default_scheme);
  99 }
 100
 101 // static
 102 ProxyServer ProxyServer::FromURI(std::string::const_iterator begin,
 103                                  std::string::const_iterator end,
 104                                  Scheme default_scheme) {
 105   // We will default to |default_scheme| if no scheme specifier was given.
 106   Scheme scheme = default_scheme;
 107
 108   // Trim the leading/trailing whitespace.
 109   HttpUtil::TrimLWS(&begin, &end);
 110
 111   // Check for [<scheme> "://"]
 112   std::string::const_iterator colon = std::find(begin, end, ':');
 113   if (colon != end &&
 114       (end - colon) >= 3 &&
 115       *(colon + 1) == '/' &&
 116       *(colon + 2) == '/') {
 117     scheme = GetSchemeFromURIInternal(begin, colon);
 118     begin = colon + 3;  // Skip past the "://"
 119   }
 120
 121   // Now parse the <host>[":"<port>].
 122   return FromSchemeHostAndPort(scheme, begin, end);
 123 }
 124
 125 std::string ProxyServer::ToURI() const {
 126   switch (scheme_) {
 127     case SCHEME_DIRECT:
 128       return "direct://";
 129     case SCHEME_HTTP:
 130       // Leave off "http://" since it is our default scheme.
 131       return host_port_pair().ToString();
 132     case SCHEME_SOCKS4:
 133       return std::string("socks4://") + host_port_pair().ToString();
 134     case SCHEME_SOCKS5:
 135       return std::string("socks5://") + host_port_pair().ToString();
 136     case SCHEME_HTTPS:
 137       return std::string("https://") + host_port_pair().ToString();
 138     case SCHEME_QUIC:
 139       return std::string("quic://") + host_port_pair().ToString();
 140     default:
 141       // Got called with an invalid scheme.
 142       NOTREACHED();
 143       return std::string();
 144   }
 145 }
 146
 147 // static
 148 ProxyServer ProxyServer::FromPacString(const std::string& pac_string) {
 149   return FromPacString(pac_string.begin(), pac_string.end());
 150 }
 151
 152 // static
 153 ProxyServer ProxyServer::FromPacString(std::string::const_iterator begin,
 154                                        std::string::const_iterator end) {
 155   // Trim the leading/trailing whitespace.
 156   HttpUtil::TrimLWS(&begin, &end);
 157
 158   // Input should match:
 159   // "DIRECT" | ( <type> 1*(LWS) <host-and-port> )
 160
 161   // Start by finding the first space (if any).
 162   std::string::const_iterator space;
 163   for (space = begin; space != end; ++space) {
 164     if (HttpUtil::IsLWS(*space)) {
 165       break;
 166     }
 167   }
 168
 169   // Everything to the left of the space is the scheme.
 170   Scheme scheme = GetSchemeFromPacTypeInternal(begin, space);
 171
 172   // And everything to the right of the space is the
 173   // <host>[":" <port>].
 174   return FromSchemeHostAndPort(scheme, space, end);
 175 }
 176
 177 std::string ProxyServer::ToPacString() const {
 178     switch (scheme_) {
 179     case SCHEME_DIRECT:
 180       return "DIRECT";
 181     case SCHEME_HTTP:
 182       return std::string("PROXY ") + host_port_pair().ToString();
 183     case SCHEME_SOCKS4:
 184       // For compatibility send SOCKS instead of SOCKS4.
 185       return std::string("SOCKS ") + host_port_pair().ToString();
 186     case SCHEME_SOCKS5:
 187       return std::string("SOCKS5 ") + host_port_pair().ToString();
 188     case SCHEME_HTTPS:
 189       return std::string("HTTPS ") + host_port_pair().ToString();
 190     case SCHEME_QUIC:
 191       return std::string("QUIC ") + host_port_pair().ToString();
 192     default:
 193       // Got called with an invalid scheme.
 194       NOTREACHED();
 195       return std::string();
 196   }
 197 }
 198
 199 // static
 200 int ProxyServer::GetDefaultPortForScheme(Scheme scheme) {
 201   switch (scheme) {
 202     case SCHEME_HTTP:
 203       return 80;
 204     case SCHEME_SOCKS4:
 205     case SCHEME_SOCKS5:
 206       return 1080;
 207     case SCHEME_HTTPS:
 208     case SCHEME_QUIC:
 209       return 443;
 210     case SCHEME_INVALID:
 211     case SCHEME_DIRECT:
 212       break;
 213   }
 214   return -1;
 215 }
 216
 217 // static
 218 ProxyServer::Scheme ProxyServer::GetSchemeFromURI(const std::string& scheme) {
 219   return GetSchemeFromURIInternal(scheme.begin(), scheme.end());
 220 }
 221
 222 // static
 223 ProxyServer ProxyServer::FromSchemeHostAndPort(
 224     Scheme scheme,
 225     std::string::const_iterator begin,
 226     std::string::const_iterator end) {
 227
 228   // Trim leading/trailing space.
 229   HttpUtil::TrimLWS(&begin, &end);
 230
 231   if (scheme == SCHEME_DIRECT && begin != end)
 232     return ProxyServer();  // Invalid -- DIRECT cannot have a host/port.
 233
 234   HostPortPair host_port_pair;
 235
 236   if (scheme != SCHEME_INVALID && scheme != SCHEME_DIRECT) {
 237     std::string host;
 238     int port = -1;
 239     // If the scheme has a host/port, parse it.
 240     bool ok = net::ParseHostAndPort(begin, end, &host, &port);
 241     if (!ok)
 242       return ProxyServer();  // Invalid -- failed parsing <host>[":"<port>]
 243
 244     // Choose a default port number if none was given.
 245     if (port == -1)
 246       port = GetDefaultPortForScheme(scheme);
 247
 248     host_port_pair = HostPortPair(HostNoBrackets(host), port);
 249   }
 250
 251   return ProxyServer(scheme, host_port_pair);
 252 }
 253
 254 }  // namespace net