WIP OMEMO TrustDb/JidDb

1 files changed, 29 insertions, 310 deletions

diff --git a/omemo_db.cpp b/omemo_db.cpp
index bc8751b..c1949c0 100644
--- a/omemo_db.cpp
+++ b/omemo_db.cpp
@@ -1,374 +1,93 @@
 #include "omemo_db.h"
 #include <QXmppConfiguration.h>
 #include <QXmppFutureUtils_p.h>
-#include <QXmppPromise.h>
-#include <qt5keychain/keychain.h>
-#include <QEventLoop>
-#include <QtConcurrent>
 #include <QString>
 #include <iostream>
 #include <optional>
 
-static const QString service_ns = "xxcc/omemo/";
+static const QString service = "xxcc", key_namespace = "omemo";
 
-OmemoDb::OmemoDb(const QString &jid) :
-    jid(jid)
+OmemoDb::OmemoDb(const JidDb &db) :
+    db(db)
 {
 }
 
-QString OmemoDb::service() const
-{
-    return service_ns + jid;
-}
-
 QXmppTask<QXmppOmemoStorage::OmemoData> OmemoDb::allData()
 {
-    return QXmpp::Private::makeReadyTask(QXmppOmemoStorage::OmemoData());
-}
-
-int OmemoDb::storeOwnKeyId(const QString &service, const uint32_t id)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/keyid");
-    job.setTextData(QString::number(id, 16));
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store own key ID: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storePrivateIdentityKey(const QString &service,
-    const QByteArray &privateIdentityKey)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/privateIdentityKey");
-    job.setBinaryData(privateIdentityKey);
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store private identity key: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storePublicIdentityKey(const QString &service,
-    const QByteArray &publicIdentityKey)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/publicIdentityKey");
-    job.setBinaryData(publicIdentityKey);
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store public identity key: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storeLatestSignedPreKeyId(const QString &service,
-    const uint32_t latestSignedPreKeyId)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/latestSignedPreKeyId");
-    job.setTextData(QString::number(latestSignedPreKeyId, 16));
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store latest signed prekey ID: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storeLatestPreKeyId(const QString &service,
-    const uint32_t latestPreKeyId)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
+    QXmppOmemoStorage::OmemoData ret;
+    QHash<QString, QHash<uint32_t, Device>> devices;
 
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/latestPreKeyId");
-    job.setTextData(QString::number(latestPreKeyId, 16));
-    job.start();
-    loop.exec();
+    for (const auto &d : db.omemoDevices())
+        ret.devices.insert(d.jid, d.devices);
 
-    if (job.error())
-    {
-        std::cerr << "Failed to store latest prekey ID: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
+    ret.ownDevice = db.omemoOwnDevice();
+    ret.preKeyPairs = db.preKeyPairs();
+    ret.signedPreKeyPairs = db.signedPreKeyPairs();
+    return QXmpp::Private::makeReadyTask(QXmppOmemoStorage::OmemoData(ret));
 }
 
 QXmppTask<void> OmemoDb::setOwnDevice(const std::optional<OwnDevice> &device)
 {
-    if (!device.has_value())
-        return QXmpp::Private::makeReadyTask();
-
-    QXmppPromise<void> promise;
-
-    auto future = QtConcurrent::run(
-    [=] () mutable
-    {
-        const auto &d = device.value();
-        const auto srv = service();
-
-        storeDeviceLabel(srv, d.label)
-            || storeOwnKeyId(srv, d.id)
-            || storePrivateIdentityKey(srv, d.privateIdentityKey)
-            || storePublicIdentityKey(srv, d.publicIdentityKey)
-            || storeLatestSignedPreKeyId(srv, d.latestSignedPreKeyId)
-            || storeLatestPreKeyId(srv, d.latestPreKeyId);
-
-        promise.finish();
-    });
+    if (device.has_value() && db.store(device.value()))
+        std::cerr << "db.store failed" << std::endl;
 
-    return promise.task();
+    return QXmpp::Private::makeReadyTask();
 }
 
 QXmppTask<void> OmemoDb::addSignedPreKeyPair(const uint32_t keyId,
     const SignedPreKeyPair &keyPair)
 {
+    if (db.store(keyId, keyPair))
+        std::cerr << "db.store failed" << std::endl;
+
     return QXmpp::Private::makeReadyTask();
 }
 
 QXmppTask<void> OmemoDb::removeSignedPreKeyPair(uint32_t keyId)
 {
+    db.removeSignedPreKeyPair(keyId);
     return QXmpp::Private::makeReadyTask();
 }
 
 QXmppTask<void> OmemoDb::addPreKeyPairs(
         const QHash<uint32_t, QByteArray> &keyPairs)
 {
+    if (db.store(keyPairs))
+        std::cerr << "db.store failed" << std::endl;
+
     return QXmpp::Private::makeReadyTask();
 }
 
 QXmppTask<void> OmemoDb::removePreKeyPair(const uint32_t keyId)
 {
+    db.removePreKeyPair(keyId);
     return QXmpp::Private::makeReadyTask();
 }
 
-int OmemoDb::storeDeviceLabel(const QString &service, const QString &label)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/label");
-    job.setTextData(label);
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store device label: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storeKeyId(const QString &service, const QByteArray &keyId)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/key_id");
-    job.setBinaryData(keyId);
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store device keyID: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storeSession(const QString &service, const QByteArray &session)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/session");
-    job.setBinaryData(session);
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store device session: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storeUnrespondedSentStanzasCount(const QString &service,
-    const int count)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/unresponded_sent_stanzas");
-    job.setTextData(QString::number(count));
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store device unresponded sent stanzas: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storeUnrespondedReceivedStanzasCount(const QString &service,
-    const int count)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/unresponded_received_stanzas");
-    job.setTextData(QString::number(count));
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store device unresponded received stanzas: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
-int OmemoDb::storeRemovalFromDeviceListDate(const QString &service,
-    const QDateTime &dt)
-{
-    QKeychain::WritePasswordJob job(service);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/unresponded_received_stanzas");
-    job.setTextData(QString::number(dt.currentMSecsSinceEpoch()));
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store device unresponded received stanzas: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-}
-
 QXmppTask<void> OmemoDb::addDevice(const QString &jid,
-    const uint32_t deviceId, const Device &device)
+    const uint32_t deviceId, const Device &d)
 {
-    const QString fullservice = service_ns + jid;
-    QXmppPromise<void> promise;
-
-    auto future = QtConcurrent::run(
-    [=] () mutable
-    {
-        storeDeviceLabel(fullservice, device.label)
-            || storeKeyId(fullservice, device.keyId)
-            || storeSession(fullservice, device.session)
-            || storeUnrespondedSentStanzasCount(fullservice,
-                device.unrespondedSentStanzasCount)
-            || storeUnrespondedReceivedStanzasCount(fullservice,
-                device.unrespondedSentStanzasCount)
-            || storeRemovalFromDeviceListDate(fullservice,
-                device.removalFromDeviceListDate);
+    if (db.store(jid, deviceId, d))
+        std::cerr << "db.store failed" << std::endl;
 
-        promise.finish();
-    });
-
-    return promise.task();
+    return QXmpp::Private::makeReadyTask();
 }
 
 QXmppTask<void> OmemoDb::removeDevice(const QString &jid,
     const uint32_t deviceId)
 {
-#if 0
-    const QString fullservice = service_ns + jid;
-    QKeychain::DeletePasswordJob job(fullservice);
-    QEventLoop loop;
-
-    loop.connect(&job, &QKeychain::Job::finished, &loop, &QEventLoop::quit);
-    job.setKey("device/unresponded_received_stanzas");
-    job.setTextData(QString::number(dt.currentMSecsSinceEpoch()));
-    job.start();
-    loop.exec();
-
-    if (job.error())
-    {
-        std::cerr << "Failed to store device unresponded received stanzas: "
-            << qPrintable(job.errorString()) << std::endl;
-        return -1;
-    }
-
-    return 0;
-#endif
+    db.removeOmemoDevice(jid, deviceId);
     return QXmpp::Private::makeReadyTask();
 }
 
 QXmppTask<void> OmemoDb::removeDevices(const QString &jid)
 {
+    db.removeOmemoDevices(jid);
     return QXmpp::Private::makeReadyTask();
 }
 
 QXmppTask<void> OmemoDb::resetAll()
 {
+    db.removeOmemo();
     return QXmpp::Private::makeReadyTask();
 }