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 } // namespace 68 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 80 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 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 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 118 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 141 ProxyServer ProxyServer::FromPacString(const std::string& pac_string) { 142 return FromPacString(pac_string.begin(), pac_string.end()); 143 } 144 145 // static 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 170 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 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 211 ProxyServer::Scheme ProxyServer::GetSchemeFromURI(const std::string& scheme) { 212 return GetSchemeFromURIInternal(scheme.begin(), scheme.end()); 213 } 214 215 // static 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
