url_canon: New CanonicalizeHostVerbose() function.

src/url_canon_ip.cc

 // Copyright 2007, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 83 matching lines @@
       return false;
     }
   }
 
   // Fill in any unused components.
   while (cur_component < 4)
     components[cur_component++] = url_parse::Component();
   return true;
 }
 
-// Converts an IPv4 component to a 32-bit number, returning true on success.
-// False means that the number is invalid and that the input can not be an
-// IP address. The number will be truncated to 32 bits.
+// Converts an IPv4 component to a 32-bit number, while checking for overflow.
+//
+// Possible return values:
+// - IPV4    - The number was valid, and did not overflow.
+// - BROKEN  - The input was numeric, but too large for a 32-bit field.
+// - NEUTRAL - Input was not numeric.
 //
 // The input is assumed to be ASCII. FindIPv4Components should have stripped
 // out any input that is greater than 7 bits. The components are assumed
 // to be non-empty.
 template<typename CHAR>
-bool IPv4ComponentToNumber(const CHAR* spec,
-                           const url_parse::Component& component,
-                           uint32_t* number) {
+CanonHostInfo::Family IPv4ComponentToNumber(
+    const CHAR* spec,
+    const url_parse::Component& component,
+    uint32_t* number) {
   // Figure out the base
   SharedCharTypes base;
   int base_prefix_len = 0;  // Size of the prefix for this base.
   if (spec[component.begin] == '0') {
     // Either hex or dec, or a standalone zero.
     if (component.len == 1) {
       base = CHAR_DEC;
     } else if (spec[component.begin + 1] == 'X' ||
                spec[component.begin + 1] == 'x') {
       base = CHAR_HEX;
       base_prefix_len = 2;
     } else {
       base = CHAR_OCT;
       base_prefix_len = 1;
     }
   } else {
     base = CHAR_DEC;
   }
 
-  // Reject any components that are too long. This is generous, Windows
-  // allows at most 16 characters for the entire host name, and 12 per
-  // component, while Mac and Linux will take up to 10 per component.
+  // Extend the prefix to consume all leading zeros.
+  while (base_prefix_len < component.len &&
+         spec[component.begin + base_prefix_len] == '0')
+    base_prefix_len++;
+
+  // Put the component, minus any base prefix, into a NULL-terminated buffer so
+  // we can call the standard library.  Because leading zeros have already been
+  // discarded, filling the entire buffer is guaranteed to trigger the 32-bit
+  // overflow check.
   const int kMaxComponentLen = 16;
-  if (component.len - base_prefix_len > kMaxComponentLen)
-    return false;
-
-  // Put the component, minus any base prefix, to a NULL-terminated buffer so
-  // we can call the standard library. We know the input is 7-bit, so convert
-  // to narrow (if this is the wide version of the template) by casting.
-  char buf[kMaxComponentLen + 1];
+  char buf[kMaxComponentLen + 1];  // digits + '\0'
   int dest_i = 0;
-  for (int i = base_prefix_len; i < component.len; i++, dest_i++) {
-    char input = static_cast<char>(spec[component.begin + i]);
+  for (int i = component.begin + base_prefix_len; i < component.end(); i++) {
+    // We know the input is 7-bit, so convert to narrow (if this is the wide
+    // version of the template) by casting.
+    char input = static_cast<char>(spec[i]);
 
     // Validate that this character is OK for the given base.
     if (!IsCharOfType(input, base))
-      return false;
-    buf[dest_i] = input;
+      return CanonHostInfo::NEUTRAL;
+
+    // Fill the buffer, if there's space remaining.  This check allows us to
+    // verify that all characters are numeric, even those that don't fit.
+    if (dest_i < kMaxComponentLen)
+      buf[dest_i++] = input;
   }
-  buf[dest_i] = 0;
+
+  buf[dest_i] = '\0';
 
   // Use the 64-bit strtoi so we get a big number (no hex, decimal, or octal
-  // number can overflow a 64-bit number in <= 16 characters). Then cast to
-  // truncate down to a 32-bit number. This may be further truncated later.
-  *number = static_cast<uint32_t>(_strtoui64(buf, NULL, BaseForType(base)));
-  return true;
+  // number can overflow a 64-bit number in <= 16 characters).
+  uint64_t num = _strtoui64(buf, NULL, BaseForType(base));
+
+  // Check for 32-bit overflow.
+  if (num > UINT32_MAX)
+    return CanonHostInfo::BROKEN;
+
+  // No overflow.  Success!
+  *number = static_cast<uint32_t>(num);
+  return CanonHostInfo::IPV4;
 }
 
 // Writes the given address (with each character representing one dotted
 // part of an IPv4 address) to the output, and updating |*out_host| to
 // identify the added portion.
 void AppendIPv4Address(const unsigned char address[4],
                        CanonOutput* output,
                        url_parse::Component* out_host) {
   out_host->begin = output->length();
   for (int i = 0; i < 4; i++) {
     char str[16];
     _itoa_s(address[i], str, 10);
 
     for (int ch = 0; str[ch] != 0; ch++)
       output->push_back(str[ch]);
 
     if (i != 3)
       output->push_back('.');
   }
   out_host->len = output->length() - out_host->begin;
 }
 
-// Converts an IPv4 address to a 32-bit number (network byte order), returning
-// true on success. False means that the input is not a valid IPv4 address.
+// Converts an IPv4 address to a 32-bit number (network byte order).
+//
+// Possible return values:
+//   IPV4    - IPv4 address was successfully parsed.
+//   BROKEN  - Input was formatted like an IPv4 address, but overflow occurred
+//             during parsing.
+//   NEUTRAL - Input couldn't possibly be interpreted as an IPv4 address.
+//             It might be an IPv6 address, or a hostname.
+//
+// On success, |num_ipv4_components| will be populated with the number of
+// components in the IPv4 address.
 template<typename CHAR>
-bool IPv4AddressToNumber(const CHAR* spec,
-                         const url_parse::Component& host,
-                         unsigned char address[4]) {
+CanonHostInfo::Family IPv4AddressToNumber(const CHAR* spec,
+                                          const url_parse::Component& host,
+                                          unsigned char address[4],
+                                          int* num_ipv4_components) {
   // The identified components. Not all may exist.
   url_parse::Component components[4];
   if (!FindIPv4Components(spec, host, components))
-    return false;
+    return CanonHostInfo::NEUTRAL;
 
   // Convert existing components to digits. Values up to
   // |existing_components| will be valid.
   uint32_t component_values[4];
   int existing_components = 0;
   for (int i = 0; i < 4; i++) {
     if (components[i].len <= 0)
       continue;
-    if (!IPv4ComponentToNumber(spec, components[i],
-                               &component_values[existing_components]))
-      return false;
+    CanonHostInfo::Family family = IPv4ComponentToNumber(
+        spec, components[i], &component_values[existing_components]);
+
+    // Stop if we hit an invalid non-empty component.
+    if (family != CanonHostInfo::IPV4)
+      return family;
+
     existing_components++;
   }
 
   // Use that sequence of numbers to fill out the 4-component IP address.
 
-  // ...first fill all but the last component by truncating to one byte.
-  for (int i = 0; i < existing_components - 1; i++)
+  // First, process all components but the last, while making sure each fits
+  // within an 8-bit field.
+  for (int i = 0; i < existing_components - 1; i++) {
+    if (component_values[i] > UINT8_MAX)
+      return CanonHostInfo::BROKEN;
     address[i] = static_cast<unsigned char>(component_values[i]);
+  }
 
-  // ...then fill out the rest of the bytes by filling them with the last
-  // component.
+  // Next, consume the last component to fill in the remaining bytes.
   uint32_t last_value = component_values[existing_components - 1];
-  if (existing_components == 1)
-    address[0] = (last_value & 0xFF000000) >> 24;
-  if (existing_components <= 2)
-    address[1] = (last_value & 0x00FF0000) >> 16;
-  if (existing_components <= 3)
-    address[2] = (last_value & 0x0000FF00) >> 8;
-  address[3] = last_value & 0xFF;
+  for (int i = 3; i >= existing_components - 1; i--) {
+    address[i] = static_cast<unsigned char>(last_value);
+    last_value >>= 8;
+  }
 
-  return true;
+  // If the last component has residual bits, report overflow.
+  if (last_value != 0)
+    return CanonHostInfo::BROKEN;
+
+  // Tell the caller how many components we saw.
+  *num_ipv4_components = existing_components;
+
+  // Success!
+  return CanonHostInfo::IPV4;
 }
 
+// Return true if we've made a final IPV4/BROKEN decision, false if the result
+// is NEUTRAL, and we could use a second opinion.
 template<typename CHAR, typename UCHAR>
 bool DoCanonicalizeIPv4Address(const CHAR* spec,
                                const url_parse::Component& host,
                                CanonOutput* output,
-                               url_parse::Component* out_host) {
+                               CanonHostInfo* host_info) {
   unsigned char address[4];
-  if (!IPv4AddressToNumber<CHAR>(spec, host, address))
-    return false;
+  host_info->family = IPv4AddressToNumber<CHAR>(
+      spec, host, address, &host_info->num_ipv4_components);
 
-  AppendIPv4Address(address, output, out_host);
-  return true;
+  switch (host_info->family) {
+    case CanonHostInfo::IPV4:
+      // Definitely an IPv4 address.
+      AppendIPv4Address(address, output, &host_info->out_host);
+      return true;
+    case CanonHostInfo::BROKEN:
+      // Definitely broken.
+      return true;
+    default:
+      // Could be IPv6 or a hostname.
+      return false;
+  }
 }
 
 // Helper class that describes the main components of an IPv6 input string.
 // See the following examples to understand how it breaks up an input string:
 //
 // [Example 1]: input = "[::aa:bb]"
 //  ==> num_hex_components = 2
 //  ==> hex_components[0] = Component(3,2) "aa"
 //  ==> hex_components[1] = Component(6,2) "bb"
 //  ==> index_of_contraction = 0
@@ skipping 251 matching lines @@
     //     "mapped" ==>  0:0:0:0:0:0000:<IPv4-literal>
     for (int j = 0; j < 10; ++j) {
       if (address[j] != 0)
         return false;
     }
     if (!((address[10] == 0 && address[11] == 0) ||
           (address[10] == 0xFF && address[11] == 0xFF)))
       return false;
 
     // Append the 32-bit number to |address|.
-    if (!IPv4AddressToNumber(spec,
-                             ipv6_parsed.ipv4_component,
-                             &address[cur_index_in_address]))
+    int ignored_num_ipv4_components;
+    if (CanonHostInfo::IPV4 !=
+        IPv4AddressToNumber(spec,
+                            ipv6_parsed.ipv4_component,
+                            &address[cur_index_in_address],
+                            &ignored_num_ipv4_components))
       return false;
   }
 
   return true;
 }
 
 // Searches for the longest sequence of zeros in |address|, and writes the
 // range into |contraction_range|. The run of zeros must be at least 16 bits,
 // and if there is a tie the first is chosen.
 void ChooseIPv6ContractionRange(const unsigned char address[16],
@@ skipping 20 matching lines @@
       // it is a candidate for the contraction.
       if (cur_range.len > 2 && cur_range.len > max_range.len) {
         max_range = cur_range;
       }
       cur_range.reset();
     }
   }
   *contraction_range = max_range;
 }
 
+// Return true if we've made a final IPV6/BROKEN decision, false if the result
+// is NEUTRAL, and we could use a second opinion.
 template<typename CHAR, typename UCHAR>
 bool DoCanonicalizeIPv6Address(const CHAR* spec,
                                const url_parse::Component& host,
                                CanonOutput* output,
-                               url_parse::Component* out_host) {
+                               CanonHostInfo* host_info) {
   // Turn the IP address into a 128 bit number.
   unsigned char address[16];
-  if (!IPv6AddressToNumber<CHAR, UCHAR>(spec, host, address))
+  if (!IPv6AddressToNumber<CHAR, UCHAR>(spec, host, address)) {
+    // If it's not an IPv6 address, scan for characters that should *only*
+    // exist in an IPv6 address.
+    for (int i = host.begin; i < host.end(); i++) {
+      switch (spec[i]) {
+        case '[':
+        case ']':
+        case ':':
+          host_info->family = CanonHostInfo::BROKEN;
+          return true;
+      }
+    }
+
+    // No invalid characters.  Could still be IPv4 or a hostname.
+    host_info->family = CanonHostInfo::NEUTRAL;
     return false;
+  }
 
-  out_host->begin = output->length();
+  host_info->out_host.begin = output->length();
   output->push_back('[');
 
   // We will now output the address according to the rules in:
   // http://tools.ietf.org/html/draft-kawamura-ipv6-text-representation-01#section-4
 
   // Start by finding where to place the "::" contraction (if any).
   url_parse::Component contraction_range;
   ChooseIPv6ContractionRange(address, &contraction_range);
 
   for (int i = 0; i < 16;) {
@@ skipping 15 matching lines @@
       for (int ch = 0; str[ch] != 0; ++ch)
         output->push_back(str[ch]);
 
       // Put a colon after each number, except the last.
       if (i < 16)
         output->push_back(':');
     }
   }
 
   output->push_back(']');
