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..1ade0f7c5f483a6bf0bc7a9cd61cc60aaead0e85 |
--- /dev/null |
+++ b/third_party/WebKit/Source/modules/fetch/MultipartParser.cpp |
@@ -0,0 +1,344 @@ |
+// 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; |
+ |
+} // namespace |
+ |
+MultipartParser::Buffer::Buffer() = default; |
+ |
+MultipartParser::Buffer::Buffer(const char* first, const char* last) |
+ : Buffer(first, static_cast<size_t>(last - first), static_cast<size_t>(last - first)) {} |
+ |
+MultipartParser::Buffer::Buffer(const char* data, size_t size, size_t capacity) |
+ : m_capacity(capacity), m_data(data), m_size(size) {} |
+ |
+bool MultipartParser::Buffer::appendIfExpected(char value) |
+{ |
+ DCHECK_LT(m_size, m_capacity); |
+ if (value != m_data[m_size]) |
+ return false; |
+ ++m_size; |
+ return true; |
+} |
+ |
+bool MultipartParser::Buffer::appendIfExpected(const char* first, const char* last) |
+{ |
+ while (first < last) { |
+ if (!appendIfExpected(*first++)) |
+ return false; |
+ } |
+ return true; |
+} |
+ |
+void MultipartParser::Buffer::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 = delimiterBuffer(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. |
+ Buffer unusedPreambleData; |
+ if (parseDataAndDelimiter(&bytes, bytesEnd, &unusedPreambleData)) |
+ 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()) { |
+ m_bufferedBytes = delimiterSuffixBuffer(); |
+ parseTransportPadding(&bytes, bytesEnd); |
+ } |
+ while (m_state == ParsingDelimiterSuffix && bytes < bytesEnd) { |
+ if (!m_bufferedBytes.appendIfExpected(*bytes++)) { |
+ m_state = Failed; |
yhirano
2016/09/20 09:49:53
If bytes == bytesEnd this function returns true. I
e_hakkinen
2016/09/20 21:59:29
True. Fixed.
|
+ } else if (m_bufferedBytes.size() == kDelimiterSuffixSize) { |
yhirano
2016/09/20 09:49:53
How about having isComplete method rather than com
e_hakkinen
2016/09/20 21:59:29
Done.
|
+ m_bufferedBytes.clear(); |
+ m_state = ParsingPartHeaderFields; |
+ } |
+ } |
+ 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)) { |
+ m_bufferedBytes = delimiterBuffer(); |
+ m_state = ParsingPartOctets; |
+ m_client->partHeaderFieldsInMultipartReceived(response.toResourceResponse()); |
+ } |
+ break; |
+ } |
+ |
+ case ParsingPartOctets: { |
+ // Parse either a non-empty part octets and a delimiter or an empty |
+ // part octets and a dash boundary. |
+ // This can happen only after part header fields. |
+ Buffer octetsData; |
+ if (parseDataAndDelimiter(&bytes, bytesEnd, &octetsData)) |
+ m_state = ParsingDelimiterOrCloseDelimiterSuffix; |
+ if (!octetsData.empty()) |
+ m_client->partDataInMultipartReceived(octetsData.data(), octetsData.size()); |
+ if (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. |
+ m_state = *bytes == '-' ? ParsingCloseDelimiterSuffix : 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. |
+ if (m_bufferedBytes.empty()) |
+ m_bufferedBytes = closeDelimiterSuffixBuffer(); |
+ while (m_state == ParsingCloseDelimiterSuffix && bytes < bytesEnd) { |
+ if (m_bufferedBytes.size() == 2u && parseTransportPadding(&bytes, bytesEnd)) |
yhirano
2016/09/20 09:49:53
What do you think about the following pattern?
wh
e_hakkinen
2016/09/20 21:59:29
I am equally fine with that. Done.
|
+ continue; |
+ if (!m_bufferedBytes.appendIfExpected(*bytes++)) { |
+ m_state = Failed; |
+ } else if (m_bufferedBytes.size() == kCloseDelimiterSuffixSize) { |
+ m_bufferedBytes.clear(); |
+ m_state = ParsingEpilogue; |
+ } |
+ } |
+ 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; |
+ |
+ case Failed: |
+ // Keep failing. |
+ return false; |
+ } |
+ } |
+ |
+ 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 part of part octets. |
+ m_client->partDataInMultipartReceived(m_bufferedBytes.data(), m_bufferedBytes.size()); |
+ m_bufferedBytes.clear(); |
+ } |
+ 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::Buffer MultipartParser::closeDelimiterSuffixBuffer(size_t size) const |
+{ |
+ return Buffer(kCloseDelimiterSuffix, size, kCloseDelimiterSuffixSize); |
+} |
+ |
+MultipartParser::Buffer MultipartParser::delimiterBuffer(size_t size) const |
+{ |
+ return Buffer(m_delimiter.data(), size, m_delimiter.size()); |
+} |
+ |
+MultipartParser::Buffer MultipartParser::delimiterSuffixBuffer(size_t size) const |
+{ |
+ return Buffer(kDelimiterSuffix, size, kDelimiterSuffixSize); |
+} |
+ |
+bool MultipartParser::parseDataAndDelimiter(const char** bytesPointer, const char* bytesEnd, Buffer* data) |
+{ |
+ bool hasInitiallyBufferedBytes = !m_bufferedBytes.empty(); |
+ const char* bytesBegin = *bytesPointer; |
+ |
+ // Continue parsing a partial delimiter in the beginning of bytes. |
+ while (*bytesPointer < bytesEnd && m_bufferedBytes.appendIfExpected(*(*bytesPointer))) { |
+ // The partial delimiter continued. |
+ ++(*bytesPointer); |
+ if (m_bufferedBytes.size() == m_delimiter.size()) { |
+ // The partial delimiter turned out to be a complete one. |
+ // Therefore, the buffered bytes are delimiter bytes. |
+ m_bufferedBytes.clear(); |
yhirano
2016/09/20 09:49:53
Can you move this statement (and the similar ones)
e_hakkinen
2016/09/20 21:59:29
Done.
|
+ *data = Buffer(); |
+ return true; // A delimiter is parsed. |
+ } |
+ } |
+ |
+ if (*bytesPointer == bytesEnd) { |
+ // More bytes are needed. All bytes are buffered for now. |
+ *data = Buffer(); |
+ return false; |
+ } |
+ |
+ if (!m_bufferedBytes.empty()) { |
+ // The partial delimiter did not turn out to be a complete one. |
+ // Therefore, the buffered bytes are data bytes. |
+ if (hasInitiallyBufferedBytes) { |
+ // Not all buffered bytes are in the range [bytesBegin, bytesEnd[ |
+ // thus the buffered bytes must be returned separately. |
+ *data = std::move(m_bufferedBytes); |
+ m_bufferedBytes = delimiterBuffer(); |
+ return false; |
+ } |
+ // The fact the some bytes are now buffered can be ignored as they are |
+ // also in the range [bytesBegin, bytesEnd[. There is no need to reset |
yhirano
2016/09/20 09:49:53
]
e_hakkinen
2016/09/20 21:59:29
*bytesEnd does not belong to the range.
|
+ // |*bytesPointer| to |bytesBegin| as (partial) delimiters cannot |
+ // overlap. |
+ } |
+ |
+ // Search for a complete delimiter within the remaining 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 data |
+ // bytes. |
+ const char* delimiterEnd = delimiterBegin + m_delimiter.size(); |
+ *bytesPointer = delimiterEnd; |
+ *data = Buffer(bytesBegin, delimiterBegin); |
+ m_bufferedBytes.clear(); |
+ return true; // A delimiter is parsed. |
+ } |
+ |
+ // Search for a partial delimiter in the end of the remaining bytes. |
+ size_t remainingBytesSize = static_cast<size_t>(bytesEnd - *bytesPointer); |
+ delimiterBegin = bytesEnd - std::min(m_delimiter.size() - 1u, remainingBytesSize); |
+ for (;;) { |
+ m_bufferedBytes = delimiterBuffer(); |
+ if (m_bufferedBytes.appendIfExpected(delimiterBegin, bytesEnd)) |
+ break; |
+ DCHECK_LT(delimiterBegin, bytesEnd); |
+ ++delimiterBegin; |
+ } |
+ |
+ // A partial delimiter (consisting of zero or more bytes) was found and |
+ // the bytes are buffered for now. The bytes before the partial delimiter |
+ // are definitely data bytes and can thus be returned. |
+ *bytesPointer = bytesEnd; |
+ *data = Buffer(bytesBegin, delimiterBegin); |
+ return false; |
+} |
+ |
+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); |
+ |
+ const AtomicString& encoding = response->toResourceResponse().httpHeaderFields().get(HTTPNames::Content_Transfer_Encoding); |
+ if (!encoding.isNull()) { |
yhirano
2016/09/20 09:49:53
Why do you need this condition?
e_hakkinen
2016/09/20 21:59:29
It is needed in order to handle the common case in
|
+ if (!(equalIgnoringCase(encoding, "binary") |
+ || equalIgnoringCase(encoding, "7bit") |
+ || equalIgnoringCase(encoding, "8bit"))) { |
+ // Decoding is not implemented. |
+ m_state = Failed; |
+ return false; |
+ } |
+ } |
+ |
+ return true; |
+} |
+ |
+bool MultipartParser::parseTransportPadding(const char** bytesPointer, const char* bytesEnd) const |
+{ |
+ const char* bytesBegin = *bytesPointer; |
+ while (*bytesPointer < bytesEnd && (*(*bytesPointer) == '\t' || *(*bytesPointer) == ' ')) |
+ ++(*bytesPointer); |
+ return *bytesPointer > bytesBegin; |
+} |
+ |
+DEFINE_TRACE(MultipartParser) |
+{ |
+ visitor->trace(m_client); |
+} |
+ |
+} // namespace blink |