mirror of
https://github.com/oxen-io/lokinet.git
synced 2024-11-03 23:15:52 +00:00
5b555ee5aa
- removes all the llarp_ev_* functions, replacing with methods/classes/functions in the llarp namespace. - banish ev/ev.h to the void - Passes various things by const lvalue ref, especially shared_ptr's that don't need to be copied (to avoid an atomic refcount increment/decrement). - Add a llarp::UDPHandle abstract class for UDP handling - Removes the UDP tick handler; code that needs tick can just do a separate handler on the event loop outside the UDP socket. - Adds an "OwnedBuffer" which owns its own memory but is implicitly convertible to a llarp_buffer_t. This is mostly needed to take over ownership of buffers from uvw without copying them as, currently, uvw does its own allocation (pending some open upstream issues/PRs). - Logic: - add `make_caller`/`call_forever`/`call_every` utility functions to abstract Call wrapping and dependent timed tasks. - Add inLogicThread() so that code can tell its inside the logic thread (typically for debugging assertions). - get rid of janky integer returns and dealing with cancellations on call_later: the other methods added here and the event loop code remove the need for them. - Event loop: - redo everything with uvw instead of libuv - rename EventLoopWakeup::Wakeup to EventLoopWakeup::Trigger to better reflect what it does. - add EventLoopRepeater for repeated events, and replace the code that reschedules itself every time it is called with a repeater. - Split up `EventLoop::run()` into a non-virtual base method and abstract `run_loop()` methods; the base method does a couple extra setup/teardown things that don't need to be in the derived class. - udp_listen is replaced with ev->udp(...) which returns a new UDPHandle object rather that needing gross C-style-but-not-actually-C-compatible structs. - Remove unused register_poll_fd_(un)readable - Use shared_ptr for EventLoopWakeup rather than returning a raw pointer; uvw lets us not have to worry about having the event loop class maintain ownership of it. - Add factory EventLoop::create() function to create a default (uvw-based) event loop (previously this was one of the llarp_ev_blahblah unnamespaced functions). - ev_libuv: this is mostly rewritten; all of the glue code/structs, in particular, are gone as they are no longer needed with uvw. - DNS: - Rename DnsHandler to DnsInterceptor to better describe what it does (this is the code that intercepts all DNS to the tun IP range for Android). - endpoint: - remove unused "isolated network" code - remove distinct (but actually always the same) variables for router/endpoint logic objects - llarp_buffer_t - make constructors type-safe against being called with points to non-size-1 values - tun packet reading: - read all available packets off the device/file descriptor; previously we were reading one packet at a time then returning to the event loop to poll again. - ReadNextPacket() now returns a 0-size packet if the read would block (so that we can implement the previous point). - ReadNextPacket() now throws on I/O error - Miscellaneous code cleanups/simplifications
179 lines
4.7 KiB
C++
179 lines
4.7 KiB
C++
#pragma once
|
|
|
|
#include <ev/vpn.hpp>
|
|
#include <vpn/common.hpp>
|
|
|
|
#include <sys/kern_control.h>
|
|
#include <sys/sys_domain.h>
|
|
#include <sys/kern_event.h>
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/socket.h>
|
|
#include <sys/param.h>
|
|
#include <sys/uio.h>
|
|
|
|
#include <arpa/inet.h>
|
|
#include <net/if.h>
|
|
#include <net/if_var.h>
|
|
#include <net/if_types.h>
|
|
#include <net/route.h>
|
|
#include <netinet/if_ether.h>
|
|
#include <netinet/in.h>
|
|
|
|
#include <fcntl.h>
|
|
#include <ifaddrs.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
|
|
namespace llarp::vpn
|
|
{
|
|
class AppleInterface : public NetworkInterface
|
|
{
|
|
const int m_FD;
|
|
const InterfaceInfo m_Info;
|
|
std::string m_IfName;
|
|
|
|
static void
|
|
Exec(std::string cmd)
|
|
{
|
|
LogDebug(cmd);
|
|
system(cmd.c_str());
|
|
}
|
|
|
|
public:
|
|
AppleInterface(InterfaceInfo info)
|
|
: m_FD{::socket(PF_SYSTEM, SOCK_DGRAM, SYSPROTO_CONTROL)}, m_Info{std::move(info)}
|
|
{
|
|
if (m_FD == -1)
|
|
throw std::invalid_argument{"cannot open control socket: " + std::string{strerror(errno)}};
|
|
|
|
ctl_info cinfo{};
|
|
const std::string apple_utun = "com.apple.net.utun_control";
|
|
std::copy_n(apple_utun.c_str(), apple_utun.size(), cinfo.ctl_name);
|
|
if (::ioctl(m_FD, CTLIOCGINFO, &cinfo) < 0)
|
|
{
|
|
::close(m_FD);
|
|
throw std::runtime_error{"ioctl CTLIOCGINFO call failed: " + std::string{strerror(errno)}};
|
|
}
|
|
sockaddr_ctl addr{};
|
|
addr.sc_id = cinfo.ctl_id;
|
|
|
|
addr.sc_len = sizeof(addr);
|
|
addr.sc_family = AF_SYSTEM;
|
|
addr.ss_sysaddr = AF_SYS_CONTROL;
|
|
addr.sc_unit = 0;
|
|
|
|
if (connect(m_FD, (sockaddr*)&addr, sizeof(addr)) < 0)
|
|
{
|
|
::close(m_FD);
|
|
throw std::runtime_error{"cannot connect to control socket address: "
|
|
+ std::string{strerror(errno)}};
|
|
}
|
|
uint32_t namesz = IFNAMSIZ;
|
|
char name[IFNAMSIZ + 1]{};
|
|
if (getsockopt(m_FD, SYSPROTO_CONTROL, 2, name, &namesz) < 0)
|
|
{
|
|
::close(m_FD);
|
|
throw std::runtime_error{"cannot query for interface name: "
|
|
+ std::string{strerror(errno)}};
|
|
}
|
|
m_IfName = name;
|
|
for (const auto& ifaddr : m_Info.addrs)
|
|
{
|
|
if (ifaddr.fam == AF_INET)
|
|
{
|
|
const huint32_t addr = net::TruncateV6(ifaddr.range.addr);
|
|
const huint32_t netmask = net::TruncateV6(ifaddr.range.netmask_bits);
|
|
const huint32_t daddr = addr & netmask;
|
|
Exec(
|
|
"/sbin/ifconfig " + m_IfName + " " + addr.ToString() + " " + daddr.ToString()
|
|
+ " mtu 1500 netmask 255.255.255.255 up");
|
|
Exec(
|
|
"/sbin/route add " + daddr.ToString() + " -netmask " + netmask.ToString()
|
|
+ " -interface " + m_IfName);
|
|
Exec("/sbin/route add " + addr.ToString() + " -interface lo0");
|
|
}
|
|
else if (ifaddr.fam == AF_INET6)
|
|
{
|
|
Exec("/sbin/ifconfig " + m_IfName + " inet6 " + ifaddr.range.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
~AppleInterface()
|
|
{
|
|
::close(m_FD);
|
|
}
|
|
|
|
std::string
|
|
IfName() const override
|
|
{
|
|
return m_IfName;
|
|
}
|
|
|
|
int
|
|
PollFD() const override
|
|
{
|
|
return m_FD;
|
|
}
|
|
|
|
bool
|
|
HasNextPacket() override
|
|
{
|
|
return false;
|
|
}
|
|
|
|
net::IPPacket
|
|
ReadNextPacket() override
|
|
{
|
|
constexpr int uintsize = sizeof(unsigned int);
|
|
net::IPPacket pkt{};
|
|
unsigned int pktinfo = 0;
|
|
const struct iovec vecs[2] = {{.iov_base = &pktinfo, .iov_len = uintsize},
|
|
{.iov_base = pkt.buf, .iov_len = sizeof(pkt.buf)}};
|
|
int sz = readv(m_FD, vecs, 2);
|
|
if (sz >= uintsize)
|
|
pkt.sz = sz - uintsize;
|
|
else if (sz >= 0 || errno == EAGAIN || errno == EWOULDBLOCK)
|
|
pkt.sz = 0;
|
|
else
|
|
throw std::error_code{errno, std::system_category()};
|
|
return pkt;
|
|
}
|
|
|
|
bool
|
|
WritePacket(net::IPPacket pkt) override
|
|
{
|
|
static unsigned int af4 = htonl(AF_INET);
|
|
static unsigned int af6 = htonl(AF_INET6);
|
|
|
|
const struct iovec vecs[2] = {
|
|
{.iov_base = pkt.IsV6() ? &af6 : &af4, .iov_len = sizeof(unsigned int)},
|
|
{.iov_base = pkt.buf, .iov_len = pkt.sz}};
|
|
|
|
ssize_t n = writev(m_FD, vecs, 2);
|
|
if (n >= (int)sizeof(unsigned int))
|
|
{
|
|
n -= sizeof(unsigned int);
|
|
return static_cast<size_t>(n) == pkt.sz;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
|
|
class ApplePlatform : public Platform
|
|
{
|
|
public:
|
|
std::shared_ptr<NetworkInterface>
|
|
ObtainInterface(InterfaceInfo info) override
|
|
{
|
|
return std::make_shared<AppleInterface>(std::move(info));
|
|
}
|
|
};
|
|
} // namespace llarp::vpn
|