build: add light mode

2026-11-09 21:07:17 +00:00 · 2019-12-13 17:10:05 -05:00
25 changed files with 348 additions and 321 deletions
@@ -7,15 +7,15 @@ set (PACKAGE_VERSION ${opendht_VERSION})
 set (VERSION "${opendht_VERSION}")

 # Options
+option (OPENDHT_LIGHT "Build minimal version of the library" OFF)
+
 option (OPENDHT_STATIC "Build static library" ON)
+
 option (OPENDHT_SHARED "Build shared library" ON)
-option (OPENDHT_LOG "Build with logs" ON)
 option (OPENDHT_PYTHON "Build Python bindings" OFF)
 option (OPENDHT_TOOLS "Build DHT tools" ON)
 option (OPENDHT_SYSTEMD "Install systemd module" OFF)
 option (OPENDHT_ARGON2 "Use included argon2 sources" OFF)
-option (OPENDHT_LTO "Build with LTO" OFF)
-option (OPENDHT_SANITIZE "Build with address sanitizer and stack protector" OFF)
 option (OPENDHT_PROXY_SERVER "Enable DHT proxy server, use Restinio and jsoncpp" OFF)
 option (OPENDHT_PUSH_NOTIFICATIONS "Enable push notifications support" OFF)
 option (OPENDHT_PROXY_SERVER_IDENTITY "Allow clients to use the node identity" OFF)
@@ -24,72 +24,89 @@ option (OPENDHT_PROXY_OPENSSL "Build DHT proxy with OpenSSL" ON)
 option (OPENDHT_PROXY_HTTP_PARSER_FORK "Build DHT proxy with custom http_parser to support old API" OFF)
 option (OPENDHT_PEER_DISCOVERY "Enable multicast peer discovery" ON)
 option (OPENDHT_INDEX "Build DHT indexation feature" OFF)
-option (OPENDHT_TESTS "Add unit tests executable" OFF)
 option (OPENDHT_C "Build C bindings" OFF)
