| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 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_bypass_rules.h" | |
| 6 | |
| 7 #include "base/stl_util.h" | |
| 8 #include "base/strings/string_number_conversions.h" | |
| 9 #include "base/strings/string_piece.h" | |
| 10 #include "base/strings/string_tokenizer.h" | |
| 11 #include "base/strings/string_util.h" | |
| 12 #include "base/strings/stringprintf.h" | |
| 13 #include "net/base/host_port_pair.h" | |
| 14 #include "net/base/net_util.h" | |
| 15 | |
| 16 namespace net { | |
| 17 | |
| 18 namespace { | |
| 19 | |
| 20 class HostnamePatternRule : public ProxyBypassRules::Rule { | |
| 21 public: | |
| 22 HostnamePatternRule(const std::string& optional_scheme, | |
| 23 const std::string& hostname_pattern, | |
| 24 int optional_port) | |
| 25 : optional_scheme_(base::StringToLowerASCII(optional_scheme)), | |
| 26 hostname_pattern_(base::StringToLowerASCII(hostname_pattern)), | |
| 27 optional_port_(optional_port) { | |
| 28 } | |
| 29 | |
| 30 bool Matches(const GURL& url) const override { | |
| 31 if (optional_port_ != -1 && url.EffectiveIntPort() != optional_port_) | |
| 32 return false; // Didn't match port expectation. | |
| 33 | |
| 34 if (!optional_scheme_.empty() && url.scheme() != optional_scheme_) | |
| 35 return false; // Didn't match scheme expectation. | |
| 36 | |
| 37 // Note it is necessary to lower-case the host, since GURL uses capital | |
| 38 // letters for percent-escaped characters. | |
| 39 return MatchPattern(base::StringToLowerASCII(url.host()), | |
| 40 hostname_pattern_); | |
| 41 } | |
| 42 | |
| 43 std::string ToString() const override { | |
| 44 std::string str; | |
| 45 if (!optional_scheme_.empty()) | |
| 46 base::StringAppendF(&str, "%s://", optional_scheme_.c_str()); | |
| 47 str += hostname_pattern_; | |
| 48 if (optional_port_ != -1) | |
| 49 base::StringAppendF(&str, ":%d", optional_port_); | |
| 50 return str; | |
| 51 } | |
| 52 | |
| 53 Rule* Clone() const override { | |
| 54 return new HostnamePatternRule(optional_scheme_, | |
| 55 hostname_pattern_, | |
| 56 optional_port_); | |
| 57 } | |
| 58 | |
| 59 private: | |
| 60 const std::string optional_scheme_; | |
| 61 const std::string hostname_pattern_; | |
| 62 const int optional_port_; | |
| 63 }; | |
| 64 | |
| 65 class BypassLocalRule : public ProxyBypassRules::Rule { | |
| 66 public: | |
| 67 bool Matches(const GURL& url) const override { | |
| 68 const std::string& host = url.host(); | |
| 69 if (host == "127.0.0.1" || host == "[::1]") | |
| 70 return true; | |
| 71 return host.find('.') == std::string::npos; | |
| 72 } | |
| 73 | |
| 74 std::string ToString() const override { return "<local>"; } | |
| 75 | |
| 76 Rule* Clone() const override { return new BypassLocalRule(); } | |
| 77 }; | |
| 78 | |
| 79 // Rule for matching a URL that is an IP address, if that IP address falls | |
| 80 // within a certain numeric range. For example, you could use this rule to | |
| 81 // match all the IPs in the CIDR block 10.10.3.4/24. | |
| 82 class BypassIPBlockRule : public ProxyBypassRules::Rule { | |
| 83 public: | |
| 84 // |ip_prefix| + |prefix_length| define the IP block to match. | |
| 85 BypassIPBlockRule(const std::string& description, | |
| 86 const std::string& optional_scheme, | |
| 87 const IPAddressNumber& ip_prefix, | |
| 88 size_t prefix_length_in_bits) | |
| 89 : description_(description), | |
| 90 optional_scheme_(optional_scheme), | |
| 91 ip_prefix_(ip_prefix), | |
| 92 prefix_length_in_bits_(prefix_length_in_bits) { | |
| 93 } | |
| 94 | |
| 95 bool Matches(const GURL& url) const override { | |
| 96 if (!url.HostIsIPAddress()) | |
| 97 return false; | |
| 98 | |
| 99 if (!optional_scheme_.empty() && url.scheme() != optional_scheme_) | |
| 100 return false; // Didn't match scheme expectation. | |
| 101 | |
| 102 // Parse the input IP literal to a number. | |
| 103 IPAddressNumber ip_number; | |
| 104 if (!ParseIPLiteralToNumber(url.HostNoBrackets(), &ip_number)) | |
| 105 return false; | |
| 106 | |
| 107 // Test if it has the expected prefix. | |
| 108 return IPNumberMatchesPrefix(ip_number, ip_prefix_, | |
| 109 prefix_length_in_bits_); | |
| 110 } | |
| 111 | |
| 112 std::string ToString() const override { return description_; } | |
| 113 | |
| 114 Rule* Clone() const override { | |
| 115 return new BypassIPBlockRule(description_, | |
| 116 optional_scheme_, | |
| 117 ip_prefix_, | |
| 118 prefix_length_in_bits_); | |
| 119 } | |
| 120 | |
| 121 private: | |
| 122 const std::string description_; | |
| 123 const std::string optional_scheme_; | |
| 124 const IPAddressNumber ip_prefix_; | |
| 125 const size_t prefix_length_in_bits_; | |
| 126 }; | |
| 127 | |
| 128 // Returns true if the given string represents an IP address. | |
| 129 // IPv6 addresses are expected to be bracketed. | |
| 130 bool IsIPAddress(const std::string& domain) { | |
| 131 // From GURL::HostIsIPAddress() | |
| 132 url::RawCanonOutputT<char, 128> ignored_output; | |
| 133 url::CanonHostInfo host_info; | |
| 134 url::Component domain_comp(0, domain.size()); | |
| 135 url::CanonicalizeIPAddress(domain.c_str(), domain_comp, &ignored_output, | |
| 136 &host_info); | |
| 137 return host_info.IsIPAddress(); | |
| 138 } | |
| 139 | |
| 140 } // namespace | |
| 141 | |
| 142 ProxyBypassRules::Rule::Rule() { | |
| 143 } | |
| 144 | |
| 145 ProxyBypassRules::Rule::~Rule() { | |
| 146 } | |
| 147 | |
| 148 bool ProxyBypassRules::Rule::Equals(const Rule& rule) const { | |
| 149 return ToString() == rule.ToString(); | |
| 150 } | |
| 151 | |
| 152 ProxyBypassRules::ProxyBypassRules() { | |
| 153 } | |
| 154 | |
| 155 ProxyBypassRules::ProxyBypassRules(const ProxyBypassRules& rhs) { | |
| 156 AssignFrom(rhs); | |
| 157 } | |
| 158 | |
| 159 ProxyBypassRules::~ProxyBypassRules() { | |
| 160 Clear(); | |
| 161 } | |
| 162 | |
| 163 ProxyBypassRules& ProxyBypassRules::operator=(const ProxyBypassRules& rhs) { | |
| 164 AssignFrom(rhs); | |
| 165 return *this; | |
| 166 } | |
| 167 | |
| 168 bool ProxyBypassRules::Matches(const GURL& url) const { | |
| 169 for (RuleList::const_iterator it = rules_.begin(); it != rules_.end(); ++it) { | |
| 170 if ((*it)->Matches(url)) | |
| 171 return true; | |
| 172 } | |
| 173 return false; | |
| 174 } | |
| 175 | |
| 176 bool ProxyBypassRules::Equals(const ProxyBypassRules& other) const { | |
| 177 if (rules_.size() != other.rules_.size()) | |
| 178 return false; | |
| 179 | |
| 180 for (size_t i = 0; i < rules_.size(); ++i) { | |
| 181 if (!rules_[i]->Equals(*other.rules_[i])) | |
| 182 return false; | |
| 183 } | |
| 184 return true; | |
| 185 } | |
| 186 | |
| 187 void ProxyBypassRules::ParseFromString(const std::string& raw) { | |
| 188 ParseFromStringInternal(raw, false); | |
| 189 } | |
| 190 | |
| 191 void ProxyBypassRules::ParseFromStringUsingSuffixMatching( | |
| 192 const std::string& raw) { | |
| 193 ParseFromStringInternal(raw, true); | |
| 194 } | |
| 195 | |
| 196 bool ProxyBypassRules::AddRuleForHostname(const std::string& optional_scheme, | |
| 197 const std::string& hostname_pattern, | |
| 198 int optional_port) { | |
| 199 if (hostname_pattern.empty()) | |
| 200 return false; | |
| 201 | |
| 202 rules_.push_back(new HostnamePatternRule(optional_scheme, | |
| 203 hostname_pattern, | |
| 204 optional_port)); | |
| 205 return true; | |
| 206 } | |
| 207 | |
| 208 void ProxyBypassRules::AddRuleToBypassLocal() { | |
| 209 rules_.push_back(new BypassLocalRule); | |
| 210 } | |
| 211 | |
| 212 bool ProxyBypassRules::AddRuleFromString(const std::string& raw) { | |
| 213 return AddRuleFromStringInternalWithLogging(raw, false); | |
| 214 } | |
| 215 | |
| 216 bool ProxyBypassRules::AddRuleFromStringUsingSuffixMatching( | |
| 217 const std::string& raw) { | |
| 218 return AddRuleFromStringInternalWithLogging(raw, true); | |
| 219 } | |
| 220 | |
| 221 std::string ProxyBypassRules::ToString() const { | |
| 222 std::string result; | |
| 223 for (RuleList::const_iterator rule(rules_.begin()); | |
| 224 rule != rules_.end(); | |
| 225 ++rule) { | |
| 226 result += (*rule)->ToString(); | |
| 227 result += ";"; | |
| 228 } | |
| 229 return result; | |
| 230 } | |
| 231 | |
| 232 void ProxyBypassRules::Clear() { | |
| 233 STLDeleteElements(&rules_); | |
| 234 } | |
| 235 | |
| 236 void ProxyBypassRules::AssignFrom(const ProxyBypassRules& other) { | |
| 237 Clear(); | |
| 238 | |
| 239 // Make a copy of the rules list. | |
| 240 for (RuleList::const_iterator it = other.rules_.begin(); | |
| 241 it != other.rules_.end(); ++it) { | |
| 242 rules_.push_back((*it)->Clone()); | |
| 243 } | |
| 244 } | |
| 245 | |
| 246 void ProxyBypassRules::ParseFromStringInternal( | |
| 247 const std::string& raw, | |
| 248 bool use_hostname_suffix_matching) { | |
| 249 Clear(); | |
| 250 | |
| 251 base::StringTokenizer entries(raw, ",;"); | |
| 252 while (entries.GetNext()) { | |
| 253 AddRuleFromStringInternalWithLogging(entries.token(), | |
| 254 use_hostname_suffix_matching); | |
| 255 } | |
| 256 } | |
| 257 | |
| 258 bool ProxyBypassRules::AddRuleFromStringInternal( | |
| 259 const std::string& raw_untrimmed, | |
| 260 bool use_hostname_suffix_matching) { | |
| 261 std::string raw; | |
| 262 base::TrimWhitespaceASCII(raw_untrimmed, base::TRIM_ALL, &raw); | |
| 263 | |
| 264 // This is the special syntax used by WinInet's bypass list -- we allow it | |
| 265 // on all platforms and interpret it the same way. | |
| 266 if (LowerCaseEqualsASCII(raw, "<local>")) { | |
| 267 AddRuleToBypassLocal(); | |
| 268 return true; | |
| 269 } | |
| 270 | |
| 271 // Extract any scheme-restriction. | |
| 272 std::string::size_type scheme_pos = raw.find("://"); | |
| 273 std::string scheme; | |
| 274 if (scheme_pos != std::string::npos) { | |
| 275 scheme = raw.substr(0, scheme_pos); | |
| 276 raw = raw.substr(scheme_pos + 3); | |
| 277 if (scheme.empty()) | |
| 278 return false; | |
| 279 } | |
| 280 | |
| 281 if (raw.empty()) | |
| 282 return false; | |
| 283 | |
| 284 // If there is a forward slash in the input, it is probably a CIDR style | |
| 285 // mask. | |
| 286 if (raw.find('/') != std::string::npos) { | |
| 287 IPAddressNumber ip_prefix; | |
| 288 size_t prefix_length_in_bits; | |
| 289 | |
| 290 if (!ParseCIDRBlock(raw, &ip_prefix, &prefix_length_in_bits)) | |
| 291 return false; | |
| 292 | |
| 293 rules_.push_back( | |
| 294 new BypassIPBlockRule(raw, scheme, ip_prefix, prefix_length_in_bits)); | |
| 295 | |
| 296 return true; | |
| 297 } | |
| 298 | |
| 299 // Check if we have an <ip-address>[:port] input. We need to treat this | |
| 300 // separately since the IP literal may not be in a canonical form. | |
| 301 std::string host; | |
| 302 int port; | |
| 303 if (ParseHostAndPort(raw, &host, &port)) { | |
| 304 // Note that HostPortPair is used to merely to convert any IPv6 literals to | |
| 305 // a URL-safe format that can be used by canonicalization below. | |
| 306 std::string bracketed_host = HostPortPair(host, 80).HostForURL(); | |
| 307 if (IsIPAddress(bracketed_host)) { | |
| 308 // Canonicalize the IP literal before adding it as a string pattern. | |
| 309 GURL tmp_url("http://" + bracketed_host); | |
| 310 return AddRuleForHostname(scheme, tmp_url.host(), port); | |
| 311 } | |
| 312 } | |
| 313 | |
| 314 // Otherwise assume we have <hostname-pattern>[:port]. | |
| 315 std::string::size_type pos_colon = raw.rfind(':'); | |
| 316 host = raw; | |
| 317 port = -1; | |
| 318 if (pos_colon != std::string::npos) { | |
| 319 if (!base::StringToInt(base::StringPiece(raw.begin() + pos_colon + 1, | |
| 320 raw.end()), | |
| 321 &port) || | |
| 322 (port < 0 || port > 0xFFFF)) { | |
| 323 return false; // Port was invalid. | |
| 324 } | |
| 325 raw = raw.substr(0, pos_colon); | |
| 326 } | |
| 327 | |
| 328 // Special-case hostnames that begin with a period. | |
| 329 // For example, we remap ".google.com" --> "*.google.com". | |
| 330 if (StartsWithASCII(raw, ".", false)) | |
| 331 raw = "*" + raw; | |
| 332 | |
| 333 // If suffix matching was asked for, make sure the pattern starts with a | |
| 334 // wildcard. | |
| 335 if (use_hostname_suffix_matching && !StartsWithASCII(raw, "*", false)) | |
| 336 raw = "*" + raw; | |
| 337 | |
| 338 return AddRuleForHostname(scheme, raw, port); | |
| 339 } | |
| 340 | |
| 341 bool ProxyBypassRules::AddRuleFromStringInternalWithLogging( | |
| 342 const std::string& raw, | |
| 343 bool use_hostname_suffix_matching) { | |
| 344 return AddRuleFromStringInternal(raw, use_hostname_suffix_matching); | |
| 345 } | |
| 346 | |
| 347 } // namespace net | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 992733002:
Remove //net (except for Android test stuff) and sdch (Closed)
Base URL: git@github.com:domokit/mojo.git@master