Changeset 561 for trunk/src/network

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;

trunk/src/network/kernel/kernel.pri

-              r160
+              r561
            kernel/qnetworkinterface.cpp
+unix:SOURCES += kernel/qhostinfo_unix.cpp kernel/qnetworkinterface_unix.cpp
+symbian: SOURCES += kernel/qhostinfo_unix.cpp kernel/qnetworkinterface_symbian.cpp
+unix:!symbian:SOURCES += kernel/qhostinfo_unix.cpp kernel/qnetworkinterface_unix.cpp
 win32:SOURCES += kernel/qhostinfo_win.cpp kernel/qnetworkinterface_win.cpp
 os2:SOURCES += kernel/qhostinfo_os2.cpp kernel/qnetworkinterface_os2.cpp
 mac:LIBS+= -framework SystemConfiguration
+mac:LIBS_PRIVATE += -framework SystemConfiguration -framework CoreFoundation
 mac:SOURCES += kernel/qnetworkproxy_mac.cpp
 else:win32:SOURCES += kernel/qnetworkproxy_win.cpp

trunk/src/network/kernel/qauthenticator.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 <qcryptographichash.h>
 #include <qhttp.h>
+#include <qiodevice.h>
 #include <qdatastream.h>
 #include <qendian.h>
 …
   \reentrant
   \ingroup io
+  \ingroup network
   \inmodule QtNetwork
   The QAuthenticator class is usually used in the
   \l{QHttp::}{authenticationRequired()} and
   \l{QHttp::}{proxyAuthenticationRequired()} signals of QHttp and
+  \l{QNetworkAccessManager::}{authenticationRequired()} and
+  \l{QNetworkAccessManager::}{proxyAuthenticationRequired()} signals of QNetworkAccessManager and
   QAbstractSocket. The class provides a way to pass back the required
   authentication information to the socket when accessing services that
   require authentication.
+  QAuthenticator supports the following authentication methods:
+  \list
+    \o Basic
+    \o NTLM version 1
+    \o Digest-MD5
+  \endlist
+  Note that, in particular, NTLM version 2 is not supported.
   \sa QSslSocket
 …
     if (!opaque.isEmpty())
         credentials += "opaque=\"" + opaque + "\", ";
     credentials += "response=\"" + response + "\"";
+    credentials += "response=\"" + response + '\"';
     if (!options.value("algorithm").isEmpty())
         credentials += ", algorithm=" + options.value("algorithm");
 …
         credentials += ", qop=" + qop + ", ";
         credentials += "nc=" + nonceCountString + ", ";
         credentials += "cnonce=\"" + cnonce + "\"";
+        credentials += "cnonce=\"" + cnonce + '\"';
+    }

trunk/src/network/kernel/qauthenticator.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/kernel/qauthenticator_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/kernel/qhostaddress.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$
 **
 …
     \class QHostAddress
     \brief The QHostAddress class provides an IP address.
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
     using isIPv4Address() or isIPv6Address(), and retrieved with
     toIPv4Address(), toIPv6Address(), or toString().
+    \note Please note that QHostAddress does not do DNS lookups.
+    QHostInfo is needed for that.
     The class also supports common predefined addresses: \l Null, \l
 …
 */
 QHostAddress::QHostAddress(const QHostAddress &address)
     : d(new QHostAddressPrivate(*address.d))
+    : d(new QHostAddressPrivate(*address.d.data()))
+{
+}
 …
 QHostAddress::~QHostAddress()
+{
-    delete d;
+}
 …
 QHostAddress &QHostAddress::operator=(const QHostAddress &address)
+{
     *d = *address.d;
+    *d.data() = *address.d.data();
     return *this;
+}
 …
 QDebug operator<<(QDebug d, const QHostAddress &address)
+{
     d.maybeSpace() << "QHostAddress(" << address.toString() << ")";
+    d.maybeSpace() << "QHostAddress(" << address.toString() << ')';
     return d.space();
+}

trunk/src/network/kernel/qhostaddress.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/qpair.h>
 #include <QtCore/qstring.h>
+#include <QtCore/qscopedpointer.h>
 #include <QtNetwork/qabstractsocket.h>
 …
 protected:
     QHostAddressPrivate *d;
+    QScopedPointer<QHostAddressPrivate> d;
 };

trunk/src/network/kernel/qhostaddress_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/kernel/qhostinfo.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 "qhostinfo_p.h"
+#include "QtCore/qscopedpointer.h"
 #include <qabstracteventdispatcher.h>
 #include <private/qunicodetables_p.h>
 …
 QT_BEGIN_NAMESPACE
+Q_GLOBAL_STATIC(QHostInfoAgent, theAgent)
+void QHostInfoAgent::staticCleanup()
+{
+    theAgent()->cleanup();
+}
+#ifndef QT_NO_THREAD
+Q_GLOBAL_STATIC(QHostInfoLookupManager, theHostInfoLookupManager)
+#endif
 //#define QHOSTINFO_DEBUG
 …
     \reentrant
     \inmodule QtNetwork
     \ingroup io
+    \ingroup network
     QHostInfo uses the lookup mechanisms provided by the operating
 …
     \snippet doc/src/snippets/code/src_network_kernel_qhostinfo.cpp 4
+    \note There is no guarantee on the order the signals will be emitted
+    if you start multiple requests with lookupHost().
     \sa abortHostLookup(), addresses(), error(), fromName()
 …
     qRegisterMetaType<QHostInfo>("QHostInfo");
+#if defined(Q_OS_WIN32) || defined(Q_OS_WINCE)
+    QWindowsSockInit bust; // makes sure WSAStartup was callled
+    int id = theIdCounter.fetchAndAddRelaxed(1); // generate unique ID
+    if (name.isEmpty()) {
+        QHostInfo hostInfo(id);
+        hostInfo.setError(QHostInfo::HostNotFound);
+        hostInfo.setErrorString(QObject::tr("No host name given"));
+        QScopedPointer<QHostInfoResult> result(new QHostInfoResult);
+        QObject::connect(result.data(), SIGNAL(resultsReady(QHostInfo)),
+                         receiver, member, Qt::QueuedConnection);
+        result.data()->emitResultsReady(hostInfo);
+        return id;
+    }
+#ifdef QT_NO_THREAD
+    QHostInfo hostInfo = QHostInfoAgent::fromName(name);
+    hostInfo.setLookupId(id);
+    QScopedPointer<QHostInfoResult> result(new QHostInfoResult);
+    QObject::connect(result.data(), SIGNAL(resultsReady(QHostInfo)),
+                     receiver, member, Qt::QueuedConnection);
+    result.data()->emitResultsReady(hostInfo);
+#else
+    QHostInfoRunnable* runnable = new QHostInfoRunnable(name, id);
+    QObject::connect(&runnable->resultEmitter, SIGNAL(resultsReady(QHostInfo)), receiver, member, Qt::QueuedConnection);
+    theHostInfoLookupManager()->scheduleLookup(runnable);
 #endif
+    // Support for IDNA
+    QString lookup = QString::fromLatin1(QUrl::toAce(name));
+    QHostInfoResult *result = new QHostInfoResult;
+    result->autoDelete = false;
+    QObject::connect(result, SIGNAL(resultsReady(QHostInfo)),
+                     receiver, member);
+    int id = result->lookupId = theIdCounter.fetchAndAddRelaxed(1);
+    if (lookup.isEmpty()) {
+        QHostInfo info(id);
+        info.setError(QHostInfo::HostNotFound);
+        info.setErrorString(QObject::tr("No host name given"));
+        QMetaObject::invokeMethod(result, "emitResultsReady", Qt::QueuedConnection,
+                                  Q_ARG(QHostInfo, info));
+        result->autoDelete = true;
+        return id;
+    }
+    QHostInfoAgent *agent = theAgent();
+    agent->addHostName(lookup, result);
+#if !defined QT_NO_THREAD
+    if (!agent->isRunning())
+        agent->start();
+    return id;
+}
+/*!
+    Aborts the host lookup with the ID \a id, as returned by lookupHost().
+    \sa lookupHost(), lookupId()
+*/
+void QHostInfo::abortHostLookup(int id)
+{
+#ifndef QT_NO_THREAD
+    theHostInfoLookupManager()->abortLookup(id);
 #else
+//    if (!agent->isRunning())
+        agent->run();
+//    else
+//      agent->wakeOne();
+    // we cannot abort if it was non threaded.. the result signal has already been posted
+    Q_UNUSED(id);
 #endif
-    return id;
+}
-/*!
-    Aborts the host lookup with the ID \a id, as returned by lookupHost().
-    \sa lookupHost(), lookupId()
-*/
-void QHostInfo::abortHostLookup(int id)
+{
-    QHostInfoAgent *agent = theAgent();
-    agent->abortLookup(id);
+}
 …
 #endif
+    if (!name.isEmpty())
+        return QHostInfoAgent::fromName(QLatin1String(QUrl::toAce(name)));
+    QHostInfo retval;
+    retval.d->err = HostNotFound;
+    retval.d->errorStr = QObject::tr("No host name given");
+    return retval;
+}
+/*!
+    \internal
+    Pops a query off the queries list, performs a blocking call to
+    QHostInfoAgent::lookupHost(), and emits the resultsReady()
+    signal. This process repeats until the queries list is empty.
+*/
+void QHostInfoAgent::run()
+{
+#ifndef QT_NO_THREAD
+    // Dont' allow thread termination during event delivery, but allow it
+    // during the actual blocking host lookup stage.
+    setTerminationEnabled(false);
+    forever
+#endif
+    {
+        QHostInfoQuery *query;
+        {
+#ifndef QT_NO_THREAD
+            // the queries list is shared between threads. lock all
+            // access to it.
+            QMutexLocker locker(&mutex);
+            if (!quit && queries.isEmpty())
+                cond.wait(&mutex);
+            if (quit) {
+                // Reset the quit variable in case QCoreApplication is
+                // destroyed and recreated.
+                quit = false;
+                break;
+            }
+            if (queries.isEmpty())
+                continue;
+#else
+            if (queries.isEmpty())
+                return;
+#endif
+            query = queries.takeFirst();
+            pendingQueryId = query->object->lookupId;
+        }
+#if defined(QHOSTINFO_DEBUG)
+        qDebug("QHostInfoAgent::run(%p): looking up \"%s\"", this,
+               query->hostName.toLatin1().constData());
+#endif
+#ifndef QT_NO_THREAD
+        // Start query - allow termination at this point, but not outside. We
+        // don't want to all termination during event delivery, but we don't
+        // want the lookup to prevent the app from quitting (the agent
+        // destructor terminates the thread).
+        setTerminationEnabled(true);
+#endif
+        QHostInfo info = fromName(query->hostName);
+#ifndef QT_NO_THREAD
+        setTerminationEnabled(false);
+#endif
+        int id = query->object->lookupId;
+        info.setLookupId(id);
+        if (pendingQueryId == id)
+            query->object->emitResultsReady(info);
+        delete query;
+    }
+    return QHostInfoAgent::fromName(name);
+}
 …
 */
 QHostInfo::QHostInfo(const QHostInfo &other)
     : d(new QHostInfoPrivate(*other.d))
+    : d(new QHostInfoPrivate(*other.d.data()))
+{
+}
 …
 QHostInfo &QHostInfo::operator=(const QHostInfo &other)
+{
     *d = *other.d;
+    *d.data() = *other.d.data();
     return *this;
+}
 …
 QHostInfo::~QHostInfo()
+{
-    delete d;
+}
 …
 */
+#ifndef QT_NO_THREAD
+QHostInfoRunnable::QHostInfoRunnable(QString hn, int i) : toBeLookedUp(hn), id(i)
+{
+    setAutoDelete(true);
+}
+// the QHostInfoLookupManager will at some point call this via a QThreadPool
+void QHostInfoRunnable::run()
+{
+    QHostInfoLookupManager *manager = theHostInfoLookupManager();
+    // check aborted
+    if (manager->wasAborted(id)) {
+        manager->lookupFinished(this);
+        return;
+    }
+    // check cache
+    // FIXME
+    // if not in cache: OS lookup
+    QHostInfo hostInfo = QHostInfoAgent::fromName(toBeLookedUp);
+    // save to cache
+    // FIXME
+    // check aborted again
+    if (manager->wasAborted(id)) {
+        manager->lookupFinished(this);
+        return;
+    }
+    // signal emission
+    hostInfo.setLookupId(id);
+    resultEmitter.emitResultsReady(hostInfo);
+    manager->lookupFinished(this);
+    // thread goes back to QThreadPool
+}
+QHostInfoLookupManager::QHostInfoLookupManager() : mutex(QMutex::Recursive), wasDeleted(false)
+{
+    moveToThread(QCoreApplicationPrivate::mainThread());
+    threadPool.setMaxThreadCount(5); // do 5 DNS lookups in parallel
+}
+QHostInfoLookupManager::~QHostInfoLookupManager()
+{
+    wasDeleted = true;
+}
+void QHostInfoLookupManager::work()
+{
+    if (wasDeleted)
+        return;
+    // goals of this function:
+    //  - launch new lookups via the thread pool
+    //  - make sure only one lookup per host/IP is in progress
+    QMutexLocker locker(&mutex);
+    if (!finishedLookups.isEmpty()) {
+        // remove ID from aborted if it is in there
+        for (int i = 0; i < finishedLookups.length(); i++) {
+           abortedLookups.removeAll(finishedLookups.at(i)->id);
+        }
+        finishedLookups.clear();
+    }
+    if (!postponedLookups.isEmpty()) {
+        // try to start the postponed ones
+        QMutableListIterator<QHostInfoRunnable*> iterator(postponedLookups);
+        while (iterator.hasNext()) {
+            QHostInfoRunnable* postponed = iterator.next();
+            // check if none of the postponed hostnames is currently running
+            bool alreadyRunning = false;
+            for (int i = 0; i < currentLookups.length(); i++) {
+                if (currentLookups.at(i)->toBeLookedUp == postponed->toBeLookedUp) {
+                    alreadyRunning = true;
+                    break;
+                }
+            }
+            if (!alreadyRunning) {
+                iterator.remove();
+                scheduledLookups.prepend(postponed); // prepend! we want to finish it ASAP
+            }
+        }
+    }
+    if (!scheduledLookups.isEmpty()) {
+        // try to start the new ones
+        QMutableListIterator<QHostInfoRunnable*> iterator(scheduledLookups);
+        while (iterator.hasNext()) {
+            QHostInfoRunnable *scheduled = iterator.next();
+            // check if a lookup for this host is already running, then postpone
+            for (int i = 0; i < currentLookups.size(); i++) {
+                if (currentLookups.at(i)->toBeLookedUp == scheduled->toBeLookedUp) {
+                    iterator.remove();
+                    postponedLookups.append(scheduled);
+                    scheduled = 0;
+                    break;
+                }
+            }
+            if (scheduled && threadPool.tryStart(scheduled)) {
+                // runnable now running in new thread, track this in currentLookups
+                iterator.remove();
+                currentLookups.append(scheduled);
+            } else if (scheduled) {
+                // wanted to start, but could not because thread pool is busy
+                break;
+            } else {
+                // was postponed, continue iterating
+                continue;
+            }
+        };
+    }
+}
+// called by QHostInfo
+void QHostInfoLookupManager::scheduleLookup(QHostInfoRunnable *r)
+{
+    if (wasDeleted)
+        return;
+    QMutexLocker locker(&this->mutex);
+    scheduledLookups.enqueue(r);
+    work();
+}
+// called by QHostInfo
+void QHostInfoLookupManager::abortLookup(int id)
+{
+    if (wasDeleted)
+        return;
+    QMutexLocker locker(&this->mutex);
+    if (!abortedLookups.contains(id))
+        abortedLookups.append(id);
+}
+// called from QHostInfoRunnable
+bool QHostInfoLookupManager::wasAborted(int id)
+{
+    if (wasDeleted)
+        return true;
+    QMutexLocker locker(&this->mutex);
+    return abortedLookups.contains(id);
+}
+// called from QHostInfoRunnable
+void QHostInfoLookupManager::lookupFinished(QHostInfoRunnable *r)
+{
+    if (wasDeleted)
+        return;
+    QMutexLocker locker(&this->mutex);
+    currentLookups.removeOne(r);
+    finishedLookups.append(r);
+    work();
+}
+#endif // QT_NO_THREAD
 QT_END_NAMESPACE

trunk/src/network/kernel/qhostinfo.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/qlist.h>
+#include <QtCore/qscopedpointer.h>
 #include <QtNetwork/qhostaddress.h>
 …
 private:
     QHostInfoPrivate *d;
+    QScopedPointer<QHostInfoPrivate> d;
 };

trunk/src/network/kernel/qhostinfo_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$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of the QLibrary class.  This header file may change from
+// of the QHostInfo class.  This header file may change from
 // version to version without notice, or even be removed.
 //
 …
 #include "QtCore/qpointer.h"
 #if !defined QT_NO_THREAD
+#ifndef QT_NO_THREAD
 #include "QtCore/qthread.h"
+#    define QHostInfoAgentBase QThread
+#else
+#    define QHostInfoAgentBase QObject
+#include "QtCore/qthreadpool.h"
+#include "QtCore/qmutex.h"
+#include "QtCore/qrunnable.h"
+#include "QtCore/qlist.h"
+#include "QtCore/qqueue.h"
 #endif
 QT_BEGIN_NAMESPACE
-static const int QHOSTINFO_THREAD_WAIT = 250; // ms
 class QHostInfoResult : public QObject
 …
+    {
         emit resultsReady(info);
-        if (autoDelete)
-            delete this;
+    }
 Q_SIGNALS:
+    void resultsReady(const QHostInfo &info);
+public:
+    int lookupId;
+    bool autoDelete;
+    void resultsReady(const QHostInfo info);
 };
+struct QHostInfoQuery
+{
+    inline QHostInfoQuery() : object(0) {}
+    inline ~QHostInfoQuery() { delete object; }
+    inline QHostInfoQuery(const QString &name, QHostInfoResult *result)
+        : hostName(name), object(result) {}
+    QString hostName;
+    QHostInfoResult *object;
+};
+class QHostInfoAgent : public QHostInfoAgentBase
+// needs to be QObject because fromName calls tr()
+class QHostInfoAgent : public QObject
+{
     Q_OBJECT
 public:
-    inline QHostInfoAgent()
+    {
-        // There is a chance that there will be two instances of
-        // QHostInfoAgent if two threads try to get Q_GLOBAL_STATIC
-        // object at the same time. The second object will be deleted
-        // immediately before anyone uses it, but we need to be
-        // careful about what we do in the constructor.
-        static QBasicAtomicInt done = Q_BASIC_ATOMIC_INITIALIZER(0);
-        if (done.testAndSetRelaxed(0, 1))
-            qAddPostRoutine(staticCleanup);
-        moveToThread(QCoreApplicationPrivate::mainThread());
-        quit = false;
-        pendingQueryId = -1;
+    }
-    inline ~QHostInfoAgent()
-    { cleanup(); }
-    void run();
     static QHostInfo fromName(const QString &hostName);
-    inline void addHostName(const QString &name, QHostInfoResult *result)
+    {
-        QMutexLocker locker(&mutex);
-        queries << new QHostInfoQuery(name, result);
-        cond.wakeOne();
+    }
-    inline void abortLookup(int id)
+    {
-        QMutexLocker locker(&mutex);
-        for (int i = 0; i < queries.size(); ++i) {
-            QHostInfoResult *result = queries.at(i)->object;
-            if (result->lookupId == id) {
-                result->disconnect();
-                delete queries.takeAt(i);
-                return;
+            }
+        }
-        if (pendingQueryId == id)
-            pendingQueryId = -1;
+    }
-    static void staticCleanup();
-public Q_SLOTS:
-    inline void cleanup()
+    {
+        {
-            QMutexLocker locker(&mutex);
-            qDeleteAll(queries);
-            queries.clear();
-            quit = true;
-            cond.wakeOne();
+        }
-#ifndef QT_NO_THREAD
-        if (!wait(QHOSTINFO_THREAD_WAIT))
-            terminate();
-        wait();
-#endif
+    }
-private:
-    QList<QHostInfoQuery *> queries;
-    QMutex mutex;
-    QWaitCondition cond;
-    volatile bool quit;
-    int pendingQueryId;
 };
 …
     inline QHostInfoPrivate()
         : err(QHostInfo::NoError),
+          errorStr(QLatin1String(QT_TRANSLATE_NOOP("QHostInfo", "Unknown error")))
+          errorStr(QLatin1String(QT_TRANSLATE_NOOP("QHostInfo", "Unknown error"))),
+          lookupId(0)
+    {
+    }
 …
 };
+#ifndef QT_NO_THREAD
+// the following classes are used for the (normal) case: We use multiple threads to lookup DNS
+class QHostInfoRunnable : public QRunnable
+{
+public:
+    QHostInfoRunnable (QString hn, int i);
+    void run();
+    QString toBeLookedUp;
+    int id;
+    QHostInfoResult resultEmitter;
+};
+class QHostInfoLookupManager : public QObject
+{
+    Q_OBJECT
+public:
+    QHostInfoLookupManager();
+    ~QHostInfoLookupManager();
+    void work();
+    // called from QHostInfo
+    void scheduleLookup(QHostInfoRunnable *r);
+    void abortLookup(int id);
+    // called from QHostInfoRunnable
+    void lookupFinished(QHostInfoRunnable *r);
+    bool wasAborted(int id);
+protected:
+    QList<QHostInfoRunnable*> currentLookups; // in progress
+    QList<QHostInfoRunnable*> postponedLookups; // postponed because in progress for same host
+    QQueue<QHostInfoRunnable*> scheduledLookups; // not yet started
+    QList<QHostInfoRunnable*> finishedLookups; // recently finished
+    QList<int> abortedLookups; // ids of aborted lookups
+    QThreadPool threadPool;
+    QMutex mutex;
+    bool wasDeleted;
+};
+#endif
 QT_END_NAMESPACE

trunk/src/network/kernel/qhostinfo_unix.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 QHOSTINFO_DEBUG
-static const int RESOLVER_TIMEOUT = 2000;
 #include "qplatformdefs.h"
 …
 #include <qfile.h>
 #include <private/qmutexpool_p.h>
+extern "C" {
+#include <private/qnet_unix_p.h>
 #include <sys/types.h>
 #include <netdb.h>
 #include <arpa/inet.h>
+#include <resolv.h>
+}
+#if defined(Q_OS_VXWORKS)
+#  include <hostLib.h>
+#else
+#  include <resolv.h>
+#endif
 #if defined (QT_NO_GETADDRINFO)
 …
+{
     QHostInfo results;
-    results.setHostName(hostName);
 #if defined(QHOSTINFO_DEBUG)
 …
         // Reverse lookup
 // Reverse lookups using getnameinfo are broken on darwin, use gethostbyaddr instead.
 #if !defined (QT_NO_GETADDRINFO) && !defined (Q_OS_DARWIN)
+#if !defined (QT_NO_GETADDRINFO) && !defined (Q_OS_DARWIN) && !defined (Q_OS_SYMBIAN)
         sockaddr_in sa4;
 #ifndef QT_NO_IPV6
 …
         char hbuf[NI_MAXHOST];
+        if (!sa || getnameinfo(sa, saSize, hbuf, sizeof(hbuf), 0, 0, 0) != 0) {
+            results.setError(QHostInfo::HostNotFound);
+            results.setErrorString(tr("Host not found"));
+            return results;
+        }
+        results.setHostName(QString::fromLatin1(hbuf));
+        if (sa && getnameinfo(sa, saSize, hbuf, sizeof(hbuf), 0, 0, 0) == 0)
+            results.setHostName(QString::fromLatin1(hbuf));
 #else
         in_addr_t inetaddr = inet_addr(hostName.toLatin1().constData());
+        in_addr_t inetaddr = qt_safe_inet_addr(hostName.toLatin1().constData());
         struct hostent *ent = gethostbyaddr((const char *)&inetaddr, sizeof(inetaddr), AF_INET);
+        if (!ent) {
+            results.setError(QHostInfo::HostNotFound);
+            results.setErrorString(tr("Host not found"));
+            return results;
+        }
+        results.setHostName(QString::fromLatin1(ent->h_name));
+#endif
+        if (ent)
+            results.setHostName(QString::fromLatin1(ent->h_name));
+#endif
+        if (results.hostName().isEmpty())
+            results.setHostName(address.toString());
+        results.setAddresses(QList<QHostAddress>() << address);
+        return results;
+    }
+    // IDN support
+    QByteArray aceHostname = QUrl::toAce(hostName);
+    results.setHostName(hostName);
+    if (aceHostname.isEmpty()) {
+        results.setError(QHostInfo::HostNotFound);
+        results.setErrorString(hostName.isEmpty() ? QObject::tr("No host name given") : QObject::tr("Invalid hostname"));
+        return results;
+    }
 …
 #endif
     int result = getaddrinfo(hostName.toLatin1().constData(), 0, &hints, &res);
+    int result = getaddrinfo(aceHostname.constData(), 0, &hints, &res);
 # ifdef Q_ADDRCONFIG
     if (result == EAI_BADFLAGS) {
         // if the lookup failed with AI_ADDRCONFIG set, try again without it
         hints.ai_flags = 0;
         result = getaddrinfo(hostName.toLatin1().constData(), 0, &hints, &res);
+        result = getaddrinfo(aceHostname.constData(), 0, &hints, &res);
+    }
 # endif
 …
     // must be provided.
     QMutexLocker locker(::getHostByNameMutex());
     hostent *result = gethostbyname(hostName.toLatin1().constData());
+    hostent *result = gethostbyname(aceHostname.constData());
     if (result) {
         if (result->h_addrtype == AF_INET) {
 …
             results.setErrorString(tr("Unknown address type"));
+        }
+#if !defined(Q_OS_VXWORKS)
     } else if (h_errno == HOST_NOT_FOUND || h_errno == NO_DATA
                || h_errno == NO_ADDRESS) {
         results.setError(QHostInfo::HostNotFound);
         results.setErrorString(tr("Host not found"));
+#endif
     } else {
         results.setError(QHostInfo::UnknownError);
 …
 QString QHostInfo::localDomainName()
+{
+#if !defined(Q_OS_VXWORKS)
     resolveLibrary();
     if (local_res_ninit) {
         // using thread-safe version
         res_state_ptr state = res_state_ptr(qMalloc(sizeof(*state)));
+        Q_CHECK_PTR(state);
         memset(state, 0, sizeof(*state));
         local_res_ninit(state);
 …
         return domainName;
+    }
+#endif
     // nothing worked, try doing it by ourselves:
     QFile resolvconf;

trunk/src/network/kernel/qhostinfo_win.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 <qtimer.h>
 #include <qmutex.h>
+#include <qurl.h>
 #include <private/qmutexpool_p.h>
 …
     sockaddr *ai_addr;
     qt_addrinfo *ai_next;
-};
-// sockaddr_in6 size changed between old and new SDK
-// Only the new version is the correct one, so always
-// use this structure.
-struct qt_in6_addr {
-    uchar qt_s6_addr[16];
-};
-struct qt_sockaddr_in6 {
-    short   sin6_family;            /* AF_INET6 */
-    u_short sin6_port;              /* Transport level port number */
-    u_long  sin6_flowinfo;          /* IPv6 flow information */
-    struct  qt_in6_addr sin6_addr;  /* IPv6 address */
-    u_long  sin6_scope_id;          /* set of interfaces for a scope */
 };
 …
 QMutex qPrivCEMutex;
 #endif
+/*
+    Performs a blocking call to gethostbyname or getaddrinfo, stores
+    the results in a QHostInfo structure and emits the
+    resultsReady() signal.
+*/
 QHostInfo QHostInfoAgent::fromName(const QString &hostName)
+{
 …
     QHostInfo results;
-    results.setHostName(hostName);
 #if defined(QHOSTINFO_DEBUG)
 …
             char hbuf[NI_MAXHOST];
+            if (local_getnameinfo(sa, saSize, hbuf, sizeof(hbuf), 0, 0, 0) != 0) {
+                results.setError(QHostInfo::HostNotFound);
+                results.setErrorString(tr("Host not found"));
+                return results;
+            }
+            results.setHostName(QString::fromLatin1(hbuf));
+            if (local_getnameinfo(sa, saSize, hbuf, sizeof(hbuf), 0, 0, 0) == 0)
+                results.setHostName(QString::fromLatin1(hbuf));
         } else {
             unsigned long addr = inet_addr(hostName.toLatin1().constData());
             struct hostent *ent = gethostbyaddr((const char*)&addr, sizeof(addr), AF_INET);
+            if (!ent) {
+                results.setError(QHostInfo::HostNotFound);
+                results.setErrorString(tr("Host not found"));
+                return results;
+            }
+            results.setHostName(QString::fromLatin1(ent->h_name));
+        }
+            if (ent)
+                results.setHostName(QString::fromLatin1(ent->h_name));
+        }
+        if (results.hostName().isEmpty())
+            results.setHostName(address.toString());
+        results.setAddresses(QList<QHostAddress>() << address);
+        return results;
+    }
+    // IDN support
+    QByteArray aceHostname = QUrl::toAce(hostName);
+    results.setHostName(hostName);
+    if (aceHostname.isEmpty()) {
+        results.setError(QHostInfo::HostNotFound);
+        results.setErrorString(hostName.isEmpty() ? tr("No host name given") : tr("Invalid hostname"));
+        return results;
+    }
 …
         // results.
         qt_addrinfo *res;
         int err = local_getaddrinfo(hostName.toLatin1().constData(), 0, 0, &res);