+option (OPENDHT_TESTS "Add unit tests executable" OFF)
+
+if (OPENDHT_LIGHT)
+    set(OPENDHT_SHARED OFF)
+    set(OPENDHT_TOOLS OFF)
+    set(OPENDHT_PROXY_SERVER OFF)
+    set(OPENDHT_PROXY_CLIENT OFF)
+    set(OPENDHT_PEER_DISCOVERY OFF)
+    set(OPENDHT_INDEX OFF)
+    set(OPENDHT_PYTHON OFF)
+    add_definitions(-DOPENDHT_LIGHT)
+endif()
+
+option (OPENDHT_LOG "Build with logs" ON)
+option (OPENDHT_LTO "Build with LTO" OFF)
+option (OPENDHT_SANITIZE "Build with address sanitizer and stack protector" OFF)

 find_package(Doxygen)
 option (OPENDHT_DOCUMENTATION "Create and install the HTML based API documentation (requires Doxygen)" ${DOXYGEN_FOUND})

 # Dependencies
 list (APPEND CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake")
-find_package (Threads)
 find_package (PkgConfig)
-find_package (GnuTLS 3.3 REQUIRED)
-pkg_search_module (Nettle nettle)
 find_package (Msgpack 1.2 REQUIRED)
-if (OPENDHT_TOOLS)
-    find_package (Readline 6 REQUIRED)
-endif ()
-if (NOT OPENDHT_ARGON2)
-    find_package(PkgConfig)
-    pkg_search_module(argon2 libargon2)
-    if (argon2_FOUND)
-        message("-- Found Argon2: " ${argon2_LIBRARY_DIRS} " (found version \"" ${argon2_VERSION} "\")")
-        link_directories (${argon2_LIBRARY_DIRS})
-    else ()
-        message("Argon2 not found, using included version.")
-        set(OPENDHT_ARGON2 ON)
-    endif()
-endif ()
-
-pkg_search_module(Jsoncpp jsoncpp)
-if (Jsoncpp_FOUND)
-    add_definitions(-DOPENDHT_JSONCPP)
-    list (APPEND opendht_SOURCES
-      src/base64.h
-      src/base64.cpp
-    )
-endif()
-
-if (OPENDHT_PROXY_SERVER OR OPENDHT_PROXY_CLIENT)
-    find_package(Restinio REQUIRED)
-    if (Restinio_FOUND)
-        find_library(FMT_LIBRARY fmt)
-        add_library(fmt SHARED IMPORTED)
-        find_library(HTTP_PARSER_LIBRARY http_parser)
-        add_library(http_parser SHARED IMPORTED)
-    endif()
-    if (NOT Jsoncpp_FOUND)
-        message(SEND_ERROR "Jsoncpp is required for DHT proxy support")
-    endif()
-    if (OPENDHT_PROXY_OPENSSL)
-        # https://cmake.org/cmake/help/latest/module/FindOpenSSL.html
-        pkg_search_module(OPENSSL REQUIRED openssl)
-        if (OPENSSL_FOUND)
-            message(STATUS "Found OpenSSL ${OPENSSL_VERSION}")
-            include_directories(${OPENSSL_INCLUDE_DIRS})
+if (NOT OPENDHT_LIGHT)
+    find_package (Threads)
+    find_package (GnuTLS 3.3 REQUIRED)
+    pkg_search_module (Nettle nettle)
+    if (OPENDHT_TOOLS)
+        find_package (Readline 6 REQUIRED)
+    endif ()
+    if (NOT OPENDHT_ARGON2)
+        find_package(PkgConfig)
+        pkg_search_module(argon2 libargon2)
+        if (argon2_FOUND)
+            message("-- Found Argon2: " ${argon2_LIBRARY_DIRS} " (found version \"" ${argon2_VERSION} "\")")
+            link_directories (${argon2_LIBRARY_DIRS})
        else ()
-            message(SEND_ERROR "OpenSSL is required for DHT proxy as specified")
+            message("Argon2 not found, using included version.")
+            set(OPENDHT_ARGON2 ON)
        endif()
+    endif ()
+
+    pkg_search_module(Jsoncpp jsoncpp)
+    if (Jsoncpp_FOUND)
+        add_definitions(-DOPENDHT_JSONCPP)
+        list (APPEND opendht_SOURCES
+        src/base64.h
+        src/base64.cpp
+        )
    endif()
-    if (OPENDHT_PROXY_HTTP_PARSER_FORK)
-        add_definitions(-DOPENDHT_PROXY_HTTP_PARSER_FORK)
+
+    if (OPENDHT_PROXY_SERVER OR OPENDHT_PROXY_CLIENT)
+        find_package(Restinio REQUIRED)
+        if (Restinio_FOUND)
+            find_library(FMT_LIBRARY fmt)
+            add_library(fmt SHARED IMPORTED)
+            find_library(HTTP_PARSER_LIBRARY http_parser)
+            add_library(http_parser SHARED IMPORTED)
+        endif()
+        if (NOT Jsoncpp_FOUND)
+            message(SEND_ERROR "Jsoncpp is required for DHT proxy support")
+        endif()
+        if (OPENDHT_PROXY_OPENSSL)
+            # https://cmake.org/cmake/help/latest/module/FindOpenSSL.html
+            pkg_search_module(OPENSSL REQUIRED openssl)
+            if (OPENSSL_FOUND)
+                message(STATUS "Found OpenSSL ${OPENSSL_VERSION}")
+                include_directories(${OPENSSL_INCLUDE_DIRS})
+            else ()
+                message(SEND_ERROR "OpenSSL is required for DHT proxy as specified")
+            endif()
+        endif()
+        if (OPENDHT_PROXY_HTTP_PARSER_FORK)
+            add_definitions(-DOPENDHT_PROXY_HTTP_PARSER_FORK)
+        endif()
+    else()
+        set(OPENDHT_PROXY_OPENSSL OFF)
+    endif()
+    if (OPENDHT_PROXY_SERVER OR OPENDHT_PROXY_CLIENT OR OPENDHT_PEER_DISCOVERY)
+        add_definitions(-DASIO_STANDALONE)
    endif()
-else()
-    set(OPENDHT_PROXY_OPENSSL OFF)
-endif()
-if (OPENDHT_PROXY_SERVER OR OPENDHT_PROXY_CLIENT OR OPENDHT_PEER_DISCOVERY)
-    add_definitions(-DASIO_STANDALONE)
 endif()

 # Build flags
@@ -161,7 +178,6 @@ set (top_srcdir "${CMAKE_CURRENT_SOURCE_DIR}")
 list (APPEND opendht_SOURCES
    src/utils.cpp
    src/infohash.cpp
-    src/crypto.cpp
    src/default_types.cpp
    src/node.cpp
    src/value.cpp
@@ -179,11 +195,7 @@ list (APPEND opendht_SOURCES
    src/routing_table.cpp
    src/node_cache.cpp
    src/network_engine.cpp
-    src/securedht.cpp
-    src/dhtrunner.cpp
    src/log.cpp
-    src/network_utils.cpp
-    src/thread_pool.cpp
 )

 list (APPEND opendht_HEADERS
@@ -191,7 +203,6 @@ list (APPEND opendht_HEADERS
    include/opendht/utils.h
    include/opendht/sockaddr.h
    include/opendht/rng.h
-    include/opendht/crypto.h
    include/opendht/infohash.h
    include/opendht/default_types.h
    include/opendht/node.h
@@ -207,11 +218,27 @@ list (APPEND opendht_HEADERS
    include/opendht/securedht.h
    include/opendht/log.h
    include/opendht/log_enable.h
-    include/opendht/thread_pool.h
-    include/opendht/network_utils.h
    include/opendht.h
 )

+if (NOT OPENDHT_LIGHT)
+    list (APPEND opendht_SOURCES
+        src/crypto.cpp
+        src/securedht.cpp
+        src/dhtrunner.cpp
+        src/network_utils.cpp
+        src/thread_pool.cpp
+    )
+
+    list (APPEND opendht_HEADERS
+        include/opendht/crypto.h
+        include/opendht/securedht.h
+        include/opendht/dhtrunner.h
+        include/opendht/thread_pool.h
+        include/opendht/network_utils.h
+    )
+endif()
+
 if (OPENDHT_PEER_DISCOVERY)
    list (APPEND opendht_SOURCES src/peer_discovery.cpp)
    list (APPEND opendht_HEADERS include/opendht/peer_discovery.h)
@@ -384,13 +411,17 @@ if (OPENDHT_TESTS)
        tests/infohashtester.cpp
        tests/valuetester.h
        tests/valuetester.cpp
-        tests/cryptotester.h
-        tests/cryptotester.cpp
-        tests/dhtrunnertester.h
-        tests/dhtrunnertester.cpp
-        tests/threadpooltester.h
-        tests/threadpooltester.cpp
    )
+    if (NOT OPENDHT_LIGHT)
+        list (APPEND test_FILES
+            tests/cryptotester.h
+            tests/cryptotester.cpp
+            tests/dhtrunnertester.h
+            tests/dhtrunnertester.cpp
+            tests/threadpooltester.h
+            tests/threadpooltester.cpp
+        )
+    endif()
    if (OPENDHT_PROXY_SERVER AND OPENDHT_PROXY_CLIENT)
        list (APPEND test_FILES
            tests/httptester.h
@@ -16,7 +16,7 @@ Values are distributed over the network, with redundancy.
 * IPv4 and IPv6 support
 * Clean and powerful C++14 map API
 * Python 3 bindings
- * REST API with optional HTTP client+server with push notification support
+ * REST API

 ## Documentation
 See the wiki: <https://github.com/savoirfairelinux/opendht/wiki>
@@ -124,7 +124,7 @@ void dht_publickey_delete(dht_publickey* pk) {

 int dht_publickey_export(const dht_publickey* pk, char* out, size_t* outlen) {
    const auto& pkey = *reinterpret_cast<const PubkeySp*>(pk);
-    return pkey->pack((uint8_t*)out, outlen);
+    return gnutls_pubkey_export(pkey->pk, GNUTLS_X509_FMT_DER, out, outlen);
 }

 dht_infohash dht_publickey_get_id(const dht_publickey* pk) {
@@ -22,8 +22,8 @@ RUN echo "*** Building nodejs/http_parser dependency ***" \

 # libasio-dev (1.10.6-3) is too old
 RUN echo "** Building a recent version of asio ***" \
-    && wget https://github.com/aberaud/asio/archive/a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571.tar.gz \
-    && tar -xvf a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571.tar.gz && cd asio-a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571/asio \
+    && wget https://github.com/aberaud/asio/archive/b2b7a1c166390459e1c169c8ae9ef3234b361e3f.tar.gz \
+    && tar -xvf b2b7a1c166390459e1c169c8ae9ef3234b361e3f.tar.gz && cd asio-b2b7a1c166390459e1c169c8ae9ef3234b361e3f/asio \
    && ./autogen.sh && ./configure --prefix=/usr --without-boost --disable-examples --disable-tests  \
    && make install \
    && cd ../../ && rm -rf asio*
@@ -5,13 +5,13 @@ RUN echo "APT::Acquire::Retries \"3\";" > /etc/apt/apt.conf.d/80-retries
 RUN apt-get update && apt-get install -y \
        apt-transport-https build-essential cmake git wget libncurses5-dev libreadline-dev nettle-dev \
        libgnutls28-dev libuv1-dev cython3 python3-dev python3-setuptools libcppunit-dev libjsoncpp-dev \
-        autotools-dev autoconf libfmt-dev libhttp-parser-dev libmsgpack-dev libssl-dev \
+        autotools-dev autoconf libfmt-dev libhttp-parser-dev libmsgpack-dev \
    && apt-get clean

 # libasio-dev (1.10) is too old
 RUN echo "** Building a recent version of asio ***" \
-    && wget https://github.com/aberaud/asio/archive/a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571.tar.gz \
-    && tar -xvf a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571.tar.gz && cd asio-a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571/asio \
+    && wget https://github.com/aberaud/asio/archive/b2b7a1c166390459e1c169c8ae9ef3234b361e3f.tar.gz \
+    && tar -xvf b2b7a1c166390459e1c169c8ae9ef3234b361e3f.tar.gz && cd asio-b2b7a1c166390459e1c169c8ae9ef3234b361e3f/asio \
    && ./autogen.sh && ./configure --prefix=/usr --without-boost --disable-examples --disable-tests  \
    && make install \
    && cd ../../ && rm -rf asio*
@@ -26,8 +26,8 @@ RUN echo "*** Building nodejs/http_parser dependency ***" \

 # libasio-dev (1.10.6-3) is too old
 RUN echo "** Building a recent version of asio ***" \
-    && wget https://github.com/aberaud/asio/archive/a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571.tar.gz \
-    && tar -xvf a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571.tar.gz && cd asio-a7d66ef4017d8f1b7f2cef1bb4ba8e23b0961571/asio \
+    && wget https://github.com/aberaud/asio/archive/b2b7a1c166390459e1c169c8ae9ef3234b361e3f.tar.gz \
+    && tar -xvf b2b7a1c166390459e1c169c8ae9ef3234b361e3f.tar.gz && cd asio-b2b7a1c166390459e1c169c8ae9ef3234b361e3f/asio \
    && ./autogen.sh && ./configure --prefix=/usr --without-boost --disable-examples --disable-tests  \
    && make install \
    && cd ../../ && rm -rf asio*
@@ -3,5 +3,5 @@ MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>

 COPY . /root/opendht
 RUN cd /root/opendht && mkdir build && cd build \
-	&& cmake -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_C=On -DOPENDHT_LTO=On -DOPENDHT_TESTS=ON ..  \
+	&& cmake -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_LTO=On -DOPENDHT_TESTS=ON ..  \
 	&& make -j8 && ./opendht_unit_tests && make install
@@ -3,5 +3,5 @@ MAINTAINER Adrien Béraud <adrien.beraud@savoirfairelinux.com>

 COPY . /root/opendht
 RUN cd /root/opendht && mkdir build && cd build \
-	&& cmake -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_C=On -DOPENDHT_TESTS=ON .. \
+	&& cmake -DCMAKE_INSTALL_PREFIX=/usr -DOPENDHT_PYTHON=On -DOPENDHT_TESTS=ON .. \
 	&& make -j8 && ./opendht_unit_tests && make install
@@ -122,6 +122,7 @@ struct OPENDHT_PUBLIC Config {
    ssize_t max_peer_req_per_sec {0};
 };

+#ifndef OPENDHT_LIGHT
 /**
 * SecureDht configuration.
 */
@@ -130,6 +131,7 @@ struct OPENDHT_PUBLIC SecureDhtConfig
    Config node_config {};
    crypto::Identity id {};
 };
+#endif

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

@@ -114,7 +114,6 @@ struct OPENDHT_PUBLIC PublicKey
    }

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

    std::string toString() const;
@@ -128,7 +127,7 @@ struct OPENDHT_PUBLIC PublicKey
        p.pack_bin_body((const char*)b.data(), b.size());
    }

-    void msgpack_unpack(const msgpack::object& o);
+    void msgpack_unpack(msgpack::object o);

    gnutls_digest_algorithm_t getPreferredDigest() const;

@@ -226,7 +225,7 @@ public:
        p.pack_bin_body((const char*)b.data(), b.size());
    }

-    void msgpack_unpack(const msgpack::object& o);
+    void msgpack_unpack(msgpack::object o);

    void revoke(const Certificate& crt, time_point t = time_point::min());

@@ -424,7 +423,7 @@ struct OPENDHT_PUBLIC Certificate {
        p.pack_bin_body((const char*)b.data(), b.size());
    }

-    void msgpack_unpack(const msgpack::object& o);
+    void msgpack_unpack(msgpack::object o);

    explicit operator bool() const { return cert; }
    PublicKey getPublicKey() const;
@@ -58,6 +58,7 @@ public:
    MSGPACK_DEFINE(service, data)
 };

+#ifndef OPENDHT_LIGHT
 template <typename T>
 class OPENDHT_PUBLIC SignedValue : public Value::Serializable<T>
 {
@@ -102,7 +103,6 @@ public:



-
 class OPENDHT_PUBLIC ImMessage : public SignedValue<ImMessage>
 {
 private:
@@ -177,19 +177,11 @@ public:
    {
        pk.pack_array(2);
        pk.pack(id);
-#if 1
        pk.pack_bin(ice_data.size());
        pk.pack_bin_body((const char*)ice_data.data(), ice_data.size());
-#else
-        // hack for backward compatibility with old opendht compiled with msgpack 1.0
-        // remove when enough people have moved to new versions
-        pk.pack_array(ice_data.size());
-        for (uint8_t b : ice_data)
-            pk.pack(b);
-#endif
    }

-    virtual void msgpack_unpack(const msgpack::object& o)
+    virtual void msgpack_unpack(msgpack::object o)
    {
        if (o.type != msgpack::type::ARRAY) throw msgpack::type_error();
        if (o.via.array.size < 2) throw msgpack::type_error();
@@ -200,6 +192,7 @@ public:
    Value::Id id {0};
    Blob ice_data;
 };
+#endif

 /* "Peer" announcement
 */
@@ -229,7 +222,7 @@ public:
        pk.pack_bin_body((const char*)addr.get(), addr.getLength());
    }

-    virtual void msgpack_unpack(const msgpack::object& o)
+    virtual void msgpack_unpack(msgpack::object o)
    {
        if (o.type == msgpack::type::BIN)
            addr = {(sockaddr*)o.via.bin.ptr, (socklen_t)o.via.bin.size};
@@ -261,8 +254,11 @@ private:
    SockAddr addr;
 };

-
+#ifndef OPENDHT_LIGHT
 OPENDHT_PUBLIC extern const std::array<std::reference_wrapper<const ValueType>, 5> DEFAULT_TYPES;
+#else
+OPENDHT_PUBLIC extern const std::array<std::reference_wrapper<const ValueType>, 1> DEFAULT_TYPES;
+#endif

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

@@ -303,7 +303,7 @@ private:
    /**
     * Send Listen with httpClient_
     */
-    void sendListen(const restinio::http_request_header_t& header, const ValueCallback& cb,
+    void sendListen(const restinio::http_request_header_t header, const ValueCallback& cb,
                    const Sp<OperationState>& opstate, Listener& listener, ListenMethod method = ListenMethod::LISTEN);
    void handleResubscribe(const asio::error_code& ec, const InfoHash& key,
                           const size_t token, std::shared_ptr<OperationState> opstate);
@@ -327,7 +327,6 @@ private:
    std::shared_ptr<dht::crypto::Certificate> serverCertificate_;
    //std::pair<std::string, std::string> serverHostService_;
    std::string pushClientId_;
-    std::string pushSessionId_;

    mutable std::mutex lockCurrentProxyInfos_;
    NodeStatus statusIpv4_ {NodeStatus::Disconnected};
@@ -281,7 +281,7 @@ private:
     * @param key of the device
     * @param json, the content to send
     */
-    void sendPushNotification(const std::string& key, Json::Value&& json, bool isAndroid, bool highPriority);
+    void sendPushNotification(const std::string& key, Json::Value&& json, bool isAndroid);

    /**
     * Send push notification with an expire timeout.
@@ -360,7 +360,6 @@ private:
 #ifdef OPENDHT_PUSH_NOTIFICATIONS
    struct Listener {
        std::string clientId;
-        std::string sessionId;
        std::future<size_t> internalToken;
        std::unique_ptr<asio::steady_timer> expireTimer;
        std::unique_ptr<asio::steady_timer> expireNotifyTimer;
@@ -118,7 +118,7 @@ private:
    template<typename T>
    T wrapCallabck(T cb) const {
        return [t=shared_from_this(),cb=std::move(cb)](auto ...params) {
-            cb(params...);
+            return cb(params...);
        };
    }

@@ -50,7 +50,7 @@ namespace dht {
 using byte = uint8_t;

 namespace crypto {
-    OPENDHT_PUBLIC void hash(const uint8_t* data, size_t data_length, uint8_t* hash, size_t hash_length);
+OPENDHT_PUBLIC void hash(const uint8_t* data, size_t data_length, uint8_t* hash, size_t hash_length);
 }

 /**
@@ -133,7 +133,7 @@ using Blob = std::vector<uint8_t>;
 /**
 * Provides backward compatibility with msgpack 1.0
 */
-OPENDHT_PUBLIC Blob unpackBlob(const msgpack::object& o);
+OPENDHT_PUBLIC Blob unpackBlob(msgpack::object& o);

 template <typename Type>
 Blob
@@ -153,7 +153,6 @@ unpackMsg(Blob b) {

 msgpack::unpacked unpackMsg(Blob b);

-msgpack::object* findMapValue(const msgpack::object& map, const char* key);
-msgpack::object* findMapValue(const msgpack::object& map, const std::string& key);
+msgpack::object* findMapValue(msgpack::object& map, const std::string& key);

 } // namespace dht
@@ -20,7 +20,7 @@
 #pragma once

 #include "infohash.h"
-#include "crypto.h"
+//#include "crypto.h"
 #include "utils.h"
 #include "sockaddr.h"

@@ -43,22 +43,15 @@

 namespace dht {

-static const std::string VALUE_KEY_ID("id");
-static const std::string VALUE_KEY_DAT("dat");
-static const std::string VALUE_KEY_PRIO("p");
-static const std::string VALUE_KEY_SIGNATURE("sig");
-
-static const std::string VALUE_KEY_SEQ("seq");
-static const std::string VALUE_KEY_DATA("data");
-static const std::string VALUE_KEY_OWNER("owner");
-static const std::string VALUE_KEY_TYPE("type");
-static const std::string VALUE_KEY_TO("to");
-static const std::string VALUE_KEY_BODY("body");
-static const std::string VALUE_KEY_USERTYPE("utype");
-
 struct Value;
 struct Query;

+namespace crypto {
+class PublicKey;
+class PrivateKey;
+class Certificate;
+}
+
 /**
 * A storage policy is applied once to every incoming value storage requests.
 * If the policy returns false, the value is dropped.
@@ -254,15 +247,9 @@ struct OPENDHT_PUBLIC Value
        };
    }

-    static Filter OwnerFilter(const crypto::PublicKey& pk) {
-        return OwnerFilter(pk.getId());
-    }
+    static Filter OwnerFilter(const crypto::PublicKey& pk);

-    static Filter OwnerFilter(const InfoHash& pkh) {
-        return [pkh](const Value& v) {
-            return v.owner and v.owner->getId() == pkh;
-        };
-    }
+    static Filter OwnerFilter(const InfoHash& pkh);

    static Filter SeqNumFilter(uint16_t seq_no) {
        return [seq_no](const Value& v) {
@@ -354,20 +341,13 @@ struct OPENDHT_PUBLIC Value
     * Afterward, checkSignature() will return true and owner will
     * be set to the corresponding public key.
     */
-    void sign(const crypto::PrivateKey& key) {
-        if (isEncrypted())
-            throw DhtException("Can't sign encrypted data.");
-        owner = std::make_shared<const crypto::PublicKey>(key.getPublicKey());
-        signature = key.sign(getToSign());
-    }
+    void sign(const crypto::PrivateKey& key);

    /**
     * Check that the value is signed and that the signature matches.
     * If true, the owner field will contain the signer public key.
     */
-    bool checkSignature() const {
-        return isSigned() and owner->checkSignature(getToSign(), signature);
-    }
+    bool checkSignature() const;

    std::shared_ptr<const crypto::PublicKey> getOwner() const {
        return std::static_pointer_cast<const crypto::PublicKey>(owner);
@@ -376,15 +356,7 @@ struct OPENDHT_PUBLIC Value
    /**
     * Sign the value with from and returns the encrypted version for to.
     */
-    Value encrypt(const crypto::PrivateKey& from, const crypto::PublicKey& to) {
-        if (isEncrypted())
-            throw DhtException("Data is already encrypted.");
-        setRecipient(to.getId());
-        sign(from);
-        Value nv {id};
-        nv.setCypher(to.encrypt(getToEncrypt()));
-        return nv;
-    }
+    Value encrypt(const crypto::PrivateKey& from, const crypto::PublicKey& to);

    Value() {}

@@ -403,7 +375,7 @@ struct OPENDHT_PUBLIC Value
     * Build a value from a json object
     * @param json
     */
-    Value(const Json::Value& json);
+    Value(Json::Value& json);
 #endif

    template <typename Type>
@@ -421,9 +393,7 @@ struct OPENDHT_PUBLIC Value

    Value(Value&& o) noexcept
     : id(o.id), owner(std::move(o.owner)), recipient(o.recipient),
-     type(o.type), data(std::move(o.data)), user_type(std::move(o.user_type)), seq(o.seq)
-     , signature(std::move(o.signature)), cypher(std::move(o.cypher))
-     , priority(o.priority) {}
+     type(o.type), data(std::move(o.data)), user_type(std::move(o.user_type)), seq(o.seq), signature(std::move(o.signature)), cypher(std::move(o.cypher)) {}

    template <typename Type>
    Value(const Type& vs)
@@ -439,7 +409,11 @@ struct OPENDHT_PUBLIC Value
    inline bool operator== (const Value& o) {
        return id == o.id &&
        (isEncrypted() ? cypher == o.cypher :
-        ((owner == o.owner || *owner == *o.owner) && type == o.type && data == o.data && user_type == o.user_type && signature == o.signature));
+        (
+#ifndef OPENDHT_LIGHT
+            (owner == o.owner || *owner == *o.owner) &&
+#endif
+            type == o.type && data == o.data && user_type == o.user_type && signature == o.signature));
    }

    void setRecipient(const InfoHash& r) {
@@ -497,20 +471,24 @@ struct OPENDHT_PUBLIC Value
    template <typename Packer>
    void msgpack_pack_to_sign(Packer& pk) const
    {
-        bool has_owner = owner && *owner;
+#ifndef OPENDHT_LIGHT
+        bool has_owner = owner && *owner
        pk.pack_map((user_type.empty()?0:1) + (has_owner?(recipient ? 5 : 4):2));
        if (has_owner) { // isSigned
-            pk.pack(VALUE_KEY_SEQ);   pk.pack(seq);
-            pk.pack(VALUE_KEY_OWNER); owner->msgpack_pack(pk);
+            pk.pack(std::string("seq"));   pk.pack(seq);
+            pk.pack(std::string("owner")); owner->msgpack_pack(pk);
            if (recipient) {
-                pk.pack(VALUE_KEY_TO); pk.pack(recipient);
+                pk.pack(std::string("to")); pk.pack(recipient);
            }
        }
-        pk.pack(VALUE_KEY_TYPE);  pk.pack(type);
-        pk.pack(VALUE_KEY_DATA);  pk.pack_bin(data.size());
-                                  pk.pack_bin_body((const char*)data.data(), data.size());
+#else
+        pk.pack_map((user_type.empty()?0:1) + 2);
+#endif
+        pk.pack(std::string("type"));  pk.pack(type);
+        pk.pack(std::string("data"));  pk.pack_bin(data.size());
+                                       pk.pack_bin_body((const char*)data.data(), data.size());
        if (not user_type.empty()) {
-            pk.pack(VALUE_KEY_USERTYPE); pk.pack(user_type);
+            pk.pack(std::string("utype")); pk.pack(user_type);
        }
    }

@@ -522,10 +500,10 @@ struct OPENDHT_PUBLIC Value
            pk.pack_bin_body((const char*)cypher.data(), cypher.size());
        } else {
            pk.pack_map(isSigned() ? 2 : 1);
-            pk.pack(VALUE_KEY_BODY); msgpack_pack_to_sign(pk);
+            pk.pack(std::string("body")); msgpack_pack_to_sign(pk);
            if (isSigned()) {
-                pk.pack(VALUE_KEY_SIGNATURE); pk.pack_bin(signature.size());
-                                              pk.pack_bin_body((const char*)signature.data(), signature.size());
+                pk.pack(std::string("sig")); pk.pack_bin(signature.size());
+                                             pk.pack_bin_body((const char*)signature.data(), signature.size());
            }
        }
    }
@@ -533,12 +511,9 @@ struct OPENDHT_PUBLIC Value
    template <typename Packer>
    void msgpack_pack(Packer& pk) const
    {
-        pk.pack_map(2 + (priority?1:0));
-        pk.pack(VALUE_KEY_ID);  pk.pack(id);
-        pk.pack(VALUE_KEY_DAT); msgpack_pack_to_encrypt(pk);
-        if (priority) {
-            pk.pack(VALUE_KEY_PRIO);  pk.pack(priority);
-        }
+        pk.pack_map(2);
+        pk.pack(std::string("id"));  pk.pack(id);
+        pk.pack(std::string("dat")); msgpack_pack_to_encrypt(pk);
    }

    template <typename Packer>
@@ -553,9 +528,11 @@ struct OPENDHT_PUBLIC Value
                    pk.pack(static_cast<uint64_t>(type));
                    break;
                case Value::Field::OwnerPk:
+#ifndef OPENDHT_LIGHT
                    if (owner)
                        owner->msgpack_pack(pk);
                    else
+#endif
                        InfoHash().msgpack_pack(pk);
                    break;
                case Value::Field::SeqNum:
@@ -569,7 +546,7 @@ struct OPENDHT_PUBLIC Value
            }
    }

-    void msgpack_unpack(const msgpack::object& o);
+    void msgpack_unpack(msgpack::object o);
    void msgpack_unpack_body(const msgpack::object& o);
    Blob getPacked() const {
        msgpack::sbuffer buffer;
@@ -620,13 +597,6 @@ struct OPENDHT_PUBLIC Value
     */
    Blob cypher {};

-    /**
-     * Priority of this value (used for push notifications)
-     * 0 = high priority
-     * 1 = normal priority
-     */
-    unsigned priority {0};
-
 private:
    friend class SecureDht;
    /* Cache for crypto ops */
@@ -683,7 +653,7 @@ struct OPENDHT_PUBLIC FieldValue
        }
    }

-    void msgpack_unpack(const msgpack::object& msg) {
+    void msgpack_unpack(msgpack::object msg) {
        hashValue = {};
        blobValue.clear();

@@ -131,7 +131,7 @@ base64_encode(const std::vector<unsigned char>& str)
    return base64_encode(str.cbegin(), str.cend());
 }

-std::vector<unsigned char>
+std::string
 base64_decode(const std::string& str)
 {
    size_t output_length = str.length() / 4 * 3 + 2;
@@ -139,5 +139,5 @@ base64_decode(const std::string& str)
    output.resize(output_length);
    base64_decode(str.data(), str.size(), output.data(), &output_length);
    output.resize(output_length);
-    return output;
+    return std::string(output.begin(), output.end());
 }
@@ -33,4 +33,4 @@ std::string base64_encode(const std::vector<unsigned char>& str);
 * @param str the input buffer
 * @return a base64-decoded buffer
 */
-std::vector<unsigned char> base64_decode(const std::string& str);
+std::string base64_decode(const std::string& str);
@@ -412,18 +412,12 @@ PublicKey::pack(Blob& b) const
        throw CryptoException(std::string("Could not export public key: null key"));
    std::vector<uint8_t> tmp(2048);
    size_t sz = tmp.size();
-    if (int err = pack(tmp.data(), &sz))
+    if (int err = gnutls_pubkey_export(pk, GNUTLS_X509_FMT_DER, tmp.data(), &sz))
        throw CryptoException(std::string("Could not export public key: ") + gnutls_strerror(err));
    tmp.resize(sz);
    b.insert(b.end(), tmp.begin(), tmp.end());
 }

-int
-PublicKey::pack(uint8_t* out, size_t* out_len) const
-{
-    return gnutls_pubkey_export(pk, GNUTLS_X509_FMT_DER, out, out_len);
-}
-
 void
 PublicKey::unpack(const uint8_t* data, size_t data_size)
 {
@@ -453,7 +447,7 @@ PublicKey::toString() const
 }

 void
-PublicKey::msgpack_unpack(const msgpack::object& o)
+PublicKey::msgpack_unpack(msgpack::object o)
 {
    if (o.type == msgpack::type::BIN)
        unpack((const uint8_t*)o.via.bin.ptr, o.via.bin.size);
@@ -798,7 +792,7 @@ Certificate::unpack(const uint8_t* dat, size_t dat_size)
 }

 void
-Certificate::msgpack_unpack(const msgpack::object& o)
+Certificate::msgpack_unpack(msgpack::object o)
 {
    if (o.type == msgpack::type::BIN)
        unpack((const uint8_t*)o.via.bin.ptr, o.via.bin.size);
@@ -1258,7 +1252,7 @@ RevocationList::unpack(const uint8_t* dat, size_t dat_size)
 }

 void
-RevocationList::msgpack_unpack(const msgpack::object& o)
+RevocationList::msgpack_unpack(msgpack::object o)
 {
    try {
        if (o.type == msgpack::type::BIN)
@@ -15,6 +15,9 @@
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif

 #include "default_types.h"

@@ -83,6 +86,8 @@ IpServiceAnnouncement::storePolicy(InfoHash h, std::shared_ptr<Value>& v, const

 const ValueType DhtMessage::TYPE(1, "DHT message", std::chrono::minutes(5), DhtMessage::storePolicy);
 const ValueType IpServiceAnnouncement::TYPE(2, "Internet Service Announcement", std::chrono::minutes(15), IpServiceAnnouncement::storePolicy);
+
+#ifndef OPENDHT_LIGHT
 const ValueType ImMessage::TYPE = {3, "IM message", std::chrono::minutes(5)};
 const ValueType TrustRequest::TYPE = {4, "Certificate trust request", std::chrono::hours(24*7)};
 const ValueType IceCandidates::TYPE = {5, "ICE candidates", std::chrono::minutes(1)};
@@ -96,6 +101,13 @@ DEFAULT_TYPES
    IceCandidates::TYPE,
    TrustRequest::TYPE
 }};
+#else
+const std::array<std::reference_wrapper<const ValueType>, 1>
+DEFAULT_TYPES
+{{
+    ValueType::USER_DATA
+}};
+#endif

 const std::array<std::reference_wrapper<const ValueType>, 1>
 DEFAULT_INSECURE_TYPES
@@ -93,16 +93,6 @@ private:
    std::string line_ {};
 };

-std::string
-getRandomSessionId(size_t length = 8) {
-    static constexpr const char chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!#$%&()*+,./:;<=>?@[]^_`{|}~";
-    std::string str(length, 0);
-    crypto::random_device rdev;
-    std::uniform_int_distribution<> dist(0, (sizeof(chars)/sizeof(char)) - 1);
-    std::generate_n( str.begin(), length, [&]{ return chars[dist(rdev)]; } );
-    return str;
-}
-
 DhtProxyClient::DhtProxyClient() {}

 DhtProxyClient::DhtProxyClient(
@@ -111,8 +101,7 @@ DhtProxyClient::DhtProxyClient(
        const std::string& pushClientId, std::shared_ptr<dht::Logger> logger)
    : proxyUrl_(serverHost)
    , clientIdentity_(clientIdentity), serverCertificate_(serverCA)
-    , pushClientId_(pushClientId), pushSessionId_(getRandomSessionId())
-    , loopSignal_(signal)
+    , pushClientId_(pushClientId), loopSignal_(signal)
    , jsonReader_(Json::CharReaderBuilder{}.newCharReader())
    , logger_(logger)
 {
@@ -940,7 +929,7 @@ DhtProxyClient::handleExpireListener(const asio::error_code &ec, const InfoHash&
 }

 void
-DhtProxyClient::sendListen(const restinio::http_request_header_t& header,
+DhtProxyClient::sendListen(const restinio::http_request_header_t header,
                           const ValueCallback& cb,
                           const Sp<OperationState>& opstate,
                           Listener& listener, ListenMethod method)
@@ -1129,12 +1118,6 @@ DhtProxyClient::pushNotificationReceived(const std::map<std::string, std::string
        statusIpv6_ = NodeStatus::Connected;
    }
    try {
-        auto sessionId = notification.find("s");
-        if (sessionId != notification.end() and sessionId->second != pushSessionId_) {
-            if (logger_)
-                logger_->d("[proxy:client] [push] ignoring push for other session");
-            return;
-        }
        std::lock_guard<std::mutex> lock(searchLock_);
        auto timeout = notification.find("timeout");
        if (timeout != notification.cend()) {
@@ -1179,7 +1162,7 @@ DhtProxyClient::pushNotificationReceived(const std::map<std::string, std::string
                } else {
                    std::stringstream ss(expired->second);
                    std::vector<Value::Id> ids;
-                    while(ss.good()) {
+                    while(ss.good()){
                        std::string substr;
                        getline(ss, substr, ',');
                        ids.emplace_back(std::stoull(substr));
@@ -1254,7 +1237,6 @@ DhtProxyClient::getPushRequest(Json::Value& body) const
 {
    body["key"] = deviceKey_;
    body["client_id"] = pushClientId_;
-    body["session_id"] = pushSessionId_;
 #ifdef __ANDROID__
    body["platform"] = "android";
 #endif
@@ -622,16 +622,15 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
    }
    try {
        std::string err;
-        Json::Value r;
+        Json::Value root;
        auto* char_data = reinterpret_cast<const char*>(request->body().data());
        auto reader = std::unique_ptr<Json::CharReader>(jsonReaderBuilder_.newCharReader());
-        if (!reader->parse(char_data, char_data + request->body().size(), &r, &err)){
+        if (!reader->parse(char_data, char_data + request->body().size(), &root, &err)){
            auto response = initHttpResponse(
                request->create_response(restinio::status_bad_request()));
            response.set_body(RESP_MSG_JSON_INCORRECT);
            return response.done();
        }
-        const Json::Value& root(r); // parse using const Json so [] never creates element
        auto pushToken = root["key"].asString();
        if (pushToken.empty()){
            auto response = initHttpResponse(
@@ -639,12 +638,12 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
            response.set_body(RESP_MSG_NO_TOKEN);
            return response.done();
        }
-        auto isAndroid = root["platform"].asString() == "android";
-        auto clientId = root["client_id"].asString();
-        auto sessionId = root["session_id"].asString();
+        auto platform = root["platform"].asString();
+        auto isAndroid = platform == "android";
+        auto clientId = root.isMember("client_id") ? root["client_id"].asString() : std::string();

        if (logger_)
-            logger_->d("[proxy:server] [subscribe %s] [client %s] [session %s]", infoHash.toString().c_str(), clientId.c_str(), sessionId.c_str());
+            logger_->d("[proxy:server] [subscribe %s] [client %s]", infoHash.toString().c_str(), clientId.c_str());
        // ================ Search for existing listener ===================
        // start the timer
        auto timeout = std::chrono::steady_clock::now() + proxy::OP_TIMEOUT;
@@ -654,11 +653,11 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
        auto pushListener = pushListeners_.emplace(pushToken, PushListener{}).first;
        auto pushListeners = pushListener->second.listeners.emplace(infoHash, std::vector<Listener>{}).first;

-        for (auto &listener: pushListeners->second) {
+        for (auto &listener: pushListeners->second){
+            if (logger_)
+                logger_->d("[proxy:server] [subscribe] found [client %s]", listener.clientId.c_str());
            // Found -> Resubscribe
-            if (listener.clientId == clientId) {
-                if (logger_)
-                    logger_->d("[proxy:server] [subscribe] found [client %s]", listener.clientId.c_str());
+            if (listener.clientId == clientId){
                // Reset timers
                listener.expireTimer->expires_at(timeout);
                listener.expireNotifyTimer->expires_at(timeout - proxy::OP_MARGIN);
@@ -693,13 +692,12 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,

        // Add listen on dht
        listener.internalToken = dht_->listen(infoHash,
-            [this, infoHash, pushToken, isAndroid, clientId, sessionId]
+            [this, infoHash, pushToken, isAndroid, clientId]
            (const std::vector<std::shared_ptr<Value>>& values, bool expired){
                // Build message content
                Json::Value json;
                json["key"] = infoHash.toString();
                json["to"] = clientId;
-                json["s"] = sessionId;
                if (expired and values.size() < 2){
                    std::stringstream ss;
                    for(size_t i = 0; i < values.size(); ++i){
@@ -708,15 +706,12 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
                    }
                    json["exp"] = ss.str();
                }
-                auto maxPrio = 1000u;
-                for (const auto& v : values)
-                    maxPrio = std::min(maxPrio, v->priority);
-                sendPushNotification(pushToken, std::move(json), isAndroid, !expired and maxPrio == 0);
+                sendPushNotification(pushToken, std::move(json), isAndroid);
                return true;
            }
        );
        // Launch timers
-        auto& ctx = io_context();
+        auto &ctx = io_context();
        // expire notify
        if (!listener.expireNotifyTimer)
            listener.expireNotifyTimer = std::make_unique<asio::steady_timer>(ctx, timeout - proxy::OP_MARGIN);
@@ -725,9 +720,8 @@ DhtProxyServer::subscribe(restinio::request_handle_t request,
        Json::Value json;
        json["timeout"] = infoHash.toString();
        json["to"] = clientId;
-        json["s"] = sessionId;
        listener.expireNotifyTimer->async_wait(std::bind(&DhtProxyServer::handleNotifyPushListenExpire, this,
-                                               std::placeholders::_1, pushToken, std::move(json), isAndroid));
+                                               std::placeholders::_1, pushToken, json, isAndroid));
        // cancel push listen
        if (!listener.expireTimer)
            listener.expireTimer = std::make_unique<asio::steady_timer>(ctx, timeout);
@@ -808,7 +802,7 @@ DhtProxyServer::handleNotifyPushListenExpire(const asio::error_code &ec, const s
    }
    if (logger_)
        logger_->d("[proxy:server] [subscribe] sending put refresh to %s token", pushToken.c_str());
-    sendPushNotification(pushToken, std::move(json), isAndroid, false);
+    sendPushNotification(pushToken, std::move(json), isAndroid);
 }

 void
@@ -850,7 +844,7 @@ DhtProxyServer::handleCancelPushListen(const asio::error_code &ec, const std::st
 }

 void
-DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& json, bool isAndroid, bool highPriority)
+DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& json, bool isAndroid)
 {
    if (pushServer_.empty())
        return;
@@ -874,7 +868,7 @@ DhtProxyServer::sendPushNotification(const std::string& token, Json::Value&& jso
        notification["tokens"] = std::move(tokens);
        notification["platform"] = isAndroid ? 2 : 1;
        notification["data"] = std::move(json);
-        notification["priority"] = highPriority ? "high" : "normal";
+        notification["priority"] = "high";
        notification["time_to_live"] = 600;

        Json::Value notifications(Json::arrayValue);
@@ -246,7 +246,7 @@ std::time_t to_time_t(time_point t) {
 }

 Blob
-unpackBlob(const msgpack::object& o) {
+unpackBlob(msgpack::object& o) {
    switch (o.type) {
    case msgpack::type::BIN:
        return {o.via.bin.ptr, o.via.bin.ptr+o.via.bin.size};
@@ -270,25 +270,11 @@ unpackMsg(Blob b) {
 }

 msgpack::object*
-findMapValue(const msgpack::object& map, const char* key) {
+findMapValue(msgpack::object& map, const std::string& key) {
    if (map.type != msgpack::type::MAP) throw msgpack::type_error();
    for (unsigned i = 0; i < map.via.map.size; i++) {
        auto& o = map.via.map.ptr[i];
-        if (o.key.type == msgpack::type::STR 
-            && std::strncmp(o.key.via.str.ptr, key, o.key.via.str.size) == 0)
-            return &o.val;
-    }
-    return nullptr;
-}
-
-msgpack::object*
-findMapValue(const msgpack::object& map, const std::string& key) {
-    if (map.type != msgpack::type::MAP) throw msgpack::type_error();
-    for (unsigned i = 0; i < map.via.map.size; i++) {
-        auto& o = map.via.map.ptr[i];
-        if (o.key.type == msgpack::type::STR 
-            && key.size() == o.key.via.str.size
-            && std::strncmp(o.key.via.str.ptr, key.data(), o.key.via.str.size) == 0)
+        if (o.key.type == msgpack::type::STR && o.key.as<std::string>() == key)
            return &o.val;
    }
    return nullptr;
@@ -22,9 +22,12 @@
 #endif

 #include "value.h"
-
 #include "default_types.h"
+#include "callbacks.h"
+
+#ifndef OPENDHT_LIGHT
 #include "securedht.h" // print certificate ID
+#endif

 #ifdef OPENDHT_JSONCPP
 #include "base64.h"
@@ -42,6 +45,46 @@ Value::Filter bindFilterRaw(FilterRaw raw_filter, void* user_data) {
    };
 }

+#ifndef OPENDHT_LIGHT
+Value::Filter
+Value::OwnerFilter(const crypto::PublicKey& pk) {
+    return OwnerFilter(pk.getId());
+}
+
+
+Value::Filter
+Value::OwnerFilter(const InfoHash& pkh) {
+    return [pkh](const Value& v) {
+        return v.owner and v.owner->getId() == pkh;
+    };
+}
+
+void
+Value::sign(const crypto::PrivateKey& key) {
+    if (isEncrypted())
+        throw DhtException("Can't sign encrypted data.");
+    owner = std::make_shared<const crypto::PublicKey>(key.getPublicKey());
+    signature = key.sign(getToSign());
+}
+
+bool
+Value::checkSignature() const {
+    return isSigned() and owner->checkSignature(getToSign(), signature);
+}
+
+Value
+Value::encrypt(const crypto::PrivateKey& from, const crypto::PublicKey& to) {
+    if (isEncrypted())
+        throw DhtException("Data is already encrypted.");
+    setRecipient(to.getId());
+    sign(from);
+    Value nv {id};
+    nv.setCypher(to.encrypt(getToEncrypt()));
+    return nv;
+}
+
+#endif
+
 std::ostream& operator<< (std::ostream& s, const Value& v)
 {
    auto flags(s.flags());
@@ -56,7 +99,9 @@ std::ostream& operator<< (std::ostream& s, const Value& v)
    if (not v.isEncrypted()) {
        if (v.type == IpServiceAnnouncement::TYPE.id) {
            s << IpServiceAnnouncement(v.data);
-        } else if (v.type == CERTIFICATE_TYPE.id) {
+        }
+#ifndef OPENDHT_LIGHT
+        else if (v.type == CERTIFICATE_TYPE.id) {
            s << "Certificate";
 #ifdef OPENDHT_LOG_CRT_ID
            try {
@@ -66,7 +111,9 @@ std::ostream& operator<< (std::ostream& s, const Value& v)
                s << " (invalid)";
            }
 #endif
-        } else {
+        }
+#endif
+        else {
            s << "Data (type: " << v.type << " ): ";
            s << std::hex;
            for (auto i : v.data)
@@ -87,6 +134,20 @@ ValueType::DEFAULT_STORE_POLICY(InfoHash, const std::shared_ptr<Value>& v, const
    return v->size() <= MAX_VALUE_SIZE;
 }

+msgpack::object*
+findMapValue(const msgpack::object& map, const std::string& key) {
+    if (map.type != msgpack::type::MAP) throw msgpack::type_error();
+    for (unsigned i = 0; i < map.via.map.size; i++) {
+        auto& o = map.via.map.ptr[i];
+        if(o.key.type != msgpack::type::STR)
+            continue;
+        if (o.key.as<std::string>() == key) {
+            return &o.val;
+        }
+    }
+    return nullptr;
+}
+
 size_t
 Value::size() const
 {
@@ -94,24 +155,20 @@ Value::size() const
 }

 void
-Value::msgpack_unpack(const msgpack::object& o)
+Value::msgpack_unpack(msgpack::object o)
 {
-    if (o.type != msgpack::type::MAP or o.via.map.size < 2)
-        throw msgpack::type_error();
+    if (o.type != msgpack::type::MAP) throw msgpack::type_error();
+    if (o.via.map.size < 2) throw msgpack::type_error();

-    if (auto rid = findMapValue(o, VALUE_KEY_ID)) {
+    if (auto rid = findMapValue(o, "id")) {
        id = rid->as<Id>();
    } else
        throw msgpack::type_error();

-    if (auto rdat = findMapValue(o, VALUE_KEY_DAT)) {
+    if (auto rdat = findMapValue(o, "dat")) {
        msgpack_unpack_body(*rdat);
    } else
        throw msgpack::type_error();
-
-    if (auto rprio = findMapValue(o, VALUE_KEY_PRIO)) {
-        priority = rprio->as<unsigned>();
-    }
 }

 void
@@ -130,37 +187,40 @@ Value::msgpack_unpack_body(const msgpack::object& o)
    } else {
        if (o.type != msgpack::type::MAP)
            throw msgpack::type_error();
-        auto rbody = findMapValue(o, VALUE_KEY_BODY);
+        auto rbody = findMapValue(o, "body");
        if (not rbody)
            throw msgpack::type_error();

-        if (auto rdata = findMapValue(*rbody, VALUE_KEY_DATA)) {
+        if (auto rdata = findMapValue(*rbody, "data")) {
            data = unpackBlob(*rdata);
        } else
            throw msgpack::type_error();

-        if (auto rtype = findMapValue(*rbody, VALUE_KEY_TYPE)) {
+        if (auto rtype = findMapValue(*rbody, "type")) {
            type = rtype->as<ValueType::Id>();
        } else
            throw msgpack::type_error();

-        if (auto rutype = findMapValue(*rbody, VALUE_KEY_USERTYPE)) {
+        if (auto rutype = findMapValue(*rbody, "utype")) {
            user_type = rutype->as<std::string>();
        }

-        if (auto rowner = findMapValue(*rbody, VALUE_KEY_OWNER)) {
-            if (auto rseq = findMapValue(*rbody, VALUE_KEY_SEQ))
+        if (auto rowner = findMapValue(*rbody, "owner")) {
+            if (auto rseq = findMapValue(*rbody, "seq"))
                seq = rseq->as<decltype(seq)>();
            else
                throw msgpack::type_error();
+
+#ifndef OPENDHT_LIGHT
            crypto::PublicKey new_owner;
            new_owner.msgpack_unpack(*rowner);
            owner = std::make_shared<const crypto::PublicKey>(std::move(new_owner));
-            if (auto rrecipient = findMapValue(*rbody, VALUE_KEY_TO)) {
+#endif
+            if (auto rrecipient = findMapValue(*rbody, "to")) {
                recipient = rrecipient->as<InfoHash>();
            }

-            if (auto rsig = findMapValue(o, VALUE_KEY_SIGNATURE)) {
+            if (auto rsig = findMapValue(o, "sig")) {
                signature = unpackBlob(*rsig);
            } else
                throw msgpack::type_error();
@@ -169,65 +229,65 @@ Value::msgpack_unpack_body(const msgpack::object& o)
 }

 #ifdef OPENDHT_JSONCPP
-Value::Value(const Json::Value& json)
+Value::Value(Json::Value& json)
 {
-    id = Value::Id(unpackId(json, VALUE_KEY_ID));
-    const auto& jcypher = json["cypher"];
-    if (jcypher.isString())
-        cypher = base64_decode(jcypher.asString());
-    const auto& jsig = json[VALUE_KEY_SIGNATURE];
-    if (jsig.isString())
-        signature = base64_decode(jsig.asString());
-    const auto& jseq = json[VALUE_KEY_SEQ];
-    if (!jseq.isNull())
-        seq = jseq.asInt();
-    const auto& jowner = json[VALUE_KEY_OWNER];
-    if (jowner.isString()) {
-        auto ownerStr = jowner.asString();
+    id = Value::Id(unpackId(json, "id"));
+    if (json.isMember("cypher")) {
+        auto cypherStr = json["cypher"].asString();
+        cypherStr = base64_decode(cypherStr);
+        cypher = std::vector<unsigned char>(cypherStr.begin(), cypherStr.end());
+    }
+    if (json.isMember("sig")) {
+        auto sigStr = json["sig"].asString();
+        sigStr = base64_decode(sigStr);
+        signature = std::vector<unsigned char>(sigStr.begin(), sigStr.end());
+    }
+    if (json.isMember("seq"))
+        seq = json["seq"].asInt();
+#ifndef OPENDHT_LIGHT
+    if (json.isMember("owner")) {
+        auto ownerStr = json["owner"].asString();
        auto ownerBlob = std::vector<unsigned char>(ownerStr.begin(), ownerStr.end());
        owner = std::make_shared<const crypto::PublicKey>(ownerBlob);
    }
-    const auto& jto = json[VALUE_KEY_TO];
-    if (jto.isString())
-        recipient = InfoHash(jto.asString());
-    const auto& jtype = json[VALUE_KEY_TYPE];
-    if (!jtype.isNull())
-        type = jtype.asInt();
-    const auto& jdata = json[VALUE_KEY_DATA];
-    if (jdata.isString())
-        data = base64_decode(jdata.asString());
-    const auto& jutype = json[VALUE_KEY_USERTYPE];
-    if (jutype.isString())
-        user_type = jutype.asString();
-    const auto& jprio = json["prio"];
-    if (jprio.isIntegral())
-        priority = jprio.asUInt();
+#endif
+    if (json.isMember("to")) {
+        auto toStr = json["to"].asString();
+        recipient = InfoHash(toStr);
+    }
+    if (json.isMember("type"))
+        type = json["type"].asInt();
+    if (json.isMember("data")){
+        auto dataStr = json["data"].asString();
+        dataStr = base64_decode(dataStr);
+        data = std::vector<unsigned char>(dataStr.begin(), dataStr.end());
+    }
+    if (json.isMember("utype"))
+        user_type = json["utype"].asString();
 }

 Json::Value
 Value::toJson() const
 {
    Json::Value val;
-    val[VALUE_KEY_ID] = std::to_string(id);
+    val["id"] = std::to_string(id);
    if (isEncrypted()) {
        val["cypher"] = base64_encode(cypher);
    } else {
        if (isSigned())
-            val[VALUE_KEY_SIGNATURE] = base64_encode(signature);
+            val["sig"] = base64_encode(signature);
        bool has_owner = owner && *owner;
        if (has_owner) { // isSigned
-            val[VALUE_KEY_SEQ] = seq;
-            val[VALUE_KEY_OWNER] = owner->toString();
+            val["seq"] = seq;
+            val["owner"] = owner->toString();
            if (recipient)
-                val[VALUE_KEY_TO] = recipient.toString();
+                val["to"] = recipient.toString();
        }
-        val[VALUE_KEY_TYPE] = type;
-        val[VALUE_KEY_DATA] = base64_encode(data);
+        val["type"] = type;
+        val["data"] = base64_encode(data);
        if (not user_type.empty())
-            val[VALUE_KEY_USERTYPE] = user_type;
+            val["utype"] = user_type;
    }
-    if (priority)
-        val["prio"] = priority;
    return val;
 }

@@ -235,11 +295,13 @@ uint64_t
 unpackId(const Json::Value& json, const std::string& key) {
    uint64_t ret = 0;
    try {
-        const auto& t = json[key];
-        if (t.isString()) {
-            ret = std::stoull(t.asString());
-        } else {
-            ret = t.asLargestUInt();
+        if (json.isMember(key)) {
+            const auto& t = json[key];
+            if (t.isString()) {
+                ret = std::stoull(t.asString());
+            } else {
+                ret = t.asLargestUInt();
+            }
        }
    } catch (...) {}
    return ret;
@@ -308,9 +370,11 @@ FieldValueIndex::FieldValueIndex(const Value& v, const Select& s)
            case Value::Field::ValueType:
                index[f] = {f, v.type};
                break;
+#ifndef OPENDHT_LIGHT
            case Value::Field::OwnerPk:
                index[f] = {f, v.owner ? v.owner->getId() : InfoHash() };
                break;
+#endif
            case Value::Field::SeqNum:
                index[f] = {f, v.seq};
                break;
@@ -409,13 +473,13 @@ Select::Select(const std::string& q_str) {

        while (std::getline(fields, token, ',')) {
            trim_str(token);
-            if (token == VALUE_KEY_ID)
+            if (token == "id")
                field(Value::Field::Id);
            else if (token == "value_type")
                field(Value::Field::ValueType);
            else if (token == "owner_pk")
                field(Value::Field::OwnerPk);
-            if (token == VALUE_KEY_SEQ)
+            if (token == "seq")
                field(Value::Field::SeqNum);
            else if (token == "user_type")
                field(Value::Field::UserType);
@@ -451,13 +515,13 @@ Where::Where(const std::string& q_str) {
                    s = value_str.substr(1, value_str.size()-2);
                else
                    s = value_str;
-                if (field_str == VALUE_KEY_ID)
+                if (field_str == "id")
                    id(v);
                else if (field_str == "value_type")
                    valueType(v);
                else if (field_str == "owner_pk")
                    owner(InfoHash(s));
-                else if (field_str == VALUE_KEY_SEQ)
+                else if (field_str == "seq")
                    seq(v);
                else if (field_str == "user_type")
                    userType(s);
@@ -517,7 +581,7 @@ std::ostream& operator<<(std::ostream& s, const dht::Select& select) {
    for (auto fs = select.fieldSelection_.begin() ; fs != select.fieldSelection_.end() ; ++fs) {
        switch (*fs) {
            case Value::Field::Id:
-                s << VALUE_KEY_ID;
+                s << "id";
                break;
            case Value::Field::ValueType:
                s << "value_type";
@@ -529,7 +593,7 @@ std::ostream& operator<<(std::ostream& s, const dht::Select& select) {
                s << "owner_public_key";
                break;
            case Value::Field::SeqNum:
-                s << VALUE_KEY_SEQ;
+                s << "seq";
                break;
            default:
                break;