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
Parse(const GURL & url,std::string * mime_type,std::string * charset,std::string * data)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 std::string unparsed_meta_data(after_colon, comma);
41 base::SplitString(unparsed_meta_data, ';', &meta_data);
42
43 std::vector<std::string>::iterator iter = meta_data.begin();
44 if (iter != meta_data.end()) {
45 mime_type->swap(*iter);
46 base::StringToLowerASCII(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 (!net::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::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 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::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
139