+        int err = local_getaddrinfo(aceHostname.constData(), 0, 0, &res);
         if (err == 0) {
             QList<QHostAddress> addresses;
 …
     } else {
         // Fall back to gethostbyname, which only supports IPv4.
         hostent *ent = gethostbyname(hostName.toLatin1().constData());
+        hostent *ent = gethostbyname(aceHostname.constData());
         if (ent) {
             char **p;

trunk/src/network/kernel/qnetworkinterface.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 (i)
             result += QLatin1Char(':');
         char buf[3];
 #if defined(Q_OS_WIN) && !defined(Q_OS_WINCE) && defined(_MSC_VER) && _MSC_VER >= 1400
 …
     \since 4.2
     \reentrant
     \ingroup io
+    \ingroup network
     Each network interface can contain zero or more IP addresses, which
 …
 */
 QNetworkAddressEntry::QNetworkAddressEntry(const QNetworkAddressEntry &other)
     : d(new QNetworkAddressEntryPrivate(*other.d))
+    : d(new QNetworkAddressEntryPrivate(*other.d.data()))
+{
+}
 …
 QNetworkAddressEntry &QNetworkAddressEntry::operator=(const QNetworkAddressEntry &other)
+{
     *d = *other.d;
+    *d.data() = *other.d.data();
     return *this;
+}
 …
 QNetworkAddressEntry::~QNetworkAddressEntry()
+{
-    delete d;
+}
 …
     \since 4.2
     \reentrant
     \ingroup io
+    \ingroup network
     QNetworkInterface represents one network interface attached to the
 …
 /*!
     Creates a copy of the the QNetworkInterface object contained in \a
+    Creates a copy of the QNetworkInterface object contained in \a
     other.
 */
 …
     if (!entry.broadcast().isNull())
         debug.nospace() << ", broadcast = " << entry.broadcast();
     debug.nospace() << ")";
+    debug.nospace() << ')';
     return debug.space();
+}
 …
                     << ", flags = ";
     flagsDebug(debug, networkInterface.flags());
+#if defined(Q_CC_RVCT)
+    // RVCT gets confused with << networkInterface.addressEntries(), reason unknown.
+    debug.nospace() << ")\n";
+#else
     debug.nospace() << ", entries = " << networkInterface.addressEntries()
                     << ")\n";
+#endif
     return debug.space();
+}

trunk/src/network/kernel/qnetworkinterface.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/qshareddata.h>
+#include <QtCore/qscopedpointer.h>
 #include <QtNetwork/qhostaddress.h>
 …
 private:
     QNetworkAddressEntryPrivate *d;
+    QScopedPointer<QNetworkAddressEntryPrivate> d;
 };

trunk/src/network/kernel/qnetworkinterface_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/kernel/qnetworkinterface_unix.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 "qnetworkinterface_p.h"
 #include "qalgorithms.h"
