Initial HTTPProxy support by simply transferring control to a tunnel

HTTPProxy.cpp

@@ -1,87 +1,247 @@
+#include <cstring>
+#include <cassert>
 #include <boost/lexical_cast.hpp>
 #include <boost/regex.hpp>
-
-#include "ClientContext.h"
 #include "HTTPProxy.h"
+#include "Identity.h"
+#include "Destination.h"
+#include "ClientContext.h"
+#include "I2PEndian.h"
 
 namespace i2p
 {
 namespace proxy
 {
-	void HTTPProxyConnection::parseHeaders(const std::string& h, std::vector<header>& hm) {
+	void HTTPProxyHandler::AsyncSockRead()
-		std::string str (h);
+	{
-		std::string::size_type idx;
+		LogPrint(eLogDebug,"--- HTTP Proxy async sock read");
-		std::string t;
+		if(m_sock) {
-		int i = 0;
+			m_sock->async_receive(boost::asio::buffer(m_http_buff, http_buffer_size),
-		while( (idx=str.find ("\r\n")) != std::string::npos) {
+						std::bind(&HTTPProxyHandler::HandleSockRecv, this,
-			t=str.substr (0,idx);
+								std::placeholders::_1, std::placeholders::_2));
-			str.erase (0,idx+2);
+		} else {
-			if (t == "")
+			LogPrint(eLogError,"--- HTTP Proxy no socket for read");
-				break;
-			idx=t.find(": ");
-			if (idx == std::string::npos)
-			{
-				std::cout << "Bad header line: " << t << std::endl;
-				break;
-			}
-			LogPrint ("Name: ", t.substr (0,idx), " Value: ", t.substr (idx+2));
-			hm[i].name = t.substr (0,idx);
-			hm[i].value = t.substr (idx+2);
-			i++;
 		}
 	}
 
-	void HTTPProxyConnection::ExtractRequest(request& r)
+	void HTTPProxyHandler::Done() {
+		if (m_parent) m_parent->RemoveHandler (shared_from_this ());
+	}
+
+	void HTTPProxyHandler::Terminate() {
+		if (dead.exchange(true)) return;
+		if (m_sock) {
+			LogPrint(eLogDebug,"--- HTTP Proxy close sock");
+			m_sock->close();
+			delete m_sock;
+			m_sock = nullptr;
+		}
+		Done();
+	}
+
+	/* All hope is lost beyond this point */
+	//TODO: handle this apropriately
+	void HTTPProxyHandler::HTTPRequestFailed(/*HTTPProxyHandler::errTypes error*/)
 	{
-		std::string requestString = m_Buffer;
+		std::string response = "HTTP/1.0 500 Internal Server Error\r\nContent-type: text/html\r\nContent-length: 0\r\n";
-		int idx=requestString.find(" ");
+		boost::asio::async_write(*m_sock, boost::asio::buffer(response,response.size()),
-		std::string method = requestString.substr(0,idx);
+					 std::bind(&HTTPProxyHandler::SentHTTPFailed, this, std::placeholders::_1));
-		requestString = requestString.substr(idx+1);
+	}
-		idx=requestString.find(" ");
+
-		std::string requestUrl = requestString.substr(0,idx);
+	void HTTPProxyHandler::EnterState(HTTPProxyHandler::state nstate) {
-		LogPrint("method is: ", method, "\nRequest is: ", requestUrl);
+		m_state = nstate;
+	}
+
+	void HTTPProxyHandler::ExtractRequest()
+	{
+		LogPrint(eLogDebug,"--- HTTP Proxy method is: ", m_method, "\nRequest is: ", m_url);
 		std::string server="";
 		std::string port="80";
 		boost::regex rHTTP("http://(.*?)(:(\\d+))?(/.*)");
 		boost::smatch m;
 		std::string path;
-		if(boost::regex_search(requestUrl, m, rHTTP, boost::match_extra)) {
+		if(boost::regex_search(m_url, m, rHTTP, boost::match_extra)) {
 			server=m[1].str();
 			if(m[2].str() != "") {
 				port=m[3].str();
 			}
 			path=m[4].str();
 		}
-		LogPrint("server is: ",server, " port is: ", port, "\n path is: ",path);
+		LogPrint(eLogDebug,"--- HTTP Proxy server is: ",server, " port is: ", port, "\n path is: ",path);
-		r.uri = path;
+		m_address = server;
-		r.method = method;
+		m_port = boost::lexical_cast<int>(port);
-		r.host = server;
+		m_path = path;
-		r.port = boost::lexical_cast<int>(port);
 	}
 
+	bool HTTPProxyHandler::ValidateHTTPRequest() {
+		if ( m_version != "HTTP/1.0" ) {
+			//TODO: we want to support 1.1 in the future
+			LogPrint(eLogError,"--- HTTP Proxy unsupported version: ", m_version);
+			HTTPRequestFailed(); //TODO: send right stuff
+			return false;
+		}
+		return true;
+	}
 
-	void HTTPProxyConnection::RunRequest()
+	bool HTTPProxyHandler::CreateHTTPRequest(uint8_t *http_buff, std::size_t len) {
+		ExtractRequest(); //TODO: parse earlier
+		if (!ValidateHTTPRequest()) return false;
+		m_request = m_method;
+		m_request.push_back(' ');
+		m_request += m_path;
+		m_request.push_back(' ');
+		m_request += m_version;
+		m_request.push_back('\r');
+		m_request.push_back('\n');
+		m_request.append(reinterpret_cast<const char *>(http_buff),len);
+		return true;
+	}
+
+	bool HTTPProxyHandler::HandleData(uint8_t *http_buff, std::size_t len)
 	{
-		request r;
+		assert(len); // This should always be called with a least a byte left to parse
-		ExtractRequest(r);
+		while (len > 0) {
-		parseHeaders(m_Buffer, r.headers);
+			//TODO: fallback to finding HOst: header if needed
-		size_t addressHelperPos = r.uri.find ("i2paddresshelper");
+			switch (m_state) {
-		if (addressHelperPos != std::string::npos)
+				case GET_METHOD:
-		{
+					switch (*http_buff) {
-			// jump service
+						case ' ': EnterState(GET_HOSTNAME); break;
-			size_t addressPos = r.uri.find ("=", addressHelperPos);
+						default: m_method.push_back(*http_buff); break;
-			if (addressPos != std::string::npos)
+					}
-			{
+					break;
-				LogPrint ("Jump service for ", r.host, " found. Inserting to address book");
+				case GET_HOSTNAME:
-				auto base64 = r.uri.substr (addressPos + 1);
+					switch (*http_buff) {
-				i2p::client::context.GetAddressBook ().InsertAddress (r.host, base64);
+						case ' ': EnterState(GET_HTTPV); break;
+						default: m_url.push_back(*http_buff); break;
+					}
+					break;
+				case GET_HTTPV:
+					switch (*http_buff) {
+						case '\r': EnterState(GET_HTTPVNL); break;
+						default: m_version.push_back(*http_buff); break;
+					}
+					break;
+				case GET_HTTPVNL:
+					switch (*http_buff) {
+						case '\n': EnterState(DONE); break;
+						default:
+							LogPrint(eLogError,"--- HTTP Proxy rejected invalid request ending with: ", ((int)*http_buff));
+							HTTPRequestFailed(); //TODO: add correct code
+							return false;
+					}
+					break;
+				default:
+					LogPrint(eLogError,"--- HTTP Proxy invalid state: ", m_state);
+					HTTPRequestFailed(); //TODO: add correct code 500
+					return false;
 			}
-		}			
+			http_buff++;
-	
+			len--;
-		LogPrint("Requesting ", r.host, ":", r.port, " with path ", r.uri, " and method ", r.method);
+			if (m_state == DONE)
-		SendToAddress (r.host, r.port,  m_Buffer, m_BufferLen);
+				return CreateHTTPRequest(http_buff,len);
+		}
+		return true;
+	}
+
+	void HTTPProxyHandler::HandleSockRecv(const boost::system::error_code & ecode, std::size_t len)
+	{
+		LogPrint(eLogDebug,"--- HTTP Proxy sock recv: ", len);
+		if(ecode) {
+			LogPrint(eLogWarning," --- HTTP Proxy sock recv got error: ", ecode);
+                        Terminate();
+			return;
+		}
+
+		if (HandleData(m_http_buff, len)) {
+			if (m_state == DONE) {
+				LogPrint(eLogInfo,"--- HTTP Proxy requested: ", m_url);
+				m_parent->GetLocalDestination ()->CreateStream (
+						std::bind (&HTTPProxyHandler::HandleStreamRequestComplete,
+						this, std::placeholders::_1), m_address, m_port);
+			} else {
+				AsyncSockRead();
+			}
+		}
+
+	}
+
+	void HTTPProxyHandler::SentHTTPFailed(const boost::system::error_code & ecode)
+	{
+		if (!ecode) {
+			Terminate();
+		} else {
+			LogPrint (eLogError,"--- HTTP Proxy Closing socket after sending failure because: ", ecode.message ());
+			Terminate();
+		}
+	}
+
+	void HTTPProxyHandler::HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream)
+	{
+		if (stream) {
+			if (dead.exchange(true)) return;
+			LogPrint (eLogInfo,"--- HTTP Proxy New I2PTunnel connection");
+			auto connection = std::make_shared<i2p::client::I2PTunnelConnection>((i2p::client::I2PTunnel *)m_parent, m_sock, stream);
+			m_parent->AddConnection (connection);
+			connection->I2PConnect (reinterpret_cast<const uint8_t*>(m_request.data()), m_request.size());
+			Done();
+		} else {
+			LogPrint (eLogError,"--- HTTP Proxy Issue when creating the stream, check the previous warnings for more info.");
+			HTTPRequestFailed(); // TODO: Send correct error message host unreachable
+		}
+	}
+
+	void HTTPProxyServer::Start ()
+	{
+		m_Acceptor.listen ();
+		Accept ();
+	}
+
+	void HTTPProxyServer::Stop ()
+	{
+		m_Acceptor.close();
+		m_Timer.cancel ();
+		ClearConnections ();
+		ClearHandlers();
+	}
+
+	void HTTPProxyServer::Accept ()
+	{
+		auto newSocket = new boost::asio::ip::tcp::socket (GetService ());
+		m_Acceptor.async_accept (*newSocket, std::bind (&HTTPProxyServer::HandleAccept, this,
+			std::placeholders::_1, newSocket));
+	}
+
+	void  HTTPProxyServer::AddHandler (std::shared_ptr<HTTPProxyHandler> handler) {
+		std::unique_lock<std::mutex> l(m_HandlersMutex);
+		m_Handlers.insert (handler);
+	}
+
+	void  HTTPProxyServer::RemoveHandler (std::shared_ptr<HTTPProxyHandler> handler)
+	{
+		std::unique_lock<std::mutex> l(m_HandlersMutex);
+		m_Handlers.erase (handler);
+	}
+
+	void  HTTPProxyServer::ClearHandlers ()
+	{
+		std::unique_lock<std::mutex> l(m_HandlersMutex);
+		m_Handlers.clear ();
+	}
+
+	void HTTPProxyServer::HandleAccept (const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket)
+	{
+		if (!ecode)
+		{
+			LogPrint(eLogDebug,"--- HTTP Proxy accepted");
+			AddHandler(std::make_shared<HTTPProxyHandler> (this, socket));
+			Accept();
+		}
+		else
+		{
+			LogPrint (eLogError,"--- HTTP Proxy Closing socket on accept because: ", ecode.message ());
+			delete socket;
+		}
 	}
 
 }
 }
-

HTTPProxy.h

@@ -1,42 +1,95 @@
 #ifndef HTTP_PROXY_H__
 #define HTTP_PROXY_H__
 
-#include <sstream>
+#include <memory>
-#include <thread>
+#include <string>
+#include <set>
 #include <boost/asio.hpp>
-#include <boost/array.hpp>
+#include <mutex>
-
+#include <atomic>
-#include "HTTPServer.h"
+#include "Identity.h"
+#include "Streaming.h"
+#include "I2PTunnel.h"
 
 namespace i2p
 {
 namespace proxy
 {
-	class HTTPProxyConnection : public i2p::util::HTTPConnection
-	{
-		public:
-			HTTPProxyConnection (boost::asio::ip::tcp::socket * socket): HTTPConnection(socket) { };
 
-		protected:
+	const size_t http_buffer_size = 8192;
-			void RunRequest();
+
-			void parseHeaders(const std::string& h, std::vector<header>& hm);
+	class HTTPProxyServer;
-			void ExtractRequest(request& r);
+	class HTTPProxyHandler: public std::enable_shared_from_this<HTTPProxyHandler> {
+		private:
+			enum state {
+				GET_METHOD,
+				GET_HOSTNAME,
+				GET_HTTPV,
+				GET_HTTPVNL, //TODO: fallback to finding HOst: header if needed
+				DONE
+			};
+
+			void EnterState(state nstate);
+			bool HandleData(uint8_t *http_buff, std::size_t len);
+			void HandleSockRecv(const boost::system::error_code & ecode, std::size_t bytes_transfered);
+			void Done();
+			void Terminate();
+			void AsyncSockRead();
+			void HTTPRequestFailed(/*std::string message*/);
+			void ExtractRequest();
+			bool ValidateHTTPRequest();
+			bool CreateHTTPRequest(uint8_t *http_buff, std::size_t len);
+			void SentHTTPFailed(const boost::system::error_code & ecode);
+			void HandleStreamRequestComplete (std::shared_ptr<i2p::stream::Stream> stream);
+
+			uint8_t m_http_buff[http_buffer_size];
+			HTTPProxyServer * m_parent;
+			boost::asio::ip::tcp::socket * m_sock;
+			std::string m_request; //Data left to be sent
+			std::string m_url; //URL
+			std::string m_method; //Method
+			std::string m_version; //HTTP version
+			std::string m_address; //Address
+			std::string m_path; //Path
+			int m_port; //Port
+			std::atomic<bool> dead; //To avoid cleaning up multiple times
+			state m_state;//Parsing state
+
+		public:
+			HTTPProxyHandler(HTTPProxyServer * parent, boost::asio::ip::tcp::socket * sock) : 
+				m_parent(parent), m_sock(sock), dead(false)
+				{ AsyncSockRead(); EnterState(GET_METHOD); }
+			~HTTPProxyHandler() { Terminate(); }
 	};
 
-	class HTTPProxy : public i2p::util::HTTPServer
+	class HTTPProxyServer: public i2p::client::I2PTunnel
 	{
-		public:
+		private:
-			HTTPProxy (int port): HTTPServer(port) {};
+			std::set<std::shared_ptr<HTTPProxyHandler> > m_Handlers;
+			boost::asio::ip::tcp::acceptor m_Acceptor;
+			boost::asio::deadline_timer m_Timer;
+			std::mutex m_HandlersMutex;
 
 		private:
-			void CreateConnection(boost::asio::ip::tcp::socket * m_NewSocket)
+
-			{
+			void Accept();
-				new HTTPProxyConnection(m_NewSocket);
+			void HandleAccept(const boost::system::error_code& ecode, boost::asio::ip::tcp::socket * socket);
-			}
+
+		public:
+			HTTPProxyServer(int port) : I2PTunnel(nullptr),
+				m_Acceptor (GetService (), boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)),
+				m_Timer (GetService ()) {};
+			~HTTPProxyServer() { Stop(); }
+
+			void Start ();
+			void Stop ();
+			void AddHandler (std::shared_ptr<HTTPProxyHandler> handler);
+			void RemoveHandler (std::shared_ptr<HTTPProxyHandler> handler);
+			void ClearHandlers ();
 	};
+
+	typedef HTTPProxyServer HTTPProxy;
 }
 }
 
-#endif
+#endif
-
-