
/*
 * Copyright 2011-2022 Cuberite Contributors
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// 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(fmt::format(FMT_STRING("Unknown transfer encoding: {}"), m_TransferEncoding));
		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(fmt::format(FMT_STRING("Invalid content length header value: \"{}\""), a_Value));
		}
		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();
}




