Changeset 846 for trunk/src/network

trunk

Property svn:mergeinfo changed
/branches/vendor/nokia/qt/4.7.2 (added) merged: 845
/branches/vendor/nokia/qt/current merged: 844
/branches/vendor/nokia/qt/4.6.3 removed

trunk/src/network/access/access.pri

-              r561
+              r846
 # Qt network access module
+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/qnetworkaccesscache_p.h \
+           access/qnetworkaccessbackend_p.h \
+           access/qnetworkaccessdatabackend_p.h \
+           access/qnetworkaccessdebugpipebackend_p.h \
+           access/qnetworkaccesshttpbackend_p.h \
+           access/qnetworkaccessfilebackend_p.h \
+           access/qnetworkaccesscachebackend_p.h \
+           access/qnetworkaccessftpbackend_p.h \
+           access/qnetworkcookie.h \
+           access/qnetworkcookie_p.h \
+           access/qnetworkcookiejar.h \
+           access/qnetworkcookiejar_p.h \
+           access/qnetworkrequest.h \
+           access/qnetworkrequest_p.h \
+           access/qnetworkreply.h \
+           access/qnetworkreply_p.h \
+           access/qnetworkreplyimpl_p.h \
+           access/qabstractnetworkcache_p.h \
+           access/qabstractnetworkcache.h \
+           access/qnetworkdiskcache_p.h \
+           access/qnetworkdiskcache.h
+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/qnetworkaccesscache_p.h \
+    access/qnetworkaccessbackend_p.h \
+    access/qnetworkaccessdatabackend_p.h \
+    access/qnetworkaccessdebugpipebackend_p.h \
+    access/qnetworkaccesshttpbackend_p.h \
+    access/qnetworkaccessfilebackend_p.h \
+    access/qnetworkaccesscachebackend_p.h \
+    access/qnetworkaccessftpbackend_p.h \
+    access/qnetworkcookie.h \
+    access/qnetworkcookie_p.h \
+    access/qnetworkcookiejar.h \
+    access/qnetworkcookiejar_p.h \
+    access/qnetworkcookiejartlds_p.h \
+    access/qnetworkrequest.h \
+    access/qnetworkrequest_p.h \
+    access/qnetworkreply.h \
+    access/qnetworkreply_p.h \
+    access/qnetworkreplyimpl_p.h \
+    access/qabstractnetworkcache_p.h \
+    access/qabstractnetworkcache.h \
+    access/qnetworkdiskcache_p.h \
+    access/qnetworkdiskcache.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/qnetworkaccessbackend.cpp \
+           access/qnetworkaccessdatabackend.cpp \
+           access/qnetworkaccessdebugpipebackend.cpp \
+           access/qnetworkaccessfilebackend.cpp \
+           access/qnetworkaccesscachebackend.cpp \
+           access/qnetworkaccessftpbackend.cpp \
+           access/qnetworkaccesshttpbackend.cpp \
+           access/qnetworkcookie.cpp \
+           access/qnetworkcookiejar.cpp \
+           access/qnetworkrequest.cpp \
+           access/qnetworkreply.cpp \
+           access/qnetworkreplyimpl.cpp \
+           access/qabstractnetworkcache.cpp \
+           access/qnetworkdiskcache.cpp
+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/qnetworkaccessbackend.cpp \
+    access/qnetworkaccessdatabackend.cpp \
+    access/qnetworkaccessdebugpipebackend.cpp \
+    access/qnetworkaccessfilebackend.cpp \
+    access/qnetworkaccesscachebackend.cpp \
+    access/qnetworkaccessftpbackend.cpp \
+    access/qnetworkaccesshttpbackend.cpp \
+    access/qnetworkcookie.cpp \
+    access/qnetworkcookiejar.cpp \
+    access/qnetworkrequest.cpp \
+    access/qnetworkreply.cpp \
+    access/qnetworkreplyimpl.cpp \
+    access/qabstractnetworkcache.cpp \
+    access/qnetworkdiskcache.cpp
+#zlib support
+contains(QT_CONFIG, zlib) {
+   INCLUDEPATH += ../3rdparty/zlib
+} else:!contains(QT_CONFIG, no-zlib) {
+   unix:LIBS_PRIVATE += -lz
+#  win32:LIBS += libz.lib
+}
+include($$PWD/../../3rdparty/zlib_dependency.pri)

trunk/src/network/access/qabstractnetworkcache.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     Writes \a metaData to the \a out stream.
     \sa {Format of the QDataStream operators}
+    \sa {Serializing Qt Data Types}
 */
 QDataStream &operator<<(QDataStream &out, const QNetworkCacheMetaData &metaData)
 …
     Reads a QNetworkCacheMetaData from the stream \a in into \a metaData.
     \sa {Format of the QDataStream operators}
+    \sa {Serializing Qt Data Types}
 */
 QDataStream &operator>>(QDataStream &in, QNetworkCacheMetaData &metaData)

trunk/src/network/access/qabstractnetworkcache.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qabstractnetworkcache_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qfilenetworkreply.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     QString fileName = url.toLocalFile();
     if (fileName.isEmpty()) {
+        fileName = url.toString(QUrl::RemoveAuthority | QUrl::RemoveFragment | QUrl::RemoveQuery);
+        if (url.scheme() == QLatin1String("qrc"))
+            fileName = QLatin1Char(':') + url.path();
+        else
+            fileName = url.toString(QUrl::RemoveAuthority | QUrl::RemoveFragment | QUrl::RemoveQuery);
+    }

trunk/src/network/access/qfilenetworkreply_p.h

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qftp.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     if (pending.isEmpty()) {
         qWarning() << "QFtpPrivate::_q_piError was called without pending command!";
+        qWarning("QFtpPrivate::_q_piError was called without pending command!");
         return;
+    }

trunk/src/network/access/qftp.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qhttp.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
             proxy.setType(QNetworkProxy::NoProxy);
         } else if (sslInUse) {
             // Disallow use of cacheing proxy with HTTPS; instead fall back to
+            // Disallow use of caching proxy with HTTPS; instead fall back to
             // transparent HTTP CONNECT proxying.
             transparentProxyInUse = true;

trunk/src/network/access/qhttp.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qhttpnetworkconnection.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 ****************************************************************************/
+#include <private/qabstractsocket_p.h>
 #include "qhttpnetworkconnection_p.h"
 #include "qhttpnetworkconnectionchannel_p.h"
 …
 #ifndef QT_NO_OPENSSL
+#    include <private/qsslsocket_p.h>
 #    include <QtNetwork/qsslkey.h>
 #    include <QtNetwork/qsslcipher.h>
 …
 QHttpNetworkConnectionPrivate::QHttpNetworkConnectionPrivate(const QString &hostName, quint16 port, bool encrypt)
 : hostName(hostName), port(port), encrypt(encrypt),
   channelCount(defaultChannelCount),
   pendingAuthSignal(false), pendingProxyAuthSignal(false)
+: state(RunningState),
+  hostName(hostName), port(port), encrypt(encrypt),
+  channelCount(defaultChannelCount)
 #ifndef QT_NO_NETWORKPROXY
   , networkProxy(QNetworkProxy::NoProxy)
 …
 QHttpNetworkConnectionPrivate::QHttpNetworkConnectionPrivate(quint16 channelCount, const QString &hostName, quint16 port, bool encrypt)
 : hostName(hostName), port(port), encrypt(encrypt),
   channelCount(channelCount),
   pendingAuthSignal(false), pendingProxyAuthSignal(false)
+: state(RunningState),
+  hostName(hostName), port(port), encrypt(encrypt),
+  channelCount(channelCount)
 #ifndef QT_NO_NETWORKPROXY
   , networkProxy(QNetworkProxy::NoProxy)
 …
         channels[i].init();
+    }
+}
+void QHttpNetworkConnectionPrivate::pauseConnection()
+{
+    state = PausedState;
+    // Disable all socket notifiers
+    for (int i = 0; i < channelCount; i++) {
+#ifndef QT_NO_OPENSSL
+        if (encrypt)
+            QSslSocketPrivate::pauseSocketNotifiers(static_cast<QSslSocket*>(channels[i].socket));
+        else
+#endif
+            QAbstractSocketPrivate::pauseSocketNotifiers(channels[i].socket);
+    }
+}
+void QHttpNetworkConnectionPrivate::resumeConnection()
+{
+    state = RunningState;
+    // Enable all socket notifiers
+    for (int i = 0; i < channelCount; i++) {
+#ifndef QT_NO_OPENSSL
+        if (encrypt)
+            QSslSocketPrivate::resumeSocketNotifiers(static_cast<QSslSocket*>(channels[i].socket));
+        else
+#endif
+            QAbstractSocketPrivate::resumeSocketNotifiers(channels[i].socket);
+        // Resume pending upload if needed
+        if (channels[i].state == QHttpNetworkConnectionChannel::WritingState)
+            QMetaObject::invokeMethod(&channels[i], "_q_uploadDataReadyRead", Qt::QueuedConnection);
+    }
+    // queue _q_startNextRequest
+    QMetaObject::invokeMethod(this->q_func(), "_q_startNextRequest", Qt::QueuedConnection);
+}
 …
     Q_ASSERT(auth);
+    // NTLM is a multi phase authentication. Copying credentials between authenticators would mess things up.
+    if (!isProxy && channels[fromChannel].authMethod == QAuthenticatorPrivate::Ntlm)
+        return;
+    if (isProxy && channels[fromChannel].proxyAuthMethod == QAuthenticatorPrivate::Ntlm)
+        return;
     // select another channel
     QAuthenticator* otherAuth = 0;
 …
     Q_ASSERT(reply);
-    Q_Q(QHttpNetworkConnection);
     resend = false;
     //create the response header to be used with QAuthenticatorPrivate.
-    QHttpResponseHeader responseHeader;
     QList<QPair<QByteArray, QByteArray> > fields = reply->header();
+    QList<QPair<QByteArray, QByteArray> >::const_iterator it = fields.constBegin();
+    while (it != fields.constEnd()) {
+        responseHeader.addValue(QString::fromLatin1(it->first), QString::fromUtf8(it->second));
+        it++;
+    }
     //find out the type of authentication protocol requested.
     QAuthenticatorPrivate::Method authMethod = reply->d_func()->authenticationMethod(isProxy);
 …
         if (isProxy) {
             auth = &channels[i].proxyAuthenticator;
             channels[i].proxyAuthMehtod = authMethod;
+            channels[i].proxyAuthMethod = authMethod;
         } else {
             auth = &channels[i].authenticator;
             channels[i].authMehtod = authMethod;
+            channels[i].authMethod = authMethod;
+        }
         //proceed with the authentication.
 …
             auth->detach();
         QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(*auth);
         priv->parseHttpResponse(responseHeader, isProxy);
+        priv->parseHttpResponse(fields, isProxy);
         if (priv->phase == QAuthenticatorPrivate::Done) {
+            if ((isProxy && pendingProxyAuthSignal) ||(!isProxy && pendingAuthSignal)) {
+                // drop the request
+                reply->d_func()->eraseData();
+                channels[i].close();
+                channels[i].lastStatus = 0;
+                channels[i].state =  QHttpNetworkConnectionChannel::Wait4AuthState;
+                return false;
+            }
+            // cannot use this socket until the slot returns
+            channels[i].state = QHttpNetworkConnectionChannel::WaitingState;
+            socket->blockSignals(true);
+            pauseConnection();
             if (!isProxy) {
+                pendingAuthSignal = true;
+                emit q->authenticationRequired(reply->request(), auth, q);
+                pendingAuthSignal = false;
+                emit reply->authenticationRequired(reply->request(), auth);
 #ifndef QT_NO_NETWORKPROXY
             } else {
+                pendingProxyAuthSignal = true;
+                emit q->proxyAuthenticationRequired(networkProxy, auth, q);
+                pendingProxyAuthSignal = false;
+                emit reply->proxyAuthenticationRequired(networkProxy, auth);
 #endif
+            }
+            socket->blockSignals(false);
+            // socket free to use
+            channels[i].state = QHttpNetworkConnectionChannel::IdleState;
+            resumeConnection();
             if (priv->phase != QAuthenticatorPrivate::Done) {
                 // send any pending requests
                 copyCredentials(i,  auth, isProxy);
-                QMetaObject::invokeMethod(q, "_q_restartAuthPendingRequests", Qt::QueuedConnection);
+            }
+        }
+        // changing values in QAuthenticator will reset the 'phase'
+        if (priv->phase == QAuthenticatorPrivate::Done) {
+        // - Changing values in QAuthenticator will reset the 'phase'. Therefore if it is still "Done"
+        //   then nothing was filled in by the user or the cache
+        // - If withCredentials has been set to false (e.g. by QtWebKit for a cross-origin XMLHttpRequest) then
+        //   we need to bail out if authentication is required.
+        if (priv->phase == QAuthenticatorPrivate::Done || !reply->request().withCredentials()) {
+            // Reset authenticator so the next request on that channel does not get messed up
+            auth = 0;
+            if (isProxy)
+                channels[i].proxyAuthenticator = QAuthenticator();
+            else
+                channels[i].authenticator = QAuthenticator();
             // authentication is cancelled, send the current contents to the user.
             emit channels[i].reply->headerChanged();
 …
                 : QNetworkReply::AuthenticationRequiredError;
             reply->d_func()->errorString = errorDetail(errorCode, socket);
+            emit q->error(errorCode, reply->d_func()->errorString);
+            emit channels[i].reply->finished();
+            emit reply->finishedWithError(errorCode, reply->d_func()->errorString);
             // ### at this point the reply could be deleted
             socket->close();
-            // remove pending request on the other channels
-            for (int j = 0; j < channelCount; ++j) {
-                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)) {
+    // Send "Authorization" header, but not if it's NTLM and the socket is already authenticated.
+    if (channels[i].authMethod != QAuthenticatorPrivate::None) {
+        if (!(channels[i].authMethod == QAuthenticatorPrivate::Ntlm && channels[i].lastStatus != 401)) {
             QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(channels[i].authenticator);
             if (priv && priv->method != QAuthenticatorPrivate::None) {
 …
+        }
+    }
+    if (channels[i].proxyAuthMehtod != QAuthenticatorPrivate::None) {
+        if (!(channels[i].proxyAuthMehtod == QAuthenticatorPrivate::Ntlm && channels[i].lastStatus != 407)) {
+    // Send "Proxy-Authorization" header, but not if it's NTLM and the socket is already authenticated.
+    if (channels[i].proxyAuthMethod != QAuthenticatorPrivate::None) {
+        if (!(channels[i].proxyAuthMethod == QAuthenticatorPrivate::Ntlm && channels[i].lastStatus != 407)) {
             QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(channels[i].proxyAuthenticator);
             if (priv && priv->method != QAuthenticatorPrivate::None) {
 …
         if (channels[i].reply == reply) {
             channels[i].reply = 0;
+            channels[i].request = QHttpNetworkRequest();
+            channels[i].resendCurrent = false;
             if (!reply->isFinished() && !channels[i].alreadyPipelinedRequests.isEmpty()) {
 …
 void QHttpNetworkConnectionPrivate::_q_startNextRequest()
+{
+    // If the QHttpNetworkConnection is currently paused then bail out immediately
+    if (state == PausedState)
+        return;
     //resend the necessary ones.
     for (int i = 0; i < channelCount; ++i) {
 …
     // try to get a free AND connected socket
     for (int i = 0; i < channelCount; ++i) {
         if (!channels[i].isSocketBusy() && channels[i].socket->state() == QAbstractSocket::ConnectedState) {
+        if (!channels[i].reply && !channels[i].isSocketBusy() && channels[i].socket->state() == QAbstractSocket::ConnectedState) {
             dequeueAndSendRequest(channels[i].socket);
+        }
 …
     // try to get a free unconnected socket
     for (int i = 0; i < channelCount; ++i) {
         if (!channels[i].isSocketBusy()) {
+        if (!channels[i].reply && !channels[i].isSocketBusy()) {
             dequeueAndSendRequest(channels[i].socket);
+        }
 …
+}
-void QHttpNetworkConnectionPrivate::_q_restartAuthPendingRequests()
+{
-    // send the request using the idle socket
-    for (int i = 0 ; i < channelCount; ++i) {
-        if (channels[i].state ==  QHttpNetworkConnectionChannel::Wait4AuthState) {
-            channels[i].state = QHttpNetworkConnectionChannel::IdleState;
-            if (channels[i].reply)
-                channels[i].sendRequest();
+        }
+    }
+}
 void QHttpNetworkConnectionPrivate::readMoreLater(QHttpNetworkReply *reply)
 …
+}
+void QHttpNetworkConnection::enableEncryption()
+{
+    Q_D(QHttpNetworkConnection);
+    d->encrypt = true;
+}
+bool QHttpNetworkConnection::isEncrypted() const
+bool QHttpNetworkConnection::isSsl() const
+{
     Q_D(const QHttpNetworkConnection);
 …
+}
+void QHttpNetworkConnection::setProxyAuthentication(QAuthenticator *authenticator)
+{
+    Q_D(QHttpNetworkConnection);
+    for (int i = 0; i < d->channelCount; ++i)
+        d->channels[i].proxyAuthenticator = *authenticator;
+}
+void QHttpNetworkConnection::setAuthentication(const QString &domain, QAuthenticator *authenticator)
+{
+    Q_UNUSED(domain); // ### domain ?
+    Q_D(QHttpNetworkConnection);
+    for (int i = 0; i < d->channelCount; ++i)
+        d->channels[i].authenticator = *authenticator;
+QHttpNetworkConnectionChannel *QHttpNetworkConnection::channels() const
+{
+    return d_func()->channels;
+}
 …
 void QHttpNetworkConnectionPrivate::emitProxyAuthenticationRequired(const QHttpNetworkConnectionChannel *chan, const QNetworkProxy &proxy, QAuthenticator* auth)
+{
+    Q_Q(QHttpNetworkConnection);
+    emit q->proxyAuthenticationRequired(proxy, auth, q);
+    // Also pause the connection because socket notifiers may fire while an user
+    // dialog is displaying
+    pauseConnection();
+    emit chan->reply->proxyAuthenticationRequired(proxy, auth);
+    resumeConnection();
     int i = indexOf(chan->socket);
     copyCredentials(i, auth, true);

trunk/src/network/access/qhttpnetworkconnection_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #endif
+    //enable encryption
+    void enableEncryption();
+    bool isEncrypted() const;
+    //authentication parameters
+    void setProxyAuthentication(QAuthenticator *authenticator);
+    void setAuthentication(const QString &domain, QAuthenticator *authenticator);
+    bool isSsl() const;
+    QHttpNetworkConnectionChannel *channels() const;
 #ifndef QT_NO_OPENSSL
 …
     void ignoreSslErrors(int channel = -1);
     void ignoreSslErrors(const QList<QSslError> &errors, int channel = -1);
+Q_SIGNALS:
+    void sslErrors(const QList<QSslError> &errors);
+#endif
+Q_SIGNALS:
+#ifndef QT_NO_NETWORKPROXY
+    //cannot be used with queued connection.
+    void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator,
+                                     const QHttpNetworkConnection *connection = 0);
+#endif
+    void authenticationRequired(const QHttpNetworkRequest &request, QAuthenticator *authenticator,
+                                const QHttpNetworkConnection *connection = 0);
+    void error(QNetworkReply::NetworkError errorCode, const QString &detail = QString());
+#endif
 private:
 …
     Q_DISABLE_COPY(QHttpNetworkConnection)
     friend class QHttpNetworkReply;
+    friend class QHttpNetworkReplyPrivate;
     friend class QHttpNetworkConnectionChannel;
     Q_PRIVATE_SLOT(d_func(), void _q_startNextRequest())
-    Q_PRIVATE_SLOT(d_func(), void _q_restartAuthPendingRequests())
 };
 …
     static const int defaultRePipelineLength;
+    enum ConnectionState {
+        RunningState = 0,
+        PausedState = 1,
+    };
     QHttpNetworkConnectionPrivate(const QString &hostName, quint16 port, bool encrypt);
     QHttpNetworkConnectionPrivate(quint16 channelCount, const QString &hostName, quint16 port, bool encrypt);
 …
     void init();
+    void pauseConnection();
+    void resumeConnection();
+    ConnectionState state;
     enum { ChunkSize = 4096 };
 …
     // 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);
 …
     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;

trunk/src/network/access/qhttpnetworkconnectionchannel.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     , pendingEncrypt(false)
     , reconnectAttempts(2)
     , authMehtod(QAuthenticatorPrivate::None)
     , proxyAuthMehtod(QAuthenticatorPrivate::None)
+    , authMethod(QAuthenticatorPrivate::None)
+    , proxyAuthMethod(QAuthenticatorPrivate::None)
 #ifndef QT_NO_OPENSSL
     , ignoreAllSslErrors(false)
 …
                      this, SLOT(_q_readyRead()),
                      Qt::DirectConnection);
+    // The disconnected() and error() signals may already come
+    // while calling connectToHost().
+    // In case of a cached hostname or an IP this
+    // will then emit a signal to the user of QNetworkReply
+    // but cannot be caught because the user did not have a chance yet
+    // to connect to QNetworkReply's signals.
+    qRegisterMetaType<QAbstractSocket::SocketError>("QAbstractSocket::SocketError");
     QObject::connect(socket, SIGNAL(disconnected()),
                      this, SLOT(_q_disconnected()),
                      Qt::DirectConnection);
+                     Qt::QueuedConnection);
     QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
                      this, SLOT(_q_error(QAbstractSocket::SocketError)),
+                     Qt::DirectConnection);
+                     Qt::QueuedConnection);
 #ifndef QT_NO_NETWORKPROXY
     QObject::connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
 …
         reply->d_func()->pipeliningUsed = false;
-        pendingEncrypt = false;
         // if the url contains authentication parameters, use the new ones
         // both channels will use the new authentication parameters
         if (!request.url().userInfo().isEmpty()) {
+        if (!request.url().userInfo().isEmpty() && request.withCredentials()) {
             QUrl url = request.url();
             QAuthenticator &auth = authenticator;
 …
                 auth.setUser(url.userName());
                 auth.setPassword(url.password());
+                emit reply->cacheCredentials(request, &auth);
                 connection->d_func()->copyCredentials(connection->d_func()->indexOf(socket), &auth, false);
+            }
 …
             request.setUrl(url);
+        }
+        connection->d_func()->createAuthorization(socket, request);
+        // Will only be false if QtWebKit is performing a cross-origin XMLHttpRequest
+        // and withCredentials has not been set to true.
+        if (request.withCredentials())
+            connection->d_func()->createAuthorization(socket, request);
 #ifndef QT_NO_NETWORKPROXY
         QByteArray header = QHttpNetworkRequestPrivate::header(request,
 …
+    }
     case QHttpNetworkConnectionChannel::ReadingState:
-    case QHttpNetworkConnectionChannel::Wait4AuthState:
         // ignore _q_bytesWritten in these states
         // fall through
 …
         case QHttpNetworkReplyPrivate::ReadingDataState: {
            QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();
+           if (replyPrivate->downstreamLimited && !replyPrivate->responseData.isEmpty() && replyPrivate->shouldEmitSignals()) {
+           if (socket->state() == QAbstractSocket::ConnectedState &&
+               replyPrivate->downstreamLimited && !replyPrivate->responseData.isEmpty() && replyPrivate->shouldEmitSignals()) {
+               // (only do the following when still connected, not when we have already been disconnected and there is still data)
                // We already have some HTTP body data. We don't read more from the socket until
                // this is fetched by QHttpNetworkAccessHttpBackend. If we would read more,
 …
                return;
+           }
             if (!replyPrivate->isChunked() && !replyPrivate->autoDecompress
                 && replyPrivate->bodyLength > 0) {
 …
     // Note that this may trigger a segfault at some other point. But then we can fix the underlying
     // problem.
+    if (!resendCurrent)
+    if (!resendCurrent) {
+        request = QHttpNetworkRequest();
         reply = 0;
+    }
     // move next from pipeline to current request
 …
         QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
     } else if (alreadyPipelinedRequests.isEmpty()) {
+        QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+        if (qobject_cast<QHttpNetworkConnection*>(connection))
+            QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+    }
+}
 …
                 : QNetworkReply::AuthenticationRequiredError;
             reply->d_func()->errorString = connection->d_func()->errorDetail(errorCode, socket);
+            emit connection->error(errorCode, reply->d_func()->errorString);
+            emit reply->finished();
+            emit reply->finishedWithError(errorCode, reply->d_func()->errorString);
+        }
         break;
     default:
+        QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+        if (qobject_cast<QHttpNetworkConnection*>(connection))
+            QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+    }
+}
 …
     close();
     resendCurrent = true;
+    QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+    if (qobject_cast<QHttpNetworkConnection*>(connection))
+        QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+}
 …
     if (!socket)
         return;
-    bool send2Reply = false;
     QNetworkReply::NetworkError errorCode = QNetworkReply::UnknownNetworkError;
 …
                 return;
             } else {
-                send2Reply = true;
                 errorCode = QNetworkReply::RemoteHostClosedError;
+            }
 …
             return;
+        }
-        send2Reply = true;
         errorCode = QNetworkReply::TimeoutError;
         break;
 …
     QPointer<QHttpNetworkConnection> that = connection;
     QString errorString = connection->d_func()->errorDetail(errorCode, socket, socket->errorString());
+    if (send2Reply) {
+        if (reply) {
+            reply->d_func()->errorString = errorString;
+            // this error matters only to this reply
+            emit reply->finishedWithError(errorCode, errorString);
+        }
+        // send the next request
+        QMetaObject::invokeMethod(that, "_q_startNextRequest", Qt::QueuedConnection);
+    } else {
+        // the failure affects all requests.
+        emit connection->error(errorCode, errorString);
+    }
+    if (reply) {
+        reply->d_func()->errorString = errorString;
+        emit reply->finishedWithError(errorCode, errorString);
+    }
+    // send the next request
+    QMetaObject::invokeMethod(that, "_q_startNextRequest", Qt::QueuedConnection);
     if (that) //signal emission triggered event loop
         close();
 …
         return; // ### error
     state = QHttpNetworkConnectionChannel::IdleState;
+    pendingEncrypt = false;
     sendRequest();
+}
 …
         return;
     //QNetworkReply::NetworkError errorCode = QNetworkReply::ProtocolFailure;
+    emit connection->sslErrors(errors);
+    // Also pause the connection because socket notifiers may fire while an user
+    // dialog is displaying
+    connection->d_func()->pauseConnection();
+    emit reply->sslErrors(errors);
+    connection->d_func()->resumeConnection();
+}

trunk/src/network/access/qhttpnetworkconnectionchannel_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         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)
+        BusyState = (ConnectingState|WritingState|WaitingState|ReadingState)
     };
     QAbstractSocket *socket;
 …
     bool pendingEncrypt; // for https (send after encrypted)
     int reconnectAttempts; // maximum 2 reconnection attempts
     QAuthenticatorPrivate::Method authMehtod;
     QAuthenticatorPrivate::Method proxyAuthMehtod;
+    QAuthenticatorPrivate::Method authMethod;
+    QAuthenticatorPrivate::Method proxyAuthMethod;
     QAuthenticator authenticator;
     QAuthenticator proxyAuthenticator;
 …
     bool isSocketReading() const;
+    friend class QNetworkAccessHttpBackend;
     protected slots:
     void _q_receiveReply();

trunk/src/network/access/qhttpnetworkheader.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+{
     bool ok = false;
+    QByteArray value = headerField("content-length");
+    // We are not using the headerField() method here because servers might send us multiple content-length
+    // headers which is crap (see QTBUG-15311). Therefore just take the first content-length header field.
+    QByteArray value;
+    QList<QPair<QByteArray, QByteArray> >::ConstIterator it = fields.constBegin(),
+                                                        end = fields.constEnd();
+    for ( ; it != end; ++it)
+        if (qstricmp("content-length", it->first) == 0) {
+            value = it->second;
+            break;
+        }
     qint64 length = value.toULongLong(&ok);
     if (ok)

trunk/src/network/access/qhttpnetworkheader_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qhttpnetworkreply.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+}
+QByteArray QHttpNetworkReply::readAll()
+{
+    Q_D(QHttpNetworkReply);
+    return d->responseData.readAll();
+}
 void QHttpNetworkReply::setDownstreamLimited(bool dsl)
+{
 …
+{
     return d_func()->pipeliningUsed;
+}
+QHttpNetworkConnection* QHttpNetworkReply::connection()
+{
+    return d_func()->connection;
+}

trunk/src/network/access/qhttpnetworkreply_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     qint64 bytesAvailableNextBlock() const;
     QByteArray readAny();
+    QByteArray readAll();
     void setDownstreamLimited(bool t);
 …
     bool isPipeliningUsed() const;
+    QHttpNetworkConnection* connection();
 #ifndef QT_NO_OPENSSL
 …
     void dataReadProgress(int done, int total);
     void dataSendProgress(qint64 done, qint64 total);
+    void cacheCredentials(const QHttpNetworkRequest &request, QAuthenticator *authenticator);
+#ifndef QT_NO_NETWORKPROXY
+    void proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator);
+#endif
+    void authenticationRequired(const QHttpNetworkRequest &request, QAuthenticator *authenticator);
 private:
     Q_DECLARE_PRIVATE(QHttpNetworkReply)

trunk/src/network/access/qhttpnetworkrequest.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         QHttpNetworkRequest::Priority pri, const QUrl &newUrl)
     : QHttpNetworkHeaderPrivate(newUrl), operation(op), priority(pri), uploadByteDevice(0),
       autoDecompress(false), pipeliningAllowed(false)