+#include "private/qnet_unix_p.h"
 #ifndef QT_NO_NETWORKINTERFACE
 …
         // get the interface list
         if (::ioctl(socket, SIOCGIFCONF, &interfaceList) >= 0) {
+        if (qt_safe_ioctl(socket, SIOCGIFCONF, &interfaceList) >= 0) {
             if (int(interfaceList.ifc_len + sizeof(ifreq) + 64) < storageBuffer.size()) {
                 // if the buffer was big enough, break
 …
         // Get the canonical name
         QByteArray oldName = req.ifr_name;
         if (::ioctl(socket, SIOCGIFNAME, &req) >= 0) {
+        if (qt_safe_ioctl(socket, SIOCGIFNAME, &req) >= 0) {
             iface->name = QString::fromLatin1(req.ifr_name);
 …
         // Get interface flags
         if (::ioctl(socket, SIOCGIFFLAGS, &req) >= 0) {
+        if (qt_safe_ioctl(socket, SIOCGIFFLAGS, &req) >= 0) {
             iface->flags = convertFlags(req.ifr_flags);
+        }
 …
 #ifdef SIOCGIFHWADDR
         // Get the HW address
         if (::ioctl(socket, SIOCGIFHWADDR, &req) >= 0) {
+        if (qt_safe_ioctl(socket, SIOCGIFHWADDR, &req) >= 0) {
             uchar *addr = (uchar *)&req.ifr_addr;
             iface->hardwareAddress = iface->makeHwAddress(6, addr);
 …
     int socket;
     if ((socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP)) == -1)
+    if ((socket = qt_safe_socket(AF_INET, SOCK_STREAM, IPPROTO_IP)) == -1)
         return interfaces;      // error
 …
         QNetworkAddressEntry entry;
         if (iface->flags & QNetworkInterface::CanBroadcast) {
             if (::ioctl(socket, SIOCGIFBRDADDR, &req) >= 0) {
+            if (qt_safe_ioctl(socket, SIOCGIFBRDADDR, &req) >= 0) {
                 sockaddr *sa = &req.ifr_addr;
                 if (sa->sa_family == AF_INET)
 …
         // Get the interface netmask
         if (::ioctl(socket, SIOCGIFNETMASK, &req) >= 0) {
+        if (qt_safe_ioctl(socket, SIOCGIFNETMASK, &req) >= 0) {
             sockaddr *sa = &req.ifr_addr;
             entry.setNetmask(addressFromSockaddr(sa));
 …
         // Get the address of the interface
         if (::ioctl(socket, SIOCGIFADDR, &req) >= 0) {
+        if (qt_safe_ioctl(socket, SIOCGIFADDR, &req) >= 0) {
             sockaddr *sa = &req.ifr_addr;
             entry.setIp(addressFromSockaddr(sa));
 …
     int socket;
     if ((socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_IP)) == -1)
+    if ((socket = qt_safe_socket(AF_INET, SOCK_STREAM, IPPROTO_IP)) == -1)
         return interfaces;      // error

trunk/src/network/kernel/qnetworkinterface_win.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$
 **
 …
         done = true;
+        HINSTANCE iphlpapiHnd;
+        QT_WA({
+                iphlpapiHnd = LoadLibraryW(L"iphlpapi");
+            }, {
+                iphlpapiHnd = LoadLibraryA("iphlpapi");
+            });
+        HINSTANCE iphlpapiHnd = LoadLibrary(L"iphlpapi");
         if (iphlpapiHnd == NULL)
             return;             // failed to load, probably Windows 95
+            return;
 #if defined(Q_OS_WINCE)
         ptrGetAdaptersInfo = (PtrGetAdaptersInfo)GetProcAddressW(iphlpapiHnd, L"GetAdaptersInfo");
         ptrGetAdaptersAddresses = (PtrGetAdaptersAddresses)GetProcAddressW(iphlpapiHnd, L"GetAdaptersAddresses");
         ptrGetNetworkParams = (PtrGetNetworkParams)GetProcAddressW(iphlpapiHnd, L"GetNetworkParams");
+        ptrGetAdaptersInfo = (PtrGetAdaptersInfo)GetProcAddress(iphlpapiHnd, L"GetAdaptersInfo");
+        ptrGetAdaptersAddresses = (PtrGetAdaptersAddresses)GetProcAddress(iphlpapiHnd, L"GetAdaptersAddresses");
+        ptrGetNetworkParams = (PtrGetNetworkParams)GetProcAddress(iphlpapiHnd, L"GetNetworkParams");
 #else
         ptrGetAdaptersInfo = (PtrGetAdaptersInfo)GetProcAddress(iphlpapiHnd, "GetAdaptersInfo");
 …
         // need more memory
         pAdapter = (IP_ADAPTER_INFO *)qMalloc(bufSize);
+        if (!pAdapter)
+            return ipv4netmasks;
         // try again
         if (ptrGetAdaptersInfo(pAdapter, &bufSize) != ERROR_SUCCESS) {
 …
         // need more memory
         pAdapter = (IP_ADAPTER_ADDRESSES *)qMalloc(bufSize);
+        if (!pAdapter)
+            return interfaces;
         // try again
         if (ptrGetAdaptersAddresses(AF_UNSPEC, flags, NULL, pAdapter, &bufSize) != ERROR_SUCCESS) {
 …
         // need more memory
         pAdapter = (IP_ADAPTER_INFO *)qMalloc(bufSize);
+        if (!pAdapter)
+            return interfaces;
         // try again
         if (ptrGetAdaptersInfo(pAdapter, &bufSize) != ERROR_SUCCESS) {
 …
     if (ptrGetNetworkParams(pinfo, &bufSize) == ERROR_BUFFER_OVERFLOW) {
         pinfo = (FIXED_INFO *)qMalloc(bufSize);
+        if (!pinfo)
+            return QString();
         // try again
         if (ptrGetNetworkParams(pinfo, &bufSize) != ERROR_SUCCESS) {

trunk/src/network/kernel/qnetworkinterface_win_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 <winsock2.h>
 #include <windows.h>
+#include <qt_windows.h>
 #include <time.h>

trunk/src/network/kernel/qnetworkproxy.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
     proxy support to the Qt network classes. The currently supported
     classes are QAbstractSocket, QTcpSocket, QUdpSocket, QTcpServer,
     QHttp and QFtp. The proxy support is designed to be as transparent
     as possible. This means that existing network-enabled applications
     that you have written should automatically support network proxy
     using the following code.
+    QNetworkAccessManager and QFtp. The proxy support is designed to
+    be as transparent as possible. This means that existing
+    network-enabled applications that you have written should
+    automatically support network proxy using the following code.
     \snippet doc/src/snippets/code/src_network_kernel_qnetworkproxy.cpp 0
 …
     The supported authentication methods are no authentication and
     username/password authentication.  Both IPv4 and IPv6 are
+    supported, but domain name resolution via the SOCKS server is not
+    supported; i.e. all domain names are resolved locally. There are
+    several things to remember when using SOCKS5 with QUdpSocket and
+    QTcpServer:
+    supported. Domain names are resolved through the SOCKS5 server if
+    the QNetworkProxy::HostNameLookupCapability is enabled, otherwise
+    they are resolved locally and the IP address is sent to the
+    server. There are several things to remember when using SOCKS5
+    with QUdpSocket and QTcpServer:
     With QUdpSocket, a call to \l {QUdpSocket::bind()}{bind()} may fail
 …
         \o Caching-only HTTP
         \o Implemented using normal HTTP commands, it is useful only
+           in the context of HTTP requests (see QHttp,
+           QNetworkAccessManager)
+           in the context of HTTP requests (see QNetworkAccessManager)
         \o CachingCapability, HostNameLookupCapability
 …
 #ifndef QT_NO_NETWORKPROXY
+#include "private/qnetworkproxy_p.h"
 #include "private/qsocks5socketengine_p.h"
 #include "private/qhttpsocketengine_p.h"
 …
+}
 Q_GLOBAL_STATIC(QGlobalNetworkProxy, globalNetworkProxy);
+Q_GLOBAL_STATIC(QGlobalNetworkProxy, globalNetworkProxy)
 namespace {
 …
     };
+    Q_ASSERT(int(type) >= 0 && int(type) <= int(QNetworkProxy::FtpCachingProxy));
+    if (int(type) < 0 || int(type) > int(QNetworkProxy::FtpCachingProxy))
+        type = QNetworkProxy::DefaultProxy;
     return QNetworkProxy::Capabilities(defaults[int(type)]);
+}
 …
     quint16 port;
     QNetworkProxy::ProxyType type;
+    bool capabilitiesSet;
     inline QNetworkProxyPrivate(QNetworkProxy::ProxyType t = QNetworkProxy::DefaultProxy,
 …
           capabilities(defaultCapabilitiesForType(t)),
           port(p),
+          type(t)
+          type(t),
+          capabilitiesSet(false)
     { }
 …
     Note that changing the type of a proxy does not change
+    the set of capabilities this QNetworkProxy object holds.
+    the set of capabilities this QNetworkProxy object holds if any
+    capabilities have been set with setCapabilities().
     \sa type(), setCapabilities()
 …
+{
     d->type = type;
+    if (!d->capabilitiesSet)
+        d->capabilities = defaultCapabilitiesForType(type);
+}
 …
+{
     d->capabilities = capabilities;
+    d->capabilitiesSet = true;
+}
 …
     \since 4.5
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
 QNetworkProxyFactory::~QNetworkProxyFactory()
+{
+}
+/*!
+    Enables the use of the platform-specific proxy settings, and only those.
+    See systemProxyForQuery() for more information.
+    Internally, this method (when called with \a enable set to true)
+    sets an application-wide proxy factory. For this reason, this method
+    is mutually exclusive with setApplicationProxyFactory: calling
+    setApplicationProxyFactory overrides the use of the system-wide proxy,
+    and calling setUseSystemConfiguration overrides any
+    application proxy or proxy factory that was previously set.
+    \since 4.6
+*/
+void QNetworkProxyFactory::setUseSystemConfiguration(bool enable)
+{
+    if (enable) {
+        setApplicationProxyFactory(new QSystemConfigurationProxyFactory);
+    } else {
+        setApplicationProxyFactory(0);
+    }
+}
 …
+}
+QT_END_NAMESPACE
 #endif // QT_NO_NETWORKPROXY
-QT_END_NAMESPACE

trunk/src/network/kernel/qnetworkproxy.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$
 **
 …
     virtual QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query = QNetworkProxyQuery()) = 0;
+    static void setUseSystemConfiguration(bool enable);
     static void setApplicationProxyFactory(QNetworkProxyFactory *factory);
     static QList<QNetworkProxy> proxyForQuery(const QNetworkProxyQuery &query);

trunk/src/network/kernel/qnetworkproxy_generic.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/kernel/qnetworkproxy_mac.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$
 **
 …
             QString url = QCFString::toQString(pacUrl);
+            // ### Use PAC somehow
+            qDebug("Mac system proxy: found PAC script at \"%s\"", qPrintable(url));
+            // ### TODO: Use PAC somehow
+        }
+    }

trunk/src/network/kernel/qnetworkproxy_win.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$
 **
 …
 #ifndef QT_NO_NETWORKPROXY
-#if defined(UNICODE)
 #include <qmutex.h>
 …
 #include <string.h>
 #include <windows.h>
+#include <qt_windows.h>
 #include <wininet.h>
 …
         return;
     initialized = true;
-    if (QSysInfo::windowsVersion() & QSysInfo::WV_DOS_based)
-        return;                 // no point, this library is only available on 2k, XP and up
 #ifdef Q_OS_WINCE
 …
 #else
     // load the winhttp.dll library
     HINSTANCE winhttpHnd = LoadLibraryW(L"winhttp");
+    HINSTANCE winhttpHnd = LoadLibrary(L"winhttp");
     if (!winhttpHnd)
         return;                 // failed to load
 …
+        }
         if (ieProxyConfig.lpszProxy) {
+            proxyServerList << QString::fromWCharArray(ieProxyConfig.lpszProxy);
+            // http://msdn.microsoft.com/en-us/library/aa384250%28VS.85%29.aspx speaks only about a "proxy URL",
+            // not multiple URLs. However we tested this and it can return multiple URLs. So we use splitSpaceSemicolon
+            // on it.
+            proxyServerList = splitSpaceSemicolon(QString::fromWCharArray(ieProxyConfig.lpszProxy));
             GlobalFree(ieProxyConfig.lpszProxy);
+        }
 …
         WINHTTP_PROXY_INFO proxyInfo;
         // try to get the proxy config for the URL, if we have a URL
+        // try to get the proxy config for the URL
         QUrl url = query.url();
+        // url could be empty, e.g. from QNetworkProxy::applicationProxy(), that's fine,
+        // we'll still ask for the proxy.
+        // But for a file url, we know we don't need one.
+        if (url.scheme() == QLatin1String("file") || url.scheme() == QLatin1String("qrc"))
+            return sp->defaultResult;
         if (query.queryType() != QNetworkProxyQuery::UrlRequest) {
             // change the scheme to https, maybe it'll work
 …
         return sp->defaultResult;
     return parseServerList(query, sp->proxyServerList);
+}
+#else  // !UNICODE
+QList<QNetworkProxy> QNetworkProxyFactory::systemProxyForQuery(const QNetworkProxyQuery &)
+{
+    return QList<QNetworkProxy>() << QNetworkProxy::NoProxy;
+}
+    QList<QNetworkProxy> result = parseServerList(query, sp->proxyServerList);
+    // In some cases, this was empty. See SF task 00062670
+    if (result.isEmpty())
+        return sp->defaultResult;
+    return result;
+}
+QT_END_NAMESPACE
 #endif
-QT_END_NAMESPACE
-#endif

trunk/src/network/kernel/qurlinfo.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$
 **
 …
     \ingroup io
     \ingroup misc
+    \ingroup network
     The information about a URL that can be retrieved includes name(),
 …
 /*!
     Sets the name of the URL to \a name. The name is the full text,
     for example, "http://doc.trolltech.com/qurlinfo.html".
+    for example, "http://qt.nokia.com/doc/qurlinfo.html".
     If you call this function for an invalid URL info, this function
 …
+}
+QT_END_NAMESPACE
 #endif // QT_NO_URLINFO
-QT_END_NAMESPACE

trunk/src/network/kernel/qurlinfo.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/network.pro

-              r160
+              r561
 QPRO_PWD = $$PWD
 DEFINES += QT_BUILD_NETWORK_LIB QT_NO_USING_NAMESPACE
+#DEFINES += QLOCALSERVER_DEBUG QLOCALSOCKET_DEBUG
+#DEFINES += QNETWORKDISKCACHE_DEBUG
+#DEFINES += QSSLSOCKET_DEBUG
+#DEFINES += QHOSTINFO_DEBUG
+#DEFINES += QABSTRACTSOCKET_DEBUG QNATIVESOCKETENGINE_DEBUG
+#DEFINES += QTCPSOCKETENGINE_DEBUG QTCPSOCKET_DEBUG QTCPSERVER_DEBUG QSSLSOCKET_DEBUG
+#DEFINES += QUDPSOCKET_DEBUG QUDPSERVER_DEBUG
 QT = core
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x64000000
 …
 QMAKE_LIBS += $$QMAKE_LIBS_NETWORK
+symbian {
+   TARGET.UID3=0x2001B2DE
+   LIBS += -lesock -linsock
+}

trunk/src/network/socket/qabstractsocket.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
     write buffer size. You can monitor its size by listening to this
     signal.
     The readyRead() signal is emitted every time a new chunk of data
     has arrived. bytesAvailable() then returns the number of bytes
 …
     is available before attempting to read it using operator>>().
     \sa QFtp, QHttp, QTcpServer
+    \sa QFtp, QNetworkAccessManager, QTcpServer
 */
 …
     QAbstractSocket::SocketError is not a registered metatype, so for queued
+    connections, you will have to register it with Q_REGISTER_METATYPE.
+    \sa error(), errorString()
+    connections, you will have to register it with Q_DECLARE_METATYPE() and
+    qRegisterMetaType().
+    \sa error(), errorString(), {Creating Custom Qt Types}
 */
 …
     QAbstractSocket::SocketState is not a registered metatype, so for queued
+    connections, you will have to register it with Q_REGISTER_METATYPE.
+    \sa state()
+    connections, you will have to register it with Q_REGISTER_METATYPE() and
+    qRegisterMetaType().
+    \sa state(), {Creating Custom Qt Types}
 */
 …
 */
+/*!
+    \enum QAbstractSocket::SocketOption
+    \since 4.6
+    This enum represents the options that can be set on a socket.
+    If desired, they can be set after having received the connected() signal from
+    the socket or after having received a new socket from a QTcpServer.
+    \value LowDelayOption Try to optimize the socket for low latency. For a QTcpSocket
+    this would set the TCP_NODELAY option and disable Nagle's algorithm. Set this to 1
+    to enable.
+    \value KeepAliveOption Set this to 1 to enable the SO_KEEPALIVE socket option
+    \sa QAbstractSocket::setSocketOption(), QAbstractSocket::socketOption()
+*/
 #include "qabstractsocket.h"
 #include "qabstractsocket_p.h"
 …
       socketEngine(0),
       cachedSocketDescriptor(-1),
+#ifdef Q_OS_LINUX
+      addToBytesAvailable(0),
+#endif
       readBufferMaxSize(0),
       readBuffer(QABSTRACTSOCKET_BUFFERSIZE),
 …
       blockingTimeout(30000),
       connectTimer(0),
+      disconnectTimer(0),
       connectTimeElapsed(0),
       hostLookupId(-1),
+      socketType(QAbstractSocket::UnknownSocketType),
       state(QAbstractSocket::UnconnectedState),
       socketError(QAbstractSocket::UnknownSocketError)
 …
         cachedSocketDescriptor = -1;
+    }
     if (connectTimer) {
+    if (connectTimer)
         connectTimer->stop();
+    }
+    if (disconnectTimer)
+        disconnectTimer->stop();
+}
 …
     if (socketEngine) {
 #if defined (Q_OS_WIN)
         if (!writeBuffer.isEmpty())
             socketEngine->setWriteNotificationEnabled(true);
+        if (!writeBuffer.isEmpty())
+            socketEngine->setWriteNotificationEnabled(true);
 #else
         if (writeBuffer.isEmpty())
             socketEngine->setWriteNotificationEnabled(false);
+        if (writeBuffer.isEmpty() && socketEngine->bytesToWrite() == 0)
+            socketEngine->setWriteNotificationEnabled(false);
 #endif
+    }
 …
+{
     Q_Q(QAbstractSocket);
+    if (!socketEngine || !socketEngine->isValid() || writeBuffer.isEmpty()) {
+    if (!socketEngine || !socketEngine->isValid() || (writeBuffer.isEmpty()
+        && socketEngine->bytesToWrite() == 0)) {
 #if defined (QABSTRACTSOCKET_DEBUG)
     qDebug("QAbstractSocketPrivate::flush() nothing to do: valid ? %s, writeBuffer.isEmpty() ? %s",
            socketEngine->isValid() ? "yes" : "no", writeBuffer.isEmpty() ? "yes" : "no");
 #endif
+        // this covers the case when the buffer was empty, but we had to wait for the socket engine to finish
+        if (state == QAbstractSocket::ClosingState)
+            q->disconnectFromHost();
         return false;
+    }
 …
+    }
+    if (writeBuffer.isEmpty() && socketEngine && socketEngine->isWriteNotificationEnabled())
+    if (writeBuffer.isEmpty() && socketEngine && socketEngine->isWriteNotificationEnabled()
+        && !socketEngine->bytesToWrite())
         socketEngine->setWriteNotificationEnabled(false);
     if (state == QAbstractSocket::ClosingState)
 …
         s += addresses.at(i).toString();
+    }
     s += "}";
+    s += '}';
     qDebug("QAbstractSocketPrivate::_q_startConnecting(hostInfo == %s)", s.toLatin1().constData());
 #endif
 …
     if (socketEngine)
         socketEngine->setWriteNotificationEnabled(false);
     connectTimer->stop();
 …
     } else {
         _q_connectToNextAddress();
+    }
+}
+void QAbstractSocketPrivate::_q_forceDisconnect()
+{
+    Q_Q(QAbstractSocket);
+    if (socketEngine && socketEngine->isValid() && state == QAbstractSocket::ClosingState) {
+        socketEngine->close();
+        q->disconnectFromHost();
+    }
+}
 …
 /*! \internal
     Sets up the the internal state after the connection has succeeded.
+    Sets up the internal state after the connection has succeeded.
 */
 void QAbstractSocketPrivate::fetchConnectionParameters()
 …
     \a hostName may be an IP address in string form (e.g.,
     "43.195.83.32"), or it may be a host name (e.g.,
     "qtsoftware.com"). QAbstractSocket will do a lookup only if
+    "example.com"). QAbstractSocket will do a lookup only if
     required. \a port is in native byte order.
 …
 #endif
+    if (d->state == ConnectedState || d->state == ConnectingState) {
+        qWarning("QAbstractSocket::connectToHost() called when already connecting/connected to \"%s\"", qPrintable(hostName));
+    if (d->state == ConnectedState || d->state == ConnectingState
+        || d->state == ClosingState || d->state == HostLookupState) {
+        qWarning("QAbstractSocket::connectToHost() called when already looking up or connecting/connected to \"%s\"", qPrintable(hostName));
         return;
+    }
 …
+}
+/*!
+    \since 4.6
+    Sets the given \a option to the value described by \a value.
+    \sa socketOption()
+*/
+void QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
+{
+#ifndef QT_NO_OPENSSL
+    if (QSslSocket *sslSocket = qobject_cast<QSslSocket*>(this)) {
+        sslSocket->setSocketOption(option, value);
+        return;
+    }
+#endif
+    if (!d_func()->socketEngine)
+        return;
+    switch (option) {
+        case LowDelayOption:
+            d_func()->socketEngine->setOption(QAbstractSocketEngine::LowDelayOption, value.toInt());
+            break;
+        case KeepAliveOption:
+            d_func()->socketEngine->setOption(QAbstractSocketEngine::KeepAliveOption, value.toInt());
+            break;
+    }
+}
+/*!
+    \since 4.6
+    Returns the value of the \a option option.
+    \sa setSocketOption()
+*/
+QVariant QAbstractSocket::socketOption(QAbstractSocket::SocketOption option)
+{
+#ifndef QT_NO_OPENSSL
+    if (QSslSocket *sslSocket = qobject_cast<QSslSocket*>(this)) {
+        return sslSocket->socketOption(option);
+    }
+#endif
+    if (!d_func()->socketEngine)
+        return QVariant();
+    int ret = -1;
+    switch (option) {
+        case LowDelayOption:
+            ret = d_func()->socketEngine->option(QAbstractSocketEngine::LowDelayOption);
+            break;
+        case KeepAliveOption:
+            ret = d_func()->socketEngine->option(QAbstractSocketEngine::KeepAliveOption);
+            break;
+    }
+    if (ret == -1)
+        return QVariant();
+    else
+        return QVariant(ret);
+}
 /*
    Returns the difference between msecs and elapsed. If msecs is -1,
 …
 /*!
     This function blocks until data is available for reading and the
+    This function blocks until new data is available for reading and the
     \l{QIODevice::}{readyRead()} signal has been emitted. The function
     will timeout after \a msecs milliseconds; the default timeout is
 …
     The function returns true if the readyRead() signal is emitted and
     there is data available for reading; otherwise it returns false
+    there is new data available for reading; otherwise it returns false
     (if an error occurred or the operation timed out).
 …
 /*!
     Aborts the current connection and resets the socket. Unlike
     disconnectFromHost(), this function immediately closes the socket, discarding
     any pending data in the write buffer.
+    Aborts the current connection and resets the socket. Unlike disconnectFromHost(),
+    this function immediately closes the socket, discarding any pending data in the
+    write buffer.
     \sa disconnectFromHost(), close()
 …
 /*!
+    Disconnects the socket's connection with the host.
+    Closes the I/O device for the socket, disconnects the socket's connection with the
+    host, closes the socket, and resets the name, address, port number and underlying
+    socket descriptor.
+    See QIODevice::close() for a description of the actions that occur when an I/O
+    device is closed.
     \sa abort()
 …
         // Wait for pending data to be written.
+        if (d->socketEngine && d->socketEngine->isValid() && d->writeBuffer.size() > 0) {
+        if (d->socketEngine && d->socketEngine->isValid() && (d->writeBuffer.size() > 0
+            || d->socketEngine->bytesToWrite() > 0)) {
+            // hack: when we are waiting for the socket engine to write bytes (only
+            // possible when using Socks5 or HTTP socket engine), then close
+            // anyway after 2 seconds. This is to prevent a timeout on Mac, where we
+            // sometimes just did not get the write notifier from the underlying
+            // CFSocket and no progress was made.
+            if (d->writeBuffer.size() == 0 && d->socketEngine->bytesToWrite() > 0) {
+                if (!d->disconnectTimer) {
+                    d->disconnectTimer = new QTimer(this);
+                    connect(d->disconnectTimer, SIGNAL(timeout()), this,
+                            SLOT(_q_forceDisconnect()), Qt::DirectConnection);
+                }
+                if (!d->disconnectTimer->isActive())
+                    d->disconnectTimer->start(2000);
+            }
             d->socketEngine->setWriteNotificationEnabled(true);
 …
 #ifdef QT3_SUPPORT
+/*! \enum QAbstractSocket::Error
+/*!
+    \enum QAbstractSocket::Error
     \compat
 …
         break;
     default:
         debug << "QAbstractSocket::SocketError(" << int(error) << ")";
+        debug << "QAbstractSocket::SocketError(" << int(error) << ')';
         break;
+    }
 …
         break;
     default:
         debug << "QAbstractSocket::SocketState(" << int(state) << ")";
+        debug << "QAbstractSocket::SocketState(" << int(state) << ')';
         break;
+    }

trunk/src/network/socket/qabstractsocket.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$
 **
 …
 #endif
     };
+    enum SocketOption {
+        LowDelayOption, // TCP_NODELAY
+        KeepAliveOption // SO_KEEPALIVE
+    };
     QAbstractSocket(SocketType socketType, QObject *parent);
 …
     bool setSocketDescriptor(int socketDescriptor, SocketState state = ConnectedState,
                              OpenMode openMode = ReadWrite);
+    // ### Qt 5: Make virtual?
+    void setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value);
+    QVariant socketOption(QAbstractSocket::SocketOption option);
     SocketType socketType() const;
 …
     Q_PRIVATE_SLOT(d_func(), void _q_abortConnectionAttempt())
     Q_PRIVATE_SLOT(d_func(), void _q_testConnection())
+    Q_PRIVATE_SLOT(d_func(), void _q_forceDisconnect())
 #ifdef QT3_SUPPORT

trunk/src/network/socket/qabstractsocket_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$
 **
 …
 //
 // This file is not part of the Qt API.  It exists for the convenience
 // of the QLibrary class.  This header file may change from
+// of the QAbstractSocket class.  This header file may change from
 // version to version without notice, or even be removed.
 //
 …
     void _q_testConnection();
     void _q_abortConnectionAttempt();
+    void _q_forceDisconnect();
     bool readSocketNotifierCalled;
 …
     QTimer *connectTimer;
+    QTimer *disconnectTimer;
     int connectTimeElapsed;

trunk/src/network/socket/qabstractsocketengine.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/socket/qabstractsocketengine_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$
 **
 …
         AddressReusable,
         BindExclusively,
+        ReceiveOutOfBandData
+        ReceiveOutOfBandData,
+        LowDelayOption,
+        KeepAliveOption
     };
 …
     virtual qint64 pendingDatagramSize() const = 0;
 #endif
+    virtual qint64 bytesToWrite() const = 0;
     virtual int option(SocketOption option) const = 0;

trunk/src/network/socket/qhttpsocketengine.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 // QT_NO_UDPSOCKET
+int QHttpSocketEngine::option(SocketOption) const
+{
+qint64 QHttpSocketEngine::bytesToWrite() const
+{
+    Q_D(const QHttpSocketEngine);
+    if (d->socket) {
+        return d->socket->bytesToWrite();
+    } else {
+        return 0;
+    }
+}
+int QHttpSocketEngine::option(SocketOption option) const
+{
+    Q_D(const QHttpSocketEngine);
+    if (d->socket) {
+        // convert the enum and call the real socket
+        if (option == QAbstractSocketEngine::LowDelayOption)
+            return d->socket->socketOption(QAbstractSocket::LowDelayOption).toInt();
+        if (option == QAbstractSocketEngine::KeepAliveOption)
+            return d->socket->socketOption(QAbstractSocket::KeepAliveOption).toInt();
+    }
     return -1;
+}
+bool QHttpSocketEngine::setOption(SocketOption, int)
+{
+bool QHttpSocketEngine::setOption(SocketOption option, int value)
+{
+    Q_D(QHttpSocketEngine);
+    if (d->socket) {
+        // convert the enum and call the real socket
+        if (option == QAbstractSocketEngine::LowDelayOption)
+            d->socket->setSocketOption(QAbstractSocket::LowDelayOption, value);
+        if (option == QAbstractSocketEngine::KeepAliveOption)
+            d->socket->setSocketOption(QAbstractSocket::KeepAliveOption, value);
+        return true;
+    }
     return false;
+}
 …
     data += " HTTP/1.1\r\n";
     data += "Proxy-Connection: keep-alive\r\n"
+            "User-Agent: Mozilla/5.0\r\n"
             "Host: " + peerAddress + "\r\n";
     QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
 …
     , writeNotificationPending(false)
     , connectionNotificationPending(false)
+    , pendingResponseData(0)
+{
     socket = 0;
 …
+}
+QT_END_NAMESPACE
 #endif
-QT_END_NAMESPACE

trunk/src/network/socket/qhttpsocketengine_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$
 **
 …
     qint64 pendingDatagramSize() const;
 #endif // QT_NO_UDPSOCKET
+    qint64 bytesToWrite() const;
     int option(SocketOption option) const;

trunk/src/network/socket/qlocalserver.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$
 **
 …
     to use it without one. In that case, you must use waitForNewConnection(),
     which blocks until either a connection is available or a timeout expires.
-    Note that this feature is not supported on Windows 9x.
     \sa QLocalSocket, QTcpServer
 …
         return 0;
     QLocalSocket *nextSocket = d->pendingConnections.dequeue();
+#ifdef Q_OS_SYMBIAN
+    if(!d->socketNotifier)
+        return nextSocket;
+#endif
+#ifndef QT_LOCALSOCKET_TCP
+    if (d->pendingConnections.size() <= d->maxPendingConnections)
 #ifndef Q_OS_WIN
+    d->socketNotifier->setEnabled(d->pendingConnections.size()
+                                   <= d->maxPendingConnections);
+        d->socketNotifier->setEnabled(true);
+#else
+        d->connectionEventNotifier->setEnabled(true);
+#endif
 #endif
     return nextSocket;

trunk/src/network/socket/qlocalserver.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$
 **
 …
 private:
     Q_DISABLE_COPY(QLocalServer)
-#if defined(QT_LOCALSOCKET_TCP)
     Q_PRIVATE_SLOT(d_func(), void _q_onNewConnection())
-#elif defined(Q_OS_WIN)
-    Q_PRIVATE_SLOT(d_func(), void _q_openSocket(HANDLE handle))
-    Q_PRIVATE_SLOT(d_func(), void _q_stoppedListening())
-    Q_PRIVATE_SLOT(d_func(), void _q_setError(QAbstractSocket::SocketError error, const QString &errorString))
-#else
-    Q_PRIVATE_SLOT(d_func(), void _q_socketActivated())
-#endif
 };

trunk/src/network/socket/qlocalserver_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$
 **
 …
 #elif defined(Q_OS_WIN)
 #   include <qt_windows.h>
 #   include <qthread.h>
+#   include <private/qwineventnotifier_p.h>
 #else
 #   include <private/qnativesocketengine_p.h>
 …
 QT_BEGIN_NAMESPACE
-#if defined(Q_OS_WIN) && !defined(QT_LOCALSOCKET_TCP)
-/*!
-    \internal
-    QLocalServerThread exists because Windows does not have a
-    way to provide notifications when there is a new connections to
-    the server.
-  */
-class QLocalServerThread : public QThread
+{
-    Q_OBJECT
-Q_SIGNALS:
-    void connected(HANDLE newSocket);
-    void error(QAbstractSocket::SocketError error, const QString &errorString);
-public:
-    QLocalServerThread(QObject *parent = 0);
-    ~QLocalServerThread();
-    void closeServer();
-public:
-    QString setName(const QString &name);
-    void run();
-    void stop();
-    bool makeHandle();
-    HANDLE gotConnectionEvent;
-    QQueue<HANDLE> pendingHandles;
-    int maxPendingConnections;
-private:
-    HANDLE stopEvent;
-    QString fullServerName;
-};
-#endif
 class QLocalServerPrivate : public QObjectPrivate
+{
 …
 public:
     QLocalServerPrivate() :
+#if defined(Q_OS_WIN) && !defined(QT_LOCALSOCKET_TCP)
+            inWaitingFunction(false),
+#elif !defined(QT_LOCALSOCKET_TCP)
+#if !defined(QT_LOCALSOCKET_TCP) && !defined(Q_OS_WIN)
             listenSocket(-1), socketNotifier(0),
 #endif
 …
     void closeServer();
     void waitForNewConnection(int msec, bool *timedOut);
+    void _q_onNewConnection();
 #if defined(QT_LOCALSOCKET_TCP)
-    void _q_onNewConnection();
     QTcpServer tcpServer;
     QMap<quintptr, QTcpSocket*> socketMap;
 #elif defined(Q_OS_WIN)
+    void _q_openSocket(HANDLE socket);
+    void _q_stoppedListening();
+    void _q_setError(QAbstractSocket::SocketError error, const QString &errorString);
+    struct Listener {
+        HANDLE handle;
+        OVERLAPPED overlapped;
+    };
+    QLocalServerThread waitForConnection;
+    bool inWaitingFunction;
+    void setError(const QString &function);
+    bool addListener();
+    QList<Listener> listeners;
+    HANDLE eventHandle;
+    QWinEventNotifier *connectionEventNotifier;
 #else
     void setError(const QString &function);
-    void _q_socketActivated();
     int listenSocket;

trunk/src/network/socket/qlocalserver_tcp.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 (pendingConnections.isEmpty())
         tcpServer.waitForNewConnection(msec, timedOut);
     else
+    else if (timedOut)
         *timedOut = false;
+}

trunk/src/network/socket/qlocalserver_unix.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 "qlocalsocket.h"
 #include "qlocalsocket_p.h"
+#include "qnet_unix_p.h"
 #ifndef QT_NO_LOCALSERVER
 …
 #include <qdir.h>
 #include <qdatetime.h>
+#ifdef Q_OS_VXWORKS
+#  include <selectLib.h>
+#endif
 QT_BEGIN_NAMESPACE
 …
     // create the unix socket
     listenSocket = qSocket(PF_UNIX, SOCK_STREAM, 0);
+    listenSocket = qt_safe_socket(PF_UNIX, SOCK_STREAM, 0);
     if (-1 == listenSocket) {
         setError(QLatin1String("QLocalServer::listen"));
 …
              fullServerName.toLatin1().size() + 1);
+#ifdef Q_OS_SYMBIAN
+    // In SYMBIAN OS it can currently happen that accept is called twice,
+    // once from waitForNewConnection and once via QSocketNotfier activity
+    //
+    // As an workaround, we set the socket to non blocking so possible
+    // subsequent call to accept will not block in any case
+    //
+    // This change can be removed once more generic fix to select thread
+    // syncronization problem is implemented.
+    int flags = fcntl(listenSocket, F_GETFL, 0);
+    if (-1 == flags
+        || -1 == (fcntl(listenSocket, F_SETFL, flags | O_NONBLOCK))) {
+        setError(QLatin1String("QLocalServer::listen"));
+        closeServer();
+        return false;
+    }
+#endif
     // bind
     if(-1 == qBind(listenSocket, (sockaddr *)&addr, sizeof(sockaddr_un))) {
+    if(-1 == QT_SOCKET_BIND(listenSocket, (sockaddr *)&addr, sizeof(sockaddr_un))) {
         setError(QLatin1String("QLocalServer::listen"));
         // if address is in use already, just close the socket, but do not delete the file
 …
     // listen for connections
     if (-1 == qListen(listenSocket, 50)) {
+    if (-1 == qt_safe_listen(listenSocket, 50)) {
         setError(QLatin1String("QLocalServer::listen"));
         closeServer();
 …
                                          QSocketNotifier::Read, q);
     q->connect(socketNotifier, SIGNAL(activated(int)),
                q, SLOT(_q_socketActivated()));
+               q, SLOT(_q_onNewConnection()));
     socketNotifier->setEnabled(maxPendingConnections > 0);
     return true;
 …
     listenSocket = -1;
+    if (socketNotifier)
+    if (socketNotifier) {
+        socketNotifier->setEnabled(false); // Otherwise, closed socket is checked before deleter runs
         socketNotifier->deleteLater();
+    socketNotifier = 0;
+        socketNotifier = 0;
+    }
     if (!fullServerName.isEmpty())
 …
     Accept the new socket.
  */
 void QLocalServerPrivate::_q_socketActivated()
+void QLocalServerPrivate::_q_onNewConnection()
+{
     Q_Q(QLocalServer);
 …
     ::sockaddr_un addr;
     QT_SOCKLEN_T length = sizeof(sockaddr_un);
     int connectedSocket = qAccept(listenSocket, (sockaddr *)&addr, &length);
+    int connectedSocket = qt_safe_accept(listenSocket, (sockaddr *)&addr, &length);
     if(-1 == connectedSocket) {
         setError(QLatin1String("QLocalSocket::activated"));
 …
     timeout.tv_usec = (msec % 1000) * 1000;
-    // timeout can not be 0 or else select will return an error.
-    if (0 == msec)
-        timeout.tv_usec = 1000;
     int result = -1;
+    // on Linux timeout will be updated by select, but _not_ on other systems.
+    QTime timer;
+    timer.start();
+    while (pendingConnections.isEmpty() && (-1 == msec || timer.elapsed() < msec)) {
+        result = ::select(listenSocket + 1, &readfds, 0, 0, &timeout);
+        if (-1 == result && errno != EINTR) {
+            setError(QLatin1String("QLocalServer::waitForNewConnection"));
+            closeServer();
+            break;
+        }
+        if (result > 0)
+            _q_socketActivated();
+    }
+    result = qt_safe_select(listenSocket + 1, &readfds, 0, 0, (msec == -1) ? 0 : &timeout);
+    if (-1 == result) {
+        setError(QLatin1String("QLocalServer::waitForNewConnection"));
+        closeServer();
+    }
+    if (result > 0)
+        _q_onNewConnection();
     if (timedOut)
         *timedOut = (result == 0);

trunk/src/network/socket/qlocalserver_win.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 <qdebug.h>
-#include <qdatetime.h>
-#include <qcoreapplication.h>
-#include <QMetaType>
 // The buffer size need to be 0 otherwise data could be
 …
 #define BUFSIZE 0
+// ###: This should be a property. Should replace the insane 50 on unix as well.
+#define SYSTEM_MAX_PENDING_SOCKETS 8
 QT_BEGIN_NAMESPACE
+QLocalServerThread::QLocalServerThread(QObject *parent) : QThread(parent),
+    maxPendingConnections(1)
+{
+    stopEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+    gotConnectionEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+}
+QLocalServerThread::~QLocalServerThread()
+{
+    stop();
+    closeServer();
+    CloseHandle(stopEvent);
+    CloseHandle(gotConnectionEvent);
+}
+void QLocalServerThread::stop()
+{
+    if (isRunning()) {
+        SetEvent(stopEvent);
+        wait();
+        ResetEvent(stopEvent);
+    }
+}
+void QLocalServerThread::closeServer()
+{
+    while (!pendingHandles.isEmpty())
+        CloseHandle(pendingHandles.dequeue());
+}
+QString QLocalServerThread::setName(const QString &name)
+{
+    QString pipePath = QLatin1String("\\\\.\\pipe\\");
+    if (name.startsWith(pipePath))
+        fullServerName = name;
+    else
+        fullServerName = pipePath + name;
+    for (int i = pendingHandles.count(); i < maxPendingConnections; ++i)
+        if (!makeHandle())
+            break;
+    return fullServerName;
+}
+bool QLocalServerThread::makeHandle()
+{
+    if (pendingHandles.count() >= maxPendingConnections)
+        return false;
+    HANDLE handle = INVALID_HANDLE_VALUE;
+    QT_WA({
+    handle = CreateNamedPipeW(
+                 (TCHAR*)fullServerName.utf16(), // pipe name
+bool QLocalServerPrivate::addListener()
+{
+    // The object must not change its address once the
+    // contained OVERLAPPED struct is passed to Windows.
+    listeners << Listener();
+    Listener &listener = listeners.last();
+    listener.handle = CreateNamedPipe(
+                 (const wchar_t *)fullServerName.utf16(), // pipe name
                  PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,       // read/write access
                  PIPE_TYPE_MESSAGE |       // message type pipe
 …
 ,                     // client time-out
                  NULL);
+    }, {
+    handle = CreateNamedPipeA(
+                 fullServerName.toLocal8Bit().constData(), // pipe name
+                 PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,       // read/write access
+                 PIPE_TYPE_MESSAGE |       // message type pipe
+                 PIPE_READMODE_MESSAGE |   // message-read mode
+                 PIPE_WAIT,                // blocking mode
+                 PIPE_UNLIMITED_INSTANCES, // max. instances
+                 BUFSIZE,                  // output buffer size
+                 BUFSIZE,                  // input buffer size
+,                     // client time-out
+                 NULL);
+    });
+    if (INVALID_HANDLE_VALUE == handle) {
+    if (listener.handle == INVALID_HANDLE_VALUE) {
+        setError(QLatin1String("QLocalServerPrivate::addListener"));
+        listeners.removeLast();
         return false;
+    }
+    pendingHandles.enqueue(handle);
+    memset(&listener.overlapped, 0, sizeof(listener.overlapped));
+    listener.overlapped.hEvent = eventHandle;
+    if (!ConnectNamedPipe(listener.handle, &listener.overlapped)) {
+        switch (GetLastError()) {
+        case ERROR_IO_PENDING:
+            break;
+        case ERROR_PIPE_CONNECTED:
+            SetEvent(eventHandle);
+            break;
+        default:
+            CloseHandle(listener.handle);
+            setError(QLatin1String("QLocalServerPrivate::addListener"));
+            listeners.removeLast();
+            return false;
+        }
+    } else {
+        Q_ASSERT_X(false, "QLocalServerPrivate::addListener", "The impossible happened");
+        SetEvent(eventHandle);
+    }
     return true;
+}
+void QLocalServerThread::run()
+{
+    OVERLAPPED  op;
+    HANDLE      handleArray[2];
+    memset(&op, 0, sizeof(op));
+    handleArray[0] = op.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+    handleArray[1] = stopEvent;
+    HANDLE handle = INVALID_HANDLE_VALUE;
+    forever {
+        if (INVALID_HANDLE_VALUE == handle) {
+            makeHandle();
+            if (!pendingHandles.isEmpty())
+                handle = pendingHandles.dequeue();
+        }
+        if (INVALID_HANDLE_VALUE == handle) {
+            int windowsError = GetLastError();
+            QString function = QLatin1String("QLocalServer::run");
+            QString errorString = QLocalServer::tr("%1: Unknown error %2").arg(function).arg(windowsError);
+            emit error(QAbstractSocket::UnknownSocketError, errorString);
+            CloseHandle(handleArray[0]);
+            SetEvent(gotConnectionEvent);
+            return;
+        }
+        BOOL isConnected = ConnectNamedPipe(handle, &op) ? TRUE : (GetLastError() == ERROR_PIPE_CONNECTED);
+        if (!isConnected) {
+            switch (WaitForMultipleObjects(2, handleArray, FALSE, INFINITE))
+            {
+            case WAIT_OBJECT_0 + 1:
+                CloseHandle(handle);
+                CloseHandle(handleArray[0]);
+void QLocalServerPrivate::setError(const QString &function)
+{
+    int windowsError = GetLastError();
+    errorString = QString::fromLatin1("%1: %2").arg(function).arg(qt_error_string(windowsError));
+    error = QAbstractSocket::UnknownSocketError;
+}
+void QLocalServerPrivate::init()
+{
+}
+bool QLocalServerPrivate::removeServer(const QString &name)
+{
+    Q_UNUSED(name);
+    return true;
+}
+bool QLocalServerPrivate::listen(const QString &name)
+{
+    Q_Q(QLocalServer);
+    QString pipePath = QLatin1String("\\\\.\\pipe\\");
+    if (name.startsWith(pipePath))
+        fullServerName = name;
+    else
+        fullServerName = pipePath + name;
+    // Use only one event for all listeners of one socket.
+    // The idea is that listener events are rare, so polling all listeners once in a while is
+    // cheap compared to waiting for N additional events in each iteration of the main loop.
+    eventHandle = CreateEvent(NULL, TRUE, FALSE, NULL);
+    connectionEventNotifier = new QWinEventNotifier(eventHandle , q);
+    q->connect(connectionEventNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_onNewConnection()));
+    for (int i = 0; i < SYSTEM_MAX_PENDING_SOCKETS; ++i)
+        if (!addListener())
+            return false;
+    return true;
+}
+void QLocalServerPrivate::_q_onNewConnection()
+{
+    Q_Q(QLocalServer);
+    DWORD dummy;
+    // Reset first, otherwise we could reset an event which was asserted
+    // immediately after we checked the conn status.
+    ResetEvent(eventHandle);
+    // Testing shows that there is indeed absolutely no guarantee which listener gets
+    // a client connection first, so there is no way around polling all of them.
+    for (int i = 0; i < listeners.size(); ) {
+        HANDLE handle = listeners[i].handle;
+        if (GetOverlappedResult(handle, &listeners[i].overlapped, &dummy, FALSE)) {
+            listeners.removeAt(i);
+            addListener();
+            if (pendingConnections.size() > maxPendingConnections)
+                connectionEventNotifier->setEnabled(false);
+            // Make this the last thing so connected slots can wreak the least havoc
+            q->incomingConnection((quintptr)handle);
+        } else {
+            if (GetLastError() != ERROR_IO_INCOMPLETE) {
+                setError(QLatin1String("QLocalServerPrivate::_q_onNewConnection"));
+                closeServer();
                 return;
+            }
+            ++i;
+        }
+        emit connected(handle);
+        handle = INVALID_HANDLE_VALUE;
+        ResetEvent(handleArray[0]);
+        SetEvent(gotConnectionEvent);
+    }
+}
+void QLocalServerPrivate::init()
+{
+    Q_Q(QLocalServer);
+    qRegisterMetaType<HANDLE>("HANDLE");
+    q->connect(&waitForConnection, SIGNAL(connected(HANDLE)),
+               q, SLOT(_q_openSocket(HANDLE)), Qt::QueuedConnection);
+    q->connect(&waitForConnection, SIGNAL(finished()),
+               q, SLOT(_q_stoppedListening()), Qt::QueuedConnection);
+    q->connect(&waitForConnection, SIGNAL(terminated()),
+               q, SLOT(_q_stoppedListening()), Qt::QueuedConnection);
+    q->connect(&waitForConnection, SIGNAL(error(QAbstractSocket::SocketError, const QString &)),
+               q, SLOT(_q_setError(QAbstractSocket::SocketError, const QString &)));
+}
+bool QLocalServerPrivate::removeServer(const QString &name)
+{
+    Q_UNUSED(name);
+    return true;
+}
+bool QLocalServerPrivate::listen(const QString &name)
+{
+    fullServerName = waitForConnection.setName(name);
+    serverName = name;
+    waitForConnection.start();
+    return true;
+}
+void QLocalServerPrivate::_q_setError(QAbstractSocket::SocketError e, const QString &eString)
+{
+    error = e;
+    errorString = eString;
+}
+void QLocalServerPrivate::_q_stoppedListening()
+{
+    Q_Q(QLocalServer);
+    if (!inWaitingFunction)
+        q->close();
+}
+void QLocalServerPrivate::_q_openSocket(HANDLE handle)
+{
+    Q_Q(QLocalServer);
+    q->incomingConnection((int)handle);
+    }
+}
 void QLocalServerPrivate::closeServer()
+{
+    waitForConnection.stop();
+    waitForConnection.closeServer();
+    connectionEventNotifier->setEnabled(false); // Otherwise, closed handle is checked before deleter runs
+    connectionEventNotifier->deleteLater();
+    connectionEventNotifier = 0;
+    CloseHandle(eventHandle);
+    for (int i = 0; i < listeners.size(); ++i)
+        CloseHandle(listeners[i].handle);
+    listeners.clear();
+}
 …
         return;
+    DWORD result = WaitForSingleObject(waitForConnection.gotConnectionEvent,
+                                       (msecs == -1) ? INFINITE : msecs);
+    DWORD result = WaitForSingleObject(eventHandle, (msecs == -1) ? INFINITE : msecs);
     if (result == WAIT_TIMEOUT) {
         if (timedOut)
             *timedOut = true;
     } else {
+        ResetEvent(waitForConnection.gotConnectionEvent);
+        QCoreApplication::instance()->processEvents();
+        _q_onNewConnection();
+    }
+}

trunk/src/network/socket/qlocalsocket.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$
 **
 …
     which blocks until the operation is complete or the timeout expires.
+    Note that this feature is not supported on Window 9x.
+    Note that this feature is not supported on versions of Windows earlier than
+    Windows XP.
     \sa QLocalServer
 …
     specified by \a socketState.
     Note: It is not possible to initialize two local sockets with the same
+    \note It is not possible to initialize two local sockets with the same
     native socket descriptor.
 …
     returns false.
     Note: The socket's state must be ConnectedState before reading
+    \note The socket's state must be ConnectedState before reading
     and writing can occur.
     \sa state()
+    \sa state(), connectToServer()
 */
 …
 /*!
     \fn bool QLocalSocket::waitForConnected(int msec)
     Waits until the socket is connected, up to \a msec milliseconds. If the
+    \fn bool QLocalSocket::waitForConnected(int msecs)
+    Waits until the socket is connected, up to \a msecs milliseconds. If the
     connection has been established, this function returns true; otherwise
     it returns false. In the case where it returns false, you can call
 …
     \snippet doc/src/snippets/code/src_network_socket_qlocalsocket_unix.cpp 0
     If msecs is -1, this function will not time out.
+    If \a msecs is -1, this function will not time out.
     \sa connectToServer(), connected()
 …
     \snippet doc/src/snippets/code/src_network_socket_qlocalsocket_unix.cpp 1
     If msecs is -1, this function will not time out.
+    If \a msecs is -1, this function will not time out.
     \sa disconnectFromServer(), close()
 …
     QLocalSocket::LocalSocketError is not a registered metatype, so for queued
+    connections, you will have to register it with Q_DECLARE_METATYPE.
+    \sa error(), errorString()
+    connections, you will have to register it with Q_DECLARE_METATYPE() and
+    qRegisterMetaType().
+    \sa error(), errorString(), {Creating Custom Qt Types}
 */
 …
     QLocalSocket::SocketState is not a registered metatype, so for queued
+    connections, you will have to register it with Q_DECLARE_METATYPE.
+    \sa state()
+    connections, you will have to register it with Q_DECLARE_METATYPE() and
+    qRegisterMetaType().
+    \sa state(), {Creating Custom Qt Types}
 */
 …
     Returns the server path that the socket is connected to.
     Note: This is platform specific
+    \note The return value of this function is platform specific.
     \sa connectToServer(), serverName()
 …
         break;
     default:
         debug << "QLocalSocket::SocketError(" << int(error) << ")";
+        debug << "QLocalSocket::SocketError(" << int(error) << ')';
         break;
+    }
 …
         break;
     default:
         debug << "QLocalSocket::SocketState(" << int(state) << ")";
+        debug << "QLocalSocket::SocketState(" << int(state) << ')';
         break;
+    }

trunk/src/network/socket/qlocalsocket.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_PRIVATE_SLOT(d_func(), void _q_canWrite())
     Q_PRIVATE_SLOT(d_func(), void _q_pipeClosed())
+    Q_PRIVATE_SLOT(d_func(), void _q_emitReadyRead())
 #else
     Q_PRIVATE_SLOT(d_func(), void _q_stateChanged(QAbstractSocket::SocketState))

trunk/src/network/socket/qlocalsocket_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 "private/qwindowspipewriter_p.h"
 #   include "private/qringbuffer_p.h"
+#   include <private/qwineventnotifier_p.h>
 #else
 #   include "private/qnativesocketengine_p.h"
 …
 QT_BEGIN_NAMESPACE
-#if !defined(Q_OS_WIN) && !defined(QT_LOCALSOCKET_TCP)
-static inline int qSocket(int af, int socketype, int proto)
+{
-    int ret;
-    while((ret = qt_socket_socket(af, socketype, proto)) == -1 && errno == EINTR){}
-    return ret;
+}
-static inline int qBind(int fd, const sockaddr *sa, int len)
+{
-    int ret;
-    while((ret = QT_SOCKET_BIND(fd, (sockaddr*)sa, len)) == -1 && errno == EINTR){}
-    return ret;
+}
-static inline int qConnect(int fd, const sockaddr *sa, int len)
+{
-    int ret;
-    while((ret = QT_SOCKET_CONNECT(fd, (sockaddr*)sa, len)) == -1 && errno == EINTR){}
-    return ret;
+}
-static inline int qListen(int fd, int backlog)
+{
-    int ret;
-    while((ret = qt_socket_listen(fd, backlog)) == -1 && errno == EINTR){}
-    return ret;
+}
-static inline int qAccept(int fd, struct sockaddr *addr, QT_SOCKLEN_T *addrlen)
+{
-    int ret;
-    while((ret = qt_socket_accept(fd, addr, addrlen)) == -1 && errno == EINTR){}
-    return ret;
+}
-#endif //#if !defined(Q_OS_WIN) && !defined(QT_LOCALSOCKET_TCP)
 #if !defined(Q_OS_WIN) || defined(QT_LOCALSOCKET_TCP)
 …
     void _q_canWrite();
     void _q_pipeClosed();
+    qint64 readData(char *data, qint64 maxSize);
+    qint64 bytesAvailable();
+    bool readFromSocket();
+    void _q_emitReadyRead();
+    DWORD bytesAvailable();
+    void startAsyncRead();
+    bool completeAsyncRead();
+    void checkReadyRead();
     HANDLE handle;
     OVERLAPPED overlapped;
 …
     qint64 readBufferMaxSize;
     QRingBuffer readBuffer;
+    QTimer dataNotifier;
+    int actualReadBufferSize;
+    QWinEventNotifier *dataReadNotifier;
     QLocalSocket::LocalSocketError error;
+    bool readyReadEmitted;
+    bool readSequenceStarted;
+    bool pendingReadyRead;
     bool pipeClosed;
+    static const qint64 initialReadBufferSize = 4096;
 #else
     QLocalUnixSocket unixSocket;
 …
     void _q_connectToSocket();
     void _q_abortConnectionAttempt();
+    void cancelDelayedConnect();
     QSocketNotifier *delayConnect;
     QTimer *connectTimer;

trunk/src/network/socket/qlocalsocket_tcp.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/socket/qlocalsocket_unix.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 "qlocalsocket.h"
 #include "qlocalsocket_p.h"
+#include "qnet_unix_p.h"
 #ifndef QT_NO_LOCALSOCKET
 …
 #include <qdir.h>
 #include <qdebug.h>
+#ifdef Q_OS_VXWORKS
+#  include <selectLib.h>
+#endif
 #define QT_CONNECT_TIMEOUT 30000
 …
     // create the socket
     if (-1 == (d->connectingSocket = qSocket(PF_UNIX, SOCK_STREAM, 0))) {
+    if (-1 == (d->connectingSocket = qt_safe_socket(PF_UNIX, SOCK_STREAM, 0))) {
         d->errorOccurred(UnsupportedSocketOperationError,
                         QLatin1String("QLocalSocket::connectToServer"));
         return;
+    }
+#ifndef Q_OS_SYMBIAN
     // set non blocking so we can try to connect and it wont wait
     int flags = fcntl(d->connectingSocket, F_GETFL, 0);
 …
         return;
+    }
+#endif
     // _q_connectToSocket does the actual connecting
 …
     ::memcpy(name.sun_path, connectingPathName.toLatin1().data(),
              connectingPathName.toLatin1().size() + 1);
     if (-1 == qConnect(connectingSocket, (struct sockaddr *)&name, sizeof(name))) {
+    if (-1 == qt_safe_connect(connectingSocket, (struct sockaddr *)&name, sizeof(name))) {
         QString function = QLatin1String("QLocalSocket::connectToServer");
         switch (errno)
 …
             // Try again later, all of the sockets listening are full
             if (!delayConnect) {
                 delayConnect = new QSocketNotifier(connectingSocket, QSocketNotifier::Write);
+                delayConnect = new QSocketNotifier(connectingSocket, QSocketNotifier::Write, q);
                 q->connect(delayConnect, SIGNAL(activated(int)), q, SLOT(_q_connectToSocket()));
+            }
 …
     // connected!
+    if (delayConnect) {
+        delayConnect->setEnabled(false);
+        delete delayConnect;
+        delayConnect = 0;
+    }
+    cancelDelayedConnect();
     serverName = connectingName;
     fullServerName = connectingPathName;
 …
+}
+void QLocalSocketPrivate::cancelDelayedConnect()
+{
+    if (delayConnect) {
+        delayConnect->setEnabled(false);
+        delete delayConnect;
+        delayConnect = 0;
+        connectTimer->stop();
+        delete connectTimer;
+        connectTimer = 0;
+    }
+}
 quintptr QLocalSocket::socketDescriptor() const
+{
 …
     Q_D(QLocalSocket);
     d->unixSocket.close();
+    if (d->delayConnect) {
+        d->delayConnect->setEnabled(false);
+        delete d->delayConnect;
+        d->delayConnect = 0;
+        d->connectTimer->stop();
+        delete d->connectTimer;
+        d->connectTimer = 0;
+    }
+    d->cancelDelayedConnect();
     if (d->connectingSocket != -1)
         ::close(d->connectingSocket);
 …
         return (state() == ConnectedState);
     fd_set readfds;
     FD_ZERO(&readfds);
     FD_SET(d->connectingSocket, &readfds);
+    fd_set fds;
+    FD_ZERO(&fds);
+    FD_SET(d->connectingSocket, &fds);
     timeval timeout;
 …
     while (state() == ConnectingState
            && (-1 == msec || timer.elapsed() < msec)) {
+        result = ::select(d->connectingSocket + 1, &readfds, 0, 0, &timeout);
+#ifdef Q_OS_SYMBIAN
+        // On Symbian, ready-to-write is signaled when non-blocking socket
+        // connect is finised. Is ready-to-read really used on other
+        // UNIX paltforms when using non-blocking AF_UNIX socket?
+        result = ::select(d->connectingSocket + 1, 0, &fds, 0, &timeout);
+#else
+        result = ::select(d->connectingSocket + 1, &fds, 0, 0, &timeout);
+#endif
         if (-1 == result && errno != EINTR) {
             d->errorOccurred( QLocalSocket::UnknownSocketError,

trunk/src/network/socket/qlocalsocket_win.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$
 **
 …
 QT_BEGIN_NAMESPACE
-#define NOTIFYTIMEOUT 100
 void QLocalSocketPrivate::init()
+{
     Q_Q(QLocalSocket);
     QObject::connect(&dataNotifier, SIGNAL(timeout()), q, SLOT(_q_notified()));
+    memset(&overlapped, 0, sizeof(overlapped));
     overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
+    dataReadNotifier = new QWinEventNotifier(overlapped.hEvent, q);
+    q->connect(dataReadNotifier, SIGNAL(activated(HANDLE)), q, SLOT(_q_notified()));
+}
 …
        pipeWriter(0),
        readBufferMaxSize(0),
+       actualReadBufferSize(0),
        error(QLocalSocket::UnknownSocketError),
+       readyReadEmitted(false),
+       readSequenceStarted(false),
+       pendingReadyRead(false),
        pipeClosed(false),
        state(QLocalSocket::UnconnectedState)
 …
         DWORD permissions = (openMode & QIODevice::ReadOnly) ? GENERIC_READ : 0;
         permissions |= (openMode & QIODevice::WriteOnly) ? GENERIC_WRITE : 0;
+        QT_WA({
+        localSocket = CreateFileW(
+                       (TCHAR*)d->fullServerName.utf16(),   // pipe name
+                       permissions,
+,              // no sharing
+                       NULL,           // default security attributes
+                       OPEN_EXISTING,  // opens existing pipe
+,              // default attributes
+                       NULL);          // no template file
+        }, {
+        localSocket = CreateFileA(
+                       d->fullServerName.toLocal8Bit().constData(), // pipe name
+                       permissions,
+,              // no sharing
+                       NULL,           // default security attributes
+                       OPEN_EXISTING,  // opens existing pipe
+,              // default attributes
+                       NULL);          // no template file
+        });
+        localSocket = CreateFile((const wchar_t *)d->fullServerName.utf16(),   // pipe name
+                                 permissions,
+,              // no sharing
+                                 NULL,           // default security attributes
+                                 OPEN_EXISTING,  // opens existing pipe
+                                 FILE_FLAG_OVERLAPPED,
+                                 NULL);          // no template file
         if (localSocket != INVALID_HANDLE_VALUE)
             break;
 …
         // All pipe instances are busy, so wait until connected or up to 5 seconds.
+        QT_WA({
+            if (!WaitNamedPipeW((TCHAR*)d->fullServerName.utf16(), 5000))
+                break;
+        }, {
+            if (!WaitNamedPipeA(d->fullServerName.toLocal8Bit().constData(), 5000))
+                break;
+        });
+        if (!WaitNamedPipe((const wchar_t *)d->fullServerName.utf16(), 5000))
+            break;
+    }
 …
     // we have a valid handle
     d->serverName = name;
     if (setSocketDescriptor((quintptr)localSocket), openMode) {
+    if (setSocketDescriptor((quintptr)localSocket, ConnectedState, openMode)) {
         d->handle = localSocket;
         emit connected();
 …
+{
     Q_D(QLocalSocket);
+    if (d->readBuffer.isEmpty()) {
+        if (!d->readFromSocket()) {
+            if (d->pipeClosed)
+                return -1;
+            return 0;
+        }
+    }
+    if (!d->dataNotifier.isActive() && d->threadData->eventDispatcher)
+        d->dataNotifier.start(NOTIFYTIMEOUT);
+    if (d->readBuffer.isEmpty())
+        return qint64(0);
+    // If readFromSocket() read data, copy it to its destination.
+    if (maxSize == 1) {
+    qint64 readSoFar;
+    // If startAsyncRead() read data, copy it to its destination.
+    if (maxSize == 1 && d->actualReadBufferSize > 0) {
         *data = d->readBuffer.getChar();
+        return 1;
+    }
+    qint64 bytesToRead = qMin(qint64(d->readBuffer.size()), maxSize);
+    qint64 readSoFar = 0;
+    while (readSoFar < bytesToRead) {
+        const char *ptr = d->readBuffer.readPointer();
+        int bytesToReadFromThisBlock = qMin(int(bytesToRead - readSoFar),
+                                            d->readBuffer.nextDataBlockSize());
+        memcpy(data + readSoFar, ptr, bytesToReadFromThisBlock);
+        readSoFar += bytesToReadFromThisBlock;
+        d->readBuffer.free(bytesToReadFromThisBlock);
+    }
+        d->actualReadBufferSize--;
+        readSoFar = 1;
+    } else {
+        qint64 bytesToRead = qMin(qint64(d->actualReadBufferSize), maxSize);
+        readSoFar = 0;
+        while (readSoFar < bytesToRead) {
+            const char *ptr = d->readBuffer.readPointer();
+            int bytesToReadFromThisBlock = qMin(bytesToRead - readSoFar,
+                                                qint64(d->readBuffer.nextDataBlockSize()));
+            memcpy(data + readSoFar, ptr, bytesToReadFromThisBlock);
+            readSoFar += bytesToReadFromThisBlock;
+            d->readBuffer.free(bytesToReadFromThisBlock);
+            d->actualReadBufferSize -= bytesToReadFromThisBlock;
+        }
+    }
+    if (d->pipeClosed) {
+        if (readSoFar == 0) {
+            QTimer::singleShot(0, this, SLOT(_q_pipeClosed()));
+            return -1;  // signal EOF
+        }
+    } else {
+        if (!d->readSequenceStarted)
+            d->startAsyncRead();
+        d->checkReadyRead();
+    }
     return readSoFar;
+}
 …
 /*!
     \internal
     read from the socket
+    Schedules or cancels a readyRead() emission depending on actual data availability
  */
+qint64 QLocalSocketPrivate::readData(char *data, qint64 maxSize)
+{
+    DWORD bytesRead = 0;
+    overlapped.Offset = 0;
+    overlapped.OffsetHigh = 0;
+    bool success = ReadFile(handle, data, maxSize, &bytesRead, &overlapped);
+    if (!success && GetLastError() == ERROR_IO_PENDING)
+        if (GetOverlappedResult(handle, &overlapped, &bytesRead, TRUE))
+            success = true;
+    if (!success) {
+        setErrorString(QLatin1String("QLocalSocket::readData"));
+        return 0;
+    }
+    return bytesRead;
+void QLocalSocketPrivate::checkReadyRead()
+{
+    if (actualReadBufferSize > 0) {
+        if (!pendingReadyRead) {
+            Q_Q(QLocalSocket);
+            QTimer::singleShot(0, q, SLOT(_q_emitReadyRead()));
+            pendingReadyRead = true;
+        }
+    } else {
+        pendingReadyRead = false;
+    }
+}
 …
     Reads data from the socket into the readbuffer
  */
+bool QLocalSocketPrivate::readFromSocket()
+{
+    qint64 bytesToRead = bytesAvailable();
+    if (bytesToRead == 0)
+void QLocalSocketPrivate::startAsyncRead()
+{
+    do {
+        DWORD bytesToRead = bytesAvailable();
+        if (bytesToRead == 0) {
+            // There are no bytes in the pipe but we need to
+            // start the overlapped read with some buffer size.
+            bytesToRead = initialReadBufferSize;
+        }
+        if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - readBuffer.size())) {
+            bytesToRead = readBufferMaxSize - readBuffer.size();
+            if (bytesToRead == 0) {
+                // Buffer is full. User must read data from the buffer
+                // before we can read more from the pipe.
+                return;
+            }
+        }
+        char *ptr = readBuffer.reserve(bytesToRead);
+        readSequenceStarted = true;
+        if (ReadFile(handle, ptr, bytesToRead, NULL, &overlapped)) {
+            completeAsyncRead();
+        } else {
+            switch (GetLastError()) {
+                case ERROR_IO_PENDING:
+                    // This is not an error. We're getting notified, when data arrives.
+                    return;
+                case ERROR_PIPE_NOT_CONNECTED:
+                    {
+                        // It may happen, that the other side closes the connection directly
+                        // after writing data. Then we must set the appropriate socket state.
+                        pipeClosed = true;
+                        Q_Q(QLocalSocket);
+                        emit q->readChannelFinished();
+                        return;
+                    }
+                default:
+                    setErrorString(QLatin1String("QLocalSocketPrivate::startAsyncRead"));
+                    return;
+            }
+        }
+    } while (!readSequenceStarted);
+}
+/*!
+    \internal
+    Sets the correct size of the read buffer after a read operation.
+    Returns false, if an error occured or the connection dropped.
+ */
+bool QLocalSocketPrivate::completeAsyncRead()
+{
+    ResetEvent(overlapped.hEvent);
+    readSequenceStarted = false;
+    DWORD bytesRead;
+    if (!GetOverlappedResult(handle, &overlapped, &bytesRead, TRUE)) {
+        if (GetLastError() != ERROR_PIPE_NOT_CONNECTED)
+            setErrorString(QLatin1String("QLocalSocketPrivate::completeAsyncRead"));
         return false;
+    if (readBufferMaxSize && bytesToRead
+                     > (readBufferMaxSize - readBuffer.size()))
+        bytesToRead = readBufferMaxSize - readBuffer.size();
+    char *ptr = readBuffer.reserve(bytesToRead);
+    qint64 readBytes = readData(ptr, bytesToRead);
+    if (readBytes == 0) {
+        readBuffer.chop(bytesToRead);
+        return false;
+    }
+    readyReadEmitted = false;
+    readBuffer.chop(int(bytesToRead - (readBytes < 0 ? qint64(0) : readBytes)));
+    }
+    actualReadBufferSize += bytesRead;
+    readBuffer.truncate(actualReadBufferSize);
     return true;
+}
 …
     if (!d->pipeWriter) {
         d->pipeWriter = new QWindowsPipeWriter(d->handle, this);
+        connect(d->pipeWriter, SIGNAL(canWrite()), this, SLOT(_q_canWrite()));
+        connect(d->pipeWriter, SIGNAL(bytesWritten(qint64)), this, SIGNAL(bytesWritten(qint64)));
         d->pipeWriter->start();
-        connect(d->pipeWriter, SIGNAL(canWrite()), this, SLOT(_q_canWrite()));
+    }
     return d->pipeWriter->write(data, maxSize);
 …
     The number of bytes available from the pipe
   */
 qint64 QLocalSocketPrivate::bytesAvailable()
+DWORD QLocalSocketPrivate::bytesAvailable()
+{
     Q_Q(QLocalSocket);
-    if (q->state() != QLocalSocket::ConnectedState)
-        return 0;
     DWORD bytes;
     if (PeekNamedPipe(handle, NULL, 0, NULL, &bytes, NULL)) {
         return bytes;
     } else {
         if (ERROR_BROKEN_PIPE == GetLastError() && !pipeClosed) {
+        if (!pipeClosed) {
             pipeClosed = true;
+            emit q->readChannelFinished();
             QTimer::singleShot(0, q, SLOT(_q_pipeClosed()));
+        }
 …
     Q_D(const QLocalSocket);
     qint64 available = QIODevice::bytesAvailable();
     available += (qint64) d->readBuffer.size();
+    available += (qint64) d->actualReadBufferSize;
     return available;
+}
 …
     if (state() != ConnectedState)
         return false;
+    return (d->readBuffer.indexOf('\n') != -1 || QIODevice::canReadLine());
+    return (QIODevice::canReadLine()
+            || d->readBuffer.indexOf('\n', d->actualReadBufferSize) != -1);
+}
 …
     d->state = ClosingState;
     emit stateChanged(d->state);
     d->readyReadEmitted = false;
     emit readChannelFinished();
+    if (!d->pipeClosed)
+        emit readChannelFinished();
     d->serverName = QString();
     d->fullServerName = QString();
 …
         return;
+    }
+    d->readSequenceStarted = false;
+    d->pendingReadyRead = false;
     d->pipeClosed = false;
     DisconnectNamedPipe(d->handle);
     CloseHandle(d->handle);
     d->handle = INVALID_HANDLE_VALUE;
+    ResetEvent(d->overlapped.hEvent);
     d->state = UnconnectedState;
     emit stateChanged(d->state);
 …
         d->pipeWriter = 0;
+    }
-    d->dataNotifier.stop();
+}
 …
     Q_D(QLocalSocket);
     d->readBuffer.clear();
+    d->actualReadBufferSize = 0;
     QIODevice::open(openMode);
     d->handle = (int*)socketDescriptor;
     d->state = socketState;
     emit stateChanged(d->state);
+    if (d->threadData->eventDispatcher)
+        d->dataNotifier.start(NOTIFYTIMEOUT);
+    if (d->state == ConnectedState && openMode.testFlag(QIODevice::ReadOnly)) {
+        d->startAsyncRead();
+        d->checkReadyRead();
+    }
     return true;
+}
 …
+{
     Q_Q(QLocalSocket);
+    if (0 != bytesAvailable()) {
+        if (readBufferMaxSize == 0 || readBuffer.size() < readBufferMaxSize) {
+            if (!readFromSocket()) {
+                return;
+            }
+            // wait until buffer is cleared before starting again
+            if (readBufferMaxSize && readBuffer.size() == readBufferMaxSize) {
+                dataNotifier.stop();
+            }
+        }
+        if (!readyReadEmitted) {
+            readyReadEmitted = true;
+            q->emit readyRead();
+        }
+    if (!completeAsyncRead()) {
+        pipeClosed = true;
+        emit q->readChannelFinished();
+        return;
+    }
+    startAsyncRead();
+    pendingReadyRead = false;
+    emit q->readyRead();
+}
+void QLocalSocketPrivate::_q_emitReadyRead()
+{
+    if (pendingReadyRead) {
+        Q_Q(QLocalSocket);
+        pendingReadyRead = false;
+        emit q->readyRead();
+    }
+}
 …
     if (state() == UnconnectedState)
         return false;
+    if (!openMode().testFlag(QIODevice::ReadOnly)) {
+        qWarning("QLocalSocket::waitForDisconnected isn't supported for write only pipes.");
+        return false;
+    }
     QIncrementalSleepTimer timer(msecs);
     forever {
         d->_q_notified();
         if (d->pipeClosed)
             close();
+        d->bytesAvailable();    // to check if PeekNamedPipe fails
+        if (d->pipeClosed)
+            close();
         if (state() == UnconnectedState)
             return true;
 …
+{
     Q_D(QLocalSocket);
+    QIncrementalSleepTimer timer(msecs);
+    forever {
+        d->_q_notified();
+        if (bytesAvailable() > 0) {
+            if (!d->readyReadEmitted) {
+                d->readyReadEmitted = true;
+                emit readyRead();
+            }
+    if (bytesAvailable() > 0)
+        return true;
+    if (d->state != QLocalSocket::ConnectedState)
+        return false;
+    Q_ASSERT(d->readSequenceStarted);
+    DWORD result = WaitForSingleObject(d->overlapped.hEvent, msecs == -1 ? INFINITE : msecs);
+    switch (result) {
+        case WAIT_OBJECT_0:
+            d->_q_notified();
             return true;
+        }
+        Sleep(timer.nextSleepTime());
+        if (timer.hasTimedOut())
+            break;
+    }
+        case WAIT_TIMEOUT:
+            return false;
+    }
+    qWarning("QLocalSocket::waitForReadyRead WaitForSingleObject failed with error code %d.", int(GetLastError()));
     return false;
+}
 …
         return false;
+    QIncrementalSleepTimer timer(msecs);
+    forever {
+        if (d->pipeWriter->hadWritten())
+            return true;
+        if (d->pipeWriter->bytesToWrite() == 0)
+            return false;
+        // Wait for the pipe writer to acknowledge that it has
+        // written. This will succeed if either the pipe writer has
+        // already written the data, or if it manages to write data
+        // within the given timeout.
+        if (d->pipeWriter->waitForWrite(0))
+            return true;
+        Sleep(timer.nextSleepTime());
+        if (timer.hasTimedOut())
+            break;
+    }
+    return false;
+    // Wait for the pipe writer to acknowledge that it has
+    // written. This will succeed if either the pipe writer has
+    // already written the data, or if it manages to write data
+    // within the given timeout.
+    return d->pipeWriter->waitForWrite(msecs);
+}

trunk/src/network/socket/qnativesocketengine.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
     switch (errorString) {
     case NonBlockingInitFailedErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Unable to initialize non-blocking socket"));
+        socketErrorString = QNativeSocketEngine::tr("Unable to initialize non-blocking socket");
         break;
     case BroadcastingInitFailedErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Unable to initialize broadcast socket"));
+        socketErrorString = QNativeSocketEngine::tr("Unable to initialize broadcast socket");
         break;
     case NoIpV6ErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Attempt to use IPv6 socket on a platform with no IPv6 support"));
+        socketErrorString = QNativeSocketEngine::tr("Attempt to use IPv6 socket on a platform with no IPv6 support");
         break;
     case RemoteHostClosedErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "The remote host closed the connection"));
+        socketErrorString = QNativeSocketEngine::tr("The remote host closed the connection");
         break;
     case TimeOutErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Network operation timed out"));
+        socketErrorString = QNativeSocketEngine::tr("Network operation timed out");
         break;
     case ResourceErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Out of resources"));
+        socketErrorString = QNativeSocketEngine::tr("Out of resources");
         break;
     case OperationUnsupportedErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Unsupported socket operation"));
+        socketErrorString = QNativeSocketEngine::tr("Unsupported socket operation");
         break;
     case ProtocolUnsupportedErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Protocol type not supported"));
+        socketErrorString = QNativeSocketEngine::tr("Protocol type not supported");
         break;
     case InvalidSocketErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Invalid socket descriptor"));
+        socketErrorString = QNativeSocketEngine::tr("Invalid socket descriptor");
         break;
     case HostUnreachableErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Host unreachable"));
+        socketErrorString = QNativeSocketEngine::tr("Host unreachable");
         break;
     case NetworkUnreachableErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Network unreachable"));
+        socketErrorString = QNativeSocketEngine::tr("Network unreachable");
         break;
     case AccessErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Permission denied"));
+        socketErrorString = QNativeSocketEngine::tr("Permission denied");
         break;
     case ConnectionTimeOutErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Connection timed out"));
+        socketErrorString = QNativeSocketEngine::tr("Connection timed out");
         break;
     case ConnectionRefusedErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Connection refused"));
+        socketErrorString = QNativeSocketEngine::tr("Connection refused");
         break;
     case AddressInuseErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "The bound address is already in use"));
+        socketErrorString = QNativeSocketEngine::tr("The bound address is already in use");
         break;
     case AddressNotAvailableErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "The address is not available"));
+        socketErrorString = QNativeSocketEngine::tr("The address is not available");
         break;
     case AddressProtectedErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "The address is protected"));
+        socketErrorString = QNativeSocketEngine::tr("The address is protected");
         break;
     case DatagramTooLargeErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Datagram was too large to send"));
+        socketErrorString = QNativeSocketEngine::tr("Datagram was too large to send");
         break;
     case SendDatagramErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Unable to send a message"));
+        socketErrorString = QNativeSocketEngine::tr("Unable to send a message");
         break;
     case ReceiveDatagramErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Unable to receive a message"));
+        socketErrorString = QNativeSocketEngine::tr("Unable to receive a message");
         break;
     case WriteErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Unable to write"));
+        socketErrorString = QNativeSocketEngine::tr("Unable to write");
         break;
     case ReadErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Network error"));
+        socketErrorString = QNativeSocketEngine::tr("Network error");
         break;
     case PortInuseErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Another socket is already listening on the same port"));
+        socketErrorString = QNativeSocketEngine::tr("Another socket is already listening on the same port");
         break;
     case NotSocketErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Operation on non-socket"));
+        socketErrorString = QNativeSocketEngine::tr("Operation on non-socket");
         break;
     case InvalidProxyTypeString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "The proxy type is invalid for this operation"));
+        socketErrorString = QNativeSocketEngine::tr("The proxy type is invalid for this operation");
         break;
     case UnknownSocketErrorString:
         socketErrorString = QLatin1String(QT_TRANSLATE_NOOP("QNativeSocketEngine", "Unknown error"));
+        socketErrorString = QNativeSocketEngine::tr("Unknown error");
         break;
+    }
 …
+    }
     // Make sure we receive out-of-band data
+    // On Symbian OS this works only with native IP stack, not with WinSock
     if (socketType == QAbstractSocket::TcpSocket
         && !setOption(ReceiveOutOfBandData, 1)) {
 …
+    }
+    // Set the send and receive buffer sizes to a magic size, found
+    // most optimal for our platforms.
+    setReceiveBufferSize(49152);
+    setSendBufferSize(49152);
+    // Before Qt 4.6, we always set the send and receive buffer size to 49152 as
+    // this was found to be an optimal value. However, modern OS
+    // all have some kind of auto tuning for this and we therefore don't set
+    // this explictly anymore.
+    // If it introduces any performance regressions for Qt 4.6.x (x > 0) then
+    // it will be put back in.
+    //
+    // You can use tests/manual/qhttpnetworkconnection to test HTTP download speed
+    // with this.
+    //
+    // pre-4.6:
+    // setReceiveBufferSize(49152);
+    // setSendBufferSize(49152);
     d->socketType = socketType;
 …
+}
+qint64 QNativeSocketEngine::bytesToWrite() const
+{
+    return 0;
+}
 /*!
     Reads up to \a maxSize bytes into \a data from the socket.
 …
 bool QNativeSocketEngine::waitForWrite(int msecs, bool *timedOut)
+{
     Q_D(const QNativeSocketEngine);
+    Q_D(QNativeSocketEngine);
     Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::waitForWrite(), false);
     Q_CHECK_NOT_STATE(QNativeSocketEngine::waitForWrite(),
 …
         d_func()->fetchConnectionParameters();
         return true;
+    } else {
+        int value = 0;
+        int valueSize = sizeof(value);
+        if (::getsockopt(d->socketDescriptor, SOL_SOCKET, SO_ERROR, (char *) &value, &valueSize) == 0) {
+            if (value == WSAECONNREFUSED) {
+                d->setError(QAbstractSocket::ConnectionRefusedError, QNativeSocketEnginePrivate::ConnectionRefusedErrorString);
+                d->socketState = QAbstractSocket::UnconnectedState;
+                return false;
+            } else if (value == WSAETIMEDOUT) {
+                d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::ConnectionTimeOutErrorString);
+                d->socketState = QAbstractSocket::UnconnectedState;
+                return false;
+            } else if (value == WSAEHOSTUNREACH) {
+                d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::HostUnreachableErrorString);
+                d->socketState = QAbstractSocket::UnconnectedState;
+                return false;
+            }
+        }
+    }
 #endif
 …
                                       int msecs, bool *timedOut)
+{
     Q_D(const QNativeSocketEngine);
+    Q_D(QNativeSocketEngine);
     Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::waitForWrite(), false);
     Q_CHECK_NOT_STATE(QNativeSocketEngine::waitForReadOrWrite(),
 …
         d_func()->fetchConnectionParameters();
         return true;
+    }
+#endif
+    } else {
+        int value = 0;
+        int valueSize = sizeof(value);
+        if (::getsockopt(d->socketDescriptor, SOL_SOCKET, SO_ERROR, (char *) &value, &valueSize) == 0) {
+            if (value == WSAECONNREFUSED) {
+                d->setError(QAbstractSocket::ConnectionRefusedError, QNativeSocketEnginePrivate::ConnectionRefusedErrorString);
+                d->socketState = QAbstractSocket::UnconnectedState;
+                return false;
+            } else if (value == WSAETIMEDOUT) {
+                d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::ConnectionTimeOutErrorString);
+                d->socketState = QAbstractSocket::UnconnectedState;
+                return false;
+            } else if (value == WSAEHOSTUNREACH) {
+                d->setError(QAbstractSocket::NetworkError, QNativeSocketEnginePrivate::HostUnreachableErrorString);
+                d->socketState = QAbstractSocket::UnconnectedState;
+                return false;
+            }
+        }
+    }
+#endif
     if (ret == 0) {
         if (timedOut)
 …
+{
     if (e->type() == QEvent::SockAct) {
+        engine->exceptionNotification();
+        if (engine->state() == QAbstractSocket::ConnectingState)
+            engine->connectionNotification();
+        else
+            engine->exceptionNotification();
         return true;
+    }

trunk/src/network/socket/qnativesocketengine_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$
 **
 …
 // We mean it.
 //
 #include "QtNetwork/qhostaddress.h"
 #include "private/qabstractsocketengine_p.h"
 #ifndef Q_OS_WIN
+#include "qplatformdefs.h"
+#  include "qplatformdefs.h"
+#else
+#  include <winsock2.h>
+#endif
+#ifdef Q_OS_SYMBIAN
+#include <private/qeventdispatcher_symbian_p.h>
+#include <unistd.h>
 #endif
 QT_BEGIN_NAMESPACE
+#ifndef Q_OS_WIN
+// Almost always the same. If not, specify in qplatformdefs.h.
+#if !defined(QT_SOCKOPTLEN_T)
+# define QT_SOCKOPTLEN_T QT_SOCKLEN_T
+#endif
+// Tru64 redefines accept -> _accept with _XOPEN_SOURCE_EXTENDED
+static inline int qt_socket_accept(int s, struct sockaddr *addr, QT_SOCKLEN_T *addrlen)
+{ return ::accept(s, addr, static_cast<QT_SOCKLEN_T *>(addrlen)); }
+#if defined(accept)
+# undef accept
+#endif
+// UnixWare 7 redefines listen -> _listen
+static inline int qt_socket_listen(int s, int backlog)
+{ return ::listen(s, backlog); }
+#if defined(listen)
+# undef listen
+#endif
+// UnixWare 7 redefines socket -> _socket
+static inline int qt_socket_socket(int domain, int type, int protocol)
+{ return ::socket(domain, type, protocol); }
+#if defined(socket)
+# undef socket
+#endif
+#endif
+// Use our own defines and structs which we know are correct
+#  define QT_SS_MAXSIZE 128
+#  define QT_SS_ALIGNSIZE (sizeof(qint64))
+#  define QT_SS_PAD1SIZE (QT_SS_ALIGNSIZE - sizeof (short))
+#  define QT_SS_PAD2SIZE (QT_SS_MAXSIZE - (sizeof (short) + QT_SS_PAD1SIZE + QT_SS_ALIGNSIZE))
+struct qt_sockaddr_storage {
+      short ss_family;
+      char __ss_pad1[QT_SS_PAD1SIZE];
+      qint64 __ss_align;
+      char __ss_pad2[QT_SS_PAD2SIZE];
+};
+// sockaddr_in6 size changed between old and new SDK
+// Only the new version is the correct one, so always
+// use this structure.
+struct qt_in6_addr {
+    quint8 qt_s6_addr[16];
+};
+struct qt_sockaddr_in6 {
+    short   sin6_family;            /* AF_INET6 */
+    quint16 sin6_port;              /* Transport level port number */
+    quint32 sin6_flowinfo;          /* IPv6 flow information */
+    struct  qt_in6_addr sin6_addr;  /* IPv6 address */
+    quint32 sin6_scope_id;          /* set of interfaces for a scope */
+};
+union qt_sockaddr {
+    sockaddr a;
+    sockaddr_in a4;
+    qt_sockaddr_in6 a6;
+    qt_sockaddr_storage storage;
+};
 class QNativeSocketEnginePrivate;
 …
     bool hasPendingDatagrams() const;
     qint64 pendingDatagramSize() const;
+    qint64 bytesToWrite() const;
     qint64 receiveBufferSize() const;

trunk/src/network/socket/qnativesocketengine_unix.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 QNATIVESOCKETENGINE_DEBUG
 #include "qnativesocketengine_p.h"
+#include "private/qnet_unix_p.h"
 #include "qiodevice.h"
 #include "qhostaddress.h"
 …
 #include <qstring.h>
 #include <ctype.h>
+#endif
+#ifdef Q_OS_SYMBIAN // ### TODO: Are these headers right?
+#include <sys/socket.h>
+#include <netinet/in.h>
+#else
+#include <netinet/tcp.h>
 #endif
 …
 static void qt_ignore_sigpipe()
+{
+#ifndef Q_NO_POSIX_SIGNALS
     // Set to ignore SIGPIPE once only.
     static QBasicAtomicInt atom = Q_BASIC_ATOMIC_INITIALIZER(0);
 …
         ::sigaction(SIGPIPE, &noaction, 0);
+    }
+#else
+    // Posix signals are not supported by the underlying platform
+    // so we don't need to ignore sigpipe signal explicitly
+#endif
+}
 …
     \a port and \a addr if they are non-null.
 */
 static inline void qt_socket_getPortAndAddress(struct sockaddr *sa, quint16 *port, QHostAddress *addr)
+static inline void qt_socket_getPortAndAddress(const qt_sockaddr *s, quint16 *port, QHostAddress *addr)
+{
 #if !defined(QT_NO_IPV6)
+    if (sa->sa_family == AF_INET6) {
+        struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *)sa;
+    if (s->a.sa_family == AF_INET6) {
         Q_IPV6ADDR tmp;
         memcpy(&tmp, &sa6->sin6_addr.s6_addr, sizeof(tmp));
+        memcpy(&tmp, &s->a6.sin6_addr, sizeof(tmp));
         if (addr) {
             QHostAddress tmpAddress;
 …
 #ifndef QT_NO_IPV6IFNAME
             char scopeid[IFNAMSIZ];
             if (::if_indextoname(sa6->sin6_scope_id, scopeid) > 0) {
+            if (::if_indextoname(s->a6.sin6_scope_id, scopeid)) {
                 addr->setScopeId(QLatin1String(scopeid));
             } else
 #endif
             addr->setScopeId(QString::number(sa6->sin6_scope_id));
+            addr->setScopeId(QString::number(s->a6.sin6_scope_id));
+        }
         if (port)
             *port = ntohs(sa6->sin6_port);
+            *port = ntohs(s->a6.sin6_port);
         return;
+    }
 #endif
-    struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
     if (port)
         *port = ntohs(sa4->sin_port);
+        *port = ntohs(s->a4.sin_port);
     if (addr) {
         QHostAddress tmpAddress;
         tmpAddress.setAddress(ntohl(sa4->sin_addr.s_addr));
+        tmpAddress.setAddress(ntohl(s->a4.sin_addr.s_addr));
         *addr = tmpAddress;
+    }
 …
 #endif
     int type = (socketType == QAbstractSocket::UdpSocket) ? SOCK_DGRAM : SOCK_STREAM;
+    int socket = qt_socket_socket(protocol, type, 0);
+#ifdef Q_OS_SYMBIAN
+    int socket = ::socket(protocol, type, 0);
+#else
+        int socket = qt_safe_socket(protocol, type, 0);
+#endif
     if (socket <= 0) {
 …
     // Ensure that the socket is closed on exec*().
     ::fcntl(socket, F_SETFD, FD_CLOEXEC);
     socketDescriptor = socket;
     return true;
 …
     int n = -1;
+    int level = SOL_SOCKET; // default
     switch (opt) {
     case QNativeSocketEngine::ReceiveBufferSocketOption:
 …
         n = SO_OOBINLINE;
         break;
+    case QNativeSocketEngine::LowDelayOption:
+        level = IPPROTO_TCP;
+        n = TCP_NODELAY;
+        break;
+    case QNativeSocketEngine::KeepAliveOption:
+        n = SO_KEEPALIVE;
+        break;
+    }
     int v = -1;
     QT_SOCKOPTLEN_T len = sizeof(v);
     if (getsockopt(socketDescriptor, SOL_SOCKET, n, (char *) &v, &len) != -1)
+    if (::getsockopt(socketDescriptor, level, n, (char *) &v, &len) != -1)
         return v;
     return -1;
+}
 …
     int n = 0;
+    int level = SOL_SOCKET; // default
     switch (opt) {
     case QNativeSocketEngine::ReceiveBufferSocketOption:
 …
     case QNativeSocketEngine::NonBlockingSocketOption: {
         // Make the socket nonblocking.
+#if !defined(Q_OS_VXWORKS)
         int flags = ::fcntl(socketDescriptor, F_GETFL, 0);
         if (flags == -1) {
 …
             return false;
+        }
+#else // Q_OS_VXWORKS
+        int onoff = 1;
+#ifdef Q_OS_SYMBIAN
+        if (::ioctl(socketDescriptor, FIONBIO, &onoff) < 0) {
+#else
+        if (qt_safe_ioctl(socketDescriptor, FIONBIO, &onoff) < 0) {
+#endif
+#ifdef QNATIVESOCKETENGINE_DEBUG
+            perror("QNativeSocketEnginePrivate::setOption(): ioctl(FIONBIO, 1) failed");
+#endif
+            return false;
+        }
+#endif // Q_OS_VXWORKS
         return true;
+    }
     case QNativeSocketEngine::AddressReusable:
 #ifdef SO_REUSEPORT
+#if defined(SO_REUSEPORT) && !defined(Q_OS_SYMBIAN)
         n = SO_REUSEPORT;
 #else
 …
         n = SO_OOBINLINE;
         break;
+    }
+    return ::setsockopt(socketDescriptor, SOL_SOCKET, n, (char *) &v, sizeof(v)) == 0;
+    case QNativeSocketEngine::LowDelayOption:
+        level = IPPROTO_TCP;
+        n = TCP_NODELAY;
+        break;
+    case QNativeSocketEngine::KeepAliveOption:
+        n = SO_KEEPALIVE;
+        break;
+    }
+    return ::setsockopt(socketDescriptor, level, n, (char *) &v, sizeof(v)) == 0;
+}
 bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &addr, quint16 port)
+{
+#ifdef QNATIVESOCKETENGINE_DEBUG
+    qDebug("QNativeSocketEnginePrivate::nativeConnect() : %d ", socketDescriptor);
+#endif
     struct sockaddr_in sockAddrIPv4;
     struct sockaddr *sockAddrPtr = 0;
 …
         // unreachable
+    }
+    int connectResult = QT_SOCKET_CONNECT(socketDescriptor, sockAddrPtr, sockAddrSize);
+#ifdef Q_OS_SYMBIAN
+    int connectResult = ::connect(socketDescriptor, sockAddrPtr, sockAddrSize);
+#else
+    int connectResult = qt_safe_connect(socketDescriptor, sockAddrPtr, sockAddrSize);
+#endif
     if (connectResult == -1) {
         switch (errno) {
 …
     int bindResult = QT_SOCKET_BIND(socketDescriptor, sockAddrPtr, sockAddrSize);
     if (bindResult < 0) {
         switch(errno) {
 …
 bool QNativeSocketEnginePrivate::nativeListen(int backlog)
+{
+    if (qt_socket_listen(socketDescriptor, backlog) < 0) {
+#ifdef Q_OS_SYMBIAN
+    if (::listen(socketDescriptor, backlog) < 0) {
+#else
+    if (qt_safe_listen(socketDescriptor, backlog) < 0) {
+#endif
         switch (errno) {
         case EADDRINUSE:
 …
 int QNativeSocketEnginePrivate::nativeAccept()
+{
+    int acceptedDescriptor = qt_socket_accept(socketDescriptor, 0, 0);
+#if defined (QNATIVESOCKETENGINE_DEBUG)
+    qDebug("QNativeSocketEnginePrivate::nativeAccept() == %i", acceptedDescriptor);
+#endif
+    // Ensure that the socket is closed on exec*()
+    ::fcntl(acceptedDescriptor, F_SETFD, FD_CLOEXEC);
+#ifdef Q_OS_SYMBIAN
+    int acceptedDescriptor = ::accept(socketDescriptor, 0, 0);
+#else
+    int acceptedDescriptor = qt_safe_accept(socketDescriptor, 0, 0);
+#endif
+    //check if we have vaild descriptor at all
+    if(acceptedDescriptor > 0) {
+        // Ensure that the socket is closed on exec*()
+        ::fcntl(acceptedDescriptor, F_SETFD, FD_CLOEXEC);
+    }
+#ifdef Q_OS_SYMBIAN
+    else {
+        qWarning("QNativeSocketEnginePrivate::nativeAccept() - acceptedDescriptor <= 0");
+    }
+#endif
     return acceptedDescriptor;
+}
 …
 qint64 QNativeSocketEnginePrivate::nativeBytesAvailable() const
+{
+    /*
+      Apparently, there is not consistency among different operating
+      systems on how to use FIONREAD.
+      FreeBSD, Linux and Solaris all expect the 3rd argument to
+      ioctl() to be an int, which is normally 32-bit even on 64-bit
+      machines.
+      IRIX, on the other hand, expects a size_t, which is 64-bit on
+-bit machines.
+      So, the solution is to use size_t initialized to zero to make
+      sure all bits are set to zero, preventing underflow with the
+      FreeBSD/Linux/Solaris ioctls.
+    */
+    size_t nbytes = 0;
+    int nbytes = 0;
     // gives shorter than true amounts on Unix domain sockets.
     qint64 available = 0;
+    if (::ioctl(socketDescriptor, FIONREAD, (char *) &nbytes) >= 0)
+        available = (qint64) *((int *) &nbytes);
+#ifdef Q_OS_SYMBIAN
+        if (::ioctl(socketDescriptor, FIONREAD, (char *) &nbytes) >= 0)
+#else
+    if (qt_safe_ioctl(socketDescriptor, FIONREAD, (char *) &nbytes) >= 0)
+#endif
+        available = (qint64) nbytes;
 #if defined (QNATIVESOCKETENGINE_DEBUG)
 …
+{
     // Create a sockaddr struct and reset its port number.
+#if !defined(QT_NO_IPV6)
+    struct sockaddr_storage storage;
+    sockaddr_in6 *storagePtrIPv6 = reinterpret_cast<sockaddr_in6 *>(&storage);
+    storagePtrIPv6->sin6_port = 0;
+#else
+    struct sockaddr storage;
+#endif
+    sockaddr *storagePtr = reinterpret_cast<sockaddr *>(&storage);
+    storagePtr->sa_family = 0;
+    sockaddr_in *storagePtrIPv4 = reinterpret_cast<sockaddr_in *>(&storage);
+    storagePtrIPv4->sin_port = 0;
+    qt_sockaddr storage;
     QT_SOCKLEN_T storageSize = sizeof(storage);
+    memset(&storage, 0, storageSize);
     // Peek 0 bytes into the next message. The size of the message may
 …
     do {
         char c;
         readBytes = ::recvfrom(socketDescriptor, &c, 1, MSG_PEEK, storagePtr, &storageSize);
+        readBytes = ::recvfrom(socketDescriptor, &c, 1, MSG_PEEK, &storage.a, &storageSize);
     } while (readBytes == -1 && errno == EINTR);
 …
+}
+#ifdef Q_OS_SYMBIAN
+qint64 QNativeSocketEnginePrivate::nativePendingDatagramSize() const
+{
+    size_t nbytes = 0;
+    ::ioctl(socketDescriptor, E32IONREAD, (char *) &nbytes);
+    return qint64(nbytes-28);
+}
+#else
 qint64 QNativeSocketEnginePrivate::nativePendingDatagramSize() const
+{
     QVarLengthArray<char, 8192> udpMessagePeekBuffer(8192);
     ssize_t recvResult = -1;
     for (;;) {
         // the data written to udpMessagePeekBuffer is discarded, so
 …
         // so.
         recvResult = ::recv(socketDescriptor, udpMessagePeekBuffer.data(),
                             udpMessagePeekBuffer.size(), MSG_PEEK);
+            udpMessagePeekBuffer.size(), MSG_PEEK);
         if (recvResult == -1 && errno == EINTR)
             continue;
 …
     return qint64(recvResult);
+}
+#endif
 qint64 QNativeSocketEnginePrivate::nativeReceiveDatagram(char *data, qint64 maxSize,
                                                     QHostAddress *address, quint16 *port)
+{
+#if !defined(QT_NO_IPV6)
+    struct sockaddr_storage aa;
+#else
+    struct sockaddr_in aa;
+#endif
+    qt_sockaddr aa;
     memset(&aa, 0, sizeof(aa));
     QT_SOCKLEN_T sz;
 …
         char c;
         recvFromResult = ::recvfrom(socketDescriptor, maxSize ? data : &c, maxSize ? maxSize : 1,
 , (struct sockaddr *)&aa, &sz);
+, &aa.a, &sz);
     } while (recvFromResult == -1 && errno == EINTR);
 …
         setError(QAbstractSocket::NetworkError, ReceiveDatagramErrorString);
     } else if (port || address) {
         qt_socket_getPortAndAddress((struct sockaddr *) &aa, port, address);
+        qt_socket_getPortAndAddress(&aa, port, address);
+    }
 …
     struct sockaddr_in6 sockAddrIPv6;
     if (host.protocol() == QAbstractSocket::IPv6Protocol) {
         memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6));
         sockAddrIPv6.sin6_family = AF_INET6;
         sockAddrIPv6.sin6_port = htons(port);
         Q_IPV6ADDR tmp = host.toIPv6Address();
         memcpy(&sockAddrIPv6.sin6_addr.s6_addr, &tmp, sizeof(tmp));
         sockAddrSize = sizeof(sockAddrIPv6);
         sockAddrPtr = (struct sockaddr *)&sockAddrIPv6;
+    memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6));
+    sockAddrIPv6.sin6_family = AF_INET6;
+    sockAddrIPv6.sin6_port = htons(port);
+    Q_IPV6ADDR tmp = host.toIPv6Address();
+    memcpy(&sockAddrIPv6.sin6_addr.s6_addr, &tmp, sizeof(tmp));
+    sockAddrSize = sizeof(sockAddrIPv6);
+    sockAddrPtr = (struct sockaddr *)&sockAddrIPv6;
     } else
 #endif
     if (host.protocol() == QAbstractSocket::IPv4Protocol) {
         memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4));
         sockAddrIPv4.sin_family = AF_INET;
         sockAddrIPv4.sin_port = htons(port);
         sockAddrIPv4.sin_addr.s_addr = htonl(host.toIPv4Address());
         sockAddrSize = sizeof(sockAddrIPv4);
         sockAddrPtr = (struct sockaddr *)&sockAddrIPv4;
+    memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4));
+    sockAddrIPv4.sin_family = AF_INET;
+    sockAddrIPv4.sin_port = htons(port);
+    sockAddrIPv4.sin_addr.s_addr = htonl(host.toIPv4Address());
+    sockAddrSize = sizeof(sockAddrIPv4);
+    sockAddrPtr = (struct sockaddr *)&sockAddrIPv4;
+    }
     // ignore the SIGPIPE signal
     qt_ignore_sigpipe();
+    ssize_t sentBytes;
+    do {
+        sentBytes = ::sendto(socketDescriptor, data, len,
+, sockAddrPtr, sockAddrSize);
+    } while (sentBytes == -1 && errno == EINTR);
+#ifdef Q_OS_SYMBIAN
+    ssize_t sentBytes = ::sendto(socketDescriptor, data, len,
+, sockAddrPtr, sockAddrSize);
+#else
+    ssize_t sentBytes = qt_safe_sendto(socketDescriptor, data, len,
+, sockAddrPtr, sockAddrSize);
+#endif
     if (sentBytes < 0) {
 …
         return false;
+#if !defined(QT_NO_IPV6)
+    struct sockaddr_storage sa;
+#else
+    struct sockaddr_in sa;
+#endif
+    struct sockaddr *sockAddrPtr = (struct sockaddr *) &sa;
+    qt_sockaddr sa;
     QT_SOCKLEN_T sockAddrSize = sizeof(sa);
     // Determine local address
     memset(&sa, 0, sizeof(sa));
     if (::getsockname(socketDescriptor, sockAddrPtr, &sockAddrSize) == 0) {
         qt_socket_getPortAndAddress(sockAddrPtr, &localPort, &localAddress);
+    if (::getsockname(socketDescriptor, &sa.a, &sockAddrSize) == 0) {
+        qt_socket_getPortAndAddress(&sa, &localPort, &localAddress);
         // Determine protocol family
         switch (sockAddrPtr->sa_family) {
+        switch (sa.a.sa_family) {
         case AF_INET:
             socketProtocol = QAbstractSocket::IPv4Protocol;
 …
     // Determine the remote address
     if (!::getpeername(socketDescriptor, sockAddrPtr, &sockAddrSize))
         qt_socket_getPortAndAddress(sockAddrPtr, &peerPort, &peerAddress);
+    if (!::getpeername(socketDescriptor, &sa.a, &sockAddrSize))
+        qt_socket_getPortAndAddress(&sa, &peerPort, &peerAddress);
     // Determine the socket type (UDP/TCP)
 …
     qDebug("QNativeSocketEngine::nativeClose()");
 #endif
+#ifdef Q_OS_SYMBIAN
     ::close(socketDescriptor);
+#else
+        qt_safe_close(socketDescriptor);
+#endif
+}
 …
     ssize_t writtenBytes;
     do {
+        writtenBytes = ::write(socketDescriptor, data, len);
+#ifdef Q_OS_SYMBIAN
+            writtenBytes = ::write(socketDescriptor, data, len);
+#else
+        writtenBytes = qt_safe_write(socketDescriptor, data, len);
+#endif
+        // writtenBytes = QT_WRITE(socketDescriptor, data, len); ### TODO S60: Should this line be removed or the one above it?
     } while (writtenBytes < 0 && errno == EINTR);
 …
     ssize_t r = 0;
     do {
+#ifdef Q_OS_SYMBIAN
         r = ::read(socketDescriptor, data, maxSize);
+#else
+        r = qt_safe_read(socketDescriptor, data, maxSize);
+#endif
     } while (r == -1 && errno == EINTR);
 …
             setError(QAbstractSocket::NetworkError, ReadErrorString);
             break;
+#ifdef Q_OS_SYMBIAN
+        case EPIPE:
+#endif
         case ECONNRESET:
+#if defined(Q_OS_VXWORKS)
+        case ESHUTDOWN:
+#endif
             r = 0;
             break;
 …
     tv.tv_usec = (timeout % 1000) * 1000;
+    QTime timer;
+    timer.start();
+#ifdef Q_OS_SYMBIAN
+    fd_set fdexception;
+    FD_ZERO(&fdexception);
+    FD_SET(socketDescriptor, &fdexception);
+#endif
     int retval;
+    do {
+        if (selectForRead)
+            retval = select(socketDescriptor + 1, &fds, 0, 0, timeout < 0 ? 0 : &tv);
+        else
+            retval = select(socketDescriptor + 1, 0, &fds, 0, timeout < 0 ? 0 : &tv);
+        if (retval != -1 || errno != EINTR)
+            break;
+        if (timeout > 0) {
+            // recalculate the timeout
+            int t = timeout - timer.elapsed();
+            if (t < 0) {
+                // oops, timeout turned negative?
+                retval = -1;
+                break;
+    if (selectForRead)
+#ifdef Q_OS_SYMBIAN
+        retval = ::select(socketDescriptor + 1, &fds, 0, &fdexception, timeout < 0 ? 0 : &tv);
+#else
+        retval = qt_safe_select(socketDescriptor + 1, &fds, 0, 0, timeout < 0 ? 0 : &tv);
+#endif
+    else
+#ifdef Q_OS_SYMBIAN
+        retval = ::select(socketDescriptor + 1, 0, &fds, &fdexception, timeout < 0 ? 0 : &tv);
+#else
+        retval = qt_safe_select(socketDescriptor + 1, 0, &fds, 0, timeout < 0 ? 0 : &tv);
+#endif
+#ifdef Q_OS_SYMBIAN
+        bool selectForExec = false;
+        if(retval != 0) {
+            if(retval < 0) {
+                qWarning("nativeSelect(....) returned < 0 for socket %d", socketDescriptor);
+            }
+            tv.tv_sec = t / 1000;
+            tv.tv_usec = (t % 1000) * 1000;
+        }
+    } while (true);
+            selectForExec = FD_ISSET(socketDescriptor, &fdexception);
+        }
+        if(selectForExec) {
+            qWarning("nativeSelect (selectForRead %d, retVal %d, errno %d) Unexpected exception for fd %d",
+                    selectForRead, retval, errno, socketDescriptor);
+            }
+#endif
     return retval;
 …
 int QNativeSocketEnginePrivate::nativeSelect(int timeout, bool checkRead, bool checkWrite,
                                       bool *selectForRead, bool *selectForWrite) const
+                       bool *selectForRead, bool *selectForWrite) const
+{
     fd_set fdread;
 …
         FD_SET(socketDescriptor, &fdwrite);
+#ifdef Q_OS_SYMBIAN
+    fd_set fdexception;
+    FD_ZERO(&fdexception);
+    FD_SET(socketDescriptor, &fdexception);
+#endif
     struct timeval tv;
     tv.tv_sec = timeout / 1000;
     tv.tv_usec = (timeout % 1000) * 1000;
+    int ret;
+#ifndef Q_OS_SYMBIAN
+    ret = qt_safe_select(socketDescriptor + 1, &fdread, &fdwrite, 0, timeout < 0 ? 0 : &tv);
+#else
     QTime timer;
     timer.start();
-    int ret;
     do {
+        ret = select(socketDescriptor + 1, &fdread, &fdwrite, 0, timeout < 0 ? 0 : &tv);
+        if (ret != -1 || errno != EINTR)
+            break;
+        ret = ::select(socketDescriptor + 1, &fdread, &fdwrite, &fdexception, timeout < 0 ? 0 : &tv);
+        bool selectForExec = false;
+        if(ret != 0) {
+            if(ret < 0) {
+                qWarning("nativeSelect(....) returned < 0 for socket %d", socketDescriptor);
+            }
+            selectForExec = FD_ISSET(socketDescriptor, &fdexception);
+        }
+        if(selectForExec) {
+            qWarning("nativeSelect (checkRead %d, checkWrite %d, ret %d, errno %d): Unexpected expectfds ready in fd %d",
+                    checkRead, checkWrite, ret, errno, socketDescriptor);
+            if (checkWrite){
+                FD_CLR(socketDescriptor, &fdread);
+                FD_SET(socketDescriptor, &fdwrite);
+            } else if (checkRead)
+                FD_SET(socketDescriptor, &fdread);
+            if ((ret == -1) && ( errno == ECONNREFUSED || errno == EPIPE ))
+                ret = 1;
+        }
+        if (ret != -1 || errno != EINTR) {
+            break;
+        }
         if (timeout > 0) {
 …
+        }
     } while (true);
+#endif
     if (ret <= 0)
         return ret;
     *selectForRead = FD_ISSET(socketDescriptor, &fdread);
     *selectForWrite = FD_ISSET(socketDescriptor, &fdwrite);
     return ret;
+}

trunk/src/network/socket/qnativesocketengine_win.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
-#if !defined (QT_NO_IPV6)
-// Use our own defines and structs which we know are correct
-#  define QT_SS_MAXSIZE 128
-#  define QT_SS_ALIGNSIZE (sizeof(__int64))
-#  define QT_SS_PAD1SIZE (QT_SS_ALIGNSIZE - sizeof (short))
-#  define QT_SS_PAD2SIZE (QT_SS_MAXSIZE - (sizeof (short) + QT_SS_PAD1SIZE + QT_SS_ALIGNSIZE))
-struct qt_sockaddr_storage {
-      short ss_family;
-      char __ss_pad1[QT_SS_PAD1SIZE];
-      __int64 __ss_align;
-      char __ss_pad2[QT_SS_PAD2SIZE];
-};
-// sockaddr_in6 size changed between old and new SDK
-// Only the new version is the correct one, so always
-// use this structure.
-struct qt_in6_addr {
-    u_char qt_s6_addr[16];
-};
-typedef struct {
-    short   sin6_family;            /* AF_INET6 */
-    u_short sin6_port;              /* Transport level port number */
-    u_long  sin6_flowinfo;          /* IPv6 flow information */
-    struct  qt_in6_addr sin6_addr;  /* IPv6 address */
-    u_long  sin6_scope_id;          /* set of interfaces for a scope */
-} qt_sockaddr_in6;
-#else
-typedef void * qt_sockaddr_in6 ;
-#endif
 #ifndef AF_INET6
 #define AF_INET6        23              /* Internetwork Version 6 */
 …
     \a port and \a addr if they are non-null.
 */
 static inline void qt_socket_getPortAndAddress(SOCKET socketDescriptor, struct sockaddr *sa, quint16 *port, QHostAddress *address)
+static inline void qt_socket_getPortAndAddress(SOCKET socketDescriptor, const qt_sockaddr *sa, quint16 *port, QHostAddress *address)
+{
 #if !defined (QT_NO_IPV6)
     if (sa->sa_family == AF_INET6) {
         qt_sockaddr_in6 *sa6 = (qt_sockaddr_in6 *)sa;
+    if (sa->a.sa_family == AF_INET6) {
+        const qt_sockaddr_in6 *sa6 = &sa->a6;
         Q_IPV6ADDR tmp;
         for (int i = 0; i < 16; ++i)
 …
     } else
 #endif
     if (sa->sa_family == AF_INET) {
         struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;
+    if (sa->a.sa_family == AF_INET) {
+        const sockaddr_in *sa4 = &sa->a4;
         unsigned long addr;
         WSANtohl(socketDescriptor, sa4->sin_addr.s_addr, &addr);
 …
     int n = -1;
+    int level = SOL_SOCKET; // default
     switch (opt) {
     case QNativeSocketEngine::ReceiveBufferSocketOption:
 …
         n = SO_OOBINLINE;
         break;
+    case QNativeSocketEngine::LowDelayOption:
+        level = IPPROTO_TCP;
+        n = TCP_NODELAY;
+        break;
+    case QNativeSocketEngine::KeepAliveOption:
+        n = SO_KEEPALIVE;
+        break;
+    }
     int v = -1;
     QT_SOCKOPTLEN_T len = sizeof(v);
     if (getsockopt(socketDescriptor, SOL_SOCKET, n, (char *) &v, &len) != -1)
+    if (getsockopt(socketDescriptor, level, n, (char *) &v, &len) != -1)
         return v;
     return -1;
 …
     int n = 0;
+    int level = SOL_SOCKET; // default
     switch (opt) {
     case QNativeSocketEngine::ReceiveBufferSocketOption:
 …
         n = SO_OOBINLINE;
         break;
+    }
+    if (::setsockopt(socketDescriptor, SOL_SOCKET, n, (char*)&v, sizeof(v)) != 0) {
+    case QNativeSocketEngine::LowDelayOption:
+        level = IPPROTO_TCP;
+        n = TCP_NODELAY;
+        break;
+    case QNativeSocketEngine::KeepAliveOption:
+        n = SO_KEEPALIVE;
+        break;
+    }
+    if (::setsockopt(socketDescriptor, level, n, (char*)&v, sizeof(v)) != 0) {
         WS_ERROR_DEBUG(WSAGetLastError());
         return false;
 …
        return false;
+#if !defined (QT_NO_IPV6)
+    struct qt_sockaddr_storage sa;
+#else
+    struct sockaddr_in sa;
+#endif
+    struct sockaddr *pSa = (struct sockaddr *) &sa;
+    QT_SOCKLEN_T sz = sizeof(sa);
+    qt_sockaddr sa;
+    QT_SOCKLEN_T sockAddrSize = sizeof(sa);
+    // Determine local address
     memset(&sa, 0, sizeof(sa));
     if (::getsockname(socketDescriptor, pSa, &sz) == 0) {
         qt_socket_getPortAndAddress(socketDescriptor, pSa, &localPort, &localAddress);
+    if (::getsockname(socketDescriptor, &sa.a, &sockAddrSize) == 0) {
+        qt_socket_getPortAndAddress(socketDescriptor, &sa, &localPort, &localAddress);
         // Determine protocol family
         switch (pSa->sa_family) {
+        switch (sa.a.sa_family) {
         case AF_INET:
             socketProtocol = QAbstractSocket::IPv4Protocol;
 …
     memset(&sa, 0, sizeof(sa));
     if (::getpeername(socketDescriptor, pSa, &sz) == 0) {
         qt_socket_getPortAndAddress(socketDescriptor, pSa, &peerPort, &peerAddress);
+    if (::getpeername(socketDescriptor, &sa.a, &sockAddrSize) == 0) {
+        qt_socket_getPortAndAddress(socketDescriptor, &sa, &peerPort, &peerAddress);
     } else {
         WS_ERROR_DEBUG(WSAGetLastError());
 …
     struct sockaddr_in sockAddrIPv4;
     qt_sockaddr_in6 sockAddrIPv6;
     struct sockaddr *sockAddrPtr;
     QT_SOCKLEN_T sockAddrSize;
+    struct sockaddr *sockAddrPtr = 0;
+    QT_SOCKLEN_T sockAddrSize = 0;
     qt_socket_setPortAndAddress(socketDescriptor, &sockAddrIPv4, &sockAddrIPv6, port, address, &sockAddrPtr, &sockAddrSize);
 …
                         break;
+                    }
+                    if (value == WSAEHOSTUNREACH) {
+                        setError(QAbstractSocket::NetworkError, HostUnreachableErrorString);
+                        socketState = QAbstractSocket::UnconnectedState;
+                        break;
+                    }
+                }
                 // fall through
 …
     struct sockaddr_in sockAddrIPv4;
     qt_sockaddr_in6 sockAddrIPv6;
     struct sockaddr *sockAddrPtr;
     QT_SOCKLEN_T sockAddrSize;
+    struct sockaddr *sockAddrPtr = 0;
+    QT_SOCKLEN_T sockAddrSize = 0;
     qt_socket_setPortAndAddress(socketDescriptor, &sockAddrIPv4, &sockAddrIPv6, port, address, &sockAddrPtr, &sockAddrSize);
 …
 #if !defined(Q_OS_WINCE)
     // Create a sockaddr struct and reset its port number.
+#if !defined(QT_NO_IPV6)
+    qt_sockaddr_in6 storage;
+    qt_sockaddr_in6 *storagePtrIPv6 = reinterpret_cast<qt_sockaddr_in6 *>(&storage);
+    storagePtrIPv6->sin6_port = 0;
+#else
+    struct sockaddr storage;
+#endif
+    sockaddr *storagePtr = reinterpret_cast<sockaddr *>(&storage);
+    storagePtr->sa_family = 0;
+    sockaddr_in *storagePtrIPv4 = reinterpret_cast<sockaddr_in *>(&storage);
+    storagePtrIPv4->sin_port = 0;
+    qt_sockaddr storage;
     QT_SOCKLEN_T storageSize = sizeof(storage);
+    memset(&storage, 0, storageSize);
     bool result = false;
 …
     DWORD available = 0;
     DWORD flags = MSG_PEEK;
     int ret = ::WSARecvFrom(socketDescriptor, &buf, 1, &available, &flags, storagePtr, &storageSize,0,0);
+    int ret = ::WSARecvFrom(socketDescriptor, &buf, 1, &available, &flags, &storage.a, &storageSize,0,0);
     int err = WSAGetLastError();
     if (ret == SOCKET_ERROR && err !=  WSAEMSGSIZE) {
 …
             flags = 0;
             ::WSARecvFrom(socketDescriptor, &buf, 1, &available, &flags,
                           storagePtr, &storageSize, 0, 0);
+                          &storage.a, &storageSize, 0, 0);
+        }
     } else {
 …
     qint64 ret = 0;
+#if !defined(QT_NO_IPV6)
+    qt_sockaddr_storage aa;
+#else
+    struct sockaddr_in aa;
+#endif
+    qt_sockaddr aa;
     memset(&aa, 0, sizeof(aa));
     QT_SOCKLEN_T sz;
     sz = sizeof(aa);
     WSABUF buf;
     buf.buf = data;
 …
     DWORD flags = 0;
     DWORD bytesRead = 0;
     int wsaRet = ::WSARecvFrom(socketDescriptor, &buf, 1, &bytesRead, &flags, (struct sockaddr *) &aa, &sz,0,0);
+    int wsaRet = ::WSARecvFrom(socketDescriptor, &buf, 1, &bytesRead, &flags, &aa.a, &sz,0,0);
     if (wsaRet == SOCKET_ERROR) {
         int err = WSAGetLastError();
         if (err == WSAEMSGSIZE) {
             // it is ok the buffer was to small if bytesRead is larger than
             // maxLength (win 9x) then assume bytes read is really maxLenth
+            // maxLength then assume bytes read is really maxLenth
             ret = qint64(bytesRead) > maxLength ? maxLength : qint64(bytesRead);
         } else {
 …
+    }
     qt_socket_getPortAndAddress(socketDescriptor, (struct sockaddr *) &aa, port, address);
+    qt_socket_getPortAndAddress(socketDescriptor, &aa, port, address);
 #if defined (QNATIVESOCKETENGINE_DEBUG)
 …
     struct sockaddr_in sockAddrIPv4;
     qt_sockaddr_in6 sockAddrIPv6;
     struct sockaddr *sockAddrPtr;
     QT_SOCKLEN_T sockAddrSize;
+    struct sockaddr *sockAddrPtr = 0;
+    QT_SOCKLEN_T sockAddrSize = 0;
     qt_socket_setPortAndAddress(socketDescriptor, &sockAddrIPv4, &sockAddrIPv6, port, address, &sockAddrPtr, &sockAddrSize);
+    if (QSysInfo::WindowsVersion & QSysInfo::WV_DOS_based && len > qint64(qt_socket_getMaxMsgSize(socketDescriptor))) {
+        // WSAEMSGSIZE is not reliable enough (win 9x) so we check max size our self.
+        setError(QAbstractSocket::DatagramTooLargeError, DatagramTooLargeErrorString);
+    WSABUF buf;
+#if !defined(Q_OS_WINCE)
+    buf.buf = len ? (char*)data : 0;
+#else
+    char tmp;
+    buf.buf = len ? (char*)data : &tmp;
+#endif
+    buf.len = len;
+    DWORD flags = 0;
+    DWORD bytesSent = 0;
+    if (::WSASendTo(socketDescriptor, &buf, 1, &bytesSent, flags, sockAddrPtr, sockAddrSize, 0,0) ==  SOCKET_ERROR) {
+        int err = WSAGetLastError();
+        WS_ERROR_DEBUG(err);
+        switch (err) {
+        case WSAEMSGSIZE:
+            setError(QAbstractSocket::DatagramTooLargeError, DatagramTooLargeErrorString);
+            break;
+        default:
+            setError(QAbstractSocket::NetworkError, SendDatagramErrorString);
+            break;
+        }
+        ret = -1;
     } else {
+        WSABUF buf;
+#if !defined(Q_OS_WINCE)
+        buf.buf = len ? (char*)data : 0;
+#else
+        char tmp;
+        buf.buf = len ? (char*)data : &tmp;
+#endif
+        buf.len = len;
+        DWORD flags = 0;
+        DWORD bytesSent = 0;
+        if (::WSASendTo(socketDescriptor, &buf, 1, &bytesSent, flags, sockAddrPtr, sockAddrSize, 0,0) ==  SOCKET_ERROR) {
+            int err = WSAGetLastError();
+            WS_ERROR_DEBUG(err);
+            switch (err) {
+            case WSAEMSGSIZE:
+                setError(QAbstractSocket::DatagramTooLargeError, DatagramTooLargeErrorString);
+                break;
+            default:
+                setError(QAbstractSocket::NetworkError, SendDatagramErrorString);
+                break;
+            }
+            ret = -1;
+        } else {
+            ret = qint64(bytesSent);
+        }
+    }
+        ret = qint64(bytesSent);
+    }
 #if defined (QNATIVESOCKETENGINE_DEBUG)
     qDebug("QNativeSocketEnginePrivate::nativeSendDatagram(%p \"%s\", %li, \"%s\", %i) == %li", data,
 …
     tv.tv_usec = (timeout % 1000) * 1000;
     if (selectForRead)
+    if (selectForRead) {
         ret = select(0, &fds, 0, 0, timeout < 0 ? 0 : &tv);
+    else
+        ret = select(0, 0, &fds, 0, timeout < 0 ? 0 : &tv);
+    } else {
+        // select for write
+        // Windows needs this to report errors when connecting a socket ...
+        fd_set fdexception;
+        FD_ZERO(&fdexception);
+        FD_SET(socketDescriptor, &fdexception);
+        ret = select(0, 0, &fds, &fdexception, timeout < 0 ? 0 : &tv);
+        // ... but if it is actually set, pretend it did not happen
+        if (ret > 0 && FD_ISSET(socketDescriptor, &fdexception))
+            ret--;
+    }
     if (readEnabled)
 …
     if (readEnabled)
         readNotifier->setEnabled(false);
     fd_set fdread;
     fd_set fdwrite;
+    fd_set fdexception;
     int ret = 0;
 …
+    }
     memset(&fdwrite, 0, sizeof(fd_set));
+    FD_ZERO(&fdexception);
     if (checkWrite) {
         fdwrite.fd_count = 1;
         fdwrite.fd_array[0] = socketDescriptor;
+        // Windows needs this to report errors when connecting a socket
+        FD_SET(socketDescriptor, &fdexception);
+    }
 …
 #if !defined(Q_OS_WINCE)
     ret = select(socketDescriptor + 1, &fdread, &fdwrite, 0, timeout < 0 ? 0 : &tv);
+    ret = select(socketDescriptor + 1, &fdread, &fdwrite, &fdexception, timeout < 0 ? 0 : &tv);
 #else
+    ret = select(1, &fdread, &fdwrite, 0, timeout < 0 ? 0 : &tv);
+#endif
+    ret = select(1, &fdread, &fdwrite, &fdexception, timeout < 0 ? 0 : &tv);
+#endif
+     //... but if it is actually set, pretend it did not happen
+    if (ret > 0 && FD_ISSET(socketDescriptor, &fdexception))
+        ret--;
     if (readEnabled)
         readNotifier->setEnabled(true);

trunk/src/network/socket/qsocks5socketengine.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$
 **
 …
 QT_BEGIN_NAMESPACE
+#ifdef Q_OS_SYMBIAN
+static const int MaxWriteBufferSize = 4*1024;
+#else
 static const int MaxWriteBufferSize = 128*1024;
+#endif
 //#define QSOCKS5SOCKETLAYER_DEBUG
 …
 static bool qt_socks5_set_host_address_and_port(const QHostAddress &address, quint16 port, QByteArray *pBuf)
+{
     QSOCKS5_DEBUG << "setting [" << address << ":" << port << "]";
+    QSOCKS5_DEBUG << "setting [" << address << ':' << port << ']';
     union {
 …
 static bool qt_socks5_set_host_name_and_port(const QString &hostname, quint16 port, QByteArray *pBuf)
+{
     QSOCKS5_DEBUG << "setting [" << hostname << ":" << port << "]";
+    QSOCKS5_DEBUG << "setting [" << hostname << ':' << port << ']';
     QByteArray encodedHostName = QUrl::toAce(hostname);
 …
     if (ret) {
         QSOCKS5_DEBUG << "got [" << address << ":" << port << "]";
+        QSOCKS5_DEBUG << "got [" << address << ':' << port << ']';
         *pAddress = address;
         *pPort = port;
 …
+{
     Q_D(QSocks5SocketEngine);
     QSOCKS5_DEBUG << "connectToHost" << address << ":" << port;
+    QSOCKS5_DEBUG << "connectToHost" << address << ':' << port;
     setPeerAddress(address);
 …
             connectData->readBuffer.clear();
         emitReadNotification();
+        data->controlSocket->close();
+        // cause a disconnect in the outer socket
+        emitWriteNotification();
     } else if (socks5State == Uninitialized
                || socks5State == AuthenticationMethodsSent
 …
         q_func()->setError(data->controlSocket->error(), data->controlSocket->errorString());
         emitReadNotification();
+        emitWriteNotification();
+    }
+}
 …
             return false;
+        }
         QSOCKS5_DEBUG << "udp actual address and port" << d->localAddress << ":" << d->localPort;
+        QSOCKS5_DEBUG << "udp actual address and port" << d->localAddress << ':' << d->localPort;
         return true;
 #endif // QT_NO_UDPSOCKET
 …
+{
     Q_D(QSocks5SocketEngine);
     QSOCKS5_Q_DEBUG << "read( , maxlen = " << maxlen << ")";
+    QSOCKS5_Q_DEBUG << "read( , maxlen = " << maxlen << ')';
     if (d->mode == QSocks5SocketEnginePrivate::ConnectMode) {
         if (d->connectData->readBuffer.size() == 0) {
 …
 #endif // QT_NO_UDPSOCKET
+qint64 QSocks5SocketEngine::bytesToWrite() const
+{
+    Q_D(const QSocks5SocketEngine);
+    if (d->data && d->data->controlSocket) {
+        return d->data->controlSocket->bytesToWrite();
+    } else {
+        return 0;
+    }
+}
 int QSocks5SocketEngine::option(SocketOption option) const
+{
+    Q_UNUSED(option);
+    Q_D(const QSocks5SocketEngine);
+    if (d->data && d->data->controlSocket) {
+        // convert the enum and call the real socket
+        if (option == QAbstractSocketEngine::LowDelayOption)
+            return d->data->controlSocket->socketOption(QAbstractSocket::LowDelayOption).toInt();
+        if (option == QAbstractSocketEngine::KeepAliveOption)
+            return d->data->controlSocket->socketOption(QAbstractSocket::KeepAliveOption).toInt();
+    }
     return -1;
+}
 …
 bool QSocks5SocketEngine::setOption(SocketOption option, int value)
+{
+    Q_UNUSED(option);
+    Q_UNUSED(value);
+    Q_D(QSocks5SocketEngine);
+    if (d->data && d->data->controlSocket) {
+        // convert the enum and call the real socket
+        if (option == QAbstractSocketEngine::LowDelayOption)
+            d->data->controlSocket->setSocketOption(QAbstractSocket::LowDelayOption, value);
+        if (option == QAbstractSocketEngine::KeepAliveOption)
+            d->data->controlSocket->setSocketOption(QAbstractSocket::KeepAliveOption, value);
+        return true;
+    }
     return false;
+}
 …
     Q_D(QSocks5SocketEngine);
     QSOCKS5_Q_DEBUG << "setReadNotificationEnabled(" << enable << ")";
+    QSOCKS5_Q_DEBUG << "setReadNotificationEnabled(" << enable << ')';
     bool emitSignal = false;
 …
         return 0;
+    }
     QSocks5SocketEngine *engine = new QSocks5SocketEngine(parent);
+    QScopedPointer<QSocks5SocketEngine> engine(new QSocks5SocketEngine(parent));
     engine->setProxy(proxy);
     return engine;
+    return engine.take();
+}

trunk/src/network/socket/qsocks5socketengine_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$
 **
 …
     qint64 pendingDatagramSize() const;
 #endif // QT_NO_UDPSOCKET
+    qint64 bytesToWrite() const;
     int option(SocketOption option) const;

trunk/src/network/socket/qtcpserver.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
     if (d->socketEngine) {
         d->socketEngine->close();
+        d->socketEngine->deleteLater();
+        QT_TRY {
+            d->socketEngine->deleteLater();
+        } QT_CATCH(const std::bad_alloc &) {
+            // in out of memory situations, the socketEngine
+            // will be deleted in ~QTcpServer (it's a child-object of this)
+        }
         d->socketEngine = 0;
+    }

trunk/src/network/socket/qtcpserver.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/socket/qtcpsocket.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
     \bold{Note:} TCP sockets cannot be opened in QIODevice::Unbuffered mode.
     \sa QTcpServer, QUdpSocket, QFtp, QHttp, {Fortune Server Example},
         {Fortune Client Example}, {Threaded Fortune Server Example},
         {Blocking Fortune Client Example}, {Loopback Example},
         {Torrent Example}
+    \sa QTcpServer, QUdpSocket, QFtp, QNetworkAccessManager,
+    {Fortune Server Example}, {Fortune Client Example},
+    {Threaded Fortune Server Example}, {Blocking Fortune Client Example},
+    {Loopback Example}, {Torrent Example}
 */

trunk/src/network/socket/qtcpsocket.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/qabstractsocket.h>
+#include <QtCore/qvariant.h>
 QT_BEGIN_HEADER

trunk/src/network/socket/qtcpsocket_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/socket/qudpsocket.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$
 **
 …
     \brief The QUdpSocket class provides a UDP socket.
     \ingroup io
+    \ingroup network
     \inmodule QtNetwork
 …
     datagram, and readDatagram() to read it.
+    \note An incoming datagram should be read when you receive the readyRead()
+    signal, otherwise this signal will not be emitted for the next datagram.
     Example:
 …
     This enum describes the different flags you can pass to modify the
     behavior of QUdpSocket::bind().
+    \note On Symbian OS bind flags behaviour depends on process capabilties.
+    If process has NetworkControl capability, the bind attempt with
+    ReuseAddressHint will always succeed even if the address and port is already
+    bound by another socket with any flags. If process does not have
+    NetworkControl capability, the bind attempt to address and port already
+    bound by another socket will always fail.
     \value ShareAddress Allow other services to bind to the same address
 …
     destination.
+    \warning In S60 5.0 and earlier versions, the writeDatagram return
+    value is not reliable for large datagrams.
     \warning Calling this function on a connected UDP socket may
     result in an error and no packet being sent. If you are using a
 …
     qint64 sent = d->socketEngine->writeDatagram(data, size, address, port);
+#ifdef Q_OS_SYMBIAN
+    if( QSysInfo::s60Version() <= QSysInfo::SV_S60_5_0 ) {
+        // This is evil hack, but for some reason native RSocket::SendTo returns 0,
+        // for large datagrams (such as 600 bytes). Based on comments from Open C team
+        // this should happen only in platforms <= S60 5.0.
+        // As an workaround, we just set sent = size
+        if( sent == 0 )
+            sent = size;
+    }
+#endif
     d->cachedSocketDescriptor = d->socketEngine->socketDescriptor();
 …
+}
 /*!
+/*!
     \fn qint64 QUdpSocket::writeDatagram(const QByteArray &datagram,
                                              const QHostAddress &host, quint16 port)

trunk/src/network/socket/qudpsocket.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/socket/socket.pri

-              r157
+              r561
                 socket/qlocalsocket_unix.cpp \
                 socket/qlocalserver_unix.cpp
+unix:HEADERS += \
+                socket/qnet_unix_p.h
 win32:SOURCES += socket/qnativesocketengine_win.cpp \
 …
     DEFINES += QT_LOCALSOCKET_TCP
+}

trunk/src/network/ssl/qssl.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.3
+    \ingroup io
+    \ingroup network
+    \ingroup ssl
     \inmodule QtNetwork
 */

trunk/src/network/ssl/qssl.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/ssl/qsslcertificate.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \ingroup ssl
     \inmodule QtNetwork
 …
     certificate, its subject, and its issuer, by calling one of the
     many accessor functions, including version(), serialNumber(),
+    issuerInfo() and subjectInfo(). You can call notValidBefore() and
+    notValidAfter() to check when the certificate was issued, and when
+    it expires. The publicKey() function returns the certificate
+    issuerInfo() and subjectInfo(). You can call effectiveDate() and
+    expiryDate() to check when the certificate starts being
+    effective and when it expires.
+    The publicKey() function returns the certificate
     subject's public key as a QSslKey. You can call issuerInfo() or
     subjectInfo() to get detailed information about the certificate
 …
 QT_BEGIN_NAMESPACE
+// forward declaration
+static QMap<QString, QString> _q_mapFromOnelineName(char *name);
 /*!
     Constructs a QSslCertificate by reading \a format encoded data
 …
 QSslCertificate::QSslCertificate(const QSslCertificate &other) : d(other.d)
+{
-    d->ref.ref();
+}
 …
 QSslCertificate::~QSslCertificate()
+{
-    if (!d->ref.deref())
-        delete d;
+}
 …
 QSslCertificate &QSslCertificate::operator=(const QSslCertificate &other)
+{
     qAtomicAssign(d, other.d);
+    d = other.d;
     return *this;
+}
 …
     if (isNull())
         return;
-    if (d->ref == 1)
-        delete d;
-    else
-        d->ref.deref();
     d = new QSslCertificatePrivate;
+}
 …
 QByteArray QSslCertificate::version() const
+{
+    if (d->versionString.isEmpty() && d->x509)
+        d->versionString =
+            QByteArray::number(qlonglong(q_ASN1_INTEGER_get(d->x509->cert_info->version)) + 1);
     return d->versionString;
+}
 /*!
     Returns the certificate's serial number string.
+    Returns the certificate's serial number string in decimal format.
 */
 QByteArray QSslCertificate::serialNumber() const
+{
+    if (d->serialNumberString.isEmpty() && d->x509)
+        d->serialNumberString =
+            QByteArray::number(qlonglong(q_ASN1_INTEGER_get(d->x509->cert_info->serialNumber)));
     return d->serialNumberString;
+}
 …
 /*!
     Returns a cryptographic digest of this certificate. By default,
     and MD5 digest will be generated, but you can also specify a
+    an MD5 digest will be generated, but you can also specify a
     custom \a algorithm.
 */
 …
 QString QSslCertificate::issuerInfo(SubjectInfo info) const
+{
+    if (d->issuerInfo.isEmpty() && d->x509)
+        d->issuerInfo =
+                _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_issuer_name(d->x509), 0, 0));
     return d->issuerInfo.value(_q_SubjectInfoToString(info));
+}
 …
 QString QSslCertificate::subjectInfo(SubjectInfo info) const
+{
+    if (d->subjectInfo.isEmpty() && d->x509)
+        d->subjectInfo =
+                _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_subject_name(d->x509), 0, 0));
     return d->subjectInfo.value(_q_SubjectInfoToString(info));
+}
 …
         return result;
     STACK *altNames = (STACK *)q_X509_get_ext_d2i(d->x509, NID_subject_alt_name, 0, 0);
+    STACK_OF(GENERAL_NAME) *altNames = (STACK_OF(GENERAL_NAME)*)q_X509_get_ext_d2i(d->x509, NID_subject_alt_name, 0, 0);
     if (altNames) {
 …
             const char *altNameStr = reinterpret_cast<const char *>(q_ASN1_STRING_data(genName->d.ia5));
             const QString altName = QLatin1String(QByteArray(altNameStr, len));
+            const QString altName = QString::fromLatin1(altNameStr, len);
             if (genName->type == GEN_DNS)
                 result.insert(QSsl::DnsEntry, altName);
 …
                 result.insert(QSsl::EmailEntry, altName);
+        }
         q_sk_free(altNames);
+        q_sk_pop_free((STACK*)altNames, reinterpret_cast<void(*)(void*)>(q_sk_free));
+    }
 …
     array = array.toBase64();
     QByteArray tmp;
     for (int i = 0; i < array.size() - 64; i += 64) {
+    for (int i = 0; i <= array.size() - 64; i += 64) {
         tmp += QByteArray::fromRawData(array.data() + i, 64);
         tmp += "\n";
 …
     if (!x509 || !QSslSocket::supportsSsl())
         return certificate;
-    certificate.d->issuerInfo =
-        _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_issuer_name(x509), 0, 0));
-    certificate.d->subjectInfo =
-        _q_mapFromOnelineName(q_X509_NAME_oneline(q_X509_get_subject_name(x509), 0, 0));
     ASN1_TIME *nbef = q_X509_get_notBefore(x509);
 …
     if (ch == '\n') {
         *offset++;
+        *offset += 1;
         return true;
+    }
 …
     debug << "QSslCertificate("
           << certificate.version()
           << "," << certificate.serialNumber()
           << "," << certificate.digest().toBase64()
           << "," << certificate.issuerInfo(QSslCertificate::Organization)
           << "," << certificate.subjectInfo(QSslCertificate::Organization)
           << "," << certificate.alternateSubjectNames()
+          << ',' << certificate.serialNumber()
+          << ',' << certificate.digest().toBase64()
+          << ',' << certificate.issuerInfo(QSslCertificate::Organization)
+          << ',' << certificate.subjectInfo(QSslCertificate::Organization)
+          << ',' << certificate.alternateSubjectNames()
 #ifndef QT_NO_TEXTSTREAM
           << "," << certificate.effectiveDate()
           << "," << certificate.expiryDate()
+          << ',' << certificate.effectiveDate()
+          << ',' << certificate.expiryDate()
 #endif
           << ")";
+          << ')';
     return debug;
+}

trunk/src/network/ssl/qsslcertificate.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/qcryptographichash.h>
 #include <QtCore/qregexp.h>
+#include <QtCore/qsharedpointer.h>
 #include <QtNetwork/qssl.h>
 …
 private:
     QSslCertificatePrivate *d;
+    QExplicitlySharedDataPointer<QSslCertificatePrivate> d;
     friend class QSslCertificatePrivate;
     friend class QSslSocketBackendPrivate;

trunk/src/network/ssl/qsslcertificate_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$
 **
 …
+    {
         QSslSocketPrivate::ensureInitialized();
-        ref = 1;
+    }

trunk/src/network/ssl/qsslcipher.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \ingroup ssl
     \inmodule QtNetwork
 …
 #ifndef QT_NO_DEBUG_STREAM
 #include <QtCore/qdebug.h>
+#endif
 QT_BEGIN_NAMESPACE
-#endif
 /*!
 …
     : d(new QSslCipherPrivate)
+{
     *d = *other.d;
+    *d.data() = *other.d.data();
+}
 …
 QSslCipher::~QSslCipher()
+{
-    delete d;
+}
 …
 QSslCipher &QSslCipher::operator=(const QSslCipher &other)
+{
     *d = *other.d;
+    *d.data() = *other.d.data();
     return *this;
+}
 …
           << ", bits=" << cipher.usedBits()
           << ", proto=" << qPrintable(cipher.protocolString())
           << ")";
+          << ')';
     return debug;
+}

trunk/src/network/ssl/qsslcipher.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/qstring.h>
+#include <QtCore/qscopedpointer.h>
 #include <QtNetwork/qssl.h>
 …
 private:
     QSslCipherPrivate *d;
+    QScopedPointer<QSslCipherPrivate> d;
     friend class QSslSocketBackendPrivate;
 };

trunk/src/network/ssl/qsslcipher_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/ssl/qsslconfiguration.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$
 **
 …
     \reentrant
     \inmodule QtNetwork
     \ingroup io
+    \ingroup network
     \ingroup ssl

trunk/src/network/ssl/qsslconfiguration.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$
 **
 …
 /****************************************************************************
 **
 ** In addition, as a special exception, Trolltech gives permission to link
+** In addition, as a special exception, Nokia gives permission to link
 ** the code of its release of Qt with the OpenSSL project's "OpenSSL" library
 ** (or modified versions of the "OpenSSL" library that use the same license

trunk/src/network/ssl/qsslconfiguration_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$
 **
 …
 /****************************************************************************
 **
 ** In addition, as a special exception, Trolltech gives permission to link
+** In addition, as a special exception, Nokia gives permission to link
 ** the code of its release of Qt with the OpenSSL project's "OpenSSL" library
 ** (or modified versions of the "OpenSSL" library that use the same license

trunk/src/network/ssl/qsslerror.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \ingroup ssl
     \inmodule QtNetwork
 …
 #include "qsslerror.h"
+#include "qsslsocket.h"
 #ifndef QT_NO_DEBUG_STREAM
 #include <QtCore/qdebug.h>
 …
 /*!
+    Constructs a QSslError object. The two optional arguments specify the \a
+    Constructs a QSslError object with no error and default certificate.
+*/
+// RVCT compiler in debug build does not like about default values in const-
+// So as an workaround we define all constructor overloads here explicitly
+QSslError::QSslError()
+    : d(new QSslErrorPrivate)
+{
+    d->error = QSslError::NoError;
+    d->certificate = QSslCertificate();
+}
+/*!
+    Constructs a QSslError object. The argument specifies the \a
+    error that occurred.
+*/
+QSslError::QSslError(SslError error)
+    : d(new QSslErrorPrivate)
+{
+    d->error = error;
+    d->certificate = QSslCertificate();
+}
+/*!
+    Constructs a QSslError object. The two arguments specify the \a
     error that occurred, and which \a certificate the error relates to.
 …
     : d(new QSslErrorPrivate)
+{
     *d = *other.d;
+    *d.data() = *other.d.data();
+}
 …
 QSslError::~QSslError()
+{
-    delete d;
+}
 …
 QSslError &QSslError::operator=(const QSslError &other)
+{
     *d = *other.d;
+    *d.data() = *other.d.data();
     return *this;
+}
 …
     switch (d->error) {
     case NoError:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "No error"));
+        errStr = QSslSocket::tr("No error");
         break;
     case UnableToGetIssuerCertificate:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The issuer certificate could not be found"));
+        errStr = QSslSocket::tr("The issuer certificate could not be found");
         break;
     case UnableToDecryptCertificateSignature:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The certificate signature could not be decrypted"));
+        errStr = QSslSocket::tr("The certificate signature could not be decrypted");
         break;
     case UnableToDecodeIssuerPublicKey:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The public key in the certificate could not be read"));
+        errStr = QSslSocket::tr("The public key in the certificate could not be read");
         break;
     case CertificateSignatureFailed:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The signature of the certificate is invalid"));
+        errStr = QSslSocket::tr("The signature of the certificate is invalid");
         break;
     case CertificateNotYetValid:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The certificate is not yet valid"));
+        errStr = QSslSocket::tr("The certificate is not yet valid");
         break;
     case CertificateExpired:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The certificate has expired"));
+        errStr = QSslSocket::tr("The certificate has expired");
         break;
     case InvalidNotBeforeField:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The certificate's notBefore field contains an invalid time"));
+        errStr = QSslSocket::tr("The certificate's notBefore field contains an invalid time");
         break;
     case InvalidNotAfterField:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The certificate's notAfter field contains an invalid time"));
+        errStr = QSslSocket::tr("The certificate's notAfter field contains an invalid time");
         break;
     case SelfSignedCertificate:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The certificate is self-signed, and untrusted"));
+        errStr = QSslSocket::tr("The certificate is self-signed, and untrusted");
         break;
     case SelfSignedCertificateInChain:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The root certificate of the certificate chain is self-signed, and untrusted"));
+        errStr = QSslSocket::tr("The root certificate of the certificate chain is self-signed, and untrusted");
         break;
     case UnableToGetLocalIssuerCertificate:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The issuer certificate of a locally looked up certificate could not be found"));
+        errStr = QSslSocket::tr("The issuer certificate of a locally looked up certificate could not be found");
         break;
     case UnableToVerifyFirstCertificate:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "No certificates could be verified"));
+        errStr = QSslSocket::tr("No certificates could be verified");
         break;
     case InvalidCaCertificate:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "One of the CA certificates is invalid"));
+        errStr = QSslSocket::tr("One of the CA certificates is invalid");
         break;
     case PathLengthExceeded:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The basicConstraints pathlength parameter has been exceeded"));
+        errStr = QSslSocket::tr("The basicConstraints path length parameter has been exceeded");
         break;
     case InvalidPurpose:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The supplied certificate is unsuited for this purpose"));
+        errStr = QSslSocket::tr("The supplied certificate is unsuitable for this purpose");
         break;
     case CertificateUntrusted:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The root CA certificate is not trusted for this purpose"));
+        errStr = QSslSocket::tr("The root CA certificate is not trusted for this purpose");
         break;
     case CertificateRejected:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The root CA certificate is marked to reject the specified purpose"));
+        errStr = QSslSocket::tr("The root CA certificate is marked to reject the specified purpose");
         break;
     case SubjectIssuerMismatch: // hostname mismatch
+        errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError,
+                                               "The current candidate issuer certificate was rejected because its"
+                                               " subject name did not match the issuer name of the current certificate"));
+        errStr = QSslSocket::tr("The current candidate issuer certificate was rejected because its"
+                                " subject name did not match the issuer name of the current certificate");
         break;
     case AuthorityIssuerSerialNumberMismatch:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The current candidate issuer certificate was rejected because"
                                                " its issuer name and serial number was present and did not match the"
                                                " authority key identifier of the current certificate"));
+        errStr = QSslSocket::tr("The current candidate issuer certificate was rejected because"
+                             " its issuer name and serial number was present and did not match the"
+                             " authority key identifier of the current certificate");
         break;
     case NoPeerCertificate:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "The peer did not present any certificate"));
+        errStr = QSslSocket::tr("The peer did not present any certificate");
         break;
     case HostNameMismatch:
+        errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError,
+                                               "The host name did not match any of the valid hosts"
+                                               " for this certificate"));
+        errStr = QSslSocket::tr("The host name did not match any of the valid hosts"
+                             " for this certificate");
         break;
     case NoSslSupport:
         break;
     default:
         errStr = QObject::tr(QT_TRANSLATE_NOOP(QSslError, "Unknown error"));
+        errStr = QSslSocket::tr("Unknown error");
         break;
+    }

trunk/src/network/ssl/qsslerror.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$
 **
 …
     };
+    QSslError(SslError error = NoError, const QSslCertificate &certificate = QSslCertificate());
+    // RVCT compiler in debug build does not like about default values in const-
+    // So as an workaround we define all constructor overloads here explicitly
+    QSslError();
+    QSslError(SslError error);
+    QSslError(SslError error, const QSslCertificate &certificate);
     QSslError(const QSslError &other);
     ~QSslError();
     QSslError &operator=(const QSslError &other);
 …
 private:
     QSslErrorPrivate *d;
+    QScopedPointer<QSslErrorPrivate> d;
 };

trunk/src/network/ssl/qsslkey.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \ingroup ssl
     \inmodule QtNetwork
 …
 QSslKey::QSslKey(const QSslKey &other) : d(other.d)
+{
-    d->ref.ref();
+}
 …
 QSslKey::~QSslKey()
+{
-    if (!d->ref.deref())
-        delete d;
+}
 …
 QSslKey &QSslKey::operator=(const QSslKey &other)
+{
     qAtomicAssign(d, other.d);
+    d = other.d;
     return *this;
+}
 …
 void QSslKey::clear()
+{
+    if (!d->ref.deref()) {
+        delete d;
+        d = new QSslKeyPrivate;
+    }
+    d = new QSslKeyPrivate;
+}
 …
           << ", " << (key.algorithm() == QSsl::Rsa ? "RSA" : "DSA")
           << ", " << key.length()
           << ")";
+          << ')';
     return debug;
+}

trunk/src/network/ssl/qsslkey.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/qnamespace.h>
 #include <QtCore/qbytearray.h>
+#include <QtCore/qsharedpointer.h>
 #include <QtNetwork/qssl.h>
 …
 class QIODevice;
 class QSslKeyPrivate;
 class Q_NETWORK_EXPORT QSslKey
 …
 private:
     QSslKeyPrivate *d;
+    QExplicitlySharedDataPointer<QSslKeyPrivate> d;
     friend class QSslCertificate;
 };

trunk/src/network/ssl/qsslkey_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$
 **
 …
+    {
         clear();
-        ref = 1;
+    }
 …
     QAtomicInt ref;
+private:
+    Q_DISABLE_COPY(QSslKeyPrivate)
 };

trunk/src/network/ssl/qsslsocket.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$
 **
 …
     \reentrant
     \ingroup io
+    \ingroup network
     \ingroup ssl
     \inmodule QtNetwork
 …
     internal buffer, and you can call write() or putChar() to write
     data back to the peer. QSslSocket will automatically encrypt the
     written data for you, and emit bytesWritten() once the data has
     been written to the peer.
+    written data for you, and emit encryptedBytesWritten() once
+    the data has been written to the peer.
     As a convenience, QSslSocket supports QTcpSocket's blocking
 …
     for use in the OpenSSL Toolkit (\l{http://www.openssl.org/}).
+    \note Be aware of the difference between the bytesWritten() signal and
+    the encryptedBytesWritten() signal. For a QTcpSocket, bytesWritten()
+    will get emitted as soon as data has been written to the TCP socket.
+    For a QSslSocket, bytesWritten() will get emitted when the data
+    is being encrypted and encryptedBytesWritten()
+    will get emitted as soon as data has been written to the TCP socket.
     \sa QSslCertificate, QSslCipher, QSslError
 */
 …
     ignoreSslErrors(), either from inside a slot function connected to
     the sslErrors() signal, or prior to entering encrypted mode. If
     ignoreSslErrors is not called, the connection is dropped, signal
+    ignoreSslErrors() is not called, the connection is dropped, signal
     disconnected() is emitted, and QSslSocket returns to the
     UnconnectedState.
 …
 /*!
+    \since 4.6
+    \overload
+    In addition to the original behaviour of connectToHostEncrypted,
+    this overloaded method enables the usage of a different hostname
+    (\a sslPeerName) for the certificate validation instead of
+    the one used for the TCP connection (\a hostName).
+    \sa connectToHostEncrypted()
+*/
+void QSslSocket::connectToHostEncrypted(const QString &hostName, quint16 port,
+                                        const QString &sslPeerName, OpenMode mode)
+{
+    Q_D(QSslSocket);
+    if (d->state == ConnectedState || d->state == ConnectingState) {
+        qWarning("QSslSocket::connectToHostEncrypted() called when already connecting/connected");
+        return;
+    }
+    d->init();
+    d->autoStartHandshake = true;
+    d->initialized = true;
+    d->verificationPeerName = sslPeerName;
+    // Note: When connecting to localhost, some platforms (e.g., HP-UX and some BSDs)
+    // establish the connection immediately (i.e., first attempt).
+    connectToHost(hostName, port, mode);
+}
+/*!
     Initializes QSslSocket with the native socket descriptor \a
     socketDescriptor. Returns true if \a socketDescriptor is accepted
 …
     Q_D(QSslSocket);
 #ifdef QSSLSOCKET_DEBUG
     qDebug() << "QSslSocket::setSocketDescriptor(" << socketDescriptor << ","
              << state << "," << openMode << ")";
+    qDebug() << "QSslSocket::setSocketDescriptor(" << socketDescriptor << ','
+             << state << ',' << openMode << ')';
 #endif
     if (!d->plainSocket)
 …
 /*!
+    \since 4.6
+    Sets the given \a option to the value described by \a value.
+    \sa socketOption()
+*/
+void QSslSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
+{
+    Q_D(QSslSocket);
+    if (d->plainSocket)
+        d->plainSocket->setSocketOption(option, value);
+}
+/*!
+    \since 4.6
+    Returns the value of the \a option option.
+    \sa setSocketOption()
+*/
+QVariant QSslSocket::socketOption(QAbstractSocket::SocketOption option)
+{
+    Q_D(QSslSocket);
+    if (d->plainSocket)
+        return d->plainSocket->socketOption(option);
+    else
+        return QVariant();
+}
+/*!
     Returns the current mode for the socket; either UnencryptedMode, where
     QSslSocket behaves identially to QTcpSocket, or one of SslClientMode or
 …
     An encrypted socket encrypts all data that is written by calling write()
     or putChar() before the data is written to the network, and descrypts all
+    or putChar() before the data is written to the network, and decrypts all
     incoming data as the data is received from the network, before you call
     read(), readLine() or getChar().
 …
     qDebug() << "QSslSocket::close()";
 #endif
+    Q_D(QSslSocket);
+    if (d->plainSocket)
+        d->plainSocket->close();
     QTcpSocket::close();
+    // must be cleared, reading/writing not possible on closed socket:
+    d->readBuffer.clear();
+    d->writeBuffer.clear();
+    // for QTcpSocket this is already done because it uses the readBuffer/writeBuffer
+    // if the QIODevice it is based on
+    // ### FIXME QSslSocket should probably do similar instead of having
+    // its own readBuffer/writeBuffer
+}
 …
 /*!
+    Returns the system default CA certificate database for your
+    system. This database is normally found in a standard place for
+    your system. If it is not found there, Qt will provide its own
+    default CA certificate database. The CA certificate database
+    This function provides a default CA certificate database
+    shipped together with Qt. The CA certificate database
     returned by this function is used to initialize the database
     returned by defaultCaCertificates(). You can replace that database
 …
     Q_D(QSslSocket);
     if (d->mode != UnencryptedMode) {
         qWarning("QSslSocket::startClientEncryption: cannot start handshake on non-plain connection");
+        qWarning("QSslSocket::startServerEncryption: cannot start handshake on non-plain connection");
         return;
+    }
 …
+{
     Q_D(QSslSocket);
+    d->ignoreSslErrors = true;
+    d->ignoreAllSslErrors = true;
+}
+/*!
+    \overload
+    \since 4.6
+    This method tells QSslSocket to ignore only the errors given in \a
+    errors.
+    Note that you can set the expected certificate in the SSL error:
+    If, for instance, you want to connect to a server that uses
+    a self-signed certificate, consider the following snippet:
+    \snippet doc/src/snippets/code/src_network_ssl_qsslsocket.cpp 6
+    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 sslErrors()
+*/
+void QSslSocket::ignoreSslErrors(const QList<QSslError> &errors)
+{
+    Q_D(QSslSocket);
+    d->ignoreErrorsList = errors;
+}
 …
 #ifdef QSSLSOCKET_DEBUG
     qDebug() << "QSslSocket::connectToHostImplementation("
              << hostName << "," << port << "," << openMode << ")";
+             << hostName << ',' << port << ',' << openMode << ')';
 #endif
     if (!d->plainSocket) {
 …
+    }
 #ifdef QSSLSOCKET_DEBUG
     qDebug() << "QSslSocket::readData(" << (void *)data << "," << maxlen << ") ==" << readBytes;
+    qDebug() << "QSslSocket::readData(" << (void *)data << ',' << maxlen << ") ==" << readBytes;
 #endif
+    // possibly trigger another transmit() to decrypt more data from the socket
+    if (d->readBuffer.isEmpty() && d->plainSocket->bytesAvailable())
+        QMetaObject::invokeMethod(this, "_q_flushReadBuffer", Qt::QueuedConnection);
     return readBytes;
+}
 …
     Q_D(QSslSocket);
 #ifdef QSSLSOCKET_DEBUG
     qDebug() << "QSslSocket::writeData(" << (void *)data << "," << len << ")";
+    qDebug() << "QSslSocket::writeData(" << (void *)data << ',' << len << ')';
 #endif
     if (d->mode == UnencryptedMode && !d->autoStartHandshake)
 …
 */
 QSslSocketPrivate::QSslSocketPrivate()
+    : initialized(false), readyReadEmittedPointer(0), plainSocket(0)
+    : initialized(false)
+    , mode(QSslSocket::UnencryptedMode)
+    , autoStartHandshake(false)
+    , connectionEncrypted(false)
+    , ignoreAllSslErrors(false)
+    , readyReadEmittedPointer(0)
+    , plainSocket(0)
+{
     QSslConfigurationPrivate::deepCopyDefaultConfiguration(&configuration);
 …
     autoStartHandshake = false;
     connectionEncrypted = false;
+    ignoreSslErrors = false;
+    ignoreAllSslErrors = false;
+    // we don't want to clear the ignoreErrorsList, so
+    // that it is possible setting it before connecting
+//    ignoreErrorsList.clear();
     readBuffer.clear();
 …
     Q_Q(QSslSocket);
 #ifdef QSSLSOCKET_DEBUG
     qDebug() << "QSslSocket::_q_stateChangedSlot(" << state << ")";
+    qDebug() << "QSslSocket::_q_stateChangedSlot(" << state << ')';
 #endif
     q->setSocketState(state);
 …
     Q_Q(QSslSocket);
 #ifdef QSSLSOCKET_DEBUG
     qDebug() << "QSslSocket::_q_errorSlot(" << error << ")";
+    qDebug() << "QSslSocket::_q_errorSlot(" << error << ')';
     qDebug() << "\tstate =" << q->state();
     qDebug() << "\terrorString =" << q->errorString();
 …
     Q_Q(QSslSocket);
 #ifdef QSSLSOCKET_DEBUG
     qDebug() << "QSslSocket::_q_bytesWrittenSlot(" << written << ")";
+    qDebug() << "QSslSocket::_q_bytesWrittenSlot(" << written << ')';
 #endif
 …
+}
+/*!
+    \internal
+*/
+void QSslSocketPrivate::_q_flushReadBuffer()
+{
+    // trigger a read from the plainSocket into SSL
+    if (mode != QSslSocket::UnencryptedMode)
+        transmit();
+}
 QT_END_NAMESPACE

trunk/src/network/ssl/qsslsocket.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$
 **
 …
     // Autostarting the SSL client handshake.
     void connectToHostEncrypted(const QString &hostName, quint16 port, OpenMode mode = ReadWrite);
+    void connectToHostEncrypted(const QString &hostName, quint16 port, const QString &sslPeerName, OpenMode mode = ReadWrite);
     bool setSocketDescriptor(int socketDescriptor, SocketState state = ConnectedState,
                              OpenMode openMode = ReadWrite);
+    // ### Qt 5: Make virtual
+    void setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value);
+    QVariant socketOption(QAbstractSocket::SocketOption option);
     SslMode mode() const;
 …
     static bool supportsSsl();
+    void ignoreSslErrors(const QList<QSslError> &errors);
 public Q_SLOTS:
 …
     Q_PRIVATE_SLOT(d_func(), void _q_bytesWrittenSlot(qint64))
     Q_PRIVATE_SLOT(d_func(), void _q_flushWriteBuffer())
+    Q_PRIVATE_SLOT(d_func(), void _q_flushReadBuffer())
     friend class QSslSocketBackendPrivate;
 };

trunk/src/network/ssl/qsslsocket_openssl.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$
 **
 …
             first = false;
         else
             cipherString.append(":");
+            cipherString.append(':');
         cipherString.append(cipher.name().toLatin1());
+    }
 …
         // Check if the certificate matches the private key.
         if (!q_SSL_CTX_check_private_key(ctx)) {
             q->setErrorString(QSslSocket::tr("Private key does not certificate public key, %1").arg(SSL_ERRORSTR()));
+            q->setErrorString(QSslSocket::tr("Private key does not certify public key, %1").arg(SSL_ERRORSTR()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
 …
 QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
+{
+#ifdef QQ_OS_UNIX
+    // Check known locations for the system's default bundle.  ### On Windows,
+    // we should use CAPI to find the bundle, and not rely on default unix
+    // locations.
+    const char *standardLocations[] = {"/etc/ssl/certs/",
+#if 0
+                                       // KDE uses KConfig for its SSL store,
+                                       // but it also stores the bundle at
+                                       // this location
+                                       "$HOME/.kde/share/apps/kssl/ca-bundle.crt",
+#endif
+};
+    const char **it = standardLocations;
+    QStringList nameFilter;
+    nameFilter << QLatin1String("*.pem") << QLatin1String("*.crt");
+    while (*it) {
+        if (QDirIterator(QLatin1String(*it), nameFilter).hasNext())
+            return certificatesFromPath(QLatin1String(*it));
+        ++it;
+    }
+#endif
+    // Qt provides a default bundle when we cannot detect the system's default
+    // bundle.
+    // Qt provides a default bundle of certificates
     QFile caBundle(QLatin1String(":/trolltech/network/ssl/qt-ca-bundle.crt"));
     if (caBundle.open(QIODevice::ReadOnly | QIODevice::Text))
 …
     // Start connecting. This will place outgoing data in the BIO, so we
     // follow up with calling transmit().
     testConnection();
+    startHandshake();
     transmit();
+}
 …
     // Start connecting. This will place outgoing data in the BIO, so we
     // follow up with calling transmit().
     testConnection();
+    startHandshake();
     transmit();
+}
 …
             qDebug() << "QSslSocketBackendPrivate::transmit: testing encryption";
 #endif
             if (testConnection()) {
+            if (startHandshake()) {
 #ifdef QSSLSOCKET_DEBUG
                 qDebug() << "QSslSocketBackendPrivate::transmit: encryption established";
 …
         // If the request is small and the remote host closes the transmission
         // after sending, there's a chance that testConnection() will already
+        // after sending, there's a chance that startHandshake() will already
         // have triggered a shutdown.
         if (!ssl)
 …
+}
 bool QSslSocketBackendPrivate::testConnection()
+bool QSslSocketBackendPrivate::startHandshake()
+{
     Q_Q(QSslSocket);
 …
             q->setSocketError(QAbstractSocket::SslHandshakeFailedError);
 #ifdef QSSLSOCKET_DEBUG
             qDebug() << "QSslSocketBackendPrivate::testConnection: error!" << q->errorString();
+            qDebug() << "QSslSocketBackendPrivate::startHandshake: error!" << q->errorString();
 #endif
             emit q->error(QAbstractSocket::SslHandshakeFailedError);
 …
         // if we're the server, don't check CN
         if (mode == QSslSocket::SslClientMode) {
             QString peerName = q->peerName();
+            QString peerName = (verificationPeerName.isEmpty () ? q->peerName() : verificationPeerName);
             QString commonName = configuration.peerCertificate.subjectInfo(QSslCertificate::CommonName);
 …
         sslErrors = errors;
         emit q->sslErrors(errors);
+        if (doVerifyPeer && !ignoreSslErrors) {
+        bool doEmitSslError;
+        if (!ignoreErrorsList.empty()) {
+            // check whether the errors we got are all in the list of expected errors
+            // (applies only if the method QSslSocket::ignoreSslErrors(const QList<QSslError> &errors)
+            // was called)
+            doEmitSslError = false;
+            for (int a = 0; a < errors.count(); a++) {
+                if (!ignoreErrorsList.contains(errors.at(a))) {
+                    doEmitSslError = true;
+                    break;
+                }
+            }
+        } else {
+            // if QSslSocket::ignoreSslErrors(const QList<QSslError> &errors) was not called and
+            // we get an SSL error, emit a signal unless we ignored all errors (by calling
+            // QSslSocket::ignoreSslErrors() )
+            doEmitSslError = !ignoreAllSslErrors;
+        }
+        // check whether we need to emit an SSL handshake error
+        if (doVerifyPeer && doEmitSslError) {
             q->setErrorString(sslErrors.first().errorString());
             q->setSocketError(QAbstractSocket::SslHandshakeFailedError);
 …
     if (!ssl || !ctx)
         return QSslCipher();
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+    // FIXME This is fairly evil, but needed to keep source level compatibility
+    // with the OpenSSL 0.9.x implementation at maximum -- some other functions
+    // don't take a const SSL_CIPHER* when they should
+    SSL_CIPHER *sessionCipher = const_cast<SSL_CIPHER *>(q_SSL_get_current_cipher(ssl));
+#else
     SSL_CIPHER *sessionCipher = q_SSL_get_current_cipher(ssl);
+#endif
     return sessionCipher ? QSslCipher_from_SSL_CIPHER(sessionCipher) : QSslCipher();
+}

trunk/src/network/ssl/qsslsocket_openssl_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$
 **
 …
 #ifdef Q_OS_WIN
 #include <windows.h>
+#include <qt_windows.h>
 #if defined(OCSP_RESPONSE)
 #undef OCSP_RESPONSE
 …
 #include <openssl/x509v3.h>
 #include <openssl/x509_vfy.h>
+#include <openssl/dsa.h>
+#include <openssl/rsa.h>
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+typedef _STACK STACK;
+#endif
 QT_BEGIN_NAMESPACE
 …
     void startServerEncryption();
     void transmit();
     bool testConnection();
+    bool startHandshake();
     void disconnectFromHost();
     void disconnected();

trunk/src/network/ssl/qsslsocket_openssl_symbols.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$
 **
 …
 DEFINEFUNC3(void *, ASN1_dup, i2d_of_void *a, a, d2i_of_void *b, b, char *c, c, return 0, return)
 #endif
+DEFINEFUNC(long, ASN1_INTEGER_get, ASN1_INTEGER *a, a, return 0, return)
 DEFINEFUNC(unsigned char *, ASN1_STRING_data, ASN1_STRING *a, a, return 0, return)
 DEFINEFUNC(int, ASN1_STRING_length, ASN1_STRING *a, a, return 0, return)
 …
 DEFINEFUNC(int, RAND_status, void, DUMMYARG, return -1, return)
 DEFINEFUNC(void, RSA_free, RSA *a, a, return, DUMMYARG)
+DEFINEFUNC(int, sk_num, STACK *a, a, return -1, return)
+DEFINEFUNC2(void, sk_pop_free, STACK *a, a, void (*b)(void*), b, return, DUMMYARG)
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+DEFINEFUNC(void, sk_free, _STACK *a, a, return, DUMMYARG)
+DEFINEFUNC2(void *, sk_value, STACK *a, a, int b, b, return 0, return)
+#else
 DEFINEFUNC(void, sk_free, STACK *a, a, return, DUMMYARG)
-DEFINEFUNC(int, sk_num, STACK *a, a, return -1, return)
 DEFINEFUNC2(char *, sk_value, STACK *a, a, int b, b, return 0, return)
+#endif
 DEFINEFUNC(int, SSL_accept, SSL *a, a, return -1, return)
 DEFINEFUNC(int, SSL_clear, SSL *a, a, return -1, return)
 …
 DEFINEFUNC4(long, SSL_CTX_ctrl, SSL_CTX *a, a, int b, b, long c, c, void *d, d, return -1, return)
 DEFINEFUNC(void, SSL_CTX_free, SSL_CTX *a, a, return, DUMMYARG)
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+DEFINEFUNC(SSL_CTX *, SSL_CTX_new, const SSL_METHOD *a, a, return 0, return)
+#else
 DEFINEFUNC(SSL_CTX *, SSL_CTX_new, SSL_METHOD *a, a, return 0, return)
+#endif
 DEFINEFUNC2(int, SSL_CTX_set_cipher_list, SSL_CTX *a, a, const char *b, b, return -1, return)
 DEFINEFUNC(int, SSL_CTX_set_default_verify_paths, SSL_CTX *a, a, return -1, return)
 …
 DEFINEFUNC(STACK_OF(SSL_CIPHER) *, SSL_get_ciphers, SSL *a, a, return 0, return)
 #endif
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+DEFINEFUNC(const SSL_CIPHER *, SSL_get_current_cipher, SSL *a, a, return 0, return)
+#else
 DEFINEFUNC(SSL_CIPHER *, SSL_get_current_cipher, SSL *a, a, return 0, return)
+#endif
 DEFINEFUNC2(int, SSL_get_error, SSL *a, a, int b, b, return -1, return)
 DEFINEFUNC(STACK_OF(X509) *, SSL_get_peer_cert_chain, SSL *a, a, return 0, return)
 …
 DEFINEFUNC(void, SSL_set_connect_state, SSL *a, a, return, DUMMYARG)
 DEFINEFUNC(int, SSL_shutdown, SSL *a, a, return -1, return)
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+DEFINEFUNC(const SSL_METHOD *, SSLv2_client_method, DUMMYARG, DUMMYARG, return 0, return)
+DEFINEFUNC(const SSL_METHOD *, SSLv3_client_method, DUMMYARG, DUMMYARG, return 0, return)
+DEFINEFUNC(const SSL_METHOD *, SSLv23_client_method, DUMMYARG, DUMMYARG, return 0, return)
+DEFINEFUNC(const SSL_METHOD *, TLSv1_client_method, DUMMYARG, DUMMYARG, return 0, return)
+DEFINEFUNC(const SSL_METHOD *, SSLv2_server_method, DUMMYARG, DUMMYARG, return 0, return)
+DEFINEFUNC(const SSL_METHOD *, SSLv3_server_method, DUMMYARG, DUMMYARG, return 0, return)
+DEFINEFUNC(const SSL_METHOD *, SSLv23_server_method, DUMMYARG, DUMMYARG, return 0, return)
+DEFINEFUNC(const SSL_METHOD *, TLSv1_server_method, DUMMYARG, DUMMYARG, return 0, return)
+#else
 DEFINEFUNC(SSL_METHOD *, SSLv2_client_method, DUMMYARG, DUMMYARG, return 0, return)
 DEFINEFUNC(SSL_METHOD *, SSLv3_client_method, DUMMYARG, DUMMYARG, return 0, return)
 …
 DEFINEFUNC(SSL_METHOD *, SSLv23_server_method, DUMMYARG, DUMMYARG, return 0, return)
 DEFINEFUNC(SSL_METHOD *, TLSv1_server_method, DUMMYARG, DUMMYARG, return 0, return)
+#endif
 DEFINEFUNC3(int, SSL_write, SSL *a, a, const void *b, b, int c, c, return -1, return)
 DEFINEFUNC2(int, X509_cmp, X509 *a, a, X509 *b, b, return -1, return)
 …
 DEFINEFUNC(void, OPENSSL_add_all_algorithms_conf, void, DUMMYARG, return, DUMMYARG)
+#ifdef Q_OS_SYMBIAN
+#define RESOLVEFUNC(func, ordinal, lib) \
+    if (!(_q_##func = _q_PTR_##func(lib->resolve(#ordinal)))) \
+        qWarning("QSslSocket: cannot resolve "#func);
+#else
 #define RESOLVEFUNC(func) \
     if (!(_q_##func = _q_PTR_##func(libs.first->resolve(#func)))     \
         && !(_q_##func = _q_PTR_##func(libs.second->resolve(#func)))) \
         qWarning("QSslSocket: cannot resolve "#func);
+#endif
 #if !defined QT_LINKED_OPENSSL
 …
     pair.second = libeay32;
     return pair;
+# elif defined(Q_OS_SYMBIAN)
+     QLibrary *libssl = new QLibrary(QLatin1String("libssl"));
+    if (!libssl->load()) {
+        // Cannot find ssleay32.dll
+        delete libssl;
+        return pair;
+    }
+    QLibrary *libcrypto = new QLibrary(QLatin1String("libcrypto"));
+    if (!libcrypto->load()) {
+        delete libcrypto;
+        delete libssl;
+        return pair;
+    }
+    pair.first = libssl;
+    pair.second = libcrypto;
+    return pair;
 # elif defined(Q_OS_UNIX)
     QLibrary *&libssl = pair.first;
 …
     // paths. See the man page for dlopen(3) on your system for more information.
+#ifdef Q_OS_OPENBSD
+    libcrypto->setLoadHints(QLibrary::ExportExternalSymbolsHint);
+#endif
 #ifdef SHLIB_VERSION_NUMBER
     // first attempt: the canonical name is libssl.so.<SHLIB_VERSION_NUMBER>
     libssl->setFileNameAndVersion(QLatin1String("ssl"), QLatin1String(SHLIB_VERSION_NUMBER));
     libcrypto->setFileNameAndVersion(QLatin1String("crypto"), QLatin1String(SHLIB_VERSION_NUMBER));
     if (libssl->load() && libcrypto->load()) {
+    if (libcrypto->load() && libssl->load()) {
         // libssl.so.<SHLIB_VERSION_NUMBER> and libcrypto.so.<SHLIB_VERSION_NUMBER> found
         return pair;
 …
     libssl->setFileNameAndVersion(QLatin1String("ssl"), -1);
     libcrypto->setFileNameAndVersion(QLatin1String("crypto"), -1);
     if (libssl->load() && libcrypto->load()) {
+    if (libcrypto->load() && libssl->load()) {
         // libssl.so.0 and libcrypto.so.0 found
         return pair;
 …
         libssl->setFileNameAndVersion(ssl, -1);
         libcrypto->setFileNameAndVersion(crypto, -1);
         if (libssl->load() && libcrypto->load()) {
+        if (libcrypto->load() && libssl->load()) {
             // libssl.so.0 and libcrypto.so.0 found
             return pair;
 …
         return false;
+#ifdef Q_OS_SYMBIAN
+#ifdef SSLEAY_MACROS
+    RESOLVEFUNC(ASN1_dup, 125, libs.second )
+#endif
+    RESOLVEFUNC(ASN1_INTEGER_get, 48, libs.second )
+    RESOLVEFUNC(ASN1_STRING_data, 71, libs.second )
+    RESOLVEFUNC(ASN1_STRING_length, 76, libs.second )
+    RESOLVEFUNC(BIO_ctrl, 184, libs.second )
+    RESOLVEFUNC(BIO_free, 209, libs.second )
+    RESOLVEFUNC(BIO_new, 222, libs.second )
+    RESOLVEFUNC(BIO_new_mem_buf, 230, libs.second )
+    RESOLVEFUNC(BIO_read, 244, libs.second )
+    RESOLVEFUNC(BIO_s_mem, 251, libs.second )
+    RESOLVEFUNC(BIO_write, 269, libs.second )
+    RESOLVEFUNC(BN_num_bits, 387, libs.second )
+    RESOLVEFUNC(CRYPTO_free, 469, libs.second )
+    RESOLVEFUNC(CRYPTO_num_locks, 500, libs.second )
+    RESOLVEFUNC(CRYPTO_set_id_callback, 513, libs.second )
+    RESOLVEFUNC(CRYPTO_set_locking_callback, 516, libs.second )
+    RESOLVEFUNC(DSA_free, 594, libs.second )
+    RESOLVEFUNC(ERR_error_string, 744, libs.second )
+    RESOLVEFUNC(ERR_get_error, 749, libs.second )
+    RESOLVEFUNC(EVP_des_ede3_cbc, 919, libs.second )
+    RESOLVEFUNC(EVP_PKEY_assign, 859, libs.second )
+    RESOLVEFUNC(EVP_PKEY_free, 867, libs.second )
+    RESOLVEFUNC(EVP_PKEY_get1_DSA, 869, libs.second )
+    RESOLVEFUNC(EVP_PKEY_get1_RSA, 870, libs.second )
+    RESOLVEFUNC(EVP_PKEY_new, 876, libs.second )
+    RESOLVEFUNC(EVP_PKEY_type, 882, libs.second )
+    RESOLVEFUNC(OBJ_nid2sn, 1036, libs.second )
+    RESOLVEFUNC(OBJ_obj2nid, 1037, libs.second )
+#ifdef SSLEAY_MACROS // ### verify
+    RESOLVEFUNC(PEM_ASN1_read_bio, 1180, libs.second )
+#else
+    RESOLVEFUNC(PEM_read_bio_DSAPrivateKey, 1219, libs.second )
+    RESOLVEFUNC(PEM_read_bio_RSAPrivateKey, 1228, libs.second )
+    RESOLVEFUNC(PEM_write_bio_DSAPrivateKey, 1260, libs.second )
+    RESOLVEFUNC(PEM_write_bio_RSAPrivateKey, 1271, libs.second )
+#endif
+    RESOLVEFUNC(PEM_read_bio_DSA_PUBKEY, 1220, libs.second )
+    RESOLVEFUNC(PEM_read_bio_RSA_PUBKEY, 1230, libs.second )
+    RESOLVEFUNC(PEM_write_bio_DSA_PUBKEY, 1261, libs.second )
+    RESOLVEFUNC(PEM_write_bio_RSA_PUBKEY, 1273, libs.second )
+    RESOLVEFUNC(RAND_seed, 1426, libs.second )
+    RESOLVEFUNC(RAND_status, 1429, libs.second )
+    RESOLVEFUNC(RSA_free, 1450, libs.second )
+    RESOLVEFUNC(sk_free, 2571, libs.second )
+    RESOLVEFUNC(sk_num, 2576, libs.second )
+    RESOLVEFUNC(sk_pop_free, 2578, libs.second )
+    RESOLVEFUNC(sk_value, 2585, libs.second )
+    RESOLVEFUNC(SSL_CIPHER_description, 11, libs.first )
+    RESOLVEFUNC(SSL_CTX_check_private_key, 21, libs.first )
+    RESOLVEFUNC(SSL_CTX_ctrl, 22, libs.first )
+    RESOLVEFUNC(SSL_CTX_free, 24, libs.first )
+    RESOLVEFUNC(SSL_CTX_new, 35, libs.first )
+    RESOLVEFUNC(SSL_CTX_set_cipher_list, 40, libs.first )
+    RESOLVEFUNC(SSL_CTX_set_default_verify_paths, 44, libs.first )
+    RESOLVEFUNC(SSL_CTX_set_verify, 56, libs.first )
+    RESOLVEFUNC(SSL_CTX_set_verify_depth, 57, libs.first )
+    RESOLVEFUNC(SSL_CTX_use_certificate, 64, libs.first )
+    RESOLVEFUNC(SSL_CTX_use_certificate_file, 67, libs.first )
+    RESOLVEFUNC(SSL_CTX_use_PrivateKey, 58, libs.first )
+    RESOLVEFUNC(SSL_CTX_use_RSAPrivateKey, 61, libs.first )
+    RESOLVEFUNC(SSL_CTX_use_PrivateKey_file, 60, libs.first )
+    RESOLVEFUNC(SSL_accept, 82, libs.first )
+    RESOLVEFUNC(SSL_clear, 92, libs.first )
+    RESOLVEFUNC(SSL_connect, 93, libs.first )
+    RESOLVEFUNC(SSL_free, 99, libs.first )
+    RESOLVEFUNC(SSL_get_ciphers, 104, libs.first )
+    RESOLVEFUNC(SSL_get_current_cipher, 106, libs.first )
+    RESOLVEFUNC(SSL_get_error, 110, libs.first )
+    RESOLVEFUNC(SSL_get_peer_cert_chain, 117, libs.first )
+    RESOLVEFUNC(SSL_get_peer_certificate, 118, libs.first )
+    RESOLVEFUNC(SSL_get_verify_result, 132, libs.first )
+    RESOLVEFUNC(SSL_library_init, 137, libs.first )
+    RESOLVEFUNC(SSL_load_error_strings, 139, libs.first )
+    RESOLVEFUNC(SSL_new, 140, libs.first )
+    RESOLVEFUNC(SSL_read, 143, libs.first )
+    RESOLVEFUNC(SSL_set_accept_state, 148, libs.first )
+    RESOLVEFUNC(SSL_set_bio, 149, libs.first )
+    RESOLVEFUNC(SSL_set_connect_state, 152, libs.first )
+    RESOLVEFUNC(SSL_shutdown, 173, libs.first )
+    RESOLVEFUNC(SSL_write, 188, libs.first )
+    RESOLVEFUNC(SSLv2_client_method, 192, libs.first )
+    RESOLVEFUNC(SSLv3_client_method, 195, libs.first )
+    RESOLVEFUNC(SSLv23_client_method, 189, libs.first )
+    RESOLVEFUNC(TLSv1_client_method, 198, libs.first )
+    RESOLVEFUNC(SSLv2_server_method, 194, libs.first )
+    RESOLVEFUNC(SSLv3_server_method, 197, libs.first )
+    RESOLVEFUNC(SSLv23_server_method, 191, libs.first )
+    RESOLVEFUNC(TLSv1_server_method, 200, libs.first )
+    RESOLVEFUNC(X509_NAME_oneline, 1830, libs.second )
+    RESOLVEFUNC(X509_PUBKEY_get, 1844, libs.second )
+    RESOLVEFUNC(X509_STORE_free, 1939, libs.second )
+    RESOLVEFUNC(X509_STORE_new, 1942, libs.second )
+    RESOLVEFUNC(X509_STORE_add_cert, 1936, libs.second )
+    RESOLVEFUNC(X509_STORE_CTX_free, 1907, libs.second )
+    RESOLVEFUNC(X509_STORE_CTX_init, 1919, libs.second )
+    RESOLVEFUNC(X509_STORE_CTX_new, 1920, libs.second )
+    RESOLVEFUNC(X509_STORE_CTX_set_purpose, 1931, libs.second )
+    RESOLVEFUNC(X509_cmp, 1992, libs.second )
+#ifndef SSLEAY_MACROS
+    RESOLVEFUNC(X509_dup, 1997, libs.second )
+#endif
+    RESOLVEFUNC(X509_EXTENSION_get_object, 1785, libs.second )
+    RESOLVEFUNC(X509_free, 2001, libs.second )
+    RESOLVEFUNC(X509_get_ext, 2012, libs.second )
+    RESOLVEFUNC(X509_get_ext_count, 2016, libs.second )
+    RESOLVEFUNC(X509_get_ext_d2i, 2017, libs.second )
+    RESOLVEFUNC(X509_get_issuer_name, 2018, libs.second )
+    RESOLVEFUNC(X509_get_subject_name, 2022, libs.second )
+    RESOLVEFUNC(X509_verify_cert, 2069, libs.second )
+    RESOLVEFUNC(d2i_X509, 2309, libs.second )
+    RESOLVEFUNC(i2d_X509, 2489, libs.second )
+#ifdef SSLEAY_MACROS
+    RESOLVEFUNC(i2d_DSAPrivateKey, 2395, libs.second )
+    RESOLVEFUNC(i2d_RSAPrivateKey, 2476, libs.second )
+    RESOLVEFUNC(d2i_DSAPrivateKey, 2220, libs.second )
+    RESOLVEFUNC(d2i_RSAPrivateKey, 2296, libs.second )
+#endif
+    RESOLVEFUNC(OPENSSL_add_all_algorithms_noconf, 1153, libs.second )
+    RESOLVEFUNC(OPENSSL_add_all_algorithms_conf, 1152, libs.second )
+#else // Q_OS_SYMBIAN
 #ifdef SSLEAY_MACROS
     RESOLVEFUNC(ASN1_dup)
 #endif
+    RESOLVEFUNC(ASN1_INTEGER_get)
     RESOLVEFUNC(ASN1_STRING_data)
     RESOLVEFUNC(ASN1_STRING_length)
 …
     RESOLVEFUNC(sk_free)
     RESOLVEFUNC(sk_num)
+    RESOLVEFUNC(sk_pop_free)
     RESOLVEFUNC(sk_value)
     RESOLVEFUNC(SSL_CIPHER_description)
 …
     RESOLVEFUNC(OPENSSL_add_all_algorithms_noconf)
     RESOLVEFUNC(OPENSSL_add_all_algorithms_conf)
+#endif // Q_OS_SYMBIAN
     symbolsResolved = true;
     delete libs.first;

trunk/src/network/ssl/qsslsocket_openssl_symbols_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$
 **
 …
 bool q_resolveOpenSslSymbols();
+long q_ASN1_INTEGER_get(ASN1_INTEGER *a);
 unsigned char * q_ASN1_STRING_data(ASN1_STRING *a);
 int q_ASN1_STRING_length(ASN1_STRING *a);
 …
 int q_RAND_status();
 void q_RSA_free(RSA *a);
+int q_sk_num(STACK *a);
+void q_sk_pop_free(STACK *a, void (*b)(void *));
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+void q_sk_free(_STACK *a);
+void * q_sk_value(STACK *a, int b);
+#else
 void q_sk_free(STACK *a);
-int q_sk_num(STACK *a);
 char * q_sk_value(STACK *a, int b);
+#endif
 int q_SSL_accept(SSL *a);
 int q_SSL_clear(SSL *a);
 …
 long q_SSL_CTX_ctrl(SSL_CTX *a, int b, long c, void *d);
 void q_SSL_CTX_free(SSL_CTX *a);
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+SSL_CTX *q_SSL_CTX_new(const SSL_METHOD *a);
+#else
 SSL_CTX *q_SSL_CTX_new(SSL_METHOD *a);
+#endif
 int q_SSL_CTX_set_cipher_list(SSL_CTX *a, const char *b);
 int q_SSL_CTX_set_default_verify_paths(SSL_CTX *a);
 …
 STACK_OF(SSL_CIPHER) *q_SSL_get_ciphers(SSL *a);
 #endif
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+const SSL_CIPHER *q_SSL_get_current_cipher(SSL *a);
+#else
 SSL_CIPHER *q_SSL_get_current_cipher(SSL *a);
+#endif
 int q_SSL_get_error(SSL *a, int b);
 STACK_OF(X509) *q_SSL_get_peer_cert_chain(SSL *a);
 …
 void q_SSL_set_connect_state(SSL *a);
 int q_SSL_shutdown(SSL *a);
+#if OPENSSL_VERSION_NUMBER >= 0x10000000L
+const SSL_METHOD *q_SSLv2_client_method();
+const SSL_METHOD *q_SSLv3_client_method();
+const SSL_METHOD *q_SSLv23_client_method();
+const SSL_METHOD *q_TLSv1_client_method();
+const SSL_METHOD *q_SSLv2_server_method();
+const SSL_METHOD *q_SSLv3_server_method();
+const SSL_METHOD *q_SSLv23_server_method();
+const SSL_METHOD *q_TLSv1_server_method();
+#else
 SSL_METHOD *q_SSLv2_client_method();
 SSL_METHOD *q_SSLv3_client_method();
 …
 SSL_METHOD *q_SSLv23_server_method();
 SSL_METHOD *q_TLSv1_server_method();
+#endif
 int q_SSL_write(SSL *a, const void *b, int c);
 int q_X509_cmp(X509 *a, X509 *b);

trunk/src/network/ssl/qsslsocket_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$
 **
 …
     bool autoStartHandshake;
     bool connectionEncrypted;
+    bool ignoreSslErrors;
+    bool ignoreAllSslErrors;
+    QList<QSslError> ignoreErrorsList;
     bool* readyReadEmittedPointer;
 …
     QSslConfigurationPrivate configuration;
     QList<QSslError> sslErrors;
+    // if set, this hostname is used for certificate validation instead of the hostname
+    // that was used for connecting to.
+    QString verificationPeerName;
     static bool ensureInitialized();
 …
     void _q_bytesWrittenSlot(qint64);
     void _q_flushWriteBuffer();
+    void _q_flushReadBuffer();
     // Platform specific functions

trunk/src/network/ssl/ssl.pri

-              r2
+              r561
 # OpenSSL support; compile in QSslSocket.
 contains(QT_CONFIG, openssl) | contains(QT_CONFIG, openssl-linked) {
+    include($$QT_SOURCE_TREE/config.tests/unix/openssl/openssl.pri)
+symbian {
+        INCLUDEPATH *= $$OS_LAYER_SSL_SYSTEMINCLUDE
+} else {
+        include($$QT_SOURCE_TREE/config.tests/unix/openssl/openssl.pri)
+}
     HEADERS += ssl/qssl.h \
 …
     # Add optional SSL libs
     LIBS += $$OPENSSL_LIBS
+    LIBS_PRIVATE += $$OPENSSL_LIBS
+}

/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: