Upstream version 5.34.104.0
[platform/framework/web/crosswalk.git] / src / 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 // TODO(bengr): Use |scheme_| to indicate that this is the data reduction proxy.
223 #if defined(SPDY_PROXY_AUTH_ORIGIN)
224 bool ProxyServer::isDataReductionProxy() const {
225     bool dev_host = false;
226 #if defined (DATA_REDUCTION_DEV_HOST)
227     dev_host = host_port_pair_.Equals(
228         HostPortPair::FromURL(GURL(DATA_REDUCTION_DEV_HOST)));
229 #endif
230   return dev_host || host_port_pair_.Equals(
231       HostPortPair::FromURL(GURL(SPDY_PROXY_AUTH_ORIGIN)));
232 }
233
234 bool ProxyServer::isDataReductionProxyFallback() const {
235 #if defined(DATA_REDUCTION_FALLBACK_HOST)
236   return host_port_pair_.Equals(
237       HostPortPair::FromURL(GURL(DATA_REDUCTION_FALLBACK_HOST)));
238 #endif  // defined(DATA_REDUCTION_FALLBACK_HOST)
239   return false;
240 }
241 #endif  // defined(SPDY_PROXY_AUTH_ORIGIN)
242
243 // static
244 ProxyServer ProxyServer::FromSchemeHostAndPort(
245     Scheme scheme,
246     std::string::const_iterator begin,
247     std::string::const_iterator end) {
248
249   // Trim leading/trailing space.
250   HttpUtil::TrimLWS(&begin, &end);
251
252   if (scheme == SCHEME_DIRECT && begin != end)
253     return ProxyServer();  // Invalid -- DIRECT cannot have a host/port.
254
255   HostPortPair host_port_pair;
256
257   if (scheme != SCHEME_INVALID && scheme != SCHEME_DIRECT) {
258     std::string host;
259     int port = -1;
260     // If the scheme has a host/port, parse it.
261     bool ok = net::ParseHostAndPort(begin, end, &host, &port);
262     if (!ok)
263       return ProxyServer();  // Invalid -- failed parsing <host>[":"<port>]
264
265     // Choose a default port number if none was given.
266     if (port == -1)
267       port = GetDefaultPortForScheme(scheme);
268
269     host_port_pair = HostPortPair(HostNoBrackets(host), port);
270   }
271
272   return ProxyServer(scheme, host_port_pair);
273 }
274
275 }  // namespace net