llarp/handlers/null.hpp

Namespaces

Name
llarp [crypto.hpp]
llarp::handlers

Classes

	Name
struct	llarp::handlers::NullEndpoint

Source code

#pragma once

#include <cstdint>
#include <llarp/service/endpoint.hpp>
#include <llarp/service/protocol_type.hpp>
#include <llarp/router/abstractrouter.hpp>
#include <llarp/ev/ev.hpp>
#include <llarp/vpn/egres_packet_router.hpp>
#include <llarp/net/ip_packet.hpp>
#include <llarp/util/buffer.hpp>

namespace llarp::handlers
{
  struct NullEndpoint final : public llarp::service::Endpoint,
                              public std::enable_shared_from_this<NullEndpoint>
  {
    NullEndpoint(AbstractRouter* r, llarp::service::Context* parent)
        : llarp::service::Endpoint{r, parent}
        , m_PacketRouter{new vpn::EgresPacketRouter{[](auto from, auto pkt) {
          var::visit(
              [&pkt](auto&& from) {
                LogError("unhandled traffic from: ", from, " of ", pkt.size(), " bytes");
              },
              from);
        }}}
    {
      r->loop()->add_ticker([this] { Pump(Now()); });
    }

    virtual bool
    HandleInboundPacket(
        const service::ConvoTag tag,
        const llarp_buffer_t& buf,
        service::ProtocolType t,
        uint64_t) override
    {
      LogTrace("Inbound ", t, " packet (", buf.sz, "B) on convo ", tag);
      if (t == service::ProtocolType::Control)
      {
        return true;
      }
      if (t == service::ProtocolType::TrafficV4 or t == service::ProtocolType::TrafficV6)
      {
        if (auto from = GetEndpointWithConvoTag(tag))
        {
          net::IPPacket pkt{};
          if (not pkt.Load(buf))
          {
            LogWarn("invalid ip packet from remote T=", tag);
            return false;
          }
          m_PacketRouter->HandleIPPacketFrom(std::move(*from), std::move(pkt));
          return true;
        }
        else
        {
          LogWarn("did not handle packet, no endpoint with convotag T=", tag);
          return false;
        }
      }
      if (t == service::ProtocolType::QUIC)
        return false;
      return true;
    }

    std::string
    GetIfName() const override
    {
      return "";
    }

    path::PathSet_ptr
    GetSelf() override
    {
      return shared_from_this();
    }

    std::weak_ptr<path::PathSet>
    GetWeak() override
    {
      return weak_from_this();
    }

    bool
    SupportsV6() const override
    {
      return false;
    }

    void
    SendPacketToRemote(const llarp_buffer_t&, service::ProtocolType) override{};

    net::ipv6addr_t
    ObtainIPForAddr(std::variant<service::Address, RouterID>) override
    {
      return {0};
    }

    std::optional<std::variant<service::Address, RouterID>>
    ObtainAddrForIP(net::ipv6addr_t) const override
    {
      return std::nullopt;
    }

    vpn::EgresPacketRouter*
    EgresPacketRouter() override
    {
      return m_PacketRouter.get();
    }

   private:
    std::unique_ptr<vpn::EgresPacketRouter> m_PacketRouter;
  };
}  // namespace llarp::handlers

---

Updated on 2026-01-10 at 22:49:45 +0000