Handle HTTP-Version information as per RFC2616 sec 3.1 references.

net/http/http_response_headers.cc

 // Copyright (c) 2012 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.
 
 // The rules for header parsing were borrowed from Firefox:
 // http://lxr.mozilla.org/seamonkey/source/netwerk/protocol/http/src/nsHttpResponseHead.cpp
 // The rules for parsing content-types were also borrowed from Firefox:
 // http://lxr.mozilla.org/mozilla/source/netwerk/base/src/nsURLHelper.cpp#834
 
 #include "net/http/http_response_headers.h"
@@ skipping 610 matching lines @@
 
 // Note: this implementation implicitly assumes that line_end points at a valid
 // sentinel character (such as '\0').
 // static
 HttpVersion HttpResponseHeaders::ParseVersion(
     std::string::const_iterator line_begin,
     std::string::const_iterator line_end) {
   std::string::const_iterator p = line_begin;
 
   // RFC2616 sec 3.1: HTTP-Version   = "HTTP" "/" 1*DIGIT "." 1*DIGIT
-  // TODO: (1*DIGIT apparently means one or more digits, but we only handle 1).
+  // 1*DIGIT means one or more digits.
   // TODO: handle leading zeros, which is allowed by the rfc1616 sec 3.1.
 
   if ((line_end - p < 4) || !LowerCaseEqualsASCII(p, p + 4, "http")) {
     DVLOG(1) << "missing status line";
     return HttpVersion();
   }
 
   p += 4;
 
   if (p >= line_end || *p != '/') {
     DVLOG(1) << "missing version";
     return HttpVersion();
   }
 
   std::string::const_iterator dot = std::find(p, line_end, '.');
   if (dot == line_end) {
     DVLOG(1) << "malformed version";
     return HttpVersion();
   }
 
-  ++p;  // from / to first digit.
-  ++dot;  // from . to second digit.
+  ++p;  // from / to dot digits.
 
-  if (!(*p >= '0' && *p <= '9' && *dot >= '0' && *dot <= '9')) {
+  std::string::const_iterator version_major = p;
+  // std::string version_major = "";
+  for (; version_major != dot; ++version_major) {
+    if (!(*version_major >= '0' && *version_major <= '9')) {
+      DVLOG(1) << "malformed version number";
+      return HttpVersion();
+    }
+  }
+
+  ++dot;  // from . to end digits.
+
+  if (!(*dot >= '0' && *dot <= '9')) {
     DVLOG(1) << "malformed version number";
     return HttpVersion();
   }
 
-  uint16 major = *p - '0';
-  uint16 minor = *dot - '0';
+  // std::string version_minor = "";
+  std::string::const_iterator version_minor = dot;
+  for (; (*version_minor >= '0' && *version_minor <= '9'); ++version_minor) {
+    // version_minor += *dot;
+  }
+  uint major_version_number, minor_version_number;
+  if (!base::StringToUint(StringPiece(p, version_major), &major_version_number))
+    return HttpVersion();
+  if (!base::StringToUint(StringPiece(dot, version_minor),
+                          &minor_version_number))
+    return HttpVersion();
+  if (major_version_number > UINT16_MAX || minor_version_number > UINT16_MAX) {
+    DVLOG(1) << "malformed version number";
+    return HttpVersion();
+  }
+
+  uint16 major = static_cast<uint16>(major_version_number);
+  uint16 minor = static_cast<uint16>(minor_version_number);
 
   return HttpVersion(major, minor);
 }
 
 // Note: this implementation implicitly assumes that line_end points at a valid
 // sentinel character (such as '\0').
 void HttpResponseHeaders::ParseStatusLine(
     std::string::const_iterator line_begin,
     std::string::const_iterator line_end,
     bool has_headers) {
@@ skipping 772 matching lines @@
   return true;
 }
 
 bool HttpResponseHeaders::IsChunkEncoded() const {
   // Ignore spurious chunked responses from HTTP/1.0 servers and proxies.
   return GetHttpVersion() >= HttpVersion(1, 1) &&
       HasHeaderValue("Transfer-Encoding", "chunked");
 }
 
 }  // namespace net