+      autoDecompress(false), pipeliningAllowed(false), withCredentials(true)
+{
+}
 …
     autoDecompress = other.autoDecompress;
     pipeliningAllowed = other.pipeliningAllowed;
+    customVerb = other.customVerb;
+    withCredentials = other.withCredentials;
+}
 …
 QByteArray QHttpNetworkRequestPrivate::methodName() const
+{
-    QByteArray ba;
     switch (operation) {
+    case QHttpNetworkRequest::Get:
+        return "GET";
+        break;
+    case QHttpNetworkRequest::Head:
+        return "HEAD";
+        break;
+    case QHttpNetworkRequest::Post:
+        return "POST";
+        break;
     case QHttpNetworkRequest::Options:
+        ba += "OPTIONS";
+        break;
+    case QHttpNetworkRequest::Get:
+        ba += "GET";
+        break;
+    case QHttpNetworkRequest::Head:
+        ba += "HEAD";
+        break;
+    case QHttpNetworkRequest::Post:
+        ba += "POST";
+        return "OPTIONS";
         break;
     case QHttpNetworkRequest::Put:
         ba += "PUT";
+        return "PUT";
         break;
     case QHttpNetworkRequest::Delete:
         ba += "DELETE";
+        return "DELETE";
         break;
     case QHttpNetworkRequest::Trace:
         ba += "TRACE";
+        return "TRACE";
         break;
     case QHttpNetworkRequest::Connect:
+        ba += "CONNECT";
+        return "CONNECT";
+        break;
+    case QHttpNetworkRequest::Custom:
+        return customVerb;
         break;
     default:
         break;
+    }
     return ba;
+    return QByteArray();
+}
 …
 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();
+    QByteArray ba;
+    ba.reserve(40 + fields.length()*25); // very rough lower bound estimation
+    ba += request.d->methodName();
+    ba += ' ';
+    ba += request.d->uri(throughProxy);
+    ba += " HTTP/";
+    ba += QByteArray::number(request.majorVersion());
+    ba += '.';
+    ba += QByteArray::number(request.minorVersion());
+    ba += "\r\n";
     QList<QPair<QByteArray, QByteArray> >::const_iterator it = fields.constBegin();
+    for (; it != fields.constEnd(); ++it)
+        ba += it->first + ": " + it->second + "\r\n";
+    QList<QPair<QByteArray, QByteArray> >::const_iterator endIt = fields.constEnd();
+    for (; it != endIt; ++it) {
+        ba += it->first;
+        ba += ": ";
+        ba += it->second;
+        ba += "\r\n";
+    }
     if (request.d->operation == QHttpNetworkRequest::Post) {
         // add content type, if not set in the request
 …
         if (!request.d->uploadByteDevice && request.d->url.hasQuery()) {
             QByteArray query = request.d->url.encodedQuery();
+            ba += "Content-Length: "+ QByteArray::number(query.size()) + "\r\n";
+            ba += "\r\n";
+            ba += "Content-Length: ";
+            ba += QByteArray::number(query.size());
+            ba += "\r\n\r\n";
             ba += query;
         } else {
 …
+}
+QByteArray QHttpNetworkRequest::customVerb() const
+{
+    return d->customVerb;
+}
+void QHttpNetworkRequest::setCustomVerb(const QByteArray &customVerb)
+{
+    d->customVerb = customVerb;
+}
 QHttpNetworkRequest::Priority QHttpNetworkRequest::priority() const
+{
 …
+}
+bool QHttpNetworkRequest::withCredentials() const
+{
+    return d->withCredentials;
+}
+void QHttpNetworkRequest::setWithCredentials(bool b)
+{
+    d->withCredentials = b;
+}
 void QHttpNetworkRequest::setUploadByteDevice(QNonContiguousByteDevice *bd)
+{

trunk/src/network/access/qhttpnetworkrequest_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         Delete,
         Trace,
+        Connect
+        Connect,
+        Custom
     };
 …
     void setOperation(Operation operation);
+    QByteArray customVerb() const;
+    void setCustomVerb(const QByteArray &customOperation);
     Priority priority() const;
     void setPriority(Priority priority);
 …
     bool isPipeliningAllowed() const;
     void setPipeliningAllowed(bool b);
+    bool withCredentials() const;
+    void setWithCredentials(bool b);
     void setUploadByteDevice(QNonContiguousByteDevice *bd);
 …
     QHttpNetworkRequest::Operation operation;
+    QByteArray customVerb;
     QHttpNetworkRequest::Priority priority;
     mutable QNonContiguousByteDevice* uploadByteDevice;
     bool autoDecompress;
     bool pipeliningAllowed;
+    bool withCredentials;
 };

trunk/src/network/access/qnetworkaccessbackend.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "QtCore/qhash.h"
 #include "QtCore/qmutex.h"
+#include "QtNetwork/qnetworksession.h"
 #include "qnetworkaccesscachebackend_p.h"
 #include "qabstractnetworkcache.h"
+#include "qhostinfo.h"
 #include "private/qnoncontiguousbytedevice_p.h"
 …
                                                                  const QNetworkRequest &request)
+{
-    QNetworkRequest::CacheLoadControl mode =
-        static_cast<QNetworkRequest::CacheLoadControl>(
-            request.attribute(QNetworkRequest::CacheLoadControlAttribute,
-                              QNetworkRequest::PreferNetwork).toInt());
-    if (mode == QNetworkRequest::AlwaysCache
-        && (op == QNetworkAccessManager::GetOperation
-        || op == QNetworkAccessManager::HeadOperation)) {
-        QNetworkAccessBackend *backend = new QNetworkAccessCacheBackend;
-        backend->manager = this;
-        return backend;
+    }
     if (!factoryDataShutdown) {
         QMutexLocker locker(&factoryData()->mutex);
 …
     if (reply->outgoingDataBuffer)
         device = QNonContiguousByteDeviceFactory::create(reply->outgoingDataBuffer);
     else
+    else if (reply->outgoingData) {
         device = QNonContiguousByteDeviceFactory::create(reply->outgoingData);
+    } else {
+        return 0;
+    }
     bool bufferDisallowed =
 …
     : manager(0)
     , reply(0)
+    , synchronous(false)
+{
+}
 …
+{
     manager->authenticationRequired(this, authenticator);
+}
+void QNetworkAccessBackend::cacheCredentials(QAuthenticator *authenticator)
+{
+    manager->cacheCredentials(this->reply->url, authenticator);
+}
 …
+}
+#ifndef QT_NO_BEARERMANAGEMENT
+/*!
+    Starts the backend.  Returns true if the backend is started.  Returns false if the backend
+    could not be started due to an unopened or roaming session.  The caller should recall this
+    function once the session has been opened or the roaming process has finished.
+*/
+bool QNetworkAccessBackend::start()
+{
+    if (!manager->networkSession) {
+        open();
+        return true;
+    }
+    // This is not ideal.
+    const QString host = reply->url.host();
+    if (host == QLatin1String("localhost") ||
+        QHostAddress(host) == QHostAddress::LocalHost ||
+        QHostAddress(host) == QHostAddress::LocalHostIPv6) {
+        // Don't need an open session for localhost access.
+        open();
+        return true;
+    }
+    if (manager->networkSession->isOpen() &&
+        manager->networkSession->state() == QNetworkSession::Connected) {
+        open();
+        return true;
+    }
+    return false;
+}
+#endif
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkaccessbackend_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual void open() = 0;
+#ifndef QT_NO_BEARERMANAGEMENT
+    virtual bool start();
+#endif
     virtual void closeDownstreamChannel() = 0;
-    virtual bool waitForDownstreamReadyRead(int msecs) = 0;
     // slot-like:
 …
     void setAttribute(QNetworkRequest::Attribute code, const QVariant &value);
+    bool isSynchronous() { return synchronous; }
+    void setSynchronous(bool sync) { synchronous = sync; }
     // 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; }
+    // Returns true if backend is able to resume downloads.
+    virtual bool canResume() const { return false; }
+    virtual void setResumeOffset(quint64 offset) { Q_UNUSED(offset); }
+    virtual bool processRequestSynchronously() { return false; }
 protected:
 …
 #endif
     void authenticationRequired(QAuthenticator *auth);
+    void cacheCredentials(QAuthenticator *auth);
     void metaDataChanged();
     void redirectionRequested(const QUrl &destination);
 …
     friend class QNetworkAccessManagerPrivate;
     friend class QNetworkAccessBackendUploadIODevice;
+    friend class QNetworkReplyImplPrivate;
     QNetworkAccessManagerPrivate *manager;
     QNetworkReplyImplPrivate *reply;
+    bool synchronous;
 };

trunk/src/network/access/qnetworkaccesscache.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkaccesscache_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkaccesscachebackend.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+}
-bool QNetworkAccessCacheBackend::waitForDownstreamReadyRead(int)
+{
-    Q_ASSERT_X(false, Q_FUNC_INFO , "This function show not have been called!");
-    return false;
+}
-bool QNetworkAccessCacheBackend::waitForUpstreamBytesWritten(int)
+{
-    Q_ASSERT_X(false, Q_FUNC_INFO, "This function show not have been called!");
-    return false;
+}
 void QNetworkAccessCacheBackend::upstreamReadyRead()
+{

trunk/src/network/access/qnetworkaccesscachebackend_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     void closeDownstreamChannel();
     void closeUpstreamChannel();
-    bool waitForDownstreamReadyRead(int msecs);
-    bool waitForUpstreamBytesWritten(int msecs);
     void upstreamReadyRead();

trunk/src/network/access/qnetworkaccessdatabackend.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qnetworkreply.h"
 #include "qurlinfo.h"
+#include "private/qdataurl_p.h"
+#include <qcoreapplication.h>
 QT_BEGIN_NAMESPACE
 …
         operation() != QNetworkAccessManager::HeadOperation) {
         // data: doesn't support anything but GET
+        QString msg = QObject::tr("Operation not supported on %1")
+        const QString msg = QCoreApplication::translate("QNetworkAccessDataBackend",
+                                                        "Operation not supported on %1")
                       .arg(uri.toString());
         error(QNetworkReply::ContentOperationNotPermittedError, msg);
 …
+    }
+    if (uri.host().isEmpty()) {
+        setHeader(QNetworkRequest::ContentTypeHeader, QLatin1String("text/plain;charset=US-ASCII"));
+    QPair<QString, QByteArray> decoded = qDecodeDataUrl(uri);
+        // the following would have been the correct thing, but
+        // reality often differs from the specification. People have
+        // data: URIs with ? and #
+        //QByteArray data = QByteArray::fromPercentEncoding(uri.encodedPath());
+        QByteArray data = QByteArray::fromPercentEncoding(uri.toEncoded());
+    if (! decoded.first.isNull()) {
+        setHeader(QNetworkRequest::ContentTypeHeader, decoded.first);
+        setHeader(QNetworkRequest::ContentLengthHeader, decoded.second.size());
+        emit metaDataChanged();
+        // remove the data: scheme
+        data.remove(0, 5);
+        QByteDataBuffer list;
+        list.append(decoded.second);
+        decoded.second.clear(); // important because of implicit sharing!
+        writeDownstreamData(list);
+        // parse it:
+        int pos = data.indexOf(',');
+        if (pos != -1) {
+            QByteArray payload = data.mid(pos + 1);
+            data.truncate(pos);
+            data = data.trimmed();
+            // find out if the payload is encoded in Base64
+            if (data.endsWith(";base64")) {
+                payload = QByteArray::fromBase64(payload);
+                data.chop(7);
+            }
+            if (data.toLower().startsWith("charset")) {
+                int i = 7;      // strlen("charset")
+                while (data.at(i) == ' ')
+                    ++i;
+                if (data.at(i) == '=')
+                    data.prepend("text/plain;");
+            }
+            if (!data.isEmpty())
+                setHeader(QNetworkRequest::ContentTypeHeader, data.trimmed());
+            setHeader(QNetworkRequest::ContentLengthHeader, payload.size());
+            emit metaDataChanged();
+            QByteDataBuffer list;
+            list.append(payload);
+            payload.clear(); // important because of implicit sharing!
+            writeDownstreamData(list);
+            finished();
+            return;
+        }
+        finished();
+        return;
+    }
     // something wrong with this URI
+    QString msg = QObject::tr("Invalid URI: %1").arg(uri.toString());
+    const QString msg = QCoreApplication::translate("QNetworkAccessDataBackend",
+                                                    "Invalid URI: %1").arg(uri.toString());
     error(QNetworkReply::ProtocolFailure, msg);
     finished();
 …
+}
+bool QNetworkAccessDataBackend::processRequestSynchronously()
+{
+#ifndef QT_NO_BEARERMANAGEMENT
+    start();
+#else
+    open();
+#endif
+    return true;
+}
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkaccessdatabackend_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual bool waitForDownstreamReadyRead(int msecs);
     virtual bool waitForUpstreamBytesWritten(int msecs);
+    virtual bool processRequestSynchronously();
 };

trunk/src/network/access/qnetworkaccessdebugpipebackend.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+    }
     error(code, QObject::tr("Socket error on %1: %2")
+    error(code, QNetworkAccessDebugPipeBackend::tr("Socket error on %1: %2")
           .arg(url().toString(), socket.errorString()));
     finished();
 …
     } else {
         // abnormal close
         QString msg = QObject::tr("Remote host closed the connection prematurely on %1")
+        QString msg = QNetworkAccessDebugPipeBackend::tr("Remote host closed the connection prematurely on %1")
                              .arg(url().toString());
         error(QNetworkReply::RemoteHostClosedError, msg);
 …
+}
-bool QNetworkAccessDebugPipeBackend::waitForDownstreamReadyRead(int ms)
+{
-    Q_UNUSED(ms);
-    qCritical("QNetworkAccess: Debug pipe backend does not support waitForReadyRead()");
-    return false;
+}
 #endif

trunk/src/network/access/qnetworkaccessdebugpipebackend_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual bool waitForDownstreamReadyRead(int msecs);
     virtual void downstreamReadyWrite();

trunk/src/network/access/qnetworkaccessfilebackend.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+}
-bool QNetworkAccessFileBackend::waitForDownstreamReadyRead(int)
+{
-    Q_ASSERT(operation() == QNetworkAccessManager::GetOperation);
-    return readMoreFromFile();
+}
 void QNetworkAccessFileBackend::downstreamReadyWrite()
+{

trunk/src/network/access/qnetworkaccessfilebackend_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual bool waitForDownstreamReadyRead(int msecs);
     virtual void downstreamReadyWrite();

trunk/src/network/access/qnetworkaccessftpbackend.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         exit(3);
 #endif
+}
-bool QNetworkAccessFtpBackend::waitForDownstreamReadyRead(int ms)
+{
-    if (!ftp)
-        return false;
-    if (ftp->bytesAvailable()) {
-        ftpReadyRead();
-        return true;
+    }
-    if (ms == 0)
-        return false;
-    qCritical("QNetworkAccess: FTP backend does not support waitForReadyRead()");
-    return false;
+}

trunk/src/network/access/qnetworkaccessftpbackend_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual bool waitForDownstreamReadyRead(int msecs);
     virtual void downstreamReadyWrite();

trunk/src/network/access/qnetworkaccesshttpbackend.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qnetworkcookie_p.h"
 #include "QtCore/qdatetime.h"
+#include "QtCore/qelapsedtimer.h"
 #include "QtNetwork/qsslconfiguration.h"
 …
     case QNetworkAccessManager::PutOperation:
     case QNetworkAccessManager::DeleteOperation:
+    case QNetworkAccessManager::CustomOperation:
         break;
 …
     , pendingSslConfiguration(0), pendingIgnoreAllSslErrors(false)
 #endif
+    , resumeOffset(0)
+{
+}
 …
         // Get the object cache that stores our QHttpNetworkConnection objects
         QNetworkAccessCache *cache = QNetworkAccessManagerPrivate::getObjectCache(this);
+        cache->releaseEntry(cacheKey);
+        // synchronous calls are not put into the cache, so for them the key is empty
+        if (!cacheKey.isEmpty())
+            cache->releaseEntry(cacheKey);
+    }
 …
     // call parent
     QNetworkAccessBackend::finished();
+}
-void QNetworkAccessHttpBackend::setupConnection()
+{
-#ifndef QT_NO_NETWORKPROXY
-    connect(http, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
-            SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
-#endif
-    connect(http, SIGNAL(authenticationRequired(QHttpNetworkRequest,QAuthenticator*)),
-            SLOT(httpAuthenticationRequired(QHttpNetworkRequest,QAuthenticator*)));
-    connect(http, SIGNAL(error(QNetworkReply::NetworkError,QString)),
-            SLOT(httpError(QNetworkReply::NetworkError,QString)));
-#ifndef QT_NO_OPENSSL
-    connect(http, SIGNAL(sslErrors(QList<QSslError>)),
-            SLOT(sslErrors(QList<QSslError>)));
-#endif
+}
 …
+}
+static QHttpNetworkRequest::Priority convert(const QNetworkRequest::Priority& prio)
+{
+    switch (prio) {
+    case QNetworkRequest::LowPriority:
+        return QHttpNetworkRequest::LowPriority;
+    case QNetworkRequest::HighPriority:
+        return QHttpNetworkRequest::HighPriority;
+    case QNetworkRequest::NormalPriority:
+    default:
+        return QHttpNetworkRequest::NormalPriority;
+    }
+}
 void QNetworkAccessHttpBackend::postRequest()
+{
     bool loadedFromCache = false;
     QHttpNetworkRequest httpRequest;
+    httpRequest.setPriority(convert(request().priority()));
     switch (operation()) {
     case QNetworkAccessManager::GetOperation:
 …
         break;
+    case QNetworkAccessManager::CustomOperation:
+        invalidateCache(); // for safety reasons, we don't know what the operation does
+        httpRequest.setOperation(QHttpNetworkRequest::Custom);
+        httpRequest.setUploadByteDevice(createUploadByteDevice());
+        httpRequest.setCustomVerb(request().attribute(
+                QNetworkRequest::CustomVerbAttribute).toByteArray());
+        break;
     default:
         break;                  // can't happen
 …
     QList<QByteArray> headers = request().rawHeaderList();
+    if (resumeOffset != 0) {
+        if (headers.contains("Range")) {
+            // Need to adjust resume offset for user specified range
+            headers.removeOne("Range");
+            // We've already verified that requestRange starts with "bytes=", see canResume.
+            QByteArray requestRange = request().rawHeader("Range").mid(6);
+            int index = requestRange.indexOf('-');
+            quint64 requestStartOffset = requestRange.left(index).toULongLong();
+            quint64 requestEndOffset = requestRange.mid(index + 1).toULongLong();
+            requestRange = "bytes=" + QByteArray::number(resumeOffset + requestStartOffset) +
+                           '-' + QByteArray::number(requestEndOffset);
+            httpRequest.setHeaderField("Range", requestRange);
+        } else {
+            httpRequest.setHeaderField("Range", "bytes=" + QByteArray::number(resumeOffset) + '-');
+        }
+    }
     foreach (const QByteArray &header, headers)
         httpRequest.setHeaderField(header, request().rawHeader(header));
 …
     if (request().attribute(QNetworkRequest::HttpPipeliningAllowedAttribute).toBool() == true)
         httpRequest.setPipeliningAllowed(true);
+    if (static_cast<QNetworkRequest::LoadControl>
+        (request().attribute(QNetworkRequest::AuthenticationReuseAttribute,
+                             QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Manual)
+        httpRequest.setWithCredentials(false);
     httpReply = http->sendRequest(httpRequest);
 …
         httpReply->ignoreSslErrors();
     httpReply->ignoreSslErrors(pendingIgnoreSslErrorsList);
+    connect(httpReply, SIGNAL(sslErrors(QList<QSslError>)),
+            SLOT(sslErrors(QList<QSslError>)));
 #endif
 …
             SLOT(httpError(QNetworkReply::NetworkError,QString)));
     connect(httpReply, SIGNAL(headerChanged()), SLOT(replyHeaderChanged()));
+    connect(httpReply, SIGNAL(cacheCredentials(QHttpNetworkRequest,QAuthenticator*)),
+            SLOT(httpCacheCredentials(QHttpNetworkRequest,QAuthenticator*)));
+#ifndef QT_NO_NETWORKPROXY
+    connect(httpReply, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
+            SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
+#endif
+    connect(httpReply, SIGNAL(authenticationRequired(const QHttpNetworkRequest,QAuthenticator*)),
+                SLOT(httpAuthenticationRequired(const QHttpNetworkRequest,QAuthenticator*)));
+}
 …
         cacheProxy.type() == QNetworkProxy::DefaultProxy) {
         // unsuitable proxies
+        QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
+                                  Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ProxyNotFoundError),
+                                  Q_ARG(QString, tr("No suitable proxy found")));
+        QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
+        return;
+    }
+#endif
+    // check if we have an open connection to this host
+    cacheKey = makeCacheKey(this, theProxy);
+    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
+        // the http object is actually a QHttpNetworkConnection
+        http = new QNetworkAccessCachedHttpConnection(url.host(), url.port(), encrypt);
+        if (isSynchronous()) {
+            error(QNetworkReply::ProxyNotFoundError, tr("No suitable proxy found"));
+            finished();
+        } else {
+            QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
+                                      Q_ARG(QNetworkReply::NetworkError, QNetworkReply::ProxyNotFoundError),
+                                      Q_ARG(QString, tr("No suitable proxy found")));
+            QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
+        }
+            return;
+    }
+#endif
+    if (isSynchronous()) {
+        // for synchronous requests, we just create a new connection
+        http = new QHttpNetworkConnection(1, url.host(), url.port(), encrypt, this);
 #ifndef QT_NO_NETWORKPROXY
         http->setTransparentProxy(transparentProxy);
         http->setCacheProxy(cacheProxy);
 #endif
+        // cache the QHttpNetworkConnection corresponding to this cache key
+        cache->addEntry(cacheKey, http);
+    }
+    setupConnection();
+    postRequest();
+        postRequest();
+        processRequestSynchronously();
+    } else {
+        // check if we have an open connection to this host
+        cacheKey = makeCacheKey(this, theProxy);
+        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
+            // the http object is actually a QHttpNetworkConnection
+            http = new QNetworkAccessCachedHttpConnection(url.host(), url.port(), encrypt);
+#ifndef QT_NO_NETWORKPROXY
+            http->setTransparentProxy(transparentProxy);
+            http->setCacheProxy(cacheProxy);
+#endif
+            // cache the QHttpNetworkConnection corresponding to this cache key
+            cache->addEntry(cacheKey, static_cast<QNetworkAccessCachedHttpConnection *>(http.data()));
+        }
+        postRequest();
+    }
+}
 …
     // this indicates that the user closed the stream while the reply isn't finished yet
+}
-bool QNetworkAccessHttpBackend::waitForDownstreamReadyRead(int msecs)
+{
-    Q_ASSERT(http);
-    if (httpReply->bytesAvailable()) {
-        readFromHttp();
-        return true;
+    }
-    if (msecs == 0) {
-        // no bytes available in the socket and no waiting
-        return false;
+    }
-    // ### FIXME
-    qCritical("QNetworkAccess: HTTP backend does not support waitForReadyRead()");
-    return false;
+}
 void QNetworkAccessHttpBackend::downstreamReadyWrite()
 …
+}
+void QNetworkAccessHttpBackend::httpCacheCredentials(const QHttpNetworkRequest &,
+                                                 QAuthenticator *auth)
+{
+    cacheCredentials(auth);
+}
 void QNetworkAccessHttpBackend::httpError(QNetworkReply::NetworkError errorCode,
                                           const QString &errorString)
 …
 #if defined(QNETWORKACCESSHTTPBACKEND_DEBUG)
     qDebug() << "http error!" << errorCode << errorString;
-#endif
-#if 0
-    static const QNetworkReply::NetworkError conversionTable[] = {
-        QNetworkReply::ConnectionRefusedError,
-        QNetworkReply::RemoteHostClosedError,
-        QNetworkReply::HostNotFoundError,
-        QNetworkReply::UnknownNetworkError, // SocketAccessError
-        QNetworkReply::UnknownNetworkError, // SocketResourceError
-        QNetworkReply::TimeoutError,        // SocketTimeoutError
-        QNetworkReply::UnknownNetworkError, // DatagramTooLargeError
-        QNetworkReply::UnknownNetworkError, // NetworkError
-        QNetworkReply::UnknownNetworkError, // AddressInUseError
-        QNetworkReply::UnknownNetworkError, // SocketAddressNotAvailableError
-        QNetworkReply::UnknownNetworkError, // UnsupportedSocketOperationError
-        QNetworkReply::UnknownNetworkError, // UnfinishedSocketOperationError
-        QNetworkReply::ProxyAuthenticationRequiredError
-    };
-    QNetworkReply::NetworkError code;
-    if (int(errorCode) >= 0 &&
-        uint(errorCode) < (sizeof conversionTable / sizeof conversionTable[0]))
-        code = conversionTable[errorCode];
-    else
-        code = QNetworkReply::UnknownNetworkError;
 #endif
     error(errorCode, errorString);
 …
     checkForRedirect(status);
     emit metaDataChanged();
     // invoke this asynchronously, else Arora/QtDemoBrowser don't like cached downloads
     // see task 250221 / 251801
+    // This needs to be emitted in the event loop because it can be reached at
+    // the direct code path of qnam.get(...) before the user has a chance
+    // to connect any signals.
+    QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
     qRegisterMetaType<QIODevice*>("QIODevice*");
     QMetaObject::invokeMethod(this, "writeDownstreamData", Qt::QueuedConnection, Q_ARG(QIODevice*, contents));
 …
