/****************************************************************************+
−
**+
−
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).+
−
** All rights reserved.+
−
** Contact: Nokia Corporation (qt-info@nokia.com)+
−
**+
−
** This file is part of the QtNetwork module of the Qt Toolkit.+
−
**+
−
** $QT_BEGIN_LICENSE:LGPL$+
−
** No Commercial Usage+
−
** This file contains pre-release code and may not be distributed.+
−
** You may use this file in accordance with the terms and conditions+
−
** contained in the Technology Preview License Agreement accompanying+
−
** this package.+
−
**+
−
** GNU Lesser General Public License Usage+
−
** Alternatively, this file may be used under the terms of the GNU Lesser+
−
** General Public License version 2.1 as published by the Free Software+
−
** Foundation and appearing in the file LICENSE.LGPL included in the+
−
** packaging of this file.  Please review the following information to+
−
** ensure the GNU Lesser General Public License version 2.1 requirements+
−
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.+
−
**+
−
** In addition, as a special exception, Nokia gives you certain additional+
−
** rights.  These rights are described in the Nokia Qt LGPL Exception+
−
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.+
−
**+
−
** If you have questions regarding the use of this file, please contact+
−
** Nokia at qt-info@nokia.com.+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
**+
−
** $QT_END_LICENSE$+
−
**+
−
****************************************************************************/+
−
+
−
//#define QFTPPI_DEBUG+
−
//#define QFTPDTP_DEBUG+
−
+
−
#include "qftp.h"+
−
#include "qabstractsocket.h"+
−
+
−
#ifndef QT_NO_FTP+
−
+
−
#include "qcoreapplication.h"+
−
#include "qtcpsocket.h"+
−
#include "qurlinfo.h"+
−
#include "qstringlist.h"+
−
#include "qregexp.h"+
−
#include "qtimer.h"+
−
#include "qfileinfo.h"+
−
#include "qhash.h"+
−
#include "qtcpserver.h"+
−
#include "qlocale.h"+
−
+
−
QT_BEGIN_NAMESPACE+
−
+
−
class QFtpPI;+
−
+
−
/*+
−
    The QFtpDTP (DTP = Data Transfer Process) controls all client side+
−
    data transfer between the client and server.+
−
*/+
−
class QFtpDTP : public QObject+
−
{+
−
    Q_OBJECT+
−
+
−
public:+
−
    enum ConnectState {+
−
        CsHostFound,+
−
        CsConnected,+
−
        CsClosed,+
−
        CsHostNotFound,+
−
        CsConnectionRefused+
−
    };+
−
+
−
    QFtpDTP(QFtpPI *p, QObject *parent = 0);+
−
+
−
    void setData(QByteArray *);+
−
    void setDevice(QIODevice *);+
−
    void writeData();+
−
    void setBytesTotal(qint64 bytes);+
−
+
−
    bool hasError() const;+
−
    QString errorMessage() const;+
−
    void clearError();+
−
+
−
    void connectToHost(const QString & host, quint16 port);+
−
    int setupListener(const QHostAddress &address);+
−
    void waitForConnection();+
−
+
−
    QTcpSocket::SocketState state() const;+
−
    qint64 bytesAvailable() const;+
−
    qint64 read(char *data, qint64 maxlen);+
−
    QByteArray readAll();+
−
+
−
    void abortConnection();+
−
+
−
    static bool parseDir(const QByteArray &buffer, const QString &userName, QUrlInfo *info);+
−
+
−
signals:+
−
    void listInfo(const QUrlInfo&);+
−
    void readyRead();+
−
    void dataTransferProgress(qint64, qint64);+
−
+
−
    void connectState(int);+
−
+
−
private slots:+
−
    void socketConnected();+
−
    void socketReadyRead();+
−
    void socketError(QAbstractSocket::SocketError);+
−
    void socketConnectionClosed();+
−
    void socketBytesWritten(qint64);+
−
    void setupSocket();+
−
+
−
    void dataReadyRead();+
−
+
−
private:+
−
    void clearData();+
−
+
−
    QTcpSocket *socket;+
−
    QTcpServer listener;+
−
+
−
    QFtpPI *pi;+
−
    QString err;+
−
    qint64 bytesDone;+
−
    qint64 bytesTotal;+
−
    bool callWriteData;+
−
+
−
    // If is_ba is true, ba is used; ba is never 0.+
−
    // Otherwise dev is used; dev can be 0 or not.+
−
    union {+
−
        QByteArray *ba;+
−
        QIODevice *dev;+
−
    } data;+
−
    bool is_ba;+
−
+
−
    QByteArray bytesFromSocket;+
−
};+
−
+
−
/**********************************************************************+
−
 *+
−
 * QFtpPI - Protocol Interpreter+
−
 *+
−
 *********************************************************************/+
−
+
−
class QFtpPI : public QObject+
−
{+
−
    Q_OBJECT+
−
+
−
public:+
−
    QFtpPI(QObject *parent = 0);+
−
+
−
    void connectToHost(const QString &host, quint16 port);+
−
+
−
    bool sendCommands(const QStringList &cmds);+
−
    bool sendCommand(const QString &cmd)+
−
        { return sendCommands(QStringList(cmd)); }+
−
+
−
    void clearPendingCommands();+
−
    void abort();+
−
+
−
    QString currentCommand() const+
−
        { return currentCmd; }+
−
+
−
    bool rawCommand;+
−
    bool transferConnectionExtended;+
−
+
−
    QFtpDTP dtp; // the PI has a DTP which is not the design of RFC 959, but it+
−
                 // makes the design simpler this way+
−
signals:+
−
    void connectState(int);+
−
    void finished(const QString&);+
−
    void error(int, const QString&);+
−
    void rawFtpReply(int, const QString&);+
−
+
−
private slots:+
−
    void hostFound();+
−
    void connected();+
−
    void connectionClosed();+
−
    void delayedCloseFinished();+
−
    void readyRead();+
−
    void error(QAbstractSocket::SocketError);+
−
+
−
    void dtpConnectState(int);+
−
+
−
private:+
−
    // the states are modelled after the generalized state diagram of RFC 959,+
−
    // page 58+
−
    enum State {+
−
        Begin,+
−
        Idle,+
−
        Waiting,+
−
        Success,+
−
        Failure+
−
    };+
−
+
−
    enum AbortState {+
−
        None,+
−
        AbortStarted,+
−
        WaitForAbortToFinish+
−
    };+
−
+
−
    bool processReply();+
−
    bool startNextCmd();+
−
+
−
    QTcpSocket commandSocket;+
−
    QString replyText;+
−
    char replyCode[3];+
−
    State state;+
−
    AbortState abortState;+
−
    QStringList pendingCommands;+
−
    QString currentCmd;+
−
+
−
    bool waitForDtpToConnect;+
−
    bool waitForDtpToClose;+
−
+
−
    QByteArray bytesFromSocket;+
−
+
−
    friend class QFtpDTP;+
−
};+
−
+
−
/**********************************************************************+
−
 *+
−
 * QFtpCommand implemenatation+
−
 *+
−
 *********************************************************************/+
−
class QFtpCommand+
−
{+
−
public:+
−
    QFtpCommand(QFtp::Command cmd, QStringList raw, const QByteArray &ba);+
−
    QFtpCommand(QFtp::Command cmd, QStringList raw, QIODevice *dev = 0);+
−
    ~QFtpCommand();+
−
+
−
    int id;+
−
    QFtp::Command command;+
−
    QStringList rawCmds;+
−
+
−
    // If is_ba is true, ba is used; ba is never 0.+
−
    // Otherwise dev is used; dev can be 0 or not.+
−
    union {+
−
        QByteArray *ba;+
−
        QIODevice *dev;+
−
    } data;+
−
    bool is_ba;+
−
+
−
    static QBasicAtomicInt idCounter;+
−
};+
−
+
−
QBasicAtomicInt QFtpCommand::idCounter = Q_BASIC_ATOMIC_INITIALIZER(1);+
−
+
−
QFtpCommand::QFtpCommand(QFtp::Command cmd, QStringList raw, const QByteArray &ba)+
−
    : command(cmd), rawCmds(raw), is_ba(true)+
−
{+
−
    id = idCounter.fetchAndAddRelaxed(1);+
−
    data.ba = new QByteArray(ba);+
−
}+
−
+
−
QFtpCommand::QFtpCommand(QFtp::Command cmd, QStringList raw, QIODevice *dev)+
−
    : command(cmd), rawCmds(raw), is_ba(false)+
−
{+
−
    id = idCounter.fetchAndAddRelaxed(1);+
−
    data.dev = dev;+
−
}+
−
+
−
QFtpCommand::~QFtpCommand()+
−
{+
−
    if (is_ba)+
−
        delete data.ba;+
−
}+
−
+
−
/**********************************************************************+
−
 *+
−
 * QFtpDTP implemenatation+
−
 *+
−
 *********************************************************************/+
−
QFtpDTP::QFtpDTP(QFtpPI *p, QObject *parent) :+
−
    QObject(parent),+
−
    socket(0),+
−
    listener(this),+
−
    pi(p),+
−
    callWriteData(false)+
−
{+
−
    clearData();+
−
    listener.setObjectName(QLatin1String("QFtpDTP active state server"));+
−
    connect(&listener, SIGNAL(newConnection()), SLOT(setupSocket()));+
−
}+
−
+
−
void QFtpDTP::setData(QByteArray *ba)+
−
{+
−
    is_ba = true;+
−
    data.ba = ba;+
−
}+
−
+
−
void QFtpDTP::setDevice(QIODevice *dev)+
−
{+
−
    is_ba = false;+
−
    data.dev = dev;+
−
}+
−
+
−
void QFtpDTP::setBytesTotal(qint64 bytes)+
−
{+
−
    bytesTotal = bytes;+
−
    bytesDone = 0;+
−
    emit dataTransferProgress(bytesDone, bytesTotal);+
−
}+
−
+
−
void QFtpDTP::connectToHost(const QString & host, quint16 port)+
−
{+
−
    bytesFromSocket.clear();+
−
+
−
    if (socket) {+
−
        delete socket;+
−
        socket = 0;+
−
    }+
−
    socket = new QTcpSocket(this);+
−
    socket->setObjectName(QLatin1String("QFtpDTP Passive state socket"));+
−
    connect(socket, SIGNAL(connected()), SLOT(socketConnected()));+
−
    connect(socket, SIGNAL(readyRead()), SLOT(socketReadyRead()));+
−
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(socketError(QAbstractSocket::SocketError)));+
−
    connect(socket, SIGNAL(disconnected()), SLOT(socketConnectionClosed()));+
−
    connect(socket, SIGNAL(bytesWritten(qint64)), SLOT(socketBytesWritten(qint64)));+
−
+
−
    socket->connectToHost(host, port);+
