- It became increasingly tedious to partition the address types between {Client,Relay}Address, as a client can operate an exit or hidden service while a relay could also be operating a hidden service. The client's hidden service would terminate in a `.loki` while the relay's would terminate in a `.snode`, complicating the ONS logic implemented in ClientAddress
- Address types were partitioned into {Network,Relay}Address; NetworkAddress conceptually encapsulates all remote hidden services (agnostic of client vs relay) and exit nodes being operated on the network: RelayAddress specifically designates an addressible relay to be used in scopes excluding hidden services and exit nodes
- 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
- there is one key difference between the address classes: ClientAddress can be constructed with an ONS name, and can therefore exist in one of 2 dual states (pubkey vs ONS)
- 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
- When two relays are repeatedly attempting connections to one another simultaneously, the connection initiated by the RouterID that appears first (in lexicographical order) is deferred to. The connection initiated by the other endpoint is marked to close quietly (w/o executing callbacks), and is rejected in the TLS verification hook
- Bypassing callback execution is critical, as it will clean-up the link::Connection object for the connection that is being deferred to; this results in BOTH connections being destroyed.
- removed superfluous typedefs obfuscating what is actually happening
- Builder -> PathBuilder; next is moving PathSet into PathBuilder
- enum -> enum class where appropriate
- ran linter