+}
+bool QNetworkAccessHttpBackend::canResume() const
+{
+    // Only GET operation supports resuming.
+    if (operation() != QNetworkAccessManager::GetOperation)
+        return false;
+    // Can only resume if server/resource supports Range header.
+    if (httpReply->headerField("Accept-Ranges", "none") == "none")
+        return false;
+    // We only support resuming for byte ranges.
+    if (request().hasRawHeader("Range")) {
+        QByteArray range = request().rawHeader("Range");
+        if (!range.startsWith("bytes="))
+            return false;
+    }
+    return true;
+}
+void QNetworkAccessHttpBackend::setResumeOffset(quint64 offset)
+{
+    resumeOffset = offset;
+}
+bool QNetworkAccessHttpBackend::processRequestSynchronously()
+{
+    QHttpNetworkConnectionChannel *channel = &http->channels()[0];
+    // Disconnect all socket signals. They will only confuse us when using waitFor*
+    QObject::disconnect(channel->socket, 0, 0, 0);
+    qint64 timeout = 20*1000; // 20 sec
+    QElapsedTimer timeoutTimer;
+    bool waitResult = channel->socket->waitForConnected(timeout);
+    timeoutTimer.start();
+    if (!waitResult || channel->socket->state() != QAbstractSocket::ConnectedState) {
+        error(QNetworkReply::UnknownNetworkError, QLatin1String("could not connect"));
+        return false;
+    }
+    channel->_q_connected(); // this will send the request (via sendRequest())
+#ifndef QT_NO_OPENSSL
+    if (http->isSsl()) {
+        qint64 remainingTimeEncrypted = timeout - timeoutTimer.elapsed();
+        if (!static_cast<QSslSocket *>(channel->socket)->waitForEncrypted(remainingTimeEncrypted)) {
+            error(QNetworkReply::SslHandshakeFailedError,
+                  QLatin1String("could not encrypt or timeout while encrypting"));
+            return false;
+        }
+        channel->_q_encrypted();
+    }
+#endif
+    // if we get a 401 or 407, we might need to send the request twice, see below
+    bool authenticating = false;
+    do {
+        channel->sendRequest();
+        qint64 remainingTimeBytesWritten;
+        while(channel->socket->bytesToWrite() > 0 ||
+              channel->state == QHttpNetworkConnectionChannel::WritingState) {
+            remainingTimeBytesWritten = timeout - timeoutTimer.elapsed();
+            channel->sendRequest(); // triggers channel->socket->write()
+            if (!channel->socket->waitForBytesWritten(remainingTimeBytesWritten)) {
+                error(QNetworkReply::TimeoutError,
+                      QLatin1String("could not write bytes to socket or timeout while writing"));
+                return false;
+            }
+        }
+        qint64 remainingTimeBytesRead = timeout - timeoutTimer.elapsed();
+        // Loop for at most remainingTime until either the socket disconnects
+        // or the reply is finished
+        do {
+            waitResult = channel->socket->waitForReadyRead(remainingTimeBytesRead);
+            remainingTimeBytesRead = timeout - timeoutTimer.elapsed();
+            if (!waitResult || remainingTimeBytesRead <= 0
+                || channel->socket->state() != QAbstractSocket::ConnectedState) {
+                error(QNetworkReply::TimeoutError,
+                      QLatin1String("could not read from socket or timeout while reading"));
+                return false;
+            }
+            if (channel->socket->bytesAvailable())
+                channel->_q_readyRead();
+            if (!httpReply)
+                return false; // we got a 401 or 407 and cannot handle it (it might happen that
+                              // disconnectFromHttp() was called, in that case the reply is zero)
+            // ### I am quite sure this does not work for NTLM
+            // ### how about uploading to an auth / proxyAuth site?
+            authenticating = (httpReply->statusCode() == 401 || httpReply->statusCode() == 407);
+            if (httpReply->isFinished())
+                break;
+        } while (remainingTimeBytesRead > 0);
+    } while (authenticating);
+    return true;
+}
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkaccesshttpbackend_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual void open();
     virtual void closeDownstreamChannel();
-    virtual bool waitForDownstreamReadyRead(int msecs);
     virtual void downstreamReadyWrite();
 …
     bool needsResetableUploadData() { return true; }
+    bool canResume() const;
+    void setResumeOffset(quint64 offset);
+    virtual bool processRequestSynchronously();
 private slots:
     void replyReadyRead();
 …
     void replyHeaderChanged();
     void httpAuthenticationRequired(const QHttpNetworkRequest &request, QAuthenticator *auth);
+    void httpCacheCredentials(const QHttpNetworkRequest &request, QAuthenticator *auth);
     void httpError(QNetworkReply::NetworkError error, const QString &errorString);
     bool sendCacheContents(const QNetworkCacheMetaData &metaData);
 …
 private:
     QHttpNetworkReply *httpReply;
     QPointer<QNetworkAccessCachedHttpConnection> http;
+    QPointer<QHttpNetworkConnection> http;
     QByteArray cacheKey;
     QNetworkAccessBackendUploadIODevice *uploadDevice;
 …
 #endif
+    quint64 resumeOffset;
     void disconnectFromHttp();
-    void setupConnection();
     void validateCache(QHttpNetworkRequest &httpRequest, bool &loadedFromCache);
     void invalidateCache();

trunk/src/network/access/qnetworkaccessmanager.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qabstractnetworkcache.h"
+#include "QtNetwork/qnetworksession.h"
+#include "QtNetwork/private/qsharednetworksession_p.h"
 #include "qnetworkaccesshttpbackend_p.h"
 #include "qnetworkaccessftpbackend_p.h"
 …
 #include "qnetworkaccessdatabackend_p.h"
 #include "qnetworkaccessdebugpipebackend_p.h"
+#include "qnetworkaccesscachebackend_p.h"
 #include "qfilenetworkreply_p.h"
 …
 #include "QtNetwork/qauthenticator.h"
 #include "QtNetwork/qsslconfiguration.h"
+#include "QtNetwork/qnetworkconfigmanager.h"
 QT_BEGIN_NAMESPACE
 …
     \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 1
+    \section1 Network and Roaming support
+    With the addition of the \l {Bearer Management} API to Qt 4.7
+    QNetworkAccessManager gained the ability to manage network connections.
+    QNetworkAccessManager can start the network interface if the device is
+    offline and terminates the interface if the current process is the last
+    one to use the uplink. Note that some platform utilize grace periods from
+    when the last application stops using a uplink until the system actually
+    terminates the connectivity link. Roaming is equally transparent. Any
+    queued/pending network requests are automatically transferred to new
+    access point.
+    Clients wanting to utilize this feature should not require any changes. In fact
+    it is likely that existing platform specific connection code can simply be
+    removed from the application.
+    \note The network and roaming support in QNetworkAccessManager is conditional
+    upon the platform supporting connection management. The
+    \l QNetworkConfigurationManager::NetworkSessionRequired can be used to
+    detect whether QNetworkAccessManager utilizes this feature. Currently only
+    Meego/Harmattan and Symbian platforms provide connection management support.
+    \note This feature cannot be used in combination with the Bearer Management
+    API as provided by QtMobility. Applications have to migrate to the Qt version
+    of Bearer Management.
     \section1 Symbian Platform Security Requirements
 …
     deleteResource())
+    \value CustomOperation      custom operation (created with
+    sendCustomRequest())    \since 4.7
     \omitvalue UnknownOperation
     \sa QNetworkReply::operation()
+*/
+/*!
+    \enum QNetworkAccessManager::NetworkAccessibility
+    Indicates whether the network is accessible via this network access manager.
+    \value UnknownAccessibility     The network accessibility cannot be determined.
+    \value NotAccessible            The network is not currently accessible, either because there
+                                    is currently no network coverage or network access has been
+                                    explicitly disabled by a call to setNetworkAccessible().
+    \value Accessible               The network is accessible.
+    \sa networkAccessible
+*/
+/*!
+    \property QNetworkAccessManager::networkAccessible
+    \brief whether the network is currently accessible via this network access manager.
+    \since 4.7
+    If the network is \l {NotAccessible}{not accessible} the network access manager will not
+    process any new network requests, all such requests will fail with an error.  Requests with
+    URLs with the file:// scheme will still be processed.
+    By default the value of this property reflects the physical state of the device.  Applications
+    may override it to disable all network requests via this network access manager by calling
+    \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 4
+    Network requests can be reenabled again by calling
+    \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 5
+    \note Calling setNetworkAccessible() does not change the network state.
+*/
+/*!
+    \fn void QNetworkAccessManager::networkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility accessible)
+    This signal is emitted when the value of the \l networkAccessible property changes.
+    \a accessible is the new network accessibility.
+*/
+/*!
+    \fn void QNetworkAccessManager::networkSessionConnected()
+    \since 4.7
+    \internal
+    This signal is emitted when the status of the network session changes into a usable (Connected)
+    state. It is used to signal to QNetworkReplys to start or migrate their network operation once
+    the network session has been opened or finished roaming.
 */
 …
     delete d_func()->proxyFactory;
 #endif
+    // Delete the QNetworkReply children first.
+    // Else a QAbstractNetworkCache might get deleted in ~QObject
+    // before a QNetworkReply that accesses the QAbstractNetworkCache
+    // object in its destructor.
+    qDeleteAll(findChildren<QNetworkReply *>());
+    // The other children will be deleted in this ~QObject
+    // FIXME instead of this "hack" make the QNetworkReplyImpl
+    // properly watch the cache deletion, e.g. via a QWeakPointer.
+}
 …
     \note QNetworkAccessManager takes ownership of the \a cookieJar object.
+    QNetworkAccessManager will set the parent of the \a cookieJar
+    passed to itself, so that the cookie jar is deleted when this
+    If \a cookieJar is in the same thread as this QNetworkAccessManager,
+    it will set the parent of the \a cookieJar
+    so that the cookie jar is deleted when this
     object is deleted as well. If you want to share cookie jars
     between different QNetworkAccessManager objects, you may want to
 …
             delete d->cookieJar;
         d->cookieJar = cookieJar;
+        d->cookieJar->setParent(this);
+        if (thread() == cookieJar->thread())
+            d->cookieJar->setParent(this);
+    }
+}
 …
     The contents as well as associated headers will be downloaded.
     \sa post(), put(), deleteResource()
+    \sa post(), put(), deleteResource(), sendCustomRequest()
 */
 QNetworkReply *QNetworkAccessManager::get(const QNetworkRequest &request)
 …
     HTTPS is undefined and will probably fail.
     \sa get(), put(), deleteResource()
+    \sa get(), put(), deleteResource(), sendCustomRequest()
 */
 QNetworkReply *QNetworkAccessManager::post(const QNetworkRequest &request, QIODevice *data)
 …
     files through HTML forms, use the POST mechanism.
     \sa get(), post()
+    \sa get(), post(), deleteResource(), sendCustomRequest()
 */
 QNetworkReply *QNetworkAccessManager::put(const QNetworkRequest &request, QIODevice *data)
 …
     HTTP DELETE request.
     \sa get(), post(), put()
+    \sa get(), post(), put(), sendCustomRequest()
 */
 QNetworkReply *QNetworkAccessManager::deleteResource(const QNetworkRequest &request)
+{
     return d_func()->postProcess(createRequest(QNetworkAccessManager::DeleteOperation, request));
+}
+#ifndef QT_NO_BEARERMANAGEMENT
+/*!
+    \since 4.7
+    Sets the network configuration that will be used when creating the
+    \l {QNetworkSession}{network session} to \a config.
+    The network configuration is used to create and open a network session before any request that
+    requires network access is process.  If no network configuration is explicitly set via this
+    function the network configuration returned by
+    QNetworkConfigurationManager::defaultConfiguration() will be used.
+    To restore the default network configuration set the network configuration to the value
+    returned from QNetworkConfigurationManager::defaultConfiguration().
+    \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 2
+    If an invalid network configuration is set, a network session will not be created.  In this
+    case network requests will be processed regardless, but may fail.  For example:
+    \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 3
+    \sa configuration(), QNetworkSession
+*/
+void QNetworkAccessManager::setConfiguration(const QNetworkConfiguration &config)
+{
+    d_func()->createSession(config);
+}
+/*!
+    \since 4.7
+    Returns the network configuration that will be used to create the
+    \l {QNetworkSession}{network session} which will be used when processing network requests.
+    \sa setConfiguration(), activeConfiguration()
+*/
+QNetworkConfiguration QNetworkAccessManager::configuration() const
+{
+    Q_D(const QNetworkAccessManager);
+    if (d->networkSession)
+        return d->networkSession->configuration();
+    else
+        return QNetworkConfiguration();
+}
+/*!
+    \since 4.7
+    Returns the current active network configuration.
+    If the network configuration returned by configuration() is of type
+    QNetworkConfiguration::ServiceNetwork this function will return the current active child
+    network configuration of that configuration.  Otherwise returns the same network configuration
+    as configuration().
+    Use this function to return the actual network configuration currently in use by the network
+    session.
+    \sa configuration()
+*/
+QNetworkConfiguration QNetworkAccessManager::activeConfiguration() const
+{
+    Q_D(const QNetworkAccessManager);
+    if (d->networkSession) {
+        QNetworkConfigurationManager manager;
+        return manager.configurationFromIdentifier(
+            d->networkSession->sessionProperty(QLatin1String("ActiveConfiguration")).toString());
+    } else {
+        return QNetworkConfiguration();
+    }
+}
+/*!
+    \since 4.7
+    Overrides the reported network accessibility.  If \a accessible is NotAccessible the reported
+    network accessiblity will always be NotAccessible.  Otherwise the reported network
+    accessibility will reflect the actual device state.
+*/
+void QNetworkAccessManager::setNetworkAccessible(QNetworkAccessManager::NetworkAccessibility accessible)
+{
+    Q_D(QNetworkAccessManager);
+    if (d->networkAccessible != accessible) {
+        NetworkAccessibility previous = networkAccessible();
+        d->networkAccessible = accessible;
+        NetworkAccessibility current = networkAccessible();
+        if (previous != current)
+            emit networkAccessibleChanged(current);
+    }
+}
+/*!
+    \since 4.7
+    Returns the current network accessibility.
+*/
+QNetworkAccessManager::NetworkAccessibility QNetworkAccessManager::networkAccessible() const
+{
+    Q_D(const QNetworkAccessManager);
+    if (d->networkSession) {
+        // d->online holds online/offline state of this network session.
+        if (d->online)
+            return d->networkAccessible;
+        else
+            return NotAccessible;
+    } else {
+        // Network accessibility is either disabled or unknown.
+        return (d->networkAccessible == NotAccessible) ? NotAccessible : UnknownAccessibility;
+    }
+}
+#endif // QT_NO_BEARERMANAGEMENT
+/*!
+    \since 4.7
+    Sends a custom request to the server identified by the URL of \a request.
+    It is the user's responsibility to send a \a verb to the server that is valid
+    according to the HTTP specification.
+    This method provides means to send verbs other than the common ones provided
+    via get() or post() etc., for instance sending an HTTP OPTIONS command.
+    If \a data is not empty, the contents of the \a data
+    device will be uploaded to the server; in that case, data must be open for
+    reading and must remain valid until the finished() signal is emitted for this reply.
+    \note This feature is currently available for HTTP only.
+    \sa get(), post(), put(), deleteResource()
+*/
+QNetworkReply *QNetworkAccessManager::sendCustomRequest(const QNetworkRequest &request, const QByteArray &verb, QIODevice *data)
+{
+    QNetworkRequest newRequest(request);
+    newRequest.setAttribute(QNetworkRequest::CustomVerbAttribute, verb);
+    return d_func()->postProcess(createRequest(QNetworkAccessManager::CustomOperation, newRequest, data));
+}
 …
     Q_D(QNetworkAccessManager);
+    // 4.7 only hotfix fast path for data:// URLs
+    // In 4.8 this is solved with QNetworkReplyDataImpl and will work there
+    // This hotfix is done for not needing a QNetworkSession for data://
+    if ((op == QNetworkAccessManager::GetOperation || op == QNetworkAccessManager::HeadOperation)
+             && (req.url().scheme() == QLatin1String("data"))) {
+        QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
+        QNetworkReplyImplPrivate *priv = reply->d_func();
+        priv->manager = this;
+        priv->backend = new QNetworkAccessDataBackend();
+        priv->backend->manager = this->d_func();
+        priv->backend->setParent(reply);
+        priv->backend->reply = priv;
+        priv->setup(op, req, outgoingData);
+        return reply;
+    }
     // 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://
+    // The QNetworkAccessFileBackend will right now only be used for PUT
     if ((op == QNetworkAccessManager::GetOperation || op == QNetworkAccessManager::HeadOperation)
          && (req.url().scheme() == QLatin1String("file")
+             || req.url().scheme() == QLatin1String("qrc")
              || req.url().scheme().isEmpty())) {
         return new QFileNetworkReply(this, req, op);
+    }
+    // A request with QNetworkRequest::AlwaysCache does not need any bearer management
+    QNetworkRequest::CacheLoadControl mode =
+        static_cast<QNetworkRequest::CacheLoadControl>(
+            req.attribute(QNetworkRequest::CacheLoadControlAttribute,
+                              QNetworkRequest::PreferNetwork).toInt());
+    if (mode == QNetworkRequest::AlwaysCache
+        && (op == QNetworkAccessManager::GetOperation
+        || op == QNetworkAccessManager::HeadOperation)) {
+        // FIXME Implement a QNetworkReplyCacheImpl instead, see QTBUG-15106
+        QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
+        QNetworkReplyImplPrivate *priv = reply->d_func();
+        priv->manager = this;
+        priv->backend = new QNetworkAccessCacheBackend();
+        priv->backend->manager = this->d_func();
+        priv->backend->setParent(reply);
+        priv->backend->reply = priv;
+        priv->setup(op, req, outgoingData);
+        return reply;
+    }
+#ifndef QT_NO_BEARERMANAGEMENT
+    // Return a disabled network reply if network access is disabled.
+    // Except if the scheme is empty or file://.
+    if (!d->networkAccessible && !(req.url().scheme() == QLatin1String("file") ||
+                                      req.url().scheme().isEmpty())) {
+        return new QDisabledNetworkReply(this, req, op);
+    }
+    if (!d->networkSession && (d->initializeSession || !d->networkConfiguration.isEmpty())) {
+        QNetworkConfigurationManager manager;
+        if (!d->networkConfiguration.isEmpty()) {
+            d->createSession(manager.configurationFromIdentifier(d->networkConfiguration));
+        } else {
+            if (manager.capabilities() & QNetworkConfigurationManager::NetworkSessionRequired)
+                d->createSession(manager.defaultConfiguration());
+            else
+                d->initializeSession = false;
+        }
+    }
+    if (d->networkSession)
+        d->networkSession->setSessionProperty(QLatin1String("AutoCloseSessionTimeout"), -1);
+#endif
     QNetworkRequest request = req;
 …
         request.setHeader(QNetworkRequest::ContentLengthHeader, outgoingData->size());