−
}+
−
+
−
int QFtpDTP::setupListener(const QHostAddress &address)+
−
{+
−
    if (!listener.isListening() && !listener.listen(address, 0))+
−
        return -1;+
−
    return listener.serverPort();+
−
}+
−
+
−
void QFtpDTP::waitForConnection()+
−
{+
−
    // This function is only interesting in Active transfer mode; it works+
−
    // around a limitation in QFtp's design by blocking, waiting for an+
−
    // incoming connection. For the default Passive mode, it does nothing.+
−
    if (listener.isListening())+
−
        listener.waitForNewConnection();+
−
}+
−
+
−
QTcpSocket::SocketState QFtpDTP::state() const+
−
{+
−
    return socket ? socket->state() : QTcpSocket::UnconnectedState;+
−
}+
−
+
−
qint64 QFtpDTP::bytesAvailable() const+
−
{+
−
    if (!socket || socket->state() != QTcpSocket::ConnectedState)+
−
        return (qint64) bytesFromSocket.size();+
−
    return socket->bytesAvailable();+
−
}+
−
+
−
qint64 QFtpDTP::read(char *data, qint64 maxlen)+
−
{+
−
    qint64 read;+
−
    if (socket && socket->state() == QTcpSocket::ConnectedState) {+
−
        read = socket->read(data, maxlen);+
−
    } else {+
−
        read = bytesFromSocket.size();+
−
        memcpy(data, bytesFromSocket.data(), read);+
−
        bytesFromSocket.clear();+
−
    }+
−
+
−
    bytesDone += read;+
−
    return read;+
−
}+
−
+
−
QByteArray QFtpDTP::readAll()+
−
{+
−
    QByteArray tmp;+
−
    if (socket && socket->state() == QTcpSocket::ConnectedState) {+
−
        tmp = socket->readAll();+
−
        bytesDone += tmp.size();+
−
    } else {+
−
        tmp = bytesFromSocket;+
−
        bytesFromSocket.clear();+
−
    }+
−
    return tmp;+
−
}+
−
+
−
void QFtpDTP::writeData()+
−
{+
−
    if (!socket)+
−
        return;+
−
+
−
    if (is_ba) {+
−
#if defined(QFTPDTP_DEBUG)+
−
        qDebug("QFtpDTP::writeData: write %d bytes", data.ba->size());+
−
#endif+
−
        if (data.ba->size() == 0)+
−
            emit dataTransferProgress(0, bytesTotal);+
−
        else+
−
            socket->write(data.ba->data(), data.ba->size());+
−
+
−
        socket->close();+
−
+
−
        clearData();+
−
    } else if (data.dev) {+
−
        callWriteData = false;+
−
        const qint64 blockSize = 16*1024;+
−
        char buf[16*1024];+
−
        qint64 read = data.dev->read(buf, blockSize);+
−
#if defined(QFTPDTP_DEBUG)+
−
        qDebug("QFtpDTP::writeData: write() of size %lli bytes", read);+
−
#endif+
−
        if (read > 0) {+
−
            socket->write(buf, read);+
−
        } else if (read == -1 || (!data.dev->isSequential() && data.dev->atEnd())) {+
−
            // error or EOF+
−
            if (bytesDone == 0 && socket->bytesToWrite() == 0)+
−
                emit dataTransferProgress(0, bytesTotal);+
−
            socket->close();+
−
            clearData();+
−
        }+
−
+
−
        // do we continue uploading?+
−
        callWriteData = data.dev != 0;+
−
    }+
−
}+
−
+
−
void QFtpDTP::dataReadyRead()+
−
{+
−
    writeData();+
−
}+
−
+
−
inline bool QFtpDTP::hasError() const+
−
{+
−
    return !err.isNull();+
−
}+
−
+
−
inline QString QFtpDTP::errorMessage() const+
−
{+
−
    return err;+
−
}+
−
+
−
inline void QFtpDTP::clearError()+
−
{+
−
    err.clear();+
−
}+
−
+
−
void QFtpDTP::abortConnection()+
−
{+
−
#if defined(QFTPDTP_DEBUG)+
−
    qDebug("QFtpDTP::abortConnection, bytesAvailable == %lli",+
−
           socket ? socket->bytesAvailable() : (qint64) 0);+
−
#endif+
−
    callWriteData = false;+
−
    clearData();+
−
+
−
    if (socket)+
−
        socket->abort();+
−
}+
−
+
−
static void _q_fixupDateTime(QDateTime *dateTime)+
−
{+
−
    // Adjust for future tolerance.+
−
    const int futureTolerance = 86400;+
−
    if (dateTime->secsTo(QDateTime::currentDateTime()) < -futureTolerance) {+
−
        QDate d = dateTime->date();+
−
        d.setYMD(d.year() - 1, d.month(), d.day());+
−
        dateTime->setDate(d);+
−
    }+
−
}+
−
+
−
static void _q_parseUnixDir(const QStringList &tokens, const QString &userName, QUrlInfo *info)+
−
{+
−
    // Unix style, 7 + 1 entries+
−
    // -rw-r--r--    1 ftp      ftp      17358091 Aug 10  2004 qt-x11-free-3.3.3.tar.gz+
−
    // drwxr-xr-x    3 ftp      ftp          4096 Apr 14  2000 compiled-examples+
−
    // lrwxrwxrwx    1 ftp      ftp             9 Oct 29  2005 qtscape -> qtmozilla+
−
    if (tokens.size() != 8)+
−
        return;+
−
+
−
    char first = tokens.at(1).at(0).toLatin1();+
−
    if (first == 'd') {+
−
        info->setDir(true);+
−
        info->setFile(false);+
−
        info->setSymLink(false);+
−
    } else if (first == '-') {+
−
        info->setDir(false);+
−
        info->setFile(true);+
−
        info->setSymLink(false);+
−
    } else if (first == 'l') {+
−
        info->setDir(true);+
−
        info->setFile(false);+
−
        info->setSymLink(true);+
−
    }+
−
+
−
    // Resolve filename+
−
    QString name = tokens.at(7);+
−
    if (info->isSymLink()) {+
−
        int linkPos = name.indexOf(QLatin1String(" ->"));+
−
        if (linkPos != -1)+
−
            name.resize(linkPos);+
−
    }+
−
    info->setName(name);+
−
+
−
    // Resolve owner & group+
−
    info->setOwner(tokens.at(3));+
−
    info->setGroup(tokens.at(4));+
−
+
−
    // Resolve size+
−
    info->setSize(tokens.at(5).toLongLong());+
−
+
−
    QStringList formats;+
−
    formats << QLatin1String("MMM dd  yyyy") << QLatin1String("MMM dd hh:mm") << QLatin1String("MMM  d  yyyy")+
−
            << QLatin1String("MMM  d hh:mm") << QLatin1String("MMM  d yyyy") << QLatin1String("MMM dd yyyy");+
−
+
−
    QString dateString = tokens.at(6);+
−
    dateString[0] = dateString[0].toUpper();+
−
+
−
    // Resolve the modification date by parsing all possible formats+
−
    QDateTime dateTime;+
−
    int n = 0;+
−
#ifndef QT_NO_DATESTRING+
−
    do {+
−
        dateTime = QLocale::c().toDateTime(dateString, formats.at(n++));+
−
    }  while (n < formats.size() && (!dateTime.isValid()));+
−
#endif+
−
+
−
    if (n == 2 || n == 4) {+
−
        // Guess the year.+
−
        dateTime.setDate(QDate(QDate::currentDate().year(),+
−
                               dateTime.date().month(),+
−
                               dateTime.date().day()));+
−
        _q_fixupDateTime(&dateTime);+
−
    }+
−
    if (dateTime.isValid())+
−
        info->setLastModified(dateTime);+
−
+
−
    // Resolve permissions+
−
    int permissions = 0;+
−
    QString p = tokens.at(2);+
−
    permissions |= (p[0] == QLatin1Char('r') ? QUrlInfo::ReadOwner : 0);+
−
    permissions |= (p[1] == QLatin1Char('w') ? QUrlInfo::WriteOwner : 0);+
−
    permissions |= (p[2] == QLatin1Char('x') ? QUrlInfo::ExeOwner : 0);+
−
    permissions |= (p[3] == QLatin1Char('r') ? QUrlInfo::ReadGroup : 0);+
−
    permissions |= (p[4] == QLatin1Char('w') ? QUrlInfo::WriteGroup : 0);+
−
    permissions |= (p[5] == QLatin1Char('x') ? QUrlInfo::ExeGroup : 0);+
−
    permissions |= (p[6] == QLatin1Char('r') ? QUrlInfo::ReadOther : 0);+
−
    permissions |= (p[7] == QLatin1Char('w') ? QUrlInfo::WriteOther : 0);+
−
    permissions |= (p[8] == QLatin1Char('x') ? QUrlInfo::ExeOther : 0);+
−
    info->setPermissions(permissions);+
−
+
−
    bool isOwner = info->owner() == userName;+
−
    info->setReadable((permissions & QUrlInfo::ReadOther) || ((permissions & QUrlInfo::ReadOwner) && isOwner));+
−
    info->setWritable((permissions & QUrlInfo::WriteOther) || ((permissions & QUrlInfo::WriteOwner) && isOwner));+
−
}+
−
+
−
static void _q_parseDosDir(const QStringList &tokens, const QString &userName, QUrlInfo *info)+
−
{+
−
    // DOS style, 3 + 1 entries+
−
    // 01-16-02  11:14AM       <DIR>          epsgroup+
−
    // 06-05-03  03:19PM                 1973 readme.txt+
−
    if (tokens.size() != 4)+
−
        return;+
−
+
−
    Q_UNUSED(userName);+
−
+
−
    QString name = tokens.at(3);+
−
    info->setName(name);+
−
    info->setSymLink(name.toLower().endsWith(QLatin1String(".lnk")));+
−
+
−
    if (tokens.at(2) == QLatin1String("<DIR>")) {+
−
        info->setFile(false);+
−
        info->setDir(true);+
−
    } else {+
−
        info->setFile(true);+
−
        info->setDir(false);+
−
        info->setSize(tokens.at(2).toLongLong());+
−
    }+
−
+
−
    // Note: We cannot use QFileInfo; permissions are for the server-side+
−
    // machine, and QFileInfo's behavior depends on the local platform.+
−
    int permissions = QUrlInfo::ReadOwner | QUrlInfo::WriteOwner+
−
                      | QUrlInfo::ReadGroup | QUrlInfo::WriteGroup+
−
                      | QUrlInfo::ReadOther | QUrlInfo::WriteOther;+
−
    QString ext;+
−
    int extIndex = name.lastIndexOf(QLatin1Char('.'));+
−
    if (extIndex != -1)+
−
        ext = name.mid(extIndex + 1);+
−
    if (ext == QLatin1String("exe") || ext == QLatin1String("bat") || ext == QLatin1String("com"))+
−
        permissions |= QUrlInfo::ExeOwner | QUrlInfo::ExeGroup | QUrlInfo::ExeOther;+
−
    info->setPermissions(permissions);+
−
+
−
    info->setReadable(true);+
−
    info->setWritable(info->isFile());+
−
+
−
    QDateTime dateTime;+
−
#ifndef QT_NO_DATESTRING+
−
    dateTime = QLocale::c().toDateTime(tokens.at(1), QLatin1String("MM-dd-yy  hh:mmAP"));+
−
    if (dateTime.date().year() < 1971) {+
−
        dateTime.setDate(QDate(dateTime.date().year() + 100,+
−
                               dateTime.date().month(),+
−
                               dateTime.date().day()));+
−
    }+
−
#endif+
−
+
−
    info->setLastModified(dateTime);+
−
+
−
}+
−
+
−
bool QFtpDTP::parseDir(const QByteArray &buffer, const QString &userName, QUrlInfo *info)+
−
{+
−
    if (buffer.isEmpty())+
−
        return false;+
−
+
−
    QString bufferStr = QString::fromLatin1(buffer).trimmed();+
−
+
−
    // Unix style FTP servers+
−
    QRegExp unixPattern(QLatin1String("^([\\-dl])([a-zA-Z\\-]{9,9})\\s+\\d+\\s+(\\S*)\\s+"+
−
                                      "(\\S*)\\s+(\\d+)\\s+(\\S+\\s+\\S+\\s+\\S+)\\s+(\\S.*)"));+
−
    if (unixPattern.indexIn(bufferStr) == 0) {+
−
        _q_parseUnixDir(unixPattern.capturedTexts(), userName, info);+
−
        return true;+
−
    }+
−
+
−
    // DOS style FTP servers+
−
    QRegExp dosPattern(QLatin1String("^(\\d\\d-\\d\\d-\\d\\d\\ \\ \\d\\d:\\d\\d[AP]M)\\s+"+
−
                                     "(<DIR>|\\d+)\\s+(\\S.*)$"));+
−
    if (dosPattern.indexIn(bufferStr) == 0) {+
−
        _q_parseDosDir(dosPattern.capturedTexts(), userName, info);+
−
        return true;+
−
    }+
−
+
−
    // Unsupported+
−
    return false;+
−
}+
−
+
−
void QFtpDTP::socketConnected()+
−
{+
−
    bytesDone = 0;+
−
#if defined(QFTPDTP_DEBUG)+
−
    qDebug("QFtpDTP::connectState(CsConnected)");+
−
#endif+
−
    emit connectState(QFtpDTP::CsConnected);+
−
}+
−
+
−
void QFtpDTP::socketReadyRead()+
−
{+
−
    if (!socket)+
−
        return;+
−
+
−
    if (pi->currentCommand().isEmpty()) {+
−
        socket->close();+
−
#if defined(QFTPDTP_DEBUG)+
−
        qDebug("QFtpDTP::connectState(CsClosed)");+
−
#endif+
−
        emit connectState(QFtpDTP::CsClosed);+
−
        return;+
−
    }+
−
+
−
    if (pi->abortState == QFtpPI::AbortStarted) {+
−
        // discard data+
−
        socket->readAll();+
−
        return;+
−
    }+
−
+
−
    if (pi->currentCommand().startsWith(QLatin1String("LIST"))) {+
−
        while (socket->canReadLine()) {+
−
            QUrlInfo i;+
−
            QByteArray line = socket->readLine();+
−
#if defined(QFTPDTP_DEBUG)+
−
            qDebug("QFtpDTP read (list): '%s'", line.constData());+
−
#endif+
−
            if (parseDir(line, QLatin1String(""), &i)) {+
−
                emit listInfo(i);+
−
            } else {+
−
                // some FTP servers don't return a 550 if the file or directory+
−
                // does not exist, but rather write a text to the data socket+
−
                // -- try to catch these cases+
−
                if (line.endsWith("No such file or directory\r\n"))+
−
                    err = QString::fromLatin1(line);+
−
            }+
−
        }+
−
    } else {+
−
        if (!is_ba && data.dev) {+
−
            do {+
−
                QByteArray ba;+
−
                ba.resize(socket->bytesAvailable());+
−
                qint64 bytesRead = socket->read(ba.data(), ba.size());+
−
                if (bytesRead < 0) {+
−
                    // a read following a readyRead() signal will+
−
                    // never fail.+
−
                    return;+
−
                }+
−
                ba.resize(bytesRead);+
−
                bytesDone += bytesRead;+
−
#if defined(QFTPDTP_DEBUG)+
−
                qDebug("QFtpDTP read: %lli bytes (total %lli bytes)", bytesRead, bytesDone);+
−
#endif+
−
                if (data.dev)       // make sure it wasn't deleted in the slot+
−
                    data.dev->write(ba);+
−
                emit dataTransferProgress(bytesDone, bytesTotal);+
−
+
−
                // Need to loop; dataTransferProgress is often connected to+
−
                // slots that update the GUI (e.g., progress bar values), and+
−
                // if events are processed, more data may have arrived.+
−
            } while (socket->bytesAvailable());+
−
        } else {+
−
#if defined(QFTPDTP_DEBUG)+
−
            qDebug("QFtpDTP readyRead: %lli bytes available (total %lli bytes read)",+
−
                   bytesAvailable(), bytesDone);+
−
#endif+
−
            emit dataTransferProgress(bytesDone+socket->bytesAvailable(), bytesTotal);+
−
            emit readyRead();+
−
        }+
−
    }+
−
}+
−
+
−
void QFtpDTP::socketError(QAbstractSocket::SocketError e)+
−
{+
−
    if (e == QTcpSocket::HostNotFoundError) {+
−
#if defined(QFTPDTP_DEBUG)+
−
        qDebug("QFtpDTP::connectState(CsHostNotFound)");+
−
#endif+
−
        emit connectState(QFtpDTP::CsHostNotFound);+
−
    } else if (e == QTcpSocket::ConnectionRefusedError) {+
−
#if defined(QFTPDTP_DEBUG)+
−
        qDebug("QFtpDTP::connectState(CsConnectionRefused)");+
−
#endif+
−
        emit connectState(QFtpDTP::CsConnectionRefused);+
−
    }+
−
}+
−
+
−
void QFtpDTP::socketConnectionClosed()+
−
{+
−
    if (!is_ba && data.dev) {+
−
        clearData();+
−
    }+
−
+
−
    bytesFromSocket = socket->readAll();+
−
#if defined(QFTPDTP_DEBUG)+
−
    qDebug("QFtpDTP::connectState(CsClosed)");+
−
#endif+
−
    emit connectState(QFtpDTP::CsClosed);+
−
}+
−
+
−
void QFtpDTP::socketBytesWritten(qint64 bytes)+
−
{+
−
    bytesDone += bytes;+
−
#if defined(QFTPDTP_DEBUG)+
−
    qDebug("QFtpDTP::bytesWritten(%lli)", bytesDone);+
−
#endif+
−
    emit dataTransferProgress(bytesDone, bytesTotal);+
−
    if (callWriteData)+
−
        writeData();+
−
}+
−
+
−
void QFtpDTP::setupSocket()+
−
{+
−
    socket = listener.nextPendingConnection();+
−
    socket->setObjectName(QLatin1String("QFtpDTP Active state socket"));+
−
    connect(socket, SIGNAL(connected()), SLOT(socketConnected()));+
−
    connect(socket, SIGNAL(readyRead()), SLOT(socketReadyRead()));+
−
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(socketError(QAbstractSocket::SocketError)));+
−
    connect(socket, SIGNAL(disconnected()), SLOT(socketConnectionClosed()));+
