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

**

** 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$

**

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

#include "qhttpsocketengine_p.h"

#include "qtcpsocket.h"

#include "qhostaddress.h"

#include "qdatetime.h"

#include "qurl.h"

#include "qhttp.h"

#if !defined(QT_NO_NETWORKPROXY) && !defined(QT_NO_HTTP)

#include <qdebug.h>

QT_BEGIN_NAMESPACE

#define DEBUG

QHttpSocketEngine::QHttpSocketEngine(QObject *parent)

    : QAbstractSocketEngine(*new QHttpSocketEnginePrivate, parent)

{

}

QHttpSocketEngine::~QHttpSocketEngine()

{

}

bool QHttpSocketEngine::initialize(QAbstractSocket::SocketType type, QAbstractSocket::NetworkLayerProtocol protocol)

{

    Q_D(QHttpSocketEngine);

    if (type != QAbstractSocket::TcpSocket)

        return false;

    setProtocol(protocol);

    setSocketType(type);

    d->socket = new QTcpSocket(this);

    // Explicitly disable proxying on the proxy socket itself to avoid

    // unwanted recursion.

    d->socket->setProxy(QNetworkProxy::NoProxy);

    // Intercept all the signals.

    connect(d->socket, SIGNAL(connected()),

            this, SLOT(slotSocketConnected()),

            Qt::DirectConnection);

    connect(d->socket, SIGNAL(disconnected()),

            this, SLOT(slotSocketDisconnected()),

            Qt::DirectConnection);

    connect(d->socket, SIGNAL(readyRead()),

            this, SLOT(slotSocketReadNotification()),

            Qt::DirectConnection);

    connect(d->socket, SIGNAL(bytesWritten(qint64)),

            this, SLOT(slotSocketBytesWritten()),

            Qt::DirectConnection);

    connect(d->socket, SIGNAL(error(QAbstractSocket::SocketError)),

            this, SLOT(slotSocketError(QAbstractSocket::SocketError)),

            Qt::DirectConnection);

    connect(d->socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)),

            this, SLOT(slotSocketStateChanged(QAbstractSocket::SocketState)),

            Qt::DirectConnection);

    return true;

}

bool QHttpSocketEngine::initialize(int, QAbstractSocket::SocketState)

{

    return false;

}

void QHttpSocketEngine::setProxy(const QNetworkProxy &proxy)

{

    Q_D(QHttpSocketEngine);

    d->proxy = proxy;

    QString user = proxy.user();

    if (!user.isEmpty())

        d->authenticator.setUser(user);

    QString password = proxy.password();

    if (!password.isEmpty())

        d->authenticator.setPassword(password);

}

int QHttpSocketEngine::socketDescriptor() const

{

    Q_D(const QHttpSocketEngine);

    return d->socket ? d->socket->socketDescriptor() : 0;

}

bool QHttpSocketEngine::isValid() const

{

    Q_D(const QHttpSocketEngine);

    return d->socket;

}

bool QHttpSocketEngine::connectInternal()

{

    Q_D(QHttpSocketEngine);

    // If the handshake is done, enter ConnectedState state and return true.

    if (d->state == Connected) {

        qWarning("QHttpSocketEngine::connectToHost: called when already connected");

        setState(QAbstractSocket::ConnectedState);

        return true;

    }

    if (d->state == ConnectSent && d->socketState != QAbstractSocket::ConnectedState)

        setState(QAbstractSocket::UnconnectedState);

    // Handshake isn't done. If unconnected, start connecting.

    if (d->state == None && d->socket->state() == QAbstractSocket::UnconnectedState) {

        setState(QAbstractSocket::ConnectingState);

        d->socket->connectToHost(d->proxy.hostName(), d->proxy.port());

    }

    // If connected (might happen right away, at least for localhost services

    // on some BSD systems), there might already be bytes available.

    if (bytesAvailable())

        slotSocketReadNotification();

    return d->socketState == QAbstractSocket::ConnectedState;

}

bool QHttpSocketEngine::connectToHost(const QHostAddress &address, quint16 port)

{

    Q_D(QHttpSocketEngine);

    setPeerAddress(address);

    setPeerPort(port);

    d->peerName.clear();

    return connectInternal();

}

bool QHttpSocketEngine::connectToHostByName(const QString &hostname, quint16 port)

{

    Q_D(QHttpSocketEngine);

    setPeerAddress(QHostAddress());

    setPeerPort(port);

    d->peerName = hostname;

    return connectInternal();

}

bool QHttpSocketEngine::bind(const QHostAddress &, quint16)

{

    return false;

}

bool QHttpSocketEngine::listen()

{

    return false;

}

int QHttpSocketEngine::accept()

{

    return 0;

}

void QHttpSocketEngine::close()

{

    Q_D(QHttpSocketEngine);

    if (d->socket) {

        d->socket->close();

        delete d->socket;

        d->socket = 0;

    }

}

qint64 QHttpSocketEngine::bytesAvailable() const

{

    Q_D(const QHttpSocketEngine);

    return d->readBuffer.size() + (d->socket ? d->socket->bytesAvailable() : 0);

}

qint64 QHttpSocketEngine::read(char *data, qint64 maxlen)

{

    Q_D(QHttpSocketEngine);

    if (d->socket->state() == QAbstractSocket::UnconnectedState

        && d->socket->bytesAvailable() == 0) {

        emitReadNotification();

    }

        // If nothing has been read so far, and the direct socket read

        // failed, return the socket's error. Otherwise, fall through and

        // return as much as we read so far.

        close();

        setError(QAbstractSocket::RemoteHostClosedError,

                 QLatin1String("Remote host closed"));

        setState(QAbstractSocket::UnconnectedState);

        return -1;

    }

    return bytesRead;

}

qint64 QHttpSocketEngine::write(const char *data, qint64 len)

{

    Q_D(QHttpSocketEngine);

    return d->socket->write(data, len);

}

#ifndef QT_NO_UDPSOCKET

qint64 QHttpSocketEngine::readDatagram(char *, qint64, QHostAddress *,

                                       quint16 *)

{

    return 0;

}

qint64 QHttpSocketEngine::writeDatagram(const char *, qint64, const QHostAddress &,

                                        quint16)

{

    return 0;

}

bool QHttpSocketEngine::hasPendingDatagrams() const

{

    return false;

}

qint64 QHttpSocketEngine::pendingDatagramSize() const

{

    return 0;

}

#endif // QT_NO_UDPSOCKET

qint64 QHttpSocketEngine::bytesToWrite() const

{

    Q_D(const QHttpSocketEngine);

    if (d->socket) {

        return d->socket->bytesToWrite();

    } else {

        return 0;

    }

}

int QHttpSocketEngine::option(SocketOption option) const

{

    Q_D(const QHttpSocketEngine);

    if (d->socket) {

        // convert the enum and call the real socket

        if (option == QAbstractSocketEngine::LowDelayOption)

            return d->socket->socketOption(QAbstractSocket::LowDelayOption).toInt();

        if (option == QAbstractSocketEngine::KeepAliveOption)

            return d->socket->socketOption(QAbstractSocket::KeepAliveOption).toInt();

    }

    return -1;

}

bool QHttpSocketEngine::setOption(SocketOption option, int value)

{

    Q_D(QHttpSocketEngine);

    if (d->socket) {

        // convert the enum and call the real socket

        if (option == QAbstractSocketEngine::LowDelayOption)

            d->socket->setSocketOption(QAbstractSocket::LowDelayOption, value);

        if (option == QAbstractSocketEngine::KeepAliveOption)

            d->socket->setSocketOption(QAbstractSocket::KeepAliveOption, value);

        return true;

    }

    return false;

}

/*

   Returns the difference between msecs and elapsed. If msecs is -1,

   however, -1 is returned.

*/

static int qt_timeout_value(int msecs, int elapsed)

{

    if (msecs == -1)

        return -1;

    int timeout = msecs - elapsed;

    return timeout < 0 ? 0 : timeout;

}

bool QHttpSocketEngine::waitForRead(int msecs, bool *timedOut)

{

    Q_D(const QHttpSocketEngine);

    if (!d->socket || d->socket->state() == QAbstractSocket::UnconnectedState)

        return false;

    QTime stopWatch;

    stopWatch.start();

    // Wait for more data if nothing is available.

    if (!d->socket->bytesAvailable()) {

        if (!d->socket->waitForReadyRead(qt_timeout_value(msecs, stopWatch.elapsed()))) {

            if (d->socket->state() == QAbstractSocket::UnconnectedState)

                return true;

            setError(d->socket->error(), d->socket->errorString());

            if (timedOut && d->socket->error() == QAbstractSocket::SocketTimeoutError)

                *timedOut = true;

            return false;

        }

    }

    // If we're not connected yet, wait until we are, or until an error

    // occurs.

    while (d->state != Connected && d->socket->waitForReadyRead(qt_timeout_value(msecs, stopWatch.elapsed()))) {

        // Loop while the protocol handshake is taking place.

    }

    // Report any error that may occur.

    if (d->state != Connected) {

        setError(d->socket->error(), d->socket->errorString());

        if (timedOut && d->socket->error() == QAbstractSocket::SocketTimeoutError)

            *timedOut = true;

        return false;

    }

    return true;

}

bool QHttpSocketEngine::waitForWrite(int msecs, bool *timedOut)

{

    Q_D(const QHttpSocketEngine);

    // If we're connected, just forward the call.

    if (d->state == Connected) {

        if (d->socket->bytesToWrite()) {

            if (!d->socket->waitForBytesWritten(msecs)) {

                if (d->socket->error() == QAbstractSocket::SocketTimeoutError && timedOut)

                    *timedOut = true;

                return false;

            }

        }

        return true;

    }

    QTime stopWatch;

    stopWatch.start();

    // If we're not connected yet, wait until we are, and until bytes have

    // been received (i.e., the socket has connected, we have sent the

    // greeting, and then received the response).

    while (d->state != Connected && d->socket->waitForReadyRead(qt_timeout_value(msecs, stopWatch.elapsed()))) {

        // Loop while the protocol handshake is taking place.

    }

    // Report any error that may occur.

    if (d->state != Connected) {

//        setError(d->socket->error(), d->socket->errorString());

        if (timedOut && d->socket->error() == QAbstractSocket::SocketTimeoutError)

            *timedOut = true;

    }

    return true;

}

bool QHttpSocketEngine::waitForReadOrWrite(bool *readyToRead, bool *readyToWrite,

                                           bool checkRead, bool checkWrite,

                                           int msecs, bool *timedOut)

{

    Q_UNUSED(checkRead);

    if (!checkWrite) {

        // Not interested in writing? Then we wait for read notifications.

        bool canRead = waitForRead(msecs, timedOut);

        if (readyToRead)

            *readyToRead = canRead;

        return canRead;

    }

    // Interested in writing? Then we wait for write notifications.

    bool canWrite = waitForWrite(msecs, timedOut);

    if (readyToWrite)

        *readyToWrite = canWrite;

    return canWrite;

}

bool QHttpSocketEngine::isReadNotificationEnabled() const

{

    Q_D(const QHttpSocketEngine);

    return d->readNotificationEnabled;

}

void QHttpSocketEngine::setReadNotificationEnabled(bool enable)

{

    Q_D(QHttpSocketEngine);

    if (d->readNotificationEnabled == enable)

        return;

    d->readNotificationEnabled = enable;

    if (enable) {

        // Enabling read notification can trigger a notification.

        if (bytesAvailable())

            slotSocketReadNotification();

    }

}

bool QHttpSocketEngine::isWriteNotificationEnabled() const

{

    Q_D(const QHttpSocketEngine);

    return d->writeNotificationEnabled;

}

void QHttpSocketEngine::setWriteNotificationEnabled(bool enable)

{

    Q_D(QHttpSocketEngine);

    d->writeNotificationEnabled = enable;

    if (enable && d->state == Connected && d->socket->state() == QAbstractSocket::ConnectedState)

        QMetaObject::invokeMethod(this, "writeNotification", Qt::QueuedConnection);

}

bool QHttpSocketEngine::isExceptionNotificationEnabled() const

{

    Q_D(const QHttpSocketEngine);

    return d->exceptNotificationEnabled;

}

void QHttpSocketEngine::setExceptionNotificationEnabled(bool enable)

{

    Q_D(QHttpSocketEngine);

    d->exceptNotificationEnabled = enable;

}

void QHttpSocketEngine::slotSocketConnected()

{

    Q_D(QHttpSocketEngine);

    // Send the greeting.

    const char method[] = "CONNECT ";

    QByteArray peerAddress = d->peerName.isEmpty() ?

                             d->peerAddress.toString().toLatin1() :

                             QUrl::toAce(d->peerName);

    QByteArray path = peerAddress + ':' + QByteArray::number(d->peerPort);

    QByteArray data = method;

    data += path;

    data += " HTTP/1.1\r\n";

    data += "Proxy-Connection: keep-alive\r\n"

            "User-Agent: Mozilla/5.0\r\n"

            "Host: " + peerAddress + "\r\n";

    QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(d->authenticator);

    //qDebug() << "slotSocketConnected: priv=" << priv << (priv ? (int)priv->method : -1);

    if (priv && priv->method != QAuthenticatorPrivate::None) {

        data += "Proxy-Authorization: " + priv->calculateResponse(method, path);

        data += "\r\n";

    }

    data += "\r\n";

//     qDebug() << ">>>>>>>> sending request" << this;

//     qDebug() << data;

//     qDebug() << ">>>>>>>";

    d->socket->write(data);

    d->state = ConnectSent;

}

void QHttpSocketEngine::slotSocketDisconnected()

{

}

void QHttpSocketEngine::slotSocketReadNotification()

{

    Q_D(QHttpSocketEngine);

    if (d->state != Connected && d->socket->bytesAvailable() == 0)

        return;

    if (d->state == Connected) {

        // Forward as a read notification.

        if (d->readNotificationEnabled)

            emitReadNotification();

        return;

    }

  readResponseContent:

    if (d->state == ReadResponseContent) {

        char dummybuffer[4096];

        while (d->pendingResponseData) {

            int read = d->socket->read(dummybuffer, qMin(sizeof(dummybuffer), (size_t)d->pendingResponseData));

            if (read >= 0)

                dummybuffer[read] = 0;

            if (read == 0)

                return;

            if (read == -1) {

                d->socket->disconnectFromHost();

                emitWriteNotification();

                return;

            }

            d->pendingResponseData -= read;

        }

        if (d->pendingResponseData > 0)

            return;

        d->state = SendAuthentication;

        slotSocketConnected();

        return;

    }

    // Still in handshake mode. Wait until we've got a full response.