mirror of
https://github.com/savoirfairelinux/opendht.git
synced 2026-11-08 04:21:51 +00:00
453 lines
17 KiB
Cython
453 lines
17 KiB
Cython
# Copyright (c) 2014-2026 Savoir-faire Linux Inc.
|
|
# SPDX-License-Identifier: MIT
|
|
|
|
from libc.stdint cimport uint8_t, uint16_t, uint32_t, uint64_t
|
|
from libcpp cimport bool, nullptr_t, nullptr
|
|
from libcpp.string cimport string
|
|
from libcpp.vector cimport vector
|
|
from libcpp.utility cimport pair
|
|
from libcpp.map cimport map
|
|
from libcpp.memory cimport shared_ptr, make_shared
|
|
from libc.string cimport const_char
|
|
|
|
ctypedef uint16_t in_port_t
|
|
ctypedef unsigned short int sa_family_t
|
|
|
|
cdef extern from "<chrono>" namespace "std::chrono" nogil:
|
|
cdef cppclass duration[ulong]:
|
|
duration() except +
|
|
|
|
cdef cppclass seconds:
|
|
duration seconds(uint64_t) except +
|
|
duration seconds()
|
|
|
|
cdef extern from "<functional>" namespace "std" nogil:
|
|
cdef cppclass hash[T]:
|
|
hash() except +
|
|
size_t get "operator()"(T)
|
|
|
|
cdef extern from "<future>" namespace "std" nogil:
|
|
cdef cppclass shared_future[T]:
|
|
shared_future() except +
|
|
bool valid() const
|
|
|
|
cdef cppclass future[T]:
|
|
future() except +
|
|
bool valid() const
|
|
shared_future[T] share()
|
|
|
|
cdef extern from "opendht/utils.h" namespace "dht":
|
|
const char* version()
|
|
cdef cppclass time_point:
|
|
@staticmethod
|
|
time_point min() const
|
|
@staticmethod
|
|
time_point max() const
|
|
|
|
cdef extern from "opendht/infohash.h" namespace "dht":
|
|
cdef cppclass InfoHash:
|
|
InfoHash() except +
|
|
InfoHash(string s) except +
|
|
string toString() const
|
|
bool getBit(unsigned bit) const
|
|
void setBit(unsigned bit, bool b)
|
|
double toFloat() const
|
|
@staticmethod
|
|
unsigned commonBits(InfoHash a, InfoHash b)
|
|
@staticmethod
|
|
InfoHash get(string s)
|
|
@staticmethod
|
|
InfoHash getRandom()
|
|
bool operator==(InfoHash) const
|
|
bool operator<(InfoHash) const
|
|
bool operator bool() const
|
|
|
|
cdef cppclass PkId:
|
|
PkId() except +
|
|
PkId(string s) except +
|
|
string toString() const
|
|
bool getBit(unsigned bit) const
|
|
void setBit(unsigned bit, bool b)
|
|
double toFloat() const
|
|
@staticmethod
|
|
unsigned commonBits(PkId a, PkId b)
|
|
@staticmethod
|
|
PkId get(string s)
|
|
@staticmethod
|
|
PkId getRandom()
|
|
bool operator==(PkId) const
|
|
bool operator<(PkId) const
|
|
bool operator bool() const
|
|
|
|
|
|
cdef extern from "opendht/sockaddr.h" namespace "dht":
|
|
cdef cppclass SockAddr:
|
|
SockAddr() except +
|
|
string toString() const
|
|
in_port_t getPort() const
|
|
void setPort(in_port_t p)
|
|
sa_family_t getFamily() const
|
|
void setFamily(sa_family_t f)
|
|
bool isLoopback() const
|
|
bool isPrivate() const
|
|
bool isUnspecified() const
|
|
@staticmethod
|
|
vector[SockAddr] resolve(string host, string service) except +
|
|
|
|
ctypedef vector[uint8_t] Blob
|
|
|
|
cdef extern from "opendht/crypto.h" namespace "dht::crypto":
|
|
ctypedef pair[shared_ptr[PrivateKey], shared_ptr[Certificate]] Identity
|
|
cdef Identity generateIdentity(string name, Identity ca, unsigned bits) except +
|
|
cdef Blob aesEncrypt(Blob data, string password) except +
|
|
cdef Blob aesDecrypt(Blob encrypted, string password) except +
|
|
|
|
cdef cppclass PrivateKey:
|
|
PrivateKey() except +
|
|
PrivateKey(Blob data, string password) except +
|
|
shared_ptr[PublicKey] getSharedPublicKey() except +
|
|
Blob serialize(string password) except +
|
|
Blob decrypt(Blob data) except +
|
|
Blob sign(Blob data) except +
|
|
@staticmethod
|
|
PrivateKey generate() except +
|
|
@staticmethod
|
|
PrivateKey generateEC() except +
|
|
|
|
cdef cppclass PublicKey:
|
|
PublicKey() except +
|
|
PublicKey(Blob data) except +
|
|
InfoHash getId() except +
|
|
PkId getLongId() except +
|
|
void pack(Blob& data) except +
|
|
Blob encrypt(Blob data) except +
|
|
bool checkSignature(Blob data, Blob signature) except +
|
|
bool operator==(PublicKey) const
|
|
|
|
cdef cppclass Certificate:
|
|
Certificate() except +
|
|
Certificate(string pem) except +
|
|
InfoHash getId() except +
|
|
PkId getLongId() except +
|
|
string toString() except +
|
|
string getName() except +
|
|
void revoke(PrivateKey key, Certificate cert) except +
|
|
@staticmethod
|
|
Certificate generate(PrivateKey key, string name, Identity ca, bool is_ca) except +
|
|
shared_ptr[Certificate] issuer
|
|
|
|
cdef cppclass TrustList:
|
|
cppclass VerifyResult:
|
|
bool operator bool() const
|
|
bool isValid() const
|
|
string toString() except +
|
|
TrustList() except +
|
|
void add(Certificate) except +
|
|
void remove(Certificate) except +
|
|
VerifyResult verify(Certificate) except +
|
|
|
|
ctypedef TrustList.VerifyResult TrustListVerifyResult
|
|
|
|
cdef extern from "opendht/value.h" namespace "dht::Value":
|
|
cdef cppclass Field:
|
|
pass
|
|
|
|
cdef extern from "opendht/value.h" namespace "dht::Value::Field":
|
|
cdef Field None
|
|
cdef Field Id
|
|
cdef Field ValueTypeField "dht::Value::Field::ValueType"
|
|
cdef Field OwnerPk
|
|
cdef Field SeqNum
|
|
cdef Field UserType
|
|
cdef Field COUNT
|
|
|
|
cdef extern from "opendht/value.h" namespace "dht":
|
|
cdef cppclass Value:
|
|
Value() except +
|
|
Value(vector[uint8_t]) except +
|
|
Value(const uint16_t t, const uint8_t* dat_ptr, size_t dat_len) except +
|
|
string toString() const
|
|
size_t size() const
|
|
bool isSigned() const
|
|
bool isEncrypted() const
|
|
uint64_t id
|
|
shared_ptr[PublicKey] owner
|
|
InfoHash recipient
|
|
vector[uint8_t] data
|
|
string user_type
|
|
uint16_t type
|
|
uint16_t seq
|
|
unsigned priority
|
|
string pushType
|
|
|
|
cdef cppclass ValueType:
|
|
ValueType() except +
|
|
ValueType(uint16_t id, string name, seconds expiration) except +
|
|
uint16_t id
|
|
string name
|
|
seconds expiration
|
|
|
|
cdef cppclass Query:
|
|
Query() except +
|
|
Query(Select s, Where w) except +
|
|
Query(string q_str) except +
|
|
bool isSatisfiedBy(const Query& q) const
|
|
string toString() const
|
|
|
|
cdef cppclass Select:
|
|
Select() except +
|
|
Select(const string& q_str) except +
|
|
bool isSatisfiedBy(const Select& os) const
|
|
Select& field(Field field)
|
|
string toString() const
|
|
|
|
cdef cppclass Where:
|
|
Where() except +
|
|
Where(const string& q_str) except +
|
|
bool isSatisfiedBy(const Where& where) const
|
|
Where& id(uint64_t id)
|
|
Where& valueType(uint16_t type)
|
|
Where& owner(InfoHash owner_pk_hash)
|
|
Where& seq(uint16_t seq_no)
|
|
Where& userType(string user_type)
|
|
string toString() const
|
|
|
|
cdef cppclass FieldValue:
|
|
uint64_t getInt() const
|
|
InfoHash getHash() const
|
|
Blob getBlob() const
|
|
|
|
cdef cppclass FieldValueIndex:
|
|
map[Field, FieldValue] index
|
|
|
|
cdef extern from "opendht/node.h" namespace "dht":
|
|
cdef cppclass Node:
|
|
Node() except +
|
|
InfoHash getId() const
|
|
string getAddrStr() const
|
|
bool isExpired() const
|
|
|
|
cdef extern from "opendht/callbacks.h" namespace "dht":
|
|
cdef cppclass NodeStats:
|
|
unsigned good_nodes
|
|
unsigned dubious_nodes
|
|
unsigned cached_nodes
|
|
unsigned incoming_nodes
|
|
unsigned table_depth
|
|
unsigned searches
|
|
unsigned node_cache_size
|
|
unsigned getKnownNodes() const
|
|
unsigned long getNetworkSizeEstimation() const
|
|
|
|
cdef cppclass NodeInfo:
|
|
InfoHash id
|
|
InfoHash node_id
|
|
NodeStats ipv4
|
|
NodeStats ipv6
|
|
size_t ongoing_ops
|
|
size_t storage_values
|
|
size_t storage_size
|
|
size_t local_storage_values
|
|
size_t local_storage_size
|
|
in_port_t bound4
|
|
in_port_t bound6
|
|
|
|
ctypedef void (*ShutdownCallbackRaw)(void *user_data)
|
|
ctypedef bool (*GetCallbackRaw)(shared_ptr[Value] values, void *user_data)
|
|
ctypedef bool (*ValueCallbackRaw)(shared_ptr[Value] values, bool expired, void *user_data)
|
|
ctypedef void (*DoneCallbackRaw)(bool done, vector[shared_ptr[Node]]* nodes, void *user_data)
|
|
ctypedef void (*DoneCallbackSimpleRaw)(bool done, void *user_data)
|
|
|
|
cppclass ShutdownCallback:
|
|
ShutdownCallback() except +
|
|
cppclass GetCallback:
|
|
GetCallback() except +
|
|
cppclass ValueCallback:
|
|
ValueCallback() except +
|
|
cppclass DoneCallback:
|
|
DoneCallback() except +
|
|
cppclass DoneCallbackSimple:
|
|
DoneCallbackSimple() except +
|
|
|
|
cdef ShutdownCallback bindShutdownCb(ShutdownCallbackRaw cb, void *user_data)
|
|
cdef GetCallback bindGetCb(GetCallbackRaw cb, void *user_data)
|
|
cdef ValueCallback bindValueCb(ValueCallbackRaw cb, void *user_data)
|
|
cdef DoneCallback bindDoneCb(DoneCallbackRaw cb, void *user_data)
|
|
cdef DoneCallbackSimple bindDoneCbSimple(DoneCallbackSimpleRaw cb, void *user_data)
|
|
|
|
cppclass Config:
|
|
InfoHash node_id
|
|
uint32_t network
|
|
bool is_bootstrap
|
|
bool maintain_storage
|
|
string persist_path
|
|
size_t max_req_per_sec
|
|
size_t max_peer_req_per_sec
|
|
ssize_t max_crypto_per_sec
|
|
ssize_t max_peer_crypto_per_sec
|
|
cppclass SecureDhtConfig:
|
|
Config node_config
|
|
Identity id
|
|
|
|
cdef extern from *:
|
|
"""
|
|
#include <Python.h>
|
|
#include <opendht/dhtrunner.h>
|
|
|
|
static std::shared_ptr<PyObject> opendht_python_owner(PyObject* data)
|
|
{
|
|
auto state = PyGILState_Ensure();
|
|
Py_INCREF(data);
|
|
PyGILState_Release(state);
|
|
return std::shared_ptr<PyObject>(data, [](PyObject* object) {
|
|
auto state = PyGILState_Ensure();
|
|
Py_DECREF(object);
|
|
PyGILState_Release(state);
|
|
});
|
|
}
|
|
|
|
static dht::ValueCallback opendht_bind_python_value_cb(
|
|
dht::ValueCallbackRaw callback, PyObject* data)
|
|
{
|
|
auto owner = opendht_python_owner(data);
|
|
return [callback, owner = std::move(owner)](
|
|
const std::vector<std::shared_ptr<dht::Value>>& values, bool expired) {
|
|
for (const auto& value : values)
|
|
if (!callback(value, expired, owner.get()))
|
|
return false;
|
|
return true;
|
|
};
|
|
}
|
|
|
|
static dht::DhtRunner::Context opendht_python_context(
|
|
void (*callback)(int, int, void*), PyObject* data)
|
|
{
|
|
dht::DhtRunner::Context context;
|
|
auto owner = opendht_python_owner(data);
|
|
context.statusChangedCallback = [callback, owner = std::move(owner)](
|
|
dht::NodeStatus ipv4, dht::NodeStatus ipv6) {
|
|
callback(static_cast<int>(ipv4), static_cast<int>(ipv6), owner.get());
|
|
};
|
|
return context;
|
|
}
|
|
|
|
static void opendht_python_run(dht::DhtRunner& runner, in_port_t port,
|
|
dht::DhtRunner::Config& config, void (*callback)(int, int, void*), PyObject* data)
|
|
{
|
|
runner.run(port, config, opendht_python_context(callback, data));
|
|
}
|
|
|
|
static void opendht_python_run(dht::DhtRunner& runner,
|
|
const char* ipv4, const char* ipv6, const char* port,
|
|
dht::DhtRunner::Config& config, void (*callback)(int, int, void*), PyObject* data)
|
|
{
|
|
runner.run(ipv4, ipv6, port, config, opendht_python_context(callback, data));
|
|
}
|
|
|
|
static void opendht_python_query(dht::DhtRunner& runner, const dht::InfoHash& key,
|
|
bool (*callback)(std::shared_ptr<dht::FieldValueIndex>, void*),
|
|
dht::DoneCallbackRaw done, PyObject* data, dht::Query query)
|
|
{
|
|
auto owner = opendht_python_owner(data);
|
|
runner.query(key,
|
|
[callback, owner](const std::vector<std::shared_ptr<dht::FieldValueIndex>>& rows) {
|
|
for (const auto& row : rows)
|
|
if (!callback(row, owner.get()))
|
|
return false;
|
|
return true;
|
|
},
|
|
[done, owner](bool ok, const std::vector<std::shared_ptr<dht::Node>>& nodes) {
|
|
done(ok, const_cast<std::vector<std::shared_ptr<dht::Node>>*>(&nodes), owner.get());
|
|
}, std::move(query));
|
|
}
|
|
"""
|
|
ValueCallback bindPythonValueCb "opendht_bind_python_value_cb"(ValueCallbackRaw callback, object data) except +
|
|
|
|
ctypedef future[size_t] ListenToken
|
|
ctypedef shared_future[size_t] SharedListenToken
|
|
|
|
cdef extern from "opendht/dhtrunner.h" namespace "dht":
|
|
cdef cppclass DhtRunner:
|
|
DhtRunner() except +
|
|
cppclass Config:
|
|
SecureDhtConfig dht_config
|
|
bool threaded
|
|
string proxy_server
|
|
string push_node_id
|
|
string push_token
|
|
string push_topic
|
|
string push_platform
|
|
string proxy_user_agent
|
|
bool peer_discovery
|
|
bool peer_publish
|
|
shared_ptr[Certificate] server_ca
|
|
Identity client_identity
|
|
SockAddr bind4
|
|
SockAddr bind6
|
|
|
|
InfoHash getId() except + nogil
|
|
shared_ptr[PublicKey] getPublicKey() except + nogil
|
|
InfoHash getNodeId() except + nogil
|
|
NodeInfo getNodeInfo() except + nogil
|
|
vector[SockAddr] getPublicAddress(sa_family_t af) except + nogil
|
|
void connectivityChanged() except + nogil
|
|
void bootstrap(const_char*, const_char*)
|
|
void bootstrap(const SockAddr&, DoneCallbackSimple done_cb)
|
|
void run(in_port_t, Config config) except +
|
|
void run(const_char*, const_char*, const_char*, Config config) except +
|
|
void join() except + nogil
|
|
void shutdown(ShutdownCallback)
|
|
void registerType(const ValueType& value) except + nogil
|
|
bool isRunning()
|
|
SockAddr getBound(sa_family_t af) except + nogil
|
|
string getStorageLog() except + nogil
|
|
string getRoutingTablesLog(sa_family_t af) except + nogil
|
|
string getSearchesLog(sa_family_t af) except + nogil
|
|
void get(InfoHash key, GetCallback get_cb, DoneCallback done_cb, nullptr_t f, Where w)
|
|
void put(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, time_point created, bool permanent)
|
|
void putSigned(InfoHash key, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
|
|
void putEncrypted(InfoHash key, PkId to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
|
|
void putEncrypted(InfoHash key, shared_ptr[PublicKey] to, shared_ptr[Value] val, DoneCallback done_cb, bool permanent)
|
|
void cancelPut(InfoHash key, shared_ptr[Value] val)
|
|
ListenToken listen(InfoHash key, ValueCallback get_cb, nullptr_t f, Where w) except +
|
|
void cancelListen(InfoHash key, SharedListenToken token) except +
|
|
vector[unsigned] getNodeMessageStats(bool i) except + nogil
|
|
|
|
ctypedef DhtRunner.Config DhtRunnerConfig
|
|
|
|
cdef extern from *:
|
|
ctypedef void (*StatusCallbackRaw)(int ipv4, int ipv6, void* data)
|
|
ctypedef bool (*QueryCallbackRaw)(shared_ptr[FieldValueIndex] row, void* data)
|
|
void runPythonRunner "opendht_python_run"(DhtRunner& runner, in_port_t port, DhtRunnerConfig& config, StatusCallbackRaw callback, object data) except + nogil
|
|
void runPythonRunnerAddress "opendht_python_run"(DhtRunner& runner, const_char* ipv4, const_char* ipv6, const_char* port, DhtRunnerConfig& config, StatusCallbackRaw callback, object data) except + nogil
|
|
void queryPython "opendht_python_query"(DhtRunner& runner, InfoHash key, QueryCallbackRaw callback, DoneCallbackRaw done, object data, Query query) except +
|
|
|
|
cdef extern from "opendht/log.h" namespace "dht::log":
|
|
void enableLogging(DhtRunner& dht) except + nogil
|
|
void disableLogging(DhtRunner& dht) except + nogil
|
|
void enableFileLogging(DhtRunner& dht, const string& path) except + nogil
|
|
|
|
cdef extern from "opendht/indexation/pht.h" namespace "dht::indexation":
|
|
size_t PHT_MAX_NODE_ENTRY_COUNT "dht::indexation::Pht::MAX_NODE_ENTRY_COUNT"
|
|
cdef cppclass Prefix:
|
|
Prefix() except +
|
|
Prefix(vector[uint8_t]) except +
|
|
string toString() const
|
|
ctypedef pair[InfoHash, uint64_t] IndexValue "dht::indexation::Value"
|
|
ctypedef map[string, vector[uint8_t]] IndexKey "dht::indexation::Pht::Key"
|
|
ctypedef map[string, uint32_t] IndexKeySpec "dht::indexation::Pht::KeySpec"
|
|
ctypedef void (*LookupCallbackRaw)(vector[shared_ptr[IndexValue]]* values, Prefix* p, void* user_data);
|
|
cdef cppclass Pht:
|
|
cppclass LookupCallback:
|
|
LookupCallback() except +
|
|
Pht(string, IndexKeySpec, shared_ptr[DhtRunner]) except +
|
|
void lookup(IndexKey k, LookupCallback cb, DoneCallbackSimple doneCb) except +
|
|
void insert(IndexKey k, IndexValue v, DoneCallbackSimple cb) except +
|
|
@staticmethod
|
|
LookupCallback bindLookupCb(LookupCallbackRaw cb, void *user_data)
|
|
|
|
cdef extern from "gnutls/gnutls.h" nogil:
|
|
int gnutls_global_init()
|
|
void gnutls_global_deinit()
|
|
const char* gnutls_strerror(int error)
|