−
    connect(socket, SIGNAL(bytesWritten(qint64)), SLOT(socketBytesWritten(qint64)));+
−
+
−
    listener.close();+
−
}+
−
+
−
void QFtpDTP::clearData()+
−
{+
−
    is_ba = false;+
−
    data.dev = 0;+
−
}+
−
+
−
/**********************************************************************+
−
 *+
−
 * QFtpPI implemenatation+
−
 *+
−
 *********************************************************************/+
−
QFtpPI::QFtpPI(QObject *parent) :+
−
    QObject(parent),+
−
    rawCommand(false),+
−
    transferConnectionExtended(true),+
−
    dtp(this),+
−
    commandSocket(0),+
−
    state(Begin), abortState(None),+
−
    currentCmd(QString()),+
−
    waitForDtpToConnect(false),+
−
    waitForDtpToClose(false)+
−
{+
−
    commandSocket.setObjectName(QLatin1String("QFtpPI_socket"));+
−
    connect(&commandSocket, SIGNAL(hostFound()),+
−
            SLOT(hostFound()));+
−
    connect(&commandSocket, SIGNAL(connected()),+
−
            SLOT(connected()));+
−
    connect(&commandSocket, SIGNAL(disconnected()),+
−
            SLOT(connectionClosed()));+
−
    connect(&commandSocket, SIGNAL(readyRead()),+
−
            SLOT(readyRead()));+
−
    connect(&commandSocket, SIGNAL(error(QAbstractSocket::SocketError)),+
−
            SLOT(error(QAbstractSocket::SocketError)));+
−
+
−
    connect(&dtp, SIGNAL(connectState(int)),+
−
             SLOT(dtpConnectState(int)));+
−
}+
−
+
−
void QFtpPI::connectToHost(const QString &host, quint16 port)+
−
{+
−
    emit connectState(QFtp::HostLookup);+
−
    commandSocket.connectToHost(host, port);+
−
}+
−
+
−
/*+
−
  Sends the sequence of commands \a cmds to the FTP server. When the commands+
−
  are all done the finished() signal is emitted. When an error occurs, the+
−
  error() signal is emitted.+
−
+
−
  If there are pending commands in the queue this functions returns false and+
−
  the \a cmds are not added to the queue; otherwise it returns true.+
−
*/+
−
bool QFtpPI::sendCommands(const QStringList &cmds)+
−
{+
−
    if (!pendingCommands.isEmpty())+
−
        return false;+
−
+
−
    if (commandSocket.state() != QTcpSocket::ConnectedState || state!=Idle) {+
−
        emit error(QFtp::NotConnected, QFtp::tr("Not connected"));+
−
        return true; // there are no pending commands+
−
    }+
−
+
−
    pendingCommands = cmds;+
−
    startNextCmd();+
−
    return true;+
−
}+
−
+
−
void QFtpPI::clearPendingCommands()+
−
{+
−
    pendingCommands.clear();+
−
    dtp.abortConnection();+
−
    currentCmd.clear();+
−
    state = Idle;+
−
}+
−
+
−
void QFtpPI::abort()+
−
{+
−
    pendingCommands.clear();+
−
+
−
    if (abortState != None)+
−
        // ABOR already sent+
−
        return;+
−
+
−
    abortState = AbortStarted;+
−
#if defined(QFTPPI_DEBUG)+
−
    qDebug("QFtpPI send: ABOR");+
−
#endif+
−
    commandSocket.write("ABOR\r\n", 6);+
−
+
−
    if (currentCmd.startsWith(QLatin1String("STOR ")))+
−
        dtp.abortConnection();+
−
}+
−
+
−
void QFtpPI::hostFound()+
−
{+
−
    emit connectState(QFtp::Connecting);+
−
}+
−
+
−
void QFtpPI::connected()+
−
{+
−
    state = Begin;+
−
#if defined(QFTPPI_DEBUG)+
−
//    qDebug("QFtpPI state: %d [connected()]", state);+
−
#endif+
−
    // try to improve performance by setting TCP_NODELAY+
−
    commandSocket.setSocketOption(QAbstractSocket::LowDelayOption, 1);+
−
+
−
    emit connectState(QFtp::Connected);+
−
}+
−
+
−
void QFtpPI::connectionClosed()+
−
{+
−
    commandSocket.close();+
−
    emit connectState(QFtp::Unconnected);+
−
}+
−
+
−
void QFtpPI::delayedCloseFinished()+
−
{+
−
    emit connectState(QFtp::Unconnected);+
−
}+
−
+
−
void QFtpPI::error(QAbstractSocket::SocketError e)+
−
{+
−
    if (e == QTcpSocket::HostNotFoundError) {+
−
        emit connectState(QFtp::Unconnected);+
−
        emit error(QFtp::HostNotFound,+
−
                    QFtp::tr("Host %1 not found").arg(commandSocket.peerName()));+
−
    } else if (e == QTcpSocket::ConnectionRefusedError) {+
−
        emit connectState(QFtp::Unconnected);+
−
        emit error(QFtp::ConnectionRefused,+
−
                    QFtp::tr("Connection refused to host %1").arg(commandSocket.peerName()));+
−
    } else if (e == QTcpSocket::SocketTimeoutError) {+
−
        emit connectState(QFtp::Unconnected);+
−
        emit error(QFtp::ConnectionRefused,+
−
                   QFtp::tr("Connection timed out to host %1").arg(commandSocket.peerName()));+
−
    }+
−
}+
−
+
−
void QFtpPI::readyRead()+
−
{+
−
    if (waitForDtpToClose)+
−
        return;+
−
+
−
    while (commandSocket.canReadLine()) {+
−
        // read line with respect to line continuation+
−
        QString line = QString::fromAscii(commandSocket.readLine());+
−
        if (replyText.isEmpty()) {+
−
            if (line.length() < 3) {+
−
                // protocol error+
−
                return;+
−
            }+
−
            const int lowerLimit[3] = {1,0,0};+
−
            const int upperLimit[3] = {5,5,9};+
−
            for (int i=0; i<3; i++) {+
−
                replyCode[i] = line[i].digitValue();+
−
                if (replyCode[i]<lowerLimit[i] || replyCode[i]>upperLimit[i]) {+
−
                    // protocol error+
−
                    return;+
−
                }+
−
            }+
−
        }+
−
        QString endOfMultiLine;+
−
        endOfMultiLine[0] = '0' + replyCode[0];+
−
        endOfMultiLine[1] = '0' + replyCode[1];+
−
        endOfMultiLine[2] = '0' + replyCode[2];+
−
        endOfMultiLine[3] = QLatin1Char(' ');+
−
        QString lineCont(endOfMultiLine);+
−
        lineCont[3] = QLatin1Char('-');+
−
        QString lineLeft4 = line.left(4);+
−
+
−
        while (lineLeft4 != endOfMultiLine) {+
−
            if (lineLeft4 == lineCont)+
−
                replyText += line.mid(4); // strip 'xyz-'+
−
            else+
−
                replyText += line;+
−
            if (!commandSocket.canReadLine())+
−
                return;+
−
            line = QString::fromAscii(commandSocket.readLine());+
−
            lineLeft4 = line.left(4);+
−
        }+
−
        replyText += line.mid(4); // strip reply code 'xyz '+
−
        if (replyText.endsWith(QLatin1String("\r\n")))+
−
            replyText.chop(2);+
−
+
−
        if (processReply())+
−
            replyText = QLatin1String("");+
−
    }+
−
}+
−
+
−
/*+
−
  Process a reply from the FTP server.+
−
+
−
  Returns true if the reply was processed or false if the reply has to be+
−
  processed at a later point.+
−
*/+
−
bool QFtpPI::processReply()+
−
{+
−
#if defined(QFTPPI_DEBUG)+
−
//    qDebug("QFtpPI state: %d [processReply() begin]", state);+
−
    if (replyText.length() < 400)+
−
        qDebug("QFtpPI recv: %d %s", 100*replyCode[0]+10*replyCode[1]+replyCode[2], replyText.toLatin1().constData());+
−
    else+
−
        qDebug("QFtpPI recv: %d (text skipped)", 100*replyCode[0]+10*replyCode[1]+replyCode[2]);+
−
#endif+
−
+
−
    int replyCodeInt = 100*replyCode[0] + 10*replyCode[1] + replyCode[2];+
−
+
−
    // process 226 replies ("Closing Data Connection") only when the data+
−
    // connection is really closed to avoid short reads of the DTP+
−
    if (replyCodeInt == 226 || (replyCodeInt == 250 && currentCmd.startsWith(QLatin1String("RETR")))) {+
−
        if (dtp.state() != QTcpSocket::UnconnectedState) {+
−
            waitForDtpToClose = true;+
−
            return false;+
−
        }+
−
    }+
−
+
−
    switch (abortState) {+
−
        case AbortStarted:+
−
            abortState = WaitForAbortToFinish;+
−
            break;+
−
        case WaitForAbortToFinish:+
−
            abortState = None;+
−
            return true;+
−
        default:+
−
            break;+
−
    }+
−
+
−
    // get new state+
−
    static const State table[5] = {+
−
        /* 1yz   2yz      3yz   4yz      5yz */+
−
        Waiting, Success, Idle, Failure, Failure+
−
    };+
−
    switch (state) {+
−
        case Begin:+
−
            if (replyCode[0] == 1) {+
−
                return true;+
−
            } else if (replyCode[0] == 2) {+
−
                state = Idle;+
−
                emit finished(QFtp::tr("Connected to host %1").arg(commandSocket.peerName()));+
−
                break;+
−
            }+
−
            // reply codes not starting with 1 or 2 are not handled.+
−
            return true;+
−
        case Waiting:+
−
            if (static_cast<signed char>(replyCode[0]) < 0 || replyCode[0] > 5)+
−
                state = Failure;+
−
            else+
−
#if defined(Q_OS_IRIX) && defined(Q_CC_GNU)+
−
            {+
−
                // work around a crash on 64 bit gcc IRIX+
−
                State *t = (State *) table;+
−
                state = t[replyCode[0] - 1];+
−
            }+
−
#else+
−
            if (replyCodeInt == 202)+
−
                state = Failure;+
−
            else+
−
                state = table[replyCode[0] - 1];+
−
#endif+
−
            break;+
−
        default:+
−
            // ignore unrequested message+
−
            return true;+
−
    }+
−
#if defined(QFTPPI_DEBUG)+
−
//    qDebug("QFtpPI state: %d [processReply() intermediate]", state);+
−
#endif+
−
+
−
    // special actions on certain replies+
−
    emit rawFtpReply(replyCodeInt, replyText);+
−
    if (rawCommand) {+
−
        rawCommand = false;+
−
    } else if (replyCodeInt == 227) {+
−
        // 227 Entering Passive Mode (h1,h2,h3,h4,p1,p2)+
−
        // rfc959 does not define this response precisely, and gives+
−
        // both examples where the parenthesis are used, and where+
−
        // they are missing. We need to scan for the address and host+
−
        // info.+
−
        QRegExp addrPortPattern(QLatin1String("(\\d+),(\\d+),(\\d+),(\\d+),(\\d+),(\\d+)"));+
−
        if (addrPortPattern.indexIn(replyText) == -1) {+
−
#if defined(QFTPPI_DEBUG)+
−
            qDebug("QFtp: bad 227 response -- address and port information missing");+
−
#endif+
−
            // this error should be reported+
−
        } else {+
−
            QStringList lst = addrPortPattern.capturedTexts();+
−
            QString host = lst[1] + QLatin1Char('.') + lst[2] + QLatin1Char('.') + lst[3] + QLatin1Char('.') + lst[4];+
−
            quint16 port = (lst[5].toUInt() << 8) + lst[6].toUInt();+
−
            waitForDtpToConnect = true;+
−
            dtp.connectToHost(host, port);+
−
        }+
−
    } else if (replyCodeInt == 229) {+
−
        // 229 Extended Passive mode OK (|||10982|)+
−
        int portPos = replyText.indexOf(QLatin1Char('('));+
−
        if (portPos == -1) {+
−
#if defined(QFTPPI_DEBUG)+
−
            qDebug("QFtp: bad 229 response -- port information missing");+
−
#endif+
−
            // this error should be reported+
−
        } else {+
−
            ++portPos;+
−
            QChar delimiter = replyText.at(portPos);+
−
            QStringList epsvParameters = replyText.mid(portPos).split(delimiter);+
−
+
−
            waitForDtpToConnect = true;+
−
            dtp.connectToHost(commandSocket.peerAddress().toString(),+
−
                              epsvParameters.at(3).toInt());+
−
        }+
−
+
−
    } else if (replyCodeInt == 230) {+
−
        if (currentCmd.startsWith(QLatin1String("USER ")) && pendingCommands.count()>0 &&+
−
            pendingCommands.first().startsWith(QLatin1String("PASS "))) {+
−
            // no need to send the PASS -- we are already logged in+
−
            pendingCommands.pop_front();+
−
        }+
−
        // 230 User logged in, proceed.+
−
        emit connectState(QFtp::LoggedIn);+
−
    } else if (replyCodeInt == 213) {+
−
        // 213 File status.+
−
        if (currentCmd.startsWith(QLatin1String("SIZE ")))+
−
            dtp.setBytesTotal(replyText.simplified().toLongLong());+
−
    } else if (replyCode[0]==1 && currentCmd.startsWith(QLatin1String("STOR "))) {+
−
        dtp.waitForConnection();+
−
        dtp.writeData();+
−
    }+
−
+
−
    // react on new state+
−
    switch (state) {+
−
        case Begin:+
−
            // should never happen+
−
            break;+
−
        case Success:+
−
            // success handling+
−
            state = Idle;+
−
            // no break!+
−
        case Idle:+
−
            if (dtp.hasError()) {+
−
                emit error(QFtp::UnknownError, dtp.errorMessage());+
−
                dtp.clearError();+
−
            }+
−
            startNextCmd();+
−
            break;+
−
        case Waiting:+
−
            // do nothing+
−
            break;+
−
        case Failure:+
−
            // If the EPSV or EPRT commands fail, replace them with+
−
            // the old PASV and PORT instead and try again.+
−
            if (currentCmd.startsWith(QLatin1String("EPSV"))) {+
−
                transferConnectionExtended = false;+
−
                pendingCommands.prepend(QLatin1String("PASV\r\n"));+
−
            } else if (currentCmd.startsWith(QLatin1String("EPRT"))) {+
−
                transferConnectionExtended = false;+
−
                pendingCommands.prepend(QLatin1String("PORT\r\n"));+
−
            } else {+
−
                emit error(QFtp::UnknownError, replyText);+
−
            }+
−
            if (state != Waiting) {+
−
                state = Idle;+
−
                startNextCmd();+
−
            }+
−
            break;+
−
    }+
−
#if defined(QFTPPI_DEBUG)+
−
//    qDebug("QFtpPI state: %d [processReply() end]", state);+
−
#endif+
−
    return true;+
−
}+
−
+
−
/*+
−
  Starts next pending command. Returns false if there are no pending commands,+
−
  otherwise it returns true.+
−
*/+
−
bool QFtpPI::startNextCmd()+
−
{+
−
    if (waitForDtpToConnect)+
−
        // don't process any new commands until we are connected+
−
        return true;+
−
+
−
#if defined(QFTPPI_DEBUG)+
−
    if (state != Idle)+
−
        qDebug("QFtpPI startNextCmd: Internal error! QFtpPI called in non-Idle state %d", state);+
−
#endif+
−
    if (pendingCommands.isEmpty()) {+
−
        currentCmd.clear();+
−
        emit finished(replyText);+
−
        return false;+
−
    }+
−
    currentCmd = pendingCommands.first();+
−
+
−
    // PORT and PASV are edited in-place, depending on whether we+
−
    // should try the extended transfer connection commands EPRT and+
−
    // EPSV. The PORT command also triggers setting up a listener, and+
−
    // the address/port arguments are edited in.+
−
    QHostAddress address = commandSocket.localAddress();+
−
    if (currentCmd.startsWith(QLatin1String("PORT"))) {+
−
        if ((address.protocol() == QTcpSocket::IPv6Protocol) && transferConnectionExtended) {+
−
            int port = dtp.setupListener(address);+
−
            currentCmd = QLatin1String("EPRT |");+
−
            currentCmd += (address.protocol() == QTcpSocket::IPv4Protocol) ? QLatin1Char('1') : QLatin1Char('2');+
−
            currentCmd += QLatin1Char('|') + address.toString() + QLatin1Char('|') + QString::number(port);+
−
            currentCmd += QLatin1Char('|');+
−
        } else if (address.protocol() == QTcpSocket::IPv4Protocol) {+
−
            int port = dtp.setupListener(address);+
−
            QString portArg;+
−
            quint32 ip = address.toIPv4Address();+
−
            portArg += QString::number((ip & 0xff000000) >> 24);+
−
            portArg += QLatin1Char(',') + QString::number((ip & 0xff0000) >> 16);+
−
            portArg += QLatin1Char(',') + QString::number((ip & 0xff00) >> 8);+
−
            portArg += QLatin1Char(',') + QString::number(ip & 0xff);+
−
            portArg += QLatin1Char(',') + QString::number((port & 0xff00) >> 8);+
−
            portArg += QLatin1Char(',') + QString::number(port & 0xff);+
−
+
−
            currentCmd = QLatin1String("PORT ");+
−
            currentCmd += portArg;+
−
        } else {+
−
            // No IPv6 connection can be set up with the PORT+
−
            // command.+
−
            return false;+
−
        }+
−
+
−
        currentCmd += QLatin1String("\r\n");+
−
    } else if (currentCmd.startsWith(QLatin1String("PASV"))) {+
−
        if ((address.protocol() == QTcpSocket::IPv6Protocol) && transferConnectionExtended)+
−
            currentCmd = QLatin1String("EPSV\r\n");+
−
    }+
−
+
−
    pendingCommands.pop_front();+
−
#if defined(QFTPPI_DEBUG)+
−
    qDebug("QFtpPI send: %s", currentCmd.left(currentCmd.length()-2).toLatin1().constData());+
−
#endif+
−
    state = Waiting;+
−
    commandSocket.write(currentCmd.toLatin1());+
−
    return true;+
−
}+
−
+
−
void QFtpPI::dtpConnectState(int s)+
−
{+
−
    switch (s) {+
−
        case QFtpDTP::CsClosed:+
−
            if (waitForDtpToClose) {+
−
                // there is an unprocessed reply+
−
                if (processReply())+
−
                    replyText = QLatin1String("");+
−
                else+
−
                    return;+
−
            }+
−
            waitForDtpToClose = false;+
−
            readyRead();+
−
            return;+
−
        case QFtpDTP::CsConnected:+
−
            waitForDtpToConnect = false;+
−
            startNextCmd();+
−
            return;+
−
        case QFtpDTP::CsHostNotFound:+
−
        case QFtpDTP::CsConnectionRefused:+
−
            emit error(QFtp::ConnectionRefused,+
−
                        QFtp::tr("Connection refused for data connection"));+
−
            startNextCmd();+
−
            return;+
−
        default:+
−
            return;+
−
    }+
−
}+
−
+
−
/**********************************************************************+
−
 *+
−
 * QFtpPrivate+
−
 *+
−
 *********************************************************************/+
