---
title: llarp
summary: crypto.hpp

---

# llarp

[crypto.hpp] [More...](#detailed-description)

## Namespaces

| Name           |
| -------------- |
| **[llarp::apple](Namespaces/namespacellarp_1_1apple.md)**  |
| **[llarp::bits](Namespaces/namespacellarp_1_1bits.md)**  |
| **[llarp::config](Namespaces/namespacellarp_1_1config.md)**  |
| **[llarp::consensus](Namespaces/namespacellarp_1_1consensus.md)**  |
| **[llarp::constants](Namespaces/namespacellarp_1_1constants.md)**  |
| **[llarp::detail](Namespaces/namespacellarp_1_1detail.md)**  |
| **[llarp::dht](Namespaces/namespacellarp_1_1dht.md)**  |
| **[llarp::dns](Namespaces/namespacellarp_1_1dns.md)**  |
| **[llarp::exit](Namespaces/namespacellarp_1_1exit.md)**  |
| **[llarp::handlers](Namespaces/namespacellarp_1_1handlers.md)**  |
| **[llarp::iwp](Namespaces/namespacellarp_1_1iwp.md)**  |
| **[llarp::json](Namespaces/namespacellarp_1_1json.md)**  |
| **[llarp::log_detail](Namespaces/namespacellarp_1_1log__detail.md)**  |
| **[llarp::logging](Namespaces/namespacellarp_1_1logging.md)**  |
| **[llarp::net](Namespaces/namespacellarp_1_1net.md)**  |
| **[llarp::path](Namespaces/namespacellarp_1_1path.md)**  |
| **[llarp::platform](Namespaces/namespacellarp_1_1platform.md)** <br>namespace for platform feature detection constexprs  |
| **[llarp::quic](Namespaces/namespacellarp_1_1quic.md)**  |
| **[llarp::routing](Namespaces/namespacellarp_1_1routing.md)**  |
| **[llarp::rpc](Namespaces/namespacellarp_1_1rpc.md)**  |
| **[llarp::service](Namespaces/namespacellarp_1_1service.md)**  |
| **[llarp::simulate](Namespaces/namespacellarp_1_1simulate.md)**  |
| **[llarp::sodium](Namespaces/namespacellarp_1_1sodium.md)**  |
| **[llarp::thread](Namespaces/namespacellarp_1_1thread.md)**  |
| **[llarp::util](Namespaces/namespacellarp_1_1util.md)**  |
| **[llarp::uv](Namespaces/namespacellarp_1_1uv.md)**  |
| **[llarp::vpn](Namespaces/namespacellarp_1_1vpn.md)**  |
| **[llarp::win32](Namespaces/namespacellarp_1_1win32.md)**  |

## Classes

|                | Name           |
| -------------- | -------------- |
| struct | **[llarp::BootstrapList](Classes/structllarp_1_1BootstrapList.md)**  |
| struct | **[llarp::ConfigGenParameters](Classes/structllarp_1_1ConfigGenParameters.md)** <br>Small struct to gather all parameters needed for config generation to reduce the number of parameters that need to be passed around.  |
| struct | **[llarp::RouterConfig](Classes/structllarp_1_1RouterConfig.md)**  |
| struct | **[llarp::PeerSelectionConfig](Classes/structllarp_1_1PeerSelectionConfig.md)** <br>config for path hop selection  |
| struct | **[llarp::NetworkConfig](Classes/structllarp_1_1NetworkConfig.md)**  |
| struct | **[llarp::DnsConfig](Classes/structllarp_1_1DnsConfig.md)**  |
| struct | **[llarp::LinksConfig](Classes/structllarp_1_1LinksConfig.md)**  |
| struct | **[llarp::ConnectConfig](Classes/structllarp_1_1ConnectConfig.md)**  |
| struct | **[llarp::ApiConfig](Classes/structllarp_1_1ApiConfig.md)**  |
| struct | **[llarp::LokidConfig](Classes/structllarp_1_1LokidConfig.md)**  |
| struct | **[llarp::BootstrapConfig](Classes/structllarp_1_1BootstrapConfig.md)**  |
| struct | **[llarp::LoggingConfig](Classes/structllarp_1_1LoggingConfig.md)**  |
| struct | **[llarp::Config](Classes/structllarp_1_1Config.md)**  |
| struct | **[llarp::OptionDefinitionBase](Classes/structllarp_1_1OptionDefinitionBase.md)** <br>A base class for specifying config options and their constraints.  |
| struct | **[llarp::OptionDefinition](Classes/structllarp_1_1OptionDefinition.md)** <br>The primary type-aware implementation of [OptionDefinitionBase](Classes/structllarp_1_1OptionDefinitionBase.md), this templated class allows for implementations which can use the std::ostringstream and std::istringstream for to/from string functionality.  |
| struct | **[llarp::ConfigDefinition](Classes/structllarp_1_1ConfigDefinition.md)** <br>A [ConfigDefinition]() holds an ordered set of OptionDefinitions defining the allowable values and their constraints (specified through calls to [defineOption()]()).  |
| struct | **[llarp::ConfigParser](Classes/structllarp_1_1ConfigParser.md)**  |
| struct | **[llarp::KeyManager](Classes/structllarp_1_1KeyManager.md)** <br>[KeyManager]() manages the cryptographic keys stored on disk for the local node.  |
| struct | **[llarp::Crypto](Classes/structllarp_1_1Crypto.md)** <br>library crypto configuration  |
| struct | **[llarp::CryptoManager](Classes/structllarp_1_1CryptoManager.md)**  |
| struct | **[llarp::CSRNG](Classes/structllarp_1_1CSRNG.md)** <br>rng type that uses [llarp::randint()](Namespaces/namespacellarp.md#function-randint), which is cryptographically secure  |
| struct | **[llarp::Encrypted](Classes/structllarp_1_1Encrypted.md)** <br>encrypted buffer base type  |
| struct | **[llarp::EncryptedFrame](Classes/structllarp_1_1EncryptedFrame.md)**  |
| struct | **[llarp::AsyncFrameDecrypter](Classes/structllarp_1_1AsyncFrameDecrypter.md)**  |
| struct | **[llarp::PubKey](Classes/structllarp_1_1PubKey.md)**  |
| struct | **[llarp::SecretKey](Classes/structllarp_1_1SecretKey.md)** <br>Stores a sodium "secret key" value, which is actually the seed concatenated with the public key.  |
| struct | **[llarp::PrivateKey](Classes/structllarp_1_1PrivateKey.md)** <br>[PrivateKey]() is similar to [SecretKey](Classes/structllarp_1_1SecretKey.md) except that it only stores the private key value and a hash, unlike [SecretKey](Classes/structllarp_1_1SecretKey.md) which stores the seed from which the private key and hash value are generated.  |
| struct | **[llarp::IdentitySecret](Classes/structllarp_1_1IdentitySecret.md)** <br>[IdentitySecret]() is a secret key from a service node secret seed.  |
| struct | **[llarp::Signature](Classes/structllarp_1_1Signature.md)**  |
| class | **[llarp::EndpointBase](Classes/classllarp_1_1EndpointBase.md)**  |
| class | **[llarp::EventLoopWakeup](Classes/classllarp_1_1EventLoopWakeup.md)** <br>distinct event loop waker upper; used to idempotently schedule a task on the next event loop  |
| class | **[llarp::EventLoopRepeater](Classes/classllarp_1_1EventLoopRepeater.md)** <br>holds a repeated task on the event loop; the task is removed on destruction  |
| class | **[llarp::EventLoop](Classes/classllarp_1_1EventLoop.md)**  |
| struct | **[llarp::UDPHandle](Classes/structllarp_1_1UDPHandle.md)**  |
| struct | **[llarp::LinkFactory](Classes/structllarp_1_1LinkFactory.md)** <br>[LinkFactory]() is responsible for returning std::functions that create the link layer types.  |
| struct | **[llarp::ILinkManager](Classes/structllarp_1_1ILinkManager.md)**  |
| struct | **[llarp::LinkManager](Classes/structllarp_1_1LinkManager.md)**  |
| struct | **[llarp::ILinkLayer](Classes/structllarp_1_1ILinkLayer.md)**  |
| struct | **[llarp::SessionStats](Classes/structllarp_1_1SessionStats.md)**  |
| struct | **[llarp::ILinkSession](Classes/structllarp_1_1ILinkSession.md)**  |
| struct | **[llarp::DHTImmediateMessage](Classes/structllarp_1_1DHTImmediateMessage.md)**  |
| struct | **[llarp::DiscardMessage](Classes/structllarp_1_1DiscardMessage.md)**  |
| struct | **[llarp::LinkIntroMessage](Classes/structllarp_1_1LinkIntroMessage.md)**  |
| struct | **[llarp::ILinkMessage](Classes/structllarp_1_1ILinkMessage.md)** <br>parsed link layer message  |
| struct | **[llarp::LinkMessageParser](Classes/structllarp_1_1LinkMessageParser.md)**  |
| struct | **[llarp::RelayUpstreamMessage](Classes/structllarp_1_1RelayUpstreamMessage.md)**  |
| struct | **[llarp::RelayDownstreamMessage](Classes/structllarp_1_1RelayDownstreamMessage.md)**  |
| struct | **[llarp::LR_CommitRecord](Classes/structllarp_1_1LR__CommitRecord.md)**  |
| struct | **[llarp::LR_CommitMessage](Classes/structllarp_1_1LR__CommitMessage.md)**  |
| struct | **[llarp::LR_StatusRecord](Classes/structllarp_1_1LR__StatusRecord.md)**  |
| struct | **[llarp::LR_StatusMessage](Classes/structllarp_1_1LR__StatusMessage.md)**  |
| struct | **[llarp::AddressInfo](Classes/structllarp_1_1AddressInfo.md)**  |
| struct | **[llarp::ExitInfo](Classes/structllarp_1_1ExitInfo.md)** <br>deprecated don't use me , this is only for backwards compat  |
| struct | **[llarp::IpAddress](Classes/structllarp_1_1IpAddress.md)** <br>A struct that can represent either an IPv4 or IPv6 address.  |
| struct | **[llarp::IPRange](Classes/structllarp_1_1IPRange.md)**  |
| struct | **[llarp::huint_t](Classes/structllarp_1_1huint__t.md)**  |
| struct | **[llarp::nuint_t](Classes/structllarp_1_1nuint__t.md)**  |
| struct | **[llarp::SockAddr](Classes/structllarp_1_1SockAddr.md)** <br>A simple [SockAddr]() wrapper which provides a sockaddr_in (IPv4).  |
| struct | **[llarp::uint128_t](Classes/structllarp_1_1uint128__t.md)** <br>128-bit unsigned integer.  |
| class | **[llarp::NodeDB](Classes/classllarp_1_1NodeDB.md)**  |
| struct | **[llarp::PathID_t](Classes/structllarp_1_1PathID__t.md)**  |
| struct | **[llarp::PeerDb](Classes/structllarp_1_1PeerDb.md)** <br>Maintains a database of stats collected about the connections with our Service Node peers.  |
| struct | **[llarp::PeerStats](Classes/structllarp_1_1PeerStats.md)**  |
| struct | **[llarp::PoW](Classes/structllarp_1_1PoW.md)** <br>proof of work  |
| struct | **[llarp::RouterProfile](Classes/structllarp_1_1RouterProfile.md)**  |
| struct | **[llarp::Profiling](Classes/structllarp_1_1Profiling.md)**  |
| struct | **[llarp::AbstractRouter](Classes/structllarp_1_1AbstractRouter.md)**  |
| struct | **[llarp::I_RCGossiper](Classes/structllarp_1_1I__RCGossiper.md)**  |
| struct | **[llarp::IOutboundMessageHandler](Classes/structllarp_1_1IOutboundMessageHandler.md)**  |
| struct | **[llarp::IOutboundSessionMaker](Classes/structllarp_1_1IOutboundSessionMaker.md)**  |
| struct | **[llarp::I_RCLookupHandler](Classes/structllarp_1_1I__RCLookupHandler.md)**  |
| struct | **[llarp::OutboundMessageHandler](Classes/structllarp_1_1OutboundMessageHandler.md)**  |
| struct | **[llarp::OutboundSessionMaker](Classes/structllarp_1_1OutboundSessionMaker.md)**  |
| struct | **[llarp::RCGossiper](Classes/structllarp_1_1RCGossiper.md)**  |
| struct | **[llarp::RCLookupHandler](Classes/structllarp_1_1RCLookupHandler.md)**  |
| struct | **[llarp::RoutePoker](Classes/structllarp_1_1RoutePoker.md)**  |
| struct | **[llarp::Router](Classes/structllarp_1_1Router.md)**  |
| struct | **[llarp::NetID](Classes/structllarp_1_1NetID.md)** <br>[NetID]().  |
| struct | **[llarp::RouterContact](Classes/structllarp_1_1RouterContact.md)** <br>[RouterContact]().  |
| struct | **[llarp::RouterID](Classes/structllarp_1_1RouterID.md)**  |
| struct | **[llarp::RouterVersion](Classes/structllarp_1_1RouterVersion.md)**  |
| struct | **[llarp::AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)** <br>aligned buffer that is sz bytes long and aligns to the nearest Alignment  |
| struct | **[llarp::OwnedBuffer](Classes/structllarp_1_1OwnedBuffer.md)**  |
| struct | **[llarp::ComparePtr](Classes/structllarp_1_1ComparePtr.md)** <br>type for comparing smart pointer's managed values  |
| struct | **[llarp::is_scoped_enum](Classes/structllarp_1_1is__scoped__enum.md)**  |
| struct | **[llarp::is_scoped_enum< T, true >](Classes/structllarp_1_1is__scoped__enum_3_01T_00_01true_01_4.md)**  |
| struct | **[llarp::LogTrace](Classes/structllarp_1_1LogTrace.md)**  |
| struct | **[llarp::LogDebug](Classes/structllarp_1_1LogDebug.md)**  |
| struct | **[llarp::LogInfo](Classes/structllarp_1_1LogInfo.md)**  |
| struct | **[llarp::LogWarn](Classes/structllarp_1_1LogWarn.md)**  |
| struct | **[llarp::LogError](Classes/structllarp_1_1LogError.md)**  |
| struct | **[llarp::buffer_printer](Classes/structllarp_1_1buffer__printer.md)**  |
| struct | **[llarp::CaselessLessThan](Classes/structllarp_1_1CaselessLessThan.md)**  |
| struct | **[llarp::time_delta](Classes/structllarp_1_1time__delta.md)**  |

## Types

|                | Name           |
| -------------- | -------------- |
| enum class| **[SendStatus](Namespaces/namespacellarp.md#enum-sendstatus)** { Success, Timeout, NoLink, InvalidRouter, RouterNotFound, Congestion} |
| enum class| **[SessionResult](Namespaces/namespacellarp.md#enum-sessionresult)** { Establish, Timeout, RouterNotFound, InvalidRouter, NoLink, EstablishFail} |
| enum class| **[RCRequestResult](Namespaces/namespacellarp.md#enum-rcrequestresult)** { Success, InvalidRouter, RouterNotFound, BadRC} |
| using llarp::ConfigParser::SectionValues_t | **[SectionValues_t](Namespaces/namespacellarp.md#using-sectionvalues-t)**  |
| using llarp::ConfigParser::Config_impl_t | **[Config_impl_t](Namespaces/namespacellarp.md#using-config-impl-t)**  |
| using std::function< void(std::string_view section, std::string_view name, std::string_view value)> | **[UndeclaredValueHandler](Namespaces/namespacellarp.md#using-undeclaredvaluehandler)**  |
| using std::unique_ptr< [OptionDefinitionBase](Classes/structllarp_1_1OptionDefinitionBase.md) > | **[OptionDefinition_ptr](Namespaces/namespacellarp.md#using-optiondefinition-ptr)**  |
| using std::unordered_map< std::string, OptionDefinition_ptr > | **[DefinitionMap](Namespaces/namespacellarp.md#using-definitionmap)**  |
| using std::unordered_map< std::string, DefinitionMap > | **[SectionMap](Namespaces/namespacellarp.md#using-sectionmap)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< SHAREDKEYSIZE > | **[SharedSecret](Namespaces/namespacellarp.md#using-sharedsecret)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< 32 > | **[KeyExchangeNonce](Namespaces/namespacellarp.md#using-keyexchangenonce)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< SHORTHASHSIZE > | **[ShortHash](Namespaces/namespacellarp.md#using-shorthash)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< HASHSIZE > | **[LongHash](Namespaces/namespacellarp.md#using-longhash)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< TUNNONCESIZE > | **[TunnelNonce](Namespaces/namespacellarp.md#using-tunnelnonce)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< NONCESIZE > | **[SymmNonce](Namespaces/namespacellarp.md#using-symmnonce)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< 32 > | **[SymmKey](Namespaces/namespacellarp.md#using-symmkey)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< PQ_CIPHERTEXTSIZE+1 > | **[PQCipherBlock](Namespaces/namespacellarp.md#using-pqcipherblock)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< PQ_PUBKEYSIZE > | **[PQPubKey](Namespaces/namespacellarp.md#using-pqpubkey)**  |
| using [AlignedBuffer](Classes/structllarp_1_1AlignedBuffer.md)< PQ_KEYPAIRSIZE > | **[PQKeyPair](Namespaces/namespacellarp.md#using-pqkeypair)**  |
| using std::function< bool([SharedSecret](Classes/structllarp_1_1AlignedBuffer.md) &, const [PubKey](Classes/structllarp_1_1PubKey.md) &, const [SecretKey](Classes/structllarp_1_1SecretKey.md) &, const [TunnelNonce](Classes/structllarp_1_1AlignedBuffer.md) &)> | **[path_dh_func](Namespaces/namespacellarp.md#using-path-dh-func)** <br>PKE(result, publickey, secretkey, nonce)  |
| using std::function< bool([SharedSecret](Classes/structllarp_1_1AlignedBuffer.md) &, const [PubKey](Classes/structllarp_1_1PubKey.md) &, const [SecretKey](Classes/structllarp_1_1SecretKey.md) &, const [TunnelNonce](Classes/structllarp_1_1AlignedBuffer.md) &)> | **[transport_dh_func](Namespaces/namespacellarp.md#using-transport-dh-func)** <br>TKE(result, publickey, secretkey, nonce)  |
| using std::function< bool([ShortHash](Classes/structllarp_1_1AlignedBuffer.md) &, const [llarp_buffer_t](Classes/structllarp__buffer__t.md) &)> | **[shorthash_func](Namespaces/namespacellarp.md#using-shorthash-func)** <br>SH(result, body)  |
| using std::shared_ptr< [EventLoop](Classes/classllarp_1_1EventLoop.md) > | **[EventLoop_ptr](Namespaces/namespacellarp.md#using-eventloop-ptr)**  |
| using std::function< bool([ILinkSession](Classes/structllarp_1_1ILinkSession.md) *, const [llarp_buffer_t](Classes/structllarp__buffer__t.md) &)> | **[LinkMessageHandler](Namespaces/namespacellarp.md#using-linkmessagehandler)** <br>handle a link layer message.  |
| using std::function< bool([Signature](Classes/structllarp_1_1Signature.md) &, const [llarp_buffer_t](Classes/structllarp__buffer__t.md) &)> | **[SignBufferFunc](Namespaces/namespacellarp.md#using-signbufferfunc)** <br>sign a buffer with identity key.  |
| using std::function< void([ILinkSession](Classes/structllarp_1_1ILinkSession.md) *)> | **[TimeoutHandler](Namespaces/namespacellarp.md#using-timeouthandler)** <br>handle connection timeout  |
| using std::function< const [llarp::RouterContact](Classes/structllarp_1_1RouterContact.md) &(void)> | **[GetRCFunc](Namespaces/namespacellarp.md#using-getrcfunc)** <br>get our RC  |
| using std::function< bool([ILinkSession](Classes/structllarp_1_1ILinkSession.md) *, bool)> | **[SessionEstablishedHandler](Namespaces/namespacellarp.md#using-sessionestablishedhandler)** <br>handler of session established return false to reject return true to accept  |
| using std::function< bool([llarp::RouterContact](Classes/structllarp_1_1RouterContact.md), [llarp::RouterContact](Classes/structllarp_1_1RouterContact.md))> | **[SessionRenegotiateHandler](Namespaces/namespacellarp.md#using-sessionrenegotiatehandler)** <br>f(new, old) handler of session renegotiation returns true if the new rc is valid returns false otherwise and the session is terminated  |
| using std::function< void([llarp::RouterID](Classes/structllarp_1_1RouterID.md))> | **[SessionClosedHandler](Namespaces/namespacellarp.md#using-sessionclosedhandler)** <br>handles close of all sessions with pubkey  |
| using std::function< void(void)> | **[PumpDoneHandler](Namespaces/namespacellarp.md#using-pumpdonehandler)** <br>notifies router that a link session has ended its pump and we should flush messages to upper layers  |
| using std::function< void(void)> | **[Work_t](Namespaces/namespacellarp.md#using-work-t)**  |
| using std::function< void(Work_t)> | **[WorkerFunc_t](Namespaces/namespacellarp.md#using-workerfunc-t)** <br>queue work to worker thread  |
| using std::function< void([llarp::RouterContact](Classes/structllarp_1_1RouterContact.md))> | **[BeforeConnectFunc_t](Namespaces/namespacellarp.md#using-beforeconnectfunc-t)** <br>before connection hook, called before we try connecting via outbound link  |
| using std::shared_ptr< [ILinkLayer](Classes/structllarp_1_1ILinkLayer.md) > | **[LinkLayer_ptr](Namespaces/namespacellarp.md#using-linklayer-ptr)**  |
| using [huint_t](Classes/structllarp_1_1huint__t.md)< uint32_t > | **[huint32_t](Namespaces/namespacellarp.md#using-huint32-t)**  |
| using [huint_t](Classes/structllarp_1_1huint__t.md)< uint16_t > | **[huint16_t](Namespaces/namespacellarp.md#using-huint16-t)**  |
| using [huint_t](Classes/structllarp_1_1huint__t.md)< [llarp::uint128_t](Classes/structllarp_1_1uint128__t.md) > | **[huint128_t](Namespaces/namespacellarp.md#using-huint128-t)**  |
| using llarp::net::port_t | **[nuint16_t](Namespaces/namespacellarp.md#using-nuint16-t)**  |
| using llarp::net::ipv4addr_t | **[nuint32_t](Namespaces/namespacellarp.md#using-nuint32-t)**  |
| using llarp::net::ipv6addr_t | **[nuint128_t](Namespaces/namespacellarp.md#using-nuint128-t)**  |
| using decltype(initStorage("")) | **[PeerDbStorage](Namespaces/namespacellarp.md#using-peerdbstorage)**  |
| using std::shared_ptr< oxenmq::OxenMQ > | **[LMQ_ptr](Namespaces/namespacellarp.md#using-lmq-ptr)**  |
| using std::function< void(SendStatus)> | **[SendStatusHandler](Namespaces/namespacellarp.md#using-sendstatushandler)**  |
| using std::function< void(const [RouterID](Classes/structllarp_1_1RouterID.md) &, const SessionResult)> | **[RouterCallback](Namespaces/namespacellarp.md#using-routercallback)**  |
| using std::function< void(const [RouterID](Classes/structllarp_1_1RouterID.md) &, const [RouterContact](Classes/structllarp_1_1RouterContact.md) *const, const RCRequestResult)> | **[RCRequestCallback](Namespaces/namespacellarp.md#using-rcrequestcallback)**  |
| using std::function< void(const std::vector< [RouterContact](Classes/structllarp_1_1RouterContact.md) > &)> | **[RouterLookupHandler](Namespaces/namespacellarp.md#using-routerlookuphandler)**  |
| using std::shared_ptr< llarp::Context > | **[Node_ptr](Namespaces/namespacellarp.md#using-node-ptr)**  |
| using std::chrono::milliseconds | **[Duration_t](Namespaces/namespacellarp.md#using-duration-t)**  |
| using std::chrono::system_clock | **[DateClock_t](Namespaces/namespacellarp.md#using-dateclock-t)**  |
| using DateClock_t::time_point | **[TimePoint_t](Namespaces/namespacellarp.md#using-timepoint-t)**  |

## Functions

|                | Name           |
| -------------- | -------------- |
| void | **[ensureConfig](Namespaces/namespacellarp.md#function-ensureconfig)**(fs::path dataDir, fs::path confFile, bool overwrite, bool asRouter) |
| fs::path | **[GetDefaultDataDir](Namespaces/namespacellarp.md#function-getdefaultdatadir)**() |
| fs::path | **[GetDefaultConfigFilename](Namespaces/namespacellarp.md#function-getdefaultconfigfilename)**() |
| fs::path | **[GetDefaultConfigPath](Namespaces/namespacellarp.md#function-getdefaultconfigpath)**() |
| fs::path | **[GetDefaultBootstrap](Namespaces/namespacellarp.md#function-getdefaultbootstrap)**() |
| uint64_t | **[randint](Namespaces/namespacellarp.md#function-randint)**()<br>return random 64bit unsigned interger  |
| const byte_t * | **[seckey_topublic](Namespaces/namespacellarp.md#function-seckey-topublic)**(const [SecretKey](Classes/structllarp_1_1SecretKey.md) & secret) |
| const byte_t * | **[pq_keypair_to_public](Namespaces/namespacellarp.md#function-pq-keypair-to-public)**(const [PQKeyPair](Classes/structllarp_1_1AlignedBuffer.md) & keypair) |
| const byte_t * | **[pq_keypair_to_secret](Namespaces/namespacellarp.md#function-pq-keypair-to-secret)**(const [PQKeyPair](Classes/structllarp_1_1AlignedBuffer.md) & keypair) |
| bool | **[operator==](Namespaces/namespacellarp.md#function-operator==)**(const [PubKey](Classes/structllarp_1_1PubKey.md) & lhs, const [PubKey](Classes/structllarp_1_1PubKey.md) & rhs) |
| bool | **[operator==](Namespaces/namespacellarp.md#function-operator==)**(const [PubKey](Classes/structllarp_1_1PubKey.md) & lhs, const [RouterID](Classes/structllarp_1_1RouterID.md) & rhs) |
| bool | **[operator==](Namespaces/namespacellarp.md#function-operator==)**(const [RouterID](Classes/structllarp_1_1RouterID.md) & lhs, const [PubKey](Classes/structllarp_1_1PubKey.md) & rhs) |
| std::string | **[LRStatusCodeToString](Namespaces/namespacellarp.md#function-lrstatuscodetostring)**(uint64_t status) |
| void | **[to_json](Namespaces/namespacellarp.md#function-to-json)**(nlohmann::json & j, const [AddressInfo](Classes/structllarp_1_1AddressInfo.md) & a) |
| bool | **[operator==](Namespaces/namespacellarp.md#function-operator==)**(const [AddressInfo](Classes/structllarp_1_1AddressInfo.md) & lhs, const [AddressInfo](Classes/structllarp_1_1AddressInfo.md) & rhs) |
| bool | **[operator<](Namespaces/namespacellarp.md#function-operator<)**(const [AddressInfo](Classes/structllarp_1_1AddressInfo.md) & lhs, const [AddressInfo](Classes/structllarp_1_1AddressInfo.md) & rhs) |
| bool | **[IsBogon](Namespaces/namespacellarp.md#function-isbogon)**([huint128_t](Classes/structllarp_1_1huint__t.md) ip)<br>forward declare  |
| bool | **[IsIPv4Bogon](Namespaces/namespacellarp.md#function-isipv4bogon)**(const [huint32_t](Classes/structllarp_1_1huint__t.md) & addr) |
| bool | **[IsIPv4Bogon](Namespaces/namespacellarp.md#function-isipv4bogon)**(const nuint32_t & addr) |
| bool | **[IsBogon](Namespaces/namespacellarp.md#function-isbogon)**(const in6_addr & addr) |
| bool | **[IsBogonRange](Namespaces/namespacellarp.md#function-isbogonrange)**(const in6_addr & host, const in6_addr & mask) |
| constexpr [huint128_t](Classes/structllarp_1_1huint__t.md) | **[_netmask_ipv6_bits](Namespaces/namespacellarp.md#function--netmask-ipv6-bits)**(uint32_t numset)<br>get a netmask with the higest numset bits set  |
| constexpr [huint128_t](Classes/structllarp_1_1huint__t.md) | **[netmask_ipv6_bits](Namespaces/namespacellarp.md#function-netmask-ipv6-bits)**(uint32_t numset) |
| constexpr uint32_t | **[_netmask_ipv4_bits](Namespaces/namespacellarp.md#function--netmask-ipv4-bits)**(uint32_t numset)<br>get a netmask with the higest numset bits set  |
| constexpr [huint32_t](Classes/structllarp_1_1huint__t.md) | **[netmask_ipv4_bits](Namespaces/namespacellarp.md#function-netmask-ipv4-bits)**(uint32_t num)<br>get a netmask given some /N range  |
| constexpr [huint32_t](Classes/structllarp_1_1huint__t.md) | **[ipaddr_ipv4_bits](Namespaces/namespacellarp.md#function-ipaddr-ipv4-bits)**(uint32_t a, uint32_t b, uint32_t c, uint32_t d) |
| constexpr bool | **[ipv6_is_mapped_ipv4](Namespaces/namespacellarp.md#function-ipv6-is-mapped-ipv4)**(const in6_addr & addr) |
| template <typename UInt_t \> <br>[llarp::nuint_t](Classes/structllarp_1_1nuint__t.md)< UInt_t > | **[ToNet](Namespaces/namespacellarp.md#function-tonet)**([llarp::huint_t](Classes/structllarp_1_1huint__t.md)< UInt_t > x) |
| template <typename UInt_t \> <br>[llarp::huint_t](Classes/structllarp_1_1huint__t.md)< UInt_t > | **[ToHost](Namespaces/namespacellarp.md#function-tohost)**([llarp::nuint_t](Classes/structllarp_1_1nuint__t.md)< UInt_t > x) |
| net::ipv4addr_t | **[xhtonl](Namespaces/namespacellarp.md#function-xhtonl)**([huint32_t](Classes/structllarp_1_1huint__t.md) x) |
| auto | **[initStorage](Namespaces/namespacellarp.md#function-initstorage)**(const std::string & file) |
| constexpr std::string_view | **[ToString](Namespaces/namespacellarp.md#function-tostring)**(SessionResult sr) |
| bool | **[systemd_resolved_set_dns](Namespaces/namespacellarp.md#function-systemd-resolved-set-dns)**(std::string if_name, [llarp::SockAddr](Classes/structllarp_1_1SockAddr.md) dns, bool global)<br>Attempts to set lokinet as the DNS server for systemd-resolved.  |
| bool | **[operator==](Namespaces/namespacellarp.md#function-operator==)**(const [RouterID](Classes/structllarp_1_1RouterID.md) & lhs, const [RouterID](Classes/structllarp_1_1RouterID.md) & rhs) |
| template <typename List_t \> <br>bool | **[BEncodeReadList](Namespaces/namespacellarp.md#function-bencodereadlist)**(List_t & result, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| bool | **[BEncodeWriteDictMsgType](Namespaces/namespacellarp.md#function-bencodewritedictmsgtype)**([llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf, const char * k, const char * t) |
| template <typename Obj_t \> <br>bool | **[BEncodeWriteDictString](Namespaces/namespacellarp.md#function-bencodewritedictstring)**(const char * k, const Obj_t & str, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Obj_t \> <br>bool | **[BEncodeWriteDictEntry](Namespaces/namespacellarp.md#function-bencodewritedictentry)**(const char * k, const Obj_t & o, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Int_t \> <br>bool | **[BEncodeWriteDictInt](Namespaces/namespacellarp.md#function-bencodewritedictint)**(const char * k, const Int_t & i, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename List_t \> <br>bool | **[BEncodeMaybeReadDictList](Namespaces/namespacellarp.md#function-bencodemaybereaddictlist)**(const char * k, List_t & item, bool & read, const [llarp_buffer_t](Classes/structllarp__buffer__t.md) & key, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Item_t \> <br>bool | **[BEncodeMaybeReadDictEntry](Namespaces/namespacellarp.md#function-bencodemaybereaddictentry)**(const char * k, Item_t & item, bool & read, const [llarp_buffer_t](Classes/structllarp__buffer__t.md) & key, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Int_t \> <br>bool | **[BEncodeMaybeReadDictInt](Namespaces/namespacellarp.md#function-bencodemaybereaddictint)**(const char * k, Int_t & i, bool & read, const [llarp_buffer_t](Classes/structllarp__buffer__t.md) & key, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Item_t \> <br>bool | **[BEncodeMaybeVerifyVersion](Namespaces/namespacellarp.md#function-bencodemaybeverifyversion)**(const char * k, Item_t & item, uint64_t expect, bool & read, const [llarp_buffer_t](Classes/structllarp__buffer__t.md) & key, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf)<br>If the key matches, reads in the version and ensures that it equals the expected version.  |
| template <typename List_t \> <br>bool | **[BEncodeWriteDictBEncodeList](Namespaces/namespacellarp.md#function-bencodewritedictbencodelist)**(const char * k, const List_t & l, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Array \> <br>bool | **[BEncodeWriteDictArray](Namespaces/namespacellarp.md#function-bencodewritedictarray)**(const char * k, const Array & array, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Iter \> <br>bool | **[BEncodeWriteList](Namespaces/namespacellarp.md#function-bencodewritelist)**(Iter itr, Iter end, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Sink \> <br>bool | **[bencode_read_dict](Namespaces/namespacellarp.md#function-bencode-read-dict)**(Sink && sink, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buffer) |
| template <typename Sink \> <br>bool | **[bencode_decode_dict](Namespaces/namespacellarp.md#function-bencode-decode-dict)**(Sink && sink, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buff) |
| template <typename Sink \> <br>bool | **[bencode_read_list](Namespaces/namespacellarp.md#function-bencode-read-list)**(Sink && sink, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buffer) |
| template <typename Array \> <br>bool | **[BEncodeReadArray](Namespaces/namespacellarp.md#function-bencodereadarray)**(Array & array, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <typename Set_t \> <br>bool | **[BEncodeReadSet](Namespaces/namespacellarp.md#function-bencodereadset)**(Set_t & set, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buffer)<br>read a std::set of decodable entities and deny duplicates  |
| template <typename Set_t \> <br>bool | **[BEncodeWriteSet](Namespaces/namespacellarp.md#function-bencodewriteset)**(const Set_t & set, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buffer)<br>write an iterable container as a list  |
| template <typename List_t \> <br>bool | **[BEncodeWriteDictList](Namespaces/namespacellarp.md#function-bencodewritedictlist)**(const char * k, List_t & list, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf) |
| template <size_t bufsz,typename T \> <br>void | **[Dump](Namespaces/namespacellarp.md#function-dump)**(const T & val) |
| template <typename T \> <br>bool | **[BDecodeReadFile](Namespaces/namespacellarp.md#function-bdecodereadfile)**(const fs::path fpath, T & t)<br>read entire file and decode its contents into t  |
| template <typename T ,size_t bufsz\> <br>bool | **[BEncodeWriteFile](Namespaces/namespacellarp.md#function-bencodewritefile)**(const fs::path fpath, const T & t)<br>bencode and write to file  |
| template <typename Int_t \> <br>bool | **[BEncodeSeekDictVersion](Namespaces/namespacellarp.md#function-bencodeseekdictversion)**(Int_t & v, [llarp_buffer_t](Classes/structllarp__buffer__t.md) * buf, const byte_t k)<br>seek for an int in a dict with a key k used for version set v to parsed value if found this call rewinds the buffer unconditionally before return returns false only if there was  |
| template <typename... T\> <br>| **[LogTrace](Namespaces/namespacellarp.md#function-logtrace)**(T && ...) |
| template <typename... T\> <br>| **[LogDebug](Namespaces/namespacellarp.md#function-logdebug)**(T && ...) |
| template <typename... T\> <br>| **[LogInfo](Namespaces/namespacellarp.md#function-loginfo)**(T && ...) |
| template <typename... T\> <br>| **[LogWarn](Namespaces/namespacellarp.md#function-logwarn)**(T && ...) |
| template <typename... T\> <br>| **[LogError](Namespaces/namespacellarp.md#function-logerror)**(T && ...) |
| void | **[Zero](Namespaces/namespacellarp.md#function-zero)**(void * ptr, size_t sz) |
| template <typename T \> <br>void | **[dumphex](Namespaces/namespacellarp.md#function-dumphex)**(const uint8_t * t) |
| template <typename T ,size_t align =128\> <br>void | **[DumpBufferHex](Namespaces/namespacellarp.md#function-dumpbufferhex)**(const T & buff) |
| template <typename T ,size_t align =128\> <br>void | **[DumpBuffer](Namespaces/namespacellarp.md#function-dumpbuffer)**(const T & buff) |
| bool | **[IsFalseValue](Namespaces/namespacellarp.md#function-isfalsevalue)**(std::string_view str) |
| bool | **[IsTrueValue](Namespaces/namespacellarp.md#function-istruevalue)**(std::string_view str) |
| std::string_view | **[TrimWhitespace](Namespaces/namespacellarp.md#function-trimwhitespace)**(std::string_view str)<br>Trim leading and trailing (ascii) whitespace from the given string; returns a std::string_view of the trimmed part of the string.  |
| bool | **[string_iequal](Namespaces/namespacellarp.md#function-string-iequal)**(std::string_view s1, std::string_view s2)<br>Returns true if the first string is equal to the second string, compared case-insensitively.  |
| template <typename S1 ,typename... S\> <br>bool | **[string_iequal_any](Namespaces/namespacellarp.md#function-string-iequal-any)**(const S1 & s1, const S &... s)<br>Returns true if the first string matches any of the given strings case-insensitively.  |
| constexpr bool | **[starts_with](Namespaces/namespacellarp.md#function-starts-with)**(std::string_view str, std::string_view prefix)<br>Returns true if the first argument begins with the second argument.  |
| constexpr bool | **[ends_with](Namespaces/namespacellarp.md#function-ends-with)**(std::string_view str, std::string_view suffix)<br>Returns true if the first argument ends with the second argument.  |
| constexpr std::string_view | **[strip_prefix](Namespaces/namespacellarp.md#function-strip-prefix)**(std::string_view str, std::string_view prefix)<br>removes a prefix from a string if it exists  |
| std::vector< std::string_view > | **[split](Namespaces/namespacellarp.md#function-split)**(std::string_view str, std::string_view delim, bool trim =false)<br>Splits a string on some delimiter string and returns a vector of string_view's pointing into the pieces of the original string.  |
| std::vector< std::string_view > | **[split_any](Namespaces/namespacellarp.md#function-split-any)**(std::string_view str, std::string_view delims, bool trim =false)<br>Splits a string on any 1 or more of the given delimiter characters and returns a vector of string_view's pointing into the pieces of the original string.  |
| template <typename It \> <br>std::string | **[join](Namespaces/namespacellarp.md#function-join)**(std::string_view delimiter, It begin, It end)<br>Joins [begin, end) with a delimiter and returns the resulting string.  |
| template <typename Container \> <br>std::string | **[join](Namespaces/namespacellarp.md#function-join)**(std::string_view delimiter, const Container & c)<br>Wrapper around the above that takes a container and passes c.begin(), c.end() to the above.  |
| void | **[trim](Namespaces/namespacellarp.md#function-trim)**(std::string_view & s)<br>Simple version of whitespace trimming: mutates the given string view to remove leading space, \t, \r,   .  |
| template <typename T \> <br>bool | **[parse_int](Namespaces/namespacellarp.md#function-parse-int)**(const std::string_view str, T & value, int base =10)<br>Parses an integer of some sort from a string, requiring that the entire string be consumed during parsing.  |
| std::string | **[lowercase_ascii_string](Namespaces/namespacellarp.md#function-lowercase-ascii-string)**(std::string src) |
| std::string | **[friendly_duration](Namespaces/namespacellarp.md#function-friendly-duration)**(std::chrono::nanoseconds dur)<br>Converts a duration into a human friendlier string.  |
| Duration_t | **[time_now_ms](Namespaces/namespacellarp.md#function-time-now-ms)**()<br>get time right now as milliseconds, this is monotonic  |
| Duration_t | **[uptime](Namespaces/namespacellarp.md#function-uptime)**()<br>get the uptime of the process  |
| uint64_t | **[ToMS](Namespaces/namespacellarp.md#function-toms)**(Duration_t duration)<br>convert to milliseconds  |
| nlohmann::json | **[to_json](Namespaces/namespacellarp.md#function-to-json)**(const Duration_t & t) |

## Attributes

|                | Name           |
| -------------- | -------------- |
| constexpr std::size_t | **[event_loop_queue_size](Namespaces/namespacellarp.md#variable-event-loop-queue-size)** <br>default queue length for logic jobs  |
| constexpr auto | **[our_rc_filename](Namespaces/namespacellarp.md#variable-our-rc-filename)**  |
| constexpr auto | **[our_identity_filename](Namespaces/namespacellarp.md#variable-our-identity-filename)**  |
| constexpr auto | **[our_enc_key_filename](Namespaces/namespacellarp.md#variable-our-enc-key-filename)**  |
| constexpr auto | **[our_transport_key_filename](Namespaces/namespacellarp.md#variable-our-transport-key-filename)**  |
| constexpr auto | **[nodedb_dirname](Namespaces/namespacellarp.md#variable-nodedb-dirname)**  |
| constexpr auto | **[TimeskipDetectedDuration](Namespaces/namespacellarp.md#variable-timeskipdetectedduration)** <br>how big of a time skip before we reset network state  |
| const std::array< uint16_t, 3 > | **[VERSION](Namespaces/namespacellarp.md#variable-version)**  |
| const std::array< uint64_t, 4 > | **[ROUTER_VERSION](Namespaces/namespacellarp.md#variable-router-version)**  |
| const char *const | **[VERSION_STR](Namespaces/namespacellarp.md#variable-version-str)**  |
| const char *const | **[VERSION_TAG](Namespaces/namespacellarp.md#variable-version-tag)**  |
| const char *const | **[VERSION_FULL](Namespaces/namespacellarp.md#variable-version-full)**  |
| const char *const | **[RELEASE_MOTTO](Namespaces/namespacellarp.md#variable-release-motto)**  |
| const char *const | **[DEFAULT_NETID](Namespaces/namespacellarp.md#variable-default-netid)**  |
| constexpr size_t | **[EncryptedFrameOverheadSize](Namespaces/namespacellarp.md#variable-encryptedframeoverheadsize)**  |
| constexpr size_t | **[EncryptedFrameBodySize](Namespaces/namespacellarp.md#variable-encryptedframebodysize)**  |
| constexpr size_t | **[EncryptedFrameSize](Namespaces/namespacellarp.md#variable-encryptedframesize)**  |
| constexpr bool | **[IsToStringFormattable< PubKey >](Namespaces/namespacellarp.md#variable-istostringformattable<-pubkey->)**  |
| constexpr bool | **[IsToStringFormattable< SecretKey >](Namespaces/namespacellarp.md#variable-istostringformattable<-secretkey->)**  |
| constexpr bool | **[IsToStringFormattable< PrivateKey >](Namespaces/namespacellarp.md#variable-istostringformattable<-privatekey->)**  |
| constexpr bool | **[IsToStringFormattable< IdentitySecret >](Namespaces/namespacellarp.md#variable-istostringformattable<-identitysecret->)**  |
| constexpr bool | **[IsToStringFormattable< AddressInfo >](Namespaces/namespacellarp.md#variable-istostringformattable<-addressinfo->)**  |
| constexpr bool | **[IsToStringFormattable< ExitInfo >](Namespaces/namespacellarp.md#variable-istostringformattable<-exitinfo->)**  |
| constexpr bool | **[IsToStringFormattable< IpAddress >](Namespaces/namespacellarp.md#variable-istostringformattable<-ipaddress->)**  |
| constexpr bool | **[IsToStringFormattable< IPRange >](Namespaces/namespacellarp.md#variable-istostringformattable<-iprange->)**  |
| constexpr std::array< uint8_t, 12 > | **[ipv4_map_prefix](Namespaces/namespacellarp.md#variable-ipv4-map-prefix)**  |
| constexpr bool | **[IsToStringFormattable< huint128_t >](Namespaces/namespacellarp.md#variable-istostringformattable<-huint128-t->)**  |
| constexpr bool | **[IsToStringFormattable< huint32_t >](Namespaces/namespacellarp.md#variable-istostringformattable<-huint32-t->)**  |
| constexpr bool | **[IsToStringFormattable< huint16_t >](Namespaces/namespacellarp.md#variable-istostringformattable<-huint16-t->)**  |
| constexpr bool | **[IsToStringFormattable< SockAddr >](Namespaces/namespacellarp.md#variable-istostringformattable<-sockaddr->)**  |
| constexpr bool | **[IsToStringFormattable< PoW >](Namespaces/namespacellarp.md#variable-istostringformattable<-pow->)**  |
| constexpr size_t | **[MaxGossipPeers](Namespaces/namespacellarp.md#variable-maxgossippeers)** <br>The maximum number of peers we will flood a gossiped RC to when propagating an RC.  |
| const size_t | **[MAX_PATH_QUEUE_SIZE](Namespaces/namespacellarp.md#variable-max-path-queue-size)**  |
| const size_t | **[MAX_OUTBOUND_QUEUE_SIZE](Namespaces/namespacellarp.md#variable-max-outbound-queue-size)**  |
| const size_t | **[MAX_OUTBOUND_MESSAGES_PER_TICK](Namespaces/namespacellarp.md#variable-max-outbound-messages-per-tick)**  |
| constexpr bool | **[IsToStringFormattable< SessionResult >](Namespaces/namespacellarp.md#variable-istostringformattable<-sessionresult->)**  |
| constexpr bool | **[IsToStringFormattable< NetID >](Namespaces/namespacellarp.md#variable-istostringformattable<-netid->)**  |
| constexpr bool | **[IsToStringFormattable< RouterContact >](Namespaces/namespacellarp.md#variable-istostringformattable<-routercontact->)**  |
| constexpr bool | **[IsToStringFormattable< RouterID >](Namespaces/namespacellarp.md#variable-istostringformattable<-routerid->)**  |
| constexpr bool | **[IsToStringFormattable< RouterVersion >](Namespaces/namespacellarp.md#variable-istostringformattable<-routerversion->)**  |
| constexpr int64_t | **[INVALID_VERSION](Namespaces/namespacellarp.md#variable-invalid-version)**  |
| const [RouterVersion](Classes/structllarp_1_1RouterVersion.md)({0, 0, 0}, INVALID_VERSION) | **[emptyRouterVersion](Namespaces/namespacellarp.md#variable-emptyrouterversion)**  |
| constexpr bool | **[is_aligned_buffer](Namespaces/namespacellarp.md#variable-is-aligned-buffer)**  |
| constexpr bool | **[IsToStringFormattable](Namespaces/namespacellarp.md#variable-istostringformattable)**  |
| constexpr bool | **[is_scoped_enum_v](Namespaces/namespacellarp.md#variable-is-scoped-enum-v)**  |
| constexpr bool | **[IsToStringFormattable< buffer_printer >](Namespaces/namespacellarp.md#variable-istostringformattable<-buffer-printer->)**  |

## Detailed Description

[crypto.hpp]

Types stored in our peerstats database are declared here.

Contains some code to help deal with [sqlite_orm](Namespaces/namespacesqlite__orm.md) in hopes of keeping other headers clean.

exit_info.h

[address_info.hpp]

libsodium abstraction layer potentially allow libssl support in the future

utilities for handling addresses on the llarp network address information model

utilities for handling exits on the llarp network Exit info model 

## Types Documentation

### enum SendStatus

| Enumerator | Value | Description |
| ---------- | ----- | ----------- |
| Success | |   |
| Timeout | |   |
| NoLink | |   |
| InvalidRouter | |   |
| RouterNotFound | |   |
| Congestion | |   |




### enum SessionResult

| Enumerator | Value | Description |
| ---------- | ----- | ----------- |
| Establish | |   |
| Timeout | |   |
| RouterNotFound | |   |
| InvalidRouter | |   |
| NoLink | |   |
| EstablishFail | |   |




### enum RCRequestResult

| Enumerator | Value | Description |
| ---------- | ----- | ----------- |
| Success | |   |
| InvalidRouter | |   |
| RouterNotFound | |   |
| BadRC | |   |




### using SectionValues_t

```cpp
using llarp::SectionValues_t = typedef llarp::ConfigParser::SectionValues_t;
```


### using Config_impl_t

```cpp
using llarp::Config_impl_t = typedef llarp::ConfigParser::Config_impl_t;
```


### using UndeclaredValueHandler

```cpp
using llarp::UndeclaredValueHandler = typedef std::function<void(std::string_view section, std::string_view name, std::string_view value)>;
```


### using OptionDefinition_ptr

```cpp
using llarp::OptionDefinition_ptr = typedef std::unique_ptr<OptionDefinitionBase>;
```


### using DefinitionMap

```cpp
using llarp::DefinitionMap = typedef std::unordered_map<std::string, OptionDefinition_ptr>;
```


### using SectionMap

```cpp
using llarp::SectionMap = typedef std::unordered_map<std::string, DefinitionMap>;
```


### using SharedSecret

```cpp
using llarp::SharedSecret = typedef AlignedBuffer<SHAREDKEYSIZE>;
```


### using KeyExchangeNonce

```cpp
using llarp::KeyExchangeNonce = typedef AlignedBuffer<32>;
```


### using ShortHash

```cpp
using llarp::ShortHash = typedef AlignedBuffer<SHORTHASHSIZE>;
```


### using LongHash

```cpp
using llarp::LongHash = typedef AlignedBuffer<HASHSIZE>;
```


### using TunnelNonce

```cpp
using llarp::TunnelNonce = typedef AlignedBuffer<TUNNONCESIZE>;
```


### using SymmNonce

```cpp
using llarp::SymmNonce = typedef AlignedBuffer<NONCESIZE>;
```


### using SymmKey

```cpp
using llarp::SymmKey = typedef AlignedBuffer<32>;
```


### using PQCipherBlock

```cpp
using llarp::PQCipherBlock = typedef AlignedBuffer<PQ_CIPHERTEXTSIZE + 1>;
```


### using PQPubKey

```cpp
using llarp::PQPubKey = typedef AlignedBuffer<PQ_PUBKEYSIZE>;
```


### using PQKeyPair

```cpp
using llarp::PQKeyPair = typedef AlignedBuffer<PQ_KEYPAIRSIZE>;
```


### using path_dh_func

```cpp
using llarp::path_dh_func = typedef std::function<bool(SharedSecret&, const PubKey&, const SecretKey&, const TunnelNonce&)>;
```

PKE(result, publickey, secretkey, nonce) 

### using transport_dh_func

```cpp
using llarp::transport_dh_func = typedef std::function<bool(SharedSecret&, const PubKey&, const SecretKey&, const TunnelNonce&)>;
```

TKE(result, publickey, secretkey, nonce) 

### using shorthash_func

```cpp
using llarp::shorthash_func = typedef std::function<bool(ShortHash&, const llarp_buffer_t&)>;
```

SH(result, body) 

### using EventLoop_ptr

```cpp
using llarp::EventLoop_ptr = typedef std::shared_ptr<EventLoop>;
```


### using LinkMessageHandler

```cpp
using llarp::LinkMessageHandler = typedef std::function<bool(ILinkSession*, const llarp_buffer_t&)>;
```

handle a link layer message. 

this allows for the message to be handled by "upper layers"

currently called from [iwp::Session](Classes/structllarp_1_1iwp_1_1Session.md) when messages are sent or received. 


### using SignBufferFunc

```cpp
using llarp::SignBufferFunc = typedef std::function<bool(Signature&, const llarp_buffer_t&)>;
```

sign a buffer with identity key. 

this function should take the given `[llarp_buffer_t](Classes/structllarp__buffer__t.md)` and sign it, prividing the signature in the out variable `[Signature](Classes/structllarp_1_1Signature.md)&`.

currently called from [iwp::Session](Classes/structllarp_1_1iwp_1_1Session.md) for signing LIMs (link introduction messages) 


### using TimeoutHandler

```cpp
using llarp::TimeoutHandler = typedef std::function<void(ILinkSession*)>;
```

handle connection timeout 

currently called from ILinkLayer::Pump() when an unestablished session times out 


### using GetRCFunc

```cpp
using llarp::GetRCFunc = typedef std::function<const llarp::RouterContact&(void)>;
```

get our RC 

currently called by [iwp::Session](Classes/structllarp_1_1iwp_1_1Session.md) to include as part of a LIM (link introduction message) 


### using SessionEstablishedHandler

```cpp
using llarp::SessionEstablishedHandler = typedef std::function<bool(ILinkSession*, bool)>;
```

handler of session established return false to reject return true to accept 

currently called in [iwp::Session](Classes/structllarp_1_1iwp_1_1Session.md) when a valid LIM is received. 


### using SessionRenegotiateHandler

```cpp
using llarp::SessionRenegotiateHandler = typedef std::function<bool(llarp::RouterContact, llarp::RouterContact)>;
```

f(new, old) handler of session renegotiation returns true if the new rc is valid returns false otherwise and the session is terminated 

currently called from [iwp::Session](Classes/structllarp_1_1iwp_1_1Session.md) when we receive a renegotiation LIM 


### using SessionClosedHandler

```cpp
using llarp::SessionClosedHandler = typedef std::function<void(llarp::RouterID)>;
```

handles close of all sessions with pubkey 

Note that this handler is called while m_AuthedLinksMutex is held

currently called from iwp::ILinkSession when a previously established session times out 


### using PumpDoneHandler

```cpp
using llarp::PumpDoneHandler = typedef std::function<void(void)>;
```

notifies router that a link session has ended its pump and we should flush messages to upper layers 

currently called at the end of every [iwp::Session::Pump()](Classes/structllarp_1_1iwp_1_1Session.md#function-pump) call 


### using Work_t

```cpp
using llarp::Work_t = typedef std::function<void(void)>;
```


### using WorkerFunc_t

```cpp
using llarp::WorkerFunc_t = typedef std::function<void(Work_t)>;
```

queue work to worker thread 

### using BeforeConnectFunc_t

```cpp
using llarp::BeforeConnectFunc_t = typedef std::function<void(llarp::RouterContact)>;
```

before connection hook, called before we try connecting via outbound link 

### using LinkLayer_ptr

```cpp
using llarp::LinkLayer_ptr = typedef std::shared_ptr<ILinkLayer>;
```


### using huint32_t

```cpp
using llarp::huint32_t = typedef huint_t<uint32_t>;
```


### using huint16_t

```cpp
using llarp::huint16_t = typedef huint_t<uint16_t>;
```


### using huint128_t

```cpp
using llarp::huint128_t = typedef huint_t<llarp::uint128_t>;
```


### using nuint16_t

```cpp
using llarp::nuint16_t = typedef llarp::net::port_t;
```


### using nuint32_t

```cpp
using llarp::nuint32_t = typedef llarp::net::ipv4addr_t;
```


### using nuint128_t

```cpp
using llarp::nuint128_t = typedef llarp::net::ipv6addr_t;
```


### using PeerDbStorage

```cpp
using llarp::PeerDbStorage = typedef decltype(initStorage(""));
```


### using LMQ_ptr

```cpp
using llarp::LMQ_ptr = typedef std::shared_ptr<oxenmq::OxenMQ>;
```


### using SendStatusHandler

```cpp
using llarp::SendStatusHandler = typedef std::function<void(SendStatus)>;
```


### using RouterCallback

```cpp
using llarp::RouterCallback = typedef std::function<void(const RouterID&, const SessionResult)>;
```


### using RCRequestCallback

```cpp
using llarp::RCRequestCallback = typedef std::function<void(const RouterID&, const RouterContact* const, const RCRequestResult)>;
```


### using RouterLookupHandler

```cpp
using llarp::RouterLookupHandler = typedef std::function<void(const std::vector<RouterContact>&)>;
```


### using Node_ptr

```cpp
using llarp::Node_ptr = typedef std::shared_ptr<llarp::Context>;
```


### using Duration_t

```cpp
using llarp::Duration_t = typedef std::chrono::milliseconds;
```


### using DateClock_t

```cpp
using llarp::DateClock_t = typedef std::chrono::system_clock;
```


### using TimePoint_t

```cpp
using llarp::TimePoint_t = typedef DateClock_t::time_point;
```



## Functions Documentation

### function ensureConfig

```cpp
void ensureConfig(
    fs::path dataDir,
    fs::path confFile,
    bool overwrite,
    bool asRouter
)
```


### function GetDefaultDataDir

```cpp
inline fs::path GetDefaultDataDir()
```


### function GetDefaultConfigFilename

```cpp
inline fs::path GetDefaultConfigFilename()
```


### function GetDefaultConfigPath

```cpp
inline fs::path GetDefaultConfigPath()
```


### function GetDefaultBootstrap

```cpp
inline fs::path GetDefaultBootstrap()
```


### function randint

```cpp
uint64_t randint()
```

return random 64bit unsigned interger 

### function seckey_topublic

```cpp
const byte_t * seckey_topublic(
    const SecretKey & secret
)
```


### function pq_keypair_to_public

```cpp
const byte_t * pq_keypair_to_public(
    const PQKeyPair & keypair
)
```


### function pq_keypair_to_secret

```cpp
const byte_t * pq_keypair_to_secret(
    const PQKeyPair & keypair
)
```


### function operator==

```cpp
inline bool operator==(
    const PubKey & lhs,
    const PubKey & rhs
)
```


### function operator==

```cpp
inline bool operator==(
    const PubKey & lhs,
    const RouterID & rhs
)
```


### function operator==

```cpp
inline bool operator==(
    const RouterID & lhs,
    const PubKey & rhs
)
```


### function LRStatusCodeToString

```cpp
std::string LRStatusCodeToString(
    uint64_t status
)
```


### function to_json

```cpp
void to_json(
    nlohmann::json & j,
    const AddressInfo & a
)
```


### function operator==

```cpp
bool operator==(
    const AddressInfo & lhs,
    const AddressInfo & rhs
)
```


### function operator<

```cpp
bool operator<(
    const AddressInfo & lhs,
    const AddressInfo & rhs
)
```


### function IsBogon

```cpp
bool IsBogon(
    huint128_t ip
)
```

forward declare 

### function IsIPv4Bogon

```cpp
bool IsIPv4Bogon(
    const huint32_t & addr
)
```


### function IsIPv4Bogon

```cpp
inline bool IsIPv4Bogon(
    const nuint32_t & addr
)
```


### function IsBogon

```cpp
bool IsBogon(
    const in6_addr & addr
)
```


### function IsBogonRange

```cpp
bool IsBogonRange(
    const in6_addr & host,
    const in6_addr & mask
)
```


### function _netmask_ipv6_bits

```cpp
constexpr huint128_t _netmask_ipv6_bits(
    uint32_t numset
)
```

get a netmask with the higest numset bits set 

### function netmask_ipv6_bits

```cpp
constexpr huint128_t netmask_ipv6_bits(
    uint32_t numset
)
```


### function _netmask_ipv4_bits

```cpp
constexpr uint32_t _netmask_ipv4_bits(
    uint32_t numset
)
```

get a netmask with the higest numset bits set 

### function netmask_ipv4_bits

```cpp
constexpr huint32_t netmask_ipv4_bits(
    uint32_t num
)
```

get a netmask given some /N range 

### function ipaddr_ipv4_bits

```cpp
constexpr huint32_t ipaddr_ipv4_bits(
    uint32_t a,
    uint32_t b,
    uint32_t c,
    uint32_t d
)
```


### function ipv6_is_mapped_ipv4

```cpp
constexpr bool ipv6_is_mapped_ipv4(
    const in6_addr & addr
)
```


### function ToNet

```cpp
template <typename UInt_t >
inline llarp::nuint_t< UInt_t > ToNet(
    llarp::huint_t< UInt_t > x
)
```


### function ToHost

```cpp
template <typename UInt_t >
inline llarp::huint_t< UInt_t > ToHost(
    llarp::nuint_t< UInt_t > x
)
```


### function xhtonl

```cpp
inline net::ipv4addr_t xhtonl(
    huint32_t x
)
```


### function initStorage

```cpp
inline auto initStorage(
    const std::string & file
)
```


### function ToString

```cpp
constexpr std::string_view ToString(
    SessionResult sr
)
```


### function systemd_resolved_set_dns

```cpp
bool systemd_resolved_set_dns(
    std::string if_name,
    llarp::SockAddr dns,
    bool global
)
```

Attempts to set lokinet as the DNS server for systemd-resolved. 

**Parameters**: 

  * **if_name** &ndash; the interface name to which we add the DNS servers, e.g. lokitun0. Typically tun_endpoint.GetIfName(). 
  * **dns** &ndash; the listening address of the lokinet DNS server 
  * **global** &ndash; whether to set up lokinet for all DNS queries (true) or just .loki & .snode addresses (false). 


Returns true if successful, false if unsupported or fails. (When compiled without systemd support this always returns false without doing anything).


### function operator==

```cpp
inline bool operator==(
    const RouterID & lhs,
    const RouterID & rhs
)
```


### function BEncodeReadList

```cpp
template <typename List_t >
bool BEncodeReadList(
    List_t & result,
    llarp_buffer_t * buf
)
```


### function BEncodeWriteDictMsgType

```cpp
inline bool BEncodeWriteDictMsgType(
    llarp_buffer_t * buf,
    const char * k,
    const char * t
)
```


### function BEncodeWriteDictString

```cpp
template <typename Obj_t >
bool BEncodeWriteDictString(
    const char * k,
    const Obj_t & str,
    llarp_buffer_t * buf
)
```


### function BEncodeWriteDictEntry

```cpp
template <typename Obj_t >
bool BEncodeWriteDictEntry(
    const char * k,
    const Obj_t & o,
    llarp_buffer_t * buf
)
```


### function BEncodeWriteDictInt

```cpp
template <typename Int_t >
bool BEncodeWriteDictInt(
    const char * k,
    const Int_t & i,
    llarp_buffer_t * buf
)
```


### function BEncodeMaybeReadDictList

```cpp
template <typename List_t >
bool BEncodeMaybeReadDictList(
    const char * k,
    List_t & item,
    bool & read,
    const llarp_buffer_t & key,
    llarp_buffer_t * buf
)
```


### function BEncodeMaybeReadDictEntry

```cpp
template <typename Item_t >
bool BEncodeMaybeReadDictEntry(
    const char * k,
    Item_t & item,
    bool & read,
    const llarp_buffer_t & key,
    llarp_buffer_t * buf
)
```


### function BEncodeMaybeReadDictInt

```cpp
template <typename Int_t >
bool BEncodeMaybeReadDictInt(
    const char * k,
    Int_t & i,
    bool & read,
    const llarp_buffer_t & key,
    llarp_buffer_t * buf
)
```


### function BEncodeMaybeVerifyVersion

```cpp
template <typename Item_t >
bool BEncodeMaybeVerifyVersion(
    const char * k,
    Item_t & item,
    uint64_t expect,
    bool & read,
    const llarp_buffer_t & key,
    llarp_buffer_t * buf
)
```

If the key matches, reads in the version and ensures that it equals the expected version. 

### function BEncodeWriteDictBEncodeList

```cpp
template <typename List_t >
bool BEncodeWriteDictBEncodeList(
    const char * k,
    const List_t & l,
    llarp_buffer_t * buf
)
```


### function BEncodeWriteDictArray

```cpp
template <typename Array >
bool BEncodeWriteDictArray(
    const char * k,
    const Array & array,
    llarp_buffer_t * buf
)
```


### function BEncodeWriteList

```cpp
template <typename Iter >
bool BEncodeWriteList(
    Iter itr,
    Iter end,
    llarp_buffer_t * buf
)
```


### function bencode_read_dict

```cpp
template <typename Sink >
bool bencode_read_dict(
    Sink && sink,
    llarp_buffer_t * buffer
)
```


### function bencode_decode_dict

```cpp
template <typename Sink >
bool bencode_decode_dict(
    Sink && sink,
    llarp_buffer_t * buff
)
```


### function bencode_read_list

```cpp
template <typename Sink >
bool bencode_read_list(
    Sink && sink,
    llarp_buffer_t * buffer
)
```


### function BEncodeReadArray

```cpp
template <typename Array >
bool BEncodeReadArray(
    Array & array,
    llarp_buffer_t * buf
)
```


### function BEncodeReadSet

```cpp
template <typename Set_t >
bool BEncodeReadSet(
    Set_t & set,
    llarp_buffer_t * buffer
)
```

read a std::set of decodable entities and deny duplicates 

### function BEncodeWriteSet

```cpp
template <typename Set_t >
bool BEncodeWriteSet(
    const Set_t & set,
    llarp_buffer_t * buffer
)
```

write an iterable container as a list 

### function BEncodeWriteDictList

```cpp
template <typename List_t >
bool BEncodeWriteDictList(
    const char * k,
    List_t & list,
    llarp_buffer_t * buf
)
```


### function Dump

```cpp
template <size_t bufsz,
typename T >
void Dump(
    const T & val
)
```


### function BDecodeReadFile

```cpp
template <typename T >
bool BDecodeReadFile(
    const fs::path fpath,
    T & t
)
```

read entire file and decode its contents into t 

### function BEncodeWriteFile

```cpp
template <typename T ,
size_t bufsz>
bool BEncodeWriteFile(
    const fs::path fpath,
    const T & t
)
```

bencode and write to file 

### function BEncodeSeekDictVersion

```cpp
template <typename Int_t >
bool BEncodeSeekDictVersion(
    Int_t & v,
    llarp_buffer_t * buf,
    const byte_t k
)
```

seek for an int in a dict with a key k used for version set v to parsed value if found this call rewinds the buffer unconditionally before return returns false only if there was 

### function LogTrace

```cpp
template <typename... T>
LogTrace(
    T && ...
)
```


### function LogDebug

```cpp
template <typename... T>
LogDebug(
    T && ...
)
```


### function LogInfo

```cpp
template <typename... T>
LogInfo(
    T && ...
)
```


### function LogWarn

```cpp
template <typename... T>
LogWarn(
    T && ...
)
```


### function LogError

```cpp
template <typename... T>
LogError(
    T && ...
)
```


### function Zero

```cpp
void Zero(
    void * ptr,
    size_t sz
)
```


### function dumphex

```cpp
template <typename T >
void dumphex(
    const uint8_t * t
)
```


### function DumpBufferHex

```cpp
template <typename T ,
size_t align =128>
void DumpBufferHex(
    const T & buff
)
```


### function DumpBuffer

```cpp
template <typename T ,
size_t align =128>
void DumpBuffer(
    const T & buff
)
```


### function IsFalseValue

```cpp
bool IsFalseValue(
    std::string_view str
)
```


### function IsTrueValue

```cpp
bool IsTrueValue(
    std::string_view str
)
```


### function TrimWhitespace

```cpp
std::string_view TrimWhitespace(
    std::string_view str
)
```

Trim leading and trailing (ascii) whitespace from the given string; returns a std::string_view of the trimmed part of the string. 

### function string_iequal

```cpp
inline bool string_iequal(
    std::string_view s1,
    std::string_view s2
)
```

Returns true if the first string is equal to the second string, compared case-insensitively. 

### function string_iequal_any

```cpp
template <typename S1 ,
typename... S>
bool string_iequal_any(
    const S1 & s1,
    const S &... s
)
```

Returns true if the first string matches any of the given strings case-insensitively. 

Arguments must be string literals, std::string, or std::string_views 


### function starts_with

```cpp
inline constexpr bool starts_with(
    std::string_view str,
    std::string_view prefix
)
```

Returns true if the first argument begins with the second argument. 

### function ends_with

```cpp
inline constexpr bool ends_with(
    std::string_view str,
    std::string_view suffix
)
```

Returns true if the first argument ends with the second argument. 

### function strip_prefix

```cpp
inline constexpr std::string_view strip_prefix(
    std::string_view str,
    std::string_view prefix
)
```

removes a prefix from a string if it exists 

### function split

```cpp
std::vector< std::string_view > split(
    std::string_view str,
    std::string_view delim,
    bool trim =false
)
```

Splits a string on some delimiter string and returns a vector of string_view's pointing into the pieces of the original string. 

The pieces are valid only as long as the original string remains valid. Leading and trailing empty substrings are not removed. If delim is empty you get back a vector of string_views each viewing one character. If `trim` is true then leading and trailing empty values will be suppressed. 

```
auto v = split("ab--c----de", "--"); // v is {"ab", "c", "", "de"}
auto v = split("abc", ""); // v is {"a", "b", "c"}
auto v = split("abc", "c"); // v is {"ab", ""}
auto v = split("abc", "c", true); // v is {"ab"}
auto v = split("-a--b--", "-"); // v is {"", "a", "", "b", "", ""}
auto v = split("-a--b--", "-", true); // v is {"a", "", "b"}
```


### function split_any

```cpp
std::vector< std::string_view > split_any(
    std::string_view str,
    std::string_view delims,
    bool trim =false
)
```

Splits a string on any 1 or more of the given delimiter characters and returns a vector of string_view's pointing into the pieces of the original string. 

If delims is empty this works the same as [split()](Namespaces/namespacellarp.md#function-split). `trim` works like split (suppresses leading and trailing empty string pieces). 

```
auto v = split_any("abcdedf", "dcx"); // v is {"ab", "e", "f"} 
```


### function join

```cpp
template <typename It >
std::string join(
    std::string_view delimiter,
    It begin,
    It end
)
```

Joins [begin, end) with a delimiter and returns the resulting string. 

Elements can be anything that is fmt formattable. 


### function join

```cpp
template <typename Container >
std::string join(
    std::string_view delimiter,
    const Container & c
)
```

Wrapper around the above that takes a container and passes c.begin(), c.end() to the above. 

### function trim

```cpp
void trim(
    std::string_view & s
)
```

Simple version of whitespace trimming: mutates the given string view to remove leading space, \t, \r,   . 

(More exotic and locale-dependent whitespace is not removed). 


### function parse_int

```cpp
template <typename T >
bool parse_int(
    const std::string_view str,
    T & value,
    int base =10
)
```

Parses an integer of some sort from a string, requiring that the entire string be consumed during parsing. 

Return false if parsing failed, sets `value` and returns true if the entire string was consumed. 


### function lowercase_ascii_string

```cpp
std::string lowercase_ascii_string(
    std::string src
)
```


### function friendly_duration

```cpp
std::string friendly_duration(
    std::chrono::nanoseconds dur
)
```

Converts a duration into a human friendlier string. 

### function time_now_ms

```cpp
Duration_t time_now_ms()
```

get time right now as milliseconds, this is monotonic 

### function uptime

```cpp
Duration_t uptime()
```

get the uptime of the process 

### function ToMS

```cpp
uint64_t ToMS(
    Duration_t duration
)
```

convert to milliseconds 

### function to_json

```cpp
nlohmann::json to_json(
    const Duration_t & t
)
```



## Attributes Documentation

### variable event_loop_queue_size

```cpp
constexpr std::size_t event_loop_queue_size = 1024;
```

default queue length for logic jobs 

### variable our_rc_filename

```cpp
constexpr auto our_rc_filename = "self.signed";
```


### variable our_identity_filename

```cpp
constexpr auto our_identity_filename = "identity.key";
```


### variable our_enc_key_filename

```cpp
constexpr auto our_enc_key_filename = "encryption.key";
```


### variable our_transport_key_filename

```cpp
constexpr auto our_transport_key_filename = "transport.key";
```


### variable nodedb_dirname

```cpp
constexpr auto nodedb_dirname = "nodedb";
```


### variable TimeskipDetectedDuration

```cpp
constexpr auto TimeskipDetectedDuration = 1min;
```

how big of a time skip before we reset network state 

### variable VERSION

```cpp
const std::array< uint16_t, 3 > VERSION;
```


### variable ROUTER_VERSION

```cpp
const std::array< uint64_t, 4 > ROUTER_VERSION;
```


### variable VERSION_STR

```cpp
const char *const VERSION_STR;
```


### variable VERSION_TAG

```cpp
const char *const VERSION_TAG;
```


### variable VERSION_FULL

```cpp
const char *const VERSION_FULL;
```


### variable RELEASE_MOTTO

```cpp
const char *const RELEASE_MOTTO;
```


### variable DEFAULT_NETID

```cpp
const char *const DEFAULT_NETID;
```


### variable EncryptedFrameOverheadSize

```cpp
static constexpr size_t EncryptedFrameOverheadSize = PUBKEYSIZE + TUNNONCESIZE + SHORTHASHSIZE;
```


### variable EncryptedFrameBodySize

```cpp
static constexpr size_t EncryptedFrameBodySize = 128 * 6;
```


### variable EncryptedFrameSize

```cpp
static constexpr size_t EncryptedFrameSize = EncryptedFrameOverheadSize + EncryptedFrameBodySize;
```


### variable IsToStringFormattable< PubKey >

```cpp
constexpr bool IsToStringFormattable< PubKey > = true;
```


### variable IsToStringFormattable< SecretKey >

```cpp
constexpr bool IsToStringFormattable< SecretKey > = true;
```


### variable IsToStringFormattable< PrivateKey >

```cpp
constexpr bool IsToStringFormattable< PrivateKey > = true;
```


### variable IsToStringFormattable< IdentitySecret >

```cpp
constexpr bool IsToStringFormattable< IdentitySecret > = true;
```


### variable IsToStringFormattable< AddressInfo >

```cpp
constexpr bool IsToStringFormattable< AddressInfo > = true;
```


### variable IsToStringFormattable< ExitInfo >

```cpp
constexpr bool IsToStringFormattable< ExitInfo > = true;
```


### variable IsToStringFormattable< IpAddress >

```cpp
constexpr bool IsToStringFormattable< IpAddress > = true;
```


### variable IsToStringFormattable< IPRange >

```cpp
constexpr bool IsToStringFormattable< IPRange > = true;
```


### variable ipv4_map_prefix

```cpp
constexpr std::array< uint8_t, 12 > ipv4_map_prefix {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff};
```


### variable IsToStringFormattable< huint128_t >

```cpp
constexpr bool IsToStringFormattable< huint128_t > = true;
```


### variable IsToStringFormattable< huint32_t >

```cpp
constexpr bool IsToStringFormattable< huint32_t > = true;
```


### variable IsToStringFormattable< huint16_t >

```cpp
constexpr bool IsToStringFormattable< huint16_t > = true;
```


### variable IsToStringFormattable< SockAddr >

```cpp
constexpr bool IsToStringFormattable< SockAddr > = true;
```


### variable IsToStringFormattable< PoW >

```cpp
constexpr bool IsToStringFormattable< PoW > = true;
```


### variable MaxGossipPeers

```cpp
constexpr size_t MaxGossipPeers = 20;
```

The maximum number of peers we will flood a gossiped RC to when propagating an RC. 

### variable MAX_PATH_QUEUE_SIZE

```cpp
static const size_t MAX_PATH_QUEUE_SIZE = 100;
```


### variable MAX_OUTBOUND_QUEUE_SIZE

```cpp
static const size_t MAX_OUTBOUND_QUEUE_SIZE = 1000;
```


### variable MAX_OUTBOUND_MESSAGES_PER_TICK

```cpp
static const size_t MAX_OUTBOUND_MESSAGES_PER_TICK = 500;
```


### variable IsToStringFormattable< SessionResult >

```cpp
constexpr bool IsToStringFormattable< SessionResult > = true;
```


### variable IsToStringFormattable< NetID >

```cpp
constexpr bool IsToStringFormattable< NetID > = true;
```


### variable IsToStringFormattable< RouterContact >

```cpp
constexpr bool IsToStringFormattable< RouterContact > = true;
```


### variable IsToStringFormattable< RouterID >

```cpp
constexpr bool IsToStringFormattable< RouterID > = true;
```


### variable IsToStringFormattable< RouterVersion >

```cpp
constexpr bool IsToStringFormattable< RouterVersion > = true;
```


### variable INVALID_VERSION

```cpp
static constexpr int64_t INVALID_VERSION = -1;
```


### variable emptyRouterVersion

```cpp
static const RouterVersion({0, 0, 0}, INVALID_VERSION) emptyRouterVersion;
```


### variable is_aligned_buffer

```cpp
constexpr bool is_aligned_buffer =
      decltype(detail::is_aligned_buffer_impl(static_cast<T*>(nullptr)))::value;
```


### variable IsToStringFormattable

```cpp
constexpr bool IsToStringFormattable = false;
```


### variable is_scoped_enum_v

```cpp
constexpr bool is_scoped_enum_v = is_scoped_enum<T>::value;
```


### variable IsToStringFormattable< buffer_printer >

```cpp
constexpr bool IsToStringFormattable< buffer_printer > = true;
```





-------------------------------

Updated on 2022-08-30 at 18:09:26 +0000