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 10 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. 283
      HTTPProxy.cpp
  2. 87
      HTTPProxy.h
  3. 55
      HTTPServer.cpp
  4. 60
      HTTPServer.h

283
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(" ");
@ -123,162 +56,68 @@ namespace proxy
m_Request.method = method; m_Request.method = method;
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) void HTTPProxyConnection::RunRequest()
{ {
i2p::data::IdentHash destination; request m_Request;
std::string fullAddress; ExtractRequest(m_Request);
if (address.find (".b32.i2p") != std::string::npos) parseHeaders(m_Buffer, m_Request.headers);
{
int li = address.find_first_of ("."); LogPrint("Requesting ", m_Request.host, " with path ", m_Request.uri, " and method ", m_Request.method);
std::string newaddress = address.substr (0, li); HandleDestinationRequest(m_Request.host, m_Request.uri);
if (i2p::data::Base32ToByteStream (newaddress.c_str (), newaddress.length (), (uint8_t *)destination, 32) != 32) }
{
LogPrint ("Invalid Base32 address ", newaddress); //void HTTPConnection::HandleDestinationRequest (const std::string& address, const std::string& uri)
return; //{
} // i2p::data::IdentHash destination;
fullAddress = newaddress + ".b32.i2p"; // std::string fullAddress;
} // if (address.find (".b32.i2p") != std::string::npos)
else // {
{ // int li = address.find_first_of (".");
auto addr = i2p::data::netdb.FindAddress (address); // std::string newaddress = address.substr (0, li);
if (!addr) // if (i2p::data::Base32ToByteStream (newaddress.c_str (), newaddress.length (), (uint8_t *)destination, 32) != 32)
{ // {
LogPrint ("Unknown address ", address); // LogPrint ("Invalid Base32 address ", newaddress);
SendReply("<html>"+ i2p::proxy::itoopieImage +"<br>Unknown address " + address + "</html>"); // return;
return; // }
} // fullAddress = newaddress + ".b32.i2p";
destination = *addr; // }
fullAddress = address; // else
} // {
// auto addr = i2p::data::netdb.FindAddress (address);
auto leaseSet = i2p::data::netdb.FindLeaseSet (destination); // if (!addr)
if (!leaseSet || !leaseSet->HasNonExpiredLeases ()) // {
{ // LogPrint ("Unknown address ", address);
i2p::data::netdb.Subscribe(destination); // SendReply("<html>"+ i2p::proxy::itoopieImage +"<br>Unknown address " + address + "</html>");
std::this_thread::sleep_for (std::chrono::seconds(10)); // wait for 10 seconds // return;
leaseSet = i2p::data::netdb.FindLeaseSet (destination); // }
if (!leaseSet || !leaseSet->HasNonExpiredLeases ()) // still no LeaseSet // destination = *addr;
{ // fullAddress = address;
SendReply(leaseSet ? "<html>"+ i2p::proxy::itoopieImage +"<br>Leases expired</html>" : "<html>"+ i2p::proxy::itoopieImage +"LeaseSet not found</html>"); // }
return; //
} // auto leaseSet = i2p::data::netdb.FindLeaseSet (destination);
} // if (!leaseSet || !leaseSet->HasNonExpiredLeases ())
if (!m_Stream) // {
m_Stream = i2p::stream::CreateStream (*leaseSet); // i2p::data::netdb.Subscribe(destination);
if (m_Stream) // std::this_thread::sleep_for (std::chrono::seconds(10)); // wait for 10 seconds
{ // leaseSet = i2p::data::netdb.FindLeaseSet (destination);
std::string request = "GET " + uri + " HTTP/1.1\n Host:" + fullAddress + "\n"; // if (!leaseSet || !leaseSet->HasNonExpiredLeases ()) // still no LeaseSet
m_Stream->Send ((uint8_t *)request.c_str (), request.length (), 10); // {
AsyncStreamReceive (); // SendReply(leaseSet ? "<html>"+ i2p::proxy::itoopieImage +"<br>Leases expired</html>" : "<html>"+ i2p::proxy::itoopieImage +"LeaseSet not found</html>");
} // return;
} // }
// }
void HTTPConnection::AsyncStreamReceive () // if (!m_Stream)
{ // m_Stream = i2p::stream::CreateStream (*leaseSet);
if (m_Stream) // if (m_Stream)
m_Stream->AsyncReceive (boost::asio::buffer (m_StreamBuffer, 8192), // {
boost::protect (boost::bind (&HTTPConnection::HandleStreamReceive, this, // std::string request = "GET " + uri + " HTTP/1.1\n Host:" + fullAddress + "\n";
boost::asio::placeholders::error, boost::asio::placeholders::bytes_transferred)), // m_Stream->Send ((uint8_t *)request.c_str (), request.length (), 10);
45); // 45 seconds timeout // AsyncStreamReceive ();
} // }
//}
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 ()
{
m_Acceptor.close();
m_Service.stop ();
if (m_Thread)
{
m_Thread->join ();
delete m_Thread;
m_Thread = nullptr;
}
}
void HTTPProxy::Run ()
{
m_Service.run ();
}
void HTTPProxy::Accept ()
{
m_NewSocket = new boost::asio::ip::tcp::socket (m_Service);
m_Acceptor.async_accept (*m_NewSocket, boost::bind (&HTTPProxy::HandleAccept, this,
boost::asio::placeholders::error));
}
void HTTPProxy::HandleAccept(const boost::system::error_code& ecode)
{
if (!ecode)
{
new HTTPConnection (m_NewSocket);
Accept ();
}
}
} }
} }

87
HTTPProxy.h
View File

File diff suppressed because one or more lines are too long

55
HTTPServer.cpp
Unescape View File

@ -64,28 +64,33 @@ namespace util
if (!ecode) if (!ecode)
{ {
m_Buffer[bytes_transferred] = 0; m_Buffer[bytes_transferred] = 0;
auto address = ExtractAddress (); RunRequest();
if (address.length () > 1) // not just '/'
{
std::string uri ("/"), b32;
size_t pos = address.find ('/', 1);
if (pos == std::string::npos)
b32 = address.substr (1); // excluding leading '/' to end of line
else
{
b32 = address.substr (1, pos - 1); // excluding leading '/' to next '/'
uri = address.substr (pos); // rest of line
}
HandleDestinationRequest (b32, uri);
}
else
HandleRequest ();
} }
else if (ecode != boost::asio::error::operation_aborted) else if (ecode != boost::asio::error::operation_aborted)
Terminate (); Terminate ();
} }
void HTTPConnection::RunRequest ()
{
auto address = ExtractAddress ();
if (address.length () > 1) // not just '/'
{
std::string uri ("/"), b32;
size_t pos = address.find ('/', 1);
if (pos == std::string::npos)
b32 = address.substr (1); // excluding leading '/' to end of line
else
{
b32 = address.substr (1, pos - 1); // excluding leading '/' to next '/'
uri = address.substr (pos); // rest of line
}
HandleDestinationRequest (b32, uri);
}
else
HandleRequest ();
}
std::string HTTPConnection::ExtractAddress () std::string HTTPConnection::ExtractAddress ()
{ {
char * get = strstr (m_Buffer, "GET"); char * get = strstr (m_Buffer, "GET");
@ -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);
}
} }
} }

60
HTTPServer.h
View File

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