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

**

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

**

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

#include "qhttpnetworkconnection_p.h"

#include "qhttpnetworkconnectionchannel_p.h"

#include "private/qnoncontiguousbytedevice_p.h"

#include <qpair.h>

#include <qdebug.h>

#ifndef QT_NO_HTTP

#ifndef QT_NO_OPENSSL

#    include <QtNetwork/qsslkey.h>

#    include <QtNetwork/qsslcipher.h>

#    include <QtNetwork/qsslconfiguration.h>

#endif

QT_BEGIN_NAMESPACE

// TODO: Put channel specific stuff here so it does not polute qhttpnetworkconnection.cpp

void QHttpNetworkConnectionChannel::init()

{

#ifndef QT_NO_OPENSSL

    if (connection->d_func()->encrypt)

        socket = new QSslSocket;

    else

        socket = new QTcpSocket;

#else

    socket = new QTcpSocket;

#endif

    // limit the socket read buffer size. we will read everything into

    // the QHttpNetworkReply anyway, so let's grow only that and not

    // here and there.

    socket->setReadBufferSize(64*1024);

    QObject::connect(socket, SIGNAL(bytesWritten(qint64)),

                     this, SLOT(_q_bytesWritten(qint64)),

                     Qt::DirectConnection);

    QObject::connect(socket, SIGNAL(connected()),

                     this, SLOT(_q_connected()),

                     Qt::DirectConnection);

    QObject::connect(socket, SIGNAL(readyRead()),

                     this, SLOT(_q_readyRead()),

                     Qt::DirectConnection);

    QObject::connect(socket, SIGNAL(disconnected()),

                     this, SLOT(_q_disconnected()),

                     Qt::DirectConnection);

    QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),

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

                     Qt::DirectConnection);

#ifndef QT_NO_NETWORKPROXY

    QObject::connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

                     this, SLOT(_q_proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

                     Qt::DirectConnection);

#endif

#ifndef QT_NO_OPENSSL

    QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);

    if (sslSocket) {

        // won't be a sslSocket if encrypt is false

        QObject::connect(sslSocket, SIGNAL(encrypted()),

                         this, SLOT(_q_encrypted()),

                         Qt::DirectConnection);

        QObject::connect(sslSocket, SIGNAL(sslErrors(QList<QSslError>)),

                         this, SLOT(_q_sslErrors(QList<QSslError>)),

                         Qt::DirectConnection);

        QObject::connect(sslSocket, SIGNAL(encryptedBytesWritten(qint64)),

                         this, SLOT(_q_encryptedBytesWritten(qint64)),

                         Qt::DirectConnection);

    }

#endif

}

void QHttpNetworkConnectionChannel::close()

{

    socket->blockSignals(true);

    socket->close();

    socket->blockSignals(false);

    state = QHttpNetworkConnectionChannel::IdleState;

}

bool QHttpNetworkConnectionChannel::sendRequest()

{

    switch (state) {

    case QHttpNetworkConnectionChannel::IdleState: { // write the header

        if (!ensureConnection()) {

            // wait for the connection (and encryption) to be done

            // sendRequest will be called again from either

            // _q_connected or _q_encrypted

            return false;

        }

        written = 0; // excluding the header

        bytesTotal = 0;

        if (reply) {

            reply->d_func()->clear();

            reply->d_func()->connection = connection;

            reply->d_func()->autoDecompress = request.d->autoDecompress;

            reply->d_func()->pipeliningUsed = false;

        }

        state = QHttpNetworkConnectionChannel::WritingState;

        pendingEncrypt = false;

        // if the url contains authentication parameters, use the new ones

        // both channels will use the new authentication parameters

        if (!request.url().userInfo().isEmpty()) {

            QUrl url = request.url();

            QAuthenticator &auth = authenticator;

            if (url.userName() != auth.user()

                || (!url.password().isEmpty() && url.password() != auth.password())) {

                auth.setUser(url.userName());

                auth.setPassword(url.password());

                connection->d_func()->copyCredentials(connection->d_func()->indexOf(socket), &auth, false);

            }

            // clear the userinfo,  since we use the same request for resending

            // userinfo in url can conflict with the one in the authenticator

            url.setUserInfo(QString());

            request.setUrl(url);

        }

        connection->d_func()->createAuthorization(socket, request);

#ifndef QT_NO_NETWORKPROXY

        QByteArray header = QHttpNetworkRequestPrivate::header(request,

            (connection->d_func()->networkProxy.type() != QNetworkProxy::NoProxy));

#else

        QByteArray header = QHttpNetworkRequestPrivate::header(request, false);

#endif

        socket->write(header);

        // flushing is dangerous (QSslSocket calls transmit which might read or error)

//        socket->flush();

        QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();

        if (uploadByteDevice) {

            // connect the signals so this function gets called again

            QObject::connect(uploadByteDevice, SIGNAL(readyRead()),this, SLOT(_q_uploadDataReadyRead()));

            bytesTotal = request.contentLength();

        } else {

            state = QHttpNetworkConnectionChannel::WaitingState;

            sendRequest();

            break;

        }

        // write the initial chunk together with the headers

        // fall through

    }

    case QHttpNetworkConnectionChannel::WritingState:

    {

        // write the data

        QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();

        if (!uploadByteDevice || bytesTotal == written) {

            if (uploadByteDevice)

                emit reply->dataSendProgress(written, bytesTotal);

            state = QHttpNetworkConnectionChannel::WaitingState; // now wait for response

            sendRequest();

            break;

        }

        // only feed the QTcpSocket buffer when there is less than 32 kB in it

        const qint64 socketBufferFill = 32*1024;

        const qint64 socketWriteMaxSize = 16*1024;

#ifndef QT_NO_OPENSSL

        QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);

        // if it is really an ssl socket, check more than just bytesToWrite()

        while ((socket->bytesToWrite() + (sslSocket ? sslSocket->encryptedBytesToWrite() : 0))

                <= socketBufferFill && bytesTotal != written)

#else

        while (socket->bytesToWrite() <= socketBufferFill

               && bytesTotal != written)

#endif

        {

            // get pointer to upload data

            qint64 currentReadSize;

            qint64 desiredReadSize = qMin(socketWriteMaxSize, bytesTotal - written);

            const char *readPointer = uploadByteDevice->readPointer(desiredReadSize, currentReadSize);

            if (currentReadSize == -1) {

                // premature eof happened

                connection->d_func()->emitReplyError(socket, reply, QNetworkReply::UnknownNetworkError);

                return false;

                break;

            } else if (readPointer == 0 || currentReadSize == 0) {

                // nothing to read currently, break the loop

                break;

            } else {

                qint64 currentWriteSize = socket->write(readPointer, currentReadSize);

                if (currentWriteSize == -1 || currentWriteSize != currentReadSize) {

                    // socket broke down

                    connection->d_func()->emitReplyError(socket, reply, QNetworkReply::UnknownNetworkError);

                    return false;

                } else {

                    written += currentWriteSize;

                    uploadByteDevice->advanceReadPointer(currentWriteSize);

                    emit reply->dataSendProgress(written, bytesTotal);

                    if (written == bytesTotal) {

                        // make sure this function is called once again

                        state = QHttpNetworkConnectionChannel::WaitingState;

                        sendRequest();

                        break;

                    }

                }

            }

        }

        break;

    }

    case QHttpNetworkConnectionChannel::WaitingState:

    {

        QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();

        if (uploadByteDevice) {

            QObject::disconnect(uploadByteDevice, SIGNAL(readyRead()), this, SLOT(_q_uploadDataReadyRead()));

        }

        // HTTP pipelining

        connection->d_func()->fillPipeline(socket);

        socket->flush();

        // ensure we try to receive a reply in all cases, even if _q_readyRead_ hat not been called

        // this is needed if the sends an reply before we have finished sending the request. In that

        // case receiveReply had been called before but ignored the server reply

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

        break;

    }

    case QHttpNetworkConnectionChannel::ReadingState:

    case QHttpNetworkConnectionChannel::Wait4AuthState:

        // ignore _q_bytesWritten in these states

        // fall through

    default:

        break;

    }

    return true;

}

void QHttpNetworkConnectionChannel::_q_receiveReply()

{

    Q_ASSERT(socket);

    qint64 bytes = 0;

    QAbstractSocket::SocketState socketState = socket->state();

    // connection might be closed to signal the end of data

    if (socketState == QAbstractSocket::UnconnectedState) {

        if (!socket->bytesAvailable()) {

            if (reply && reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {

                reply->d_func()->state = QHttpNetworkReplyPrivate::AllDoneState;

                this->state = QHttpNetworkConnectionChannel::IdleState;

                allDone();

            } else {

                // try to reconnect/resend before sending an error.

                if (reconnectAttempts-- > 0) {

                    closeAndResendCurrentRequest();

                } else if (reply) {

                    reply->d_func()->errorString = connection->d_func()->errorDetail(QNetworkReply::RemoteHostClosedError, socket);

                    emit reply->finishedWithError(QNetworkReply::RemoteHostClosedError, reply->d_func()->errorString);

                    QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);

                }

            }

        }

    }

    // read loop for the response

    while (socket->bytesAvailable()) {

        QHttpNetworkReplyPrivate::ReplyState state = reply ? reply->d_func()->state : QHttpNetworkReplyPrivate::AllDoneState;

        switch (state) {

        case QHttpNetworkReplyPrivate::NothingDoneState:

        case QHttpNetworkReplyPrivate::ReadingStatusState: {

            eatWhitespace();

            qint64 statusBytes = reply->d_func()->readStatus(socket);

            if (statusBytes == -1 && reconnectAttempts <= 0) {

                // too many errors reading/receiving/parsing the status, close the socket and emit error

                close();

                reply->d_func()->errorString = connection->d_func()->errorDetail(QNetworkReply::ProtocolFailure, socket);

                emit reply->finishedWithError(QNetworkReply::ProtocolFailure, reply->d_func()->errorString);

                QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);

                break;

            } else if (statusBytes == -1) {

                reconnectAttempts--;

                reply->d_func()->clear();

                closeAndResendCurrentRequest();

                break;

            }

            bytes += statusBytes;

            lastStatus = reply->d_func()->statusCode;

            break;

        }

        case QHttpNetworkReplyPrivate::ReadingHeaderState: {

            QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();

            bytes += replyPrivate->readHeader(socket);

            if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState) {

                if (replyPrivate->isGzipped() && replyPrivate->autoDecompress) {

                    // remove the Content-Length from header

                    replyPrivate->removeAutoDecompressHeader();

                } else {

                    replyPrivate->autoDecompress = false;

                }

                if (replyPrivate->statusCode == 100) {

                    replyPrivate->state = QHttpNetworkReplyPrivate::ReadingStatusState;

                    break; // ignore

                }

                if (replyPrivate->shouldEmitSignals())

                    emit reply->headerChanged();

                if (!replyPrivate->expectContent()) {

                    replyPrivate->state = QHttpNetworkReplyPrivate::AllDoneState;

                    this->state = QHttpNetworkConnectionChannel::IdleState;

                    allDone();

                    return;

                }

            }

            break;

        }

        case QHttpNetworkReplyPrivate::ReadingDataState: {

           QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();

           if (replyPrivate->downstreamLimited && !replyPrivate->responseData.isEmpty() && replyPrivate->shouldEmitSignals()) {

               // We already have some HTTP body data. We don't read more from the socket until

               // this is fetched by QHttpNetworkAccessHttpBackend. If we would read more,

               // we could not limit our read buffer usage.

               // We only do this when shouldEmitSignals==true because our HTTP parsing

               // always needs to parse the 401/407 replies. Therefore they don't really obey

               // to the read buffer maximum size, but we don't care since they should be small.

               return;

           }

            if (!replyPrivate->isChunked() && !replyPrivate->autoDecompress

                && replyPrivate->bodyLength > 0) {

                // bulk files like images should fulfill these properties and

                // we can therefore save on memory copying

                bytes = replyPrivate->readBodyFast(socket, &replyPrivate->responseData);

                replyPrivate->totalProgress += bytes;

                if (replyPrivate->shouldEmitSignals()) {

                    QPointer<QHttpNetworkReply> replyPointer = reply;

                    emit reply->readyRead();

                    // make sure that the reply is valid

                    if (replyPointer.isNull())

                        return;

                    emit reply->dataReadProgress(replyPrivate->totalProgress, replyPrivate->bodyLength);

                    // make sure that the reply is valid

                    if (replyPointer.isNull())

                        return;

                }

            }

            else

            {

                // use the traditional slower reading (for compressed encoding, chunked encoding,

                // no content-length etc)

                QByteDataBuffer byteDatas;

                bytes = replyPrivate->readBody(socket, &byteDatas);

                if (bytes) {

                    if (replyPrivate->autoDecompress)

                        replyPrivate->appendCompressedReplyData(byteDatas);

                    else

                        replyPrivate->appendUncompressedReplyData(byteDatas);

                    if (!replyPrivate->autoDecompress) {

                        replyPrivate->totalProgress += bytes;

                        if (replyPrivate->shouldEmitSignals()) {

                            QPointer<QHttpNetworkReply> replyPointer = reply;

                            // important: At the point of this readyRead(), the byteDatas list must be empty,

                            // else implicit sharing will trigger memcpy when the user is reading data!

                            emit reply->readyRead();

                            // make sure that the reply is valid

                            if (replyPointer.isNull())

                                return;

                            emit reply->dataReadProgress(replyPrivate->totalProgress, replyPrivate->bodyLength);

                            // make sure that the reply is valid

                           if (replyPointer.isNull())

                                return;

                        }

                    }

#ifndef QT_NO_COMPRESS

                    else if (!expand(false)) { // expand a chunk if possible

                        return; // ### expand failed

                    }

#endif

                }

            }

            if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState)

                break;

            // everything done, fall through

            }

      case QHttpNetworkReplyPrivate::AllDoneState:

            this->state = QHttpNetworkConnectionChannel::IdleState;

            allDone();

            break;

        default:

            break;

        }

    }

}

bool QHttpNetworkConnectionChannel::ensureConnection()

{

    QAbstractSocket::SocketState socketState = socket->state();

    // resend this request after we receive the disconnected signal

    if (socketState == QAbstractSocket::ClosingState) {

        resendCurrent = true;

        return false;

    }

    // already trying to connect?

    if (socketState == QAbstractSocket::HostLookupState ||

        socketState == QAbstractSocket::ConnectingState) {

        return false;

    }

    // make sure that this socket is in a connected state, if not initiate

    // connection to the host.

    if (socketState != QAbstractSocket::ConnectedState) {

        // connect to the host if not already connected.

        state = QHttpNetworkConnectionChannel::ConnectingState;

        pendingEncrypt = connection->d_func()->encrypt;

        // reset state

        pipeliningSupported = PipeliningSupportUnknown;

        // This workaround is needed since we use QAuthenticator for NTLM authentication. The "phase == Done"

        // is the usual criteria for emitting authentication signals. The "phase" is set to "Done" when the

        // last header for Authorization is generated by the QAuthenticator. Basic & Digest logic does not

        // check the "phase" for generating the Authorization header. NTLM authentication is a two stage

        // process & needs the "phase". To make sure the QAuthenticator uses the current username/password

        // the phase is reset to Start.

        QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(authenticator);

        if (priv && priv->phase == QAuthenticatorPrivate::Done)

            priv->phase = QAuthenticatorPrivate::Start;

        priv = QAuthenticatorPrivate::getPrivate(proxyAuthenticator);

        if (priv && priv->phase == QAuthenticatorPrivate::Done)

            priv->phase = QAuthenticatorPrivate::Start;

        QString connectHost = connection->d_func()->hostName;

        qint16 connectPort = connection->d_func()->port;

#ifndef QT_NO_NETWORKPROXY

        // HTTPS always use transparent proxy.

        if (connection->d_func()->networkProxy.type() != QNetworkProxy::NoProxy && !connection->d_func()->encrypt) {

            connectHost = connection->d_func()->networkProxy.hostName();

            connectPort = connection->d_func()->networkProxy.port();

        }

#endif

        if (connection->d_func()->encrypt) {

#ifndef QT_NO_OPENSSL

            QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);

            sslSocket->connectToHostEncrypted(connectHost, connectPort);

            if (ignoreAllSslErrors)

                sslSocket->ignoreSslErrors();

            sslSocket->ignoreSslErrors(ignoreSslErrorsList);

#else

            connection->d_func()->emitReplyError(socket, reply, QNetworkReply::ProtocolUnknownError);

#endif

        } else {

            socket->connectToHost(connectHost, connectPort);

        }

        return false;

    }

    return true;

}

#ifndef QT_NO_COMPRESS

bool QHttpNetworkConnectionChannel::expand(bool dataComplete)

{

    Q_ASSERT(socket);

    Q_ASSERT(reply);

    qint64 total = reply->d_func()->compressedData.size();

    if (total >= CHUNK || dataComplete) {

         // uncompress the data

        QByteArray content, inflated;

        content = reply->d_func()->compressedData;

        reply->d_func()->compressedData.clear();

        int ret = Z_OK;

        if (content.size())

            ret = reply->d_func()->gunzipBodyPartially(content, inflated);

        int retCheck = (dataComplete) ? Z_STREAM_END : Z_OK;

        if (ret >= retCheck) {

            if (inflated.size()) {

                reply->d_func()->totalProgress += inflated.size();

                reply->d_func()->appendUncompressedReplyData(inflated);