lokinet/llarp/iwp/linklayer.hpp

#pragma once

#include <llarp/constants/link_layer.hpp>
#include <llarp/crypto/crypto.hpp>
#include <llarp/crypto/encrypted.hpp>
#include <llarp/crypto/types.hpp>
#include <llarp/link/server.hpp>
#include <llarp/config/key_manager.hpp>

#include <memory>

#include <llarp/ev/ev.hpp>

namespace llarp::iwp
{
  struct Session;

  struct LinkLayer final : public ILinkLayer
  {
    LinkLayer(
        std::shared_ptr<KeyManager> keyManager,
        std::shared_ptr<EventLoop> ev,
        GetRCFunc getrc,
        LinkMessageHandler h,
        SignBufferFunc sign,
        BeforeConnectFunc_t before,
        SessionEstablishedHandler est,
        SessionRenegotiateHandler reneg,
        TimeoutHandler timeout,
        SessionClosedHandler closed,
        PumpDoneHandler pumpDone,
        WorkerFunc_t dowork,
        bool permitInbound);

    std::shared_ptr<ILinkSession>
    NewOutboundSession(const RouterContact& rc, const AddressInfo& ai) override;

    std::string_view
    Name() const override;

    uint16_t
    Rank() const override;

    void
    RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt) override;

    void
    WakeupPlaintext();

    std::string
    PrintableName() const;

   private:
    void
    HandleWakeupPlaintext();

    const std::shared_ptr<EventLoopWakeup> m_Wakeup;
    std::vector<ILinkSession*> m_WakingUp;
    const bool m_Inbound;
  };

  using LinkLayer_ptr = std::shared_ptr<LinkLayer>;
}  // namespace llarp::iwp
standardize include format and pragma once All #ifndef guards on headers have been removed, I think, in favor of #pragma once Headers are now included as `#include "filename"` if the included file resides in the same directory as the file including it, or any subdirectory therein. Otherwise they are included as `#include <project/top/dir/relative/path/filename>` The above does not include system/os headers. 2021-03-09 22:24:35 +00:00			`#pragma once`
Refactor iwp into multiple files 2019-03-29 14:30:19 +00:00
standardize include format and pragma once All #ifndef guards on headers have been removed, I think, in favor of #pragma once Headers are now included as `#include "filename"` if the included file resides in the same directory as the file including it, or any subdirectory therein. Otherwise they are included as `#include <project/top/dir/relative/path/filename>` The above does not include system/os headers. 2021-03-09 22:24:35 +00:00			`#include <llarp/constants/link_layer.hpp>`
			`#include <llarp/crypto/crypto.hpp>`
			`#include <llarp/crypto/encrypted.hpp>`
			`#include <llarp/crypto/types.hpp>`
			`#include <llarp/link/server.hpp>`
			`#include <llarp/config/key_manager.hpp>`
feedback from tom. * remove unneeded header. * fix typo in docs 2021-02-23 10:48:50 +00:00
Handle link transport key in KeyManager 2019-12-03 17:58:53 +00:00			`#include <memory>`
Refactor iwp into multiple files 2019-03-29 14:30:19 +00:00
standardize include format and pragma once All #ifndef guards on headers have been removed, I think, in favor of #pragma once Headers are now included as `#include "filename"` if the included file resides in the same directory as the file including it, or any subdirectory therein. Otherwise they are included as `#include <project/top/dir/relative/path/filename>` The above does not include system/os headers. 2021-03-09 22:24:35 +00:00			`#include <llarp/ev/ev.hpp>`
try coleasing inbound packets from iwp 2021-02-22 13:26:32 +00:00
			`namespace llarp::iwp`
Refactor iwp into multiple files 2019-03-29 14:30:19 +00:00			`{`
try coleasing inbound packets from iwp 2021-02-22 13:26:32 +00:00			`struct Session;`

			`struct LinkLayer final : public ILinkLayer`
Refactor iwp into multiple files 2019-03-29 14:30:19 +00:00			`{`
try coleasing inbound packets from iwp 2021-02-22 13:26:32 +00:00			`LinkLayer(`
			`std::shared_ptr<KeyManager> keyManager,`
			`std::shared_ptr<EventLoop> ev,`
			`GetRCFunc getrc,`
			`LinkMessageHandler h,`
			`SignBufferFunc sign,`
			`BeforeConnectFunc_t before,`
			`SessionEstablishedHandler est,`
			`SessionRenegotiateHandler reneg,`
			`TimeoutHandler timeout,`
			`SessionClosedHandler closed,`
			`PumpDoneHandler pumpDone,`
			`WorkerFunc_t dowork,`
			`bool permitInbound);`

			`std::shared_ptr<ILinkSession>`
			`NewOutboundSession(const RouterContact& rc, const AddressInfo& ai) override;`

Fix multi-field < ordering 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. 2022-10-13 17:19:25 +00:00			`std::string_view`
try coleasing inbound packets from iwp 2021-02-22 13:26:32 +00:00			`Name() const override;`

			`uint16_t`
			`Rank() const override;`

			`void`
			`RecvFrom(const SockAddr& from, ILinkSession::Packet_t pkt) override;`

			`void`
			`WakeupPlaintext();`

more information in logs 2021-07-01 12:30:29 +00:00			`std::string`
			`PrintableName() const;`

try coleasing inbound packets from iwp 2021-02-22 13:26:32 +00:00			`private:`
			`void`
			`HandleWakeupPlaintext();`

Replace libuv with uvw & related refactoring - removes all the llarp_ev_* functions, replacing with methods/classes/functions in the llarp namespace. - banish ev/ev.h to the void - Passes various things by const lvalue ref, especially shared_ptr's that don't need to be copied (to avoid an atomic refcount increment/decrement). - Add a llarp::UDPHandle abstract class for UDP handling - Removes the UDP tick handler; code that needs tick can just do a separate handler on the event loop outside the UDP socket. - Adds an "OwnedBuffer" which owns its own memory but is implicitly convertible to a llarp_buffer_t. This is mostly needed to take over ownership of buffers from uvw without copying them as, currently, uvw does its own allocation (pending some open upstream issues/PRs). - Logic: - add `make_caller`/`call_forever`/`call_every` utility functions to abstract Call wrapping and dependent timed tasks. - Add inLogicThread() so that code can tell its inside the logic thread (typically for debugging assertions). - get rid of janky integer returns and dealing with cancellations on call_later: the other methods added here and the event loop code remove the need for them. - Event loop: - redo everything with uvw instead of libuv - rename EventLoopWakeup::Wakeup to EventLoopWakeup::Trigger to better reflect what it does. - add EventLoopRepeater for repeated events, and replace the code that reschedules itself every time it is called with a repeater. - Split up `EventLoop::run()` into a non-virtual base method and abstract `run_loop()` methods; the base method does a couple extra setup/teardown things that don't need to be in the derived class. - udp_listen is replaced with ev->udp(...) which returns a new UDPHandle object rather that needing gross C-style-but-not-actually-C-compatible structs. - Remove unused register_poll_fd_(un)readable - Use shared_ptr for EventLoopWakeup rather than returning a raw pointer; uvw lets us not have to worry about having the event loop class maintain ownership of it. - Add factory EventLoop::create() function to create a default (uvw-based) event loop (previously this was one of the llarp_ev_blahblah unnamespaced functions). - ev_libuv: this is mostly rewritten; all of the glue code/structs, in particular, are gone as they are no longer needed with uvw. - DNS: - Rename DnsHandler to DnsInterceptor to better describe what it does (this is the code that intercepts all DNS to the tun IP range for Android). - endpoint: - remove unused "isolated network" code - remove distinct (but actually always the same) variables for router/endpoint logic objects - llarp_buffer_t - make constructors type-safe against being called with points to non-size-1 values - tun packet reading: - read all available packets off the device/file descriptor; previously we were reading one packet at a time then returning to the event loop to poll again. - ReadNextPacket() now returns a 0-size packet if the read would block (so that we can implement the previous point). - ReadNextPacket() now throws on I/O error - Miscellaneous code cleanups/simplifications 2021-03-02 02:06:20 +00:00			`const std::shared_ptr<EventLoopWakeup> m_Wakeup;`
Fix link layer delivery race condition (fix random ping delays) We trigger a pump immediately, but this is racey because we add to our plaintext data in a worker thread; if the worker thread runs after the pump then it ends up leaving plaintext to be handled, but there's no wakeup until the next one. This was the cause of seeing a random +1s and bunching added to ping responses sometimes: it wasn't until the next ping goes through the network that the plaintext queue gets processed, at which point it flushes the old one and often the new one together. The fix here gets rid of the map of sessions needing wakeups and instead adds an atomic flag to all of them to let us figure out which ones need to be flushed. 2021-11-11 21:46:53 +00:00			`std::vector<ILinkSession*> m_WakingUp;`
* add log warn * throw if inbound link makes outbound session 2021-07-01 12:14:43 +00:00			`const bool m_Inbound;`
try coleasing inbound packets from iwp 2021-02-22 13:26:32 +00:00			`};`

			`using LinkLayer_ptr = std::shared_ptr<LinkLayer>;`
			`} // namespace llarp::iwp`