blob: ec051a85665e38dab79f406c5c20632a9ca247c9 [file] [log] [blame]
// 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.
// NOTE: based loosely on mozilla's nsDataChannel.cpp
#include <algorithm>
#include "net/base/data_url.h"
#include "base/base64.h"
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "net/base/escape.h"
#include "net/base/mime_util.h"
#include "net/http/http_response_headers.h"
#include "net/http/http_util.h"
#include "url/gurl.h"
namespace net {
bool DataURL::Parse(const GURL& url,
std::string* mime_type,
std::string* charset,
std::string* data) {
if (!url.is_valid() || !url.has_scheme())
return false;
DCHECK(!data || data->empty());
std::string content = url.GetContent();
std::string::const_iterator begin = content.begin();
std::string::const_iterator end = content.end();
std::string::const_iterator comma = std::find(begin, end, ',');
if (comma == end)
return false;
std::vector<base::StringPiece> meta_data =
base::SplitStringPiece(base::StringPiece(begin, comma), ";",
// These are moved to |mime_type| and |charset| on success.
std::string mime_type_value;
std::string charset_value;
auto iter = meta_data.cbegin();
if (iter != meta_data.cend()) {
mime_type_value = base::ToLowerASCII(*iter);
static constexpr base::StringPiece kBase64Tag("base64");
static constexpr base::StringPiece kCharsetTag("charset=");
bool base64_encoded = false;
for (; iter != meta_data.cend(); ++iter) {
if (!base64_encoded &&
base::EqualsCaseInsensitiveASCII(*iter, kBase64Tag)) {
base64_encoded = true;
} else if (charset_value.empty() &&
base::StartsWith(*iter, kCharsetTag,
base::CompareCase::INSENSITIVE_ASCII)) {
charset_value = iter->substr(kCharsetTag.size()).as_string();
// The grammar for charset is not specially defined in RFC2045 and
// RFC2397. It just needs to be a token.
if (!HttpUtil::IsToken(charset_value))
return false;
if (mime_type_value.empty()) {
// Fallback to the default if nothing specified in the mediatype part as
// specified in RFC2045. As specified in RFC2397, we use |charset| even if
// |mime_type| is empty.
mime_type_value = "text/plain";
if (charset_value.empty())
charset_value = "US-ASCII";
} else if (!ParseMimeTypeWithoutParameter(mime_type_value, nullptr,
nullptr)) {
// Fallback to the default as recommended in RFC2045 when the mediatype
// value is invalid. For this case, we don't respect |charset| but force it
// set to "US-ASCII".
mime_type_value = "text/plain";
charset_value = "US-ASCII";
// The caller may not be interested in receiving the data.
if (data) {
// Preserve spaces if dealing with text or xml input, same as mozilla:
// but strip them otherwise:
// (Spaces in a data URL should be escaped, which is handled below, so any
// spaces now are wrong. People expect to be able to enter them in the URL
// bar for text, and it can't hurt, so we allow it.)
// TODO(mmenke): Is removing all spaces reasonable? GURL removes trailing
// spaces itself, anyways. Should we just trim leading spaces instead?
// Allowing random intermediary spaces seems unnecessary.
base::StringPiece raw_body(comma + 1, end);
// For base64, we may have url-escaped whitespace which is not part
// of the data, and should be stripped. Otherwise, the escaped whitespace
// could be part of the payload, so don't strip it.
if (base64_encoded) {
std::string unescaped_body = UnescapeBinaryURLComponent(raw_body);
// Strip spaces, which aren't allowed in Base64 encoding.
base::EraseIf(unescaped_body, base::IsAsciiWhitespace<char>);
size_t length = unescaped_body.length();
size_t padding_needed = 4 - (length % 4);
// If the input wasn't padded, then we pad it as necessary until we have a
// length that is a multiple of 4 as required by our decoder. We don't
// correct if the input was incorrectly padded. If |padding_needed| == 3,
// then the input isn't well formed and decoding will fail with or without
// padding.
if ((padding_needed == 1 || padding_needed == 2) &&
unescaped_body[length - 1] != '=') {
unescaped_body.resize(length + padding_needed, '=');
if (!base::Base64Decode(unescaped_body, data))
return false;
} else {
// Strip whitespace for non-text MIME types.
std::string temp;
if (!(, 5, "text/") == 0 ||
mime_type_value.find("xml") != std::string::npos)) {
temp = raw_body.as_string();
base::EraseIf(temp, base::IsAsciiWhitespace<char>);
raw_body = temp;
*data = UnescapeBinaryURLComponent(raw_body);
*mime_type = std::move(mime_type_value);
*charset = std::move(charset_value);
return true;
Error DataURL::BuildResponse(const GURL& url,
base::StringPiece method,
std::string* mime_type,
std::string* charset,
std::string* data,
scoped_refptr<HttpResponseHeaders>* headers) {
if (!DataURL::Parse(url, mime_type, charset, data))
// |mime_type| set by DataURL::Parse() is guaranteed to be in
// token "/" token
// form. |charset| can be an empty string.
// "charset" in the Content-Type header is specified explicitly to follow
// the "token" ABNF in the HTTP spec. When the DataURL::Parse() call is
// successful, it's guaranteed that the string in |charset| follows the
// "token" ABNF.
std::string content_type = *mime_type;
if (!charset->empty())
content_type.append(";charset=" + *charset);
// The terminal double CRLF isn't needed by TryToCreate().
*headers = HttpResponseHeaders::TryToCreate(
"HTTP/1.1 200 OK\r\n"
"Content-Type:" +
// Above line should always succeed - TryToCreate() only fails when there are
// nulls in the string, and DataURL::Parse() can't return nulls in anything
// but the |data| argument.
if (base::EqualsCaseInsensitiveASCII(method, "HEAD"))
return OK;
} // namespace net