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