Implemented basic HTTP message header parsing.

VC2008/MCServer.vcproj

@@ -900,6 +900,14 @@
 				RelativePath="..\source\WebAdmin.h"
 				>
 			</File>
+			<File
+				RelativePath="..\source\WebServer.cpp"
+				>
+			</File>
+			<File
+				RelativePath="..\source\WebServer.h"
+				>
+			</File>
 			<File
 				RelativePath="..\source\World.cpp"
 				>

source/Root.cpp

@@ -135,11 +135,9 @@ void cRoot::Start(void)
 		{
 			LOGWARNING("webadmin.ini inaccessible, wabadmin is disabled");
 		}
-
-		if (WebIniFile.GetValueB("WebAdmin", "Enabled", false))
+		else
 		{
-			LOG("Creating WebAdmin...");
-			m_WebAdmin = new cWebAdmin(8080);
+			m_WebServer.Initialize(WebIniFile);
 		}
 
 		LOG("Loading settings...");

source/Root.h

@@ -2,6 +2,7 @@
 #pragma once
 
 #include "Authenticator.h"
+#include "WebServer.h"
 
 
 
@@ -141,6 +142,7 @@ private:
 	cWebAdmin *        m_WebAdmin;
 	cPluginManager *   m_PluginManager;
 	cAuthenticator     m_Authenticator;
+	cWebServer         m_WebServer;
 
 	cMCLogger *      m_Log;
 

source/WebServer.cpp