+    }
+    if (d->cookieJar) {
+        QList<QNetworkCookie> cookies = d->cookieJar->cookiesForUrl(request.url());
+        if (!cookies.isEmpty())
+            request.setHeader(QNetworkRequest::CookieHeader, qVariantFromValue(cookies));
+    if (static_cast<QNetworkRequest::LoadControl>
+        (request.attribute(QNetworkRequest::CookieLoadControlAttribute,
+                           QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Automatic) {
+        if (d->cookieJar) {
+            QList<QNetworkCookie> cookies = d->cookieJar->cookiesForUrl(request.url());
+            if (!cookies.isEmpty())
+                request.setHeader(QNetworkRequest::CookieHeader, qVariantFromValue(cookies));
+        }
+    }
 …
     QUrl url = request.url();
     QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
+#ifndef QT_NO_BEARERMANAGEMENT
+    if (req.url().scheme() != QLatin1String("file") && !req.url().scheme().isEmpty()) {
+        connect(this, SIGNAL(networkSessionConnected()),
+                reply, SLOT(_q_networkSessionConnected()));
+    }
+#endif
     QNetworkReplyImplPrivate *priv = reply->d_func();
     priv->manager = this;
     // second step: fetch cached credentials
+    QNetworkAuthenticationCredential *cred = d->fetchCachedCredentials(url);
+    if (cred) {
+        url.setUserName(cred->user);
+        url.setPassword(cred->password);
+        priv->urlForLastAuthentication = url;
+    }
+    // This is not done for the time being, we should use signal emissions to request
+    // the credentials from cache.
     // third step: find a backend
 …
         priv->backend->reply = priv;
+    }
-    // fourth step: setup the reply
-    priv->setup(op, request, outgoingData);
 #ifndef QT_NO_OPENSSL
     reply->setSslConfiguration(request.sslConfiguration());
 #endif
+    // fourth step: setup the reply
+    priv->setup(op, request, outgoingData);
     return reply;
+}
 …
+{
     Q_Q(QNetworkAccessManager);
     QNetworkReply *reply = qobject_cast<QNetworkReply *>(q->sender());
     if (reply)
         emit q->finished(reply);
+#ifndef QT_NO_BEARERMANAGEMENT
+    if (networkSession && q->findChildren<QNetworkReply *>().count() == 1)
+        networkSession->setSessionProperty(QLatin1String("AutoCloseSessionTimeout"), 120000);
+#endif
+}
 …
     // don't try the cache for the same URL twice in a row
     // being called twice for the same URL means the authentication failed
+    if (url != backend->reply->urlForLastAuthentication) {
+    // also called when last URL is empty, e.g. on first call
+    if (backend->reply->urlForLastAuthentication.isEmpty()
+            || url != backend->reply->urlForLastAuthentication) {
         QNetworkAuthenticationCredential *cred = fetchCachedCredentials(url, authenticator);
         if (cred) {
 …
+    }
+    // if we emit a signal here in synchronous mode, the user might spin
+    // an event loop, which might recurse and lead to problems
+    if (backend->isSynchronous())
+        return;
     backend->reply->urlForLastAuthentication = url;
     emit q->authenticationRequired(backend->reply->q_func(), authenticator);
     addCredentials(url, authenticator);
+    cacheCredentials(url, authenticator);
+}
 …
     //      or a new function proxyAuthenticationSucceeded(true|false)
     if (proxy != backend->reply->lastProxyAuthentication) {
         QNetworkAuthenticationCredential *cred = fetchCachedCredentials(proxy);
+        QNetworkAuthenticationCredential *cred = fetchCachedProxyCredentials(proxy);
         if (cred) {
             authenticator->setUser(cred->user);
 …
+    }
+    // if we emit a signal here in synchronous mode, the user might spin
+    // an event loop, which might recurse and lead to problems
+    if (backend->isSynchronous())
+        return;
     backend->reply->lastProxyAuthentication = proxy;
     emit q->proxyAuthenticationRequired(proxy, authenticator);
     addCredentials(proxy, authenticator);
+}
 void QNetworkAccessManagerPrivate::addCredentials(const QNetworkProxy &p,
+    cacheProxyCredentials(proxy, authenticator);
+}
+void QNetworkAccessManagerPrivate::cacheProxyCredentials(const QNetworkProxy &p,
                                                   const QAuthenticator *authenticator)
+{
 …
 QNetworkAuthenticationCredential *
 QNetworkAccessManagerPrivate::fetchCachedCredentials(const QNetworkProxy &p,
+QNetworkAccessManagerPrivate::fetchCachedProxyCredentials(const QNetworkProxy &p,
                                                      const QAuthenticator *authenticator)
+{
 …
 #endif
 void QNetworkAccessManagerPrivate::addCredentials(const QUrl &url,
+void QNetworkAccessManagerPrivate::cacheCredentials(const QUrl &url,
                                                   const QAuthenticator *authenticator)
+{
 …
+}
+#ifndef QT_NO_BEARERMANAGEMENT
+void QNetworkAccessManagerPrivate::createSession(const QNetworkConfiguration &config)
+{
+    Q_Q(QNetworkAccessManager);
+    initializeSession = false;
+    if (!config.isValid()) {
+        networkSession.clear();
+        online = false;
+        if (networkAccessible == QNetworkAccessManager::NotAccessible)
+            emit q->networkAccessibleChanged(QNetworkAccessManager::NotAccessible);
+        else
+            emit q->networkAccessibleChanged(QNetworkAccessManager::UnknownAccessibility);
+        return;
+    }
+    networkSession = QSharedNetworkSessionManager::getSession(config);
+    QObject::connect(networkSession.data(), SIGNAL(opened()), q, SIGNAL(networkSessionConnected()), Qt::QueuedConnection);
+    //QueuedConnection is used to avoid deleting the networkSession inside its closed signal
+    QObject::connect(networkSession.data(), SIGNAL(closed()), q, SLOT(_q_networkSessionClosed()), Qt::QueuedConnection);
+    QObject::connect(networkSession.data(), SIGNAL(stateChanged(QNetworkSession::State)),
+                     q, SLOT(_q_networkSessionStateChanged(QNetworkSession::State)), Qt::QueuedConnection);
+    _q_networkSessionStateChanged(networkSession->state());
+}
+void QNetworkAccessManagerPrivate::_q_networkSessionClosed()
+{
+    if (networkSession) {
+        networkConfiguration = networkSession->configuration().identifier();
+        networkSession.clear();
+    }
+}
+void QNetworkAccessManagerPrivate::_q_networkSessionStateChanged(QNetworkSession::State state)
+{
+    Q_Q(QNetworkAccessManager);
+    if (state == QNetworkSession::Connected)
+        emit q->networkSessionConnected();
+    if (online) {
+        if (state != QNetworkSession::Connected && state != QNetworkSession::Roaming) {
+            online = false;
+            emit q->networkAccessibleChanged(QNetworkAccessManager::NotAccessible);
+        }
+    } else {
+        if (state == QNetworkSession::Connected || state == QNetworkSession::Roaming) {
+            online = true;
+            emit q->networkAccessibleChanged(networkAccessible);
+        }
+    }
+}
+#endif // QT_NO_BEARERMANAGEMENT
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkaccessmanager.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 class QNetworkProxyFactory;
 class QSslError;
+#if !defined(QT_NO_BEARERMANAGEMENT) && !defined(QT_MOBILITY_BEARER)
+class QNetworkConfiguration;
+#endif
 class QNetworkReplyImplPrivate;
 …
+{
     Q_OBJECT
+#ifndef QT_NO_BEARERMANAGEMENT
+    Q_PROPERTY(NetworkAccessibility networkAccessible READ networkAccessible WRITE setNetworkAccessible NOTIFY networkAccessibleChanged)
+#endif
 public:
     enum Operation {
 …
         PostOperation,
         DeleteOperation,
+        CustomOperation,
         UnknownOperation = 0
     };
+#ifndef QT_NO_BEARERMANAGEMENT
+    enum NetworkAccessibility {
+        UnknownAccessibility = -1,
+        NotAccessible = 0,
+        Accessible = 1
+    };
+#endif
     explicit QNetworkAccessManager(QObject *parent = 0);
 …
     QNetworkReply *put(const QNetworkRequest &request, const QByteArray &data);
     QNetworkReply *deleteResource(const QNetworkRequest &request);
+    QNetworkReply *sendCustomRequest(const QNetworkRequest &request, const QByteArray &verb, QIODevice *data = 0);
+#if !defined(QT_NO_BEARERMANAGEMENT) && !defined(QT_MOBILITY_BEARER)
+    void setConfiguration(const QNetworkConfiguration &config);
+    QNetworkConfiguration configuration() const;
+    QNetworkConfiguration activeConfiguration() const;
+#endif
+#ifndef QT_NO_BEARERMANAGEMENT
+    void setNetworkAccessible(NetworkAccessibility accessible);
+    NetworkAccessibility networkAccessible() const;
+#endif
 Q_SIGNALS:
 …
 #endif
+#if !defined(QT_NO_BEARERMANAGEMENT) && !defined(QT_MOBILITY_BEARER)
+    void networkSessionConnected();
+#endif
+#ifndef QT_NO_BEARERMANAGEMENT
+    void networkAccessibleChanged(QNetworkAccessManager::NetworkAccessibility accessible);
+#endif
 protected:
     virtual QNetworkReply *createRequest(Operation op, const QNetworkRequest &request,
 …
     Q_PRIVATE_SLOT(d_func(), void _q_replyFinished())
     Q_PRIVATE_SLOT(d_func(), void _q_replySslErrors(QList<QSslError>))
+#if !defined(QT_NO_BEARERMANAGEMENT) && !defined(QT_MOBILITY_BEARER)
+    Q_PRIVATE_SLOT(d_func(), void _q_networkSessionClosed())
+    Q_PRIVATE_SLOT(d_func(), void _q_networkSessionStateChanged(QNetworkSession::State))
+#endif
 };

trunk/src/network/access/qnetworkaccessmanager_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "private/qobject_p.h"
 #include "QtNetwork/qnetworkproxy.h"
+#include "QtNetwork/qnetworksession.h"
 QT_BEGIN_NAMESPACE
 …
           proxyFactory(0),
 #endif
+#ifndef QT_NO_BEARERMANAGEMENT
+          networkSession(0),
+          networkAccessible(QNetworkAccessManager::Accessible),
+          online(false),
+          initializeSession(true),
+#endif
           cookieJarCreated(false)
     { }
 …
     void authenticationRequired(QNetworkAccessBackend *backend, QAuthenticator *authenticator);
     void addCredentials(const QUrl &url, const QAuthenticator *auth);
+    void cacheCredentials(const QUrl &url, const QAuthenticator *auth);
     QNetworkAuthenticationCredential *fetchCachedCredentials(const QUrl &url,
                                                              const QAuthenticator *auth = 0);
 …
     void proxyAuthenticationRequired(QNetworkAccessBackend *backend, const QNetworkProxy &proxy,
                                      QAuthenticator *authenticator);
     void addCredentials(const QNetworkProxy &proxy, const QAuthenticator *auth);
     QNetworkAuthenticationCredential *fetchCachedCredentials(const QNetworkProxy &proxy,
+    void cacheProxyCredentials(const QNetworkProxy &proxy, const QAuthenticator *auth);
+    QNetworkAuthenticationCredential *fetchCachedProxyCredentials(const QNetworkProxy &proxy,
                                                              const QAuthenticator *auth = 0);
     QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query);
 …
     QNetworkAccessBackend *findBackend(QNetworkAccessManager::Operation op, const QNetworkRequest &request);
+#ifndef QT_NO_BEARERMANAGEMENT
+    void createSession(const QNetworkConfiguration &config);
+    void _q_networkSessionClosed();
+    void _q_networkSessionNewConfigurationActivated();
+    void _q_networkSessionPreferredConfigurationChanged(const QNetworkConfiguration &config,
+                                                        bool isSeamless);
+    void _q_networkSessionStateChanged(QNetworkSession::State state);
+#endif
     // this is the cache for storing downloaded files
 …
 #endif
+#ifndef QT_NO_BEARERMANAGEMENT
+    QSharedPointer<QNetworkSession> networkSession;
+    QString networkConfiguration;
+    QNetworkAccessManager::NetworkAccessibility networkAccessible;
+    bool online;
+    bool initializeSession;
+#endif
     bool cookieJarCreated;
     // this cache can be used by individual backends to cache e.g. their TCP connections to a server

trunk/src/network/access/qnetworkcookie.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
                     QString normalizedDomain = QUrl::fromAce(QUrl::toAce(QString::fromUtf8(rawDomain)));
+                    if (normalizedDomain.isEmpty() && !rawDomain.isEmpty())
+                        return result;
                     cookie.setDomain(maybeLeadingDot + normalizedDomain);
                 } else if (field.first == "max-age") {

trunk/src/network/access/qnetworkcookie.h

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkcookie_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkcookiejar.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qnetworkcookiejar.h"
+#include "qnetworkcookiejartlds_p.h"
 #include "qnetworkcookiejar_p.h"
 …
     url object.
+    Returns true if one or more cookes are set for url otherwise false.
+    Returns true if one or more cookies are set for \a url,
+    otherwise false.
     If a cookie already exists in the cookie jar, it will be
 …
             QString domain = cookie.domain();
             if (!(isParentDomain(domain, defaultDomain)
+                || isParentDomain(defaultDomain, domain))) {
+                    continue;           // not accepted
+            }
+            // reject if domain is like ".com"
+            // (i.e., reject if domain does not contain embedded dots, see RFC 2109 section 4.3.2)
+            // this is just a rudimentary check and does not cover all cases
+            if (domain.lastIndexOf(QLatin1Char('.')) == 0)
+                continue;           // not accepted
+                || isParentDomain(defaultDomain, domain)))
+                continue; // not accepted
+            // the check for effective TLDs makes the "embedded dot" rule from RFC 2109 section 4.3.2
+            // redundant; the "leading dot" rule has been relaxed anyway, see above
+            // we remove the leading dot for this check
+            if (QNetworkCookieJarPrivate::isEffectiveTLD(domain.remove(0, 1)))
+                continue; // not accepted
+        }
 …
     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.
+    cookies sorted decreasingly by path length.
     The default QNetworkCookieJar class implements only a very basic
 …
     QDateTime now = QDateTime::currentDateTime();
     QList<QNetworkCookie> result;
+    bool isEncrypted = url.scheme().toLower() == QLatin1String("https");
     // scan our cookies for something that matches
 …
             continue;
         if (!(*it).isSessionCookie() && (*it).expirationDate() < now)
+            continue;
+        if ((*it).isSecure() && !isEncrypted)
             continue;
 …
+}
+bool QNetworkCookieJarPrivate::isEffectiveTLD(const QString &domain)
+{
+    // for domain 'foo.bar.com':
+    // 1. return if TLD table contains 'foo.bar.com'
+    if (containsTLDEntry(domain))
+        return true;
+    if (domain.contains(QLatin1Char('.'))) {
+        int count = domain.size() - domain.indexOf(QLatin1Char('.'));
+        QString wildCardDomain;
+        wildCardDomain.reserve(count + 1);
+        wildCardDomain.append(QLatin1Char('*'));
+        wildCardDomain.append(domain.right(count));
+        // 2. if table contains '*.bar.com',
+        // test if table contains '!foo.bar.com'
+        if (containsTLDEntry(wildCardDomain)) {
+            QString exceptionDomain;
+            exceptionDomain.reserve(domain.size() + 1);
+            exceptionDomain.append(QLatin1Char('!'));
+            exceptionDomain.append(domain);
+            return (! containsTLDEntry(exceptionDomain));
+        }
+    }
+    return false;
+}
+bool QNetworkCookieJarPrivate::containsTLDEntry(const QString &entry)
+{
+    int index = qHash(entry) % tldCount;
+    int currentDomainIndex = tldIndices[index];
+    while (currentDomainIndex < tldIndices[index+1]) {
+        QString currentEntry = QString::fromUtf8(tldData + currentDomainIndex);
+        if (currentEntry == entry)
+            return true;
+        currentDomainIndex += qstrlen(tldData + currentDomainIndex) + 1; // +1 for the ending \0
+    }
+    return false;
+}
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkcookiejar.h

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkcookiejar_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     QList<QNetworkCookie> allCookies;
+    static bool Q_AUTOTEST_EXPORT isEffectiveTLD(const QString &domain);
+    static bool containsTLDEntry(const QString &entry);
     Q_DECLARE_PUBLIC(QNetworkCookieJar)
 };

trunk/src/network/access/qnetworkdiskcache.cpp

-              r774
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     QDirIterator it(cacheDirectory(), filters, QDirIterator::Subdirectories);
+    // performance tweak: we store the size together with the name in
+    // order to avoid querying the size again before the file is deleted
+    typedef QPair<QString, qint64> ExpireInfo;
+    QMultiMap<QDateTime, ExpireInfo> cacheItems;
+    QMultiMap<QDateTime, QString> cacheItems;
     qint64 totalSize = 0;
     while (it.hasNext()) {
 …
         QString fileName = info.fileName();
         if (fileName.endsWith(CACHE_POSTFIX) && fileName.startsWith(CACHE_PREFIX)) {
+            ExpireInfo item = qMakePair(path, info.size());
+            cacheItems.insert(info.created(), item);
+            totalSize += item.second;
+            cacheItems.insert(info.created(), path);
+            totalSize += info.size();
+        }
+    }
 …
     int removedFiles = 0;
     qint64 goal = (maximumCacheSize() * 9) / 10;
     QMultiMap<QDateTime, ExpireInfo>::const_iterator i = cacheItems.constBegin();
+    QMultiMap<QDateTime, QString>::const_iterator i = cacheItems.constBegin();
     while (i != cacheItems.constEnd()) {
         if (totalSize < goal)
             break;
+        const ExpireInfo &item = i.value();
+        QFile::remove(item.first);
+        totalSize -= item.second;
+        QString name = i.value();
+        QFile file(name);
+        qint64 size = file.size();
+        file.remove();
+        totalSize -= size;
         ++removedFiles;
         ++i;

trunk/src/network/access/qnetworkdiskcache.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkdiskcache_p.h

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkreply.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     should have been emitted.
+    \value TemporaryNetworkFailureError the connection was broken due
+    to disconnection from the network, however the system has initiated
+    roaming to another access point. The request should be resubmitted
+    and will be processed as soon as the connection is re-established.
     \value ProxyConnectionRefusedError the connection to the proxy
     server was refused (the proxy server is not accepting requests)
 …
     bytesTotal. At that time, \a bytesTotal will not be -1.
-    This signal is suitable to connecting to QProgressBar::setValue()
-    to update the QProgressBar that provides user feedback.
     \sa downloadProgress()
 */
 …
     The download is finished when \a bytesReceived is equal to \a
     bytesTotal. At that time, \a bytesTotal will not be -1.
-    This signal is suitable to connecting to QProgressBar::setValue()
-    to update the QProgressBar that provides user feedback.
     Note that the values of both \a bytesReceived and \a bytesTotal
 …
         return it->second;
     return QByteArray();
+}
+/*! \typedef QNetworkReply::RawHeaderPair
+  RawHeaderPair is a QPair<QByteArray, QByteArray> where the first
+  QByteArray is the header name and the second is the header.
+ */
+/*!
+  Returns a list of raw header pairs.
+ */
+const QList<QNetworkReply::RawHeaderPair>& QNetworkReply::rawHeaderPairs() const
+{
+    Q_D(const QNetworkReply);
+    return d->rawHeaders;
+}

trunk/src/network/access/qnetworkreply.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         OperationCanceledError,
         SslHandshakeFailedError,
+        TemporaryNetworkFailureError,
         UnknownNetworkError = 99,
 …
     QByteArray rawHeader(const QByteArray &headerName) const;
+    typedef QPair<QByteArray, QByteArray> RawHeaderPair;
+    const QList<RawHeaderPair>& rawHeaderPairs() const;
     // attributes
     QVariant attribute(QNetworkRequest::Attribute code) const;

trunk/src/network/access/qnetworkreply_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/access/qnetworkreplyimpl.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "QtCore/qdatetime.h"
 #include "QtNetwork/qsslconfiguration.h"
+#include "QtNetwork/qnetworksession.h"
 #include "qnetworkaccesshttpbackend_p.h"
+#include "qnetworkaccessmanager_p.h"
 #include <QtCore/QCoreApplication>
 …
       cacheEnabled(false), cacheSaveDevice(0),
       notificationHandlingPaused(false),
       bytesDownloaded(0), lastBytesDownloaded(-1), bytesUploaded(-1),
+      bytesDownloaded(0), lastBytesDownloaded(-1), bytesUploaded(-1), preMigrationDownloaded(-1),
       httpStatusCode(0),
       state(Idle)
 …
+    }
+    backend->open();
+    if (state != Finished) {
+        if (operation == QNetworkAccessManager::GetOperation)
+            pendingNotifications.append(NotifyDownstreamReadyWrite);
+        handleNotifications();
+#ifndef QT_NO_BEARERMANAGEMENT
+    if (!backend->start()) { // ### we should call that method even if bearer is not used
+        // backend failed to start because the session state is not Connected.
+        // QNetworkAccessManager will call reply->backend->start() again for us when the session
+        // state changes.
+        state = WaitingForSession;
+        QNetworkSession *session = manager->d_func()->networkSession.data();
+        if (session) {
+            Q_Q(QNetworkReplyImpl);
+            QObject::connect(session, SIGNAL(error(QNetworkSession::SessionError)),
+                             q, SLOT(_q_networkSessionFailed()));
+            if (!session->isOpen())
+                session->open();
+        } else {
+            qWarning("Backend is waiting for QNetworkSession to connect, but there is none!");
+        }
+        return;
+    }
+#endif
+    if (backend && backend->isSynchronous()) {
+        state = Finished;
+    } else {
+        if (state != Finished) {
+            if (operation == QNetworkAccessManager::GetOperation)
+                pendingNotifications.append(NotifyDownstreamReadyWrite);
+            handleNotifications();
+        }
+    }
+}
 …
     lastBytesDownloaded = bytesDownloaded;
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
+    if (preMigrationDownloaded != Q_INT64_C(-1))
+        totalSize = totalSize.toLongLong() + preMigrationDownloaded;
     pauseNotificationHandling();
     emit q->downloadProgress(bytesDownloaded,
 …
+}
+#ifndef QT_NO_BEARERMANAGEMENT
+void QNetworkReplyImplPrivate::_q_networkSessionConnected()
+{
+    Q_Q(QNetworkReplyImpl);
+    if (manager.isNull())
+        return;
+    QNetworkSession *session = manager->d_func()->networkSession.data();
+    if (!session)
+        return;
+    if (session->state() != QNetworkSession::Connected)
+        return;
+    switch (state) {
+    case QNetworkReplyImplPrivate::Buffering:
+    case QNetworkReplyImplPrivate::Working:
+    case QNetworkReplyImplPrivate::Reconnecting:
+        // Migrate existing downloads to new network connection.
+        migrateBackend();
+        break;
+    case QNetworkReplyImplPrivate::WaitingForSession:
+        // Start waiting requests.
+        QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+        break;
+    default:
+        ;
+    }
+}
+void QNetworkReplyImplPrivate::_q_networkSessionFailed()
+{
+    // Abort waiting and working replies.
+    if (state == WaitingForSession || state == Working) {
+        state = Working;
+        error(QNetworkReplyImpl::UnknownNetworkError,
+              QCoreApplication::translate("QNetworkReply", "Network session error."));
+        finished();
+    }
+}
+#endif
 void QNetworkReplyImplPrivate::setup(QNetworkAccessManager::Operation op, const QNetworkRequest &req,
                                      QIODevice *data)
 …
     operation = op;
+    if (outgoingData && backend) {
+    q->QIODevice::open(QIODevice::ReadOnly);
+    // Internal code that does a HTTP reply for the synchronous Ajax
+    // in QtWebKit.
+    QVariant synchronousHttpAttribute = req.attribute(
+            static_cast<QNetworkRequest::Attribute>(QNetworkRequest::DownloadBufferAttribute + 1));
+    if (backend && synchronousHttpAttribute.toBool()) {
+        backend->setSynchronous(true);
+        if (outgoingData && outgoingData->isSequential()) {
+            outgoingDataBuffer = new QRingBuffer();
+            QByteArray data;
+            do {
+                data = outgoingData->readAll();
+                if (data.isEmpty())
+                    break;
+                outgoingDataBuffer->append(data);
+            } while (1);
+        }
+    }
+    if (outgoingData && backend && !backend->isSynchronous()) {
         // there is data to be uploaded, e.g. HTTP POST.
 …
             bool bufferingDisallowed =
                     req.attribute(QNetworkRequest::DoNotBufferUploadDataAttribute,
                                              false).toBool();
+                                  false).toBool();
             if (bufferingDisallowed) {
 …
         // for HTTP, we want to send out the request as fast as possible to the network, without
         // invoking methods in a QueuedConnection
+        if (qobject_cast<QNetworkAccessHttpBackend *>(backend)) {
+#ifndef QT_NO_HTTP
+        if (qobject_cast<QNetworkAccessHttpBackend *>(backend) || (backend && backend->isSynchronous())) {
             _q_startOperation();
         } else {
             QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+        }
+    }
+    q->QIODevice::open(QIODevice::ReadOnly);
+#else
+        if (backend && backend->isSynchronous())
+            _q_startOperation();
+        else
+            QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+#endif // QT_NO_HTTP
+        }
+}
 …
     QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
+    if (preMigrationDownloaded != Q_INT64_C(-1))
+        totalSize = totalSize.toLongLong() + preMigrationDownloaded;
     pauseNotificationHandling();
     emit q->downloadProgress(bytesDownloaded,
 …
 void QNetworkReplyImplPrivate::appendDownstreamData(const QByteArray &data)
+{
+    Q_UNUSED(data)
     // TODO implement
 …
+{
     Q_Q(QNetworkReplyImpl);
+    if (state == Finished || state == Aborted)
+        return;
+    if (state == Finished || state == Aborted || state == WaitingForSession)
+        return;
+    pauseNotificationHandling();
+    QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
+    if (preMigrationDownloaded != Q_INT64_C(-1))
+        totalSize = totalSize.toLongLong() + preMigrationDownloaded;
+    if (!manager.isNull()) {
+#ifndef QT_NO_BEARERMANAGEMENT
+        QNetworkSession *session = manager->d_func()->networkSession.data();
+        if (session && session->state() == QNetworkSession::Roaming &&
+            state == Working && errorCode != QNetworkReply::OperationCanceledError) {
+            // only content with a known size will fail with a temporary network failure error
+            if (!totalSize.isNull()) {
+                if (bytesDownloaded != totalSize) {
+                    if (migrateBackend()) {
+                        // either we are migrating or the request is finished/aborted
+                        if (state == Reconnecting || state == WaitingForSession) {
+                            resumeNotificationHandling();
+                            return; // exit early if we are migrating.
+                        }
+                    } else {
+                        error(QNetworkReply::TemporaryNetworkFailureError,
+                              QNetworkReply::tr("Temporary network failure."));
+                    }
+                }
+            }
+        }
+#endif
+    }
+    resumeNotificationHandling();
     state = Finished;
 …
     pauseNotificationHandling();
-    QVariant totalSize = cookedHeaders.value(QNetworkRequest::ContentLengthHeader);
     if (totalSize.isNull() || totalSize == -1) {
         emit q->downloadProgress(bytesDownloaded, bytesDownloaded);
 …
     resumeNotificationHandling();
+    completeCacheSave();
+    // if we don't know the total size of or we received everything save the cache
+    if (totalSize.isNull() || totalSize == -1 || bytesDownloaded == totalSize)
+        completeCacheSave();
     // note: might not be a good idea, since users could decide to delete us
 …
+{
     Q_Q(QNetworkReplyImpl);
+    // do we have cookies?
+    if (cookedHeaders.contains(QNetworkRequest::SetCookieHeader) && !manager.isNull()) {
+    // 1. do we have cookies?
+    // 2. are we allowed to set them?
+    if (cookedHeaders.contains(QNetworkRequest::SetCookieHeader) && !manager.isNull()
+        && (static_cast<QNetworkRequest::LoadControl>
+            (request.attribute(QNetworkRequest::CookieSaveControlAttribute,
+                               QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Automatic)) {
         QList<QNetworkCookie> cookies =
             qvariant_cast<QList<QNetworkCookie> >(cookedHeaders.value(QNetworkRequest::SetCookieHeader));
 …
     d->finished();
+}
+bool QNetworkReplyImpl::canReadLine () const
+{
+    Q_D(const QNetworkReplyImpl);
+    return QNetworkReply::canReadLine() || d->readBuffer.canReadLine();
+}
 /*!
 …
+}
+/*
+    Migrates the backend of the QNetworkReply to a new network connection if required.  Returns
+    true if the reply is migrated or it is not required; otherwise returns false.
+*/
+bool QNetworkReplyImplPrivate::migrateBackend()
+{
+    Q_Q(QNetworkReplyImpl);
+    // Network reply is already finished or aborted, don't need to migrate.
+    if (state == Finished || state == Aborted)
+        return true;
+    // Backend does not support resuming download.
+    if (!backend->canResume())
+        return false;
+    // Request has outgoing data, not migrating.
+    if (outgoingData)
+        return false;
+    // Request is serviced from the cache, don't need to migrate.
+    if (copyDevice)
+        return true;
+    state = QNetworkReplyImplPrivate::Reconnecting;
+    if (backend) {
+        delete backend;
+        backend = 0;
+    }
+    cookedHeaders.clear();
+    rawHeaders.clear();
+    preMigrationDownloaded = bytesDownloaded;
+    backend = manager->d_func()->findBackend(operation, request);
+    if (backend) {
+        backend->setParent(q);
+        backend->reply = this;
+        backend->setResumeOffset(bytesDownloaded);
+    }
+#ifndef QT_NO_HTTP
+    if (qobject_cast<QNetworkAccessHttpBackend *>(backend)) {
+        _q_startOperation();
+    } else {
+        QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+    }
+#else
+    QMetaObject::invokeMethod(q, "_q_startOperation", Qt::QueuedConnection);
+#endif // QT_NO_HTTP
+    return true;
+}
+#ifndef QT_NO_BEARERMANAGEMENT
+QDisabledNetworkReply::QDisabledNetworkReply(QObject *parent,
+                                             const QNetworkRequest &req,
+                                             QNetworkAccessManager::Operation op)
+:   QNetworkReply(parent)
+{
+    setRequest(req);
+    setUrl(req.url());
+    setOperation(op);
+    qRegisterMetaType<QNetworkReply::NetworkError>("QNetworkReply::NetworkError");
+    QString msg = QCoreApplication::translate("QNetworkAccessManager",
+                                              "Network access is disabled.");
+    setError(UnknownNetworkError, msg);
+    QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
+        Q_ARG(QNetworkReply::NetworkError, UnknownNetworkError));
+    QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
+}
+QDisabledNetworkReply::~QDisabledNetworkReply()
+{
+}
+#endif
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkreplyimpl_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     virtual void abort();
     // reimplemented from QNetworkReply
+    // reimplemented from QNetworkReply / QIODevice
     virtual void close();
     virtual qint64 bytesAvailable() const;
     virtual void setReadBufferSize(qint64 size);
+    virtual bool canReadLine () const;
     virtual qint64 readData(char *data, qint64 maxlen);
 …
     Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingData())
     Q_PRIVATE_SLOT(d_func(), void _q_bufferOutgoingDataFinished())
+#ifndef QT_NO_BEARERMANAGEMENT
+    Q_PRIVATE_SLOT(d_func(), void _q_networkSessionConnected())
+    Q_PRIVATE_SLOT(d_func(), void _q_networkSessionFailed())
+#endif
 };
 …
     enum State {
+        Idle,
+        Buffering,
+        Working,
+        Finished,
+        Aborted
+        Idle,               // The reply is idle.
+        Buffering,          // The reply is buffering outgoing data.
+        Working,            // The reply is uploading/downloading data.
+        Finished,           // The reply has finished.
+        Aborted,            // The reply has been aborted.
+        WaitingForSession,  // The reply is waiting for the session to open before connecting.
+        Reconnecting        // The reply will reconnect to once roaming has completed.
     };
 …
     void _q_bufferOutgoingData();
     void _q_bufferOutgoingDataFinished();
+#ifndef QT_NO_BEARERMANAGEMENT
+    void _q_networkSessionConnected();
+    void _q_networkSessionFailed();
+#endif
     void setup(QNetworkAccessManager::Operation op, const QNetworkRequest &request,
 …
     QAbstractNetworkCache *networkCache() const;
+    bool migrateBackend();
     bool cacheEnabled;
     QIODevice *cacheSaveDevice;
 …
     qint64 lastBytesDownloaded;
     qint64 bytesUploaded;
+    qint64 preMigrationDownloaded;
     QString httpReasonPhrase;
 …
 };
+#ifndef QT_NO_BEARERMANAGEMENT
+class QDisabledNetworkReply : public QNetworkReply
+{
+    Q_OBJECT
+public:
+    QDisabledNetworkReply(QObject *parent, const QNetworkRequest &req,
+                          QNetworkAccessManager::Operation op);
+    ~QDisabledNetworkReply();
+    void abort() { }
+protected:
+    qint64 readData(char *, qint64) { return -1; }
+};
+#endif
 QT_END_NAMESPACE

trunk/src/network/access/qnetworkrequest.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 /*!
     \enum QNetworkRequest::Attribute
+    \since 4.7
     Attribute codes for the QNetworkRequest and QNetworkReply.
 …
         header must be set.
      \value HttpPipeliningAllowedAttribute
+    \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
+    \value HttpPipeliningWasUsedAttribute
         Replies only, type: QVariant::Bool
         Indicates whether the HTTP pipelining was used for receiving
         this reply.
+    \value CustomVerbAttribute
+       Requests only, type: QVariant::ByteArray
+       Holds the value for the custom HTTP verb to send (destined for usage
+       of other verbs than GET, POST, PUT and DELETE). This verb is set
+       when calling QNetworkAccessManager::sendCustomRequest().
+    \value CookieLoadControlAttribute
+        Requests only, type: QVariant::Int (default: QNetworkRequest::Automatic)
+        Indicates whether to send 'Cookie' headers in the request.
+        This attribute is set to false by QtWebKit when creating a cross-origin
+        XMLHttpRequest where withCredentials has not been set explicitly to true by the
+        Javascript that created the request.
+        See \l{http://www.w3.org/TR/XMLHttpRequest2/#credentials-flag}{here} for more information.
+        (This value was introduced in 4.7.)
+    \value CookieSaveControlAttribute
+        Requests only, type: QVariant::Int (default: QNetworkRequest::Automatic)
+        Indicates whether to save 'Cookie' headers received from the server in reply
+        to the request.
+        This attribute is set to false by QtWebKit when creating a cross-origin
+        XMLHttpRequest where withCredentials has not been set explicitly to true by the
+        Javascript that created the request.
+        See \l{http://www.w3.org/TR/XMLHttpRequest2/#credentials-flag} {here} for more information.
+        (This value was introduced in 4.7.)
+    \value AuthenticationReuseAttribute
+        Requests only, type: QVariant::Int (default: QNetworkRequest::Automatic)
+        Indicates whether to use cached authorization credentials in the request,
+        if available. If this is set to QNetworkRequest::Manual and the authentication
+        mechanism is 'Basic' or 'Digest', Qt will not send an an 'Authorization' HTTP
+        header with any cached credentials it may have for the request's URL.
+        This attribute is set to QNetworkRequest::Manual by QtWebKit when creating a cross-origin
+        XMLHttpRequest where withCredentials has not been set explicitly to true by the
+        Javascript that created the request.
+        See \l{http://www.w3.org/TR/XMLHttpRequest2/#credentials-flag} {here} for more information.
+        (This value was introduced in 4.7.)
+    \omitvalue MaximumDownloadBufferSizeAttribute
+    \omitvalue DownloadBufferAttribute
     \value User
 …
 */
+/*!
+    \enum QNetworkRequest::LoadControl
+    \since 4.7
+    Indicates if an aspect of the request's loading mechanism has been
+    manually overridden, e.g. by QtWebKit.
+    \value Automatic            default value: indicates default behaviour.
+    \value Manual               indicates behaviour has been manually overridden.
+*/
 class QNetworkRequestPrivate: public QSharedData, public QNetworkHeadersPrivate
+{
 public:
     inline QNetworkRequestPrivate()
+        : priority(QNetworkRequest::NormalPriority)
 #ifndef QT_NO_OPENSSL
         : sslConfiguration(0)
+        , sslConfiguration(0)
 #endif
     { qRegisterMetaType<QNetworkRequest>(); }
 …
+    {
         url = other.url;
+        priority = other.priority;
 #ifndef QT_NO_OPENSSL
 …
+    {
         return url == other.url &&
+            priority == other.priority &&
             rawHeaders == other.rawHeaders &&
             attributes == other.attributes;
 …
     QUrl url;
+    QNetworkRequest::Priority priority;
 #ifndef QT_NO_OPENSSL
     mutable QSslConfiguration *sslConfiguration;
 …
+{
     return d->originatingObject.data();
+}
+/*!
+    \since 4.7
+    Return the priority of this request.
+    \sa setPriority()
+*/
+QNetworkRequest::Priority QNetworkRequest::priority() const
+{
+    return d->priority;
+}
+/*! \enum QNetworkRequest::Priority
+  \since 4.7
+  This enum lists the possible network request priorities.
+  \value HighPriority   High priority
+  \value NormalPriority Normal priority
+  \value LowPriority    Low priority
+ */
+/*!
+    \since 4.7
+    Set the priority of this request to \a priority.
+    \note The \a priority is only a hint to the network access
+    manager.  It can use it or not. Currently it is used for HTTP to
+    decide which request should be sent first to a server.
+    \sa priority()
+*/
+void QNetworkRequest::setPriority(Priority priority)
+{
+    d->priority = priority;
+}
 …
     QNetworkRequest::KnownHeaders parsedKey = parseHeaderName(key);
     if (parsedKey != QNetworkRequest::KnownHeaders(-1)) {
         if (value.isNull())
+        if (value.isNull()) {
             cookedHeaders.remove(parsedKey);
+        else
+        } else if (parsedKey == QNetworkRequest::ContentLengthHeader
+                 && cookedHeaders.contains(QNetworkRequest::ContentLengthHeader)) {
+            // Only set the cooked header "Content-Length" once.
+            // See bug QTBUG-15311
+        } else {
             cookedHeaders.insert(parsedKey, parseHeaderValue(parsedKey, value));
+        }
+    }
+}

trunk/src/network/access/qnetworkrequest.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         HttpPipeliningAllowedAttribute,
         HttpPipeliningWasUsedAttribute,
+        CustomVerbAttribute,
+        CookieLoadControlAttribute,
+        AuthenticationReuseAttribute,
+        CookieSaveControlAttribute,
+        MaximumDownloadBufferSizeAttribute, // internal
+        DownloadBufferAttribute, // internal
+        // (DownloadBufferAttribute + 1) is reserved internal for QSynchronousHttpNetworkReply
+        // add the enum in 4.8
         User = 1000,
 …
         PreferCache,
         AlwaysCache
+    };
+    enum LoadControl {
+        Automatic = 0,
+        Manual
+    };
+    enum Priority {
+        HighPriority = 1,
+        NormalPriority = 3,
+        LowPriority = 5
     };
 …
     QObject *originatingObject() const;
+    Priority priority() const;
+    void setPriority(Priority priority);
 private:
     QSharedDataPointer<QNetworkRequestPrivate> d;

trunk/src/network/access/qnetworkrequest_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/kernel.pri

r561	r846
29	29	mac:SOURCES += kernel/qnetworkproxy_mac.cpp
30	30	else:win32:SOURCES += kernel/qnetworkproxy_win.cpp
	31	else:symbian:SOURCES += kernel/qnetworkproxy_symbian.cpp
31	32	else:SOURCES += kernel/qnetworkproxy_generic.cpp
32	33
	34	symbian: LIBS += -lcommsdat

trunk/src/network/kernel/qauthenticator.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qendian.h>
 #include <qstring.h>
+#include <qdatetime.h>
+//#define NTLMV1_CLIENT
 QT_BEGIN_NAMESPACE
+#ifdef NTLMV1_CLIENT
 #include "../../3rdparty/des/des.cpp"
+#endif
 static QByteArray qNtlmPhase1();
 …
   Note that, in particular, NTLM version 2 is not supported.
+  \section1 Options
+  In addition to the username and password required for authentication, a
+  QAuthenticator object can also contain additional options. The
+  options() function can be used to query incoming options sent by
+  the server; the setOption() function can
+  be used to set outgoing options, to be processed by the authenticator
+  calculation. The options accepted and provided depend on the authentication
+  type (see method()).
+  The following tables list known incoming options as well as accepted
+  outgoing options. The list of incoming options is not exhaustive, since
+  servers may include additional information at any time. The list of
+  outgoing options is exhaustive, however, and no unknown options will be
+  treated or sent back to the server.
+  \section2 Basic
+  \table
+    \header \o Option \o Direction \o Description
+    \row \o \tt{realm} \o Incoming \o Contains the realm of the authentication, the same as realm()
+  \endtable
+  The Basic authentication mechanism supports no outgoing options.
+  \section2 NTLM version 1
+  The NTLM authentication mechanism currently supports no incoming or outgoing options.
+  \section2 Digest-MD5
+  \table
+    \header \o Option \o Direction \o Description
+    \row \o \tt{realm} \o Incoming \o Contains the realm of the authentication, the same as realm()
+  \endtable
+  The Digest-MD5 authentication mechanism supports no outgoing options.
   \sa QSslSocket
 */
 …
     if (d == other.d)
         return *this;
+    detach();
+    d->user = other.d->user;
+    d->password = other.d->password;
+    if (d && !d->ref.deref())
+        delete d;
+    d = other.d;
+    if (d)
+        d->ref.ref();
     return *this;
+}
 …
         && d->password == other.d->password
         && d->realm == other.d->realm
+        && d->method == other.d->method;
+        && d->method == other.d->method
+        && d->options == other.d->options;
+}
 …
+{
     detach();
+    d->user = user;
+    int separatorPosn = 0;
+    switch(d->method) {
+    case QAuthenticatorPrivate::Ntlm:
+        if((separatorPosn = user.indexOf(QLatin1String("\\"))) != -1) {
+            //domain name is present
+            d->realm.clear();
+            d->userDomain = user.left(separatorPosn);
+            d->extractedUser = user.mid(separatorPosn + 1);
+            d->user = user;
+        } else if((separatorPosn = user.indexOf(QLatin1String("@"))) != -1) {
+            //domain name is present
+            d->realm.clear();
+            d->userDomain = user.left(separatorPosn);
+            d->extractedUser = user.left(separatorPosn);
+            d->user = user;
+        } else {
+            d->extractedUser = user;
+            d->user = user;
+            d->realm.clear();
+            d->userDomain.clear();
+        }
+        break;
+    default:
+        d->user = user;
+        d->userDomain.clear();
+        break;
+    }
+}
 …
+}
+/*!
+  returns true if the authenticator is null.
+/*!
+    \since 4.7
+    Returns the value related to option \a opt if it was set by the server.
+    See \l{QAuthenticator#Options} for more information on incoming options.
+    If option \a opt isn't found, an invalid QVariant will be returned.
+    \sa options(), QAuthenticator#Options
+*/
+QVariant QAuthenticator::option(const QString &opt) const
+{
+    return d ? d->options.value(opt) : QVariant();
+}
+/*!
+    \since 4.7
+    Returns all incoming options set in this QAuthenticator object by parsing
+    the server reply. See \l{QAuthenticator#Options} for more information
+    on incoming options.
+    \sa option(), QAuthenticator#Options
+*/
+QVariantHash QAuthenticator::options() const
+{
+    return d ? d->options : QVariantHash();
+}
+/*!
+    \since 4.7
+    Sets the outgoing option \a opt to value \a value.
+    See \l{QAuthenticator#Options} for more information on outgoing options.
+    \sa options(), option(), QAuthenticator#Options
+*/
+void QAuthenticator::setOption(const QString &opt, const QVariant &value)
+{
+    detach();
+    d->options.insert(opt, value);
+}
+/*!
+    Returns true if the authenticator is null.
 */
 bool QAuthenticator::isNull() const
 …
 void QAuthenticatorPrivate::parseHttpResponse(const QHttpResponseHeader &header, bool isProxy)
+{
+    QList<QPair<QString, QString> > values = header.values();
+    const QList<QPair<QString, QString> > values = header.values();
+    QList<QPair<QByteArray, QByteArray> > rawValues;
+    QList<QPair<QString, QString> >::const_iterator it, end;
+    for (it = values.constBegin(), end = values.constEnd(); it != end; ++it)
+        rawValues.append(qMakePair(it->first.toLatin1(), it->second.toUtf8()));
+    // continue in byte array form
+    parseHttpResponse(rawValues, isProxy);
+}
+#endif
+void QAuthenticatorPrivate::parseHttpResponse(const QList<QPair<QByteArray, QByteArray> > &values, bool isProxy)
+{
     const char *search = isProxy ? "proxy-authenticate" : "www-authenticate";
 …
     */
     QString headerVal;
+    QByteArray headerVal;
     for (int i = 0; i < values.size(); ++i) {
         const QPair<QString, QString> &current = values.at(i);
         if (current.first.toLower() != QLatin1String(search))
+        const QPair<QByteArray, QByteArray> &current = values.at(i);
+        if (current.first.toLower() != search)
             continue;
+        QString str = current.second;
+        if (method < Basic && str.startsWith(QLatin1String("Basic"), Qt::CaseInsensitive)) {
+            method = Basic; headerVal = str.mid(6);
+        } else if (method < Ntlm && str.startsWith(QLatin1String("NTLM"), Qt::CaseInsensitive)) {
+        QByteArray str = current.second.toLower();
+        if (method < Basic && str.startsWith("basic")) {
+            method = Basic;
+            headerVal = current.second.mid(6);
+        } else if (method < Ntlm && str.startsWith("ntlm")) {
             method = Ntlm;
             headerVal = str.mid(5);
         } else if (method < DigestMd5 && str.startsWith(QLatin1String("Digest"), Qt::CaseInsensitive)) {
+            headerVal = current.second.mid(5);
+        } else if (method < DigestMd5 && str.startsWith("digest")) {
             method = DigestMd5;
             headerVal = str.mid(7);
+            headerVal = current.second.mid(7);
+        }
+    }
     challenge = headerVal.trimmed().toLatin1();
+    challenge = headerVal.trimmed();
     QHash<QByteArray, QByteArray> options = parseDigestAuthenticationChallenge(challenge);
     switch(method) {
     case Basic:
+        realm = QString::fromLatin1(options.value("realm"));
+        if(realm.isEmpty())
+            this->options[QLatin1String("realm")] = realm = QString::fromLatin1(options.value("realm"));
         if (user.isEmpty())
             phase = Done;
 …
     case Ntlm:
         // #### extract from header
-        realm.clear();
         break;
     case DigestMd5: {
+        realm = QString::fromLatin1(options.value("realm"));
+        if(realm.isEmpty())
+            this->options[QLatin1String("realm")] = realm = QString::fromLatin1(options.value("realm"));
         if (options.value("stale").toLower() == "true")
             phase = Start;
 …
+    }
+}
-#endif
 QByteArray QAuthenticatorPrivate::calculateResponse(const QByteArray &requestMethod, const QByteArray &path)
 …
 #define NTLMSSP_NEGOTIATE_56 0x80000000
+/*
+ * AvId values
+ */
+#define AVTIMESTAMP 7
+//#define NTLMV1_CLIENT
+//************************Global variables***************************
+const int blockSize = 64; //As per RFC2104 Block-size is 512 bits
+const int nDigestLen = 16; //Trunctaion Length of the Hmac-Md5 digest
+const quint8 respversion = 1;
+const quint8 hirespversion = 1;
 /* usage:
 …
     // extracted
     QString targetNameStr, targetInfoStr;
+    QByteArray targetInfoBuff;
 };
 …
     QByteArray lmResponseBuf, ntlmResponseBuf;
     QString domainStr, userStr, workstationStr, sessionKeyStr;
+    QByteArray v2Hash;
 };
 …
+}
+#ifdef NTLMV1_CLIENT
 static QByteArray qEncodeNtlmResponse(const QAuthenticatorPrivate *ctx, const QNtlmPhase2Block& ch)
+{
 …
     return rc;
+}
+#endif
+/*********************************************************************
+* Function Name: qEncodeHmacMd5
+* Params:
+*    key:   Type - QByteArray
+*         - It is the Authentication key
+*    message:   Type - QByteArray
+*         - This is the actual message which will be encoded
+*           using HMacMd5 hash algorithm
+*
+* Return Value:
+*    hmacDigest:   Type - QByteArray
+*
+* Description:
+*    This function will be used to encode the input message using
+*    HMacMd5 hash algorithm.
+*
+*    As per the RFC2104 the HMacMd5 algorithm can be specified
+*        ---------------------------------------
+*         MD5(K XOR opad, MD5(K XOR ipad, text))
+*        ---------------------------------------
+*
+*********************************************************************/
+QByteArray qEncodeHmacMd5(QByteArray &key, const QByteArray &message)
+{
+    Q_ASSERT_X(!(message.isEmpty()),"qEncodeHmacMd5", "Empty message check");
+    Q_ASSERT_X(!(key.isEmpty()),"qEncodeHmacMd5", "Empty key check");
+    QCryptographicHash hash(QCryptographicHash::Md5);
+    QByteArray hMsg;
+    QByteArray iKeyPad(blockSize, 0x36);
+    QByteArray oKeyPad(blockSize, 0x5c);
+    hash.reset();
+    // Adjust the key length to blockSize
+    if(blockSize < key.length()) {
+        hash.addData(key);
+        key = hash.result(); //MD5 will always return 16 bytes length output
+    }
+    //Key will be <= 16 or 20 bytes as hash function (MD5 or SHA hash algorithms)
+    //key size can be max of Block size only
+    key = key.leftJustified(blockSize,0,true);
+    //iKeyPad, oKeyPad and key are all of same size "blockSize"
+    //xor of iKeyPad with Key and store the result into iKeyPad
+    for(int i = 0; i<key.size();i++) {
+        iKeyPad[i] = key[i]^iKeyPad[i];
+    }
+    //xor of oKeyPad with Key and store the result into oKeyPad
+    for(int i = 0; i<key.size();i++) {
+        oKeyPad[i] = key[i]^oKeyPad[i];
+    }
+    iKeyPad.append(message); // (K0 xor ipad) || text
+    hash.reset();
+    hash.addData(iKeyPad);
+    hMsg = hash.result();
+                    //Digest gen after pass-1: H((K0 xor ipad)||text)
+    QByteArray hmacDigest;
+    oKeyPad.append(hMsg);
+    hash.reset();
+    hash.addData(oKeyPad);
+    hmacDigest = hash.result();
+                    // H((K0 xor opad )|| H((K0 xor ipad) || text))
+    /*hmacDigest should not be less than half the length of the HMAC output
+      (to match the birthday attack bound) and not less than 80 bits
+      (a suitable lower bound on the number of bits that need to be
+      predicted by an attacker).
+      Refer RFC 2104 for more details on truncation part */
+    /*MD5 hash always returns 16 byte digest only and HMAC-MD5 spec
+      (RFC 2104) also says digest length should be 16 bytes*/
+    return hmacDigest;
+}
+static QByteArray qCreatev2Hash(const QAuthenticatorPrivate *ctx,
+                                QNtlmPhase3Block *phase3)
+{
+    Q_ASSERT(phase3 != 0);
+    // since v2 Hash is need for both NTLMv2 and LMv2 it is calculated
+    // only once and stored and reused
+    if(phase3->v2Hash.size() == 0) {
+        QCryptographicHash md4(QCryptographicHash::Md4);
+        QByteArray passUnicode = qStringAsUcs2Le(ctx->password);
+        md4.addData(passUnicode.data(), passUnicode.size());
+        QByteArray hashKey = md4.result();
+        Q_ASSERT(hashKey.size() == 16);
+        // Assuming the user and domain is always unicode in challenge
+        QByteArray message =
+                qStringAsUcs2Le(ctx->extractedUser.toUpper()) +
+                qStringAsUcs2Le(phase3->domainStr);
+        phase3->v2Hash = qEncodeHmacMd5(hashKey, message);
+    }
+    return phase3->v2Hash;
+}
+static QByteArray clientChallenge(const QAuthenticatorPrivate *ctx)
+{
+    Q_ASSERT(ctx->cnonce.size() >= 8);
+    QByteArray clientCh = ctx->cnonce.right(8);
+    return clientCh;
+}
+// caller has to ensure a valid targetInfoBuff
+static QByteArray qExtractServerTime(const QByteArray& targetInfoBuff)
+{
+    QByteArray timeArray;
+    QDataStream ds(targetInfoBuff);
+    ds.setByteOrder(QDataStream::LittleEndian);
+    quint16 avId;
+    quint16 avLen;
+    ds >> avId;
+    ds >> avLen;
+    while(avId != 0) {
+        if(avId == AVTIMESTAMP) {
+            timeArray.resize(avLen);
+            //avLen size of QByteArray is allocated
+            ds.readRawData(timeArray.data(), avLen);
+            break;
+        }
+        ds.skipRawData(avLen);
+        ds >> avId;
+        ds >> avLen;
+    }
+    return timeArray;
+}
+static QByteArray qEncodeNtlmv2Response(const QAuthenticatorPrivate *ctx,
+                                        const QNtlmPhase2Block& ch,
+                                        QNtlmPhase3Block *phase3)
+{
+    Q_ASSERT(phase3 != 0);
+    // return value stored in phase3
+    qCreatev2Hash(ctx, phase3);
+    QByteArray temp;
+    QDataStream ds(&temp, QIODevice::WriteOnly);
+    ds.setByteOrder(QDataStream::LittleEndian);
+    ds << respversion;
+    ds << hirespversion;
+    //Reserved
+    QByteArray reserved1(6, 0);
+    ds.writeRawData(reserved1.constData(), reserved1.size());
+    quint64 time = 0;
+    QByteArray timeArray;
+    if(ch.targetInfo.len)
+    {
+        timeArray = qExtractServerTime(ch.targetInfoBuff);
+    }
+    //if server sends time, use it instead of current time
+    if(timeArray.size()) {
+        ds.writeRawData(timeArray.constData(), timeArray.size());
+    } else {
+        QDateTime currentTime(QDate::currentDate(),
+                              QTime::currentTime(), Qt::UTC);
+        // number of seconds between 1601 and epoc(1970)
+        // 369 years, 89 leap years
+        // ((369 * 365) + 89) * 24 * 3600 = 11644473600
+        time = Q_UINT64_C(currentTime.toTime_t() + 11644473600);
+        // represented as 100 nano seconds
+        time = Q_UINT64_C(time * 10000000);
+        ds << time;
+    }
+    //8 byte client challenge
+    QByteArray clientCh = clientChallenge(ctx);
+    ds.writeRawData(clientCh.constData(), clientCh.size());
+    //Reserved
+    QByteArray reserved2(4, 0);
+    ds.writeRawData(reserved2.constData(), reserved2.size());
+    if (ch.targetInfo.len > 0) {
+        ds.writeRawData(ch.targetInfoBuff.constData(),
+                        ch.targetInfoBuff.size());
+    }
+    //Reserved
+    QByteArray reserved3(4, 0);
+    ds.writeRawData(reserved3.constData(), reserved3.size());
+    QByteArray message((const char*)ch.challenge, sizeof(ch.challenge));
+    message.append(temp);
+    QByteArray ntChallengeResp = qEncodeHmacMd5(phase3->v2Hash, message);
+    ntChallengeResp.append(temp);
+    return ntChallengeResp;
+}
+static QByteArray qEncodeLmv2Response(const QAuthenticatorPrivate *ctx,
+                                      const QNtlmPhase2Block& ch,
+                                      QNtlmPhase3Block *phase3)
+{
+    Q_ASSERT(phase3 != 0);
+    // return value stored in phase3
+    qCreatev2Hash(ctx, phase3);
+    QByteArray message((const char*)ch.challenge, sizeof(ch.challenge));
+    QByteArray clientCh = clientChallenge(ctx);
+    message.append(clientCh);
+    QByteArray lmChallengeResp = qEncodeHmacMd5(phase3->v2Hash, message);
+    lmChallengeResp.append(clientCh);
+    return lmChallengeResp;
+}
 static bool qNtlmDecodePhase2(const QByteArray& data, QNtlmPhase2Block& ch)
 …
     if (ch.targetInfo.len > 0) {
+        // UNUSED right now
+        if (ch.targetInfo.len + ch.targetInfo.offset > (unsigned)data.size())
+            return false;
+        ch.targetInfoBuff = data.mid(ch.targetInfo.offset, ch.targetInfo.len);
+    }
 …
     bool unicode = ch.flags & NTLMSSP_NEGOTIATE_UNICODE;
-    ctx->realm = ch.targetNameStr;
     pb.flags = NTLMSSP_NEGOTIATE_NTLM;
 …
     Q_ASSERT(QNtlmPhase3BlockBase::Size == sizeof(QNtlmPhase3BlockBase));
+    offset = qEncodeNtlmString(pb.domain, offset, ctx->realm, unicode);
+    pb.domainStr = ctx->realm;
+    offset = qEncodeNtlmString(pb.user, offset, ctx->user, unicode);
+    pb.userStr = ctx->user;
+    if(ctx->userDomain.isEmpty()) {
+        offset = qEncodeNtlmString(pb.domain, offset, ch.targetNameStr, unicode);
+        pb.domainStr = ch.targetNameStr;
+    } else {
+        offset = qEncodeNtlmString(pb.domain, offset, ctx->userDomain, unicode);
+        pb.domainStr = ctx->userDomain;
+    }
+    offset = qEncodeNtlmString(pb.user, offset, ctx->extractedUser, unicode);
+    pb.userStr = ctx->extractedUser;
     offset = qEncodeNtlmString(pb.workstation, offset, ctx->workstation, unicode);
 …
     // Get LM response
+#ifdef NTLMV1_CLIENT
     pb.lmResponseBuf = qEncodeLmResponse(ctx, ch);
+#else
+    if (ch.targetInfo.len > 0) {
+        pb.lmResponseBuf = QByteArray();
+    } else {
+        pb.lmResponseBuf = qEncodeLmv2Response(ctx, ch, &pb);
+    }
+#endif
     offset = qEncodeNtlmBuffer(pb.lmResponse, offset, pb.lmResponseBuf);
     // Get NTLM response
+#ifdef NTLMV1_CLIENT
     pb.ntlmResponseBuf = qEncodeNtlmResponse(ctx, ch);
+#else
+    pb.ntlmResponseBuf = qEncodeNtlmv2Response(ctx, ch, &pb);
+#endif
     offset = qEncodeNtlmBuffer(pb.ntlmResponse, offset, pb.ntlmResponseBuf);

trunk/src/network/kernel/qauthenticator.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <QtCore/qstring.h>
+#include <QtCore/qvariant.h>
 QT_BEGIN_HEADER
 …
     QString realm() const;
+    QVariant option(const QString &opt) const;
+    QVariantHash options() const;
+    void setOption(const QString &opt, const QVariant &value);
     bool isNull() const;
     void detach();

trunk/src/network/kernel/qauthenticator_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qstring.h>
 #include <qauthenticator.h>
+#include <qvariant.h>
 QT_BEGIN_NAMESPACE
 …
 class QHttpResponseHeader;
 class QAuthenticatorPrivate
+class Q_AUTOTEST_EXPORT QAuthenticatorPrivate
+{
 public:
 …
     QAtomicInt ref;
     QString user;
+    QString extractedUser;
     QString password;
     QHash<QByteArray, QByteArray> options;
+    QVariantHash options;
     Method method;
     QString realm;
 …
     // ntlm specific
     QString workstation;
+    QString userDomain;
     QByteArray calculateResponse(const QByteArray &method, const QByteArray &path);
 …
     void parseHttpResponse(const QHttpResponseHeader &, bool isProxy);
 #endif
+    void parseHttpResponse(const QList<QPair<QByteArray, QByteArray> >&, bool isProxy);
 };

trunk/src/network/kernel/qhostaddress.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     and QUdpSocket to connect to a host or to set up a server.
     A host address is set with setAddress(), checked for its type
     using isIPv4Address() or isIPv6Address(), and retrieved with
     toIPv4Address(), toIPv6Address(), or toString().
+    A host address is set with setAddress(), and retrieved with
+    toIPv4Address(), toIPv6Address(), or toString(). You can check the
+    type with protocol().
     \note Please note that QHostAddress does not do DNS lookups.
 …
     2130706433 (i.e. 0x7f000001).
+    This value is only valid if isIp4Addr() returns true.
+    This value is only valid if the Protocol() is
+    \l{QAbstractSocket::}{IPv4Protocol}.
     \sa toString()
 …
     \snippet doc/src/snippets/code/src_network_kernel_qhostaddress.cpp 0
+    This value is only valid if isIPv6Address() returns true.
+    This value is only valid if the protocol() is
+    \l{QAbstractSocket::}{IPv6Protocol}.
     \sa toString()
 …
     to the stream.
     \sa {Format of the QDataStream operators}
+    \sa {Serializing Qt Data Types}
 */
 QDataStream &operator<<(QDataStream &out, const QHostAddress &address)
 …
     reference to the stream.
     \sa {Format of the QDataStream operators}
+    \sa {Serializing Qt Data Types}
 */
 QDataStream &operator>>(QDataStream &in, QHostAddress &address)

trunk/src/network/kernel/qhostaddress.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qhostaddress_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qhostinfo.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         QHostInfo hostInfo(id);
         hostInfo.setError(QHostInfo::HostNotFound);
         hostInfo.setErrorString(QObject::tr("No host name given"));
+        hostInfo.setErrorString(QCoreApplication::translate("QHostInfo", "No host name given"));
         QScopedPointer<QHostInfoResult> result(new QHostInfoResult);
         QObject::connect(result.data(), SIGNAL(resultsReady(QHostInfo)),
 …
 #endif
+    return QHostInfoAgent::fromName(name);
+    QHostInfo hostInfo = QHostInfoAgent::fromName(name);
+    QHostInfoLookupManager *manager = theHostInfoLookupManager();
+    manager->cache.put(name, hostInfo);
+    return hostInfo;
+}
 …
     resultEmitter.emitResultsReady(hostInfo);
+    // now also iterate through the postponed ones
+    {
+        QMutexLocker locker(&manager->mutex);
+        QMutableListIterator<QHostInfoRunnable*> iterator(manager->postponedLookups);
+        while (iterator.hasNext()) {
+            QHostInfoRunnable* postponed = iterator.next();
+            if (toBeLookedUp == postponed->toBeLookedUp) {
+                // we can now emit
+                iterator.remove();
+                hostInfo.setLookupId(postponed->id);
+                postponed->resultEmitter.emitResultsReady(hostInfo);
+            }
+        }
+    }
     manager->lookupFinished(this);
 …
     // don't qDeleteAll currentLookups, the QThreadPool has ownership
+    qDeleteAll(postponedLookups);
+    qDeleteAll(scheduledLookups);
+    qDeleteAll(finishedLookups);
+    clear();
+}
+void QHostInfoLookupManager::clear()
+{
+    {
+        QMutexLocker locker(&mutex);
+        qDeleteAll(postponedLookups);
+        qDeleteAll(scheduledLookups);
+        qDeleteAll(finishedLookups);
+        postponedLookups.clear();
+        scheduledLookups.clear();
+        finishedLookups.clear();
+    }
+    threadPool.waitForDone();
+    cache.clear();
+}
 …
     QMutexLocker locker(&this->mutex);
+    // is postponed? delete and return
+    for (int i = 0; i < postponedLookups.length(); i++) {
+        if (postponedLookups.at(i)->id == id) {
+            delete postponedLookups.takeAt(i);
+            return;
+        }
+    }
+    // is scheduled? delete and return
+    for (int i = 0; i < scheduledLookups.length(); i++) {
+        if (scheduledLookups.at(i)->id == id) {
+            delete scheduledLookups.takeAt(i);
+            return;
+        }
+    }
     if (!abortedLookups.contains(id))
         abortedLookups.append(id);
 …
+}
 // This function returns immediatly when we had a result in the cache, else it will later emit a signal
+// This function returns immediately when we had a result in the cache, else it will later emit a signal
 QHostInfo qt_qhostinfo_lookup(const QString &name, QObject *receiver, const char *member, bool *valid, int *id)
+{
 …
     QHostInfoLookupManager* manager = theHostInfoLookupManager();
     if (manager) {
         manager->cache.clear();
+        manager->clear();
+    }
+}

trunk/src/network/kernel/qhostinfo.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qhostinfo_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 Q_SIGNALS:
     void resultsReady(const QHostInfo info);
+    void resultsReady(const QHostInfo &info);
 };
 …
 // Do NOT use them outside of QAbstractSocket.
 QHostInfo Q_NETWORK_EXPORT qt_qhostinfo_lookup(const QString &name, QObject *receiver, const char *member, bool *valid, int *id);
 void Q_NETWORK_EXPORT qt_qhostinfo_clear_cache();
+void Q_AUTOTEST_EXPORT qt_qhostinfo_clear_cache();
 void Q_AUTOTEST_EXPORT qt_qhostinfo_enable_cache(bool e);
 …
     ~QHostInfoLookupManager();
+    void clear();
     void work();
 …
     QHostInfoCache cache;
+    friend class QHostInfoRunnable;
 protected:
     QList<QHostInfoRunnable*> currentLookups; // in progress

trunk/src/network/kernel/qhostinfo_unix.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     if (aceHostname.isEmpty()) {
         results.setError(QHostInfo::HostNotFound);
+        results.setErrorString(hostName.isEmpty() ? QObject::tr("No host name given") : QObject::tr("Invalid hostname"));
+        results.setErrorString(hostName.isEmpty() ?
+                               QCoreApplication::translate("QHostInfoAgent", "No host name given") :
+                               QCoreApplication::translate("QHostInfoAgent", "Invalid hostname"));
         return results;
+    }
 …
     hints.ai_flags = Q_ADDRCONFIG;
 #endif
+#ifdef Q_OS_SYMBIAN
+#   ifdef QHOSTINFO_DEBUG
+        qDebug() << "Setting flags: 'hints.ai_flags &= AI_V4MAPPED | AI_ALL'";
+#   endif
+#endif
     int result = getaddrinfo(aceHostname.constData(), 0, &hints, &res);
 …
         // if the lookup failed with AI_ADDRCONFIG set, try again without it
         hints.ai_flags = 0;
+#ifdef Q_OS_SYMBIAN
+#   ifdef QHOSTINFO_DEBUG
+        qDebug() << "Setting flags: 'hints.ai_flags &= AI_V4MAPPED | AI_ALL'";
+#   endif
+        hints.ai_flags &= AI_V4MAPPED | AI_ALL;
+#endif
         result = getaddrinfo(aceHostname.constData(), 0, &hints, &res);
+    }
 …
         QList<QHostAddress> addresses;
         while (node) {
+#ifdef QHOSTINFO_DEBUG
+                qDebug() << "getaddrinfo node: flags:" << node->ai_flags << "family:" << node->ai_family << "ai_socktype:" << node->ai_socktype << "ai_protocol:" << node->ai_protocol << "ai_addrlen:" << node->ai_addrlen;
+#endif
             if (node->ai_family == AF_INET) {
                 QHostAddress addr;
 …
             else if (node->ai_family == AF_INET6) {
                 QHostAddress addr;
+                addr.setAddress(((sockaddr_in6 *) node->ai_addr)->sin6_addr.s6_addr);
+                sockaddr_in6 *sa6 = (sockaddr_in6 *) node->ai_addr;
+                addr.setAddress(sa6->sin6_addr.s6_addr);
+                if (sa6->sin6_scope_id)
+                    addr.setScopeId(QString::number(sa6->sin6_scope_id));
                 if (!addresses.contains(addr))
                     addresses.append(addr);

trunk/src/network/kernel/qhostinfo_win.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "private/qnativesocketengine_p.h"
 #include <ws2tcpip.h>
 #include <qlibrary.h>
+#include <private/qsystemlibrary_p.h>
 #include <qmutex.h>
 #include <qurl.h>
 …
     // back to gethostbyname(), which has no IPv6 support.
 #if !defined(Q_OS_WINCE)
     local_getaddrinfo = (getaddrinfoProto) QLibrary::resolve(QLatin1String("ws2_32.dll"), "getaddrinfo");
     local_freeaddrinfo = (freeaddrinfoProto) QLibrary::resolve(QLatin1String("ws2_32.dll"), "freeaddrinfo");
     local_getnameinfo = (getnameinfoProto) QLibrary::resolve(QLatin1String("ws2_32.dll"), "getnameinfo");
+    local_getaddrinfo = (getaddrinfoProto) QSystemLibrary::resolve(QLatin1String("ws2_32"), "getaddrinfo");
+    local_freeaddrinfo = (freeaddrinfoProto) QSystemLibrary::resolve(QLatin1String("ws2_32"), "freeaddrinfo");
+    local_getnameinfo = (getnameinfoProto) QSystemLibrary::resolve(QLatin1String("ws2_32"), "getnameinfo");
 #else
     local_getaddrinfo = (getaddrinfoProto) QLibrary::resolve(QLatin1String("ws2.dll"), "getaddrinfo");
     local_freeaddrinfo = (freeaddrinfoProto) QLibrary::resolve(QLatin1String("ws2.dll"), "freeaddrinfo");
     local_getnameinfo = (getnameinfoProto) QLibrary::resolve(QLatin1String("ws2.dll"), "getnameinfo");
+    local_getaddrinfo = (getaddrinfoProto) QSystemLibrary::resolve(QLatin1String("ws2"), "getaddrinfo");
+    local_freeaddrinfo = (freeaddrinfoProto) QSystemLibrary::resolve(QLatin1String("ws2"), "freeaddrinfo");
+    local_getnameinfo = (getnameinfoProto) QSystemLibrary::resolve(QLatin1String("ws2"), "getnameinfo");
 #endif
+}

trunk/src/network/kernel/qnetworkinterface.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkinterface.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkinterface_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkinterface_symbian.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkinterface_unix.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkinterface_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qhash.h>
 #include <qurl.h>
+#include <private/qsystemlibrary_p.h>
 QT_BEGIN_NAMESPACE
 …
         done = true;
         HINSTANCE iphlpapiHnd = LoadLibrary(L"iphlpapi");
+        HINSTANCE iphlpapiHnd = QSystemLibrary::load(L"iphlpapi");
         if (iphlpapiHnd == NULL)
             return;

trunk/src/network/kernel/qnetworkinterface_win_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkproxy.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     : d(0)
+{
+    globalNetworkProxy()->init();
+    if (QGlobalNetworkProxy *globalProxy = globalNetworkProxy())
+        globalProxy->init();
+}
 …
     : d(new QNetworkProxyPrivate(type, hostName, port, user, password))
+{
+    globalNetworkProxy()->init();
+    if (QGlobalNetworkProxy *globalProxy = globalNetworkProxy())
+        globalProxy->init();
+}
 …
     such object, the factory will be queried for sockets created by
     that framework only.
+    \section1 System Proxies
+    You can configure a factory to use the system proxy's settings.
+    Call the setUseSystemConfiguration() function with true to enable
+    this behavior, or false to disable it.
+    Similarly, you can use a factory to make queries directly to the
+    system proxy by calling its systemProxyForQuery() function.
+    \warning Depending on the configuration of the user's system, the
+    use of system proxy features on certain platforms may be subject
+    to limitations. The systemProxyForQuery() documentation contains a
+    list of these limitations for those platforms that are affected.
 */
 …
 /*!
+    \since 4.6
     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
+    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
+    \note See the systemProxyForQuery() documentation for a list of
+    limitations related to the use of system proxies.
 */
 void QNetworkProxyFactory::setUseSystemConfiguration(bool enable)
 …
     listed here.
+    On MacOS X, this function will ignore the Proxy Auto Configuration
+    \list
+    \o On MacOS X, this function will ignore the Proxy Auto Configuration
     settings, since it cannot execute the associated ECMAScript code.
+    \o On Windows platforms, this function may take several seconds to
+    execute depending on the configuration of the user's system.
+    \endlist
 */

trunk/src/network/kernel/qnetworkproxy.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkproxy_generic.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qnetworkproxy_mac.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
+    }
+    if (isHostExcluded(dict, query.peerHostName()))
+    if (isHostExcluded(dict, query.peerHostName())) {
+        CFRelease(dict);
         return result;          // no proxy for this host
+    }
     // is there a PAC enabled? If so, use it first.
 …
+    }
+    CFRelease(dict);
     return result;
+}

trunk/src/network/kernel/qnetworkproxy_win.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qt_windows.h>
 #include <wininet.h>
+#include <private/qsystemlibrary_p.h>
 /*
 …
 #define WINHTTP_NO_PROXY_NAME     NULL
 #define WINHTTP_NO_PROXY_BYPASS   NULL
+#define WINHTTP_ERROR_BASE                      12000
+#define ERROR_WINHTTP_LOGIN_FAILURE             (WINHTTP_ERROR_BASE + 15)
+#define ERROR_WINHTTP_AUTODETECTION_FAILED      (WINHTTP_ERROR_BASE + 180)
 QT_BEGIN_NAMESPACE
 …
 #else
     // load the winhttp.dll library
     HINSTANCE winhttpHnd = LoadLibrary(L"winhttp");
     if (!winhttpHnd)
+    QSystemLibrary lib(L"winhttp");
+    if (!lib.load())
         return;                 // failed to load
     ptrWinHttpOpen = (PtrWinHttpOpen)GetProcAddress(winhttpHnd, "WinHttpOpen");
     ptrWinHttpCloseHandle = (PtrWinHttpCloseHandle)GetProcAddress(winhttpHnd, "WinHttpCloseHandle");
     ptrWinHttpGetProxyForUrl = (PtrWinHttpGetProxyForUrl)GetProcAddress(winhttpHnd, "WinHttpGetProxyForUrl");
     ptrWinHttpGetDefaultProxyConfiguration = (PtrWinHttpGetDefaultProxyConfiguration)GetProcAddress(winhttpHnd, "WinHttpGetDefaultProxyConfiguration");
     ptrWinHttpGetIEProxyConfigForCurrentUser = (PtrWinHttpGetIEProxyConfigForCurrentUser)GetProcAddress(winhttpHnd, "WinHttpGetIEProxyConfigForCurrentUser");
+    ptrWinHttpOpen = (PtrWinHttpOpen)lib.resolve("WinHttpOpen");
+    ptrWinHttpCloseHandle = (PtrWinHttpCloseHandle)lib.resolve("WinHttpCloseHandle");
+    ptrWinHttpGetProxyForUrl = (PtrWinHttpGetProxyForUrl)lib.resolve("WinHttpGetProxyForUrl");
+    ptrWinHttpGetDefaultProxyConfiguration = (PtrWinHttpGetDefaultProxyConfiguration)lib.resolve("WinHttpGetDefaultProxyConfiguration");
+    ptrWinHttpGetIEProxyConfigForCurrentUser = (PtrWinHttpGetIEProxyConfigForCurrentUser)lib.resolve("WinHttpGetIEProxyConfigForCurrentUser");
     // Try to obtain the Internet Explorer configuration.
 …
         isAutoConfig = true;
         memset(&autoProxyOptions, 0, sizeof autoProxyOptions);
         autoProxyOptions.fAutoLogonIfChallenged = true;
+        autoProxyOptions.fAutoLogonIfChallenged = false;
         if (ieProxyConfig.fAutoDetect) {
             autoProxyOptions.dwFlags = WINHTTP_AUTOPROXY_AUTO_DETECT;
 …
             url.setScheme(QLatin1String("https"));
+        }
+        if (ptrWinHttpGetProxyForUrl(sp->hHttpSession,
+                                     (LPCWSTR)url.toString().utf16(),
+                                     &sp->autoProxyOptions,
+                                     &proxyInfo)) {
+        bool getProxySucceeded = ptrWinHttpGetProxyForUrl(sp->hHttpSession,
+                                                (LPCWSTR)url.toString().utf16(),
+                                                &sp->autoProxyOptions,
+                                                &proxyInfo);
+        DWORD getProxyError = GetLastError();
+        if (!getProxySucceeded
+            && (ERROR_WINHTTP_LOGIN_FAILURE == getProxyError)) {
+            // We first tried without AutoLogon, because this might prevent caching the result.
+            // But now we've to enable it (http://msdn.microsoft.com/en-us/library/aa383153%28v=VS.85%29.aspx)
+            sp->autoProxyOptions.fAutoLogonIfChallenged = TRUE;
+            getProxySucceeded = ptrWinHttpGetProxyForUrl(sp->hHttpSession,
+                                               (LPCWSTR)url.toString().utf16(),
+                                                &sp->autoProxyOptions,
+                                                &proxyInfo);
+            getProxyError = GetLastError();
+        }
+        if (getProxySucceeded) {
             // yes, we got a config for this URL
             QString proxyBypass = QString::fromWCharArray(proxyInfo.lpszProxyBypass);
 …
         // GetProxyForUrl failed
+        if (ERROR_WINHTTP_AUTODETECTION_FAILED == getProxyError) {
+            //No config file could be retrieved on the network.
+            //Don't search for it next time again.
+            sp->isAutoConfig = false;
+        }
         return sp->defaultResult;
+    }

trunk/src/network/kernel/qurlinfo.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/kernel/qurlinfo.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/network.pro

-              r561
+              r846
 include(../qbase.pri)
 include(access/access.pri)
+include(bearer/bearer.pri)
 include(kernel/kernel.pri)
 include(socket/socket.pri)
 …
 symbian {
    TARGET.UID3=0x2001B2DE
    LIBS += -lesock -linsock
+   LIBS += -lesock -linsock -lcertstore -lefsrv -lctframework
+}

trunk/src/network/socket/qabstractsocket.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <qabstracteventdispatcher.h>
-#include <qdatetime.h>
 #include <qhostaddress.h>
 #include <qhostinfo.h>
 …
 #include <qpointer.h>
 #include <qtimer.h>
+#include <qelapsedtimer.h>
 #ifndef QT_NO_OPENSSL
 …
+}
+void QAbstractSocketPrivate::pauseSocketNotifiers(QAbstractSocket *socket)
+{
+    QAbstractSocketEngine *socketEngine = socket->d_func()->socketEngine;
+    if (!socketEngine)
+        return;
+    socket->d_func()->prePauseReadSocketNotifierState = socketEngine->isReadNotificationEnabled();
+    socket->d_func()->prePauseWriteSocketNotifierState = socketEngine->isWriteNotificationEnabled();
+    socket->d_func()->prePauseExceptionSocketNotifierState = socketEngine->isExceptionNotificationEnabled();
+    socketEngine->setReadNotificationEnabled(false);
+    socketEngine->setWriteNotificationEnabled(false);
+    socketEngine->setExceptionNotificationEnabled(false);
+}
+void QAbstractSocketPrivate::resumeSocketNotifiers(QAbstractSocket *socket)
+{
+    QAbstractSocketEngine *socketEngine = socket->d_func()->socketEngine;
+    if (!socketEngine)
+        return;
+    socketEngine->setReadNotificationEnabled(socket->d_func()->prePauseReadSocketNotifierState);
+    socketEngine->setWriteNotificationEnabled(socket->d_func()->prePauseWriteSocketNotifierState);
+    socketEngine->setExceptionNotificationEnabled(socket->d_func()->prePauseExceptionSocketNotifierState);
+}
+QAbstractSocketEngine* QAbstractSocketPrivate::getSocketEngine(QAbstractSocket *socket)
+{
+    return socket->d_func()->socketEngine;
+}
 /*! \internal
 …
     } else {
         if (d->threadData->eventDispatcher) {
             // this internal API for QHostInfo either immediatly gives us the desired
+            // this internal API for QHostInfo either immediately gives us the desired
             // QHostInfo from cache or later calls the _q_startConnecting slot.
             bool immediateResultValid = false;
 …
     bool wasPendingClose = d->pendingClose;
     d->pendingClose = false;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
+    }
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
         return false;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
+    }
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();

trunk/src/network/socket/qabstractsocket.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qabstractsocket_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     QAbstractSocket::SocketError socketError;
+    bool prePauseReadSocketNotifierState;
+    bool prePauseWriteSocketNotifierState;
+    bool prePauseExceptionSocketNotifierState;
+    static void pauseSocketNotifiers(QAbstractSocket*);
+    static void resumeSocketNotifiers(QAbstractSocket*);
+    static QAbstractSocketEngine* getSocketEngine(QAbstractSocket*);
 };

trunk/src/network/socket/qabstractsocketengine.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qabstractsocketengine_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qhttpsocketengine.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qtcpsocket.h"
 #include "qhostaddress.h"
-#include "qdatetime.h"
 #include "qurl.h"
 #include "qhttp.h"
+#include "qelapsedtimer.h"
 #if !defined(QT_NO_NETWORKPROXY) && !defined(QT_NO_HTTP)
 …
         return false;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
+    }
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();

trunk/src/network/socket/qhttpsocketengine_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qlocalserver.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qlocalserver.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qlocalserver_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         HANDLE handle;
         OVERLAPPED overlapped;
+        bool connected;
     };

trunk/src/network/socket/qlocalserver_tcp.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qlocalserver_unix.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     //
     // This change can be removed once more generic fix to select thread
     // syncronization problem is implemented.
+    // synchronization problem is implemented.
     int flags = fcntl(listenSocket, F_GETFL, 0);
     if (-1 == flags

trunk/src/network/socket/qlocalserver_win.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
                  (const wchar_t *)fullServerName.utf16(), // pipe name
                  PIPE_ACCESS_DUPLEX | FILE_FLAG_OVERLAPPED,       // read/write access
                  PIPE_TYPE_MESSAGE |       // message type pipe
                  PIPE_READMODE_MESSAGE |   // message-read mode
+                 PIPE_TYPE_BYTE |          // byte type pipe
+                 PIPE_READMODE_BYTE |      // byte-read mode
                  PIPE_WAIT,                // blocking mode
                  PIPE_UNLIMITED_INSTANCES, // max. instances
 …
         switch (GetLastError()) {
         case ERROR_IO_PENDING:
+            listener.connected = false;
             break;
         case ERROR_PIPE_CONNECTED:
+            listener.connected = true;
             SetEvent(eventHandle);
             break;
 …
     for (int i = 0; i < listeners.size(); ) {
         HANDLE handle = listeners[i].handle;
+        if (GetOverlappedResult(handle, &listeners[i].overlapped, &dummy, FALSE)) {
+        if (listeners[i].connected
+            || GetOverlappedResult(handle, &listeners[i].overlapped, &dummy, FALSE))
+        {
             listeners.removeAt(i);

trunk/src/network/socket/qlocalsocket.cpp

r755	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qlocalsocket.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qlocalsocket_p.h

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     void _q_pipeClosed();
     void _q_emitReadyRead();
     DWORD bytesAvailable();
+    DWORD checkPipeState();
     void startAsyncRead();
     bool completeAsyncRead();

trunk/src/network/socket/qlocalsocket_tcp.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qlocalsocket_unix.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <errno.h>
-#include <qdatetime.h>
 #include <qdir.h>
 #include <qdebug.h>
+#include <qelapsedtimer.h>
 #ifdef Q_OS_VXWORKS
 …
     int result = -1;
     // on Linux timeout will be updated by select, but _not_ on other systems.
     QTime timer;
+    QElapsedTimer timer;
     timer.start();
     while (state() == ConnectingState

trunk/src/network/socket/qlocalsocket_win.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     Q_D(QLocalSocket);
+    if (d->pipeClosed && d->actualReadBufferSize == 0)
+        return -1;  // signal EOF
     qint64 readSoFar;
     // If startAsyncRead() read data, copy it to its destination.
 …
     if (d->pipeClosed) {
         if (readSoFar == 0) {
+        if (d->actualReadBufferSize == 0)
             QTimer::singleShot(0, this, SLOT(_q_pipeClosed()));
-            return -1;  // signal EOF
+        }
     } else {
         if (!d->readSequenceStarted)
 …
+{
     do {
+        DWORD bytesToRead = bytesAvailable();
+        DWORD bytesToRead = checkPipeState();
+        if (pipeClosed)
+            return;
         if (bytesToRead == 0) {
             // There are no bytes in the pipe but we need to
 …
                     // This is not an error. We're getting notified, when data arrives.
                     return;
+                case ERROR_MORE_DATA:
+                    // This is not an error. The synchronous read succeeded.
+                    // We're connected to a message mode pipe and the message
+                    // didn't fit into the pipe's system buffer.
+                    completeAsyncRead();
+                    break;
                 case ERROR_PIPE_NOT_CONNECTED:
+                    {
 …
     \internal
     Sets the correct size of the read buffer after a read operation.
     Returns false, if an error occured or the connection dropped.
+    Returns false, if an error occurred or the connection dropped.
  */
 bool QLocalSocketPrivate::completeAsyncRead()
 …
     DWORD bytesRead;
     if (!GetOverlappedResult(handle, &overlapped, &bytesRead, TRUE)) {
+        if (GetLastError() != ERROR_PIPE_NOT_CONNECTED)
+        switch (GetLastError()) {
+        case ERROR_MORE_DATA:
+            // This is not an error. We're connected to a message mode
+            // pipe and the message didn't fit into the pipe's system
+            // buffer. We will read the remaining data in the next call.
+            break;
+        case ERROR_PIPE_NOT_CONNECTED:
+            return false;
+        default:
             setErrorString(QLatin1String("QLocalSocketPrivate::completeAsyncRead"));
+        return false;
+            return false;
+        }
+    }
 …
 /*!
+    The number of bytes available from the pipe
+  */
+DWORD QLocalSocketPrivate::bytesAvailable()
+    \internal
+    Returns the number of available bytes in the pipe.
+    Sets QLocalSocketPrivate::pipeClosed to true if the connection is broken.
+ */
+DWORD QLocalSocketPrivate::checkPipeState()
+{
     Q_Q(QLocalSocket);
 …
             pipeClosed = true;
             emit q->readChannelFinished();
+            QTimer::singleShot(0, q, SLOT(_q_pipeClosed()));
+            if (actualReadBufferSize == 0)
+                QTimer::singleShot(0, q, SLOT(_q_pipeClosed()));
+        }
+    }
 …
         pipeClosed = true;
         emit q->readChannelFinished();
+        if (actualReadBufferSize == 0)
+            QTimer::singleShot(0, q, SLOT(_q_pipeClosed()));
         return;
+    }
 …
     QIncrementalSleepTimer timer(msecs);
     forever {
         d->bytesAvailable();    // to check if PeekNamedPipe fails
+        d->checkPipeState();
         if (d->pipeClosed)
             close();
 …
         return false;
+    // We already know that the pipe is gone, but did not enter the event loop yet.
+    if (d->pipeClosed) {
+        close();
+        return false;
+    }
     Q_ASSERT(d->readSequenceStarted);
     DWORD result = WaitForSingleObject(d->overlapped.hEvent, msecs == -1 ? INFINITE : msecs);
 …
         case WAIT_OBJECT_0:
             d->_q_notified();
+            // We just noticed that the pipe is gone.
+            if (d->pipeClosed) {
+                close();
+                return false;
+            }
             return true;
         case WAIT_TIMEOUT:

trunk/src/network/socket/qnativesocketengine.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         // one exception: SocketError(11) bypasses this as it's purely
         // a temporary internal error condition.
+        // Another exception is the way the waitFor*() functions set
+        // an error when a timeout occurs. After the call to setError()
+        // they reset the hasSetSocketError to false
         return;
+    }
 …
         d->setError(QAbstractSocket::SocketTimeoutError,
             QNativeSocketEnginePrivate::TimeOutErrorString);
+        d->hasSetSocketError = false; // A timeout error is temporary in waitFor functions
         return false;
     } else if (state() == QAbstractSocket::ConnectingState) {
 …
         d->setError(QAbstractSocket::SocketTimeoutError,
                     QNativeSocketEnginePrivate::TimeOutErrorString);
+        d->hasSetSocketError = false; // A timeout error is temporary in waitFor functions
         return false;
     } else if (state() == QAbstractSocket::ConnectingState) {
 …
         d->setError(QAbstractSocket::SocketTimeoutError,
                     QNativeSocketEnginePrivate::TimeOutErrorString);
+        d->hasSetSocketError = false; // A timeout error is temporary in waitFor functions
         return false;
     } else if (state() == QAbstractSocket::ConnectingState) {

trunk/src/network/socket/qnativesocketengine_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qnativesocketengine_unix.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qiodevice.h"
 #include "qhostaddress.h"
+#include "qelapsedtimer.h"
 #include "qvarlengtharray.h"
-#include "qdatetime.h"
 #include <time.h>
 #include <errno.h>
 …
+    }
-    // Ensure that the socket is closed on exec*().
-    ::fcntl(socket, F_SETFD, FD_CLOEXEC);
     socketDescriptor = socket;
     return true;
 …
         sockAddrIPv6.sin6_family = AF_INET6;
         sockAddrIPv6.sin6_port = htons(port);
+        QString scopeid = addr.scopeId();
+        bool ok;
+        sockAddrIPv6.sin6_scope_id = scopeid.toInt(&ok);
 #ifndef QT_NO_IPV6IFNAME
+        sockAddrIPv6.sin6_scope_id = ::if_nametoindex(addr.scopeId().toLatin1().data());
+#else
+        sockAddrIPv6.sin6_scope_id = addr.scopeId().toInt();
+        if (!ok)
+            sockAddrIPv6.sin6_scope_id = ::if_nametoindex(scopeid.toLatin1());
 #endif
         Q_IPV6ADDR ip6 = addr.toIPv6Address();
 …
         case EFAULT:
         case ENOTSOCK:
+#ifdef Q_OS_SYMBIAN
+        case EPIPE:
+#endif
             socketState = QAbstractSocket::UnconnectedState;
         default:
 …
 #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
 …
     ret = qt_safe_select(socketDescriptor + 1, &fdread, &fdwrite, 0, timeout < 0 ? 0 : &tv);
 #else
     QTime timer;
+    QElapsedTimer timer;
     timer.start();

trunk/src/network/socket/qnativesocketengine_win.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
         memset(sockAddrIPv6, 0, sizeof(qt_sockaddr_in6));
         sockAddrIPv6->sin6_family = AF_INET6;
+        sockAddrIPv6->sin6_scope_id = address.scopeId().toInt();
         WSAHtons(socketDescriptor, port, &(sockAddrIPv6->sin6_port));
         Q_IPV6ADDR tmp = address.toIPv6Address();
 …
     int acceptedDescriptor = WSAAccept(socketDescriptor, 0,0,0,0);
         if (acceptedDescriptor != -1 && QAbstractEventDispatcher::instance()) {
                 // Becuase of WSAAsyncSelect() WSAAccept returns a non blocking socket
+                // Because of WSAAsyncSelect() WSAAccept returns a non blocking socket
                 // with the same attributes as the listening socket including the current
                 // WSAAsyncSelect(). To be able to change the socket to blocking mode the

trunk/src/network/socket/qnet_unix_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qsocks5socketengine.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qhash.h"
 #include "qqueue.h"
 #include "qdatetime.h"
+#include "qelapsedtimer.h"
 #include "qmutex.h"
 #include "qthread.h"
 …
     QHostAddress peerAddress;
     quint16 peerPort;
     QDateTime timeStamp;
+    QElapsedTimer timeStamp;
 };
 …
         // qDebug() << "delete it";
