I2P: End-to-End encrypted and anonymous Internet https://i2pd.website/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 

486 lines
18 KiB

#include <boost/bind.hpp>
#include <boost/bind/protect.hpp>
#include <boost/lexical_cast.hpp>
#include "base64.h"
#include "Log.h"
#include "Tunnel.h"
#include "TransitTunnel.h"
#include "Transports.h"
#include "NetDb.h"
#include "HTTPServer.h"
namespace i2p
{
namespace util
{
const std::string HTTPConnection::itoopieImage =
"<img alt=\"\" src=\"data:image/png;base64,"
"iVBORw0KGgoAAAANSUhEUgAAADYAAABECAYAAAG9qPaBAAAACXBIWXMAAA7DAAAOwwHHb6h"
"kAAAStElEQVR4nMU7CXRUVbL1ek0nTUI6BLNAICEIhESWQAAFgsH8D4g5IwSHg6PfEQ/E0T"
"gIBIMIGPDIyBiFgcAB/YOj8kVAZIkywyI4yBbjINFIZAeZxASykU53esv9Vbffe3R3ujuds"
"EzB7ffe3erWrbp1q+reALgDc/1QyLkM/zO5QqJbk6YmYHY7L5DSrZaffw6gVPIeCFT0I9BP"
"V1CxShgFOrGuAxuq4J/CrW53fcAOwiBWBH2ZQhCY3HLhwoWRiZMTaxQKBZiMJrh+9Pqg119"
"/vUxJFTIyMtKKCopqP1nzScTNSzcXxcXFmdPT0+N5y2nTpikHDhzYl6MHaMVUgy0vu1Iz2n"
"MSJDBRQW0tMIvlVgU+dq0WqUBobATQaNq21IvTx7CiW9c6Bum8gD8xuXZrFuDrc4I4Hx8vS"
"AbXQli8ePHUTcc3wcO/EWD9D6fg1VdfvY/PEBaMEAQhuKioaG5KSkrx2LFjz/JWCsW3vDMk"
"uLvD4eipVCq1+GnEdBHzjN5oZtLIKZWX89FbvFV0a+ScqFr+PHXqFCO4cuWWcPhs6IrNNWF"
"Zrd+G5TCcVVQA27UL2Jo1wB5XRvD5NKCQ+Wp0xQJjZZmVGCAyARuq3RoKHo1H4dwfoxe7zQ"
"5Wi1UueCHzhfH4+Er65gKP05vY2trak94X/nYhhEeGQ9LwJGh1tMKvV3+FkwdOwpIlSwjjw"
"0hwzfLly39SiR3UIeMM2Dhk1jOzMlyHkBKdApkjMvk71sElaG8BPzNcLhau8VXBFTJ69XJn"
"Aa5hv7yDkBCc9seBrVjhbKDTKTjT/TV80dk7kyWkpqaGlZWVSdLiFXZQo8TE7iw4WClJB5d"
"N8d0rKH2J1rRp4JfRktpzA3FVynUVLmWFKHPwmBABly4BfPcdaho91hPSEU0679CzM2aCMa"
"wYktmwoQJ7XNHNTRYleZQqS1IhBMMRpkHEphIGStVAuTdSo1rhCDX5k9eZiI0wsNrt72NjQ"
"cagU6t5ntcGBCkjUxhKPE+aIA0r2l/Eky5E59ZIkvYgfMT87dO/MWmWbBbbrRH0iYXpWdP7"
"qFSqKqxrUuGPHvMfQCnXVl+p/nF13uqUkNAQpEsJX332FZiNZqi6UFWCUh6HmisG658hTHp"
"qQD1GRUXt/+XML1eam5sTp06ZuqS6otpAem/YvGEivwSq313AlsQr2r9isLEns935wpgRde"
"TPcqUFCxZ0CQ4OjsDXUExEowqHQzRasWIzPusw3UAkrf46lueBkKhUwHDPYLNmOTXXxIluG"
"+nhQDryB7QxsenTfetWDz1L6Yq/DhV+ykxoCkBMjBp3wgbeV0nJSVi/3lmYkBAtEzZw4P3c"
"Ihg6FOIwo6ajVO2gaaMRGwxBrKGhgfeqRimOixN4flraENQ8SqbX61lm5iOeFHYI/gheNsL"
"2ppKMos4gI2jyVL7tJZoNbJfUGWRh4ijZs8/6RkDmnRqRdAeNm5nnDbwtKrIZNO9CH5gDPX"
"hGLByHfzMr6HD9XreOhp/RvEqFLl47pLL+8C29zsG02rVM5VGXjDTNHkiGEbhG0YByZmLus"
"mVon1nHAqo9r4i+gUb4H6hAZveQslZ71vGlLsgQGPXsf4+DsJBgeHfHl0CK2QJjvFYuwOU1"
"e0s+RIaFgmriDJ/9+tVNKrWKkeVBkJqeCtl/yIaC3xdAi6kF5hTOgb4P9JXrvvWHt+Dquav"
"0ijsSJASMDPWYpqSkxPD1ka+r1u5b26Y8d0IuvLX9rTb5G5duBK1dmzBp0iTS7y0+kWFhKF"
"otEaieyRzXk5pev2H9XHurffI7u9+RG8zNmgtNDU3w2DOPQXxSPPRJ7gPvzn2XdiU4/NnhI"
"7kv5i7FvQF1saMZxfUmPuuGDBnS8MQTTzgImYDGcXeNRtOLzCip0927d4/8/vvv3/RGuSuQ"
"l4Ht5O/Bgwe/mpWVdcKl3IGPSkqcsldeeSVMp9NF4ygixY3njgFS14JqrQqt6ypXntHGFmK"
"z2cIQYSjuq0Ql35/a2+RcqKAFbcdBmxGJCds1WK3Wm2+//XYzR+CvMSInKjVms1mNlKuxoR"
"KnW4kD4u1IMWOeA/McWMeGdcgasGI7e2dmwRVWArhtmBWYMvy26ATslRA89BCwN95w7tZdu"
"8qKl1L8nUBkog4PHvStiAcNkhFm3Q6iCjLLyZFtb2spKJARhnUGETdyLl4Edu2as6PISOd2"
"IiGYOdOZn53t/O7fn393SjCukBNCncTGdpf9Cp3O6SYQz8i/IDCZTGzGDDXPx/VNCL347f6"
"B7djhpKq0tFTu9NixY6yqSvQpESwWC38CuNkfeR1GJu3Cq1atYrRYybjJy8vl+ZmZSm78hI"
"eHo93RhN8hPH/IEI5sX6eQUUpKUrKsrElMq9Vw3+5WPveOEVEXOW/kyE4iO3y4Y8aOC88Wd"
"RRZTUctK0pqNUem6yiyWBplIGtMSlOmdF70Cc6BnxiKazp5Ehj6sIRsVWeRbQZRJzY0+EZU"
"WAgsTKFkkc5wCqWVHUGik5BMg0jZF6aON2ygdQfsyBHAhSzGAGC47NFuhyQJ4SxvHXvuZyR"
"Jb0SAGm7Ag3LmX1Z/Db/7HcD2iPvRZtTjPyX0g2CvI70PrcAasHnr281IJVcnMgsiYBc4I3"
"ofQTWcgJtQ9BLAg2kCdhPd7rSI1sjP3spc/bMn6YcsW4Lu2PXTuD9+HFrpbH3KnysHYICj/"
"NnoFMhp7SHbj6l/HVZOhJOynT9vHsDx4wDF9gd8IsoQyqAe2z2HBNmcfsUPfkfmNkhRQNa/"
"9BwzdNHz923IfM8gimswxb73/9ifZs6g9zpfHXubG6rM4w2GLiFQs3UjzM+ejPPyE8yGs2B"
"18YhoynoIsokIeh0ZY3DQFzKf1hVq+utY2o0ChaHhofDU/Kdg/7b9cPb7s0ARknmr5sF9PX"
"ngFw59fgj+8ck/oKm+yW+fPgvIqXjvn++1yX9p4ksw7YVpkDou1S1/+czlPHrplwDPDIrAz"
"J8/nzYo5ho3leDJl58EQ3dDm/zmm80QFBzkoFjR1q1blX6RERIyw9EAjdbr9T3Du4Zvf23G"
"a20aHN17FPZu3tsmPyY+BkJ0ITvROel5+vTpmPz8/HDRyJVBKSIiu6Eb7r7EhEjkV/iwYcN"
"KL1y9MEPfVa+M7uVczJcrLkP1tWqIiI6Aj/78EWRMzYDaX2thbf5aMDebHTnP5eTijk5mew"
"g+g7Af1bhx4+yHDx/mKkUpBq66YYpCG92Adr4GZ1Bobm5WFe8sfqZbVDfY88EeOPrlUcAO4"
"MIPF6D0UClk/T4LDu04BNYWK1ScqoCaazWKQYMGbdFqtQ5yTuikgKJomBQZGRlWQigQf4KC"
"gnqgIxHt6kAsW7bsK/ADAu0prG1gYMmSJW4mOfloOMhfli5dep3PKSISPD2V1NTUvPr6+uj"
"GxsZEibdGo/H+fv36fWgwGG5I9fC9ITk52V8ISYNyoC4oKBBUKAwW/GhCflHwUA4DPProo9"
"/5oywQIKsMWWPEflsoBKgg9wZtwjpEWI0kUyDf1n437QOtHHzcQGQ30BG8SXlcGk+cOGEfP"
"358CyKiClYcSSsJAz0EQQjIERQRULsWbNeE7zewvxv4XV9YWMi3gjYdiRHfYKRUh1Orw5Fp"
"sYEan2pw8k6B34IYLW0VE3VGkVNiiRnLTCjNpjVr1ridMPkcNS0JJJ88Tg2tF5RYjgw7U+I"
"gBHySkmklr5OQISts6H1aIyIibIGGaG8HyD87Be7eKbclg4OdSTwN9Ex0TjPjbg+uo0BHF1"
"WYpOMclp7udIDas2/JmUUbilvsLt4yHedN+E8SlIKpQSJo/HhnwLajnoGUaBLmznXjIgUi0"
"+41USsIOZ0mpKa6c8ZkcjrhgRJUVubupFPKybnFfUzr7hVRbxBCEh/pZJEcjsREJXqhMay4"
"+FPuf69Y8SLT61VyFEFKVLdfPxWLj49mmzZt4nV37drFBg8ewGJj1dxXp3r79rlxr9NeUaA"
"wGERlQFEJybenwwzy771Bfv4c+XCDOEvHqx9++KHXupSv06lkCVi3zo1zdzw85grrRCQ8Mk"
"LIpbiPFCVZuXIl/0Z1zQdKERP6Jk7QGsRtArlazHAf4PmhoaFs7969vC3lK5UKN5czIkImb"
"MvdJKyYkEjxJSnl5Wl4rOn8+fNMDKHyyAwaNEigkp/oSXXPnQPWrZvsB+MWEMwnYfToh1B0"
"1XzNufb9yCMyYUfuJmEbpAF5asCaGmBPPeVUKFQeFgZs0SL/Kp8O7skv91Qerik2ViZs890"
"kbBSIayw/v/OqPdBUXOymQNLvJmEEKyRkdOXlbhFF3HTZtO+6VnQjjlR+Xt6dJ4pCRwD3fh"
"+TgE5pm8hTIgJJNd8uQbR36XRuKl5Km+4FQSTr11wRU7SvGyaDoEKN59R8gRBCimXLFmBJ9"
"wtMiRO0COKYFLepgOFsOnRn4c4bXVLK78hAA3GAyC7cLD4hDFTQE7TwKTItySXwlwllUJlU"
"D+Xlzu+pUwHQGG4DOmRxqkIPmXYDzIQoiHWGj3xCDpyD99DObnXGkshtGQcUwWsHfJ0x0pk"
"UiQDXRlr0w+Lwl07HvUUxf4BmOCUY4cxh5/fGjQB7dynQVB8FBk8UkgsXIBRBImyH69iXM5"
"wBIAYl2wFvhEWC00fi8XgUB9QW8TAbYuQKC+AibmqVPCJHIVuazfVb7BCJLelS1uzZyC0Y0"
"JaoAOGv8Cv8C4ywFok6D2bXXujKVUCxS3+iSG4DxaR4EIxi0t/CUH5NNhlKpRkE3Nfg6acB"
"3n/f2ahvbwEmXImBNR6XcwOFBDgJl6CFi+g1GInT8y1UcC/G962BjhImAV35IQKTFFh9EIS"
"gm9z29mki0tG3L8DxA0qot40OFL8MX+BUTYYf4eUpk2BsygD4378fguKT/3KtMgJTSaD9BR"
"w9AadobsP0KH3sLsiDSWlDeEFjswkKPt4Of9n5d/5NF0U+Q9UyGSIC6tiIOoE4cw0scG7Ta"
"oiPipTL4p/OhV+u116GDp5Fd4QwCQgrIfJ+FiJ1jJtctKAFQ6uSR8SDkFjcGiBaEQRmrQLO"
"qSyg1utgwPihMCzrIaivqYd1C4tAr1KDVqOCK9U3pH7I+KfYp89w/Z0iLEyhVDQkJCXAoo2"
"LeHCbbtREREVAl65t7wytX7weTh89DRazhUd0p+ZMbRdB4R8L4eJPF6XPKZg+7+gg/Z/beA"
"F0R4aoNWr5FmZUXBT07t/bK1EEzy9/HjKfyAR9mB6Gjx8eEI7GukYI6RICOIGAbg0FeDrMA"
"L/6mKL+x48f14SFhaktFotaq9VSvO/imyvebEJUXUoOlEDaI+3HXPRd9WBsNMLmws2QtzaP"
"JsdnXbr4QxKQMioFyo6VVS2Yv+Cy1WqN0mg0NtebLEuXLqVweuB34jZs2KCuqqoicyDIZrN"
"psXEQJSlqSs/Tp0/HfvHlFx/1SOyhHZA6ALKfz/Y5UDpgeOfld/g1qeycbPjmy29gwowJXr"
"l3YOsB2L91P+fwng/2OMaMHjMrPT2dbs7Q/R8b4uZEYWpBYi2Y14KEWpBIiyeRMmGzZs1Sh"
"4eHB2NFOsUIFlOQGApWeob3S0tLe+zbt++v434zTlVysARGTx4NsfGx/OiFiMHZhgs/XoCh"
"6UO5uO58fyf07tcbBo8ZzE+46OjmwYkPgrHBCGXHyyB5RDLE9I6BE/tPQOWlStP0305/MiE"
"hoY2VId4TIwJbUKm0IPfNKE3NyARTWlpaC90ZkwnLzc3V6hFQ1Gih0K1fuqis8XWriv7mor"
"a2drI0NSgmoEYpDdYH88vMKrUKHHYH3Ky7CWaTmWtI+ibQBmlh5H+NhKheUfy75t81cKn8E"
"lw9f5X/nYArhISElOTk5LyGT6+XBcQ7aXTzzkjHHXQsUVdXZ9y4caNNugNN3KHbd3RlrCuJ"
"nreOCLZt2/bwmTNnFvsq9wbYHw3MgTPs3+L1AJzos9nZ2fl9+vRp8FcPCTTj2BuRe8RhOgI"
"xSX/cEoTs7EIcQ6rD6FANuaXuyCD+UyAeIDXjmBtx3VEyovCZJVEjztFsEuf04jMYG+hIWQ"
"R60e9eAnOeI9FxjklMZOcZy8vLzShVDrcBi2JJx6lBSDm6ToogZK9OzNOIZ0l0Ytnh/e92g"
"QjBh500I47DIp1ZkQJBMTQ1NDS00NqS6vs9swKRIM8kEUiJNCZ+k5/kengm0DMQTouxSIJW"
"OnSjmCSpPWe3Dn4eRgkJsOIk20jN0zsWWf2dkQUsYkRoZWWlEjWUSq1Wq8QDOiJIJR7QKXH"
"mZALpBJiemCfQOxEr9UWDl4jBcn6CSAFWfCcF04p9cYJw3dO3HSfIjjjszc3N9piYGEcgh3"
"13ZO0Q0SjbAu6DCkQs4FYg4EwKcOv4WsAFLePCb04Y/ZFCY2MjQ8uGE4cTx7A9f7/dk8r/B"
"+U0vclvzH+PAAAAAElFTkSuQmCC"
"\" />";
namespace misc_strings
{
const char name_value_separator[] = { ':', ' ' };
const char crlf[] = { '\r', '\n' };
} // namespace misc_strings
std::vector<boost::asio::const_buffer> HTTPConnection::reply::to_buffers(int status)
{
std::vector<boost::asio::const_buffer> buffers;
if (headers.size () > 0)
{
switch (status)
{
case 105: buffers.push_back(boost::asio::buffer("HTTP/1.0 105 Name Not Resolved\r\n")); break;
case 200: buffers.push_back(boost::asio::buffer("HTTP/1.0 200 OK\r\n")); break;
case 400: buffers.push_back(boost::asio::buffer("HTTP/1.0 400 Bad Request\r\n")); break;
case 404: buffers.push_back(boost::asio::buffer("HTTP/1.0 404 Not Found\r\n")); break;
case 408: buffers.push_back(boost::asio::buffer("HTTP/1.0 408 Request Timeout\r\n")); break;
case 500: buffers.push_back(boost::asio::buffer("HTTP/1.0 500 Internal Server Error\r\n")); break;
case 502: buffers.push_back(boost::asio::buffer("HTTP/1.0 502 Bad Gateway\r\n")); break;
case 503: buffers.push_back(boost::asio::buffer("HTTP/1.0 503 Not Implemented\r\n")); break;
case 504: buffers.push_back(boost::asio::buffer("HTTP/1.0 504 Gateway Timeout\r\n")); break;
default:
buffers.push_back(boost::asio::buffer("HTTP/1.0 200 OK\r\n"));
}
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 ()
{
if (m_Stream)
{
m_Stream->Close ();
DeleteStream (m_Stream);
}
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;
RunRequest();
}
else if (ecode != boost::asio::error::operation_aborted)
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 ()
{
char * get = strstr (m_Buffer, "GET");
if (get)
{
char * http = strstr (get, "HTTP");
if (http)
return std::string (get + 4, http - get - 5);
}
return "";
}
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::HandleRequest ()
{
std::stringstream s;
s << "<html>";
FillContent (s);
s << "</html>";
SendReply (s.str ());
}
void HTTPConnection::FillContent (std::stringstream& s)
{
s << "Data path: " << i2p::util::filesystem::GetDataDir().string() << "<BR>" << "<BR>";
s << "Our external address:" << "<BR>" << "<BR>";
for (auto& address : i2p::context.GetRouterInfo().GetAddresses())
{
switch (address.transportStyle)
{
case i2p::data::RouterInfo::eTransportNTCP:
s << "NTCP&nbsp;&nbsp;";
break;
case i2p::data::RouterInfo::eTransportSSU:
s << "SSU&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;";
break;
default:
s << "Unknown&nbsp;&nbsp;";
}
s << address.host.to_string() << ":" << address.port << "<BR>";
}
s << "<P>Tunnels</P>";
for (auto it: i2p::tunnel::tunnels.GetOutboundTunnels ())
{
it->GetTunnelConfig ()->Print (s);
if (it->GetTunnelPool () && !it->GetTunnelPool ()->IsExploratory ())
s << " " << "Pool";
if (it->IsFailed ())
s << " " << "Failed";
s << " " << (int)it->GetNumSentBytes () << "<BR>";
}
for (auto it: i2p::tunnel::tunnels.GetInboundTunnels ())
{
it.second->GetTunnelConfig ()->Print (s);
if (it.second->GetTunnelPool () && !it.second->GetTunnelPool ()->IsExploratory ())
s << " " << "Pool";
if (it.second->IsFailed ())
s << " " << "Failed";
s << " " << (int)it.second->GetNumReceivedBytes () << "<BR>";
}
s << "<P>Transit tunnels</P>";
for (auto it: i2p::tunnel::tunnels.GetTransitTunnels ())
{
if (dynamic_cast<i2p::tunnel::TransitTunnelGateway *>(it.second))
s << it.second->GetTunnelID () << "-->";
else if (dynamic_cast<i2p::tunnel::TransitTunnelEndpoint *>(it.second))
s << "-->" << it.second->GetTunnelID ();
else
s << "-->" << it.second->GetTunnelID () << "-->";
s << " " << it.second->GetNumTransmittedBytes () << "<BR>";
}
s << "<P>Transports</P>";
s << "NTCP<BR>";
for (auto it: i2p::transports.GetNTCPSessions ())
{
// RouterInfo of incoming connection doesn't have address
bool outgoing = it.second->GetRemoteRouterInfo ().GetNTCPAddress ();
if (it.second->IsEstablished ())
{
if (outgoing) s << "-->";
s << it.second->GetRemoteRouterInfo ().GetIdentHashAbbreviation () << ": "
<< it.second->GetSocket ().remote_endpoint().address ().to_string ();
if (!outgoing) s << "-->";
s << "<BR>";
}
}
auto ssuServer = i2p::transports.GetSSUServer ();
if (ssuServer)
{
s << "<BR>SSU<BR>";
for (auto it: ssuServer->GetSessions ())
{
// incoming connections don't have remote router
bool outgoing = it.second->GetRemoteRouter ();
auto endpoint = it.second->GetRemoteEndpoint ();
if (outgoing) s << "-->";
s << endpoint.address ().to_string () << ":" << endpoint.port ();
if (!outgoing) s << "-->";
s << "<BR>";
}
}
s << "<p><a href=\"zmw2cyw2vj7f6obx3msmdvdepdhnw2ctc4okza2zjxlukkdfckhq\">Flibusta</a></p>";
}
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)
{
if (i2p::data::Base32ToByteStream(address.c_str(), address.length() - strlen(".b32.i2p"), (uint8_t *)destination, 32) != 32)
{
LogPrint ("Invalid Base32 address ", address);
SendReply ("<html>" + itoopieImage + "<br>Invalid Base32 address", 400);
return;
}
fullAddress = address;
}
else
{
if (address.find(".i2p") != std::string::npos)
{
auto addr = i2p::data::netdb.FindAddress(address);
if (!addr)
{
LogPrint ("Unknown address ", address);
SendReply ("<html>" + itoopieImage + "<br>Unknown address " + address + "</html>", 105);
return;
}
destination = *addr;
fullAddress = address;
}
else
{
if (i2p::data::Base32ToByteStream(address.c_str(), address.length(), (uint8_t *)destination, 32) != 32)
{
LogPrint("Invalid Base32 address ", address);
SendReply("<html>" + itoopieImage + "<br>Invalid Base32 address", 400);
return;
}
fullAddress = address + ".b32.i2p";
}
}
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>" + itoopieImage + "<br>Leases expired</html>" : "<html>" + itoopieImage + "LeaseSet not found</html>", 504);
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>" + itoopieImage + "<br>Not responding</html>", 504);
else
Terminate ();
}
}
void HTTPConnection::SendReply (const std::string& content, int status)
{
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(status),
boost::bind (&HTTPConnection::HandleWriteReply, this,
boost::asio::placeholders::error));
}
HTTPServer::HTTPServer (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)
{
}
HTTPServer::~HTTPServer ()
{
Stop ();
}
void HTTPServer::Start ()
{
m_Thread = new std::thread (std::bind (&HTTPServer::Run, this));
m_Acceptor.listen ();
Accept ();
}
void HTTPServer::Stop ()
{
m_Acceptor.close();
m_Service.stop ();
if (m_Thread)
{
m_Thread->join ();
delete m_Thread;
m_Thread = nullptr;
}
}
void HTTPServer::Run ()
{
m_Service.run ();
}
void HTTPServer::Accept ()
{
m_NewSocket = new boost::asio::ip::tcp::socket (m_Service);
m_Acceptor.async_accept (*m_NewSocket, boost::bind (&HTTPServer::HandleAccept, this,
boost::asio::placeholders::error));
}
void HTTPServer::HandleAccept(const boost::system::error_code& ecode)
{
if (!ecode)
{
CreateConnection(m_NewSocket); // new HTTPConnection(m_NewSocket);
Accept ();
}
}
void HTTPServer::CreateConnection(boost::asio::ip::tcp::socket * m_NewSocket)
{
new HTTPConnection (m_NewSocket);
}
}
}