Merge pull request #114 from dr7ana/manual_routing

No-UDP Endpoints: manual data I/O routing

Author: dr7ana

external/oxen-logging

@@ -380,6 +380,8 @@ namespace oxen::quic
             return &_path;
         }
 
+        Path invert() const { return {remote, local}; }
+
         std::string to_string() const;
     };
 }  // namespace oxen::quic

include/oxen/quic/address.hpp

@@ -57,8 +57,8 @@ namespace oxen::quic
         template <typename... Opt>
         Endpoint(Network& n, const Address& listen_addr, Opt&&... opts) : net{n}, _local{listen_addr}
         {
-            _init_internals();
             ((void)handle_ep_opt(std::forward<Opt>(opts)), ...);
+            _init_internals();
             if (_static_secret.empty())
                 _static_secret = make_static_secret();
         }
@@ -88,7 +88,7 @@ namespace oxen::quic
             std::promise<std::shared_ptr<Connection>> p;
             auto f = p.get_future();
 
-            if (!remote.is_addressable())
+            if (not _manual_routing and !remote.is_addressable())
                 throw std::invalid_argument("Address must be addressible to connect");
 
             if (_local.is_ipv6() && !remote.is_ipv6())
@@ -195,6 +195,8 @@ namespace oxen::quic
         // Returns a random value suitable for use as the Endpoint static secret value.
         static ustring make_static_secret();
 
+        void manually_receive_packet(Packet&& pkt);
+
       private:
         friend class Network;
         friend class Loop;
@@ -212,6 +214,8 @@ namespace oxen::quic
         Splitting _policy{Splitting::NONE};
         int _rbufsize{4096};
 
+        opt::manual_routing _manual_routing;
+
         uint64_t _next_rid{0};
 
         ustring _static_secret;
@@ -243,6 +247,7 @@ namespace oxen::quic
         void handle_ep_opt(connection_established_callback conn_established_cb);
         void handle_ep_opt(connection_closed_callback conn_closed_cb);
         void handle_ep_opt(opt::static_secret ssecret);
+        void handle_ep_opt(opt::manual_routing mrouting);
 
         // Takes a std::optional-wrapped option that does nothing if the optional is empty,
         // otherwise passes it through to the above.  This is here to allow runtime-dependent
@@ -373,7 +378,7 @@ namespace oxen::quic
         void send_or_queue_packet(
                 const Path& p, std::vector<std::byte> buf, uint8_t ecn, std::function<void(io_result)> callback = nullptr);
 
-        void send_version_negotiation(const ngtcp2_version_cid& vid, const Path& p);
+        void send_version_negotiation(const ngtcp2_version_cid& vid, Path p);
 
         void check_timeouts();
 

include/oxen/quic/endpoint.hpp

@@ -6,138 +6,173 @@
 #include "crypto.hpp"
 #include "types.hpp"
 