−
+
−
QT_BEGIN_INCLUDE_NAMESPACE+
−
#include <private/qobject_p.h>+
−
QT_END_INCLUDE_NAMESPACE+
−
+
−
class QFtpPrivate : public QObjectPrivate+
−
{+
−
    Q_DECLARE_PUBLIC(QFtp)+
−
public:+
−
+
−
    inline QFtpPrivate() : close_waitForStateChange(false), state(QFtp::Unconnected),+
−
                           transferMode(QFtp::Passive), error(QFtp::NoError)+
−
    { }+
−
+
−
    ~QFtpPrivate() { while (!pending.isEmpty()) delete pending.takeFirst(); }+
−
+
−
    // private slots+
−
    void _q_startNextCommand();+
−
    void _q_piFinished(const QString&);+
−
    void _q_piError(int, const QString&);+
−
    void _q_piConnectState(int);+
−
    void _q_piFtpReply(int, const QString&);+
−
+
−
    int addCommand(QFtpCommand *cmd);+
−
+
−
    QFtpPI pi;+
−
    QList<QFtpCommand *> pending;+
−
    bool close_waitForStateChange;+
−
    QFtp::State state;+
−
    QFtp::TransferMode transferMode;+
−
    QFtp::Error error;+
−
    QString errorString;+
−
+
−
    QString host;+
−
    quint16 port;+
−
    QString proxyHost;+
−
    quint16 proxyPort;+
−
};+
−
+
−
int QFtpPrivate::addCommand(QFtpCommand *cmd)+
−
{+
−
    pending.append(cmd);+
−
+
−
    if (pending.count() == 1) {+
−
        // don't emit the commandStarted() signal before the ID is returned+
−
        QTimer::singleShot(0, q_func(), SLOT(_q_startNextCommand()));+
−
    }+
−
    return cmd->id;+
−
}+
−
+
−
/**********************************************************************+
−
 *+
−
 * QFtp implementation+
−
 *+
−
 *********************************************************************/+
