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

@@ -413,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;

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/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();
 
     /**
@@ -415,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

@@ -40,7 +40,8 @@ namespace dht {
 enum class PushType {
     None = 0,
     Android,
-    iOS
+    iOS,
+    UnifiedPush
 };
 }
 MSGPACK_ADD_ENUM(dht::PushType)
@@ -392,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()) {
@@ -406,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);
@@ -437,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) {
@@ -445,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/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/dht_proxy_client.cpp

@@ -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;
@@ -1325,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"] = "ios";
-#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,11 +762,13 @@ DhtProxyServer::getTypeFromString(const std::string& type) {
         return PushType::Android;
     else if (type == "ios")
         return PushType::iOS;
+    else if (type == "unifiedpush")
+        return PushType::UnifiedPush;
     return PushType::None;
 }
 
 std::string
-DhtProxyServer::getDefaultTopic(PushType type) {
+DhtProxyServer::getDefaultTopic(PushType) {
     return bundleId_;
 }
 
@@ -886,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;
                         }
@@ -961,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);
 }
 
@@ -1011,50 +1019,63 @@ 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 (highPriority) {
-                Json::Value alert(Json::objectValue);
-                alert["title"]="hello";
-                notification["push_type"] = "alert";
-                notification["alert"] = alert;
-                notification["mutable_content"] = true;
-            } else {
-                notification["push_type"] = "background";
-                notification["content_available"] = true;
+        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";
+                    notification["push_type"] = "alert";
+                    notification["alert"] = alert;
+                    notification["mutable_content"] = true;
+                } else {
+                    notification["push_type"] = "background";
+                    notification["content_available"] = true;
+                }
             }
+
+            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){
@@ -1072,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);
@@ -1170,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();
                         }
                     }
@@ -1182,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;
@@ -1194,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 {
@@ -1224,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/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)
     );
 }
 

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);