qhttp.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtNetwork module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** 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, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
**
** $QT_END_LICENSE$
**
****************************************************************************/

//#define QHTTP_DEBUG

#include <qplatformdefs.h>
#include "qhttp.h"

#ifndef QT_NO_HTTP
# include "private/qobject_p.h"
# include "qtcpsocket.h"
# include "qsslsocket.h"
# include "qtextstream.h"
# include "qmap.h"
# include "qlist.h"
# include "qstring.h"
# include "qstringlist.h"
# include "qbuffer.h"
# include "private/qringbuffer_p.h"
# include "qcoreevent.h"
# include "qurl.h"
# include "qnetworkproxy.h"
# include "qauthenticator.h"
# include "qauthenticator_p.h"
# include "qdebug.h"
# include "qtimer.h"
#endif

#ifndef QT_NO_HTTP

QT_BEGIN_NAMESPACE

class QHttpNormalRequest;
class QHttpRequest
{
public:
    QHttpRequest() : finished(false)
    { id = idCounter.fetchAndAddRelaxed(1); }
    virtual ~QHttpRequest()
    { }

    virtual void start(QHttp *) = 0;
    virtual bool hasRequestHeader();
    virtual QHttpRequestHeader requestHeader();

    virtual QIODevice *sourceDevice() = 0;
    virtual QIODevice *destinationDevice() = 0;

    int id;
    bool finished;

private:
    static QBasicAtomicInt idCounter;
};

class QHttpPrivate : public QObjectPrivate
{
public:
    Q_DECLARE_PUBLIC(QHttp)

    inline QHttpPrivate()
        : socket(0), reconnectAttempts(2),
          deleteSocket(0), state(QHttp::Unconnected),
          error(QHttp::NoError), port(0), mode(QHttp::ConnectionModeHttp),
          toDevice(0), postDevice(0), bytesDone(0), chunkedSize(-1),
          repost(false), pendingPost(false)
    {
    }

    inline ~QHttpPrivate()
    {
        while (!pending.isEmpty())
            delete pending.takeFirst();

        if (deleteSocket)
            delete socket;
    }

    // private slots
    void _q_startNextRequest();
    void _q_slotReadyRead();
    void _q_slotConnected();
    void _q_slotError(QAbstractSocket::SocketError);
    void _q_slotClosed();
    void _q_slotBytesWritten(qint64 numBytes);
#ifndef QT_NO_OPENSSL
    void _q_slotEncryptedBytesWritten(qint64 numBytes);
#endif
    void _q_slotDoFinished();
    void _q_slotSendRequest();
    void _q_continuePost();

    int addRequest(QHttpNormalRequest *);
    int addRequest(QHttpRequest *);
    void finishedWithSuccess();
    void finishedWithError(const QString &detail, int errorCode);

    void init();
    void setState(int);
    void closeConn();
    void setSock(QTcpSocket *sock);

    void postMoreData();

    QTcpSocket *socket;
    int reconnectAttempts;
    bool deleteSocket;
    QList<QHttpRequest *> pending;

    QHttp::State state;
    QHttp::Error error;
    QString errorString;

    QString hostName;
    quint16 port;
    QHttp::ConnectionMode mode;

    QByteArray buffer;
    QIODevice *toDevice;
    QIODevice *postDevice;

    qint64 bytesDone;
    qint64 bytesTotal;
    qint64 chunkedSize;

    QHttpRequestHeader header;

    bool readHeader;
    QString headerStr;
    QHttpResponseHeader response;

    QRingBuffer rba;

#ifndef QT_NO_NETWORKPROXY
    QNetworkProxy proxy;
    QAuthenticator proxyAuthenticator;
#endif
    QAuthenticator authenticator;
    bool repost;
    bool hasFinishedWithError;
    bool pendingPost;
    QTimer post100ContinueTimer;
};

QBasicAtomicInt QHttpRequest::idCounter = Q_BASIC_ATOMIC_INITIALIZER(1);

bool QHttpRequest::hasRequestHeader()
{
    return false;
}

QHttpRequestHeader QHttpRequest::requestHeader()
{
    return QHttpRequestHeader();
}

/****************************************************
 *
 * QHttpNormalRequest
 *
 ****************************************************/

class QHttpNormalRequest : public QHttpRequest
{
public:
    QHttpNormalRequest(const QHttpRequestHeader &h, QIODevice *d, QIODevice *t) :
        header(h), to(t)
    {
        is_ba = false;
        data.dev = d;
    }

    QHttpNormalRequest(const QHttpRequestHeader &h, QByteArray *d, QIODevice *t) :
        header(h), to(t)
    {
        is_ba = true;
        data.ba = d;
    }

    ~QHttpNormalRequest()
    {
        if (is_ba)
            delete data.ba;
    }

    void start(QHttp *);
    bool hasRequestHeader();
    QHttpRequestHeader requestHeader();
    inline void setRequestHeader(const QHttpRequestHeader &h) { header = h; }

    QIODevice *sourceDevice();
    QIODevice *destinationDevice();

protected:
    QHttpRequestHeader header;

private:
    union {
        QByteArray *ba;
        QIODevice *dev;
    } data;
    bool is_ba;
    QIODevice *to;
};

void QHttpNormalRequest::start(QHttp *http)
{
    if (!http->d_func()->socket)
        http->d_func()->setSock(0);
    http->d_func()->header = header;

    if (is_ba) {
        http->d_func()->buffer = *data.ba;
        if (http->d_func()->buffer.size() >= 0)
            http->d_func()->header.setContentLength(http->d_func()->buffer.size());

        http->d_func()->postDevice = 0;
    } else {
        http->d_func()->buffer = QByteArray();

        if (data.dev && (data.dev->isOpen() || data.dev->open(QIODevice::ReadOnly))) {
            http->d_func()->postDevice = data.dev;
            if (http->d_func()->postDevice->size() >= 0)
                http->d_func()->header.setContentLength(http->d_func()->postDevice->size());
        } else {
            http->d_func()->postDevice = 0;
        }
    }

    if (to && (to->isOpen() || to->open(QIODevice::WriteOnly)))
        http->d_func()->toDevice = to;
    else
        http->d_func()->toDevice = 0;

    http->d_func()->reconnectAttempts = 2;
    http->d_func()->_q_slotSendRequest();
}

bool QHttpNormalRequest::hasRequestHeader()
{
    return true;
}

QHttpRequestHeader QHttpNormalRequest::requestHeader()
{
    return header;
}

QIODevice *QHttpNormalRequest::sourceDevice()
{
    if (is_ba)
        return 0;
    return data.dev;
}

QIODevice *QHttpNormalRequest::destinationDevice()
{
    return to;
}

/****************************************************
 *
 * QHttpPGHRequest
 * (like a QHttpNormalRequest, but for the convenience
 * functions put(), get() and head() -- i.e. set the
 * host header field correctly before sending the
 * request)
 *
 ****************************************************/

class QHttpPGHRequest : public QHttpNormalRequest
{
public:
    QHttpPGHRequest(const QHttpRequestHeader &h, QIODevice *d, QIODevice *t) :
        QHttpNormalRequest(h, d, t)
    { }

    QHttpPGHRequest(const QHttpRequestHeader &h, QByteArray *d, QIODevice *t) :
        QHttpNormalRequest(h, d, t)
    { }

    ~QHttpPGHRequest()
    { }

    void start(QHttp *);
};

