net/base/data_url.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 // NOTE: based loosely on mozilla's nsDataChannel.cpp
   6
   7 #include <algorithm>
   8
   9 #include "net/base/data_url.h"
  10
  11 #include "base/base64.h"
  12 #include "base/basictypes.h"
  13 #include "base/strings/string_split.h"
  14 #include "base/strings/string_util.h"
  15 #include "net/base/escape.h"
  16 #include "net/base/mime_util.h"
  17 #include "net/http/http_util.h"
  18 #include "url/gurl.h"
  19
  20 namespace net {
  21
  22 // static
  23 bool DataURL::Parse(const GURL& url, std::string* mime_type,
  24                     std::string* charset, std::string* data) {
  25   DCHECK(mime_type->empty());
  26   DCHECK(charset->empty());
  27   std::string::const_iterator begin = url.spec().begin();
  28   std::string::const_iterator end = url.spec().end();
  29
  30   std::string::const_iterator after_colon = std::find(begin, end, ':');
  31   if (after_colon == end)
  32     return false;
  33   ++after_colon;
  34
  35   std::string::const_iterator comma = std::find(after_colon, end, ',');
  36   if (comma == end)
  37     return false;
  38
  39   std::vector<std::string> meta_data =
  40       base::SplitString(base::StringPiece(after_colon, comma), ";",
  41                         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
  42
  43   std::vector<std::string>::iterator iter = meta_data.begin();
  44   if (iter != meta_data.end()) {
  45     mime_type->swap(*iter);
  46     *mime_type = base::ToLowerASCII(*mime_type);
  47     ++iter;
  48   }
  49
  50   static const char kBase64Tag[] = "base64";
  51   static const char kCharsetTag[] = "charset=";
  52   const size_t kCharsetTagLength = arraysize(kCharsetTag) - 1;
  53
  54   bool base64_encoded = false;
  55   for (; iter != meta_data.end(); ++iter) {
  56     if (!base64_encoded && *iter == kBase64Tag) {
  57       base64_encoded = true;
  58     } else if (charset->empty() &&
  59                iter->compare(0, kCharsetTagLength, kCharsetTag) == 0) {
  60       charset->assign(iter->substr(kCharsetTagLength));
  61       // The grammar for charset is not specially defined in RFC2045 and
  62       // RFC2397. It just needs to be a token.
  63       if (!HttpUtil::IsToken(*charset))
  64         return false;
  65     }
  66   }
  67
  68   if (mime_type->empty()) {
  69     // Fallback to the default if nothing specified in the mediatype part as
  70     // specified in RFC2045. As specified in RFC2397, we use |charset| even if
  71     // |mime_type| is empty.
  72     mime_type->assign("text/plain");
  73   } else if (!ParseMimeTypeWithoutParameter(*mime_type, NULL, NULL)) {
  74     // Fallback to the default as recommended in RFC2045 when the mediatype
  75     // value is invalid. For this case, we don't respect |charset| but force it
  76     // set to "US-ASCII".
  77     mime_type->assign("text/plain");
  78     charset->assign("US-ASCII");
  79   }
  80   if (charset->empty())
  81     charset->assign("US-ASCII");
  82
  83   // The caller may not be interested in receiving the data.
  84   if (!data)
  85     return true;
  86
  87   // Preserve spaces if dealing with text or xml input, same as mozilla:
  88   //   https://bugzilla.mozilla.org/show_bug.cgi?id=138052
  89   // but strip them otherwise:
  90   //   https://bugzilla.mozilla.org/show_bug.cgi?id=37200
  91   // (Spaces in a data URL should be escaped, which is handled below, so any
  92   // spaces now are wrong. People expect to be able to enter them in the URL
  93   // bar for text, and it can't hurt, so we allow it.)
  94   std::string temp_data = std::string(comma + 1, end);
  95
  96   // For base64, we may have url-escaped whitespace which is not part
  97   // of the data, and should be stripped. Otherwise, the escaped whitespace
  98   // could be part of the payload, so don't strip it.
  99   if (base64_encoded) {
 100     temp_data = UnescapeURLComponent(temp_data,
 101         UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS |
 102         UnescapeRule::SPOOFING_AND_CONTROL_CHARS);
 103   }
 104
 105   // Strip whitespace.
 106   if (base64_encoded || !(mime_type->compare(0, 5, "text/") == 0 ||
 107                           mime_type->find("xml") != std::string::npos)) {
 108     temp_data.erase(std::remove_if(temp_data.begin(), temp_data.end(),
 109                                    base::IsAsciiWhitespace<wchar_t>),
 110                     temp_data.end());
 111   }
 112
 113   if (!base64_encoded) {
 114     temp_data = UnescapeURLComponent(temp_data,
 115         UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS |
 116         UnescapeRule::SPOOFING_AND_CONTROL_CHARS);
 117   }
 118
 119   if (base64_encoded) {
 120     size_t length = temp_data.length();
 121     size_t padding_needed = 4 - (length % 4);
 122     // If the input wasn't padded, then we pad it as necessary until we have a
 123     // length that is a multiple of 4 as required by our decoder. We don't
 124     // correct if the input was incorrectly padded. If |padding_needed| == 3,
 125     // then the input isn't well formed and decoding will fail with or without
 126     // padding.
 127     if ((padding_needed == 1 || padding_needed == 2) &&
 128         temp_data[length - 1] != '=') {
 129       temp_data.resize(length + padding_needed, '=');
 130     }
 131     return base::Base64Decode(temp_data, data);
 132   }
 133
 134   temp_data.swap(*data);
 135   return true;
 136 }
 137
 138 }  // namespace net