Martas/Towards
1
0
Fork 0
Code Issues 7 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

#1 - quicr module

Browse Source
This commit is contained in:
Martin Slachta
2026-07-22 17:34:44 +02:00
parent a04f0dc262
commit f4174eb0c7
177 changed files with 5309 additions and 2265 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/network/include/NetworkError.hpp
-70
View File
@@ -1,70 +0,0 @@
#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/network/include/bytebuffer/ByteBuffer.hpp
-126
View File
@@ -1,126 +0,0 @@
#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/network/include/bytebuffer/ByteBufferCodec.hpp
-27
View File
@@ -1,27 +0,0 @@
#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/network/include/bytebuffer/ByteBufferDecoder.hpp
-55
View File
@@ -1,55 +0,0 @@
#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/network/include/bytebuffer/ByteBufferEncoder.hpp
-25
View File
@@ -1,25 +0,0 @@
#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/network/include/bytebuffer/ByteBufferReader.hpp
-78
View File
@@ -1,78 +0,0 @@
#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/network/include/bytebuffer/ByteBufferStreamReader.hpp
-38
View File
@@ -1,38 +0,0 @@
#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/network/include/bytebuffer/ByteBufferWriter.hpp
-64
View File
@@ -1,64 +0,0 @@
#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/network/include/exception/ByteBufferOverflowException.hpp
-13
View File
@@ -1,13 +0,0 @@
#pragma once
#include <exception>
namespace tw::net {
class ByteBufferOverflowException : public std::exception {
const char* what() const noexcept override {
return "Byte buffer overflow";
}
};
}
modules/network/include/frames/Frame.hpp
+1 -1
View File
@@ -1,7 +1,7 @@
#pragma once
#include "common.hpp"
#include "protocol/quicr/QuicrFrameType.hpp"
#include "quicr/QuicrFrameType.hpp"
#include <cstddef>
#include <vector>
modules/network/include/io/BufferReader.hpp
-65
View File
@@ -1,65 +0,0 @@
#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/network/include/io/BufferWriter.hpp
-55
View File
@@ -1,55 +0,0 @@
#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/network/include/io/Read.hpp
-45
View File
@@ -1,45 +0,0 @@
#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/network/include/io/Write.hpp
-32
View File
@@ -1,32 +0,0 @@
#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;
};
}
modules/network/include/messenger/MessageHandler.hpp
-168
View File
@@ -1,168 +0,0 @@
#pragma once
#include <concepts>
#include <functional>
#include <google/protobuf/message.h>
#include <span>
#include "Address.hpp"
#include "Messenger.hpp"
#include "NetworkError.hpp"
#include "TcpStream.hpp"
#include "packets/Packet.hpp"
#include "packets/LoginPacket.hpp"
#include "protocol/quicr/QuicrConnection.hpp"
namespace tw::net {
/**
* Contains handlers for each message type. Calls this handler when message comes in.
*/
class MessageHandler {
private:
// std::optional<Messenger<std::byte, quicr::QuicrConnection>> m_quicr_messenger;
// Messenger<std::byte, TcpStream> m_server_messenger;
std::unique_ptr<quicr::QuicrEndpoint> m_quicr_endpoint;
quicr::QuicrConnection* m_quicr_connection;
std::vector<std::function<tl::expected<void, NetworkError>(std::span<std::byte>)>> m_handlers;
std::unique_ptr<quicr::QuicrEndpoint> create_endpoint() {
auto endpoint_r = quicr::QuicrEndpoint::create();
if(!endpoint_r) {
spdlog::error("Failed to create QuicrEndpoint: {}", endpoint_r.error().message());
throw std::runtime_error("Failed to create QuicrEndpoint");
}
return std::make_unique<quicr::QuicrEndpoint>(std::move(endpoint_r.value()));
}
public:
const bool is_connected() const {
return m_quicr_connection->state() == quicr::QuicrConnectionState::Established;
}
MessageHandler(MessageHandler&& m)
// : m_server_messenger{std::move(m.m_server_messenger)},
:
m_handlers(std::move(m.m_handlers)),
m_quicr_endpoint(std::move(m.m_quicr_endpoint)),
m_quicr_connection(m.m_quicr_connection) {
}
MessageHandler(Address address) :
m_quicr_endpoint(create_endpoint()),
m_quicr_connection(m_quicr_endpoint->connect(address).value()),
m_handlers(100) {
spdlog::info("Connected to server at {}", address.to_string());
}
// MessageHandler(Messenger<std::byte, TcpStream>&& server_messenger) :
// // m_server_messenger{std::move(server_messenger)},
// m_quicr_connection(std::move(server_messenger.connection())),
// m_handlers(100) {
// }
template<typename T>
constexpr void set_handler(const std::function<void(T*)> handler) {
PacketType type = Message<T>::value;
m_handlers[type] = [handler, this](std::span<std::byte> data) -> tl::expected<void, NetworkError> {
T result = {};
result.ParseFromArray(data.data(), data.size());
// spdlog::info("Deserialized message [{}]: {}", (int32_t)Message<T>::value, result.DebugString());
handler(&result);
// if(m_server_messenger.peek().has_value() && m_server_messenger.peek().value() == Message<T>::value) {
// tl::expected<T, NetworkError> mesg = m_server_messenger.pop<T>(nullptr);
// if(!mesg.has_value()) {
// return tl::make_unexpected(mesg.error());
// }
// handler(&mesg.value());
// }
return {};
};
}
constexpr void set_raw_handler(uint32_t type, const std::function<tl::expected<void, NetworkError>(std::span<std::byte>)> handler) {
m_handlers[type] = handler;
}
void update() {
m_quicr_endpoint->poll();
while(true) {
std::vector<std::byte> buffer(64 * 1024);
auto read_r = m_quicr_connection->read_into(buffer);
if(!read_r) {
spdlog::error("Failed to read from QUICr stream: {}", read_r.error().message());
break;
}
if(*read_r == 0) {
break;
}
uint32_t type = reinterpret_cast<uint32_t*>(buffer.data())[0];
if(m_handlers[type] == nullptr) {
spdlog::warn("Unknown message type: {}", type);
throw std::runtime_error("Unknown message type: {}");
break;
}
auto handler_r = m_handlers[type](std::span<std::byte>(buffer.data(), *read_r).subspan(sizeof(uint32_t)));
if(!handler_r) {
spdlog::error("Handler error");
break;
}
}
// while(m_server_messenger.peek().has_value() && m_server_messenger.peek().value().has_value()) {
// std::optional<PacketType> type = m_server_messenger.peek().value();
// if(type >= m_handlers.size() || m_handlers[type.value()] == nullptr) {
// spdlog::warn("Unknown message type: {}", (int)type.value());
// break;
// }
// auto r = m_handlers[type.value()]();
// if(!r) {
// spdlog::error("Failed to handle message: {}", r.error().message());
// }
// }
}
template<std::derived_from<google::protobuf::Message> T>
tl::expected<size_t, NetworkError> send(T& mesg) {
std::string payload;
if(!mesg.SerializeToString(&payload)) {
spdlog::error("Failed to serialize message");
return 0;
}
int32_t length = payload.length();
if(length == 0) {
return 0;
}
std::vector<std::byte> bytes(length + sizeof(uint32_t));
uint32_t type = Message<T>::value;
auto payload_bytes = std::as_writable_bytes(std::span(payload));
memcpy(bytes.data(), &type, sizeof(type));
memcpy(bytes.data() + sizeof(uint32_t), payload_bytes.data(), payload_bytes.size());
auto send_r = m_quicr_connection->send_message(bytes, false);
if(!send_r) {
spdlog::error("Failed to send message: {}", send_r.error().message());
return 0;
}
return payload_bytes.size();
}
};
}
modules/network/include/messenger/Messenger.hpp
-209
View File
@@ -1,209 +0,0 @@
#pragma once
#include <immintrin.h>
#include <optional>
#include <span>
#include <google/protobuf/message.h>
#include <google/protobuf/io/zero_copy_stream_impl.h>
#include <tracy/Tracy.hpp>
#include "NetworkError.hpp"
#include "packets/Packet.hpp"
#include "MessageRegistry.hpp"
#include "protocol/quicr/QuicrFrameType.hpp"
#include "tl/expected.hpp"
namespace tw::net {
template<typename TData, std::derived_from<Write<TData>> TOutput>
class Messenger {
private:
const uint32_t MAX_MESG_BODY_SIZE = 65536;
const uint32_t MESG_MAGIC = 0x1DEADBEE;
TOutput m_stream;
std::optional<PacketType> m_next_packet_type;
bool m_is_skipping;
uint32_t m_buffered_size;
size_t m_mesg_size;
size_t m_read_head;
std::vector<std::byte> m_input_buffer;
public:
Messenger(Messenger && m) :
m_stream(std::move(m.m_stream)),
m_next_packet_type(m.m_next_packet_type),
m_input_buffer(std::move(m.m_input_buffer)),
m_buffered_size(m.m_buffered_size),
m_is_skipping(m.m_is_skipping),
m_mesg_size(m.m_mesg_size),
m_read_head(m.m_read_head)
{
// m_stream.set_non_blocking();
}
Messenger(TOutput&& stream) :
m_stream(std::move(stream)),
m_input_buffer(MAX_MESG_BODY_SIZE),
m_buffered_size(0),
m_is_skipping(false),
m_mesg_size(0),
m_read_head(0)
{
// m_stream.set_non_blocking();
}
Messenger<TData, TOutput> operator=(const Messenger<TData, TOutput>&) = delete;
Messenger<TData, TOutput> operator=(Messenger<TData, TOutput>&& m) {
m_stream = std::move(m.m_stream);
m_next_packet_type = m.m_next_packet_type;
m_input_buffer = std::move(m.m_input_buffer);
m_buffered_size = m.m_buffered_size;
m_is_skipping = m.m_is_skipping;
m_mesg_size = m.m_mesg_size;
m_read_head = m.m_read_head;
}
template <std::derived_from<google::protobuf::Message> T>
tl::expected<size_t, NetworkError> send(T &content) {
ZoneScopedN("Messenger::send");
auto id = (int32_t)Message<T>::value;
std::string payload;
if(!content.SerializeToString(&payload)) {
spdlog::error("Failed to serialize message");
throw std::runtime_error("Serialization failed");
}
// spdlog::info("Sending {}: {}", (int)Message<T>::value, content.DebugString());
int32_t length = payload.length();
if(length == 0) {
return 0;
}
// append encoded id & length before payload and write it to the stream
//
const uint32_t HEADER_SIZE = 4 + 4 + 4 + 4;
std::string message;
message.resize(HEADER_SIZE + payload.length());
const uint32_t magic = 0xDEADBEEF;
const uint32_t frame_type = quicr::FrameType::StreamBase;
std::memcpy(message.data(), &magic, sizeof(magic));
std::memcpy(message.data() + sizeof(magic), &frame_type, sizeof(frame_type));
std::memcpy(message.data() + sizeof(frame_type) + sizeof(magic), &length, sizeof(length));
std::memcpy(message.data() + sizeof(frame_type) + sizeof(magic) + sizeof(length), &id, sizeof(id));
// std::memcpy(message.data() + sizeof(id) + sizeof(length), &MESG_MAGIC, sizeof(MESG_MAGIC));
std::memcpy(message.data() + HEADER_SIZE, payload.data(), payload.length());
auto write_result = m_stream.write(std::as_writable_bytes(std::span(message)));
if(!write_result.has_value()) {
return tl::make_unexpected(write_result.error());
}
return write_result.value();
}
int32_t m_packet_peek_size = 0;
tl::expected<std::optional<PacketType>, NetworkError> peek() {
ZoneScopedN("Messenger::peek");
if(m_next_packet_type.has_value()) {
return m_next_packet_type;
}
if(m_read_head < 4) {
auto result = m_stream.read_into(std::as_writable_bytes(std::span{(char*)m_input_buffer.data(), sizeof(PacketType) - m_read_head}));
if(!result.has_value()) {
return tl::make_unexpected(result.error());
}
m_read_head += result.value();
if(m_read_head < 4) {
return {};
}
}
if(m_read_head < 8) {
auto result = m_stream.read_into(std::as_writable_bytes(std::span{(char*)m_input_buffer.data() + m_read_head, 8 - m_read_head}));
if(!result.has_value()) {
return tl::make_unexpected(result.error());
}
m_read_head += result.value();
if(m_read_head < 8) {
return {};
}
m_mesg_size = *reinterpret_cast<uint32_t*>(m_input_buffer.data() + 4);
}
if(m_read_head < m_mesg_size + 8) {
if(m_mesg_size + 8 > m_input_buffer.size()) {
return tl::make_unexpected(NetworkError(NetworkErrorType::NOT_ENOUGH_MEMORY));
}
auto result = m_stream.read_into(std::as_writable_bytes(std::span{(char*)m_input_buffer.data() + m_read_head, m_mesg_size + 8 - m_read_head}));
if(!result.has_value()) {
return tl::make_unexpected(result.error());
}
m_read_head += result.value();
if(m_read_head < m_mesg_size + 8) {
return {};
}
}
m_next_packet_type = (PacketType)(*reinterpret_cast<int32_t*>(m_input_buffer.data()));
return m_next_packet_type;
}
template<typename T>
tl::expected<T, NetworkError> pop(size_t* out_size) {
ZoneScopedN("Messenger::pop");
T result = {};
result.ParseFromArray(m_input_buffer.data() + 8, m_mesg_size);
// spdlog::info("Received {}: {}", (int)m_next_packet_type.value(), result.DebugString());
m_read_head = 0;
m_mesg_size = 0;
m_next_packet_type = {};
return result;
}
void skip() {
}
void clear() {
m_next_packet_type = std::nullopt;
int message_length = 0;
int size = sizeof(message_length);
// m_stream.read_exact(std::as_writable_bytes(std::span{&message_length, 1}));
std::vector<char> data(message_length);
// m_stream.read_exact(std::as_writable_bytes(std::span{data.data(), (size_t)message_length}));
// m_input_buffer.reset();
}
};
}
modules/network/include/messenger/MessengerDebugLog.hpp
-29
View File
@@ -1,29 +0,0 @@
#pragma once
#include "MessageRegistry.hpp"
#include <spdlog/spdlog.h>
#include <string>
#include <fstream>
class MessengerDebugLog {
public:
MessengerDebugLog(MessengerDebugLog&& m) :
m_log_file(std::move(m.m_log_file))
{ }
MessengerDebugLog(const std::string& log_file_path);
~MessengerDebugLog();
template<typename T>
void log_send(const T& message) {
spdlog::info("Sending [{}]: {}", (int)tw::Message<T>::value, message.DebugString());
}
template<typename T>
void log_recv(const T& message) {
spdlog::info("Received [{}]: {}", (int)tw::Message<T>::value, message.DebugString());
}
private:
std::ofstream m_log_file;
};
modules/network/include/metrics/BucketMetric.hpp
-157
View File
@@ -1,157 +0,0 @@
#pragma once
#include <chrono>
#include <cstdint>
#include <stdexcept>
#include <vector>
#include <print>
namespace tw::net {
template<typename T>
struct AverageOp {
uint32_t count;
T sum;
AverageOp() :
count(0),
sum{} {
}
void add(const T value) {
sum += value;
count++;
}
T result() const {
return count == 0 ? 0 : sum / count;
}
};
template<typename T>
struct SumOp {
T sum;
void add(const T value) {
sum += value;
}
T result() const {
return sum;
}
};
template<typename T, typename Interval,
typename Operation = SumOp<T>,
typename Clock = std::chrono::steady_clock>
class BucketMetric {
T m_min, m_max;
std::vector<T> m_metric;
std::vector<uint32_t> m_bucket_idx;
Operation m_op;
uint32_t m_offset;
uint32_t m_right, m_left;
std::string m_format;
const uint32_t get_bucket(Clock::time_point time_point) const {
return std::chrono::floor<Interval>(time_point).time_since_epoch().count() - m_offset;
}
public:
BucketMetric(std::string format, uint32_t size) :
m_metric(size),
m_bucket_idx(size),
m_right(0), m_left(0),
m_offset(0),
m_format(format)
{
m_offset = get_bucket(Clock::now());
}
const T max() const {
return m_max;
}
const T min() const {
return m_min;
}
const std::string& format() const {
return m_format;
}
size_t max_size() const {
return m_metric.size();
}
void push(T value) {
auto time = Clock::now();
size_t bucket = get_bucket(time) % m_metric.size();
size_t idx = get_bucket(time);
// set result to correct bucket
if(m_right != bucket) {
m_metric[m_right] = m_op.result();
m_min = std::min(m_min, m_op.result());
m_max = std::max(m_max, m_op.result());
m_bucket_idx[m_right] = idx++;
m_right++;
m_op = {};
}
// reset all buckets until the required one
for(; m_right != bucket; m_right = (m_right + 1) % m_metric.size()) {
m_metric[m_right] = {};
m_bucket_idx[m_right] = idx++;
if(m_right == m_left) {
m_left = (m_left + 1) % m_metric.size();
}
}
m_op.add(value);
}
const size_t get_size() const {
return m_right - m_left + (m_left > m_right ? m_metric.size() : 0);
}
const T get(uint32_t idx) const {
if(idx > get_size()) {
throw std::invalid_argument("`idx` cannot be higher than buffer size");
}
return m_metric[m_left + idx].result();
}
std::span<T> get_head() {
return std::span(m_metric).subspan(m_left, (m_right > m_left ? m_right : m_metric.size()));
}
std::span<uint32_t> get_head_timeline() {
return std::span(m_bucket_idx).subspan(m_left, (m_right > m_left ? m_right : m_bucket_idx.size()));
}
std::span<T> get_tail() {
if(m_right > m_left) {
return std::span<T>();
}
return std::span(m_metric).subspan(0, m_right);
}
std::span<uint32_t> get_tail_timeline() {
if(m_right > m_left) {
return std::span<T>();
}
return std::span(m_bucket_idx).subspan(0, m_right);
}
};
}
modules/network/include/metrics/HistoryBuffer.hpp
+9 -8
View File
@@ -42,7 +42,7 @@ public:
}
std::optional<const TValue*> get(TKey key) const {
for(size_t i = m_tail; i != m_head; (i++) % max_size()) {
for(size_t i = m_tail; i != m_head; i = (i + 1) % max_size()) {
if(m_buffer[i].first > key) {
return {};
}
@@ -56,24 +56,25 @@ public:
}
bool set(TKey key, const TValue& value) {
if(key < m_buffer.at(m_tail).first) {
// If buffer has entries and key is older than the oldest, reject it
if(m_tail != m_head && key < m_buffer.at(m_tail).first) {
return false;
}
int i = m_tail + 1;
size_t i = (m_tail + 1) % max_size();
if(m_tail != m_head) {
for(i = m_tail + 1; i != m_head; i++) {
for(i = (m_tail + 1) % max_size(); i != m_head; i = (i + 1) % max_size()) {
if(m_buffer.at(i).first > key) {
m_buffer[(i - 1) % max_size()] = std::make_pair(key, value);
m_head++;
m_buffer[(i - 1 + max_size()) % max_size()] = std::make_pair(key, value);
m_head = (m_head + 1) % max_size();
return true;
} else {
m_buffer[(i - 1) % max_size()] = m_buffer[i];
m_buffer[(i - 1 + max_size()) % max_size()] = m_buffer[i];
}
}
}
m_buffer[(i - 1) % max_size()] = std::make_pair(key, value);
m_buffer[(i - 1 + max_size()) % max_size()] = std::make_pair(key, value);
m_head = (m_head + 1) % max_size();
return true;
}
modules/network/include/metrics/NetworkStatsLogger.hpp
-134
View File
@@ -1,134 +0,0 @@
#pragma once
#include <cstdint>
#include <chrono>
#include <filesystem>
#include <cassert>
#include "Address.hpp"
#include "BucketMetric.hpp"
#include "packets/Packet.hpp"
#include "MessageRegistry.hpp"
namespace tw::net {
using Clock = std::chrono::steady_clock;
using TimePoint = Clock::time_point;
struct NetworkSendInfo {
PacketType message_type;
bool is_sent_by_us;
Address target;
TimePoint timepoint;
std::span<uint8_t> buffer;
NetworkSendInfo(
PacketType message_type,
bool is_sent_by_us,
const Address& target,
const std::span<uint8_t> buffer
) :
message_type(message_type),
is_sent_by_us(is_sent_by_us),
target(target),
timepoint(std::chrono::steady_clock::now()),
buffer(buffer)
{
}
};
class NetworkStatsLogger {
private:
std::vector<NetworkSendInfo> m_backlog;
std::vector<uint8_t> m_buffer;
size_t m_left, m_right;
std::optional<std::ostream> m_output;
using Interval = std::chrono::seconds;
BucketMetric<uint32_t, Interval, AverageOp<uint32_t>> m_ping_metric;
BucketMetric<uint32_t, Interval, SumOp<uint32_t>> m_outgoing;
BucketMetric<uint32_t, Interval, SumOp<uint32_t>> m_incoming;
public:
NetworkStatsLogger() :
m_backlog(10000, {MESSAGE_PACKET, false, Address({}, 0), {}}),
m_buffer(1000000),
m_left(0), m_right(0),
m_ping_metric("ms", 1000),
m_outgoing("b/s", 1000),
m_incoming("b/s", 1000)
{ }
void set_file_output(std::filesystem::path path);
size_t get_size() {
return m_right - m_left + (m_right < m_left ? m_backlog.size() : 0);
}
NetworkSendInfo& get_item(uint32_t idx) {
return m_backlog[(m_left + idx) % m_backlog.size()];
}
std::span<uint8_t> allocate_memory_for_buffer(size_t size) {
uint32_t start = m_right;
if(m_buffer.size() - m_right < size) {
// throw away packets from the start to make space
for(; m_backlog[m_left].buffer.data() < m_buffer.data() + start + size &&
m_left != m_right; m_left = (m_left + 1) % m_buffer.size()) { }
start = 0;
}
uint32_t end = start + size;
return std::span<uint8_t>(m_buffer.begin() + start, m_buffer.begin() + end);
}
// constexpr void log(PacketType message_type, bool is_sent, const Address& target, const ByteBuffer& content) {
// std::span<uint8_t> span = allocate_memory_for_buffer(content.size());
// memcpy(span.data(), content.data().data(), content.size());
// m_right = (m_right + 1) % m_backlog.size();
// m_backlog[m_right] = NetworkSendInfo(message_type, is_sent, target, span);
// }
// constexpr void log_receive(
// PacketType message_type,
// const Address& from
// ) {
// log(message_type, false, from, content);
// m_incoming.push(content.size());
// }
// constexpr void log_send(
// PacketType message_type,
// const Address& to
// ) {
// log(message_type, true, to, content);
// m_outgoing.push(content.size());
// }
void log_ping(uint32_t ping) {
m_ping_metric.push(ping);
}
BucketMetric<uint32_t, Interval, AverageOp<uint32_t>>& ping(){
return m_ping_metric;
}
BucketMetric<uint32_t, Interval>& outgoing(){
return m_outgoing;
}
BucketMetric<uint32_t, Interval>& incoming(){
return m_incoming;
}
};
}
modules/network/include/packets/LoginPacket.hpp
-67
View File
@@ -1,67 +0,0 @@
#pragma once
#include "Entity.pb.h"
#include "PlayerMove.pb.h"
#include "WorldState.pb.h"
#include "Login.pb.h"
#include "Packet.hpp"
#include "Serialization.hpp"
const int MAX_USERNAME_LENGTH = 128;
struct LoginPacket {
uint32_t username_length;
char username[MAX_USERNAME_LENGTH];
};
// template<>
// class Message<LoginPacket> {
// public:
// static constexpr PacketType value = LOGIN_REQUEST_MSG;
// };
template<>
class tw::net::Serializer<LoginPacket> final {
public:
static bool serialize(Serialization& buffer, LoginPacket& value) {
buffer.serialize(&value.username_length);
buffer.serialize(value.username, value.username_length);
return true;
}
};
// inline void to_json(json& j, const LoginPacket& value) {
// j = json{
// {"username_length", value.username_length},
// {"username", std::string(value.username, value.username_length)}
// };
// }
// inline void from_json(const json& j, LoginPacket& value) {
// j.at("username_length").get_to(value.username_length);
// j.at("username").get_to(value.username);
// }
struct LoginStatusPacket {
bool is_okay;
LoginStatusPacket() {
}
LoginStatusPacket(bool is_okay) :
is_okay(is_okay)
{
}
};
template<>
class tw::net::Serializer<LoginStatusPacket> final {
public:
static bool serialize(Serialization& buffer, LoginStatusPacket& value) {
return buffer.serialize(&value.is_okay);
}
};
modules/network/include/packets/Packet.hpp
-26
View File
@@ -1,26 +0,0 @@
#pragma once
#include "Serializers.hpp"
// #define PACKET(name) struct #name {
// template<>
// class tw::net::Serializer<const PacketType> final {
// public:
// static bool serialize(tw::net::Serialization& buffer, const PacketType& value) {
// uint32_t v = value;
// return buffer.serialize((uint32_t*)&v);
// }
// };
// template<>
// class tw::net::Serializer<PacketType> final {
// public:
// static bool serialize(tw::net::Serialization& buffer, PacketType& value) {
// return buffer.serialize((uint32_t*)&value);
// }
// };
modules/network/include/protocol/quicr/QuicrConnection.hpp
-221
View File
@@ -1,221 +0,0 @@
#pragma once
#include "Address.hpp"
#include "NetworkError.hpp"
#include "bytebuffer/ByteBuffer.hpp"
#include "io/Read.hpp"
#include "protocol/quicr/QuicrConnectionIdGenerator.hpp"
#include "protocol/quicr/QuicrEndpoint.hpp"
#include "protocol/quicr/QuicrError.hpp"
#include "protocol/quicr/QuicrPacket.hpp"
#include "protocol/quicr/QuicrReliability.hpp"
#include <cstddef>
#include <chrono>
#include <deque>
#include <sys/socket.h>
#include <tl/expected.hpp>
namespace tw::net::quicr {
const int TW_NET_HEARTBEAT_INTERVAL_IN_MILLIS = 5000;
const int TW_NET_HELLO_RETRY_INTERVAL_IN_MILLIS = 500;
/**
* Overwriting ring buffer;
*/
template<typename T>
class Ring {
std::vector<T> m_buffer;
size_t m_head = 0;
size_t m_tail = 0;
public:
const T pop() {
T value = m_buffer[m_tail];
m_tail = (m_tail + 1) % m_buffer.size();
return value;
}
void push_back(T value) {
m_head = (m_head + 1) % m_buffer.size();
if(m_tail == m_head) {
m_tail += 1;
}
m_buffer[m_head] = value;
}
private:
};
class UdpConnectionStreamPayloadQueue {
std::vector<std::byte> m_buffer;
Ring<uint32_t> m_payload_ends;
std::span<std::byte> pop() {
return std::span(m_buffer.data(), m_payload_ends.pop());
}
};
enum QuicrConnectionState {
Closed,
SentHello,
ReceivedHello,
Established
};
constexpr uint64_t STREAM_FLAG_FIN = 0x01;
constexpr uint64_t STREAM_FLAG_LEN = 0x02;
constexpr uint64_t STREAM_FLAG_OFF = 0x04;
class QuicrEndpoint;
/**
* Established QUICr connection.
*/
class QuicrConnection : Read<std::byte> {
static constexpr int PROTOCOL_VERSION = 1;
static constexpr int MAX_HELLO_RETRIES = 5;
static constexpr int HELLO_RETRY_INTERVAL_MS = 200;
using Clock = std::chrono::steady_clock;
Address m_peer_address;
QuicrEndpoint* m_endpoint;
QuicrReliabilityUnit* m_reliability_unit;
uint32_t m_packet_number = 1;
uint64_t m_self_id;
uint64_t m_peer_id;
Clock::time_point m_last_heartbeat_sent;
Clock::time_point m_last_heartbeat_received;
QuicrConnectionState m_state;
std::vector<std::byte> m_recv_buffer;
std::deque<std::vector<std::byte>> m_messages;
std::deque<std::vector<std::byte>> m_outbound_messages;
std::vector<QuicrFrame> m_outbound_frames;
std::vector<uint32_t> m_hello_packets;
/**
* Builds and writes next datagram.
*/
tl::expected<size_t, NetworkError> write_datagram(std::span<std::byte> data);
public:
QuicrConnection(uint64_t self_id, uint64_t peer_id, Address peer_address, QuicrEndpoint* endpoint) :
m_peer_address{peer_address},
m_endpoint{endpoint},
m_self_id{generate_id()},
m_peer_id{generate_id()},
m_state(QuicrConnectionState::Closed),
m_last_heartbeat_received(Clock::now()),
m_recv_buffer(64 * 1024),
m_reliability_unit(new QuicrReliabilityUnit(this))
{ }
// static tl::expected<QuicrConnection, NetworkError> connect(const Address& address);
constexpr Address address() {
return m_peer_address;
}
constexpr const uint64_t& self_id() const {
return m_self_id;
}
constexpr const uint64_t& peer_id() const {
return m_peer_id;
}
constexpr QuicrConnectionState state() {
return m_state;
}
void set_peer_id(uint64_t peer_id) {
m_peer_id = peer_id;
}
bool is_timed_out() const {
return m_last_heartbeat_received < std::chrono::steady_clock::now() - std::chrono::milliseconds(TW_NET_HEARTBEAT_INTERVAL_IN_MILLIS * 2);
}
tl::expected<void, NetworkError> send_keep_alive();
void send_initial_hello();
/**
* Schedules one stream frame to be sent.
*/
tl::expected<void, QuicrError>
send_message(std::span<std::byte> data, bool is_reliable);
/*
* Processes stream frame and appends message to the queue.
*/
bool process_stream_frame(uint64_t type, std::span<const std::byte> dgram, size_t& offset);
/**
* Hello frame
* - Protocol version
* - self connection ID
*/
void send_hello();
bool process_hello(const QuicrPacket& packet, const QuicrFrame& frame);
bool process_hello_fin(const QuicrPacket& packet, const QuicrFrame& frame);
/**
* Hello ACK frame:
* - Protocol version
* - self connection ID
* - echoed peer ID
*/
void send_hello_ack_frame();
bool process_hello_ack_frame(std::span<const std::byte> dgram, size_t& off);
/*
* Handshake Done Frame
* - Protocol version
* - self connection ID
* - echoed peer ID
*/
void send_handshake_done();
bool process_handshake_done(std::span<const std::byte> dgram, size_t& off);
bool process_ack_frame(const QuicrPacket& packet, const QuicrFrame& frame);
void process_datagram(std::span<std::byte> dgram);
// void update();
// void drain_socket();
tl::expected<size_t, NetworkError> read_into(std::span<std::byte> target) override;
void on_tick(std::chrono::steady_clock::time_point now);
bool has_next_datagram();
std::vector<std::byte> pop_datagram();
size_t flush() {
return 0;
}
void encode_next_packet(RingByteBuffer& target);
};
}
modules/network/include/protocol/quicr/QuicrConnectionIdGenerator.hpp
-13
View File
@@ -1,13 +0,0 @@
#pragma once
#include <cstdint>
#include <random>
namespace tw::net::quicr {
static uint64_t generate_id() {
static std::mt19937_64 rng(std::random_device{}());
return rng() & 0x3FFFFFFFFFFFFFFF;
}
}
modules/network/include/protocol/quicr/QuicrConnectionListener.hpp
-62
View File
@@ -1,62 +0,0 @@
#pragma once
#include "NetworkError.hpp"
#include "tl/expected.hpp"
#include <memory>
#include <sys/socket.h>
#include <deque>
namespace tw::net::quicr {
class QuicrConnection;
class QuicrEndpoint;
class QuicrConnectionListener {
std::deque<QuicrConnection*> m_listened_connections;
QuicrConnectionListener(QuicrEndpoint* endpoint);
public:
QuicrConnectionListener(const QuicrConnectionListener&) = delete;
QuicrConnectionListener& operator=(const QuicrConnectionListener&) = delete;
QuicrConnectionListener(QuicrConnectionListener&&) = delete;
QuicrConnectionListener& operator=(QuicrConnectionListener&&) = delete;
static tl::expected<std::unique_ptr<QuicrConnectionListener>, NetworkError>
listen(QuicrEndpoint* endpoint);
QuicrConnection* listen();
void on_new_connection(QuicrConnection* connection) {
m_listened_connections.push_back(connection);
}
/**
* Receives single datagram.
*/
// tl::expected<size_t, NetworkError> recv_into(std::span<std::byte> buffer, Address* from) {
// struct sockaddr_storage sockaddr_from;
// socklen_t from_length = sizeof( sockaddr_from );
// int result = ::recvfrom(m_socket_fd, (char*)m_input_buffer.data(), m_input_buffer.size(), 0, (struct sockaddr*) &sockaddr_from, &from_length );
// *from = Address(sockaddr_from);
// return result;
// }
// sends single datagram to the given address
// void send_to(const Address& address, std::span<const std::byte> data) {
// size_t r = ::sendto(m_stream.socket_fd(), data.data(), data.size(),
// MSG_NOSIGNAL | MSG_DONTWAIT,
// address.sockaddr(), address.socklen());
// if(r <= 0) {
// spdlog::error("Failed to send datagram to {}: {}", address.to_string(), strerror(errno));
// }
// }
};
}
modules/network/include/protocol/quicr/QuicrConnectionState.hpp
-10
View File
@@ -1,10 +0,0 @@
#pragma once
namespace tw::quicr {
enum QuicrConnectionState {
AwaitingHello = 0,
AwaitingHelloAck = 1,
Established = 2,
TimedOut = 3
};
}
modules/network/include/protocol/quicr/QuicrEncoder.hpp
-77
View File
@@ -1,77 +0,0 @@
#pragma once
#include "bytebuffer/ByteBuffer.hpp"
#include "bytebuffer/ByteBufferReader.hpp"
#include "bytebuffer/ByteBufferWriter.hpp"
#include "protocol/quicr/QuicrFrame.hpp"
#include "protocol/quicr/QuicrPacket.hpp"
#include <cstddef>
namespace tw::net::quicr {
class QuicrConnection;
class QuicrEncoder {
public:
static size_t encode_frame(RingByteBuffer& target, QuicrFrame& frame);
};
class QuicrDecoder {
public:
static QuicrPacket decode_packet_header(std::span<std::byte> data, size_t& offset);
static QuicrPacket decode_packet(std::span<std::byte> data);
};
template<typename T>
class QuicrFrameCodec {
public:
static size_t encode(ByteBufferWriter& writer, T& frame);
static T decode(ByteBufferReader& reader);
};
/*
* Encodes a QUICr objects into datagram byte vector.
*/
class QuicrPacketEncoder {
public:
QuicrPacketEncoder(std::span<std::byte> target, size_t& offset,
QuicrPacketType type, std::optional<uint32_t> packet_number,
QuicrConnection& connection);
QuicrPacketEncoder& encode_stream_frame(std::span<std::byte> data, bool is_reliable);
QuicrPacketEncoder& encode_ack_frame(std::vector<uint32_t>& acked_packets);
QuicrPacketEncoder& encode_frame(QuicrFrame& frame);
constexpr size_t size() const {
return m_writer.length();
}
private:
void write_length(size_t value) {
m_target[size_val_offset] = static_cast<std::byte>(value >> 24);
m_target[size_val_offset + 1] = static_cast<std::byte>(value >> 16);
m_target[size_val_offset + 2] = static_cast<std::byte>(value >> 8);
m_target[size_val_offset + 3] = static_cast<std::byte>(value);
}
void set_as_reliable() {
m_target[is_reliable_val_offset] = static_cast<std::byte>(1);
}
std::span<std::byte> m_target;
ByteBufferWriter m_writer;
size_t size_val_offset;
size_t is_reliable_val_offset;
size_t& m_offset;
QuicrPacketType m_type;
QuicrConnection& m_connection;
};
}
modules/network/include/protocol/quicr/QuicrEndpoint.hpp
-70
View File
@@ -1,70 +0,0 @@
#pragma once
#include "Address.hpp"
#include "NetworkError.hpp"
#include "protocol/quicr/QuicrConnection.hpp"
#include <tl/expected.hpp>
#include <memory>
#include <unordered_map>
#include <unistd.h>
namespace tw::net::quicr {
class QuicrConnection;
class QuicrConnectionListener;
class QuicrEndpoint {
int32_t m_socket_fd;
std::unordered_map<uint64_t, std::shared_ptr<QuicrConnection>> m_connections;
std::vector<std::byte> m_inbound_buffer;
QuicrConnectionListener* m_new_connection_handler;
void process_datagram(std::span<std::byte> datagram, Address from);
QuicrEndpoint(int socket_fd);
public:
QuicrEndpoint(const QuicrEndpoint&) = delete;
QuicrEndpoint& operator=(const QuicrEndpoint&) = delete;
QuicrEndpoint(QuicrEndpoint&&) = delete;
QuicrEndpoint& operator=(QuicrEndpoint&&) = delete;
~QuicrEndpoint() {
::close(m_socket_fd);
m_socket_fd = -1;
}
std::vector<std::pair<uint64_t, std::shared_ptr<QuicrConnection>>> clients() const {
std::vector<std::pair<uint64_t, std::shared_ptr<QuicrConnection>>> result;
for (const auto& [id, connection] : m_connections) {
result.emplace_back(id, connection);
}
return result;
}
static tl::expected<std::unique_ptr<QuicrEndpoint>, NetworkError> create();
/**
* Creates the QUICr endpoint and binds it to a port.
*/
static tl::expected<std::unique_ptr<QuicrEndpoint>, NetworkError> create_and_bind(int16_t port);
void assign_listener(QuicrConnectionListener* listener) {
m_new_connection_handler = listener;
}
tl::expected<void, NetworkError> bind(int port);
tl::expected<QuicrConnection*, NetworkError> connect(Address address);
tl::expected<size_t, NetworkError> send_to(std::span<std::byte> data, Address to);
tl::expected<size_t, NetworkError> read_from_into(std::span<std::byte> data, Address* out_from);
void poll();
};
}
modules/network/include/protocol/quicr/QuicrError.hpp
-34
View File
@@ -1,34 +0,0 @@
#pragma once
#include <algorithm>
#include <string>
namespace tw::net::quicr {
enum class QuicrErrorType {
ConnectionClosed
};
struct QuicrError {
public:
QuicrError(QuicrErrorType type) : type_(type), message_(map_quicr_error_type(type)) {}
QuicrError(QuicrErrorType type, std::string message) : type_(type), message_(std::move(message)) {}
QuicrErrorType type() const { return type_; }
std::string message() const { return message_; }
private:
static std::string map_quicr_error_type(QuicrErrorType type) {
switch (type) {
case QuicrErrorType::ConnectionClosed:
return "ConnectionClosed";
default:
return "Unknown";
}
}
std::string message_;
QuicrErrorType type_;
};
}
modules/network/include/protocol/quicr/QuicrFrame.hpp
-61
View File
@@ -1,61 +0,0 @@
#pragma once
#include "protocol/quicr/QuicrFrameType.hpp"
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
namespace tw::net::quicr {
struct QuicrFrame {
public:
uint64_t frame_number;
FrameType type;
bool is_reliable;
std::vector<std::byte> content;
static QuicrFrame make_hello() {
QuicrFrame frame;
frame.type = FrameType::Hello;
frame.is_reliable = true;
return frame;
}
static QuicrFrame make_hello_fin() {
QuicrFrame frame;
frame.type = FrameType::HelloFin;
frame.is_reliable = true;
return frame;
}
static QuicrFrame make_stream(std::vector<std::byte> content) {
QuicrFrame frame;
frame.type = FrameType::StreamBase;
frame.is_reliable = false;
frame.content = std::move(content);
return frame;
}
static QuicrFrame make_ack(std::vector<std::uint32_t> content) {
QuicrFrame frame;
frame.type = FrameType::Ack;
frame.is_reliable = true;
frame.content = std::move(std::vector<std::byte>(
std::as_bytes(std::span(content)).begin(),
std::as_bytes(std::span(content)).end())
);
return frame;
}
};
}
modules/network/include/protocol/quicr/QuicrFrameType.hpp
-25
View File
@@ -1,25 +0,0 @@
#pragma once
#include <cstdint>
namespace tw::net::quicr {
enum FrameType : uint8_t {
Padding = 0x00,
KeepAlive = 0x01,
Ack = 0x02,
AckEcn = 0x03,
ResetStream = 0x04,
StopSending = 0x05,
Crypto = 0x06,
NewToken = 0x07,
// STREAM is 0x08..0x0f (low 3 bits are flags)
StreamBase = 0x08, // interpret specially
StreamUnreliable = 0x09,
Hello = 0x10,
HelloFin = 0x11,
HandshakeDone = 0x12
};
}
modules/network/include/protocol/quicr/QuicrPacket.hpp
-29
View File
@@ -1,29 +0,0 @@
#pragma once
#include "QuicrFrame.hpp"
#include "protocol/quicr/QuicrPacketType.hpp"
#include <optional>
namespace tw::net::quicr {
class QuicrPacket {
public:
QuicrPacketType type;
uint64_t destination_id;
uint64_t local_id;
bool require_ack;
std::optional<uint32_t> packet_number;
uint32_t length;
std::vector<QuicrFrame> frames;
QuicrPacket()
: type(QuicrPacketType::Unknown), destination_id(0), local_id(0),
require_ack(false), packet_number({}), length(0), frames() {}
};
} // namespace tw::net::quicr
modules/network/include/protocol/quicr/QuicrPacketType.hpp
-14
View File
@@ -1,14 +0,0 @@
#pragma once
#include <cstdint>
namespace tw::net::quicr {
enum class QuicrPacketType : uint8_t {
Unknown,
Initial,
Handshake,
Established
};
}
modules/network/include/protocol/quicr/QuicrReliability.hpp
-95
View File
@@ -1,95 +0,0 @@
#pragma once
#include "bytebuffer/ByteBuffer.hpp"
#include "protocol/quicr/QuicrFrame.hpp"
#include <cstddef>
#include <deque>
#include <map>
#include <set>
#include <vector>
namespace tw::net::quicr {
class QuicrConnection;
struct QuicrReliablePacket {
public:
uint32_t packet_number;
std::set<uint32_t> frame_numbers;
};
struct QuicrReliableFrame {
using Clock = std::chrono::steady_clock;
Clock::time_point deadline;
QuicrFrame frame;
};
/**
* Assembles next packet from frames.
*/
class QuicrReliabilityUnit {
using Clock = std::chrono::steady_clock;
const QuicrConnection* connection;
std::vector<uint32_t> m_acks_to_send;
std::map<uint32_t, QuicrReliableFrame*> awaiting_ack_frames;
std::map<uint32_t, QuicrReliablePacket> packets_in_flight;
uint32_t m_last_frame_number = 0;
uint32_t next_frame_number() {
return ++m_last_frame_number;
}
// uint64_t m_largest_received;
// uint64_t m_ack_bitfield;
// uint64_t m_frame_number;
// size_t encode_packet_header(RingByteBuffer& buffer, const QuicrConnection* connection);
// size_t encode_frame_header(RingByteBuffer& buffer, const QuicrFrame& frame);
// size_t encode_frame_body(RingByteBuffer& buffer, const QuicrFrame& frame);
// size_t encode_frame(RingByteBuffer& buffer, const QuicrFrame& frame);
public:
QuicrReliabilityUnit(const QuicrConnection* connection) :
connection{connection}
// m_largest_received{0},
// m_ack_bitfield{0},
// m_frame_number{0}
{ }
void on_ack_received(uint32_t frame_number);
/**
* Pushes packet to acknowledge
*/
void push_ack(uint32_t packet_number);
bool has_acks_to_send() {
return m_acks_to_send.size() > 0;
}
std::vector<uint32_t> pop_acks_to_send();
void push_reliable_frame(Clock::time_point deadline, QuicrFrame&& frame);
void push_reliable_frame(Clock::time_point deadline, QuicrFrame& frame);
bool has_reliable_frames_to_resend();
/**
* Pops all frames that should be re-send and marks them with new_packet_number.
*/
std::vector<QuicrFrame> pop_frames_to_resend(uint32_t new_packet_number);
};
}
modules/network/include/protocol/quicr/QuicrStream.hpp
-34
View File
@@ -1,34 +0,0 @@
#include "NetworkError.hpp"
#include "protocol/quicr/QuicrConnection.hpp"
#include "tl/expected.hpp"
namespace tw::net::quicr {
class QuicrStream : Write<std::byte>, Read<std::byte> {
QuicrConnection* m_connection;
bool m_is_reliable;
public:
QuicrStream(QuicrConnection* connection, bool is_reliable);
tl::expected<size_t, NetworkError> write(std::span<std::byte> data) override {
auto send_r = m_connection->send_message(data, m_is_reliable);
if(!send_r) {
return tl::make_unexpected(NetworkError::from_errno(CONNECTION_RESET));
}
return *send_r;
}
tl::expected<size_t, NetworkError> read_into(std::span<std::byte> target) override {
auto read_r = m_connection->read_into(target);
if(!read_r) {
return tl::make_unexpected(NetworkError::from_errno(CONNECTION_RESET));
}
return *read_r;
}
};
}
modules/network/include/protocol/quicr/VarInt.hpp
-91
View File
@@ -1,91 +0,0 @@
#pragma once
#include <cstddef>
#include <cstdint>
#include <optional>
#include <span>
#include <vector>
namespace tw::net::quicr {
struct VarInt {
uint64_t value = 0;
// byte length of the number in the stream. Use to adjust offset.
size_t bytes = 0;
VarInt(uint64_t value) {
if (value <= 63) {
bytes = 1;
} else if (value <= 16383) {
bytes = 2;
} else if (value <= 1073741823) {
bytes = 4;
}
bytes = 8;
this->value = value;
}
VarInt(uint64_t value, size_t bytes) {
this->value = value;
this->bytes = bytes;
}
static std::optional<VarInt> decode(std::span<const std::byte> in) {
if (in.empty()) return std::nullopt;
return VarInt(*(uint64_t*)in.data(), sizeof(uint64_t));
// uint8_t b0 = std::to_integer<uint8_t>(in[0]);
// uint8_t prefix = (b0 >> 6) & 0x03;
// size_t len = size_t(1) << prefix; // 1, 2, 4, 8
// if (in.size() < len) return std::nullopt;
// uint64_t v = (uint64_t)(b0 & 0x3f);
// for (size_t i = 1; i < len; ++i) {
// v = (v << 8) | std::to_integer<uint8_t>(in[i]);
// }
// return VarInt(v, len);
}
size_t encode(std::vector<std::byte>& out) {
// if (value <= 63) {
// out.push_back(std::byte(value));
// return 1;
// }
// if (value <= 16383) {
// out.push_back(std::byte(0x40 | ((value >> 8) & 0x3f)));
// out.push_back(std::byte(value & 0xff));
// return 2;
// }
// if (value <= 1073741823) {
// out.push_back(std::byte(0x80 | ((value >> 24) & 0x3f)));
// out.push_back(std::byte((value >> 16) & 0xff));
// out.push_back(std::byte((value >> 8) & 0xff));
// out.push_back(std::byte(value & 0xff));
// return 4;
// }
// 8-byte
// out.push_back(std::byte(0xc0 | ((value >> 56) & 0x3f)));
// out.push_back(std::byte((value >> 48) & 0xff));
// out.push_back(std::byte((value >> 40) & 0xff));
// out.push_back(std::byte((value >> 32) & 0xff));
// out.push_back(std::byte((value >> 24) & 0xff));
// out.push_back(std::byte((value >> 16) & 0xff));
// out.push_back(std::byte((value >> 8) & 0xff));
// out.push_back(std::byte(value & 0xff));
// insert value into span
for (int i = 0; i < 8; ++i) {
out.push_back(std::byte((value >> (i * 8)) & 0xFF));
}
return 8;
}
};
}
modules/network/include/protocol/quicr/frames/QuicrAckFrame.hpp
-25
View File
@@ -1,25 +0,0 @@
#pragma once
#include "protocol/quicr/QuicrEncoder.hpp"
namespace tw::net::quicr {
class QuicrAckFrame {
public:
QuicrAckFrame() = default;
};
template<>
class QuicrFrameCodec<QuicrAckFrame> {
public:
static size_t encode(ByteBufferWriter& writer, QuicrAckFrame& frame) {
}
static QuicrAckFrame decode(ByteBufferReader& reader) {
}
};
}