url_parse: Segment partially-typed IPv6 literals....

src/url_parse.cc

 /* Based on nsURLParsers.cc from Mozilla
  * -------------------------------------
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  * for the specific language governing rights and limitations under the
@@ skipping 129 matching lines @@
                      const Component& serverinfo,
                      Component* hostname,
                      Component* port_num) {
   if (serverinfo.len == 0) {
     // No server info, host name is empty.
     hostname->reset();
     port_num->reset();
     return;
   }
 
-  // Search backwards for a ':' but stop on ']' (IPv6 address literal
-  // delimiter).
-  int i = serverinfo.begin + serverinfo.len - 1;
-  int colon = -1, bracket = -1;
-  while (i >= serverinfo.begin && colon < 0) {
+  // If the host starts with a left-bracket, assume the entire host is an
+  // IPv6 literal.  Otherwise, assume none of the host is an IPv6 literal.
+  // This assumption will be overridden if we find a right-bracket.
+  //
+  // Our IPv6 address canonicalization code requires both brackets to exist,
+  // but the ability to locate an incomplete address can still be useful.
+  int ipv6_terminator = spec[serverinfo.begin] == '[' ? serverinfo.end() : -1;
+  int colon = -1;
+
+  // Find the last right-bracket, and the last colon.
+  for (int i = serverinfo.begin; i < serverinfo.end(); i++) {
     switch (spec[i]) {
       case ']':
-        bracket = i;
+        ipv6_terminator = i;
         break;
       case ':':
-        if (bracket < 0)
-          colon = i;  // Will cause loop to terminate.
+        colon = i;
         break;
     }
-    i--;
   }
 
-  if (colon >= 0) {
+  if (colon > ipv6_terminator) {
     // Found a port number: <hostname>:<port>
-    int host_len = colon - serverinfo.begin;
-    if (host_len)
-      *hostname = MakeRange(serverinfo.begin, colon);
-    else
+    *hostname = MakeRange(serverinfo.begin, colon);
+    if (hostname->len == 0)
       hostname->reset();
-    *port_num = MakeRange(colon + 1, serverinfo.begin + serverinfo.len);
+    *port_num = MakeRange(colon + 1, serverinfo.end());
   } else {
     // No port: <hostname>
     *hostname = serverinfo;
     port_num->reset();
   }
 }
 
 // Given an already-identified auth section, breaks it into its consituent
 // parts. The port number will be parsed and the resulting integer will be
 // filled into the given *port variable, or -1 if there is no port number or it
@@ skipping 194 matching lines @@
 void DoParseMailtoURL(const CHAR* spec, int spec_len, Parsed* parsed) {
   DCHECK(spec_len >= 0);
 
   // Get the non-path and non-scheme parts of the URL out of the way, we never
   // use them.
   parsed->username.reset();
   parsed->password.reset();
   parsed->host.reset();
   parsed->port.reset();
   parsed->ref.reset();
-  parsed->query.reset(); // May use this; reset for convenience.
+  parsed->query.reset();  // May use this; reset for convenience.
 
   // Strip leading & trailing spaces and control characters.
   int begin = 0;
   TrimURL(spec, &begin, &spec_len);
 
   // Handle empty specs or ones that contain only whitespace or control chars.
   if (begin == spec_len) {
     parsed->scheme.reset();
     parsed->path.reset();
     return;
@@ skipping 37 matching lines @@
   }
 }
 
 // Converts a port number in a string to an integer. We'd like to just call
 // sscanf but our input is not NULL-terminated, which sscanf requires. Instead,
 // we copy the digits to a small stack buffer (since we know the maximum number
 // of digits in a valid port number) that we can NULL terminate.
 template<typename CHAR>
 int DoParsePort(const CHAR* spec, const Component& component) {
   // Easy success case when there is no port.
-  const int max_digits = 5;
+  const int kMaxDigits = 5;
   if (!component.is_nonempty())
     return PORT_UNSPECIFIED;
 
   // Skip over any leading 0s.
   Component digits_comp(component.end(), 0);
   for (int i = 0; i < component.len; i++) {
     if (spec[component.begin + i] != '0') {
       digits_comp = MakeRange(component.begin + i, component.end());
       break;
     }
   }
   if (digits_comp.len == 0)
     return 0;  // All digits were 0.
 
   // Verify we don't have too many digits (we'll be copying to our buffer so
   // we need to double-check).
-  if (digits_comp.len > max_digits)
+  if (digits_comp.len > kMaxDigits)
     return PORT_INVALID;
 
   // Copy valid digits to the buffer.
-  char digits[max_digits + 1];  // +1 for null terminator
+  char digits[kMaxDigits + 1];  // +1 for null terminator
   for (int i = 0; i < digits_comp.len; i++) {
     CHAR ch = spec[digits_comp.begin + i];
     if (!IsPortDigit(ch)) {
       // Invalid port digit, fail.
       return PORT_INVALID;
     }
     digits[i] = static_cast<char>(ch);
   }
 
   // Null-terminate the string and convert to integer. Since we guarantee
@@ skipping 267 matching lines @@
 }
 
 void ParseAfterScheme(const char16* spec,
                       int spec_len,
                       int after_scheme,
                       Parsed* parsed) {
   DoParseAfterScheme(spec, spec_len, after_scheme, parsed);
 }
 
 }  // namespace url_parse