+    }
     bindData->timeStamp = QDateTime::currentDateTime();
+    bindData->timeStamp.start();
     store.insert(socketDescriptor, bindData);
     // start sweep timer if not started
 …
         while (it.hasNext()) {
             it.next();
             if (it.value()->timeStamp.secsTo(QDateTime::currentDateTime()) > 350) {
+            if (it.value()->timeStamp.hasExpired(350000)) {
                 QSOCKS5_DEBUG << "QSocks5BindStore removing JJJJ";
                 it.remove();
 …
     int msecs = SOCKS5_BLOCKING_BIND_TIMEOUT;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
     d->data->controlSocket->connectToHost(d->proxyInfo.hostName(), d->proxyInfo.port());
 …
         if (d->data->controlSocket->state() == QAbstractSocket::ConnectedState) {
             int msecs = 100;
             QTime stopWatch;
+            QElapsedTimer stopWatch;
             stopWatch.start();
             while (!d->data->controlSocket->bytesToWrite()) {
 …
         UdpAssociateSuccess;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
     d->readNotificationActivated = false;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
     QSOCKS5_DEBUG << "waitForWrite" << msecs;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();

trunk/src/network/socket/qsocks5socketengine_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qtcpserver.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     use its setSocketDescriptor() method.
     \sa newConnection(), nextPendingConnection()
+    \sa newConnection(), nextPendingConnection(), addPendingConnection()
 */
 void QTcpServer::incomingConnection(int socketDescriptor)
 …
     QTcpSocket *socket = new QTcpSocket(this);
     socket->setSocketDescriptor(socketDescriptor);
+    addPendingConnection(socket);
+}
+/*!
+    This function is called by QTcpServer::incomingConnection()
+    to add the \a socket to the list of pending incoming connections.
+    \note Don't forget to call this member from reimplemented
+    incomingConnection() if you do not want to break the
+    Pending Connections mechanism.
+    \sa incomingConnection()
+    \since 4.7
+*/
+void QTcpServer::addPendingConnection(QTcpSocket* socket)
+{
     d_func()->pendingConnections.append(socket);
+}

trunk/src/network/socket/qtcpserver.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 protected:
     virtual void incomingConnection(int handle);
+    void addPendingConnection(QTcpSocket* socket);
 Q_SIGNALS:

trunk/src/network/socket/qtcpsocket.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qtcpsocket.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qtcpsocket_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qudpsocket.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/socket/qudpsocket.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qssl.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qssl.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslcertificate.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 /*!
     Returns the certificate's serial number string in decimal format.
+    In case the serial number cannot be converted to decimal format
+    (i.e. if it is bigger than 4294967295, which means it does not fit into 4 bytes),
+    its hexadecimal version is returned.
 */
 QByteArray QSslCertificate::serialNumber() const
+{
+    if (d->serialNumberString.isEmpty() && d->x509)
+        d->serialNumberString =
+            QByteArray::number(qlonglong(q_ASN1_INTEGER_get(d->x509->cert_info->serialNumber)));
+    if (d->serialNumberString.isEmpty() && d->x509) {
+        ASN1_INTEGER *serialNumber = d->x509->cert_info->serialNumber;
+        // if we cannot convert to a long, just output the hexadecimal number
+        if (serialNumber->length > 4) {
+            QByteArray hexString;
+            hexString.reserve(serialNumber->length * 3);
+            for (int a = 0; a < serialNumber->length; ++a) {
+                hexString += QByteArray::number(serialNumber->data[a], 16).rightJustified(2, '0');
+                hexString += ':';
+            }
+            hexString.chop(1);
+            d->serialNumberString = hexString;
+        } else {
+            d->serialNumberString = QByteArray::number(qlonglong(q_ASN1_INTEGER_get(serialNumber)));
+        }
+    }
     return d->serialNumberString;
+}
 …
     int startIndex = 0;
     if (pathPrefix.trimmed().isEmpty()) {
+        startIndex = 2;
+        pathPrefix = QLatin1String(".");
+        if(path.startsWith(QLatin1Char('/'))) {
+            pathPrefix = path.left(path.indexOf(QRegExp(QLatin1String("[\\*\\?\\[]"))));
+            pathPrefix = path.left(path.lastIndexOf(QLatin1Char('/')));
+        } else {
+            startIndex = 2;
+            pathPrefix = QLatin1String(".");
+        }
+    }
 …
 static bool matchLineFeed(const QByteArray &pem, int *offset)
+{
     char ch;
+    char ch = 0;
     // ignore extra whitespace at the end of the line

trunk/src/network/ssl/qsslcertificate.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslcertificate_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslcipher.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslcipher.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslcipher_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslconfiguration.cpp

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
   Returns this connection's CA certificate database. The CA certificate
   database is used by the socket during the handshake phase to
+  validate the peer's certificate. It can be moodified prior to the
+  handshake with addCaCertificate(), addCaCertificates(), and
+  setCaCertificates().
+  validate the peer's certificate. It can be modified prior to the
+  handshake with setCaCertificates(), or with \l{QSslSocket}'s
+  \l{QSslSocket::}{addCaCertificate()} and
+  \l{QSslSocket::}{addCaCertificates()}.
   \sa setCaCertificates()

trunk/src/network/ssl/qsslconfiguration.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslconfiguration_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslerror.cpp

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslerror.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslkey.cpp

r769	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslkey.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslkey_p.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslsocket.cpp

-              r769
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     signal. This mode is the default for clients.
     \value AutoVerifyPeer QSslSocket will automaticaly use QueryPeer for
+    \value AutoVerifyPeer QSslSocket will automatically use QueryPeer for
     server sockets and VerifyPeer for client sockets.
 …
 #include <QtCore/qdebug.h>
 #include <QtCore/qdir.h>
-#include <QtCore/qdatetime.h>
 #include <QtCore/qmutex.h>
+#include <QtCore/qelapsedtimer.h>
 #include <QtNetwork/qhostaddress.h>
 #include <QtNetwork/qhostinfo.h>
 …
     The default mode is AutoVerifyPeer, which tells QSslSocket to use
     VerifyPeer for clients, QueryPeer for clients.
+    VerifyPeer for clients and QueryPeer for servers.
     \sa setPeerVerifyMode(), peerVerifyDepth(), mode()
 …
     The default mode is AutoVerifyPeer, which tells QSslSocket to use
     VerifyPeer for clients, QueryPeer for clients.
+    VerifyPeer for clients and QueryPeer for servers.
     Setting this mode after encryption has started has no effect on the
 …
     Returns the current default CA certificate database. This database
     is originally set to your system's default CA certificate database.
     If no system default database is found, Qt will provide its own
     default database. You can override the default CA certificate database
+    If no system default database is found, an empty database will be
+    returned. You can override the default CA certificate database
     with your own CA certificate database using setDefaultCaCertificates().
 …
 /*!
     This function provides a default CA certificate database
     shipped together with Qt. The CA certificate database
+    This function provides the CA certificate database
+    provided by the operating system. The CA certificate database
     returned by this function is used to initialize the database
     returned by defaultCaCertificates(). You can replace that database
 …
 QList<QSslCertificate> QSslSocket::systemCaCertificates()
+{
     QSslSocketPrivate::ensureInitialized();
+    // we are calling ensureInitialized() in the method below
     return QSslSocketPrivate::systemCaCertificates();
+}
 …
         return false;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
     d->readyReadEmittedPointer = &readyReadEmitted;
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
         return d->plainSocket->waitForBytesWritten(msecs);
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
         return d->plainSocket->waitForDisconnected(msecs);
     QTime stopWatch;
+    QElapsedTimer stopWatch;
     stopWatch.start();
 …
 bool QSslSocket::supportsSsl()
+{
     return QSslSocketPrivate::ensureInitialized();
+    return QSslSocketPrivate::supportsSsl();
+}
 …
     QMutexLocker locker(&globalData()->mutex);
     const QSslConfigurationPrivate *global = globalData()->config.constData();
+    if (!global) {
+        ptr = 0;
+        return;
+    }
     ptr->ref = 1;
 …
+}
+void QSslSocketPrivate::pauseSocketNotifiers(QSslSocket *socket)
+{
+    if (!socket->d_func()->plainSocket)
+        return;
+    QAbstractSocketPrivate::pauseSocketNotifiers(socket->d_func()->plainSocket);
+}
+void QSslSocketPrivate::resumeSocketNotifiers(QSslSocket *socket)
+{
+    if (!socket->d_func()->plainSocket)
+        return;
+    QAbstractSocketPrivate::resumeSocketNotifiers(socket->d_func()->plainSocket);
+}
 /*!
     \internal

trunk/src/network/ssl/qsslsocket.h

r651	r846
1	1	/****************************************************************************
2	2	**
3		** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
	3	** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
4	4	** All rights reserved.
5	5	** Contact: Nokia Corporation (qt-info@nokia.com)

trunk/src/network/ssl/qsslsocket_openssl.cpp

-              r788
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include <QtCore/qdir.h>
 #include <QtCore/qdiriterator.h>
+#include <QtCore/qelapsedtimer.h>
 #include <QtCore/qfile.h>
 #include <QtCore/qfileinfo.h>
 …
 #include <QtCore/qurl.h>
 #include <QtCore/qvarlengtharray.h>
+static void initNetworkResources()
+{
+    // Initialize resources
+    Q_INIT_RESOURCE(network);
+}
+#include <QLibrary> // for loading the security lib for the CA store
 QT_BEGIN_NAMESPACE
+// Useful defines
+#define SSL_ERRORSTR() QString::fromLocal8Bit(q_ERR_error_string(q_ERR_get_error(), NULL))
+#if defined(Q_OS_MAC)
+#define kSecTrustSettingsDomainSystem 2 // so we do not need to include the header file
+    PtrSecCertificateGetData QSslSocketPrivate::ptrSecCertificateGetData = 0;
+    PtrSecTrustSettingsCopyCertificates QSslSocketPrivate::ptrSecTrustSettingsCopyCertificates = 0;
+    PtrSecTrustCopyAnchorCertificates QSslSocketPrivate::ptrSecTrustCopyAnchorCertificates = 0;
+#elif defined(Q_OS_WIN)
+    PtrCertOpenSystemStoreW QSslSocketPrivate::ptrCertOpenSystemStoreW = 0;
+    PtrCertFindCertificateInStore QSslSocketPrivate::ptrCertFindCertificateInStore = 0;
+    PtrCertCloseStore QSslSocketPrivate::ptrCertCloseStore = 0;
+#elif defined(Q_OS_SYMBIAN)
+#include <e32base.h>
+#include <e32std.h>
+#include <e32debug.h>
+#include <QtCore/private/qcore_symbian_p.h>
+#endif
+bool QSslSocketPrivate::s_libraryLoaded = false;
+bool QSslSocketPrivate::s_loadedCiphersAndCerts = false;
 /* \internal
 …
 static unsigned long id_function()
+{
     return (unsigned long)QThread::currentThreadId();
+    return (quintptr)QThread::currentThreadId();
+}
 } // extern "C"
 …
     : ssl(0),
       ctx(0),
+      pkey(0),
       readBio(0),
       writeBio(0),
 …
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Error creating SSL context (%1)").arg(SSL_ERRORSTR()));
+        q->setErrorString(QSslSocket::tr("Error creating SSL context (%1)").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
 …
     if (!q_SSL_CTX_set_cipher_list(ctx, cipherString.data())) {
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Invalid or empty cipher list (%1)").arg(SSL_ERRORSTR()));
+        q->setErrorString(QSslSocket::tr("Invalid or empty cipher list (%1)").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
 …
     // Add all our CAs to this store.
+    foreach (const QSslCertificate &caCertificate, q->caCertificates())
+    QList<QSslCertificate> expiredCerts;
+    foreach (const QSslCertificate &caCertificate, q->caCertificates()) {
+        // add expired certs later, so that the
+        // valid ones are used before the expired ones
+        if (! caCertificate.isValid()) {
+            expiredCerts.append(caCertificate);
+        } else {
+            q_X509_STORE_add_cert(ctx->cert_store, (X509 *)caCertificate.handle());
+        }
+    }
+    // now add the expired certs
+    foreach (const QSslCertificate &caCertificate, expiredCerts) {
         q_X509_STORE_add_cert(ctx->cert_store, (X509 *)caCertificate.handle());
+    }
     // Register a custom callback to get all verification errors.
 …
         // Require a private key as well.
         if (configuration.privateKey.isNull()) {
             q->setErrorString(QSslSocket::tr("Cannot provide a certificate with no key, %1").arg(SSL_ERRORSTR()));
+            q->setErrorString(QSslSocket::tr("Cannot provide a certificate with no key, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
 …
         // Load certificate
         if (!q_SSL_CTX_use_certificate(ctx, (X509 *)configuration.localCertificate.handle())) {
             q->setErrorString(QSslSocket::tr("Error loading local certificate, %1").arg(SSL_ERRORSTR()));
+            q->setErrorString(QSslSocket::tr("Error loading local certificate, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
 …
         // Load private key
+        EVP_PKEY *pkey = q_EVP_PKEY_new();
+        pkey = q_EVP_PKEY_new();
+        // before we were using EVP_PKEY_assign_R* functions and did not use EVP_PKEY_free.
+        // this lead to a memory leak. Now we use the *_set1_* functions which do not
+        // take ownership of the RSA/DSA key instance because the QSslKey already has ownership.
         if (configuration.privateKey.algorithm() == QSsl::Rsa)
             q_EVP_PKEY_assign_RSA(pkey, (RSA *)configuration.privateKey.handle());
+            q_EVP_PKEY_set1_RSA(pkey, (RSA *)configuration.privateKey.handle());
         else
             q_EVP_PKEY_assign_DSA(pkey, (DSA *)configuration.privateKey.handle());
+            q_EVP_PKEY_set1_DSA(pkey, (DSA *)configuration.privateKey.handle());
         if (!q_SSL_CTX_use_PrivateKey(ctx, pkey)) {
             q->setErrorString(QSslSocket::tr("Error loading private key, %1").arg(SSL_ERRORSTR()));
+            q->setErrorString(QSslSocket::tr("Error loading private key, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
 …
         // Check if the certificate matches the private key.
         if (!q_SSL_CTX_check_private_key(ctx)) {
             q->setErrorString(QSslSocket::tr("Private key does not certify public key, %1").arg(SSL_ERRORSTR()));
+            q->setErrorString(QSslSocket::tr("Private key does not certify public key, %1").arg(getErrorsFromOpenSsl()));
             emit q->error(QAbstractSocket::UnknownSocketError);
             return false;
 …
     if (!(ssl = q_SSL_new(ctx))) {
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Error creating SSL session, %1").arg(SSL_ERRORSTR()));
+        q->setErrorString(QSslSocket::tr("Error creating SSL session, %1").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
 …
     if (!readBio || !writeBio) {
         // ### Bad error code
         q->setErrorString(QSslSocket::tr("Error creating SSL session: %1").arg(SSL_ERRORSTR()));
+        q->setErrorString(QSslSocket::tr("Error creating SSL session: %1").arg(getErrorsFromOpenSsl()));
         q->setSocketError(QAbstractSocket::UnknownSocketError);
         emit q->error(QAbstractSocket::UnknownSocketError);
 …
     \internal
     Declared static in QSslSocketPrivate, makes sure the SSL libraries have
     been initialized.
+    Does the minimum amount of initialization to determine whether SSL
+    is supported or not.
 */
+bool QSslSocketPrivate::ensureInitialized()
+bool QSslSocketPrivate::supportsSsl()
+{
+    return ensureLibraryLoaded();
+}
+bool QSslSocketPrivate::ensureLibraryLoaded()
+{
     if (!q_resolveOpenSslSymbols())
 …
     // Check if the library itself needs to be initialized.
     QMutexLocker locker(openssl_locks()->initLock());
+    static int q_initialized = false;
+    if (!q_initialized) {
+        q_initialized = true;
+        // Initialize resources
+        initNetworkResources();
+    if (!s_libraryLoaded) {
+        s_libraryLoaded = true;
         // Initialize OpenSSL.
 …
                 return false;
+        }
-        resetDefaultCiphers();
-        setDefaultCaCertificates(systemCaCertificates());
+    }
     return true;
+}
+void QSslSocketPrivate::ensureCiphersAndCertsLoaded()
+{
+    QMutexLocker locker(openssl_locks()->initLock());
+    if (s_loadedCiphersAndCerts)
+        return;
+    s_loadedCiphersAndCerts = true;
+    resetDefaultCiphers();
+    //load symbols needed to receive certificates from system store
+#if defined(Q_OS_MAC)
+    QLibrary securityLib("/System/Library/Frameworks/Security.framework/Versions/Current/Security");
+    if (securityLib.load()) {
+        ptrSecCertificateGetData = (PtrSecCertificateGetData) securityLib.resolve("SecCertificateGetData");
+        if (!ptrSecCertificateGetData)
+            qWarning("could not resolve symbols in security library"); // should never happen
+        ptrSecTrustSettingsCopyCertificates = (PtrSecTrustSettingsCopyCertificates) securityLib.resolve("SecTrustSettingsCopyCertificates");
+        if (!ptrSecTrustSettingsCopyCertificates) { // method was introduced in Leopard, use legacy method if it's not there
+            ptrSecTrustCopyAnchorCertificates = (PtrSecTrustCopyAnchorCertificates) securityLib.resolve("SecTrustCopyAnchorCertificates");
+            if (!ptrSecTrustCopyAnchorCertificates)
+                qWarning("could not resolve symbols in security library"); // should never happen
+        }
+    } else {
+        qWarning("could not load security library");
+    }
+#elif defined(Q_OS_WIN)
+    HINSTANCE hLib = LoadLibraryW(L"Crypt32");
+    if (hLib) {
+#if defined(Q_OS_WINCE)
+        ptrCertOpenSystemStoreW = (PtrCertOpenSystemStoreW)GetProcAddress(hLib, L"CertOpenStore");
+        ptrCertFindCertificateInStore = (PtrCertFindCertificateInStore)GetProcAddress(hLib, L"CertFindCertificateInStore");
+        ptrCertCloseStore = (PtrCertCloseStore)GetProcAddress(hLib, L"CertCloseStore");
+#else
+        ptrCertOpenSystemStoreW = (PtrCertOpenSystemStoreW)GetProcAddress(hLib, "CertOpenSystemStoreW");
+        ptrCertFindCertificateInStore = (PtrCertFindCertificateInStore)GetProcAddress(hLib, "CertFindCertificateInStore");
+        ptrCertCloseStore = (PtrCertCloseStore)GetProcAddress(hLib, "CertCloseStore");
+#endif
+        if (!ptrCertOpenSystemStoreW || !ptrCertFindCertificateInStore || !ptrCertCloseStore)
+            qWarning("could not resolve symbols in crypt32 library"); // should never happen
+    } else {
+        qWarning("could not load crypt32 library"); // should never happen
+    }
+#endif
+    setDefaultCaCertificates(systemCaCertificates());
+}
+/*!
+    \internal
+    Declared static in QSslSocketPrivate, makes sure the SSL libraries have
+    been initialized.
+*/
+void QSslSocketPrivate::ensureInitialized()
+{
+    if (!supportsSsl())
+        return;
+    ensureCiphersAndCertsLoaded();
+}
 …
+}
+#if defined(Q_OS_SYMBIAN)
+CSymbianCertificateRetriever::CSymbianCertificateRetriever() : CActive(CActive::EPriorityStandard),
+    iCertificatePtr(0,0,0), iSequenceError(KErrNone)
+{
+}
+CSymbianCertificateRetriever::~CSymbianCertificateRetriever()
+{
+    iThread.Close();
+}
+CSymbianCertificateRetriever* CSymbianCertificateRetriever::NewL()
+{
+    CSymbianCertificateRetriever* self = new (ELeave) CSymbianCertificateRetriever();
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop();
+    return self;
+}
+int CSymbianCertificateRetriever::GetCertificates(QList<QByteArray> &certificates)
+{
+    iCertificates = &certificates;
+    TRequestStatus status;
+    iThread.Logon(status);
+    iThread.Resume();
+    User::WaitForRequest(status);
+    if (iThread.ExitType() == EExitKill)
+        return KErrDied;
+    else
+        return status.Int();    // Logon() completes with the thread's exit value
+}
+void CSymbianCertificateRetriever::doThreadEntryL()
+{
+    CActiveScheduler* activeScheduler = new (ELeave) CActiveScheduler;
+    CleanupStack::PushL(activeScheduler);
+    CActiveScheduler::Install(activeScheduler);
+    CActiveScheduler::Add(this);
+    // These aren't deleted in the destructor so leaving the to CS is ok
+    iCertStore = CUnifiedCertStore::NewLC(qt_s60GetRFs(), EFalse);
+    iCertFilter = CCertAttributeFilter::NewLC();
+    // only interested in CA certs
+    iCertFilter->SetOwnerType(ECACertificate);
+    // only interested in X.509 format (we don't support WAP formats)
+    iCertFilter->SetFormat(EX509Certificate);
+    // Kick off the sequence by initializing the cert store
+    iState = Initializing;
+    iCertStore->Initialize(iStatus);
+    SetActive();
+    CActiveScheduler::Start();
+    // Sequence complete, clean up
+    // These MUST be cleaned up before the installed CActiveScheduler is destroyed and can't be left to the
+    // destructor of CSymbianCertificateRetriever. Otherwise the destructor of CActiveScheduler will get
+    // stuck.
+    iCertInfos.Close();
+    CleanupStack::PopAndDestroy(3);     // activeScheduler, iCertStore, iCertFilter
+}
+TInt CSymbianCertificateRetriever::ThreadEntryPoint(TAny* aParams)
+{
+    User::SetCritical(User::EProcessCritical);
+    CTrapCleanup* cleanupStack = CTrapCleanup::New();
+    CSymbianCertificateRetriever* self = (CSymbianCertificateRetriever*) aParams;
+    TRAPD(err, self->doThreadEntryL());
+    delete cleanupStack;
+    // doThreadEntryL() can leave only before the retrieval sequence is started
+    if (err)
+        return err;
+    else
+        return self->iSequenceError;    // return any error that occurred during the retrieval
+}
+void CSymbianCertificateRetriever::ConstructL()
+{
+    TInt err;
+    int i=0;
+    QString name(QLatin1String("CertWorkerThread-%1"));
+    //recently closed thread names remain in use for a while until all handles have been closed
+    //including users of RUndertaker
+    do {
+        err = iThread.Create(qt_QString2TPtrC(name.arg(i++)),
+            CSymbianCertificateRetriever::ThreadEntryPoint, 16384, NULL, this);
+    } while (err == KErrAlreadyExists);
+    User::LeaveIfError(err);
+}
+void CSymbianCertificateRetriever::DoCancel()
+{
+    switch(iState) {
+    case Initializing:
+        iCertStore->CancelInitialize();
+        break;
+    case Listing:
+        iCertStore->CancelList();
+        break;
+    case RetrievingCertificates:
+        iCertStore->CancelGetCert();
+        break;
+    }
+}
+TInt CSymbianCertificateRetriever::RunError(TInt aError)
+{
+    // If something goes wrong in the sequence, abort the sequence
+    iSequenceError = aError;    // this gets reported to the client in the TRequestStatus
+    CActiveScheduler::Stop();
+    return KErrNone;
+}
+void CSymbianCertificateRetriever::GetCertificateL()
+{
+    if (iCurrentCertIndex < iCertInfos.Count()) {
+        CCTCertInfo* certInfo = iCertInfos[iCurrentCertIndex++];
+        iCertificateData = QByteArray();
+        QT_TRYCATCH_LEAVING(iCertificateData.resize(certInfo->Size()));
+        iCertificatePtr.Set((TUint8*)iCertificateData.data(), 0, iCertificateData.size());
+#ifdef QSSLSOCKET_DEBUG
+        qDebug() << "getting " << qt_TDesC2QString(certInfo->Label()) << " size=" << certInfo->Size();
+        qDebug() << "format=" << certInfo->CertificateFormat();
+        qDebug() << "ownertype=" << certInfo->CertificateOwnerType();
+        qDebug() << "type=" << hex << certInfo->Type().iUid;
+#endif
+        iCertStore->Retrieve(*certInfo, iCertificatePtr, iStatus);
+        iState = RetrievingCertificates;
+        SetActive();
+    } else {
+        //reached end of list
+        CActiveScheduler::Stop();
+    }
+}
+void CSymbianCertificateRetriever::RunL()
+{
+#ifdef QSSLSOCKET_DEBUG
+    qDebug() << "CSymbianCertificateRetriever::RunL status " << iStatus.Int() << " count " << iCertInfos.Count() << " index " << iCurrentCertIndex;
+#endif
+    switch (iState) {
+    case Initializing:
+        User::LeaveIfError(iStatus.Int()); // initialise fail means pointless to continue
+        iState = Listing;
+        iCertStore->List(iCertInfos, *iCertFilter, iStatus);
+        SetActive();
+        break;
+    case Listing:
+        User::LeaveIfError(iStatus.Int()); // listing fail means pointless to continue
+        iCurrentCertIndex = 0;
+        GetCertificateL();
+        break;
+    case RetrievingCertificates:
+        if (iStatus.Int() == KErrNone)
+            iCertificates->append(iCertificateData);
+        else
+            qWarning() << "CSymbianCertificateRetriever: failed to retrieve a certificate, error " << iStatus.Int();
+        GetCertificateL();
+        break;
+    }
+}
+#endif // defined(Q_OS_SYMBIAN)
 QList<QSslCertificate> QSslSocketPrivate::systemCaCertificates()
+{
+    // Qt provides a default bundle of certificates
+    QFile caBundle(QLatin1String(":/trolltech/network/ssl/qt-ca-bundle.crt"));
+    if (caBundle.open(QIODevice::ReadOnly | QIODevice::Text))
+        return QSslCertificate::fromDevice(&caBundle);
+    // Unreachable; return no bundle.
+    return QList<QSslCertificate>();
+    ensureInitialized();
+#ifdef QSSLSOCKET_DEBUG
+    QElapsedTimer timer;
+    timer.start();
+#endif
+    QList<QSslCertificate> systemCerts;
+#if defined(Q_OS_MAC)
+    CFArrayRef cfCerts;
+    OSStatus status = 1;
+    OSStatus SecCertificateGetData (
+       SecCertificateRef certificate,
+       CSSM_DATA_PTR data
+    );
+    if (ptrSecCertificateGetData) {
+        if (ptrSecTrustSettingsCopyCertificates)
+            status = ptrSecTrustSettingsCopyCertificates(kSecTrustSettingsDomainSystem, &cfCerts);
+        else if (ptrSecTrustCopyAnchorCertificates)
+            status = ptrSecTrustCopyAnchorCertificates(&cfCerts);
+        if (!status) {
+            CFIndex size = CFArrayGetCount(cfCerts);
+            for (CFIndex i = 0; i < size; ++i) {
+                SecCertificateRef cfCert = (SecCertificateRef)CFArrayGetValueAtIndex(cfCerts, i);
+                CSSM_DATA data;
+                CSSM_DATA_PTR dataPtr = &data;
+                if (ptrSecCertificateGetData(cfCert, dataPtr)) {
+                    qWarning("error retrieving a CA certificate from the system store");
+                } else {
+                    int len = data.Length;
+                    char *rawData = reinterpret_cast<char *>(data.Data);
+                    QByteArray rawCert(rawData, len);
+                    systemCerts.append(QSslCertificate::fromData(rawCert, QSsl::Der));
+                }
+            }
+        }
+        else {
+           // no detailed error handling here
+           qWarning("could not retrieve system CA certificates");
+        }
+    }
+#elif defined(Q_OS_WIN)
+    if (ptrCertOpenSystemStoreW && ptrCertFindCertificateInStore && ptrCertCloseStore) {
+        HCERTSTORE hSystemStore;
+#if defined(Q_OS_WINCE)
+        hSystemStore = ptrCertOpenSystemStoreW(CERT_STORE_PROV_SYSTEM_W,
+,
+,
+                                               CERT_STORE_NO_CRYPT_RELEASE_FLAG|CERT_SYSTEM_STORE_CURRENT_USER,
+                                               L"ROOT");
+#else
+        hSystemStore = ptrCertOpenSystemStoreW(0, L"ROOT");
+#endif
+        if(hSystemStore) {
+            PCCERT_CONTEXT pc = NULL;
+            while(1) {
+                pc = ptrCertFindCertificateInStore( hSystemStore, X509_ASN_ENCODING, 0, CERT_FIND_ANY, NULL, pc);
+                if(!pc)
+                    break;
+                QByteArray der((const char *)(pc->pbCertEncoded), static_cast<int>(pc->cbCertEncoded));
+                QSslCertificate cert(der, QSsl::Der);
+                systemCerts.append(cert);
+            }
+            ptrCertCloseStore(hSystemStore, 0);
+        }
+    }
+#elif defined(Q_OS_UNIX) && !defined(Q_OS_SYMBIAN)
+    QSet<QString> certFiles;
+    QList<QByteArray> directories;
+    directories << "/etc/ssl/certs/"; // (K)ubuntu, OpenSUSE, Mandriva, MeeGo ...
+    directories << "/usr/lib/ssl/certs/"; // Gentoo, Mandrake
+    directories << "/usr/share/ssl/"; // Centos, Redhat, SuSE
+    directories << "/usr/local/ssl/"; // Normal OpenSSL Tarball
+    directories << "/var/ssl/certs/"; // AIX
+    directories << "/usr/local/ssl/certs/"; // Solaris
+    directories << "/opt/openssl/certs/"; // HP-UX
+    QDir currentDir;
+    QStringList nameFilters;
+    nameFilters << QLatin1String("*.pem") << QLatin1String("*.crt");
+    currentDir.setNameFilters(nameFilters);
+    for (int a = 0; a < directories.count(); a++) {
+        currentDir.setPath(QLatin1String(directories.at(a)));
+        QDirIterator it(currentDir);
+        while(it.hasNext()) {
+            it.next();
+            // use canonical path here to not load the same certificate twice if symlinked
+            certFiles.insert(it.fileInfo().canonicalFilePath());
+        }
+    }
+    QSetIterator<QString> it(certFiles);
+    while(it.hasNext()) {
+        systemCerts.append(QSslCertificate::fromPath(it.next()));
+    }
+    systemCerts.append(QSslCertificate::fromPath(QLatin1String("/etc/pki/tls/certs/ca-bundle.crt"), QSsl::Pem)); // Fedora, Mandriva
+    systemCerts.append(QSslCertificate::fromPath(QLatin1String("/usr/local/share/certs/ca-root-nss.crt"), QSsl::Pem)); // FreeBSD's ca_root_nss
+#elif defined(Q_OS_SYMBIAN)
+    QList<QByteArray> certs;
+    QScopedPointer<CSymbianCertificateRetriever> retriever(CSymbianCertificateRetriever::NewL());
+    retriever->GetCertificates(certs);
+    foreach (const QByteArray &encodedCert, certs) {
+        QSslCertificate cert(encodedCert, QSsl::Der);
+        if (!cert.isNull()) {
+#ifdef QSSLSOCKET_DEBUG
+            qDebug() << "imported certificate: " << cert.issuerInfo(QSslCertificate::CommonName);
+#endif
+            systemCerts.append(cert);
+        }
+    }
+#endif
+#ifdef QSSLSOCKET_DEBUG
+    qDebug() << "systemCaCertificates retrieval time " << timer.elapsed() << "ms";
+    qDebug() << "imported " << systemCerts.count() << " certificates";
+#endif
+    return systemCerts;
+}
 …
                 if (writtenBytes <= 0) {
                     // ### Better error handling.
                     q->setErrorString(QSslSocket::tr("Unable to write data: %1").arg(SSL_ERRORSTR()));
+                    q->setErrorString(QSslSocket::tr("Unable to write data: %1").arg(getErrorsFromOpenSsl()));
                     q->setSocketError(QAbstractSocket::UnknownSocketError);
                     emit q->error(QAbstractSocket::UnknownSocketError);
 …
                 } else {
                     // ### Better error handling.
                     q->setErrorString(QSslSocket::tr("Unable to decrypt data: %1").arg(SSL_ERRORSTR()));
+                    q->setErrorString(QSslSocket::tr("Unable to decrypt data: %1").arg(getErrorsFromOpenSsl()));
                     q->setSocketError(QAbstractSocket::UnknownSocketError);
                     emit q->error(QAbstractSocket::UnknownSocketError);
 …
                 plainSocket->disconnectFromHost();
                 break;
+            case SSL_ERROR_SYSCALL: // some IO error
+            case SSL_ERROR_SSL: // error in the SSL library
+                // we do not know exactly what the error is, nor whether we can recover from it,
+                // so just return to prevent an endless loop in the outer "while" statement
+                q->setErrorString(QSslSocket::tr("Error while reading: %1").arg(getErrorsFromOpenSsl()));
+                q->setSocketError(QAbstractSocket::UnknownSocketError);
+                emit q->error(QAbstractSocket::UnknownSocketError);
+                return;
             default:
+                // ### Handle errors better.
+                q->setErrorString(QSslSocket::tr("Error while reading: %1").arg(SSL_ERRORSTR()));
+                // SSL_ERROR_WANT_CONNECT, SSL_ERROR_WANT_ACCEPT: can only happen with a
+                // BIO_s_connect() or BIO_s_accept(), which we do not call.
+                // SSL_ERROR_WANT_X509_LOOKUP: can only happen with a
+                // SSL_CTX_set_client_cert_cb(), which we do not call.
+                // So this default case should never be triggered.
+                q->setErrorString(QSslSocket::tr("Error while reading: %1").arg(getErrorsFromOpenSsl()));
                 q->setSocketError(QAbstractSocket::UnknownSocketError);
                 emit q->error(QAbstractSocket::UnknownSocketError);
 …
             break;
         default:
+            // ### Handle errors better
+            q->setErrorString(QSslSocket::tr("Error during SSL handshake: %1").arg(SSL_ERRORSTR()));
+            q->setErrorString(QSslSocket::tr("Error during SSL handshake: %1").arg(getErrorsFromOpenSsl()));
             q->setSocketError(QAbstractSocket::SslHandshakeFailedError);
 #ifdef QSSLSOCKET_DEBUG
 …
             QString commonName = configuration.peerCertificate.subjectInfo(QSslCertificate::CommonName);
+            QRegExp regexp(commonName, Qt::CaseInsensitive, QRegExp::Wildcard);
+            if (!regexp.exactMatch(peerName)) {
+            if (!isMatchingHostname(commonName.toLower(), peerName.toLower())) {
                 bool matched = false;
                 foreach (const QString &altName, configuration.peerCertificate
                          .alternateSubjectNames().values(QSsl::DnsEntry)) {
+                    regexp.setPattern(altName);
+                    if (regexp.exactMatch(peerName)) {
+                    if (isMatchingHostname(altName.toLower(), peerName.toLower())) {
                         matched = true;
                         break;
+                    }
+                }
                 if (!matched) {
                     // No matches in common names or alternate names.
 …
         ctx = 0;
+    }
+    if (pkey) {
+        q_EVP_PKEY_free(pkey);
+        pkey = 0;
+    }
+}
 …
+}
+QString QSslSocketBackendPrivate::getErrorsFromOpenSsl()
+{
+    QString errorString;
+    unsigned long errNum;
+    while((errNum = q_ERR_get_error())) {
+        if (! errorString.isEmpty())
+            errorString.append(QLatin1String(", "));
+        const char *error = q_ERR_error_string(errNum, NULL);
+        errorString.append(QString::fromAscii(error)); // error is ascii according to man ERR_error_string
+    }
+    return errorString;
+}
+bool QSslSocketBackendPrivate::isMatchingHostname(const QString &cn, const QString &hostname)
+{
+    int wildcard = cn.indexOf(QLatin1Char('*'));
+    // Check this is a wildcard cert, if not then just compare the strings
+    if (wildcard < 0)
+        return cn == hostname;
+    int firstCnDot = cn.indexOf(QLatin1Char('.'));
+    int secondCnDot = cn.indexOf(QLatin1Char('.'), firstCnDot+1);
+    // Check at least 3 components
+    if ((-1 == secondCnDot) || (secondCnDot+1 >= cn.length()))
+        return false;
+    // Check * is last character of 1st component (ie. there's a following .)
+    if (wildcard+1 != firstCnDot)
+        return false;
+    // Check only one star
+    if (cn.lastIndexOf(QLatin1Char('*')) != wildcard)
+        return false;
+    // Check characters preceding * (if any) match
+    if (wildcard && (hostname.leftRef(wildcard) != cn.leftRef(wildcard)))
+        return false;
+    // Check characters following first . match
+    if (hostname.midRef(hostname.indexOf(QLatin1Char('.'))) != cn.midRef(firstCnDot))
+        return false;
+    // Check if the hostname is an IP address, if so then wildcards are not allowed
+    QHostAddress addr(hostname);
+    if (!addr.isNull())
+        return false;
+    // Ok, I guess this was a wildcard CN and the hostname matches.
+    return true;
+}
 QT_END_NAMESPACE

trunk/src/network/ssl/qsslsocket_openssl_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
     SSL *ssl;
     SSL_CTX *ctx;
+    EVP_PKEY *pkey;
     BIO *readBio;
     BIO *writeBio;
 …
     static QSslCipher QSslCipher_from_SSL_CIPHER(SSL_CIPHER *cipher);
     static QList<QSslCertificate> STACKOFX509_to_QSslCertificates(STACK_OF(X509) *x509);
+    Q_AUTOTEST_EXPORT static bool isMatchingHostname(const QString &cn, const QString &hostname);
+    static QString getErrorsFromOpenSsl();
 };
+#if defined(Q_OS_SYMBIAN)
+#include <QByteArray>
+#include <e32base.h>
+#include <f32file.h>
+#include <unifiedcertstore.h>     // link against certstore.lib
+#include <ccertattributefilter.h> // link against ctframework.lib
+// The purpose of this class is to wrap the asynchronous API of Symbian certificate store to one
+// synchronizable call. The user of this class needs to provide a TRequestStatus object which can
+// be used with User::WaitForRequest() unlike with the calls of the certificate store API.
+// A thread is used instead of a CActiveSchedulerWait scheme, because that would make the call
+// asynchronous (other events might be processed during the call even though the call would be seemingly
+// synchronous).
+class CSymbianCertificateRetriever : public CActive
+{
+public:
+    static CSymbianCertificateRetriever* NewL();
+    ~CSymbianCertificateRetriever();
+    int GetCertificates(QList<QByteArray> &aCertificates);
+private:
+    void ConstructL();
+    CSymbianCertificateRetriever();
+    static TInt ThreadEntryPoint(TAny* aParams);
+    void doThreadEntryL();
+    void GetCertificateL();
+    void DoCancel();
+    void RunL();
+    TInt RunError(TInt aError);
+private:
+    enum {
+        Initializing,
+        Listing,
+        RetrievingCertificates
+    } iState;
+    RThread iThread;
+    CUnifiedCertStore* iCertStore;
+    RMPointerArray<CCTCertInfo> iCertInfos;
+    CCertAttributeFilter* iCertFilter;
+    TInt iCurrentCertIndex;
+    QByteArray iCertificateData;
+    TPtr8 iCertificatePtr;
+    QList<QByteArray>* iCertificates;
+    TInt iSequenceError;
+};
+#endif
 QT_END_NAMESPACE

trunk/src/network/ssl/qsslsocket_openssl_symbols.cpp

-              r788
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 #include "qsslsocket_openssl_symbols_p.h"
+#include <QtCore/qlibrary.h>
+#ifdef Q_OS_WIN
+# include <private/qsystemlibrary_p.h>
+#else
+# include <QtCore/qlibrary.h>
+#endif
 #include <QtCore/qmutex.h>
 #include <private/qmutexpool_p.h>
 …
 DEFINEFUNC(const EVP_CIPHER *, EVP_des_ede3_cbc, DUMMYARG, DUMMYARG, return 0, return)
 DEFINEFUNC3(int, EVP_PKEY_assign, EVP_PKEY *a, a, int b, b, char *c, c, return -1, return)
+DEFINEFUNC2(int, EVP_PKEY_set1_RSA, EVP_PKEY *a, a, RSA *b, b, return -1, return)
+DEFINEFUNC2(int, EVP_PKEY_set1_DSA, EVP_PKEY *a, a, DSA *b, b, return -1, return)
 DEFINEFUNC(void, EVP_PKEY_free, EVP_PKEY *a, a, return, DUMMYARG)
 DEFINEFUNC(DSA *, EVP_PKEY_get1_DSA, EVP_PKEY *a, a, return 0, return)
 …
             .split(QLatin1Char(':'), QString::SkipEmptyParts);
 #  endif
     paths << QLatin1String("/usr/lib") << QLatin1String("/usr/local/lib");
+    paths << QLatin1String("/lib") << QLatin1String("/usr/lib") << QLatin1String("/usr/local/lib");
     QStringList foundSsls;
 …
+}
 # endif
+#ifdef Q_OS_WIN
+static QPair<QSystemLibrary*, QSystemLibrary*> loadOpenSslWin32()
+{
+    QPair<QSystemLibrary*,QSystemLibrary*> pair;
+    pair.first = 0;
+    pair.second = 0;
+    QSystemLibrary *ssleay32 = new QSystemLibrary(QLatin1String("ssleay32"));
+    if (!ssleay32->load(false)) {
+        // Cannot find ssleay32.dll
+        delete ssleay32;
+        return pair;
+    }
+    QSystemLibrary *libeay32 = new QSystemLibrary(QLatin1String("libeay32"));
+    if (!libeay32->load(false)) {
+        delete ssleay32;
+        delete libeay32;
+        return pair;
+    }
+    pair.first = ssleay32;
+    pair.second = libeay32;
+    return pair;
+}
+#else
 static QPair<QLibrary*, QLibrary*> loadOpenSsl()
 …
     pair.second = 0;
+# ifdef Q_OS_WIN
+    QLibrary *ssleay32 = new QLibrary(QLatin1String("ssleay32"));
+    if (!ssleay32->load()) {
+        // Cannot find ssleay32.dll
+        delete ssleay32;
+        return pair;
+    }
+    QLibrary *libeay32 = new QLibrary(QLatin1String("libeay32"));
+    if (!libeay32->load()) {
+        delete ssleay32;
+        delete libeay32;
+        return pair;
+    }
+    pair.first = ssleay32;
+    pair.second = libeay32;
+    return pair;
+# elif defined(Q_OS_SYMBIAN)
+# if defined(Q_OS_SYMBIAN)
      QLibrary *libssl = new QLibrary(QLatin1String("libssl"));
     if (!libssl->load()) {
 …
 # endif
+}
+#endif
 bool q_resolveOpenSslSymbols()
 …
     triedToResolveSymbols = true;
+#ifdef Q_OS_WIN
+    QPair<QSystemLibrary *, QSystemLibrary *> libs = loadOpenSslWin32();
+#else
     QPair<QLibrary *, QLibrary *> libs = loadOpenSsl();
+#endif
     if (!libs.first || !libs.second)
         // failed to load them
 …
     RESOLVEFUNC(EVP_des_ede3_cbc, 919, libs.second )
     RESOLVEFUNC(EVP_PKEY_assign, 859, libs.second )
+    RESOLVEFUNC(EVP_PKEY_set1_RSA, 880, libs.second )
+    RESOLVEFUNC(EVP_PKEY_set1_DSA, 879, libs.second )
     RESOLVEFUNC(EVP_PKEY_free, 867, libs.second )
     RESOLVEFUNC(EVP_PKEY_get1_DSA, 869, libs.second )
 …
     RESOLVEFUNC(EVP_des_ede3_cbc)
     RESOLVEFUNC(EVP_PKEY_assign)
+    RESOLVEFUNC(EVP_PKEY_set1_RSA)
+    RESOLVEFUNC(EVP_PKEY_set1_DSA)
     RESOLVEFUNC(EVP_PKEY_free)
     RESOLVEFUNC(EVP_PKEY_get1_DSA)
 …
 QDateTime q_getTimeFromASN1(const ASN1_TIME *aTime)
+{
-    char lBuffer[24];
-    char *pBuffer = lBuffer;
     size_t lTimeLength = aTime->length;
     char *pString = (char *) aTime->data;
     if (aTime->type == V_ASN1_UTCTIME) {
+        char lBuffer[24];
+        char *pBuffer = lBuffer;
         if ((lTimeLength < 11) || (lTimeLength > 17))
             return QDateTime();
 …
         pBuffer += 10;
         pString += 10;
+        if ((*pString == 'Z') || (*pString == '-') || (*pString == '+')) {
+            *pBuffer++ = '0';
+            *pBuffer++ = '0';
+        } else {
+            *pBuffer++ = *pString++;
+            *pBuffer++ = *pString++;
+            // Skip any fractional seconds...
+            if (*pString == '.') {
+                pString++;
+                while ((*pString >= '0') && (*pString <= '9'))
+                    pString++;
+            }
+        }
+        *pBuffer++ = 'Z';
+        *pBuffer++ = '\0';
+        time_t lSecondsFromUCT;
+        if (*pString == 'Z') {
+            lSecondsFromUCT = 0;
+        } else {
+            if ((*pString != '+') && (*pString != '-'))
+                return QDateTime();
+            lSecondsFromUCT = ((pString[1] - '0') * 10 + (pString[2] - '0')) * 60;
+            lSecondsFromUCT += (pString[3] - '0') * 10 + (pString[4] - '0');
+            lSecondsFromUCT *= 60;
+            if (*pString == '-')
+                lSecondsFromUCT = -lSecondsFromUCT;
+        }
+        tm lTime;
+        lTime.tm_sec = ((lBuffer[10] - '0') * 10) + (lBuffer[11] - '0');
+        lTime.tm_min = ((lBuffer[8] - '0') * 10) + (lBuffer[9] - '0');
+        lTime.tm_hour = ((lBuffer[6] - '0') * 10) + (lBuffer[7] - '0');
+        lTime.tm_mday = ((lBuffer[4] - '0') * 10) + (lBuffer[5] - '0');
+        lTime.tm_mon = (((lBuffer[2] - '0') * 10) + (lBuffer[3] - '0')) - 1;
+        lTime.tm_year = ((lBuffer[0] - '0') * 10) + (lBuffer[1] - '0');
+        if (lTime.tm_year < 50)
+            lTime.tm_year += 100; // RFC 2459
+        QDate resDate(lTime.tm_year + 1900, lTime.tm_mon + 1, lTime.tm_mday);
+        QTime resTime(lTime.tm_hour, lTime.tm_min, lTime.tm_sec);
+        QDateTime result(resDate, resTime, Qt::UTC);
+        result = result.addSecs(lSecondsFromUCT);
+        return result;
+    } else if (aTime->type == V_ASN1_GENERALIZEDTIME) {
+        if (lTimeLength < 15)
+            return QDateTime(); // hopefully never triggered
+        // generalized time is always YYYYMMDDHHMMSSZ (RFC 2459, section 4.1.2.5.2)
+        tm lTime;
+        lTime.tm_sec = ((pString[12] - '0') * 10) + (pString[13] - '0');
+        lTime.tm_min = ((pString[10] - '0') * 10) + (pString[11] - '0');
+        lTime.tm_hour = ((pString[8] - '0') * 10) + (pString[9] - '0');
+        lTime.tm_mday = ((pString[6] - '0') * 10) + (pString[7] - '0');
+        lTime.tm_mon = (((pString[4] - '0') * 10) + (pString[5] - '0'));
+        lTime.tm_year = ((pString[0] - '0') * 1000) + ((pString[1] - '0') * 100) +
+                        ((pString[2] - '0') * 10) + (pString[3] - '0');
+        QDate resDate(lTime.tm_year, lTime.tm_mon, lTime.tm_mday);
+        QTime resTime(lTime.tm_hour, lTime.tm_min, lTime.tm_sec);
+        QDateTime result(resDate, resTime, Qt::UTC);
+        return result;
     } else {
+        if (lTimeLength < 13)
+            return QDateTime();
+        memcpy(pBuffer, pString, 12);
+        pBuffer += 12;
+        pString += 12;
+    }
+    if ((*pString == 'Z') || (*pString == '-') || (*pString == '+')) {
+        *pBuffer++ = '0';
+        *pBuffer++ = '0';
+    } else {
+        *pBuffer++ = *pString++;
+        *pBuffer++ = *pString++;
+        // Skip any fractional seconds...
+        if (*pString == '.') {
+            pString++;
+            while ((*pString >= '0') && (*pString <= '9'))
+                pString++;
+        }
+    }
+    *pBuffer++ = 'Z';
+    *pBuffer++ = '\0';
+    time_t lSecondsFromUCT;
+    if (*pString == 'Z') {
+        lSecondsFromUCT = 0;
+    } else {
+        if ((*pString != '+') && (*pString != '-'))
+            return QDateTime();
+        lSecondsFromUCT = ((pString[1] - '0') * 10 + (pString[2] - '0')) * 60;
+        lSecondsFromUCT += (pString[3] - '0') * 10 + (pString[4] - '0');
+        lSecondsFromUCT *= 60;
+        if (*pString == '-')
+            lSecondsFromUCT = -lSecondsFromUCT;
+    }
+    tm lTime;
+    lTime.tm_sec = ((lBuffer[10] - '0') * 10) + (lBuffer[11] - '0');
+    lTime.tm_min = ((lBuffer[8] - '0') * 10) + (lBuffer[9] - '0');
+    lTime.tm_hour = ((lBuffer[6] - '0') * 10) + (lBuffer[7] - '0');
+    lTime.tm_mday = ((lBuffer[4] - '0') * 10) + (lBuffer[5] - '0');
+    lTime.tm_mon = (((lBuffer[2] - '0') * 10) + (lBuffer[3] - '0')) - 1;
+    lTime.tm_year = ((lBuffer[0] - '0') * 10) + (lBuffer[1] - '0');
+    if (lTime.tm_year < 50)
+        lTime.tm_year += 100; // RFC 2459
+    QDate resDate(lTime.tm_year + 1900, lTime.tm_mon + 1, lTime.tm_mday);
+    QTime resTime(lTime.tm_hour, lTime.tm_min, lTime.tm_sec);
+    QDateTime result(resDate, resTime, Qt::UTC);
+    result = result.addSecs(lSecondsFromUCT);
+    return result;
+        qWarning("unsupported date format detected");
+        return QDateTime();
+    }
+}

trunk/src/network/ssl/qsslsocket_openssl_symbols_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 const EVP_CIPHER *q_EVP_des_ede3_cbc();
 int q_EVP_PKEY_assign(EVP_PKEY *a, int b, char *c);
+int q_EVP_PKEY_set1_RSA(EVP_PKEY *a, RSA *b);
+int q_EVP_PKEY_set1_DSA(EVP_PKEY *a, DSA *b);
 void q_EVP_PKEY_free(EVP_PKEY *a);
 RSA *q_EVP_PKEY_get1_RSA(EVP_PKEY *a);

trunk/src/network/ssl/qsslsocket_p.h

-              r651
+              r846
 /****************************************************************************
 **
 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation (qt-info@nokia.com)
 …
 QT_BEGIN_NAMESPACE
+#if defined(Q_OS_MAC)
+#include <Security/SecCertificate.h>
+#include <CoreFoundation/CFArray.h>
+    typedef OSStatus (*PtrSecCertificateGetData)(SecCertificateRef, CSSM_DATA_PTR);
+    typedef OSStatus (*PtrSecTrustSettingsCopyCertificates)(int, CFArrayRef*);
+    typedef OSStatus (*PtrSecTrustCopyAnchorCertificates)(CFArrayRef*);
+#elif defined(Q_OS_WIN)
+#include <wincrypt.h>
+#ifndef HCRYPTPROV_LEGACY
+#define HCRYPTPROV_LEGACY HCRYPTPROV
+#endif
+#if defined(Q_OS_WINCE)
+    typedef HCERTSTORE (WINAPI *PtrCertOpenSystemStoreW)(LPCSTR, DWORD, HCRYPTPROV_LEGACY, DWORD, const void*);
+#else
+    typedef HCERTSTORE (WINAPI *PtrCertOpenSystemStoreW)(HCRYPTPROV_LEGACY, LPCWSTR);
+#endif
+    typedef PCCERT_CONTEXT (WINAPI *PtrCertFindCertificateInStore)(HCERTSTORE, DWORD, DWORD, DWORD, const void*, PCCERT_CONTEXT);
+    typedef BOOL (WINAPI *PtrCertCloseStore)(HCERTSTORE, DWORD);
+#endif
 class QSslSocketPrivate : public QTcpSocketPrivate
+{
 …
     QString verificationPeerName;
+    static bool ensureInitialized();
+    static bool supportsSsl();
+    static void ensureInitialized();
     static void deinitialize();
     static QList<QSslCipher> defaultCiphers();
 …
     static void addDefaultCaCertificates(const QList<QSslCertificate> &certs);
+#if defined(Q_OS_MAC)
+    static PtrSecCertificateGetData ptrSecCertificateGetData;
+    static PtrSecTrustSettingsCopyCertificates ptrSecTrustSettingsCopyCertificates;
+    static PtrSecTrustCopyAnchorCertificates ptrSecTrustCopyAnchorCertificates;
+#elif defined(Q_OS_WIN)
+    static PtrCertOpenSystemStoreW ptrCertOpenSystemStoreW;
+    static PtrCertFindCertificateInStore ptrCertFindCertificateInStore;
+    static PtrCertCloseStore ptrCertCloseStore;
+#endif
     // The socket itself, including private slots.
     QTcpSocket *plainSocket;
     void createPlainSocket(QIODevice::OpenMode openMode);
+    static void pauseSocketNotifiers(QSslSocket*);
+    static void resumeSocketNotifiers(QSslSocket*);
     void _q_connectedSlot();
     void _q_hostFoundSlot();
 …
     virtual void disconnected() = 0;
     virtual QSslCipher sessionCipher() const = 0;
+private:
+    static bool ensureLibraryLoaded();
+    static void ensureCiphersAndCertsLoaded();
+    static bool s_libraryLoaded;
+    static bool s_loadedCiphersAndCerts;
 };

trunk/src/network/ssl/ssl.pri

-              r788
+              r846
                ssl/qsslsocket_openssl_symbols.cpp
-    # Include Qt's default CA bundle
-    RESOURCES += network.qrc
     # Add optional SSL libs
     LIBS_PRIVATE += $$OPENSSL_LIBS

/branches/vendor/nokia/qt/4.7.2 (added)	merged: 845
/branches/vendor/nokia/qt/current	merged: 844
/branches/vendor/nokia/qt/4.6.3	removed

Context Navigation

Legend:

Download in other formats: