File indexing completed on 2024-04-28 05:50:06

 /*
  * SPDX-License-Identifier: GPL-3.0-or-later
  * SPDX-FileCopyrightText: 2020 Johan Ouwerkerk <jm.ouwerkerk@gmail.com>
  */
 #ifndef ACCOUNTS_ACTIONS_P_H
 #define ACCOUNTS_ACTIONS_P_H
 
 #include "account.h"
 
 #include <QObject>
 #include <QDateTime>
 #include <QSet>
 #include <QSettings>
 #include <QString>
 #include <QUuid>
 #include <QVector>
 
 #include <functional>
 #include <optional>
 
 #include "../secrets/secrets.h"
 #include "keys.h"
 
 namespace accounts
 {
     class AccountJob: public QObject // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit AccountJob();
         virtual ~AccountJob();
     public Q_SLOTS:
         virtual void run(void);
     Q_SIGNALS:
         void finished(void);
     };
 
     class Null: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit Null();
         void run(void) override;
     };
 
     class RequestAccountPassword: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit RequestAccountPassword(const SettingsProvider &settings, AccountSecret *secret);
         void run(void) override;
     private Q_SLOTS:
         void fail(void);
         void unlock(void);
         void finish(void);
     Q_SIGNALS:
         void unlocked(void);
         void failed(void);
     private:
         const SettingsProvider m_settings;
         AccountSecret * const m_secret;
     private:
         bool m_failed;
         bool m_succeeded;
     };
 
     class LoadAccounts: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit LoadAccounts(const SettingsProvider &settings, const AccountSecret *secret,
                               const std::function<qint64(void)> &clock = &QDateTime::currentMSecsSinceEpoch);
         void run(void) override;
     Q_SIGNALS:
         void foundHotp(const QUuid id, const QString name, const QString issuer,
                        const QByteArray secret, const QByteArray nonce, uint tokenLength,
                        quint64 counter, bool fixedTruncation, uint offset, bool checksum);
         void foundTotp(const QUuid id, const QString name, const QString issuer,
                        const QByteArray secret, const QByteArray nonce, uint tokenLength,
                        uint timeStep, const QDateTime epoch, accounts::Account::Hash hash);
         void failedToLoadAllAccounts(void);
     private:
         const SettingsProvider m_settings;
         const AccountSecret * const m_secret;
         const std::function<qint64(void)> m_clock;
     };
 
     class DeleteAccounts: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit DeleteAccounts(const SettingsProvider &settings, const QSet<QUuid> &ids);
         void run(void) override;
     Q_SIGNALS:
         void invalid(void);
     private:
         const SettingsProvider m_settings;
         const QSet<QUuid> m_ids;
     };
 
     class SaveHotp: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit SaveHotp(const SettingsProvider &settings,
                           const QUuid id, const QString &accountName, const QString &issuer,
                           const secrets::EncryptedSecret &secret, uint tokenLength,
                           quint64 counter, const std::optional<uint> offset, bool checksum);
         void run(void) override;
     Q_SIGNALS:
         void invalid(void);
         void saved(const QUuid id, const QString accountName, const QString issuer,
                    const QByteArray secret, const QByteArray nonce, uint tokenLength,
                    quint64 counter, bool fixedTruncation, uint offset, bool checksum);
     private:
         const SettingsProvider m_settings;
         const QUuid m_id;
         const QString m_accountName;
         const QString m_issuer;
         const secrets::EncryptedSecret m_secret;
         const uint m_tokenLength;
         const quint64 m_counter;
         const std::optional<uint> m_offset;
         const bool m_checksum;
     };
 
     class SaveTotp: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit SaveTotp(const SettingsProvider &settings,
                           const QUuid id, const QString &accountName, const QString &issuer,
                           const secrets::EncryptedSecret &secret, uint tokenLength,
                           uint timeStep, const QDateTime &epoch, Account::Hash hash,
                           const std::function<qint64(void)> &clock = &QDateTime::currentMSecsSinceEpoch);
         void run(void) override;
     Q_SIGNALS:
         void invalid(void);
         void saved(const QUuid id, const QString accountName, const QString issuer,
                    const QByteArray secret, const QByteArray nonce, uint tokenLength,
                    uint timeStep, const QDateTime epoch, accounts::Account::Hash hash);
     private:
         const SettingsProvider m_settings;
         const QUuid m_id;
         const QString m_accountName;
         const QString m_issuer;
         const secrets::EncryptedSecret m_secret;
         const uint m_tokenLength;
         const uint m_timeStep;
         const QDateTime m_epoch;
         const Account::Hash m_hash;
         const std::function<qint64(void)> m_clock;
     };
 
     class ComputeTotp: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit ComputeTotp(const AccountSecret *secret,
                              const secrets::EncryptedSecret &tokenSecret, uint tokenLength,
                              const QDateTime &epoch, uint timeStep, const Account::Hash hash,
                              const std::function<qint64(void)> &clock = &QDateTime::currentMSecsSinceEpoch);
         void run(void) override;
     Q_SIGNALS:
         void otp(const QString otp, const QString nextOtp, const QDateTime validFrom, const QDateTime validUntil);
     private:
         const AccountSecret * const m_secret;
         const secrets::EncryptedSecret m_tokenSecret;
         const uint m_tokenLength;
         const QDateTime m_epoch;
         const uint m_timeStep;
         const Account::Hash m_hash;
         const std::function<qint64(void)> m_clock;
     };
 
     class ComputeHotp: public AccountJob // clazy:exclude=ctor-missing-parent-argument
     {
         Q_OBJECT
     public:
         explicit ComputeHotp(const AccountSecret *secret,
                              const secrets::EncryptedSecret &tokenSecret, uint tokenLength,
                              quint64 counter, const std::optional<uint> offset, bool checksum);
         void run(void) override;
     Q_SIGNALS:
         void otp(const QString otp, const QString nextOtp, const quint64 nextCounter);
     private:
         const AccountSecret * const m_secret;
         const secrets::EncryptedSecret m_tokenSecret;
         const uint m_tokenLength;
         const quint64 m_counter;
         const std::optional<uint> m_offset;
         const bool m_checksum;
     };
 
     class Dispatcher: public QObject
     {
         Q_OBJECT
     public:
         explicit Dispatcher(QThread *thread, QObject *parent = nullptr);
         bool empty(void) const;
         void queueAndProceed(AccountJob *job, const std::function<void(void)> &setup_callbacks);
     Q_SIGNALS:
         void dispatch(void);
     private Q_SLOTS:
         void next(void);
     private:
         void dispatchNext(void);
     private:
         QThread * const m_thread;
     private:
         AccountJob *m_current;
         QVector<AccountJob*> m_pending;
     };
 }
 
 #endif