lokinet/llarp/ev_epoll.hpp

553 lines
11 KiB
C++
Raw Normal View History

2018-04-30 13:18:57 +00:00
#ifndef EV_EPOLL_HPP
#define EV_EPOLL_HPP
#include <fcntl.h>
#include <llarp/buffer.h>
2018-05-18 13:17:58 +00:00
#include <llarp/net.h>
2018-05-28 20:51:15 +00:00
#include <signal.h>
2018-04-30 16:14:20 +00:00
#include <sys/epoll.h>
#include <sys/un.h>
2018-08-15 15:36:34 +00:00
#include <tuntap.h>
2018-04-30 16:14:20 +00:00
#include <unistd.h>
2018-05-18 13:17:58 +00:00
#include <cstdio>
2018-08-22 15:52:10 +00:00
#include "buffer.hpp"
2018-04-30 16:14:20 +00:00
#include "ev.hpp"
#include "llarp/net.hpp"
#include "logger.hpp"
2018-08-22 15:52:10 +00:00
#include "mem.hpp"
#include <cassert>
2018-04-30 13:18:57 +00:00
namespace llarp
{
int
tcp_conn::read(void* buf, size_t sz)
{
if(_shouldClose)
return -1;
ssize_t amount = ::read(fd, buf, sz);
if(amount > 0)
{
2018-11-01 12:47:14 +00:00
if(tcp.read)
tcp.read(&tcp, buf, amount);
}
else
{
// error
_shouldClose = true;
return -1;
}
return 0;
}
2018-11-01 12:47:14 +00:00
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;
// pretty much every UNIX system still extant, _including_ solaris
// (on both sides of the fork) can ignore SIGPIPE....except
// the other vendored systems... -rick
return ::send(fd, buf, sz, MSG_NOSIGNAL); // ignore sigpipe
}
2018-11-01 12:47:14 +00:00
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(errno == EINPROGRESS)
{
// in progress
llarp::LogDebug("connect in progress");
errno = 0;
return;
}
else if(_conn->error)
{
// wtf?
llarp::LogError("error connecting ", strerror(errno));
_conn->error(_conn);
}
}
int
tcp_serv::read(void*, size_t)
{
int new_fd = ::accept(fd, nullptr, nullptr);
if(new_fd == -1)
{
llarp::LogError("failed to accept on ", fd, ":", strerror(errno));
return -1;
}
// build handler
2018-11-01 12:47:14 +00:00
llarp::tcp_conn* connimpl = new tcp_conn(loop, new_fd);
if(loop->add_ev(connimpl, true))
{
// call callback
if(tcp->accepted)
2018-11-01 12:47:14 +00:00
tcp->accepted(tcp, &connimpl->tcp);
return 0;
}
// cleanup error
delete connimpl;
return -1;
}
struct udp_listener : public ev_io
{
llarp_udp_io* udp;
2018-04-30 13:18:57 +00:00
udp_listener(int fd, llarp_udp_io* u) : ev_io(fd), udp(u){};
2018-04-30 13:18:57 +00:00
~udp_listener()
{
}
2018-04-30 16:14:20 +00:00
2018-10-25 12:39:32 +00:00
bool
2018-10-19 11:41:36 +00:00
tick()
{
if(udp->tick)
udp->tick(udp);
2018-10-25 12:39:32 +00:00
return true;
2018-10-19 11:41:36 +00:00
}
int
read(void* buf, size_t sz)
{
2018-05-23 20:37:43 +00:00
sockaddr_in6 src;
socklen_t slen = sizeof(sockaddr_in6);
sockaddr* addr = (sockaddr*)&src;
2018-10-15 16:20:45 +00:00
ssize_t ret = ::recvfrom(fd, buf, sz, 0, addr, &slen);
if(ret < 0)
2018-04-30 13:18:57 +00:00
return -1;
if(static_cast< size_t >(ret) > sz)
2018-10-15 16:20:45 +00:00
return -1;
2018-05-23 20:37:43 +00:00
udp->recvfrom(udp, addr, buf, ret);
return 0;
2018-04-30 13:18:57 +00:00
}
int
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, data, sz, SOCK_NONBLOCK, to, slen);
if(sent == -1)
{
llarp::LogWarn(strerror(errno));
}
return sent;
}
};
2018-08-15 15:36:34 +00:00
struct tun : public ev_io
{
llarp_tun_io* t;
device* tunif;
2018-10-29 16:48:36 +00:00
tun(llarp_tun_io* tio, llarp_ev_loop* l)
: ev_io(-1, new LossyWriteQueue_t("tun_write_queue", l))
2018-08-15 15:36:34 +00:00
, t(tio)
, tunif(tuntap_init())
{
};
int
sendto(__attribute__((unused)) const sockaddr* to,
__attribute__((unused)) const void* data,
__attribute__((unused)) size_t sz)
2018-08-15 15:36:34 +00:00
{
return -1;
}
2018-10-25 12:39:32 +00:00
bool
2018-10-19 11:41:36 +00:00
tick()
{
if(t->tick)
t->tick(t);
2018-10-25 19:06:16 +00:00
flush_write();
2018-10-25 12:39:32 +00:00
return true;
2018-10-19 11:41:36 +00:00
}
void
flush_write()
{
if(t->before_write)
{
t->before_write(t);
}
ev_io::flush_write();
}
2018-08-15 15:36:34 +00:00
int
read(void* buf, size_t sz)
{
ssize_t ret = tuntap_read(tunif, buf, sz);
2018-10-01 17:16:15 +00:00
if(ret > 0 && t->recvpkt)
2018-08-22 15:52:10 +00:00
{
2018-10-01 17:16:15 +00:00
// does not have pktinfo
t->recvpkt(t, buf, ret);
2018-08-22 15:52:10 +00:00
}
return ret;
2018-08-15 15:36:34 +00:00
}
bool
setup()
{
2018-08-22 15:52:10 +00:00
llarp::LogDebug("set ifname to ", t->ifname);
strncpy(tunif->if_name, t->ifname, sizeof(tunif->if_name));
2018-08-20 19:12:12 +00:00
if(tuntap_start(tunif, TUNTAP_MODE_TUNNEL, 0) == -1)
2018-08-22 15:52:10 +00:00
{
llarp::LogWarn("failed to start interface");
2018-08-15 15:36:34 +00:00
return false;
2018-08-22 15:52:10 +00:00
}
if(tuntap_up(tunif) == -1)
{
llarp::LogWarn("failed to put interface up: ", strerror(errno));
2018-08-15 15:36:34 +00:00
return false;
2018-08-22 15:52:10 +00:00
}
2018-09-20 22:38:45 +00:00
if(tuntap_set_ip(tunif, t->ifaddr, t->ifaddr, t->netmask) == -1)
2018-08-22 15:52:10 +00:00
{
llarp::LogWarn("failed to set ip");
2018-08-15 15:36:34 +00:00
return false;
2018-08-22 15:52:10 +00:00
}
2018-08-15 15:36:34 +00:00
fd = tunif->tun_fd;
if(fd == -1)
return false;
// set non blocking
int flags = fcntl(fd, F_GETFL, 0);
if(flags == -1)
return false;
return fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1;
2018-08-15 15:36:34 +00:00
}
~tun()
{
}
};
2018-04-30 16:14:20 +00:00
}; // namespace llarp
2018-04-30 13:18:57 +00:00
struct llarp_epoll_loop : public llarp_ev_loop
{
2018-04-30 13:18:57 +00:00
int epollfd;
llarp_epoll_loop() : epollfd(-1)
{
}
2018-04-30 16:14:20 +00:00
bool
2018-11-01 12:47:14 +00:00
tcp_connect(struct llarp_tcp_connecter* tcp, const sockaddr* remoteaddr)
{
// create socket
int fd = ::socket(remoteaddr->sa_family, SOCK_STREAM, 0);
if(fd == -1)
return false;
2018-11-01 12:47:14 +00:00
// set non blocking
int flags = fcntl(fd, F_GETFL, 0);
if(flags == -1)
{
::close(fd);
return false;
2018-11-01 12:47:14 +00:00
}
if(fcntl(fd, F_SETFL, flags | O_NONBLOCK) == -1)
{
::close(fd);
return false;
2018-11-01 12:47:14 +00:00
}
llarp::tcp_conn* conn = new llarp::tcp_conn(this, fd, remoteaddr, tcp);
add_ev(conn, true);
2018-11-01 12:47:14 +00:00
conn->connect();
return true;
2018-11-01 12:47:14 +00:00
}
llarp::ev_io*
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;
}
2018-11-01 12:47:14 +00:00
return new llarp::tcp_serv(this, fd, tcp);
}
virtual bool
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);
}
~llarp_epoll_loop()
{
2018-05-28 20:51:15 +00:00
if(epollfd != -1)
close(epollfd);
}
2018-04-30 13:18:57 +00:00
2018-08-10 03:51:38 +00:00
bool
running() const
{
return epollfd != -1;
}
bool
init()
{
if(epollfd == -1)
2018-07-24 01:44:01 +00:00
epollfd = epoll_create(1);
2018-05-28 20:51:15 +00:00
return false;
2018-04-30 13:18:57 +00:00
}
2018-06-06 12:46:26 +00:00
int
2018-06-06 21:23:57 +00:00
tick(int ms)
2018-06-06 12:46:26 +00:00
{
epoll_event events[1024];
int result;
2018-06-06 21:23:57 +00:00
result = epoll_wait(epollfd, events, 1024, ms);
2018-06-06 12:46:26 +00:00
if(result > 0)
{
int idx = 0;
while(idx < result)
{
llarp::ev_io* ev = static_cast< llarp::ev_io* >(events[idx].data.ptr);
if(ev)
2018-06-06 12:46:26 +00:00
{
2018-11-01 12:47:14 +00:00
if(events[idx].events & EPOLLERR)
{
2018-11-01 12:47:14 +00:00
ev->error();
}
2018-11-01 12:47:14 +00:00
else
2018-10-25 12:39:32 +00:00
{
2018-11-01 12:47:14 +00:00
if(events[idx].events & EPOLLIN)
{
ev->read(readbuf, sizeof(readbuf));
}
if(events[idx].events & EPOLLOUT)
{
ev->flush_write();
}
2018-10-25 12:39:32 +00:00
}
2018-08-15 15:36:34 +00:00
}
2018-06-06 12:46:26 +00:00
++idx;
}
}
2018-09-10 13:43:36 +00:00
if(result != -1)
tick_listeners();
2018-06-06 12:46:26 +00:00
return result;
}
int
run()
{
2018-04-30 13:18:57 +00:00
epoll_event events[1024];
int result;
do
{
2018-08-10 03:51:38 +00:00
result = epoll_wait(epollfd, events, 1024, EV_TICK_INTERVAL);
if(result > 0)
{
2018-04-30 13:18:57 +00:00
int idx = 0;
while(idx < result)
{
llarp::ev_io* ev = static_cast< llarp::ev_io* >(events[idx].data.ptr);
if(ev)
{
2018-11-01 12:47:14 +00:00
if(events[idx].events & EPOLLERR)
{
2018-11-01 12:47:14 +00:00
ev->error();
}
2018-11-01 12:47:14 +00:00
else
2018-10-25 12:39:32 +00:00
{
2018-11-01 12:47:14 +00:00
if(events[idx].events & EPOLLIN)
{
ev->read(readbuf, sizeof(readbuf));
}
if(events[idx].events & EPOLLOUT)
{
ev->flush_write();
}
2018-10-25 12:39:32 +00:00
}
2018-08-15 15:36:34 +00:00
}
2018-04-30 13:18:57 +00:00
++idx;
}
}
2018-09-10 13:43:36 +00:00
if(result != -1)
tick_listeners();
2018-05-28 20:51:15 +00:00
} while(epollfd != -1);
2018-04-30 13:18:57 +00:00
return result;
}
int
udp_bind(const sockaddr* addr)
{
2018-04-30 13:18:57 +00:00
socklen_t slen;
switch(addr->sa_family)
{
2018-04-30 16:14:20 +00:00
case AF_INET:
slen = sizeof(struct sockaddr_in);
break;
case AF_INET6:
slen = sizeof(struct sockaddr_in6);
break;
default:
return -1;
2018-04-30 13:18:57 +00:00
}
int fd = socket(addr->sa_family, SOCK_DGRAM, 0);
if(fd == -1)
2018-05-23 13:49:00 +00:00
{
perror("socket()");
return -1;
2018-05-23 13:49:00 +00:00
}
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);
if(bind(fd, addr, slen) == -1)
{
2018-05-23 13:49:00 +00:00
perror("bind()");
2018-04-30 13:18:57 +00:00
close(fd);
return -1;
}
2018-05-23 13:49:00 +00:00
2018-04-30 13:18:57 +00:00
return fd;
}
bool
close_ev(llarp::ev_io* ev)
2018-05-16 16:41:20 +00:00
{
2018-10-25 12:39:32 +00:00
return epoll_ctl(epollfd, EPOLL_CTL_DEL, ev->fd, nullptr) != -1;
2018-05-16 16:41:20 +00:00
}
2018-08-15 15:36:34 +00:00
llarp::ev_io*
create_tun(llarp_tun_io* tun)
{
2018-10-29 16:48:36 +00:00
llarp::tun* t = new llarp::tun(tun, this);
2018-08-15 15:36:34 +00:00
if(t->setup())
2018-10-19 11:41:36 +00:00
{
2018-08-15 15:36:34 +00:00
return t;
2018-10-19 11:41:36 +00:00
}
2018-08-15 15:36:34 +00:00
delete t;
return nullptr;
}
llarp::ev_io*
create_udp(llarp_udp_io* l, const sockaddr* src)
{
2018-05-23 13:49:00 +00:00
int fd = udp_bind(src);
if(fd == -1)
2018-08-15 15:36:34 +00:00
return nullptr;
2018-10-21 17:07:17 +00:00
llarp::ev_io* listener = new llarp::udp_listener(fd, l);
2018-10-19 11:41:36 +00:00
l->impl = listener;
2018-08-15 15:36:34 +00:00
return listener;
}
bool
2018-08-16 15:31:32 +00:00
add_ev(llarp::ev_io* e, bool write)
2018-08-15 15:36:34 +00:00
{
2018-04-30 13:18:57 +00:00
epoll_event ev;
2018-08-15 15:36:34 +00:00
ev.data.ptr = e;
2018-11-01 12:47:14 +00:00
ev.events = EPOLLIN | EPOLLERR;
if(write)
ev.events |= EPOLLOUT;
2018-08-15 15:36:34 +00:00
if(epoll_ctl(epollfd, EPOLL_CTL_ADD, e->fd, &ev) == -1)
{
2018-08-15 15:36:34 +00:00
delete e;
2018-04-30 13:18:57 +00:00
return false;
}
2018-10-21 17:07:17 +00:00
handlers.emplace_back(e);
2018-04-30 13:18:57 +00:00
return true;
}
2018-04-30 16:14:20 +00:00
bool
udp_close(llarp_udp_io* l)
2018-05-16 16:41:20 +00:00
{
2018-05-28 20:58:10 +00:00
bool ret = false;
llarp::udp_listener* listener =
static_cast< llarp::udp_listener* >(l->impl);
2018-05-22 19:19:06 +00:00
if(listener)
{
2018-05-28 20:58:10 +00:00
close_ev(listener);
2018-10-25 12:39:32 +00:00
// remove handler
auto itr = handlers.begin();
while(itr != handlers.end())
{
if(itr->get() == listener)
itr = handlers.erase(itr);
else
++itr;
}
2018-05-22 19:19:06 +00:00
l->impl = nullptr;
2018-10-19 11:41:36 +00:00
ret = true;
2018-05-22 19:19:06 +00:00
}
return ret;
2018-05-16 16:41:20 +00:00
}
void
stop()
{
2018-09-10 13:43:36 +00:00
if(epollfd != -1)
close(epollfd);
epollfd = -1;
2018-04-30 13:18:57 +00:00
}
};
#endif