Namespaces
	crypto

	log

Classes
struct	Bucket

struct	Config

class	Dht

class	DhtException

class	DhtInterface

class	DhtMessage

class	DhtProxyClient

class	DhtProxyServer

class	DhtRunner

class	EncryptedValue

class	ExecutionContext

class	Executor

class	FieldValue
	Describes a value filter. More...

class	FieldValueIndex
	An index for field values. More...

class	Hash

struct	HexMap

class	IceCandidates

class	ImMessage

class	IpServiceAnnouncement

struct	Logger

struct	LogMethod

struct	Node

struct	NodeCache

struct	NodeExport

struct	NodeInfo

struct	NodeStats

class	PeerDiscovery

struct	ProxyServerConfig

class	Query
	Describes a query destined to another peer. More...

class	RateLimiter

class	RoutingTable

class	Scheduler
	Job scheduler. More...

class	SecureDht

struct	SecureDhtConfig

class	Select
	Serializable Value field selection. More...

class	SignedValue

class	SockAddr

struct	Socket

class	SocketException

class	ThreadPool

class	TrustRequest

class	TypeStore

class	uniform_duration_distribution

struct	Value

struct	ValueType

class	Where
	Serializable dht::Value filter. More...

Typedefs
using	ValuesExport = std::pair< InfoHash, Blob >

using	QueryCallback = std::function< bool(const std::vector< std::shared_ptr< FieldValueIndex > > &fields)>

using	GetCallback = std::function< bool(const std::vector< std::shared_ptr< Value > > &values)>

using	ValueCallback = std::function< bool(const std::vector< std::shared_ptr< Value > > &values, bool expired)>

using	GetCallbackSimple = std::function< bool(std::shared_ptr< Value > value)>

using	ShutdownCallback = std::function< void()>

using	IdentityAnnouncedCb = std::function< void(bool)>

using	CertificateStoreQuery = std::function< std::vector< std::shared_ptr< crypto::Certificate > >(const InfoHash &pk_id)>

typedef bool(*	GetCallbackRaw) (std::shared_ptr< Value >, void *user_data)

typedef bool(*	ValueCallbackRaw) (std::shared_ptr< Value >, bool expired, void *user_data)

using	DoneCallback = std::function< void(bool success, const std::vector< std::shared_ptr< Node > > &nodes)>

typedef void(*	DoneCallbackRaw) (bool, std::vector< std::shared_ptr< Node >> , void user_data)

typedef void(*	ShutdownCallbackRaw) (void *user_data)

typedef void(*	DoneCallbackSimpleRaw) (bool, void *user_data)

typedef bool(*	FilterRaw) (const Value &, void *user_data)

using	DoneCallbackSimple = std::function< void(bool success)>

using	RestRouter = restinio::router::express_router_t<>

using	RequestStatus = restinio::request_handling_status_t

using	byte = uint8_t

using	InfoHash = Hash< HASH_LEN >

using	h256 = Hash< 32 >

using	PkId = h256

using	Tid = uint32_t

using	SocketCb = std::function< void(const Sp< Node > &, net::RequestAnswer &&)>

using	NetId = uint32_t

using	want_t = int_fast8_t

template<class T >
using	Sp = std::shared_ptr< T >

using	clock = std::chrono::steady_clock

using	system_clock = std::chrono::system_clock

using	time_point = clock::time_point

using	duration = clock::duration

using	Blob = std::vector< uint8_t >

using	StorePolicy = std::function< bool(InfoHash key, std::shared_ptr< Value > &value, const InfoHash &from, const SockAddr &addr)>

using	EditPolicy = std::function< bool(InfoHash key, const std::shared_ptr< Value > &old_val, std::shared_ptr< Value > &new_val, const InfoHash &from, const SockAddr &addr)>

Enumerations
enum	NodeStatus { Disconnected, Connecting, Connected }