−
/*!+
−
    \class QFtp+
−
    \brief The QFtp class provides an implementation of the client side of FTP protocol.+
−
+
−
    \ingroup network+
−
    \inmodule QtNetwork+
−
+
−
+
−
    This class provides a direct interface to FTP that allows you to+
−
    have more control over the requests. However, for new+
−
    applications, it is recommended to use QNetworkAccessManager and+
−
    QNetworkReply, as those classes possess a simpler, yet more+
−
    powerful API.+
−
+
−
    The class works asynchronously, so there are no blocking+
−
    functions. If an operation cannot be executed immediately, the+
−
    function will still return straight away and the operation will be+
−
    scheduled for later execution. The results of scheduled operations+
−
    are reported via signals. This approach depends on the event loop+
−
    being in operation.+
−
+
−
    The operations that can be scheduled (they are called "commands"+
−
    in the rest of the documentation) are the following:+
−
    connectToHost(), login(), close(), list(), cd(), get(), put(),+
−
    remove(), mkdir(), rmdir(), rename() and rawCommand().+
−
+
−
    All of these commands return a unique identifier that allows you+
−
    to keep track of the command that is currently being executed.+
−
    When the execution of a command starts, the commandStarted()+
−
    signal with the command's identifier is emitted. When the command+
−
    is finished, the commandFinished() signal is emitted with the+
−
    command's identifier and a bool that indicates whether the command+
−
    finished with an error.+
−
+
−
    In some cases, you might want to execute a sequence of commands,+
−
    e.g. if you want to connect and login to a FTP server. This is+
−
    simply achieved:+
−
+
−
    \snippet doc/src/snippets/code/src_network_access_qftp.cpp 0+
−
+
−
    In this case two FTP commands have been scheduled. When the last+
−
    scheduled command has finished, a done() signal is emitted with+
−
    a bool argument that tells you whether the sequence finished with+
−
    an error.+
−
+
−
    If an error occurs during the execution of one of the commands in+
−
    a sequence of commands, all the pending commands (i.e. scheduled,+
−
    but not yet executed commands) are cleared and no signals are+
−
    emitted for them.+
−
+
−
    Some commands, e.g. list(), emit additional signals to report+
−
    their results.+
−
+
−
    Example: If you want to download the INSTALL file from the Qt+
−
    FTP server, you would write this:+
−
+
−
    \snippet doc/src/snippets/code/src_network_access_qftp.cpp 1+
−
+
−
    For this example the following sequence of signals is emitted+
−
    (with small variations, depending on network traffic, etc.):+
−
+
−
    \snippet doc/src/snippets/code/src_network_access_qftp.cpp 2+
−
+
−
    The dataTransferProgress() signal in the above example is useful+
−
    if you want to show a \link QProgressBar progress bar \endlink to+
−
    inform the user about the progress of the download. The+
−
    readyRead() signal tells you that there is data ready to be read.+
−
    The amount of data can be queried then with the bytesAvailable()+
−
    function and it can be read with the read() or readAll()+
−
    function.+
−
+
−
    If the login fails for the above example, the signals would look+
−
    like this:+
−
+
−
    \snippet doc/src/snippets/code/src_network_access_qftp.cpp 3+
−
+
−
    You can then get details about the error with the error() and+
−
    errorString() functions.+
−
+
−
    For file transfer, QFtp can use both active or passive mode, and+
−
    it uses passive file transfer mode by default; see the+
−
    documentation for setTransferMode() for more details about this.+
−
+
−
    Call setProxy() to make QFtp connect via an FTP proxy server.+
−
+
−
    The functions currentId() and currentCommand() provide more+
−
    information about the currently executing command.+
−
+
−
    The functions hasPendingCommands() and clearPendingCommands()+
−
    allow you to query and clear the list of pending commands.+
−
+
−
    If you are an experienced network programmer and want to have+
−
    complete control you can use rawCommand() to execute arbitrary FTP+
−
    commands.+
−
+
−
    \warning The current version of QFtp doesn't fully support+
−
    non-Unix FTP servers.+
−
+
−
    \sa QNetworkAccessManager, QNetworkRequest, QNetworkReply,+
−
        {FTP Example}+
−
*/+
−
+
−
+
−
/*!+
−
    Constructs a QFtp object with the given \a parent.+
−
*/+
−
QFtp::QFtp(QObject *parent)+
−
    : QObject(*new QFtpPrivate, parent)+
