mirror of
https://github.com/oxen-io/lokinet.git
synced 2024-11-15 12:13:24 +00:00
871c3e3281
* wintun vpn platform for windows
* bundle config snippets into nsis installer for exit node, keyfile persisting, reduced hops mode.
* use wintun for vpn platform
* isolate all windows platform specific code into their own compilation units and libraries
* split up internal libraries into more specific components
* rename liblokinet.a target to liblokinet-amalgum.a to elimiate ambiguity with liblokinet.so
* DNS platform for win32
* rename llarp/ev/ev_libuv.{c,h}pp to llarp/ev/libuv.{c,h}pp as the old name was idiotic
* split up net platform into win32 and posix specific compilation units
* rename lokinet_init.c to easter_eggs.cpp as that is what they are for and it does not need to be a c compilation target
* add cmake option STRIP_SYMBOLS for seperating out debug symbols for windows builds
* intercept dns traffic on all interfaces on windows using windivert and feed it into lokinet
103 lines
2.3 KiB
C++
103 lines
2.3 KiB
C++
#pragma once
|
|
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
#include "platform.hpp"
|
|
#include "common.hpp"
|
|
#include <llarp.hpp>
|
|
|
|
namespace llarp::vpn
|
|
{
|
|
class AndroidInterface : public NetworkInterface
|
|
{
|
|
const int m_fd;
|
|
|
|
public:
|
|
AndroidInterface(InterfaceInfo info, int fd) : NetworkInterface{std::move(info)}, m_fd{fd}
|
|
{
|
|
if (m_fd == -1)
|
|
throw std::runtime_error(
|
|
"Error opening AndroidVPN layer FD: " + std::string{strerror(errno)});
|
|
}
|
|
|
|
virtual ~AndroidInterface()
|
|
{
|
|
if (m_fd != -1)
|
|
::close(m_fd);
|
|
}
|
|
|
|
int
|
|
PollFD() const override
|
|
{
|
|
return m_fd;
|
|
}
|
|
|
|
net::IPPacket
|
|
ReadNextPacket() override
|
|
{
|
|
std::vector<byte_t> pkt;
|
|
pkt.reserve(net::IPPacket::MaxSize);
|
|
const auto n = read(m_fd, pkt.data(), pkt.capacity());
|
|
pkt.resize(std::min(std::max(ssize_t{}, n), static_cast<ssize_t>(pkt.capacity())));
|
|
return net::IPPacket{std::move(pkt)};
|
|
}
|
|
|
|
bool
|
|
WritePacket(net::IPPacket pkt) override
|
|
{
|
|
const auto sz = write(m_fd, pkt.data(), pkt.size());
|
|
if (sz <= 0)
|
|
return false;
|
|
return sz == static_cast<ssize_t>(pkt.size());
|
|
}
|
|
};
|
|
|
|
class AndroidRouteManager : public IRouteManager
|
|
{
|
|
void AddRoute(net::ipaddr_t, net::ipaddr_t) override{};
|
|
|
|
void DelRoute(net::ipaddr_t, net::ipaddr_t) override{};
|
|
|
|
void
|
|
AddDefaultRouteViaInterface(NetworkInterface&) override{};
|
|
|
|
void
|
|
DelDefaultRouteViaInterface(NetworkInterface&) override{};
|
|
|
|
void
|
|
AddRouteViaInterface(NetworkInterface&, IPRange) override{};
|
|
|
|
void
|
|
DelRouteViaInterface(NetworkInterface&, IPRange) override{};
|
|
|
|
std::vector<net::ipaddr_t>
|
|
GetGatewaysNotOnInterface(NetworkInterface&) override
|
|
{
|
|
return std::vector<net::ipaddr_t>{};
|
|
};
|
|
};
|
|
|
|
class AndroidPlatform : public Platform
|
|
{
|
|
const int fd;
|
|
AndroidRouteManager _routeManager{};
|
|
|
|
public:
|
|
AndroidPlatform(llarp::Context* ctx) : fd{ctx->androidFD}
|
|
{}
|
|
|
|
std::shared_ptr<NetworkInterface>
|
|
ObtainInterface(InterfaceInfo info, AbstractRouter*) override
|
|
{
|
|
return std::make_shared<AndroidInterface>(std::move(info), fd);
|
|
}
|
|
IRouteManager&
|
|
RouteManager() override
|
|
{
|
|
return _routeManager;
|
|
}
|
|
};
|
|
|
|
} // namespace llarp::vpn
|