mirror of
https://github.com/oxen-io/lokinet.git
synced 2024-11-15 12:13:24 +00:00
bf2665bbe7
- control messages can be sent along a path
- the path owner onion-encrypts the "inner" message for each hop in the
path
- relays on the path will onion the payload in both directions, such
that the terminal relay will get the plaintext "inner" message and the
client will get the plaintext "response" to that.
- control messages have (mostly, see below) been changed to be invokable
either over a path or directly to a relay, as appropriate.
TODO:
- exit messages need looked at, so they have not yet been changed for
this
- path transfer messages (traffic from client to client over 2 paths
with a shared "pivot") are not yet implemented
154 lines
4.0 KiB
C++
154 lines
4.0 KiB
C++
#pragma once
|
|
|
|
#include "router_id.hpp"
|
|
|
|
#include <llarp/dns/srv_data.hpp>
|
|
#include <llarp/ev/ev.hpp>
|
|
#include <llarp/link/tunnel.hpp>
|
|
#include <llarp/service/address.hpp>
|
|
#include <llarp/service/convotag.hpp>
|
|
#include <llarp/service/protocol_type.hpp>
|
|
|
|
#include <oxenc/variant.h>
|
|
#include <quic.hpp>
|
|
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <optional>
|
|
#include <set>
|
|
#include <string>
|
|
#include <tuple>
|
|
#include <unordered_set>
|
|
|
|
namespace llarp
|
|
{
|
|
namespace dns
|
|
{
|
|
class Server;
|
|
}
|
|
|
|
// TODO: add forward declaration of TunnelManager
|
|
// namespace link
|
|
// {
|
|
// class TunneLManager;
|
|
// }
|
|
|
|
class EndpointBase
|
|
{
|
|
std::unordered_set<dns::SRVData> m_SRVRecords;
|
|
|
|
public:
|
|
virtual ~EndpointBase() = default;
|
|
|
|
using AddressVariant_t = std::variant<service::Address, RouterID>;
|
|
|
|
struct SendStat
|
|
{
|
|
/// how many routing messages we sent to them
|
|
uint64_t messagesSend;
|
|
/// how many routing messages we got from them
|
|
uint64_t messagesRecv;
|
|
/// how many convos have we had to this guy total?
|
|
size_t numTotalConvos;
|
|
/// current estimated rtt
|
|
Duration_t estimatedRTT;
|
|
/// last time point when we sent a message to them
|
|
Duration_t lastSendAt;
|
|
/// last time point when we got a message from them
|
|
Duration_t lastRecvAt;
|
|
};
|
|
|
|
/// info about a quic mapping
|
|
struct QUICMappingInfo
|
|
{
|
|
/// srv data if it was provided
|
|
std::optional<dns::SRVData> srv;
|
|
/// address we are bound on
|
|
SockAddr localAddr;
|
|
/// the remote's lns name if we have one
|
|
std::optional<std::string> remoteName;
|
|
/// the remote's address
|
|
AddressVariant_t remoteAddr;
|
|
/// the remote's port we are connecting to
|
|
uint16_t remotePort;
|
|
};
|
|
|
|
/// maybe get quic mapping info given its stream id
|
|
/// returns std::nullopt if we have no stream given that id
|
|
std::optional<QUICMappingInfo>
|
|
GetQUICMappingInfoByID(int stream_id) const;
|
|
|
|
/// add an srv record to this endpoint's descriptor
|
|
void
|
|
PutSRVRecord(dns::SRVData srv);
|
|
|
|
/// get dns serverr if we have on on this endpoint
|
|
virtual std::shared_ptr<dns::Server>
|
|
DNS() const
|
|
{
|
|
return nullptr;
|
|
};
|
|
|
|
/// called when srv data changes in some way
|
|
virtual void
|
|
SRVRecordsChanged() = 0;
|
|
|
|
/// remove srv records from this endpoint that match a filter
|
|
/// for each srv record call it with filter, remove if filter returns true
|
|
/// return if we removed any srv records
|
|
bool
|
|
DelSRVRecordIf(std::function<bool(const dns::SRVData&)> filter);
|
|
|
|
/// get copy of all srv records
|
|
std::set<dns::SRVData>
|
|
SRVRecords() const;
|
|
|
|
/// get statistics about how much traffic we sent and recv'd to a remote endpoint
|
|
virtual std::optional<SendStat>
|
|
GetStatFor(AddressVariant_t remote) const = 0;
|
|
|
|
/// list all remote endpoint addresses we have that are mapped
|
|
virtual std::unordered_set<AddressVariant_t>
|
|
AllRemoteEndpoints() const = 0;
|
|
|
|
/// get our local address
|
|
virtual AddressVariant_t
|
|
LocalAddress() const = 0;
|
|
|
|
virtual link::TunnelManager*
|
|
GetQUICTunnel() = 0;
|
|
|
|
virtual std::optional<AddressVariant_t>
|
|
GetEndpointWithConvoTag(service::ConvoTag tag) const = 0;
|
|
|
|
virtual std::optional<service::ConvoTag>
|
|
GetBestConvoTagFor(AddressVariant_t addr) const = 0;
|
|
|
|
virtual bool
|
|
EnsurePathTo(
|
|
AddressVariant_t addr,
|
|
std::function<void(std::optional<service::ConvoTag>)> hook,
|
|
llarp_time_t timeout) = 0;
|
|
|
|
virtual void
|
|
lookup_name(std::string name, std::function<void(std::string, bool)> func) = 0;
|
|
|
|
virtual const EventLoop_ptr&
|
|
Loop() = 0;
|
|
|
|
virtual bool
|
|
send_to(service::ConvoTag tag, std::string payload) = 0;
|
|
|
|
/// lookup srv records async
|
|
virtual void
|
|
LookupServiceAsync(
|
|
std::string name,
|
|
std::string service,
|
|
std::function<void(std::vector<dns::SRVData>)> resultHandler) = 0;
|
|
|
|
virtual void
|
|
MarkAddressOutbound(service::Address remote) = 0;
|
|
};
|
|
|
|
} // namespace llarp
|