fsdclient.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 2019 swift Project Community / Contributors
// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-swift-pilot-client-1
 
 
#ifndef SWIFT_CORE_FSD_CLIENT_H
#define SWIFT_CORE_FSD_CLIENT_H
 
#include "core/fsd/enums.h"
#include "core/fsd/messagebase.h"
#include "core/swiftcoreexport.h"
#include "core/vatsim/vatsimsettings.h"
#include "misc/aviation/aircrafticaocode.h"
#include "misc/aviation/atcstationlist.h"
#include "misc/aviation/callsign.h"
#include "misc/aviation/flightplan.h"
#include "misc/aviation/informationmessage.h"
#include "misc/digestsignal.h"
#include "misc/network/clientprovider.h"
#include "misc/network/connectionstatus.h"
#include "misc/network/ecosystemprovider.h"
#include "misc/network/loginmode.h"
#include "misc/network/rawfsdmessage.h"
#include "misc/network/server.h"
#include "misc/network/textmessagelist.h"
#include "misc/simulation/ownaircraftprovider.h"
#include "misc/simulation/remoteaircraftprovider.h"
#include "misc/simulation/simulationenvironmentprovider.h"
#include "misc/tokenbucket.h"
#include "misc/worker.h"
 
#ifdef SWIFT_VATSIM_SUPPORT
#    include "vatsim/vatsimauth.h"
#endif
 
#include <atomic>
 
#include <QCommandLineOption>
#include <QHash>
#include <QObject>
#include <QQueue>
#include <QReadWriteLock>
#include <QString>
#include <QTcpSocket>
#include <QTimer>
#include <QtGlobal>
 
constexpr int PROTOCOL_REVISION_CLASSIC = 9;
constexpr int PROTOCOL_REVISION_VATSIM_ATC = 10;
constexpr int PROTOCOL_REVISION_VATSIM_AUTH = 100;
constexpr int PROTOCOL_REVISION_VATSIM_VELOCITY = 101;
 
class QNetworkReply;
 
namespace SwiftFsdTest
{
    class CTestFSDClient;
}
namespace swift::core::fsd
{
    enum class TextMessageGroups
    {
        AllClients,
        AllAtcClients,
        AllPilotClients,
        AllSups
    };
 
    class SWIFT_CORE_EXPORT CFSDClient :
        public swift::misc::CContinuousWorker,
        public swift::misc::network::IEcosystemProvider, // provide info about used ecosystem
        public swift::misc::network::CClientAware, // network can set client information
        public swift::misc::simulation::COwnAircraftAware, // network vatlib consumes own aircraft data and sets
                                                           // ICAO/callsign data
        public swift::misc::simulation::CRemoteAircraftAware, // check if we really need to process network packets
                                                              // (e.g. parts)
        public swift::misc::simulation::CSimulationEnvironmentAware // allows to consume ground elevations
    {
        Q_OBJECT
        Q_INTERFACES(swift::misc::network::IEcosystemProvider)
 
    public:
        static const QStringList &getLogCategories();
 
        CFSDClient(swift::misc::network::IClientProvider *clientProvider,
                   swift::misc::simulation::IOwnAircraftProvider *ownAircraftProvider,
                   swift::misc::simulation::IRemoteAircraftProvider *remoteAircraftProvider, QObject *owner = nullptr);
 
        void setClientName(const QString &clientName)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_clientName = clientName;
        }
        void setHostApplication(const QString &hostApplication)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_hostApplication = hostApplication;
        }
        void setVersion(int major, int minor)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_versionMajor = major;
            m_versionMinor = minor;
        }
 
#ifdef SWIFT_VATSIM_SUPPORT
        void setClientIdAndKey(quint16 id, const QByteArray &key);
#endif
 
        void setClientCapabilities(Capabilities capabilities)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_capabilities = capabilities;
        }
        void setServer(const swift::misc::network::CServer &server);
        void setLoginMode(const swift::misc::network::CLoginMode &mode)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_loginMode = mode;
        }
        void setCallsign(const swift::misc::aviation::CCallsign &callsign);
        void setPartnerCallsign(const swift::misc::aviation::CCallsign &callsign)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_partnerCallsign = callsign;
        }
        void setIcaoCodes(const swift::misc::simulation::CSimulatedAircraft &ownAircraft);
        void setLiveryAndModelString(const QString &livery, bool sendLiveryString, const QString &modelString,
                                     bool sendModelString);
        void setSimType(const swift::misc::simulation::CSimulatorInfo &simInfo);
        void setSimType(swift::misc::simulation::CSimulatorInfo::Simulator simulator);
        void setPilotRating(PilotRating rating)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_pilotRating = rating;
        }
        void setAtcRating(AtcRating rating)
        {
            QWriteLocker l(&m_lockUserClientBuffered);
            m_atcRating = rating;
        }
 
        // ------ thread safe access to preset values -----
 
        const swift::misc::network::CServer &getServer() const
        {
            QReadLocker l(&m_lockUserClientBuffered);
            return m_server;
        }
 
        QStringList getPresetValues() const;
 
        swift::misc::aviation::CCallsign getPresetCallsign() const
        {
            QReadLocker l(&m_lockUserClientBuffered);
            return m_ownCallsign;
        }
 
        swift::misc::aviation::CCallsign getPresetPartnerCallsign() const
        {
            QReadLocker l(&m_lockUserClientBuffered);
            return m_partnerCallsign;
        }
 
        swift::misc::network::CLoginMode getLoginMode() const
        {
            QReadLocker l(&m_lockUserClientBuffered);
            return m_loginMode;
        }
 
        PilotRating getPilotRating() const
        {
            QReadLocker l(&m_lockUserClientBuffered);
            return m_pilotRating;
        }
 
        void connectToServer();
        void disconnectFromServer();
 
        void addInterimPositionReceiver(const swift::misc::aviation::CCallsign &receiver)
        {
            m_interimPositionReceivers.push_back(receiver);
        }
        void removeInterimPositionReceiver(const swift::misc::aviation::CCallsign &receiver)
        {
            m_interimPositionReceivers.remove(receiver);
        }
 
        void sendClientQueryCapabilities(const swift::misc::aviation::CCallsign &callsign);
        void sendClientQueryCom1Freq(const swift::misc::aviation::CCallsign &callsign);
        void sendClientQueryRealName(const swift::misc::aviation::CCallsign &callsign);
        void sendClientQueryServer(const swift::misc::aviation::CCallsign &callsign);
        void sendClientQueryAtis(const swift::misc::aviation::CCallsign &callsign);
        void sendClientQueryFlightPlan(const swift::misc::aviation::CCallsign &callsign);
        void sendClientQueryAircraftConfig(const swift::misc::aviation::CCallsign &callsign);
        void sendTextMessages(const swift::misc::network::CTextMessageList &messages);
        void sendTextMessage(const swift::misc::network::CTextMessage &message);
        void sendTextMessage(TextMessageGroups receiverGroup, const QString &message);
        void sendRadioMessage(const QVector<int> &frequencieskHz, const QString &message);
        void sendFlightPlan(const swift::misc::aviation::CFlightPlan &flightPlan);
        void sendPlaneInfoRequest(const swift::misc::aviation::CCallsign &receiver);
        void sendPlaneInfoRequestFsinn(const swift::misc::aviation::CCallsign &callsign);
 
        swift::misc::aviation::CCallsignSet getInterimPositionReceivers() const;
        void setInterimPositionReceivers(const swift::misc::aviation::CCallsignSet &interimPositionReceivers);
 
        swift::misc::network::CConnectionStatus getConnectionStatus() const
        {
            QReadLocker l(&m_lockConnectionStatus);
            return m_connectionStatus;
        }
        bool isConnected() const { return this->getConnectionStatus().isConnected(); }
        bool isDisconnected() const { return this->getConnectionStatus().isDisconnected(); }
        bool isPendingConnection() const;
 
        bool setStatisticsEnable(bool enabled)
        {
            m_statistics = enabled;
            return enabled;
        }
        bool isStatisticsEnabled() const { return m_statistics; }
 
        void clearStatistics();
 
        QString getNetworkStatisticsAsText(bool reset, const QString &separator = "\n");
 
        void printToConsole(bool on) { m_printToConsole = on; }
 
        void gracefulShutdown();
 
    signals:
        void atcDataUpdateReceived(const swift::misc::aviation::CCallsign &callsign,
                                   const swift::misc::physical_quantities::CFrequency &freq,
                                   const swift::misc::geo::CCoordinateGeodetic &pos,
                                   const swift::misc::physical_quantities::CLength &range);
        void deleteAtcReceived(const QString &cid);
        void deletePilotReceived(const QString &cid);
        void pilotDataUpdateReceived(const swift::misc::aviation::CAircraftSituation &situation,
                                     const swift::misc::aviation::CTransponder &transponder);
        void pongReceived(const QString &sender, double elapsedTimeMs);
        void flightPlanReceived(const swift::misc::aviation::CCallsign &callsign,
                                const swift::misc::aviation::CFlightPlan &flightPlan);
        void textMessagesReceived(const swift::misc::network::CTextMessageList &messages);
        void aircraftConfigReceived(const QString &sender, const QJsonObject &config, qint64 currentOffsetTimeMs);
        void validAtcResponseReceived(const QString &callsign, bool isValidAtc);
        void capabilityResponseReceived(const swift::misc::aviation::CCallsign &sender,
                                        swift::misc::network::CClient::Capabilities capabilities);
        void com1FrequencyResponseReceived(const QString &sender,
                                           const swift::misc::physical_quantities::CFrequency &frequency);
        void realNameResponseReceived(const QString &sender, const QString &realName);
        void serverResponseReceived(const QString &sender, const QString &hostName);
        void planeInformationReceived(const QString &sender, const QString &aircraft, const QString &airline,
                                      const QString &livery);
        void customPilotPacketReceived(const QString &sender, const QStringList &data);
        void interimPilotDataUpdatedReceived(const swift::misc::aviation::CAircraftSituation &situation);
        void visualPilotDataUpdateReceived(const swift::misc::aviation::CAircraftSituation &situation);
        void euroscopeSimDataUpdatedReceived(const swift::misc::aviation::CAircraftSituation &situation,
                                             const swift::misc::aviation::CAircraftParts &parts,
                                             qint64 currentOffsetTimeMs, const QString &model, const QString &livery);
        void rawFsdMessage(const swift::misc::network::CRawFsdMessage &rawFsdMessage);
        void planeInformationFsinnReceived(const swift::misc::aviation::CCallsign &callsign,
                                           const QString &airlineIcaoDesignator, const QString &aircraftDesignator,
                                           const QString &combinedAircraftType, const QString &modelString);
        void muteRequestReceived(bool mute);
 
 
        void atisReplyReceived(const swift::misc::aviation::CCallsign &callsign,
                               const swift::misc::aviation::CInformationMessage &atis);
 
        void atisLogoffTimeReplyReceived(const swift::misc::aviation::CCallsign &callsign, const QString &zuluTime);
 
        void textMessageSent(const swift::misc::network::CTextMessage &sentMessage);
 
        void connectionStatusChanged(swift::misc::network::CConnectionStatus oldStatus,
                                     swift::misc::network::CConnectionStatus newStatus);
 
        void severeNetworkError(const QString &errorMessage);
 
        void killRequestReceived(const QString &reason);
 
    private:
        friend SwiftFsdTest::CTestFSDClient;
 
        void sendLogin(const QString &token = {});
        void sendDeletePilot();
        void sendDeleteAtc();
        void sendPilotDataUpdate();
        void sendInterimPilotDataUpdate();
        void sendVisualPilotDataUpdate(bool slowUpdate = false);
        void sendAtcDataUpdate(double latitude, double longitude);
        void sendPing(const QString &receiver);
        //
        void sendClientQueryIsValidAtc(const swift::misc::aviation::CCallsign &callsign);
        void sendClientQuery(ClientQueryType queryType, const swift::misc::aviation::CCallsign &receiver,
                             const QStringList &queryData = {});
        void sendTextMessage(const QString &receiver, const QString &message);
        void sendPlaneInformation(const QString &receiver, const QString &aircraft, const QString &airline = {},
                                  const QString &livery = {});
        void sendPlaneInformationFsinn(const swift::misc::aviation::CCallsign &callsign);
        void sendAircraftConfiguration(const QString &receiver, const QString &aircraftConfigJson);
        //
        void sendMessageString(const QString &message);
        void sendQueuedMessage();
 
        int increaseStatisticsValue(const QString &identifier, const QString &appendix = {});
        int increaseStatisticsValue(const QString &identifier, int value);
 
        template <class T>
        void sendQueuedMessage(const T &message)
        {
            if (!message.isValid()) { return; }
            if (m_unitTestMode)
            {
                this->sendDirectMessage(message);
                return;
            }
            m_queuedFsdMessages.enqueue(messageToFSDString(message));
        }
 
        template <class T>
        void sendDirectMessage(const T &message)
        {
            if (!message.isValid()) { return; }
            this->sendMessageString(messageToFSDString(message));
        }
 
        void sendFsdMessage(const QString &message);
        void setUnitTestMode(bool on) { m_unitTestMode = on; }
 
        static const QString &defaultModelString()
        {
            static const QString dm("Cessna Skyhawk 172SP");
            return dm;
        }
 
        static const QString &noModelString()
        {
            static const QString noms("swift empty string");
            return noms;
        }
 
        QString getConfiguredModelString(const swift::misc::simulation::CSimulatedAircraft &myAircraft) const;
 
        QString getConfiguredLiveryString(const swift::misc::simulation::CSimulatedAircraft &myAircraft) const;
 
        struct JsonPackets
        {
            static const QJsonObject &aircraftConfigRequest();
        };
 
        void sendAuthChallenge(const QString &challenge);
        void sendAuthResponse(const QString &response);
        void sendPong(const QString &receiver, const QString &timestamp);
        void sendClientResponse(ClientQueryType queryType, const QString &receiver);
#ifdef SWIFT_VATSIM_SUPPORT
        void sendClientIdentification(const QString &fsdChallenge);
#endif
        void sendIncrementalAircraftConfig();
 
        void readDataFromSocket() { this->readDataFromSocketMaxLines(); }
        void readDataFromSocketMaxLines(int maxLines = -1);
        void parseMessage(const QString &lineRaw);
 
        QString socketErrorString(QAbstractSocket::SocketError error) const;
        static QString socketErrorToQString(QAbstractSocket::SocketError error);
 
        void initializeMessageTypes();
 
        // Type to string
        const QString &messageTypeToString(MessageType mt) const;
 
        void handleAtcDataUpdate(const QStringList &tokens);
#ifdef SWIFT_VATSIM_SUPPORT
        void handleAuthChallenge(const QStringList &tokens);
        void handleAuthResponse(const QStringList &tokens);
#endif
        void handleDeleteATC(const QStringList &tokens);
        void handleDeletePilot(const QStringList &tokens);
        void handleTextMessage(const QStringList &tokens);
        void handlePilotDataUpdate(const QStringList &tokens);
        void handleVisualPilotDataUpdate(const QStringList &tokens, MessageType messageType);
        void handleVisualPilotDataToggle(const QStringList &tokens);
        void handleEuroscopeSimData(const QStringList &tokens);
        void handlePing(const QStringList &tokens);
        void handlePong(const QStringList &tokens);
        void handleKillRequest(const QStringList &tokens);
        void handleFlightPlan(const QStringList &tokens);
        void handleClientQuery(const QStringList &tokens);
        void handleClientResponse(const QStringList &tokens);
        void handleServerError(const QStringList &tokens);
        void handleCustomPilotPacket(const QStringList &tokens);
#ifdef SWIFT_VATSIM_SUPPORT
        void handleFsdIdentification(const QStringList &tokens);
#endif
        void handleRehost(const QStringList &tokens);
        void handleMute(const QStringList &tokens);
 
        //
        void handleUnknownPacket(const QString &line);
        void handleUnknownPacket(const QStringList &tokens);
 
        void printSocketError(QAbstractSocket::SocketError socketError);
        void handleSocketError(QAbstractSocket::SocketError socketError);
        void handleSocketConnected();
 
        void updateConnectionStatus(swift::misc::network::CConnectionStatus newStatus);
 
        void consolidateTextMessage(const swift::misc::network::CTextMessage &textMessage);
 
        void emitConsolidatedTextMessages();
 
        qint64 receivedPositionFixTsAndGetOffsetTime(const swift::misc::aviation::CCallsign &callsign,
                                                     qint64 markerTs = -1);
 
        qint64 currentOffsetTime(const swift::misc::aviation::CCallsign &callsign) const;
 
        void clearState();
 
        void clearState(const swift::misc::aviation::CCallsign &callsign);
 
        void insertLatestOffsetTime(const swift::misc::aviation::CCallsign &callsign, qint64 offsetMs);
 
        qint64 averageOffsetTimeMs(const swift::misc::aviation::CCallsign &callsign, int &count,
                                   int maxLastValues = c_maxOffsetTimes) const;
 
        bool isInterimPositionSendingEnabledForServer() const;
        bool isInterimPositionReceivingEnabledForServer() const;
        bool isVisualPositionSendingEnabledForServer() const;
        const swift::misc::network::CFsdSetup &getSetupForServer() const;
 
        void maybeHandleAtisReply(const swift::misc::aviation::CCallsign &sender,
                                  const swift::misc::aviation::CCallsign &receiver, const QString &message);
 
        void fsdMessageSettingsChanged();
 
        void emitRawFsdMessage(const QString &fsdMessage, bool isSent);
 
        bool saveNetworkStatistics(const QString &server);
 
        void startPositionTimers();
        void stopPositionTimers();
 
        void updateAtisMap(const QString &callsign, AtisLineType type, const QString &line);
 
        void pendingTimeoutCheck();
 
        static swift::misc::physical_quantities::CLength
        fixAtcRange(const swift::misc::physical_quantities::CLength &networkRange,
                    const swift::misc::aviation::CCallsign &cs);
 
        static swift::misc::physical_quantities::CLength
        maxOrNotNull(const swift::misc::physical_quantities::CLength &l1,
                     const swift::misc::physical_quantities::CLength &l2);
 
        static QString noColons(const QString &input);
 
        void getVatsimAuthToken(const QString &cid, const QString &password,
                                const swift::misc::CSlot<void(const QString &)> &callback);
 
        static FlightType getFlightType(swift::misc::aviation::CFlightPlan::FlightRules flightRule);
 