enum	ImStatus : uint8_t { NONE = 0, TYPING, RECEIVED, READ }

enum	PushType { None = 0, Android, iOS }

Functions
constexpr const char *	statusToStr (NodeStatus status)

OPENDHT_PUBLIC GetCallbackSimple	bindGetCb (GetCallbackRaw raw_cb, void *user_data)

OPENDHT_PUBLIC GetCallback	bindGetCb (GetCallbackSimple cb)

OPENDHT_PUBLIC ValueCallback	bindValueCb (ValueCallbackRaw raw_cb, void *user_data)

OPENDHT_PUBLIC ShutdownCallback	bindShutdownCb (ShutdownCallbackRaw shutdown_cb_raw, void *user_data)

OPENDHT_PUBLIC DoneCallback	bindDoneCb (DoneCallbackSimple donecb)

OPENDHT_PUBLIC DoneCallback	bindDoneCb (DoneCallbackRaw raw_cb, void *user_data)

OPENDHT_PUBLIC DoneCallbackSimple	bindDoneCbSimple (DoneCallbackSimpleRaw raw_cb, void *user_data)

OPENDHT_PUBLIC Value::Filter	bindFilterRaw (FilterRaw raw_filter, void *user_data)

template<size_t N>
std::ostream &	operator<< (std::ostream &s, const Hash< N > &h)

template<size_t N>
std::istream &	operator>> (std::istream &s, Hash< N > &h)

std::string	toHex (const uint8_t *data, size_t size)

std::string	toHex (const std::vector< uint8_t > &data)

OPENDHT_PUBLIC std::string	print_addr (const sockaddr *sa, socklen_t slen)

OPENDHT_PUBLIC std::string	print_addr (const sockaddr_storage &ss, socklen_t sslen)

OPENDHT_PUBLIC bool	operator== (const SockAddr &a, const SockAddr &b)

OPENDHT_PUBLIC const char *	version ()

template<typename Key , typename Item , typename Condition >
void	erase_if (std::map< Key, Item > &map, const Condition &condition)

OPENDHT_PUBLIC std::pair< std::string, std::string >	splitPort (const std::string &s)

time_point	from_time_t (std::time_t t)

std::time_t	to_time_t (time_point t)

std::string	to_str (double d)

template<class DT >
static double	print_dt (DT d)

template<class DT >
static std::string	print_duration (DT d)

template<class TimePoint >
static std::string	print_time_relative (TimePoint now, TimePoint d)

OPENDHT_PUBLIC Blob	unpackBlob (const msgpack::object &o)

template<typename Type >
Blob	packMsg (const Type &t)

template<typename Type >
Type	unpackMsg (Blob b)

msgpack::object *	findMapValue (const msgpack::object &map, const char *key, size_t length)

msgpack::object *	findMapValue (const msgpack::object &map, const char *key)

msgpack::object *	findMapValue (const msgpack::object &map, std::string_view key)

static constexpr auto	VALUE_KEY_ID ("id")

static const std::string	VALUE_KEY_DAT ("dat")

static const std::string	VALUE_KEY_PRIO ("p")

static const std::string	VALUE_KEY_SIGNATURE ("sig")

static const std::string	VALUE_KEY_SEQ ("seq")

static const std::string	VALUE_KEY_DATA ("data")

static const std::string	VALUE_KEY_OWNER ("owner")

static const std::string	VALUE_KEY_TYPE ("type")

static const std::string	VALUE_KEY_TO ("to")

static const std::string	VALUE_KEY_BODY ("body")

static const std::string	VALUE_KEY_USERTYPE ("utype")

template<typename T , typename std::enable_if< std::is_base_of< Value::SerializableBase, T >::value, T >::type * = nullptr>
Value::Filter	getFilterSet (Value::Filter f)

template<typename T , typename std::enable_if< std::is_base_of< Value::SerializableBase, T >::value, T >::type * = nullptr>
Value::Filter	getFilterSet ()