-namespace oxen::quic::opt
+namespace oxen::quic
 {
-    using namespace std::chrono_literals;
+    class Endpoint;
 
-    struct max_streams
+    namespace opt
     {
-        uint64_t stream_count{DEFAULT_MAX_BIDI_STREAMS};
-        max_streams() = default;
-        explicit max_streams(uint64_t s) : stream_count{s} {}
-    };
-
-    // If non-zero, this sets a keep-alive timer for outgoing PINGs on this connection so that a
-    // functioning but idle connection can stay alive indefinitely without hitting the connection's
-    // idle timeout.  Typically in designing a protocol you need only one side to send pings; the
-    // responses to a ping keep the connection in the other direction alive.  This value should
-    // typically be lower than the idle_timeout of both sides of the connection to be effective.
-    //
-    // If this option is not specified or is set to a duration of 0 then outgoing PINGs will not be
-    // sent on the connection.
-    struct keep_alive
-    {
-        std::chrono::milliseconds time{0ms};
-        keep_alive() = default;
-        explicit keep_alive(std::chrono::milliseconds val) : time{val} {}
-    };
-
-    // Can be used to override the default (30s) maximum idle timeout for a connection.  Note that
-    // this is negotiated during connection establishment, and the lower value advertised by each
-    // side will be used for the connection.  Can be 0 to disable idle timeout entirely, but such an
-    // option has caveats for connections across unknown internet boxes (see comments in RFC 9000,
-    // section 10.1.2).
-    struct idle_timeout
-    {
-        std::chrono::milliseconds timeout{DEFAULT_IDLE_TIMEOUT};
-        idle_timeout() = default;
-        explicit idle_timeout(std::chrono::milliseconds val) : timeout{val} {}
-    };
-
-    /// This can be initialized a few different ways. Simply passing a default constructed struct
-    /// to Network::Endpoint(...) will enable datagrams without packet-splitting. From there, pass
-    /// `Splitting::ACTIVE` to the constructor to enable packet-splitting.
-    ///
-    /// The size of the rotating datagram buffer can also be specified as a second parameter to the
-    /// constructor. Buffer size is subdivided amongst 4 equally sized buffer rows, so the bufsize
-    /// must be perfectly divisible by 4
-    ///
-    /// In some use cases, the user may want the receive data as a string view or a string literal.
-    /// The default is string literal; setting
-    ///
-    /// The max size of a transmittable datagram can be queried directly from connection_interface::
-    /// get_max_datagram_size(). At connection initialization, ngtcp2 will default this value to 1200.
-    /// The actual value is negotiated upwards via path discovery, reaching a theoretical maximum of
-    /// NGTCP2_MAX_PMTUD_UDP_PAYLOAD_SIZE (1452), or near it, per datagram. Please note that enabling
-    /// datagram splitting will double whatever value is returned.
-    ///
-    /// Note: this setting CANNOT be changed for an endpoint after creation, it must be
-    /// destroyed and re-initialized with the desired settings.
-    struct enable_datagrams
-    {
-        bool split_packets{false};
-        Splitting mode{Splitting::NONE};
-        // Note: this is the size of the entire buffer, divided amongst 4 rows
-        int bufsize{4096};
-
-        enable_datagrams() = default;
-        explicit enable_datagrams(bool e) = delete;
-        explicit enable_datagrams(Splitting m) : split_packets{true}, mode{m} {}
-        explicit enable_datagrams(Splitting m, int b) : split_packets{true}, mode{m}, bufsize{b}
+        using namespace std::chrono_literals;
+
+        struct max_streams
         {
-            if (b <= 0)
-                throw std::out_of_range{"Bufsize must be positive"};
-            if (b > 1 << 14)
-                throw std::out_of_range{"Bufsize too large"};
-            if (b % 4 != 0)
-                throw std::invalid_argument{"Bufsize must be evenly divisible between 4 rows"};
-        }
-    };
-
-    // supported ALPNs for outbound connections
-    struct outbound_alpns
-    {
-        std::vector<ustring> alpns;
-        explicit outbound_alpns(std::vector<ustring> alpns = {}) : alpns{std::move(alpns)} {}
+            uint64_t stream_count{DEFAULT_MAX_BIDI_STREAMS};
+            max_streams() = default;
+            explicit max_streams(uint64_t s) : stream_count{s} {}
+        };
 
-        // Convenience wrapper that sets a single ALPN value from a regular string:
-        explicit outbound_alpns(std::string_view alpn) : outbound_alpns{{ustring{to_usv(alpn)}}} {}
-    };
+        // supported ALPNs for outbound connections
+        struct outbound_alpns
+        {
+            std::vector<ustring> alpns;
+            explicit outbound_alpns(std::vector<ustring> alpns = {}) : alpns{std::move(alpns)} {}
 
-    // supported ALPNs for inbound connections
-    struct inbound_alpns
-    {
-        std::vector<ustring> alpns;
-        explicit inbound_alpns(std::vector<ustring> alpns = {}) : alpns{std::move(alpns)} {}
+            // Convenience wrapper that sets a single ALPN value from a regular string:
+            explicit outbound_alpns(std::string_view alpn) : outbound_alpns{{ustring{to_usv(alpn)}}} {}
+        };
 
-        // Convenience wrapper that sets a single ALPN value from a regular string:
-        explicit inbound_alpns(std::string_view alpn) : inbound_alpns{{ustring{to_usv(alpn)}}} {}
-    };
+        // supported ALPNs for inbound connections
+        struct inbound_alpns
+        {
+            std::vector<ustring> alpns;
+            explicit inbound_alpns(std::vector<ustring> alpns = {}) : alpns{std::move(alpns)} {}
 
-    // Sets the inbound and outbound ALPNs simulatneous to the same value(s).  This is equivalent to
-    // passing outbound_alpns and inbound_alps, separately, with the same vector argument.
-    struct alpns
-    {
-        std::vector<ustring> inout_alpns;
-        explicit alpns(std::vector<ustring> alpns = {}) : inout_alpns{std::move(alpns)} {}
+            // Convenience wrapper that sets a single ALPN value from a regular string:
+            explicit inbound_alpns(std::string_view alpn) : inbound_alpns{{ustring{to_usv(alpn)}}} {}
+        };
 
-        // Convenience wrapper that sets a single ALPN value from a regular string:
-        explicit alpns(std::string_view alpn) : alpns{{ustring{to_usv(alpn)}}} {}
-    };
+        // Sets the inbound and outbound ALPNs simulatneous to the same value(s).  This is equivalent to
+        // passing outbound_alpns and inbound_alps, separately, with the same vector argument.
+        struct alpns
+        {
+            std::vector<ustring> inout_alpns;
+            explicit alpns(std::vector<ustring> alpns = {}) : inout_alpns{std::move(alpns)} {}
 
-    struct handshake_timeout
-    {
-        std::chrono::nanoseconds timeout;
-        explicit handshake_timeout(std::chrono::nanoseconds ns = 0ns) : timeout{ns} {}
-    };
-
-    // Used to provide precalculated static secret data for an endpoint to use for validation
-    // tokens.  If not provided, 32 random bytes are generated during endpoint construction.  The
-    // data provided must be (at least) SECRET_MIN_SIZE long (longer values are ignored).  For a
-    // deterministic value you should not pass sensitive data here (such as a raw private key), but
-    // instead use a cryptographically secure hash (ideally with a unique key or suffix) of such
-    // data.
-    struct static_secret
-    {
-        inline static constexpr size_t SECRET_MIN_SIZE = 16;
+            // Convenience wrapper that sets a single ALPN value from a regular string:
+            explicit alpns(std::string_view alpn) : alpns{{ustring{to_usv(alpn)}}} {}
+        };
 
-        ustring secret;
-        explicit static_secret(ustring s) : secret{std::move(s)}
+        struct handshake_timeout
+        {
+            std::chrono::nanoseconds timeout;
+            explicit handshake_timeout(std::chrono::nanoseconds ns = 0ns) : timeout{ns} {}
+        };
+
+        // If non-zero, this sets a keep-alive timer for outgoing PINGs on this connection so that a
+        // functioning but idle connection can stay alive indefinitely without hitting the connection's
+        // idle timeout.  Typically in designing a protocol you need only one side to send pings; the
+        // responses to a ping keep the connection in the other direction alive.  This value should
+        // typically be lower than the idle_timeout of both sides of the connection to be effective.
+        //
+        // If this option is not specified or is set to a duration of 0 then outgoing PINGs will not be
+        // sent on the connection.
+        struct keep_alive
+        {
+            std::chrono::milliseconds time{0ms};
+            keep_alive() = default;
+            explicit keep_alive(std::chrono::milliseconds val) : time{val} {}
+        };
+
+        // Can be used to override the default (30s) maximum idle timeout for a connection.  Note that
+        // this is negotiated during connection establishment, and the lower value advertised by each
+        // side will be used for the connection.  Can be 0 to disable idle timeout entirely, but such an
+        // option has caveats for connections across unknown internet boxes (see comments in RFC 9000,
+        // section 10.1.2).
+        struct idle_timeout
+        {
+            std::chrono::milliseconds timeout{DEFAULT_IDLE_TIMEOUT};
+            idle_timeout() = default;
+            explicit idle_timeout(std::chrono::milliseconds val) : timeout{val} {}
+        };
+
+        /// This can be initialized a few different ways. Simply passing a default constructed struct
+        /// to Network::Endpoint(...) will enable datagrams without packet-splitting. From there, pass
+        /// `Splitting::ACTIVE` to the constructor to enable packet-splitting.
+        ///
+        /// The size of the rotating datagram buffer can also be specified as a second parameter to the
+        /// constructor. Buffer size is subdivided amongst 4 equally sized buffer rows, so the bufsize
+        /// must be perfectly divisible by 4
+        ///
+        /// In some use cases, the user may want the receive data as a string view or a string literal.
+        /// The default is string literal; setting
+        ///
+        /// The max size of a transmittable datagram can be queried directly from connection_interface::
+        /// get_max_datagram_size(). At connection initialization, ngtcp2 will default this value to 1200.
+        /// The actual value is negotiated upwards via path discovery, reaching a theoretical maximum of
+        /// NGTCP2_MAX_PMTUD_UDP_PAYLOAD_SIZE (1452), or near it, per datagram. Please note that enabling
+        /// datagram splitting will double whatever value is returned.
+        ///
+        /// Note: this setting CANNOT be changed for an endpoint after creation, it must be
+        /// destroyed and re-initialized with the desired settings.
+        struct enable_datagrams
+        {
+            bool split_packets{false};
+            Splitting mode{Splitting::NONE};
+            // Note: this is the size of the entire buffer, divided amongst 4 rows
+            int bufsize{4096};
+
+            enable_datagrams() = default;
+            explicit enable_datagrams(bool e) = delete;
+            explicit enable_datagrams(Splitting m) : split_packets{true}, mode{m} {}
+            explicit enable_datagrams(Splitting m, int b) : split_packets{true}, mode{m}, bufsize{b}
+            {
+                if (b <= 0)
+                    throw std::out_of_range{"Bufsize must be positive"};
+                if (b > 1 << 14)
+                    throw std::out_of_range{"Bufsize too large"};
+                if (b % 4 != 0)
+                    throw std::invalid_argument{"Bufsize must be evenly divisible between 4 rows"};
+            }
+        };
+
+        // Used to provide precalculated static secret data for an endpoint to use for validation
+        // tokens.  If not provided, 32 random bytes are generated during endpoint construction.  The
+        // data provided must be (at least) SECRET_MIN_SIZE long (longer values are ignored).  For a
+        // deterministic value you should not pass sensitive data here (such as a raw private key), but
+        // instead use a cryptographically secure hash (ideally with a unique key or suffix) of such
+        // data.
+        struct static_secret
+        {
+            inline static constexpr size_t SECRET_MIN_SIZE = 16;
+
+            ustring secret;
+            explicit static_secret(ustring s) : secret{std::move(s)}
+            {
+                if (secret.size() < SECRET_MIN_SIZE)
+                    throw std::invalid_argument{
+                            "opt::static_secret requires data of at least " + std::to_string(SECRET_MIN_SIZE) + "bytes"};
+            }
+        };
+
+        // Used to provide a callback that bypasses sending packets out through the UDP socket. The passing of
+        // this opt will also bypass the creation of the UDP socket entirely. The application will also need to
+        // take responsibility for passing packets into the Endpoint via Endpoint::manually_receive_packet(...)
+        struct manual_routing
         {
-            if (secret.size() < SECRET_MIN_SIZE)
-                throw std::invalid_argument{
-                        "opt::static_secret requires data of at least " + std::to_string(SECRET_MIN_SIZE) + "bytes"};
-        }
-    };
+            using send_handler_t = std::function<void(const Path&, bstring_view)>;
+
+          private:
+            friend Endpoint;
+
+            manual_routing() = default;
+
+            send_handler_t send_hook = nullptr;
+
+          public:
+            explicit manual_routing(send_handler_t cb) : send_hook{std::move(cb)}
+            {
+                if (not send_hook)
+                    throw std::runtime_error{"opt::manual_routing must be constructed with a send handler hook!"};
+            }
+
+            io_result operator()(const Path& p, bstring_view data, size_t& n)
+            {
+                send_hook(p, data);
+                n = 0;
+                return io_result{};
+            }
 
