SigningController.h

Go to the documentation of this file.

#pragma once
 
#include <QtCore/QMutex>
#include <QtCore/QObject>
#include <QtCore/QString>
#include <QtCore/QTimer>
#include <chrono>
#include <optional>
 
#include "EdgeTriggeredCounter.h"
#include "MAVLinkMessageType.h"
#include "MAVLinkSigning.h"
#include "SigningChannel.h"
#include "SigningFailure.h"
#include "SigningStatus.h"
 
class SigningController : public QObject
{
    Q_OBJECT
public:
    using FailReason = SigningFailure::Reason;
    using State = SigningStatus::State;
 
    Q_PROPERTY(State state READ state NOTIFY stateChanged)
 
    explicit SigningController(mavlink_channel_t channel, QObject* parent = nullptr);
    ~SigningController() override;
 
    State state() const;
    SigningStatus status() const;
 
    bool isEnabled() const;
    QString keyName() const;
    QString statusText() const;
 
    [[nodiscard]] std::optional<SigningFailure> tryBeginEnable(uint8_t expectedSysId, const QString& keyName,
                                                               const MAVLinkSigning::SigningKey& keyBytes);
 
    [[nodiscard]] std::optional<SigningFailure> tryBeginDisable(uint8_t expectedSysId);
 
    void cancelPending(const QString& detail = {});
 
    bool clearSigning();
 
    bool initSigningImmediate(QByteArrayView key, MAVLinkSigning::UnsignedAcceptancePolicy policy,
                              const QString& keyNameHint = {});
 
    const SigningChannel& channel() const { return _channel; }
 
    bool signOutgoing(mavlink_message_t& message) { return _channel.signOutgoing(message); }
 
    void recordDetectMiss() { _channel.recordDetectMiss(); }
 
    void clearDetectCooldown() { _channel.clearDetectCooldown(); }
 
    bool processFrame(bool framingOk, const mavlink_message_t& message);
 
    void resetBadSigBurst();
 
    bool wallClockRefreshActiveForTesting() const { return _wallClockRefresh.isActive(); }
 
    static void setTimeoutForTesting(std::chrono::milliseconds timeout) { _timeoutOverride = timeout; }
 
signals:
    void stateChanged();
    void keyAutoDetected(const QString& keyName);
    void alertRaised(const QString& detail);
 
    void signingConfirmed(const QString& keyName);
 
    void signingFailed(SigningFailure failure);
 
private:
    enum class OpKind : uint8_t
    {
        None,
        Enable,
        Disable
    };
 
    struct PendingOp
    {
        OpKind kind = OpKind::None;
        uint8_t expectedSysId = 0;
        QString keyName;
        MAVLinkSigning::SigningKey keyBytes{};
        bool unsignedSeen = false;
    };
 
    bool _isPendingLocked() const { return _op.kind != OpKind::None; }
 
    void _handleFsmFrameLocked(const mavlink_message_t& message);
    void _confirmLocked();
    void _failLocked(FailReason reason, const QString& detail, bool cancelled = false);
    void _clearLocked();
    void _setOpLocked(PendingOp next);
    void _completeDisableSuccessLocked();
    void _onTimeout();
    void _setWallClockRefresh(bool on);
 
    SigningChannel _channel;
    mavlink_channel_t _mavlinkChannel;
    mutable QRecursiveMutex _fsmMutex;
    PendingOp _op;
    std::optional<QGC::AutoSuspendGuard> _autoDetectGuard;
    QTimer _timeout;
    QTimer _wallClockRefresh;
 
    static constexpr uint8_t kBadSignatureAlertThreshold = 3;
    QGC::EdgeTriggeredCounter<uint8_t> _badSigBurst{kBadSignatureAlertThreshold};
 
    static constexpr auto kTimeout = std::chrono::seconds(5);
    static std::chrono::milliseconds _effectiveTimeout()
    {
        return _timeoutOverride > std::chrono::milliseconds::zero() ? _timeoutOverride
                                                                    : std::chrono::milliseconds(kTimeout);
    }
    static inline std::chrono::milliseconds _timeoutOverride{0};
    static constexpr auto kWallClockRefreshInterval = std::chrono::seconds(1);
};