−
{+
−
    Q_D(QFtp);+
−
    d->errorString = tr("Unknown error");+
−
+
−
    connect(&d->pi, SIGNAL(connectState(int)),+
−
            SLOT(_q_piConnectState(int)));+
−
    connect(&d->pi, SIGNAL(finished(QString)),+
−
            SLOT(_q_piFinished(QString)));+
−
    connect(&d->pi, SIGNAL(error(int,QString)),+
−
            SLOT(_q_piError(int,QString)));+
−
    connect(&d->pi, SIGNAL(rawFtpReply(int,QString)),+
−
            SLOT(_q_piFtpReply(int,QString)));+
−
+
−
    connect(&d->pi.dtp, SIGNAL(readyRead()),+
−
            SIGNAL(readyRead()));+
−
    connect(&d->pi.dtp, SIGNAL(dataTransferProgress(qint64,qint64)),+
−
            SIGNAL(dataTransferProgress(qint64,qint64)));+
−
    connect(&d->pi.dtp, SIGNAL(listInfo(QUrlInfo)),+
−
            SIGNAL(listInfo(QUrlInfo)));+
−
}+
−
+
−
#ifdef QT3_SUPPORT+
−
/*!+
−
    Use one of the constructors that doesn't take the \a name+
−
    argument and then use setObjectName() instead.+
−
*/+
−
QFtp::QFtp(QObject *parent, const char *name)+
−
    : QObject(*new QFtpPrivate, parent)+
−
{+
−
    Q_D(QFtp);+
−
    setObjectName(QLatin1String(name));+
−
    d->errorString = tr("Unknown error");+
−
+
−
    connect(&d->pi, SIGNAL(connectState(int)),+
−
            SLOT(_q_piConnectState(int)));+
−
    connect(&d->pi, SIGNAL(finished(QString)),+
−
            SLOT(_q_piFinished(QString)));+
−
    connect(&d->pi, SIGNAL(error(int,QString)),+
−
            SLOT(_q_piError(int,QString)));+
−
    connect(&d->pi, SIGNAL(rawFtpReply(int,QString)),+
−
            SLOT(_q_piFtpReply(int,QString)));+
−
+
−
    connect(&d->pi.dtp, SIGNAL(readyRead()),+
−
            SIGNAL(readyRead()));+
−
    connect(&d->pi.dtp, SIGNAL(dataTransferProgress(qint64,qint64)),+
−
            SIGNAL(dataTransferProgress(qint64,qint64)));+
−
    connect(&d->pi.dtp, SIGNAL(listInfo(QUrlInfo)),+
−
            SIGNAL(listInfo(QUrlInfo)));+
−
}+
−
#endif+
−
+
−
/*!+
−
    \enum QFtp::State+
−
+
−
    This enum defines the connection state:+
−
+
−
    \value Unconnected There is no connection to the host.+
−
    \value HostLookup A host name lookup is in progress.+
−
    \value Connecting An attempt to connect to the host is in progress.+
−
    \value Connected Connection to the host has been achieved.+
−
    \value LoggedIn Connection and user login have been achieved.+
−
    \value Closing The connection is closing down, but it is not yet+
−
    closed. (The state will be \c Unconnected when the connection is+
−
    closed.)+
−
+
−
    \sa stateChanged() state()+
−
*/+
−
/*!+
−
    \enum QFtp::TransferMode+
−
+
−
    FTP works with two socket connections; one for commands and+
−
    another for transmitting data. While the command connection is+
−
    always initiated by the client, the second connection can be+
−
    initiated by either the client or the server.+
−
+
−
    This enum defines whether the client (Passive mode) or the server+
−
    (Active mode) should set up the data connection.+
−
+
−
    \value Passive The client connects to the server to transmit its+
−
    data.+
−
+
−
    \value Active The server connects to the client to transmit its+
−
    data.+
−
*/+
−
/*!+
−
    \enum QFtp::TransferType+
−
+
−
    This enum identifies the data transfer type used with get and+
−
    put commands.+
−
+
−
    \value Binary The data will be transferred in Binary mode.+
−
+
−
    \value Ascii The data will be transferred in Ascii mode and new line+
−
    characters will be converted to the local format.+
−
*/+
−
/*!+
−
    \enum QFtp::Error+
−
+
−
    This enum identifies the error that occurred.+
−
+
−
    \value NoError No error occurred.+
−
    \value HostNotFound The host name lookup failed.+
−
    \value ConnectionRefused The server refused the connection.+
−
    \value NotConnected Tried to send a command, but there is no connection to+
−
    a server.+
−
    \value UnknownError An error other than those specified above+
−
    occurred.+
−
+
−
    \sa error()+
−
*/+
−
+
−
/*!+
−
    \enum QFtp::Command+
−
+
−
    This enum is used as the return value for the currentCommand() function.+
−
    This allows you to perform specific actions for particular+
−
    commands, e.g. in a FTP client, you might want to clear the+
−
    directory view when a list() command is started; in this case you+
−
    can simply check in the slot connected to the start() signal if+
−
    the currentCommand() is \c List.+
−
+
−
    \value None No command is being executed.+
−
    \value SetTransferMode set the \link TransferMode transfer\endlink mode.+
−
    \value SetProxy switch proxying on or off.+
−
    \value ConnectToHost connectToHost() is being executed.+
−
    \value Login login() is being executed.+
−
    \value Close close() is being executed.+
−
    \value List list() is being executed.+
−
    \value Cd cd() is being executed.+
−
    \value Get get() is being executed.+
−
    \value Put put() is being executed.+
−
    \value Remove remove() is being executed.+
−
    \value Mkdir mkdir() is being executed.+
−
    \value Rmdir rmdir() is being executed.+
−
    \value Rename rename() is being executed.+
−
    \value RawCommand rawCommand() is being executed.+
−
+
−
    \sa currentCommand()+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::stateChanged(int state)+
−
+
−
    This signal is emitted when the state of the connection changes.+
−
    The argument \a state is the new state of the connection; it is+
−
    one of the \l State values.+
−
+
−
    It is usually emitted in response to a connectToHost() or close()+
−
    command, but it can also be emitted "spontaneously", e.g. when the+
−
    server closes the connection unexpectedly.+
−
+
−
    \sa connectToHost() close() state() State+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::listInfo(const QUrlInfo &i);+
−
+
−
    This signal is emitted for each directory entry the list() command+
−
    finds. The details of the entry are stored in \a i.+
−
+
−
    \sa list()+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::commandStarted(int id)+
−
+
−
    This signal is emitted when processing the command identified by+
−
    \a id starts.+
−
+
−
    \sa commandFinished() done()+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::commandFinished(int id, bool error)+
−
+
−
    This signal is emitted when processing the command identified by+
−
    \a id has finished. \a error is true if an error occurred during+
−
    the processing; otherwise \a error is false.+
−
+
−
    \sa commandStarted() done() error() errorString()+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::done(bool error)+
−
+
−
    This signal is emitted when the last pending command has finished;+
−
    (it is emitted after the last command's commandFinished() signal).+
−
    \a error is true if an error occurred during the processing;+
−
    otherwise \a error is false.+
−
+
−
    \sa commandFinished() error() errorString()+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::readyRead()+
−
+
−
    This signal is emitted in response to a get() command when there+
−
    is new data to read.+
−
+
−
    If you specify a device as the second argument in the get()+
−
    command, this signal is \e not emitted; instead the data is+
−
    written directly to the device.+
−
+
−
    You can read the data with the readAll() or read() functions.+
−
+
−
    This signal is useful if you want to process the data in chunks as+
−
    soon as it becomes available. If you are only interested in the+
−
    complete data, just connect to the commandFinished() signal and+
−
    read the data then instead.+
−
+
−
    \sa get() read() readAll() bytesAvailable()+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::dataTransferProgress(qint64 done, qint64 total)+
−
+
−
    This signal is emitted in response to a get() or put() request to+
−
    indicate the current progress of the download or upload.+
−
+
−
    \a done is the amount of data that has already been transferred+
−
    and \a total is the total amount of data to be read or written. It+
−
    is possible that the QFtp class is not able to determine the total+
−
    amount of data that should be transferred, in which case \a total+
−
    is 0. (If you connect this signal to a QProgressBar, the progress+
−
    bar shows a busy indicator if the total is 0).+
−
+
−
    \warning \a done and \a total are not necessarily the size in+
−
    bytes, since for large files these values might need to be+
−
    "scaled" to avoid overflow.+
−
+
−
    \sa get(), put(), QProgressBar+
−
*/+
−
+
−
/*!+
−
    \fn void QFtp::rawCommandReply(int replyCode, const QString &detail);+
−
+
−
    This signal is emitted in response to the rawCommand() function.+
−
    \a replyCode is the 3 digit reply code and \a detail is the text+
−
    that follows the reply code.+
−
+
−
    \sa rawCommand()+
−
*/+
−
+
−
/*!+
−
    Connects to the FTP server \a host using port \a port.+
−
+
−
    The stateChanged() signal is emitted when the state of the+
−
    connecting process changes, e.g. to \c HostLookup, then \c+
−
    Connecting, then \c Connected.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa stateChanged() commandStarted() commandFinished()+
−
*/+
−
int QFtp::connectToHost(const QString &host, quint16 port)+
−
{+
−
    QStringList cmds;+
−
    cmds << host;+
−
    cmds << QString::number((uint)port);+
−
    int id = d_func()->addCommand(new QFtpCommand(ConnectToHost, cmds));+
−
    d_func()->pi.transferConnectionExtended = true;+
−
    return id;+
−
}+
−
+
−
/*!+
−
    Logs in to the FTP server with the username \a user and the+
−
    password \a password.+
−
+
−
    The stateChanged() signal is emitted when the state of the+
−
    connecting process changes, e.g. to \c LoggedIn.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa commandStarted() commandFinished()+
−
*/+
−
int QFtp::login(const QString &user, const QString &password)+
−
{+
−
    QStringList cmds;+
−
    cmds << (QLatin1String("USER ") + (user.isNull() ? QLatin1String("anonymous") : user) + QLatin1String("\r\n"));+
−
    cmds << (QLatin1String("PASS ") + (password.isNull() ? QLatin1String("anonymous@") : password) + QLatin1String("\r\n"));+
−
    return d_func()->addCommand(new QFtpCommand(Login, cmds));+
−
}+
−
+
−
/*!+
−
    Closes the connection to the FTP server.+
−
+
−
    The stateChanged() signal is emitted when the state of the+
−
    connecting process changes, e.g. to \c Closing, then \c+
−
    Unconnected.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa stateChanged() commandStarted() commandFinished()+
−
*/+
−
int QFtp::close()+
−
{+
−
    return d_func()->addCommand(new QFtpCommand(Close, QStringList(QLatin1String("QUIT\r\n"))));+
−
}+
−
+
−
/*!+
−
    Sets the current FTP transfer mode to \a mode. The default is QFtp::Passive.+
−
+
−
    \sa QFtp::TransferMode+
−
*/+
−
int QFtp::setTransferMode(TransferMode mode)+
−
{+
−
    int id = d_func()->addCommand(new QFtpCommand(SetTransferMode, QStringList()));+
−
    d_func()->pi.transferConnectionExtended = true;+
−
    d_func()->transferMode = mode;+
−
    return id;+
−
}+
−
+
−
/*!+
−
    Enables use of the FTP proxy on host \a host and port \a+
−
    port. Calling this function with \a host empty disables proxying.+
−
+
−
    QFtp does not support FTP-over-HTTP proxy servers. Use+
−
    QNetworkAccessManager for this.+
−
*/+
−
int QFtp::setProxy(const QString &host, quint16 port)+
−
{+
−
    QStringList args;+
−
    args << host << QString::number(port);+
−
    return d_func()->addCommand(new QFtpCommand(SetProxy, args));+
−
}+
−
+
−
/*!+
−
    Lists the contents of directory \a dir on the FTP server. If \a+
−
    dir is empty, it lists the contents of the current directory.+
−
+
−
    The listInfo() signal is emitted for each directory entry found.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa listInfo() commandStarted() commandFinished()+
−
*/+
−
int QFtp::list(const QString &dir)+
−
{+
−
    QStringList cmds;+
−
    cmds << QLatin1String("TYPE A\r\n");+
−
    cmds << QLatin1String(d_func()->transferMode == Passive ? "PASV\r\n" : "PORT\r\n");+
−
    if (dir.isEmpty())+
−
        cmds << QLatin1String("LIST\r\n");+
−
    else+
−
        cmds << (QLatin1String("LIST ") + dir + QLatin1String("\r\n"));+
−
    return d_func()->addCommand(new QFtpCommand(List, cmds));+
−
}+
−
+
−
/*!+
−
    Changes the working directory of the server to \a dir.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa commandStarted() commandFinished()+
−
*/+
−
int QFtp::cd(const QString &dir)+
−
{+
−
    return d_func()->addCommand(new QFtpCommand(Cd, QStringList(QLatin1String("CWD ") + dir + QLatin1String("\r\n"))));+
−
}+
−
+
−
/*!+
−
    Downloads the file \a file from the server.+
−
+
−
    If \a dev is 0, then the readyRead() signal is emitted when there+
−
    is data available to read. You can then read the data with the+
−
    read() or readAll() functions.+
−
+
−
    If \a dev is not 0, the data is written directly to the device \a+
−
    dev. Make sure that the \a dev pointer is valid for the duration+
−
    of the operation (it is safe to delete it when the+
−
    commandFinished() signal is emitted). In this case the readyRead()+
−
    signal is \e not emitted and you cannot read data with the+
−
    read() or readAll() functions.+
−
+
−
    If you don't read the data immediately it becomes available, i.e.+
−
    when the readyRead() signal is emitted, it is still available+
−
    until the next command is started.+
−
+
−
    For example, if you want to present the data to the user as soon+
−
    as there is something available, connect to the readyRead() signal+
−
    and read the data immediately. On the other hand, if you only want+
−
    to work with the complete data, you can connect to the+
−
    commandFinished() signal and read the data when the get() command+
−
    is finished.+
−
+
−
    The data is transferred as Binary or Ascii depending on the value+
−
    of \a type.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa readyRead() dataTransferProgress() commandStarted()+
−
    commandFinished()+
−
*/+
−
int QFtp::get(const QString &file, QIODevice *dev, TransferType type)+
−
{+
−
    QStringList cmds;+
−
    cmds << QLatin1String("SIZE ") + file + QLatin1String("\r\n");+
−
    if (type == Binary)+
−
        cmds << QLatin1String("TYPE I\r\n");+
−
    else+
−
        cmds << QLatin1String("TYPE A\r\n");+
−
    cmds << QLatin1String(d_func()->transferMode == Passive ? "PASV\r\n" : "PORT\r\n");+
−
    cmds << QLatin1String("RETR ") + file + QLatin1String("\r\n");+
−
    return d_func()->addCommand(new QFtpCommand(Get, cmds, dev));+
−
}+
−
+
−
/*!+
−
    \overload+
−
+
−
    Writes a copy of the given \a data to the file called \a file on+
−
    the server. The progress of the upload is reported by the+
−
    dataTransferProgress() signal.+
−
+
−
    The data is transferred as Binary or Ascii depending on the value+
−
    of \a type.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    Since this function takes a copy of the \a data, you can discard+
−
    your own copy when this function returns.+
−
+
−
    \sa dataTransferProgress() commandStarted() commandFinished()+
−
*/+
−
int QFtp::put(const QByteArray &data, const QString &file, TransferType type)+
−
{+
−
    QStringList cmds;+
−
    if (type == Binary)+
−
        cmds << QLatin1String("TYPE I\r\n");+
−
    else+
−
        cmds << QLatin1String("TYPE A\r\n");+
−
    cmds << QLatin1String(d_func()->transferMode == Passive ? "PASV\r\n" : "PORT\r\n");+
−
    cmds << QLatin1String("ALLO ") + QString::number(data.size()) + QLatin1String("\r\n");+
−
    cmds << QLatin1String("STOR ") + file + QLatin1String("\r\n");+
−
    return d_func()->addCommand(new QFtpCommand(Put, cmds, data));+
−
}+
−
+
−
/*!+
−
    Reads the data from the IO device \a dev, and writes it to the+
−
    file called \a file on the server. The data is read in chunks from+
−
    the IO device, so this overload allows you to transmit large+
−
    amounts of data without the need to read all the data into memory+
−
    at once.+
−
+
−
    The data is transferred as Binary or Ascii depending on the value+
−
    of \a type.+
−
+
−
    Make sure that the \a dev pointer is valid for the duration of the+
−
    operation (it is safe to delete it when the commandFinished() is+
−
    emitted).+
−
*/+
−
int QFtp::put(QIODevice *dev, const QString &file, TransferType type)+
−
{+
−
    QStringList cmds;+
−
    if (type == Binary)+
−
        cmds << QLatin1String("TYPE I\r\n");+
−
    else+
−
        cmds << QLatin1String("TYPE A\r\n");+
−
    cmds << QLatin1String(d_func()->transferMode == Passive ? "PASV\r\n" : "PORT\r\n");+
−
    if (!dev->isSequential())+
−
        cmds << QLatin1String("ALLO ") + QString::number(dev->size()) + QLatin1String("\r\n");+
−
    cmds << QLatin1String("STOR ") + file + QLatin1String("\r\n");+
−
    return d_func()->addCommand(new QFtpCommand(Put, cmds, dev));+
−
}+
−
+
−
/*!+
−
    Deletes the file called \a file from the server.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa commandStarted() commandFinished()+
−
*/+
−
int QFtp::remove(const QString &file)+
−
{+
−
    return d_func()->addCommand(new QFtpCommand(Remove, QStringList(QLatin1String("DELE ") + file + QLatin1String("\r\n"))));+
−
}+
−
+
−
/*!+
−
    Creates a directory called \a dir on the server.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa commandStarted() commandFinished()+
−
*/+
−
int QFtp::mkdir(const QString &dir)+
−
{+
−
    return d_func()->addCommand(new QFtpCommand(Mkdir, QStringList(QLatin1String("MKD ") + dir + QLatin1String("\r\n"))));+
−
}+
−
+
−
/*!+
−
    Removes the directory called \a dir from the server.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa commandStarted() commandFinished()+
−
*/+
−
int QFtp::rmdir(const QString &dir)+
−
{+
−
    return d_func()->addCommand(new QFtpCommand(Rmdir, QStringList(QLatin1String("RMD ") + dir + QLatin1String("\r\n"))));+
−
}+
−
+
−
/*!+
−
    Renames the file called \a oldname to \a newname on the server.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa commandStarted() commandFinished()+
−
*/+
−
int QFtp::rename(const QString &oldname, const QString &newname)+
−
{+
−
    QStringList cmds;+
−
    cmds << QLatin1String("RNFR ") + oldname + QLatin1String("\r\n");+
−
    cmds << QLatin1String("RNTO ") + newname + QLatin1String("\r\n");+
−
    return d_func()->addCommand(new QFtpCommand(Rename, cmds));+
−
}+
−
+
−
/*!+
−
    Sends the raw FTP command \a command to the FTP server. This is+
−
    useful for low-level FTP access. If the operation you wish to+
−
    perform has an equivalent QFtp function, we recommend using the+
−
    function instead of raw FTP commands since the functions are+
−
    easier and safer.+
−
+
−
    The function does not block and returns immediately. The command+
−
    is scheduled, and its execution is performed asynchronously. The+
−
    function returns a unique identifier which is passed by+
−
    commandStarted() and commandFinished().+
−
+
−
    When the command is started the commandStarted() signal is+
−
    emitted. When it is finished the commandFinished() signal is+
−
    emitted.+
−
+
−
    \sa rawCommandReply() commandStarted() commandFinished()+
−
*/+
−
int QFtp::rawCommand(const QString &command)+
−
{+
−
    QString cmd = command.trimmed() + QLatin1String("\r\n");+
−
    return d_func()->addCommand(new QFtpCommand(RawCommand, QStringList(cmd)));+
−
}+
−
+
−
/*!+
−
    Returns the number of bytes that can be read from the data socket+
−
    at the moment.+
−
+
−
    \sa get() readyRead() read() readAll()+
−
*/+
−
qint64 QFtp::bytesAvailable() const+
−
{+
−
    return d_func()->pi.dtp.bytesAvailable();+
−
}+
−
+
−
/*! \fn qint64 QFtp::readBlock(char *data, quint64 maxlen)+
−
+
−
    Use read() instead.+
−
*/+
−
+
−
/*!+
−
    Reads \a maxlen bytes from the data socket into \a data and+
−
    returns the number of bytes read. Returns -1 if an error occurred.+
−
+
−
    \sa get() readyRead() bytesAvailable() readAll()+
−
*/+
−
qint64 QFtp::read(char *data, qint64 maxlen)+
−
{+
−
    return d_func()->pi.dtp.read(data, maxlen);+
−
}+
−
+
−
/*!+
−
    Reads all the bytes available from the data socket and returns+
−
    them.+
−
+
−
    \sa get() readyRead() bytesAvailable() read()+
−
*/+
−
QByteArray QFtp::readAll()+
−
{+
−
    return d_func()->pi.dtp.readAll();+
−
}+
−
+
−
/*!+
−
    Aborts the current command and deletes all scheduled commands.+
−
+
−
    If there is an unfinished command (i.e. a command for which the+
−
    commandStarted() signal has been emitted, but for which the+
−
    commandFinished() signal has not been emitted), this function+
−
    sends an \c ABORT command to the server. When the server replies+
−
    that the command is aborted, the commandFinished() signal with the+
−
    \c error argument set to \c true is emitted for the command. Due+
−
    to timing issues, it is possible that the command had already+
−
    finished before the abort request reached the server, in which+
−
    case, the commandFinished() signal is emitted with the \c error+
−
    argument set to \c false.+
−
+
−
    For all other commands that are affected by the abort(), no+
−
    signals are emitted.+
−
+
−
    If you don't start further FTP commands directly after the+
−
    abort(), there won't be any scheduled commands and the done()+
−
    signal is emitted.+
−
+
−
    \warning Some FTP servers, for example the BSD FTP daemon (version+
−
    0.3), wrongly return a positive reply even when an abort has+
−
    occurred. For these servers the commandFinished() signal has its+
−
    error flag set to \c false, even though the command did not+
−
    complete successfully.+
−
+
−
    \sa clearPendingCommands()+
−
*/+
−
void QFtp::abort()+
−
{+
−
    if (d_func()->pending.isEmpty())+
−
        return;+
−
+
−
    clearPendingCommands();+
−
    d_func()->pi.abort();+
−
}+
−
+
−
/*!+
−
    Returns the identifier of the FTP command that is being executed+
−
    or 0 if there is no command being executed.+
−
+
−
    \sa currentCommand()+
−
*/+
−
int QFtp::currentId() const+
−
{+
−
    if (d_func()->pending.isEmpty())+
−
        return 0;+
−
    return d_func()->pending.first()->id;+
−
}+
−
+
−
/*!+
−
    Returns the command type of the FTP command being executed or \c+
−
    None if there is no command being executed.+
−
+
−
    \sa currentId()+
−
*/+
−
QFtp::Command QFtp::currentCommand() const+
−
{+
−
    if (d_func()->pending.isEmpty())+
−
        return None;+
−
    return d_func()->pending.first()->command;+
−
}+
−
+
−
/*!+
−
    Returns the QIODevice pointer that is used by the FTP command to read data+
−
    from or store data to. If there is no current FTP command being executed or+
−
    if the command does not use an IO device, this function returns 0.+
−
+
−
    This function can be used to delete the QIODevice in the slot connected to+
−
    the commandFinished() signal.+
−
+
−
    \sa get() put()+
−
*/+
−
QIODevice* QFtp::currentDevice() const+
−
{+
−
    if (d_func()->pending.isEmpty())+
−
        return 0;+
−
    QFtpCommand *c = d_func()->pending.first();+
−
    if (c->is_ba)+
−
        return 0;+
−
    return c->data.dev;+
−
}+
−
+
−
/*!+
−
    Returns true if there are any commands scheduled that have not yet+
−
    been executed; otherwise returns false.+
−
+
−
    The command that is being executed is \e not considered as a+
−
    scheduled command.+
−
+
−
    \sa clearPendingCommands() currentId() currentCommand()+
−
*/+
−
bool QFtp::hasPendingCommands() const+
−
{+
−
    return d_func()->pending.count() > 1;+
−
}+
−
+
−
/*!+
−
    Deletes all pending commands from the list of scheduled commands.+
−
    This does not affect the command that is being executed. If you+
−
    want to stop this as well, use abort().+
−
+
−
    \sa hasPendingCommands() abort()+
−
*/+
−
void QFtp::clearPendingCommands()+
−
{+
−
    // delete all entires except the first one+
−
    while (d_func()->pending.count() > 1)+
−
        delete d_func()->pending.takeLast();+
−
}+
−
+
−
/*!+
−
    Returns the current state of the object. When the state changes,+
−
    the stateChanged() signal is emitted.+
−
+
−
    \sa State stateChanged()+
−
*/+
−
QFtp::State QFtp::state() const+
−
{+
−
    return d_func()->state;+
−
}+
−
+
−
/*!+
−
    Returns the last error that occurred. This is useful to find out+
−
    what went wrong when receiving a commandFinished() or a done()+
−
    signal with the \c error argument set to \c true.+
−
+
−
    If you start a new command, the error status is reset to \c NoError.+
−
*/+
−
QFtp::Error QFtp::error() const+
−
{+
−
    return d_func()->error;+
−
}+
−
+
−
/*!+
−
    Returns a human-readable description of the last error that+
−
    occurred. This is useful for presenting a error message to the+
−
    user when receiving a commandFinished() or a done() signal with+
−
    the \c error argument set to \c true.+
−
+
−
    The error string is often (but not always) the reply from the+
−
    server, so it is not always possible to translate the string. If+
−
    the message comes from Qt, the string has already passed through+
−
    tr().+
−
*/+
−
QString QFtp::errorString() const+
−
{+
−
    return d_func()->errorString;+
−
}+
−
+
−
/*! \internal+
−
*/+
−
void QFtpPrivate::_q_startNextCommand()+
−
{+
−
    Q_Q(QFtp);+
−
    if (pending.isEmpty())+
−
        return;+
−
    QFtpCommand *c = pending.first();+
−
+
−
    error = QFtp::NoError;+
−
    errorString = QT_TRANSLATE_NOOP(QFtp, QLatin1String("Unknown error"));+
−
+
−
    if (q->bytesAvailable())+
−
        q->readAll(); // clear the data+
−
    emit q->commandStarted(c->id);+
−
+
−
    // Proxy support, replace the Login argument in place, then fall+
−
    // through.+
−
    if (c->command == QFtp::Login && !proxyHost.isEmpty()) {+
−
        QString loginString = c->rawCmds.first().trimmed();+
−
        loginString += QLatin1Char('@') + host;+
−
        if (port && port != 21)+
−
            loginString += QLatin1Char(':') + QString::number(port);+
−
        loginString += QLatin1String("\r\n");+
−
        c->rawCmds[0] = loginString;+
−
    }+
−
+
−
    if (c->command == QFtp::SetTransferMode) {+
−
        _q_piFinished(QLatin1String("Transfer mode set"));+
−
    } else if (c->command == QFtp::SetProxy) {+
−
        proxyHost = c->rawCmds[0];+
−
        proxyPort = c->rawCmds[1].toUInt();+
−
        c->rawCmds.clear();+
−
        _q_piFinished(QLatin1String("Proxy set to ") + proxyHost + QLatin1Char(':') + QString::number(proxyPort));+
−
    } else if (c->command == QFtp::ConnectToHost) {+
−
        if (!proxyHost.isEmpty()) {+
−
            host = c->rawCmds[0];+
−
            port = c->rawCmds[1].toUInt();+
−
            pi.connectToHost(proxyHost, proxyPort);+
−
        } else {+
−
            pi.connectToHost(c->rawCmds[0], c->rawCmds[1].toUInt());+
−
        }+
−
    } else {+
−
        if (c->command == QFtp::Put) {+
−
            if (c->is_ba) {+
−
                pi.dtp.setData(c->data.ba);+
−
                pi.dtp.setBytesTotal(c->data.ba->size());+
−
            } else if (c->data.dev && (c->data.dev->isOpen() || c->data.dev->open(QIODevice::ReadOnly))) {+
−
                pi.dtp.setDevice(c->data.dev);+
−
                if (c->data.dev->isSequential()) {+
−
                    pi.dtp.setBytesTotal(0);+
−
                    pi.dtp.connect(c->data.dev, SIGNAL(readyRead()), SLOT(dataReadyRead()));+
−
                    pi.dtp.connect(c->data.dev, SIGNAL(readChannelFinished()), SLOT(dataReadyRead()));+
−
                } else {+
−
                    pi.dtp.setBytesTotal(c->data.dev->size());+
−
                }+
−
            }+
−
        } else if (c->command == QFtp::Get) {+
−
            if (!c->is_ba && c->data.dev) {+
−
                pi.dtp.setDevice(c->data.dev);+
−
            }+
−
        } else if (c->command == QFtp::Close) {+
−
            state = QFtp::Closing;+
−
            emit q->stateChanged(state);+
−
        }+
−
        pi.sendCommands(c->rawCmds);+
−
    }+
−
}+
−
+
−
/*! \internal+
−
*/+
−
void QFtpPrivate::_q_piFinished(const QString&)+
−
{+
−
    if (pending.isEmpty())+
−
        return;+
−
    QFtpCommand *c = pending.first();+
−
+
−
    if (c->command == QFtp::Close) {+
−
        // The order of in which the slots are called is arbitrary, so+
−
        // disconnect the SIGNAL-SIGNAL temporary to make sure that we+
−
        // don't get the commandFinished() signal before the stateChanged()+
−
        // signal.+
−
        if (state != QFtp::Unconnected) {+
−
            close_waitForStateChange = true;+
−
            return;+
−
        }+
−
    }+
−
    emit q_func()->commandFinished(c->id, false);+
−
    pending.removeFirst();+
−
+
−
    delete c;+
−
+
−
    if (pending.isEmpty()) {+
−
        emit q_func()->done(false);+
−
    } else {+
−
        _q_startNextCommand();+
−
    }+
−
}+
−
+
−
/*! \internal+
−
*/+
−
void QFtpPrivate::_q_piError(int errorCode, const QString &text)+
−
{+
−
    Q_Q(QFtp);+
−
+
−
    if (pending.isEmpty()) {+
−
        qWarning() << "QFtpPrivate::_q_piError was called without pending command!";+
−
        return;+
−
    }+
−
+
−
    QFtpCommand *c = pending.first();+
−
+
−
    // non-fatal errors+
−
    if (c->command == QFtp::Get && pi.currentCommand().startsWith(QLatin1String("SIZE "))) {+
−
        pi.dtp.setBytesTotal(-1);+
−
        return;+
−
    } else if (c->command==QFtp::Put && pi.currentCommand().startsWith(QLatin1String("ALLO "))) {+
−
        return;+
−
    }+
−
+
−
    error = QFtp::Error(errorCode);+
−
    switch (q->currentCommand()) {+
−
        case QFtp::ConnectToHost:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Connecting to host failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::Login:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Login failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::List:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Listing directory failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::Cd:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Changing directory failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::Get:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Downloading file failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::Put:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Uploading file failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::Remove:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Removing file failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::Mkdir:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Creating directory failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        case QFtp::Rmdir:+
−
            errorString = QString::fromLatin1(QT_TRANSLATE_NOOP("QFtp", "Removing directory failed:\n%1"))+
−
                          .arg(text);+
−
            break;+
−
        default:+
−
            errorString = text;+
−
            break;+
−
    }+
−
+
−
    pi.clearPendingCommands();+
−
    q->clearPendingCommands();+
−
    emit q->commandFinished(c->id, true);+
−
+
−
    pending.removeFirst();+
−
    delete c;+
−
    if (pending.isEmpty())+
−
        emit q->done(true);+
−
    else+
−
        _q_startNextCommand();+
−
}+
−
+
−
/*! \internal+
−
*/+
−
void QFtpPrivate::_q_piConnectState(int connectState)+
−
{+
−
    state = QFtp::State(connectState);+
−
    emit q_func()->stateChanged(state);+
−
    if (close_waitForStateChange) {+
−
        close_waitForStateChange = false;+
−
        _q_piFinished(QLatin1String(QT_TRANSLATE_NOOP("QFtp", "Connection closed")));+
−
    }+
−
}+
−
+
−
/*! \internal+
−
*/+
−
void QFtpPrivate::_q_piFtpReply(int code, const QString &text)+
−
{+
−
    if (q_func()->currentCommand() == QFtp::RawCommand) {+
−
        pi.rawCommand = true;+
−
        emit q_func()->rawCommandReply(code, text);+
−
    }+
−
}+
−
+
−
/*!+
−
    Destructor.+
−
*/+
−
QFtp::~QFtp()+
−
{+
−
    abort();+
−
    close();+
−
}+
−
+
−
QT_END_NAMESPACE+
−
+
−
#include "qftp.moc"+
−
+
−
#include "moc_qftp.cpp"+
−
+
−
#endif // QT_NO_FTP+
−