Changeset 561 for trunk/src/network/access

trunk

Property svn:mergeinfo set to (toggle deleted branches)
/branches/vendor/nokia/qt/4.6.1 merged eligible
/branches/vendor/nokia/qt/current merged eligible
/branches/vendor/trolltech/qt/current 3-149

trunk/src/network/access/access.pri

-              r2
+              r561
 HEADERS += access/qftp.h \
            access/qhttp.h \
+           access/qhttpnetworkheader_p.h \
+           access/qhttpnetworkrequest_p.h \
+           access/qhttpnetworkreply_p.h \
            access/qhttpnetworkconnection_p.h \
+           access/qhttpnetworkconnectionchannel_p.h \
+           access/qfilenetworkreply_p.h \
            access/qnetworkaccessmanager.h \
            access/qnetworkaccessmanager_p.h \
 …
            access/qnetworkcookie.h \
            access/qnetworkcookie_p.h \
+           access/qnetworkcookiejar.h \
+           access/qnetworkcookiejar_p.h \
            access/qnetworkrequest.h \
            access/qnetworkrequest_p.h \
 …
 SOURCES += access/qftp.cpp \
            access/qhttp.cpp \
+           access/qhttpnetworkheader.cpp \
+           access/qhttpnetworkrequest.cpp \
+           access/qhttpnetworkreply.cpp \
            access/qhttpnetworkconnection.cpp \
+           access/qhttpnetworkconnectionchannel.cpp \
+           access/qfilenetworkreply.cpp \
            access/qnetworkaccessmanager.cpp \
            access/qnetworkaccesscache.cpp \
 …
            access/qnetworkaccesshttpbackend.cpp \
            access/qnetworkcookie.cpp \
+           access/qnetworkcookiejar.cpp \
            access/qnetworkrequest.cpp \
            access/qnetworkreply.cpp \
 …
    INCLUDEPATH += ../3rdparty/zlib
 } else:!contains(QT_CONFIG, no-zlib) {
    unix:LIBS += -lz
+   unix:LIBS_PRIVATE += -lz
 #  win32:LIBS += libz.lib
+}

trunk/src/network/access/qabstractnetworkcache.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 /*!
+    \since 4.6
     Returns all the attributes stored with this cache item.
 …
 /*!
+    \since 4.6
     Sets all attributes of this cache item to be the map \a attributes.

trunk/src/network/access/qabstractnetworkcache.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/network/access/qabstractnetworkcache_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/network/access/qftp.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     bytesFromSocket.clear();
     if (socket)
+    if (socket) {
         delete socket;
+        socket = 0;
+    }
     socket = new QTcpSocket(this);
     socket->setObjectName(QLatin1String("QFtpDTP Passive state socket"));
 …
 //    qDebug("QFtpPI state: %d [connected()]", state);
 #endif
+    // try to improve performance by setting TCP_NODELAY
+    commandSocket.setSocketOption(QAbstractSocket::LowDelayOption, 1);
     emit connectState(QFtp::Connected);
+}
 …
     \brief The QFtp class provides an implementation of the client side of FTP protocol.
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
+    \mainclass
     This class provides a direct interface to FTP that allows you to
 …
     their results.
     Example: If you want to download the INSTALL file from Trolltech's
+    Example: If you want to download the INSTALL file from the Qt
     FTP server, you would write this:
 …
     non-Unix FTP servers.
     \sa QHttp, QNetworkAccessManager, QNetworkRequest, QNetworkReply,
+    \sa QNetworkAccessManager, QNetworkRequest, QNetworkReply,
         {FTP Example}
 */
 …
 int QFtp::connectToHost(const QString &host, quint16 port)
+{
-    d_func()->pi.transferConnectionExtended = true;
     QStringList cmds;
     cmds << host;
     cmds << QString::number((uint)port);
+    return d_func()->addCommand(new QFtpCommand(ConnectToHost, cmds));
+    int id = d_func()->addCommand(new QFtpCommand(ConnectToHost, cmds));
+    d_func()->pi.transferConnectionExtended = true;
+    return id;
+}
 …
 int QFtp::setTransferMode(TransferMode mode)
+{
+    int id = d_func()->addCommand(new QFtpCommand(SetTransferMode, QStringList()));
     d_func()->pi.transferConnectionExtended = true;
     d_func()->transferMode = mode;
     return d_func()->addCommand(new QFtpCommand(SetTransferMode, QStringList()));
+    return id;
+}
 …
     port. Calling this function with \a host empty disables proxying.
     QFtp does not support FTP-over-HTTP proxy servers. Use QHttp for
     this.
+    QFtp does not support FTP-over-HTTP proxy servers. Use
+    QNetworkAccessManager for this.
 */
 int QFtp::setProxy(const QString &host, quint16 port)

trunk/src/network/access/qftp.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/network/access/qhttp.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #endif
+#ifndef QT_NO_HTTP
 QT_BEGIN_NAMESPACE
-#ifndef QT_NO_HTTP
 class QHttpNormalRequest;
 …
     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 closeConn();
     void setSock(QTcpSocket *sock);