@@ -0,0 +1,341 @@
+
+// WebServer.cpp
+
+// Implements the cWebServer class representing a HTTP webserver that uses cListenThread and cSocketThreads for processing
+
+#include "Globals.h"
+#include "WebServer.h"
+
+
+
+
+
+// Disable MSVC warnings:
+#if defined(_MSC_VER)
+	#pragma warning(push)
+	#pragma warning(disable:4355)  // 'this' : used in base member initializer list
+#endif
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cWebRequest:
+
+cWebRequest::cWebRequest(cWebServer & a_WebServer) :
+	m_WebServer(a_WebServer),
+	m_IsReceivingHeaders(true)
+{
+}
+
+
+
+
+void cWebRequest::SendStatusAndReason(int a_StatusCode, const AString & a_Response)
+{
+	AppendPrintf(m_OutgoingData, "%d %s\r\n\r\n", a_StatusCode, a_Response.c_str());
+}
+
+
+
+
+
+void cWebRequest::ParseHeader(size_t a_IdxEnd)
+{
+	size_t Next = ParseRequestLine(a_IdxEnd);
+	if (Next == AString::npos)
+	{
+		SendStatusAndReason(HTTP_BAD_REQUEST, "Bad request");
+		return;
+	}
+	
+	AString Key;
+	while (Next < a_IdxEnd)
+	{
+		Next = ParseHeaderField(Next, a_IdxEnd, Key);
+		if (Next == AString::npos)
+		{
+			SendStatusAndReason(HTTP_BAD_REQUEST, "Bad request");
+			return;
+		}
+	}
+	
+	m_WebServer.RequestReady(this);
+}
+
+
+
+
+size_t cWebRequest::ParseRequestLine(size_t a_IdxEnd)
+{	
+	// Ignore the initial CRLFs (HTTP spec's "should")
+	size_t LineStart = 0;
+	while (
+		(LineStart < a_IdxEnd) &&
+		(
+			(m_IncomingHeaderData[LineStart] == '\r') ||
+			(m_IncomingHeaderData[LineStart] == '\n')
+		)
+	)
+	{
+		LineStart++;
+	}
+	if (LineStart >= a_IdxEnd)
+	{
+		return AString::npos;
+	}
+	
+	// Get the Request-Line
+	size_t LineEnd = m_IncomingHeaderData.find("\r\n", LineStart);
+	if (LineEnd == AString::npos)
+	{
+		return AString::npos;
+	}
+	AString RequestLine = m_IncomingHeaderData.substr(LineStart, LineEnd - LineStart);
+	
+	// Find the method:
+	size_t Space = RequestLine.find(" ", LineStart);
+	if (Space == AString::npos)
+	{
+		return AString::npos;
+	}
+	m_Method = RequestLine.substr(0, Space);
+	
+	// Find the URL:
+	size_t Space2 = RequestLine.find(" ", Space + 1);
+	if (Space2 == AString::npos)
+	{
+		return AString::npos;
+	}
+	m_URL = RequestLine.substr(Space, Space2 - Space);
+	
+	// Check that there's HTTP/version at the end
+	if (strncmp(RequestLine.c_str() + Space2 + 1, "HTTP/1.", 7) != 0)
+	{
+		return AString::npos;
+	}
+	
+	return LineEnd + 2;
+}
+
+
+
+
+
+size_t cWebRequest::ParseHeaderField(size_t a_IdxStart, size_t a_IdxEnd, AString & a_Key)
+{
+	if (a_IdxStart >= a_IdxEnd)
+	{
+		return a_IdxEnd;
+	}
+	if (m_IncomingHeaderData[a_IdxStart] <= ' ')
+	{
+		return ParseHeaderFieldContinuation(a_IdxStart + 1, a_IdxEnd, a_Key);
+	}
+	size_t ValueIdx = 0;
+	AString Key;
+	for (size_t i = a_IdxStart; i < a_IdxEnd; i++)
+	{
+		switch (m_IncomingHeaderData[i])
+		{
+			case '\n':
+			{
+				if ((ValueIdx == 0) || (i < ValueIdx - 2) || (i < a_IdxStart + 1) || (m_IncomingHeaderData[i - 1] != '\r'))
+				{
+					// Invalid header field - no colon or no CR before LF
+					return AString::npos;
+				}
+				AString Value = m_IncomingHeaderData.substr(ValueIdx + 1, i - ValueIdx - 2);
+				AddHeader(Key, Value);
+				a_Key = Key;
+				return i + 1;
+			}
+			case ':':
+			{
+				if (ValueIdx == 0)
+				{
+					Key = m_IncomingHeaderData.substr(a_IdxStart, i - a_IdxStart);
+					ValueIdx = i;
+				}
+				break;
+			}
+			case ' ':
+			case '\t':
+			{
+				if (ValueIdx == i - 1)
+				{
+					// Value has started in this char, but it is whitespace, so move the start one char further
+					ValueIdx = i;
+				}
+			}
+		}  // switch (char)
+	}  // for i - m_IncomingHeaderData[]
+	// No header found, return the end-of-data index:
+	return a_IdxEnd;
+}
+
+
+
+
+
+size_t cWebRequest::ParseHeaderFieldContinuation(size_t a_IdxStart, size_t a_IdxEnd, AString & a_Key)
+{
+	size_t Start = a_IdxStart;
+	for (size_t i = a_IdxStart; i < a_IdxEnd; i++)
+	{
+		if ((m_IncomingHeaderData[i] > ' ') && (Start == a_IdxStart))
+		{
+			Start = i;
+		}
+		else if (m_IncomingHeaderData[i] == '\n')
+		{
+			if ((i < a_IdxStart + 1) || (m_IncomingHeaderData[i - 1] != '\r'))
+			{
+				// There wasn't a CR before this LF
+				return AString::npos;
+			}
+			AString Value = m_IncomingHeaderData.substr(Start, i - Start - 1);
+			AddHeader(a_Key, Value);
+			return i + 1;
+		}
+	}
+	// LF not found, how? We found it at the header end (CRLFCRLF)
+	ASSERT(!"LF not found, wtf?");
+	return AString::npos;
+}
+
+
+
+
+
+void cWebRequest::AddHeader(const AString & a_Key, const AString & a_Value)
+{
+	cNameValueMap::iterator itr = m_Headers.find(a_Key);
+	if (itr == m_Headers.end())
+	{
+		m_Headers[a_Key] = a_Value;
+	}
+	else
+	{
+		// The header-field key is specified multiple times, combine into comma-separated list (RFC 2616 @ 4.2)
+		itr->second.append(", ");
+		itr->second.append(a_Value);
+	}
+}
+
+
+
+
+
+void cWebRequest::DataReceived(const char * a_Data, int a_Size)
+{
+	if (m_IsReceivingHeaders)
+	{
+		// Start searching 3 chars from the end of the already received data, if available:
+		size_t SearchStart = m_IncomingHeaderData.size();
+		SearchStart = (SearchStart > 3) ? SearchStart - 3 : 0;
+		
+		m_IncomingHeaderData.append(a_Data, a_Size);
+		
+		// Parse the header, if it is complete:
+		size_t idxEnd = m_IncomingHeaderData.find("\r\n\r\n", SearchStart);
+		if (idxEnd != AString::npos)
+		{
+			ParseHeader(idxEnd + 2);
+			m_IsReceivingHeaders = false;
+		}
+	}
+	else
+	{
+		// TODO: Receive the body, and the next request (If HTTP/1.1 keepalive
+	}
+}
+
+
+
+
+
+void cWebRequest::GetOutgoingData(AString & a_Data)
+{
+	std::swap(a_Data, m_OutgoingData);
+}
+
+
+
+
+
+void cWebRequest::SocketClosed(void)
+{
+	// TODO: m_WebServer.RequestFinished(this);
+}
+
+
+
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// cWebServer:
+
+cWebServer::cWebServer(void) :
+	m_ListenThreadIPv4(*this, cSocket::IPv4, "WebServer IPv4"),
+	m_ListenThreadIPv6(*this, cSocket::IPv6, "WebServer IPv6"),
+	m_SocketThreads()
+{
+}
+
+
+
+
+
+bool cWebServer::Initialize(cIniFile & a_IniFile)
+{
+	if (!a_IniFile.GetValueSetB("WebAdmin", "Enabled", false))
+	{
+		// The WebAdmin is disabled
+		return true;
+	}
+	bool HasAnyPort;
+	HasAnyPort = m_ListenThreadIPv4.Initialize(a_IniFile.GetValueSet("WebAdmin", "Port", "8081"));
+	HasAnyPort = m_ListenThreadIPv6.Initialize(a_IniFile.GetValueSet("WebAdmin", "PortsIPv6", "8082, 3300")) || HasAnyPort;
+	if (!HasAnyPort)
+	{
+		LOG("WebAdmin is disabled");
+		return false;
+	}
+	if (!m_ListenThreadIPv4.Start())
+	{
+		return false;
+	}
+	if (!m_ListenThreadIPv6.Start())
+	{
+		m_ListenThreadIPv4.Stop();
+		return false;
+	}
+	return true;
+}
+
+
+
+
+
+void cWebServer::OnConnectionAccepted(cSocket & a_Socket)
+{
+	cWebRequest * Request = new cWebRequest(*this);
+	m_SocketThreads.AddClient(a_Socket, Request);
+	cCSLock Lock(m_CSRequests);
+	m_Requests.push_back(Request);
+}
+
+
+
+
+
+void cWebServer::RequestReady(cWebRequest * a_Request)
+{
+	a_Request->SendStatusAndReason(cWebRequest::HTTP_OK, "Hello");
+}
+
+
+
+

source/WebServer.h

@@ -0,0 +1,122 @@
+
+// WebServer.h
+
+// Declares the cWebServer class representing a HTTP webserver that uses cListenThread and cSocketThreads for processing
+
+
+
+
+
+#pragma once
+
+#include "OSSupport/ListenThread.h"
+#include "OSSupport/SocketThreads.h"
+#include "../iniFile/iniFile.h"
+
+
+
+
+
+// fwd:
+class cWebServer;
+
+
+
+
+
+class cWebRequest :
+	public cSocketThreads::cCallback
+{
+public:
+	enum
+	{
+		HTTP_OK = 200,
+		HTTP_BAD_REQUEST = 400,
+	} ;
+	
+	cWebRequest(cWebServer & a_WebServer);
+	
+	/// Sends HTTP status code together with a_Reason
+	void SendStatusAndReason(int a_StatusCode, const AString & a_Reason);
+	
+protected:
+	typedef std::map<AString, AString> cNameValueMap;
+	
+	cWebServer & m_WebServer;
+	
+	AString       m_Method;   ///< Method of the request (GET / PUT / POST / ...)
+	AString       m_URL;      ///< Full URL of the request
+	cNameValueMap m_Headers;  ///< All the headers the request has come with
+	
+	AString m_IncomingHeaderData;  ///< All the incoming data until the entire header is parsed
+	
+	/// Set to true when the header haven't been received yet. If false, receiving the optional body.
+	bool m_IsReceivingHeaders;
+	
+	/// Data that is queued for sending, once the socket becomes writable
+	AString m_OutgoingData;
+	
+	
+	/// Parses the header in m_IncomingData until the specified end mark
+	void ParseHeader(size_t a_IdxEnd);
+	
+	/** Parses the RequestLine out of m_IncomingHeaderData, up to index a_IdxEnd
+	Returns the index to the next line, or npos if invalid request
+	*/
+	size_t ParseRequestLine(size_t a_IdxEnd);
+	
+	/** Parses one header field out of m_IncomingHeaderData, starting at the specified offset, up to offset a_IdxEnd.
+	Returns the index to the next line, or npos if invalid request.
+	a_Key is set to the key that was parsed (used for multi-line headers)
+	*/
+	size_t ParseHeaderField(size_t a_IdxStart, size_t a_IdxEnd, AString & a_Key);
+	
+	/** Parses one header field that is known to be a continuation of previous header.
+	Returns the index to the next line, or npos if invalid request.
+	*/
+	size_t ParseHeaderFieldContinuation(size_t a_IdxStart, size_t a_IdxEnd, AString & a_Key);
+	
+	/// Adds a header into m_Headers; appends if key already exists
+	void AddHeader(const AString & a_Key, const AString & a_Value);
+	
+	// cSocketThreads::cCallback overrides:
+	virtual void DataReceived   (const char * a_Data, int a_Size) override;  // Data is received from the client
+	virtual void GetOutgoingData(AString & a_Data) override;  // Data can be sent to client
+	virtual void SocketClosed   (void) override;  // The socket has been closed for any reason
+} ;
+
+typedef std::vector<cWebRequest *> cWebRequests;
+
+
+
+
+class cWebServer :
+	public cListenThread::cCallback
+{
+public:
+	cWebServer(void);
+	
+	bool Initialize(cIniFile & a_IniFile);
+	
+protected:
+	friend class cWebRequest;
+	
+	cListenThread m_ListenThreadIPv4;
+	cListenThread m_ListenThreadIPv6;
+	
+	cSocketThreads m_SocketThreads;
+
+	cCriticalSection m_CSRequests;
+	cWebRequests     m_Requests;    ///< All the requests that are currently being serviced
+
+	// cListenThread::cCallback overrides:
+	virtual void OnConnectionAccepted(cSocket & a_Socket) override;
+	
+	/// Called by cWebRequest when it finishes parsing its header
+	void RequestReady(cWebRequest * a_Request);
+} ;
+
+
+
+
+