#1 - quicr module

modules/io/include/NetworkError.hpp

@@ -0,0 +1,70 @@
+#pragma once
+
+#include <cerrno>
+#include <cstring>
+#include <string>
+namespace tw::net {
+
+
+enum NetworkErrorType {
+    MESSAGE_TOO_LONG = 90,
+    ADDRESS_FAMILY_NOT_SUPPORTED = 97,
+    BAD_FILE_DESCRIPTOR = 9,
+    CONNECTION_RESET = 104,
+    WOULD_BLOCK = 11,
+    INTERRUPED = 4,
+    INVALID_ARGUMENT = 22,
+    NOT_CONNECTED = 107,
+    NOT_SOCKET = 88,
+    OPERATION_NOT_SUPPORTED = 95,
+    TIMED_OUT = 110,
+    IO_ERROR = 5,
+    NO_BUFFER_SPACE = 105,
+    NOT_ENOUGH_MEMORY = 12,
+    DESTINATION_ADDRESS_REQUIRED = 89,
+    BROKEN_PIPE = 32
+};
+
+struct NetworkError {
+    NetworkErrorType m_type;
+
+public:
+    static NetworkError from_errno(int err) {
+        return { static_cast<NetworkErrorType>(err) };
+    }
+
+    std::string message() const {
+        switch (m_type) {
+            case BAD_FILE_DESCRIPTOR:
+                return "The socket is not a valid file descriptor";
+            case CONNECTION_RESET:
+                return "A connection was forcibly closed by a peer.";
+            case INTERRUPED:
+                return "The function was interrupted by a signal that was caught, before any data was available.";
+            case INVALID_ARGUMENT:
+                return "The MSG_OOB flag is set and no out-of-band data is available.";
+            case NOT_CONNECTED:
+                return "A function is attempted on connection-mode socket that is not connected.";
+            case NOT_SOCKET:
+                return "Socket operation on non-socket.";
+            case OPERATION_NOT_SUPPORTED:
+                return "The specified flags are not supported for this socket type or protocol.";
+            case TIMED_OUT:
+                return "The connection timed out during connection establishment, or due to a transmission timeout on active connection.";
+            case IO_ERROR:
+                return "An I/O error occurred while reading from or writing to the file system.";
+            case NO_BUFFER_SPACE:
+                return "Insufficient resources were available in the system to perform the operation.";
+            case NOT_ENOUGH_MEMORY:
+                return "Insufficient memory was available to complete the operation.";
+            case DESTINATION_ADDRESS_REQUIRED:
+                return "The destination address is required for this operation.";
+            case BROKEN_PIPE:
+                return "The write end of a pipe or socket has been closed.";
+            default:
+                return std::string(strerror(static_cast<int>(m_type)));
+        }
+    }
+};
+
+}

modules/io/include/bytebuffer/ByteBuffer.hpp

@@ -0,0 +1,126 @@
+#pragma once
+
+#include <cstring>
+#include <optional>
+#include <span>
+#include <spdlog/spdlog.h>
+#include <vector>
+
+namespace tw::net {
+
+/**
+ * Circular byte buffer.
+ */
+class RingByteBuffer {
+public:
+    RingByteBuffer(std::span<std::byte> target, bool is_for_reading) : buffer(target), writeOffset(is_for_reading ? target.size() : 0) {}
+
+    size_t peek_bytes(void* dst, size_t size, size_t offset = 0) {
+        if(remaining_read() - offset < size) {
+            return 0;
+        }
+
+        size_t cursor = (readOffset + offset) % buffer.size();
+
+        if(cursor + size <= buffer.size()) {
+            std::memcpy(dst, buffer.data() + cursor, size);
+        } else {
+            size_t firstPart = buffer.size() - cursor;
+            std::memcpy(dst, buffer.data() + cursor, firstPart);
+            std::memcpy((std::byte*)dst + firstPart, buffer.data(), size - firstPart);
+        }
+
+        return size;
+    }
+
+    template<typename T>
+    size_t pop_bytes(T* dst) {
+        return pop_bytes(dst, sizeof(T));
+    }
+
+    size_t pop_bytes(void* dst, size_t size) {
+        size_t peeked = peek_bytes(dst, size);
+        if(peeked < size) {
+            return 0;
+        }
+
+        skip(size);
+        return size;
+    }
+
+    size_t pop_bytes(std::span<std::byte> dst) {
+        return pop_bytes(dst.data(), dst.size());
+    }
+
+    template<typename T>
+    size_t write_bytes(const T *data) {
+        return write_bytes((void*)data, sizeof(T));
+    }
+
+    size_t write_bytes(void* data, size_t size) {
+        return write_bytes(std::span<const std::byte>{(std::byte*)data, (std::byte*)data + size});
+    }
+
+    size_t write_bytes(std::span<const std::byte> data) {
+        if(remaining_write() < data.size()) {
+            return 0;
+        }
+
+        if(writeOffset + data.size() <= buffer.size()) {
+            std::memcpy(buffer.data() + writeOffset, data.data(), data.size());
+            writeOffset += data.size();
+        } else {
+            size_t firstPart = buffer.size() - writeOffset;
+            std::memcpy(buffer.data() + writeOffset, data.data(), firstPart);
+            std::memcpy(buffer.data(), data.data() + firstPart, data.size() - firstPart);
+            writeOffset = (writeOffset + data.size()) % buffer.size();
+        }
+
+        return data.size();
+    }
+
+    size_t remaining_write() const {
+        if(writeOffset >= readOffset) {
+            return buffer.size() - writeOffset + readOffset;
+        } else {
+            return readOffset - writeOffset;
+        }
+    }
+
+    size_t remaining_read() const {
+        if(writeOffset >= readOffset) {
+            return writeOffset - readOffset;
+        }
+
+        return buffer.size() - readOffset + writeOffset;
+    }
+
+    void reset() {
+        readOffset = 0;
+        writeOffset = 0;
+    }
+
+    void skip(size_t bytes) {
+        readOffset = (readOffset + std::min(bytes, remaining_read())) % buffer.size();
+        spdlog::info("New read offset: {}", readOffset);
+    }
+
+    void skip_write(size_t bytes) {
+        writeOffset = (writeOffset + std::min(bytes, remaining_write())) % buffer.size();
+    }
+
+    std::span<std::byte> get_next_available_block() {
+        if (writeOffset >= readOffset) {
+            return std::span(buffer.data() + writeOffset, buffer.size() - writeOffset);
+        } else {
+            return std::span(buffer.data() + writeOffset, readOffset - writeOffset);
+        }
+    }
+
+private:
+    std::span<std::byte> buffer;
+    size_t readOffset = 0;
+    size_t writeOffset = 0;
+};
+
+} // namespace tw::net

modules/io/include/bytebuffer/ByteBufferCodec.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "bytebuffer/ByteBuffer.hpp"
+#include <type_traits>
+
+namespace tw::net {
+template<typename T, typename Enable = void>
+struct ByteBufferCodec
+{
+    static size_t encoding(RingByteBuffer&, T*, size_t offset)
+    {
+        static_assert(sizeof(T) == 0, "No decoder for this type");
+    }
+};
+
+/**
+ * Default implementation for trivially copyable types
+ */
+template<typename T>
+struct ByteBufferCodec<T, std::enable_if_t<std::is_trivially_copyable_v<T>>>
+{
+    static size_t encoding(RingByteBuffer& buf, T* target, size_t offset)
+    {
+        return buf.peek_bytes(target, sizeof(T), offset);
+    }
+};
+}

modules/io/include/bytebuffer/ByteBufferDecoder.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include "ByteBuffer.hpp"
+
+namespace tw::net {
+
+template<typename T, typename Enable = void>
+struct ByteBufferCodec
+{
+    static T bytes(RingByteBuffer&, size_t)
+    {
+        static_assert(sizeof(T) == 0, "No decoder for this type");
+    }
+};
+
+/**
+ * Default implementation for trivially copyable types
+ */
+template<typename T>
+struct ByteBufferCodec<T, std::enable_if_t<std::is_trivially_copyable_v<T>>>
+{
+    static std::optional<T> encoding(RingByteBuffer& buf, size_t offset = 0)
+    {
+        T value;
+        size_t r = buf.peek_bytes(&value, sizeof(T), offset);
+        if(r < sizeof(T)) {
+            return {};
+        }
+
+        return value;
+    }
+};
+
+struct ByteBufferDecoder {
+    ByteBufferDecoder(RingByteBuffer& buf) : m_buf(buf) {}
+
+    template<typename T>
+    std::optional<T> pop(size_t offset = 0)
+    {
+        std::optional<T> s = ByteBufferCodec<T>::bytes(m_buf, offset);
+        m_buf.skip(sizeof(T));
+
+        return s;
+    }
+
+    template<typename T>
+    std::optional<T> peek(size_t offset = 0) {
+        return ByteBufferCodec<T>::bytes(m_buf, offset);
+    }
+
+private:
+    RingByteBuffer& m_buf;
+};
+
+}

modules/io/include/bytebuffer/ByteBufferEncoder.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ByteBuffer.hpp"
+#include "bytebuffer/ByteBufferCodec.hpp"
+
+namespace tw::net {
+
+
+struct ByteBufferDecoder {
+    ByteBufferDecoder(RingByteBuffer& buf) : m_buf(buf) {}
+
+    template<typename T>
+    std::optional<T> push(size_t offset = 0)
+    {
+        std::optional<T> s = ByteBufferCodec<T>::bytes(m_buf, offset);
+        m_buf.skip(sizeof(T));
+
+        return s;
+    }
+
+private:
+    RingByteBuffer& m_buf;
+};
+
+}

modules/io/include/bytebuffer/ByteBufferReader.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <cstring>
+#include <span>
+#include <spdlog/spdlog.h>
+
+namespace tw::net {
+
+/**
+ * Circular byte buffer.
+ */
+class ByteBufferReader {
+public:
+    ByteBufferReader(std::span<std::byte> target) : buffer(target), readOffset(0) {}
+
+    ByteBufferReader(std::span<const std::byte> target) : buffer(target), readOffset(0) {}
+
+    size_t peek_bytes(void* dst, size_t size, size_t offset = 0) {
+        if(remaining() - offset < size) {
+            spdlog::warn("Could not peek entire frame, remaining: {}/{}", remaining() - offset, size);
+            return 0;
+        }
+
+        size_t cursor = readOffset + offset;
+
+        // if(cursor + size <= buffer.size()) {
+        std::memcpy(dst, buffer.data() + cursor, size);
+        // } else {
+        //     size_t firstPart = buffer.size() - cursor;
+        //     std::memcpy(dst, buffer.data() + cursor, firstPart);
+        //     std::memcpy((std::byte*)dst + firstPart, buffer.data(), size - firstPart);
+        // }
+
+        return size;
+    }
+
+    template<typename T>
+    size_t pop_bytes(T* dst) {
+        return pop_bytes(dst, sizeof(T));
+    }
+
+    size_t pop_bytes(void* dst, size_t size) {
+        size_t peeked = peek_bytes(dst, size);
+        if(peeked < size) {
+            spdlog::warn("Could not read entire frame, peeked only: {}/{}", peeked, size);
+            return 0;
+        }
+
+        skip(size);
+        return size;
+    }
+
+    size_t pop_bytes(std::span<std::byte> dst) {
+        return pop_bytes(dst.data(), dst.size());
+    }
+
+    size_t position() const {
+        return readOffset;
+    }
+
+    size_t remaining() const {
+        return buffer.size() - readOffset;
+    }
+
+    void reset() {
+        readOffset = 0;
+    }
+
+    void skip(size_t bytes) {
+        readOffset = (readOffset + std::min(bytes, remaining()));
+    }
+
+private:
+    std::span<const std::byte> buffer;
+    size_t readOffset = 0;
+};
+
+} // namespace tw::net

modules/io/include/bytebuffer/ByteBufferStreamReader.hpp

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "io/Read.hpp"
+#include "ByteBuffer.hpp"
+
+namespace tw::net {
+
+class ByteBufferStreamReader {
+public:
+    static size_t read(Read<std::byte>* from, RingByteBuffer* to) {
+        auto block = to->get_next_available_block();
+        auto r = from->read_into(block);
+        if(!r || *r == 0) {
+            return 0;
+        }
+
+        to->skip_write(*r);
+
+        if(*r == block.size()) {
+            auto next_block = to->get_next_available_block();
+            if(next_block.size() == 0) {
+                return *r;
+            }
+
+            auto r2 = from->read_into(next_block);
+            if(!r2 || *r2 == 0) {
+                return *r;
+            }
+
+            to->skip_write(*r2);
+            return *r + *r2;
+        }
+
+        return *r;
+    }
+};
+
+}

modules/io/include/bytebuffer/ByteBufferWriter.hpp

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <cstring>
+#include <span>
+#include <spdlog/spdlog.h>
+
+namespace tw::net {
+
+/**
+ * Circular byte buffer.
+ */
+class ByteBufferWriter {
+public:
+    ByteBufferWriter(std::span<std::byte> target) : buffer(target) {}
+
+    template<typename T>
+    size_t write_bytes(const T *data) {
+        return write_bytes((void*)data, sizeof(T));
+    }
+
+    size_t write_bytes(void* data, size_t size) {
+        return write_bytes(std::span<const std::byte>{(std::byte*)data, (std::byte*)data + size});
+    }
+
+    size_t write_bytes(std::span<const std::byte> data) {
+        if(remaining() < data.size()) {
+            return 0;
+        }
+
+        if(writeOffset + data.size() <= buffer.size()) {
+            std::memcpy(buffer.data() + writeOffset, data.data(), data.size());
+            writeOffset += data.size();
+        } else {
+            size_t firstPart = buffer.size() - writeOffset;
+            std::memcpy(buffer.data() + writeOffset, data.data(), firstPart);
+            std::memcpy(buffer.data(), data.data() + firstPart, data.size() - firstPart);
+            writeOffset = (writeOffset + data.size()) % buffer.size();
+        }
+
+        return data.size();
+    }
+
+    constexpr size_t length() const {
+        return writeOffset;
+    }
+
+    size_t remaining() const {
+        return buffer.size() - writeOffset;
+    }
+
+    void reset() {
+        writeOffset = 0;
+    }
+
+    void skip_write(size_t bytes) {
+        writeOffset = (writeOffset + std::min(bytes, remaining()));
+    }
+
+private:
+    std::span<std::byte> buffer;
+    size_t writeOffset = 0;
+};
+
+} // namespace tw::net

modules/io/include/exception/ByteBufferOverflowException.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <exception>
+
+namespace tw::net {
+
+class ByteBufferOverflowException : public std::exception {
+    const char* what() const noexcept override {
+        return "Byte buffer overflow";
+    }
+};
+
+}

modules/io/include/io/BufferReader.hpp

@@ -0,0 +1,65 @@
+#pragma once
+
+#include "Read.hpp"
+
+#include <spdlog/spdlog.h>
+#include <vector>
+
+namespace tw::net {
+
+template<typename T>
+class BufferReader : public Read<T> {
+    Read<T>* m_readable;
+
+    std::vector<T> m_buffer;
+
+    size_t m_head;
+    size_t m_tail;
+
+    size_t remaining_size() {
+        return m_head - m_tail;
+    }
+
+public:
+    BufferReader(Read<T>* readable, size_t buffer_size) :
+        m_readable(readable),
+        m_buffer(buffer_size),
+        m_head(0),
+        m_tail(0) {
+
+    }
+
+    size_t read(std::span<T> target) override {
+        size_t read_size = std::min(remaining_size(), target.size());
+        std::copy(m_buffer.begin() + m_tail,
+                m_buffer.begin() + m_tail + read_size,
+                target.begin());
+
+        spdlog::info("Read {} bytes", read_size);
+
+        m_tail += read_size;
+
+        // read next chunk
+        if(m_tail == m_head && read_size < target.size()) {
+            spdlog::info("Reading next chunk");
+            m_head = m_readable->read(std::span<T>(m_buffer.begin(), m_buffer.end()));
+            m_tail = 0;
+        }
+
+        if(target.size() > read_size && m_head > 0) {
+            read_size += read(std::span<T>(target.begin() + read_size, target.end()));
+        }
+
+        return read_size;
+    }
+
+    std::optional<T> peek() {
+        if(remaining_size() > 0) {
+            return m_buffer[m_tail];
+        }
+
+        return std::nullopt;
+    }
+};
+
+}

modules/io/include/io/BufferWriter.hpp

@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstdint>
+#include <cstddef>
+#include <vector>
+
+#include "Write.hpp"
+
+namespace tw::net {
+
+template<typename T>
+class BufferWriter : public Write<T> {
+private:
+    Write<T>* m_writeable;
+    std::vector<T> m_buffer;
+    uint32_t m_head;
+
+public:
+    size_t remaining_size() {
+        return m_buffer.size() - m_head;
+    }
+
+    BufferWriter(Write<T>* writeable, size_t buffer_size) :
+        m_writeable(writeable),
+        m_buffer(buffer_size),
+        m_head(0)
+    { }
+
+    virtual size_t write(std::span<T> data) override {
+        if(remaining_size() < data.size()) {
+            size_t write_size = flush();
+            write_size += m_writeable->write_into(data);
+            m_head = 0;
+
+            return write_size;
+        }
+
+        std::copy(data.begin(), data.end(), m_buffer.begin() + m_head);
+        size_t write_size = data.size();
+
+        m_head += data.size();
+
+        return write_size;
+    }
+
+    virtual size_t flush() override {
+        m_writeable->write_into(std::span<T>(m_buffer.begin(), m_buffer.begin() + m_head));
+        size_t write_size = m_head;
+        m_head = 0;
+
+        return write_size;
+    }
+};
+
+}

modules/io/include/io/Read.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "NetworkError.hpp"
+#include "tl/expected.hpp"
+#include <span>
+
+namespace tw::net {
+
+template<typename T>
+class Read {
+public:
+    virtual ~Read() = default;
+    virtual tl::expected<size_t, NetworkError> read_into(std::span<T> target) = 0;
+
+    tl::expected<size_t, NetworkError> read_exact_into(std::span<std::byte> data) {
+        size_t total_read = 0;
+        while (total_read < data.size()) {
+            auto read = this->read_into(data.subspan(total_read));
+            if(!read.has_value()) {
+                if(read.error().m_type == NetworkErrorType::WOULD_BLOCK) {
+                    continue;
+                } else {
+                    return read;
+                }
+            }
+
+            total_read += read.value();
+        }
+        return total_read;
+    }
+
+    tl::expected<std::vector<std::byte>, NetworkError> read_exact(size_t size) {
+        std::vector<std::byte> buffer(size);
+        auto result = this->read_exact_into(std::span{buffer});
+
+        if(result.has_value()) {
+            return buffer;
+        }
+
+        return tl::make_unexpected(result.error());
+    }
+
+};
+
+}

modules/io/include/io/Write.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "NetworkError.hpp"
+#include <tl/expected.hpp>
+#include <limits>
+#include <span>
+#include <string>
+#include <type_traits>
+
+namespace tw::net {
+
+template<typename T>
+class Write {
+public:
+    virtual ~Write() = default;
+
+    virtual tl::expected<size_t, NetworkError> write(std::span<T> data) = 0;
+
+    tl::expected<size_t, NetworkError> write(const std::string& data) {
+        return write(std::span<std::byte>((std::byte*)(data.c_str()), data.size()));
+    }
+
+    template<typename TNum,
+        typename std::enable_if_t<std::is_integral<TNum>::value || std::is_enum<TNum>::value, bool> = true>
+    tl::expected<size_t, NetworkError> write(TNum data) {
+        return write(std::as_writable_bytes(std::span{&data, 1}));
+    }
+
+    virtual size_t flush() = 0;
+};
+
+}