Index: third_party/WebKit/Source/modules/fetch/MultipartParser.cpp |
diff --git a/third_party/WebKit/Source/modules/fetch/MultipartParser.cpp b/third_party/WebKit/Source/modules/fetch/MultipartParser.cpp |
new file mode 100644 |
index 0000000000000000000000000000000000000000..d5efc77c370ce78d65ab5b1719f690e48f7ea348 |
--- /dev/null |
+++ b/third_party/WebKit/Source/modules/fetch/MultipartParser.cpp |
@@ -0,0 +1,349 @@ |
+// Copyright 2016 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. |
+ |
+#include "modules/fetch/MultipartParser.h" |
+ |
+#include "platform/HTTPNames.h" |
+#include "public/platform/Platform.h" |
+ |
+#include <algorithm> |
+#include <utility> |
+ |
+namespace blink { |
+ |
+namespace { |
+ |
+constexpr char kCloseDelimiterSuffix[] = "--\r\n"; |
+constexpr size_t kCloseDelimiterSuffixSize = WTF_ARRAY_LENGTH(kCloseDelimiterSuffix) - 1u; |
+constexpr size_t kDashBoundaryOffset = 2u; // The length of "--". |
+constexpr char kDelimiterSuffix[] = "\r\n"; |
+constexpr size_t kDelimiterSuffixSize = WTF_ARRAY_LENGTH(kDelimiterSuffix) - 1u; |
+ |
+bool octetsNeedDecoding(const WebURLResponse& response) |
+{ |
+ const AtomicString& encoding = response.toResourceResponse().httpHeaderFields().get(HTTPNames::Content_Transfer_Encoding); |
+ |
+ // Decoding is not needed if a transfer encoding is not used. |
+ if (encoding.isNull()) |
+ return false; |
+ |
+ // Decoding is not needed if a no-op transfer encoding is used. |
+ if (equalIgnoringCase(encoding, "binary") |
+ || equalIgnoringCase(encoding, "7bit") |
+ || equalIgnoringCase(encoding, "8bit")) { |
+ return false; |
+ } |
+ |
+ return true; |
+} |
+ |
+} // namespace |
+ |
+MultipartParser::Matcher::Matcher() = default; |
+ |
+MultipartParser::Matcher::Matcher(const char* data, size_t size, size_t capacity) |
+ : m_capacity(capacity), m_data(data), m_size(size) {} |
+ |
+bool MultipartParser::Matcher::appendIfExpected(char value) |
+{ |
+ DCHECK_LT(m_size, m_capacity); |
+ if (value != m_data[m_size]) |
+ return false; |
+ ++m_size; |
+ return true; |
+} |
+ |
+bool MultipartParser::Matcher::appendIfExpected(const char* first, const char* last) |
+{ |
+ while (first < last) { |
+ if (!appendIfExpected(*first++)) |
+ return false; |
+ } |
+ return true; |
+} |
+ |
+void MultipartParser::Matcher::clear() |
+{ |
+ m_size = 0u; |
+} |
+ |
+MultipartParser::MultipartParser(Vector<char> boundary, Client* client) |
+ : m_client(client) |
+ , m_delimiter(std::move(boundary)) |
+ , m_state(ParsingPreamble) |
+{ |
+ // The delimiter consists of "\r\n" and a dash boundary which consists of |
+ // "--" and a boundary. |
+ m_delimiter.prepend("\r\n--", 4u); |
+ m_bufferedBytes = delimiterMatcher(kDashBoundaryOffset); |
+} |
+ |
+bool MultipartParser::appendData(const char* bytes, size_t size) |
+{ |
+ DCHECK_NE(Finished, m_state); |
+ DCHECK_NE(Cancelled, m_state); |
+ |
+ const char* bytesEnd = bytes + size; |
+ |
+ while (bytes < bytesEnd) { |
+ switch (m_state) { |
+ case ParsingPreamble: |
+ // Parse either a preamble and a delimiter or a dash boundary. |
+ parseDelimiter(&bytes, bytesEnd); |
+ if (!m_bufferedBytes.isComplete() && bytes < bytesEnd) { |
+ // Parse a preamble (by ignoring it) and parse a delimiter. |
+ m_bufferedBytes.clear(); |
+ parseDataAndDelimiter(&bytes, bytesEnd); |
+ } |
+ if (m_bufferedBytes.isComplete()) { |
+ // Prepare for a delimiter suffix. |
+ m_bufferedBytes = delimiterSuffixMatcher(); |
+ m_state = ParsingDelimiterSuffix; |
+ } |
+ break; |
+ |
+ case ParsingDelimiterSuffix: |
+ // Parse transport padding and "\r\n" after a delimiter. |
+ // This can happen after either a preamble or part octets. |
+ if (m_bufferedBytes.empty()) |
+ parseTransportPadding(&bytes, bytesEnd); |
+ while (bytes < bytesEnd) { |
+ if (!m_bufferedBytes.appendIfExpected(*bytes++)) |
+ return false; |
+ if (m_bufferedBytes.isComplete()) { |
+ // Prepare for part header fields. |
+ m_state = ParsingPartHeaderFields; |
+ break; |
+ } |
+ } |
+ break; |
+ |
+ case ParsingPartHeaderFields: { |
+ // Parse part header fields (which ends with "\r\n") and an empty |
+ // line (which also ends with "\r\n"). |
+ // This can happen after a delimiter and a delimiter suffix which |
+ // can happen after either a preamble or part octets. |
+ WebURLResponse response; |
+ if (parseHeaderFields(&bytes, bytesEnd, &response)) { |
+ // Decoding is not implemented. |
+ if (octetsNeedDecoding(response)) |
+ return false; |
+ // Prepare for part octets. |
+ m_bufferedBytes = delimiterMatcher(); |
+ m_state = ParsingPartOctets; |
+ m_client->partHeaderFieldsInMultipartReceived(response.toResourceResponse()); |
+ } |
+ break; |
+ } |
+ |
+ case ParsingPartOctets: { |
+ // Parse part octets and a delimiter. |
+ // This can happen only after part header fields. |
yhirano
2016/09/21 09:02:57
Can you tell me what "This can happen" mean?
e_hakkinen
2016/09/22 22:27:16
It refers to this parsing part octets and a delimi
|
+ bool hasInitiallyBufferedBytes = !m_bufferedBytes.empty(); |
+ const char* octetsBegin = bytes; |
+ parseDelimiter(&bytes, bytesEnd); |
+ if (!m_bufferedBytes.isComplete() && bytes < bytesEnd) { |
+ if (!m_bufferedBytes.empty() && hasInitiallyBufferedBytes) { |
+ // The buffered bytes turned out to be octet bytes instead |
+ // of delimiter bytes. Additionally, some of the buffered |
+ // bytes are from the previous call and are therefore not |
+ // in the range [octetsBegin, bytesEnd[. |
+ m_client->partDataInMultipartReceived(m_bufferedBytes.data(), m_bufferedBytes.size()); |
+ octetsBegin = bytes; |
+ } |
+ if (m_state == ParsingPartOctets) { |
yhirano
2016/09/21 09:02:57
[optional] Moving the if statement to just after t
yhirano
2016/09/21 09:02:57
if (m_state != ParsingPartOctets)
break;
would
e_hakkinen
2016/09/22 22:27:16
Done.
|
+ m_bufferedBytes.clear(); |
+ parseDataAndDelimiter(&bytes, bytesEnd); |
+ const char* octetsEnd = bytes - m_bufferedBytes.size(); |
+ if (octetsEnd > octetsBegin) |
yhirano
2016/09/21 09:02:57
You are using the |begin < end| pattern in this fi
e_hakkinen
2016/09/22 22:27:16
Done.
|
+ m_client->partDataInMultipartReceived(octetsBegin, static_cast<size_t>(octetsEnd - octetsBegin)); |
+ } |
+ } |
+ if (m_state == ParsingPartOctets && m_bufferedBytes.isComplete()) { |
+ m_state = ParsingDelimiterOrCloseDelimiterSuffix; |
+ m_client->partDataInMultipartFullyReceived(); |
+ } |
+ break; |
+ } |
+ |
+ case ParsingDelimiterOrCloseDelimiterSuffix: |
+ // Determine whether this is a delimiter suffix or a close |
+ // delimiter suffix. |
+ // This can happen only after part octets. |
+ if (*bytes == '-') { |
+ // Prepare for a close delimiter suffix. |
+ m_bufferedBytes = closeDelimiterSuffixMatcher(); |
+ m_state = ParsingCloseDelimiterSuffix; |
+ } else { |
+ // Prepare for a delimiter suffix. |
+ m_bufferedBytes = delimiterSuffixMatcher(); |
+ m_state = ParsingDelimiterSuffix; |
+ } |
+ break; |
+ |
+ case ParsingCloseDelimiterSuffix: |
+ // Parse "--", transport padding and "\r\n" after a delimiter |
+ // (a delimiter and "--" constitute a close delimiter). |
+ // This can happen only after part octets. |
+ for (;;) { |
+ if (m_bufferedBytes.size() == 2u) |
+ parseTransportPadding(&bytes, bytesEnd); |
+ if (bytes >= bytesEnd) |
+ break; |
+ if (!m_bufferedBytes.appendIfExpected(*bytes++)) |
+ return false; |
+ if (m_bufferedBytes.isComplete()) { |
+ // Prepare for an epilogue. |
+ m_state = ParsingEpilogue; |
+ break; |
+ } |
+ } |
+ break; |
+ |
+ case ParsingEpilogue: |
+ // Parse an epilogue (by ignoring it). |
+ // This can happen only after a delimiter and a close delimiter |
+ // suffix which can happen only after part octets. |
+ return true; |
+ |
+ case Cancelled: |
+ case Finished: |
+ // The client changed the state. |
+ return true; |
+ } |
+ } |
+ |
+ DCHECK_EQ(bytesEnd, bytes); |
+ |
+ return true; |
+} |
+ |
+void MultipartParser::cancel() |
+{ |
+ m_state = Cancelled; |
+} |
+ |
+bool MultipartParser::finish() |
+{ |
+ DCHECK_NE(Cancelled, m_state); |
+ |
+ State initialState = m_state; |
+ |
+ if (m_state == ParsingPartOctets && !m_bufferedBytes.empty()) { |
+ // The end of append bytes looked like a delimiter but was not a full |
+ // one, after all. Treat the those bytes as octet bytes. |
+ m_client->partDataInMultipartReceived(m_bufferedBytes.data(), m_bufferedBytes.size()); |
+ } |
+ m_state = Finished; |
+ |
+ switch (initialState) { |
+ case ParsingCloseDelimiterSuffix: |
+ // Require a full close delimiter consisting of a delimiter and "--" |
+ // but ignore missing or partial "\r\n" after that. |
+ return m_bufferedBytes.size() >= 2u; |
+ case ParsingEpilogue: |
+ case Finished: |
+ return true; |
+ default: |
+ return false; |
+ } |
+} |
+ |
+MultipartParser::Matcher MultipartParser::closeDelimiterSuffixMatcher() const |
+{ |
+ return Matcher(kCloseDelimiterSuffix, 0u, kCloseDelimiterSuffixSize); |
+} |
+ |
+MultipartParser::Matcher MultipartParser::delimiterMatcher(size_t size) const |
+{ |
+ return Matcher(m_delimiter.data(), size, m_delimiter.size()); |
+} |
+ |
+MultipartParser::Matcher MultipartParser::delimiterSuffixMatcher() const |
+{ |
+ return Matcher(kDelimiterSuffix, 0u, kDelimiterSuffixSize); |
+} |
+ |
+void MultipartParser::parseDataAndDelimiter(const char** bytesPointer, const char* bytesEnd) |
+{ |
+ DCHECK(m_bufferedBytes.empty()); |
+ |
+ // Search for a complete delimiter within the bytes. |
+ const char* delimiterBegin = std::search(*bytesPointer, bytesEnd, m_delimiter.begin(), m_delimiter.end()); |
+ if (delimiterBegin != bytesEnd) { |
+ // A complete delimiter was found. The bytes before that are octet |
+ // bytes. |
+ const char* delimiterEnd = delimiterBegin + m_delimiter.size(); |
+ if (!m_bufferedBytes.appendIfExpected(delimiterBegin, delimiterEnd)) |
yhirano
2016/09/21 09:02:57
bool matched = m_bufferedBytes.appendIfExpected(de
e_hakkinen
2016/09/22 22:27:16
Done.
|
+ NOTREACHED(); |
+ DCHECK(m_bufferedBytes.isComplete()); |
+ *bytesPointer = delimiterEnd; |
+ } else { |
+ // Search for a partial delimiter in the end of the bytes. |
+ size_t size = static_cast<size_t>(bytesEnd - *bytesPointer); |
+ delimiterBegin = bytesEnd - std::min(m_delimiter.size() - 1u, size); |
+ for (;;) { |
yhirano
2016/09/21 09:02:57
How about
for (const char* begin = ...; begin < b
e_hakkinen
2016/09/22 22:27:16
Done. That decreases the number of times the loop
|
+ if (m_bufferedBytes.appendIfExpected(delimiterBegin, bytesEnd)) |
+ break; |
+ m_bufferedBytes.clear(); |
+ DCHECK_LT(delimiterBegin, bytesEnd); |
+ ++delimiterBegin; |
+ } |
+ // A partial delimiter (consisting of zero or more bytes) was found in |
+ // the end of bytes. The partial delimiter bytes are buffered for now. |
+ // The bytes before that are definitely octet bytes. |
+ *bytesPointer = bytesEnd; |
+ } |
+ |
+ DCHECK(m_bufferedBytes.isComplete() || *bytesPointer == bytesEnd); |
+} |
+ |
+void MultipartParser::parseDelimiter(const char** bytesPointer, const char* bytesEnd) |
+{ |
+ DCHECK(!m_bufferedBytes.isComplete()); |
+ while (*bytesPointer < bytesEnd && m_bufferedBytes.appendIfExpected(*(*bytesPointer))) { |
+ ++(*bytesPointer); |
+ if (m_bufferedBytes.isComplete()) |
+ break; |
+ } |
+} |
+ |
+bool MultipartParser::parseHeaderFields(const char** bytesPointer, const char* bytesEnd, WebURLResponse* response) |
+{ |
+ // Combine the current bytes with buffered header bytes if needed. |
+ const char* headerBytes = *bytesPointer; |
+ size_t headerSize = static_cast<size_t>(bytesEnd - *bytesPointer); |
+ if (!m_bufferedHeaderBytes.isEmpty()) { |
+ m_bufferedHeaderBytes.append(headerBytes, headerSize); |
+ headerBytes = m_bufferedHeaderBytes.data(); |
+ headerSize = m_bufferedHeaderBytes.size(); |
+ } |
+ |
+ size_t end = 0u; |
+ if (!Platform::current()->parseMultipartHeadersFromBody(headerBytes, headerSize, response, &end)) { |
+ // Store the current header bytes for the next call unless that has |
+ // already been done. |
+ if (m_bufferedHeaderBytes.isEmpty()) |
+ m_bufferedHeaderBytes.append(headerBytes, headerSize); |
+ *bytesPointer = bytesEnd; |
+ return false; |
+ } |
+ m_bufferedHeaderBytes.clear(); |
+ *bytesPointer = bytesEnd - (headerSize - end); |
+ |
+ return true; |
+} |
+ |
+void MultipartParser::parseTransportPadding(const char** bytesPointer, const char* bytesEnd) const |
+{ |
+ while (*bytesPointer < bytesEnd && (*(*bytesPointer) == '\t' || *(*bytesPointer) == ' ')) |
+ ++(*bytesPointer); |
+} |
+ |
+DEFINE_TRACE(MultipartParser) |
+{ |
+ visitor->trace(m_client); |
+} |
+ |
+} // namespace blink |