url_canon: New CanonicalizeHostVerbose() function.

src/url_canon_host.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 64 matching lines @@
 // based on how many times you run the canonicalizer. We prefer to always report
 // the same vailidity, so reject this.
 const unsigned char kEsc = 0xff;
 const unsigned char kHostCharLookup[0x80] = {
 // 00-1f: all are invalid
      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 //  ' '   !    "    #    $    %    &    '    (    )    *    +    ,    -    .    /
    kEsc,kEsc,kEsc,kEsc,kEsc,  0, kEsc,kEsc,kEsc,kEsc,kEsc, '+',kEsc, '-', '.',  0,
 //   0    1    2    3    4    5    6    7    8    9    :    ;    <    =    >    ?
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',  0 ,  0 ,kEsc,kEsc,kEsc,  0 ,
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':',  0 ,kEsc,kEsc,kEsc,  0 ,
 //   @    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O
    kEsc, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 //   P    Q    R    S    T    U    V    W    X    Y    Z    [    \    ]    ^    _
     'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[',  0 , ']',  0 , '_',
 //   `    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o
    kEsc, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 //   p    q    r    s    t    u    v    w    x    y    z    {    |    }    ~
     'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',kEsc,kEsc,kEsc,  0 ,  0 };
 
 const int kTempHostBufferLen = 1024;
@@ skipping 10 matching lines @@
   *has_non_ascii = false;
   *has_escaped = false;
   for (int i = host.begin; i < end; i++) {
     if (static_cast<UCHAR>(spec[i]) >= 0x80)
       *has_non_ascii = true;
     else if (spec[i] == '%')
       *has_escaped = true;
   }
 }
 
-// Considers the current contents of the output and sees if it looks like an
-// IP address. This is called because we canonicalize to the output assuming
-// that it's not an IP address, and now need to fix it if we produced one.
-//
-// The generated hostname is identified by |host|. The output will be fixed
-// with a canonical IP address if the host looks like one. Otherwise, there
-// will be no change.
-void InterpretIPAddress(const url_parse::Component& host,
-                        CanonOutput* output) {
-  // Canonicalize the IP address in the output to this temporary buffer.
-  // IP addresses are small, so this should not cause an allocation.
-  RawCanonOutput<64> canon_ip;
-  url_parse::Component out_host;  // Unused.
-  if (CanonicalizeIPAddress(output->data(), host, &canon_ip, &out_host)) {
-    // Looks like an IP address, overwrite the existing host with the newly
-    // canonicalized IP address.
-    output->set_length(host.begin);
-    output->Append(canon_ip.data(), canon_ip.length());
-  }
-}
-
 // Canonicalizes a host name that is entirely 8-bit characters (even though
 // the type holding them may be 16 bits. Escaped characters will be unescaped.
 // Non-7-bit characters (for example, UTF-8) will be passed unchanged.
 //
 // The |*has_non_ascii| flag will be true if there are non-7-bit characters in
 // the output.
 //
 // This function is used in two situations:
 //
 //  * When the caller knows there is no non-ASCII or percent escaped
 //    characters. This is what DoHost does. The result will be a completely
 //    canonicalized host since we know nothing weird can happen (escaped
 //    characters could be unescaped to non-7-bit, so they have to be treated
 //    with suspicion at this point). It does not use the |has_non_ascii| flag.
 //
 //  * When the caller has an 8-bit string that may need unescaping.
 //    DoComplexHost calls us this situation to do unescaping and validation.
 //    After this, it may do other IDN operations depending on the value of the
 //    |*has_non_ascii| flag.
 //
 // The return value indicates if the output is a potentially valid host name.
 template<typename CHAR>
 bool DoSimpleHost(const CHAR* host, int host_len, CanonOutput* output,
                   bool* has_non_ascii) {
   *has_non_ascii = false;
 
-  // First check if the host name is an IP address.
-  url_parse::Component out_ip;  // Unused: we compute the size ourselves later.
-  if (CanonicalizeIPAddress(host, url_parse::Component(0, host_len),
-                            output, &out_ip))
-    return true;
-
   bool success = true;
   for (int i = 0; i < host_len; i++) {
     unsigned char source = static_cast<unsigned char>(host[i]);
     if (source == '%') {
       // Handle unescaping. This will replace |source| with the unescaped char.
       if (!DecodeEscaped(host, &i, host_len, &source)) {
         // Invalid escaped character. There is nothing that can make this
         // host valid. We append an escaped percent so the URL looks reasonable
         // and mark as failed.
         AppendEscapedChar('%', output);
@@ skipping 69 matching lines @@
     // unescaped input requires IDN.
     if (!DoSimpleHost(host, host_len, output, &has_non_ascii)) {
       // Error with some escape sequence. We'll call the current output
       // complete. DoSimpleHost will have written some "reasonable" output.
       return false;
     }
 
     // Unescaping may have left us with ASCII input, in which case the
     // unescaped version we wrote to output is complete.
     if (!has_non_ascii) {
-      // Need to be sure to check for IP addresses in the newly unescaped
-      // output. This will fix the output if necessary.
-      InterpretIPAddress(url_parse::MakeRange(begin_length, output->length()),
-                         output);
       return true;
     }
 
     // Save the pointer into the data was just converted (it may be appended to
     // other data in the output buffer).
     utf8_source = &output->data()[begin_length];
     utf8_source_len = output->length() - begin_length;
   } else {
     // We don't need to unescape, use input for IDNization later. (We know the
     // input has non-ASCII, or the simple version would have been called
@@ skipping 49 matching lines @@
   }
 
   // No unescaping necessary, we can safely pass the input to ICU. This
   // function will only get called if we either have escaped or non-ascii
   // input, so it's safe to just use ICU now. Even if the input is ASCII,
   // this function will do the right thing (just slower than we could).
   return DoIDNHost(host, host_len, output);
 }
 
 template<typename CHAR, typename UCHAR>
-bool DoHost(const CHAR* spec,
+void DoHost(const CHAR* spec,
             const url_parse::Component& host,
             CanonOutput* output,
-            url_parse::Component* out_host) {
-  bool success = true;
+            CanonHostInfo* host_info) {
   if (host.len <= 0) {
     // Empty hosts don't need anything.
-    *out_host = url_parse::Component();
-    return true;
+    host_info->family = CanonHostInfo::NEUTRAL;
+    host_info->out_host = url_parse::Component();
+    return;
   }
 
   bool has_non_ascii, has_escaped;
   ScanHostname<CHAR, UCHAR>(spec, host, &has_non_ascii, &has_escaped);
 
-  out_host->begin = output->length();
+  // Keep track of output's initial length, so we can rewind later.
+  const int output_begin = output->length();
 
+  bool success;
   if (!has_non_ascii && !has_escaped) {
-    success &= DoSimpleHost(&spec[host.begin], host.len,
-                            output, &has_non_ascii);
+    success = DoSimpleHost(&spec[host.begin], host.len,
+                           output, &has_non_ascii);
     DCHECK(!has_non_ascii);
   } else {
-    success &= DoComplexHost(&spec[host.begin], host.len,
-                             has_non_ascii, has_escaped, output);
-    // We could have had escaped numerals that should now be canonicalized as
-    // an IP address. This should be exceedingly rare, it's probably mostly
-    // used by scammers.
+    success = DoComplexHost(&spec[host.begin], host.len,
+                            has_non_ascii, has_escaped, output);
   }
 
-  out_host->len = output->length() - out_host->begin;
-  return success;
+  if (!success) {
+    // Canonicalization failed.  Set BROKEN to notify the caller.
+    host_info->family = CanonHostInfo::BROKEN;
+  } else {
+    // After all the other canonicalization, check if we ended up with an IP
+    // address.  IP addresses are small, so writing into this temporary buffer
+    // should not cause an allocation.
+    RawCanonOutput<64> canon_ip;
+    CanonicalizeIPAddress(output->data(),
+                          url_parse::MakeRange(output_begin, output->length()),
+                          &canon_ip, host_info);
+
+    // If we got an IPv4/IPv6 address, copy the canonical form back to the
+    // real buffer.  Otherwise, it's a hostname or broken IP, in which case
+    // we just leave it in place.
+    if (host_info->IsIPAddress()) {
+      output->set_length(output_begin);
+      output->Append(canon_ip.data(), canon_ip.length());
+    }
+  }
+
+  host_info->out_host = url_parse::MakeRange(output_begin, output->length());
 }
 
 }  // namespace
 
 bool CanonicalizeHost(const char* spec,
                       const url_parse::Component& host,
                       CanonOutput* output,
                       url_parse::Component* out_host) {
-  return DoHost<char, unsigned char>(spec, host, output, out_host);
+  CanonHostInfo host_info;
+  DoHost<char, unsigned char>(spec, host, output, &host_info);
+  *out_host = host_info.out_host;
+  return (host_info.family != CanonHostInfo::BROKEN);
 }
 
 bool CanonicalizeHost(const char16* spec,
                       const url_parse::Component& host,
                       CanonOutput* output,
                       url_parse::Component* out_host) {
-  return DoHost<char16, char16>(spec, host, output, out_host);
+  CanonHostInfo host_info;
+  DoHost<char16, char16>(spec, host, output, &host_info);
+  *out_host = host_info.out_host;
+  return (host_info.family != CanonHostInfo::BROKEN);
+}
+
+void CanonicalizeHostVerbose(const char* spec,
+                             const url_parse::Component& host,
+                             CanonOutput* output,
+                             CanonHostInfo *host_info) {
+  DoHost<char, unsigned char>(spec, host, output, host_info);
+}
+
+void CanonicalizeHostVerbose(const char16* spec,
+                             const url_parse::Component& host,
+                             CanonOutput* output,
+                             CanonHostInfo *host_info) {
+  DoHost<char16, char16>(spec, host, output, host_info);
 }
 
 }  // namespace url_canon