template<class T >
std::vector< T >	unpackVector (const std::vector< std::shared_ptr< Value >> &vals)

Variables
static constexpr size_t	DEFAULT_STORAGE_LIMIT {1024 * 1024 * 64}

OPENDHT_PUBLIC const std::array< std::reference_wrapper< const ValueType >, 5 >	DEFAULT_TYPES

OPENDHT_PUBLIC const std::array< std::reference_wrapper< const ValueType >, 1 >	DEFAULT_INSECURE_TYPES

OPENDHT_PUBLIC const HexMap	hex_map

static constexpr unsigned	TARGET_NODES {8}

const ValueType	CERTIFICATE_TYPE

static constexpr const size_t	MAX_VALUE_SIZE {1024 * 64}

Detailed Description

OpenDHT C++ namespace

Typedef Documentation

◆ Blob

using dht::Blob = typedef std::vector<uint8_t>

Arbitrary binary data.

Definition at line 151 of file utils.h.

◆ EditPolicy

using dht::EditPolicy = typedef std::function<bool(InfoHash key, const std::shared_ptr<Value>& old_val, std::shared_ptr<Value>& new_val, const InfoHash& from, const SockAddr& addr)>

An edition policy is applied once to every incoming value storage requests, if a value already exists for this key and value id. If the policy returns false, the edition request is ignored. The default behavior is to deny edition (see {ValueType::DEFAULT_EDIT_POLICY}). Some {ValueType}s may override this behavior (e.g. SignedValue).

Parameters

key	the key where the value is stored.
old_val	the previously stored value.
new_val	the new value to be stored. The value can be edited by the edit policy.
from	id of the requesting node.
form_addr	network address of the incoming request.
from_len	network address lendth of the incoming request.

Definition at line 90 of file value.h.

◆ StorePolicy

using dht::StorePolicy = typedef std::function<bool(InfoHash key, std::shared_ptr<Value>& value, const InfoHash& from, const SockAddr& addr)>

A storage policy is applied once to every incoming value storage requests. If the policy returns false, the value is dropped.

Parameters

key	the key where the storage is requested.
value	the value to be stored. The value can be edited by the storage policy.
from	id of the requesting node.
form_addr	network address of the incoming request.
from_len	network address lendth of the incoming request.

Definition at line 74 of file value.h.

Enumeration Type Documentation

◆ NodeStatus

enum dht::NodeStatus

strong

Current status of a DHT node.

Definition at line 42 of file callbacks.h.

Function Documentation

◆ print_dt()

template<class DT >

static double dht::print_dt ( DT d )

static

Converts std::chrono::duration to floating-point seconds.

Definition at line 99 of file utils.h.

◆ splitPort()

OPENDHT_PUBLIC std::pair<std::string, std::string> dht::splitPort ( const std::string & s )

Split "[host]:port" or "host:port" to pair<"host", "port">.

◆ unpackBlob()

OPENDHT_PUBLIC Blob dht::unpackBlob ( const msgpack::object & o )

Provides backward compatibility with msgpack 1.0

Variable Documentation

◆ CERTIFICATE_TYPE

const ValueType dht::CERTIFICATE_TYPE

Initial value:

= {
    8, "Certificate", std::chrono::hours(24 * 7),
    
    [](InfoHash id, Sp<Value>& v, const InfoHash&, const SockAddr&) {
        try {
            crypto::Certificate crt(v->data);
            
            return crt.getPublicKey().getId() == id;
        } catch (const std::exception& e) {}
        return false;
    },
    [](InfoHash, const Sp<Value>& o, Sp<Value>& n, const InfoHash&, const SockAddr&) {
        try {
            return crypto::Certificate(o->data).getPublicKey().getId() == crypto::Certificate(n->data).getPublicKey().getId();
        } catch (const std::exception& e) {}
        return false;
    }
}

Definition at line 374 of file securedht.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables