value: use move in where

Because there is multiple unifiedpush endpoint (ntfy.sh is one),
we should not pass it as an option to dhtnode, but use the one
provided by the user in the token (from unified push library).

.github/workflows/ccpp.yml

@@ -59,9 +59,9 @@ jobs:
     - name: restinio
       run: |
         mkdir restinio && cd restinio
-        wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz
-        ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz
-        cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/dev
+        wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz
+        ls -l && tar -xzf bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz
+        cd restinio-bbaa034dbcc7555ce67df0f8a1475591a7441733/dev
         cmake -DCMAKE_INSTALL_PREFIX=/usr/local -DRESTINIO_TEST=OFF -DRESTINIO_SAMPLE=OFF \
                 -DRESTINIO_INSTALL_SAMPLES=OFF -DRESTINIO_BENCH=OFF -DRESTINIO_INSTALL_BENCHES=OFF \
                 -DRESTINIO_FIND_DEPS=ON -DRESTINIO_ALLOW_SOBJECTIZER=Off -DRESTINIO_USE_BOOST_ASIO=none .

.github/workflows/clang-analyzer.yml

@@ -18,9 +18,9 @@ jobs:
       - name: restinio
         run: |
           mkdir restinio && cd restinio \
-          && wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
-          && ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
-          && cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/dev \
+          && wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+          && ls -l && tar -xzf bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+          && cd restinio-bbaa034dbcc7555ce67df0f8a1475591a7441733/dev \
           && cmake -DCMAKE_INSTALL_PREFIX=/usr -DRESTINIO_TEST=OFF -DRESTINIO_SAMPLE=OFF \
                   -DRESTINIO_INSTALL_SAMPLES=OFF -DRESTINIO_BENCH=OFF -DRESTINIO_INSTALL_BENCHES=OFF \
                   -DRESTINIO_FIND_DEPS=ON -DRESTINIO_ALLOW_SOBJECTIZER=Off -DRESTINIO_USE_BOOST_ASIO=none . \

CMakeLists.txt

@@ -14,7 +14,7 @@ include(FindPkgConfig)
 include(cmake/CheckAtomic.cmake)
 
 set (opendht_VERSION_MAJOR 2)
-set (opendht_VERSION_MINOR 4.9)
+set (opendht_VERSION_MINOR 4.10)
 set (opendht_VERSION ${opendht_VERSION_MAJOR}.${opendht_VERSION_MINOR})
 set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")
@@ -223,13 +223,6 @@ list (APPEND opendht_SOURCES
     src/thread_pool.cpp
 )
 
-if (APPLE)
-    list (APPEND opendht_SOURCES
-        src/compat/apple/apple_utils.h
-        src/compat/apple/apple_utils.mm
-    )
-endif()
-
 list (APPEND opendht_HEADERS
     include/opendht/def.h
     include/opendht/utils.h
@@ -420,6 +413,7 @@ if (OPENDHT_C)
             c/opendht.cpp
             c/opendht_c.h
         )
+        set_target_properties (opendht-c-static PROPERTIES OUTPUT_NAME "opendht-c")
         target_link_libraries(opendht-c-static PRIVATE opendht-static)
         install (TARGETS opendht-c-static DESTINATION ${CMAKE_INSTALL_LIBDIR} EXPORT opendht-c-static)
     endif ()

c/opendht.cpp

@@ -343,6 +343,7 @@ int dht_runner_run_config(dht_runner* r, in_port_t port, const dht_runner_config
         config.push_node_id = conf->push_node_id ? std::string(conf->push_node_id) : std::string{};
         config.push_token = conf->push_token ? std::string(conf->push_token) : std::string{};
         config.push_topic = conf->push_topic ? std::string(conf->push_topic) : std::string{};
+        config.push_platform = conf->push_platform ? std::string(conf->push_platform) : std::string{};
         config.peer_discovery = conf->peer_discovery;
         config.peer_publish = conf->peer_publish;
 

c/opendht_c.h

@@ -147,6 +147,7 @@ struct OPENDHT_PUBLIC dht_runner_config {
     const char* push_node_id;
     const char* push_token;
     const char* push_topic;
+    const char* push_platform;
     bool peer_discovery;
     bool peer_publish;
     dht_certificate* server_ca;

configure.ac

@@ -1,7 +1,7 @@
 dnl define macros
 m4_define([opendht_major_version], 2)
 m4_define([opendht_minor_version], 4)
-m4_define([opendht_patch_version], 9)
+m4_define([opendht_patch_version], 10)
 m4_define([opendht_version],
 		  [opendht_major_version.opendht_minor_version.opendht_patch_version])
 
@@ -32,7 +32,6 @@ LT_INIT()
 LT_LANG(C++)
 AC_LANG(C++)
 AC_PROG_CXX
-AC_PROG_OBJCXX
 AX_CXX_COMPILE_STDCXX(17,[noext],[mandatory])
 
 dnl Check for logs
@@ -92,7 +91,6 @@ case "${host_os}" in
     SYS=linux
     ;;
   darwin*)
-    APPLE=1
     SYS=darwin
     ;;
   mingw32*)
@@ -112,7 +110,6 @@ case "${host_os}" in
     ;;
 esac
 
-AM_CONDITIONAL(APPLE, [test "x$SYS" = "xdarwin"])
 AM_CONDITIONAL(WIN32, [test "x$SYS" = "xmingw32"])
 AS_IF([test "x$SYS" = "xandroid"],
       [], [LDFLAGS="${LDFLAGS} -lpthread"])
@@ -191,7 +188,6 @@ AM_COND_IF([PROXY_CLIENT_OR_SERVER], [
 ])
 
 CXXFLAGS="${CXXFLAGS} -DMSGPACK_NO_BOOST -DMSGPACK_DISABLE_LEGACY_NIL -DMSGPACK_DISABLE_LEGACY_CONVERT"
-OBJCXX="$CXX $CXXFLAGS"
 
 AC_ARG_ENABLE([tools], AS_HELP_STRING([--disable-tools],[Disable tools (CLI DHT node)]),,build_tools=yes)
 AM_CONDITIONAL(ENABLE_TOOLS, test x$build_tools == xyes)

docker/DockerfileDeps

@@ -18,9 +18,9 @@ RUN apt-get update && apt-get install -y \
 
 RUN echo "*** Downloading RESTinio ***" \
     && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
-    && ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
-    && cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/dev \
+    && wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+    && ls -l && tar -xzf bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+    && cd restinio-bbaa034dbcc7555ce67df0f8a1475591a7441733/dev \
     && cmake -DCMAKE_INSTALL_PREFIX=/usr -DRESTINIO_TEST=OFF -DRESTINIO_SAMPLE=OFF \
              -DRESTINIO_INSTALL_SAMPLES=OFF -DRESTINIO_BENCH=OFF -DRESTINIO_INSTALL_BENCHES=OFF \
              -DRESTINIO_FIND_DEPS=ON -DRESTINIO_ALLOW_SOBJECTIZER=Off -DRESTINIO_USE_BOOST_ASIO=none . \

docker/DockerfileDepsLlvm

@@ -22,9 +22,9 @@ ENV CXX c++
 
 RUN echo "*** Downloading RESTinio ***" \
     && mkdir restinio && cd restinio \
