Ensure HttpResponseHeaders::raw_headers_ always ends with 2 '\0' characters.

net/http/http_response_headers.cc

 // Copyright (c) 2011 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 372 matching lines @@
   // ParseStatusLine adds a normalized status line to raw_headers_
   std::string::const_iterator line_begin = raw_input.begin();
   std::string::const_iterator line_end =
       std::find(line_begin, raw_input.end(), '\0');
   // has_headers = true, if there is any data following the status line.
   // Used by ParseStatusLine() to decide if a HTTP/0.9 is really a HTTP/1.0.
   bool has_headers = (line_end != raw_input.end() &&
                       (line_end + 1) != raw_input.end() &&
                       *(line_end + 1) != '\0');
   ParseStatusLine(line_begin, line_end, has_headers);
+  raw_headers_.push_back('\0');  // terminate status line with a null

[rvargas (doing something else), 2011/11/30 22:53:09]

Nit: Start with uppercase and end with period.

 
   if (line_end == raw_input.end()) {
-    raw_headers_.push_back('\0');
+    raw_headers_.push_back('\0');  // ensure the headers end with a double null

[rvargas (doing something else), 2011/11/30 22:53:09]

ibid

+
+    DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 2]);
+    DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 1]);
     return;
   }
 
   // Including a terminating null byte.
   size_t status_line_len = raw_headers_.size();
 
   // Now, we add the rest of the raw headers to raw_headers_, and begin parsing
   // it (to populate our parsed_ vector).
   raw_headers_.append(line_end + 1, raw_input.end());
 
   // Adjust to point at the null byte following the status line
   line_end = raw_headers_.begin() + status_line_len - 1;
 
   HttpUtil::HeadersIterator headers(line_end + 1, raw_headers_.end(),
                                     std::string(1, '\0'));
   while (headers.GetNext()) {
     AddHeader(headers.name_begin(),
               headers.name_end(),
               headers.values_begin(),
               headers.values_end());
   }
+
+  // Ensure the headers end with a double null.
+  while (raw_headers_.size() < 2 ||
+         raw_headers_[raw_headers_.size() - 2] != '\0' ||
+         raw_headers_[raw_headers_.size() - 1] != '\0') {
+    raw_headers_.push_back('\0');
+  }
+
+  DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 2]);
+  DCHECK_EQ('\0', raw_headers_[raw_headers_.size() - 1]);
 }
 
 // Append all of our headers to the final output string.
 void HttpResponseHeaders::GetNormalizedHeaders(std::string* output) const {
   // copy up to the null byte.  this just copies the status line.
   output->assign(raw_headers_.c_str());
 
   // headers may appear multiple times (not necessarily in succession) in the
   // header data, so we build a map from header name to generated header lines.
   // to preserve the order of the original headers, the actual values are kept
@@ skipping 229 matching lines @@
     DVLOG(1) << "assuming HTTP/" << http_version_.major_value() << "."
              << http_version_.minor_value();
   }
 
   // TODO(eroman): this doesn't make sense if ParseVersion failed.
   std::string::const_iterator p = std::find(line_begin, line_end, ' ');
 
   if (p == line_end) {
     DVLOG(1) << "missing response status; assuming 200 OK";
     raw_headers_.append(" 200 OK");
-    raw_headers_.push_back('\0');
     response_code_ = 200;
     return;
   }
 
   // Skip whitespace.
   while (*p == ' ')
     ++p;
 
   std::string::const_iterator code = p;
   while (*p >= '0' && *p <= '9')
@@ skipping 19 matching lines @@
     --line_end;
 
   if (p == line_end) {
     DVLOG(1) << "missing response status text; assuming OK";
     // Not super critical what we put here. Just use "OK"
     // even if it isn't descriptive of response_code_.
     raw_headers_.append("OK");
   } else {
     raw_headers_.append(p, line_end);
   }
-
-  raw_headers_.push_back('\0');
 }
 
 size_t HttpResponseHeaders::FindHeader(size_t from,
                                        const std::string& search) const {
   for (size_t i = from; i < parsed_.size(); ++i) {
     if (parsed_[i].is_continuation())
       continue;
     const std::string::const_iterator& name_begin = parsed_[i].name_begin;
     const std::string::const_iterator& name_end = parsed_[i].name_end;
     if (static_cast<size_t>(name_end - name_begin) == search.size() &&
@@ skipping 573 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