Change ParseHostAndPort() to not include brackets around IPv6 literals.

net/proxy/proxy_bypass_rules.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/proxy/proxy_bypass_rules.h"
 
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_piece.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
-#include "base/strings/string_piece.h"
-#include "base/strings/string_tokenizer.h"
+#include "net/base/host_port_pair.h"
 #include "net/base/net_util.h"
 
 namespace net {
 
 namespace {
 
 class HostnamePatternRule : public ProxyBypassRules::Rule {
  public:
   HostnamePatternRule(const std::string& optional_scheme,
                       const std::string& hostname_pattern,
@@ skipping 101 matching lines @@
   }
 
  private:
   const std::string description_;
   const std::string optional_scheme_;
   const IPAddressNumber ip_prefix_;
   const size_t prefix_length_in_bits_;
 };
 
 // Returns true if the given string represents an IP address.
+// IPv6 addresses are expected to be bracketed.
 bool IsIPAddress(const std::string& domain) {
   // From GURL::HostIsIPAddress()
   url::RawCanonOutputT<char, 128> ignored_output;
   url::CanonHostInfo host_info;
   url::Component domain_comp(0, domain.size());
   url::CanonicalizeIPAddress(domain.c_str(), domain_comp, &ignored_output,
                              &host_info);
   return host_info.IsIPAddress();
 }
 
@@ skipping 154 matching lines @@
         new BypassIPBlockRule(raw, scheme, ip_prefix, prefix_length_in_bits));
 
     return true;
   }
 
   // Check if we have an <ip-address>[:port] input. We need to treat this
   // separately since the IP literal may not be in a canonical form.
   std::string host;
   int port;
   if (ParseHostAndPort(raw, &host, &port)) {
-    if (IsIPAddress(host)) {
+    std::string bracketed_host = HostPortPair(host, 80).HostForURL();

[Ryan Hamilton, 2014/09/24 21:48:49]

nit: s/80/port/ ?  (I suspect it doesn't actually matter, but still :>)

[eroman, 2014/09/24 21:59:28]

The specific port used does not matter, I am just using that function in order
to potentially bracket IPv6 literals. (Will document).

I considered changing ParseHostAndPort() to returning a HostPortPair, which
would make IPv6 behavior more clear (and in fact why HostPortPair was introduced
in the first place).

The issue with that is that HostPortPair makes ports required, whereas
ParseHostAndPort considers the port optional (by setting to -1 when
unspecified).

... Long story short, I hardcoded port=80 because I don't want to pass -1 into
HostPortPair's constructor, which expects a uint16. Because integer underflow is
not cool.

+    if (IsIPAddress(bracketed_host)) {
       // Canonicalize the IP literal before adding it as a string pattern.
-      GURL tmp_url("http://" + host);
+      GURL tmp_url("http://" + bracketed_host);
       return AddRuleForHostname(scheme, tmp_url.host(), port);
     }
   }
 
   // Otherwise assume we have <hostname-pattern>[:port].
   std::string::size_type pos_colon = raw.rfind(':');
   host = raw;
   port = -1;
   if (pos_colon != std::string::npos) {
     if (!base::StringToInt(base::StringPiece(raw.begin() + pos_colon + 1,
@@ skipping 18 matching lines @@
   return AddRuleForHostname(scheme, raw, port);
 }
 
 bool ProxyBypassRules::AddRuleFromStringInternalWithLogging(
     const std::string& raw,
     bool use_hostname_suffix_matching) {
   return AddRuleFromStringInternal(raw, use_hostname_suffix_matching);
 }
 
 }  // namespace net