• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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.
GetSchemeFromPacTypeInternal(std::string::const_iterator begin,std::string::const_iterator end)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.
GetSchemeFromURIInternal(std::string::const_iterator begin,std::string::const_iterator end)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 }  // namespace
68 
ProxyServer(Scheme scheme,const HostPortPair & host_port_pair)69 ProxyServer::ProxyServer(Scheme scheme, const HostPortPair& host_port_pair)
70       : scheme_(scheme), host_port_pair_(host_port_pair) {
71   if (scheme_ == SCHEME_DIRECT || scheme_ == SCHEME_INVALID) {
72     // |host_port_pair| isn't relevant for these special schemes, so none should
73     // have been specified. It is important for this to be consistent since we
74     // do raw field comparisons in the equality and comparison functions.
75     DCHECK(host_port_pair.Equals(HostPortPair()));
76     host_port_pair_ = HostPortPair();
77   }
78 }
79 
host_port_pair() const80 const HostPortPair& ProxyServer::host_port_pair() const {
81   // Doesn't make sense to call this if the URI scheme doesn't
82   // have concept of a host.
83   DCHECK(is_valid());
84   DCHECK(!is_direct());
85   return host_port_pair_;
86 }
87 
88 // static
FromURI(const std::string & uri,Scheme default_scheme)89 ProxyServer ProxyServer::FromURI(const std::string& uri,
90                                  Scheme default_scheme) {
91   return FromURI(uri.begin(), uri.end(), default_scheme);
92 }
93 
94 // static
FromURI(std::string::const_iterator begin,std::string::const_iterator end,Scheme default_scheme)95 ProxyServer ProxyServer::FromURI(std::string::const_iterator begin,
96                                  std::string::const_iterator end,
97                                  Scheme default_scheme) {
98   // We will default to |default_scheme| if no scheme specifier was given.
99   Scheme scheme = default_scheme;
100 
101   // Trim the leading/trailing whitespace.
102   HttpUtil::TrimLWS(&begin, &end);
103 
104   // Check for [<scheme> "://"]
105   std::string::const_iterator colon = std::find(begin, end, ':');
106   if (colon != end &&
107       (end - colon) >= 3 &&
108       *(colon + 1) == '/' &&
109       *(colon + 2) == '/') {
110     scheme = GetSchemeFromURIInternal(begin, colon);
111     begin = colon + 3;  // Skip past the "://"
112   }
113 
114   // Now parse the <host>[":"<port>].
115   return FromSchemeHostAndPort(scheme, begin, end);
116 }
117 
ToURI() const118 std::string ProxyServer::ToURI() const {
119   switch (scheme_) {
120     case SCHEME_DIRECT:
121       return "direct://";
122     case SCHEME_HTTP:
123       // Leave off "http://" since it is our default scheme.
124       return host_port_pair().ToString();
125     case SCHEME_SOCKS4:
126       return std::string("socks4://") + host_port_pair().ToString();
127     case SCHEME_SOCKS5:
128       return std::string("socks5://") + host_port_pair().ToString();
129     case SCHEME_HTTPS:
130       return std::string("https://") + host_port_pair().ToString();
131     case SCHEME_QUIC:
132       return std::string("quic://") + host_port_pair().ToString();
133     default:
134       // Got called with an invalid scheme.
135       NOTREACHED();
136       return std::string();
137   }
138 }
139 
140 // static
FromPacString(const std::string & pac_string)141 ProxyServer ProxyServer::FromPacString(const std::string& pac_string) {
142   return FromPacString(pac_string.begin(), pac_string.end());
143 }
144 
145 // static
FromPacString(std::string::const_iterator begin,std::string::const_iterator end)146 ProxyServer ProxyServer::FromPacString(std::string::const_iterator begin,
147                                        std::string::const_iterator end) {
148   // Trim the leading/trailing whitespace.
149   HttpUtil::TrimLWS(&begin, &end);
150 
151   // Input should match:
152   // "DIRECT" | ( <type> 1*(LWS) <host-and-port> )
153 
154   // Start by finding the first space (if any).
155   std::string::const_iterator space;
156   for (space = begin; space != end; ++space) {
157     if (HttpUtil::IsLWS(*space)) {
158       break;
159     }
160   }
161 
162   // Everything to the left of the space is the scheme.
163   Scheme scheme = GetSchemeFromPacTypeInternal(begin, space);
164 
165   // And everything to the right of the space is the
166   // <host>[":" <port>].
167   return FromSchemeHostAndPort(scheme, space, end);
168 }
169 
ToPacString() const170 std::string ProxyServer::ToPacString() const {
171     switch (scheme_) {
172     case SCHEME_DIRECT:
173       return "DIRECT";
174     case SCHEME_HTTP:
175       return std::string("PROXY ") + host_port_pair().ToString();
176     case SCHEME_SOCKS4:
177       // For compatibility send SOCKS instead of SOCKS4.
178       return std::string("SOCKS ") + host_port_pair().ToString();
179     case SCHEME_SOCKS5:
180       return std::string("SOCKS5 ") + host_port_pair().ToString();
181     case SCHEME_HTTPS:
182       return std::string("HTTPS ") + host_port_pair().ToString();
183     case SCHEME_QUIC:
184       return std::string("QUIC ") + host_port_pair().ToString();
185     default:
186       // Got called with an invalid scheme.
187       NOTREACHED();
188       return std::string();
189   }
190 }
191 
192 // static
GetDefaultPortForScheme(Scheme scheme)193 int ProxyServer::GetDefaultPortForScheme(Scheme scheme) {
194   switch (scheme) {
195     case SCHEME_HTTP:
196       return 80;
197     case SCHEME_SOCKS4:
198     case SCHEME_SOCKS5:
199       return 1080;
200     case SCHEME_HTTPS:
201     case SCHEME_QUIC:
202       return 443;
203     case SCHEME_INVALID:
204     case SCHEME_DIRECT:
205       break;
206   }
207   return -1;
208 }
209 
210 // static
GetSchemeFromURI(const std::string & scheme)211 ProxyServer::Scheme ProxyServer::GetSchemeFromURI(const std::string& scheme) {
212   return GetSchemeFromURIInternal(scheme.begin(), scheme.end());
213 }
214 
215 // static
FromSchemeHostAndPort(Scheme scheme,std::string::const_iterator begin,std::string::const_iterator end)216 ProxyServer ProxyServer::FromSchemeHostAndPort(
217     Scheme scheme,
218     std::string::const_iterator begin,
219     std::string::const_iterator end) {
220 
221   // Trim leading/trailing space.
222   HttpUtil::TrimLWS(&begin, &end);
223 
224   if (scheme == SCHEME_DIRECT && begin != end)
225     return ProxyServer();  // Invalid -- DIRECT cannot have a host/port.
226 
227   HostPortPair host_port_pair;
228 
229   if (scheme != SCHEME_INVALID && scheme != SCHEME_DIRECT) {
230     std::string host;
231     int port = -1;
232     // If the scheme has a host/port, parse it.
233     bool ok = net::ParseHostAndPort(begin, end, &host, &port);
234     if (!ok)
235       return ProxyServer();  // Invalid -- failed parsing <host>[":"<port>]
236 
237     // Choose a default port number if none was given.
238     if (port == -1)
239       port = GetDefaultPortForScheme(scheme);
240 
241     host_port_pair = HostPortPair(host, port);
242   }
243 
244   return ProxyServer(scheme, host_port_pair);
245 }
246 
247 }  // namespace net
248