bash-tech/squawk
1
0
Fork 0
forked from blue/squawk
Code Pull requests Activity

Some work on omemo handler, NOT DONE, BUILD FAILS!

Browse source
This commit is contained in:
Blue 2022-12-15 02:08:08 +03:00
parent 820dc845ea
commit 0b61b6e928
Signed by untrusted user: blue
GPG key ID: 9B203B252A63EE38
7 changed files with 187 additions and 12 deletions
Download patch file Download diff file Expand all files Collapse all files

144
core/handlers/omemohandler.cpp
View file

@ -14,4 +14,148 @@
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include <QDebug>
#include "omemohandler.h"
#include "core/account.h"
Core::OmemoHandler::OmemoHandler(Account* account) :
QXmppOmemoStorage(),
acc(account),
ownDevice(std::nullopt),
db("omemo"),
meta(db.addCache<QString, QVariant>("meta")),
devices(db.addCache<QString, QHash<uint32_t, Device>>("devices")),
preKeyPairs(db.addCache<uint32_t, QByteArray>("preKeyPairs")),
signedPreKeyPairs(db.addCache<uint32_t, QXmppOmemoStorage::SignedPreKeyPair>("signedPreKeyPairs"))
{
db.open();
try {
QVariant own = meta->getRecord("ownDevice");
ownDevice.value() = own.value<OwnDevice>();
qDebug() << "Successfully found own device omemo data for account" << acc->getName();
} catch (const DataBase::NotFound& e) {
qDebug() << "No device omemo data was found for account" << acc->getName();
}
}
Core::OmemoHandler::~OmemoHandler() {
db.close();
}
QFuture<void> Core::OmemoHandler::emptyVoidFuture() {
QFutureInterface<QXmppOmemoStorage::OmemoData> result(QFutureInterfaceBase::Started);
result.reportFinished();
return result.future();
}
QFuture<QXmppOmemoStorage::OmemoData> Core::OmemoHandler::allData() {
OmemoData data;
data.ownDevice = ownDevice;
std::map<uint32_t, QByteArray> pkeys = preKeyPairs->readAll();
for (const std::pair<const uint32_t, QByteArray>& pair : pkeys) {
data.preKeyPairs.insert(pair.first, pair.second);
}
std::map<uint32_t, QXmppOmemoStorage::SignedPreKeyPair> spre = signedPreKeyPairs->readAll();
for (const std::pair<const uint32_t, QXmppOmemoStorage::SignedPreKeyPair>& pair : spre) {
data.signedPreKeyPairs.insert(pair.first, pair.second);
}
std::map<QString, QHash<uint32_t, Device>> devs = devices->readAll();
for (const std::pair<const QString, QHash<uint32_t, Device>>& pair : devs) {
data.devices.insert(pair.first, pair.second);
}
QFutureInterface<QXmppOmemoStorage::OmemoData> result(QFutureInterfaceBase::Started);
result.reportResult(std::move(data));
result.reportFinished();
return result.future();
}
QFuture<void> Core::OmemoHandler::addDevice(const QString& jid, uint32_t deviceId, const QXmppOmemoStorage::Device& device) {
QHash<uint32_t, Device> devs;
bool had = true;
try {
devs = devices->getRecord(jid);
} catch (const DataBase::NotFound& error) {
had = false;
}
devs.insert(deviceId, device);
if (had) {
devices->changeRecord(jid, devs);
} else {
devices->addRecord(jid, devs);
}
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::addPreKeyPairs(const QHash<uint32_t, QByteArray>& keyPairs) {
for (QHash<uint32_t, QByteArray>::const_iterator itr = keyPairs.begin(), end = keyPairs.end(); itr != end; ++itr) {
preKeyPairs->forceRecord(itr.key(), itr.value());
}
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::addSignedPreKeyPair(uint32_t keyId, const QXmppOmemoStorage::SignedPreKeyPair& keyPair) {
signedPreKeyPairs->addRecord(keyId, keyPair);
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::removeDevice(const QString& jid, uint32_t deviceId) {
QHash<uint32_t, Device> devs = devices->getRecord(jid);
devs.remove(deviceId);
if (devs.isEmpty()) {
devices->removeRecord(jid);
} else {
devices->changeRecord(jid, devs);
}
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::removeDevices(const QString& jid) {
devices->removeRecord(jid);
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::removePreKeyPair(uint32_t keyId) {
preKeyPairs->removeRecord(keyId);
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::removeSignedPreKeyPair(uint32_t keyId) {
signedPreKeyPairs->removeRecord(keyId);
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::setOwnDevice(const std::optional<OwnDevice>& device) {
bool had = ownDevice.has_value();
ownDevice = device;
if (ownDevice.has_value()) {
if (had) {
meta->changeRecord("ownDevice", QVariant::fromValue(ownDevice.value()));
} else {
meta->addRecord("ownDevice", QVariant::fromValue(ownDevice.value()));
}
} else {
if (had) {
meta->removeRecord("ownDevice");
}
}
return emptyVoidFuture();
}
QFuture<void> Core::OmemoHandler::resetAll() {
ownDevice = std::nullopt;
db.drop();
return emptyVoidFuture();
}

28
core/handlers/omemohandler.h
View file

@ -18,14 +18,17 @@
#define CORE_OMEMOHANDLER_H
#include <QXmppOmemoStorage.h>
#include <core/storage/cache.h>
#include <cache.h>
Q_DECLARE_METATYPE(QXmppOmemoStorage::OwnDevice);
namespace Core {
class Account;
class OmemoHandler : public QXmppOmemoStorage
{
public:
OmemoHandler();
OmemoHandler(Account* account);
~OmemoHandler() override;
QFuture<OmemoData> allData() override;
@ -45,13 +48,24 @@ public:
QFuture<void> resetAll() override;
private:
static QFuture<void> emptyVoidFuture();
private:
Account* acc;
std::optional<OwnDevice> ownDevice;
Cache<QString, QHash<uint32_t, Device>> devices;
Cache<uint32_t, QByteArray> preKeyPairs;
Cache<uint32_t, QXmppOmemoStorage::SignedPreKeyPair> signedPreKeyPairs;
DataBase db;
DataBase::Cache<QString, QVariant>* meta;
DataBase::Cache<QString, QHash<uint32_t, Device>>* devices;
DataBase::Cache<uint32_t, QByteArray>* preKeyPairs;
DataBase::Cache<uint32_t, QXmppOmemoStorage::SignedPreKeyPair>* signedPreKeyPairs;
};
}
QDataStream& operator << (QDataStream &out, const QXmppOmemoStorage::Device& device);
QDataStream& operator >> (QDataStream &out, QXmppOmemoStorage::Device device);
QDataStream& operator << (QDataStream &out, const QXmppOmemoStorage::SignedPreKeyPair& device);
QDataStream& operator >> (QDataStream &out, QXmppOmemoStorage::SignedPreKeyPair device);
#endif // CORE_OMEMOHANDLER_H