Initial commit; WIP, not yet functional

Author: jagerman

.gitignore

@@ -0,0 +1,3 @@
+build*/
+.cache/
+compile_commands.json

CMakeLists.txt

@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 3.10)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+
+find_program(CCACHE_PROGRAM ccache)
+if(CCACHE_PROGRAM)
+  foreach(lang C CXX)
+    if(NOT DEFINED CMAKE_${lang}_COMPILER_LAUNCHER AND NOT CMAKE_${lang}_COMPILER MATCHES ".*/ccache")
+      message(STATUS "Enabling ccache for ${lang}")
+      set(CMAKE_${lang}_COMPILER_LAUNCHER ${CCACHE_PROGRAM} CACHE STRING "")
+    endif()
+  endforeach()
+endif()
+
+project(plainquic
+    VERSION 0.0.1
+    DESCRIPTION "QUIC test implementation"
+    LANGUAGES C CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+set(NGTCP2_DIR "${PROJECT_SOURCE_DIR}/../build" CACHE "PATH" "Path to built ngtpc2 build dir")
+
+add_library(quictest
+    address.cpp
+    client.cpp
+    connection.cpp
+    endpoint.cpp
+    server.cpp
+    )
+
+add_library(ngtcp2 STATIC IMPORTED GLOBAL)
+set_target_properties(ngtcp2 PROPERTIES IMPORTED_LOCATION ${NGTCP2_DIR}/lib/libngtcp2.a)
+target_include_directories(ngtcp2 INTERFACE ${NGTCP2_DIR}/lib/includes ${NGTCP2_DIR}/../lib/includes)
+
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(LIBUV libuv>=1.18.0 IMPORTED_TARGET)
+pkg_check_modules(OXENMQ liboxenmq>=1.2.3 IMPORTED_TARGET)
+
+target_link_libraries(quictest PUBLIC ngtcp2 PkgConfig::LIBUV PkgConfig::OXENMQ)
+
+add_executable(echo-server echo-server.cpp)
+add_executable(echo-client echo-client.cpp)
+
+target_link_libraries(echo-server quictest)
+target_link_libraries(echo-client quictest)

README.md

@@ -0,0 +1 @@
+# WIP - liblokinet QUIC-based, plaintext tunnel

address.cpp

@@ -0,0 +1,46 @@
+#include "address.h"
+
+extern "C" {
+#include <arpa/inet.h>
+}
+
+#include <iostream>
+
+namespace quic {
+
+using namespace std::literals;
+
+Address::Address(std::array<uint8_t, 4> ip, uint16_t port) {
+    s.in.sin_family = AF_INET;
+    std::memcpy(&s.in.sin_addr.s_addr, ip.data(), ip.size());
+    s.in.sin_port = htons(port);
+    a.addrlen = sizeof(s.in);
+}
+
+Address::Address(const sockaddr_any* addr, size_t addrlen) {
+    assert(addrlen == sizeof(sockaddr_in)); // FIXME: IPv6 support
+    std::memmove(&s, addr, addrlen);
+    a.addrlen = addrlen;
+}
+Address& Address::operator=(const Address& addr) {
+    std::memmove(&s, &addr.s, sizeof(s));
+    a.addrlen = addr.a.addrlen;
+    return *this;
+}
+
+std::string Address::to_string() const {
+    if (a.addrlen != sizeof(sockaddr_in))
+        return "(unknown-addr)";
+    char buf[INET_ADDRSTRLEN] = {0};
+    inet_ntop(AF_INET, &s.in.sin_addr, buf, INET_ADDRSTRLEN);
+    return buf + ":"s + std::to_string(ntohs(s.in.sin_port));
+}
+
+std::ostream& operator<<(std::ostream& o, const Address& a) {
+    return o << a.to_string();
+}
+std::ostream& operator<<(std::ostream& o, const Path& p) {
+    return o << p.local << "<-" << p.remote;
+}
+
+}

address.h

@@ -0,0 +1,81 @@
+#pragma once
+
+#include <array>
+#include <cassert>
+#include <cstring>
+#include <string>
+#include <iosfwd>
+
+#include <ngtcp2/ngtcp2.h>
+
+extern "C" {
+#include <netinet/in.h>
+#include <sys/socket.h>
+}
+
+namespace quic {
+
+union sockaddr_any {
+  sockaddr_storage storage;
+  sockaddr sa;
+  sockaddr_in6 in6;
+  sockaddr_in in;
+};
+
+
+class Address {
+    sockaddr_any s{};
+    ngtcp2_addr a{0, &s.sa, nullptr};
+public:
+    Address() = default;
+    Address(std::array<uint8_t, 4> ip, uint16_t port);
+    Address(const sockaddr_any* addr, size_t addrlen);
+    Address(const Address& addr) {
+        *this = addr;
+    }
+    Address& operator=(const Address& addr);
+
+    // Implicit conversion to sockaddr* and ngtcp2_addr& so that an Address can be passed wherever
+    // one of those is expected.
+    operator sockaddr*() { return a.addr; }
+    operator const sockaddr*() const { return a.addr; }
+    constexpr socklen_t sockaddr_size() const { return a.addrlen; }
+    operator ngtcp2_addr&() { return a; }
+    operator const ngtcp2_addr&() const { return a; }
+
+    std::string to_string() const;
+};
+
+// Wraps an ngtcp2_path (which is basically just and address pair) with remote/local components.
+// Implicitly convertable to a ngtcp2_path* so that this can be passed wherever a ngtcp2_path* is
+// taken in the ngtcp2 API.
+struct Path {
+    Address local{}, remote{};
+    ngtcp2_path path{
+        {0, local, nullptr},
+        {0, remote, nullptr}};
+
+    Path() = default;
+    Path(const Address& local, const Address& remote) : local{local}, remote{remote} {}
+    Path(const Address& local, const sockaddr_any* remote_addr, size_t remote_len)
+        : local{local}, remote{remote_addr, remote_len} {}
+    Path(const Path& p) : local{p.local}, remote{p.remote} {}
+
+    Path& operator=(const Path& p) {
+        local = p.local;
+        remote = p.remote;
+        return *this;
+    }
+
+    // Equivalent to `&obj.path`, but slightly more convenient for passing into ngtcp2 functions
+    // taking a ngtcp2_path pointer.
+    operator ngtcp2_path*() { return &path; }
+    operator const ngtcp2_path*() const { return &path; }
+
+    std::string to_string() const;
+};
+
+std::ostream& operator<<(std::ostream& o, const Address& a);
+std::ostream& operator<<(std::ostream& o, const Path& p);
+
+}

client.cpp

@@ -0,0 +1,57 @@
+
+#include "client.h"
+#include "log.h"
+
+namespace quic {
+
+Client::Client(Address remote, uv_loop_t* loop, std::optional<Address> local)
+        : Endpoint{std::move(local), loop} {
+    // Our UDP socket is now set up, so now we initiate contact with the remote QUIC
+    Debug("Connecting to ", remote);
+
+    // TODO: need timers for:
+    //
+    // - timeout (to disconnect if idle for too longer)
+    //
+    // - probably don't need for lokinet tunnel: change local addr -- attempts to re-bind the local socket
+    //
+    // - key_update_timer
+    //
+    // - delay_stream_timer
+
+
+    conns_iterator it = conns.end();
+    try {
+        auto* s = dynamic_cast<Server*>(this);
+        assert(s);
+        auto [insit, ins] = conns.emplace(std::piecewise_construct,
+                std::forward_as_tuple(local_cid),
+                std::forward_as_tuple(*s, local_cid, hd, p.path));
+        if (!ins)
+            Warn("Internal error: duplicate connection id?");
+        else
+            it = insit;
+    } catch (const std::exception& e) {
+        Warn("Failed to create Connection: ", e.what());
+    }
+
+
+}
+
+void Client::handle_packet(const Packet& p) {
+    version_info vi;
+    auto rv = ngtcp2_pkt_decode_version_cid(&vi.version, &vi.dcid, &vi.dcid_len, &vi.scid, &vi.scid_len,
+            reinterpret_cast<const uint8_t*>(p.data.data()), p.data.size(), NGTCP2_MAX_CIDLEN);
+    if (rv == 1) // 1 means Version Negotiation should be sent
+        return send_version_negotiation(vi, p.path.remote);
+    else if (rv != 0) {
+        Warn("QUIC packet header decode failed: ", ngtcp2_strerror(rv));
+        return;
+    }
+
+    if (vi.dcid_len > ConnectionID::max_size()) {
+        Warn("Internal error: destination ID is longer than should be allowed");
+        return;
+    }
+
+}

client.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include "endpoint.h"
+
+#include <optional>
+
+namespace quic {
+
+class Client : public Endpoint {
+public:
+    // Constructs a client that establishes an outgoing connection to `remote`.  `local` can be used
+    // to optionally bind to a local IP and/or port for the connection.
+    Client(Address remote, uv_loop_t* loop, std::optional<Address> local = std::nullopt);
+
+private:
+    void handle_packet(const Packet& p) override;
+};
+
+}