io.hpp

// SPDX-License-Identifier: LGPL-3.0-or-later
// Copyright © 2020 Florian Fischer
#pragma once

#include <sys/socket.h>
#include <sys/types.h>

#include <cassert>
#include <cstddef>
#include <functional>
#include <memory>
#include <string>

#include "io/Future.hpp"	// IWYU pragma: keep
#include "io/IoContext.hpp"

#ifndef NDEBUG
#include "Runtime.hpp"
#endif

/*
 * Header defining the public POSIX-like IO interface of emper.
 * All functions defined in this header must be used inside a fiber.
 * The emper IoContext to handle the IO request will be the one setup by the
 * Runtime and returned by IoContext::getCurrentIo().
 */

class Fiber;

namespace emper::io {
/**
 * @brief non-blocking recv mimicking POSIX recv(3)
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param buffer destination buffer
 * @param length length of the message in bytes
 * @param flags type of message reception
 *
 * @return Future object which signals the completion of the recv request
 */
inline auto recv(int socket, void *buffer, size_t length, int flags) -> std::unique_ptr<Future> {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->recv(socket, buffer, length, flags);
}

/**
 * @brief Blocking recv mimicking POSIX recv(3)
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param buffer destination buffer
 * @param length length of the message in bytes
 * @param flags type of message reception

 * @return -1 on error, 0 when receiving from a closed socket, otherwise the received bytes
 */
inline auto recvAndWait(int socket, void *buffer, size_t length, int flags) -> ssize_t {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->recvAndWait(socket, buffer, length, flags);
}

/**
 * @brief Non-blocking send mimicking POSIX send(3)
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param buffer source buffer
 * @param length length of the message in bytes
 * @param flags type of message transmission
 *
 * @return Future object which signals the completion of the send request
 */
inline auto send(int socket, const void *buffer, size_t length, int flags)
		-> std::unique_ptr<Future> {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->send(socket, buffer, length, flags);
}

/**
 * @brief Blocking send mimicking POSIX send(3)
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param buffer source buffer
 * @param length length of the message in bytes
 * @param flags type of message transmission
 *
 * @return -1 on error, otherwise the number of sent bytes
 */
inline auto sendAndWait(int socket, const void *buffer, size_t length, int flags) -> ssize_t {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->sendAndWait(socket, buffer, length, flags);
}

/**
 * @brief Non-blocking connect mimicking POSIX connect(3)
 *
 * It is discouraged to call connect on a socket with the SOCK_NONBLOCK flag set
 * because the request submitted to io_uring will immediately be completed
 * with EINPROGESS or EALREADY and must be repeatedly reinserted into the submission
 * queue and io_uring afterwards.
 * To efficiently connect a socket don't set its SOCK_NONBLOCK flag.
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param address buffer containing the address to connect to
 * @param address_len length of the sockaddr structure
 *
 * @return Future object which signals the completion of the connect request
 */
inline auto connect(int socket, const struct sockaddr *address, socklen_t address_len)
		-> std::unique_ptr<Future> {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->connect(socket, address, address_len);
}

/**
 * @brief Blocking connect mimicking POSIX connect(3)
 *
 * It is discouraged to call connect on a socket with the SOCK_NONBLOCK flag set
 * because the request submitted to io_uring will immediately be completed
 * with EINPROGESS or EALREADY and must be repeatedly reinserted into the submission
 * queue and io_uring afterwards.
 * To efficiently connect a socket don't set its SOCK_NONBLOCK flag.
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param address buffer containing the address to connect to
 * @param address_len length of the sockaddr structure
 *
 * @return -1 on error, 0 otherwise
 */
inline auto connectAndWait(int socket, const struct sockaddr *address, socklen_t address_len)
		-> int {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->connectAndWait(socket, address, address_len);
}

/**
 * @brief Non-blocking accept mimicking POSIX accept(3)
 *
 * It is discouraged to call accept on a socket with the SOCK_NONBLOCK flag set
 * because the request submitted to io_uring will immediately be completed
 * with EAGAIN or EWOULDBLOCK and must be repeatedly reinserted into the submission
 * queue and io_uring afterwards.
 * To efficiently accept new connections don't set the SOCK_NONBLOCK flag.
 *
 * If emper is build with the meson option 'io_try_syscall' after a new connection
 * is accepted the SOCK_NONBLOCK flag on the returned socket will be set to enable
 * future non-blocking recv or send syscalls.
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param[out] address buffer to store the clients address
 * @param[in, out] address_len length of the supplied sockaddr structure
 *
 * @return Future object which signals the completion of the accept request
 */
inline auto accept(int socket, struct sockaddr *address, socklen_t *address_len)
		-> std::unique_ptr<Future> {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->accept(socket, address, address_len);
}

/**
 * @brief Blocking accept mimicking POSIX accept(3)
 *
 * It is discouraged to call accept on a socket with the SOCK_NONBLOCK flag set
 * because the request submitted to io_uring will immediately be completed
 * with EAGAIN or EWOULDBLOCK and must be repeatedly reinserted into the submission
 * queue and io_uring afterwards.
 * To efficiently accept new connections don't set the SOCK_NONBLOCK flag.
 *
 * If emper is build with the meson option 'io_try_syscall' after a new connection
 * is accepted the SOCK_NONBLOCK flag on the returned socket will be set to enable
 * future non-blocking recv or send syscalls.
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param socket file descriptor for this operation
 * @param[out] address buffer to store the clients address
 * @param[in, out] address_len length of the supplied sockaddr structure
 *
 * @return -1 on error, otherwise the non-negative file descriptor of the accepted socket.
 */
inline auto acceptAndWait(int socket, struct sockaddr *address, socklen_t *address_len) -> int {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->acceptAndWait(socket, address, address_len);
}

/**
 * @brief Non-blocking read for regular files mimicking POSIX read(3)
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param fildes file descriptor to the regular file to be read from
 * @param buf destination buffer
 * @param nbyte amount of bytes to read
 * @param offset offset in the file
 *
 * @return Future object which signals the completion of the read request
 */
inline auto readFile(int fildes, void *buf, size_t nbyte, off_t offset = 0)
		-> std::unique_ptr<Future> {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->readFile(fildes, buf, nbyte, offset);
}

/**
 * @brief Blocking read for regular files mimicking POSIX read(3)
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param fildes file descriptor to the regular file to be written to
 * @param buf destination buffer
 * @param nbyte amount of bytes to read
 * @param offset offset in the file
 *
 * @return -1 on error, otherwise the number of bytes read
 */
inline auto readFileAndWait(int fildes, void *buf, size_t nbyte, off_t offset = 0) -> ssize_t {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->readFileAndWait(fildes, buf, nbyte, offset);
}

/**
 * @brief Non-blocking write for regular files mimicking POSIX write(3)
 *
 * Currently only reading from regular files is tested and supported.
 * Reading from other file types could work but may result in undefined behavior.
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param fildes file descriptor to the regular file to be written to
 * @param buf source buffer
 * @param nbyte amount of bytes to write
 * @param offset offset in the file
 *
 * @return Future object which signals the completion of the write request
 */
inline auto writeFile(int fildes, const void *buf, size_t nbyte, off_t offset = 0)
		-> std::unique_ptr<Future> {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->writeFile(fildes, buf, nbyte, offset);
}

/**
 * @brief Blocking write for regular files mimicking POSIX write(3)
 *
 * Currently only writing to regular files is tested and supported.
 * Writing to other file types could work but may result in undefined behavior.
 *
 * This method must be called from inside the emper runtime because it uses
 * the worker-local IoContext
 *
 * @param fildes file descriptor to the regular file to be written to
 * @param buf source buffer
 * @param nbyte amount of bytes to write
 * @param offset offset in the file
 *
 * @return -1 on error, otherwise the number of bytes written
 */
inline auto writeFileAndWait(int fildes, const void *buf, size_t nbyte, off_t offset = 0)
		-> ssize_t {
	assert(Runtime::inRuntime());
	IoContext *io = IoContext::getWorkerIo();
	return io->writeFileAndWait(fildes, buf, nbyte, offset);
}

/**
 * @brief Fiber accepting TCP connections and scheduling handler fibers
 *
 * @param host The host address the socket should be listening on
 * @param port The port the socket should be listening on
 * @param handler A function or lambda the started handler Fibers should execute.
 *        It is called with the file descriptor returned by accept.
 * @param backlog The TCP connection backlog.
 *
 * @return nullptr on error, otherwise the TCP listener Fiber
 */
auto tcp_listener(std::string &host, int &port, const std::function<void(int)> &handler,
									int backlog = 1024) -> Fiber *;

}	 // namespace emper::io