mirror of https://github.com/oxen-io/lokinet
Merge branch 'staging' of ssh://github.com/loki-project/loki-network into staging
Jeff Becker
5 years ago
commit
ed0294ddcf
File diff suppressed because it is too large
Load Diff
@ -1 +1,583 @@
|
||||
#include <ev/ev_kqueue.hpp>
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
inline int
|
||||
tcp_conn::read(byte_t* buf, size_t sz)
|
||||
{
|
||||
if(sz == 0)
|
||||
{
|
||||
if(tcp.read)
|
||||
tcp.read(&tcp, llarp::InitBuffer(nullptr, 0));
|
||||
return 0;
|
||||
}
|
||||
if(_shouldClose)
|
||||
return -1;
|
||||
|
||||
ssize_t amount = ::read(fd, buf, sz);
|
||||
|
||||
if(amount >= 0)
|
||||
{
|
||||
if(tcp.read)
|
||||
tcp.read(&tcp, llarp::InitBuffer(buf, amount));
|
||||
}
|
||||
else
|
||||
{
|
||||
if(errno == EAGAIN || errno == EWOULDBLOCK)
|
||||
{
|
||||
errno = 0;
|
||||
return 0;
|
||||
}
|
||||
_shouldClose = true;
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
inline void
|
||||
tcp_conn::flush_write()
|
||||
{
|
||||
connected();
|
||||
ev_io::flush_write();
|
||||
}
|
||||
|
||||
inline ssize_t
|
||||
tcp_conn::do_write(void* buf, size_t sz)
|
||||
{
|
||||
if(_shouldClose)
|
||||
return -1;
|
||||
|
||||
#if defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__)
|
||||
// macintosh uses a weird sockopt
|
||||
return ::send(fd, buf, sz, MSG_NOSIGNAL); // ignore sigpipe
|
||||
#else
|
||||
return ::send(fd, buf, sz, 0);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline void
|
||||
tcp_conn::connect()
|
||||
{
|
||||
socklen_t slen = sizeof(sockaddr_in);
|
||||
if(_addr.ss_family == AF_UNIX)
|
||||
slen = sizeof(sockaddr_un);
|
||||
else if(_addr.ss_family == AF_INET6)
|
||||
slen = sizeof(sockaddr_in6);
|
||||
int result = ::connect(fd, (const sockaddr*)&_addr, slen);
|
||||
if(result == 0)
|
||||
{
|
||||
llarp::LogDebug("Connected");
|
||||
connected();
|
||||
}
|
||||
else if(errno == EINPROGRESS)
|
||||
{
|
||||
llarp::LogDebug("connect in progress");
|
||||
errno = 0;
|
||||
return;
|
||||
}
|
||||
else if(_conn)
|
||||
{
|
||||
_conn->error(_conn);
|
||||
}
|
||||
}
|
||||
|
||||
inline int
|
||||
tcp_serv::read(byte_t*, size_t)
|
||||
{
|
||||
int new_fd = ::accept(fd, nullptr, nullptr);
|
||||
if(new_fd == -1)
|
||||
{
|
||||
llarp::LogError("failed to accept on ", fd, ": ", strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
// get flags
|
||||
int flags = fcntl(new_fd, F_GETFL, 0);
|
||||
if(flags == -1)
|
||||
{
|
||||
::close(new_fd);
|
||||
return -1;
|
||||
}
|
||||
// set flags
|
||||
if(fcntl(new_fd, F_SETFL, flags | O_NONBLOCK) == -1)
|
||||
{
|
||||
llarp::LogError("Failed to set non block on ", fd, ": ", strerror(errno));
|
||||
::close(new_fd);
|
||||
return -1;
|
||||
}
|
||||
// build handler
|
||||
llarp::tcp_conn* connimpl = new llarp::tcp_conn(loop, new_fd);
|
||||
if(loop->add_ev(connimpl, true))
|
||||
{
|
||||
// call callback
|
||||
if(tcp->accepted)
|
||||
tcp->accepted(tcp, &connimpl->tcp);
|
||||
return 0;
|
||||
}
|
||||
// cleanup error
|
||||
delete connimpl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool
|
||||
udp_listener::tick()
|
||||
{
|
||||
if(udp->tick)
|
||||
udp->tick(udp);
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
udp_listener::read(byte_t* buf, size_t sz)
|
||||
{
|
||||
sockaddr_in6 src;
|
||||
socklen_t slen = sizeof(sockaddr_in6);
|
||||
sockaddr* addr = (sockaddr*)&src;
|
||||
ssize_t ret = ::recvfrom(fd, buf, sz, 0, addr, &slen);
|
||||
if(ret < 0)
|
||||
{
|
||||
llarp::LogWarn("recvfrom failed");
|
||||
return -1;
|
||||
}
|
||||
if(static_cast< size_t >(ret) > sz)
|
||||
{
|
||||
llarp::LogWarn("ret > sz");
|
||||
return -1;
|
||||
}
|
||||
if(!addr)
|
||||
{
|
||||
llarp::LogWarn("no source addr");
|
||||
}
|
||||
// Addr is the source
|
||||
udp->recvfrom(udp, addr, llarp::InitBuffer(buf, ret));
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
udp_listener::sendto(const sockaddr* to, const void* data, size_t sz)
|
||||
{
|
||||
socklen_t slen;
|
||||
switch(to->sa_family)
|
||||
{
|
||||
case AF_INET:
|
||||
slen = sizeof(struct sockaddr_in);
|
||||
break;
|
||||
case AF_INET6:
|
||||
slen = sizeof(struct sockaddr_in6);
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
if(!fd)
|
||||
{
|
||||
printf("kqueue sendto fd empty\n");
|
||||
return -1;
|
||||
}
|
||||
ssize_t sent = ::sendto(fd, data, sz, 0, to, slen);
|
||||
if(sent == -1 || errno)
|
||||
{
|
||||
llarp::LogError("failed to send udp: ", strerror(errno));
|
||||
errno = 0;
|
||||
}
|
||||
return sent;
|
||||
}
|
||||
|
||||
int
|
||||
tun::sendto(__attribute__((unused)) const sockaddr* to,
|
||||
__attribute__((unused)) const void* data,
|
||||
__attribute__((unused)) size_t sz)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
#ifdef __APPLE__
|
||||
ssize_t
|
||||
tun::do_write(void* buf, size_t sz)
|
||||
{
|
||||
iovec vecs[2];
|
||||
// TODO: IPV6
|
||||
uint32_t t = htonl(AF_INET);
|
||||
vecs[0].iov_base = &t;
|
||||
vecs[0].iov_len = sizeof(t);
|
||||
vecs[1].iov_base = buf;
|
||||
vecs[1].iov_len = sz;
|
||||
return writev(fd, vecs, 2);
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
tun::before_flush_write()
|
||||
{
|
||||
if(t->before_write)
|
||||
{
|
||||
t->before_write(t);
|
||||
}
|
||||
}
|
||||
|
||||
bool
|
||||
tun::tick()
|
||||
{
|
||||
if(t->tick)
|
||||
t->tick(t);
|
||||
flush_write();
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
tun::read(byte_t* buf, size_t)
|
||||
{
|
||||
// all BSDs have packet info except freebsd
|
||||
#ifdef __FreeBSD__
|
||||
const ssize_t offset = 0;
|
||||
#else
|
||||
const ssize_t offset = 4;
|
||||
#endif
|
||||
|
||||
ssize_t ret = ::read(fd, buf, 1500);
|
||||
if(ret > offset && t->recvpkt)
|
||||
{
|
||||
buf += offset;
|
||||
ret -= offset;
|
||||
auto pkt = llarp::InitBuffer(buf, ret);
|
||||
t->recvpkt(t, pkt);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
bool
|
||||
tun::setup()
|
||||
{
|
||||
llarp::LogDebug("set up tunif");
|
||||
if(tuntap_start(tunif, TUNTAP_MODE_TUNNEL, TUNTAP_ID_ANY) == -1)
|
||||
return false;
|
||||
|
||||
if(tuntap_up(tunif) == -1)
|
||||
return false;
|
||||
if(tuntap_set_ifname(tunif, t->ifname) == -1)
|
||||
return false;
|
||||
llarp::LogInfo("set ", tunif->if_name, " to use address ", t->ifaddr);
|
||||
|
||||
if(tuntap_set_ip(tunif, t->ifaddr, t->ifaddr, t->netmask) == -1)
|
||||
return false;
|
||||
fd = tunif->tun_fd;
|
||||
return fd != -1;
|
||||
}
|
||||
|
||||
}; // namespace llarp
|
||||
|
||||
llarp::ev_io*
|
||||
llarp_kqueue_loop::bind_tcp(llarp_tcp_acceptor* tcp, const sockaddr* bindaddr)
|
||||
{
|
||||
int fd = ::socket(bindaddr->sa_family, SOCK_STREAM, 0);
|
||||
if(fd == -1)
|
||||
return nullptr;
|
||||
socklen_t sz = sizeof(sockaddr_in);
|
||||
if(bindaddr->sa_family == AF_INET6)
|
||||
{
|
||||
sz = sizeof(sockaddr_in6);
|
||||
}
|
||||
else if(bindaddr->sa_family == AF_UNIX)
|
||||
{
|
||||
sz = sizeof(sockaddr_un);
|
||||
}
|
||||
if(::bind(fd, bindaddr, sz) == -1)
|
||||
{
|
||||
::close(fd);
|
||||
return nullptr;
|
||||
}
|
||||
if(::listen(fd, 5) == -1)
|
||||
{
|
||||
::close(fd);
|
||||
return nullptr;
|
||||
}
|
||||
// set non blocking
|
||||
int flags = fcntl(fd, F_GETFL, 0);
|
||||
if(flags == -1)
|
||||
{
|
||||
::close(fd);
|
||||
return nullptr;
|
||||
}
|
||||
if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
|
||||
{
|
||||
::close(fd);
|
||||
return nullptr;
|
||||
}
|
||||
llarp::ev_io* serv = new llarp::tcp_serv(this, fd, tcp);
|
||||
tcp->impl = serv;
|
||||
return serv;
|
||||
}
|
||||
|
||||
llarp::ev_io*
|
||||
llarp_kqueue_loop::create_tun(llarp_tun_io* tun)
|
||||
{
|
||||
llarp::tun* t = new llarp::tun(tun, this);
|
||||
if(t->setup())
|
||||
return t;
|
||||
delete t;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_kqueue_loop::init()
|
||||
{
|
||||
if(kqueuefd == -1)
|
||||
{
|
||||
kqueuefd = kqueue();
|
||||
}
|
||||
return kqueuefd != -1;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_kqueue_loop::running() const
|
||||
{
|
||||
return kqueuefd != -1;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_kqueue_loop::tcp_connect(llarp_tcp_connecter* tcp, const sockaddr* addr)
|
||||
{
|
||||
int fd = ::socket(addr->sa_family, SOCK_STREAM, 0);
|
||||
if(fd == -1)
|
||||
return false;
|
||||
int flags = fcntl(fd, F_GETFL, 0);
|
||||
if(flags == -1)
|
||||
{
|
||||
::close(fd);
|
||||
return false;
|
||||
}
|
||||
if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
|
||||
{
|
||||
::close(fd);
|
||||
return false;
|
||||
}
|
||||
|
||||
llarp::tcp_conn* conn = new llarp::tcp_conn(this, fd, addr, tcp);
|
||||
add_ev(conn, true);
|
||||
conn->connect();
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
llarp_kqueue_loop::tick(int ms)
|
||||
{
|
||||
std::array< struct kevent, 1024 > events;
|
||||
int result;
|
||||
timespec t;
|
||||
t.tv_sec = 0;
|
||||
t.tv_nsec = ms * 1000000UL;
|
||||
result = kevent(kqueuefd, nullptr, 0, events.data(), events.size(), &t);
|
||||
// result: 0 is a timeout
|
||||
if(result > 0)
|
||||
{
|
||||
int idx = 0;
|
||||
while(idx < result)
|
||||
{
|
||||
llarp::ev_io* ev = static_cast< llarp::ev_io* >(events[idx].udata);
|
||||
if(ev)
|
||||
{
|
||||
if(events[idx].filter & EVFILT_READ)
|
||||
ev->read(readbuf,
|
||||
std::min(sizeof(readbuf), size_t(events[idx].data)));
|
||||
if(events[idx].filter & EVFILT_WRITE)
|
||||
{
|
||||
ev->flush_write_buffers(events[idx].data);
|
||||
}
|
||||
}
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
if(result != -1)
|
||||
tick_listeners();
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
llarp_kqueue_loop::run()
|
||||
{
|
||||
timespec t;
|
||||
t.tv_sec = 0;
|
||||
t.tv_nsec = 1000000UL * EV_TICK_INTERVAL;
|
||||
struct kevent events[1024];
|
||||
int result;
|
||||
do
|
||||
{
|
||||
result = kevent(kqueuefd, nullptr, 0, events, 1024, &t);
|
||||
// result: 0 is a timeout
|
||||
if(result > 0)
|
||||
{
|
||||
int idx = 0;
|
||||
while(idx < result)
|
||||
{
|
||||
llarp::ev_io* ev = static_cast< llarp::ev_io* >(events[idx].udata);
|
||||
if(ev)
|
||||
{
|
||||
if(events[idx].filter & EVFILT_READ)
|
||||
ev->read(readbuf,
|
||||
std::min(sizeof(readbuf), size_t(events[idx].data)));
|
||||
if(events[idx].filter & EVFILT_WRITE)
|
||||
ev->flush_write_buffers(events[idx].data);
|
||||
}
|
||||
else
|
||||
{
|
||||
llarp::LogWarn("kqueue event ", idx, " udata wasnt an ev_io");
|
||||
}
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
if(result != -1)
|
||||
tick_listeners();
|
||||
} while(result != -1);
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
llarp_kqueue_loop::udp_bind(const sockaddr* addr)
|
||||
{
|
||||
socklen_t slen;
|
||||
llarp::LogDebug("kqueue bind affam", addr->sa_family);
|
||||
switch(addr->sa_family)
|
||||
{
|
||||
case AF_INET:
|
||||
slen = sizeof(struct sockaddr_in);
|
||||
break;
|
||||
case AF_INET6:
|
||||
slen = sizeof(struct sockaddr_in6);
|
||||
break;
|
||||
#ifdef AF_LINK
|
||||
#endif
|
||||
#ifdef AF_PACKET
|
||||
case AF_PACKET:
|
||||
slen = sizeof(struct sockaddr_ll);
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
llarp::LogError("unsupported address family");
|
||||
return -1;
|
||||
}
|
||||
int fd = socket(addr->sa_family, SOCK_DGRAM, 0);
|
||||
if(fd == -1)
|
||||
{
|
||||
perror("socket()");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(addr->sa_family == AF_INET6)
|
||||
{
|
||||
// enable dual stack explicitly
|
||||
int dual = 1;
|
||||
if(setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &dual, sizeof(dual)) == -1)
|
||||
{
|
||||
// failed
|
||||
perror("setsockopt()");
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
llarp::Addr a(*addr);
|
||||
llarp::LogDebug("bind to ", a);
|
||||
// FreeBSD handbook said to do this
|
||||
if(addr->sa_family == AF_INET && INADDR_ANY)
|
||||
a._addr4.sin_addr.s_addr = htonl(INADDR_ANY);
|
||||
|
||||
if(bind(fd, addr, slen) == -1)
|
||||
{
|
||||
perror("bind()");
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
return fd;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_kqueue_loop::udp_listen(llarp_udp_io* l, const sockaddr* src)
|
||||
{
|
||||
auto ev = create_udp(l, src);
|
||||
if(ev)
|
||||
l->fd = ev->fd;
|
||||
return ev && add_ev(ev, false);
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_kqueue_loop::close_ev(llarp::ev_io* ev)
|
||||
{
|
||||
EV_SET(&ev->change, ev->fd, ev->flags, EV_DELETE, 0, 0, nullptr);
|
||||
return kevent(kqueuefd, &ev->change, 1, nullptr, 0, nullptr) != -1;
|
||||
}
|
||||
|
||||
llarp::ev_io*
|
||||
llarp_kqueue_loop::create_udp(llarp_udp_io* l, const sockaddr* src)
|
||||
{
|
||||
int fd = udp_bind(src);
|
||||
if(fd == -1)
|
||||
return nullptr;
|
||||
llarp::udp_listener* listener = new llarp::udp_listener(fd, l);
|
||||
l->impl = listener;
|
||||
return listener;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_kqueue_loop::add_ev(llarp::ev_io* ev, bool w)
|
||||
{
|
||||
ev->flags = EVFILT_READ;
|
||||
EV_SET(&ev->change, ev->fd, EVFILT_READ, EV_ADD, 0, 0, ev);
|
||||
if(kevent(kqueuefd, &ev->change, 1, nullptr, 0, nullptr) == -1)
|
||||
{
|
||||
llarp::LogError("Failed to add event: ", strerror(errno));
|
||||
delete ev;
|
||||
return false;
|
||||
}
|
||||
if(w)
|
||||
{
|
||||
ev->flags |= EVFILT_WRITE;
|
||||
EV_SET(&ev->change, ev->fd, EVFILT_WRITE, EV_ADD, 0, 0, ev);
|
||||
if(kevent(kqueuefd, &ev->change, 1, nullptr, 0, nullptr) == -1)
|
||||
{
|
||||
llarp::LogError("Failed to add event: ", strerror(errno));
|
||||
delete ev;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
handlers.emplace_back(ev);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_kqueue_loop::udp_close(llarp_udp_io* l)
|
||||
{
|
||||
bool ret = false;
|
||||
auto listener = static_cast< llarp::udp_listener* >(l->impl);
|
||||
if(listener)
|
||||
{
|
||||
// printf("Calling close_ev for [%x] fd[%d]\n", listener, listener->fd);
|
||||
ret = close_ev(listener);
|
||||
// remove handler
|
||||
auto itr = handlers.begin();
|
||||
while(itr != handlers.end())
|
||||
{
|
||||
if(itr->get() == listener)
|
||||
{
|
||||
itr = handlers.erase(itr);
|
||||
ret = true;
|
||||
}
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
l->impl = nullptr;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_kqueue_loop::stop()
|
||||
{
|
||||
auto itr = handlers.begin();
|
||||
while(itr != handlers.end())
|
||||
{
|
||||
close_ev(itr->get());
|
||||
itr = handlers.erase(itr);
|
||||
}
|
||||
|
||||
if(kqueuefd != -1)
|
||||
::close(kqueuefd);
|
||||
|
||||
kqueuefd = -1;
|
||||
}
|
||||
@ -1 +1,629 @@
|
||||
#include <ev/ev_win32.hpp>
|
||||
|
||||
// a single event queue for the TUN interface
|
||||
HANDLE tun_event_queue = INVALID_HANDLE_VALUE;
|
||||
|
||||
// we hand the kernel our thread handles to process completion events
|
||||
HANDLE* kThreadPool;
|
||||
|
||||
// list of TUN listeners (useful for exits or other nodes with multiple TUNs)
|
||||
std::list< win32_tun_io* > tun_listeners;
|
||||
|
||||
void
|
||||
begin_tun_loop(int nThreads)
|
||||
{
|
||||
kThreadPool = new HANDLE[nThreads];
|
||||
for(int i = 0; i < nThreads; ++i)
|
||||
{
|
||||
kThreadPool[i] =
|
||||
CreateThread(nullptr, 0, &tun_ev_loop, nullptr, 0, nullptr);
|
||||
}
|
||||
llarp::LogInfo("created ", nThreads, " threads for TUN event queue");
|
||||
}
|
||||
|
||||
// this one is called from the TUN handler
|
||||
bool
|
||||
win32_tun_io::queue_write(const byte_t* buf, size_t sz)
|
||||
{
|
||||
do_write((void*)buf, sz);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
win32_tun_io::setup()
|
||||
{
|
||||
if(tuntap_start(tunif, TUNTAP_MODE_TUNNEL, 0) == -1)
|
||||
{
|
||||
llarp::LogWarn("failed to start interface");
|
||||
return false;
|
||||
}
|
||||
if(tuntap_set_ip(tunif, t->ifaddr, t->ifaddr, t->netmask) == -1)
|
||||
{
|
||||
llarp::LogWarn("failed to set ip");
|
||||
return false;
|
||||
}
|
||||
if(tuntap_up(tunif) == -1)
|
||||
{
|
||||
char ebuf[1024];
|
||||
int err = GetLastError();
|
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, err, LANG_NEUTRAL, ebuf,
|
||||
1024, nullptr);
|
||||
llarp::LogWarn("failed to put interface up: ", ebuf);
|
||||
return false;
|
||||
}
|
||||
|
||||
if(tunif->tun_fd == INVALID_HANDLE_VALUE)
|
||||
return false;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// first TUN device gets to set up the event port
|
||||
bool
|
||||
win32_tun_io::add_ev()
|
||||
{
|
||||
if(tun_event_queue == INVALID_HANDLE_VALUE)
|
||||
{
|
||||
SYSTEM_INFO sys_info;
|
||||
GetSystemInfo(&sys_info);
|
||||
unsigned long numCPU = sys_info.dwNumberOfProcessors;
|
||||
// let the system handle 2x the number of CPUs or hardware
|
||||
// threads
|
||||
tun_event_queue = CreateIoCompletionPort(tunif->tun_fd, nullptr,
|
||||
(ULONG_PTR)this, numCPU * 2);
|
||||
begin_tun_loop(numCPU * 2);
|
||||
}
|
||||
else
|
||||
CreateIoCompletionPort(tunif->tun_fd, tun_event_queue, (ULONG_PTR)this, 0);
|
||||
|
||||
// we're already non-blocking
|
||||
// add to list
|
||||
tun_listeners.push_back(this);
|
||||
read(readbuf, 4096);
|
||||
return true;
|
||||
}
|
||||
|
||||
// places data in event queue for kernel to process
|
||||
void
|
||||
win32_tun_io::do_write(void* data, size_t sz)
|
||||
{
|
||||
asio_evt_pkt* pkt = new asio_evt_pkt;
|
||||
pkt->buf = data;
|
||||
pkt->sz = sz;
|
||||
pkt->write = true;
|
||||
memset(&pkt->pkt, '\0', sizeof(pkt->pkt));
|
||||
WriteFile(tunif->tun_fd, data, sz, nullptr, &pkt->pkt);
|
||||
}
|
||||
|
||||
// while this one is called from the event loop
|
||||
// eventually comes back and calls queue_write()
|
||||
void
|
||||
win32_tun_io::flush_write()
|
||||
{
|
||||
if(t->before_write)
|
||||
t->before_write(t);
|
||||
}
|
||||
|
||||
void
|
||||
win32_tun_io::read(byte_t* buf, size_t sz)
|
||||
{
|
||||
asio_evt_pkt* pkt = new asio_evt_pkt;
|
||||
pkt->buf = buf;
|
||||
memset(&pkt->pkt, '\0', sizeof(OVERLAPPED));
|
||||
pkt->sz = sz;
|
||||
pkt->write = false;
|
||||
ReadFile(tunif->tun_fd, buf, sz, nullptr, &pkt->pkt);
|
||||
}
|
||||
|
||||
// and now the event loop itself
|
||||
extern "C" DWORD FAR PASCAL
|
||||
tun_ev_loop(void* unused)
|
||||
{
|
||||
UNREFERENCED_PARAMETER(unused);
|
||||
|
||||
DWORD size = 0;
|
||||
OVERLAPPED* ovl = nullptr;
|
||||
ULONG_PTR listener = 0;
|
||||
asio_evt_pkt* pkt = nullptr;
|
||||
BOOL alert;
|
||||
|
||||
while(true)
|
||||
{
|
||||
alert =
|
||||
GetQueuedCompletionStatus(tun_event_queue, &size, &listener, &ovl, 100);
|
||||
|
||||
if(!alert)
|
||||
{
|
||||
// tick listeners on io timeout, this is required to be done every tick
|
||||
// cycle regardless of any io being done, this manages the internal state
|
||||
// of the tun logic
|
||||
for(const auto& tun : tun_listeners)
|
||||
{
|
||||
if(tun->t->tick)
|
||||
tun->t->tick(tun->t);
|
||||
tun->flush_write();
|
||||
}
|
||||
continue; // let's go at it once more
|
||||
}
|
||||
if(listener == (ULONG_PTR)~0)
|
||||
break;
|
||||
// if we're here, then we got something interesting :>
|
||||
pkt = (asio_evt_pkt*)ovl;
|
||||
win32_tun_io* ev = reinterpret_cast< win32_tun_io* >(listener);
|
||||
if(!pkt->write)
|
||||
{
|
||||
// llarp::LogInfo("read tun ", size, " bytes, pass to handler");
|
||||
// skip if our buffer remains empty
|
||||
// (if our buffer is empty, we don't even have a valid IP frame.
|
||||
// just throw it out)
|
||||
if(*(byte_t*)pkt->buf == '\0')
|
||||
{
|
||||
delete pkt;
|
||||
continue;
|
||||
}
|
||||
if(ev->t->recvpkt)
|
||||
ev->t->recvpkt(ev->t, llarp::InitBuffer(pkt->buf, size));
|
||||
ev->read(ev->readbuf, sizeof(ev->readbuf));
|
||||
}
|
||||
else
|
||||
{
|
||||
// ok let's queue another read!
|
||||
ev->read(ev->readbuf, sizeof(ev->readbuf));
|
||||
}
|
||||
if(ev->t->tick)
|
||||
ev->t->tick(ev->t);
|
||||
ev->flush_write();
|
||||
delete pkt; // don't leak
|
||||
}
|
||||
llarp::LogInfo("exit TUN event loop thread from system managed thread pool");
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
exit_tun_loop()
|
||||
{
|
||||
// if we get all-ones in the queue, thread exits, and we clean up
|
||||
PostQueuedCompletionStatus(tun_event_queue, 0, ~0, nullptr);
|
||||
|
||||
// kill the kernel's thread pool
|
||||
int i = (&kThreadPool)[1] - kThreadPool; // get the size of our thread pool
|
||||
llarp::LogInfo("closing ", i, " threads");
|
||||
WaitForMultipleObjects(i, kThreadPool, TRUE, INFINITE);
|
||||
for(int j = 0; j < i; ++j)
|
||||
CloseHandle(kThreadPool[j]);
|
||||
delete[] kThreadPool;
|
||||
|
||||
// the IOCP refcount is decreased each time an associated fd
|
||||
// is closed
|
||||
// the fds are closed in their destructors
|
||||
// once we get to zero, we can safely close the event port
|
||||
auto itr = tun_listeners.begin();
|
||||
while(itr != tun_listeners.end())
|
||||
{
|
||||
delete(*itr);
|
||||
itr = tun_listeners.erase(itr);
|
||||
}
|
||||
CloseHandle(tun_event_queue);
|
||||
}
|
||||
|
||||
namespace llarp
|
||||
{
|
||||
int
|
||||
tcp_conn::read(byte_t* buf, size_t sz)
|
||||
{
|
||||
if(_shouldClose)
|
||||
return -1;
|
||||
|
||||
ssize_t amount = uread(fd, (char*)buf, sz);
|
||||
|
||||
if(amount > 0)
|
||||
{
|
||||
if(tcp.read)
|
||||
tcp.read(&tcp, llarp::InitBuffer(buf, amount));
|
||||
}
|
||||
else
|
||||
{
|
||||
// error
|
||||
_shouldClose = true;
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
void
|
||||
tcp_conn::flush_write()
|
||||
{
|
||||
connected();
|
||||
ev_io::flush_write();
|
||||
}
|
||||
|
||||
ssize_t
|
||||
tcp_conn::do_write(void* buf, size_t sz)
|
||||
{
|
||||
if(_shouldClose)
|
||||
return -1;
|
||||
return uwrite(fd, (char*)buf, sz);
|
||||
}
|
||||
|
||||
void
|
||||
tcp_conn::connect()
|
||||
{
|
||||
socklen_t slen = sizeof(sockaddr_in);
|
||||
if(_addr.ss_family == AF_UNIX)
|
||||
slen = sizeof(sockaddr_un);
|
||||
else if(_addr.ss_family == AF_INET6)
|
||||
slen = sizeof(sockaddr_in6);
|
||||
int result = ::connect(fd, (const sockaddr*)&_addr, slen);
|
||||
if(result == 0)
|
||||
{
|
||||
llarp::LogDebug("connected immedidately");
|
||||
connected();
|
||||
}
|
||||
else if(WSAGetLastError() == WSAEINPROGRESS)
|
||||
{
|
||||
// in progress
|
||||
llarp::LogDebug("connect in progress");
|
||||
WSASetLastError(0);
|
||||
return;
|
||||
}
|
||||
else if(_conn->error)
|
||||
{
|
||||
// wtf?
|
||||
char ebuf[1024];
|
||||
int err = WSAGetLastError();
|
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, err, LANG_NEUTRAL,
|
||||
ebuf, 1024, nullptr);
|
||||
llarp::LogError("error connecting: ", ebuf);
|
||||
_conn->error(_conn);
|
||||
}
|
||||
}
|
||||
|
||||
int
|
||||
tcp_serv::read(byte_t*, size_t)
|
||||
{
|
||||
int new_fd = ::accept(fd, nullptr, nullptr);
|
||||
if(new_fd == -1)
|
||||
{
|
||||
char ebuf[1024];
|
||||
int err = WSAGetLastError();
|
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, err, LANG_NEUTRAL,
|
||||
ebuf, 1024, nullptr);
|
||||
llarp::LogError("failed to accept on ", fd, ":", ebuf);
|
||||
return -1;
|
||||
}
|
||||
// build handler
|
||||
llarp::tcp_conn* connimpl = new tcp_conn(loop, new_fd);
|
||||
if(loop->add_ev(connimpl, true))
|
||||
{
|
||||
// call callback
|
||||
if(tcp->accepted)
|
||||
tcp->accepted(tcp, &connimpl->tcp);
|
||||
return 0;
|
||||
}
|
||||
// cleanup error
|
||||
delete connimpl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
bool
|
||||
udp_listener::tick()
|
||||
{
|
||||
if(udp->tick)
|
||||
udp->tick(udp);
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
udp_listener::read(byte_t* buf, size_t sz)
|
||||
{
|
||||
llarp_buffer_t b;
|
||||
b.base = buf;
|
||||
b.cur = b.base;
|
||||
sockaddr_in6 src;
|
||||
socklen_t slen = sizeof(sockaddr_in6);
|
||||
sockaddr* addr = (sockaddr*)&src;
|
||||
ssize_t ret = ::recvfrom(fd, (char*)b.base, sz, 0, addr, &slen);
|
||||
if(ret < 0)
|
||||
return -1;
|
||||
if(static_cast< size_t >(ret) > sz)
|
||||
return -1;
|
||||
b.sz = ret;
|
||||
udp->recvfrom(udp, addr, b);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int
|
||||
udp_listener::sendto(const sockaddr* to, const void* data, size_t sz)
|
||||
{
|
||||
socklen_t slen;
|
||||
switch(to->sa_family)
|
||||
{
|
||||
case AF_INET:
|
||||
slen = sizeof(struct sockaddr_in);
|
||||
break;
|
||||
case AF_INET6:
|
||||
slen = sizeof(struct sockaddr_in6);
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
ssize_t sent = ::sendto(fd, (char*)data, sz, 0, to, slen);
|
||||
if(sent == -1)
|
||||
{
|
||||
char ebuf[1024];
|
||||
int err = WSAGetLastError();
|
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, err, LANG_NEUTRAL,
|
||||
ebuf, 1024, nullptr);
|
||||
llarp::LogWarn(ebuf);
|
||||
}
|
||||
return sent;
|
||||
}
|
||||
|
||||
}; // namespace llarp
|
||||
|
||||
bool
|
||||
llarp_win32_loop::tcp_connect(struct llarp_tcp_connecter* tcp,
|
||||
const sockaddr* remoteaddr)
|
||||
{
|
||||
// create socket
|
||||
int fd = usocket(remoteaddr->sa_family, SOCK_STREAM, 0);
|
||||
if(fd == -1)
|
||||
return false;
|
||||
llarp::tcp_conn* conn = new llarp::tcp_conn(this, fd, remoteaddr, tcp);
|
||||
add_ev(conn, true);
|
||||
conn->connect();
|
||||
return true;
|
||||
}
|
||||
|
||||
llarp::ev_io*
|
||||
llarp_win32_loop::bind_tcp(llarp_tcp_acceptor* tcp, const sockaddr* bindaddr)
|
||||
{
|
||||
int fd = usocket(bindaddr->sa_family, SOCK_STREAM, 0);
|
||||
if(fd == -1)
|
||||
return nullptr;
|
||||
socklen_t sz = sizeof(sockaddr_in);
|
||||
if(bindaddr->sa_family == AF_INET6)
|
||||
{
|
||||
sz = sizeof(sockaddr_in6);
|
||||
}
|
||||
// keep. inexplicably, windows now has unix domain sockets
|
||||
// for now, use the ID numbers directly until this comes out of
|
||||
// beta
|
||||
else if(bindaddr->sa_family == AF_UNIX)
|
||||
sz = sizeof(sockaddr_un);
|
||||
|
||||
if(::bind(fd, bindaddr, sz) == -1)
|
||||
{
|
||||
uclose(fd);
|
||||
return nullptr;
|
||||
}
|
||||
if(ulisten(fd, 5) == -1)
|
||||
{
|
||||
uclose(fd);
|
||||
return nullptr;
|
||||
}
|
||||
return new llarp::tcp_serv(this, fd, tcp);
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_win32_loop::udp_listen(llarp_udp_io* l, const sockaddr* src)
|
||||
{
|
||||
auto ev = create_udp(l, src);
|
||||
if(ev)
|
||||
l->fd = ev->fd;
|
||||
return ev && add_ev(ev, false);
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_win32_loop::running() const
|
||||
{
|
||||
return (upollfd != nullptr);
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_win32_loop::init()
|
||||
{
|
||||
if(!upollfd)
|
||||
upollfd = upoll_create(1);
|
||||
return upollfd != nullptr;
|
||||
}
|
||||
|
||||
// OK, the event loop, as it exists now, will _only_
|
||||
// work on sockets (and not very efficiently at that).
|
||||
int
|
||||
llarp_win32_loop::tick(int ms)
|
||||
{
|
||||
upoll_event_t events[1024];
|
||||
int result;
|
||||
result = upoll_wait(upollfd, events, 1024, ms);
|
||||
if(result > 0)
|
||||
{
|
||||
int idx = 0;
|
||||
while(idx < result)
|
||||
{
|
||||
llarp::ev_io* ev = static_cast< llarp::ev_io* >(events[idx].data.ptr);
|
||||
if(ev)
|
||||
{
|
||||
if(events[idx].events & UPOLLERR)
|
||||
{
|
||||
ev->error();
|
||||
}
|
||||
else
|
||||
{
|
||||
if(events[idx].events & UPOLLIN)
|
||||
{
|
||||
ev->read(readbuf, sizeof(readbuf));
|
||||
}
|
||||
if(events[idx].events & UPOLLOUT)
|
||||
{
|
||||
ev->flush_write();
|
||||
}
|
||||
}
|
||||
}
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
|
||||
if(result != -1)
|
||||
tick_listeners();
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
llarp_win32_loop::run()
|
||||
{
|
||||
upoll_event_t events[1024];
|
||||
int result;
|
||||
do
|
||||
{
|
||||
result = upoll_wait(upollfd, events, 1024, EV_TICK_INTERVAL);
|
||||
if(result > 0)
|
||||
{
|
||||
int idx = 0;
|
||||
while(idx < result)
|
||||
{
|
||||
llarp::ev_io* ev = static_cast< llarp::ev_io* >(events[idx].data.ptr);
|
||||
if(ev)
|
||||
{
|
||||
if(events[idx].events & UPOLLERR)
|
||||
{
|
||||
ev->error();
|
||||
}
|
||||
else
|
||||
{
|
||||
if(events[idx].events & UPOLLIN)
|
||||
{
|
||||
ev->read(readbuf, sizeof(readbuf));
|
||||
}
|
||||
if(events[idx].events & UPOLLOUT)
|
||||
{
|
||||
ev->flush_write();
|
||||
}
|
||||
}
|
||||
}
|
||||
++idx;
|
||||
}
|
||||
}
|
||||
if(result != -1)
|
||||
tick_listeners();
|
||||
} while(upollfd);
|
||||
return result;
|
||||
}
|
||||
|
||||
int
|
||||
llarp_win32_loop::udp_bind(const sockaddr* addr)
|
||||
{
|
||||
socklen_t slen;
|
||||
switch(addr->sa_family)
|
||||
{
|
||||
case AF_INET:
|
||||
slen = sizeof(struct sockaddr_in);
|
||||
break;
|
||||
case AF_INET6:
|
||||
slen = sizeof(struct sockaddr_in6);
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
int fd = usocket(addr->sa_family, SOCK_DGRAM, 0);
|
||||
if(fd == -1)
|
||||
{
|
||||
perror("usocket()");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(addr->sa_family == AF_INET6)
|
||||
{
|
||||
// enable dual stack explicitly
|
||||
int dual = 1;
|
||||
if(setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (char*)&dual, sizeof(dual))
|
||||
== -1)
|
||||
{
|
||||
// failed
|
||||
perror("setsockopt()");
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
llarp::Addr a(*addr);
|
||||
llarp::LogDebug("bind to ", a);
|
||||
if(bind(fd, addr, slen) == -1)
|
||||
{
|
||||
perror("bind()");
|
||||
close(fd);
|
||||
return -1;
|
||||
}
|
||||
|
||||
return fd;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_win32_loop::close_ev(llarp::ev_io* ev)
|
||||
{
|
||||
return upoll_ctl(upollfd, UPOLL_CTL_DEL, ev->fd, nullptr) != -1;
|
||||
}
|
||||
|
||||
// no tunnels here
|
||||
llarp::ev_io*
|
||||
llarp_win32_loop::create_tun(llarp_tun_io* tun)
|
||||
{
|
||||
UNREFERENCED_PARAMETER(tun);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
llarp::ev_io*
|
||||
llarp_win32_loop::create_udp(llarp_udp_io* l, const sockaddr* src)
|
||||
{
|
||||
int fd = udp_bind(src);
|
||||
if(fd == -1)
|
||||
return nullptr;
|
||||
llarp::ev_io* listener = new llarp::udp_listener(fd, l);
|
||||
l->impl = listener;
|
||||
return listener;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_win32_loop::add_ev(llarp::ev_io* e, bool write)
|
||||
{
|
||||
upoll_event_t ev;
|
||||
ev.data.ptr = e;
|
||||
ev.events = UPOLLIN | UPOLLERR;
|
||||
if(write)
|
||||
ev.events |= UPOLLOUT;
|
||||
if(upoll_ctl(upollfd, UPOLL_CTL_ADD, e->fd, &ev) == -1)
|
||||
{
|
||||
delete e;
|
||||
return false;
|
||||
}
|
||||
handlers.emplace_back(e);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool
|
||||
llarp_win32_loop::udp_close(llarp_udp_io* l)
|
||||
{
|
||||
bool ret = false;
|
||||
llarp::udp_listener* listener = static_cast< llarp::udp_listener* >(l->impl);
|
||||
if(listener)
|
||||
{
|
||||
close_ev(listener);
|
||||
// remove handler
|
||||
auto itr = handlers.begin();
|
||||
while(itr != handlers.end())
|
||||
{
|
||||
if(itr->get() == listener)
|
||||
itr = handlers.erase(itr);
|
||||
else
|
||||
++itr;
|
||||
}
|
||||
l->impl = nullptr;
|
||||
ret = true;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void
|
||||
llarp_win32_loop::stop()
|
||||
{
|
||||
// do nothing
|
||||
}
|
||||
Binary file not shown.
Loading…
Reference in New Issue