void QHttpPGHRequest::start(QHttp *http)
{
    if (http->d_func()->port && http->d_func()->port != 80)
    header.setValue(QLatin1String("Host"), http->d_func()->hostName + QLatin1Char(':') + QString::number(http->d_func()->port));
    else
    header.setValue(QLatin1String("Host"), http->d_func()->hostName);
    QHttpNormalRequest::start(http);
}

/****************************************************
 *
 * QHttpSetHostRequest
 *
 ****************************************************/

class QHttpSetHostRequest : public QHttpRequest
{
public:
    QHttpSetHostRequest(const QString &h, quint16 p, QHttp::ConnectionMode m)
        : hostName(h), port(p), mode(m)
    { }

    void start(QHttp *);

    QIODevice *sourceDevice()
    { return 0; }
    QIODevice *destinationDevice()
    { return 0; }

private:
    QString hostName;
    quint16 port;
    QHttp::ConnectionMode mode;
};

void QHttpSetHostRequest::start(QHttp *http)
{
    http->d_func()->hostName = hostName;
    http->d_func()->port = port;
    http->d_func()->mode = mode;

#ifdef QT_NO_OPENSSL
    if (mode == QHttp::ConnectionModeHttps) {
        // SSL requested but no SSL support compiled in
        http->d_func()->finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "HTTPS connection requested but SSL support not compiled in")),
                          QHttp::UnknownError);
        return;
    }
#endif

    http->d_func()->finishedWithSuccess();
}

/****************************************************
 *
 * QHttpSetUserRequest
 *
 ****************************************************/

class QHttpSetUserRequest : public QHttpRequest
{
public:
    QHttpSetUserRequest(const QString &userName, const QString &password) :
        user(userName), pass(password)
    { }

    void start(QHttp *);

    QIODevice *sourceDevice()
    { return 0; }
    QIODevice *destinationDevice()
    { return 0; }

private:
    QString user;
    QString pass;
};

void QHttpSetUserRequest::start(QHttp *http)
{
    http->d_func()->authenticator.setUser(user);
    http->d_func()->authenticator.setPassword(pass);
    http->d_func()->finishedWithSuccess();
}

#ifndef QT_NO_NETWORKPROXY

/****************************************************
 *
 * QHttpSetProxyRequest
 *
 ****************************************************/

class QHttpSetProxyRequest : public QHttpRequest
{
public:
    inline QHttpSetProxyRequest(const QNetworkProxy &proxy)
    {
        this->proxy = proxy;
    }

    inline void start(QHttp *http)
    {
        http->d_func()->proxy = proxy;
        QString user = proxy.user();
        if (!user.isEmpty())
            http->d_func()->proxyAuthenticator.setUser(user);
        QString password = proxy.password();
        if (!password.isEmpty())
            http->d_func()->proxyAuthenticator.setPassword(password);
        http->d_func()->finishedWithSuccess();
    }

    inline QIODevice *sourceDevice()
    { return 0; }
    inline QIODevice *destinationDevice()
    { return 0; }
private:
    QNetworkProxy proxy;
};

#endif // QT_NO_NETWORKPROXY

/****************************************************
 *
 * QHttpSetSocketRequest
 *
 ****************************************************/

class QHttpSetSocketRequest : public QHttpRequest
{
public:
    QHttpSetSocketRequest(QTcpSocket *s) : socket(s)
    { }

    void start(QHttp *);

    QIODevice *sourceDevice()
    { return 0; }
    QIODevice *destinationDevice()
    { return 0; }

private:
    QTcpSocket *socket;
};

void QHttpSetSocketRequest::start(QHttp *http)
{
    http->d_func()->setSock(socket);
    http->d_func()->finishedWithSuccess();
}

/****************************************************
 *
 * QHttpCloseRequest
 *
 ****************************************************/

class QHttpCloseRequest : public QHttpRequest
{
public:
    QHttpCloseRequest()
    { }
    void start(QHttp *);

    QIODevice *sourceDevice()
    { return 0; }
    QIODevice *destinationDevice()
    { return 0; }
};

void QHttpCloseRequest::start(QHttp *http)
{
    http->d_func()->closeConn();
}

class QHttpHeaderPrivate
{
    Q_DECLARE_PUBLIC(QHttpHeader)
public:
    inline virtual ~QHttpHeaderPrivate() {}

    QList<QPair<QString, QString> > values;
    bool valid;
    QHttpHeader *q_ptr;
};

/****************************************************
 *
 * QHttpHeader
 *
 ****************************************************/

QHttpHeader::QHttpHeader()
    : d_ptr(new QHttpHeaderPrivate)
{
    Q_D(QHttpHeader);
    d->q_ptr = this;
    d->valid = true;
}

QHttpHeader::QHttpHeader(const QHttpHeader &header)
    : d_ptr(new QHttpHeaderPrivate)
{
    Q_D(QHttpHeader);
    d->q_ptr = this;
    d->valid = header.d_func()->valid;
    d->values = header.d_func()->values;
}

QHttpHeader::QHttpHeader(const QString &str)
    : d_ptr(new QHttpHeaderPrivate)
{
    Q_D(QHttpHeader);
    d->q_ptr = this;
    d->valid = true;
    parse(str);
}

QHttpHeader::QHttpHeader(QHttpHeaderPrivate &dd, const QString &str)
    : d_ptr(&dd)
{
    Q_D(QHttpHeader);
    d->q_ptr = this;
    d->valid = true;
    if (!str.isEmpty())
        parse(str);
}

QHttpHeader::QHttpHeader(QHttpHeaderPrivate &dd, const QHttpHeader &header)
    : d_ptr(&dd)
{
    Q_D(QHttpHeader);
    d->q_ptr = this;
    d->valid = header.d_func()->valid;
    d->values = header.d_func()->values;
}
QHttpHeader::~QHttpHeader()
{
}

QHttpHeader &QHttpHeader::operator=(const QHttpHeader &h)
{
    Q_D(QHttpHeader);
    d->values = h.d_func()->values;
    d->valid = h.d_func()->valid;
    return *this;
}

bool QHttpHeader::isValid() const
{
    Q_D(const QHttpHeader);
    return d->valid;
}

bool QHttpHeader::parse(const QString &str)
{
    Q_D(QHttpHeader);
    QStringList lst;
    int pos = str.indexOf(QLatin1Char('\n'));
    if (pos > 0 && str.at(pos - 1) == QLatin1Char('\r'))
        lst = str.trimmed().split(QLatin1String("\r\n"));
    else
        lst = str.trimmed().split(QLatin1String("\n"));
    lst.removeAll(QString()); // No empties

    if (lst.isEmpty())
        return true;

    QStringList lines;
    QStringList::Iterator it = lst.begin();
    for (; it != lst.end(); ++it) {
        if (!(*it).isEmpty()) {
            if ((*it)[0].isSpace()) {
                if (!lines.isEmpty()) {
                    lines.last() += QLatin1Char(' ');
                    lines.last() += (*it).trimmed();
                }
            } else {
                lines.append((*it));
            }
        }
    }

    int number = 0;
    it = lines.begin();
    for (; it != lines.end(); ++it) {
        if (!parseLine(*it, number++)) {
            d->valid = false;
            return false;
        }
    }
    return true;
}

void QHttpHeader::setValid(bool v)
{
    Q_D(QHttpHeader);
    d->valid = v;
}

QString QHttpHeader::value(const QString &key) const
{
    Q_D(const QHttpHeader);
    QString lowercaseKey = key.toLower();
    QList<QPair<QString, QString> >::ConstIterator it = d->values.constBegin();
    while (it != d->values.constEnd()) {
        if ((*it).first.toLower() == lowercaseKey)
            return (*it).second;
        ++it;
    }
    return QString();
}

QStringList QHttpHeader::allValues(const QString &key) const
{
    Q_D(const QHttpHeader);
    QString lowercaseKey = key.toLower();
    QStringList valueList;
    QList<QPair<QString, QString> >::ConstIterator it = d->values.constBegin();
    while (it != d->values.constEnd()) {
        if ((*it).first.toLower() == lowercaseKey)
            valueList.append((*it).second);
        ++it;
    }
    return valueList;
}

QStringList QHttpHeader::keys() const
{
    Q_D(const QHttpHeader);
    QStringList keyList;
    QSet<QString> seenKeys;
    QList<QPair<QString, QString> >::ConstIterator it = d->values.constBegin();
    while (it != d->values.constEnd()) {
        const QString &key = (*it).first;
        QString lowercaseKey = key.toLower();
        if (!seenKeys.contains(lowercaseKey)) {
            keyList.append(key);
            seenKeys.insert(lowercaseKey);
        }
        ++it;
    }
    return keyList;
}

bool QHttpHeader::hasKey(const QString &key) const
{
    Q_D(const QHttpHeader);
    QString lowercaseKey = key.toLower();
    QList<QPair<QString, QString> >::ConstIterator it = d->values.constBegin();
    while (it != d->values.constEnd()) {
        if ((*it).first.toLower() == lowercaseKey)
            return true;
        ++it;
    }
    return false;
}

void QHttpHeader::setValue(const QString &key, const QString &value)
{
    Q_D(QHttpHeader);
    QString lowercaseKey = key.toLower();
    QList<QPair<QString, QString> >::Iterator it = d->values.begin();
    while (it != d->values.end()) {
        if ((*it).first.toLower() == lowercaseKey) {
            (*it).second = value;
            return;
        }
        ++it;
    }
    // not found so add
    addValue(key, value);
}

void QHttpHeader::setValues(const QList<QPair<QString, QString> > &values)
{
    Q_D(QHttpHeader);
    d->values = values;
}

void QHttpHeader::addValue(const QString &key, const QString &value)
{
    Q_D(QHttpHeader);
    d->values.append(qMakePair(key, value));
}

QList<QPair<QString, QString> > QHttpHeader::values() const
{
    Q_D(const QHttpHeader);
    return d->values;
}

void QHttpHeader::removeValue(const QString &key)
{
    Q_D(QHttpHeader);
    QString lowercaseKey = key.toLower();
    QList<QPair<QString, QString> >::Iterator it = d->values.begin();
    while (it != d->values.end()) {
        if ((*it).first.toLower() == lowercaseKey) {
            d->values.erase(it);
            return;
        }
        ++it;
    }
}

void QHttpHeader::removeAllValues(const QString &key)
{
    Q_D(QHttpHeader);
    QString lowercaseKey = key.toLower();
    QList<QPair<QString, QString> >::Iterator it = d->values.begin();
    while (it != d->values.end()) {
        if ((*it).first.toLower() == lowercaseKey) {
            it = d->values.erase(it);
            continue;
        }
        ++it;
    }
}

bool QHttpHeader::parseLine(const QString &line, int)
{
    int i = line.indexOf(QLatin1Char(':'));
    if (i == -1)
        return false;

    addValue(line.left(i).trimmed(), line.mid(i + 1).trimmed());

    return true;
}

QString QHttpHeader::toString() const
{
    Q_D(const QHttpHeader);
    if (!isValid())
        return QLatin1String("");

    QString ret = QLatin1String("");

    QList<QPair<QString, QString> >::ConstIterator it = d->values.constBegin();
    while (it != d->values.constEnd()) {
        ret += (*it).first + QLatin1String(": ") + (*it).second + QLatin1String("\r\n");
        ++it;
    }
    return ret;
}

bool QHttpHeader::hasContentLength() const
{
    return hasKey(QLatin1String("content-length"));
}

uint QHttpHeader::contentLength() const
{
    return value(QLatin1String("content-length")).toUInt();
}

void QHttpHeader::setContentLength(int len)
{
    setValue(QLatin1String("content-length"), QString::number(len));
}

bool QHttpHeader::hasContentType() const
{
    return hasKey(QLatin1String("content-type"));
}

QString QHttpHeader::contentType() const
{
    QString type = value(QLatin1String("content-type"));
    if (type.isEmpty())
        return QString();

    int pos = type.indexOf(QLatin1Char(';'));
    if (pos == -1)
        return type;

    return type.left(pos).trimmed();
}

void QHttpHeader::setContentType(const QString &type)
{
    setValue(QLatin1String("content-type"), type);
}

class QHttpResponseHeaderPrivate : public QHttpHeaderPrivate
{
    Q_DECLARE_PUBLIC(QHttpResponseHeader)
public:
    int statCode;
    QString reasonPhr;
    int majVer;
    int minVer;
};

/****************************************************
 *
 * QHttpResponseHeader
 *
 ****************************************************/

QHttpResponseHeader::QHttpResponseHeader()
    : QHttpHeader(*new QHttpResponseHeaderPrivate)
{
    setValid(false);
}

QHttpResponseHeader::QHttpResponseHeader(const QHttpResponseHeader &header)
    : QHttpHeader(*new QHttpResponseHeaderPrivate, header)
{
    Q_D(QHttpResponseHeader);
    d->statCode = header.d_func()->statCode;
    d->reasonPhr = header.d_func()->reasonPhr;
    d->majVer = header.d_func()->majVer;
    d->minVer = header.d_func()->minVer;
}

QHttpResponseHeader &QHttpResponseHeader::operator=(const QHttpResponseHeader &header)
{
    Q_D(QHttpResponseHeader);
    QHttpHeader::operator=(header);
    d->statCode = header.d_func()->statCode;
    d->reasonPhr = header.d_func()->reasonPhr;
    d->majVer = header.d_func()->majVer;
    d->minVer = header.d_func()->minVer;
    return *this;
}

QHttpResponseHeader::QHttpResponseHeader(const QString &str)
    : QHttpHeader(*new QHttpResponseHeaderPrivate)
{
    parse(str);
}

QHttpResponseHeader::QHttpResponseHeader(int code, const QString &text, int majorVer, int minorVer)
    : QHttpHeader(*new QHttpResponseHeaderPrivate)
{
    setStatusLine(code, text, majorVer, minorVer);
}

void QHttpResponseHeader::setStatusLine(int code, const QString &text, int majorVer, int minorVer)
{
    Q_D(QHttpResponseHeader);
    setValid(true);
    d->statCode = code;
    d->reasonPhr = text;
    d->majVer = majorVer;
    d->minVer = minorVer;
}

int QHttpResponseHeader::statusCode() const
{
    Q_D(const QHttpResponseHeader);
    return d->statCode;
}

QString QHttpResponseHeader::reasonPhrase() const
{
    Q_D(const QHttpResponseHeader);
    return d->reasonPhr;
}

int QHttpResponseHeader::majorVersion() const
{
    Q_D(const QHttpResponseHeader);
    return d->majVer;
}

int QHttpResponseHeader::minorVersion() const
{
    Q_D(const QHttpResponseHeader);
    return d->minVer;
}

bool QHttpResponseHeader::parseLine(const QString &line, int number)
{
    Q_D(QHttpResponseHeader);
    if (number != 0)
        return QHttpHeader::parseLine(line, number);

    QString l = line.simplified();
    if (l.length() < 10)
        return false;

    if (l.left(5) == QLatin1String("HTTP/") && l[5].isDigit() && l[6] == QLatin1Char('.') &&
        l[7].isDigit() && l[8] == QLatin1Char(' ') && l[9].isDigit()) {
        d->majVer = l[5].toLatin1() - '0';
        d->minVer = l[7].toLatin1() - '0';

        int pos = l.indexOf(QLatin1Char(' '), 9);
        if (pos != -1) {
            d->reasonPhr = l.mid(pos + 1);
            d->statCode = l.mid(9, pos - 9).toInt();
        } else {
            d->statCode = l.mid(9).toInt();
            d->reasonPhr.clear();
        }
    } else {
        return false;
    }

    return true;
}

QString QHttpResponseHeader::toString() const
{
    Q_D(const QHttpResponseHeader);
    QString ret(QLatin1String("HTTP/%1.%2 %3 %4\r\n%5\r\n"));
    return ret.arg(d->majVer).arg(d->minVer).arg(d->statCode).arg(d->reasonPhr).arg(QHttpHeader::toString());
}

class QHttpRequestHeaderPrivate : public QHttpHeaderPrivate
{
    Q_DECLARE_PUBLIC(QHttpRequestHeader)
public:
    QString m;
    QString p;
    int majVer;
    int minVer;
};

/****************************************************
 *
 * QHttpRequestHeader
 *
 ****************************************************/

QHttpRequestHeader::QHttpRequestHeader()
    : QHttpHeader(*new QHttpRequestHeaderPrivate)
{
    setValid(false);
}

QHttpRequestHeader::QHttpRequestHeader(const QString &method, const QString &path, int majorVer, int minorVer)
    : QHttpHeader(*new QHttpRequestHeaderPrivate)
{
    Q_D(QHttpRequestHeader);
    d->m = method;
    d->p = path;
    d->majVer = majorVer;
    d->minVer = minorVer;
}

QHttpRequestHeader::QHttpRequestHeader(const QHttpRequestHeader &header)
    : QHttpHeader(*new QHttpRequestHeaderPrivate, header)
{
    Q_D(QHttpRequestHeader);
    d->m = header.d_func()->m;
    d->p = header.d_func()->p;
    d->majVer = header.d_func()->majVer;
    d->minVer = header.d_func()->minVer;
}

QHttpRequestHeader &QHttpRequestHeader::operator=(const QHttpRequestHeader &header)
{
    Q_D(QHttpRequestHeader);
    QHttpHeader::operator=(header);
    d->m = header.d_func()->m;
    d->p = header.d_func()->p;
    d->majVer = header.d_func()->majVer;
    d->minVer = header.d_func()->minVer;
    return *this;
}

QHttpRequestHeader::QHttpRequestHeader(const QString &str)
    : QHttpHeader(*new QHttpRequestHeaderPrivate)
{
    parse(str);
}

void QHttpRequestHeader::setRequest(const QString &method, const QString &path, int majorVer, int minorVer)
{
    Q_D(QHttpRequestHeader);
    setValid(true);
    d->m = method;
    d->p = path;
    d->majVer = majorVer;
    d->minVer = minorVer;
}

QString QHttpRequestHeader::method() const
{
    Q_D(const QHttpRequestHeader);
    return d->m;
}

QString QHttpRequestHeader::path() const
{
    Q_D(const QHttpRequestHeader);
    return d->p;
}

int QHttpRequestHeader::majorVersion() const
{
    Q_D(const QHttpRequestHeader);
    return d->majVer;
}

int QHttpRequestHeader::minorVersion() const
{
    Q_D(const QHttpRequestHeader);
    return d->minVer;
}

bool QHttpRequestHeader::parseLine(const QString &line, int number)
{
    Q_D(QHttpRequestHeader);
    if (number != 0)
        return QHttpHeader::parseLine(line, number);

    QStringList lst = line.simplified().split(QLatin1String(" "));
    if (lst.count() > 0) {
        d->m = lst[0];
        if (lst.count() > 1) {
            d->p = lst[1];
            if (lst.count() > 2) {
                QString v = lst[2];
                if (v.length() >= 8 && v.left(5) == QLatin1String("HTTP/") &&
                    v[5].isDigit() && v[6] == QLatin1Char('.') && v[7].isDigit()) {
                    d->majVer = v[5].toLatin1() - '0';
                    d->minVer = v[7].toLatin1() - '0';
                    return true;
                }
            }
        }
    }

    return false;
}

QString QHttpRequestHeader::toString() const
{
    Q_D(const QHttpRequestHeader);
    QString first(QLatin1String("%1 %2"));
    QString last(QLatin1String(" HTTP/%3.%4\r\n%5\r\n"));
    return first.arg(d->m).arg(d->p) +
        last.arg(d->majVer).arg(d->minVer).arg(QHttpHeader::toString());
}


/****************************************************
 *
 * QHttp
 *
 ****************************************************/
QHttp::QHttp(QObject *parent)
    : QObject(*new QHttpPrivate, parent)
{
    Q_D(QHttp);
    d->init();
}

QHttp::QHttp(const QString &hostName, quint16 port, QObject *parent)
    : QObject(*new QHttpPrivate, parent)
{
    Q_D(QHttp);
    d->init();

    d->hostName = hostName;
    d->port = port;
}

QHttp::QHttp(const QString &hostName, ConnectionMode mode, quint16 port, QObject *parent)
    : QObject(*new QHttpPrivate, parent)
{
    Q_D(QHttp);
    d->init();

    d->hostName = hostName;
    if (port == 0)
        port = (mode == ConnectionModeHttp) ? 80 : 443;
    d->port = port;
    d->mode = mode;
}

void QHttpPrivate::init()
{
    Q_Q(QHttp);
    errorString = QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Unknown error"));
    QMetaObject::invokeMethod(q, "_q_slotDoFinished", Qt::QueuedConnection);
    post100ContinueTimer.setSingleShot(true);
    QObject::connect(&post100ContinueTimer, SIGNAL(timeout()), q, SLOT(_q_continuePost()));
}

QHttp::~QHttp()
{
    abort();
}

#ifndef QT_NO_NETWORKPROXY

#endif

void QHttp::abort()
{
    Q_D(QHttp);
    if (d->pending.isEmpty())
        return;

    d->finishedWithError(tr("Request aborted"), Aborted);
    clearPendingRequests();
    if (d->socket)
        d->socket->abort();
    d->closeConn();
}

qint64 QHttp::bytesAvailable() const
{
    Q_D(const QHttp);
#if defined(QHTTP_DEBUG)
    qDebug("QHttp::bytesAvailable(): %d bytes", (int)d->rba.size());
#endif
    return qint64(d->rba.size());
}

qint64 QHttp::read(char *data, qint64 maxlen)
{
    Q_D(QHttp);
    if (data == 0 && maxlen != 0) {
        qWarning("QHttp::read: Null pointer error");
        return -1;
    }
    if (maxlen >= d->rba.size())
        maxlen = d->rba.size();
    int readSoFar = 0;
    while (!d->rba.isEmpty() && readSoFar < maxlen) {
        int nextBlockSize = d->rba.nextDataBlockSize();
        int bytesToRead = qMin<qint64>(maxlen - readSoFar, nextBlockSize);
        memcpy(data + readSoFar, d->rba.readPointer(), bytesToRead);
        d->rba.free(bytesToRead);
        readSoFar += bytesToRead;
    }

    d->bytesDone += maxlen;
#if defined(QHTTP_DEBUG)
    qDebug("QHttp::read(): read %lld bytes (%lld bytes done)", maxlen, d->bytesDone);
#endif
    return maxlen;
}

QByteArray QHttp::readAll()
{
    qint64 avail = bytesAvailable();
    QByteArray tmp;
    tmp.resize(int(avail));
    qint64 got = read(tmp.data(), int(avail));
    tmp.resize(got);
    return tmp;
}

int QHttp::currentId() const
{
    Q_D(const QHttp);
    if (d->pending.isEmpty())
        return 0;
    return d->pending.first()->id;
}

QHttpRequestHeader QHttp::currentRequest() const
{
    Q_D(const QHttp);
    if (!d->pending.isEmpty()) {
        QHttpRequest *r = d->pending.first();
        if (r->hasRequestHeader())
            return r->requestHeader();
    }
    return QHttpRequestHeader();
}

QHttpResponseHeader QHttp::lastResponse() const
{
    Q_D(const QHttp);
    return d->response;
}

QIODevice *QHttp::currentSourceDevice() const
{
    Q_D(const QHttp);
    if (d->pending.isEmpty())
        return 0;
    return d->pending.first()->sourceDevice();
}

QIODevice *QHttp::currentDestinationDevice() const
{
    Q_D(const QHttp);
    if (d->pending.isEmpty())
        return 0;
    return d->pending.first()->destinationDevice();
}

bool QHttp::hasPendingRequests() const
{
    Q_D(const QHttp);
    return d->pending.count() > 1;
}

void QHttp::clearPendingRequests()
{
    Q_D(QHttp);
    // delete all entires except the first one
    while (d->pending.count() > 1)
        delete d->pending.takeLast();
}

int QHttp::setHost(const QString &hostName, quint16 port)
{
    Q_D(QHttp);
    return d->addRequest(new QHttpSetHostRequest(hostName, port, ConnectionModeHttp));
}

int QHttp::setHost(const QString &hostName, ConnectionMode mode, quint16 port)
{
#ifdef QT_NO_OPENSSL
    if (mode == ConnectionModeHttps)
        qWarning("QHttp::setHost: HTTPS connection requested but SSL support not compiled in");
#endif
    Q_D(QHttp);
    if (port == 0)
        port = (mode == ConnectionModeHttp) ? 80 : 443;
    return d->addRequest(new QHttpSetHostRequest(hostName, port, mode));
}

int QHttp::setSocket(QTcpSocket *socket)
{
    Q_D(QHttp);
    return d->addRequest(new QHttpSetSocketRequest(socket));
}

int QHttp::setUser(const QString &userName, const QString &password)
{
    Q_D(QHttp);
    return d->addRequest(new QHttpSetUserRequest(userName, password));
}

#ifndef QT_NO_NETWORKPROXY

int QHttp::setProxy(const QString &host, int port,
                    const QString &username, const QString &password)
{
    Q_D(QHttp);
    QNetworkProxy proxy(QNetworkProxy::HttpProxy, host, port, username, password);
    return d->addRequest(new QHttpSetProxyRequest(proxy));
}

int QHttp::setProxy(const QNetworkProxy &proxy)
{
    Q_D(QHttp);
    return d->addRequest(new QHttpSetProxyRequest(proxy));
}

#endif

int QHttp::get(const QString &path, QIODevice *to)
{
    Q_D(QHttp);
    QHttpRequestHeader header(QLatin1String("GET"), path);
    header.setValue(QLatin1String("Connection"), QLatin1String("Keep-Alive"));
    return d->addRequest(new QHttpPGHRequest(header, (QIODevice *) 0, to));
}

int QHttp::post(const QString &path, QIODevice *data, QIODevice *to )
{
    Q_D(QHttp);
    QHttpRequestHeader header(QLatin1String("POST"), path);
    header.setValue(QLatin1String("Connection"), QLatin1String("Keep-Alive"));
    return d->addRequest(new QHttpPGHRequest(header, data, to));
}

int QHttp::post(const QString &path, const QByteArray &data, QIODevice *to)
{
    Q_D(QHttp);
    QHttpRequestHeader header(QLatin1String("POST"), path);
    header.setValue(QLatin1String("Connection"), QLatin1String("Keep-Alive"));
    return d->addRequest(new QHttpPGHRequest(header, new QByteArray(data), to));
}

int QHttp::head(const QString &path)
{
    Q_D(QHttp);
    QHttpRequestHeader header(QLatin1String("HEAD"), path);
    header.setValue(QLatin1String("Connection"), QLatin1String("Keep-Alive"));
    return d->addRequest(new QHttpPGHRequest(header, (QIODevice*)0, 0));
}

int QHttp::request(const QHttpRequestHeader &header, QIODevice *data, QIODevice *to)
{
    Q_D(QHttp);
    return d->addRequest(new QHttpNormalRequest(header, data, to));
}

int QHttp::request(const QHttpRequestHeader &header, const QByteArray &data, QIODevice *to )
{
    Q_D(QHttp);
    return d->addRequest(new QHttpNormalRequest(header, new QByteArray(data), to));
}

int QHttp::close()
{
    Q_D(QHttp);
    return d->addRequest(new QHttpCloseRequest());
}

int QHttp::closeConnection()
{
    Q_D(QHttp);
    return d->addRequest(new QHttpCloseRequest());
}

int QHttpPrivate::addRequest(QHttpNormalRequest *req)
{
    QHttpRequestHeader h = req->requestHeader();
    if (h.path().isEmpty()) {
        // note: the following qWarning is autotested. If you change it, change the test too.
        qWarning("QHttp: empty path requested is invalid -- using '/'");
        h.setRequest(h.method(), QLatin1String("/"), h.majorVersion(), h.minorVersion());
        req->setRequestHeader(h);
    }

    // contine below
    return addRequest(static_cast<QHttpRequest *>(req));
}

int QHttpPrivate::addRequest(QHttpRequest *req)
{
    Q_Q(QHttp);
    pending.append(req);

    if (pending.count() == 1) {
        // don't emit the requestStarted() signal before the id is returned
        QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
    }
    return req->id;
}

void QHttpPrivate::_q_startNextRequest()
{
    Q_Q(QHttp);
    if (pending.isEmpty())
        return;
    QHttpRequest *r = pending.first();

    error = QHttp::NoError;
    errorString = QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Unknown error"));

    if (q->bytesAvailable() != 0)
        q->readAll(); // clear the data
    emit q->requestStarted(r->id);
    r->start(q);
}

void QHttpPrivate::_q_slotSendRequest()
{
    if (hostName.isNull()) {
        finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "No server set to connect to")),
                          QHttp::UnknownError);
        return;
    }

    QString connectionHost = hostName;
    int connectionPort = port;
    bool sslInUse = false;

#ifndef QT_NO_OPENSSL
    QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
    if (mode == QHttp::ConnectionModeHttps || (sslSocket && sslSocket->isEncrypted()))
        sslInUse = true;
#endif

#ifndef QT_NO_NETWORKPROXY
    bool cachingProxyInUse = false;
    bool transparentProxyInUse = false;
    if (proxy.type() == QNetworkProxy::DefaultProxy)
        proxy = QNetworkProxy::applicationProxy();

    if (proxy.type() == QNetworkProxy::HttpCachingProxy) {
        if (proxy.hostName().isEmpty())
            proxy.setType(QNetworkProxy::NoProxy);
        else
            cachingProxyInUse = true;
    } else if (proxy.type() == QNetworkProxy::HttpProxy) {
        // Compatibility behaviour: HttpProxy can be used to mean both
        // transparent and caching proxy
        if (proxy.hostName().isEmpty()) {
            proxy.setType(QNetworkProxy::NoProxy);
        } else if (sslInUse) {
            // Disallow use of caching proxy with HTTPS; instead fall back to
            // transparent HTTP CONNECT proxying.
            transparentProxyInUse = true;
        } else {
            proxy.setType(QNetworkProxy::HttpCachingProxy);
            cachingProxyInUse = true;
        }
    }

    // Proxy support. Insert the Proxy-Authorization item into the
    // header before it's sent off to the proxy.
    if (cachingProxyInUse) {
        QUrl proxyUrl;
        proxyUrl.setScheme(QLatin1String("http"));
        proxyUrl.setHost(hostName);
        if (port && port != 80)
            proxyUrl.setPort(port);
        QString request = QString::fromAscii(proxyUrl.resolved(QUrl::fromEncoded(header.path().toLatin1())).toEncoded());

        header.setRequest(header.method(), request, header.majorVersion(), header.minorVersion());
        header.setValue(QLatin1String("Proxy-Connection"), QLatin1String("keep-alive"));

        QAuthenticatorPrivate *auth = QAuthenticatorPrivate::getPrivate(proxyAuthenticator);
        if (auth && auth->method != QAuthenticatorPrivate::None) {
            QByteArray response = auth->calculateResponse(header.method().toLatin1(), header.path().toLatin1());
            header.setValue(QLatin1String("Proxy-Authorization"), QString::fromLatin1(response));
        }

        connectionHost = proxy.hostName();
        connectionPort = proxy.port();
    }

    if (transparentProxyInUse || sslInUse) {
        socket->setProxy(proxy);
    }
#endif

    // Username support. Insert the user and password into the query
    // string.
    QAuthenticatorPrivate *auth = QAuthenticatorPrivate::getPrivate(authenticator);
    if (auth && auth->method != QAuthenticatorPrivate::None) {
        QByteArray response = auth->calculateResponse(header.method().toLatin1(), header.path().toLatin1());
        header.setValue(QLatin1String("Authorization"), QString::fromLatin1(response));
    }

    // Do we need to setup a new connection or can we reuse an
    // existing one?
    if (socket->peerName() != connectionHost || socket->peerPort() != connectionPort
        || socket->state() != QTcpSocket::ConnectedState
#ifndef QT_NO_OPENSSL
        || (sslSocket && sslSocket->isEncrypted() != (mode == QHttp::ConnectionModeHttps))
#endif
        ) {
        socket->blockSignals(true);
        socket->abort();
        socket->blockSignals(false);

        setState(QHttp::Connecting);
#ifndef QT_NO_OPENSSL
        if (sslSocket && mode == QHttp::ConnectionModeHttps) {
            sslSocket->connectToHostEncrypted(hostName, port);
        } else
#endif
        {
            socket->connectToHost(connectionHost, connectionPort);
        }
    } else {
        _q_slotConnected();
    }

}

void QHttpPrivate::finishedWithSuccess()
{
    Q_Q(QHttp);
    if (pending.isEmpty())
        return;
    QHttpRequest *r = pending.first();

    // did we recurse?
    if (r->finished)
        return;
    r->finished = true;
    hasFinishedWithError = false;

    emit q->requestFinished(r->id, false);
    if (hasFinishedWithError) {
        // we recursed and changed into an error. The finishedWithError function
        // below has emitted the done(bool) signal and cleared the queue by now.
        return;
    }

    pending.removeFirst();
    delete r;

    if (pending.isEmpty()) {
        emit q->done(false);
    } else {
        _q_startNextRequest();
    }
}

void QHttpPrivate::finishedWithError(const QString &detail, int errorCode)
{
    Q_Q(QHttp);
    if (pending.isEmpty())
        return;
    QHttpRequest *r = pending.first();
    hasFinishedWithError = true;

    error = QHttp::Error(errorCode);
    errorString = detail;

    // did we recurse?
    if (!r->finished) {
        r->finished = true;
        emit q->requestFinished(r->id, true);
    }

    while (!pending.isEmpty())
        delete pending.takeFirst();
    emit q->done(hasFinishedWithError);
}

void QHttpPrivate::_q_slotClosed()
{
    Q_Q(QHttp);

    if (state == QHttp::Reading) {
        if (response.hasKey(QLatin1String("content-length"))) {
            // We got Content-Length, so did we get all bytes?
            if (bytesDone + q->bytesAvailable() != response.contentLength()) {
                finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Wrong content length")), QHttp::WrongContentLength);
            }
        }
    } else if (state == QHttp::Connecting || state == QHttp::Sending) {
        finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Server closed connection unexpectedly")), QHttp::UnexpectedClose);
    }

    postDevice = 0;
    if (state != QHttp::Closing)
        setState(QHttp::Closing);
    QMetaObject::invokeMethod(q, "_q_slotDoFinished", Qt::QueuedConnection);
}

void QHttpPrivate::_q_continuePost()
{
    if (pendingPost) {
        pendingPost = false;
        setState(QHttp::Sending);
        _q_slotBytesWritten(0);
    }
}

void QHttpPrivate::_q_slotConnected()
{
    if (state != QHttp::Sending) {
        bytesDone = 0;
        setState(QHttp::Sending);
    }

    QString str = header.toString();
    bytesTotal = str.length();
    socket->write(str.toLatin1(), bytesTotal);
#if defined(QHTTP_DEBUG)
    qDebug("QHttp: write request header %p:\n---{\n%s}---", &header, str.toLatin1().constData());
#endif

    if (postDevice) {
        postDevice->seek(0);    // reposition the device
        bytesTotal += postDevice->size();
        //check for 100-continue
        if (header.value(QLatin1String("expect")).contains(QLatin1String("100-continue"), Qt::CaseInsensitive)) {
            //create a time out for 2 secs.
            pendingPost = true;
            post100ContinueTimer.start(2000);
        }
    } else {
        bytesTotal += buffer.size();
        socket->write(buffer, buffer.size());
    }
}

void QHttpPrivate::_q_slotError(QAbstractSocket::SocketError err)
{
    Q_Q(QHttp);
    postDevice = 0;

    if (state == QHttp::Connecting || state == QHttp::Reading || state == QHttp::Sending) {
        switch (err) {
        case QTcpSocket::ConnectionRefusedError:
            finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Connection refused (or timed out)")), QHttp::ConnectionRefused);
            break;
        case QTcpSocket::HostNotFoundError:
            finishedWithError(QString::fromLatin1(QT_TRANSLATE_NOOP("QHttp", "Host %1 not found"))
                              .arg(socket->peerName()), QHttp::HostNotFound);
            break;
        case QTcpSocket::RemoteHostClosedError:
            if (state == QHttp::Sending && reconnectAttempts--) {
                setState(QHttp::Closing);
                setState(QHttp::Unconnected);
                socket->blockSignals(true);
                socket->abort();
                socket->blockSignals(false);
                QMetaObject::invokeMethod(q, "_q_slotSendRequest", Qt::QueuedConnection);
                return;
            }
            break;
#ifndef QT_NO_NETWORKPROXY
        case QTcpSocket::ProxyAuthenticationRequiredError:
            finishedWithError(socket->errorString(), QHttp::ProxyAuthenticationRequiredError);
            break;
#endif
        default:
            finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "HTTP request failed")), QHttp::UnknownError);
            break;
        }
    }

    closeConn();
}

#ifndef QT_NO_OPENSSL
void QHttpPrivate::_q_slotEncryptedBytesWritten(qint64 written)
{
    Q_UNUSED(written);
    postMoreData();
}
#endif

void QHttpPrivate::_q_slotBytesWritten(qint64 written)
{
    Q_Q(QHttp);
    bytesDone += written;
    emit q->dataSendProgress(bytesDone, bytesTotal);
    postMoreData();
}

// Send the POST data
void QHttpPrivate::postMoreData()
{
    if (pendingPost)
        return;

    if (!postDevice)
        return;

    // the following is backported code from Qt 4.6 QNetworkAccessManager.
    // We also have to check the encryptedBytesToWrite() if it is an SSL socket.
#ifndef QT_NO_OPENSSL
    QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
    // if it is really an ssl socket, check more than just bytesToWrite()
    if ((socket->bytesToWrite() + (sslSocket ? sslSocket->encryptedBytesToWrite() : 0)) == 0) {
#else
    if (socket->bytesToWrite() == 0) {
#endif
        int max = qMin<qint64>(4096, postDevice->size() - postDevice->pos());
        QByteArray arr;
        arr.resize(max);

        int n = postDevice->read(arr.data(), max);
        if (n < 0) {
            qWarning("Could not read enough bytes from the device");
            closeConn();
            return;
        }
        if (postDevice->atEnd()) {
            postDevice = 0;
        }

        socket->write(arr, n);
    }
}

void QHttpPrivate::_q_slotReadyRead()
{
    Q_Q(QHttp);
    QHttp::State oldState = state;
    if (state != QHttp::Reading) {
        setState(QHttp::Reading);
        readHeader = true;
        headerStr = QLatin1String("");
        bytesDone = 0;
        chunkedSize = -1;
        repost = false;
    }

    while (readHeader) {
        bool end = false;
        QString tmp;
        while (!end && socket->canReadLine()) {
            tmp = QString::fromAscii(socket->readLine());
            if (tmp == QLatin1String("\r\n") || tmp == QLatin1String("\n") || tmp.isEmpty())
                end = true;
            else
                headerStr += tmp;
        }

        if (!end)
            return;

        response = QHttpResponseHeader(headerStr);
        headerStr = QLatin1String("");
#if defined(QHTTP_DEBUG)
        qDebug("QHttp: read response header:\n---{\n%s}---", response.toString().toLatin1().constData());
#endif
        // Check header
        if (!response.isValid()) {
            finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Invalid HTTP response header")),
                              QHttp::InvalidResponseHeader);
            closeConn();
            return;
        }

        int statusCode = response.statusCode();
        if (statusCode == 401 || statusCode == 407) { // (Proxy) Authentication required
            QAuthenticator *auth =
#ifndef QT_NO_NETWORKPROXY
                statusCode == 407
                ? &proxyAuthenticator :
#endif
                &authenticator;
            if (auth->isNull())
                auth->detach();
            QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(*auth);
            priv->parseHttpResponse(response, (statusCode == 407));
            if (priv->phase == QAuthenticatorPrivate::Done) {
                socket->blockSignals(true);
#ifndef QT_NO_NETWORKPROXY
                if (statusCode == 407)
                    emit q->proxyAuthenticationRequired(proxy, auth);
                else
#endif
                    emit q->authenticationRequired(hostName, port, auth);
                socket->blockSignals(false);
            } else if (priv->phase == QAuthenticatorPrivate::Invalid) {
                finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Unknown authentication method")),
                        QHttp::AuthenticationRequiredError);
                closeConn();
                return;
            }

            // priv->phase will get reset to QAuthenticatorPrivate::Start if the authenticator got modified in the signal above.
            if (priv->phase == QAuthenticatorPrivate::Done) {
#ifndef QT_NO_NETWORKPROXY
                if (statusCode == 407)
                    finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Proxy authentication required")),
                                      QHttp::ProxyAuthenticationRequiredError);
                else
#endif
                    finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Authentication required")),
                                      QHttp::AuthenticationRequiredError);
                closeConn();
                return;
            } else {
                // close the connection if it isn't already and reconnect using the chosen authentication method
                bool willClose = (response.value(QLatin1String("proxy-connection")).toLower() == QLatin1String("close"))
                                 || (response.value(QLatin1String("connection")).toLower() == QLatin1String("close"));
                if (willClose) {
                    if (socket) {
                        setState(QHttp::Closing);
                        socket->blockSignals(true);
                        socket->close();
                        socket->blockSignals(false);
                        socket->readAll();
                    }
                    _q_slotSendRequest();
                    return;
                } else {
                    repost = true;
                }
            }
        } else {
            buffer.clear();
        }

        if (response.statusCode() == 100 && pendingPost) {
            // if we have pending POST, start sending data otherwise ignore
            post100ContinueTimer.stop();
            QMetaObject::invokeMethod(q, "_q_continuePost", Qt::QueuedConnection);
            return;
        }

        // The 100-continue header is ignored (in case of no 'expect:100-continue' header),
        // because when using the POST method, we send both the request header and data in
        // one chunk.
        if (response.statusCode() != 100) {
            post100ContinueTimer.stop();
            pendingPost = false;
            readHeader = false;
            if (response.hasKey(QLatin1String("transfer-encoding")) &&
                response.value(QLatin1String("transfer-encoding")).toLower().contains(QLatin1String("chunked")))
                chunkedSize = 0;

            if (!repost)
                emit q->responseHeaderReceived(response);
            if (state == QHttp::Unconnected || state == QHttp::Closing)
                return;
        } else {
            // Restore the state, the next incoming data will be treated as if
            // we never say the 100 response.
            state = oldState;
        }
    }

    bool everythingRead = false;

    if (q->currentRequest().method() == QLatin1String("HEAD") ||
        response.statusCode() == 304 || response.statusCode() == 204 ||
        response.statusCode() == 205) {
        // HEAD requests have only headers as replies
        // These status codes never have a body:
        //  304 Not Modified
        //  204 No Content
        //  205 Reset Content
        everythingRead = true;
    } else {
        qint64 n = socket->bytesAvailable();
        QByteArray *arr = 0;
        if (chunkedSize != -1) {
            // transfer-encoding is chunked
            for (;;) {
                // get chunk size
                if (chunkedSize == 0) {
                    if (!socket->canReadLine())
                        break;
                    QString sizeString = QString::fromAscii(socket->readLine());
                    int tPos = sizeString.indexOf(QLatin1Char(';'));
                    if (tPos != -1)
                        sizeString.truncate(tPos);
                    bool ok;
                    chunkedSize = sizeString.toInt(&ok, 16);
                    if (!ok) {
                        finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Invalid HTTP chunked body")),
                                          QHttp::WrongContentLength);
                        closeConn();
                        delete arr;
                        return;
                    }
                    if (chunkedSize == 0) // last-chunk
                        chunkedSize = -2;
                }

                // read trailer
                while (chunkedSize == -2 && socket->canReadLine()) {
                    QString read = QString::fromAscii(socket->readLine());
                    if (read == QLatin1String("\r\n") || read == QLatin1String("\n"))
                        chunkedSize = -1;
                }
                if (chunkedSize == -1) {
                    everythingRead = true;
                    break;
                }

                // make sure that you can read the terminating CRLF,
                // otherwise wait until next time...
                n = socket->bytesAvailable();
                if (n == 0)
                    break;
                if (n == chunkedSize || n == chunkedSize+1) {
                    n = chunkedSize - 1;
                    if (n == 0)
                        break;
                }

                // read data
                qint64 toRead = chunkedSize < 0 ? n : qMin(n, chunkedSize);
                if (!arr)
                    arr = new QByteArray;
                uint oldArrSize = arr->size();
                arr->resize(oldArrSize + toRead);
                qint64 read = socket->read(arr->data()+oldArrSize, toRead);
                arr->resize(oldArrSize + read);

                chunkedSize -= read;

                if (chunkedSize == 0 && n - read >= 2) {
                    // read terminating CRLF
                    char tmp[2];
                    socket->read(tmp, 2);
                    if (tmp[0] != '\r' || tmp[1] != '\n') {
                        finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Invalid HTTP chunked body")),
                                          QHttp::WrongContentLength);
                        closeConn();
                        delete arr;
                        return;
                    }
                }
            }
        } else if (response.hasContentLength()) {
            if (repost && (n < response.contentLength())) {
                // wait for the content to be available fully
                // if repost is required, the content is ignored
                return;
            }
            n = qMin(qint64(response.contentLength() - bytesDone), n);
            if (n > 0) {
                arr = new QByteArray;
                arr->resize(n);
                qint64 read = socket->read(arr->data(), n);
                arr->resize(read);
            }
            if (bytesDone + q->bytesAvailable() + n == response.contentLength())
                everythingRead = true;
        } else if (n > 0) {
            // workaround for VC++ bug
            QByteArray temp = socket->readAll();
            arr = new QByteArray(temp);
        }

        if (arr && !repost) {
            n = arr->size();
            if (toDevice) {
                qint64 bytesWritten;
                bytesWritten = toDevice->write(*arr, n);
                delete arr;
                arr = 0;
                // if writing to the device does not succeed, quit with error
                if (bytesWritten == -1 || bytesWritten < n) {
                    finishedWithError(QLatin1String(QT_TRANSLATE_NOOP("QHttp", "Error writing response to device")), QHttp::UnknownError);
                } else {
                    bytesDone += bytesWritten;
#if defined(QHTTP_DEBUG)
                qDebug("QHttp::_q_slotReadyRead(): read %lld bytes (%lld bytes done)", n, bytesDone);
#endif
                }
                if (response.hasContentLength())
                    emit q->dataReadProgress(bytesDone, response.contentLength());
                else
                    emit q->dataReadProgress(bytesDone, 0);
            } else {
                char *ptr = rba.reserve(arr->size());
                memcpy(ptr, arr->data(), arr->size());
                delete arr;
                arr = 0;
#if defined(QHTTP_DEBUG)
                qDebug("QHttp::_q_slotReadyRead(): read %lld bytes (%lld bytes done)", n, bytesDone + q->bytesAvailable());
#endif
                if (response.hasContentLength())
                    emit q->dataReadProgress(bytesDone + q->bytesAvailable(), response.contentLength());
                else
                    emit q->dataReadProgress(bytesDone + q->bytesAvailable(), 0);
                emit q->readyRead(response);
            }
        }

        delete arr;
    }

    if (everythingRead) {
        if (repost) {
            _q_slotSendRequest();
            return;
        }
        // Handle "Connection: close"
        if (response.value(QLatin1String("connection")).toLower() == QLatin1String("close")) {
            closeConn();
        } else {
            setState(QHttp::Connected);
            // Start a timer, so that we emit the keep alive signal
            // "after" this method returned.
            QMetaObject::invokeMethod(q, "_q_slotDoFinished", Qt::QueuedConnection);
        }
    }
}

void QHttpPrivate::_q_slotDoFinished()
{
    if (state == QHttp::Connected) {
        finishedWithSuccess();
    } else if (state != QHttp::Unconnected) {
        setState(QHttp::Unconnected);
        finishedWithSuccess();
    }
}


QHttp::State QHttp::state() const
{
    Q_D(const QHttp);
    return d->state;
}

QHttp::Error QHttp::error() const
{
    Q_D(const QHttp);
    return d->error;
}

QString QHttp::errorString() const
{
    Q_D(const QHttp);
    return d->errorString;
}

void QHttpPrivate::setState(int s)
{
    Q_Q(QHttp);
#if defined(QHTTP_DEBUG)
    qDebug("QHttp state changed %d -> %d", state, s);
#endif
    state = QHttp::State(s);
    emit q->stateChanged(s);
}

void QHttpPrivate::closeConn()
{
    Q_Q(QHttp);
    // If no connection is open -> ignore
    if (state == QHttp::Closing || state == QHttp::Unconnected)
        return;

    postDevice = 0;
    setState(QHttp::Closing);

    // Already closed ?
    if (!socket || !socket->isOpen()) {
        QMetaObject::invokeMethod(q, "_q_slotDoFinished", Qt::QueuedConnection);
    } else {
        // Close now.
        socket->close();
    }
}

void QHttpPrivate::setSock(QTcpSocket *sock)
{
    Q_Q(const QHttp);

    // disconnect all existing signals
    if (socket)
        socket->disconnect();
    if (deleteSocket)
        delete socket;

    // use the new QTcpSocket socket, or create one if socket is 0.
    deleteSocket = (sock == 0);
    socket = sock;
    if (!socket) {
#ifndef QT_NO_OPENSSL
        if (QSslSocket::supportsSsl())
            socket = new QSslSocket();
        else
#endif
            socket = new QTcpSocket();
    }

    // connect all signals
    QObject::connect(socket, SIGNAL(connected()), q, SLOT(_q_slotConnected()));
    QObject::connect(socket, SIGNAL(disconnected()), q, SLOT(_q_slotClosed()));
    QObject::connect(socket, SIGNAL(readyRead()), q, SLOT(_q_slotReadyRead()));
    QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), q, SLOT(_q_slotError(QAbstractSocket::SocketError)));
    QObject::connect(socket, SIGNAL(bytesWritten(qint64)),
                     q, SLOT(_q_slotBytesWritten(qint64)));
#ifndef QT_NO_NETWORKPROXY
    QObject::connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
                     q, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
#endif

#ifndef QT_NO_OPENSSL
    if (qobject_cast<QSslSocket *>(socket)) {
        QObject::connect(socket, SIGNAL(sslErrors(QList<QSslError>)),
                         q, SIGNAL(sslErrors(QList<QSslError>)));
        QObject::connect(socket, SIGNAL(encryptedBytesWritten(qint64)),
                         q, SLOT(_q_slotEncryptedBytesWritten(qint64)));
    }
#endif
}

#ifndef QT_NO_OPENSSL
void QHttp::ignoreSslErrors()
{
    Q_D(QHttp);
    QSslSocket *sslSocket = qobject_cast<QSslSocket *>(d->socket);
    if (sslSocket)
        sslSocket->ignoreSslErrors();
}
#endif

QT_END_NAMESPACE

#include "moc_qhttp.cpp"

#endif