mirror of https://github.com/oxen-io/lokinet
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
398 lines
11 KiB
C++
398 lines
11 KiB
C++
#include <abyss/server.hpp>
|
|
|
|
#include <abyss/http.hpp>
|
|
#include <util/buffer.hpp>
|
|
#include <util/logging/logger.hpp>
|
|
#include <util/time.hpp>
|
|
|
|
#include <algorithm>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <unordered_map>
|
|
|
|
namespace abyss
|
|
{
|
|
namespace httpd
|
|
{
|
|
namespace json = llarp::json;
|
|
struct ConnImpl : abyss::http::HeaderReader
|
|
{
|
|
llarp_tcp_conn* _conn;
|
|
IRPCHandler* handler;
|
|
BaseReqHandler* _parent;
|
|
llarp_time_t m_LastActive;
|
|
llarp_time_t m_ReadTimeout;
|
|
bool m_Bad;
|
|
std::unique_ptr<json::IParser> m_BodyParser;
|
|
nlohmann::json m_Request;
|
|
|
|
enum HTTPState
|
|
{
|
|
eReadHTTPMethodLine,
|
|
eReadHTTPHeaders,
|
|
eReadHTTPBody,
|
|
eWriteHTTPStatusLine,
|
|
eWriteHTTPHeaders,
|
|
eWriteHTTPBody,
|
|
eCloseMe
|
|
};
|
|
|
|
HTTPState m_State;
|
|
|
|
ConnImpl(BaseReqHandler* p, llarp_tcp_conn* c, llarp_time_t readtimeout)
|
|
: _conn(c), _parent(p)
|
|
{
|
|
handler = nullptr;
|
|
m_LastActive = p->now();
|
|
m_ReadTimeout = readtimeout;
|
|
// set up tcp members
|
|
_conn->user = this;
|
|
_conn->read = &ConnImpl::OnRead;
|
|
_conn->tick = &ConnImpl::OnTick;
|
|
_conn->closed = &ConnImpl::OnClosed;
|
|
m_Bad = false;
|
|
m_State = eReadHTTPMethodLine;
|
|
}
|
|
|
|
~ConnImpl() = default;
|
|
|
|
bool
|
|
FeedLine(std::string& line)
|
|
{
|
|
bool done = false;
|
|
switch (m_State)
|
|
{
|
|
case eReadHTTPMethodLine:
|
|
return ProcessMethodLine(line);
|
|
case eReadHTTPHeaders:
|
|
if (!ProcessHeaderLine(line, done))
|
|
return false;
|
|
if (done)
|
|
m_State = eReadHTTPBody;
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
ProcessMethodLine(string_view line)
|
|
{
|
|
auto idx = line.find_first_of(' ');
|
|
if (idx == string_view::npos)
|
|
return false;
|
|
Header.Method = std::string(line.substr(0, idx));
|
|
line = line.substr(idx + 1);
|
|
idx = line.find_first_of(' ');
|
|
if (idx == string_view::npos)
|
|
return false;
|
|
Header.Path = std::string(line.substr(0, idx));
|
|
m_State = eReadHTTPHeaders;
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ShouldProcessHeader(const string_view& name) const
|
|
{
|
|
// TODO: header whitelist
|
|
return name == string_view("content-type") || name == string_view("content-length")
|
|
|| name == string_view("host");
|
|
}
|
|
|
|
bool
|
|
WriteResponseSimple(
|
|
int code, const std::string& msg, const char* contentType, const char* content)
|
|
{
|
|
char buf[512] = {0};
|
|
size_t contentLength = strlen(content);
|
|
int sz = snprintf(
|
|
buf,
|
|
sizeof(buf),
|
|
"HTTP/1.0 %d %s\r\nContent-Type: "
|
|
"%s\r\nContent-Length: %zu\r\n\r\n",
|
|
code,
|
|
msg.c_str(),
|
|
contentType,
|
|
contentLength);
|
|
if (sz <= 0)
|
|
return false;
|
|
if (!llarp_tcp_conn_async_write(_conn, llarp_buffer_t(buf, sz)))
|
|
return false;
|
|
|
|
m_State = eWriteHTTPBody;
|
|
|
|
return llarp_tcp_conn_async_write(_conn, llarp_buffer_t(content, contentLength));
|
|
}
|
|
|
|
bool
|
|
FeedBody(const char* buf, size_t sz)
|
|
{
|
|
if (Header.Method != "POST")
|
|
{
|
|
return WriteResponseSimple(405, "Method Not Allowed", "text/plain", "nope");
|
|
}
|
|
{
|
|
auto itr = Header.Headers.find("content-type");
|
|
if (itr == Header.Headers.end())
|
|
{
|
|
return WriteResponseSimple(
|
|
415, "Unsupported Media Type", "text/plain", "no content type provided");
|
|
}
|
|
else if (itr->second != string_view("application/json"))
|
|
{
|
|
return WriteResponseSimple(
|
|
415, "Unsupported Media Type", "text/plain", "this does not look like jsonrpc 2.0");
|
|
}
|
|
}
|
|
// initialize body parser
|
|
if (m_BodyParser == nullptr)
|
|
{
|
|
auto itr = Header.Headers.find("content-length");
|
|
if (itr == Header.Headers.end())
|
|
{
|
|
return WriteResponseSimple(400, "Bad Request", "text/plain", "no content length");
|
|
}
|
|
ssize_t contentLength = std::stoll(itr->second);
|
|
if (contentLength <= 0)
|
|
{
|
|
return WriteResponseSimple(400, "Bad Request", "text/plain", "bad content length");
|
|
}
|
|
else
|
|
{
|
|
m_BodyParser.reset(json::MakeParser(contentLength));
|
|
}
|
|
itr = Header.Headers.find("host");
|
|
if (itr == Header.Headers.end())
|
|
{
|
|
return WriteResponseSimple(400, "Bad Request", "text/plain", "no host header provided");
|
|
}
|
|
if (not handler->ValidateHost(itr->second))
|
|
{
|
|
return WriteResponseSimple(400, "Bad Request", "text/plain", "invalid host header");
|
|
}
|
|
}
|
|
if (!m_BodyParser->FeedData(buf, sz))
|
|
{
|
|
return WriteResponseSimple(400, "Bad Request", "text/plain", "invalid body size");
|
|
}
|
|
|
|
switch (m_BodyParser->Parse(m_Request))
|
|
{
|
|
case json::IParser::eNeedData:
|
|
return true;
|
|
case json::IParser::eParseError:
|
|
return WriteResponseSimple(400, "Bad Request", "text/plain", "bad json object");
|
|
case json::IParser::eDone:
|
|
if (m_Request.is_object() && m_Request.count("params") && m_Request.count("method")
|
|
&& m_Request.count("id") && m_Request["id"].is_string()
|
|
&& m_Request["method"].is_string() && m_Request["params"].is_object())
|
|
{
|
|
nlohmann::json response;
|
|
response["jsonrpc"] = "2.0";
|
|
response["id"] = m_Request["id"].get<std::string>();
|
|
auto value = handler->HandleJSONRPC(
|
|
m_Request["method"].get<std::string>(), m_Request["params"]);
|
|
|
|
if (!value.is_null())
|
|
response["result"] = std::move(value);
|
|
|
|
return WriteResponseJSON(response);
|
|
}
|
|
return WriteResponseSimple(500, "internal error", "text/plain", "nope");
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool
|
|
WriteResponseJSON(const nlohmann::json& response)
|
|
{
|
|
std::string responseStr = response.dump();
|
|
return WriteResponseSimple(200, "OK", "application/json", responseStr.c_str());
|
|
}
|
|
|
|
bool
|
|
ProcessRead(const char* buf, size_t sz)
|
|
{
|
|
llarp::LogDebug("http read ", sz, " bytes");
|
|
if (m_Bad)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!sz)
|
|
return true;
|
|
|
|
bool done = false;
|
|
m_LastActive = _parent->now();
|
|
|
|
if (m_State < eReadHTTPBody)
|
|
{
|
|
const char* end = strstr(buf, "\r\n");
|
|
while (end)
|
|
{
|
|
string_view line(buf, end - buf);
|
|
switch (m_State)
|
|
{
|
|
case eReadHTTPMethodLine:
|
|
if (!ProcessMethodLine(line))
|
|
return false;
|
|
sz -= line.size() + (2 * sizeof(char));
|
|
break;
|
|
case eReadHTTPHeaders:
|
|
if (!ProcessHeaderLine(line, done))
|
|
return false;
|
|
sz -= line.size() + (2 * sizeof(char));
|
|
if (done)
|
|
m_State = eReadHTTPBody;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
buf = end + (2 * sizeof(char));
|
|
end = strstr(buf, "\r\n");
|
|
}
|
|
}
|
|
if (m_State == eReadHTTPBody)
|
|
return FeedBody(buf, sz);
|
|
return false;
|
|
}
|
|
|
|
static void
|
|
OnRead(llarp_tcp_conn* conn, const llarp_buffer_t& buf)
|
|
{
|
|
ConnImpl* self = static_cast<ConnImpl*>(conn->user);
|
|
if (!self->ProcessRead((const char*)buf.base, buf.sz))
|
|
self->MarkBad();
|
|
}
|
|
|
|
static void
|
|
OnClosed(llarp_tcp_conn* conn)
|
|
{
|
|
llarp::LogDebug("connection closed");
|
|
ConnImpl* self = static_cast<ConnImpl*>(conn->user);
|
|
self->_conn = nullptr;
|
|
self->m_State = eCloseMe;
|
|
}
|
|
|
|
static void
|
|
OnTick(llarp_tcp_conn* conn)
|
|
{
|
|
ConnImpl* self = static_cast<ConnImpl*>(conn->user);
|
|
self->Tick();
|
|
}
|
|
|
|
void
|
|
Tick()
|
|
{
|
|
if (m_Bad)
|
|
Close();
|
|
}
|
|
|
|
/// mark bad so next tick we are closed
|
|
void
|
|
MarkBad()
|
|
{
|
|
m_Bad = true;
|
|
}
|
|
|
|
bool
|
|
ShouldClose(llarp_time_t now) const
|
|
{
|
|
return now - m_LastActive > m_ReadTimeout || m_Bad || m_State == eCloseMe;
|
|
}
|
|
|
|
void
|
|
Close()
|
|
{
|
|
if (_conn)
|
|
{
|
|
llarp_tcp_conn_close(_conn);
|
|
_conn = nullptr;
|
|
}
|
|
}
|
|
}; // namespace http
|
|
|
|
IRPCHandler::IRPCHandler(ConnImpl* conn) : m_Impl(conn)
|
|
{
|
|
}
|
|
|
|
IRPCHandler::~IRPCHandler()
|
|
{
|
|
m_Impl->Close();
|
|
delete m_Impl;
|
|
}
|
|
|
|
bool
|
|
IRPCHandler::ShouldClose(llarp_time_t now) const
|
|
{
|
|
return m_Impl->ShouldClose(now);
|
|
}
|
|
|
|
BaseReqHandler::BaseReqHandler(llarp_time_t reqtimeout) : m_ReqTimeout(reqtimeout)
|
|
{
|
|
m_acceptor.accepted = &BaseReqHandler::OnAccept;
|
|
m_acceptor.user = this;
|
|
m_acceptor.tick = &OnTick;
|
|
m_acceptor.closed = nullptr;
|
|
}
|
|
|
|
bool
|
|
BaseReqHandler::ServeAsync(
|
|
llarp_ev_loop_ptr loop, std::shared_ptr<llarp::Logic> logic, const sockaddr* bindaddr)
|
|
{
|
|
m_loop = loop;
|
|
m_Logic = logic;
|
|
return llarp_tcp_serve(m_loop.get(), &m_acceptor, bindaddr);
|
|
}
|
|
|
|
void
|
|
BaseReqHandler::OnTick(llarp_tcp_acceptor* tcp)
|
|
{
|
|
BaseReqHandler* self = static_cast<BaseReqHandler*>(tcp->user);
|
|
|
|
self->Tick();
|
|
}
|
|
|
|
void
|
|
BaseReqHandler::Tick()
|
|
{
|
|
auto _now = now();
|
|
auto itr = m_Conns.begin();
|
|
while (itr != m_Conns.end())
|
|
{
|
|
if ((*itr)->ShouldClose(_now))
|
|
itr = m_Conns.erase(itr);
|
|
else
|
|
++itr;
|
|
}
|
|
}
|
|
|
|
void
|
|
BaseReqHandler::Close()
|
|
{
|
|
llarp_tcp_acceptor_close(&m_acceptor);
|
|
}
|
|
|
|
BaseReqHandler::~BaseReqHandler()
|
|
{
|
|
}
|
|
|
|
void
|
|
BaseReqHandler::OnAccept(llarp_tcp_acceptor* acceptor, llarp_tcp_conn* conn)
|
|
{
|
|
BaseReqHandler* self = static_cast<BaseReqHandler*>(acceptor->user);
|
|
ConnImpl* connimpl = new ConnImpl(self, conn, self->m_ReqTimeout);
|
|
IRPCHandler* rpcHandler = self->CreateHandler(connimpl);
|
|
if (rpcHandler == nullptr)
|
|
{
|
|
connimpl->Close();
|
|
delete connimpl;
|
|
return;
|
|
}
|
|
connimpl->handler = rpcHandler;
|
|
self->m_Conns.emplace_back(rpcHandler);
|
|
}
|
|
} // namespace httpd
|
|
} // namespace abyss
|