/****************************************************************************

**

** Copyright (C) 2009 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) {