From fac9e8bec1983fa9dff8f447fef106e427dfec26 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Thu, 20 Jul 2023 17:02:05 +0200
Subject: c++: Renamed src to c++

---
 src/io/io_unix.cpp | 894 -----------------------------------------------------
 1 file changed, 894 deletions(-)
 delete mode 100644 src/io/io_unix.cpp

(limited to 'src/io/io_unix.cpp')

diff --git a/src/io/io_unix.cpp b/src/io/io_unix.cpp
deleted file mode 100644
index c3b4f17..0000000
--- a/src/io/io_unix.cpp
+++ /dev/null
@@ -1,894 +0,0 @@
-#ifdef SAW_UNIX
-
-#include <csignal>
-#include <sys/signalfd.h>
-
-#include <fcntl.h>
-#include <netdb.h>
-#include <netinet/in.h>
-#include <sys/epoll.h>
-#include <sys/socket.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/un.h>
-
-#include <cassert>
-#include <cstring>
-
-#include <errno.h>
-#include <unistd.h>
-
-#include <queue>
-#include <sstream>
-#include <unordered_map>
-#include <vector>
-
-#include "io.h"
-
-namespace saw {
-namespace unix {
-constexpr int MAX_EPOLL_EVENTS = 256;
-
-class unix_event_port;
-class i_fd_owner {
-protected:
-	unix_event_port &event_port_;
-
-private:
-	int file_descriptor_;
-	int fd_flags_;
-	uint32_t event_mask_;
-
-public:
-	i_fd_owner(unix_event_port &event_port, int file_descriptor, int fd_flags,
-			   uint32_t event_mask);
-
-	virtual ~i_fd_owner();
-
-	virtual void notify(uint32_t mask) = 0;
-
-	int fd() const { return file_descriptor_; }
-};
-
-class unix_event_port final : public event_port {
-private:
-	int epoll_fd_;
-	int signal_fd_;
-
-	sigset_t signal_fd_set_;
-
-	std::unordered_multimap<Signal, own<conveyor_feeder<void>>>
-		signal_conveyors_;
-
-	int pipefds_[2];
-
-	std::vector<int> to_unix_signal(Signal signal) const {
-		switch (signal) {
-		case Signal::User1:
-			return {SIGUSR1};
-		case Signal::Terminate:
-		default:
-			return {SIGTERM, SIGQUIT, SIGINT};
-		}
-	}
-
-	Signal from_unix_signal(int signal) const {
-		switch (signal) {
-		case SIGUSR1:
-			return Signal::User1;
-		case SIGTERM:
-		case SIGINT:
-		case SIGQUIT:
-		default:
-			return Signal::Terminate;
-		}
-	}
-
-	void notify_signal_listener(int sig) {
-		Signal signal = from_unix_signal(sig);
-
-		auto equal_range = signal_conveyors_.equal_range(signal);
-		for (auto iter = equal_range.first; iter != equal_range.second;
-			 ++iter) {
-
-			if (iter->second) {
-				if (iter->second->space() > 0) {
-					iter->second->feed();
-				}
-			}
-		}
-	}
-
-	bool poll_impl(int time) {
-		epoll_event events[MAX_EPOLL_EVENTS];
-		int nfds = 0;
-		do {
-			nfds = epoll_wait(epoll_fd_, events, MAX_EPOLL_EVENTS, time);
-
-			if (nfds < 0) {
-				/// @todo error_handling
-				return false;
-			}
-
-			for (int i = 0; i < nfds; ++i) {
-				if (events[i].data.u64 == 0) {
-					while (1) {
-						struct ::signalfd_siginfo siginfo;
-						ssize_t n =
-							::read(signal_fd_, &siginfo, sizeof(siginfo));
-						if (n < 0) {
-							break;
-						}
-						assert(n == sizeof(siginfo));
-
-						notify_signal_listener(siginfo.ssi_signo);
-					}
-				} else if (events[i].data.u64 == 1) {
-					uint8_t i;
-					if (pipefds_[0] < 0) {
-						continue;
-					}
-					while (1) {
-						ssize_t n = ::recv(pipefds_[0], &i, sizeof(i), 0);
-						if (n < 0) {
-							break;
-						}
-					}
-				} else {
-					i_fd_owner *owner =
-						reinterpret_cast<i_fd_owner *>(events[i].data.ptr);
-					if (owner) {
-						owner->notify(events[i].events);
-					}
-				}
-			}
-		} while (nfds == MAX_EPOLL_EVENTS);
-
-		return true;
-	}
-
-public:
-	unix_event_port() : epoll_fd_{-1}, signal_fd_{-1} {
-		::signal(SIGPIPE, SIG_IGN);
-
-		epoll_fd_ = ::epoll_create1(EPOLL_CLOEXEC);
-		if (epoll_fd_ < 0) {
-			return;
-		}
-
-		::sigemptyset(&signal_fd_set_);
-		signal_fd_ =
-			::signalfd(-1, &signal_fd_set_, SFD_NONBLOCK | SFD_CLOEXEC);
-		if (signal_fd_ < 0) {
-			return;
-		}
-
-		struct epoll_event event;
-		memset(&event, 0, sizeof(event));
-		event.events = EPOLLIN;
-		event.data.u64 = 0;
-		::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, signal_fd_, &event);
-
-		int rc = ::pipe2(pipefds_, O_NONBLOCK | O_CLOEXEC);
-		if (rc < 0) {
-			return;
-		}
-		memset(&event, 0, sizeof(event));
-		event.events = EPOLLIN;
-		event.data.u64 = 1;
-		::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, pipefds_[0], &event);
-	}
-
-	~unix_event_port() {
-		::close(epoll_fd_);
-		::close(signal_fd_);
-		::close(pipefds_[0]);
-		::close(pipefds_[1]);
-	}
-
-	conveyor<void> on_signal(Signal signal) override {
-		auto caf = new_conveyor_and_feeder<void>();
-
-		signal_conveyors_.insert(std::make_pair(signal, std::move(caf.feeder)));
-
-		std::vector<int> sig = to_unix_signal(signal);
-
-		for (auto iter = sig.begin(); iter != sig.end(); ++iter) {
-			::sigaddset(&signal_fd_set_, *iter);
-		}
-		::sigprocmask(SIG_BLOCK, &signal_fd_set_, nullptr);
-		::signalfd(signal_fd_, &signal_fd_set_, SFD_NONBLOCK | SFD_CLOEXEC);
-
-		auto node = conveyor<void>::from_conveyor(std::move(caf.conveyor));
-		return conveyor<void>::to_conveyor(std::move(node));
-	}
-
-	void poll() override { poll_impl(0); }
-
-	void wait() override { poll_impl(-1); }
-
-	void wait(const std::chrono::steady_clock::duration &duration) override {
-		poll_impl(
-			std::chrono::duration_cast<std::chrono::milliseconds>(duration)
-				.count());
-	}
-	void
-	wait(const std::chrono::steady_clock::time_point &time_point) override {
-		auto now = std::chrono::steady_clock::now();
-		if (time_point <= now) {
-			poll();
-		} else {
-			poll_impl(std::chrono::duration_cast<std::chrono::milliseconds>(
-						  time_point - now)
-						  .count());
-		}
-	}
-
-	void wake() override {
-		/// @todo pipe() in the beginning and write something minor into it like
-		/// uint8_t or sth the value itself doesn't matter
-		if (pipefds_[1] < 0) {
-			return;
-		}
-		uint8_t i = 0;
-		::send(pipefds_[1], &i, sizeof(i), MSG_DONTWAIT);
-	}
-
-	void subscribe(i_fd_owner &owner, int fd, uint32_t event_mask) {
-		if (epoll_fd_ < 0 || fd < 0) {
-			return;
-		}
-		::epoll_event event;
-		memset(&event, 0, sizeof(event));
-		event.events = event_mask | EPOLLET;
-		event.data.ptr = &owner;
-
-		if (::epoll_ctl(epoll_fd_, EPOLL_CTL_ADD, fd, &event) < 0) {
-			/// @todo error_handling
-			return;
-		}
-	}
-
-	void unsubscribe(int fd) {
-		if (epoll_fd_ < 0 || fd < 0) {
-			return;
-		}
-		if (::epoll_ctl(epoll_fd_, EPOLL_CTL_DEL, fd, nullptr) < 0) {
-			/// @todo error_handling
-			return;
-		}
-	}
-};
-
-ssize_t unix_read(int fd, void *buffer, size_t length);
-ssize_t unix_write(int fd, const void *buffer, size_t length);
-
-class unix_io_stream final : public io_stream, public i_fd_owner {
-private:
-	own<conveyor_feeder<void>> read_ready_ = nullptr;
-	own<conveyor_feeder<void>> on_read_disconnect_ = nullptr;
-	own<conveyor_feeder<void>> write_ready_ = nullptr;
-
-public:
-	unix_io_stream(unix_event_port &event_port, int file_descriptor,
-				   int fd_flags, uint32_t event_mask);
-
-	error_or<size_t> read(void *buffer, size_t length) override;
-
-	conveyor<void> read_ready() override;
-
-	conveyor<void> on_read_disconnected() override;
-
-	error_or<size_t> write(const void *buffer, size_t length) override;
-
-	conveyor<void> write_ready() override;
-
-	/*
-		void read(void *buffer, size_t min_length, size_t max_length) override;
-		Conveyor<size_t> readDone() override;
-		Conveyor<void> readReady() override;
-
-		Conveyor<void> onReadDisconnected() override;
-
-		void write(const void *buffer, size_t length) override;
-		Conveyor<size_t> writeDone() override;
-		Conveyor<void> writeReady() override;
-	*/
-
-	void notify(uint32_t mask) override;
-};
-
-class unix_server final : public server, public i_fd_owner {
-private:
-	own<conveyor_feeder<own<io_stream>>> accept_feeder_ = nullptr;
-
-public:
-	unix_server(unix_event_port &event_port, int file_descriptor, int fd_flags);
-
-	conveyor<own<io_stream>> accept() override;
-
-	void notify(uint32_t mask) override;
-};
-
-class unix_datagram final : public datagram, public i_fd_owner {
-private:
-	own<conveyor_feeder<void>> read_ready_ = nullptr;
-	own<conveyor_feeder<void>> write_ready_ = nullptr;
-
-public:
-	unix_datagram(unix_event_port &event_port, int file_descriptor,
-				  int fd_flags);
-
-	error_or<size_t> read(void *buffer, size_t length) override;
-	conveyor<void> read_ready() override;
-
-	error_or<size_t> write(const void *buffer, size_t length,
-						   network_address &dest) override;
-	conveyor<void> write_ready() override;
-
-	void notify(uint32_t mask) override;
-};
-
-/**
- * Helper class which provides potential addresses to NetworkAddress
- */
-class socket_address {
-private:
-	union {
-		struct sockaddr generic;
-		struct sockaddr_un unix;
-		struct sockaddr_in inet;
-		struct sockaddr_in6 inet6;
-		struct sockaddr_storage storage;
-	} address_;
-
-	socklen_t address_length_;
-	bool wildcard_;
-
-	socket_address() : wildcard_{false} {}
-
-public:
-	socket_address(const void *sockaddr, socklen_t len, bool wildcard)
-		: address_length_{len}, wildcard_{wildcard} {
-		assert(len <= sizeof(address_));
-		memcpy(&address_.generic, sockaddr, len);
-	}
-
-	int socket(int type) const {
-		type |= SOCK_NONBLOCK | SOCK_CLOEXEC;
-
-		int result = ::socket(address_.generic.sa_family, type, 0);
-		return result;
-	}
-
-	bool bind(int fd) const {
-		if (wildcard_) {
-			int value = 0;
-			::setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &value, sizeof(value));
-		}
-		int error = ::bind(fd, &address_.generic, address_length_);
-		return error < 0;
-	}
-
-	struct ::sockaddr *get_raw() {
-		return &address_.generic;
-	}
-
-	const struct ::sockaddr *get_raw() const { return &address_.generic; }
-
-	socklen_t get_raw_length() const { return address_length_; }
-
-	static std::vector<socket_address> resolve(std::string_view str,
-											   uint16_t port_hint) {
-		std::vector<socket_address> results;
-
-		struct ::addrinfo *head;
-		struct ::addrinfo hints;
-		memset(&hints, 0, sizeof(hints));
-		hints.ai_family = AF_UNSPEC;
-
-		std::string port_string = std::to_string(port_hint);
-		bool wildcard = str == "*" || str == "::";
-		std::string address_string{str};
-
-		int error = ::getaddrinfo(address_string.c_str(), port_string.c_str(),
-								  &hints, &head);
-
-		if (error) {
-			return {};
-		}
-
-		for (struct ::addrinfo *it = head; it != nullptr; it = it->ai_next) {
-			if (it->ai_addrlen > sizeof(socket_address::address_)) {
-				continue;
-			}
-			results.push_back({it->ai_addr, it->ai_addrlen, wildcard});
-		}
-		::freeaddrinfo(head);
-		return results;
-	}
-};
-
-class unix_network_address final : public os_network_address {
-private:
-	const std::string path_;
-	uint16_t port_hint_;
-	std::vector<socket_address> addresses_;
-
-public:
-	unix_network_address(const std::string &path, uint16_t port_hint,
-						 std::vector<socket_address> &&addr)
-		: path_{path}, port_hint_{port_hint}, addresses_{std::move(addr)} {}
-
-	const std::string &address() const override;
-
-	uint16_t port() const override;
-
-	// Custom address info
-	socket_address &unix_address(size_t i = 0);
-	size_t unix_address_size() const;
-};
-
-class unix_network final : public network {
-private:
-	unix_event_port &event_port_;
-
-public:
-	unix_network(unix_event_port &event_port);
-
-	conveyor<own<network_address>>
-	resolve_address(const std::string &address,
-					uint16_t port_hint = 0) override;
-
-	own<server> listen(network_address &addr) override;
-
-	conveyor<own<io_stream>> connect(network_address &addr) override;
-
-	own<class datagram> datagram(network_address &addr) override;
-};
-
-class unix_io_provider final : public io_provider {
-private:
-	unix_event_port &event_port_;
-	class event_loop event_loop_;
-
-	unix_network unix_network_;
-
-public:
-	unix_io_provider(unix_event_port &port_ref, own<event_port> port);
-
-	class network &get_network() override;
-
-	own<input_stream> wrap_input_fd(int fd) override;
-
-	class event_loop &event_loop();
-};
-
-i_fd_owner::i_fd_owner(unix_event_port &event_port, int file_descriptor,
-					   int fd_flags, uint32_t event_mask)
-	: event_port_{event_port}, file_descriptor_{file_descriptor},
-	  fd_flags_{fd_flags}, event_mask_{event_mask} {
-	event_port_.subscribe(*this, file_descriptor, event_mask);
-}
-
-i_fd_owner::~i_fd_owner() {
-	if (file_descriptor_ >= 0) {
-		event_port_.unsubscribe(file_descriptor_);
-		::close(file_descriptor_);
-	}
-}
-
-ssize_t unix_read(int fd, void *buffer, size_t length) {
-	return ::recv(fd, buffer, length, 0);
-}
-
-ssize_t unix_write(int fd, const void *buffer, size_t length) {
-	return ::send(fd, buffer, length, 0);
-}
-
-unix_io_stream::unix_io_stream(unix_event_port &event_port, int file_descriptor,
-							   int fd_flags, uint32_t event_mask)
-	: i_fd_owner{event_port, file_descriptor, fd_flags,
-				 event_mask | EPOLLRDHUP} {}
-
-error_or<size_t> unix_io_stream::read(void *buffer, size_t length) {
-	ssize_t read_bytes = unix_read(fd(), buffer, length);
-	if (read_bytes > 0) {
-		return static_cast<size_t>(read_bytes);
-	} else if (read_bytes == 0) {
-		return make_error<err::disconnected>();
-	}
-
-	return make_error<err::resource_busy>();
-}
-
-conveyor<void> unix_io_stream::read_ready() {
-	auto caf = new_conveyor_and_feeder<void>();
-	read_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-conveyor<void> unix_io_stream::on_read_disconnected() {
-	auto caf = new_conveyor_and_feeder<void>();
-	on_read_disconnect_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-error_or<size_t> unix_io_stream::write(const void *buffer, size_t length) {
-	ssize_t write_bytes = unix_write(fd(), buffer, length);
-	if (write_bytes > 0) {
-		return static_cast<size_t>(write_bytes);
-	}
-
-	int error = errno;
-
-	if (error == EAGAIN || error == EWOULDBLOCK) {
-		return make_error<err::resource_busy>();
-	}
-
-	return make_error<err::disconnected>();
-}
-
-conveyor<void> unix_io_stream::write_ready() {
-	auto caf = new_conveyor_and_feeder<void>();
-	write_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-void unix_io_stream::notify(uint32_t mask) {
-	if (mask & EPOLLOUT) {
-		if (write_ready_) {
-			write_ready_->feed();
-		}
-	}
-
-	if (mask & EPOLLIN) {
-		if (read_ready_) {
-			read_ready_->feed();
-		}
-	}
-
-	if (mask & EPOLLRDHUP) {
-		if (on_read_disconnect_) {
-			on_read_disconnect_->feed();
-		}
-	}
-}
-
-unix_server::unix_server(unix_event_port &event_port, int file_descriptor,
-						 int fd_flags)
-	: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN} {}
-
-conveyor<own<io_stream>> unix_server::accept() {
-	auto caf = new_conveyor_and_feeder<own<io_stream>>();
-	accept_feeder_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-void unix_server::notify(uint32_t mask) {
-	if (mask & EPOLLIN) {
-		if (accept_feeder_) {
-			struct ::sockaddr_storage address;
-			socklen_t address_length = sizeof(address);
-
-			int accept_fd =
-				::accept4(fd(), reinterpret_cast<struct ::sockaddr *>(&address),
-						  &address_length, SOCK_NONBLOCK | SOCK_CLOEXEC);
-			if (accept_fd < 0) {
-				return;
-			}
-			auto fd_stream = heap<unix_io_stream>(event_port_, accept_fd, 0,
-												  EPOLLIN | EPOLLOUT);
-			accept_feeder_->feed(std::move(fd_stream));
-		}
-	}
-}
-
-unix_datagram::unix_datagram(unix_event_port &event_port, int file_descriptor,
-							 int fd_flags)
-	: i_fd_owner{event_port, file_descriptor, fd_flags, EPOLLIN | EPOLLOUT} {}
-
-namespace {
-ssize_t unix_read_msg(int fd, void *buffer, size_t length) {
-	struct ::sockaddr_storage their_addr;
-	socklen_t addr_len = sizeof(sockaddr_storage);
-	return ::recvfrom(fd, buffer, length, 0,
-					  reinterpret_cast<struct ::sockaddr *>(&their_addr),
-					  &addr_len);
-}
-
-ssize_t unix_write_msg(int fd, const void *buffer, size_t length,
-					   ::sockaddr *dest_addr, socklen_t dest_addr_len) {
-
-	return ::sendto(fd, buffer, length, 0, dest_addr, dest_addr_len);
-}
-} // namespace
-
-error_or<size_t> unix_datagram::read(void *buffer, size_t length) {
-	ssize_t read_bytes = unix_read_msg(fd(), buffer, length);
-	if (read_bytes > 0) {
-		return static_cast<size_t>(read_bytes);
-	}
-	return make_error<err::resource_busy>();
-}
-
-conveyor<void> unix_datagram::read_ready() {
-	auto caf = new_conveyor_and_feeder<void>();
-	read_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-error_or<size_t> unix_datagram::write(const void *buffer, size_t length,
-									  network_address &dest) {
-	unix_network_address &unix_dest = static_cast<unix_network_address &>(dest);
-	socket_address &sock_addr = unix_dest.unix_address();
-	socklen_t sock_addr_length = sock_addr.get_raw_length();
-	ssize_t write_bytes = unix_write_msg(fd(), buffer, length,
-										 sock_addr.get_raw(), sock_addr_length);
-	if (write_bytes > 0) {
-		return static_cast<size_t>(write_bytes);
-	}
-	return make_error<err::resource_busy>();
-}
-
-conveyor<void> unix_datagram::write_ready() {
-	auto caf = new_conveyor_and_feeder<void>();
-	write_ready_ = std::move(caf.feeder);
-	return std::move(caf.conveyor);
-}
-
-void unix_datagram::notify(uint32_t mask) {
-	if (mask & EPOLLOUT) {
-		if (write_ready_) {
-			write_ready_->feed();
-		}
-	}
-
-	if (mask & EPOLLIN) {
-		if (read_ready_) {
-			read_ready_->feed();
-		}
-	}
-}
-
-namespace {
-bool begins_with(const std::string_view &viewed,
-				 const std::string_view &begins) {
-	return viewed.size() >= begins.size() &&
-		   viewed.compare(0, begins.size(), begins) == 0;
-}
-
-std::variant<unix_network_address, unix_network_address *>
-translate_network_address_to_unix_network_address(network_address &addr) {
-	auto addr_variant = addr.representation();
-	std::variant<unix_network_address, unix_network_address *> os_addr =
-		std::visit(
-			[](auto &arg)
-				-> std::variant<unix_network_address, unix_network_address *> {
-				using T = std::decay_t<decltype(arg)>;
-
-				if constexpr (std::is_same_v<T, os_network_address *>) {
-					return static_cast<unix_network_address *>(arg);
-				}
-
-				auto sock_addrs = socket_address::resolve(
-					std::string_view{arg->address()}, arg->port());
-
-				return unix_network_address{arg->address(), arg->port(),
-											std::move(sock_addrs)};
-			},
-			addr_variant);
-	return os_addr;
-}
-
-unix_network_address &translate_to_unix_address_ref(
-	std::variant<unix_network_address, unix_network_address *> &addr_variant) {
-	return std::visit(
-		[](auto &arg) -> unix_network_address & {
-			using T = std::decay_t<decltype(arg)>;
-
-			if constexpr (std::is_same_v<T, unix_network_address>) {
-				return arg;
-			} else if constexpr (std::is_same_v<T, unix_network_address *>) {
-				return *arg;
-			} else {
-				static_assert(true, "Cases exhausted");
-			}
-		},
-		addr_variant);
-}
-
-} // namespace
-
-own<server> unix_network::listen(network_address &addr) {
-	auto unix_addr_storage =
-		translate_network_address_to_unix_network_address(addr);
-	unix_network_address &address =
-		translate_to_unix_address_ref(unix_addr_storage);
-
-	assert(address.unix_address_size() > 0);
-	if (address.unix_address_size() == 0) {
-		return nullptr;
-	}
-
-	int fd = address.unix_address(0).socket(SOCK_STREAM);
-	if (fd < 0) {
-		return nullptr;
-	}
-
-	int val = 1;
-	int rc = ::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
-	if (rc < 0) {
-		::close(fd);
-		return nullptr;
-	}
-
-	bool failed = address.unix_address(0).bind(fd);
-	if (failed) {
-		::close(fd);
-		return nullptr;
-	}
-
-	::listen(fd, SOMAXCONN);
-
-	return heap<unix_server>(event_port_, fd, 0);
-}
-
-conveyor<own<io_stream>> unix_network::connect(network_address &addr) {
-	auto unix_addr_storage =
-		translate_network_address_to_unix_network_address(addr);
-	unix_network_address &address =
-		translate_to_unix_address_ref(unix_addr_storage);
-
-	assert(address.unix_address_size() > 0);
-	if (address.unix_address_size() == 0) {
-		return conveyor<own<io_stream>>{make_error<err::critical>()};
-	}
-
-	int fd = address.unix_address(0).socket(SOCK_STREAM);
-	if (fd < 0) {
-		return conveyor<own<io_stream>>{make_error<err::disconnected>()};
-	}
-
-	own<unix_io_stream> io_str =
-		heap<unix_io_stream>(event_port_, fd, 0, EPOLLIN | EPOLLOUT);
-
-	bool success = false;
-	for (size_t i = 0; i < address.unix_address_size(); ++i) {
-		socket_address &addr_iter = address.unix_address(i);
-		int status =
-			::connect(fd, addr_iter.get_raw(), addr_iter.get_raw_length());
-		if (status < 0) {
-			int error = errno;
-			/*
-			 * It's not connected yet...
-			 * But edge triggered epolling means that it'll
-			 * be ready when the signal is triggered
-			 */
-
-			/// @todo Add limit node when implemented
-			if (error == EINPROGRESS) {
-				/*
-				Conveyor<void> write_ready = io_stream->writeReady();
-				return write_ready.then(
-					[ios{std::move(io_stream)}]() mutable {
-						ios->write_ready = nullptr;
-						return std::move(ios);
-					});
-				*/
-				success = true;
-				break;
-			} else if (error != EINTR) {
-				/// @todo Push error message from
-				return conveyor<own<io_stream>>{make_error<err::disconnected>()};
-			}
-		} else {
-			success = true;
-			break;
-		}
-	}
-
-	if (!success) {
-		return conveyor<own<io_stream>>{make_error<err::disconnected>()};
-	}
-
-	return conveyor<own<io_stream>>{std::move(io_str)};
-}
-
-own<datagram> unix_network::datagram(network_address &addr) {
-	auto unix_addr_storage =
-		translate_network_address_to_unix_network_address(addr);
-	unix_network_address &address =
-		translate_to_unix_address_ref(unix_addr_storage);
-
-	SAW_ASSERT(address.unix_address_size() > 0) { return nullptr; }
-
-	int fd = address.unix_address(0).socket(SOCK_DGRAM);
-
-	int optval = 1;
-	int rc =
-		::setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
-	if (rc < 0) {
-		::close(fd);
-		return nullptr;
-	}
-
-	bool failed = address.unix_address(0).bind(fd);
-	if (failed) {
-		::close(fd);
-		return nullptr;
-	}
-	/// @todo
-	return heap<unix_datagram>(event_port_, fd, 0);
-}
-
-const std::string &unix_network_address::address() const { return path_; }
-
-uint16_t unix_network_address::port() const { return port_hint_; }
-
-socket_address &unix_network_address::unix_address(size_t i) {
-	assert(i < addresses_.size());
-	/// @todo change from list to vector?
-	return addresses_.at(i);
-}
-
-size_t unix_network_address::unix_address_size() const {
-	return addresses_.size();
-}
-
-unix_network::unix_network(unix_event_port &event) : event_port_{event} {}
-
-conveyor<own<network_address>>
-unix_network::resolve_address(const std::string &path, uint16_t port_hint) {
-	std::string_view addr_view{path};
-	{
-		std::string_view str_begins_with = "unix:";
-		if (begins_with(addr_view, str_begins_with)) {
-			addr_view.remove_prefix(str_begins_with.size());
-		}
-	}
-
-	std::vector<socket_address> addresses =
-		socket_address::resolve(addr_view, port_hint);
-
-	return conveyor<own<network_address>>{
-		heap<unix_network_address>(path, port_hint, std::move(addresses))};
-}
-
-unix_io_provider::unix_io_provider(unix_event_port &port_ref,
-								   own<event_port> port)
-	: event_port_{port_ref}, event_loop_{std::move(port)}, unix_network_{
-															   port_ref} {}
-
-own<input_stream> unix_io_provider::wrap_input_fd(int fd) {
-	return heap<unix_io_stream>(event_port_, fd, 0, EPOLLIN);
-}
-
-class network &unix_io_provider::get_network() {
-	return static_cast<class network &>(unix_network_);
-}
-
-class event_loop &unix_io_provider::event_loop() {
-	return event_loop_;
-}
-
-} // namespace unix
-
-error_or<async_io_context> setup_async_io() {
-	using namespace unix;
-	try {
-		own<unix_event_port> prt = heap<unix_event_port>();
-		unix_event_port &prt_ref = *prt;
-
-		own<unix_io_provider> io_provider =
-			heap<unix_io_provider>(prt_ref, std::move(prt));
-
-		event_loop &loop_ref = io_provider->event_loop();
-
-		return {{std::move(io_provider), loop_ref, prt_ref}};
-	} catch (std::bad_alloc &) {
-		return make_error<err::out_of_memory>();
-	}
-}
-} // namespace saw
-#endif
-- 
cgit v1.2.3