-}  // namespace oxen::quic::opt
+            explicit operator bool() const { return send_hook != nullptr; }
+        };
+    }  //  namespace opt
+}  // namespace oxen::quic

include/oxen/quic/opt.hpp

@@ -14,6 +14,7 @@ extern "C"
 #include <event2/event.h>
 
 #include <cstdint>
+#include <variant>
 
 #include "address.hpp"
 #include "types.hpp"
@@ -33,11 +34,24 @@ namespace oxen::quic
     struct Packet
     {
         Path path;
-        bstring_view data;
         ngtcp2_pkt_info pkt_info{};
-
-        /// Constructs a packet from a path and data:
-        Packet(Path p, bstring_view d) : path{std::move(p)}, data{std::move(d)} {}
+        std::variant<bstring_view, bstring> pkt_data;
+
+        template <typename Char = std::byte, typename = std::enable_if_t<sizeof(Char) == 1>>
+        std::basic_string_view<Char> data() const
+        {
+            return std::visit(
+                    [](const auto& d) {
+                        return std::basic_string_view<Char>{reinterpret_cast<const Char*>(d.data()), d.size()};
+                    },
+                    pkt_data);
+        }
+
+        /// Constructs a packet from a path and data view:
+        Packet(Path p, bstring_view d) : path{std::move(p)}, pkt_data{std::move(d)} {}
+
+        /// Constructs a packet from a path and transferred data:
+        Packet(Path p, bstring&& d) : path{std::move(p)}, pkt_data{std::move(d)} {}
 
         /// Constructs a packet from a local address, data, and the IP header; remote addr and ECN
         /// data are extracted from the header.