You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
383 lines
7.3 KiB
383 lines
7.3 KiB
#pragma once
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <sys/un.h>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <atomic>
|
|
#include <array>
|
|
#include <variant>
|
|
#include <cassert>
|
|
|
|
// TODO: Scavenge for useful parts and discard
|
|
|
|
namespace gp{
|
|
using open_opt_flags = int;
|
|
|
|
enum class open_options : open_opt_flags {
|
|
append = O_APPEND,
|
|
create = O_CREAT,
|
|
async = O_ASYNC,
|
|
direct = O_DIRECT,
|
|
data_sync = O_DSYNC,
|
|
file_sync = O_SYNC,
|
|
exclusive = O_EXCL,
|
|
no_access_time = O_NOATIME,
|
|
no_follow = O_NOFOLLOW,
|
|
read = O_RDONLY,
|
|
write = O_WRONLY,
|
|
#ifdef O_TEMP
|
|
temporary = O_TEMP,
|
|
#endif
|
|
#ifdef O_TRUC
|
|
truncate = O_TRUC,
|
|
#endif
|
|
};
|
|
|
|
using open_opt_mode = int;
|
|
|
|
enum class open_modes : open_opt_mode {
|
|
user_read = S_IRUSR,
|
|
user_write = S_IWUSR,
|
|
user_exec = S_IXUSR,
|
|
group_read = S_IRGRP,
|
|
group_write = S_IWGRP,
|
|
group_exec = S_IXGRP,
|
|
other_read = S_IROTH,
|
|
other_write = S_IWOTH,
|
|
other_exec = S_IXOTH,
|
|
set_uid = S_ISUID,
|
|
set_gid = S_ISGID,
|
|
sticky_bit = S_ISVTX,
|
|
};
|
|
|
|
enum class socket_domain : int {
|
|
ip4 = AF_INET,
|
|
ip6 = AF_INET6,
|
|
unix = AF_UNIX
|
|
};
|
|
|
|
enum class socket_protocol : int {
|
|
tcp_like = SOCK_STREAM,
|
|
udp_like = SOCK_DGRAM
|
|
};
|
|
|
|
|
|
using socket_opt_flags = int;
|
|
|
|
enum class net_socket_opt_flags : socket_opt_flags {
|
|
non_blocking = SOCK_NONBLOCK,
|
|
close_on_exec = SOCK_CLOEXEC,
|
|
};
|
|
|
|
using socket_opt_flags = int;
|
|
|
|
enum class unix_socket_opt_flags : socket_opt_flags {
|
|
non_blocking = SOCK_NONBLOCK,
|
|
close_on_exec = SOCK_CLOEXEC,
|
|
};
|
|
|
|
using address = std::variant<sockaddr_in, sockaddr_in6, sockaddr_un>;
|
|
|
|
template<typename T>
|
|
struct stream_expect{
|
|
const T v;
|
|
stream_expect(T value)
|
|
: v(value)
|
|
{}
|
|
};
|
|
|
|
template<typename T>
|
|
std::istream& operator>>(std::istream& in, const stream_expect<T>& expector)
|
|
{
|
|
T vin;
|
|
in >> vin;
|
|
if(vin != expector.v)
|
|
throw std::runtime_error("Expector failed");
|
|
return in;
|
|
}
|
|
|
|
address make_ipv4(const std::string_view addr, const uint16_t port)
|
|
{
|
|
std::stringstream din;
|
|
din<<addr;
|
|
std::array<uint8_t, 4> address{0};
|
|
int ex;
|
|
din>>ex
|
|
>>stream_expect<char>('.');
|
|
address[0]=ex;
|
|
din>>ex
|
|
>>stream_expect<char>('.');
|
|
address[1]=ex;
|
|
din>>ex
|
|
>>stream_expect<char>('.');
|
|
address[2]=ex;
|
|
din>>ex;
|
|
address[3]=ex;
|
|
|
|
sockaddr_in ret;
|
|
in_addr ret_addr;
|
|
ret_addr.s_addr = *((uint32_t*)&address);
|
|
ret.sin_family = AF_INET;
|
|
ret.sin_addr = ret_addr;
|
|
ret.sin_port = htons(port);
|
|
return ret;
|
|
}
|
|
|
|
// TODO: make an IPv6 parser
|
|
//address make_ipv6(const std::string_view addr, const uint16_t port){}
|
|
|
|
address make_unix(const std::string_view filename)
|
|
{
|
|
sockaddr_un ret;
|
|
if(filename.size()>(sizeof(ret.sun_path)-1))
|
|
throw std::runtime_error("Filename too long");
|
|
|
|
ret.sun_family = AF_UNIX;
|
|
*std::copy(filename.begin(), filename.end(), ret.sun_path) = '\0';
|
|
return ret;
|
|
}
|
|
|
|
class shared_fd {
|
|
int fd;
|
|
std::atomic_int* guard;
|
|
int last_error;
|
|
shared_fd(int fd_v)
|
|
: fd(fd_v)
|
|
, guard(new std::atomic_int{1})
|
|
, last_error(0)
|
|
{}
|
|
|
|
public:
|
|
shared_fd()
|
|
: fd(-1)
|
|
, guard(nullptr)
|
|
, last_error(0)
|
|
{}
|
|
|
|
shared_fd(const shared_fd& oth)
|
|
: fd(oth.fd)
|
|
, guard(oth.guard)
|
|
, last_error(0)
|
|
{
|
|
if(guard)
|
|
guard->fetch_add(1, std::memory_order_acq_rel);
|
|
}
|
|
|
|
shared_fd(shared_fd&& oth)
|
|
: last_error(0)
|
|
{
|
|
fd=oth.fd;
|
|
guard=oth.guard;
|
|
oth.fd=-1;
|
|
oth.guard=nullptr;
|
|
}
|
|
|
|
const int get() const {
|
|
return fd;
|
|
}
|
|
|
|
void operator=(const shared_fd& oth)
|
|
{
|
|
this->~shared_fd();
|
|
fd = oth.fd;
|
|
guard = oth.guard;
|
|
if(guard)
|
|
guard->fetch_add(1, std::memory_order_acq_rel);
|
|
}
|
|
|
|
void operator=(shared_fd&& oth)
|
|
{
|
|
std::swap(fd,oth.fd);
|
|
std::swap(guard,oth.guard);
|
|
}
|
|
|
|
static shared_fd open(const std::string& filename, const open_opt_flags& flags, const open_opt_mode& mode = 0)
|
|
{
|
|
shared_fd ret{::open(filename.c_str(), flags, mode)};
|
|
return ret;
|
|
}
|
|
|
|
static shared_fd create(const std::string& filename, const open_opt_mode& mode)
|
|
{
|
|
shared_fd ret{::creat(filename.c_str(), mode)};
|
|
return ret;
|
|
}
|
|
|
|
static shared_fd tcp_socket()
|
|
{
|
|
shared_fd ret;
|
|
|
|
auto res = ::socket(AF_INET, SOCK_STREAM, 0);
|
|
if(res >= 0)
|
|
{
|
|
ret = shared_fd{res};
|
|
fcntl(res, F_SETFL, O_NONBLOCK);
|
|
}
|
|
else
|
|
ret.last_error = errno;
|
|
return ret;
|
|
}
|
|
|
|
static shared_fd socket(const socket_domain& dom, const socket_protocol& proto)//, const net_socket_opt_flags& flags)
|
|
{
|
|
shared_fd ret;
|
|
|
|
auto res = ::socket((int)dom, (int)proto, (int)0);
|
|
if(res >= 0)
|
|
{
|
|
ret = shared_fd{res};
|
|
}
|
|
else
|
|
ret.last_error = errno;
|
|
return ret;
|
|
}
|
|
|
|
static shared_fd unix_socket(const socket_protocol& proto, const socket_opt_flags flags) {
|
|
shared_fd ret;
|
|
|
|
auto res = ::socket((int)AF_UNIX, (int)proto, (int)flags);
|
|
if(res >= 0)
|
|
ret = shared_fd{res};
|
|
|
|
return ret;
|
|
}
|
|
|
|
static std::pair<shared_fd,shared_fd> unix_socket_pair(const socket_protocol& proto, const net_socket_opt_flags flags) {
|
|
std::pair<gp::shared_fd, gp::shared_fd> ret;
|
|
int fds[2];
|
|
auto result = ::socketpair((int)AF_UNIX, (int)proto, (int)flags, fds);
|
|
if(result != 0)
|
|
return ret;
|
|
ret.first = shared_fd(fds[0]);
|
|
ret.second = shared_fd(fds[1]);
|
|
|
|
return ret;
|
|
}
|
|
|
|
bool is_valid() const {
|
|
return guard && (fd>=0);
|
|
}
|
|
|
|
bool has_failed() const {
|
|
return last_error;
|
|
}
|
|
|
|
bool was_connection_refused() const {
|
|
return last_error==ECONNREFUSED;
|
|
}
|
|
|
|
bool in_progress() const {
|
|
return last_error==EINPROGRESS;
|
|
}
|
|
|
|
bool must_retry() const {
|
|
return last_error==EAGAIN;
|
|
}
|
|
|
|
int error() const {
|
|
return last_error;
|
|
}
|
|
|
|
void bind(const address& addr)
|
|
{
|
|
int ret;
|
|
std::visit([&](const auto& v){
|
|
ret = ::bind(fd, (struct sockaddr*)&v, sizeof(v));
|
|
}, addr);
|
|
if(ret==0)
|
|
{
|
|
last_error = 0;
|
|
return;
|
|
}
|
|
else
|
|
last_error = errno;
|
|
}
|
|
|
|
void connect(const address& addr)
|
|
{
|
|
int ret;
|
|
std::visit([&](const auto& v){
|
|
ret = ::connect(fd, (struct sockaddr*)&v, sizeof(v));
|
|
}, addr);
|
|
if(ret!=0)
|
|
{
|
|
last_error = errno;
|
|
return;
|
|
}
|
|
last_error = 0;
|
|
}
|
|
|
|
void listen(const int& backlog = 16)
|
|
{
|
|
int ret = 0;
|
|
std::visit([&](){
|
|
ret = ::listen(fd, backlog);
|
|
});
|
|
if(ret!=0)
|
|
{
|
|
last_error = errno;
|
|
return;
|
|
}
|
|
last_error = 0;
|
|
}
|
|
|
|
shared_fd accept()
|
|
{
|
|
int ret = 0;
|
|
std::array<uint8_t, 256> buffer;
|
|
socklen_t len;
|
|
ret = ::accept(fd,(sockaddr*)buffer.begin(), &len);
|
|
if(ret!=0)
|
|
{
|
|
last_error = errno;
|
|
return shared_fd{};
|
|
}
|
|
last_error = 0;
|
|
return shared_fd{ret};
|
|
}
|
|
|
|
std::string_view read(const std::string_view buffer)
|
|
{
|
|
int sz = ::read(fd, (void*)(buffer.begin()), buffer.size());
|
|
if(sz<0)
|
|
last_error = errno;
|
|
else
|
|
last_error = 0;
|
|
sz = sz<0?0:sz;
|
|
return std::string_view(buffer.begin(), sz);
|
|
}
|
|
|
|
std::string_view write(const std::string_view buffer)
|
|
{
|
|
int sz = ::write(fd, (void*)(buffer.begin()), buffer.size());
|
|
if(sz<0)
|
|
last_error = errno;
|
|
else
|
|
last_error = 0;
|
|
sz = sz<0?0:sz;
|
|
return std::string_view(buffer.begin()+sz, buffer.size()-sz);
|
|
}
|
|
|
|
~shared_fd()
|
|
{
|
|
if(guard)
|
|
if(guard->fetch_sub(1, std::memory_order_acq_rel) == 1)
|
|
{
|
|
assert(guard->load() == 0);
|
|
assert(fd >= 0);
|
|
delete guard;
|
|
guard = nullptr;
|
|
if(fd >= 0)
|
|
{
|
|
::close(fd);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|