OLD | NEW |
---|---|
(Empty) | |
1 // Copyright 2016 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 "modules/fetch/MultipartParser.h" | |
6 | |
7 #include "public/platform/Platform.h" | |
8 | |
9 #include <algorithm> | |
10 #include <utility> | |
11 | |
12 namespace blink { | |
13 | |
14 namespace { | |
15 const char kCloseDelimiterSuffix[] = "--\r\n"; | |
yhirano
2016/09/07 06:00:16
constexpr
ditto below.
e_hakkinen
2016/09/08 00:06:29
Done.
| |
16 const char kDelimiterSuffix[] = "\r\n"; | |
17 const size_t kDelimiterOffsetForEmptyPreamble = 2u; // For no "\r\n" prefix. | |
18 const size_t kDelimiterOffsetForEmptyBody = kDelimiterOffsetForEmptyPreamble ; | |
19 const size_t kDelimiterOffsetForErroneousBoundaryPrefix = 4u; // For no "\r\ n--" prefix. | |
20 } | |
21 | |
22 MultipartParser::MultipartParser(Vector<char> boundary, Client* client) | |
23 : m_delimiter(std::move(boundary)) | |
24 , m_client(client) | |
25 , m_seenDelimiterLength(0u) | |
26 , m_seenDelimiterOffset(kDelimiterOffsetForEmptyPreamble) | |
27 { | |
28 // The delimiter consists of "\r\n" and a dash delimiter which consists of | |
29 // "--" and a boundary. | |
30 m_delimiter.prepend("\r\n--", 4u); | |
31 } | |
32 | |
33 bool MultipartParser::appendData(const char* bytes, size_t size) | |
34 { | |
35 DCHECK_NE(Finished, m_state); | |
36 DCHECK_NE(Cancelled, m_state); | |
37 | |
38 while (size > 0u) { | |
39 size_t index = 0u; | |
40 | |
41 switch (m_state) { | |
42 case ParsingPreamble: | |
43 // Parse either a preamble and a delimiter or a dash delimiter. | |
44 if (parseDelimiter(bytes, size, &index)) { | |
45 if (m_seenDelimiterOffset == kDelimiterOffsetForErroneousBoundar yPrefix) { | |
46 // Remove the erroneous boundary prefix (see parseDelimiter | |
47 // for details). | |
48 m_delimiter.remove(kDelimiterOffsetForErroneousBoundaryPrefi x, 2u); | |
49 m_seenDelimiterLength -= 2u; | |
50 } | |
51 m_state = ParsingDelimiterSuffix; | |
52 } | |
53 break; | |
54 | |
55 case ParsingDelimiterSuffix: | |
56 // Parse transport padding and "\r\n" after a delimiter. | |
57 if (parseDelimiterSuffix(bytes, size, &index, kDelimiterSuffix)) | |
58 m_state = ParsingPartHeaderFields; | |
59 break; | |
60 | |
61 case ParsingPartHeaderFields: { | |
62 // Parse part header fields (which ends with "\r\n") and an empty | |
63 // line (which also ends with "\r\n"). | |
64 WebURLResponse response; | |
65 | |
66 // Combine the current bytes with previously seen header bytes if | |
67 // needed. | |
68 const char* headerBytes = bytes + index; | |
69 size_t headerSize = size - index; | |
70 if (!m_seenHeaderBytes.isEmpty()) { | |
71 m_seenHeaderBytes.append(headerBytes, headerSize); | |
72 headerBytes = m_seenHeaderBytes.data(); | |
73 headerSize = m_seenHeaderBytes.size(); | |
74 } | |
75 | |
76 size_t end = 0; | |
77 if (!Platform::current()->parseMultipartHeadersFromBody(headerBytes, headerSize, &response, &end)) { | |
78 // Store the current bytes for the next call. | |
79 if (headerBytes != m_seenHeaderBytes.data()) | |
80 m_seenHeaderBytes.append(headerBytes, headerSize); | |
81 return true; | |
82 } | |
83 | |
84 m_seenDelimiterLength = 0u; | |
85 m_seenDelimiterOffset = kDelimiterOffsetForEmptyBody; | |
86 m_seenHeaderBytes.shrink(0); | |
87 m_state = ParsingPartOctets; | |
88 index = size - (headerSize - end); | |
89 m_client->partHeaderFieldsInMultipartReceived( | |
90 response.toResourceResponse()); | |
91 break; | |
92 } | |
93 | |
94 case ParsingPartOctets: { | |
95 // Parse either a non-empty part octets and a delimiter or an empty | |
96 // part octets and a dash delimiter. | |
97 size_t initialSeenDelimiterLength = m_seenDelimiterLength; | |
98 size_t initialSeenDelimiterOffset = m_seenDelimiterOffset; | |
99 if (parseDelimiter(bytes, size, &index)) | |
100 m_state = ParsingDelimiterOrCloseDelimiterSuffix; | |
101 if (index >= m_seenDelimiterLength && initialSeenDelimiterLength > 0 u) | |
102 m_client->partDataInMultipartReceived(m_delimiter.data() + initi alSeenDelimiterOffset, initialSeenDelimiterLength); | |
103 if (index > m_seenDelimiterLength) | |
104 m_client->partDataInMultipartReceived(bytes, index - m_seenDelim iterLength); | |
105 if (m_state == ParsingDelimiterOrCloseDelimiterSuffix) | |
106 m_client->partDataInMultipartFullyReceived(); | |
107 break; | |
108 } | |
109 | |
110 case ParsingDelimiterOrCloseDelimiterSuffix: | |
111 m_state = bytes[index] != '-' ? ParsingDelimiterSuffix : ParsingClos eDelimiterSuffix; | |
112 break; | |
113 | |
114 case ParsingCloseDelimiterSuffix: | |
115 // Parse "--", transport padding and "\r\n" after a delimiter | |
116 // (a delimiter and "--" constitute a close delimiter). | |
117 if (parseDelimiterSuffix(bytes, size, &index, kCloseDelimiterSuffix) ) | |
118 m_state = ParsingEpilogue; | |
119 break; | |
120 | |
121 case ParsingEpilogue: | |
122 // Data in an epilogue should be ignored. | |
123 return true; | |
124 | |
125 case Cancelled: | |
126 case Finished: | |
127 // The client changed the state. | |
128 return true; | |
129 | |
130 case Failed: | |
131 // Keep failing. | |
132 return false; | |
133 } | |
134 | |
135 bytes += index; | |
136 size -= index; | |
137 } | |
138 | |
139 return true; | |
140 } | |
141 | |
142 void MultipartParser::cancel() | |
143 { | |
144 m_state = Cancelled; | |
145 } | |
146 | |
147 bool MultipartParser::finish() | |
148 { | |
149 DCHECK_NE(Cancelled, m_state); | |
150 | |
151 State initialState = m_state; | |
152 | |
153 if (m_state == ParsingPartOctets && m_seenDelimiterLength > 0u && m_seenDeli miterOffset + m_seenDelimiterLength < m_delimiter.size()) { | |
154 // The end of append bytes looked like a delimiter but was not a full | |
155 // one, after all. Treat the those bytes as part of part octets. | |
156 m_client->partDataInMultipartReceived( | |
157 m_delimiter.data() + m_seenDelimiterOffset, m_seenDelimiterLength); | |
158 } | |
159 m_state = Finished; | |
160 | |
161 switch (initialState) { | |
162 case ParsingCloseDelimiterSuffix: | |
163 // Require a full close delimiter consisting of a delimiter and "--" | |
164 // but ignore missing or partial "\r\n" after that. | |
165 return seenDelimiterSuffixLength() >= 2u; | |
166 case ParsingEpilogue: | |
167 case Finished: | |
168 return true; | |
169 default: | |
170 return false; | |
171 } | |
172 } | |
173 | |
174 size_t MultipartParser::countNonDelimiterBytes(const char* bytes, size_t size) c onst | |
175 { | |
176 const char* p = static_cast<const char*>(memchr(bytes, '\r', size)); | |
177 if (p) | |
178 return static_cast<size_t>(p - bytes); | |
179 return size; | |
180 } | |
181 | |
182 size_t MultipartParser::countPossibleDelimiterBytes(const char* bytes, size_t si ze) const | |
183 { | |
184 size_t index = 0u; | |
185 while (index < size && m_seenDelimiterOffset + m_seenDelimiterLength + index < m_delimiter.size() && bytes[index] == m_delimiter[m_seenDelimiterOffset + m_s eenDelimiterLength + index]) | |
186 ++index; | |
187 return index; | |
188 } | |
189 | |
190 size_t MultipartParser::countTransportPaddingBytes(const char* bytes, size_t siz e) const | |
191 { | |
192 size_t index = 0u; | |
193 while (index < size && (bytes[index] == '\t' || bytes[index] == ' ')) | |
194 ++index; | |
195 return index; | |
196 } | |
197 | |
198 bool MultipartParser::parseDelimiter(const char* bytes, size_t size, size_t* ind ex) | |
199 { | |
200 for (;;) { | |
201 // Try to continue reading a delimiter. | |
202 size_t possibleDelimiterBytes = countPossibleDelimiterBytes(bytes + *ind ex, size - *index); | |
203 if (possibleDelimiterBytes > 0u) { | |
204 m_seenDelimiterLength += possibleDelimiterBytes; | |
205 *index += possibleDelimiterBytes; | |
206 } | |
207 size_t seenDelimiterEnd = m_seenDelimiterOffset + m_seenDelimiterLength; | |
208 if (seenDelimiterEnd == m_delimiter.size()) | |
209 return true; | |
210 if (*index >= size) | |
211 break; | |
212 if (m_state == ParsingPreamble | |
213 && m_seenDelimiterOffset < kDelimiterOffsetForErroneousBoundaryPrefi x | |
214 && kDelimiterOffsetForErroneousBoundaryPrefix <= seenDelimiterEnd | |
215 && seenDelimiterEnd <= m_delimiter.size() - 2u | |
216 && std::equal( | |
217 m_delimiter.data() + kDelimiterOffsetForErroneousBoundaryPrefix - 2u, | |
218 m_delimiter.data() + seenDelimiterEnd, | |
219 m_delimiter.data() + kDelimiterOffsetForErroneousBoundaryPrefix) ) { | |
220 // Some servers erroneously prefix the boundary with "--" (see | |
221 // https://crbug.com/5786). Repeat the delimiter search with | |
yhirano
2016/09/07 06:00:16
This is a problem for multipart/x-mixed-replace. A
e_hakkinen
2016/09/08 00:06:29
OK, let's do that initially.
Although this is a n
| |
222 // an offset which ignores that erroneous prefix. Gecko does | |
223 // the same. | |
224 m_seenDelimiterLength -= kDelimiterOffsetForErroneousBoundaryPrefix - 2u - m_seenDelimiterOffset; | |
225 m_seenDelimiterOffset = kDelimiterOffsetForErroneousBoundaryPrefix; | |
226 continue; | |
227 } | |
228 | |
229 // Jump to the next possible delimiter or to the end of bytes. | |
230 m_seenDelimiterLength = 0u; | |
231 m_seenDelimiterOffset = 0u; | |
232 *index += countNonDelimiterBytes(bytes + *index, size - *index); | |
233 } | |
234 return false; | |
235 } | |
236 | |
237 bool MultipartParser::parseDelimiterSuffix(const char* bytes, size_t size, size_ t* index, const char* suffix) | |
238 { | |
239 while (char expected = suffix[seenDelimiterSuffixLength()]) { | |
240 if (expected == '\r') | |
241 *index += countTransportPaddingBytes(bytes + *index, size - *index); | |
242 if (*index >= size) | |
243 return false; | |
244 if (bytes[(*index)++] != expected) { | |
245 m_state = Failed; | |
246 return false; | |
247 } | |
248 ++m_seenDelimiterLength; | |
249 } | |
250 return true; | |
251 } | |
252 | |
253 size_t MultipartParser::seenDelimiterSuffixLength() const | |
254 { | |
255 return m_seenDelimiterOffset + m_seenDelimiterLength - m_delimiter.size(); | |
256 } | |
257 | |
258 DEFINE_TRACE(MultipartParser) | |
259 { | |
260 visitor->trace(m_client); | |
261 } | |
262 | |
263 } // namespace blink | |
OLD | NEW |