-  out_host->len = output->length() - out_host->begin;
+  host_info->out_host.len = output->length() - host_info->out_host.begin;
 
+  host_info->family = CanonHostInfo::IPV6;
   return true;
 }
 
 }  // namespace
 
 bool FindIPv4Components(const char* spec,
                         const url_parse::Component& host,
                         url_parse::Component components[4]) {
   return DoFindIPv4Components<char, unsigned char>(spec, host, components);
 }
 
 bool FindIPv4Components(const char16* spec,
                         const url_parse::Component& host,
                         url_parse::Component components[4]) {
   return DoFindIPv4Components<char16, char16>(spec, host, components);
 }
 
-bool CanonicalizeIPAddress(const char* spec,
+void CanonicalizeIPAddress(const char* spec,
                            const url_parse::Component& host,
                            CanonOutput* output,
-                           url_parse::Component* out_host) {
-  return
-      DoCanonicalizeIPv4Address<char, unsigned char>(
-          spec, host, output, out_host) ||
-      DoCanonicalizeIPv6Address<char, unsigned char>(
-          spec, host, output, out_host);
+                           CanonHostInfo* host_info) {
+  if (DoCanonicalizeIPv4Address<char, unsigned char>(
+          spec, host, output, host_info))
+    return;
+  if (DoCanonicalizeIPv6Address<char, unsigned char>(
+          spec, host, output, host_info))
+    return;
 }
 
-bool CanonicalizeIPAddress(const char16* spec,
+void CanonicalizeIPAddress(const char16* spec,
                            const url_parse::Component& host,
                            CanonOutput* output,
-                           url_parse::Component* out_host) {
-  return
-      DoCanonicalizeIPv4Address<char16, char16>(
-          spec, host, output, out_host) ||
-      DoCanonicalizeIPv6Address<char16, char16>(
-          spec, host, output, out_host);
+                           CanonHostInfo* host_info) {
+  if (DoCanonicalizeIPv4Address<char16, char16>(
+          spec, host, output, host_info))
+    return;
+  if (DoCanonicalizeIPv6Address<char16, char16>(
+          spec, host, output, host_info))
+    return;
 }
 
 }  // namespace url_canon