+    void postMoreData();
     QTcpSocket *socket;
 …
 /*!
     \class QHttpHeader
+    \obsolete
     \brief The QHttpHeader class contains header information for HTTP.
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
 QHttpHeader::~QHttpHeader()
+{
-    delete d_ptr;
+}
 …
 /*!
     Returns true if the header has an entry for the the special HTTP
+    Returns true if the header has an entry for the special HTTP
     header field \c content-type; otherwise returns false.
 …
 /*!
     \class QHttpResponseHeader
+    \obsolete
     \brief The QHttpResponseHeader class contains response header information for HTTP.
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
+}
 /*! \reimp
+/*! \internal
 */
 bool QHttpResponseHeader::parseLine(const QString &line, int number)
 …
 /*!
     \class QHttpRequestHeader
+    \obsolete
     \brief The QHttpRequestHeader class contains request header information for HTTP.
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
+}
 /*! \reimp
+/*! \internal
 */
 bool QHttpRequestHeader::parseLine(const QString &line, int number)
 …
 /*!
     \class QHttp
+    \obsolete
     \reentrant
     \brief The QHttp class provides an implementation of the HTTP protocol.
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
+    \mainclass
     This class provides a direct interface to HTTP that allows you to
     have more control over the requests and that allows you to access
     the response header fields. However, for new applications, it is
+    download and upload data with the HTTP protocol.
+    However, for new applications, it is
     recommended to use QNetworkAccessManager and QNetworkReply, as
+    those classes possess a simpler, yet more powerful API.
+    those classes possess a simpler, yet more powerful API
+    and a more modern protocol implementation.
     The class works asynchronously, so there are no blocking
 …
     To make an HTTP request you must set up suitable HTTP headers. The
+    following example demonstrates, how to request the main HTML page
+    from the Trolltech home page (i.e., the URL
+    \c http://qtsoftware.com/index.html):
+    following example demonstrates how to request the main HTML page
+    from the Qt website (i.e., the URL \c http://qt.nokia.com/index.html):
     \snippet doc/src/snippets/code/src_network_access_qhttp.cpp 2
 …
     This enum is used to specify the mode of connection to use:
     \value ConnectionModeHttp The connection is a regular Http connection to the server
     \value ConnectionModeHttps The Https protocol is used and the connection is encrypted using SSL.
     When using the Https mode, care should be taken to connect to the sslErrors signal, and
     handle possible Ssl errors.
+    \value ConnectionModeHttp The connection is a regular HTTP connection to the server
+    \value ConnectionModeHttps The HTTPS protocol is used and the connection is encrypted using SSL.
+    When using the HTTPS mode, care should be taken to connect to the sslErrors signal, and
+    handle possible SSL errors.
     \sa QSslSocket
 …
     If port is 0, it will use the default port for the \a mode used
     (80 for Http and 443 fopr Https).
+    (80 for HTTP and 443 for HTTPS).
     The function does not block; instead, it returns immediately. The request
 …
     \a path must be a absolute path like \c /index.html or an
     absolute URI like \c http://qtsoftware.com/index.html and
+    absolute URI like \c http://example.com/index.html and
     must be encoded with either QUrl::toPercentEncoding() or
     QUrl::encodedPath().
 …
     \a path must be an absolute path like \c /index.html or an
     absolute URI like \c http://qtsoftware.com/index.html and
+    absolute URI like \c http://example.com/index.html and
     must be encoded with either QUrl::toPercentEncoding() or
     QUrl::encodedPath().
 …
     \a path must be an absolute path like \c /index.html or an
     absolute URI like \c http://qtsoftware.com/index.html.
+    absolute URI like \c http://example.com/index.html.
     The function does not block; instead, it returns immediately. The request
 …
+}
+#ifndef QT_NO_OPENSSL
+void QHttpPrivate::_q_slotEncryptedBytesWritten(qint64 written)
+{
+    Q_UNUSED(written);
+    postMoreData();
+}
+#endif
 void QHttpPrivate::_q_slotBytesWritten(qint64 written)
+{
 …
     bytesDone += written;
     emit q->dataSendProgress(bytesDone, bytesTotal);
+    postMoreData();
+}
+// Send the POST data
+void QHttpPrivate::postMoreData()
+{
     if (pendingPost)
         return;
 …
         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;
 …
                      q, SLOT(_q_slotBytesWritten(qint64)));
 #ifndef QT_NO_NETWORKPROXY
     QObject::connect(socket, SIGNAL(proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *)),
                      q, SIGNAL(proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *)));
+    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(const QList<QSslError> &)),
+                         q, SIGNAL(sslErrors(const QList<QSslError> &)));
+        QObject::connect(socket, SIGNAL(sslErrors(QList<QSslError>)),
+                         q, SIGNAL(sslErrors(QList<QSslError>)));
+        QObject::connect(socket, SIGNAL(encryptedBytesWritten(qint64)),
+                         q, SLOT(_q_slotEncryptedBytesWritten(qint64)));
+    }
 #endif

trunk/src/network/access/qhttp.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include <QtCore/qmap.h>
 #include <QtCore/qpair.h>
+#include <QtCore/qscopedpointer.h>
 QT_BEGIN_HEADER
 …
     QHttpHeader(QHttpHeaderPrivate &dd, const QString &str = QString());
     QHttpHeader(QHttpHeaderPrivate &dd, const QHttpHeader &header);
     QHttpHeaderPrivate *d_ptr;
+    QScopedPointer<QHttpHeaderPrivate> d_ptr;
 private:
 …
     Q_PRIVATE_SLOT(d_func(), void _q_slotClosed())
     Q_PRIVATE_SLOT(d_func(), void _q_slotBytesWritten(qint64 numBytes))
+#ifndef QT_NO_OPENSSL
+    Q_PRIVATE_SLOT(d_func(), void _q_slotEncryptedBytesWritten(qint64 numBytes))
+#endif
     Q_PRIVATE_SLOT(d_func(), void _q_slotDoFinished())
     Q_PRIVATE_SLOT(d_func(), void _q_slotSendRequest())

trunk/src/network/access/qhttpnetworkconnection.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** 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 <private/qnetworkrequest_p.h>
 #include <private/qobject_p.h>
 …
 #include <qnetworkproxy.h>
 #include <qauthenticator.h>
+#include <qbytearraymatcher.h>
 #include <qbuffer.h>
 #include <qpair.h>
 …
 #endif
+#ifndef QT_NO_COMPRESS
+#    include <zlib.h>
+static const unsigned char gz_magic[2] = {0x1f, 0x8b}; // gzip magic header
+// gzip flag byte
+#define HEAD_CRC     0x02 // bit 1 set: header CRC present
+#define EXTRA_FIELD  0x04 // bit 2 set: extra field present
+#define ORIG_NAME    0x08 // bit 3 set: original file name present
+#define COMMENT      0x10 // bit 4 set: file comment present
+#define RESERVED     0xE0 // bits 5..7: reserved
+#define CHUNK 16384
+QT_BEGIN_NAMESPACE
+#ifdef Q_OS_SYMBIAN
+const int QHttpNetworkConnectionPrivate::defaultChannelCount = 3;
+#else
+const int QHttpNetworkConnectionPrivate::defaultChannelCount = 6;
 #endif
+QT_BEGIN_NAMESPACE
+class QHttpNetworkHeaderPrivate : public QSharedData
+{
+public:
+    QUrl url;
+    QList<QPair<QByteArray, QByteArray> > fields;
+    QHttpNetworkHeaderPrivate(const QUrl &newUrl = QUrl());
+    QHttpNetworkHeaderPrivate(const QHttpNetworkHeaderPrivate &other);
+    inline qint64 contentLength() const;
+    inline void setContentLength(qint64 length);
+    inline QByteArray headerField(const QByteArray &name, const QByteArray &defaultValue = QByteArray()) const;
+    inline QList<QByteArray> headerFieldValues(const QByteArray &name) const;
+    inline void setHeaderField(const QByteArray &name, const QByteArray &data);
+    bool operator==(const QHttpNetworkHeaderPrivate &other) const;
+};
+QHttpNetworkHeaderPrivate::QHttpNetworkHeaderPrivate(const QUrl &newUrl)
+    :url(newUrl)
+{
+}
+QHttpNetworkHeaderPrivate::QHttpNetworkHeaderPrivate(const QHttpNetworkHeaderPrivate &other)
+    :QSharedData(other)
+{
+    url = other.url;
+    fields = other.fields;
+}
+qint64 QHttpNetworkHeaderPrivate::contentLength() const
+{
+    bool ok = false;
+    QByteArray value = headerField("content-length");
+    qint64 length = value.toULongLong(&ok);
+    if (ok)
+        return length;
+    return -1; // the header field is not set
+}
+void QHttpNetworkHeaderPrivate::setContentLength(qint64 length)
+{
+    setHeaderField("Content-Length", QByteArray::number(length));
+}
+QByteArray QHttpNetworkHeaderPrivate::headerField(const QByteArray &name, const QByteArray &defaultValue) const
+{
+    QList<QByteArray> allValues = headerFieldValues(name);
+    if (allValues.isEmpty())
+        return defaultValue;
+    QByteArray result;
+    bool first = true;
+    foreach (QByteArray value, allValues) {
+        if (!first)
+            result += ", ";
+        first = false;
+        result += value;
+    }
+    return result;
+}
+QList<QByteArray> QHttpNetworkHeaderPrivate::headerFieldValues(const QByteArray &name) const
+{
+    QList<QByteArray> result;
+    QByteArray lowerName = name.toLower();
+    QList<QPair<QByteArray, QByteArray> >::ConstIterator it = fields.constBegin(),
+                                                        end = fields.constEnd();
+    for ( ; it != end; ++it)
+        if (lowerName == it->first.toLower())
+            result += it->second;
+    return result;
+}
+void QHttpNetworkHeaderPrivate::setHeaderField(const QByteArray &name, const QByteArray &data)
+{
+    QByteArray lowerName = name.toLower();
+    QList<QPair<QByteArray, QByteArray> >::Iterator it = fields.begin();
+    while (it != fields.end()) {
+        if (lowerName == it->first.toLower())
+            it = fields.erase(it);
+        else
+            ++it;
+    }
+    fields.append(qMakePair(name, data));
+}
+bool QHttpNetworkHeaderPrivate::operator==(const QHttpNetworkHeaderPrivate &other) const
+{
+   return (url == other.url);
+}
+// QHttpNetworkRequestPrivate
+class QHttpNetworkRequestPrivate : public QHttpNetworkHeaderPrivate
+{
+public:
+    QHttpNetworkRequestPrivate(QHttpNetworkRequest::Operation op,
+        QHttpNetworkRequest::Priority pri, const QUrl &newUrl = QUrl());
+    QHttpNetworkRequestPrivate(const QHttpNetworkRequestPrivate &other);
+    ~QHttpNetworkRequestPrivate();
+    bool operator==(const QHttpNetworkRequestPrivate &other) const;
+    QByteArray methodName() const;
+    QByteArray uri(bool throughProxy) const;
+    static QByteArray header(const QHttpNetworkRequest &request, bool throughProxy);
+    QHttpNetworkRequest::Operation operation;
+    QHttpNetworkRequest::Priority priority;
+    mutable QIODevice *data;
+    bool autoDecompress;
+};
+QHttpNetworkRequestPrivate::QHttpNetworkRequestPrivate(QHttpNetworkRequest::Operation op,
+        QHttpNetworkRequest::Priority pri, const QUrl &newUrl)
+    : QHttpNetworkHeaderPrivate(newUrl), operation(op), priority(pri), data(0),
+      autoDecompress(false)
+{
+}
+QHttpNetworkRequestPrivate::QHttpNetworkRequestPrivate(const QHttpNetworkRequestPrivate &other)
+    : QHttpNetworkHeaderPrivate(other)
+{
+    operation = other.operation;
+    priority = other.priority;
+    data = other.data;
+    autoDecompress = other.autoDecompress;
+}
+QHttpNetworkRequestPrivate::~QHttpNetworkRequestPrivate()
+{
+}
+bool QHttpNetworkRequestPrivate::operator==(const QHttpNetworkRequestPrivate &other) const
+{
+    return QHttpNetworkHeaderPrivate::operator==(other)
+        && (operation == other.operation)
+        && (data == other.data);
+}
+QByteArray QHttpNetworkRequestPrivate::methodName() const
+{
+    QByteArray ba;
+    switch (operation) {
+    case QHttpNetworkRequest::Options:
+        ba += "OPTIONS";
+        break;
+    case QHttpNetworkRequest::Get:
+        ba += "GET";
+        break;
+    case QHttpNetworkRequest::Head:
+        ba += "HEAD";
+        break;
+    case QHttpNetworkRequest::Post:
+        ba += "POST";
+        break;
+    case QHttpNetworkRequest::Put:
+        ba += "PUT";
+        break;
+    case QHttpNetworkRequest::Delete:
+        ba += "DELETE";
+        break;
+    case QHttpNetworkRequest::Trace:
+        ba += "TRACE";
+        break;
+    case QHttpNetworkRequest::Connect:
+        ba += "CONNECT";
+        break;
+    default:
+        break;
+    }
+    return ba;
+}
+QByteArray QHttpNetworkRequestPrivate::uri(bool throughProxy) const
+{
+    QUrl::FormattingOptions format(QUrl::RemoveFragment);
+    // for POST, query data is send as content
+    if (operation == QHttpNetworkRequest::Post && !data)
+        format |= QUrl::RemoveQuery;
+    // for requests through proxy, the Request-URI contains full url
+    if (throughProxy)
+        format |= QUrl::RemoveUserInfo;
+    else
+        format |= QUrl::RemoveScheme | QUrl::RemoveAuthority;
+    QByteArray uri = url.toEncoded(format);
+    if (uri.isEmpty() || (throughProxy && url.path().isEmpty()))
+        uri += '/';
+    return uri;
+}
+QByteArray QHttpNetworkRequestPrivate::header(const QHttpNetworkRequest &request, bool throughProxy)
+{
+    QByteArray ba = request.d->methodName();
+    QByteArray uri = request.d->uri(throughProxy);
+    ba += " " + uri;
+    QString majorVersion = QString::number(request.majorVersion());
+    QString minorVersion = QString::number(request.minorVersion());
+    ba += " HTTP/" + majorVersion.toLatin1() + "." + minorVersion.toLatin1() + "\r\n";
+    QList<QPair<QByteArray, QByteArray> > fields = request.header();
+    QList<QPair<QByteArray, QByteArray> >::const_iterator it = fields.constBegin();
+    for (; it != fields.constEnd(); ++it)
+        ba += it->first + ": " + it->second + "\r\n";
+    if (request.d->operation == QHttpNetworkRequest::Post) {
+        // add content type, if not set in the request
+        if (request.headerField("content-type").isEmpty())
+            ba += "Content-Type: application/x-www-form-urlencoded\r\n";
+        if (!request.d->data && request.d->url.hasQuery()) {
+            QByteArray query = request.d->url.encodedQuery();
+            ba += "Content-Length: "+ QByteArray::number(query.size()) + "\r\n";
+            ba += "\r\n";
+            ba += query;
+        } else {
+            ba += "\r\n";
+        }
+    } else {
+        ba += "\r\n";
+    }
+     return ba;
+}
+class QHttpNetworkReplyPrivate : public QObjectPrivate, public QHttpNetworkHeaderPrivate
+{
+public:
+    QHttpNetworkReplyPrivate(const QUrl &newUrl = QUrl());
+    ~QHttpNetworkReplyPrivate();
+    qint64 readStatus(QAbstractSocket *socket);
+    void parseStatus(const QByteArray &status);
+    qint64 readHeader(QAbstractSocket *socket);
+    void parseHeader(const QByteArray &header);
+    qint64 readBody(QAbstractSocket *socket, QIODevice *out);
+    bool findChallenge(bool forProxy, QByteArray &challenge) const;
+    QAuthenticatorPrivate::Method authenticationMethod(bool isProxy) const;
+    void clear();
+    qint64 transferRaw(QIODevice *in, QIODevice *out, qint64 size);
+    qint64 transferChunked(QIODevice *in, QIODevice *out);
+    qint64 getChunkSize(QIODevice *in, qint64 *chunkSize);
+    qint64 bytesAvailable() const;
+    bool isChunked();
+    bool connectionCloseEnabled();
+    bool isGzipped();
+#ifndef QT_NO_COMPRESS
+    bool gzipCheckHeader(QByteArray &content, int &pos);
+    int gunzipBodyPartially(QByteArray &compressed, QByteArray &inflated);
+#endif
+    void removeAutoDecompressHeader();
+    enum ReplyState {
+        NothingDoneState,
+        ReadingStatusState,
+        ReadingHeaderState,
+        ReadingDataState,
+        AllDoneState
+    } state;
+    QHttpNetworkRequest request;
+    int statusCode;
+    int majorVersion;
+    int minorVersion;
+    QString errorString;
+    QString reasonPhrase;
+    qint64 bodyLength;
+    qint64 contentRead;
+    qint64 totalProgress;
+    QByteArray fragment;
+    qint64 currentChunkSize;
+    qint64 currentChunkRead;
+    QPointer<QHttpNetworkConnection> connection;
+    bool initInflate;
+    bool streamEnd;
+#ifndef QT_NO_COMPRESS
+    z_stream inflateStrm;
+#endif
+    bool autoDecompress;
+    QByteArray responseData; // uncompressed body
+    QByteArray compressedData; // compressed body (temporary)
+    QBuffer requestDataBuffer;
+    bool requestIsBuffering;
+    bool requestIsPrepared;
+};
+QHttpNetworkReplyPrivate::QHttpNetworkReplyPrivate(const QUrl &newUrl)
+    : QHttpNetworkHeaderPrivate(newUrl), state(NothingDoneState), statusCode(100),
+      majorVersion(0), minorVersion(0), bodyLength(0), contentRead(0), totalProgress(0),
+      currentChunkSize(0), currentChunkRead(0), connection(0), initInflate(false),
+      autoDecompress(false), requestIsBuffering(false), requestIsPrepared(false)
+{
+}
+QHttpNetworkReplyPrivate::~QHttpNetworkReplyPrivate()
+{
+}
+void QHttpNetworkReplyPrivate::clear()
+{
+    state = NothingDoneState;
+    statusCode = 100;
+    bodyLength = 0;
+    contentRead = 0;
+    totalProgress = 0;
+    currentChunkSize = 0;
+    currentChunkRead = 0;
+    connection = 0;
+#ifndef QT_NO_COMPRESS
+    if (initInflate)
+        inflateEnd(&inflateStrm);
+#endif
+    initInflate = false;
+    streamEnd = false;
+    autoDecompress = false;
+    fields.clear();
+}
+// QHttpNetworkReplyPrivate
+qint64 QHttpNetworkReplyPrivate::bytesAvailable() const
+{
+    return (state != ReadingDataState ? 0 : fragment.size());
+}
+bool QHttpNetworkReplyPrivate::isGzipped()
+{
+    QByteArray encoding = headerField("content-encoding");
+    return encoding.toLower() == "gzip";
+}
+void QHttpNetworkReplyPrivate::removeAutoDecompressHeader()
+{
+    // The header "Content-Encoding  = gzip" is retained.
+    // Content-Length is removed since the actual one send by the server is for compressed data
+    QByteArray name("content-length");
+    QByteArray lowerName = name.toLower();
+    QList<QPair<QByteArray, QByteArray> >::Iterator it = fields.begin(),
+                                                   end = fields.end();
+    while (it != end) {
+        if (name == it->first.toLower()) {
+            fields.erase(it);
+            break;
+        }
+        ++it;
+    }
+}
+bool QHttpNetworkReplyPrivate::findChallenge(bool forProxy, QByteArray &challenge) const
+{
+    challenge.clear();
+    // find out the type of authentication protocol requested.
+    QByteArray header = forProxy ? "proxy-authenticate" : "www-authenticate";
+    // pick the best protocol (has to match parsing in QAuthenticatorPrivate)
+    QList<QByteArray> challenges = headerFieldValues(header);
+    for (int i = 0; i<challenges.size(); i++) {
+        QByteArray line = challenges.at(i);
+        if (!line.toLower().startsWith("negotiate"))
+            challenge = line;
+    }
+    return !challenge.isEmpty();
+}
+QAuthenticatorPrivate::Method QHttpNetworkReplyPrivate::authenticationMethod(bool isProxy) const
+{
+    // The logic is same as the one used in void QAuthenticatorPrivate::parseHttpResponse()
+    QAuthenticatorPrivate::Method method = QAuthenticatorPrivate::None;
+    QByteArray header = isProxy ? "proxy-authenticate" : "www-authenticate";
+    QList<QByteArray> challenges = headerFieldValues(header);
+    for (int i = 0; i<challenges.size(); i++) {
+        QByteArray line = challenges.at(i).trimmed().toLower();
+        if (method < QAuthenticatorPrivate::Basic
+            && line.startsWith("basic")) {
+            method = QAuthenticatorPrivate::Basic;
+        } else if (method < QAuthenticatorPrivate::Ntlm
+            && line.startsWith("ntlm")) {
+            method = QAuthenticatorPrivate::Ntlm;
+        } else if (method < QAuthenticatorPrivate::DigestMd5
+            && line.startsWith("digest")) {
+            method = QAuthenticatorPrivate::DigestMd5;
+        }
+    }
+    return method;
+}
+#ifndef QT_NO_COMPRESS
+bool QHttpNetworkReplyPrivate::gzipCheckHeader(QByteArray &content, int &pos)
+{
+    int method = 0; // method byte
+    int flags = 0;  // flags byte
+    bool ret = false;
+    // Assure two bytes in the buffer so we can peek ahead -- handle case
+    // where first byte of header is at the end of the buffer after the last
+    // gzip segment
+    pos = -1;
+    QByteArray &body = content;
+    int maxPos = body.size()-1;
+    if (maxPos < 1) {
+        return ret;
+    }
+    // Peek ahead to check the gzip magic header
+    if (body[0] != char(gz_magic[0]) ||
+        body[1] != char(gz_magic[1])) {
+        return ret;
+    }
+    pos += 2;
+    // Check the rest of the gzip header
+    if (++pos <= maxPos)
+        method = body[pos];
+    if (pos++ <= maxPos)
+        flags = body[pos];
+    if (method != Z_DEFLATED || (flags & RESERVED) != 0) {
+        return ret;
+    }
+    // Discard time, xflags and OS code:
+    pos += 6;
+    if (pos > maxPos)
+        return ret;
+    if ((flags & EXTRA_FIELD) && ((pos+2) <= maxPos)) { // skip the extra field
+        unsigned len =  (unsigned)body[++pos];
+        len += ((unsigned)body[++pos])<<8;
+        pos += len;
+        if (pos > maxPos)
+            return ret;
+    }
+    if ((flags & ORIG_NAME) != 0) { // skip the original file name
+        while(++pos <= maxPos && body[pos]) {}
+    }
+    if ((flags & COMMENT) != 0) {   // skip the .gz file comment
+        while(++pos <= maxPos && body[pos]) {}
+    }
+    if ((flags & HEAD_CRC) != 0) {  // skip the header crc
+        pos += 2;
+        if (pos > maxPos)
+            return ret;
+    }
+    ret = (pos < maxPos); // return failed, if no more bytes left
+    return ret;
+}
+int QHttpNetworkReplyPrivate::gunzipBodyPartially(QByteArray &compressed, QByteArray &inflated)
+{
+    int ret = Z_DATA_ERROR;
+    unsigned have;
+    unsigned char out[CHUNK];
+    int pos = -1;
+    if (!initInflate) {
+        // check the header
+        if (!gzipCheckHeader(compressed, pos))
+            return ret;
+        // allocate inflate state
+        inflateStrm.zalloc = Z_NULL;
+        inflateStrm.zfree = Z_NULL;
+        inflateStrm.opaque = Z_NULL;
+        inflateStrm.avail_in = 0;
+        inflateStrm.next_in = Z_NULL;
+        ret = inflateInit2(&inflateStrm, -MAX_WBITS);
+        if (ret != Z_OK)
+            return ret;
+        initInflate = true;
+        streamEnd = false;
+    }
+    //remove the header.
+    compressed.remove(0, pos+1);
+    // expand until deflate stream ends
+    inflateStrm.next_in = (unsigned char *)compressed.data();
+    inflateStrm.avail_in = compressed.size();
+    do {
+        inflateStrm.avail_out = sizeof(out);
+        inflateStrm.next_out = out;
+        ret = inflate(&inflateStrm, Z_NO_FLUSH);
+        switch (ret) {
+        case Z_NEED_DICT:
+            ret = Z_DATA_ERROR;
+            // and fall through
+        case Z_DATA_ERROR:
+        case Z_MEM_ERROR:
+            inflateEnd(&inflateStrm);
+            initInflate = false;
+            return ret;
+        }
+        have = sizeof(out) - inflateStrm.avail_out;
+        inflated.append(QByteArray((const char *)out, have));
+     } while (inflateStrm.avail_out == 0);
+    // clean up and return
+    if (ret <= Z_ERRNO || ret == Z_STREAM_END) {
+        inflateEnd(&inflateStrm);
+        initInflate = false;
+    }
+    streamEnd = (ret == Z_STREAM_END);
+    return ret;
+}
+#endif
+qint64 QHttpNetworkReplyPrivate::readStatus(QAbstractSocket *socket)
+{
+    qint64 bytes = 0;
+    char c;
+    while (socket->bytesAvailable()) {
+        // allow both CRLF & LF (only) line endings
+        if (socket->peek(&c, 1) == 1 && c == '\n') {
+            bytes += socket->read(&c, 1); // read the "n"
+            // remove the CR at the end
+            if (fragment.endsWith('\r')) {
+                fragment.truncate(fragment.length()-1);
+            }
+            parseStatus(fragment);
+            state = ReadingHeaderState;
+            fragment.clear(); // next fragment
+            break;
+        } else {
+            c = 0;
+            bytes += socket->read(&c, 1);
+            fragment.append(c);
+        }
+    }
+    return bytes;
+}
+void QHttpNetworkReplyPrivate::parseStatus(const QByteArray &status)
+{
+    const QByteArrayMatcher sp(" ");
+    int i = sp.indexIn(status);
+    const QByteArray version = status.mid(0, i);
+    int j = sp.indexIn(status, i + 1);
+    const QByteArray code = status.mid(i + 1, j - i - 1);
+    const QByteArray reason = status.mid(j + 1, status.count() - j);
+    const QByteArrayMatcher slash("/");
+    int k = slash.indexIn(version);
+    const QByteArrayMatcher dot(".");
+    int l = dot.indexIn(version, k);
+    const QByteArray major = version.mid(k + 1, l - k - 1);
+    const QByteArray minor = version.mid(l + 1, version.count() - l);
+    majorVersion = QString::fromAscii(major.constData()).toInt();
+    minorVersion = QString::fromAscii(minor.constData()).toInt();
+    statusCode = QString::fromAscii(code.constData()).toInt();
+    reasonPhrase = QString::fromAscii(reason.constData());
+}
+qint64 QHttpNetworkReplyPrivate::readHeader(QAbstractSocket *socket)
+{
+    qint64 bytes = 0;
+    char crlfcrlf[5];
+    crlfcrlf[4] = '\0';
+    char c = 0;
+    bool allHeaders = false;
+    while (!allHeaders && socket->bytesAvailable()) {
+        if (socket->peek(&c, 1) == 1 && c == '\n') {
+            // check for possible header endings. As per HTTP rfc,
+            // the header endings will be marked by CRLFCRLF. But
+            // we will allow CRLFLF, LFLF & CRLFCRLF
+            if (fragment.endsWith("\n\r") || fragment.endsWith('\n'))
+                allHeaders = true;
+        }
+        bytes += socket->read(&c, 1);
+        fragment.append(c);
+    }
+    // we received all headers now parse them
+    if (allHeaders) {
+        parseHeader(fragment);
+        state = ReadingDataState;
+        fragment.clear(); // next fragment
+        bodyLength = contentLength(); // cache the length
+    }
+    return bytes;
+}
+void QHttpNetworkReplyPrivate::parseHeader(const QByteArray &header)
+{
+    // see rfc2616, sec 4 for information about HTTP/1.1 headers.
+    // allows relaxed parsing here, accepts both CRLF & LF line endings
+    const QByteArrayMatcher lf("\n");
+    const QByteArrayMatcher colon(":");
+    int i = 0;
+    while (i < header.count()) {
+        int j = colon.indexIn(header, i); // field-name
+        if (j == -1)
+            break;
+        const QByteArray field = header.mid(i, j - i).trimmed();
+        j++;
+        // any number of LWS is allowed before and after the value
+        QByteArray value;
+        do {
+            i = lf.indexIn(header, j);
+            if (i == -1)
+                break;
+            if (!value.isEmpty())
+                value += ' ';
+            // check if we have CRLF or only LF
+            bool hasCR = (i && header[i-1] == '\r');
+            int length = i -(hasCR ? 1: 0) - j;
+            value += header.mid(j, length).trimmed();
+            j = ++i;
+        } while (i < header.count() && (header.at(i) == ' ' || header.at(i) == '\t'));
+        if (i == -1)
+            break; // something is wrong
+        fields.append(qMakePair(field, value));
+    }
+}
+bool QHttpNetworkReplyPrivate::isChunked()
+{
+    return headerField("transfer-encoding").toLower().contains("chunked");
+}
+bool QHttpNetworkReplyPrivate::connectionCloseEnabled()
+{
+    return (headerField("connection").toLower().contains("close") ||
+            headerField("proxy-connection").toLower().contains("close"));
+}
+qint64 QHttpNetworkReplyPrivate::readBody(QAbstractSocket *socket, QIODevice *out)
+{
+    qint64 bytes = 0;
+    if (isChunked()) {
+        bytes += transferChunked(socket, out); // chunked transfer encoding (rfc 2616, sec 3.6)
+    } else if (bodyLength > 0) { // we have a Content-Length
+        bytes += transferRaw(socket, out, bodyLength - contentRead);
+        if (contentRead + bytes == bodyLength)
+            state = AllDoneState;
+    } else {
+        bytes += transferRaw(socket, out, socket->bytesAvailable());
+    }
+    if (state == AllDoneState)
+        socket->readAll(); // Read the rest to clean (CRLF)
+    contentRead += bytes;
+    return bytes;
+}
+qint64 QHttpNetworkReplyPrivate::transferRaw(QIODevice *in, QIODevice *out, qint64 size)
+{
+    qint64 bytes = 0;
+    Q_ASSERT(in);
+    Q_ASSERT(out);
+    int toBeRead = qMin<qint64>(128*1024, qMin<qint64>(size, in->bytesAvailable()));
+    QByteArray raw(toBeRead, 0);
+    while (size > 0) {
+        qint64 read = in->read(raw.data(), raw.size());
+        if (read == 0)
+            return bytes;
+        // ### error checking here
+        qint64 written = out->write(raw.data(), read);
+        if (written == 0)
+            return bytes;
+        if (read != written)
+            qDebug() << "### read" << read << "written" << written;
+        bytes += read;
+        size -= read;
+        out->waitForBytesWritten(-1); // throttle
+    }
+    return bytes;
+}
+qint64 QHttpNetworkReplyPrivate::transferChunked(QIODevice *in, QIODevice *out)
+{
+    qint64 bytes = 0;
+    while (in->bytesAvailable()) { // while we can read from input
+        // if we are done with the current chunk, get the size of the new chunk
+        if (currentChunkRead >= currentChunkSize) {
+            currentChunkSize = 0;
+            currentChunkRead = 0;
+            if (bytes) {
+                char crlf[2];
+                bytes += in->read(crlf, 2); // read the "\r\n" after the chunk
+            }
+            bytes += getChunkSize(in, &currentChunkSize);
+            if (currentChunkSize == -1)
+                break;
+        }
+        // if the chunk size is 0, end of the stream
+        if (currentChunkSize == 0) {
+            state = AllDoneState;
+            break;
+        }
+        // otherwise, read data
+        qint64 readSize = qMin(in->bytesAvailable(), currentChunkSize - currentChunkRead);
+        QByteArray buffer(readSize, 0);
+        qint64 read = in->read(buffer.data(), readSize);
+        bytes += read;
+        currentChunkRead += read;
+        qint64 written = out->write(buffer);
+        Q_UNUSED(written); // Avoid compile warning when building release
+        Q_ASSERT(read == written);
+        // ### error checking here
+        out->waitForBytesWritten(-1);
+    }
+    return bytes;
+}
+qint64 QHttpNetworkReplyPrivate::getChunkSize(QIODevice *in, qint64 *chunkSize)
+{
+    qint64 bytes = 0;
+    char crlf[2];
+    *chunkSize = -1;
+    int bytesAvailable = in->bytesAvailable();
+    while (bytesAvailable > bytes) {
+        qint64 sniffedBytes =  in->peek(crlf, 2);
+        int fragmentSize = fragment.size();
+        // check the next two bytes for a "\r\n", skip blank lines
+        if ((fragmentSize && sniffedBytes == 2 && crlf[0] == '\r' && crlf[1] == '\n')
+           ||(fragmentSize > 1 && fragment.endsWith('\r')  && crlf[0] == '\n'))
+        {
+            bytes += in->read(crlf, 1);     // read the \r or \n
+            if (crlf[0] == '\r')
+                bytes += in->read(crlf, 1); // read the \n
+            bool ok = false;
+            // ignore the chunk-extension
+            fragment = fragment.mid(0, fragment.indexOf(';')).trimmed();
+            *chunkSize = fragment.toLong(&ok, 16);
+            fragment.clear();
+            break; // size done
+        } else {
+            // read the fragment to the buffer
+            char c = 0;
+            bytes += in->read(&c, 1);
+            fragment.append(c);
+        }
+    }
+    return bytes;
+}
+// QHttpNetworkConnectionPrivate
+typedef QPair<QHttpNetworkRequest, QHttpNetworkReply*> HttpMessagePair;
+class QHttpNetworkConnectionPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QHttpNetworkConnection)
+public:
+    QHttpNetworkConnectionPrivate(const QString &hostName, quint16 port, bool encrypt);
+    ~QHttpNetworkConnectionPrivate();
+    void init();
+    void connectSignals(QAbstractSocket *socket);
+    enum SocketState {
+        IdleState = 0,          // ready to send request
+        ConnectingState = 1,    // connecting to host
+        WritingState = 2,       // writing the data
+        WaitingState = 4,       // waiting for reply
+        ReadingState = 8,       // reading the reply
+        Wait4AuthState = 0x10,  // blocked for send till the current authentication slot is done
+        BusyState = (ConnectingState|WritingState|WaitingState|ReadingState|Wait4AuthState)
+    };
+    enum { ChunkSize = 4096 };
+    int indexOf(QAbstractSocket *socket) const;
+    bool isSocketBusy(QAbstractSocket *socket) const;
+    bool isSocketWriting(QAbstractSocket *socket) const;
+    bool isSocketWaiting(QAbstractSocket *socket) const;
+    bool isSocketReading(QAbstractSocket *socket) const;
+    QHttpNetworkReply *queueRequest(const QHttpNetworkRequest &request);
+    void unqueueRequest(QAbstractSocket *socket);
+    void prepareRequest(HttpMessagePair &request);
+    bool sendRequest(QAbstractSocket *socket);
+    void receiveReply(QAbstractSocket *socket, QHttpNetworkReply *reply);
+    void resendCurrentRequest(QAbstractSocket *socket);
+    void closeChannel(int channel);
+    void copyCredentials(int fromChannel, QAuthenticator *auth, bool isProxy);
+    // private slots
+    void _q_bytesWritten(qint64 bytes); // proceed sending
+    void _q_readyRead(); // pending data to read
+    void _q_disconnected(); // disconnected from host
+    void _q_startNextRequest(); // send the next request from the queue
+    void _q_restartPendingRequest(); // send the currently blocked request
+    void _q_connected(); // start sending request
+    void _q_error(QAbstractSocket::SocketError); // error from socket
+#ifndef QT_NO_NETWORKPROXY
+    void _q_proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *auth); // from transparent proxy
+#endif
+    void _q_dataReadyReadNoBuffer();
+    void _q_dataReadyReadBuffer();
+    void createAuthorization(QAbstractSocket *socket, QHttpNetworkRequest &request);
+    bool ensureConnection(QAbstractSocket *socket);
+    QString errorDetail(QNetworkReply::NetworkError errorCode, QAbstractSocket *socket);
+    void eraseData(QHttpNetworkReply *reply);
+#ifndef QT_NO_COMPRESS
+    bool expand(QAbstractSocket *socket, QHttpNetworkReply *reply, bool dataComplete);
+#endif
+    void bufferData(HttpMessagePair &request);
+    void removeReply(QHttpNetworkReply *reply);
+    QString hostName;
+    quint16 port;
+    bool encrypt;
+    struct Channel {
+        QAbstractSocket *socket;
+        SocketState state;
+        QHttpNetworkRequest request; // current request
+        QHttpNetworkReply *reply; // current reply for this request
+        qint64 written;
+        qint64 bytesTotal;
+        bool resendCurrent;
+        int lastStatus; // last status received on this channel
+        bool pendingEncrypt; // for https (send after encrypted)
+        int reconnectAttempts; // maximum 2 reconnection attempts
+        QAuthenticatorPrivate::Method authMehtod;
+        QAuthenticatorPrivate::Method proxyAuthMehtod;
+        QAuthenticator authenticator;
+        QAuthenticator proxyAuthenticator;
+#ifndef QT_NO_OPENSSL
+        bool ignoreSSLErrors;
+#endif
+        Channel() :state(IdleState), reply(0), written(0), bytesTotal(0), resendCurrent(false), reconnectAttempts(2),
+            authMehtod(QAuthenticatorPrivate::None), proxyAuthMehtod(QAuthenticatorPrivate::None)
+#ifndef QT_NO_OPENSSL
+            , ignoreSSLErrors(false)
+#endif
+        {}
+    };
+    static const int channelCount;
+    Channel channels[2]; // maximum of 2 socket connections to the server
+    bool pendingAuthSignal; // there is an incomplete authentication signal
+    bool pendingProxyAuthSignal; // there is an incomplete proxy authentication signal
+    void appendData(QHttpNetworkReply &reply, const QByteArray &fragment, bool compressed);
+    qint64 bytesAvailable(const QHttpNetworkReply &reply, bool compressed = false) const;
+    qint64 read(QHttpNetworkReply &reply, QByteArray &data, qint64 maxSize, bool compressed);
+    void emitReplyError(QAbstractSocket *socket, QHttpNetworkReply *reply, QNetworkReply::NetworkError errorCode);
+    bool handleAuthenticateChallenge(QAbstractSocket *socket, QHttpNetworkReply *reply, bool isProxy, bool &resend);
+    void allDone(QAbstractSocket *socket, QHttpNetworkReply *reply);
+    void handleStatus(QAbstractSocket *socket, QHttpNetworkReply *reply);
+    inline bool emitSignals(QHttpNetworkReply *reply);
+    inline bool expectContent(QHttpNetworkReply *reply);
+#ifndef QT_NO_OPENSSL
+    void _q_encrypted(); // start sending request (https)
+    void _q_sslErrors(const QList<QSslError> &errors); // ssl errors from the socket
+    QSslConfiguration sslConfiguration(const QHttpNetworkReply &reply) const;
+#endif
+#ifndef QT_NO_NETWORKPROXY
+    QNetworkProxy networkProxy;
+#endif
+    //The request queues
+    QList<HttpMessagePair> highPriorityQueue;
+    QList<HttpMessagePair> lowPriorityQueue;
+};
+const int QHttpNetworkConnectionPrivate::channelCount = 2;
+// the maximum amount of requests that might be pipelined into a socket
+// from what was suggested, 3 seems to be OK
+const int QHttpNetworkConnectionPrivate::defaultPipelineLength = 3;
 QHttpNetworkConnectionPrivate::QHttpNetworkConnectionPrivate(const QString &hostName, quint16 port, bool encrypt)
 : hostName(hostName), port(port), encrypt(encrypt),
+  channelCount(defaultChannelCount),
   pendingAuthSignal(false), pendingProxyAuthSignal(false)
 #ifndef QT_NO_NETWORKPROXY
 …
 #endif
+{
+}
+    channels = new QHttpNetworkConnectionChannel[channelCount];
+}
+QHttpNetworkConnectionPrivate::QHttpNetworkConnectionPrivate(quint16 channelCount, const QString &hostName, quint16 port, bool encrypt)
+: hostName(hostName), port(port), encrypt(encrypt),
+  channelCount(channelCount),
+  pendingAuthSignal(false), pendingProxyAuthSignal(false)
+#ifndef QT_NO_NETWORKPROXY
+  , networkProxy(QNetworkProxy::NoProxy)
+#endif
+{
+    channels = new QHttpNetworkConnectionChannel[channelCount];
+}
 QHttpNetworkConnectionPrivate::~QHttpNetworkConnectionPrivate()
+{
     for (int i = 0; i < channelCount; ++i) {
+        channels[i].socket->close();
+        delete channels[i].socket;
+    }
+}
+void QHttpNetworkConnectionPrivate::connectSignals(QAbstractSocket *socket)
+{
+    Q_Q(QHttpNetworkConnection);
+    QObject::connect(socket, SIGNAL(bytesWritten(qint64)),
+               q, SLOT(_q_bytesWritten(qint64)),
+               Qt::DirectConnection);
+    QObject::connect(socket, SIGNAL(connected()),
+               q, SLOT(_q_connected()),
+               Qt::DirectConnection);
+    QObject::connect(socket, SIGNAL(readyRead()),
+               q, SLOT(_q_readyRead()),
+               Qt::DirectConnection);
+    QObject::connect(socket, SIGNAL(disconnected()),
+               q, SLOT(_q_disconnected()),
+               Qt::DirectConnection);
+    QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
+               q, SLOT(_q_error(QAbstractSocket::SocketError)),
+               Qt::DirectConnection);
+#ifndef QT_NO_NETWORKPROXY
+    QObject::connect(socket, SIGNAL(proxyAuthenticationRequired(const QNetworkProxy&, QAuthenticator*)),
+               q, SLOT(_q_proxyAuthenticationRequired(const QNetworkProxy&, QAuthenticator*)),
+               Qt::DirectConnection);
+#endif
+#ifndef QT_NO_OPENSSL
+    QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
+    QObject::connect(sslSocket, SIGNAL(encrypted()),
+                     q, SLOT(_q_encrypted()),
+                     Qt::DirectConnection);
+    QObject::connect(sslSocket, SIGNAL(sslErrors(const QList<QSslError>&)),
+               q, SLOT(_q_sslErrors(const QList<QSslError>&)),
+               Qt::DirectConnection);
+#endif
+        if (channels[i].socket) {
+            channels[i].socket->close();
+            delete channels[i].socket;
+        }
+    }
+    delete []channels;
+}
 void QHttpNetworkConnectionPrivate::init()
+{
+    for (int i = 0; i < channelCount; ++i) {
+#ifndef QT_NO_OPENSSL
+        channels[i].socket = new QSslSocket;
+#else
+        channels[i].socket = new QTcpSocket;
+#endif
+        connectSignals(channels[i].socket);
+    for (int i = 0; i < channelCount; i++) {
+        channels[i].setConnection(this->q_func());
+        channels[i].init();
+    }
+}
 …
         if (channels[i].socket == socket)
             return i;
+    return -1;
+}
+bool QHttpNetworkConnectionPrivate::isSocketBusy(QAbstractSocket *socket) const
+{
+    int i = indexOf(socket);
+    return (channels[i].state & BusyState);
+}
+bool QHttpNetworkConnectionPrivate::isSocketWriting(QAbstractSocket *socket) const
+{
+    int i = indexOf(socket);
+    return (i != -1 && (channels[i].state & WritingState));
+}
+bool QHttpNetworkConnectionPrivate::isSocketWaiting(QAbstractSocket *socket) const
+{
+    int i = indexOf(socket);
+    return (i != -1 && (channels[i].state & WaitingState));
+}
+bool QHttpNetworkConnectionPrivate::isSocketReading(QAbstractSocket *socket) const
+{
+    int i = indexOf(socket);
+    return (i != -1 && (channels[i].state & ReadingState));
+}
+void QHttpNetworkConnectionPrivate::appendData(QHttpNetworkReply &reply, const QByteArray &fragment, bool compressed)
+{
+    QByteArray *ba = (compressed) ? &reply.d_func()->compressedData : &reply.d_func()->responseData;
+    ba->append(fragment);
+    return;
+}
+qint64 QHttpNetworkConnectionPrivate::bytesAvailable(const QHttpNetworkReply &reply, bool compressed) const
+{
+    const QByteArray *ba = (compressed) ? &reply.d_func()->compressedData : &reply.d_func()->responseData;
+    return ba->size();
+}
+qint64 QHttpNetworkConnectionPrivate::read(QHttpNetworkReply &reply, QByteArray &data, qint64 maxSize, bool compressed)
+{
+    QByteArray *ba = (compressed) ? &reply.d_func()->compressedData : &reply.d_func()->responseData;
+    if (maxSize == -1 || maxSize >= ba->size()) {
+        // read the whole data
+        data = *ba;
+        ba->clear();
+    } else {
+        // read only the requested length
+        data = ba->mid(0, maxSize);
+        ba->remove(0, maxSize);
+    }
+    return data.size();
+}
+void QHttpNetworkConnectionPrivate::eraseData(QHttpNetworkReply *reply)
+{
+    reply->d_func()->compressedData.clear();
+    reply->d_func()->responseData.clear();
+    qFatal("Called with unknown socket object.");
+    return 0;
+}
+qint64 QHttpNetworkConnectionPrivate::uncompressedBytesAvailable(const QHttpNetworkReply &reply) const
+{
+    return reply.d_func()->responseData.byteAmount();
+}
+qint64 QHttpNetworkConnectionPrivate::uncompressedBytesAvailableNextBlock(const QHttpNetworkReply &reply) const
+{
+    return reply.d_func()->responseData.sizeNextBlock();
+}
 …
     QByteArray value;
     // check if Content-Length is provided
+    QIODevice *data = request.data();
+    if (data && request.contentLength() == -1) {
+        if (!data->isSequential())
+            request.setContentLength(data->size());
+        else
+            bufferData(messagePair); // ### or do chunked upload
+    QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();
+    if (uploadByteDevice) {
+        if (request.contentLength() != -1 && uploadByteDevice->size() != -1) {
+            // both values known, take the smaller one.
+            request.setContentLength(qMin(uploadByteDevice->size(), request.contentLength()));
+        } else if (request.contentLength() == -1 && uploadByteDevice->size() != -1) {
+            // content length not supplied by user, but the upload device knows it
+            request.setContentLength(uploadByteDevice->size());
+        } else if (request.contentLength() != -1 && uploadByteDevice->size() == -1) {
+            // everything OK, the user supplied us the contentLength
+        } else if (request.contentLength() == -1 && uploadByteDevice->size() == -1) {
+            qFatal("QHttpNetworkConnectionPrivate: Neither content-length nor upload device size were given");
+        }
+    }
     // set the Connection/Proxy-Connection: Keep-Alive headers
 …
+    }
 #endif
+    // set the gzip header
+    // If the request had a accept-encoding set, we better not mess
+    // with it. If it was not set, we announce that we understand gzip
+    // and remember this fact in request.d->autoDecompress so that
+    // we can later decompress the HTTP reply if it has such an
+    // encoding.
     value = request.headerField("accept-encoding");
     if (value.isEmpty()) {
 …
 #endif
+    }
+    // some websites mandate an accept-language header and fail
+    // if it is not sent. This is a problem with the website and
+    // not with us, but we work around this by setting
+    // one always.
+    value = request.headerField("accept-language");
+    if (value.isEmpty()) {
+        QString systemLocale = QLocale::system().name().replace(QChar::fromAscii('_'),QChar::fromAscii('-'));
+        QString acceptLanguage;
+        if (systemLocale == QLatin1String("C"))
+            acceptLanguage = QString::fromAscii("en,*");
+        else if (systemLocale.startsWith(QLatin1String("en-")))
+            acceptLanguage = QString::fromAscii("%1,*").arg(systemLocale);
+        else
+            acceptLanguage = QString::fromAscii("%1,en,*").arg(systemLocale);
+        request.setHeaderField("Accept-Language", acceptLanguage.toAscii());
+    }
     // set the User Agent
     value = request.headerField("user-agent");
 …
+}
+bool QHttpNetworkConnectionPrivate::ensureConnection(QAbstractSocket *socket)
+{
+    // make sure that this socket is in a connected state, if not initiate
+    // connection to the host.
+    if (socket->state() != QAbstractSocket::ConnectedState) {
+        // connect to the host if not already connected.
+        int index = indexOf(socket);
+        channels[index].state = ConnectingState;
+        channels[index].pendingEncrypt = encrypt;
+        // 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(channels[index].authenticator);
+        if (priv && priv->phase == QAuthenticatorPrivate::Done)
+            priv->phase = QAuthenticatorPrivate::Start;
+        priv = QAuthenticatorPrivate::getPrivate(channels[index].proxyAuthenticator);
+        if (priv && priv->phase == QAuthenticatorPrivate::Done)
+            priv->phase = QAuthenticatorPrivate::Start;
+        QString connectHost = hostName;
+        qint16 connectPort = port;
+#ifndef QT_NO_NETWORKPROXY
+        // HTTPS always use transparent proxy.
+        if (networkProxy.type() != QNetworkProxy::NoProxy && !encrypt) {
+            connectHost = networkProxy.hostName();
+            connectPort = networkProxy.port();
+        }
+#endif
+        if (encrypt) {
+#ifndef QT_NO_OPENSSL
+            QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
+            sslSocket->connectToHostEncrypted(connectHost, connectPort);
+            if (channels[index].ignoreSSLErrors)
+                sslSocket->ignoreSslErrors();
+#else
+            emitReplyError(socket, channels[index].reply, QNetworkReply::ProtocolUnknownError);
+#endif
+        } else {
+            socket->connectToHost(connectHost, connectPort);
+        }
+        return false;
+    }
+    return true;
+}
+bool QHttpNetworkConnectionPrivate::sendRequest(QAbstractSocket *socket)
+{
+    Q_Q(QHttpNetworkConnection);
+    int i = indexOf(socket);
+    switch (channels[i].state) {
+    case IdleState: { // write the header
+        if (!ensureConnection(socket)) {
+            // wait for the connection (and encryption) to be done
+            // sendRequest will be called again from either
+            // _q_connected or _q_encrypted
+            return false;
+        }
+        channels[i].written = 0; // excluding the header
+        channels[i].bytesTotal = 0;
+        if (channels[i].reply) {
+            channels[i].reply->d_func()->clear();
+            channels[i].reply->d_func()->connection = q;
+            channels[i].reply->d_func()->autoDecompress = channels[i].request.d->autoDecompress;
+        }
+        channels[i].state = WritingState;
+        channels[i].pendingEncrypt = false;
+        // if the url contains authentication parameters, use the new ones
+        // both channels will use the new authentication parameters
+        if (!channels[i].request.url().userInfo().isEmpty()) {
+            QUrl url = channels[i].request.url();
+            QAuthenticator &auth = channels[i].authenticator;
+            if (url.userName() != auth.user()
+                || (!url.password().isEmpty() && url.password() != auth.password())) {
+                auth.setUser(url.userName());
+                auth.setPassword(url.password());
+                copyCredentials(i, &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());
+            channels[i].request.setUrl(url);
+        }
+        createAuthorization(socket, channels[i].request);
+#ifndef QT_NO_NETWORKPROXY
+        QByteArray header = QHttpNetworkRequestPrivate::header(channels[i].request,
+            (networkProxy.type() != QNetworkProxy::NoProxy));
+#else
+        QByteArray header = QHttpNetworkRequestPrivate::header(channels[i].request,
+            false);
+#endif
+        socket->write(header);
+        QIODevice *data = channels[i].request.d->data;
+        QHttpNetworkReply *reply = channels[i].reply;
+        if (reply && reply->d_func()->requestDataBuffer.size())
+            data = &channels[i].reply->d_func()->requestDataBuffer;
+        if (data && (data->isOpen() || data->open(QIODevice::ReadOnly))) {
+            if (data->isSequential()) {
+                channels[i].bytesTotal = -1;
+                QObject::connect(data, SIGNAL(readyRead()), q, SLOT(_q_dataReadyReadNoBuffer()));
+                QObject::connect(data, SIGNAL(readChannelFinished()), q, SLOT(_q_dataReadyReadNoBuffer()));
+            } else {
+                channels[i].bytesTotal = data->size();
+            }
+        } else {
+            channels[i].state = WaitingState;
+            break;
+        }
+        // write the initial chunk together with the headers
+        // fall through
+    }
+    case WritingState: { // write the data
+        QIODevice *data = channels[i].request.d->data;
+        if (channels[i].reply->d_func()->requestDataBuffer.size())
+            data = &channels[i].reply->d_func()->requestDataBuffer;
+        if (!data || channels[i].bytesTotal == channels[i].written) {
+            channels[i].state = WaitingState; // now wait for response
+            break;
+        }
+        QByteArray chunk;
+        chunk.resize(ChunkSize);
+        qint64 readSize = data->read(chunk.data(), ChunkSize);
+        if (readSize == -1) {
+            // source has reached EOF
+            channels[i].state = WaitingState; // now wait for response
+        } else if (readSize > 0) {
+            // source gave us something useful
+            channels[i].written += socket->write(chunk.data(), readSize);
+            if (channels[i].reply)
+                emit channels[i].reply->dataSendProgress(channels[i].written, channels[i].bytesTotal);
+        }
+        break;
+    }
+    case WaitingState:
+    case ReadingState:
+    case Wait4AuthState:
+        // ignore _q_bytesWritten in these states
+        // fall through
+    default:
+        break;
+    }
+    return true;
+}
+bool QHttpNetworkConnectionPrivate::emitSignals(QHttpNetworkReply *reply)
+{
+    // for 401 & 407 don't emit the data signals. Content along with these
+    // responses are send only if the authentication fails.
+    return (reply && reply->d_func()->statusCode != 401 && reply->d_func()->statusCode != 407);
+}
+bool QHttpNetworkConnectionPrivate::expectContent(QHttpNetworkReply *reply)
+{
+    // check whether we can expect content after the headers (rfc 2616, sec4.4)
+    if (!reply)
+        return false;
+    if ((reply->d_func()->statusCode >= 100 && reply->d_func()->statusCode < 200)
+        || reply->d_func()->statusCode == 204 || reply->d_func()->statusCode == 304)
+        return false;
+    if (reply->d_func()->request.operation() == QHttpNetworkRequest::Head)
+        return !emitSignals(reply);
+    if (reply->d_func()->contentLength() == 0)
+        return false;
+    return true;
+}
 void QHttpNetworkConnectionPrivate::emitReplyError(QAbstractSocket *socket,
 …
         int i = indexOf(socket);
         // remove the corrupt data if any
         eraseData(channels[i].reply);
         closeChannel(i);
+        reply->d_func()->eraseData();
+        channels[i].close();
         // send the next request
-        QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
+    }
+}
-#ifndef QT_NO_COMPRESS
-bool QHttpNetworkConnectionPrivate::expand(QAbstractSocket *socket, QHttpNetworkReply *reply, bool dataComplete)
+{
-    Q_ASSERT(socket);
-    Q_ASSERT(reply);
-    qint64 total = bytesAvailable(*reply, true);
-    if (total >= CHUNK || dataComplete) {
-        int i = indexOf(socket);
-         // uncompress the data
-        QByteArray content, inflated;
-        read(*reply, content, -1, true);
-        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();
-                appendData(*reply, inflated, false);
-                if (emitSignals(reply)) {
-                    emit reply->readyRead();
-                    // make sure that the reply is valid
-                    if (channels[i].reply != reply)
-                        return true;
-                    emit reply->dataReadProgress(reply->d_func()->totalProgress, 0);
-                    // make sure that the reply is valid
-                    if (channels[i].reply != reply)
-                        return true;
+                }
+            }
-        } else {
-            emitReplyError(socket, reply, QNetworkReply::ProtocolFailure);
-            return false;
+        }
+    }
-    return true;
+}
-#endif
-void QHttpNetworkConnectionPrivate::receiveReply(QAbstractSocket *socket, QHttpNetworkReply *reply)
+{
-    Q_ASSERT(socket);
-    Q_Q(QHttpNetworkConnection);
-    qint64 bytes = 0;
-    QAbstractSocket::SocketState state = socket->state();
-    int i = indexOf(socket);
-    // connection might be closed to signal the end of data
-    if (state == QAbstractSocket::UnconnectedState) {
-        if (!socket->bytesAvailable()) {
-            if (reply && reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {
-                reply->d_func()->state = QHttpNetworkReplyPrivate::AllDoneState;
-                channels[i].state = IdleState;
-                allDone(socket, reply);
-            } else {
-                // try to reconnect/resend before sending an error.
-                if (channels[i].reconnectAttempts-- > 0) {
-                    resendCurrentRequest(socket);
-                } else {
-                    reply->d_func()->errorString = errorDetail(QNetworkReply::RemoteHostClosedError, socket);
-                    emit reply->finishedWithError(QNetworkReply::RemoteHostClosedError, reply->d_func()->errorString);
-                    QMetaObject::invokeMethod(q, "_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:
-            bytes += reply->d_func()->readStatus(socket);
-            channels[i].lastStatus = reply->d_func()->statusCode;
-            break;
-        case QHttpNetworkReplyPrivate::ReadingHeaderState:
-            bytes += reply->d_func()->readHeader(socket);
-            if (reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {
-                if (reply->d_func()->isGzipped() && reply->d_func()->autoDecompress) {
-                    // remove the Content-Length from header
-                    reply->d_func()->removeAutoDecompressHeader();
-                } else {
-                    reply->d_func()->autoDecompress = false;
+                }
-                if (reply && reply->d_func()->statusCode == 100) {
-                    reply->d_func()->state = QHttpNetworkReplyPrivate::ReadingStatusState;
-                    break; // ignore
+                }
-                if (emitSignals(reply))
-                    emit reply->headerChanged();
-                if (!expectContent(reply)) {
-                    reply->d_func()->state = QHttpNetworkReplyPrivate::AllDoneState;
-                    channels[i].state = IdleState;
-                    allDone(socket, reply);
-                    return;
+                }
+            }
-            break;
-        case QHttpNetworkReplyPrivate::ReadingDataState: {
-            QBuffer fragment;
-            fragment.open(QIODevice::WriteOnly);
-            bytes = reply->d_func()->readBody(socket, &fragment);
-            if (bytes) {
-                appendData(*reply, fragment.data(), reply->d_func()->autoDecompress);
-                if (!reply->d_func()->autoDecompress) {
-                    reply->d_func()->totalProgress += fragment.size();
-                    if (emitSignals(reply)) {
-                        emit reply->readyRead();
-                        // make sure that the reply is valid
-                        if (channels[i].reply != reply)
-                            return;
-                        emit reply->dataReadProgress(reply->d_func()->totalProgress, reply->d_func()->bodyLength);
-                        // make sure that the reply is valid
-                        if (channels[i].reply != reply)
-                            return;
+                    }
+                }
-#ifndef QT_NO_COMPRESS
-                else if (!expand(socket, reply, false)) { // expand a chunk if possible
-                    return; // ### expand failed
+                }
-#endif
+            }
-            if (reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState)
-                break;
-            // everything done, fall through
+            }
-      case QHttpNetworkReplyPrivate::AllDoneState:
-            channels[i].state = IdleState;
-            allDone(socket, reply);
-            break;
-        default:
-            break;
+        }
+    }
+}
-void QHttpNetworkConnectionPrivate::allDone(QAbstractSocket *socket, QHttpNetworkReply *reply)
+{
-#ifndef QT_NO_COMPRESS
-    // expand the whole data.
-    if (expectContent(reply) && reply->d_func()->autoDecompress && !reply->d_func()->streamEnd)
-        expand(socket, reply, true); // ### if expand returns false, its an error
-#endif
-    // while handling 401 & 407, we might reset the status code, so save this.
-    bool emitFinished = emitSignals(reply);
-    handleStatus(socket, reply);
-    // ### at this point there should be no more data on the socket
-    // close if server requested
-    int i = indexOf(socket);
-    if (reply->d_func()->connectionCloseEnabled())
-        closeChannel(i);
-    // queue the finished signal, this is required since we might send new requests from
-    // slot connected to it. The socket will not fire readyRead signal, if we are already
-    // in the slot connected to readyRead
-    if (emitFinished)
-        QMetaObject::invokeMethod(reply, "finished", Qt::QueuedConnection);
-    // reset the reconnection attempts after we receive a complete reply.
-    // in case of failures, each channel will attempt two reconnects before emitting error.
-    channels[i].reconnectAttempts = 2;
+}
-void QHttpNetworkConnectionPrivate::handleStatus(QAbstractSocket *socket, QHttpNetworkReply *reply)
+{
-    Q_ASSERT(socket);
-    Q_ASSERT(reply);
-    Q_Q(QHttpNetworkConnection);
-    int statusCode = reply->statusCode();
-    bool resend = false;
-    switch (statusCode) {
-    case 401:
-    case 407:
-        handleAuthenticateChallenge(socket, reply, (statusCode == 407), resend);
-        if (resend) {
-            eraseData(reply);
-            sendRequest(socket);
+        }
-        break;
-    default:
         QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
+    }
 …
+// handles the authentication for one channel and eventually re-starts the other channels
 bool QHttpNetworkConnectionPrivate::handleAuthenticateChallenge(QAbstractSocket *socket, QHttpNetworkReply *reply,
                                                                 bool isProxy, bool &resend)
 …
             if ((isProxy && pendingProxyAuthSignal) ||(!isProxy && pendingAuthSignal)) {
                 // drop the request
                 eraseData(channels[i].reply);
                 closeChannel(i);
+                reply->d_func()->eraseData();
+                channels[i].close();
                 channels[i].lastStatus = 0;
                 channels[i].state =  Wait4AuthState;
+                channels[i].state =  QHttpNetworkConnectionChannel::Wait4AuthState;
                 return false;
+            }
             // cannot use this socket until the slot returns
             channels[i].state = WaitingState;
+            channels[i].state = QHttpNetworkConnectionChannel::WaitingState;
             socket->blockSignals(true);
             if (!isProxy) {
 …
             socket->blockSignals(false);
             // socket free to use
             channels[i].state = IdleState;
+            channels[i].state = QHttpNetworkConnectionChannel::IdleState;
             if (priv->phase != QAuthenticatorPrivate::Done) {
                 // send any pending requests
                 copyCredentials(i,  auth, isProxy);
                 QMetaObject::invokeMethod(q, "_q_restartPendingRequest", Qt::QueuedConnection);
+                QMetaObject::invokeMethod(q, "_q_restartAuthPendingRequests", Qt::QueuedConnection);
+            }
+        }
 …
             emit channels[i].reply->headerChanged();
             emit channels[i].reply->readyRead();
-            emit channels[i].reply->finished();
             QNetworkReply::NetworkError errorCode =
                 isProxy
 …
             // remove pending request on the other channels
             for (int j = 0; j < channelCount; ++j) {
                 if (j != i && channels[j].state ==  Wait4AuthState)
                     channels[j].state = IdleState;
+                if (j != i && channels[j].state ==  QHttpNetworkConnectionChannel::Wait4AuthState)
+                    channels[j].state = QHttpNetworkConnectionChannel::IdleState;
+            }
             return true;
 …
     int i = indexOf(socket);
     if (channels[i].authMehtod != QAuthenticatorPrivate::None) {
         if (!(channels[i].authMehtod == QAuthenticatorPrivate::Ntlm && channels[i].lastStatus != 401)) {
 …
             if (priv && priv->method != QAuthenticatorPrivate::None) {
                 QByteArray response = priv->calculateResponse(request.d->methodName(), request.d->uri(false));
                 request.setHeaderField("authorization", response);
+                request.setHeaderField("Authorization", response);
+            }
+        }
 …
             if (priv && priv->method != QAuthenticatorPrivate::None) {
                 QByteArray response = priv->calculateResponse(request.d->methodName(), request.d->uri(false));
                 request.setHeaderField("proxy-authorization", response);
+                request.setHeaderField("Proxy-Authorization", response);
+            }
+        }
 …
+}
+void QHttpNetworkConnectionPrivate::unqueueRequest(QAbstractSocket *socket)
+void QHttpNetworkConnectionPrivate::requeueRequest(const HttpMessagePair &pair)
+{
+    Q_Q(QHttpNetworkConnection);
+    QHttpNetworkRequest request = pair.first;
+    switch (request.priority()) {
+    case QHttpNetworkRequest::HighPriority:
+        highPriorityQueue.prepend(pair);
+        break;
+    case QHttpNetworkRequest::NormalPriority:
+    case QHttpNetworkRequest::LowPriority:
+        lowPriorityQueue.prepend(pair);
+        break;
+    }
+    QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
+}
+void QHttpNetworkConnectionPrivate::dequeueAndSendRequest(QAbstractSocket *socket)
+{
     Q_ASSERT(socket);
 …
     if (!highPriorityQueue.isEmpty()) {
+        for (int j = highPriorityQueue.count() - 1; j >= 0; --j) {
+            HttpMessagePair &messagePair = highPriorityQueue[j];
+            if (!messagePair.second->d_func()->requestIsPrepared)
+                prepareRequest(messagePair);
+            if (!messagePair.second->d_func()->requestIsBuffering) {
+                channels[i].request = messagePair.first;
+                channels[i].reply = messagePair.second;
+                sendRequest(socket);
+                highPriorityQueue.removeAt(j);
+                return;
+            }
+        }
+        // remove from queue before sendRequest! else we might pipeline the same request again
+        HttpMessagePair messagePair = highPriorityQueue.takeLast();
+        if (!messagePair.second->d_func()->requestIsPrepared)
+            prepareRequest(messagePair);
+        channels[i].request = messagePair.first;
+        channels[i].reply = messagePair.second;
+        channels[i].sendRequest();
+        return;
+    }
     if (!lowPriorityQueue.isEmpty()) {
+        for (int j = lowPriorityQueue.count() - 1; j >= 0; --j) {
+            HttpMessagePair &messagePair = lowPriorityQueue[j];
+            if (!messagePair.second->d_func()->requestIsPrepared)
+                prepareRequest(messagePair);
+            if (!messagePair.second->d_func()->requestIsBuffering) {
+                channels[i].request = messagePair.first;
+                channels[i].reply = messagePair.second;
+                sendRequest(socket);
+                lowPriorityQueue.removeAt(j);
+                return;
+            }
+        }
+    }
+}
+void QHttpNetworkConnectionPrivate::closeChannel(int channel)
+{
+    QAbstractSocket *socket = channels[channel].socket;
+    socket->blockSignals(true);
+    socket->close();
+    socket->blockSignals(false);
+    channels[channel].state = IdleState;
+}
+void QHttpNetworkConnectionPrivate::resendCurrentRequest(QAbstractSocket *socket)
+{
+    Q_Q(QHttpNetworkConnection);
+    Q_ASSERT(socket);
+        // remove from queue before sendRequest! else we might pipeline the same request again
+        HttpMessagePair messagePair = lowPriorityQueue.takeLast();
+        if (!messagePair.second->d_func()->requestIsPrepared)
+            prepareRequest(messagePair);
+        channels[i].request = messagePair.first;
+        channels[i].reply = messagePair.second;
+        channels[i].sendRequest();
+        return;
+    }
+}
+// this is called from _q_startNextRequest and when a request has been sent down a socket from the channel
+void QHttpNetworkConnectionPrivate::fillPipeline(QAbstractSocket *socket)
+{
+    // return fast if there is nothing to pipeline
+    if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
+        return;
     int i = indexOf(socket);
+    closeChannel(i);
+    channels[i].resendCurrent = true;
+    QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
+}
+    bool highPriorityQueueProcessingDone = false;
+    bool lowPriorityQueueProcessingDone = false;
+    while (!highPriorityQueueProcessingDone && !lowPriorityQueueProcessingDone) {
+        // this loop runs once per request we intend to pipeline in.
+        if (channels[i].pipeliningSupported != QHttpNetworkConnectionChannel::PipeliningProbablySupported)
+            return;
+        // the current request that is in must already support pipelining
+        if (!channels[i].request.isPipeliningAllowed())
+            return;
+        // the current request must be a idempotent (right now we only check GET)
+        if (channels[i].request.operation() != QHttpNetworkRequest::Get)
+            return;
+        // check if socket is connected
+        if (socket->state() != QAbstractSocket::ConnectedState)
+            return;
+        // check for resendCurrent
+        if (channels[i].resendCurrent)
+            return;
+        // we do not like authentication stuff
+        // ### make sure to be OK with this in later releases
+        if (!channels[i].authenticator.isNull() || !channels[i].authenticator.user().isEmpty())
+            return;
+        if (!channels[i].proxyAuthenticator.isNull() || !channels[i].proxyAuthenticator.user().isEmpty())
+            return;
+        // check for pipeline length
+        if (channels[i].alreadyPipelinedRequests.length() >= defaultPipelineLength)
+            return;
+        // must be in ReadingState or WaitingState
+        if (! (channels[i].state == QHttpNetworkConnectionChannel::WaitingState
+               || channels[i].state == QHttpNetworkConnectionChannel::ReadingState))
+            return;
+        highPriorityQueueProcessingDone = fillPipeline(highPriorityQueue, channels[i]);
+        // not finished with highPriorityQueue? then loop again
+        if (!highPriorityQueueProcessingDone)
+            continue;
+        // highPriorityQueue was processed, now deal with the lowPriorityQueue
+        lowPriorityQueueProcessingDone = fillPipeline(lowPriorityQueue, channels[i]);
+    }
+}
+// returns true when the processing of a queue has been done
+bool QHttpNetworkConnectionPrivate::fillPipeline(QList<HttpMessagePair> &queue, QHttpNetworkConnectionChannel &channel)
+{
+    if (queue.isEmpty())
+        return true;
+    for (int i = queue.count() - 1; i >= 0; --i) {
+        HttpMessagePair messagePair = queue.at(i);
+        const QHttpNetworkRequest &request = messagePair.first;
+        // we currently do not support pipelining if HTTP authentication is used
+        if (!request.url().userInfo().isEmpty())
+            continue;
+        // take only GET requests
+        if (request.operation() != QHttpNetworkRequest::Get)
+            continue;
+        if (!request.isPipeliningAllowed())
+            continue;
+        // remove it from the queue
+        queue.takeAt(i);
+        // we modify the queue we iterate over here, but since we return from the function
+        // afterwards this is fine.
+        // actually send it
+        if (!messagePair.second->d_func()->requestIsPrepared)
+            prepareRequest(messagePair);
+        channel.pipelineInto(messagePair);
+        // return false because we processed something and need to process again
+        return false;
+    }
+    // return true, the queue has been processed and not changed
+    return true;
+}
 QString QHttpNetworkConnectionPrivate::errorDetail(QNetworkReply::NetworkError errorCode, QAbstractSocket* socket)
 …
+}
+// this is called from the destructor of QHttpNetworkReply. It is called when
+// the reply was finished correctly or when it was aborted.
 void QHttpNetworkConnectionPrivate::removeReply(QHttpNetworkReply *reply)
+{
     Q_Q(QHttpNetworkConnection);
     // remove the from active list.
+    // check if the reply is currently being processed or it is pipelined in
     for (int i = 0; i < channelCount; ++i) {
+        // is the reply associated the currently processing of this channel?
         if (channels[i].reply == reply) {
             channels[i].reply = 0;
+            closeChannel(i);
+            if (!reply->isFinished() && !channels[i].alreadyPipelinedRequests.isEmpty()) {
+                // the reply had to be prematurely removed, e.g. it was not finished
+                // therefore we have to requeue the already pipelined requests.
+                channels[i].requeueCurrentlyPipelinedRequests();
+            }
+            // if HTTP mandates we should close
+            // or the reply is not finished yet, e.g. it was aborted
+            // we have to close that connection
+            if (reply->d_func()->isConnectionCloseEnabled() || !reply->isFinished())
+                channels[i].close();
             QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
             return;
+        }
+        // is the reply inside the pipeline of this channel already?
+        for (int j = 0; j < channels[i].alreadyPipelinedRequests.length(); j++) {
+            if (channels[i].alreadyPipelinedRequests.at(j).second == reply) {
+               // Remove that HttpMessagePair
+               channels[i].alreadyPipelinedRequests.removeAt(j);
+               channels[i].requeueCurrentlyPipelinedRequests();
+               // Since some requests had already been pipelined, but we removed
+               // one and re-queued the others
+               // we must force a connection close after the request that is
+               // currently in processing has been finished.
+               if (channels[i].reply)
+                   channels[i].reply->d_func()->forceConnectionCloseEnabled = true;
+               QMetaObject::invokeMethod(q, "_q_startNextRequest", Qt::QueuedConnection);
+               return;
+            }
+        }
+    }
 …
-//private slots
-void QHttpNetworkConnectionPrivate::_q_readyRead()
+{
-    Q_Q(QHttpNetworkConnection);
-    QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(q->sender());
-    if (!socket)
-        return; // ### error
-    if (isSocketWaiting(socket) || isSocketReading(socket)) {
-        int i = indexOf(socket);
-        channels[i].state = ReadingState;
-        if (channels[i].reply)
-            receiveReply(socket, channels[i].reply);
+    }
-    // ### error
+}
-void QHttpNetworkConnectionPrivate::_q_bytesWritten(qint64 bytes)
+{
-    Q_UNUSED(bytes);
-    Q_Q(QHttpNetworkConnection);
-    QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(q->sender());
-    if (!socket)
-        return; // ### error
-    if (isSocketWriting(socket))
-        sendRequest(socket);
-    // otherwise we do nothing
+}
-void QHttpNetworkConnectionPrivate::_q_disconnected()
+{
-    Q_Q(QHttpNetworkConnection);
-    QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(q->sender());
-    if (!socket)
-        return; // ### error
-    // read the available data before closing
-    int i = indexOf(socket);
-    if (isSocketWaiting(socket) || isSocketReading(socket)) {
-        channels[i].state = ReadingState;
-        if (channels[i].reply)
-            receiveReply(socket, channels[i].reply);
+    }
-    channels[i].state = IdleState;
+}
 void QHttpNetworkConnectionPrivate::_q_startNextRequest()
+{
+    // send the current request again
+    if (channels[0].resendCurrent || channels[1].resendCurrent) {
+        int i = channels[0].resendCurrent ? 0:1;
+        QAbstractSocket *socket = channels[i].socket;
+        channels[i].resendCurrent = false;
+        channels[i].state = IdleState;
+        if (channels[i].reply)
+            sendRequest(socket);
+    //resend the necessary ones.
+    for (int i = 0; i < channelCount; ++i) {
+        if (channels[i].resendCurrent) {
+            channels[i].resendCurrent = false;
+            channels[i].state = QHttpNetworkConnectionChannel::IdleState;
+            if (channels[i].reply)
+                channels[i].sendRequest();
+        }
+    }
+    QAbstractSocket *socket = 0;
+    for (int i = 0; i < channelCount; ++i) {
+        QAbstractSocket *chSocket = channels[i].socket;
+        // send the request using the idle socket
+        if (!channels[i].isSocketBusy()) {
+            socket = chSocket;
+            break;
+        }
+    }
+    // this socket is free,
+    if (socket)
+        dequeueAndSendRequest(socket);
+    // try to push more into all sockets
+    // ### FIXME we should move this to the beginning of the function
+    // as soon as QtWebkit is properly using the pipelining
+    // (e.g. not for XMLHttpRequest or the first page load)
+    // ### FIXME we should also divide the requests more even
+    // on the connected sockets
+    //tryToFillPipeline(socket);
+    // return fast if there is nothing to pipeline
+    if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
         return;
+    }
+    // send the request using the idle socket
+    QAbstractSocket *socket = channels[0].socket;
+    if (isSocketBusy(socket)) {
+        socket = (isSocketBusy(channels[1].socket) ? 0 :channels[1].socket);
+    }
+    if (!socket) {
+        return; // this will be called after finishing current request.
+    }
+    unqueueRequest(socket);
+}
+void QHttpNetworkConnectionPrivate::_q_restartPendingRequest()
+    for (int j = 0; j < channelCount; j++)
+        fillPipeline(channels[j].socket);
+}
+void QHttpNetworkConnectionPrivate::_q_restartAuthPendingRequests()
+{
     // send the request using the idle socket
     for (int i = 0 ; i < channelCount; ++i) {
+        QAbstractSocket *socket = channels[i].socket;
+        if (channels[i].state ==  Wait4AuthState) {
+            channels[i].state = IdleState;
+        if (channels[i].state ==  QHttpNetworkConnectionChannel::Wait4AuthState) {
+            channels[i].state = QHttpNetworkConnectionChannel::IdleState;
             if (channels[i].reply)
+                sendRequest(socket);
+        }
+    }
+}
+void QHttpNetworkConnectionPrivate::_q_connected()
+{
+    Q_Q(QHttpNetworkConnection);
+    QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(q->sender());
+    if (!socket)
+        return; // ### error
+    int i = indexOf(socket);
+    // ### FIXME: if the server closes the connection unexpectedly, we shouldn't send the same broken request again!
+    //channels[i].reconnectAttempts = 2;
+    if (!channels[i].pendingEncrypt) {
+        channels[i].state = IdleState;
+        if (channels[i].reply)
+            sendRequest(socket);
+        else
+            closeChannel(i);
+    }
+}
+void QHttpNetworkConnectionPrivate::_q_error(QAbstractSocket::SocketError socketError)
+{
+    Q_Q(QHttpNetworkConnection);
+    QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(q->sender());
+    if (!socket)
+        return;
+    bool send2Reply = false;
+    int i = indexOf(socket);
+    QNetworkReply::NetworkError errorCode = QNetworkReply::UnknownNetworkError;
+    switch (socketError) {
+    case QAbstractSocket::HostNotFoundError:
+        errorCode = QNetworkReply::HostNotFoundError;
+        break;
+    case QAbstractSocket::ConnectionRefusedError:
+        errorCode = QNetworkReply::ConnectionRefusedError;
+        break;
+    case QAbstractSocket::RemoteHostClosedError:
+        // try to reconnect/resend before sending an error.
+        // while "Reading" the _q_disconnected() will handle this.
+        if (channels[i].state != IdleState && channels[i].state != ReadingState) {
+            if (channels[i].reconnectAttempts-- > 0) {
+                resendCurrentRequest(socket);
+                return;
+            } else {
+                send2Reply = true;
+                errorCode = QNetworkReply::RemoteHostClosedError;
+            }
+        } else {
+            return;
+        }
+        break;
+    case QAbstractSocket::SocketTimeoutError:
+        // try to reconnect/resend before sending an error.
+        if (channels[i].state == WritingState &&  (channels[i].reconnectAttempts-- > 0)) {
+            resendCurrentRequest(socket);
+            return;
+        }
+        send2Reply = true;
+        errorCode = QNetworkReply::TimeoutError;
+        break;
+    case QAbstractSocket::ProxyAuthenticationRequiredError:
+        errorCode = QNetworkReply::ProxyAuthenticationRequiredError;
+        break;
+    case QAbstractSocket::SslHandshakeFailedError:
+        errorCode = QNetworkReply::SslHandshakeFailedError;
+        break;
+    default:
+        // all other errors are treated as NetworkError
+        errorCode = QNetworkReply::UnknownNetworkError;
+        break;
+    }
+    QPointer<QObject> that = q;
+    QString errorString = errorDetail(errorCode, socket);
+    if (send2Reply) {
+        if (channels[i].reply) {
+            channels[i].reply->d_func()->errorString = errorString;
+            // this error matters only to this reply
+            emit channels[i].reply->finishedWithError(errorCode, errorString);
+        }
+        // send the next request
+        QMetaObject::invokeMethod(that, "_q_startNextRequest", Qt::QueuedConnection);
+    } else {
+        // the failure affects all requests.
+        emit q->error(errorCode, errorString);
+    }
+    if (that) //signals make enter the event loop
+        closeChannel(i);
+}
+#ifndef QT_NO_NETWORKPROXY
+void QHttpNetworkConnectionPrivate::_q_proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator* auth)
+{
+    Q_Q(QHttpNetworkConnection);
+    emit q->proxyAuthenticationRequired(proxy, auth, q);
+}
+#endif
+void QHttpNetworkConnectionPrivate::_q_dataReadyReadNoBuffer()
+{
+    Q_Q(QHttpNetworkConnection);
+    // data emitted either readyRead()
+    // find out which channel it is for
+    QIODevice *sender = qobject_cast<QIODevice *>(q->sender());
+    // won't match anything if the qobject_cast above failed
+    for (int i = 0; i < channelCount; ++i) {
+        if (sender == channels[i].request.data()) {
+            sendRequest(channels[i].socket);
+            break;
+        }
+    }
+}
+void QHttpNetworkConnectionPrivate::_q_dataReadyReadBuffer()
+{
+    Q_Q(QHttpNetworkConnection);
+    QIODevice *sender = qobject_cast<QIODevice *>(q->sender());
+    HttpMessagePair *thePair = 0;
+    for (int i = 0; !thePair && i < lowPriorityQueue.size(); ++i)
+        if (lowPriorityQueue.at(i).first.data() == sender)
+            thePair = &lowPriorityQueue[i];
+    for (int i = 0; !thePair && i < highPriorityQueue.size(); ++i)
+        if (highPriorityQueue.at(i).first.data() == sender)
+            thePair = &highPriorityQueue[i];
+    if (thePair) {
+        bufferData(*thePair);
+        // are we finished buffering?
+        if (!thePair->second->d_func()->requestIsBuffering)
+            _q_startNextRequest();
+    }
+}
+void QHttpNetworkConnectionPrivate::bufferData(HttpMessagePair &messagePair)
+{
+    Q_Q(QHttpNetworkConnection);
+    QHttpNetworkRequest &request = messagePair.first;
+    QHttpNetworkReply *reply = messagePair.second;
+    Q_ASSERT(request.data());
+    if (!reply->d_func()->requestIsBuffering) { // first time
+        QObject::connect(request.data(), SIGNAL(readyRead()), q, SLOT(_q_dataReadyReadBuffer()));
+        QObject::connect(request.data(), SIGNAL(readChannelFinished()), q, SLOT(_q_dataReadyReadBuffer()));
+        reply->d_func()->requestIsBuffering = true;
+        reply->d_func()->requestDataBuffer.open(QIODevice::ReadWrite);
+    }
+    // always try to read at least one byte
+    // ### FIXME! use a QRingBuffer
+    qint64 bytesToRead = qMax<qint64>(1, request.data()->bytesAvailable());
+    QByteArray newData;
+    newData.resize(bytesToRead);
+    qint64 bytesActuallyRead = request.data()->read(newData.data(), bytesToRead);
+    if (bytesActuallyRead > 0) {
+        // we read something
+        newData.chop(bytesToRead - bytesActuallyRead);
+        reply->d_func()->requestDataBuffer.write(newData);
+    } else if (bytesActuallyRead == -1) { // last time
+        QObject::disconnect(request.data(), SIGNAL(readyRead()), q, SLOT(_q_dataReadyReadBuffer()));
+        QObject::disconnect(request.data(), SIGNAL(readChannelFinished()), q, SLOT(_q_dataReadyReadBuffer()));
+        request.setContentLength(reply->d_func()->requestDataBuffer.size());
+        reply->d_func()->requestDataBuffer.seek(0);
+        reply->d_func()->requestIsBuffering = false;
+    }
+}
+// QHttpNetworkConnection
+                channels[i].sendRequest();
+        }
+    }
+}
 QHttpNetworkConnection::QHttpNetworkConnection(const QString &hostName, quint16 port, bool encrypt, QObject *parent)
     : QObject(*(new QHttpNetworkConnectionPrivate(hostName, port, encrypt)), parent)
+{
+    Q_D(QHttpNetworkConnection);
+    d->init();
+}
+QHttpNetworkConnection::QHttpNetworkConnection(quint16 connectionCount, const QString &hostName, quint16 port, bool encrypt, QObject *parent)
+     : QObject(*(new QHttpNetworkConnectionPrivate(connectionCount, hostName, port, encrypt)), parent)
+{
     Q_D(QHttpNetworkConnection);
 …
 #endif
-// QHttpNetworkRequest
-QHttpNetworkRequest::QHttpNetworkRequest(const QUrl &url, Operation operation, Priority priority)
-    : d(new QHttpNetworkRequestPrivate(operation, priority, url))
+{
+}
-QHttpNetworkRequest::QHttpNetworkRequest(const QHttpNetworkRequest &other)
-    : QHttpNetworkHeader(other), d(other.d)
+{
+}
-QHttpNetworkRequest::~QHttpNetworkRequest()
+{
+}
-QUrl QHttpNetworkRequest::url() const
+{
-    return d->url;
+}
-void QHttpNetworkRequest::setUrl(const QUrl &url)
+{
-    d->url = url;
+}
-qint64 QHttpNetworkRequest::contentLength() const
+{
-    return d->contentLength();
+}
-void QHttpNetworkRequest::setContentLength(qint64 length)
+{
-    d->setContentLength(length);
+}
-QList<QPair<QByteArray, QByteArray> > QHttpNetworkRequest::header() const
+{
-    return d->fields;
+}
-QByteArray QHttpNetworkRequest::headerField(const QByteArray &name, const QByteArray &defaultValue) const
+{
-    return d->headerField(name, defaultValue);
+}
-void QHttpNetworkRequest::setHeaderField(const QByteArray &name, const QByteArray &data)
+{
-    d->setHeaderField(name, data);
+}
-QHttpNetworkRequest &QHttpNetworkRequest::operator=(const QHttpNetworkRequest &other)
+{
-    d = other.d;
-    return *this;
+}
-bool QHttpNetworkRequest::operator==(const QHttpNetworkRequest &other) const
+{
-    return d->operator==(*other.d);
+}
-QHttpNetworkRequest::Operation QHttpNetworkRequest::operation() const
+{
-    return d->operation;
+}
-void QHttpNetworkRequest::setOperation(Operation operation)
+{
-    d->operation = operation;
+}
-QHttpNetworkRequest::Priority QHttpNetworkRequest::priority() const
+{
-    return d->priority;
+}
-void QHttpNetworkRequest::setPriority(Priority priority)
+{
-    d->priority = priority;
+}
-QIODevice *QHttpNetworkRequest::data() const
+{
-    return d->data;
+}
-void QHttpNetworkRequest::setData(QIODevice *data)
+{
-    d->data = data;
+}
-int QHttpNetworkRequest::majorVersion() const
+{
-    return 1;
+}
-int QHttpNetworkRequest::minorVersion() const
+{
-    return 1;
+}
-// QHttpNetworkReply
-QHttpNetworkReply::QHttpNetworkReply(const QUrl &url, QObject *parent)
-    : QObject(*new QHttpNetworkReplyPrivate(url), parent)
+{
+}
-QHttpNetworkReply::~QHttpNetworkReply()
+{
-    Q_D(QHttpNetworkReply);
-    if (d->connection) {
-        d->connection->d_func()->removeReply(this);
+    }
+}
-QUrl QHttpNetworkReply::url() const
+{
-    return d_func()->url;
+}
-void QHttpNetworkReply::setUrl(const QUrl &url)
+{
-    Q_D(QHttpNetworkReply);
-    d->url = url;
+}
-qint64 QHttpNetworkReply::contentLength() const
+{
-    return d_func()->contentLength();
+}
-void QHttpNetworkReply::setContentLength(qint64 length)
+{
-    Q_D(QHttpNetworkReply);
-    d->setContentLength(length);
+}
-QList<QPair<QByteArray, QByteArray> > QHttpNetworkReply::header() const
+{
-    return d_func()->fields;
+}
-QByteArray QHttpNetworkReply::headerField(const QByteArray &name, const QByteArray &defaultValue) const
+{
-    return d_func()->headerField(name, defaultValue);
+}
-void QHttpNetworkReply::setHeaderField(const QByteArray &name, const QByteArray &data)
+{
-    Q_D(QHttpNetworkReply);
-    d->setHeaderField(name, data);
+}
-void QHttpNetworkReply::parseHeader(const QByteArray &header)
+{
-    Q_D(QHttpNetworkReply);
-    d->parseHeader(header);
+}
-QHttpNetworkRequest QHttpNetworkReply::request() const
+{
-    return d_func()->request;
+}
-void QHttpNetworkReply::setRequest(const QHttpNetworkRequest &request)
+{
-    Q_D(QHttpNetworkReply);
-    d->request = request;
+}
-int QHttpNetworkReply::statusCode() const
+{
-    return d_func()->statusCode;
+}
-void QHttpNetworkReply::setStatusCode(int code)
+{
-    Q_D(QHttpNetworkReply);
-    d->statusCode = code;
+}
-QString QHttpNetworkReply::errorString() const
+{
-    return d_func()->errorString;
+}
-QString QHttpNetworkReply::reasonPhrase() const
+{
-    return d_func()->reasonPhrase;
+}
-void QHttpNetworkReply::setErrorString(const QString &error)
+{
-    Q_D(QHttpNetworkReply);
-    d->errorString = error;
+}
-int QHttpNetworkReply::majorVersion() const
+{
-    return d_func()->majorVersion;
+}
-int QHttpNetworkReply::minorVersion() const
+{
-    return d_func()->minorVersion;
+}
-qint64 QHttpNetworkReply::bytesAvailable() const
+{
-    Q_D(const QHttpNetworkReply);
-    if (d->connection)
-        return d->connection->d_func()->bytesAvailable(*this);
-    else
-        return -1;
+}
-QByteArray QHttpNetworkReply::read(qint64 maxSize)
+{
-    Q_D(QHttpNetworkReply);
-    QByteArray data;
-    if (d->connection)
-        d->connection->d_func()->read(*this, data, maxSize, false);
-    return data;
+}
-bool QHttpNetworkReply::isFinished() const
+{
-    return d_func()->state == QHttpNetworkReplyPrivate::AllDoneState;
+}
 // SSL support below
 #ifndef QT_NO_OPENSSL
-void QHttpNetworkConnectionPrivate::_q_encrypted()
+{
-    Q_Q(QHttpNetworkConnection);
-    QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(q->sender());
-    if (!socket)
-        return; // ### error
-    channels[indexOf(socket)].state = IdleState;
-    sendRequest(socket);
+}
-void QHttpNetworkConnectionPrivate::_q_sslErrors(const QList<QSslError> &errors)
+{
-    Q_Q(QHttpNetworkConnection);
-    QAbstractSocket *socket = qobject_cast<QAbstractSocket*>(q->sender());
-    if (!socket)
-        return;
-    //QNetworkReply::NetworkError errorCode = QNetworkReply::ProtocolFailure;
-    emit q->sslErrors(errors);
+}
 QSslConfiguration QHttpNetworkConnectionPrivate::sslConfiguration(const QHttpNetworkReply &reply) const
+{
+    if (!encrypt)
+        return QSslConfiguration();
     for (int i = 0; i < channelCount; ++i)
         if (channels[i].reply == &reply)
 …
+{
     Q_D(QHttpNetworkConnection);
+    if (!d->encrypt)
+        return;
     // set the config on all channels
     for (int i = 0; i < d->channelCount; ++i)
 …
+{
     Q_D(QHttpNetworkConnection);
+    if (!d->encrypt)
+        return;
     if (channel == -1) { // ignore for all channels
         for (int i = 0; i < d->channelCount; ++i) {
             static_cast<QSslSocket *>(d->channels[i].socket)->ignoreSslErrors();
             d->channels[i].ignoreSSLErrors = true;
+            d->channels[i].ignoreAllSslErrors = true;
+        }
     } else {
         static_cast<QSslSocket *>(d->channels[channel].socket)->ignoreSslErrors();
+        d->channels[channel].ignoreSSLErrors = true;
+    }
+}
+QSslConfiguration QHttpNetworkReply::sslConfiguration() const
+{
+    Q_D(const QHttpNetworkReply);
+    if (d->connection)
+        return d->connection->d_func()->sslConfiguration(*this);
+    return QSslConfiguration();
+}
+void QHttpNetworkReply::setSslConfiguration(const QSslConfiguration &config)
+{
+    Q_D(QHttpNetworkReply);
+    if (d->connection)
+        d->connection->setSslConfiguration(config);
+}
+void QHttpNetworkReply::ignoreSslErrors()
+{
+    Q_D(QHttpNetworkReply);
+    if (d->connection)
+        d->connection->ignoreSslErrors();
+}
+        d->channels[channel].ignoreAllSslErrors = true;
+    }
+}
+void QHttpNetworkConnection::ignoreSslErrors(const QList<QSslError> &errors, int channel)
+{
+    Q_D(QHttpNetworkConnection);
+    if (!d->encrypt)
+        return;
+    if (channel == -1) { // ignore for all channels
+        for (int i = 0; i < d->channelCount; ++i) {
+            static_cast<QSslSocket *>(d->channels[i].socket)->ignoreSslErrors(errors);
+            d->channels[i].ignoreSslErrorsList = errors;
+        }
+    } else {
+        static_cast<QSslSocket *>(d->channels[channel].socket)->ignoreSslErrors(errors);
+        d->channels[channel].ignoreSslErrorsList = errors;
+    }
+}
 #endif //QT_NO_OPENSSL
+#ifndef QT_NO_NETWORKPROXY
+// only called from QHttpNetworkConnectionChannel::_q_proxyAuthenticationRequired, not
+// from QHttpNetworkConnectionChannel::handleAuthenticationChallenge
+// e.g. it is for SOCKS proxies which require authentication.
+void QHttpNetworkConnectionPrivate::emitProxyAuthenticationRequired(const QHttpNetworkConnectionChannel *chan, const QNetworkProxy &proxy, QAuthenticator* auth)
+{
+    Q_Q(QHttpNetworkConnection);
+    emit q->proxyAuthenticationRequired(proxy, auth, q);
+    int i = indexOf(chan->socket);
+    copyCredentials(i, auth, true);
+}
+#endif
 QT_END_NAMESPACE

trunk/src/network/access/qhttpnetworkconnection_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include <QtNetwork/qnetworkreply.h>
 #include <QtNetwork/qabstractsocket.h>
+#include <private/qobject_p.h>
+#include <qauthenticator.h>
+#include <qnetworkproxy.h>
+#include <qbuffer.h>
+#include <private/qhttpnetworkheader_p.h>
+#include <private/qhttpnetworkrequest_p.h>
+#include <private/qhttpnetworkreply_p.h>
+#include <private/qhttpnetworkconnectionchannel_p.h>
 #ifndef QT_NO_HTTP
 …
 class QHttpNetworkRequest;
 class QHttpNetworkReply;
+class QByteArray;
 class QHttpNetworkConnectionPrivate;
 …
     QHttpNetworkConnection(const QString &hostName, quint16 port = 80, bool encrypt = false, QObject *parent = 0);
+    QHttpNetworkConnection(quint16 channelCount, const QString &hostName, quint16 port = 80, bool encrypt = false, QObject *parent = 0);
     ~QHttpNetworkConnection();
 …
     void setSslConfiguration(const QSslConfiguration &config);
     void ignoreSslErrors(int channel = -1);
+    void ignoreSslErrors(const QList<QSslError> &errors, int channel = -1);
 Q_SIGNALS:
 …
     Q_DISABLE_COPY(QHttpNetworkConnection)
     friend class QHttpNetworkReply;
+    Q_PRIVATE_SLOT(d_func(), void _q_bytesWritten(qint64))
+    Q_PRIVATE_SLOT(d_func(), void _q_readyRead())
+    Q_PRIVATE_SLOT(d_func(), void _q_disconnected())
+    friend class QHttpNetworkConnectionChannel;
     Q_PRIVATE_SLOT(d_func(), void _q_startNextRequest())
+    Q_PRIVATE_SLOT(d_func(), void _q_restartPendingRequest())
+    Q_PRIVATE_SLOT(d_func(), void _q_connected())
+    Q_PRIVATE_SLOT(d_func(), void _q_error(QAbstractSocket::SocketError))
+    Q_PRIVATE_SLOT(d_func(), void _q_restartAuthPendingRequests())
+};
+// private classes
+typedef QPair<QHttpNetworkRequest, QHttpNetworkReply*> HttpMessagePair;
+class QHttpNetworkConnectionPrivate : public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QHttpNetworkConnection)
+public:
+    static const int defaultChannelCount;
+    static const int defaultPipelineLength;
+    QHttpNetworkConnectionPrivate(const QString &hostName, quint16 port, bool encrypt);
+    QHttpNetworkConnectionPrivate(quint16 channelCount, const QString &hostName, quint16 port, bool encrypt);
+    ~QHttpNetworkConnectionPrivate();
+    void init();
+    enum { ChunkSize = 4096 };
+    int indexOf(QAbstractSocket *socket) const;
+    QHttpNetworkReply *queueRequest(const QHttpNetworkRequest &request);
+    void requeueRequest(const HttpMessagePair &pair); // e.g. after pipeline broke
+    void dequeueAndSendRequest(QAbstractSocket *socket);
+    void prepareRequest(HttpMessagePair &request);
+    void fillPipeline(QAbstractSocket *socket);
+    bool fillPipeline(QList<HttpMessagePair> &queue, QHttpNetworkConnectionChannel &channel);
+    void copyCredentials(int fromChannel, QAuthenticator *auth, bool isProxy);
+    // private slots
+    void _q_startNextRequest(); // send the next request from the queue
+    void _q_restartAuthPendingRequests(); // send the currently blocked request
+    void createAuthorization(QAbstractSocket *socket, QHttpNetworkRequest &request);
+    QString errorDetail(QNetworkReply::NetworkError errorCode, QAbstractSocket *socket);
+#ifndef QT_NO_COMPRESS
+    bool expand(QAbstractSocket *socket, QHttpNetworkReply *reply, bool dataComplete);
+#endif
+    void removeReply(QHttpNetworkReply *reply);
+    QString hostName;
+    quint16 port;
+    bool encrypt;
+    const int channelCount;
+    QHttpNetworkConnectionChannel *channels; // parallel connections to the server
+    bool pendingAuthSignal; // there is an incomplete authentication signal
+    bool pendingProxyAuthSignal; // there is an incomplete proxy authentication signal
+    qint64 uncompressedBytesAvailable(const QHttpNetworkReply &reply) const;
+    qint64 uncompressedBytesAvailableNextBlock(const QHttpNetworkReply &reply) const;
+    void emitReplyError(QAbstractSocket *socket, QHttpNetworkReply *reply, QNetworkReply::NetworkError errorCode);
+    bool handleAuthenticateChallenge(QAbstractSocket *socket, QHttpNetworkReply *reply, bool isProxy, bool &resend);
+#ifndef QT_NO_OPENSSL
+    QSslConfiguration sslConfiguration(const QHttpNetworkReply &reply) const;
+#endif
 #ifndef QT_NO_NETWORKPROXY
     Q_PRIVATE_SLOT(d_func(), void _q_proxyAuthenticationRequired(const QNetworkProxy&, QAuthenticator*))
+#endif
+    Q_PRIVATE_SLOT(d_func(), void _q_dataReadyReadBuffer())
+    Q_PRIVATE_SLOT(d_func(), void _q_dataReadyReadNoBuffer())
+#ifndef QT_NO_OPENSSL
     Q_PRIVATE_SLOT(d_func(), void _q_encrypted())
+    Q_PRIVATE_SLOT(d_func(), void _q_sslErrors(const QList<QSslError>&))
+#endif
+    QNetworkProxy networkProxy;
+    void emitProxyAuthenticationRequired(const QHttpNetworkConnectionChannel *chan, const QNetworkProxy &proxy, QAuthenticator* auth);
+#endif
+    //The request queues
+    QList<HttpMessagePair> highPriorityQueue;
+    QList<HttpMessagePair> lowPriorityQueue;
+    friend class QHttpNetworkConnectionChannel;
 };
+class Q_AUTOTEST_EXPORT QHttpNetworkHeader
+{
+public:
+    virtual ~QHttpNetworkHeader() {};
+    virtual QUrl url() const = 0;
+    virtual void setUrl(const QUrl &url) = 0;
+    virtual int majorVersion() const = 0;
+    virtual int minorVersion() const = 0;
+    virtual qint64 contentLength() const = 0;
+    virtual void setContentLength(qint64 length) = 0;
+    virtual QList<QPair<QByteArray, QByteArray> > header() const = 0;
+    virtual QByteArray headerField(const QByteArray &name, const QByteArray &defaultValue = QByteArray()) const = 0;
+    virtual void setHeaderField(const QByteArray &name, const QByteArray &data) = 0;
+};
+class QHttpNetworkRequestPrivate;
+class Q_AUTOTEST_EXPORT QHttpNetworkRequest: public QHttpNetworkHeader
+{
+public:
+    enum Operation {
+        Options,
+        Get,
+        Head,
+        Post,
+        Put,
+        Delete,
+        Trace,
+        Connect
+    };
+    enum Priority {
+        HighPriority,
+        NormalPriority,
+        LowPriority
+    };
+    QHttpNetworkRequest(const QUrl &url = QUrl(), Operation operation = Get, Priority priority = NormalPriority);
+    QHttpNetworkRequest(const QHttpNetworkRequest &other);
+    virtual ~QHttpNetworkRequest();
+    QHttpNetworkRequest &operator=(const QHttpNetworkRequest &other);
+    bool operator==(const QHttpNetworkRequest &other) const;
+    QUrl url() const;
+    void setUrl(const QUrl &url);
+    int majorVersion() const;
+    int minorVersion() const;
+    qint64 contentLength() const;
+    void setContentLength(qint64 length);
+    QList<QPair<QByteArray, QByteArray> > header() const;
+    QByteArray headerField(const QByteArray &name, const QByteArray &defaultValue = QByteArray()) const;
+    void setHeaderField(const QByteArray &name, const QByteArray &data);
+    Operation operation() const;
+    void setOperation(Operation operation);
+    Priority priority() const;
+    void setPriority(Priority priority);
+    QIODevice *data() const;
+    void setData(QIODevice *data);
+private:
+    QSharedDataPointer<QHttpNetworkRequestPrivate> d;
+    friend class QHttpNetworkRequestPrivate;
+    friend class QHttpNetworkConnectionPrivate;
+};
+class QHttpNetworkReplyPrivate;
+class Q_AUTOTEST_EXPORT QHttpNetworkReply : public QObject, public QHttpNetworkHeader
+{
+    Q_OBJECT
+public:
+    explicit QHttpNetworkReply(const QUrl &url = QUrl(), QObject *parent = 0);
+    virtual ~QHttpNetworkReply();
+    QUrl url() const;
+    void setUrl(const QUrl &url);
+    int majorVersion() const;
+    int minorVersion() const;
+    qint64 contentLength() const;
+    void setContentLength(qint64 length);
+    QList<QPair<QByteArray, QByteArray> > header() const;
+    QByteArray headerField(const QByteArray &name, const QByteArray &defaultValue = QByteArray()) const;
+    void setHeaderField(const QByteArray &name, const QByteArray &data);
+    void parseHeader(const QByteArray &header); // mainly for testing
+    QHttpNetworkRequest request() const;
+    void setRequest(const QHttpNetworkRequest &request);
+    int statusCode() const;
+    void setStatusCode(int code);
+    QString errorString() const;
+    void setErrorString(const QString &error);
+    QString reasonPhrase() const;
+    qint64 bytesAvailable() const;
+    QByteArray read(qint64 maxSize = -1);
+    bool isFinished() const;
+#ifndef QT_NO_OPENSSL
+    QSslConfiguration sslConfiguration() const;
+    void setSslConfiguration(const QSslConfiguration &config);
+    void ignoreSslErrors();
+Q_SIGNALS:
+    void sslErrors(const QList<QSslError> &errors);
+#endif
+Q_SIGNALS:
+    void readyRead();
+    void finished();
+    void finishedWithError(QNetworkReply::NetworkError errorCode, const QString &detail = QString());
+    void headerChanged();
+    void dataReadProgress(int done, int total);
+    void dataSendProgress(int done, int total);
+private:
+    Q_DECLARE_PRIVATE(QHttpNetworkReply)
+    friend class QHttpNetworkConnection;
+    friend class QHttpNetworkConnectionPrivate;
+};
 QT_END_NAMESPACE
-Q_DECLARE_METATYPE(QHttpNetworkRequest)
-//Q_DECLARE_METATYPE(QHttpNetworkReply)
 #endif // QT_NO_HTTP

trunk/src/network/access/qnetworkaccessbackend.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "qabstractnetworkcache.h"
+#include "private/qnoncontiguousbytedevice_p.h"
 QT_BEGIN_NAMESPACE
 …
     if (mode == QNetworkRequest::AlwaysCache
         && (op == QNetworkAccessManager::GetOperation
+        || op == QNetworkAccessManager::HeadOperation))
+        return new QNetworkAccessCacheBackend;
+        || op == QNetworkAccessManager::HeadOperation)) {
+        QNetworkAccessBackend *backend = new QNetworkAccessCacheBackend;
+        backend->manager = this;
+        return backend;
+    }
     if (!factoryDataShutdown) {
 …
+}
+QNonContiguousByteDevice* QNetworkAccessBackend::createUploadByteDevice()
+{
+    QNonContiguousByteDevice* device = 0;
+    if (reply->outgoingDataBuffer)
+        device = QNonContiguousByteDeviceFactory::create(reply->outgoingDataBuffer);
+    else
+        device = QNonContiguousByteDeviceFactory::create(reply->outgoingData);
+    bool bufferDisallowed =
+            reply->request.attribute(QNetworkRequest::DoNotBufferUploadDataAttribute,
+                          QVariant(false)) == QVariant(true);
+    if (bufferDisallowed)
+        device->disableReset();
+    // make sure we delete this later
+    device->setParent(this);
+    connect(device, SIGNAL(readProgress(qint64,qint64)), this, SLOT(emitReplyUploadProgress(qint64,qint64)));
+    return device;
+}
+// need to have this function since the reply is a private member variable
+// and the special backends need to access this.
+void QNetworkAccessBackend::emitReplyUploadProgress(qint64 bytesSent, qint64 bytesTotal)
+{
+    if (reply->isFinished())
+        return;
+    reply->emitUploadProgress(bytesSent, bytesTotal);
+}
 QNetworkAccessBackend::QNetworkAccessBackend()
+    : manager(0)
+    , reply(0)
+{
+}
 …
+}
-void QNetworkAccessBackend::upstreamReadyRead()
+{
-    // do nothing
+}
 void QNetworkAccessBackend::downstreamReadyWrite()
+{
 …
 void QNetworkAccessBackend::ignoreSslErrors()
+{
+    // do nothing
+}
+void QNetworkAccessBackend::ignoreSslErrors(const QList<QSslError> &errors)
+{
+    Q_UNUSED(errors);
     // do nothing
+}
 …
 QAbstractNetworkCache *QNetworkAccessBackend::networkCache() const
+{
+    return reply->networkCache; // should be the same as manager->networkCache
+    if (!manager)
+        return 0;
+    return manager->networkCache;
+}
 …
+}
-qint64 QNetworkAccessBackend::upstreamBytesAvailable() const
+{
-    return reply->writeBuffer.size();
+}
-void QNetworkAccessBackend::upstreamBytesConsumed(qint64 count)
+{
-    // remove count bytes from the write buffer
-    reply->consume(count);
+}
-QByteArray QNetworkAccessBackend::readUpstream()
+{
-    // ### this is expensive. Consider making QRingBuffer::peekAll keep the buffer it returns
-    return reply->writeBuffer.peek(upstreamBytesAvailable());
+}
 qint64 QNetworkAccessBackend::nextDownstreamBlockSize() const
+{
 …
+}
+qint64 QNetworkAccessBackend::downstreamBytesToConsume() const
+{
+    return reply->writeBuffer.size();
+}
+void QNetworkAccessBackend::writeDownstreamData(const QByteArray &data)
+{
+    reply->feed(data);
+void QNetworkAccessBackend::writeDownstreamData(QByteDataBuffer &list)
+{
+    reply->appendDownstreamData(list);
+}
 void QNetworkAccessBackend::writeDownstreamData(QIODevice *data)
+{
     reply->feed(data);
+    reply->appendDownstreamData(data);
+}

trunk/src/network/access/qnetworkaccessbackend_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 class QAbstractNetworkCache;
 class QNetworkCacheMetaData;
+class QNetworkAccessBackendUploadIODevice;
+class QNonContiguousByteDevice;
 // Should support direct file upload from disk or download to disk.
 …
     //
     // - Upstream:
+    //   Upstream is data that is being written into this connection,
+    //   from the user. Upstream operates in a "pull" mechanism: the
+    //   connection will be notified that there is more data available
+    //   by a call to "upstreamReadyRead". The number of bytes
+    //   available is given by upstreamBytesAvailable(). A call to
+    //   readUpstream() always yields the entire upstream buffer. When
+    //   the connection has processed a certain amount of bytes from
+    //   that buffer, it should call upstreamBytesConsumed().
+    //   The upstream uses a QNonContiguousByteDevice provided
+    //   by the backend. This device emits the usual readyRead()
+    //   signal when the backend has data available for the connection
+    //   to write. The different backends can listen on this signal
+    //   and then pull upload data from the QNonContiguousByteDevice and
+    //   deal with it.
+    //
     //
     // - Downstream:
 …
     virtual void open() = 0;
     virtual void closeDownstreamChannel() = 0;
-    virtual void closeUpstreamChannel() = 0;
     virtual bool waitForDownstreamReadyRead(int msecs) = 0;
-    virtual bool waitForUpstreamBytesWritten(int msecs) = 0;
     // slot-like:
-    virtual void upstreamReadyRead();
     virtual void downstreamReadyWrite();
     virtual void copyFinished(QIODevice *);
     virtual void ignoreSslErrors();
+    virtual void ignoreSslErrors(const QList<QSslError> &errors);
     virtual void fetchSslConfiguration(QSslConfiguration &configuration) const;
 …
     void setAttribute(QNetworkRequest::Attribute code, const QVariant &value);
+    // return true if the QNonContiguousByteDevice of the upload
+    // data needs to support reset(). Currently needed for HTTP.
+    // This will possibly enable buffering of the upload data.
+    virtual bool needsResetableUploadData() { return false; }
 protected:
+    // these functions control the upstream mechanism
+    // that is, data coming into the backend and out via the connection
+    qint64 upstreamBytesAvailable() const;
+    void upstreamBytesConsumed(qint64 count);
+    QByteArray readUpstream();
+    // Create the device used for reading the upload data
+    QNonContiguousByteDevice* createUploadByteDevice();
     // these functions control the downstream mechanism
     // that is, data that has come via the connection and is going out the backend
     qint64 nextDownstreamBlockSize() const;
+    qint64 downstreamBytesToConsume() const;
+    void writeDownstreamData(const QByteArray &data);
+    void writeDownstreamData(QByteDataBuffer &list);
+public slots:
+    // for task 251801, needs to be a slot to be called asynchronously
     void writeDownstreamData(QIODevice *data);
 …
     void redirectionRequested(const QUrl &destination);
     void sslErrors(const QList<QSslError> &errors);
+    void emitReplyUploadProgress(qint64 bytesSent, qint64 bytesTotal);
 private:
     friend class QNetworkAccessManager;
     friend class QNetworkAccessManagerPrivate;
+    friend class QNetworkAccessBackendUploadIODevice;
     QNetworkAccessManagerPrivate *manager;
     QNetworkReplyImplPrivate *reply;

trunk/src/network/access/qnetworkaccesscache.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/network/access/qnetworkaccesscache_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 class QUrl;
+// this class is not about caching files but about
+// caching objects used by QNetworkAccessManager, e.g. existing TCP connections
+// or credentials.
 class QNetworkAccessCache: public QObject
+{

trunk/src/network/access/qnetworkaccesscachebackend.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 QNetworkAccessCacheBackend::QNetworkAccessCacheBackend()
     : QNetworkAccessBackend()
+    , device(0)
+{
+}
 …
     setAttribute(QNetworkRequest::HttpReasonPhraseAttribute, attributes.value(QNetworkRequest::HttpReasonPhraseAttribute));
     setAttribute(QNetworkRequest::SourceIsFromCacheAttribute, true);
+    // set the raw headers
+    QNetworkCacheMetaData::RawHeaderList rawHeaders = item.rawHeaders();
+    QNetworkCacheMetaData::RawHeaderList::ConstIterator it = rawHeaders.constBegin(),
+                                                       end = rawHeaders.constEnd();
+    for ( ; it != end; ++it)
+        setRawHeader(it->first, it->second);
+    // handle a possible redirect
+    QVariant redirectionTarget = attributes.value(QNetworkRequest::RedirectionTargetAttribute);
+    if (redirectionTarget.isValid()) {
+        setAttribute(QNetworkRequest::RedirectionTargetAttribute, redirectionTarget);
+        redirectionRequested(redirectionTarget.toUrl());
+    }
     // signal we're open

trunk/src/network/access/qnetworkaccesscachebackend_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/network/access/qnetworkaccessdatabackend.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
             emit metaDataChanged();
+            writeDownstreamData(payload);
+            QByteDataBuffer list;
+            list.append(payload);
+            payload.clear(); // important because of implicit sharing!
+            writeDownstreamData(list);
             finished();
             return;

trunk/src/network/access/qnetworkaccessdatabackend_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/network/access/qnetworkaccessdebugpipebackend.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "qnetworkaccessdebugpipebackend_p.h"
 #include "QtCore/qdatastream.h"
+#include <QCoreApplication>
+#include "private/qnoncontiguousbytedevice_p.h"
 QT_BEGIN_NAMESPACE
 …
     ReadBufferSize = 16384,
     WriteBufferSize = ReadBufferSize
-};
-struct QNetworkAccessDebugPipeBackend::DataPacket
+{
-    QList<QPair<QByteArray, QByteArray> > headers;
-    QByteArray data;
 };
 …
 QNetworkAccessDebugPipeBackend::QNetworkAccessDebugPipeBackend()
+    : incomingPacketSize(0), bareProtocol(false)
+    : bareProtocol(false), hasUploadFinished(false), hasDownloadFinished(false),
+    hasEverythingFinished(false), bytesDownloaded(0), bytesUploaded(0)
+{
+}
 …
 QNetworkAccessDebugPipeBackend::~QNetworkAccessDebugPipeBackend()
+{
+    // this is signals disconnect, not network!
     socket.disconnect(this);    // we're not interested in the signals at this point
+}
 …
     socket.connectToHost(url().host(), url().port(12345));
     socket.setReadBufferSize(ReadBufferSize);
+    // socket ready read -> we can push from socket to downstream
     connect(&socket, SIGNAL(readyRead()), SLOT(socketReadyRead()));
-    connect(&socket, SIGNAL(bytesWritten(qint64)), SLOT(socketBytesWritten(qint64)));
     connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(socketError()));
     connect(&socket, SIGNAL(disconnected()), SLOT(socketDisconnected()));
+    connect(&socket, SIGNAL(connected()), SLOT(socketConnected()));
+    // socket bytes written -> we can push more from upstream to socket
+    connect(&socket, SIGNAL(bytesWritten(qint64)), SLOT(socketBytesWritten(qint64)));
     bareProtocol = url().queryItemValue(QLatin1String("bare")) == QLatin1String("1");
+    if (!bareProtocol) {
+        // "Handshake":
+        // send outgoing metadata and the URL being requested
+        DataPacket packet;
+        //packet.metaData = request().metaData();
+        packet.data = url().toEncoded();
+        send(packet);
+    }
+    if (operation() == QNetworkAccessManager::PutOperation) {
+        uploadByteDevice = createUploadByteDevice();
+        QObject::connect(uploadByteDevice, SIGNAL(readyRead()), this, SLOT(uploadReadyReadSlot()));
+        QMetaObject::invokeMethod(this, "uploadReadyReadSlot", Qt::QueuedConnection);
+    }
+}
+void QNetworkAccessDebugPipeBackend::socketReadyRead()
+{
+    pushFromSocketToDownstream();
+}
+void QNetworkAccessDebugPipeBackend::downstreamReadyWrite()
+{
+    pushFromSocketToDownstream();
+}
+void QNetworkAccessDebugPipeBackend::socketBytesWritten(qint64)
+{
+    pushFromUpstreamToSocket();
+}
+void QNetworkAccessDebugPipeBackend::uploadReadyReadSlot()
+{
+    pushFromUpstreamToSocket();
+}
+void QNetworkAccessDebugPipeBackend::pushFromSocketToDownstream()
+{
+    QByteArray buffer;
+    if (socket.state() == QAbstractSocket::ConnectingState) {
+        return;
+    }
+    forever {
+        if (hasDownloadFinished)
+            return;
+        buffer.resize(ReadBufferSize);
+        qint64 haveRead = socket.read(buffer.data(), ReadBufferSize);
+        if (haveRead == -1) {
+            hasDownloadFinished = true;
+            // this ensures a good last downloadProgress is emitted
+            setHeader(QNetworkRequest::ContentLengthHeader, QVariant());
+            possiblyFinish();
+            break;
+        } else if (haveRead == 0) {
+            break;
+        } else {
+            // have read something
+            buffer.resize(haveRead);
+            bytesDownloaded += haveRead;
+            QByteDataBuffer list;
+            list.append(buffer);
+            buffer.clear(); // important because of implicit sharing!
+            writeDownstreamData(list);
+        }
+    }
+}
+void QNetworkAccessDebugPipeBackend::pushFromUpstreamToSocket()
+{
+    // FIXME
+    if (operation() == QNetworkAccessManager::PutOperation) {
+        if (hasUploadFinished)
+            return;
+        forever {
+            if (socket.bytesToWrite() >= WriteBufferSize)
+                return;
+            qint64 haveRead;
+            const char *readPointer = uploadByteDevice->readPointer(WriteBufferSize, haveRead);
+            if (haveRead == -1) {
+                // EOF
+                hasUploadFinished = true;
+                emitReplyUploadProgress(bytesUploaded, bytesUploaded);
+                possiblyFinish();
+                break;
+            } else if (haveRead == 0 || readPointer == 0) {
+                // nothing to read right now, we will be called again later
+                break;
+            } else {
+                qint64 haveWritten;
+                haveWritten = socket.write(readPointer, haveRead);
+                if (haveWritten < 0) {
+                    // write error!
+                    QString msg = QCoreApplication::translate("QNetworkAccessDebugPipeBackend", "Write error writing to %1: %2")
+                                  .arg(url().toString(), socket.errorString());
+                    error(QNetworkReply::ProtocolFailure, msg);
+                    finished();
+                    return;
+                } else {
+                    uploadByteDevice->advanceReadPointer(haveWritten);
+                    bytesUploaded += haveWritten;
+                    emitReplyUploadProgress(bytesUploaded, -1);
+                }
+                //QCoreApplication::processEvents();
+            }
+        }
+    }
+}
+void QNetworkAccessDebugPipeBackend::possiblyFinish()
+{
+    if (hasEverythingFinished)
+        return;
+    hasEverythingFinished = true;
+    if ((operation() == QNetworkAccessManager::GetOperation) && hasDownloadFinished) {
+        socket.close();
+        finished();
+    } else if ((operation() == QNetworkAccessManager::PutOperation) && hasUploadFinished) {
+        socket.close();
+        finished();
+    }
+}
 void QNetworkAccessDebugPipeBackend::closeDownstreamChannel()
+{
+    if (operation() == QNetworkAccessManager::GetOperation)
+        socket.disconnectFromHost();
+}
+void QNetworkAccessDebugPipeBackend::closeUpstreamChannel()
+{
+    if (operation() == QNetworkAccessManager::PutOperation)
+        socket.disconnectFromHost();
+    else if (operation() == QNetworkAccessManager::PostOperation) {
+        send(DataPacket());
+    }
+}
+bool QNetworkAccessDebugPipeBackend::waitForDownstreamReadyRead(int ms)
+{
+    readyReadEmitted = false;
+    if (socket.bytesAvailable()) {
+        socketReadyRead();
+        if (readyReadEmitted)
+            return true;
+    }
+    socket.waitForReadyRead(ms);
+    return readyReadEmitted;
+}
+bool QNetworkAccessDebugPipeBackend::waitForUpstreamBytesWritten(int ms)
+{
+    bytesWrittenEmitted = false;
+    upstreamReadyRead();
+    if (bytesWrittenEmitted)
+        return true;
+    socket.waitForBytesWritten(ms);
+    return bytesWrittenEmitted;
+}
+void QNetworkAccessDebugPipeBackend::upstreamReadyRead()
+{
+    int maxWrite = WriteBufferSize - socket.bytesToWrite();
+    if (maxWrite <= 0)
+        return;                 // can't write yet, wait for the socket to write
+    if (bareProtocol) {
+        QByteArray data = readUpstream();
+        if (data.isEmpty())
+            return;
+        socket.write(data);
+        upstreamBytesConsumed(data.size());
+        bytesWrittenEmitted = true;
+        return;
+    }
+    DataPacket packet;
+    packet.data = readUpstream();
+    if (packet.data.isEmpty())
+        return;                 // we'll be called again when there's data
+    if (packet.data.size() > maxWrite)
+        packet.data.truncate(maxWrite);
+    if (!send(packet)) {
+        QString msg = QObject::tr("Write error writing to %1: %2")
+                      .arg(url().toString(), socket.errorString());
+        error(QNetworkReply::ProtocolFailure, msg);
+        finished();
+        return;
+    }
+    upstreamBytesConsumed(packet.data.size());
+    bytesWrittenEmitted = true;
+}
+void QNetworkAccessDebugPipeBackend::downstreamReadyWrite()
+{
+    socketReadyRead();
+}
+void QNetworkAccessDebugPipeBackend::socketReadyRead()
+{
+    if (bareProtocol) {
+        qint64 bytesToRead = socket.bytesAvailable();
+        if (bytesToRead) {
+            QByteArray buffer;
+            buffer.resize(bytesToRead);
+            qint64 bytesRead = socket.read(buffer.data(), bytesToRead);
+            if (bytesRead < bytesToRead)
+                buffer.truncate(bytesRead);
+            writeDownstreamData(buffer);
+            readyReadEmitted = true;
+        }
+        return;
+    }
+    while (canReceive() &&
+           (socket.state() == QAbstractSocket::UnconnectedState || nextDownstreamBlockSize())) {
+        DataPacket packet;
+        if (receive(packet)) {
+            if (!packet.headers.isEmpty()) {
+                QList<QPair<QByteArray, QByteArray> >::ConstIterator
+                    it = packet.headers.constBegin(),
+                    end = packet.headers.constEnd();
+                for ( ; it != end; ++it)
+                    setRawHeader(it->first, it->second);
+                metaDataChanged();
+            }
+            if (!packet.data.isEmpty()) {
+                writeDownstreamData(packet.data);
+                readyReadEmitted = true;
+            }
+            if (packet.headers.isEmpty() && packet.data.isEmpty()) {
+                // it's an eof
+                socket.close();
+                readyReadEmitted = true;
+            }
+        } else {
+            // got an error
+            QString msg = QObject::tr("Read error reading from %1: %2")
+                          .arg(url().toString(), socket.errorString());
+            error(QNetworkReply::ProtocolFailure, msg);
+            finished();
+            return;
+        }
+    }
+}
+void QNetworkAccessDebugPipeBackend::socketBytesWritten(qint64)
+{
+    upstreamReadyRead();
+}
+    qWarning("QNetworkAccessDebugPipeBackend::closeDownstreamChannel() %d",operation());;
+    //if (operation() == QNetworkAccessManager::GetOperation)
+    //    socket.disconnectFromHost();
+}
 void QNetworkAccessDebugPipeBackend::socketError()
+{
+    qWarning("QNetworkAccessDebugPipeBackend::socketError() %d",socket.error());
     QNetworkReply::NetworkError code;
     switch (socket.error()) {
 …
 void QNetworkAccessDebugPipeBackend::socketDisconnected()
+{
+    socketReadyRead();
+    if (incomingPacketSize == 0 && socket.bytesToWrite() == 0) {
+    pushFromSocketToDownstream();
+    if (socket.bytesToWrite() == 0) {
         // normal close
-        finished();
     } else {
         // abnormal close
 …
                              .arg(url().toString());
         error(QNetworkReply::RemoteHostClosedError, msg);
         finished();
+    }
+}
+bool QNetworkAccessDebugPipeBackend::send(const DataPacket &packet)
+{
+    QByteArray ba;
+    {
+        QDataStream stream(&ba, QIODevice::WriteOnly);
+        stream.setVersion(QDataStream::Qt_4_4);
+        stream << packet.headers << packet.data;
+    }
+    qint32 outgoingPacketSize = ba.size();
+    qint64 written = socket.write((const char*)&outgoingPacketSize, sizeof outgoingPacketSize);
+    written += socket.write(ba);
+    return quint64(written) == (outgoingPacketSize + sizeof outgoingPacketSize);
+}
+bool QNetworkAccessDebugPipeBackend::receive(DataPacket &packet)
+{
+    if (!canReceive())
+        return false;
+    // canReceive() does the setting up for us
+    Q_ASSERT(socket.bytesAvailable() >= incomingPacketSize);
+    QByteArray incomingPacket = socket.read(incomingPacketSize);
+    QDataStream stream(&incomingPacket, QIODevice::ReadOnly);
+    stream.setVersion(QDataStream::Qt_4_4);
+    stream >> packet.headers >> packet.data;
+    // reset for next packet:
+    incomingPacketSize = 0;
+    socket.setReadBufferSize(ReadBufferSize);
+    return true;
+}
+bool QNetworkAccessDebugPipeBackend::canReceive()
+{
+    if (incomingPacketSize == 0) {
+        // read the packet size
+        if (quint64(socket.bytesAvailable()) >= sizeof incomingPacketSize)
+            socket.read((char*)&incomingPacketSize, sizeof incomingPacketSize);
+        else
+            return false;
+    }
+    if (incomingPacketSize == 0) {
+        QString msg = QObject::tr("Protocol error: packet of size 0 received");
+        error(QNetworkReply::ProtocolFailure, msg);
+        finished();
+        socket.blockSignals(true);
+        socket.abort();
+        socket.blockSignals(false);
+        return false;
+    }
+    return socket.bytesAvailable() >= incomingPacketSize;
+void QNetworkAccessDebugPipeBackend::socketConnected()
+{
+}
+bool QNetworkAccessDebugPipeBackend::waitForDownstreamReadyRead(int ms)
+{
+    Q_UNUSED(ms);
+    qCritical("QNetworkAccess: Debug pipe backend does not support waitForReadyRead()");
+    return false;
+}

trunk/src/network/access/qnetworkaccessdebugpipebackend_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     Q_OBJECT
 public:
-    struct DataPacket;
     QNetworkAccessDebugPipeBackend();
     virtual ~QNetworkAccessDebugPipeBackend();
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual void closeUpstreamChannel();
     virtual bool waitForDownstreamReadyRead(int msecs);
-    virtual bool waitForUpstreamBytesWritten(int msecs);
-    virtual void upstreamReadyRead();
     virtual void downstreamReadyWrite();
+protected:
+    void pushFromSocketToDownstream();
+    void pushFromUpstreamToSocket();
+    void possiblyFinish();
+    QNonContiguousByteDevice *uploadByteDevice;
 private slots:
+    void uploadReadyReadSlot();
     void socketReadyRead();
     void socketBytesWritten(qint64 bytes);
     void socketError();
     void socketDisconnected();
+    void socketConnected();
 private:
     QTcpSocket socket;
-    qint32 incomingPacketSize;
-    bool readyReadEmitted;
-    bool bytesWrittenEmitted;
     bool bareProtocol;
+    bool hasUploadFinished;
+    bool hasDownloadFinished;
+    bool hasEverythingFinished;
+    bool send(const DataPacket &packet);
+    bool canReceive();
+    bool receive(DataPacket &packet);
+    qint64 bytesDownloaded;
+    qint64 bytesUploaded;
 };

trunk/src/network/access/qnetworkaccessfilebackend.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "qurlinfo.h"
 #include "qdir.h"
+#include "private/qnoncontiguousbytedevice_p.h"
 #include <QtCore/QCoreApplication>
 …
 QNetworkAccessFileBackend::QNetworkAccessFileBackend()
     : totalBytes(0)
+    : uploadByteDevice(0), totalBytes(0), hasUploadFinished(false)
+{
+}
 …
     if (fileName.isEmpty()) {
         if (url.scheme() == QLatin1String("qrc"))
             fileName = QLatin1String(":") + url.path();
+            fileName = QLatin1Char(':') + url.path();
         else
             fileName = url.toString(QUrl::RemoveAuthority | QUrl::RemoveFragment | QUrl::RemoveQuery);
 …
     case QNetworkAccessManager::PutOperation:
         mode = QIODevice::WriteOnly | QIODevice::Truncate;
+        uploadByteDevice = createUploadByteDevice();
+        QObject::connect(uploadByteDevice, SIGNAL(readyRead()), this, SLOT(uploadReadyReadSlot()));
+        QMetaObject::invokeMethod(this, "uploadReadyReadSlot", Qt::QueuedConnection);
         break;
     default:
 …
+}
+void QNetworkAccessFileBackend::uploadReadyReadSlot()
+{
+    if (hasUploadFinished)
+        return;
+    forever {
+        qint64 haveRead;
+        const char *readPointer = uploadByteDevice->readPointer(-1, haveRead);
+        if (haveRead == -1) {
+            // EOF
+            hasUploadFinished = true;
+            file.flush();
+            file.close();
+            finished();
+            break;
+        } else if (haveRead == 0 || readPointer == 0) {
+            // nothing to read right now, we will be called again later
+            break;
+        } else {
+            qint64 haveWritten;
+            haveWritten = file.write(readPointer, haveRead);
+            if (haveWritten < 0) {
+                // write error!
+                QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Write error writing to %1: %2")
+                              .arg(url().toString(), file.errorString());
+                error(QNetworkReply::ProtocolFailure, msg);
+                finished();
+                return;
+            } else {
+                uploadByteDevice->advanceReadPointer(haveWritten);
+            }
+            file.flush();
+        }
+    }
+}
 void QNetworkAccessFileBackend::closeDownstreamChannel()
+{
     if (operation() == QNetworkAccessManager::GetOperation) {
         file.close();
-        //downstreamChannelClosed();
+    }
+}
-void QNetworkAccessFileBackend::closeUpstreamChannel()
+{
-    if (operation() == QNetworkAccessManager::PutOperation) {
-        file.close();
-        finished();
+    }
+}
 …
     Q_ASSERT(operation() == QNetworkAccessManager::GetOperation);
     return readMoreFromFile();
+}
-bool QNetworkAccessFileBackend::waitForUpstreamBytesWritten(int)
+{
-    Q_ASSERT_X(false, "QNetworkAccessFileBackend::waitForUpstreamBytesWritten",
-               "This function should never have been called, since there is never anything "
-               "left to be written!");
-    return false;
+}
-void QNetworkAccessFileBackend::upstreamReadyRead()
+{
-    Q_ASSERT_X(operation() == QNetworkAccessManager::PutOperation, "QNetworkAccessFileBackend",
-               "We're being told to upload data but operation isn't PUT!");
-    // there's more data to be written to the file
-    while (upstreamBytesAvailable()) {
-        // write everything and let QFile handle it
-        int written = file.write(readUpstream());
-        if (written < 0) {
-            // write error!
-            QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Write error writing to %1: %2")
-                                                    .arg(url().toString(), file.errorString());
-            error(QNetworkReply::ProtocolFailure, msg);
-            finished();
-            return;
+        }
-        // successful write
-        file.flush();
-        upstreamBytesConsumed(written);
+    }
+}
 …
         data.resize(actuallyRead);
         totalBytes += actuallyRead;
+        writeDownstreamData(data);
+        QByteDataBuffer list;
+        list.append(data);
+        data.clear(); // important because of implicit sharing!
+        writeDownstreamData(list);
+    }
     return true;

trunk/src/network/access/qnetworkaccessfilebackend_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 class QNetworkAccessFileBackend: public QNetworkAccessBackend
+{
+    Q_OBJECT
 public:
     QNetworkAccessFileBackend();
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual void closeUpstreamChannel();
     virtual bool waitForDownstreamReadyRead(int msecs);
-    virtual bool waitForUpstreamBytesWritten(int msecs);
-    virtual void upstreamReadyRead();
     virtual void downstreamReadyWrite();
+public slots:
+    void uploadReadyReadSlot();
+protected:
+    QNonContiguousByteDevice *uploadByteDevice;
 private:
     QFile file;
     qint64 totalBytes;
+    bool hasUploadFinished;
     bool loadFileInfo();

trunk/src/network/access/qnetworkaccessftpbackend.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "qnetworkaccessmanager_p.h"
 #include "QtNetwork/qauthenticator.h"
+#include "private/qnoncontiguousbytedevice_p.h"
 #ifndef QT_NO_FTP
 …
+}
+class QNetworkAccessFtpIODevice: public QIODevice
+{
+    //Q_OBJECT
+public:
+    QNetworkAccessFtpBackend *backend;
+    bool eof;
+    inline QNetworkAccessFtpIODevice(QNetworkAccessFtpBackend *parent)
+        : QIODevice(parent), backend(parent), eof(false)
+        { open(ReadOnly); }
+    bool isSequential() const { return true; }
+    bool atEnd() const { return backend->upstreamBytesAvailable() == 0; }
+    qint64 bytesAvailable() const { return backend->upstreamBytesAvailable(); }
+    qint64 bytesToWrite() const { return backend->downstreamBytesToConsume(); }
+protected:
+    qint64 readData(char *data, qint64 maxlen)
+    {
+        const QByteArray toSend = backend->readUpstream();
+        maxlen = qMin<qint64>(maxlen, toSend.size());
+        if (!maxlen)
+            return eof ? -1 : 0;
+        backend->upstreamBytesConsumed(maxlen);
+        memcpy(data, toSend.constData(), maxlen);
+        return maxlen;
+    }
+    qint64 writeData(const char *, qint64)
+    { return -1; }
+    friend class QNetworkAccessFtpBackend;
+};
+class QNetworkAccessFtpFtp: public QFtp, public QNetworkAccessCache::CacheableObject
+class QNetworkAccessCachedFtpConnection: public QFtp, public QNetworkAccessCache::CacheableObject
+{
     // Q_OBJECT
 public:
     QNetworkAccessFtpFtp()
+    QNetworkAccessCachedFtpConnection()
+    {
         setExpires(true);
 …
     state = LoggingIn;
     QNetworkAccessCache* cache = QNetworkAccessManagerPrivate::getCache(this);
+    QNetworkAccessCache* objectCache = QNetworkAccessManagerPrivate::getObjectCache(this);
     QByteArray cacheKey = makeCacheKey(url);
     if (!cache->requestEntry(cacheKey, this,
+    if (!objectCache->requestEntry(cacheKey, this,
                              SLOT(ftpConnectionReady(QNetworkAccessCache::CacheableObject*)))) {
         ftp = new QNetworkAccessFtpFtp;
+        ftp = new QNetworkAccessCachedFtpConnection;
 #ifndef QT_NO_NETWORKPROXY
         if (proxy.type() == QNetworkProxy::FtpCachingProxy)
 …
         ftp->login(url.userName(), url.password());
         cache->addEntry(cacheKey, ftp);
+        objectCache->addEntry(cacheKey, ftp);
         ftpConnectionReady(ftp);
+    }
+    uploadDevice = new QNetworkAccessFtpIODevice(this);
+    // Put operation
+    if (operation() == QNetworkAccessManager::PutOperation) {
+        uploadDevice = QNonContiguousByteDeviceFactory::wrap(createUploadByteDevice());
+        uploadDevice->setParent(this);
+    }
+}
 …
+}
-void QNetworkAccessFtpBackend::closeUpstreamChannel()
+{
-    if (operation() == QNetworkAccessManager::PutOperation) {
-        Q_ASSERT(uploadDevice);
-        uploadDevice->eof = true;
-        if (!upstreamBytesAvailable())
-            emit uploadDevice->readyRead();
+    }
+}
 bool QNetworkAccessFtpBackend::waitForDownstreamReadyRead(int ms)
+{
 …
+}
-bool QNetworkAccessFtpBackend::waitForUpstreamBytesWritten(int ms)
+{
-    Q_UNUSED(ms);
-    qCritical("QNetworkAccess: FTP backend does not support waitForBytesWritten()");
-    return false;
+}
-void QNetworkAccessFtpBackend::upstreamReadyRead()
+{
-    // uh... how does QFtp operate?
+}
 void QNetworkAccessFtpBackend::downstreamReadyWrite()
+{
 …
 void QNetworkAccessFtpBackend::ftpConnectionReady(QNetworkAccessCache::CacheableObject *o)
+{
     ftp = static_cast<QNetworkAccessFtpFtp *>(o);
+    ftp = static_cast<QNetworkAccessCachedFtpConnection *>(o);
     connect(ftp, SIGNAL(done(bool)), SLOT(ftpDone()));
     connect(ftp, SIGNAL(rawCommandReply(int,QString)), SLOT(ftpRawCommandReply(int,QString)));
 …
         QByteArray key = makeCacheKey(url());
         QNetworkAccessManagerPrivate::getCache(this)->releaseEntry(key);
+        QNetworkAccessManagerPrivate::getObjectCache(this)->releaseEntry(key);
         ftp = 0;
 …
         // we're not connected, so remove the cache entry:
         QByteArray key = makeCacheKey(url());
         QNetworkAccessManagerPrivate::getCache(this)->removeEntry(key);
+        QNetworkAccessManagerPrivate::getObjectCache(this)->removeEntry(key);
         disconnect(ftp, 0, this, 0);
 …
 void QNetworkAccessFtpBackend::ftpReadyRead()
+{
+    writeDownstreamData(ftp->readAll());
+    QByteArray data = ftp->readAll();
+    QByteDataBuffer list;
+    list.append(data);
+    data.clear(); // important because of implicit sharing!
+    writeDownstreamData(list);
+}

trunk/src/network/access/qnetworkaccessftpbackend_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 class QNetworkAccessFtpIODevice;
 class QNetworkAccessFtpFtp;
+class QNetworkAccessCachedFtpConnection;
 class QNetworkAccessFtpBackend: public QNetworkAccessBackend
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual void closeUpstreamChannel();
     virtual bool waitForDownstreamReadyRead(int msecs);
-    virtual bool waitForUpstreamBytesWritten(int msecs);
-    virtual void upstreamReadyRead();
     virtual void downstreamReadyWrite();
 …
 private:
     friend class QNetworkAccessFtpIODevice;
     QPointer<QNetworkAccessFtpFtp> ftp;
     QNetworkAccessFtpIODevice *uploadDevice;
+    QPointer<QNetworkAccessCachedFtpConnection> ftp;
+    QIODevice *uploadDevice;
     qint64 totalBytes;
     int helpId, sizeId, mdtmId;

trunk/src/network/access/qnetworkaccesshttpbackend.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     case QNetworkAccessManager::HeadOperation:
     case QNetworkAccessManager::PutOperation:
+    case QNetworkAccessManager::DeleteOperation:
         break;
 …
     case 404:               // Not Found
         code = QNetworkReply::ContentNotFoundError;
+        break;
+    case 405:               // Method Not Allowed
+        code = QNetworkReply::ContentOperationNotPermittedError;
         break;
 …
+}
 class QNetworkAccessHttpBackendCache: public QHttpNetworkConnection,
+class QNetworkAccessCachedHttpConnection: public QHttpNetworkConnection,
                                       public QNetworkAccessCache::CacheableObject
+{
     // Q_OBJECT
 public:
     QNetworkAccessHttpBackendCache(const QString &hostName, quint16 port, bool encrypt)
+    QNetworkAccessCachedHttpConnection(const QString &hostName, quint16 port, bool encrypt)
         : QHttpNetworkConnection(hostName, port, encrypt)
+    {
 …
 };
-class QNetworkAccessHttpBackendIODevice: public QIODevice
+{
-    // Q_OBJECT
-public:
-    bool eof;
-    QNetworkAccessHttpBackendIODevice(QNetworkAccessHttpBackend *parent)
-        : QIODevice(parent), eof(false)
+    {
-        setOpenMode(ReadOnly);
+    }
-    bool isSequential() const { return true; }
-    qint64 bytesAvailable() const
-    { return static_cast<QNetworkAccessHttpBackend *>(parent())->upstreamBytesAvailable(); }
-protected:
-    virtual qint64 readData(char *buffer, qint64 maxlen)
+    {
-        qint64 ret = static_cast<QNetworkAccessHttpBackend *>(parent())->deviceReadData(buffer, maxlen);
-        if (!ret && eof)
-            return -1;
-        return ret;
+    }
-    virtual qint64 writeData(const char *, qint64)
+    {
-        return -1;              // cannot write
+    }
-    friend class QNetworkAccessHttpBackend;
-};
 QNetworkAccessHttpBackend::QNetworkAccessHttpBackend()
     : QNetworkAccessBackend(), httpReply(0), http(0), uploadDevice(0)
 #ifndef QT_NO_OPENSSL
     , pendingSslConfiguration(0), pendingIgnoreSslErrors(false)
+    , pendingSslConfiguration(0), pendingIgnoreAllSslErrors(false)
 #endif
+{
 …
+{
     if (http) {
+        // This is abut disconnecting signals, not about disconnecting TCP connections
         disconnect(http, 0, this, 0);
+        QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getCache(this);
+        // Get the object cache that stores our QHttpNetworkConnection objects
+        QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getObjectCache(this);
         cache->releaseEntry(cacheKey);
+    }
+    // This is abut disconnecting signals, not about disconnecting TCP connections
     if (httpReply)
         disconnect(httpReply, 0, this, 0);
 …
         invalidateCache();
         httpRequest.setOperation(QHttpNetworkRequest::Post);
         uploadDevice = new QNetworkAccessHttpBackendIODevice(this);
+        httpRequest.setUploadByteDevice(createUploadByteDevice());
         break;
 …
         invalidateCache();
         httpRequest.setOperation(QHttpNetworkRequest::Put);
+        uploadDevice = new QNetworkAccessHttpBackendIODevice(this);
+        httpRequest.setUploadByteDevice(createUploadByteDevice());
+        break;
+    case QNetworkAccessManager::DeleteOperation:
+        invalidateCache();
+        httpRequest.setOperation(QHttpNetworkRequest::Delete);
         break;
 …
+    }
-    httpRequest.setData(uploadDevice);
     httpRequest.setUrl(url());
 …
     if (loadedFromCache) {
+        QNetworkAccessBackend::finished();
+        // commented this out since it will be called later anyway
+        // by copyFinished()
+        //QNetworkAccessBackend::finished();
         return;    // no need to send the request! :)
+    }
+    if (request().attribute(QNetworkRequest::HttpPipeliningAllowedAttribute).toBool() == true)
+        httpRequest.setPipeliningAllowed(true);
     httpReply = http->sendRequest(httpRequest);
 …
     if (pendingSslConfiguration)
         httpReply->setSslConfiguration(*pendingSslConfiguration);
     if (pendingIgnoreSslErrors)
+    if (pendingIgnoreAllSslErrors)
         httpReply->ignoreSslErrors();
+    httpReply->ignoreSslErrors(pendingIgnoreSslErrorsList);
 #endif
 …
     // check if we have an open connection to this host
     cacheKey = makeCacheKey(this, theProxy);
+    QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getCache(this);
+    if ((http = static_cast<QNetworkAccessHttpBackendCache *>(cache->requestEntryNow(cacheKey))) == 0) {
+    QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getObjectCache(this);
+    // the http object is actually a QHttpNetworkConnection
+    http = static_cast<QNetworkAccessCachedHttpConnection *>(cache->requestEntryNow(cacheKey));
+    if (http == 0) {
         // no entry in cache; create an object
+        http = new QNetworkAccessHttpBackendCache(url.host(), url.port(), encrypt);
+        // the http object is actually a QHttpNetworkConnection
+        http = new QNetworkAccessCachedHttpConnection(url.host(), url.port(), encrypt);
 #ifndef QT_NO_NETWORKPROXY
 …
 #endif
+        // cache the QHttpNetworkConnection corresponding to this cache key
         cache->addEntry(cacheKey, http);
+    }
 …
+{
     // this indicates that the user closed the stream while the reply isn't finished yet
+}
-void QNetworkAccessHttpBackend::closeUpstreamChannel()
+{
-    // this indicates that the user finished uploading the data for POST
-    Q_ASSERT(uploadDevice);
-    uploadDevice->eof = true;
-    emit uploadDevice->readChannelFinished();
+}
 …
+}
-bool QNetworkAccessHttpBackend::waitForUpstreamBytesWritten(int msecs)
+{
-    // ### FIXME: not implemented in QHttpNetworkAccess
-    Q_UNUSED(msecs);
-    qCritical("QNetworkAccess: HTTP backend does not support waitForBytesWritten()");
-    return false;
+}
-void QNetworkAccessHttpBackend::upstreamReadyRead()
+{
-    // There is more data available from the user to be uploaded
-    // QHttpNetworkAccess implements the upload rate control:
-    //  we simply tell QHttpNetworkAccess that there is more data available
-    //  it'll pull from us when it can (through uploadDevice)
-    Q_ASSERT(uploadDevice);
-    emit uploadDevice->readyRead();
+}
-qint64 QNetworkAccessHttpBackend::deviceReadData(char *buffer, qint64 maxlen)
+{
-    QByteArray toBeUploaded = readUpstream();
-    if (toBeUploaded.isEmpty())
-        return 0;               // nothing to be uploaded
-    maxlen = qMin<qint64>(maxlen, toBeUploaded.length());
-    memcpy(buffer, toBeUploaded.constData(), maxlen);
-    upstreamBytesConsumed(maxlen);
-    return maxlen;
+}
 void QNetworkAccessHttpBackend::downstreamReadyWrite()
 …
         return;
+    // We implement the download rate control
+    // Don't read from QHttpNetworkAccess more than QNetworkAccessBackend wants
+    // One of the two functions above will be called when we can read again
+    qint64 bytesToRead = qBound<qint64>(0, httpReply->bytesAvailable(), nextDownstreamBlockSize());
+    if (!bytesToRead)
+        return;
+    QByteArray data = httpReply->read(bytesToRead);
+    writeDownstreamData(data);
+    // We read possibly more than nextDownstreamBlockSize(), but
+    // this is not a critical thing since it is already in the
+    // memory anyway
+    QByteDataBuffer list;
+    while (httpReply->bytesAvailable() != 0 && nextDownstreamBlockSize() != 0 && nextDownstreamBlockSize() > list.byteAmount()) {
+        QByteArray data = httpReply->readAny();
+        list.append(data);
+    }
+    if (!list.isEmpty())
+      writeDownstreamData(list);
+}
 …
     // once we call finished(), we won't have access to httpReply anymore
     QSslConfiguration sslConfig = httpReply->sslConfiguration();
     if (pendingSslConfiguration)
+    if (pendingSslConfiguration) {
         *pendingSslConfiguration = sslConfig;
+    else if (!sslConfig.isNull())
+        pendingSslConfiguration = new QSslConfiguration(sslConfig);
+    } else if (!sslConfig.isNull()) {
+        QT_TRY {
+            pendingSslConfiguration = new QSslConfiguration(sslConfig);
+        } QT_CATCH(...) {
+            qWarning("QNetworkAccess: could not allocate a QSslConfiguration object for a SSL connection.");
+        }
+    }
 #endif
 …
 void QNetworkAccessHttpBackend::replyHeaderChanged()
+{
+    setAttribute(QNetworkRequest::HttpPipeliningWasUsedAttribute, httpReply->isPipeliningUsed());
     // reconstruct the HTTP header
     QList<QPair<QByteArray, QByteArray> > headerMap = httpReply->header();
 …
         QByteArray value = rawHeader(it->first);
         if (!value.isEmpty()) {
             if (it->first.toLower() == "set-cookie")
+            if (qstricmp(it->first.constData(), "set-cookie") == 0)
                 value += "\n";
             else
 …
     checkForRedirect(status);
+    writeDownstreamData(contents);
+    emit metaDataChanged();
+    // invoke this asynchronously, else Arora/QtDemoBrowser don't like cached downloads
+    // see task 250221 / 251801
+    qRegisterMetaType<QIODevice*>("QIODevice*");
+    QMetaObject::invokeMethod(this, "writeDownstreamData", Qt::QueuedConnection, Q_ARG(QIODevice*, contents));
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
     qDebug() << "Successfully sent cache:" << url() << contents->size() << "bytes";
 …
         httpReply->ignoreSslErrors();
     else
+        pendingIgnoreSslErrors = true;
+        pendingIgnoreAllSslErrors = true;
+}
+void QNetworkAccessHttpBackend::ignoreSslErrors(const QList<QSslError> &errors)
+{
+    if (httpReply) {
+        httpReply->ignoreSslErrors(errors);
+    } else {
+        // the pending list is set if QNetworkReply::ignoreSslErrors(const QList<QSslError> &errors)
+        // is called before QNetworkAccessManager::get() (or post(), etc.)
+        pendingIgnoreSslErrorsList = errors;
+    }
+}
 …
             continue;
+        // for 4.6.0, we were planning to not store the date header in the
+        // cached resource; through that we planned to reduce the number
+        // of writes to disk when using a QNetworkDiskCache (i.e. don't
+        // write to disk when only the date changes).
+        // However, without the date we cannot calculate the age of the page
+        // anymore. Consider a proper fix of that problem for 4.6.1.
+        //if (header == "date")
+            //continue;
         // Don't store Warning 1xx headers
         if (header == "warning") {
 …
         metaData.setLastModified(QNetworkHeadersPrivate::fromHttpDate(it->second));
+    bool canDiskCache = true; // Everything defaults to being cacheable on disk
+    // 14.32
+    // HTTP/1.1 caches SHOULD treat "Pragma: no-cache" as if the client
+    // had sent "Cache-Control: no-cache".
+    it = cacheHeaders.findRawHeader("pragma");
+    if (it != cacheHeaders.rawHeaders.constEnd()
+        && it->second == "no-cache")
+    bool canDiskCache;
+    // only cache GET replies by default, all other replies (POST, PUT, DELETE)
+    //  are not cacheable by default (according to RFC 2616 section 9)
+    if (httpReply->request().operation() == QHttpNetworkRequest::Get) {
+        canDiskCache = true;
+        // 14.32
+        // HTTP/1.1 caches SHOULD treat "Pragma: no-cache" as if the client
+        // had sent "Cache-Control: no-cache".
+        it = cacheHeaders.findRawHeader("pragma");
+        if (it != cacheHeaders.rawHeaders.constEnd()
+            && it->second == "no-cache")
+            canDiskCache = false;
+        // HTTP/1.1. Check the Cache-Control header
+        if (cacheControl.contains("no-cache"))
+            canDiskCache = false;
+        else if (cacheControl.contains("no-store"))
+            canDiskCache = false;
+    // responses to POST might be cacheable
+    } else if (httpReply->request().operation() == QHttpNetworkRequest::Post) {
         canDiskCache = false;
+    // HTTP/1.1. Check the Cache-Control header
+    if (cacheControl.contains("no-cache"))
+        // some pages contain "expires:" and "cache-control: no-cache" field,
+        // so we only might cache POST requests if we get "cache-control: max-age ..."
+        if (cacheControl.contains("max-age"))
+            canDiskCache = true;
+    // responses to PUT and DELETE are not cacheable
+    } else {
         canDiskCache = false;
+    else if (cacheControl.contains("no-store"))
+        canDiskCache = false;
+    }
     metaData.setSaveToDisk(canDiskCache);

trunk/src/network/access/qnetworkaccesshttpbackend_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 QT_BEGIN_NAMESPACE
 class QNetworkAccessHttpBackendCache;
+class QNetworkAccessCachedHttpConnection;
 class QNetworkAccessHttpBackendIODevice;
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual void closeUpstreamChannel();
     virtual bool waitForDownstreamReadyRead(int msecs);
-    virtual bool waitForUpstreamBytesWritten(int msecs);
-    virtual void upstreamReadyRead();
     virtual void downstreamReadyWrite();
     virtual void copyFinished(QIODevice *);
 #ifndef QT_NO_OPENSSL
     virtual void ignoreSslErrors();
+    virtual void ignoreSslErrors(const QList<QSslError> &errors);
     virtual void fetchSslConfiguration(QSslConfiguration &configuration) const;
 …
     qint64 deviceReadData(char *buffer, qint64 maxlen);
+    // we return true since HTTP needs to send PUT/POST data again after having authenticated
+    bool needsResetableUploadData() { return true; }
 private slots:
 …
 private:
     QHttpNetworkReply *httpReply;
     QPointer<QNetworkAccessHttpBackendCache> http;
+    QPointer<QNetworkAccessCachedHttpConnection> http;
     QByteArray cacheKey;
+    QNetworkAccessHttpBackendIODevice *uploadDevice;
+    QNetworkAccessBackendUploadIODevice *uploadDevice;
 #ifndef QT_NO_OPENSSL
     QSslConfiguration *pendingSslConfiguration;
+    bool pendingIgnoreSslErrors;
+    bool pendingIgnoreAllSslErrors;
+    QList<QSslError> pendingIgnoreSslErrorsList;
 #endif
 …
     void readFromHttp();
     void checkForRedirect(const int statusCode);
-    friend class QNetworkAccessHttpBackendIODevice;
 };

trunk/src/network/access/qnetworkaccessmanager.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "qnetworkaccessdatabackend_p.h"
 #include "qnetworkaccessdebugpipebackend_p.h"
+#include "qfilenetworkreply_p.h"
 #include "QtCore/qbuffer.h"
 …
     \class QNetworkAccessManager
     \brief The QNetworkAccessManager class allows the application to
     post network requests and receive replies
+    send network requests and receive replies
     \since 4.4
+    \ingroup network
     \inmodule QtNetwork
     \reentrant
 …
     QNetworkReply object. The returned object is used to obtain any data
     returned in response to the corresponding request.
-    the reply to is where most of the signals as well
-    as the downloaded data are posted.
     A simple download off the network could be accomplished with:
 …
     as well as meta-data (headers, etc.).
+    \note The slot is responsible for deleting the object at that point.
+    \note After the request has finished, it is the responsibility of the user
+    to delete the QNetworkReply object at an appropriate time. Do not directly
+    delete it inside the slot connected to finished(). You can use the
+    deleteLater() function.
     A more involved example, assuming the manager is already existent,
 …
     \value PostOperation        send the contents of an HTML form for
     processing via HTTP POST (created with post())
+    \value DeleteOperation      delete contents operation (created with
+    deleteResource())
     \omitvalue UnknownOperation
 …
     See QNetworkReply::finished() for information on the status that
     the object will be in.
+    \note Do not delete the \a reply object in the slot connected to this
+    signal. Use deleteLater().
     \sa QNetworkReply::finished(), QNetworkReply::error()
 …
     case QNetworkProxy::FtpCachingProxy:
         key.setScheme(QLatin1String("proxy-ftp"));
+        break;
     case QNetworkProxy::DefaultProxy:
 …
         delete d->networkCache;
         d->networkCache = cache;
+        d->networkCache->setParent(this);
+        if (d->networkCache)
+            d->networkCache->setParent(this);
+    }
+}
 …
 /*!
     This function is used to post a request to obtain the network
     headers for \a request. It takes its name after the HTTP request
+    associated (HEAD). It returns a new QNetworkReply object which
     will contain such headers.
+    Posts a request to obtain the network headers for \a request
+    and returns a new QNetworkReply object which will contain such headers
+    The function is named after the HTTP request associated (HEAD).
 */
 QNetworkReply *QNetworkAccessManager::head(const QNetworkRequest &request)
 …
 /*!
+    This function is used to post a request to obtain the contents of
+    the target \a request. It will cause the contents to be
+    downloaded, along with the headers associated with it. It returns
+    a new QNetworkReply object opened for reading which emits its
+    QIODevice::readyRead() signal whenever new data arrives.
+    \sa post(), put()
+    Posts a request to obtain the contents of the target \a request
+    and returns a new QNetworkReply object opened for reading which emits the
+    \l{QIODevice::readyRead()}{readyRead()} signal whenever new data
+    arrives.
+    The contents as well as associated headers will be downloaded.
+    \sa post(), put(), deleteResource()
 */
 QNetworkReply *QNetworkAccessManager::get(const QNetworkRequest &request)
 …
 /*!
+    This function is used to send an HTTP POST request to the
+    destination specified by \a request. The contents of the \a data
+    Sends an HTTP POST request to the destination specified by \a request
+    and returns a new QNetworkReply object opened for reading that will
+    contain the reply sent by the server. The contents of  the \a data
     device will be uploaded to the server.
+    \a data must be open for reading and must remain valid until the
+    finished() signal is emitted for this reply.
+    \note Sending a POST request on protocols other than HTTP and
+    HTTPS is undefined and will probably fail.
+    \sa get(), put(), deleteResource()
+*/
+QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, QIODevice *data)
+{
+    return d_func()->postProcess(createRequest(QNetworkAccessManager::PostOperation, request, data));
+}
+/*!
+    \overload
+    Sends the contents of the \a data byte array to the destination
+    specified by \a request.
+*/
+QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, const QByteArray &data)
+{
+    QBuffer *buffer = new QBuffer;
+    buffer->setData(data);
+    buffer->open(QIODevice::ReadOnly);
+    QNetworkReply *reply = post(request, buffer);
+    buffer->setParent(reply);
+    return reply;
+}
+/*!
+    Uploads the contents of \a data to the destination \a request and
+    returnes a new QNetworkReply object that will be open for reply.
     \a data must be opened for reading when this function is called
 …
     this reply.
+    The returned QNetworkReply object will be open for reading and
+    will contain the reply sent by the server to the POST request.
+    Note: sending a POST request on protocols other than HTTP and
+    HTTPS is undefined and will probably fail.
+    \sa get(), put()
+*/
+QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, QIODevice *data)
+{
+    return d_func()->postProcess(createRequest(QNetworkAccessManager::PostOperation, request, data));
+    Whether anything will be available for reading from the returned
+    object is protocol dependent. For HTTP, the server may send a
+    small HTML page indicating the upload was successful (or not).
+    Other protocols will probably have content in their replies.
+    \note For HTTP, this request will send a PUT request, which most servers
+    do not allow. Form upload mechanisms, including that of uploading
+    files through HTML forms, use the POST mechanism.
+    \sa get(), post()
+*/
+QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, QIODevice *data)
+{
+    return d_func()->postProcess(createRequest(QNetworkAccessManager::PutOperation, request, data));
+}
 /*!
     \overload
     This function sends the contents of the \a data byte array to the
     destination specified by \a request.
 */
 QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, const QByteArray &data)
+    Sends the contents of the \a data byte array to the destination
+    specified by \a request.
+*/
+QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, const QByteArray &data)
+{
     QBuffer *buffer = new QBuffer;
 …
     buffer->open(QIODevice::ReadOnly);
-    QNetworkReply *reply = post(request, buffer);
-    buffer->setParent(reply);
-    return reply;
+}
-/*!
-    This function is used to upload the contents of \a data to the
-    destination \a request.
-    \a data must be opened for reading when this function is called
-    and must remain valid until the finished() signal is emitted for
-    this reply.
-    The returned QNetworkReply object will be open for reply, but
-    whether anything will be available for reading is protocol
-    dependent. For HTTP, the server may send a small HTML page
-    indicating the upload was successful (or not). Other protocols
-    will probably have content in their replies.
-    For HTTP, this request will send a PUT request, which most servers
-    do not allow. Form upload mechanisms, including that of uploading
-    files through HTML forms, use the POST mechanism.
-    \sa get(), post()
-*/
-QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, QIODevice *data)
+{
-    return d_func()->postProcess(createRequest(QNetworkAccessManager::PutOperation, request, data));
+}
-/*!
-    \overload
-    This function sends the contents of the \a data byte array to the
-    destination specified by \a request.
-*/
-QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, const QByteArray &data)
+{
-    QBuffer *buffer = new QBuffer;
-    buffer->setData(data);
-    buffer->open(QIODevice::ReadOnly);
     QNetworkReply *reply = put(request, buffer);
     buffer->setParent(reply);
     return reply;
+}
+/*!
+    \since 4.6
+    Sends a request to delete the resource identified by the URL of \a request.
+    \note This feature is currently available for HTTP only, performing an
+    HTTP DELETE request.
+    \sa get(), post(), put()
+*/
+QNetworkReply *QNetworkAccessManager::deleteResource(const QNetworkRequest &request)
+{
+    return d_func()->postProcess(createRequest(QNetworkAccessManager::DeleteOperation, request));
+}
 …
+{
     Q_D(QNetworkAccessManager);
+    // fast path for GET on file:// URLs
+    // Also if the scheme is empty we consider it a file.
+    // The QNetworkAccessFileBackend will right now only be used
+    // for PUT or qrc://
+    if (op == QNetworkAccessManager::GetOperation
+         && (req.url().scheme() == QLatin1String("file")
+             || req.url().scheme().isEmpty())) {
+        return new QFileNetworkReply(this, req);
+    }
     QNetworkRequest request = req;
     if (!request.header(QNetworkRequest::ContentLengthHeader).isValid() &&
 …
+    }
+    // third step: setup the reply
+    // third step: find a backend
+    priv->backend = d->findBackend(op, request);
+    // fourth step: setup the reply
     priv->setup(op, request, outgoingData);
-    if (request.attribute(QNetworkRequest::CacheLoadControlAttribute, QNetworkRequest::PreferNetwork).toInt() !=
-        QNetworkRequest::AlwaysNetwork)
-        priv->setNetworkCache(d->networkCache);
 #ifndef QT_NO_NETWORKPROXY
     QList<QNetworkProxy> proxyList = d->queryProxy(QNetworkProxyQuery(request.url()));
     priv->proxyList = proxyList;
 #endif
-    // fourth step: find a backend
-    priv->backend = d->findBackend(op, request);
     if (priv->backend) {
         priv->backend->setParent(reply);
 …
         // keep the ugly hack in here
         QNetworkAccessManagerPrivate *that = const_cast<QNetworkAccessManagerPrivate *>(this);
+        that->cookieJar = new QNetworkCookieJar(that->q_func());
         that->cookieJarCreated = true;
-        that->cookieJar = new QNetworkCookieJar(that->q_func());
+    }
+}
 …