#ifdef SWIFT_VATSIM_SUPPORT
        vatsim_auth *m_clientAuth = nullptr;
        vatsim_auth *m_serverAuth = nullptr;
#endif
        QString m_lastServerAuthChallenge;
        qint64 m_loginSince = -1; 
        static constexpr qint64 PendingConnectionTimeoutMs = 7500;
 
        // Parser
        QHash<QString, MessageType> m_messageTypeMapping;
 
        std::shared_ptr<QTcpSocket> m_socket =
            std::make_shared<QTcpSocket>(this); 
        void connectSocketSignals();
        void initiateConnection(std::shared_ptr<QTcpSocket> rehostingSocket = {}, const QString &rehostingHost = {});
        void resolveLoadBalancing(const QString &host, std::function<void(const QString &)> callback);
        bool m_rehosting = false;
 
        std::atomic_bool m_unitTestMode { false };
        std::atomic_bool m_printToConsole { false };
 
        swift::misc::network::CConnectionStatus m_connectionStatus;
        mutable QReadWriteLock m_lockConnectionStatus { QReadWriteLock::Recursive };
 
        swift::misc::aviation::CAircraftParts m_sentAircraftConfig; 
        swift::misc::CTokenBucket m_tokenBucket; 
        swift::misc::aviation::CCallsignSet m_interimPositionReceivers; 
        swift::misc::network::CTextMessageList m_textMessagesToConsolidate; 
        misc::CDigestSignal m_dsSendTextMessage { this, &CFSDClient::emitConsolidatedTextMessages,
                                                  std::chrono::milliseconds(250), 10 };
 
        struct AtisMessage
        {
            QString m_voiceRoom;
            QStringList m_textLines;
            QString m_zuluLogoff;
            int m_lineCount = 0;
        };
 
        QMap<QString, AtisMessage> m_mapAtisMessages;
 
        struct PendingAtisQuery
        {
            QDateTime m_queryTime = QDateTime::currentDateTimeUtc();
            QStringList m_atisMessage;
        };
 
        QHash<swift::misc::aviation::CCallsign, PendingAtisQuery> m_pendingAtisQueries;
        QHash<swift::misc::aviation::CCallsign, qint64> m_lastPositionUpdate;
        QHash<swift::misc::aviation::CCallsign, QList<qint64>> m_lastOffsetTimes; 
 
        swift::misc::aviation::CAtcStationList m_atcStations;
 
        swift::misc::CSettingReadOnly<swift::core::vatsim::TRawFsdMessageSetting> m_fsdMessageSetting {
            this, &CFSDClient::fsdMessageSettingsChanged
        };
        QFile m_rawFsdMessageLogFile;
        std::atomic_bool m_rawFsdMessagesEnabled { false };
        std::atomic_bool m_filterPasswordFromLogin { false };
 
        // timer parents are needed as we move to thread
        QTimer m_scheduledConfigUpdate { this }; 
        QTimer m_positionUpdateTimer { this }; 
        QTimer m_interimPositionUpdateTimer { this }; 
        QTimer m_visualPositionUpdateTimer { this }; 
        QTimer m_fsdSendMessageTimer { this }; 
 
        qint64 m_additionalOffsetTime = 0; 
 
        std::atomic_bool m_statistics { false };
        QMap<QString, int> m_callStatistics; 
        QVector<QPair<qint64, QString>> m_callByTime; 
        mutable QReadWriteLock m_lockStatistics { QReadWriteLock::Recursive }; 
 
        // User data
        swift::misc::network::CServer m_server;
        swift::misc::network::CLoginMode m_loginMode;
        QStringEncoder m_encoder;
        QStringDecoder m_decoder;
        SimType m_simType = SimType::Unknown;
        PilotRating m_pilotRating = PilotRating::Unknown;
        AtcRating m_atcRating = AtcRating::Unknown;
        swift::misc::simulation::CSimulatorInfo m_simTypeInfo; // same as m_simType
 
        // Client data
        QString m_clientName;
        QString m_hostApplication;
        int m_versionMajor = 0;
        int m_versionMinor = 0;
        int m_protocolRevision = 0;
        ServerType m_serverType = ServerType::LegacyFsd;
        Capabilities m_capabilities = Capabilities::None;
 
        // buffered data for FSD
        swift::misc::aviation::CCallsign m_ownCallsign; 
        swift::misc::aviation::CCallsign
            m_partnerCallsign; 
        swift::misc::aviation::CAircraftIcaoCode
            m_ownAircraftIcaoCode; 
        swift::misc::aviation::CAirlineIcaoCode
            m_ownAirlineIcaoCode; 
        QString m_ownLivery; 
        QString m_ownModelString; 
        std::atomic_bool m_sendLiveryString { true };
        std::atomic_bool m_sendModelString { true };
 
        mutable QReadWriteLock m_lockUserClientBuffered {
            QReadWriteLock::Recursive
        }; 
        QString getOwnCallsignAsString() const
        {
            QReadLocker l(&m_lockUserClientBuffered);
            return m_ownCallsign.asString();
        }
 
        QQueue<QString> m_queuedFsdMessages;
 
        void handleIllegalFsdState(const QString &message);
 
        static int constexpr c_maxOffsetTimes = 6; 
        static int constexpr c_processingIntervalMsec = 100; 
        static int constexpr c_updatePositionIntervalMsec =
            5000; 
        static int constexpr c_updateInterimPositionIntervalMsec =
            1000; 
        static int constexpr c_updateVisualPositionIntervalMsec =
            200; 
        static int constexpr c_sendFsdMsgIntervalMsec = 10; 
        bool m_stoppedSendingVisualPositions = false; 
        bool m_serverWantsVisualPositions = false; 
        unsigned m_visualPositionUpdateSentCount = 0; 
    };
} // namespace swift::core::fsd
 
#endif // SWIFT_CORE_FSD_CLIENT_H