diff options
author | Mattes D <github@xoft.cz> | 2016-03-01 16:58:43 +0100 |
---|---|---|
committer | Mattes D <github@xoft.cz> | 2016-03-01 16:58:43 +0100 |
commit | 7cc8f8dd2213cade66633d196f579895385a869a (patch) | |
tree | 83219a6eaf87a2050c10662fb8caa5d1514a6af4 /src/HTTP/HTTPMessageParser.cpp | |
parent | Merge pull request #3057 from tonibm19/master (diff) | |
parent | HTTP: Fixed typos and bad leftovers. (diff) | |
download | cuberite-7cc8f8dd2213cade66633d196f579895385a869a.tar cuberite-7cc8f8dd2213cade66633d196f579895385a869a.tar.gz cuberite-7cc8f8dd2213cade66633d196f579895385a869a.tar.bz2 cuberite-7cc8f8dd2213cade66633d196f579895385a869a.tar.lz cuberite-7cc8f8dd2213cade66633d196f579895385a869a.tar.xz cuberite-7cc8f8dd2213cade66633d196f579895385a869a.tar.zst cuberite-7cc8f8dd2213cade66633d196f579895385a869a.zip |
Diffstat (limited to 'src/HTTP/HTTPMessageParser.cpp')
-rw-r--r-- | src/HTTP/HTTPMessageParser.cpp | 222 |
1 files changed, 222 insertions, 0 deletions
diff --git a/src/HTTP/HTTPMessageParser.cpp b/src/HTTP/HTTPMessageParser.cpp new file mode 100644 index 000000000..10d3d4ad9 --- /dev/null +++ b/src/HTTP/HTTPMessageParser.cpp @@ -0,0 +1,222 @@ + +// HTTPMessageParser.cpp + +// Implements the cHTTPMessageParser class that parses HTTP messages (request or response) being pushed into the parser, +// and reports the individual parts via callbacks + +#include "Globals.h" +#include "HTTPMessageParser.h" + + + + + +cHTTPMessageParser::cHTTPMessageParser(cHTTPMessageParser::cCallbacks & a_Callbacks): + m_Callbacks(a_Callbacks), + m_EnvelopeParser(*this) +{ + Reset(); +} + + + + + +size_t cHTTPMessageParser::Parse(const char * a_Data, size_t a_Size) +{ + // If parsing already finished or errorred, let the caller keep all the data: + if (m_IsFinished || m_HasHadError) + { + return 0; + } + + // If still waiting for the status line, add to buffer and try parsing it: + auto inBufferSoFar = m_Buffer.size(); + if (m_FirstLine.empty()) + { + m_Buffer.append(a_Data, a_Size); + auto bytesConsumedFirstLine = ParseFirstLine(); + ASSERT(bytesConsumedFirstLine <= inBufferSoFar + a_Size); // Haven't consumed more data than there is in the buffer + ASSERT(bytesConsumedFirstLine > inBufferSoFar); // Have consumed at least the previous buffer contents + if (m_FirstLine.empty()) + { + // All data used, but not a complete status line yet. + return a_Size; + } + if (m_HasHadError) + { + return AString::npos; + } + // Status line completed, feed the rest of the buffer into the envelope parser: + auto bytesConsumedEnvelope = m_EnvelopeParser.Parse(m_Buffer.data(), m_Buffer.size()); + if (bytesConsumedEnvelope == AString::npos) + { + m_HasHadError = true; + m_Callbacks.OnError("Failed to parse the envelope"); + return AString::npos; + } + ASSERT(bytesConsumedEnvelope <= bytesConsumedFirstLine + a_Size); // Haven't consumed more data than there was in the buffer + m_Buffer.erase(0, bytesConsumedEnvelope); + if (!m_EnvelopeParser.IsInHeaders()) + { + HeadersFinished(); + // Process any data still left in the buffer as message body: + auto bytesConsumedBody = ParseBody(m_Buffer.data(), m_Buffer.size()); + if (bytesConsumedBody == AString::npos) + { + // Error has already been reported by ParseBody, just bail out: + return AString::npos; + } + return bytesConsumedBody + bytesConsumedEnvelope + bytesConsumedFirstLine - inBufferSoFar; + } + return a_Size; + } // if (m_FirstLine.empty()) + + // If still parsing headers, send them to the envelope parser: + if (m_EnvelopeParser.IsInHeaders()) + { + auto bytesConsumed = m_EnvelopeParser.Parse(a_Data, a_Size); + if (bytesConsumed == AString::npos) + { + m_HasHadError = true; + m_Callbacks.OnError("Failed to parse the envelope"); + return AString::npos; + } + if (!m_EnvelopeParser.IsInHeaders()) + { + HeadersFinished(); + // Process any data still left as message body: + auto bytesConsumedBody = ParseBody(a_Data + bytesConsumed, a_Size - bytesConsumed); + if (bytesConsumedBody == AString::npos) + { + // Error has already been reported by ParseBody, just bail out: + return AString::npos; + } + } + return a_Size; + } + + // Already parsing the body + return ParseBody(a_Data, a_Size); +} + + + + + +void cHTTPMessageParser::Reset(void) +{ + m_HasHadError = false; + m_IsFinished = false; + m_FirstLine.clear(); + m_Buffer.clear(); + m_EnvelopeParser.Reset(); + m_TransferEncodingParser.reset(); + m_TransferEncoding.clear(); + m_ContentLength = 0; +} + + + + +size_t cHTTPMessageParser::ParseFirstLine(void) +{ + auto idxLineEnd = m_Buffer.find("\r\n"); + if (idxLineEnd == AString::npos) + { + // Not a complete line yet + return m_Buffer.size(); + } + m_FirstLine = m_Buffer.substr(0, idxLineEnd); + m_Buffer.erase(0, idxLineEnd + 2); + m_Callbacks.OnFirstLine(m_FirstLine); + return idxLineEnd + 2; +} + + + + +size_t cHTTPMessageParser::ParseBody(const char * a_Data, size_t a_Size) +{ + if (m_TransferEncodingParser == nullptr) + { + // We have no Transfer-encoding parser assigned. This should have happened when finishing the envelope + OnError("No transfer encoding parser"); + return AString::npos; + } + + // Parse the body using the transfer encoding parser: + // (Note that TE parser returns the number of bytes left, while we return the number of bytes consumed) + return a_Size - m_TransferEncodingParser->Parse(a_Data, a_Size); +} + + + + + +void cHTTPMessageParser::HeadersFinished(void) +{ + m_Callbacks.OnHeadersFinished(); + m_TransferEncodingParser = cTransferEncodingParser::Create(*this, m_TransferEncoding, m_ContentLength); + if (m_TransferEncodingParser == nullptr) + { + OnError(Printf("Unknown transfer encoding: %s", m_TransferEncoding.c_str())); + return; + } +} + + + + + +void cHTTPMessageParser::OnHeaderLine(const AString & a_Key, const AString & a_Value) +{ + m_Callbacks.OnHeaderLine(a_Key, a_Value); + auto Key = StrToLower(a_Key); + if (Key == "content-length") + { + if (!StringToInteger(a_Value, m_ContentLength)) + { + OnError(Printf("Invalid content length header value: \"%s\"", a_Value.c_str())); + } + return; + } + if (Key == "transfer-encoding") + { + m_TransferEncoding = a_Value; + return; + } +} + + + + + +void cHTTPMessageParser::OnError(const AString & a_ErrorDescription) +{ + m_HasHadError = true; + m_Callbacks.OnError(a_ErrorDescription); +} + + + + + +void cHTTPMessageParser::OnBodyData(const void * a_Data, size_t a_Size) +{ + m_Callbacks.OnBodyData(a_Data, a_Size); +} + + + + + +void cHTTPMessageParser::OnBodyFinished(void) +{ + m_IsFinished = true; + m_Callbacks.OnBodyFinished(); +} + + + + |