36 typedef std::function<void(
bool)> SignatureCheckCallback;
42 auto c = conf.node_config;
43 if (not c.node_id and conf.id.second)
44 c.
node_id = InfoHash::get(
"node:"+conf.id.second->getId().toString());
54 SecureDht(std::unique_ptr<DhtInterface>
dht,
Config config, IdentityAnnouncedCb iacb = {},
const std::shared_ptr<Logger>& l = {});
58 InfoHash getId()
const {
59 return key_ ? key_->getPublicKey().getId() : InfoHash();
61 PkId getLongId()
const {
62 return key_ ? key_->getPublicKey().getLongId() : PkId();
64 Sp<crypto::PublicKey> getPublicKey()
const {
65 return key_ ? key_->getSharedPublicKey() : Sp<crypto::PublicKey>{};
68 ValueType secureType(ValueType&& type);
70 ValueType secureType(
const ValueType& type) {
71 ValueType tmp_type = type;
72 return secureType(std::move(tmp_type));
75 void registerType(
const ValueType& type)
override {
77 dht_->registerType(secureType(type));
79 void registerType(ValueType&& type) {
81 dht_->registerType(secureType(std::forward<ValueType>(type)));
83 void registerInsecureType(
const ValueType& type) {
85 dht_->registerType(type);
94 void get(
const InfoHash&
id, GetCallback cb, DoneCallbackSimple donecb={}, Value::Filter&& f = {}, Where&& w = {})
override {
95 get(
id, cb, bindDoneCb(donecb), std::forward<Value::Filter>(f), std::forward<Where>(w));
97 void get(
const InfoHash& key, GetCallbackSimple cb, DoneCallback donecb={}, Value::Filter&& f={}, Where&& w = {})
override {
98 get(key, bindGetCb(cb), donecb, std::forward<Value::Filter>(f), std::forward<Where>(w));
100 void get(
const InfoHash& key, GetCallbackSimple cb, DoneCallbackSimple donecb, Value::Filter&& f={}, Where&& w = {})
override {
101 get(key, bindGetCb(cb), bindDoneCb(donecb), std::forward<Value::Filter>(f), std::forward<Where>(w));
107 void putSigned(
const InfoHash& hash, Sp<Value> val, DoneCallback callback,
bool permanent =
false);
108 void putSigned(
const InfoHash& hash,
Value&& v, DoneCallback callback,
bool permanent =
false) {
109 putSigned(hash, std::make_shared<Value>(std::move(v)), callback, permanent);
118 void putEncrypted(
const InfoHash& hash,
const InfoHash& to,
Value&& v, DoneCallback callback,
bool permanent =
false) {
119 putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
121 void putEncrypted(
const InfoHash& hash,
const crypto::PublicKey& to, Sp<Value> val, DoneCallback callback,
bool permanent =
false);
123 putEncrypted(hash, to, std::make_shared<Value>(std::move(v)), callback, permanent);
135 void findCertificate(
const InfoHash& node,
const std::function<
void(
const Sp<crypto::Certificate>)>& cb);
136 void findPublicKey(
const InfoHash& node,
const std::function<
void(
const Sp<crypto::PublicKey>)>& cb);
138 Sp<crypto::Certificate> registerCertificate(
const InfoHash& node,
const Blob& cert);
139 void registerCertificate(Sp<crypto::Certificate>& cert);
141 Sp<crypto::Certificate> getCertificate(
const InfoHash& node)
const;
142 Sp<crypto::PublicKey> getPublicKey(
const InfoHash& node)
const;
150 localQueryMethod_ = std::move(query_method);
152 void setOnPublicAddressChanged(PublicAddressChangedCb cb)
override {
153 dht_->setOnPublicAddressChanged(cb);
159 void shutdown(ShutdownCallback cb,
bool stop =
false)
override {
160 dht_->shutdown(cb, stop);
162 void dumpTables()
const override {
168 return dht_->getStoreSize();
170 std::string getStorageLog()
const override {
171 return dht_->getStorageLog();
173 std::string getStorageLog(
const InfoHash& h)
const override {
174 return dht_->getStorageLog(h);
177 dht_->setStorageLimit(limit);
179 size_t getStorageLimit()
const override {
180 return dht_->getStorageLimit();
184 return dht_->exportNodes();
186 std::vector<ValuesExport> exportValues()
const override {
187 return dht_->exportValues();
189 void importValues(
const std::vector<ValuesExport>& v)
override {
190 dht_->importValues(v);
192 NodeStats getNodesStats(sa_family_t af)
const override {
193 return dht_->getNodesStats(af);
195 std::vector<unsigned> getNodeMessageStats(
bool in =
false)
override {
196 return dht_->getNodeMessageStats(in);
198 std::string getRoutingTablesLog(sa_family_t af)
const override {
199 return dht_->getRoutingTablesLog(af);
201 std::string getSearchesLog(sa_family_t af)
const override {
202 return dht_->getSearchesLog(af);
204 std::string getSearchLog(
const InfoHash& h, sa_family_t af = AF_UNSPEC)
const override {
205 return dht_->getSearchLog(h, af);
207 std::vector<SockAddr> getPublicAddress(sa_family_t family = 0)
override {
208 return dht_->getPublicAddress(family);
210 time_point periodic(
const uint8_t *buf,
size_t buflen, SockAddr sa,
const time_point& now)
override {
211 return dht_->periodic(buf, buflen, std::move(sa), now);
213 time_point periodic(
const uint8_t *buf,
size_t buflen,
const sockaddr* from, socklen_t fromlen,
const time_point& now)
override {
214 return dht_->periodic(buf, buflen, from, fromlen, now);
217 return dht_->updateStatus(af);
219 NodeStatus getStatus(sa_family_t af)
const override {
220 return dht_->getStatus(af);
222 NodeStatus getStatus()
const override {
223 return dht_->getStatus();
225 net::DatagramSocket* getSocket()
const override {
226 return dht_->getSocket();
229 return dht_->isRunning(af);
231 const ValueType& getType(ValueType::Id type_id)
const override {
232 return dht_->getType(type_id);
234 void addBootstrap(
const std::string& host,
const std::string& service)
override {
235 dht_->addBootstrap(host, service);
237 void clearBootstrap()
override {
238 dht_->clearBootstrap();
241 dht_->insertNode(
id, sa);
243 void insertNode(
const NodeExport& n)
override {
246 void pingNode(SockAddr sa, DoneCallbackSimple&& cb={})
override {
247 dht_->pingNode(std::move(sa), std::move(cb));
249 void query(
const InfoHash& key, QueryCallback cb, DoneCallback done_cb = {},
Query&& q = {})
override {
250 dht_->query(key, cb, done_cb, std::move(q));
252 void query(
const InfoHash& key, QueryCallback cb, DoneCallbackSimple done_cb = {}, Query&& q = {})
override {
253 dht_->query(key, cb, done_cb, std::move(q));
256 return dht_->getLocal(key, f);
259 return dht_->getLocalById(key, vid);
263 DoneCallback cb=
nullptr,
264 time_point created=time_point::max(),
265 bool permanent =
false)
override
267 dht_->put(key, v, cb, created, permanent);
271 DoneCallbackSimple cb,
272 time_point created=time_point::max(),
273 bool permanent =
false)
override
275 dht_->put(key, v, cb, created, permanent);
278 void put(
const InfoHash& key,
280 DoneCallback cb=
nullptr,
281 time_point created=time_point::max(),
282 bool permanent =
false)
override
284 dht_->put(key, std::move(v), cb, created, permanent);
286 void put(
const InfoHash& key,
288 DoneCallbackSimple cb,
289 time_point created=time_point::max(),
290 bool permanent =
false)
override
292 dht_->put(key, std::move(v), cb, created, permanent);
295 return dht_->getPut(h);
298 return dht_->getPut(h, vid);
301 return dht_->cancelPut(h, vid);
306 size_t listen(
const InfoHash& key, GetCallbackSimple cb, Value::Filter f={}, Where w = {})
override {
307 return listen(key, bindGetCb(cb), f, w);
309 bool cancelListen(
const InfoHash& h,
size_t token)
override {
310 return dht_->cancelListen(h, token);
313 dht_->connectivityChanged(af);
315 void connectivityChanged()
override {
316 dht_->connectivityChanged();
319 void forwardAllMessages(
bool forward) {
320 forward_all_ = forward;
323 void setPushNotificationToken(
const std::string& token =
"")
override {
324 dht_->setPushNotificationToken(token);
332 dht_->pushNotificationReceived(notification);
335 void setLogger(
const Logger& logger)
override {
336 DhtInterface::setLogger(logger);
337 dht_->setLogger(logger);
340 void setLogger(
const std::shared_ptr<Logger>& logger)
override {
341 DhtInterface::setLogger(logger);
342 dht_->setLogger(logger);
349 DhtInterface::setLogFilter(f);
350 dht_->setLogFilter(f);
354 std::unique_ptr<DhtInterface> dht_;
359 Sp<Value> checkValue(
const Sp<Value>& v);
360 ValueCallback getCallbackFilter(
const ValueCallback&,
Value::Filter&&);
361 GetCallback getCallbackFilter(
const GetCallback&,
Value::Filter&&);
363 Sp<crypto::PrivateKey> key_ {};
364 Sp<crypto::Certificate> certificate_ {};
367 CertificateStoreQuery localQueryMethod_ {};
370 std::map<InfoHash, Sp<crypto::Certificate>> nodesCertificates_ {};
371 std::map<InfoHash, Sp<crypto::PublicKey>> nodesPubKeys_ {};
373 std::atomic_bool forward_all_ {
false};
374 bool enableCache_ {
false};