llarp/path/ihophandler.hpp

Namespaces

Name
llarp [crypto.hpp]
llarp::routing
llarp::path

Classes

	Name
struct	llarp::path::IHopHandler

Source code

#pragma once

#include <llarp/crypto/types.hpp>
#include <llarp/util/types.hpp>
#include <llarp/crypto/encrypted_frame.hpp>
#include <llarp/util/decaying_hashset.hpp>
#include <llarp/messages/relay.hpp>
#include <vector>

#include <memory>

struct llarp_buffer_t;

namespace llarp
{
  struct AbstractRouter;
}

namespace llarp::routing
{
  struct IMessage;
}

namespace llarp::path
{
  struct IHopHandler
  {
    using TrafficEvent_t = std::pair<std::vector<byte_t>, TunnelNonce>;

    virtual ~IHopHandler() = default;

    virtual PathID_t
    RXID() const = 0;

    virtual void DecayFilters(llarp_time_t){};

    virtual bool
    Expired(llarp_time_t now) const = 0;

    virtual bool
    ExpiresSoon(llarp_time_t now, llarp_time_t dlt) const = 0;

    virtual bool
    SendRoutingMessage(const routing::IMessage& msg, AbstractRouter* r) = 0;

    // handle data in upstream direction
    virtual bool
    HandleUpstream(const llarp_buffer_t& X, const TunnelNonce& Y, AbstractRouter* r) = 0;
    // handle data in downstream direction
    virtual bool
    HandleDownstream(const llarp_buffer_t& X, const TunnelNonce& Y, AbstractRouter* r) = 0;

    virtual llarp_time_t
    LastRemoteActivityAt() const = 0;

    virtual bool
    HandleLRSM(uint64_t status, std::array<EncryptedFrame, 8>& frames, AbstractRouter* r) = 0;

    uint64_t
    NextSeqNo()
    {
      return m_SequenceNum++;
    }

   protected:
    uint64_t m_SequenceNum = 0;

    virtual void
    HandleAllUpstream(std::vector<RelayUpstreamMessage> msgs, AbstractRouter* r) = 0;
    virtual void
    HandleAllDownstream(std::vector<RelayDownstreamMessage> msgs, AbstractRouter* r) = 0;
  };

  using HopHandler_ptr = std::shared_ptr<IHopHandler>;

}  // namespace llarp::path

---

Updated on 2026-04-01 at 23:35:40 +0000