2018-08-08 21:37:33 +02:00
|
|
|
#ifndef LLARP_HANDLERS_TUN_HPP
|
|
|
|
#define LLARP_HANDLERS_TUN_HPP
|
2018-12-12 03:15:08 +01:00
|
|
|
|
|
|
|
#include <dns/server.hpp>
|
2019-01-11 02:19:36 +01:00
|
|
|
#include <ev/ev.h>
|
2019-01-14 22:46:07 +01:00
|
|
|
#include <net/ip.hpp>
|
2019-01-11 02:42:02 +01:00
|
|
|
#include <net/net.hpp>
|
2018-12-12 03:15:08 +01:00
|
|
|
#include <service/endpoint.hpp>
|
2019-01-13 23:39:10 +01:00
|
|
|
#include <util/codel.hpp>
|
2019-01-10 20:41:51 +01:00
|
|
|
#include <util/threading.hpp>
|
2018-08-08 21:37:33 +02:00
|
|
|
|
|
|
|
namespace llarp
|
|
|
|
{
|
|
|
|
namespace handlers
|
|
|
|
{
|
2018-08-17 21:49:58 +02:00
|
|
|
static const int DefaultTunNetmask = 16;
|
|
|
|
static const char DefaultTunIfname[] = "lokinet0";
|
|
|
|
static const char DefaultTunDstAddr[] = "10.10.0.1";
|
|
|
|
static const char DefaultTunSrcAddr[] = "10.10.0.2";
|
|
|
|
|
2018-12-03 23:22:59 +01:00
|
|
|
struct TunEndpoint : public service::Endpoint, public dns::IQueryHandler
|
2018-08-08 21:37:33 +02:00
|
|
|
{
|
2019-02-11 20:45:42 +01:00
|
|
|
TunEndpoint(const std::string& nickname, AbstractRouter* r,
|
2019-01-28 16:26:35 +01:00
|
|
|
llarp::service::Context* parent);
|
2018-08-16 16:34:15 +02:00
|
|
|
~TunEndpoint();
|
|
|
|
|
2018-11-12 17:43:40 +01:00
|
|
|
virtual bool
|
2018-12-05 00:45:08 +01:00
|
|
|
SetOption(const std::string& k, const std::string& v) override;
|
2018-08-16 16:34:15 +02:00
|
|
|
|
2018-11-12 17:43:40 +01:00
|
|
|
virtual void
|
2018-12-05 00:45:08 +01:00
|
|
|
Tick(llarp_time_t now) override;
|
2018-08-16 16:34:15 +02:00
|
|
|
|
2019-02-11 18:14:43 +01:00
|
|
|
util::StatusObject
|
|
|
|
ExtractStatus() const override;
|
2019-02-08 20:43:25 +01:00
|
|
|
|
2018-12-03 23:22:59 +01:00
|
|
|
bool
|
|
|
|
ShouldHookDNSMessage(const dns::Message& msg) const override;
|
|
|
|
|
|
|
|
bool
|
|
|
|
HandleHookedDNSMessage(
|
2019-01-07 23:15:31 +01:00
|
|
|
dns::Message&& query,
|
2018-12-03 23:22:59 +01:00
|
|
|
std::function< void(dns::Message) > sendreply) override;
|
|
|
|
|
2018-08-16 16:34:15 +02:00
|
|
|
void
|
|
|
|
TickTun(llarp_time_t now);
|
|
|
|
|
2018-08-22 17:52:10 +02:00
|
|
|
bool
|
2018-11-30 15:14:30 +01:00
|
|
|
MapAddress(const service::Address& remote, huint32_t ip, bool SNode);
|
2018-08-22 17:52:10 +02:00
|
|
|
|
2018-08-16 16:34:15 +02:00
|
|
|
bool
|
2018-12-05 00:45:08 +01:00
|
|
|
Start() override;
|
2018-08-16 16:34:15 +02:00
|
|
|
|
2018-12-24 17:09:05 +01:00
|
|
|
bool
|
|
|
|
Stop() override;
|
|
|
|
|
2018-12-02 19:07:07 +01:00
|
|
|
bool
|
2018-11-30 15:14:30 +01:00
|
|
|
IsSNode() const;
|
|
|
|
|
2018-08-16 16:34:15 +02:00
|
|
|
/// set up tun interface, blocking
|
|
|
|
bool
|
|
|
|
SetupTun();
|
|
|
|
|
|
|
|
/// overrides Endpoint
|
|
|
|
bool
|
2018-12-05 00:45:08 +01:00
|
|
|
SetupNetworking() override;
|
2018-08-16 16:34:15 +02:00
|
|
|
|
2018-09-18 19:48:26 +02:00
|
|
|
/// overrides Endpoint
|
2018-08-21 20:17:16 +02:00
|
|
|
/// handle inbound traffic
|
2018-09-18 13:08:47 +02:00
|
|
|
bool
|
2019-02-01 02:58:06 +01:00
|
|
|
HandleWriteIPPacket(const llarp_buffer_t& buf,
|
2018-12-02 19:07:07 +01:00
|
|
|
std::function< huint32_t(void) > getFromIP) override;
|
2018-08-18 16:01:21 +02:00
|
|
|
|
2018-11-14 13:23:08 +01:00
|
|
|
/// queue outbound packet to the world
|
|
|
|
bool
|
|
|
|
QueueOutboundTraffic(llarp::net::IPv4Packet&& pkt);
|
|
|
|
|
2019-01-28 16:26:35 +01:00
|
|
|
/// we have a resolvable ip address
|
|
|
|
bool
|
|
|
|
HasIfAddr() const override
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-11-14 13:23:08 +01:00
|
|
|
/// get the local interface's address
|
|
|
|
huint32_t
|
2019-01-29 23:08:51 +01:00
|
|
|
GetIfAddr() const override;
|
2018-11-14 13:23:08 +01:00
|
|
|
|
|
|
|
bool
|
|
|
|
HasLocalIP(const huint32_t& ip) const;
|
|
|
|
|
2018-08-16 16:34:15 +02:00
|
|
|
llarp_tun_io tunif;
|
2018-12-02 19:07:07 +01:00
|
|
|
std::unique_ptr< llarp_fd_promise > Promise;
|
2018-08-16 16:34:15 +02:00
|
|
|
|
2018-08-21 20:17:16 +02:00
|
|
|
/// called before writing to tun interface
|
2018-08-16 16:34:15 +02:00
|
|
|
static void
|
2018-08-17 21:49:58 +02:00
|
|
|
tunifBeforeWrite(llarp_tun_io* t);
|
2018-08-16 16:34:15 +02:00
|
|
|
|
2018-08-22 17:52:10 +02:00
|
|
|
/// handle user to network send buffer flush
|
|
|
|
/// called in router logic thread
|
|
|
|
static void
|
|
|
|
handleNetSend(void*);
|
|
|
|
|
2018-08-21 20:17:16 +02:00
|
|
|
/// called every time we wish to read a packet from the tun interface
|
2018-08-16 16:34:15 +02:00
|
|
|
static void
|
2019-02-01 02:58:06 +01:00
|
|
|
tunifRecvPkt(llarp_tun_io* t, const llarp_buffer_t& buf);
|
2018-08-16 16:34:15 +02:00
|
|
|
|
2018-08-21 20:17:16 +02:00
|
|
|
/// called in the endpoint logic thread
|
2018-08-16 16:34:15 +02:00
|
|
|
static void
|
|
|
|
handleTickTun(void* u);
|
|
|
|
|
2018-11-14 13:23:08 +01:00
|
|
|
/// get a key for ip address
|
|
|
|
template < typename Addr >
|
|
|
|
Addr
|
2018-11-29 15:01:13 +01:00
|
|
|
ObtainAddrForIP(huint32_t ip, bool isSNode)
|
2018-11-14 13:23:08 +01:00
|
|
|
{
|
|
|
|
auto itr = m_IPToAddr.find(ip);
|
2018-11-29 15:01:13 +01:00
|
|
|
if(itr == m_IPToAddr.end() || m_SNodes[itr->second] != isSNode)
|
2018-11-14 13:23:08 +01:00
|
|
|
{
|
|
|
|
// not found
|
|
|
|
Addr addr;
|
|
|
|
addr.Zero();
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
// found
|
2019-01-02 02:04:08 +01:00
|
|
|
return Addr{itr->second};
|
2018-11-14 13:23:08 +01:00
|
|
|
}
|
2018-10-19 16:53:06 +02:00
|
|
|
|
2018-10-23 20:18:00 +02:00
|
|
|
bool
|
2019-01-02 02:04:04 +01:00
|
|
|
HasAddress(const AlignedBuffer< 32 >& addr) const override
|
2018-10-23 20:18:00 +02:00
|
|
|
{
|
2018-11-14 13:23:08 +01:00
|
|
|
return m_AddrToIP.find(addr) != m_AddrToIP.end();
|
2018-10-23 20:18:00 +02:00
|
|
|
}
|
|
|
|
|
2018-11-14 13:23:08 +01:00
|
|
|
/// get ip address for key unconditionally
|
2018-10-23 23:33:49 +02:00
|
|
|
huint32_t
|
2019-01-02 02:03:53 +01:00
|
|
|
ObtainIPForAddr(const AlignedBuffer< 32 >& addr,
|
|
|
|
bool serviceNode) override;
|
2018-10-23 23:33:49 +02:00
|
|
|
|
2018-12-15 17:56:35 +01:00
|
|
|
/// flush network traffic
|
|
|
|
void
|
|
|
|
Flush();
|
|
|
|
|
2018-08-17 21:49:58 +02:00
|
|
|
protected:
|
2018-11-23 00:59:03 +01:00
|
|
|
using PacketQueue_t = llarp::util::CoDelQueue<
|
2018-08-17 21:49:58 +02:00
|
|
|
net::IPv4Packet, net::IPv4Packet::GetTime, net::IPv4Packet::PutTime,
|
2018-11-23 00:59:03 +01:00
|
|
|
net::IPv4Packet::CompareOrder, net::IPv4Packet::GetNow >;
|
2018-08-17 21:49:58 +02:00
|
|
|
/// queue for sending packets over the network from us
|
|
|
|
PacketQueue_t m_UserToNetworkPktQueue;
|
|
|
|
/// queue for sending packets to user from network
|
|
|
|
PacketQueue_t m_NetworkToUserPktQueue;
|
|
|
|
/// return true if we have a remote loki address for this ip address
|
|
|
|
bool
|
2018-10-10 17:14:45 +02:00
|
|
|
HasRemoteForIP(huint32_t ipv4) const;
|
2018-10-19 16:53:06 +02:00
|
|
|
|
2018-08-21 20:17:16 +02:00
|
|
|
/// mark this address as active
|
|
|
|
void
|
2018-10-10 17:14:45 +02:00
|
|
|
MarkIPActive(huint32_t ip);
|
2018-08-21 20:17:16 +02:00
|
|
|
|
2018-09-10 13:08:09 +02:00
|
|
|
/// mark this address as active forever
|
|
|
|
void
|
2018-10-10 17:14:45 +02:00
|
|
|
MarkIPActiveForever(huint32_t ip);
|
2018-09-10 13:08:09 +02:00
|
|
|
|
2018-11-12 17:43:40 +01:00
|
|
|
/// flush ip packets
|
|
|
|
virtual void
|
2018-08-22 17:52:10 +02:00
|
|
|
FlushSend();
|
|
|
|
|
2018-11-14 13:23:08 +01:00
|
|
|
/// maps ip to key (host byte order)
|
|
|
|
std::unordered_map< huint32_t, AlignedBuffer< 32 >, huint32_t::Hash >
|
|
|
|
m_IPToAddr;
|
|
|
|
/// maps key to ip (host byte order)
|
|
|
|
std::unordered_map< AlignedBuffer< 32 >, huint32_t,
|
|
|
|
AlignedBuffer< 32 >::Hash >
|
|
|
|
m_AddrToIP;
|
|
|
|
|
2018-12-02 19:07:07 +01:00
|
|
|
/// maps key to true if key is a service node, maps key to false if key is
|
|
|
|
/// a hidden service
|
|
|
|
std::unordered_map< AlignedBuffer< 32 >, bool, AlignedBuffer< 32 >::Hash >
|
|
|
|
m_SNodes;
|
2018-11-29 14:12:35 +01:00
|
|
|
|
2018-08-16 16:34:15 +02:00
|
|
|
private:
|
2018-11-14 20:34:17 +01:00
|
|
|
bool
|
2019-02-01 02:58:06 +01:00
|
|
|
QueueInboundPacketForExit(const llarp_buffer_t& buf)
|
2018-11-14 20:34:17 +01:00
|
|
|
{
|
2019-02-03 01:48:10 +01:00
|
|
|
ManagedBuffer copy{buf};
|
2019-02-01 02:58:06 +01:00
|
|
|
|
2018-11-14 20:34:17 +01:00
|
|
|
return m_NetworkToUserPktQueue.EmplaceIf(
|
|
|
|
[&](llarp::net::IPv4Packet& pkt) -> bool {
|
2019-02-03 00:12:42 +01:00
|
|
|
if(!pkt.Load(copy.underlying))
|
2018-11-14 20:34:17 +01:00
|
|
|
return false;
|
|
|
|
pkt.UpdateIPv4PacketOnDst(pkt.src(), m_OurIP);
|
|
|
|
return true;
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2019-03-01 20:10:42 +01:00
|
|
|
template < typename Addr_t, typename Endpoint_t >
|
2018-12-03 23:22:59 +01:00
|
|
|
void
|
2019-03-01 20:10:42 +01:00
|
|
|
SendDNSReply(Addr_t addr, Endpoint_t* ctx, dns::Message* query,
|
|
|
|
std::function< void(dns::Message) > reply, bool snode)
|
|
|
|
{
|
|
|
|
if(ctx)
|
|
|
|
{
|
|
|
|
huint32_t ip = ObtainIPForAddr(addr, snode);
|
|
|
|
query->AddINReply(ip);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
query->AddNXReply();
|
|
|
|
reply(*query);
|
|
|
|
delete query;
|
|
|
|
}
|
2018-12-03 23:22:59 +01:00
|
|
|
|
2018-10-19 18:54:08 +02:00
|
|
|
#ifndef WIN32
|
2018-12-03 15:39:30 +01:00
|
|
|
/// handles fd injection force android
|
2018-12-02 19:07:07 +01:00
|
|
|
std::promise< int > m_VPNPromise;
|
2018-12-03 15:39:30 +01:00
|
|
|
#endif
|
2018-12-03 23:22:59 +01:00
|
|
|
|
|
|
|
/// our dns resolver
|
|
|
|
dns::Proxy m_Resolver;
|
2018-09-22 12:25:16 +02:00
|
|
|
|
2018-08-21 20:17:16 +02:00
|
|
|
/// maps ip address to timestamp last active
|
2018-10-10 17:50:52 +02:00
|
|
|
std::unordered_map< huint32_t, llarp_time_t, huint32_t::Hash >
|
|
|
|
m_IPActivity;
|
2018-09-23 18:47:18 +02:00
|
|
|
/// our ip address (host byte order)
|
2018-10-10 17:14:45 +02:00
|
|
|
huint32_t m_OurIP;
|
2018-09-23 18:47:18 +02:00
|
|
|
/// next ip address to allocate (host byte order)
|
2018-10-10 17:14:45 +02:00
|
|
|
huint32_t m_NextIP;
|
|
|
|
/// highest ip address to allocate (host byte order)
|
|
|
|
huint32_t m_MaxIP;
|
2018-12-03 23:22:59 +01:00
|
|
|
/// our ip range we are using
|
|
|
|
llarp::IPRange m_OurRange;
|
|
|
|
/// upstream dns resolver list
|
|
|
|
std::vector< llarp::Addr > m_UpstreamResolvers;
|
2018-11-11 14:14:19 +01:00
|
|
|
/// local dns
|
|
|
|
llarp::Addr m_LocalResolverAddr;
|
2018-08-08 21:37:33 +02:00
|
|
|
};
|
|
|
|
} // namespace handlers
|
|
|
|
} // namespace llarp
|
|
|
|
|
2018-08-16 16:34:15 +02:00
|
|
|
#endif
|