net/spdy/spdy_http_utils.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/spdy/spdy_http_utils.h"
   6
   7 #include <string>
   8
   9 #include "base/strings/string_number_conversions.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/time/time.h"
  12 #include "net/base/escape.h"
  13 #include "net/base/load_flags.h"
  14 #include "net/base/net_util.h"
  15 #include "net/http/http_request_headers.h"
  16 #include "net/http/http_request_info.h"
  17 #include "net/http/http_response_headers.h"
  18 #include "net/http/http_response_info.h"
  19 #include "net/http/http_util.h"
  20
  21 namespace net {
  22
  23 bool SpdyHeadersToHttpResponse(const SpdyHeaderBlock& headers,
  24                                SpdyMajorVersion protocol_version,
  25                                HttpResponseInfo* response) {
  26   std::string status_key = (protocol_version >= SPDY3) ? ":status" : "status";
  27   std::string version_key =
  28       (protocol_version >= SPDY3) ? ":version" : "version";
  29   std::string version;
  30   std::string status;
  31
  32   // The "status" header is required. "version" is required below SPDY4.
  33   SpdyHeaderBlock::const_iterator it;
  34   it = headers.find(status_key);
  35   if (it == headers.end())
  36     return false;
  37   status = it->second;
  38
  39   if (protocol_version >= SPDY4) {
  40     version = "HTTP/1.1";
  41   } else {
  42     it = headers.find(version_key);
  43     if (it == headers.end())
  44       return false;
  45     version = it->second;
  46   }
  47   std::string raw_headers(version);
  48   raw_headers.push_back(' ');
  49   raw_headers.append(status);
  50   raw_headers.push_back('\0');
  51   for (it = headers.begin(); it != headers.end(); ++it) {
  52     // For each value, if the server sends a NUL-separated
  53     // list of values, we separate that back out into
  54     // individual headers for each value in the list.
  55     // e.g.
  56     //    Set-Cookie "foo\0bar"
  57     // becomes
  58     //    Set-Cookie: foo\0
  59     //    Set-Cookie: bar\0
  60     std::string value = it->second;
  61     size_t start = 0;
  62     size_t end = 0;
  63     do {
  64       end = value.find('\0', start);
  65       std::string tval;
  66       if (end != value.npos)
  67         tval = value.substr(start, (end - start));
  68       else
  69         tval = value.substr(start);
  70       if (protocol_version >= 3 && it->first[0] == ':')
  71         raw_headers.append(it->first.substr(1));
  72       else
  73         raw_headers.append(it->first);
  74       raw_headers.push_back(':');
  75       raw_headers.append(tval);
  76       raw_headers.push_back('\0');
  77       start = end + 1;
  78     } while (end != value.npos);
  79   }
  80
  81   response->headers = new HttpResponseHeaders(raw_headers);
  82   response->was_fetched_via_spdy = true;
  83   return true;
  84 }
  85
  86 void CreateSpdyHeadersFromHttpRequest(const HttpRequestInfo& info,
  87                                       const HttpRequestHeaders& request_headers,
  88                                       SpdyHeaderBlock* headers,
  89                                       SpdyMajorVersion protocol_version,
  90                                       bool direct) {
  91
  92   HttpRequestHeaders::Iterator it(request_headers);
  93   while (it.GetNext()) {
  94     std::string name = StringToLowerASCII(it.name());
  95     if (name == "connection" || name == "proxy-connection" ||
  96         name == "transfer-encoding" || name == "host") {
  97       continue;
  98     }
  99     if (headers->find(name) == headers->end()) {
 100       (*headers)[name] = it.value();
 101     } else {
 102       std::string new_value = (*headers)[name];
 103       new_value.append(1, '\0');  // +=() doesn't append 0's
 104       new_value += it.value();
 105       (*headers)[name] = new_value;
 106     }
 107   }
 108   static const char kHttpProtocolVersion[] = "HTTP/1.1";
 109
 110   if (protocol_version < SPDY3) {
 111     (*headers)["version"] = kHttpProtocolVersion;
 112     (*headers)["method"] = info.method;
 113     (*headers)["host"] = GetHostAndOptionalPort(info.url);
 114     (*headers)["scheme"] = info.url.scheme();
 115     if (direct)
 116       (*headers)["url"] = HttpUtil::PathForRequest(info.url);
 117     else
 118       (*headers)["url"] = HttpUtil::SpecForRequest(info.url);
 119   } else {
 120     if (protocol_version < SPDY4) {
 121       (*headers)[":version"] = kHttpProtocolVersion;
 122       (*headers)[":host"] = GetHostAndOptionalPort(info.url);
 123     } else {
 124       (*headers)[":authority"] = GetHostAndOptionalPort(info.url);
 125     }
 126     (*headers)[":method"] = info.method;
 127     (*headers)[":scheme"] = info.url.scheme();
 128     (*headers)[":path"] = HttpUtil::PathForRequest(info.url);
 129   }
 130 }
 131
 132 COMPILE_ASSERT(HIGHEST - LOWEST < 4 &&
 133                HIGHEST - MINIMUM_PRIORITY < 5,
 134                request_priority_incompatible_with_spdy);
 135
 136 SpdyPriority ConvertRequestPriorityToSpdyPriority(
 137     const RequestPriority priority,
 138     SpdyMajorVersion protocol_version) {
 139   DCHECK_GE(priority, MINIMUM_PRIORITY);
 140   DCHECK_LE(priority, MAXIMUM_PRIORITY);
 141   if (protocol_version == SPDY2) {
 142     // SPDY 2 only has 2 bits of priority, but we have 5 RequestPriorities.
 143     // Map IDLE => 3, LOWEST => 2, LOW => 2, MEDIUM => 1, HIGHEST => 0.
 144     if (priority > LOWEST) {
 145       return static_cast<SpdyPriority>(HIGHEST - priority);
 146     } else {
 147       return static_cast<SpdyPriority>(HIGHEST - priority - 1);
 148     }
 149   } else {
 150     return static_cast<SpdyPriority>(HIGHEST - priority);
 151   }
 152 }
 153
 154 NET_EXPORT_PRIVATE RequestPriority ConvertSpdyPriorityToRequestPriority(
 155     SpdyPriority priority,
 156     SpdyMajorVersion protocol_version) {
 157   // Handle invalid values gracefully, and pick LOW to map 2 back
 158   // to for SPDY/2.
 159   SpdyPriority idle_cutoff = (protocol_version == SPDY2) ? 3 : 5;
 160   return (priority >= idle_cutoff) ?
 161       IDLE : static_cast<RequestPriority>(HIGHEST - priority);
 162 }
 163
 164 GURL GetUrlFromHeaderBlock(const SpdyHeaderBlock& headers,
 165                            SpdyMajorVersion protocol_version,
 166                            bool pushed) {
 167   // SPDY 2 server push urls are specified in a single "url" header.
 168   if (pushed && protocol_version == SPDY2) {
 169       std::string url;
 170       SpdyHeaderBlock::const_iterator it;
 171       it = headers.find("url");
 172       if (it != headers.end())
 173         url = it->second;
 174       return GURL(url);
 175   }
 176
 177   const char* scheme_header = protocol_version >= SPDY3 ? ":scheme" : "scheme";
 178   const char* host_header = protocol_version >= SPDY4 ? ":authority" :
 179       (protocol_version >= SPDY3 ? ":host" : "host");
 180   const char* path_header = protocol_version >= SPDY3 ? ":path" : "url";
 181
 182   std::string scheme;
 183   std::string host_port;
 184   std::string path;
 185   SpdyHeaderBlock::const_iterator it;
 186   it = headers.find(scheme_header);
 187   if (it != headers.end())
 188     scheme = it->second;
 189   it = headers.find(host_header);
 190   if (it != headers.end())
 191     host_port = it->second;
 192   it = headers.find(path_header);
 193   if (it != headers.end())
 194     path = it->second;
 195
 196   std::string url = (scheme.empty() || host_port.empty() || path.empty())
 197                         ? std::string()
 198                         : scheme + "://" + host_port + path;
 199   return GURL(url);
 200 }
 201
 202 }  // namespace net