PurpleI2P
/
i2pd
mirror of https://github.com/PurpleI2P/i2pd.git
1
0
Fork 0
Code Issues Releases Activity
Browse Source

Merge pull request #49 from chertov/master 

use HTTPConnection as the base class for proxy
pull/50/head
orignal 11 years ago
parent
69c013d6ab df0e235de2
commit
9d373dba1e
4 changed files with 144 additions and 341 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 275
      HTTPProxy.cpp
  2. 83
      HTTPProxy.h
  3. 27
      HTTPServer.cpp
  4. 18
      HTTPServer.h

275
HTTPProxy.cpp
Unescape View File

@ -1,80 +1,13 @@
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp> #include <boost/lexical_cast.hpp>
#include <boost/bind/protect.hpp>
#include <boost/regex.hpp> #include <boost/regex.hpp>
#include "base64.h"
#include "Log.h"
#include "Tunnel.h"
#include "TransitTunnel.h"
#include "Transports.h"
#include "NetDb.h"
#include "Streaming.h"
#include "HTTPProxy.h" #include "HTTPProxy.h"
namespace i2p namespace i2p
{ {
namespace proxy namespace proxy
{ {
namespace misc_strings void HTTPProxyConnection::parseHeaders(const std::string& h, std::vector<header>& hm) {
{
const char name_value_separator[] = { ':', ' ' };
const char crlf[] = { '\r', '\n' };
} // namespace misc_strings
std::vector<boost::asio::const_buffer> HTTPConnection::reply::to_buffers()
{
std::vector<boost::asio::const_buffer> buffers;
if (headers.size () > 0)
{
buffers.push_back (boost::asio::buffer ("HTTP/1.0 200 OK\r\n")); // always OK
for (std::size_t i = 0; i < headers.size(); ++i)
{
header& h = headers[i];
buffers.push_back(boost::asio::buffer(h.name));
buffers.push_back(boost::asio::buffer(misc_strings::name_value_separator));
buffers.push_back(boost::asio::buffer(h.value));
buffers.push_back(boost::asio::buffer(misc_strings::crlf));
}
buffers.push_back(boost::asio::buffer(misc_strings::crlf));
}
buffers.push_back(boost::asio::buffer(content));
return buffers;
}
void HTTPConnection::Terminate ()
{
m_Socket->close ();
delete this;
}
void HTTPConnection::Receive ()
{
m_Socket->async_read_some (boost::asio::buffer (m_Buffer, 8192),
boost::bind(&HTTPConnection::HandleReceive, this,
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred));
}
void HTTPConnection::HandleReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
{
if (!ecode)
{
m_Buffer[bytes_transferred] = 0;
request m_Request;
ExtractRequest (m_Request);
parseHeaders (m_Buffer, m_Request.headers);
LogPrint("Requesting ", m_Request.host, " with path ", m_Request.uri, " and method ", m_Request.method);
HandleDestinationRequest (m_Request.host, m_Request.uri);
}
else if (ecode != boost::asio::error::operation_aborted)
Terminate ();
}
void HTTPConnection::parseHeaders(const std::string& h, std::vector<header>& hm) {
std::string str (h); std::string str (h);
std::string::size_type idx; std::string::size_type idx;
std::string t; std::string t;
@ -97,7 +30,7 @@ namespace proxy
} }
} }
void HTTPConnection::ExtractRequest (request &m_Request) void HTTPProxyConnection::ExtractRequest(request &m_Request)
{ {
std::string requestString = m_Buffer; std::string requestString = m_Buffer;
int idx=requestString.find(" "); int idx=requestString.find(" ");
@ -124,161 +57,67 @@ namespace proxy
m_Request.host = server; m_Request.host = server;
} }
void HTTPConnection::HandleWriteReply (const boost::system::error_code& ecode)
{
Terminate ();
}
void HTTPConnection::HandleWrite (const boost::system::error_code& ecode)
{
if (ecode || (m_Stream && !m_Stream->IsOpen ()))
Terminate ();
else // data keeps coming
AsyncStreamReceive ();
}
void HTTPConnection::HandleDestinationRequest (const std::string& address, const std::string& uri)
{
i2p::data::IdentHash destination;
std::string fullAddress;
if (address.find (".b32.i2p") != std::string::npos)
{
int li = address.find_first_of (".");
std::string newaddress = address.substr (0, li);
if (i2p::data::Base32ToByteStream (newaddress.c_str (), newaddress.length (), (uint8_t *)destination, 32) != 32)
{
LogPrint ("Invalid Base32 address ", newaddress);
return;
}
fullAddress = newaddress + ".b32.i2p";
}
else
{
auto addr = i2p::data::netdb.FindAddress (address);
if (!addr)
{
LogPrint ("Unknown address ", address);
SendReply("<html>"+ i2p::proxy::itoopieImage +"<br>Unknown address " + address + "</html>");
return;
}
destination = *addr;
fullAddress = address;
}
auto leaseSet = i2p::data::netdb.FindLeaseSet (destination);
if (!leaseSet || !leaseSet->HasNonExpiredLeases ())
{
i2p::data::netdb.Subscribe(destination);
std::this_thread::sleep_for (std::chrono::seconds(10)); // wait for 10 seconds
leaseSet = i2p::data::netdb.FindLeaseSet (destination);
if (!leaseSet || !leaseSet->HasNonExpiredLeases ()) // still no LeaseSet
{
SendReply(leaseSet ? "<html>"+ i2p::proxy::itoopieImage +"<br>Leases expired</html>" : "<html>"+ i2p::proxy::itoopieImage +"LeaseSet not found</html>");
return;
}
}
if (!m_Stream)
m_Stream = i2p::stream::CreateStream (*leaseSet);
if (m_Stream)
{
std::string request = "GET " + uri + " HTTP/1.1\n Host:" + fullAddress + "\n";
m_Stream->Send ((uint8_t *)request.c_str (), request.length (), 10);
AsyncStreamReceive ();
}
}
void HTTPConnection::AsyncStreamReceive ()
{
if (m_Stream)
m_Stream->AsyncReceive (boost::asio::buffer (m_StreamBuffer, 8192),
boost::protect (boost::bind (&HTTPConnection::HandleStreamReceive, this,
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)),
45); // 45 seconds timeout
}
void HTTPConnection::HandleStreamReceive (const boost::system::error_code& ecode, std::size_t bytes_transferred)
{
if (bytes_transferred)
{
boost::asio::async_write (*m_Socket, boost::asio::buffer (m_StreamBuffer, bytes_transferred),
boost::bind (&HTTPConnection::HandleWrite, this, boost::asio::placeholders::error));
}
else
{
if (m_Stream && m_Stream->IsOpen ())
SendReply ("<html>"+ i2p::proxy::itoopieImage +"<br>Not responding</html>");
else
Terminate ();
}
}
void HTTPConnection::SendReply (const std::string& content)
{
m_Reply.content = content;
m_Reply.headers.resize(2);
m_Reply.headers[0].name = "Content-Length";
m_Reply.headers[0].value = boost::lexical_cast<std::string>(m_Reply.content.size());
m_Reply.headers[1].name = "Content-Type";
m_Reply.headers[1].value = "text/html";
boost::asio::async_write (*m_Socket, m_Reply.to_buffers(),
boost::bind (&HTTPConnection::HandleWriteReply, this,
boost::asio::placeholders::error));
}
HTTPProxy::HTTPProxy (int port):
m_Thread (nullptr), m_Work (m_Service),
m_Acceptor (m_Service, boost::asio::ip::tcp::endpoint (boost::asio::ip::tcp::v4(), port)),
m_NewSocket (nullptr)
{
}
HTTPProxy::~HTTPProxy ()
{
Stop ();
}
void HTTPProxy::Start ()
{
m_Thread = new std::thread (std::bind (&HTTPProxy::Run, this));
m_Acceptor.listen ();
Accept ();
}
void HTTPProxy::Stop () void HTTPProxyConnection::RunRequest()
{
m_Acceptor.close();
m_Service.stop ();
if (m_Thread)
{ {
m_Thread->join (); request m_Request;
delete m_Thread; ExtractRequest(m_Request);
m_Thread = nullptr; parseHeaders(m_Buffer, m_Request.headers);
}
}
void HTTPProxy::Run () LogPrint("Requesting ", m_Request.host, " with path ", m_Request.uri, " and method ", m_Request.method);
{ HandleDestinationRequest(m_Request.host, m_Request.uri);
m_Service.run ();
} }
void HTTPProxy::Accept () //void HTTPConnection::HandleDestinationRequest (const std::string& address, const std::string& uri)
{ //{
m_NewSocket = new boost::asio::ip::tcp::socket (m_Service); // i2p::data::IdentHash destination;
m_Acceptor.async_accept (*m_NewSocket, boost::bind (&HTTPProxy::HandleAccept, this, // std::string fullAddress;
boost::asio::placeholders::error)); // if (address.find (".b32.i2p") != std::string::npos)
} // {
// int li = address.find_first_of (".");
// std::string newaddress = address.substr (0, li);
// if (i2p::data::Base32ToByteStream (newaddress.c_str (), newaddress.length (), (uint8_t *)destination, 32) != 32)
// {
// LogPrint ("Invalid Base32 address ", newaddress);
// return;
// }
// fullAddress = newaddress + ".b32.i2p";
// }
// else
// {
// auto addr = i2p::data::netdb.FindAddress (address);
// if (!addr)
// {
// LogPrint ("Unknown address ", address);
// SendReply("<html>"+ i2p::proxy::itoopieImage +"<br>Unknown address " + address + "</html>");
// return;
// }
// destination = *addr;
// fullAddress = address;
// }
//
// auto leaseSet = i2p::data::netdb.FindLeaseSet (destination);
// if (!leaseSet || !leaseSet->HasNonExpiredLeases ())
// {
// i2p::data::netdb.Subscribe(destination);
// std::this_thread::sleep_for (std::chrono::seconds(10)); // wait for 10 seconds
// leaseSet = i2p::data::netdb.FindLeaseSet (destination);
// if (!leaseSet || !leaseSet->HasNonExpiredLeases ()) // still no LeaseSet
// {
// SendReply(leaseSet ? "<html>"+ i2p::proxy::itoopieImage +"<br>Leases expired</html>" : "<html>"+ i2p::proxy::itoopieImage +"LeaseSet not found</html>");
// return;
// }
// }
// if (!m_Stream)
// m_Stream = i2p::stream::CreateStream (*leaseSet);
// if (m_Stream)
// {
// std::string request = "GET " + uri + " HTTP/1.1\n Host:" + fullAddress + "\n";
// m_Stream->Send ((uint8_t *)request.c_str (), request.length (), 10);
// AsyncStreamReceive ();
// }
//}
void HTTPProxy::HandleAccept(const boost::system::error_code& ecode)
{
if (!ecode)
{
new HTTPConnection (m_NewSocket);
Accept ();
}
}
} }
} }

83
HTTPProxy.h
View File

File diff suppressed because one or more lines are too long

27
HTTPServer.cpp
Unescape View File

@ -64,6 +64,14 @@ namespace util
if (!ecode) if (!ecode)
{ {
m_Buffer[bytes_transferred] = 0; m_Buffer[bytes_transferred] = 0;
RunRequest();
}
else if (ecode != boost::asio::error::operation_aborted)
Terminate ();
}
void HTTPConnection::RunRequest ()
{
auto address = ExtractAddress (); auto address = ExtractAddress ();
if (address.length () > 1) // not just '/' if (address.length () > 1) // not just '/'
{ {
@ -82,9 +90,6 @@ namespace util
else else
HandleRequest (); HandleRequest ();
} }
else if (ecode != boost::asio::error::operation_aborted)
Terminate ();
}
std::string HTTPConnection::ExtractAddress () std::string HTTPConnection::ExtractAddress ()
{ {
@ -215,7 +220,7 @@ namespace util
if (!addr) if (!addr)
{ {
LogPrint ("Unknown address ", address); LogPrint ("Unknown address ", address);
SendReply ("Unknown address"); SendReply ("<html>" + itoopieImage + "<br>Unknown address " + address + "</html>");
return; return;
} }
destination = *addr; destination = *addr;
@ -226,7 +231,7 @@ namespace util
if (i2p::data::Base32ToByteStream (address.c_str (), address.length (), (uint8_t *)destination, 32) != 32) if (i2p::data::Base32ToByteStream (address.c_str (), address.length (), (uint8_t *)destination, 32) != 32)
{ {
LogPrint ("Invalid Base32 address ", address); LogPrint ("Invalid Base32 address ", address);
SendReply ("Invalid Base32 address"); SendReply ("<html>" + itoopieImage + "<br>Invalid Base32 address");
return; return;
} }
fullAddress = address + ".b32.i2p"; fullAddress = address + ".b32.i2p";
@ -240,7 +245,7 @@ namespace util
leaseSet = i2p::data::netdb.FindLeaseSet (destination); leaseSet = i2p::data::netdb.FindLeaseSet (destination);
if (!leaseSet || !leaseSet->HasNonExpiredLeases ()) // still no LeaseSet if (!leaseSet || !leaseSet->HasNonExpiredLeases ()) // still no LeaseSet
{ {
SendReply (leaseSet ? "<html>Leases expired</html>" : "<html>LeaseSet not found</html>"); SendReply (leaseSet ? "<html>" + itoopieImage + "<br>Leases expired</html>" : "<html>" + itoopieImage + "LeaseSet not found</html>");
return; return;
} }
} }
@ -273,7 +278,7 @@ namespace util
else else
{ {
if (m_Stream && m_Stream->IsOpen ()) if (m_Stream && m_Stream->IsOpen ())
SendReply ("Not responding"); SendReply ("<html>" + itoopieImage + "<br>Not responding</html>");
else else
Terminate (); Terminate ();
} }
@ -341,10 +346,16 @@ namespace util
{ {
if (!ecode) if (!ecode)
{ {
new HTTPConnection (m_NewSocket); CreateConnection(m_NewSocket); // new HTTPConnection(m_NewSocket);
Accept (); Accept ();
} }
} }
void HTTPServer::CreateConnection(boost::asio::ip::tcp::socket * m_NewSocket)
{
new HTTPConnection (m_NewSocket);
}
} }
} }

18
HTTPServer.h
View File

File diff suppressed because one or more lines are too long
Write Preview
Loading…
Cancel
Save