Landing Recent QUIC changes until 4/8/2016 17:17 UTC

net/quic/spdy_utils.cc

 // Copyright (c) 2013 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.
 
 #include "net/quic/spdy_utils.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_framer.h"
 #include "net/spdy/spdy_protocol.h"
 #include "url/gurl.h"
 
 using std::string;
 using std::vector;
 
 namespace net {
 
+bool ascii_isupper(unsigned char c) {
+  return c >= 'A' && c <= 'Z';
+}
+
 // static
 string SpdyUtils::SerializeUncompressedHeaders(const SpdyHeaderBlock& headers) {
   SpdyMajorVersion spdy_version = HTTP2;
 
   size_t length = SpdyFramer::GetSerializedLength(spdy_version, &headers);
   SpdyFrameBuilder builder(length, spdy_version);
   SpdyFramer framer(spdy_version);
   framer.SerializeHeaderBlockWithoutCompression(&builder, headers);
   SpdySerializedFrame block(builder.take());
   return string(block.data(), length);
@@ skipping 67 matching lines @@
       return false;
     }
 
     // TODO(rjshade): Check for other forbidden keys, following the HTTP/2 spec.
   }
 
   DVLOG(1) << "Successfully parsed Trailers.";
   return true;
 }
 
+bool SpdyUtils::CopyAndValidateTrailers(const QuicHeaderList& header_list,
+                                        size_t* final_byte_offset,
+                                        SpdyHeaderBlock* trailers) {
+  for (const auto& p : header_list) {
+    const string& name = p.first;
+    if (name.empty() || name[0] == ':') {
+      DVLOG(1) << "Trailers must not be empty, and must not contain pseudo-"
+               << "headers. Found: '" << name << "'";
+      return false;
+    }
+
+    if (std::any_of(name.begin(), name.end(), ascii_isupper)) {
+      DVLOG(1) << "Malformed header: Header name " << name
+               << " contains upper-case characters.";
+      return false;
+    }
+
+    if (trailers->find(name) != trailers->end()) {
+      DVLOG(1) << "Duplicate header '" << name << "' found in trailers.";
+      return false;
+    }
+
+    (*trailers)[name] = p.second;
+  }
+
+  if (trailers->empty()) {
+    DVLOG(1) << "Request Trailers are invalid.";
+    return false;  // Trailers were invalid.
+  }
+
+  // Pull out the final offset pseudo header which indicates the number of
+  // response body bytes expected.
+  auto it = trailers->find(kFinalOffsetHeaderKey);
+  if (it == trailers->end() || !StringToSizeT(it->second, final_byte_offset)) {
+    DVLOG(1) << "Required key '" << kFinalOffsetHeaderKey << "' not present";
+    return false;
+  }
+  // The final offset header is no longer needed.
+  trailers->erase(it->first);
+
+  // TODO(rjshade): Check for other forbidden keys, following the HTTP/2 spec.
+
+  DVLOG(1) << "Successfully parsed Trailers: " << trailers->DebugString();
+  return true;
+}
+
 // static
 string SpdyUtils::GetUrlFromHeaderBlock(const SpdyHeaderBlock& headers) {
   SpdyHeaderBlock::const_iterator it = headers.find(":scheme");
   if (it == headers.end()) {
     return "";
   }
   std::string url = it->second.as_string();
 
   url.append("://");
 
@@ skipping 16 matching lines @@
   return GURL(GetUrlFromHeaderBlock(headers)).host();
 }
 
 // static
 bool SpdyUtils::UrlIsValid(const SpdyHeaderBlock& headers) {
   string url(GetUrlFromHeaderBlock(headers));
   return url != "" && GURL(url).is_valid();
 }
 
 }  // namespace net