Explicitly whitelist the test server port.

net/base/net_util.cc

 // Copyright (c) 2010 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/base/net_util.h"
 
 #include <algorithm>
 #include <map>
 #include <unicode/regex.h>
 #include <unicode/ucnv.h>
@@ skipping 1034 matching lines @@
 }  // namespace
 
 const FormatUrlType kFormatUrlOmitNothing                     = 0;
 const FormatUrlType kFormatUrlOmitUsernamePassword            = 1 << 0;
 const FormatUrlType kFormatUrlOmitHTTP                        = 1 << 1;
 const FormatUrlType kFormatUrlOmitTrailingSlashOnBareHostname = 1 << 2;
 const FormatUrlType kFormatUrlOmitAll = kFormatUrlOmitUsernamePassword |
     kFormatUrlOmitHTTP | kFormatUrlOmitTrailingSlashOnBareHostname;
 
 // TODO(viettrungluu): We don't want non-POD globals; change this.
-std::set<int> explicitly_allowed_ports;
+std::multiset<int> explicitly_allowed_ports;
 
 GURL FilePathToFileURL(const FilePath& path) {
   // Produce a URL like "file:///C:/foo" for a regular file, or
   // "file://///server/path" for UNC. The URL canonicalizer will fix up the
   // latter case to be the canonical UNC form: "file://server/path"
   FilePath::StringType url_string(kFileURLPrefix);
   url_string.append(path.value());
 
   // Now do replacement of some characters. Since we assume the input is a
   // literal filename, anything the URL parser might consider special should
@@ skipping 423 matching lines @@
     }
   }
   // Port not explicitly allowed by FTP, so return the default restrictions.
   return IsPortAllowedByDefault(port);
 }
 
 bool IsPortAllowedByOverride(int port) {
   if (explicitly_allowed_ports.empty())
     return false;
 
-  std::set<int>::const_iterator it =
-      std::find(explicitly_allowed_ports.begin(),
-                explicitly_allowed_ports.end(),
-                port);
-
-  return it != explicitly_allowed_ports.end();
+  return explicitly_allowed_ports.count(port) > 0;
 }
 
 int SetNonBlocking(int fd) {
 #if defined(OS_WIN)
   unsigned long no_block = 1;
   return ioctlsocket(fd, FIONBIO, &no_block);
 #elif defined(OS_POSIX)
   int flags = fcntl(fd, F_GETFL, 0);
   if (-1 == flags)
     return flags;
@@ skipping 204 matching lines @@
   replacements.ClearRef();
   return url.ReplaceComponents(replacements);
 }
 
 // Specifies a comma separated list of port numbers that should be accepted
 // despite bans. If the string is invalid no allowed ports are stored.
 void SetExplicitlyAllowedPorts(const std::string& allowed_ports) {
   if (allowed_ports.empty())
     return;
 
-  std::set<int> ports;
+  std::multiset<int> ports;
   size_t last = 0;
   size_t size = allowed_ports.size();
   // The comma delimiter.
   const std::string::value_type kComma = ',';
 
   // Overflow is still possible for evil user inputs.
   for (size_t i = 0; i <= size; ++i) {
     // The string should be composed of only digits and commas.
     if (i != size && !IsAsciiDigit(allowed_ports[i]) &&
         (allowed_ports[i] != kComma))
       return;
     if (i == size || allowed_ports[i] == kComma) {
       if (i > last) {
         int port;
         base::StringToInt(allowed_ports.begin() + last,
                           allowed_ports.begin() + i,
                           &port);
         ports.insert(port);
       }
       last = i + 1;
     }
   }
   explicitly_allowed_ports = ports;
 }
 
+ScopedPortException::ScopedPortException(int port) : port_(port) {
+  explicitly_allowed_ports.insert(port);
+}
+
+ScopedPortException::~ScopedPortException() {
+  std::multiset<int>::iterator it = explicitly_allowed_ports.find(port_);
+  if (it != explicitly_allowed_ports.end())
+    explicitly_allowed_ports.erase(it);
+  else
+    NOTREACHED();
+}
+
 enum IPv6SupportStatus {
   IPV6_CANNOT_CREATE_SOCKETS,
   IPV6_CAN_CREATE_SOCKETS,
   IPV6_GETIFADDRS_FAILED,
   IPV6_GLOBAL_ADDRESS_MISSING,
   IPV6_GLOBAL_ADDRESS_PRESENT,
   IPV6_INTERFACE_ARRAY_TOO_SHORT,
   IPV6_SUPPORT_MAX  // Bounding values for enumeration.
 };
 
@@ skipping 288 matching lines @@
 }
 
 int GetPortFromAddrinfo(const struct addrinfo* info) {
   uint16* port_field = GetPortFieldFromAddrinfo(info);
   if (!port_field)
     return -1;
   return ntohs(*port_field);
 }
 
 }  // namespace net