qftpcompat.h

Go to the documentation of this file.

 
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "qftpcompatdirentry.h"
 
#include <QAbstractSocket>
#include <QObject>
#include <QQueue>
#include <QSslConfiguration>
#include <QSslError>
#include <QSslSocket>
#include <QUrl>
 
class QIODevice;
class QByteArray;
 
namespace QFtpCompatInternal { struct Command; }

class QFtpCompat : public QObject
{
    Q_OBJECT
 
public:
    // -----------------------------------------------------------------
    // Enumerations
    // -----------------------------------------------------------------

    enum class State {
        Unconnected, 
        Connecting,  
        Connected,   
        LoggedIn,    
        Closing,     
    };
    Q_ENUM(State)
 
    
    enum class Error {
        NoError,            
        HostNotFound,       
        ConnectionRefused,  
        NetworkTimeout,     
        NetworkError,       
        NotConnected,       
        NotLoggedIn,        
        LoginFailed,        
        FileNotFound,       
        PermissionDenied,   
        ServerError,        
        ParseError,         
        LocalFileError,     
        Aborted,            
        TransferFailed,     
        UnknownError,       
        // TLS-specific
        TlsHandshakeFailed, 
        AuthTlsRejected,    
    };
    Q_ENUM(Error)
 
    
    enum class TransferMode {
        Passive, 
        Active,  
    };
    Q_ENUM(TransferMode)
 
    
    enum class TransferType {
        Binary, 
        Ascii,  
    };
    Q_ENUM(TransferType)
 
    
    enum class EncryptionMode {
        None,
        Explicit,
        Implicit,
    };
    Q_ENUM(EncryptionMode)
 
    // -----------------------------------------------------------------
    // Construction
    // -----------------------------------------------------------------
 
    explicit QFtpCompat(QObject *parent = nullptr);
    ~QFtpCompat() override;
 
    // -----------------------------------------------------------------
    // Connection commands
    // -----------------------------------------------------------------

    int open(const QUrl &url,
             EncryptionMode mode = EncryptionMode::None);

    void close();

    void abort();
 
    // -----------------------------------------------------------------
    // Transfer commands
    // -----------------------------------------------------------------

    int get(const QUrl &url, QIODevice *dst,
            TransferType type = TransferType::Binary);

    int get(const QUrl &url, QByteArray *dst,
            TransferType type = TransferType::Binary);

    int put(const QUrl &url, const QByteArray &data,
            TransferType type = TransferType::Binary);

    int put(const QUrl &url, QIODevice *src,
            TransferType type = TransferType::Binary);
 
    // -----------------------------------------------------------------
    // Directory / file-management commands
    // -----------------------------------------------------------------

    int list(const QUrl &url);

    int mkdir(const QUrl &url);

    int rmdir(const QUrl &url);

    int remove(const QUrl &url);

    int rename(const QUrl &from, const QUrl &to);

    int cd(const QUrl &url);

    int pwd();

    int rawCommand(const QString &command);
 
    // -----------------------------------------------------------------
    // State queries
    // -----------------------------------------------------------------

    [[nodiscard]] State  state()       const noexcept;
    [[nodiscard]] Error  error()       const noexcept;
    [[nodiscard]] QString errorString() const noexcept;
    [[nodiscard]] int    currentId()   const noexcept;
    [[nodiscard]] bool   hasPendingCommands() const noexcept;

    // -----------------------------------------------------------------
    // TLS / SSL
    // -----------------------------------------------------------------

    void setSslConfiguration(const QSslConfiguration &config);

    [[nodiscard]] QSslConfiguration sslConfiguration() const;

    void ignoreSslErrors();
 
    void clearPendingCommands();

    void resetConnection();
 
signals:
    void stateChanged(QFtpCompat::State newState);

    void commandStarted(int id);

    void commandFinished(int id, bool error);

    void done(bool error);

    void listInfo(QFtpCompatDirEntry entry);

    void dataTransferProgress(qint64 bytesTransferred, qint64 bytesTotal);

    void rawCommandReply(int code, QString detail);

    void sslErrors(const QList<QSslError> &errors);
 
private slots:
    void onControlConnected();
    void onControlReadyRead();
    void onControlError(QAbstractSocket::SocketError socketError);
 
    void onDataConnected();
    void onDataReadyRead();
    void onDataDisconnected();
    void onDataError(QAbstractSocket::SocketError socketError);
    void onTransferCompleted();
 
private:
    // -----------------------------------------------------------------
    // Internal state machine
    // -----------------------------------------------------------------
    enum class ControlState {
        Idle,
        WaitingForWelcome,
        WaitingForUserAck,
        WaitingForPassAck,
        WaitingForTypeAck,
        WaitingForPasvAck,
        ConnectingData,
        WaitingForTransferStartAck,
        Transferring,
        WaitingForTransferCompleteAck,
        WaitingForSimpleAck,    
        WaitingForRnfrAck,
        WaitingForRntoAck,
        WaitingForAbortAck,
        WaitingForQuitAck,
        // TLS-specific states
        WaitingForAuthTlsAck,       
        WaitingForPbszAck,          
        WaitingForProtAck,          
        WaitingForControlHandshake, 
        WaitingForDataHandshake,    
    };
 
    // -----------------------------------------------------------------
    // Command queue management
    // -----------------------------------------------------------------
    int  enqueue(QFtpCompatInternal::Command *cmd);
    void startNextCommand();
    void startCurrentCommand();
 
    void finalizeCommand(bool hadError);
 
    // -----------------------------------------------------------------
    // FTP protocol helpers
    // -----------------------------------------------------------------
    void sendCommand(const QByteArray &cmd);
    void processResponse(int code, const QByteArray &message);
 
    void beginDataTransfer();       
    void sendTypeCommand();
    void sendPasv();
    void sendDataTransferCommand(); 
    void startDataChannelEncryption(); 
 
    [[nodiscard]] bool parsePasvAddress(const QByteArray &msg,
                                        QString &host, quint16 &port) const;
 
    void setError(Error err, const QString &detail);
    void setState(State s);
 
    [[nodiscard]] bool isDataTransferCommand() const noexcept;
 
    // -----------------------------------------------------------------
    // Data
    // -----------------------------------------------------------------
    QSslSocket *m_control{nullptr};
    QSslSocket *m_data{nullptr};
 
    EncryptionMode  m_encMode{EncryptionMode::None};
    QSslConfiguration m_sslConfig{QSslConfiguration::defaultConfiguration()};
 
    QByteArray m_dataReadBuf;     
 
    State        m_state{State::Unconnected};
    ControlState m_ctrlState{ControlState::Idle};
    Error        m_error{Error::NoError};
    QString      m_errorString;
 
    QString  m_host;
    quint16  m_port{21};
 
    // Current command
    QFtpCompatInternal::Command *m_current{nullptr};
    QQueue<QFtpCompatInternal::Command *> m_queue;
 
    int m_nextId{0};
 
    // Data-channel completion flags (see DownloadManager design notes)
    bool m_dataChannelClosed{false};
    bool m_ctrlTransferComplete{false};
 
    bool m_abortPending{false};
 
    qint64 m_downloadReceived{0};   
    qint64 m_uploadTotal{0};        
    qint64 m_uploadTransferred{0};  
};