- Packets coming in and out of full clients need their IP src/dest addresses re-written
- Lokinet's TUN device sucks up all packets aimed at the if range, correctly addressing them to the proper outbound
- On reception, lokinet's TUN device addresses correctly for the mapped application receiving the packet
- Brought a lil somethin' somethin' from libquic for CI
- Bump oxenmq to cpp20 branch
- Revert cpr to 1.9 stable for subproject curl dep bug
- link::TunnelManager will be re-implemented in link::QUICTunnel to make and accept TCP connections
- Will be simplified using Libevent and hooked into the new LocalEndpoint/RemoteHandler model
- TCP{Handle,Socket} ownership model will be revised to more monadic model; this will allow the TCPSockets (sockets representing accepted connections) to function entirely independantly of the bound socket
- cleaned up config parsing using the better Address/IP types and quic::Address where appropriate
- created new templated address_map using concepts constraining local types to quic::Address and IPRange, and remote types to {Client,Relay}Address
- now the correct local addresses and ranges can be passed to the correct handlers and endpoints for remote and local exit/service operation
- basically fully configured ::RemoteHandler
- deleted deprecated object files previously removed from compilation
- Deprecate pathset, smashed into PathBuilder (renamed to PathHandler)
- Re-abstraction of sessions and PathHandlers
- Renamed PathBuilder -> PathHandler to more accurately reflect purpose
- {Service,Exit}Handler will remain as PathHandlers, though currently no path-sharing amongst sessions being managed is to be implemented. Handlers will maintain their own paths for both lookups and initiating sessions, while sessions will manage their paths independantly.
- Session object handling necessitates the differentiation between outbound and inbound sessions. Initiators of sessions are entirely responsible for dictating the chosen path on which the session communicates, and must therefore continually build and manage paths for the negotiated session.
- Outbound sessions are now {Service,Exit}Sessions
- Inbound sessions are implemented with InboundSession, which is agnostic to the type of service being operated locally (service vs exit, client vs relay, etc). When the Session initiator signals a switch to a different path, it will be assigned to the InboundSession object by {Service,Exit}Endpoint, which manages local services and exits
- includes are now sorted in consistent, logical order; first step in an attempt to fix the tomfoolery (no relation to Tom) brought in by include-what-you-use
- shuffled around some cmake linking to simplify dependency graph
- superfluous files removed
- routing messages and surrounding code
- shim code in place for iteration and optimization after deciding what to do with buffer, string handling, and subsequent function calls
Lots and lots of places in the code had broken < operators because they
are returning something like:
foo < other.foo or bar < other.bar;
but this breaks both the strict weak ordering requirements that are
required for the "Compare" requirement for things like
std::map/set/priority_queue.
For example:
a = {.foo=1, .bar=3}
b = {.foo=3, .bar=1}
does not have an ordering over a and b (both `a < b` and `b < a` are
satisfied at the same time).
This needs to be instead something like:
foo < other.foo or (foo == other.foo and bar < other.bar)
but that's a bit clunkier, and it is easier to use std::tie for tuple's
built-in < comparison which does the right thing:
std::tie(foo, bar) < std::tie(other.foo, other.bar)
(Initially I noticed this in SockAddr/sockaddr_in6, but upon further
investigation this extends to the major of multi-field `operator<`'s.)
This fixes it by using std::tie (or something similar) everywhere we are
doing multi-field inequalities.
dr7ana
Jason Rhinelander
Jeff Becker