-    && wget https://github.com/aberaud/restinio/archive/e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
-    && ls -l && tar -xzf e0a261dd8488246a3cb8bbb3ea781ea5139c3c94.tar.gz \
-    && cd restinio-e0a261dd8488246a3cb8bbb3ea781ea5139c3c94/dev \
+    && wget https://github.com/aberaud/restinio/archive/bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+    && ls -l && tar -xzf bbaa034dbcc7555ce67df0f8a1475591a7441733.tar.gz \
+    && cd restinio-bbaa034dbcc7555ce67df0f8a1475591a7441733/dev \
     && cmake -DCMAKE_INSTALL_PREFIX=/usr -DRESTINIO_TEST=OFF -DRESTINIO_SAMPLE=OFF \
              -DRESTINIO_INSTALL_SAMPLES=OFF -DRESTINIO_BENCH=OFF -DRESTINIO_INSTALL_BENCHES=OFF \
              -DRESTINIO_FIND_DEPS=ON -DRESTINIO_ALLOW_SOBJECTIZER=Off -DRESTINIO_USE_BOOST_ASIO=none . \

include/opendht/crypto.h

@@ -34,6 +34,7 @@ extern "C" {
 #include <memory>
 #include <atomic>
 #include <mutex>
+#include <string_view>
 
 #ifdef _WIN32
 #include <iso646.h>
@@ -86,7 +87,8 @@ struct OPENDHT_PUBLIC PublicKey
     /** Import public key from serialized data */
     PublicKey(const uint8_t* dat, size_t dat_size);
     PublicKey(const Blob& pk) : PublicKey(pk.data(), pk.size()) {}
-    PublicKey(PublicKey&& o) noexcept : pk(o.pk) { o.pk = nullptr; };
+    PublicKey(std::string_view pk) : PublicKey((const uint8_t*)pk.data(), pk.size()) {}
+    PublicKey(PublicKey&& o) noexcept : pk(o.pk) { o.pk = nullptr; }
 
     ~PublicKey();
     explicit operator bool() const { return pk; }
@@ -118,7 +120,9 @@ struct OPENDHT_PUBLIC PublicKey
     inline Blob encrypt(const Blob& data) const {
         return encrypt(data.data(), data.size());
     }
-
+    inline Blob encrypt(std::string_view data) const {
+        return encrypt((const uint8_t*)data.data(), data.size());
+    }
     void pack(Blob& b) const;
     int pack(uint8_t* out, size_t* out_len) const;
     void unpack(const uint8_t* dat, size_t dat_size);
@@ -167,7 +171,9 @@ struct OPENDHT_PUBLIC PrivateKey
     PrivateKey& operator=(PrivateKey&& o) noexcept;
 
     PrivateKey(const uint8_t* src, size_t src_size, const char* password = nullptr);
-    PrivateKey(const Blob& src, const std::string& password = {}) : PrivateKey(src.data(), src.size(), password.data()) {}
+    PrivateKey(const Blob& src, const std::string& password = {}) : PrivateKey(src.data(), src.size(), password.c_str()) {}
+    PrivateKey(std::string_view src, const std::string& password = {}) : PrivateKey((const uint8_t*)src.data(), src.size(), password.c_str()) {}
+
     ~PrivateKey();
     explicit operator bool() const { return key; }
 
@@ -182,6 +188,7 @@ struct OPENDHT_PUBLIC PrivateKey
      * @returns the signature data.
      */
     Blob sign(const uint8_t* data, size_t data_len) const;
+    inline Blob sign(std::string_view dat) const { return sign((const uint8_t*)dat.data(), dat.size()); }
     inline Blob sign(const Blob& dat) const { return sign(dat.data(), dat.size()); }
 
     /**
@@ -294,6 +301,7 @@ class OPENDHT_PUBLIC CertificateRequest {
 public:
     CertificateRequest();
     CertificateRequest(const uint8_t* data, size_t size);
+    CertificateRequest(std::string_view src) : CertificateRequest((const uint8_t*)src.data(), src.size()) {}
     CertificateRequest(const Blob& data) : CertificateRequest(data.data(), data.size()) {}
 
     CertificateRequest(CertificateRequest&& o) noexcept : request(std::move(o.request)) {
@@ -327,8 +335,9 @@ private:
 class OPENDHT_PUBLIC OcspRequest
 {
 public:
-    OcspRequest(gnutls_ocsp_req_t r) : request(r) {};
+    OcspRequest(gnutls_ocsp_req_t r) : request(r) {}
     OcspRequest(const uint8_t* dat_ptr, size_t dat_size);
+    OcspRequest(std::string_view dat): OcspRequest((const uint8_t*)dat.data(), dat.size()) {}
     ~OcspRequest();
 
     /*
@@ -346,7 +355,7 @@ class OPENDHT_PUBLIC OcspResponse
 {
 public:
     OcspResponse(const uint8_t* dat_ptr, size_t dat_size);
-    OcspResponse(const std::string& response) : OcspResponse((const uint8_t*)response.data(), response.size()) {};
+    OcspResponse(std::string_view response) : OcspResponse((const uint8_t*)response.data(), response.size()) {}
     ~OcspResponse();
 
     Blob pack() const;
@@ -388,12 +397,10 @@ struct OPENDHT_PUBLIC Certificate {
      * ordered from subject to issuer
      */
     Certificate(const Blob& crt);
-    Certificate(const std::string& pem) : cert(nullptr) {
-        unpack((const uint8_t*)pem.data(), pem.size());
-    }
     Certificate(const uint8_t* dat, size_t dat_size) : cert(nullptr) {
         unpack(dat, dat_size);
     }
+    Certificate(std::string_view pem) : Certificate((const uint8_t*)pem.data(), pem.size()) {}
 
     /**
      * Import certificate chain (PEM or DER),

include/opendht/dht_interface.h

@@ -266,6 +266,7 @@ public:
     virtual void setPushNotificationToken(const std::string&) {};
 
     virtual void setPushNotificationTopic(const std::string&) {};
+    virtual void setPushNotificationPlatform(const std::string&) {};
 
     /**
      * Call linked callback with a push notification

include/opendht/dht_proxy_client.h

@@ -75,6 +75,14 @@ public:
 #endif
     }
 
+    virtual void setPushNotificationPlatform(const std::string& platform) override {
+#ifdef OPENDHT_PUSH_NOTIFICATIONS
+        platform_ = platform;
+#else
+        (void) platform;
+#endif
+    }
+
     virtual ~DhtProxyClient();
 
     /**
@@ -344,6 +352,8 @@ private:
     NodeStatus statusIpv6_ {NodeStatus::Disconnected};
     NodeStats stats4_ {};
     NodeStats stats6_ {};
+    SockAddr localAddrv4_;
+    SockAddr localAddrv6_;
     SockAddr publicAddressV4_;
     SockAddr publicAddressV6_;
     std::atomic_bool launchConnectedCbs_ {false};
@@ -413,6 +423,20 @@ private:
      */
     std::string notificationTopic_ {};
 
+    /**
+     * Platform for push notifications (supported android, ios, unifiedpush)
+     */
+    std::string platform_
+#ifdef __ANDROID__
+    {"android"};
+#else
+#ifdef __APPLE__
+    {"ios"};
+#else
+    {};
+#endif
+#endif
+
     const std::function<void()> loopSignal_;
 
 #ifdef OPENDHT_PUSH_NOTIFICATIONS

include/opendht/dht_proxy_server.h

@@ -41,7 +41,7 @@ enum class PushType {
     None = 0,
     Android,
     iOS,
-    iOSLegacy
+    UnifiedPush
 };
 }
 MSGPACK_ADD_ENUM(dht::PushType)
@@ -393,7 +393,7 @@ private:
         template <typename Packer>
         void msgpack_pack(Packer& p) const
         {
-            p.pack_map(2 + (sessionCtx ? 1 : 0) + (clientId.empty() ? 0 : 1) + (type == PushType::None ? 0 : 2));
+            p.pack_map(2 + (sessionCtx ? 1 : 0) + (clientId.empty() ? 0 : 1) + (type == PushType::None ? 0 : 2) + (topic.empty() ? 0 : 1));
             p.pack("value"); p.pack(value);
             p.pack("exp"); p.pack(to_time_t(expiration));
             if (not clientId.empty()) {
@@ -407,6 +407,9 @@ private:
                 p.pack("t"); p.pack(type);
                 p.pack("token"); p.pack(pushToken);
             }
+            if (not topic.empty()) {
+                p.pack("top"); p.pack(topic);
+            }
         }
 
         void msgpack_unpack(const msgpack::object& o);
@@ -438,7 +441,7 @@ private:
         template <typename Packer>
         void msgpack_pack(Packer& p) const
         {
-            p.pack_map(sessionCtx ? 4 : 3);
+            p.pack_map(3 + (sessionCtx ? 1 : 0) + (topic.empty() ? 0 : 1));
             p.pack("cid"); p.pack(clientId);
             p.pack("exp"); p.pack(to_time_t(expiration));
             if (sessionCtx) {
@@ -446,6 +449,9 @@ private:
                 p.pack("sid"); p.pack(sessionCtx->sessionId);
             }
             p.pack("t"); p.pack(type);
+            if (!topic.empty()) {
+                p.pack("top"); p.pack(topic);
+            }
         }
 
         void msgpack_unpack(const msgpack::object& o);

include/opendht/dhtrunner.h

@@ -62,6 +62,7 @@ public:
         std::string push_node_id {};
         std::string push_token {};
         std::string push_topic {};
+        std::string push_platform {};
         bool peer_discovery {false};
         bool peer_publish {false};
         std::shared_ptr<dht::crypto::Certificate> server_ca;
@@ -453,6 +454,11 @@ public:
      */
     void setPushNotificationTopic(const std::string& topic);
 
+     /**
+     * Sets the push notification platform
+     */
+    void setPushNotificationPlatform(const std::string& platform);
+
     /**
      * Insert a push notification to process for OpenDHT
      */

include/opendht/http.h

@@ -114,13 +114,16 @@ public:
     void async_read(size_t bytes, BytesHandlerCb cb);
     void async_read_some(size_t bytes, BytesHandlerCb cb);
 
-    void timeout(const std::chrono::seconds timeout, HandlerCb cb = {});
+    const asio::ip::address& local_address() const;
+
+    void timeout(const std::chrono::seconds& timeout, HandlerCb cb = {});
+
     void close();
 
 private:
 
     template<typename T>
-    T wrapCallabck(T cb) const {
+    T wrapCallback(T cb) const {
         return [t=shared_from_this(),cb=std::move(cb)](auto ...params) {
             cb(params...);
         };
@@ -142,6 +145,8 @@ private:
     asio::streambuf read_buf_;
     std::istream istream_;
 
+    asio::ip::address local_address_;
+
     std::unique_ptr<asio::steady_timer> timeout_timer_;
     std::shared_ptr<dht::Logger> logger_;
     bool checkOcsp_ {false};
@@ -261,6 +266,11 @@ public:
         return resolver_->get_url();
     };
 
+    void timeout(const std::chrono::seconds& timeout, HandlerCb cb = {}) {
+        timeout_ = timeout;
+        timeoutCb_ = cb;
+    }
+
     /** The previous request in case of redirect following */
     std::shared_ptr<Request> getPrevious() const {
         return prev_.lock();
@@ -370,6 +380,9 @@ private:
     std::weak_ptr<Request> prev_;
     unsigned num_redirect {0};
     bool follow_redirect {true};
+
+    HandlerCb timeoutCb_ {};
+    std::chrono::seconds timeout_ {0};
 };
 
 } // namespace http

include/opendht/infohash.h

@@ -249,6 +249,8 @@ public:
     template <size_t M>
     OPENDHT_PUBLIC friend std::istream& operator>> (std::istream& s, Hash<M>& h);
 
+    /** Returns view to thread-allocated memory, only valid until the next call to this function. */
+    std::string_view to_view() const { return std::string_view(to_c_str(), N*2); }
     const char* to_c_str() const;
 
     std::string toString() const;

include/opendht/value.h

@@ -171,29 +171,29 @@ struct OPENDHT_PUBLIC Value
         template<typename Functor>
         Filter(Functor f) : std::function<bool(const Value&)>::function(f) {}
 
-        Filter chain(Filter&& f2) {
+        inline Filter chain(Filter&& f2) {
             auto f1 = *this;
             return chain(std::move(f1), std::move(f2));
         }
-        Filter chainOr(Filter&& f2) {
+        inline Filter chainOr(Filter&& f2) {
             auto f1 = *this;
             return chainOr(std::move(f1), std::move(f2));
         }
-        static Filter chain(Filter&& f1, Filter&& f2) {
+        static inline Filter chain(Filter&& f1, Filter&& f2) {
             if (not f1) return std::move(f2);
             if (not f2) return std::move(f1);
             return [f1 = std::move(f1), f2 = std::move(f2)](const Value& v) {
                 return f1(v) and f2(v);
             };
         }
-        static Filter chain(const Filter& f1, const Filter& f2) {
+        static inline Filter chain(const Filter& f1, const Filter& f2) {
             if (not f1) return f2;
             if (not f2) return f1;
             return [f1,f2](const Value& v) {
                 return f1(v) and f2(v);
             };
         }
-        static Filter chainAll(std::vector<Filter>&& set) {
+        static inline Filter chainAll(std::vector<Filter>&& set) {
             if (set.empty()) return {};
             return [set = std::move(set)](const Value& v) {
                 for (const auto& f : set)
@@ -202,16 +202,16 @@ struct OPENDHT_PUBLIC Value
                 return true;
             };
         }
-        static Filter chain(std::initializer_list<Filter> l) {
+        static inline Filter chain(std::initializer_list<Filter> l) {
             return chainAll(std::vector<Filter>(l.begin(), l.end()));
         }
-        static Filter chainOr(Filter&& f1, Filter&& f2) {
+        static inline Filter chainOr(Filter&& f1, Filter&& f2) {
             if (not f1 or not f2) return {};
             return [f1=std::move(f1),f2=std::move(f2)](const Value& v) {
                 return f1(v) or f2(v);
             };
         }
-        static Filter notFilter(Filter&& f) {
+        static inline Filter notFilter(Filter&& f) {
             if (not f) return [](const Value&) { return false; };
             return [f = std::move(f)](const Value& v) { return not f(v); };
         }
@@ -228,50 +228,50 @@ struct OPENDHT_PUBLIC Value
 
     /* Sneaky functions disguised in classes */
 
-    static const Filter AllFilter() {
+    static inline Filter AllFilter() {
         return {};
     }
 
-    static Filter TypeFilter(const ValueType& t) {
+    static inline Filter TypeFilter(const ValueType& t) {
         return [tid = t.id](const Value& v) {
             return v.type == tid;
         };
     }
-    static Filter TypeFilter(const ValueType::Id& tid) {
+    static inline Filter TypeFilter(const ValueType::Id& tid) {
         return [tid](const Value& v) {
             return v.type == tid;
         };
     }
 
-    static Filter IdFilter(const Id id) {
+    static inline Filter IdFilter(const Id id) {
         return [id](const Value& v) {
             return v.id == id;
         };
     }
 
-    static Filter RecipientFilter(const InfoHash& r) {
+    static inline Filter RecipientFilter(const InfoHash& r) {
         return [r](const Value& v) {
             return v.recipient == r;
         };
     }
 
-    static Filter OwnerFilter(const crypto::PublicKey& pk) {
+    static inline Filter OwnerFilter(const crypto::PublicKey& pk) {
         return OwnerFilter(pk.getId());
     }
 
-    static Filter OwnerFilter(const InfoHash& pkh) {
+    static inline Filter OwnerFilter(const InfoHash& pkh) {
         return [pkh](const Value& v) {
             return v.owner and v.owner->getId() == pkh;
         };
     }
 
-    static Filter SeqNumFilter(uint16_t seq_no) {
+    static inline Filter SeqNumFilter(uint16_t seq_no) {
         return [seq_no](const Value& v) {
             return v.seq == seq_no;
         };
     }
 
-    static Filter UserTypeFilter(std::string ut) {
+    static inline Filter UserTypeFilter(std::string ut) {
         return [ut = std::move(ut)](const Value& v) {
             return v.user_type == ut;
         };
@@ -804,11 +804,11 @@ struct OPENDHT_PUBLIC Where
      *
      * @return the resulting Where instance.
      */
-    Where& id(Value::Id id) {
+    Where&& id(Value::Id id) {
         FieldValue fv {Value::Field::Id, id};
         if (std::find(filters_.begin(), filters_.end(), fv) == filters_.end())
             filters_.emplace_back(std::move(fv));
-        return *this;
+        return std::move(*this);
     }
 
     /**
@@ -818,11 +818,11 @@ struct OPENDHT_PUBLIC Where
      *
      * @return the resulting Where instance.
      */
-    Where& valueType(ValueType::Id type) {
+    Where&& valueType(ValueType::Id type) {
         FieldValue fv {Value::Field::ValueType, type};
         if (std::find(filters_.begin(), filters_.end(), fv) == filters_.end())
             filters_.emplace_back(std::move(fv));
-        return *this;
+        return std::move(*this);
     }
 
     /**
@@ -832,11 +832,11 @@ struct OPENDHT_PUBLIC Where
      *
      * @return the resulting Where instance.
      */
-    Where& owner(InfoHash owner_pk_hash) {
+    Where&& owner(InfoHash owner_pk_hash) {
         FieldValue fv {Value::Field::OwnerPk, owner_pk_hash};
         if (std::find(filters_.begin(), filters_.end(), fv) == filters_.end())
             filters_.emplace_back(std::move(fv));
-        return *this;
+        return std::move(*this);
     }
 
     /**
@@ -846,11 +846,11 @@ struct OPENDHT_PUBLIC Where
      *
      * @return the resulting Where instance.
      */
-    Where& seq(uint16_t seq_no) {
+    Where&& seq(uint16_t seq_no) {
         FieldValue fv {Value::Field::SeqNum, seq_no};
         if (std::find(filters_.begin(), filters_.end(), fv) == filters_.end())
             filters_.emplace_back(std::move(fv));
-        return *this;
+        return std::move(*this);
     }
 
     /**
@@ -860,11 +860,11 @@ struct OPENDHT_PUBLIC Where
      *
      * @return the resulting Where instance.
      */
-    Where& userType(std::string_view user_type) {
+    Where&& userType(std::string_view user_type) {
         FieldValue fv {Value::Field::UserType, Blob {user_type.begin(), user_type.end()}};
         if (std::find(filters_.begin(), filters_.end(), fv) == filters_.end())
             filters_.emplace_back(std::move(fv));
-        return *this;
+        return std::move(*this);
     }
 
     /**
@@ -873,7 +873,10 @@ struct OPENDHT_PUBLIC Where
      * @return the resulting Value::Filter.
      */
     Value::Filter getFilter() const {
-        if (filters_.empty()) return {};
+        if (filters_.empty())
+            return {};
+        if (filters_.size() == 1)
+            return filters_[0].getLocalFilter();
         std::vector<Value::Filter> fset;
         fset.reserve(filters_.size());
         for (const auto& f : filters_) {

rust/Cargo.toml

@@ -8,4 +8,4 @@ edition = "2018"
 
 [dependencies]
 libc="0.2.0"
-os_socketaddr="0.1.0"
+os_socketaddr="0.2.3"

rust/src/dhtrunner.rs

@@ -48,6 +48,7 @@ impl DhtRunnerConfig {
             push_node_id: ptr::null(),
             push_token: ptr::null(),
             push_topic: ptr::null(),
+            push_platform: ptr::null(),
             peer_discovery: false,
             peer_publish: false,
             server_ca: ptr::null_mut(),
@@ -78,6 +79,10 @@ impl DhtRunnerConfig {
         self.push_topic = CString::new(push_topic).unwrap().as_ptr();
     }
 
+    pub fn set_push_platform(&mut self, push_platform: &str) {
+        self.push_platform = CString::new(push_platform).unwrap().as_ptr();
+    }
+
     pub fn set_identity(&mut self, certificate: Box<DhtCertificate>, privatekey: Box<PrivateKey>) {
         self.dht_config.id.privatekey = Box::into_raw(privatekey);
         self.dht_config.id.certificate = Box::into_raw(certificate);

rust/src/ffi.rs

@@ -119,6 +119,7 @@ pub struct DhtRunnerConfig
     pub push_node_id: *const c_char,
     pub push_token: *const c_char,
     pub push_topic: *const c_char,
+    pub push_platform: *const c_char,
     pub peer_discovery: bool,
     pub peer_publish: bool,
     pub server_ca: *mut DhtCertificate,

src/Makefile.am

@@ -30,12 +30,6 @@ libopendht_la_SOURCES  = \
         network_utils.cpp \
         thread_pool.cpp
 
-if APPLE
-libopendht_la_SOURCES += \
-        compat/apple/apple_utils.h \
-        compat/apple/apple_utils.mm
-endif
-
 if WIN32
 libopendht_la_SOURCES += rng.cpp
 endif

src/compat/apple/apple_utils.h

@@ -1,26 +0,0 @@
-/*
- *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include <string>
-
-namespace dht {
-namespace apple_utils {
-
-std::string getPlatformVersion();
-
-}
-}

src/compat/apple/apple_utils.mm

@@ -1,44 +0,0 @@
-/*
- *  Copyright (C) 2014-2022 Savoir-faire Linux Inc.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 3 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program. If not, see <https://www.gnu.org/licenses/>.
- */
-
-#include "apple_utils.h"
-
-#ifdef __APPLE__
-#include <Foundation/Foundation.h>
-#include "TargetConditionals.h"
-#endif
-
-namespace dht {
-namespace apple_utils {
-
-std::string
-getPlatformVersion() {
-#ifdef __APPLE__
-    #if TARGET_OS_IPHONE
-    if (@available(iOS 14.5, *)) {
-        return  "ios";
-    }
-    return "apple";
-    #elif TARGET_OS_MAC
-    return "macos";
-    #endif
-#endif
-    return "";
-}
-
-}
-} /* dht */

src/dht_proxy_client.cpp

@@ -22,9 +22,6 @@
 #include "dhtrunner.h"
 #include "op_cache.h"
 #include "utils.h"
-#ifdef __APPLE__
-#include "compat/apple/apple_utils.h"
-#endif
 
 #include <http_parser.h>
 #include <deque>
@@ -120,6 +117,9 @@ DhtProxyClient::DhtProxyClient(
     , loopSignal_(signal)
     , jsonReader_(Json::CharReaderBuilder{}.newCharReader())
 {
+    localAddrv4_.setFamily(AF_INET);
+    localAddrv6_.setFamily(AF_INET6);
+
     jsonBuilder_["commentStyle"] = "None";
     jsonBuilder_["indentation"] = "";
     if (logger_) {
@@ -322,19 +322,23 @@ DhtProxyClient::get(const InfoHash& key, GetCallback cb, DoneCallback donecb, Va
         setHeaderFields(*request);
 
         auto opstate = std::make_shared<OperationState>();
-        Value::Filter filter = w.empty() ? f : f.chain(w.getFilter());
 
-        auto rxBuf = std::make_shared<LineSplit>();
-        request->add_on_body_callback([this, key, opstate, filter, rxBuf, cb](const char* at, size_t length){
+        request->add_on_body_callback([
+            this,
+            key,
+            opstate,
+            filter = Value::Filter::chain(std::move(f), w.getFilter()),
+            rxBuf = std::make_shared<LineSplit>(),
+            cb
+        ](const char* at, size_t length){
             try {
-                auto& b = *rxBuf;
-                b.append(at, length);
+                rxBuf->append(at, length);
                 // one value per body line
                 std::vector<Sp<Value>> values;
-                while (b.getLine('\n') and !opstate->stop) {
+                while (rxBuf->getLine('\n') and !opstate->stop) {
                     std::string err;
                     Json::Value json;
-                    const auto& line = b.line();
+                    const auto& line = rxBuf->line();
                     if (!jsonReader_->parse(line.data(), line.data() + line.size(), &json, &err)){
                         opstate->ok.store(false);
                         return;
@@ -661,6 +665,12 @@ DhtProxyClient::queryProxyInfo(const Sp<InfoState>& infoState, const Sp<http::Re
                 if (!jsonReader_->parse(response.body.data(), response.body.data() + response.body.size(), &proxyInfos, &err)){
                     onProxyInfos(Json::Value{}, family);
                 } else if (not infoState->cancel) {
+                    if (auto req = response.request.lock()) {
+                        if (auto conn = req->get_connection()) {
+                            const auto& localAddr = conn->local_address();
+                            proxyInfos["local_ip"] = localAddr.to_string();
+                        }
+                    }
                     onProxyInfos(proxyInfos, family);
                 }
             }
@@ -692,10 +702,17 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
     std::unique_lock<std::mutex> l(lockCurrentProxyInfos_);
     auto oldStatus = std::max(statusIpv4_, statusIpv6_);
     auto& status = family == AF_INET ? statusIpv4_ : statusIpv6_;
+    auto ipChanged = false;
+    auto& pubAddress = family == AF_INET? publicAddressV4_ : publicAddressV6_;
+    auto& localAddress = family == AF_INET? localAddrv4_ : localAddrv6_;
     if (not proxyInfos.isMember("node_id")) {
         if (logger_)
             logger_->e("[proxy:client] [info] request failed for %s", family == AF_INET ? "ipv4" : "ipv6");
         status = NodeStatus::Disconnected;
+        if (pubAddress) {
+            pubAddress = {};
+            ipChanged = true;
+        }
     } else {
         if (logger_)
             logger_->d("[proxy:client] [info] got proxy reply for %s",
@@ -704,19 +721,25 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
             myid = InfoHash(proxyInfos["node_id"].asString());
             stats4_ = NodeStats(proxyInfos["ipv4"]);
             stats6_ = NodeStats(proxyInfos["ipv6"]);
-            if (stats4_.good_nodes + stats6_.good_nodes)
+            auto publicIp = parsePublicAddress(proxyInfos["public_ip"]);
+            ipChanged = pubAddress && pubAddress.toString() != publicIp.toString();
+            pubAddress = publicIp;
+
+            if (proxyInfos.isMember("local_ip")) {
+                std::string localIp = proxyInfos["local_ip"].asString();
+                if (localAddress.toString() != localIp) {
+                    localAddress.setAddress(localIp.c_str());
+                    ipChanged = (bool)localAddress;
+                }
+            }
+
+            if (!ipChanged && stats4_.good_nodes + stats6_.good_nodes)
                 status = NodeStatus::Connected;
-            else if (stats4_.dubious_nodes + stats6_.dubious_nodes)
+            else if (!ipChanged && stats4_.dubious_nodes + stats6_.dubious_nodes)
                 status = NodeStatus::Connecting;
             else
                 status = NodeStatus::Disconnected;
 
-            auto publicIp = parsePublicAddress(proxyInfos["public_ip"]);
-            auto publicFamily = publicIp.getFamily();
-            if (publicFamily == AF_INET)
-                publicAddressV4_ = publicIp;
-            else if (publicFamily == AF_INET6)
-                publicAddressV6_ = publicIp;
         } catch (const std::exception& e) {
             if (logger_)
                 logger_->e("[proxy:client] [info] error processing: %s", e.what());
@@ -742,7 +765,10 @@ DhtProxyClient::onProxyInfos(const Json::Value& proxyInfos, const sa_family_t fa
         nextProxyConfirmationTimer_->async_wait(std::bind(&DhtProxyClient::handleProxyConfirm, this, std::placeholders::_1));
     }
     else if (newStatus == NodeStatus::Disconnected) {
-        nextProxyConfirmationTimer_->expires_at(std::chrono::steady_clock::now() + std::chrono::minutes(1));
+        auto next = std::chrono::steady_clock::now();
+        if (!ipChanged)
+            next += std::chrono::minutes(1);
+        nextProxyConfirmationTimer_->expires_at(next);
         nextProxyConfirmationTimer_->async_wait(std::bind(&DhtProxyClient::handleProxyConfirm, this, std::placeholders::_1));
     }
     l.unlock();
@@ -1303,13 +1329,8 @@ DhtProxyClient::getPushRequest(Json::Value& body) const
     body["key"] = deviceKey_;
     body["client_id"] = pushClientId_;
     body["session_id"] = pushSessionId_;
-#ifdef __ANDROID__
-    body["platform"] = "android";
-#endif
-#ifdef __APPLE__
     body["topic"] = notificationTopic_;
-    body["platform"] = apple_utils::getPlatformVersion();
-#endif
+    body["platform"] = platform_;
 }
 
 std::string

src/dht_proxy_server.cpp

@@ -173,6 +173,9 @@ DhtProxyServer::PermanentPut::msgpack_unpack(const msgpack::object& o)
     if (auto val = findMapValue(o, "value"sv)) {
         value = std::make_shared<dht::Value>(*val);
     }
+    if (auto top = findMapValue(o, "top"sv)) {
+        topic = top->as<std::string>();
+    }
 }
 
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
@@ -194,6 +197,9 @@ DhtProxyServer::Listener::msgpack_unpack(const msgpack::object& o)
     if (auto t = findMapValue(o, "t"sv)) {
         type = t->as<PushType>();
     }
+    if (auto top = findMapValue(o, "top"sv)) {
+        topic = top->as<std::string>();
+    }
 }
 #endif
 
@@ -409,7 +415,7 @@ DhtProxyServer::loadState(Is& is, size_t size) {
                                         json["s"] = sessionCtx->sessionId;
                                     }
                                     if (expired and values.size() < 2){
-                                        std::stringstream ss;
+                                        std::ostringstream ss;
                                         for(size_t i = 0; i < values.size(); ++i){
                                             if(i != 0) ss << ",";
                                             ss << values[i]->id;
@@ -756,20 +762,14 @@ DhtProxyServer::getTypeFromString(const std::string& type) {
         return PushType::Android;
     else if (type == "ios")
         return PushType::iOS;
-    else if (type == "apple")
-        return PushType::iOSLegacy; // proxy_client is not updated or using ios < 14.5
+    else if (type == "unifiedpush")
+        return PushType::UnifiedPush;
     return PushType::None;
 }
 
 std::string
-DhtProxyServer::getDefaultTopic(PushType type) {
-    if (bundleId_.empty())
-        return {};
-    if (type == PushType::iOS)
-        return bundleId_;
-    else if (type == PushType::iOSLegacy)
-        return bundleId_  + ".voip";
-    return {};
+DhtProxyServer::getDefaultTopic(PushType) {
+    return bundleId_;
 }
 
 RequestStatus
@@ -894,8 +894,8 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
                         json["s"] = sessionCtx->sessionId;
                     }
                     if (expired and values.size() < 2){
-                        std::stringstream ss;
-                        for(size_t i = 0; i < values.size(); ++i){
+                        std::ostringstream ss;
+                        for(size_t i = 0; i < values.size(); ++i) {
                             if(i != 0) ss << ",";
                             ss << values[i]->id;
                         }
@@ -969,7 +969,7 @@ DhtProxyServer::handleNotifyPushListenExpire(const asio::error_code &ec, const s
             logger_->e("[proxy:server] [subscribe] error sending put refresh: %s", ec.message().c_str());
     }
     if (logger_)
-        logger_->d("[proxy:server] [subscribe] sending put refresh to %s token", pushToken.c_str());
+        logger_->d("[proxy:server] [subscribe] sending refresh to %s token", pushToken.c_str());
     sendPushNotification(pushToken, jsonProvider(), type, false, topic);
 }
 
@@ -1019,33 +1019,43 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
 
     unsigned reqid = 0;
     try {
-        auto request = std::make_shared<http::Request>(io_context(), pushHostPort_.first, pushHostPort_.second,
-                                                                    httpsServer_ ? true : false, logger_);
+        std::shared_ptr<http::Request> request;
+        http::Url tokenUrl(token);
+        if (type == PushType::UnifiedPush)
+            request = std::make_shared<http::Request>(io_context(), tokenUrl.protocol + "://" + tokenUrl.host, logger_);
+        else
+            request = std::make_shared<http::Request>(io_context(), pushHostPort_.first, pushHostPort_.second, pushHostPort_.first.find("https://") == 0, logger_);;
         reqid = request->id();
-        request->set_target("/api/push");
+        request->set_target(type == PushType::UnifiedPush ? (tokenUrl.target) : "/api/push");
         request->set_method(restinio::http_method_post());
-        request->set_header_field(restinio::http_field_t::host, pushServer_.c_str());
+        request->set_header_field(restinio::http_field_t::host, type == PushType::UnifiedPush ? tokenUrl.host.c_str() : pushServer_.c_str());
         request->set_header_field(restinio::http_field_t::user_agent, "RESTinio client");
         request->set_header_field(restinio::http_field_t::accept, "*/*");
         request->set_header_field(restinio::http_field_t::content_type, "application/json");
 
-        // NOTE: see https://github.com/appleboy/gorush
-        Json::Value notification(Json::objectValue);
-        Json::Value tokens(Json::arrayValue);
-        tokens[0] = token;
-        notification["tokens"] = std::move(tokens);
-        notification["platform"] = type == PushType::Android ? 2 : 1;
-        notification["data"] = std::move(json);
-        notification["priority"] = highPriority ? "high" : "normal";
-        if (type == PushType::Android)
-            notification["time_to_live"] = 3600 * 24; // 24 hours
-        else {
-            const auto expiration = std::chrono::system_clock::now() + std::chrono::hours(24);
-            uint32_t exp = std::chrono::duration_cast<std::chrono::seconds>(expiration.time_since_epoch()).count();
-            notification["expiration"] = exp;
-            if (!topic.empty())
-                notification["topic"] = topic;
-            if (type == PushType::iOS) {
+        if (type == PushType::UnifiedPush) {
+            Json::Value notification(Json::objectValue);
+            notification["message"] = Json::writeString(jsonBuilder_, std::move(json));
+            notification["topic"] = token;
+            notification["priority"] = highPriority ? 5 : 1;
+            request->set_body(Json::writeString(jsonBuilder_, std::move(json)));
+        } else {
+            // NOTE: see https://github.com/appleboy/gorush
+            Json::Value notification(Json::objectValue);
+            Json::Value tokens(Json::arrayValue);
+            tokens[0] = token;
+            notification["tokens"] = std::move(tokens);
+            notification["platform"] = type == PushType::Android ? 2 : 1;
+            notification["data"] = std::move(json);
+            notification["priority"] = highPriority ? "high" : "normal";
+            if (type == PushType::Android)
+                notification["time_to_live"] = 3600 * 24; // 24 hours
+            else {
+                const auto expiration = std::chrono::system_clock::now() + std::chrono::hours(24);
+                uint32_t exp = std::chrono::duration_cast<std::chrono::seconds>(expiration.time_since_epoch()).count();
+                notification["expiration"] = exp;
+                if (!topic.empty())
+                    notification["topic"] = topic;
                 if (highPriority) {
                     Json::Value alert(Json::objectValue);
                     alert["title"]="hello";
@@ -1056,17 +1066,16 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
                     notification["push_type"] = "background";
                     notification["content_available"] = true;
                 }
-            } else if (type == PushType::iOSLegacy) {
-                notification["push_type"] = "voip";
             }
+
+            Json::Value notifications(Json::arrayValue);
+            notifications[0] = notification;
+
+            Json::Value content;
+            content["notifications"] = std::move(notifications);
+            request->set_body(Json::writeString(jsonBuilder_, content));
         }
 
-        Json::Value notifications(Json::arrayValue);
-        notifications[0] = notification;
-
-        Json::Value content;
-        content["notifications"] = std::move(notifications);
-        request->set_body(Json::writeString(jsonBuilder_, content));
         request->add_on_state_change_callback([this, reqid]
                                               (http::Request::State state, const http::Response& response){
             if (state == http::Request::State::DONE){
@@ -1084,7 +1093,7 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
     }
     catch (const std::exception &e){
         if (logger_)
-            logger_->e("[proxy:server] [notification] error send push: %i", e.what());
+            logger_->e("[proxy:server] [notification] error send push: %s", e.what());
         if (reqid) {
             std::lock_guard<std::mutex> l(requestLock_);
             requests_.erase(reqid);
@@ -1182,7 +1191,7 @@ DhtProxyServer::put(restinio::request_handle_t request,
                                 }
                             }
                             auto response = initHttpResponse(request->create_response());
-                            response.append_body(Json::writeString(jsonBuilder_, value->toJson()) + "\n");
+                            response.append_body(Json::writeString(jsonBuilder_, pp.second.value->toJson()) + "\n");
                             return response.done();
                         }
                     }
@@ -1194,9 +1203,8 @@ DhtProxyServer::put(restinio::request_handle_t request,
                 pput.value = value;
                 pput.expiration = timeout;
                 if (not pput.expireTimer) {
-                    auto &ctx = io_context();
                     // cancel permanent put
-                    pput.expireTimer = std::make_unique<asio::steady_timer>(ctx, timeout);
+                    pput.expireTimer = std::make_unique<asio::steady_timer>(io_context(), timeout);
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
                     if (not pushToken.empty()) {
                         pput.pushToken = pushToken;
@@ -1206,24 +1214,6 @@ DhtProxyServer::put(restinio::request_handle_t request,
                             topic = getDefaultTopic(pput.type);
                         pput.topic = topic;
                         pput.sessionCtx = std::make_shared<PushSessionContext>(sessionId);
-                        // notify push listen expire
-                        auto jsonProvider = [infoHash, clientId, vid, sessionCtx = pput.sessionCtx](){
-                            Json::Value json;
-                            json["timeout"] = infoHash.toString();
-                            json["to"] = clientId;
-                            json["vid"] = std::to_string(vid);
-                            std::lock_guard<std::mutex> l(sessionCtx->lock);
-                            json["s"] = sessionCtx->sessionId;
-                            return json;
-                        };
-                        if (!pput.expireNotifyTimer)
-                            pput.expireNotifyTimer = std::make_unique<asio::steady_timer>(ctx,
-                                                     timeout - proxy::OP_MARGIN);
-                        else
-                            pput.expireNotifyTimer->expires_at(timeout - proxy::OP_MARGIN);
-                        pput.expireNotifyTimer->async_wait(std::bind(
-                            &DhtProxyServer::handleNotifyPushListenExpire, this,
-                            std::placeholders::_1, pushToken, std::move(jsonProvider), pput.type, pput.topic));
                     }
 #endif
                 } else {
@@ -1236,12 +1226,34 @@ DhtProxyServer::put(restinio::request_handle_t request,
                         }
                     }
                     pput.expireTimer->expires_at(timeout);
-                    if (pput.expireNotifyTimer)
-                        pput.expireNotifyTimer->expires_at(timeout - proxy::OP_MARGIN);
                 }
                 pput.expireTimer->async_wait(std::bind(&DhtProxyServer::handleCancelPermamentPut, this,
                                                 std::placeholders::_1, infoHash, vid));
+
+#ifdef OPENDHT_PUSH_NOTIFICATIONS
+                // notify put permanent expiration
+                if (pput.sessionCtx) {
+                    auto jsonProvider = [infoHash, clientId, vid, sessionCtx = pput.sessionCtx](){
+                        Json::Value json;
+                        json["timeout"] = infoHash.toString();
+                        json["to"] = clientId;
+                        json["vid"] = std::to_string(vid);
+                        std::lock_guard<std::mutex> l(sessionCtx->lock);
+                        json["s"] = sessionCtx->sessionId;
+                        return json;
+                    };
+                    if (!pput.expireNotifyTimer)
+                        pput.expireNotifyTimer = std::make_unique<asio::steady_timer>(io_context(),
+                                                    timeout - proxy::OP_MARGIN);
+                    else
+                        pput.expireNotifyTimer->expires_at(timeout - proxy::OP_MARGIN);
+                    pput.expireNotifyTimer->async_wait(std::bind(
+                        &DhtProxyServer::handleNotifyPushListenExpire, this,
+                        std::placeholders::_1, pushToken, std::move(jsonProvider), pput.type, pput.topic));
+                }
+#endif
             }
+
             dht_->put(infoHash, value, [this, request, value](bool ok){
                 if (ok){
                     auto response = initHttpResponse(request->create_response());

src/dhtrunner.cpp

@@ -1115,6 +1115,8 @@ DhtRunner::enableProxy(bool proxify)
             dht_via_proxy->setPushNotificationToken(config_.push_token);
         if (not config_.push_topic.empty())
             dht_via_proxy->setPushNotificationTopic(config_.push_topic);
+        if (not config_.push_platform.empty())
+            dht_via_proxy->setPushNotificationPlatform(config_.push_platform);
         dht_ = std::make_unique<SecureDht>(std::move(dht_via_proxy), config_.dht_config, identityAnnouncedCb_, logger_);
         // and use it
         use_proxy = proxify;
@@ -1162,6 +1164,18 @@ DhtRunner::setPushNotificationTopic(const std::string& topic) {
 #endif
 }
 
+void
+DhtRunner::setPushNotificationPlatform(const std::string& platform) {
+    std::lock_guard<std::mutex> lck(dht_mtx);
+#if defined(OPENDHT_PROXY_CLIENT) && defined(OPENDHT_PUSH_NOTIFICATIONS)
+    config_.push_platform = platform;
+    if (dht_)
+        dht_->setPushNotificationPlatform(platform);
+#else
+    (void) platform;
+#endif
+}
+
 void
 DhtRunner::pushNotificationReceived(const std::map<std::string, std::string>& data)
 {

src/http.cpp

@@ -569,9 +569,10 @@ Connection::async_connect(std::vector<asio::ip::tcp::endpoint>&& endpoints, Conn
 
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-variable"
-    ConnectHandlerCb wcb = [&base, cb=std::move(cb)](const asio::error_code& ec, const asio::ip::tcp::endpoint& endpoint) {
+    ConnectHandlerCb wcb = [this, &base, cb=std::move(cb)](const asio::error_code& ec, const asio::ip::tcp::endpoint& endpoint) {
         if (!ec) {
             auto socket = base.native_handle();
+            local_address_ = base.local_endpoint().address();
             // Once connected, set a keep alive on the TCP socket with 30 seconds delay
             // This will generate broken pipes as soon as possible.
             // Note this needs to be done once connected to have a valid native_handle()
@@ -619,9 +620,9 @@ Connection::async_connect(std::vector<asio::ip::tcp::endpoint>&& endpoints, Conn
 #pragma GCC diagnostic pop
 
     if (ssl_socket_)
-        asio::async_connect(ssl_socket_->lowest_layer(), std::move(endpoints), wrapCallabck(std::move(wcb)));
+        asio::async_connect(ssl_socket_->lowest_layer(), std::move(endpoints), wrapCallback(std::move(wcb)));
     else
-        asio::async_connect(*socket_, std::move(endpoints), wrapCallabck(std::move(wcb)));
+        asio::async_connect(*socket_, std::move(endpoints), wrapCallback(std::move(wcb)));
 }
 
 void
@@ -666,8 +667,8 @@ Connection::async_write(BytesHandlerCb cb)
         if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
-    if (ssl_socket_)  asio::async_write(*ssl_socket_, write_buf_, wrapCallabck(std::move(cb)));
-    else if (socket_) asio::async_write(*socket_, write_buf_, wrapCallabck(std::move(cb)));
+    if (ssl_socket_)  asio::async_write(*ssl_socket_, write_buf_, wrapCallback(std::move(cb)));
+    else if (socket_) asio::async_write(*socket_, write_buf_, wrapCallback(std::move(cb)));
     else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
@@ -679,8 +680,8 @@ Connection::async_read_until(const char* delim, BytesHandlerCb cb)
         if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
-    if (ssl_socket_)  asio::async_read_until(*ssl_socket_, read_buf_, delim, wrapCallabck(std::move(cb)));
-    else if (socket_) asio::async_read_until(*socket_, read_buf_, delim, wrapCallabck(std::move(cb)));
+    if (ssl_socket_)  asio::async_read_until(*ssl_socket_, read_buf_, delim, wrapCallback(std::move(cb)));
+    else if (socket_) asio::async_read_until(*socket_, read_buf_, delim, wrapCallback(std::move(cb)));
     else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
@@ -692,8 +693,8 @@ Connection::async_read_until(char delim, BytesHandlerCb cb)
         if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
-    if (ssl_socket_)  asio::async_read_until(*ssl_socket_, read_buf_, delim, wrapCallabck(std::move(cb)));
-    else if (socket_) asio::async_read_until(*socket_, read_buf_, delim, wrapCallabck(std::move(cb)));
+    if (ssl_socket_)  asio::async_read_until(*ssl_socket_, read_buf_, delim, wrapCallback(std::move(cb)));
+    else if (socket_) asio::async_read_until(*socket_, read_buf_, delim, wrapCallback(std::move(cb)));
     else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
@@ -705,8 +706,8 @@ Connection::async_read(size_t bytes, BytesHandlerCb cb)
         if (cb) ctx_.post([cb](){ cb(asio::error::broken_pipe, 0); });
         return;
     }
-    if (ssl_socket_)  asio::async_read(*ssl_socket_, read_buf_, asio::transfer_exactly(bytes), wrapCallabck(std::move(cb)));
-    else if (socket_) asio::async_read(*socket_, read_buf_, asio::transfer_exactly(bytes), wrapCallabck(std::move(cb)));
+    if (ssl_socket_)  asio::async_read(*ssl_socket_, read_buf_, asio::transfer_exactly(bytes), wrapCallback(std::move(cb)));
+    else if (socket_) asio::async_read(*socket_, read_buf_, asio::transfer_exactly(bytes), wrapCallback(std::move(cb)));
     else if (cb)      ctx_.post([cb](){ cb(asio::error::operation_aborted, 0); });
 }
 
@@ -727,16 +728,15 @@ Connection::async_read_some(size_t bytes, BytesHandlerCb cb)
     else              socket_->async_read_some(buf, onEnd);
 }
 
+const asio::ip::address&
+Connection::local_address() const
+{
+    return local_address_;
+}
+
 void
-Connection::timeout(const std::chrono::seconds timeout, HandlerCb cb)
+Connection::timeout(const std::chrono::seconds& timeout, HandlerCb cb)
 {
-    if (!is_open()){
-        if (logger_)
-            logger_->e("[connection:%i] closed, can't timeout", id_);
-        if (cb)
-            cb(asio::error::operation_aborted);
-        return;
-    }
     if (!timeout_timer_)
         timeout_timer_ = std::make_unique<asio::steady_timer>(ctx_);
     timeout_timer_->expires_at(std::chrono::steady_clock::now() + timeout);
@@ -1195,6 +1195,9 @@ Request::connect(std::vector<asio::ip::tcp::endpoint>&& endpoints, HandlerCb cb)
     else
         conn_ = std::make_shared<Connection>(ctx_, false/*ssl*/, logger_);
 
+    if (conn_ && timeoutCb_)
+        conn_->timeout(timeout_, std::move(timeoutCb_));
+
     // try to connect to any until one works
     std::weak_ptr<Request> wthis = shared_from_this();
     conn_->async_connect(std::move(endpoints), [wthis, cb, isHttps]

src/securedht.cpp

@@ -326,7 +326,7 @@ SecureDht::listen(const InfoHash& id, GetCallback cb, Value::Filter f, Where w)
 void
 SecureDht::putSigned(const InfoHash& hash, Sp<Value> val, DoneCallback callback, bool permanent)
 {
-    if (not key_)  {
+    if (not key_ or not hash or not val)  {
         if (callback)
             callback(false, {});
         return;
@@ -365,7 +365,7 @@ SecureDht::putSigned(const InfoHash& hash, Sp<Value> val, DoneCallback callback,
             dht_->put(hash, val, callback, time_point::max(), permanent);
         },
         Value::IdFilter(val->id),
-        std::move(Where().id(val->id))
+        Where().id(val->id)
     );
 }
 

src/thread_pool.cpp

@@ -106,6 +106,7 @@ ThreadPool::stop()
 {
     std::lock_guard<std::mutex> l(lock_);
     running_ = false;
+    tasks_ = {};
     cv_.notify_all();
 }
 

tools/dhtnode.cpp

@@ -43,7 +43,7 @@ void print_version() {
 }
 
 void print_usage() {
-    std::cout << "Usage: dhtnode [-v [-l logfile]] [-i] [-d] [-n network_id] [-p local_port] [-b bootstrap_host[:port]] [--proxyserver local_port] [--proxyserverssl local_port] [--bundleid bundleid]" << std::endl << std::endl;
+    std::cout << "Usage: dhtnode [-v [-l logfile]] [-i] [-d] [-n network_id] [-p local_port] [-b bootstrap_host[:port]] [--proxyserver local_port] [--proxyserverssl local_port] [--bundleid bundleid] [--openpush endpoint]" << std::endl << std::endl;
     print_info();
 }
 

tools/tools_common.h

@@ -243,7 +243,7 @@ parseArgs(int argc, char **argv) {
     int opt;
     std::string privkey;
     std::string proxy_privkey;
-    while ((opt = getopt_long(argc, argv, "hidsvDUPp:n:b:f:l:", long_options, nullptr)) != -1) {
+    while ((opt = getopt_long(argc, argv, "hidsvODUPp:n:b:f:l:", long_options, nullptr)) != -1) {
         switch (opt) {
         case 'p': {
                 int port_arg = atoi(optarg);