File indexing completed on 2024-04-21 04:43:51

 /*
  * Copyright (C) 2003-2008  Justin Karneges <justin@affinix.com>
  * Copyright (C) 2004,2005  Brad Hards <bradh@frogmouth.net>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301  USA
  *
  */
 
 #include "qca_keystore.h"
 
 #include <QAbstractEventDispatcher>
 #include <QCoreApplication>
 #include <QMutex>
 #include <QPointer>
 #include <QSet>
 #include <QWaitCondition>
 
 #include <cstdio>  // fprintf
 #include <cstdlib> // abort
 
 #include "qcaprovider.h"
 
 Q_DECLARE_METATYPE(QCA::KeyStoreEntry)
 Q_DECLARE_METATYPE(QList<QCA::KeyStoreEntry>)
 Q_DECLARE_METATYPE(QList<QCA::KeyStoreEntry::Type>)
 Q_DECLARE_METATYPE(QCA::KeyBundle)
 Q_DECLARE_METATYPE(QCA::Certificate)
 Q_DECLARE_METATYPE(QCA::CRL)
 Q_DECLARE_METATYPE(QCA::PGPKey)
 
 namespace QCA {
 
 Provider::Context *getContext(const QString &type, Provider *p);
 
 // from qca_plugin.cpp
 QString truncate_log(const QString &in, int size);
 
 /*
   How this stuff works:
 
   KeyStoreListContext is queried for a list of store context ids.  A signal
   is used to indicate when the list may have changed, so polling for changes
   is not necessary.  Context ids change for every new presence of a store.
   Even if a user removes and inserts the same smart card device, which has
   the same storeId, the context id will ALWAYS be different.  If a previously
   known context id is missing from a later queried list, then it means the
   associated store is unavailable.  It is recommended that the provider just
   use a counter for the contextId, incrementing the value anytime a new
   context is made.
 
   KeyStoreTracker manages all of the keystore stuff, and exists in its own
   thread (called the tracker thread).  All of the KeyStoreListContext
   objects exist in the tracker thread.
 */
 
 /*
   scenarios to handle:
   - ksm.start shouldn't block
   - keystore in available list, but gone by the time it is requested
   - keystore is unavailable during a call to a keystoreentry method
   - keystore/keystoreentry methods called simultaneously from different threads
   - and of course, objects from keystores should work, despite being created
     in the keystore thread
 */
 
 //----------------------------------------------------------------------------
 // KeyStoreTracker
 //----------------------------------------------------------------------------
 static int tracker_id_at = 0;
 
 class KeyStoreTracker : public QObject
 {
     Q_OBJECT
 public:
     static KeyStoreTracker *self;
 
     class Item
     {
     public:
         // combine keystore owner and contextid into a single id
         int trackerId;
 
         // number of times the keystore has been updated
         int updateCount;
 
         // keystore context
         KeyStoreListContext *owner;
         int                  storeContextId;
 
         // properties
         QString        storeId;
         QString        name;
         KeyStore::Type type;
         bool           isReadOnly;
 
         Item()
             : trackerId(-1)
             , updateCount(0)
             , owner(nullptr)
             , storeContextId(-1)
             , storeId(QLatin1String(""))
             , name(QLatin1String(""))
             , type(KeyStore::System)
             , isReadOnly(false)
         {
         }
     };
 
     QMutex                      m;
     QSet<KeyStoreListContext *> sources;
     QSet<KeyStoreListContext *> busySources;
     QList<Item>                 items;
     QString                     dtext;
     bool                        startedAll;
     bool                        busy;
 
     QMutex updateMutex;
 
     KeyStoreTracker()
     {
         self = this;
 
         qRegisterMetaType<KeyStoreEntry>();
         qRegisterMetaType<QList<KeyStoreEntry>>();
         qRegisterMetaType<QList<KeyStoreEntry::Type>>();
         qRegisterMetaType<KeyBundle>();
         qRegisterMetaType<Certificate>();
         qRegisterMetaType<CRL>();
         qRegisterMetaType<PGPKey>();
 
         connect(this, &KeyStoreTracker::updated_p, this, &KeyStoreTracker::updated_locked, Qt::QueuedConnection);
 
         startedAll = false;
         busy       = true; // we start out busy
     }
 
     ~KeyStoreTracker() override
     {
         qDeleteAll(sources);
         self = nullptr;
     }
 
     static KeyStoreTracker *instance()
     {
         return self;
     }
 
     // thread-safe
     bool isBusy()
     {
         QMutexLocker locker(&m);
         return busy;
     }
 
     // thread-safe
     QList<Item> getItems()
     {
         QMutexLocker locker(&m);
         return items;
     }
 
     // thread-safe
     QString getDText()
     {
         QMutexLocker locker(&m);
         return dtext;
     }
 
     // thread-safe
     void clearDText()
     {
         QMutexLocker locker(&m);
         dtext.clear();
     }
 
     // thread-safe
     void addTarget(KeyStoreManagerPrivate *ksm);
 
     // thread-safe
     void removeTarget(QObject *ksm)
     {
         QMutexLocker locker(&updateMutex);
         disconnect(ksm);
     }
 
 public Q_SLOTS:
     void spinEventLoop()
     {
         QAbstractEventDispatcher::instance()->processEvents(QEventLoop::AllEvents);
     }
 
     void start()
     {
         // grab providers (and default)
         ProviderList list = providers();
         list.append(defaultProvider());
 
         for (int n = 0; n < list.count(); ++n) {
             Provider *p = list[n];
             if (p->features().contains(QStringLiteral("keystorelist")) && !haveProviderSource(p))
                 startProvider(p);
         }
 
         startedAll = true;
     }
 
     void start(const QString &provider)
     {
         // grab providers (and default)
         ProviderList list = providers();
         list.append(defaultProvider());
 
         Provider *p = nullptr;
         for (int n = 0; n < list.count(); ++n) {
             if (list[n]->name() == provider) {
                 p = list[n];
                 break;
             }
         }
 
         if (p && p->features().contains(QStringLiteral("keystorelist")) && !haveProviderSource(p))
             startProvider(p);
     }
 
     void scan()
     {
         if (startedAll)
             start();
     }
 
     QList<QCA::KeyStoreEntry> entryList(int trackerId)
     {
         QList<KeyStoreEntry> out;
         int                  at = findItem(trackerId);
         if (at == -1)
             return out;
         Item                               &i    = items[at];
         const QList<KeyStoreEntryContext *> list = i.owner->entryList(i.storeContextId);
         for (int n = 0; n < list.count(); ++n) {
             KeyStoreEntry entry;
             entry.change(list[n]);
             out.append(entry);
         }
         return out;
     }
 
     QList<QCA::KeyStoreEntry::Type> entryTypes(int trackerId)
     {
         QList<KeyStoreEntry::Type> out;
         int                        at = findItem(trackerId);
         if (at == -1)
             return out;
         Item &i = items[at];
         return i.owner->entryTypes(i.storeContextId);
     }
 
     // hack with void *
     void *entry(const QString &storeId, const QString &entryId)
     {
         KeyStoreListContext *c         = nullptr;
         int                  contextId = -1;
         m.lock();
         foreach (const Item &i, items) {
             if (i.storeId == storeId) {
                 c         = i.owner;
                 contextId = i.storeContextId;
                 break;
             }
         }
         m.unlock();
         if (!c)
             return nullptr;
 
         return c->entry(contextId, entryId);
     }
 
     // hack with void *
     void *entryPassive(const QString &serialized)
     {
         foreach (KeyStoreListContext *ksl, sources) {
             // "is this yours?"
             KeyStoreEntryContext *e = ksl->entryPassive(serialized);
             if (e)
                 return e;
         }
         return nullptr;
     }
 
     QString writeEntry(int trackerId, const QVariant &v)
     {
         int at = findItem(trackerId);
         if (at == -1)
             return QString();
         Item &i = items[at];
         if (v.canConvert<KeyBundle>())
             return i.owner->writeEntry(i.storeContextId, v.value<KeyBundle>());
         else if (v.canConvert<Certificate>())
             return i.owner->writeEntry(i.storeContextId, v.value<Certificate>());
         else if (v.canConvert<CRL>())
             return i.owner->writeEntry(i.storeContextId, v.value<CRL>());
         else if (v.canConvert<PGPKey>())
             return i.owner->writeEntry(i.storeContextId, v.value<PGPKey>());
         else
             return QString();
     }
 
     QString writeEntry(int trackerId, const QCA::KeyBundle &v)
     {
         int at = findItem(trackerId);
         if (at == -1)
             return QString();
         Item &i = items[at];
 
         return i.owner->writeEntry(i.storeContextId, v);
     }
 
     QString writeEntry(int trackerId, const QCA::Certificate &v)
     {
         int at = findItem(trackerId);
         if (at == -1)
             return QString();
         Item &i = items[at];
 
         return i.owner->writeEntry(i.storeContextId, v);
     }
 
     QString writeEntry(int trackerId, const QCA::CRL &v)
     {
         int at = findItem(trackerId);
         if (at == -1)
             return QString();
         Item &i = items[at];
 
         return i.owner->writeEntry(i.storeContextId, v);
     }
 
     QString writeEntry(int trackerId, const QCA::PGPKey &v)
     {
         int at = findItem(trackerId);
         if (at == -1)
             return QString();
         Item &i = items[at];
 
         return i.owner->writeEntry(i.storeContextId, v);
     }
 
     bool removeEntry(int trackerId, const QString &entryId)
     {
         int at = findItem(trackerId);
         if (at == -1)
             return false;
         Item &i = items[at];
         return i.owner->removeEntry(i.storeContextId, entryId);
     }
 
 Q_SIGNALS:
     // emit this when items or busy state changes
     void updated();
     void updated_p();
 
 private Q_SLOTS:
     void updated_locked()
     {
         QMutexLocker locker(&updateMutex);
         emit         updated();
     }
 
 private:
     bool haveProviderSource(Provider *p) const
     {
         foreach (KeyStoreListContext *ksl, sources) {
             if (ksl->provider() == p)
                 return true;
         }
         return false;
     }
 
     int findItem(int trackerId)
     {
         for (int n = 0; n < items.count(); ++n) {
             if (items[n].trackerId == trackerId)
                 return n;
         }
         return -1;
     }
 
     void startProvider(Provider *p)
     {
         KeyStoreListContext *c = static_cast<KeyStoreListContext *>(getContext(QStringLiteral("keystorelist"), p));
         if (!c)
             return;
 
         sources += c;
         busySources += c;
         connect(c, &KeyStoreListContext::busyStart, this, &KeyStoreTracker::ksl_busyStart);
         connect(c, &KeyStoreListContext::busyEnd, this, &KeyStoreTracker::ksl_busyEnd);
         connect(c, &KeyStoreListContext::updated, this, &KeyStoreTracker::ksl_updated);
         connect(c, &KeyStoreListContext::diagnosticText, this, &KeyStoreTracker::ksl_diagnosticText);
         connect(c, &KeyStoreListContext::storeUpdated, this, &KeyStoreTracker::ksl_storeUpdated);
         c->start();
         c->setUpdatesEnabled(true);
 
         QCA_logTextMessage(QStringLiteral("keystore: startProvider %1").arg(p->name()), Logger::Information);
     }
 
     bool updateStores(KeyStoreListContext *c)
     {
         bool changed = false;
 
         QMutexLocker locker(&m);
 
         const QList<int> keyStores = c->keyStores();
 
         // remove any contexts that are gone
         for (int n = 0; n < items.count(); ++n) {
             if (items[n].owner == c && !keyStores.contains(items[n].storeContextId)) {
                 QCA_logTextMessage(QStringLiteral("keystore: updateStores remove %1").arg(items[n].storeContextId),
                                    Logger::Information);
 
                 items.removeAt(n);
                 --n; // adjust position
 
                 changed = true;
             }
         }
 
         // handle add/updates
         foreach (int id, keyStores) {
             // do we have it already?
             int at = -1;
             for (int n = 0; n < items.count(); ++n) {
                 if (items[n].owner == c && items[n].storeContextId == id) {
                     at = n;
                     break;
                 }
             }
 
             // if so, update it
             if (at != -1) {
                 Item &i = items[at];
 
                 QString name       = c->name(id);
                 bool    isReadOnly = c->isReadOnly(id);
                 if (i.name != name || i.isReadOnly != isReadOnly) {
                     QCA_logTextMessage(QStringLiteral("keystore: updateStores update %1").arg(id), Logger::Information);
                     i.name       = name;
                     i.isReadOnly = isReadOnly;
                     changed      = true;
                 }
             }
             // otherwise, add it
             else {
                 QCA_logTextMessage(QStringLiteral("keystore: updateStores add %1").arg(id), Logger::Information);
 
                 Item i;
                 i.trackerId      = tracker_id_at++;
                 i.updateCount    = 0;
                 i.owner          = c;
                 i.storeContextId = id;
                 i.storeId        = c->storeId(id);
                 i.name           = c->name(id);
                 i.type           = c->type(id);
                 i.isReadOnly     = c->isReadOnly(id);
                 items += i;
 
                 changed = true;
             }
         }
 
         return changed;
     }
 
 private Q_SLOTS:
     void ksl_busyStart()
     {
         KeyStoreListContext *c = (KeyStoreListContext *)sender();
 
         QCA_logTextMessage(QStringLiteral("keystore: ksl_busyStart %1").arg(c->provider()->name()),
                            Logger::Information);
 
         if (!busySources.contains(c)) {
             busySources += c;
 
             QCA_logTextMessage(QStringLiteral("keystore: emitting updated"), Logger::Information);
             emit updated_p();
         }
     }
 
     void ksl_busyEnd()
     {
         KeyStoreListContext *c = (KeyStoreListContext *)sender();
 
         QCA_logTextMessage(QStringLiteral("keystore: ksl_busyEnd %1").arg(c->provider()->name()), Logger::Information);
 
         busySources.remove(c);
         bool       changed  = updateStores(c);
         const bool any_busy = !busySources.isEmpty();
 
         if (!any_busy) {
             m.lock();
             busy = false;
             m.unlock();
         }
 
         if (!any_busy || changed) {
             QCA_logTextMessage(QStringLiteral("keystore: emitting updated"), Logger::Information);
             emit updated_p();
         }
     }
 
     void ksl_updated()
     {
         KeyStoreListContext *c = (KeyStoreListContext *)sender();
 
         QCA_logTextMessage(QStringLiteral("keystore: ksl_updated %1").arg(c->provider()->name()), Logger::Information);
 
         bool changed = updateStores(c);
         if (changed) {
             QCA_logTextMessage(QStringLiteral("keystore: emitting updated"), Logger::Information);
             emit updated_p();
         }
     }
 
     void ksl_diagnosticText(const QString &str)
     {
         QMutexLocker locker(&m);
         dtext += str;
         dtext = truncate_log(dtext, 100000);
     }
 
     void ksl_storeUpdated(int id)
     {
         KeyStoreListContext *c = (KeyStoreListContext *)sender();
 
         QCA_logTextMessage(
             QStringLiteral("keystore: ksl_storeUpdated %1 %2").arg(c->provider()->name(), QString::number(id)),
             Logger::Information);
 
         QMutexLocker locker(&m);
         for (int n = 0; n < items.count(); ++n) {
             Item &i = items[n];
             if (i.owner == c && i.storeContextId == id) {
                 ++i.updateCount;
 
                 QCA_logTextMessage(
                     QStringLiteral("keystore: %1 updateCount = %2").arg(i.name, QString::number(i.updateCount)),
                     Logger::Information);
 
                 QCA_logTextMessage(QStringLiteral("keystore: emitting updated"), Logger::Information);
                 emit updated_p();
                 return;
             }
         }
     }
 };
 
 KeyStoreTracker *KeyStoreTracker::self = nullptr;
 
 //----------------------------------------------------------------------------
 // KeyStoreThread
 //----------------------------------------------------------------------------
 class KeyStoreThread : public SyncThread
 {
     Q_OBJECT
 public:
     KeyStoreTracker *tracker;
     QMutex           call_mutex;
 
     KeyStoreThread(QObject *parent = nullptr)
         : SyncThread(parent)
     {
     }
 
     ~KeyStoreThread() override
     {
         stop();
     }
 
     void atStart() override
     {
         tracker = new KeyStoreTracker;
     }
 
     void atEnd() override
     {
         delete tracker;
     }
 };
 
 //----------------------------------------------------------------------------
 // KeyStoreGlobal
 //----------------------------------------------------------------------------
 class KeyStoreManagerGlobal;
 
 Q_GLOBAL_STATIC(QMutex, ksm_mutex)
 static KeyStoreManagerGlobal *g_ksm = nullptr;
 
 class KeyStoreManagerGlobal
 {
 public:
     KeyStoreThread *thread;
 
     KeyStoreManagerGlobal()
     {
         thread = new KeyStoreThread;
         thread->moveToThread(QCoreApplication::instance()->thread());
         thread->start();
     }
 
     ~KeyStoreManagerGlobal()
     {
         delete thread;
     }
 
     KeyStoreManagerGlobal(const KeyStoreManagerGlobal &)            = delete;
     KeyStoreManagerGlobal &operator=(const KeyStoreManagerGlobal &) = delete;
 };
 
 // this function is thread-safe
 static QVariant trackercall(const char *method, const QVariantList &args = QVariantList())
 {
     QVariant ret;
     bool     ok;
 
     g_ksm->thread->call_mutex.lock();
     ret = g_ksm->thread->call(KeyStoreTracker::instance(), method, args, &ok);
     g_ksm->thread->call_mutex.unlock();
 
     Q_ASSERT(ok);
     if (!ok) {
         fprintf(stderr, "QCA: KeyStoreTracker call [%s] failed.\n", method);
         abort();
         return QVariant();
     }
     return ret;
 }
 
 //----------------------------------------------------------------------------
 // KeyStoreEntry
 //----------------------------------------------------------------------------
 class KeyStoreEntry::Private
 {
 public:
     bool accessible;
 
     Private()
     {
         accessible = false;
     }
 };
 
 KeyStoreEntry::KeyStoreEntry()
     : d(new Private)
 {
 }
 
 KeyStoreEntry::KeyStoreEntry(const QString &serialized)
     : d(new Private)
 {
     *this = fromString(serialized);
 }
 
 KeyStoreEntry::KeyStoreEntry(const KeyStoreEntry &from)
     : Algorithm(from)
     , d(new Private(*from.d))
 {
 }
 
 KeyStoreEntry::~KeyStoreEntry()
 {
     delete d;
 }
 
 KeyStoreEntry &KeyStoreEntry::operator=(const KeyStoreEntry &from)
 {
     Algorithm::operator=(from);
     *d = *from.d;
     return *this;
 }
 
 bool KeyStoreEntry::isNull() const
 {
     return (!context() ? true : false);
 }
 
 bool KeyStoreEntry::isAvailable() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->isAvailable();
 }
 
 bool KeyStoreEntry::isAccessible() const
 {
     return d->accessible;
 }
 
 KeyStoreEntry::Type KeyStoreEntry::type() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->type();
 }
 
 QString KeyStoreEntry::name() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->name();
 }
 
 QString KeyStoreEntry::id() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->id();
 }
 
 QString KeyStoreEntry::storeName() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->storeName();
 }
 
 QString KeyStoreEntry::storeId() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->storeId();
 }
 
 QString KeyStoreEntry::toString() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->serialize();
 }
 
 KeyStoreEntry KeyStoreEntry::fromString(const QString &serialized)
 {
     KeyStoreEntry         e;
     KeyStoreEntryContext *c = (KeyStoreEntryContext *)KeyStoreTracker::instance()->entryPassive(serialized);
     if (c)
         e.change(c);
     return e;
 }
 
 KeyBundle KeyStoreEntry::keyBundle() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->keyBundle();
 }
 
 Certificate KeyStoreEntry::certificate() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->certificate();
 }
 
 CRL KeyStoreEntry::crl() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->crl();
 }
 
 PGPKey KeyStoreEntry::pgpSecretKey() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->pgpSecretKey();
 }
 
 PGPKey KeyStoreEntry::pgpPublicKey() const
 {
     return static_cast<const KeyStoreEntryContext *>(context())->pgpPublicKey();
 }
 
 bool KeyStoreEntry::ensureAvailable()
 {
     const QString         storeId = this->storeId();
     const QString         entryId = id();
     KeyStoreEntryContext *c =
         (KeyStoreEntryContext *)trackercall("entry", QVariantList() << storeId << entryId).value<void *>();
     if (c)
         change(c);
     return isAvailable();
 }
 
 bool KeyStoreEntry::ensureAccess()
 {
     if (!ensureAvailable()) {
         d->accessible = false;
         return false;
     }
     const bool ok = static_cast<KeyStoreEntryContext *>(context())->ensureAccess();
     d->accessible = ok;
     return d->accessible;
 }
 
 //----------------------------------------------------------------------------
 // KeyStoreEntryWatcher
 //----------------------------------------------------------------------------
 class KeyStoreEntryWatcher::Private : public QObject
 {
     Q_OBJECT
 public:
     KeyStoreEntryWatcher *q;
     KeyStoreManager       ksm;
     KeyStoreEntry         entry;
     QString               storeId, entryId;
     KeyStore             *ks;
     bool                  avail;
 
     Private(KeyStoreEntryWatcher *_q)
         : QObject(_q)
         , q(_q)
         , ksm(this)
     {
         ks    = nullptr;
         avail = false;
         connect(&ksm, &KeyStoreManager::keyStoreAvailable, this, &KeyStoreEntryWatcher::Private::ksm_available);
     }
 
     ~Private() override
     {
         delete ks;
     }
 
     void start()
     {
         const QStringList list = ksm.keyStores();
         foreach (const QString &storeId, list)
             ksm_available(storeId);
     }
 
 private Q_SLOTS:
     void ksm_available(const QString &_storeId)
     {
         // we only care about one store
         if (_storeId == storeId) {
             ks = new KeyStore(storeId, &ksm);
             connect(ks, &KeyStore::updated, this, &Private::ks_updated);
             ks->startAsynchronousMode();
         }
     }
 
     void ks_updated()
     {
         bool                       found = false;
         const QList<KeyStoreEntry> list  = ks->entryList();
         foreach (const KeyStoreEntry &e, list) {
             if (e.id() == entryId && e.isAvailable()) {
                 found = true;
                 if (!avail)
                     entry = e;
                 break;
             }
         }
 
         if (found && !avail) {
             avail = true;
             emit q->available();
         } else if (!found && avail) {
             avail = false;
             emit q->unavailable();
         }
     }
 
     void ks_unavailable()
     {
         delete ks;
         ks = nullptr;
 
         if (avail) {
             avail = false;
             emit q->unavailable();
         }
     }
 };
 
 KeyStoreEntryWatcher::KeyStoreEntryWatcher(const KeyStoreEntry &e, QObject *parent)
     : QObject(parent)
 {
     d = new Private(this);
     if (!e.isNull()) {
         d->entry   = e;
         d->storeId = e.storeId();
         d->entryId = e.id();
         d->start();
     }
 }
 
 KeyStoreEntryWatcher::~KeyStoreEntryWatcher()
 {
     delete d;
 }
 
 KeyStoreEntry KeyStoreEntryWatcher::entry() const
 {
     return d->entry;
 }
 
 //----------------------------------------------------------------------------
 // KeyStore
 //----------------------------------------------------------------------------
 // union thingy
 class KeyStoreWriteEntry
 {
 public:
     enum Type
     {
         TypeKeyBundle,
         TypeCertificate,
         TypeCRL,
         TypePGPKey
     };
 
     Type        type;
     KeyBundle   keyBundle;
     Certificate cert;
     CRL         crl;
     PGPKey      pgpKey;
 
     KeyStoreWriteEntry()
     {
     }
 
     KeyStoreWriteEntry(const KeyBundle &_keyBundle)
         : type(TypeKeyBundle)
         , keyBundle(_keyBundle)
     {
     }
 
     KeyStoreWriteEntry(const Certificate &_cert)
         : type(TypeCertificate)
         , cert(_cert)
     {
     }
 
     KeyStoreWriteEntry(const CRL &_crl)
         : type(TypeCRL)
         , crl(_crl)
     {
     }
 
     KeyStoreWriteEntry(const PGPKey &_pgpKey)
         : type(TypePGPKey)
         , pgpKey(_pgpKey)
     {
     }
 };
 
 class KeyStoreOperation : public QThread
 {
     Q_OBJECT
 public:
     enum Type
     {
         EntryList,
         WriteEntry,
         RemoveEntry
     };
 
     Type type;
     int  trackerId;
 
     KeyStoreWriteEntry   wentry;    // in: WriteEntry
     QList<KeyStoreEntry> entryList; // out: EntryList
     QString              entryId;   // in: RemoveEntry, out: WriteEntry
     bool                 success;   // out: RemoveEntry
 
     KeyStoreOperation(QObject *parent = nullptr)
         : QThread(parent)
     {
     }
 
     ~KeyStoreOperation() override
     {
         wait();
     }
 
 protected:
     void run() override
     {
         if (type == EntryList)
             entryList = trackercall("entryList", QVariantList() << trackerId).value<QList<KeyStoreEntry>>();
         else if (type == WriteEntry) {
             QVariant arg;
             if (wentry.type == KeyStoreWriteEntry::TypeKeyBundle)
                 arg = QVariant::fromValue<KeyBundle>(wentry.keyBundle);
             else if (wentry.type == KeyStoreWriteEntry::TypeCertificate)
                 arg = QVariant::fromValue<Certificate>(wentry.cert);
             else if (wentry.type == KeyStoreWriteEntry::TypeCRL)
                 arg = QVariant::fromValue<CRL>(wentry.crl);
             else if (wentry.type == KeyStoreWriteEntry::TypePGPKey)
                 arg = QVariant::fromValue<PGPKey>(wentry.pgpKey);
 
             // note: each variant in the argument list is resolved
             //   to its native type.  so even though it looks like
             //   we're attempting to call a method named
             //   writeEntry(QString,QVariant), we're actually
             //   calling one of many possible methods, such as
             //   writeEntry(QString,PGPKey) or
             //   writeEntry(QString,Certificate), etc, depending
             //   on the type of object we put in the variant.
             entryId = trackercall("writeEntry", QVariantList() << trackerId << arg).toString();
         } else // RemoveEntry
         {
             success = trackercall("removeEntry", QVariantList() << trackerId << entryId).toBool();
         }
     }
 };
 
 class KeyStorePrivate : public QObject
 {
     Q_OBJECT
 public:
     KeyStore                  *q;
     KeyStoreManager           *ksm;
     int                        trackerId;
     KeyStoreTracker::Item      item;
     bool                       async;
     bool                       need_update;
     QList<KeyStoreEntry>       latestEntryList;
     QList<KeyStoreOperation *> ops;
 
     KeyStorePrivate(KeyStore *_q)
         : QObject(_q)
         , q(_q)
         , async(false)
     {
     }
 
     ~KeyStorePrivate() override
     {
         qDeleteAll(ops);
     }
 
     // implemented below, after KeyStorePrivate is declared
     void                   reg();
     void                   unreg();
     KeyStoreTracker::Item *getItem(const QString &storeId);
     KeyStoreTracker::Item *getItem(int trackerId);
 
     void invalidate()
     {
         trackerId = -1;
         unreg();
     }
 
     bool have_entryList_op() const
     {
         foreach (KeyStoreOperation *op, ops) {
             if (op->type == KeyStoreOperation::EntryList)
                 return true;
         }
         return false;
     }
 
     void handle_updated()
     {
         if (async) {
             if (!have_entryList_op())
                 async_entryList();
             else
                 need_update = true;
         } else
             emit q->updated();
     }
 
     void async_entryList()
     {
         KeyStoreOperation *op = new KeyStoreOperation(this);
         // use queued for signal-safety
         connect(op, &KeyStoreOperation::finished, this, &KeyStorePrivate::op_finished, Qt::QueuedConnection);
         op->type      = KeyStoreOperation::EntryList;
         op->trackerId = trackerId;
         ops += op;
         op->start();
     }
 
     void async_writeEntry(const KeyStoreWriteEntry &wentry)
     {
         KeyStoreOperation *op = new KeyStoreOperation(this);
         // use queued for signal-safety
         connect(op, &KeyStoreOperation::finished, this, &KeyStorePrivate::op_finished, Qt::QueuedConnection);
         op->type      = KeyStoreOperation::WriteEntry;
         op->trackerId = trackerId;
         op->wentry    = wentry;
         ops += op;
         op->start();
     }
 
     void async_removeEntry(const QString &entryId)
     {
         KeyStoreOperation *op = new KeyStoreOperation(this);
         // use queued for signal-safety
         connect(op, &KeyStoreOperation::finished, this, &KeyStorePrivate::op_finished, Qt::QueuedConnection);
         op->type      = KeyStoreOperation::RemoveEntry;
         op->trackerId = trackerId;
         op->entryId   = entryId;
         ops += op;
         op->start();
     }
 
 private Q_SLOTS:
     void op_finished()
     {
         KeyStoreOperation *op = (KeyStoreOperation *)sender();
 
         if (op->type == KeyStoreOperation::EntryList) {
             latestEntryList = op->entryList;
             ops.removeAll(op);
             delete op;
 
             if (need_update) {
                 need_update = false;
                 async_entryList();
             }
 
             emit q->updated();
         } else if (op->type == KeyStoreOperation::WriteEntry) {
             QString entryId = op->entryId;
             ops.removeAll(op);
             delete op;
 
             emit q->entryWritten(entryId);
         } else // RemoveEntry
         {
             bool success = op->success;
             ops.removeAll(op);
             delete op;
 
             emit q->entryRemoved(success);
         }
     }
 };
 
 KeyStore::KeyStore(const QString &id, KeyStoreManager *keyStoreManager)
     : QObject(keyStoreManager)
 {
     d      = new KeyStorePrivate(this);
     d->ksm = keyStoreManager;
 
     KeyStoreTracker::Item *i = d->getItem(id);
     if (i) {
         d->trackerId = i->trackerId;
         d->item      = *i;
         d->reg();
     } else
         d->trackerId = -1;
 }
 
 KeyStore::~KeyStore()
 {
     if (d->trackerId != -1)
         d->unreg();
     delete d;
 }
 
 bool KeyStore::isValid() const
 {
     return (d->getItem(d->trackerId) ? true : false);
 }
 
 KeyStore::Type KeyStore::type() const
 {
     return d->item.type;
 }
 
 QString KeyStore::name() const
 {
     return d->item.name;
 }
 
 QString KeyStore::id() const
 {
     return d->item.storeId;
 }
 
 bool KeyStore::isReadOnly() const
 {
     return d->item.isReadOnly;
 }
 
 void KeyStore::startAsynchronousMode()
 {
     if (d->async)
         return;
 
     d->async = true;
 
     // initial entrylist
     d->need_update = false;
     d->async_entryList();
 }
 
 QList<KeyStoreEntry> KeyStore::entryList() const
 {
     if (d->async)
         return d->latestEntryList;
 
     if (d->trackerId == -1)
         return QList<KeyStoreEntry>();
     return trackercall("entryList", QVariantList() << d->trackerId).value<QList<KeyStoreEntry>>();
 }
 
 bool KeyStore::holdsTrustedCertificates() const
 {
     QList<KeyStoreEntry::Type> list;
     if (d->trackerId == -1)
         return false;
     list = trackercall("entryTypes", QVariantList() << d->trackerId).value<QList<KeyStoreEntry::Type>>();
     if (list.contains(KeyStoreEntry::TypeCertificate) || list.contains(KeyStoreEntry::TypeCRL))
         return true;
     return false;
 }
 
 bool KeyStore::holdsIdentities() const
 {
     QList<KeyStoreEntry::Type> list;
     if (d->trackerId == -1)
         return false;
     list = trackercall("entryTypes", QVariantList() << d->trackerId).value<QList<KeyStoreEntry::Type>>();
     if (list.contains(KeyStoreEntry::TypeKeyBundle) || list.contains(KeyStoreEntry::TypePGPSecretKey))
         return true;
     return false;
 }
 
 bool KeyStore::holdsPGPPublicKeys() const
 {
     QList<KeyStoreEntry::Type> list;
     if (d->trackerId == -1)
         return false;
     list = trackercall("entryTypes", QVariantList() << d->trackerId).value<QList<KeyStoreEntry::Type>>();
     if (list.contains(KeyStoreEntry::TypePGPPublicKey))
         return true;
     return false;
 }
 
 QString KeyStore::writeEntry(const KeyBundle &kb)
 {
     if (d->async) {
         d->async_writeEntry(KeyStoreWriteEntry(kb));
         return QString();
     } else {
         const auto arg = QVariant::fromValue<KeyBundle>(kb);
         return trackercall("writeEntry", QVariantList() << d->trackerId << arg).toString();
     }
 }
 
 QString KeyStore::writeEntry(const Certificate &cert)
 {
     if (d->async) {
         d->async_writeEntry(KeyStoreWriteEntry(cert));
         return QString();
     } else {
         const auto arg = QVariant::fromValue<Certificate>(cert);
         return trackercall("writeEntry", QVariantList() << d->trackerId << arg).toString();
     }
 }
 
 QString KeyStore::writeEntry(const CRL &crl)
 {
     if (d->async) {
         d->async_writeEntry(KeyStoreWriteEntry(crl));
         return QString();
     } else {
         const auto arg = QVariant::fromValue<CRL>(crl);
         return trackercall("writeEntry", QVariantList() << d->trackerId << arg).toString();
     }
 }
 
 QString KeyStore::writeEntry(const PGPKey &key)
 {
     if (d->async) {
         d->async_writeEntry(KeyStoreWriteEntry(key));
         return QString();
     } else {
         const auto arg = QVariant::fromValue<PGPKey>(key);
         return trackercall("writeEntry", QVariantList() << d->trackerId << arg).toString();
     }
 }
 
 bool KeyStore::removeEntry(const QString &id)
 {
     if (d->async) {
         d->async_removeEntry(id);
         return false;
     } else {
         return trackercall("removeEntry", QVariantList() << d->trackerId << id).toBool();
     }
 }
 
 //----------------------------------------------------------------------------
 // KeyStoreManager
 //----------------------------------------------------------------------------
 static void ensure_init()
 {
     QMutexLocker locker(ksm_mutex());
     if (!g_ksm)
         g_ksm = new KeyStoreManagerGlobal;
 }
 
 // static functions
 void KeyStoreManager::start()
 {
     ensure_init();
     QMetaObject::invokeMethod(KeyStoreTracker::instance(), "start", Qt::QueuedConnection);
     trackercall("spinEventLoop");
 }
 
 void KeyStoreManager::start(const QString &provider)
 {
     ensure_init();
     QMetaObject::invokeMethod(KeyStoreTracker::instance(), "start", Qt::QueuedConnection, Q_ARG(QString, provider));
     trackercall("spinEventLoop");
 }
 
 QString KeyStoreManager::diagnosticText()
 {
     ensure_init();
 
     // spin one event cycle in the tracker, to receive any pending text.
     //   note that since trackercall also goes through the eventloop,
     //   this may end up doing two rounds.  probably no big deal.
     trackercall("spinEventLoop");
 
     return KeyStoreTracker::instance()->getDText();
 }
 
 void KeyStoreManager::clearDiagnosticText()
 {
     ensure_init();
     KeyStoreTracker::instance()->clearDText();
 }
 
 void KeyStoreManager::scan()
 {
     ensure_init();
     QMetaObject::invokeMethod(KeyStoreTracker::instance(), "scan", Qt::QueuedConnection);
 }
 
 void KeyStoreManager::shutdown()
 {
     QMutexLocker locker(ksm_mutex());
     delete g_ksm;
     g_ksm = nullptr;
 }
 
 // object
 class KeyStoreManagerPrivate : public QObject
 {
     Q_OBJECT
 public:
     KeyStoreManager *q;
 
     QMutex                       m;
     QWaitCondition               w;
     bool                         busy;
     QList<KeyStoreTracker::Item> items;
     bool                         pending, waiting;
 
     QMultiHash<int, KeyStore *> keyStoreForTrackerId;
     QHash<KeyStore *, int>      trackerIdForKeyStore;
 
     KeyStoreManagerPrivate(KeyStoreManager *_q)
         : QObject(_q)
         , q(_q)
     {
         pending = false;
         waiting = false;
     }
 
     ~KeyStoreManagerPrivate() override
     {
         // invalidate registered keystores
         QList<KeyStore *>              list;
         QHashIterator<KeyStore *, int> it(trackerIdForKeyStore);
         while (it.hasNext()) {
             it.next();
             list += it.key();
         }
         foreach (KeyStore *ks, list)
             ks->d->invalidate();
     }
 
     // for keystore
     void reg(KeyStore *ks, int trackerId)
     {
         keyStoreForTrackerId.insert(trackerId, ks);
         trackerIdForKeyStore.insert(ks, trackerId);
     }
 
     void unreg(KeyStore *ks)
     {
         int trackerId = trackerIdForKeyStore.take(ks);
 
         // this is the only way I know to remove one item from a multihash
         QList<KeyStore *> vals = keyStoreForTrackerId.values(trackerId);
         keyStoreForTrackerId.remove(trackerId);
         vals.removeAll(ks);
         foreach (KeyStore *i, vals)
             keyStoreForTrackerId.insert(trackerId, i);
     }
 
     KeyStoreTracker::Item *getItem(const QString &storeId)
     {
         for (int n = 0; n < items.count(); ++n) {
             KeyStoreTracker::Item *i = &items[n];
             if (i->storeId == storeId)
                 return i;
         }
         return nullptr;
     }
 
     KeyStoreTracker::Item *getItem(int trackerId)
     {
         for (int n = 0; n < items.count(); ++n) {
             KeyStoreTracker::Item *i = &items[n];
             if (i->trackerId == trackerId)
                 return i;
         }
         return nullptr;
     }
 
     void do_update()
     {
         // ksm doesn't have reset or state changes so we can
         //   use QPointer here for full SS.
         QPointer<QObject> self(this);
 
         const bool                         newbusy  = KeyStoreTracker::instance()->isBusy();
         const QList<KeyStoreTracker::Item> newitems = KeyStoreTracker::instance()->getItems();
 
         if (!busy && newbusy) {
             emit q->busyStarted();
             if (!self)
                 return;
         }
         if (busy && !newbusy) {
             emit q->busyFinished();
             if (!self)
                 return;
         }
 
         QStringList here;
         QList<int>  changed;
         QList<int>  gone;
 
         // removed
         for (int n = 0; n < items.count(); ++n) {
             KeyStoreTracker::Item &i     = items[n];
             bool                   found = false;
             for (int k = 0; k < newitems.count(); ++k) {
                 if (i.trackerId == newitems[k].trackerId) {
                     found = true;
                     break;
                 }
             }
             if (!found)
                 gone += i.trackerId;
         }
 
         // changed
         for (int n = 0; n < items.count(); ++n) {
             KeyStoreTracker::Item &i = items[n];
             for (int k = 0; k < newitems.count(); ++k) {
                 if (i.trackerId == newitems[k].trackerId) {
                     if (i.updateCount < newitems[k].updateCount)
                         changed += i.trackerId;
                     break;
                 }
             }
         }
 
         // added
         for (int n = 0; n < newitems.count(); ++n) {
             const KeyStoreTracker::Item &i     = newitems[n];
             bool                         found = false;
             for (int k = 0; k < items.count(); ++k) {
                 if (i.trackerId == items[k].trackerId) {
                     found = true;
                     break;
                 }
             }
             if (!found)
                 here += i.storeId;
         }
 
         busy  = newbusy;
         items = newitems;
 
         // signals
         foreach (int trackerId, gone) {
             KeyStore *ks = keyStoreForTrackerId.value(trackerId);
             if (ks) {
                 ks->d->invalidate();
                 emit ks->unavailable();
                 if (!self)
                     return;
             }
         }
 
         foreach (int trackerId, changed) {
             KeyStore *ks = keyStoreForTrackerId.value(trackerId);
             if (ks) {
                 ks->d->handle_updated();
                 if (!self)
                     return;
             }
         }
 
         foreach (const QString &storeId, here) {
             emit q->keyStoreAvailable(storeId);
             if (!self)
                 return;
         }
     }
 
 public Q_SLOTS:
     void tracker_updated()
     {
         QCA_logTextMessage(QString::asprintf("keystore: %p: tracker_updated start", q), Logger::Information);
 
         QMutexLocker locker(&m);
         if (!pending) {
             QMetaObject::invokeMethod(this, "update", Qt::QueuedConnection);
             pending = true;
         }
         if (waiting && !KeyStoreTracker::instance()->isBusy()) {
             busy  = false;
             items = KeyStoreTracker::instance()->getItems();
             w.wakeOne();
         }
 
         QCA_logTextMessage(QString::asprintf("keystore: %p: tracker_updated end", q), Logger::Information);
     }
 
     void update()
     {
         m.lock();
         pending = false;
         m.unlock();
 
         do_update();
     }
 };
 
 // from KeyStoreTracker
 void KeyStoreTracker::addTarget(KeyStoreManagerPrivate *ksm)
 {
     QMutexLocker locker(&updateMutex);
     connect(this, &KeyStoreTracker::updated, ksm, &KeyStoreManagerPrivate::tracker_updated, Qt::DirectConnection);
 }
 
 // from KeyStorePrivate
 void KeyStorePrivate::reg()
 {
     ksm->d->reg(q, trackerId);
 }
 
 void KeyStorePrivate::unreg()
 {
     ksm->d->unreg(q);
 }
 
 KeyStoreTracker::Item *KeyStorePrivate::getItem(const QString &storeId)
 {
     return ksm->d->getItem(storeId);
 }
 
 KeyStoreTracker::Item *KeyStorePrivate::getItem(int trackerId)
 {
     return ksm->d->getItem(trackerId);
 }
 
 KeyStoreManager::KeyStoreManager(QObject *parent)
     : QObject(parent)
 {
     ensure_init();
     d = new KeyStoreManagerPrivate(this);
     KeyStoreTracker::instance()->addTarget(d);
     sync();
 }
 
 KeyStoreManager::~KeyStoreManager()
 {
     Q_ASSERT(KeyStoreTracker::instance());
     KeyStoreTracker::instance()->removeTarget(d);
     delete d;
 }
 
 bool KeyStoreManager::isBusy() const
 {
     return d->busy;
 }
 
 void KeyStoreManager::waitForBusyFinished()
 {
     d->m.lock();
     d->busy = KeyStoreTracker::instance()->isBusy();
     if (d->busy) {
         d->waiting = true;
         d->w.wait(&d->m);
         d->waiting = false;
     }
     d->m.unlock();
 }
 
 QStringList KeyStoreManager::keyStores() const
 {
     QStringList out;
     for (int n = 0; n < d->items.count(); ++n)
         out += d->items[n].storeId;
     return out;
 }
 
 void KeyStoreManager::sync()
 {
     d->busy  = KeyStoreTracker::instance()->isBusy();
     d->items = KeyStoreTracker::instance()->getItems();
 }
 
 //----------------------------------------------------------------------------
 // KeyStoreInfo
 //----------------------------------------------------------------------------
 class KeyStoreInfo::Private : public QSharedData
 {
 public:
     KeyStore::Type type;
     QString        id, name;
 };
 
 KeyStoreInfo::KeyStoreInfo()
 {
 }
 
 KeyStoreInfo::KeyStoreInfo(KeyStore::Type type, const QString &id, const QString &name)
     : d(new Private)
 {
     d->type = type;
     d->id   = id;
     d->name = name;
 }
 
 KeyStoreInfo::KeyStoreInfo(const KeyStoreInfo &from)
     : d(from.d)
 {
 }
 
 KeyStoreInfo::~KeyStoreInfo()
 {
 }
 
 KeyStoreInfo &KeyStoreInfo::operator=(const KeyStoreInfo &from)
 {
     d = from.d;
     return *this;
 }
 
 bool KeyStoreInfo::isNull() const
 {
     return (d ? false : true);
 }
 
 KeyStore::Type KeyStoreInfo::type() const
 {
     return d->type;
 }
 
 QString KeyStoreInfo::id() const
 {
     return d->id;
 }
 
 QString KeyStoreInfo::name() const
 {
     return d->name;
 }
 
 }
 
 #include "qca_keystore.moc"