+{
     Q_Q(QNetworkAccessManager);
+    // ### FIXME Tracking of successful authentications
+    // This code is a bit broken right now for SOCKS authentication
+    // first request: proxyAuthenticationRequired gets emitted, credentials gets saved
+    // second request: (proxy != backend->reply->lastProxyAuthentication) does not evaluate to true,
+    //      proxyAuthenticationRequired gets emitted again
+    // possible solution: some tracking inside the authenticator
+    //      or a new function proxyAuthenticationSucceeded(true|false)
     if (proxy != backend->reply->lastProxyAuthentication) {
         QNetworkAuthenticationCredential *cred = fetchCachedCredentials(proxy);
 …
             QNetworkAuthenticationCache *auth = new QNetworkAuthenticationCache;
             auth->insert(QString(), authenticator->user(), authenticator->password());
             cache.addEntry(cacheKey, auth); // replace the existing one, if there's any
+            objectCache.addEntry(cacheKey, auth); // replace the existing one, if there's any
             if (realm.isEmpty()) {
 …
     if (cacheKey.isEmpty())
         return 0;
     if (!cache.hasEntry(cacheKey))
+    if (!objectCache.hasEntry(cacheKey))
         return 0;
     QNetworkAuthenticationCache *auth =
         static_cast<QNetworkAuthenticationCache *>(cache.requestEntryNow(cacheKey));
+        static_cast<QNetworkAuthenticationCache *>(objectCache.requestEntryNow(cacheKey));
     QNetworkAuthenticationCredential *cred = auth->findClosestMatch(QString());
     cache.releaseEntry(cacheKey);
+    objectCache.releaseEntry(cacheKey);
     // proxy cache credentials always have exactly one item
 …
     do {
         QByteArray cacheKey = authenticationKey(copy, realm);
         if (cache.hasEntry(cacheKey)) {
+        if (objectCache.hasEntry(cacheKey)) {
             QNetworkAuthenticationCache *auth =
                 static_cast<QNetworkAuthenticationCache *>(cache.requestEntryNow(cacheKey));
+                static_cast<QNetworkAuthenticationCache *>(objectCache.requestEntryNow(cacheKey));
             auth->insert(domain, authenticator->user(), authenticator->password());
             cache.releaseEntry(cacheKey);
+            objectCache.releaseEntry(cacheKey);
         } else {
             QNetworkAuthenticationCache *auth = new QNetworkAuthenticationCache;
             auth->insert(domain, authenticator->user(), authenticator->password());
             cache.addEntry(cacheKey, auth);
+            objectCache.addEntry(cacheKey, auth);
+        }
 …
     QByteArray cacheKey = authenticationKey(url, realm);
     if (!cache.hasEntry(cacheKey))
+    if (!objectCache.hasEntry(cacheKey))
         return 0;
     QNetworkAuthenticationCache *auth =
         static_cast<QNetworkAuthenticationCache *>(cache.requestEntryNow(cacheKey));
+        static_cast<QNetworkAuthenticationCache *>(objectCache.requestEntryNow(cacheKey));
     QNetworkAuthenticationCredential *cred = auth->findClosestMatch(url.path());
     cache.releaseEntry(cacheKey);
+    objectCache.releaseEntry(cacheKey);
     return cred;
+}
 …
 void QNetworkAccessManagerPrivate::clearCache(QNetworkAccessManager *manager)
+{
+    manager->d_func()->cache.clear();
+    manager->d_func()->objectCache.clear();
+}
+QNetworkAccessManagerPrivate::~QNetworkAccessManagerPrivate()
+{
+}

trunk/src/network/access/qnetworkaccessmanager.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
         PutOperation,
         PostOperation,
+        DeleteOperation,
         UnknownOperation = 0
 …
     QNetworkReply *put(const QNetworkRequest &request, QIODevice *data);
     QNetworkReply *put(const QNetworkRequest &request, const QByteArray &data);
+    QNetworkReply *deleteResource(const QNetworkRequest &request);
 Q_SIGNALS:

trunk/src/network/access/qnetworkaccessmanager_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
           cookieJarCreated(false)
     { }
+    ~QNetworkAccessManagerPrivate();
     void _q_replyFinished();
 …
     QNetworkAccessBackend *findBackend(QNetworkAccessManager::Operation op, const QNetworkRequest &request);
+    // this is the cache for storing downloaded files
     QAbstractNetworkCache *networkCache;
     QNetworkCookieJar *cookieJar;
+    QNetworkAccessCache cache;
 #ifndef QT_NO_NETWORKPROXY
     QNetworkProxy proxy;
 …
     bool cookieJarCreated;
+    static inline QNetworkAccessCache *getCache(QNetworkAccessBackend *backend)
+    { return &backend->manager->cache; }
+    // this cache can be used by individual backends to cache e.g. their TCP connections to a server
+    // and use the connections for multiple requests.
+    QNetworkAccessCache objectCache;
+    static inline QNetworkAccessCache *getObjectCache(QNetworkAccessBackend *backend)
+    { return &backend->manager->objectCache; }
     Q_AUTOTEST_EXPORT static void clearCache(QNetworkAccessManager *manager);

trunk/src/network/access/qnetworkcookie.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
         if (!d->domain.isEmpty()) {
             result += "; domain=";
+            result += QUrl::toAce(d->domain);
+            QString domainNoDot = d->domain;
+            if (domainNoDot.startsWith(QLatin1Char('.'))) {
+                result += '.';
+                domainNoDot = domainNoDot.mid(1);
+            }
+            result += QUrl::toAce(domainNoDot);
+        }
         if (!d->path.isEmpty()) {
 …
 QList<QNetworkCookie> QNetworkCookie::parseCookies(const QByteArray &cookieString)
+{
+    // cookieString can be a number of set-cookie header strings joined together
+    // by \n, parse each line separately.
+    QList<QNetworkCookie> cookies;
+    QList<QByteArray> list = cookieString.split('\n');
+    for (int a = 0; a < list.size(); a++)
+        cookies += QNetworkCookiePrivate::parseSetCookieHeaderLine(list.at(a));
+    return cookies;
+}
+QList<QNetworkCookie> QNetworkCookiePrivate::parseSetCookieHeaderLine(const QByteArray &cookieString)
+{
     // According to http://wp.netscape.com/newsref/std/cookie_spec.html,<
     // the Set-Cookie response header is of the format:
 …
         QNetworkCookie cookie;
-        // When there are multiple SetCookie headers they are join with a new line
-        // \n will always be the start of a new cookie
-        int endOfSetCookie = cookieString.indexOf('\n', position);
-        if (endOfSetCookie == -1)
-            endOfSetCookie = length;
         // The first part is always the "NAME=VALUE" part
         QPair<QByteArray,QByteArray> field = nextField(cookieString, position);
 …
         position = nextNonWhitespace(cookieString, position);
         bool endOfCookie = false;
         while (!endOfCookie && position < endOfSetCookie)
+        while (!endOfCookie && position < length) {
             switch (cookieString.at(position++)) {
             case ',':
 …
                     QDateTime dt = parseDateString(dateString.toLower());
                     if (!dt.isValid()) {
+                        cookie = QNetworkCookie();
+                        endOfCookie = true;
+                        continue;
+                        return result;
+                    }
                     cookie.setExpirationDate(dt);
 …
                     int secs = field.second.toInt(&ok);
                     if (!ok)
+                        // invalid cookie string
+                        return QList<QNetworkCookie>();
+                        return result;
                     cookie.setExpirationDate(now.addSecs(secs));
                 } else if (field.first == "path") {
 …
                     if (field.second != "1") {
                         // oops, we don't know how to handle this cookie
+                        cookie = QNetworkCookie();
+                        endOfCookie = true;
+                        continue;
+                        return result;
+                    }
                 } else {
 …
                 position = nextNonWhitespace(cookieString, position);
-                if (position > endOfSetCookie)
-                    endOfCookie = true;
+            }
+        }
         if (!cookie.name().isEmpty())
 …
 QDebug operator<<(QDebug s, const QNetworkCookie &cookie)
+{
     s.nospace() << "QNetworkCookie(" << cookie.toRawForm(QNetworkCookie::Full) << ")";
+    s.nospace() << "QNetworkCookie(" << cookie.toRawForm(QNetworkCookie::Full) << ')';
     return s.space();
+}
 #endif
-class QNetworkCookieJarPrivate: public QObjectPrivate
+{
-public:
-    QList<QNetworkCookie> allCookies;
-    Q_DECLARE_PUBLIC(QNetworkCookieJar)
-};
-/*!
-    \class QNetworkCookieJar
-    \brief The QNetworkCookieJar class implements a simple jar of QNetworkCookie objects
-    \since 4.4
-    Cookies are small bits of information that stateless protocols
-    like HTTP use to maintain some persistent information across
-    requests.
-    A cookie is set by a remote server when it replies to a request
-    and it expects the same cookie to be sent back when further
-    requests are sent.
-    The cookie jar is the object that holds all cookies set in
-    previous requests. Web browsers save their cookie jars to disk in
-    order to conserve permanent cookies across invocations of the
-    application.
-    QNetworkCookieJar does not implement permanent storage: it only
-    keeps the cookies in memory. Once the QNetworkCookieJar object is
-    deleted, all cookies it held will be discarded as well. If you
-    want to save the cookies, you should derive from this class and
-    implement the saving to disk to your own storage format.
-    This class implements only the basic security recommended by the
-    cookie specifications and does not implement any cookie acceptance
-    policy (it accepts all cookies set by any requests). In order to
-    override those rules, you should reimplement the
-    cookiesForUrl() and setCookiesFromUrl() virtual
-    functions. They are called by QNetworkReply and
-    QNetworkAccessManager when they detect new cookies and when they
-    require cookies.
-    \sa QNetworkCookie, QNetworkAccessManager, QNetworkReply,
-    QNetworkRequest, QNetworkAccessManager::setCookieJar()
-*/
-/*!
-    Creates a QNetworkCookieJar object and sets the parent object to
-    be \a parent.
-    The cookie jar is initialized to empty.
-*/
-QNetworkCookieJar::QNetworkCookieJar(QObject *parent)
-    : QObject(*new QNetworkCookieJarPrivate, parent)
+{
+}
-/*!
-    Destroys this cookie jar object and discards all cookies stored in
-    it. Cookies are not saved to disk in the QNetworkCookieJar default
-    implementation.
-    If you need to save the cookies to disk, you have to derive from
-    QNetworkCookieJar and save the cookies to disk yourself.
-*/
-QNetworkCookieJar::~QNetworkCookieJar()
+{
+}
-/*!
-    Returns all cookies stored in this cookie jar. This function is
-    suitable for derived classes to save cookies to disk, as well as
-    to implement cookie expiration and other policies.
-    \sa setAllCookies(), cookiesForUrl()
-*/
-QList<QNetworkCookie> QNetworkCookieJar::allCookies() const
+{
-    return d_func()->allCookies;
+}
-/*!
-    Sets the internal list of cookies held by this cookie jar to be \a
-    cookieList. This function is suitable for derived classes to
-    implement loading cookies from permanent storage, or their own
-    cookie acceptance policies by reimplementing
-    setCookiesFromUrl().
-    \sa allCookies(), setCookiesFromUrl()
-*/
-void QNetworkCookieJar::setAllCookies(const QList<QNetworkCookie> &cookieList)
+{
-    Q_D(QNetworkCookieJar);
-    d->allCookies = cookieList;
+}
-static inline bool isParentPath(QString path, QString reference)
+{
-    if (!path.endsWith(QLatin1Char('/')))
-        path += QLatin1Char('/');
-    if (!reference.endsWith(QLatin1Char('/')))
-        reference += QLatin1Char('/');
-    return path.startsWith(reference);
+}
-static inline bool isParentDomain(QString domain, QString reference)
+{
-    if (!reference.startsWith(QLatin1Char('.')))
-        return domain == reference;
-    return domain.endsWith(reference) || domain == reference.mid(1);
+}
-/*!
-    Adds the cookies in the list \a cookieList to this cookie
-    jar. Default values for path and domain are taken from the \a
-    url object.
-    Returns true if one or more cookes are set for url otherwise false.
-    If a cookie already exists in the cookie jar, it will be
-    overridden by those in \a cookieList.
-    The default QNetworkCookieJar class implements only a very basic
-    security policy (it makes sure that the cookies' domain and path
-    match the reply's). To enhance the security policy with your own
-    algorithms, override setCookiesFromUrl().
-    Also, QNetworkCookieJar does not have a maximum cookie jar
-    size. Reimplement this function to discard older cookies to create
-    room for new ones.
-    \sa cookiesForUrl(), QNetworkAccessManager::setCookieJar()
-*/
-bool QNetworkCookieJar::setCookiesFromUrl(const QList<QNetworkCookie> &cookieList,
-                                          const QUrl &url)
+{
-    Q_D(QNetworkCookieJar);
-    QString defaultDomain = url.host();
-    QString pathAndFileName = url.path();
-    QString defaultPath = pathAndFileName.left(pathAndFileName.lastIndexOf(QLatin1Char('/'))+1);
-    if (defaultPath.isEmpty())
-        defaultPath = QLatin1Char('/');
-    int added = 0;
-    QDateTime now = QDateTime::currentDateTime();
-    foreach (QNetworkCookie cookie, cookieList) {
-        bool isDeletion = !cookie.isSessionCookie() &&
-                          cookie.expirationDate() < now;
-        // validate the cookie & set the defaults if unset
-        // (RFC 2965: "The request-URI MUST path-match the Path attribute of the cookie.")
-        if (cookie.path().isEmpty())
-            cookie.setPath(defaultPath);
-        else if (!isParentPath(pathAndFileName, cookie.path()))
-            continue;           // not accepted
-        if (cookie.domain().isEmpty()) {
-            cookie.setDomain(defaultDomain);
-        } else {
-            QString domain = cookie.domain();
-            if (!(isParentDomain(domain, defaultDomain)
-                || isParentDomain(defaultDomain, domain))) {
-                    continue;           // not accepted
+            }
+        }
-        QList<QNetworkCookie>::Iterator it = d->allCookies.begin(),
-                                       end = d->allCookies.end();
-        for ( ; it != end; ++it)
-            // does this cookie already exist?
-            if (cookie.name() == it->name() &&
-                cookie.domain() == it->domain() &&
-                cookie.path() == it->path()) {
-                // found a match
-                d->allCookies.erase(it);
-                break;
+            }
-        // did not find a match
-        if (!isDeletion) {
-            d->allCookies += cookie;
-            ++added;
+        }
+    }
-    return (added > 0);
+}
-/*!
-    Returns the cookies to be added to when a request is sent to
-    \a url. This function is called by the default
-    QNetworkAccessManager::createRequest(), which adds the
-    cookies returned by this function to the request being sent.
-    If more than one cookie with the same name is found, but with
-    differing paths, the one with longer path is returned before the
-    one with shorter path. In other words, this function returns
-    cookies sorted by path length.
-    The default QNetworkCookieJar class implements only a very basic
-    security policy (it makes sure that the cookies' domain and path
-    match the reply's). To enhance the security policy with your own
-    algorithms, override cookiesForUrl().
-    \sa setCookiesFromUrl(), QNetworkAccessManager::setCookieJar()
-*/
-QList<QNetworkCookie> QNetworkCookieJar::cookiesForUrl(const QUrl &url) const
+{
-//     \b Warning! This is only a dumb implementation!
-//     It does NOT follow all of the recommendations from
-//     http://wp.netscape.com/newsref/std/cookie_spec.html
-//     It does not implement a very good cross-domain verification yet.
-    Q_D(const QNetworkCookieJar);
-    QDateTime now = QDateTime::currentDateTime();
-    QList<QNetworkCookie> result;
-    // scan our cookies for something that matches
-    QList<QNetworkCookie>::ConstIterator it = d->allCookies.constBegin(),
-                                        end = d->allCookies.constEnd();
-    for ( ; it != end; ++it) {
-        if (!isParentDomain(url.host(), it->domain()))
-            continue;
-        if (!isParentPath(url.path(), it->path()))
-            continue;
-        if (!(*it).isSessionCookie() && (*it).expirationDate() < now)
-            continue;
-        // insert this cookie into result, sorted by path
-        QList<QNetworkCookie>::Iterator insertIt = result.begin();
-        while (insertIt != result.end()) {
-            if (insertIt->path().length() < it->path().length()) {
-                // insert here
-                insertIt = result.insert(insertIt, *it);
-                break;
-            } else {
-                ++insertIt;
+            }
+        }
-        // this is the shortest path yet, just append
-        if (insertIt == result.end())
-            result += *it;
+    }
-    return result;
+}
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkcookie.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 Q_DECLARE_TYPEINFO(QNetworkCookie, Q_MOVABLE_TYPE);
-class QNetworkCookieJarPrivate;
-class Q_NETWORK_EXPORT QNetworkCookieJar: public QObject
+{
-    Q_OBJECT
-public:
-    QNetworkCookieJar(QObject *parent = 0);
-    virtual ~QNetworkCookieJar();
-    virtual QList<QNetworkCookie> cookiesForUrl(const QUrl &url) const;
-    virtual bool setCookiesFromUrl(const QList<QNetworkCookie> &cookieList, const QUrl &url);
-protected:
-    QList<QNetworkCookie> allCookies() const;
-    void setAllCookies(const QList<QNetworkCookie> &cookieList);
-private:
-    Q_DECLARE_PRIVATE(QNetworkCookieJar)
-    Q_DISABLE_COPY(QNetworkCookieJar)
-};
 #ifndef QT_NO_DEBUG_STREAM
 class QDebug;
 …
 QT_END_NAMESPACE
+// ### Qt5 remove this include
+#include "qnetworkcookiejar.h"
 Q_DECLARE_METATYPE(QNetworkCookie)
 Q_DECLARE_METATYPE(QList<QNetworkCookie>)

trunk/src/network/access/qnetworkcookie_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 public:
     inline QNetworkCookiePrivate() : secure(false), httpOnly(false) { }
+    static QList<QNetworkCookie> parseSetCookieHeaderLine(const QByteArray &cookieString);
     QDateTime expirationDate;

trunk/src/network/access/qnetworkdiskcache.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 //#define QNETWORKDISKCACHE_DEBUG
+#ifndef QT_NO_NETWORKDISKCACHE
 #include "qnetworkdiskcache.h"
 #include "qnetworkdiskcache_p.h"
+#include "QtCore/qscopedpointer.h"
 #include <qfile.h>
 …
     Note you have to set the cache directory before it will work.
+    A network disk cache can be enabled by:
+    \snippet doc/src/snippets/code/src_network_access_qnetworkdiskcache.cpp 0
+    When sending requests, to control the preference of when to use the cache
+    and when to use the network, consider the following:
+    \snippet doc/src/snippets/code/src_network_access_qnetworkdiskcache.cpp 1
+    To check whether the response came from the cache or from the network, the
+    following can be applied:
+    \snippet doc/src/snippets/code/src_network_access_qnetworkdiskcache.cpp 2
 */
 …
+        }
+    }
+    QCacheItem *cacheItem = new QCacheItem;
+    QScopedPointer<QCacheItem> cacheItem(new QCacheItem);
     cacheItem->metaData = metaData;
 …
     } else {
         QString templateName = d->tmpCacheFileName();
+        cacheItem->file = new QTemporaryFile(templateName, &cacheItem->data);
+        cacheItem->file->open();
+        QT_TRY {
+            cacheItem->file = new QTemporaryFile(templateName, &cacheItem->data);
+        } QT_CATCH(...) {
+            cacheItem->file = 0;
+        }
+        if (!cacheItem->file || !cacheItem->file->open()) {
+            qWarning() << "QNetworkDiskCache::prepare() unable to open temporary file";
+            cacheItem.reset();
+            return 0;
+        }
         cacheItem->writeHeader(cacheItem->file);
         device = cacheItem->file;
+    }
     d->inserting[device] = cacheItem;
+    d->inserting[device] = cacheItem.take();
     return device;
+}
 …
     if (QFile::exists(fileName)) {
         if (!QFile::remove(fileName)) {
             qWarning() << "QNetworkDiskCache: could't remove the cache file " << fileName;
+            qWarning() << "QNetworkDiskCache: couldn't remove the cache file " << fileName;
             return;
+        }
 …
 #endif
     Q_D(QNetworkDiskCache);
     QBuffer *buffer = 0;
+    QScopedPointer<QBuffer> buffer;
     if (!url.isValid())
         return buffer;
+        return 0;
     if (d->lastItem.metaData.url() == url && d->lastItem.data.isOpen()) {
         buffer = new QBuffer;
+        buffer.reset(new QBuffer);
         buffer->setData(d->lastItem.data.data());
     } else {
+        QFile *file = new QFile(d->cacheFileName(url));
+        if (!file->open(QFile::ReadOnly | QIODevice::Unbuffered)) {
+            delete file;
+        QScopedPointer<QFile> file(new QFile(d->cacheFileName(url)));
+        if (!file->open(QFile::ReadOnly | QIODevice::Unbuffered))
             return 0;
+        }
         if (!d->lastItem.read(file, true)) {
+        if (!d->lastItem.read(file.data(), true)) {
             file->close();
             remove(url);
-            delete file;
             return 0;
+        }
         if (d->lastItem.data.isOpen()) {
             // compressed
             buffer = new QBuffer;
+            buffer.reset(new QBuffer);
             buffer->setData(d->lastItem.data.data());
-            delete file;
         } else {
             buffer = new QBuffer;
+            buffer.reset(new QBuffer);
             // ### verify that QFile uses the fd size and not the file name
             qint64 size = file->size() - file->pos();
 …
 #endif
             if (p) {
-                file->setParent(buffer);
                 buffer->setData((const char *)p, size);
+                file.take()->setParent(buffer.data());
             } else {
                 buffer->setData(file->readAll());
-                delete file;
+            }
+        }
+    }
     buffer->open(QBuffer::ReadOnly);
     return buffer;
+    return buffer.take();
+}
 …
     Returns the current size of the cache.
     When the current size of the cache is greater then the maximumCacheSize()
+    When the current size of the cache is greater than the maximumCacheSize()
     older cache files are removed until the total size is less then 90% of
     maximumCacheSize() starting with the oldest ones first using the file
 …
     QDirIterator it(cacheDirectory(), filters, QDirIterator::Subdirectories);
     QMap<QDateTime, QString> cacheItems;
+    QMultiMap<QDateTime, QString> cacheItems;
     qint64 totalSize = 0;
     while (it.hasNext()) {
 …
         QString fileName = info.fileName();
         if (fileName.endsWith(CACHE_POSTFIX) && fileName.startsWith(CACHE_PREFIX)) {
             cacheItems[info.created()] = path;
+            cacheItems.insert(info.created(), path);
             totalSize += info.size();
+        }
 …
     int removedFiles = 0;
     qint64 goal = (maximumCacheSize() * 9) / 10;
     QMap<QDateTime, QString>::const_iterator i = cacheItems.constBegin();
+    QMultiMap<QDateTime, QString>::const_iterator i = cacheItems.constBegin();
     while (i != cacheItems.constEnd()) {
         if (totalSize < goal)
 …
 QT_END_NAMESPACE
+#endif // QT_NO_NETWORKDISKCACHE

trunk/src/network/access/qnetworkdiskcache.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 QT_MODULE(Network)
+#ifndef QT_NO_NETWORKDISKCACHE
 class QNetworkDiskCachePrivate;
 …
 };
+#endif // QT_NO_NETWORKDISKCACHE
 QT_END_NAMESPACE
 …
 #endif // QNETWORKDISKCACHE_H

trunk/src/network/access/qnetworkdiskcache_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **

trunk/src/network/access/qnetworkreply.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     \since 4.4
     \brief The QNetworkReply class contains the data and headers for a request
     posted with QNetworkAccessManager
+    sent with QNetworkAccessManager
     \reentrant
+    \ingroup network
     \inmodule QtNetwork
 …
     content.
+    \note Do not delete the object in the slot connected to the
+    error() or finished() signal. Use deleteLater().
     \sa QNetworkRequest, QNetworkAccessManager
 */
 …
     were not accepted (if any)
+    \value ContentReSendError          the request needed to be sent
+    again, but this failed for example because the upload data
+    could not be read a second time.
     \value ProtocolUnknownError         the Network Access API cannot
     honor the request because the protocol is not known
 …
     was detected
     \value UnknownContentError          an unknonwn error related to
+    \value UnknownContentError          an unknown error related to
     the remote content was detected
 …
     parameter is this object.
+    \note Do not delete the object in the slot connected to this
+    signal. Use deleteLater().
     \sa QNetworkAccessManager::finished()
 */
 …
     detected. Call errorString() to obtain a textual representation of
     the error condition.
+    \note Do not delete the object in the slot connected to this
+    signal. Use deleteLater().
     \sa error(), errorString()
 …
+{
     return d_func()->errorCode;
+}
+/*!
+    \since 4.6
+    Returns true when the reply has finished or was aborted.
+    \sa isRunning()
+*/
+bool QNetworkReply::isFinished() const
+{
+    return d_func()->isFinished();
+}
+/*!
+    \since 4.6
+    Returns true when the request is still processing and the
+    reply has not finished or was aborted yet.
+    \sa isFinished()
+*/
+bool QNetworkReply::isRunning() const
+{
+    return !isFinished();
+}
 …
+    }
+}
+/*!
+    \overload
+    \since 4.6
+    If this function is called, the SSL errors given in \a errors
+    will be ignored.
+    Note that you can set the expected certificate in the SSL error:
+    If, for instance, you want to issue a request to a server that uses
+    a self-signed certificate, consider the following snippet:
+    \snippet doc/src/snippets/code/src_network_access_qnetworkreply.cpp 0
+    Multiple calls to this function will replace the list of errors that
+    were passed in previous calls.
+    You can clear the list of errors you want to ignore by calling this
+    function with an empty list.
+    \sa sslConfiguration(), sslErrors(), QSslSocket::ignoreSslErrors()
+*/
+void QNetworkReply::ignoreSslErrors(const QList<QSslError> &errors)
+{
+    // do this cryptic trick, because we could not add a virtual method to this class later on
+    // since that breaks binary compatibility
+    int id = metaObject()->indexOfMethod("ignoreSslErrorsImplementation(QList<QSslError>)");
+    if (id != -1) {
+        QList<QSslError> copy(errors);
+        void *arr[] = { 0, &copy };
+        qt_metacall(QMetaObject::InvokeMetaMethod, id, arr);
+    }
+}
 #endif
 …
     found.
     \sa sslConfiguration(), sslErrors()
+    \sa sslConfiguration(), sslErrors(), QSslSocket::ignoreSslErrors()
 */
 void QNetworkReply::ignoreSslErrors()

trunk/src/network/access/qnetworkreply.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
         ContentNotFoundError,
         AuthenticationRequiredError,
+        ContentReSendError,
         UnknownContentError = 299,
 …
     QNetworkRequest request() const;
     NetworkError error() const;
+    bool isFinished() const;
+    bool isRunning() const;
     QUrl url() const;
 …
     QSslConfiguration sslConfiguration() const;
     void setSslConfiguration(const QSslConfiguration &configuration);
+    void ignoreSslErrors(const QList<QSslError> &errors);
 #endif

trunk/src/network/access/qnetworkreply_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
     { reply->d_func()->manager = manager; }
+    virtual bool isFinished() const { return false; }
     Q_DECLARE_PUBLIC(QNetworkReply)
 };

trunk/src/network/access/qnetworkreplyimpl.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "QtCore/qdatetime.h"
 #include "QtNetwork/qsslconfiguration.h"
+#include "qnetworkaccesshttpbackend_p.h"
 #include <QtCore/QCoreApplication>
 …
 inline QNetworkReplyImplPrivate::QNetworkReplyImplPrivate()
+    : copyDevice(0), networkCache(0),
+    : backend(0), outgoingData(0), outgoingDataBuffer(0),
+      copyDevice(0),
       cacheEnabled(false), cacheSaveDevice(0),
+      notificationHandlingPaused(false),
       bytesDownloaded(0), lastBytesDownloaded(-1), bytesUploaded(-1),
+      httpStatusCode(0),
       state(Idle)
+{
 …
 void QNetworkReplyImplPrivate::_q_startOperation()
+{
+    // This function is called exactly once
+    // ensure this function is only being called once
+    if (state == Working) {
+        qDebug("QNetworkReplyImpl::_q_startOperation was called more than once");
+        return;
+    }
     state = Working;
     if (!backend) {
         error(QNetworkReplyImpl::ProtocolUnknownError,
 …
         if (operation == QNetworkAccessManager::GetOperation)
             pendingNotifications.append(NotifyDownstreamReadyWrite);
-        if (outgoingData) {
-            _q_sourceReadyRead();
-#if 0 // ### FIXME
-            if (outgoingData->atEndOfStream() && writeBuffer.isEmpty())
-                // empty upload
-                emit q->uploadProgress(0, 0);
-#endif
+        }
         handleNotifications();
 …
+}
-void QNetworkReplyImplPrivate::_q_sourceReadyRead()
+{
-    // read data from the outgoingData QIODevice into our internal buffer
-    enum { DesiredBufferSize = 32 * 1024 };
-    if (writeBuffer.size() >= DesiredBufferSize)
-        return;                 // don't grow the buffer too much
-    // read as many bytes are available or up until we fill up the buffer
-    // but always read at least one byte
-    qint64 bytesToRead = qBound<qint64>(1, outgoingData->bytesAvailable(),
-                                        DesiredBufferSize - writeBuffer.size());
-    char *ptr = writeBuffer.reserve(bytesToRead);
-    qint64 bytesActuallyRead = outgoingData->read(ptr, bytesToRead);
-    if (bytesActuallyRead == -1) {
-        // EOF
-        writeBuffer.chop(bytesToRead);
-        backendNotify(NotifyCloseUpstreamChannel);
-        return;
+    }
-    if (bytesActuallyRead < bytesToRead)
-        writeBuffer.chop(bytesToRead - bytesActuallyRead);
-    // if we did read anything, let the backend know and handle it
-    if (bytesActuallyRead)
-        backendNotify(NotifyUpstreamReadyRead);
-    // check for EOF again
-    if (!outgoingData->isSequential() && outgoingData->atEnd())
-        backendNotify(NotifyCloseUpstreamChannel);
+}
-void QNetworkReplyImplPrivate::_q_sourceReadChannelFinished()
+{
-    _q_sourceReadyRead();
+}
 void QNetworkReplyImplPrivate::_q_copyReadyRead()
+{
     Q_Q(QNetworkReplyImpl);
+    if (!copyDevice && !q->isOpen())
+        return;
+    qint64 bytesToRead = nextDownstreamBlockSize();
+    if (bytesToRead == 0)
+        // we'll be called again, eventually
+        return;
+    bytesToRead = qBound<qint64>(1, bytesToRead, copyDevice->bytesAvailable());
+    char *ptr = readBuffer.reserve(bytesToRead);
+    qint64 bytesActuallyRead = copyDevice->read(ptr, bytesToRead);
+    if (bytesActuallyRead == -1) {
+        readBuffer.chop(bytesToRead);
+        backendNotify(NotifyCopyFinished);
+        return;
+    }
+    if (bytesActuallyRead != bytesToRead)
+        readBuffer.chop(bytesToRead - bytesActuallyRead);
+    if (!copyDevice->isSequential() && copyDevice->atEnd())
+        backendNotify(NotifyCopyFinished);
+    bytesDownloaded += bytesActuallyRead;
+    if (state != Working)
+        return;
+    if (!copyDevice || !q->isOpen())
+        return;
+    forever {
+        qint64 bytesToRead = nextDownstreamBlockSize();
+        if (bytesToRead == 0)
+            // we'll be called again, eventually
+            break;
+        bytesToRead = qBound<qint64>(1, bytesToRead, copyDevice->bytesAvailable());
+        QByteArray byteData;
+        byteData.resize(bytesToRead);
+        qint64 bytesActuallyRead = copyDevice->read(byteData.data(), byteData.size());
+        if (bytesActuallyRead == -1) {
+            byteData.clear();
+            backendNotify(NotifyCopyFinished);
+            break;
+        }
+        byteData.resize(bytesActuallyRead);
+        readBuffer.append(byteData);
+        if (!copyDevice->isSequential() && copyDevice->atEnd()) {
+            backendNotify(NotifyCopyFinished);
+            bytesDownloaded += bytesActuallyRead;
+            break;
+        }
+        bytesDownloaded += bytesActuallyRead;
+    }
+    if (bytesDownloaded == lastBytesDownloaded) {
+        // we didn't read anything
+        return;
+    }
     lastBytesDownloaded = bytesDownloaded;
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
+    pauseNotificationHandling();
     emit q->downloadProgress(bytesDownloaded,
                              totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
     emit q->readyRead();
+    resumeNotificationHandling();
+}
 …
     _q_copyReadyRead();
+}
+void QNetworkReplyImplPrivate::_q_bufferOutgoingDataFinished()
+{
+    Q_Q(QNetworkReplyImpl);
+    // make sure this is only called once, ever.
+    //_q_bufferOutgoingData may call it or the readChannelFinished emission
+    if (state != Buffering)
+        return;
+    // disconnect signals
+    QObject::disconnect(outgoingData, SIGNAL(readyRead()), q, SLOT(_q_bufferOutgoingData()));
+    QObject::disconnect(outgoingData, SIGNAL(readChannelFinished()), q, SLOT(_q_bufferOutgoingDataFinished()));
+    // finally, start the request
+    QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+}
+void QNetworkReplyImplPrivate::_q_bufferOutgoingData()
+{
+    Q_Q(QNetworkReplyImpl);
+    if (!outgoingDataBuffer) {
+        // first call, create our buffer
+        outgoingDataBuffer = new QRingBuffer();
+        QObject::connect(outgoingData, SIGNAL(readyRead()), q, SLOT(_q_bufferOutgoingData()));
+        QObject::connect(outgoingData, SIGNAL(readChannelFinished()), q, SLOT(_q_bufferOutgoingDataFinished()));
+    }
+    qint64 bytesBuffered = 0;
+    qint64 bytesToBuffer = 0;
+    // read data into our buffer
+    forever {
+        bytesToBuffer = outgoingData->bytesAvailable();
+        // unknown? just try 2 kB, this also ensures we always try to read the EOF
+        if (bytesToBuffer <= 0)
+            bytesToBuffer = 2*1024;
+        char *dst = outgoingDataBuffer->reserve(bytesToBuffer);
+        bytesBuffered = outgoingData->read(dst, bytesToBuffer);
+        if (bytesBuffered == -1) {
+            // EOF has been reached.
+            outgoingDataBuffer->chop(bytesToBuffer);
+            _q_bufferOutgoingDataFinished();
+            break;
+        } else if (bytesBuffered == 0) {
+            // nothing read right now, just wait until we get called again
+            outgoingDataBuffer->chop(bytesToBuffer);
+            break;
+        } else {
+            // don't break, try to read() again
+            outgoingDataBuffer->chop(bytesToBuffer - bytesBuffered);
+        }
+    }
+}
 void QNetworkReplyImplPrivate::setup(QNetworkAccessManager::Operation op, const QNetworkRequest &req,
 …
     operation = op;
+    if (outgoingData) {
+        q->connect(outgoingData, SIGNAL(readyRead()), SLOT(_q_sourceReadyRead()));
+        q->connect(outgoingData, SIGNAL(readChannelFinished()), SLOT(_q_sourceReadChannelFinished()));
+    if (outgoingData && backend) {
+        // there is data to be uploaded, e.g. HTTP POST.
+        if (!backend->needsResetableUploadData() || !outgoingData->isSequential()) {
+            // backend does not need upload buffering or
+            // fixed size non-sequential
+            // just start the operation
+            QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+        } else {
+            bool bufferingDisallowed =
+                    req.attribute(QNetworkRequest::DoNotBufferUploadDataAttribute,
+                                             false).toBool();
+            if (bufferingDisallowed) {
+                // if a valid content-length header for the request was supplied, we can disable buffering
+                // if not, we will buffer anyway
+                if (req.header(QNetworkRequest::ContentLengthHeader).isValid()) {
+                    QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+                } else {
+                    state = Buffering;
+                    QMetaObject::invokeMethod(q, "_q_bufferOutgoingData", Qt::QueuedConnection);
+                }
+            } else {
+                // _q_startOperation will be called when the buffering has finished.
+                state = Buffering;
+                QMetaObject::invokeMethod(q, "_q_bufferOutgoingData", Qt::QueuedConnection);
+            }
+        }
+    } else {
+        // No outgoing data (e.g. HTTP GET request)
+        // or no backend
+        // if no backend, _q_startOperation will handle the error of this
+        QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+    }
     q->QIODevice::open(QIODevice::ReadOnly);
-    QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+}
-void QNetworkReplyImplPrivate::setNetworkCache(QAbstractNetworkCache *nc)
+{
-    networkCache = nc;
+}
 …
 void QNetworkReplyImplPrivate::handleNotifications()
+{
+    if (notificationHandlingPaused)
+        return;
     NotificationQueue current = pendingNotifications;
     pendingNotifications.clear();
 …
         return;
     while (!current.isEmpty()) {
+    while (state == Working && !current.isEmpty()) {
         InternalNotifications notification = current.dequeue();
         switch (notification) {
 …
             break;
-        case NotifyUpstreamReadyRead:
-            backend->upstreamReadyRead();
-            break;
         case NotifyCloseDownstreamChannel:
             backend->closeDownstreamChannel();
-            break;
-        case NotifyCloseUpstreamChannel:
-            backend->closeUpstreamChannel();
             break;
 …
+}
+// Do not handle the notifications while we are emitting downloadProgress
+// or readyRead
+void QNetworkReplyImplPrivate::pauseNotificationHandling()
+{
+    notificationHandlingPaused = true;
+}
+// Resume notification handling
+void QNetworkReplyImplPrivate::resumeNotificationHandling()
+{
+    Q_Q(QNetworkReplyImpl);
+    notificationHandlingPaused = false;
+    if (pendingNotifications.size() >= 1)
+        QCoreApplication::postEvent(q, new QEvent(QEvent::NetworkReplyUpdated));
+}
+QAbstractNetworkCache *QNetworkReplyImplPrivate::networkCache() const
+{
+    if (!backend)
+        return 0;
+    return backend->networkCache();
+}
 void QNetworkReplyImplPrivate::createCache()
+{
     // check if we can save and if we're allowed to
+    if (!networkCache || !request.attribute(QNetworkRequest::CacheSaveControlAttribute, true).toBool())
+    if (!networkCache()
+        || !request.attribute(QNetworkRequest::CacheSaveControlAttribute, true).toBool()
+        || request.attribute(QNetworkRequest::CacheLoadControlAttribute,
+                             QNetworkRequest::PreferNetwork).toInt()
+            == QNetworkRequest::AlwaysNetwork)
         return;
     cacheEnabled = true;
 …
 bool QNetworkReplyImplPrivate::isCachingEnabled() const
+{
     return (cacheEnabled && networkCache != 0);
+    return (cacheEnabled && networkCache() != 0);
+}
 …
                "backend %s probably needs to be fixed",
                backend->metaObject()->className());
         networkCache->remove(url);
+        networkCache()->remove(url);
         cacheSaveDevice = 0;
         cacheEnabled = false;
 …
+{
     if (cacheEnabled && errorCode != QNetworkReplyImpl::NoError) {
         networkCache->remove(url);
+        networkCache()->remove(url);
     } else if (cacheEnabled && cacheSaveDevice) {
         networkCache->insert(cacheSaveDevice);
+        networkCache()->insert(cacheSaveDevice);
+    }
     cacheSaveDevice = 0;
 …
+}
+void QNetworkReplyImplPrivate::consume(qint64 count)
+{
+    Q_Q(QNetworkReplyImpl);
+    if (count <= 0) {
+        qWarning("QNetworkConnection: backend signalled that it consumed %ld bytes", long(count));
+        return;
+    }
+    if (outgoingData)
+        // schedule another read from the source
+        QMetaObject::invokeMethod(q_func(), "_q_sourceReadyRead", Qt::QueuedConnection);
+    writeBuffer.skip(count);
+    if (bytesUploaded == -1)
+        bytesUploaded = count;
+    else
+        bytesUploaded += count;
+    QVariant totalSize = request.header(QNetworkRequest::ContentLengthHeader);
+    emit q->uploadProgress(bytesUploaded,
+                           totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
+}
+void QNetworkReplyImplPrivate::emitUploadProgress(qint64 bytesSent, qint64 bytesTotal)
+{
+    Q_Q(QNetworkReplyImpl);
+    bytesUploaded = bytesSent;
+    pauseNotificationHandling();
+    emit q->uploadProgress(bytesSent, bytesTotal);
+    resumeNotificationHandling();
+}
 qint64 QNetworkReplyImplPrivate::nextDownstreamBlockSize() const
 …
         return DesiredBufferSize;
+    return qMax<qint64>(0, readBufferMaxSize - readBuffer.size());
+}
+void QNetworkReplyImplPrivate::feed(const QByteArray &data)
+    return qMax<qint64>(0, readBufferMaxSize - readBuffer.byteAmount());
+}
+// we received downstream data and send this to the cache
+// and to our readBuffer (which in turn gets read by the user of QNetworkReply)
+void QNetworkReplyImplPrivate::appendDownstreamData(QByteDataBuffer &data)
+{
     Q_Q(QNetworkReplyImpl);
     if (!q->isOpen())
         return;
-    char *ptr = readBuffer.reserve(data.size());
-    memcpy(ptr, data.constData(), data.size());
     if (cacheEnabled && !cacheSaveDevice) {
 …
         metaData.setUrl(url);
         metaData = backend->fetchCacheMetaData(metaData);
+        cacheSaveDevice = networkCache->prepare(metaData);
+        // save the redirect request also in the cache
+        QVariant redirectionTarget = q->attribute(QNetworkRequest::RedirectionTargetAttribute);
+        if (redirectionTarget.isValid()) {
+            QNetworkCacheMetaData::AttributesMap attributes = metaData.attributes();
+            attributes.insert(QNetworkRequest::RedirectionTargetAttribute, redirectionTarget);
+            metaData.setAttributes(attributes);
+        }
+        cacheSaveDevice = networkCache()->prepare(metaData);
         if (!cacheSaveDevice || (cacheSaveDevice && !cacheSaveDevice->isOpen())) {
             if (cacheSaveDevice && !cacheSaveDevice->isOpen())
                 qCritical("QNetworkReplyImpl: network cache returned a device that is not open -- "
                       "class %s probably needs to be fixed",
                       networkCache->metaObject()->className());
             networkCache->remove(url);
+                      networkCache()->metaObject()->className());
+            networkCache()->remove(url);
             cacheSaveDevice = 0;
             cacheEnabled = false;
 …
+    }
+    if (cacheSaveDevice)
+        cacheSaveDevice->write(data);
+    bytesDownloaded += data.size();
+    qint64 bytesWritten = 0;
+    for (int i = 0; i < data.bufferCount(); i++) {
+        QByteArray item = data[i];
+        if (cacheSaveDevice)
+            cacheSaveDevice->write(item.constData(), item.size());
+        readBuffer.append(item);
+        bytesWritten += item.size();
+    }
+    data.clear();
+    bytesDownloaded += bytesWritten;
     lastBytesDownloaded = bytesDownloaded;
 …
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
+    pauseNotificationHandling();
     emit q->downloadProgress(bytesDownloaded,
                              totalSize.isNull() ? Q_INT64_C(-1) : totalSize.toLongLong());
+    // important: At the point of this readyRead(), the data parameter list must be empty,
+    // else implicit sharing will trigger memcpy when the user is reading data!
     emit q->readyRead();
     // hopefully we haven't been deleted here
     if (!qq.isNull()) {
+        resumeNotificationHandling();
         // do we still have room in the buffer?
         if (nextDownstreamBlockSize() > 0)
 …
+}
+void QNetworkReplyImplPrivate::feed(QIODevice *data)
+{
+    Q_Q(QNetworkReplyImpl);
+    Q_ASSERT(q->isOpen());
+// this is used when it was fetched from the cache, right?
+void QNetworkReplyImplPrivate::appendDownstreamData(QIODevice *data)
+{
+    Q_Q(QNetworkReplyImpl);
+    if (!q->isOpen())
+        return;
     // read until EOF from data
 …
+{
     Q_Q(QNetworkReplyImpl);
     Q_ASSERT_X(state != Finished, "QNetworkReplyImpl",
                "Backend called finished/finishedWithError more than once");
+    if (state == Finished || state == Aborted)
+        return;
     state = Finished;
     pendingNotifications.clear();
+    pauseNotificationHandling();
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
     if (bytesDownloaded != lastBytesDownloaded || totalSize.isNull())
+    if (totalSize.isNull() || totalSize == -1) {
         emit q->downloadProgress(bytesDownloaded, bytesDownloaded);
+    if (bytesUploaded == -1 && outgoingData)
+    }
+    if (bytesUploaded == -1 && (outgoingData || outgoingDataBuffer))
         emit q->uploadProgress(0, 0);
+    resumeNotificationHandling();
     completeCacheSave();
 …
     // which would delete the backend too...
     // maybe we should protect the backend
+    pauseNotificationHandling();
     emit q->readChannelFinished();
     emit q->finished();
+    resumeNotificationHandling();
+}
 …
+}
+bool QNetworkReplyImplPrivate::isFinished() const
+{
+    return (state == Finished || state == Aborted);
+}
 QNetworkReplyImpl::QNetworkReplyImpl(QObject *parent)
     : QNetworkReply(*new QNetworkReplyImplPrivate, parent)
 …
     Q_D(QNetworkReplyImpl);
     if (d->isCachingEnabled())
+        d->networkCache->remove(url());
+        d->networkCache()->remove(url());
+    if (d->outgoingDataBuffer)
+        delete d->outgoingDataBuffer;
+}
 …
+{
     Q_D(QNetworkReplyImpl);
     if (d->state == QNetworkReplyImplPrivate::Aborted)
+    if (d->state == QNetworkReplyImplPrivate::Finished || d->state == QNetworkReplyImplPrivate::Aborted)
         return;
     // stop both upload and download
-    if (d->backend) {
-        d->backend->deleteLater();
-        d->backend = 0;
+    }
     if (d->outgoingData)
         disconnect(d->outgoingData, 0, this, 0);
 …
+    }
     d->state = QNetworkReplyImplPrivate::Aborted;
+    // finished may access the backend
+    if (d->backend) {
+        d->backend->deleteLater();
+        d->backend = 0;
+    }
+}
 …
 qint64 QNetworkReplyImpl::bytesAvailable() const
+{
     return QNetworkReply::bytesAvailable() + d_func()->readBuffer.size();
+    return QNetworkReply::bytesAvailable() + d_func()->readBuffer.byteAmount();
+}
 …
     Q_D(QNetworkReplyImpl);
     if (size > d->readBufferMaxSize &&
         size == d->readBuffer.size())
+        size > d->readBuffer.byteAmount())
         d->backendNotify(QNetworkReplyImplPrivate::NotifyDownstreamReadyWrite);
 …
+}
+void QNetworkReplyImpl::ignoreSslErrorsImplementation(const QList<QSslError> &errors)
+{
+    Q_D(QNetworkReplyImpl);
+    if (d->backend)
+        d->backend->ignoreSslErrors(errors);
+}
 #endif  // QT_NO_OPENSSL
 …
+    }
     maxlen = qMin<qint64>(maxlen, d->readBuffer.size());
+    maxlen = qMin<qint64>(maxlen, d->readBuffer.byteAmount());
     return d->readBuffer.read(data, maxlen);
+}

trunk/src/network/access/qnetworkreplyimpl_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "QtCore/qmap.h"
 #include "QtCore/qqueue.h"
+#include "QtCore/qbuffer.h"
 #include "private/qringbuffer_p.h"
+#include "private/qbytedata_p.h"
 QT_BEGIN_NAMESPACE
 …
     Q_INVOKABLE void setSslConfigurationImplementation(const QSslConfiguration &configuration);
     virtual void ignoreSslErrors();
+    Q_INVOKABLE virtual void ignoreSslErrorsImplementation(const QList<QSslError> &errors);
 #endif
     Q_DECLARE_PRIVATE(QNetworkReplyImpl)
     Q_PRIVATE_SLOT(d_func(), void _q_startOperation())
-    Q_PRIVATE_SLOT(d_func(), void _q_sourceReadyRead())
-    Q_PRIVATE_SLOT(d_func(), void _q_sourceReadChannelFinished())
     Q_PRIVATE_SLOT(d_func(), void _q_copyReadyRead())
     Q_PRIVATE_SLOT(d_func(), void _q_copyReadChannelFinished())
+    Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingData())
+    Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingDataFinished())
 };
 …
     enum InternalNotifications {
         NotifyDownstreamReadyWrite,
-        NotifyUpstreamReadyRead,
         NotifyCloseDownstreamChannel,
-        NotifyCloseUpstreamChannel,
         NotifyCopyFinished
     };
 …
     enum State {
         Idle,
         Opening,
+        Buffering,
         Working,
         Finished,
 …
     void _q_copyReadyRead();
     void _q_copyReadChannelFinished();
+    void _q_bufferOutgoingData();
+    void _q_bufferOutgoingDataFinished();
     void setup(QNetworkAccessManager::Operation op, const QNetworkRequest &request,
                QIODevice *outgoingData);
+    void setNetworkCache(QAbstractNetworkCache *networkCache);
+    void pauseNotificationHandling();
+    void resumeNotificationHandling();
     void backendNotify(InternalNotifications notification);
     void handleNotifications();
 …
     bool isCachingEnabled() const;
     void consume(qint64 count);
+    void emitUploadProgress(qint64 bytesSent, qint64 bytesTotal);
     qint64 nextDownstreamBlockSize() const;
     void feed(const QByteArray &data);
     void feed(QIODevice *data);
+    void appendDownstreamData(QByteDataBuffer &data);
+    void appendDownstreamData(QIODevice *data);
     void finished();
     void error(QNetworkReply::NetworkError code, const QString &errorString);
 …
     void sslErrors(const QList<QSslError> &errors);
+    bool isFinished() const;
     QNetworkAccessBackend *backend;
     QIODevice *outgoingData;
+    QRingBuffer *outgoingDataBuffer;
     QIODevice *copyDevice;
     QAbstractNetworkCache *networkCache;
+    QAbstractNetworkCache *networkCache() const;
     bool cacheEnabled;
 …
     NotificationQueue pendingNotifications;
+    bool notificationHandlingPaused;
     QUrl urlForLastAuthentication;
 #ifndef QT_NO_NETWORKPROXY
 …
 #endif
+    QRingBuffer readBuffer;
+    QRingBuffer writeBuffer;
+    QByteDataBuffer readBuffer;
     qint64 bytesDownloaded;
     qint64 lastBytesDownloaded;

trunk/src/network/access/qnetworkrequest.cpp

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "QtCore/qdatetime.h"
+#include <ctype.h>
+#ifndef QT_NO_DATESTRING
+# include <stdio.h>
+#endif
 QT_BEGIN_NAMESPACE
 /*!
     \class QNetworkRequest
     \brief The QNetworkRequest class holds one request to be sent with the Network Access API.
+    \brief The QNetworkRequest class holds a request to be sent with QNetworkAccessManager.
     \since 4.4
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
         be automatically cached. If true, data may be cached, provided
         it is cacheable (what is cacheable depends on the protocol
+        being used). Note that the default QNetworkAccessManager
+        implementation does not support caching, so it will ignore
+        this attribute.
+        being used).
     \value SourceIsFromCacheAttribute
 …
         Indicates whether the data was obtained from cache
         or not.
+    \value DoNotBufferUploadDataAttribute
+        Requests only, type: QVariant::Bool (default: false)
+        Indicates whether the QNetworkAccessManager code is
+        allowed to buffer the upload data, e.g. when doing a HTTP POST.
+        When using this flag with sequential upload data, the ContentLengthHeader
+        header must be set.
+     \value HttpPipeliningAllowedAttribute
+        Requests only, type: QVariant::Bool (default: false)
+        Indicates whether the QNetworkAccessManager code is
+        allowed to use HTTP pipelining with this request.
+     \value HttpPipeliningWasUsedAttribute
+        Replies only, type: QVariant::Bool
+        Indicates whether the HTTP pipelining was used for receiving
+        this reply.
     \value User
 …
 #ifndef QT_NO_OPENSSL
+        sslConfiguration = 0;
         if (other.sslConfiguration)
             sslConfiguration = new QSslConfiguration(*other.sslConfiguration);
-        else
-            sslConfiguration = 0;
 #endif
+    }
 …
+}
 #endif
+/*!
+    \since 4.6
+    Allows setting a reference to the \a object initiating
+    the request.
+    For example QtWebKit sets the originating object to the
+    QWebFrame that initiated the request.
+    \sa originatingObject()
+*/
+void QNetworkRequest::setOriginatingObject(QObject *object)
+{
+    d->originatingObject = object;
+}
+/*!
+    \since 4.6
+    Returns a reference to the object that initiated this
+    network request; returns 0 if not set or the object has
+    been destroyed.
+    \sa setOriginatingObject()
+*/
+QObject *QNetworkRequest::originatingObject() const
+{
+    return d->originatingObject.data();
+}
 static QByteArray headerName(QNetworkRequest::KnownHeaders header)
 …
     // headerName is not empty here
+    QByteArray lower = headerName.toLower();
+    switch (lower.at(0)) {
+    switch (tolower(headerName.at(0))) {
     case 'c':
         if (lower == "content-type")
+        if (qstricmp(headerName.constData(), "content-type") == 0)
             return QNetworkRequest::ContentTypeHeader;
         else if (lower == "content-length")
+        else if (qstricmp(headerName.constData(), "content-length") == 0)
             return QNetworkRequest::ContentLengthHeader;
         else if (lower == "cookie")
+        else if (qstricmp(headerName.constData(), "cookie") == 0)
             return QNetworkRequest::CookieHeader;
         break;
     case 'l':
         if (lower == "location")
+        if (qstricmp(headerName.constData(), "location") == 0)
             return QNetworkRequest::LocationHeader;
         else if (lower == "last-modified")
+        else if (qstricmp(headerName.constData(), "last-modified") == 0)
             return QNetworkRequest::LastModifiedHeader;
         break;
     case 's':
         if (lower == "set-cookie")
+        if (qstricmp(headerName.constData(), "set-cookie") == 0)
             return QNetworkRequest::SetCookieHeader;
         break;
 …
 QNetworkHeadersPrivate::findRawHeader(const QByteArray &key) const
+{
-    QByteArray lowerKey = key.toLower();
     RawHeadersList::ConstIterator it = rawHeaders.constBegin();
     RawHeadersList::ConstIterator end = rawHeaders.constEnd();
     for ( ; it != end; ++it)
         if (it->first.toLower() == lowerKey)
+        if (qstricmp(it->first.constData(), key.constData()) == 0)
             return it;
 …
 void QNetworkHeadersPrivate::setRawHeaderInternal(const QByteArray &key, const QByteArray &value)
+{
-    QByteArray lowerKey = key.toLower();
     RawHeadersList::Iterator it = rawHeaders.begin();
     while (it != rawHeaders.end()) {
         if (it->first.toLower() == lowerKey)
+        if (qstricmp(it->first.constData(), key.constData()) == 0)
             it = rawHeaders.erase(it);
         else
 …
+}
+// Fast month string to int conversion. This code
+// assumes that the Month name is correct and that
+// the string is at least three chars long.
+static int name_to_month(const char* month_str)
+{
+    switch (month_str[0]) {
+    case 'J':
+        switch (month_str[1]) {
+        case 'a':
+            return 1;
+            break;
+        case 'u':
+            switch (month_str[2] ) {
+            case 'n':
+                return 6;
+                break;
+            case 'l':
+                return 7;
+                break;
+            }
+        }
+        break;
+    case 'F':
+        return 2;
+        break;
+    case 'M':
+        switch (month_str[2] ) {
+        case 'r':
+            return 3;
+            break;
+        case 'y':
+            return 5;
+            break;
+        }
+        break;
+    case 'A':
+        switch (month_str[1]) {
+        case 'p':
+            return 4;
+            break;
+        case 'u':
+            return 8;
+            break;
+        }
+        break;
+    case 'O':
+        return 10;
+        break;
+    case 'S':
+        return 9;
+        break;
+    case 'N':
+        return 11;
+        break;
+    case 'D':
+        return 12;
+        break;
+    }
+    return 0;
+}
 QDateTime QNetworkHeadersPrivate::fromHttpDate(const QByteArray &value)
+{
 …
         dt = QDateTime::fromString(QString::fromLatin1(value), Qt::TextDate);
     } else {
+        // eat the weekday, the comma and the space following it
+        QString sansWeekday = QString::fromLatin1(value.constData() + pos + 2);
+        QLocale c = QLocale::c();
+        if (pos == 3)
+            // must be RFC 1123 date
+            dt = c.toDateTime(sansWeekday, QLatin1String("dd MMM yyyy hh:mm:ss 'GMT"));
+        else
+        // Use sscanf over QLocal/QDateTimeParser for speed reasons. See the
+        // QtWebKit performance benchmarks to get an idea.
+        if (pos == 3) {
+            char month_name[4];
+            int day, year, hour, minute, second;
+            if (sscanf(value.constData(), "%*3s, %d %3s %d %d:%d:%d 'GMT'", &day, month_name, &year, &hour, &minute, &second) == 6)
+                dt = QDateTime(QDate(year, name_to_month(month_name), day), QTime(hour, minute, second));
+        } else {
+            QLocale c = QLocale::c();
+            // eat the weekday, the comma and the space following it
+            QString sansWeekday = QString::fromLatin1(value.constData() + pos + 2);
             // must be RFC 850 date
             dt = c.toDateTime(sansWeekday, QLatin1String("dd-MMM-yy hh:mm:ss 'GMT'"));
+        }
+    }
 #endif // QT_NO_DATESTRING

trunk/src/network/access/qnetworkrequest.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
         CacheSaveControlAttribute,
         SourceIsFromCacheAttribute,
+        DoNotBufferUploadDataAttribute,
+        HttpPipeliningAllowedAttribute,
+        HttpPipeliningWasUsedAttribute,
         User = 1000,
 …
 #endif
+    void setOriginatingObject(QObject *object);
+    QObject *originatingObject() const;
 private:
     QSharedDataPointer<QNetworkRequestPrivate> d;

trunk/src/network/access/qnetworkrequest_p.h

-              r2
+              r561
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (qt-info@nokia.com)
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
 **
 ** This file is part of the QtNetwork module of the Qt Toolkit.
 …
 ** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+** 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.
 **
 ** GNU General Public License Usage
 …
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
 ** If you are unsure which license is appropriate for your use, please
 ** contact the sales department at qt-sales@nokia.com.
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
 ** $QT_END_LICENSE$
 **
 …
 #include "QtCore/qhash.h"
 #include "QtCore/qshareddata.h"
+#include "QtCore/qsharedpointer.h"
 QT_BEGIN_NAMESPACE
 …
     CookedHeadersMap cookedHeaders;
     AttributesMap attributes;
+    QWeakPointer<QObject> originatingObject;
     RawHeadersList::ConstIterator findRawHeader(const QByteArray &key) const;

/branches/vendor/nokia/qt/4.6.1	merged	eligible
/branches/vendor/nokia/qt/current	merged	eligible
/branches/vendor/trolltech/qt/current	3-149

Context Navigation

Legend:

Download in other formats: