Replace opendht with sibs pubsub

This should fix issues with memory usage/leaks and make it easier
to get peers subscribed to the same key.
It will also be easier to modify and also works easier cross platform
because of no additional dependencies.

1 files changed, 8 insertions, 61 deletions

diff --git a/src/DatabaseStorage.cpp b/src/DatabaseStorage.cpp
index 9398254..14b74e8 100644
--- a/src/DatabaseStorage.cpp
+++ b/src/DatabaseStorage.cpp
@@ -158,18 +158,6 @@ namespace odhtdb
             metadataSerializer.add(STORAGE_VERSION);
             randombytes_buf(passwordSalt, PASSWORD_SALT_LEN);
             metadataSerializer.add(passwordSalt, PASSWORD_SALT_LEN);
-            
-            identity = dht::crypto::generateIdentity();
-            dht::Blob privateKeyData = identity.first->serialize();
-            metadataSerializer.add((u16)privateKeyData.size());
-            metadataSerializer.add(privateKeyData.data(), privateKeyData.size());
-
-            dht::Blob certificateData;
-            identity.second->pack(certificateData);
-            metadataSerializer.add((u16)certificateData.size());
-            metadataSerializer.add(certificateData.data(), certificateData.size());
-            
-            fileAppend(metadataFilePath, { metadataSerializer.getBuffer().data(), metadataSerializer.getBuffer().size() });
         }
         catch(sibs::DeserializeException &e)
         {
@@ -335,37 +323,13 @@ namespace odhtdb
             throw std::runtime_error("Wrong storage version!");
         
         deserializer.extract(passwordSalt, PASSWORD_SALT_LEN);
-        
-        u16 privateKeySize = deserializer.extract<u16>();
-        dht::Blob privateKeyRaw;
-        privateKeyRaw.resize(privateKeySize);
-        deserializer.extract(&privateKeyRaw[0], privateKeySize);
-        identity.first = make_shared<dht::crypto::PrivateKey>(privateKeyRaw);
-        
-        u16 certificateSize = deserializer.extract<u16>();
-        dht::Blob certificateRaw;
-        certificateRaw.resize(certificateSize);
-        deserializer.extract(&certificateRaw[0], certificateSize);
-        identity.second = make_shared<dht::crypto::Certificate>(certificateRaw);
-        
         assert(deserializer.empty());
     }
     
     void DatabaseStorage::loadRemoteNodesFromFile()
     {
         OwnedByteArray remoteNodesFileContent = fileGetContent(remoteNodesFilePath);
-        msgpack::unpacker pac;
-        pac.reserve_buffer(remoteNodesFileContent.size);
-        memcpy(pac.buffer(), remoteNodesFileContent.data, remoteNodesFileContent.size);
-        pac.buffer_consumed(remoteNodesFileContent.size);
-        
-        msgpack::object_handle oh;
-        while(pac.next(oh))
-        {
-            auto importedNodes = oh.get().as<vector<dht::NodeExport>>();
-            remoteNodes.reserve(remoteNodes.size() + importedNodes.size());
-            remoteNodes.insert(remoteNodes.end(), importedNodes.begin(), importedNodes.end());
-        }
+        remotePeers = sibs::DirectConnectionsUtils::deserializePeers(remoteNodesFileContent.data, remoteNodesFileContent.size);
     }
     
     static void sqlite_step_throw_on_failure(sqlite3 *db, sqlite3_stmt *stmt, const char *description)
@@ -1025,29 +989,17 @@ namespace odhtdb
             decryptNodeData(nodeHash, nodeDecryptionKeyResult.second);
     }
     
-    struct RemoteNodePacker
+    const vector<std::shared_ptr<sibs::DirectConnectionPeer>>& DatabaseStorage::getRemotePeers() const
     {
-        sibs::SafeSerializer serializer;
-        
-        RemoteNodePacker& write(const char *data, size_t size)
-        {
-            serializer.add((const u8*)data, size);
-            return *this;
-        }
-    };
-    
-    const vector<dht::NodeExport>& DatabaseStorage::getRemoteNodes() const
-    {
-        return remoteNodes;
+        return remotePeers;
     }
     
-    void DatabaseStorage::setRemoteNodes(const std::vector<dht::NodeExport> &remoteNodes)
+    void DatabaseStorage::setRemotePeers(const std::vector<std::shared_ptr<sibs::DirectConnectionPeer>> &remotePeers)
     {
-        Log::debug("Storing %u remote nodes", remoteNodes.size());
-        this->remoteNodes = remoteNodes;
-        RemoteNodePacker remoteNodePacker;
-        msgpack::pack(remoteNodePacker, remoteNodes);
-        fileOverwrite(remoteNodesFilePath, DataView(remoteNodePacker.serializer.getBuffer().data(), remoteNodePacker.serializer.getBuffer().size()));
+        Log::debug("Storing %u remote peers", remotePeers.size());
+        this->remotePeers = remotePeers;
+        std::vector<u8> serializedPeers = sibs::DirectConnectionsUtils::serializePeers(remotePeers);
+        fileOverwrite(remoteNodesFilePath, DataView(serializedPeers.data(), serializedPeers.size()));
     }
     
     vector<OwnedByteArray> DatabaseStorage::getUserGroups(const Hash &nodeHash, const Signature::PublicKey &userPublicKey) const
@@ -1292,11 +1244,6 @@ namespace odhtdb
         return true;
     }
     
-    const dht::crypto::Identity& DatabaseStorage::getIdentity() const
-    {
-        return identity;
-    }
-    
     void DatabaseStorage::update()
     {
         auto time = chrono::high_resolution_clock::now().time_since_epoch();