mirror of https://github.com/oxen-io/lokinet
QUIC lokinet integration refactor
Refactors how quic packets get handled: the actual tunnels now live in
tunnel.hpp's TunnelManager which holds and manages all the quic<->tcp
tunnelling. service::Endpoint now holds a TunnelManager rather than a
quic::Server. We only need one quic server, but we need a separate quic
client instance per outgoing quic tunnel, and TunnelManager handles all
that glue now.
Adds QUIC packet handling to get to the right tunnel code. This
required multiplexing incoming quic packets, as follows:
Adds a very small quic tunnel packet header of 4 bytes:
[1, SPORT, ECN] for client->server packets, where SPORT is our
source "port" (really: just a uint16_t unique quic instance
identifier)
or
[2, DPORT, ECN] for server->client packets where the DPORT is the SPORT
from above.
(This also reworks ECN bits to get properly carried over lokinet.)
We don't need a destination/source port for the server-side because
there is only ever one quic server (and we know we're going to it when
the first byte of the header is 1).
Removes the config option for quic exposing ports; a full lokinet will
simply accept anything incoming on quic and tunnel it to the requested
port on the the local endpoint IP (this handler will come in a following
commit).
Replace ConvoTags with full addresses: we need to carry the port, as
well, which the ConvoTag can't give us, so change those to more general
SockAddrs from which we can extract both the ConvoTag *and* the port.
Add a pending connection queue along with new quic-side handlers to call
when a stream becomes available (TunnelManager uses this to wire up
pending incoming conns with quic streams as streams open up).
Completely get rid of tunnel_server/tunnel_client.cpp code; it is now
moved to tunnel.hpp.
Add listen()/forget() methods in TunnelManager for setting up quic
listening sockets (for liblokinet usage).
Add open()/close() methods in TunnelManager for spinning up new quic
clients for outgoing quic connections.
pull/1576/head
Jason Rhinelander
3 years ago
committed by
Jeff Becker
parent
158ea4a951
commit
752879d712
@ -1,111 +1,634 @@
|
||||
#include "tunnel.hpp"
|
||||
#include "service/convotag.hpp"
|
||||
#include "service/endpoint.hpp"
|
||||
#include "service/name.hpp"
|
||||
#include "stream.hpp"
|
||||
#include <limits>
|
||||
#include <llarp/util/logging/buffer.hpp>
|
||||
#include <llarp/util/logging/logger.hpp>
|
||||
#include <llarp/util/str.hpp>
|
||||
#include <llarp/ev/ev_libuv.hpp>
|
||||
#include <memory>
|
||||
#include <stdexcept>
|
||||
#include <type_traits>
|
||||
|
||||
namespace llarp::quic::tunnel
|
||||
namespace llarp::quic
|
||||
{
|
||||
// Takes data from the tcp connection and pushes it down the quic tunnel
|
||||
void
|
||||
on_outgoing_data(uvw::DataEvent& event, uvw::TCPHandle& client)
|
||||
{
|
||||
auto stream = client.data<llarp::quic::Stream>();
|
||||
assert(stream);
|
||||
std::string_view data{event.data.get(), event.length};
|
||||
auto peer = client.peer();
|
||||
LogDebug(peer.ip, ":", peer.port, " → lokinet ", buffer_printer{data});
|
||||
// Steal the buffer from the DataEvent's unique_ptr<char[]>:
|
||||
stream->append_buffer(reinterpret_cast<const std::byte*>(event.data.release()), event.length);
|
||||
if (stream->used() >= PAUSE_SIZE)
|
||||
{
|
||||
LogDebug(
|
||||
"quic tunnel is congested (have ",
|
||||
stream->used(),
|
||||
" bytes in flight); pausing local tcp connection reads");
|
||||
client.stop();
|
||||
stream->when_available([](llarp::quic::Stream& s) {
|
||||
auto client = s.data<uvw::TCPHandle>();
|
||||
if (s.used() < PAUSE_SIZE)
|
||||
namespace
|
||||
{
|
||||
// Takes data from the tcp connection and pushes it down the quic tunnel
|
||||
void
|
||||
on_outgoing_data(uvw::DataEvent& event, uvw::TCPHandle& client)
|
||||
{
|
||||
auto stream = client.data<Stream>();
|
||||
assert(stream);
|
||||
std::string_view data{event.data.get(), event.length};
|
||||
auto peer = client.peer();
|
||||
LogDebug(peer.ip, ":", peer.port, " → lokinet ", buffer_printer{data});
|
||||
// Steal the buffer from the DataEvent's unique_ptr<char[]>:
|
||||
stream->append_buffer(reinterpret_cast<const std::byte*>(event.data.release()), event.length);
|
||||
if (stream->used() >= tunnel::PAUSE_SIZE)
|
||||
{
|
||||
LogDebug(
|
||||
"quic tunnel is congested (have ",
|
||||
stream->used(),
|
||||
" bytes in flight); pausing local tcp connection reads");
|
||||
client.stop();
|
||||
stream->when_available([](Stream& s) {
|
||||
auto client = s.data<uvw::TCPHandle>();
|
||||
if (s.used() < tunnel::PAUSE_SIZE)
|
||||
{
|
||||
LogDebug("quic tunnel is no longer congested; resuming tcp connection reading");
|
||||
client->read();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
else
|
||||
{
|
||||
LogDebug("Queued ", event.length, " bytes");
|
||||
}
|
||||
}
|
||||
|
||||
// Received data from the quic tunnel and sends it to the TCP connection
|
||||
void
|
||||
on_incoming_data(Stream& stream, bstring_view bdata)
|
||||
{
|
||||
auto tcp = stream.data<uvw::TCPHandle>();
|
||||
assert(tcp);
|
||||
std::string_view data{reinterpret_cast<const char*>(bdata.data()), bdata.size()};
|
||||
auto peer = tcp->peer();
|
||||
LogTrace(peer.ip, ":", peer.port, " ← lokinet ", buffer_printer{data});
|
||||
|
||||
if (data.empty())
|
||||
return;
|
||||
|
||||
// Try first to write immediately from the existing buffer to avoid needing an
|
||||
// allocation and copy:
|
||||
auto written = tcp->tryWrite(const_cast<char*>(data.data()), data.size());
|
||||
if (written < (int)data.size())
|
||||
{
|
||||
data.remove_prefix(written);
|
||||
|
||||
auto wdata = std::make_unique<char[]>(data.size());
|
||||
std::copy(data.begin(), data.end(), wdata.get());
|
||||
tcp->write(std::move(wdata), data.size());
|
||||
}
|
||||
}
|
||||
|
||||
// Creates a new tcp handle that forwards incoming data/errors/closes into appropriate actions
|
||||
// on the given quic stream.
|
||||
void
|
||||
install_stream_forwarding(uvw::TCPHandle& tcp, Stream& stream)
|
||||
{
|
||||
tcp.data(stream.shared_from_this());
|
||||
stream.weak_data(tcp.weak_from_this());
|
||||
|
||||
tcp.clear(); // Clear any existing initial event handlers
|
||||
|
||||
tcp.on<uvw::CloseEvent>([](auto&, uvw::TCPHandle& c) {
|
||||
// This fires sometime after we call `close()` to signal that the close is done.
|
||||
LogError("Connection closed to ", c.peer().ip, ":", c.peer().port, "; closing quic stream");
|
||||
c.data<Stream>()->close();
|
||||
c.data(nullptr);
|
||||
});
|
||||
tcp.on<uvw::EndEvent>([](auto&, uvw::TCPHandle& c) {
|
||||
// This fires on eof, most likely because the other side of the TCP connection closed it.
|
||||
LogError("EOF on connection to ", c.peer().ip, ":", c.peer().port);
|
||||
c.close();
|
||||
});
|
||||
tcp.on<uvw::ErrorEvent>([](const uvw::ErrorEvent& e, uvw::TCPHandle& tcp) {
|
||||
LogError(
|
||||
"ErrorEvent[",
|
||||
e.name(),
|
||||
": ",
|
||||
e.what(),
|
||||
"] on connection with ",
|
||||
tcp.peer().ip,
|
||||
":",
|
||||
tcp.peer().port,
|
||||
", shutting down quic stream");
|
||||
// Failed to open connection, so close the quic stream
|
||||
auto stream = tcp.data<Stream>();
|
||||
if (stream)
|
||||
stream->close(tunnel::ERROR_TCP);
|
||||
tcp.closeReset();
|
||||
});
|
||||
tcp.on<uvw::DataEvent>(on_outgoing_data);
|
||||
stream.data_callback = on_incoming_data;
|
||||
}
|
||||
// This initial data handler is responsible for pulling off the initial stream data that comes
|
||||
// back, confirming that the tunnel is opened on the other end. Currently this is a null byte
|
||||
// (CONNECT_INIT) but in the future we might encode additional data here (and, if that happens,
|
||||
// we want this older implementation to fail).
|
||||
//
|
||||
// If the initial byte checks out we replace this handler with the regular stream handler (and
|
||||
// forward the rest of the data to it if we got more than just the single byte).
|
||||
void
|
||||
initial_client_data_handler(uvw::TCPHandle& client, Stream& stream, bstring_view bdata)
|
||||
{
|
||||
if (bdata.empty())
|
||||
return;
|
||||
client.clear(); // Clear these initial event handlers: we either set up the proper ones, or
|
||||
// close
|
||||
|
||||
if (auto b0 = bdata[0]; b0 == tunnel::CONNECT_INIT)
|
||||
{
|
||||
// Set up callbacks, which replaces both of these initial callbacks
|
||||
client.read();
|
||||
install_stream_forwarding(client, stream);
|
||||
|
||||
if (bdata.size() > 1)
|
||||
{
|
||||
LogDebug("quic tunnel is no longer congested; resuming tcp connection reading");
|
||||
client->read();
|
||||
return true;
|
||||
bdata.remove_prefix(1);
|
||||
stream.data_callback(stream, std::move(bdata));
|
||||
}
|
||||
LogTrace("starting client reading");
|
||||
}
|
||||
else
|
||||
{
|
||||
LogWarn(
|
||||
"Remote connection returned invalid initial byte (0x",
|
||||
oxenmq::to_hex(bdata.begin(), bdata.begin() + 1),
|
||||
"); dropping connection");
|
||||
stream.close(tunnel::ERROR_BAD_INIT);
|
||||
client.closeReset();
|
||||
}
|
||||
stream.io_ready();
|
||||
}
|
||||
|
||||
// Initial close handler that gets replaced as soon as we receive a valid byte (in the above
|
||||
// handler). If this gets called then it means the quic remote quic end closed before we
|
||||
// established the end-to-end tunnel (for example because the remote's tunnel connection
|
||||
// failed):
|
||||
void
|
||||
initial_client_close_handler(
|
||||
uvw::TCPHandle& client, Stream& /*stream*/, std::optional<uint64_t> error_code)
|
||||
{
|
||||
if (error_code && *error_code == tunnel::ERROR_CONNECT)
|
||||
LogDebug("Remote TCP connection failed, closing local connection");
|
||||
else
|
||||
LogWarn(
|
||||
"Stream connection closed ",
|
||||
error_code ? "with error " + std::to_string(*error_code) : "gracefully",
|
||||
"; closing local TCP connection.");
|
||||
auto peer = client.peer();
|
||||
LogDebug("Closing connection to ", peer.ip, ":", peer.port);
|
||||
client.clear();
|
||||
if (error_code)
|
||||
client.closeReset();
|
||||
else
|
||||
client.close();
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TunnelManager::TunnelManager(service::Endpoint& se) : service_endpoint_{se}
|
||||
{
|
||||
// Cleanup callback to clear out closed tunnel connections
|
||||
service_endpoint_.Loop()->call_every(500ms, timer_keepalive_, [this] {
|
||||
LogTrace("Checking quic tunnels for finished connections");
|
||||
for (auto ctit = client_tunnels_.begin(); ctit != client_tunnels_.end();)
|
||||
{
|
||||
// Clear any accepted connections that have been closed:
|
||||
auto& [port, ct] = *ctit;
|
||||
for (auto it = ct.conns.begin(); it != ct.conns.end();)
|
||||
{
|
||||
// TCP connections keep a shared_ptr to their quic::Stream while open and clear it when
|
||||
// closed. (We don't want to use `.active()` here because we do deliberately temporarily
|
||||
// stop the TCP connection when the quic side gets congested.
|
||||
if (not *it or not(*it)->data())
|
||||
{
|
||||
LogDebug("Cleanup up closed outgoing tunnel on quic:", port);
|
||||
it = ct.conns.erase(it);
|
||||
}
|
||||
else
|
||||
++it;
|
||||
}
|
||||
|
||||
// If there are not accepted connections left *and* we stopped listening for new ones then
|
||||
// destroy the whole thing.
|
||||
if (ct.conns.empty() and (not ct.tcp or not ct.tcp->active()))
|
||||
{
|
||||
LogDebug("All sockets closed on quic:", port, ", destroying tunnel data");
|
||||
ctit = client_tunnels_.erase(ctit);
|
||||
}
|
||||
else
|
||||
++ctit;
|
||||
}
|
||||
LogTrace("Done quic tunnel cleanup check");
|
||||
});
|
||||
}
|
||||
|
||||
void
|
||||
TunnelManager::make_server()
|
||||
{
|
||||
// auto loop = get_loop();
|
||||
|
||||
server_ = std::make_unique<Server>(service_endpoint_);
|
||||
server_->stream_open_callback = [this](Stream& stream, uint16_t port) -> bool {
|
||||
stream.close_callback = [](quic::Stream& st,
|
||||
[[maybe_unused]] std::optional<uint64_t> errcode) {
|
||||
auto tcp = st.data<uvw::TCPHandle>();
|
||||
if (tcp)
|
||||
tcp->close();
|
||||
};
|
||||
|
||||
auto& conn = stream.get_connection();
|
||||
auto remote = service_endpoint_.GetEndpointWithConvoTag(conn.path.remote);
|
||||
if (!remote)
|
||||
{
|
||||
LogWarn("Received new stream open from invalid/unknown convo tag, dropping stream");
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
auto lokinet_addr = var::visit([](auto&& remote) { return remote.ToString(); }, *remote);
|
||||
auto tunnel_to = allow_connection(lokinet_addr, port);
|
||||
if (not tunnel_to)
|
||||
return false;
|
||||
LogDebug("quic stream from ", lokinet_addr, " to ", port, " tunnelling to ", *tunnel_to);
|
||||
|
||||
auto tcp = get_loop()->resource<uvw::TCPHandle>();
|
||||
auto error_handler = tcp->once<uvw::ErrorEvent>(
|
||||
[&stream, to = *tunnel_to](const uvw::ErrorEvent&, uvw::TCPHandle&) {
|
||||
LogWarn("Failed to connect to ", to, ", shutting down quic stream");
|
||||
stream.close(tunnel::ERROR_CONNECT);
|
||||
});
|
||||
|
||||
// As soon as we connect to the local tcp tunnel port we fire a CONNECT_INIT down the stream
|
||||
// tunnel to let the other end know the connection was successful, then set up regular
|
||||
// stream handling to handle any other to/from data.
|
||||
tcp->once<uvw::ConnectEvent>(
|
||||
[streamw = stream.weak_from_this(), error_handler = std::move(error_handler)](
|
||||
const uvw::ConnectEvent&, uvw::TCPHandle& tcp) {
|
||||
auto peer = tcp.peer();
|
||||
auto stream = streamw.lock();
|
||||
if (!stream)
|
||||
{
|
||||
LogWarn(
|
||||
"Connected to TCP ",
|
||||
peer.ip,
|
||||
":",
|
||||
peer.port,
|
||||
" but quic stream has gone away; close/resetting local TCP connection");
|
||||
tcp.closeReset();
|
||||
return;
|
||||
}
|
||||
LogDebug("Connected to ", peer.ip, ":", peer.port, " for quic ", stream->id());
|
||||
// Set up the data stream forwarding (which also clears these initial handlers).
|
||||
install_stream_forwarding(tcp, *stream);
|
||||
assert(stream->used() == 0);
|
||||
|
||||
// Send the magic byte, and start reading from the tcp tunnel in the logic thread
|
||||
stream->append_buffer(new std::byte[1]{tunnel::CONNECT_INIT}, 1);
|
||||
tcp.read();
|
||||
});
|
||||
|
||||
tcp->connect(*tunnel_to->operator const sockaddr*());
|
||||
|
||||
return true;
|
||||
};
|
||||
}
|
||||
|
||||
int
|
||||
TunnelManager::listen(ListenHandler handler)
|
||||
{
|
||||
if (!handler)
|
||||
throw std::logic_error{"Cannot call listen() with a null handler"};
|
||||
assert(service_endpoint_.Loop()->inEventLoop());
|
||||
if (not server_)
|
||||
make_server();
|
||||
|
||||
int id = next_handler_id_++;
|
||||
incoming_handlers_.emplace_hint(incoming_handlers_.end(), id, std::move(handler));
|
||||
return id;
|
||||
}
|
||||
|
||||
int
|
||||
TunnelManager::listen(uint16_t port)
|
||||
{
|
||||
return listen([port](std::string_view, uint16_t p) -> std::optional<SockAddr> {
|
||||
if (p == port)
|
||||
return SockAddr{127, 0, 0, 1, huint16_t{port}};
|
||||
return std::nullopt;
|
||||
});
|
||||
}
|
||||
|
||||
void
|
||||
TunnelManager::forget(int id)
|
||||
{
|
||||
incoming_handlers_.erase(id);
|
||||
}
|
||||
|
||||
std::optional<SockAddr>
|
||||
TunnelManager::allow_connection(std::string_view lokinet_addr, uint16_t port)
|
||||
{
|
||||
for (auto& [id, handler] : incoming_handlers_)
|
||||
{
|
||||
try
|
||||
{
|
||||
if (auto addr = handler(lokinet_addr, port))
|
||||
return addr;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
LogWarn(
|
||||
"Incoming quic connection from ",
|
||||
lokinet_addr,
|
||||
" to ",
|
||||
port,
|
||||
" denied via exception (",
|
||||
e.what(),
|
||||
")");
|
||||
return std::nullopt;
|
||||
}
|
||||
}
|
||||
LogWarn(
|
||||
"Incoming quic connection from ", lokinet_addr, " to ", port, " declined by all handlers");
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
std::shared_ptr<uvw::Loop>
|
||||
TunnelManager::get_loop()
|
||||
{
|
||||
if (auto loop = service_endpoint_.Loop()->MaybeGetUVWLoop())
|
||||
return loop;
|
||||
throw std::logic_error{"TunnelManager requires a libuv-based event loop"};
|
||||
}
|
||||
|
||||
// Finds the first unused key in `map`, starting at `start` and wrapping back to 0 if we hit the
|
||||
// end. Requires an unsigned int type for the key. Requires nullopt if the map is completely
|
||||
// full, otherwise returns the free key.
|
||||
template <
|
||||
typename K,
|
||||
typename V,
|
||||
typename = std::enable_if_t<std::is_integral_v<K> && std::is_unsigned_v<K>>>
|
||||
static std::optional<K>
|
||||
find_unused_key(std::map<K, V>& map, K start)
|
||||
{
|
||||
if (map.size() == std::numeric_limits<K>::max())
|
||||
return std::nullopt; // The map is completely full
|
||||
[[maybe_unused]] bool from_zero = (start == K{0});
|
||||
|
||||
// Start at the first key >= start, then walk 1-by-1 (incrementing start) until we find a
|
||||
// strictly > key, which means we've found a hole we can use
|
||||
auto it = map.lower_bound(start);
|
||||
if (it == map.end())
|
||||
return start;
|
||||
|
||||
for (; it != map.end(); ++it, ++start)
|
||||
if (it->first != start)
|
||||
return start;
|
||||
if (start != 0) // `start` didn't wrap which means we found an empty slot
|
||||
return start;
|
||||
assert(!from_zero); // There *must* be a free slot somewhere in [0, max] (otherwise the map
|
||||
// would be completely full and we'd have returned nullopt).
|
||||
return find_unused_key(map, K{0});
|
||||
}
|
||||
|
||||
// Wrap common tasks and cleanup that we need to do from multiple places while establishing a
|
||||
// tunnel
|
||||
bool
|
||||
TunnelManager::continue_connecting(
|
||||
uint16_t pseudo_port, bool step_success, std::string_view step_name, std::string_view addr)
|
||||
{
|
||||
assert(service_endpoint_.Loop()->inEventLoop());
|
||||
auto it = client_tunnels_.find(pseudo_port);
|
||||
if (it == client_tunnels_.end())
|
||||
{
|
||||
LogDebug("QUIC tunnel to ", addr, " closed before ", step_name, " finished");
|
||||
return false;
|
||||
}
|
||||
if (!step_success)
|
||||
{
|
||||
LogWarn("QUIC tunnel to ", addr, " failed during ", step_name, "; aborting tunnel");
|
||||
it->second.tcp->closeReset();
|
||||
if (it->second.open_cb)
|
||||
it->second.open_cb(false);
|
||||
client_tunnels_.erase(it);
|
||||
}
|
||||
return step_success;
|
||||
}
|
||||
|
||||
std::pair<SockAddr, uint16_t>
|
||||
TunnelManager::open(
|
||||
std::string_view remote_address, uint16_t port, OpenCallback on_open, SockAddr bind_addr)
|
||||
{
|
||||
std::string remote_addr = lowercase_ascii_string(std::string{remote_address});
|
||||
|
||||
std::pair<SockAddr, uint16_t> result;
|
||||
auto& [saddr, pport] = result;
|
||||
|
||||
auto maybe_remote = service::ParseAddress(remote_addr);
|
||||
if (!maybe_remote)
|
||||
{
|
||||
if (not service::NameIsValid(remote_addr))
|
||||
throw std::invalid_argument{"Invalid remote lokinet name/address"};
|
||||
// Otherwise it's a valid ONS name, so we'll initiate an ONS lookup below
|
||||
}
|
||||
|
||||
// Open the TCP tunnel right away; it will just block new incoming connections until the quic
|
||||
// connection is established, but this still allows the caller to connect right away and queue
|
||||
// an initial request (rather than having to wait via a callback before connecting). It also
|
||||
// makes sure we can actually listen on the given address before we go ahead with establishing
|
||||
// the quic connection.
|
||||
auto tcp_tunnel = get_loop()->resource<uvw::TCPHandle>();
|
||||
const char* failed = nullptr;
|
||||
auto err_handler =
|
||||
tcp_tunnel->once<uvw::ErrorEvent>([&failed](auto& evt, auto&) { failed = evt.what(); });
|
||||
tcp_tunnel->bind(*bind_addr.operator const sockaddr*());
|
||||
tcp_tunnel->listen();
|
||||
tcp_tunnel->erase(err_handler);
|
||||
|
||||
if (failed)
|
||||
{
|
||||
tcp_tunnel->closeReset();
|
||||
throw std::runtime_error{
|
||||
"Failed to bind/listen local TCP tunnel socket on " + bind_addr.toString() + ": "
|
||||
+ failed};
|
||||
}
|
||||
|
||||
auto bound = tcp_tunnel->sock();
|
||||
saddr = SockAddr{bound.ip, static_cast<uint16_t>(bound.port)};
|
||||
|
||||
// Find the first unused psuedo-port value starting from next_pseudo_port_.
|
||||
if (auto p = find_unused_key(client_tunnels_, next_pseudo_port_))
|
||||
pport = *p;
|
||||
else
|
||||
throw std::runtime_error{
|
||||
"Unable to open an outgoing quic connection: too many existing connections"};
|
||||
(next_pseudo_port_ = pport)++;
|
||||
|
||||
// We are emplacing into client_tunnels_ here: beyond this point we must not throw until we
|
||||
// return (or if we do, make sure we remove this row from client_tunnels_ first).
|
||||
assert(client_tunnels_.count(pport) == 0);
|
||||
auto& ct = client_tunnels_[pport];
|
||||
ct.open_cb = std::move(on_open);
|
||||
ct.tcp = std::move(tcp_tunnel);
|
||||
|
||||
auto after_path = [this, port, pport = pport, remote_addr](auto maybe_convo) {
|
||||
if (not continue_connecting(pport, (bool)maybe_convo, "path build", remote_addr))
|
||||
return;
|
||||
SockAddr dest{maybe_convo->ToV6()};
|
||||
dest.setPort(port);
|
||||
make_client(dest, *client_tunnels_.find(pport));
|
||||
};
|
||||
|
||||
if (!maybe_remote)
|
||||
{
|
||||
LogDebug("Queued ", event.length, " bytes");
|
||||
// We were given an ONS address, so it's a two-step process: first we resolve the ONS name,
|
||||
// then we have to build a path to that address.
|
||||
service_endpoint_.LookupNameAsync(
|
||||
remote_addr,
|
||||
[this,
|
||||
after_path = std::move(after_path),
|
||||
pport = pport,
|
||||
remote_addr = std::move(remote_addr)](auto maybe_remote) {
|
||||
if (not continue_connecting(
|
||||
pport, (bool)maybe_remote, "endpoint ONS lookup", remote_addr))
|
||||
return;
|
||||
service_endpoint_.EnsurePathTo(*maybe_remote, after_path, open_timeout);
|
||||
});
|
||||
return result;
|
||||
}
|
||||
|
||||
auto& remote = *maybe_remote;
|
||||
|
||||
// See if we have an existing convo tag we can use to start things immediately
|
||||
if (auto maybe_convo = service_endpoint_.GetBestConvoTagFor(remote))
|
||||
after_path(maybe_convo);
|
||||
else
|
||||
service_endpoint_.EnsurePathTo(remote, after_path, open_timeout);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
// Received data from the quic tunnel and sends it to the TCP connection
|
||||
void
|
||||
on_incoming_data(llarp::quic::Stream& stream, llarp::quic::bstring_view bdata)
|
||||
TunnelManager::close(int id)
|
||||
{
|
||||
auto tcp = stream.data<uvw::TCPHandle>();
|
||||
assert(tcp);
|
||||
std::string_view data{reinterpret_cast<const char*>(bdata.data()), bdata.size()};
|
||||
auto peer = tcp->peer();
|
||||
LogTrace(peer.ip, ":", peer.port, " ← lokinet ", buffer_printer{data});
|
||||
|
||||
if (data.empty())
|
||||
return;
|
||||
if (auto it = client_tunnels_.find(id); it != client_tunnels_.end())
|
||||
{
|
||||
it->second.tcp->close();
|
||||
it->second.tcp.reset();
|
||||
}
|
||||
}
|
||||
|
||||
// Try first to write immediately from the existing buffer to avoid needing an
|
||||
// allocation and copy:
|
||||
auto written = tcp->tryWrite(const_cast<char*>(data.data()), data.size());
|
||||
if (written < (int)data.size())
|
||||
TunnelManager::ClientTunnel::~ClientTunnel()
|
||||
{
|
||||
if (tcp)
|
||||
{
|
||||
data.remove_prefix(written);
|
||||
tcp->close();
|
||||
tcp.reset();
|
||||
}
|
||||
for (auto& conn : conns)
|
||||
conn->closeReset();
|
||||
conns.clear();
|
||||
|
||||
auto wdata = std::make_unique<char[]>(data.size());
|
||||
std::copy(data.begin(), data.end(), wdata.get());
|
||||
tcp->write(std::move(wdata), data.size());
|
||||
while (not pending_incoming.empty())
|
||||
{
|
||||
if (auto tcp = pending_incoming.front().lock())
|
||||
{
|
||||
tcp->clear();
|
||||
tcp->close();
|
||||
}
|
||||
pending_incoming.pop();
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
install_stream_forwarding(uvw::TCPHandle& tcp, llarp::quic::Stream& stream)
|
||||
{
|
||||
tcp.data(stream.shared_from_this());
|
||||
stream.weak_data(tcp.weak_from_this());
|
||||
|
||||
tcp.on<uvw::CloseEvent>([](auto&, uvw::TCPHandle& c) {
|
||||
// This fires sometime after we call `close()` to signal that the close is done.
|
||||
LogError(
|
||||
"Connection with ",
|
||||
c.peer().ip,
|
||||
":",
|
||||
c.peer().port,
|
||||
" closed directly, closing quic stream");
|
||||
c.data<llarp::quic::Stream>()->close();
|
||||
});
|
||||
tcp.on<uvw::EndEvent>([](auto&, uvw::TCPHandle& c) {
|
||||
// This fires on eof, most likely because the other side of the TCP connection closed it.
|
||||
LogError("EOF on connection with ", c.peer().ip, ":", c.peer().port, ", closing quic stream");
|
||||
c.data<llarp::quic::Stream>()->close();
|
||||
});
|
||||
tcp.on<uvw::ErrorEvent>([](const uvw::ErrorEvent& e, uvw::TCPHandle& tcp) {
|
||||
LogError(
|
||||
"ErrorEvent[",
|
||||
e.name(),
|
||||
": ",
|
||||
e.what(),
|
||||
"] on connection with ",
|
||||
tcp.peer().ip,
|
||||
":",
|
||||
tcp.peer().port,
|
||||
", shutting down quic stream");
|
||||
// Failed to open connection, so close the quic stream
|
||||
auto stream = tcp.data<llarp::quic::Stream>();
|
||||
if (stream)
|
||||
stream->close(ERROR_TCP);
|
||||
tcp.close();
|
||||
});
|
||||
tcp.on<uvw::DataEvent>(tunnel::on_outgoing_data);
|
||||
stream.data_callback = on_incoming_data;
|
||||
TunnelManager::make_client(const SockAddr& remote, std::pair<const uint16_t, ClientTunnel>& row)
|
||||
{
|
||||
assert(remote.getPort() > 0);
|
||||
auto& [pport, tunnel] = row;
|
||||
assert(not tunnel.client);
|
||||
tunnel.client = std::make_unique<Client>(service_endpoint_, remote, pport);
|
||||
auto conn = tunnel.client->get_connection();
|
||||
|
||||
conn->on_stream_available = [this, id = row.first](Connection& conn) {
|
||||
if (auto it = client_tunnels_.find(id); it != client_tunnels_.end())
|
||||
flush_pending_incoming(it->second, conn);
|
||||
};
|
||||
}
|
||||
|
||||
void
|
||||
TunnelManager::flush_pending_incoming(ClientTunnel& ct, Connection& conn)
|
||||
{
|
||||
int available = conn.get_streams_available();
|
||||
while (available > 0 and not ct.pending_incoming.empty())
|
||||
{
|
||||
auto client = ct.pending_incoming.front().lock();
|
||||
ct.pending_incoming.pop();
|
||||
if (not client)
|
||||
continue;
|
||||
|
||||
try
|
||||
{
|
||||
conn.open_stream(
|
||||
[client](auto&&... args) {
|
||||
initial_client_data_handler(*client, std::forward<decltype(args)>(args)...);
|
||||
},
|
||||
[client](auto&&... args) {
|
||||
initial_client_close_handler(*client, std::forward<decltype(args)>(args)...);
|
||||
});
|
||||
available--;
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
LogWarn("Opening quic stream failed: ", e.what());
|
||||
client->closeReset();
|
||||
}
|
||||
|
||||
LogTrace("Set up new stream");
|
||||
conn.io_ready();
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace llarp::quic::tunnel
|
||||
void
|
||||
TunnelManager::receive_packet(const service::ConvoTag& tag, const llarp_buffer_t& buf)
|
||||
{
|
||||
if (buf.sz <= 4)
|
||||
{
|
||||
LogWarn("invalid quic packet: packet size (", buf.sz, ") too small");
|
||||
return;
|
||||
}
|
||||
auto type = static_cast<std::byte>(buf.base[0]);
|
||||
nuint16_t pseudo_port_n;
|
||||
std::memcpy(&pseudo_port_n.n, &buf.base[1], 2);
|
||||
uint16_t pseudo_port = ToHost(pseudo_port_n).h;
|
||||
auto ecn = static_cast<uint8_t>(buf.base[3]);
|
||||
bstring_view data{reinterpret_cast<const std::byte*>(&buf.base[4]), buf.sz - 4};
|
||||
|
||||
SockAddr remote{tag.ToV6()};
|
||||
quic::Endpoint* ep = nullptr;
|
||||
if (type == CLIENT_TO_SERVER)
|
||||
{
|
||||
// Client-to-server: the header port is the return port
|
||||
remote.setPort(pseudo_port);
|
||||
if (!server_)
|
||||
{
|
||||
LogWarn("Dropping incoming quic packet to server: no listeners");
|
||||
return;
|
||||
}
|
||||
ep = server_.get();
|
||||
}
|
||||
else if (type == SERVER_TO_CLIENT)
|
||||
{
|
||||
// Server-to-client: the header port tells us which client tunnel this is going to
|
||||
if (auto it = client_tunnels_.find(pseudo_port); it != client_tunnels_.end())
|
||||
ep = it->second.client.get();
|
||||
|
||||
if (not ep)
|
||||
{
|
||||
LogWarn("Incoming quic packet to invalid/closed client; dropping");
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
LogWarn("Invalid incoming quic packet type ", type, "; dropping packet");
|
||||
return;
|
||||
}
|
||||
ep->receive_packet(remote, ecn, data);
|
||||
}
|
||||
} // namespace llarp::quic
|
||||
|
||||
@ -1,143 +0,0 @@
|
||||
#include "connection.hpp"
|
||||
#include "client.hpp"
|
||||
#include "stream.hpp"
|
||||
#include "tunnel.hpp"
|
||||
#include <llarp/util/logging/logger.hpp>
|
||||
|
||||
#include <oxenmq/hex.h>
|
||||
|
||||
#include <util/str.hpp>
|
||||
|
||||
#include <charconv>
|
||||
#include <iterator>
|
||||
|
||||
#include <uvw.hpp>
|
||||
|
||||
/*
|
||||
using namespace std::literals;
|
||||
|
||||
namespace llarp::quic::tunnel
|
||||
{
|
||||
// When we receive a new incoming connection we immediately initiate a new quic stream. This quic
|
||||
// stream in turn causes the other end to initiate a TCP connection on whatever port we specified
|
||||
// in the connection; if the connection is established, it sends back a single byte 0x00
|
||||
// (CONNECT_INIT); otherwise it shuts down the stream with an error code.
|
||||
void
|
||||
on_new_connection(const uvw::ListenEvent&, uvw::TCPHandle& server)
|
||||
{
|
||||
LogDebug("New connection!\n");
|
||||
auto client = server.loop().resource<uvw::TCPHandle>();
|
||||
server.accept(*client);
|
||||
|
||||
auto conn = server.data<llarp::quic::Connection>();
|
||||
std::shared_ptr<llarp::quic::Stream> stream;
|
||||
try
|
||||
{
|
||||
LogTrace("open stream");
|
||||
stream = conn->open_stream(
|
||||
[client](llarp::quic::Stream& stream, llarp::quic::bstring_view bdata) {
|
||||
if (bdata.empty())
|
||||
return;
|
||||
if (auto b0 = bdata[0]; b0 == tunnel::CONNECT_INIT)
|
||||
{
|
||||
// Set up callbacks, which replaces both of these initial callbacks
|
||||
client->read();
|
||||
tunnel::install_stream_forwarding(*client, stream);
|
||||
|
||||
if (bdata.size() > 1)
|
||||
{
|
||||
bdata.remove_prefix(1);
|
||||
stream.data_callback(stream, std::move(bdata));
|
||||
}
|
||||
LogTrace("starting client reading");
|
||||
}
|
||||
else
|
||||
{
|
||||
LogWarn(
|
||||
"Remote connection returned invalid initial byte (0x",
|
||||
oxenmq::to_hex(bdata.begin(), bdata.begin() + 1),
|
||||
"); dropping connection");
|
||||
client->closeReset();
|
||||
stream.close(tunnel::ERROR_BAD_INIT);
|
||||
}
|
||||
stream.io_ready();
|
||||
},
|
||||
[client](llarp::quic::Stream&, std::optional<uint64_t> error_code) mutable {
|
||||
if (error_code && *error_code == tunnel::ERROR_CONNECT)
|
||||
LogDebug("Remote TCP connection failed, closing local connection");
|
||||
else
|
||||
LogWarn(
|
||||
"Stream connection closed ",
|
||||
error_code ? "with error " + std::to_string(*error_code) : "gracefully",
|
||||
"; closing local TCP connection.");
|
||||
auto peer = client->peer();
|
||||
LogDebug("Closing connection to ", peer.ip, ":", peer.port);
|
||||
if (error_code)
|
||||
client->closeReset();
|
||||
else
|
||||
client->close();
|
||||
});
|
||||
stream->io_ready();
|
||||
}
|
||||
catch (const std::exception& e)
|
||||
{
|
||||
LogDebug("open stream failed");
|
||||
client->closeReset();
|
||||
return;
|
||||
}
|
||||
|
||||
LogTrace("done stream setup");
|
||||
conn->io_ready();
|
||||
}
|
||||
|
||||
int
|
||||
usage(std::string_view arg0, std::string_view msg)
|
||||
{
|
||||
std::cerr << msg << "\n\n"
|
||||
<< "Usage: " << arg0
|
||||
<< " [DESTPORT [SERVERPORT [LISTENPORT]]]\n\nDefaults to ports 4444 4242 5555\n";
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char* argv[])
|
||||
{
|
||||
auto loop = uvw::Loop::create();
|
||||
|
||||
std::array<uint16_t, 3> ports{{4444, 4242, 5555}};
|
||||
for (size_t i = 0; i < ports.size(); i++)
|
||||
{
|
||||
if (argc < 2 + (int)i)
|
||||
break;
|
||||
if (!parse_int(argv[1 + i], ports[i]))
|
||||
return usage(argv[0], "Invalid port "s + argv[1 + i]);
|
||||
}
|
||||
auto& [dest_port, server_port, listen_port] = ports;
|
||||
std::cout << "Connecting to quic server at localhost:" << server_port
|
||||
<< " to reach tunneled port " << dest_port
|
||||
<< ", listening on localhost:" << listen_port << "\n";
|
||||
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
|
||||
LogDebug("Initializing client");
|
||||
auto tunnel_client = std::make_shared<llarp::quic::Client>(
|
||||
llarp::quic::Address{{127, 0, 0, 1}, server_port}, // server addr
|
||||
loop,
|
||||
dest_port // tunnel destination port
|
||||
);
|
||||
tunnel_client->default_stream_buffer_size = 0; // We steal uvw's provided buffers
|
||||
LogDebug("Initialized client");
|
||||
|
||||
// Start listening for TCP connections:
|
||||
auto server = loop->resource<uvw::TCPHandle>();
|
||||
server->data(tunnel_client->get_connection());
|
||||
server->on<uvw::ListenEvent>(llarp::quic::tunnel::on_new_connection);
|
||||
|
||||
server->bind("127.0.0.1", listen_port);
|
||||
server->listen();
|
||||
|
||||
loop->run();
|
||||
}
|
||||
|
||||
} // namespace llarp::quic::tunnel
|
||||
*/
|
||||
@ -1,158 +0,0 @@
|
||||
#include "tunnel_server.hpp"
|
||||
#include "tunnel.hpp"
|
||||
#include "connection.hpp"
|
||||
#include "server.hpp"
|
||||
#include <llarp/util/logging/logger.hpp>
|
||||
|
||||
#include <util/str.hpp>
|
||||
|
||||
#include <uvw/tcp.h>
|
||||
|
||||
/*
|
||||
using namespace std::literals;
|
||||
|
||||
namespace llarp::quic::tunnel
|
||||
{
|
||||
IncomingTunnel::IncomingTunnel(uint16_t localhost_port)
|
||||
: IncomingTunnel{
|
||||
[localhost_port](
|
||||
[[maybe_unused]] const auto& remote, uint16_t port, SockAddr& connect_to) {
|
||||
if (port != localhost_port)
|
||||
return AcceptResult::DECLINE;
|
||||
connect_to.setIPv4(127, 0, 0, 1);
|
||||
connect_to.setPort(port);
|
||||
return AcceptResult::ACCEPT;
|
||||
}}
|
||||
{}
|
||||
|
||||
int
|
||||
usage(std::string_view arg0, std::string_view msg)
|
||||
{
|
||||
std::cerr << msg << "\n\n"
|
||||
<< "Usage: " << arg0
|
||||
<< " [LISTENPORT [ALLOWED ...]]\n\nDefaults to listening on 4242 and allowing "
|
||||
"22,80,4444,8080\n";
|
||||
return 1;
|
||||
}
|
||||
|
||||
int
|
||||
main(int argc, char* argv[])
|
||||
{
|
||||
uint16_t listen_port = 4242;
|
||||
std::set<uint16_t> allowed_ports{{22, 80, 4444, 8080}};
|
||||
|
||||
if (argc >= 2 && !parse_int(argv[1], listen_port))
|
||||
return usage(argv[0], "Invalid port "s + argv[1]);
|
||||
if (argc >= 3)
|
||||
{
|
||||
allowed_ports.clear();
|
||||
for (int i = 2; i < argc; i++)
|
||||
{
|
||||
if (argv[i] == "all"sv)
|
||||
{
|
||||
allowed_ports.clear();
|
||||
break;
|
||||
}
|
||||
uint16_t port;
|
||||
if (!parse_int(argv[i], port))
|
||||
return usage(argv[0], "Invalid port "s + argv[i]);
|
||||
allowed_ports.insert(port);
|
||||
}
|
||||
}
|
||||
|
||||
auto loop = uvw::Loop::create();
|
||||
|
||||
Address listen_addr{{0, 0, 0, 0}, listen_port};
|
||||
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
|
||||
// The local address we connect to for incoming connections. (localhost for this demo, should
|
||||
// be the localhost.loki address for lokinet).
|
||||
std::string localhost = "127.0.0.1";
|
||||
|
||||
LogInfo("Initializing QUIC server");
|
||||
llarp::quic::Server s{
|
||||
listen_addr,
|
||||
loop,
|
||||
[loop, localhost, allowed_ports](
|
||||
llarp::quic::Server&, llarp::quic::Stream& stream, uint16_t port) {
|
||||
LogDebug("New incoming quic stream ", stream.id(), " to reach ", localhost, ":", port);
|
||||
if (port == 0 || !(allowed_ports.empty() || allowed_ports.count(port)))
|
||||
{
|
||||
LogWarn(
|
||||
"quic stream denied by configuration: ", port, " is not a permitted local port");
|
||||
return false;
|
||||
}
|
||||
|
||||
stream.close_callback = [](llarp::quic::Stream& strm,
|
||||
std::optional<uint64_t> error_code) {
|
||||
LogDebug(
|
||||
error_code ? "Remote side" : "We",
|
||||
" closed the quic stream, closing localhost tcp connection");
|
||||
if (error_code && *error_code > 0)
|
||||
LogWarn("Remote quic stream was closed with error code ", *error_code);
|
||||
auto tcp = strm.data<uvw::TCPHandle>();
|
||||
if (!tcp)
|
||||
LogDebug("Local TCP connection already closed");
|
||||
else
|
||||
tcp->close();
|
||||
};
|
||||
// Try to open a TCP connection to the configured localhost port; if we establish a
|
||||
// connection then we immediately send a CONNECT_INIT back down the stream; if we fail
|
||||
// then we send a fail-to-connect error code. Once we successfully connect both of
|
||||
// these handlers get replaced with the normal tunnel handlers.
|
||||
auto tcp = loop->resource<uvw::TCPHandle>();
|
||||
auto error_handler = tcp->once<uvw::ErrorEvent>(
|
||||
[&stream, localhost, port](const uvw::ErrorEvent&, uvw::TCPHandle&) {
|
||||
LogWarn(
|
||||
"Failed to connect to ", localhost, ":", port, ", shutting down quic stream");
|
||||
stream.close(tunnel::ERROR_CONNECT);
|
||||
});
|
||||
tcp->once<uvw::ConnectEvent>(
|
||||
[streamw = stream.weak_from_this(), error_handler = std::move(error_handler)](
|
||||
const uvw::ConnectEvent&, uvw::TCPHandle& tcp) {
|
||||
auto peer = tcp.peer();
|
||||
auto stream = streamw.lock();
|
||||
if (!stream)
|
||||
{
|
||||
LogWarn(
|
||||
"Connected to ",
|
||||
peer.ip,
|
||||
":",
|
||||
peer.port,
|
||||
" but quic stream has gone away; resetting local connection");
|
||||
tcp.closeReset();
|
||||
return;
|
||||
}
|
||||
LogDebug("Connected to ", peer.ip, ":", peer.port, " for quic ", stream->id());
|
||||
tcp.erase(error_handler);
|
||||
tunnel::install_stream_forwarding(tcp, *stream);
|
||||
assert(stream->used() == 0);
|
||||
|
||||
stream->append_buffer(new std::byte[1]{tunnel::CONNECT_INIT}, 1);
|
||||
tcp.read();
|
||||
});
|
||||
|
||||
// FIXME, need to configure this
|
||||
tcp->connect("127.0.0.1", port);
|
||||
|
||||
return true;
|
||||
}};
|
||||
s.default_stream_buffer_size = 0; // We steal uvw's provided buffers
|
||||
LogDebug("Initialized server");
|
||||
std::cout << "Listening on localhost:" << listen_port
|
||||
<< " with tunnel(s) to localhost port(s):";
|
||||
if (allowed_ports.empty())
|
||||
std::cout << " (any)";
|
||||
for (auto p : allowed_ports)
|
||||
std::cout << ' ' << p;
|
||||
std::cout << '\n';
|
||||
|
||||
loop->run();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
} // namespace llarp::quic::tunnel
|
||||
|
||||
*/
|
||||
@ -1,80 +0,0 @@
|
||||
#pragma once
|
||||
|
||||
#include "address.hpp"
|
||||
#include <llarp/net/sock_addr.hpp>
|
||||
#include <llarp/ev/ev.hpp>
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace llarp::quic::tunnel
|
||||
{
|
||||
enum class AcceptResult : int
|
||||
{
|
||||
ACCEPT = 0, // Accepts a connection
|
||||
DECLINE = -1, // Declines a connection (try other callbacks, refuse if all decline)
|
||||
REFUSE = -2, // Refuses a connection (don't try any more callbacks)
|
||||
};
|
||||
|
||||
// Class that wraps an incoming connection acceptance callback (to allow for callback removal).
|
||||
// This is not directly constructible: you must construct it via the TunnelServer instance.
|
||||
class IncomingTunnel final
|
||||
{
|
||||
public:
|
||||
using AcceptCallback = std::function<AcceptResult(
|
||||
const Address& remote, uint16_t port, llarp::SockAddr& connect_to)>;
|
||||
|
||||
private:
|
||||
AcceptCallback accept;
|
||||
|
||||
friend class TunnelServer;
|
||||
|
||||
// Constructor with a full callback; invoked via TunnelServer::add_incoming_tunnel
|
||||
explicit IncomingTunnel(AcceptCallback accept) : accept{std::move(accept)}
|
||||
{}
|
||||
|
||||
// Constructor for a simple forwarding to a single localhost port. E.g. IncomingTunnel(22)
|
||||
// allows incoming connections to reach port 22 and forwards them to localhost:22.
|
||||
explicit IncomingTunnel(uint16_t localhost_port);
|
||||
|
||||
// Constructor for forwarding everything to the same port; this is used by full clients by
|
||||
// default.
|
||||
IncomingTunnel();
|
||||
};
|
||||
|
||||
// Class that handles incoming quic connections. This class sets itself up in the llarp event
|
||||
// loop on construction and maintains a list of incoming acceptor callbacks. When a new incoming
|
||||
// quic connections is being established we try the callbacks one by one to determine the local
|
||||
// TCP port the tunnel should be connected to until:
|
||||
// - a callback sets connect_to and returns AcceptResult::ACCEPT - we connect it to the returned
|
||||
// address
|
||||
// - a callback returns AcceptResult::REFUSE - we reject the connection
|
||||
//
|
||||
// If a callback returns AcceptResult::DECLINE then we skip that callback and try the next one; if
|
||||
// all callbacks decline (or we have no callbacks at all) then we reject the connection.
|
||||
//
|
||||
// Note that tunnel operations and initialization are done in the event loop thread and so will
|
||||
// not take effect until the next event loop tick when called from some other thread.
|
||||
class TunnelServer : public std::enable_shared_from_this<TunnelServer>
|
||||
{
|
||||
public:
|
||||
explicit TunnelServer(EventLoop_ptr ev);
|
||||
|
||||
// Appends a new tunnel to the end of the queue; all arguments are forwarded to private
|
||||
// constructor(s) of IncomingTunnel.
|
||||
template <typename... Args>
|
||||
std::shared_ptr<IncomingTunnel>
|
||||
add_incoming_tunnel(Args&&... args)
|
||||
{
|
||||
return std::shared_ptr<IncomingTunnel>{new IncomingTunnel{std::forward<Args>(args)...}};
|
||||
}
|
||||
|
||||
// Removes a tunnel acceptor from the acceptor queue.
|
||||
void
|
||||
remove_incoming_tunnel(std::weak_ptr<IncomingTunnel> tunnel);
|
||||
|
||||
private:
|
||||
EventLoop_ptr ev;
|
||||
std::vector<std::shared_ptr<IncomingTunnel>> tunnels;
|
||||
};
|
||||
|
||||
} // namespace llarp::quic::tunnel
|
||||
Loading…
Reference in New Issue