Changeset 769 for trunk/src/network

Timestamp:

Aug 2, 2010, 9:27:30 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.3 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/network/access/qfilenetworkreply.cpp (modified) (9 diffs)
• src/network/access/qfilenetworkreply_p.h (modified) (2 diffs)
• src/network/access/qftp.cpp (modified) (1 diff)
• src/network/access/qhttpnetworkconnection.cpp (modified) (11 diffs)
• src/network/access/qhttpnetworkconnection_p.h (modified) (2 diffs)
• src/network/access/qhttpnetworkconnectionchannel.cpp (modified) (26 diffs)
• src/network/access/qhttpnetworkconnectionchannel_p.h (modified) (5 diffs)
• src/network/access/qhttpnetworkheader.cpp (modified) (1 diff)
• src/network/access/qhttpnetworkreply.cpp (modified) (9 diffs)
• src/network/access/qhttpnetworkreply_p.h (modified) (3 diffs)
• src/network/access/qnetworkaccessbackend.cpp (modified) (1 diff)
• src/network/access/qnetworkaccesshttpbackend.cpp (modified) (3 diffs)
• src/network/access/qnetworkaccesshttpbackend_p.h (modified) (1 diff)
• src/network/access/qnetworkaccessmanager.cpp (modified) (4 diffs)
• src/network/access/qnetworkcookie.h (modified) (1 diff)
• src/network/access/qnetworkcookiejar.h (modified) (1 diff)
• src/network/access/qnetworkdiskcache.cpp (modified) (2 diffs)
• src/network/access/qnetworkdiskcache_p.h (modified) (2 diffs)
• src/network/access/qnetworkreplyimpl.cpp (modified) (5 diffs)
• src/network/access/qnetworkreplyimpl_p.h (modified) (1 diff)
• src/network/access/qnetworkrequest.cpp (modified) (2 diffs)
• src/network/kernel/qauthenticator.cpp (modified) (2 diffs)
• src/network/kernel/qhostinfo.cpp (modified) (8 diffs)
• src/network/kernel/qhostinfo_p.h (modified) (4 diffs)
• src/network/kernel/qhostinfo_unix.cpp (modified) (1 diff)
• src/network/kernel/qhostinfo_win.cpp (modified) (1 diff)
• src/network/kernel/qnetworkinterface.cpp (modified) (2 diffs)
• src/network/socket/qabstractsocket.cpp (modified) (8 diffs)
• src/network/socket/qlocalserver.cpp (modified) (2 diffs)
• src/network/socket/qlocalserver_win.cpp (modified) (1 diff)
• src/network/socket/qlocalsocket_p.h (modified) (1 diff)
• src/network/socket/qlocalsocket_tcp.cpp (modified) (3 diffs)
• src/network/socket/qlocalsocket_unix.cpp (modified) (4 diffs)
• src/network/socket/qlocalsocket_win.cpp (modified) (5 diffs)
• src/network/socket/qnativesocketengine.cpp (modified) (1 diff)
• src/network/socket/qnativesocketengine_unix.cpp (modified) (6 diffs)
• src/network/socket/qnativesocketengine_win.cpp (modified) (1 diff)
• src/network/socket/qtcpserver.cpp (modified) (3 diffs)
• src/network/socket/qtcpsocket.cpp (modified) (1 diff)
• src/network/socket/qudpsocket.cpp (modified) (1 diff)
• src/network/ssl/qsslcertificate.cpp (modified) (1 diff)
• src/network/ssl/qsslkey.cpp (modified) (1 diff)
• src/network/ssl/qsslsocket.cpp (modified) (2 diffs)
• src/network/ssl/qsslsocket_openssl.cpp (modified) (1 diff)
• src/network/ssl/qsslsocket_openssl_symbols.cpp (modified) (1 diff)

trunk/src/network/access/qfilenetworkreply.cpp

@@ -50 +50 @@
 
 QFileNetworkReplyPrivate::QFileNetworkReplyPrivate()
-    : QNetworkReplyPrivate(), realFileSize(0)
-{
+    : QNetworkReplyPrivate(), fileEngine(0), fileSize(0), filePos(0)
+{
+}
+
+QFileNetworkReplyPrivate::~QFileNetworkReplyPrivate()
+{
+    delete fileEngine;
 }
 
@@ -95 +100 @@
         fileName = url.toString(QUrl::RemoveAuthority | QUrl::RemoveFragment | QUrl::RemoveQuery);
     }
-    d->realFile.setFileName(fileName);
-
-    QFileInfo fi(d->realFile);
+
+    QFileInfo fi(fileName);
     if (fi.isDir()) {
         QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Cannot open %1: Path is a directory").arg(url.toString());
@@ -107 +111 @@
     }
 
-    bool opened = d->realFile.open(QIODevice::ReadOnly | QIODevice::Unbuffered);
+    d->fileEngine = QAbstractFileEngine::create(fileName);
+    bool opened = d->fileEngine->open(QIODevice::ReadOnly | QIODevice::Unbuffered);
 
     // could we open the file?
     if (!opened) {
         QString msg = QCoreApplication::translate("QNetworkAccessFileBackend", "Error opening %1: %2")
-                      .arg(d->realFile.fileName(), d->realFile.errorString());
-
-        if (d->realFile.exists()) {
+                      .arg(errorString());
+
+        if (.exists()) {
             setError(QNetworkReply::ContentAccessDenied, msg);
             QMetaObject::invokeMethod(this, "error", Qt::QueuedConnection,
@@ -127 +132 @@
     }
 
-    d->realFileSize = fi.size();
+    d->ileSize = fi.size();
     setHeader(QNetworkRequest::LastModifiedHeader, fi.lastModified());
-    setHeader(QNetworkRequest::ContentLengthHeader, d->realFileSize);
+    setHeader(QNetworkRequest::ContentLengthHeader, d->ileSize);
 
     QMetaObject::invokeMethod(this, "metaDataChanged", Qt::QueuedConnection);
     QMetaObject::invokeMethod(this, "downloadProgress", Qt::QueuedConnection,
-        Q_ARG(qint64, d->realFileSize), Q_ARG(qint64, d->realFileSize));
+        Q_ARG(qint64, d->ileSize));
     QMetaObject::invokeMethod(this, "readyRead", Qt::QueuedConnection);
     QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
@@ -147 +152 @@
     Q_D(QFileNetworkReply);
     QNetworkReply::close();
-    d->realFile.close();
+    if (d->fileEngine)
+        d->fileEngine->close();
 }
 
@@ -154 +160 @@
     Q_D(QFileNetworkReply);
     QNetworkReply::close();
-    d->realFile.close();
+    if (d->fileEngine)
+        d->fileEngine->close();
 }
 
@@ -160 +167 @@
 {
     Q_D(const QFileNetworkReply);
-    return QNetworkReply::bytesAvailable() + d->realFile.bytesAvailable();
+    if (!d->fileEngine)
+        return 0;
+
+    return QNetworkReply::bytesAvailable() + d->fileSize - d->filePos;
 }
 
@@ -171 +181 @@
 {
     Q_D(const QFileNetworkReply);
-    return d->realFileSize;
+    return d->ileSize;
 }
 
@@ -180 +190 @@
 {
     Q_D(QFileNetworkReply);
-    qint64 ret = d->realFile.read(data, maxlen);
-    if (ret == 0 && bytesAvailable() == 0)
+    if (!d->fileEngine)
+        return -1;
+
+    qint64 ret = d->fileEngine->read(data, maxlen);
+    if (ret == 0 && bytesAvailable() == 0) {
         return -1; // everything had been read
-    else
-        return ret;
+    } else if (ret > 0) {
+        d->filePos += ret;
+    }
+
+    return ret;
 }
 

trunk/src/network/access/qfilenetworkreply_p.h

@@ -58 +58 @@
 #include "qnetworkaccessmanager.h"
 #include <QFile>
+
 
 QT_BEGIN_NAMESPACE
@@ -86 +87 @@
 public:
     QFileNetworkReplyPrivate();
+
 
-    QFile realFile;
-    qint64 realFileSize;
+    QAbstractFileEngine *fileEngine;
+    qint64 fileSize;
+    qint64 filePos;
 
     virtual bool isFinished() const;

trunk/src/network/access/qftp.cpp

@@ -2310 +2310 @@
 {
     Q_Q(QFtp);
+
+
+
+
+
+
     QFtpCommand *c = pending.first();
 

trunk/src/network/access/qhttpnetworkconnection.cpp

@@ -72 +72 @@
 #endif
 
-// the maximum amount of requests that might be pipelined into a socket
-// from what was suggested, 3 seems to be OK
+// The pipeline length. So there will be 4 requests in flight.
 const int QHttpNetworkConnectionPrivate::defaultPipelineLength = 3;
+
+
+
 
 
@@ -405 +407 @@
     reply->setRequest(request);
     reply->d_func()->connection = q;
+
     HttpMessagePair pair = qMakePair(request, reply);
 
@@ -416 +419 @@
         break;
     }
+
     // this used to be called via invokeMethod and a QueuedConnection
+
+
+
+
+
+
+
     _q_startNextRequest();
+
+
     return reply;
 }
@@ -423 +436 @@
 void QHttpNetworkConnectionPrivate::requeueRequest(const HttpMessagePair &pair)
 {
+
+
     QHttpNetworkRequest request = pair.first;
     switch (request.priority()) {
@@ -433 +448 @@
         break;
     }
-    // this used to be called via invokeMethod and a QueuedConnection
-    _q_startNextRequest();
+
+    );
 }
 
@@ -475 +490 @@
     int i = indexOf(socket);
 
-    bool highPriorityQueueProcessingDone = false;
-    bool lowPriorityQueueProcessingDone = false;
-
-    while (!highPriorityQueueProcessingDone && !lowPriorityQueueProcessingDone) {
-        // this loop runs once per request we intend to pipeline in.
-
-        if (channels[i].pipeliningSupported != QHttpNetworkConnectionChannel::PipeliningProbablySupported)
-            return;
-
-        // the current request that is in must already support pipelining
-        if (!channels[i].request.isPipeliningAllowed())
-            return;
-
-        // the current request must be a idempotent (right now we only check GET)
-        if (channels[i].request.operation() != QHttpNetworkRequest::Get)
-            return;
-
-        // check if socket is connected
-        if (socket->state() != QAbstractSocket::ConnectedState)
-            return;
-
-        // check for resendCurrent
-        if (channels[i].resendCurrent)
-            return;
-
-        // we do not like authentication stuff
-        // ### make sure to be OK with this in later releases
-        if (!channels[i].authenticator.isNull() || !channels[i].authenticator.user().isEmpty())
-            return;
-        if (!channels[i].proxyAuthenticator.isNull() || !channels[i].proxyAuthenticator.user().isEmpty())
-            return;
-
-        // check for pipeline length
+    // return fast if there was no reply right now processed
+    if (channels[i].reply == 0)
+        return;
+
+    if (! (defaultPipelineLength - channels[i].alreadyPipelinedRequests.length() >= defaultRePipelineLength)) {
+        return;
+    }
+
+    if (channels[i].pipeliningSupported != QHttpNetworkConnectionChannel::PipeliningProbablySupported)
+        return;
+
+    // the current request that is in must already support pipelining
+    if (!channels[i].request.isPipeliningAllowed())
+        return;
+
+    // the current request must be a idempotent (right now we only check GET)
+    if (channels[i].request.operation() != QHttpNetworkRequest::Get)
+        return;
+
+    // check if socket is connected
+    if (socket->state() != QAbstractSocket::ConnectedState)
+        return;
+
+    // check for resendCurrent
+    if (channels[i].resendCurrent)
+        return;
+
+    // we do not like authentication stuff
+    // ### make sure to be OK with this in later releases
+    if (!channels[i].authenticator.isNull() || !channels[i].authenticator.user().isEmpty())
+        return;
+    if (!channels[i].proxyAuthenticator.isNull() || !channels[i].proxyAuthenticator.user().isEmpty())
+        return;
+
+    // must be in ReadingState or WaitingState
+    if (! (channels[i].state == QHttpNetworkConnectionChannel::WaitingState
+           || channels[i].state == QHttpNetworkConnectionChannel::ReadingState))
+        return;
+
+
+    //qDebug() << "QHttpNetworkConnectionPrivate::fillPipeline processing highPriorityQueue, size=" << highPriorityQueue.size() << " alreadyPipelined=" << channels[i].alreadyPipelinedRequests.length();
+    int lengthBefore;
+    while (!highPriorityQueue.isEmpty()) {
+        lengthBefore = channels[i].alreadyPipelinedRequests.length();
+        fillPipeline(highPriorityQueue, channels[i]);
+
         if (channels[i].alreadyPipelinedRequests.length() >= defaultPipelineLength)
             return;
 
-        // must be in ReadingState or WaitingState
-        if (! (channels[i].state == QHttpNetworkConnectionChannel::WaitingState
-               || channels[i].state == QHttpNetworkConnectionChannel::ReadingState))
+        if (lengthBefore == channels[i].alreadyPipelinedRequests.length())
+            break; // did not process anything, now do the low prio queue
+    }
+
+    //qDebug() << "QHttpNetworkConnectionPrivate::fillPipeline processing lowPriorityQueue, size=" << lowPriorityQueue.size() << " alreadyPipelined=" << channels[i].alreadyPipelinedRequests.length();
+    while (!lowPriorityQueue.isEmpty()) {
+        lengthBefore = channels[i].alreadyPipelinedRequests.length();
+        fillPipeline(lowPriorityQueue, channels[i]);
+
+        if (channels[i].alreadyPipelinedRequests.length() >= defaultPipelineLength)
             return;
 
-        highPriorityQueueProcessingDone = fillPipeline(highPriorityQueue, channels[i]);
-        // not finished with highPriorityQueue? then loop again
-        if (!highPriorityQueueProcessingDone)
-            continue;
-        // highPriorityQueue was processed, now deal with the lowPriorityQueue
-        lowPriorityQueueProcessingDone = fillPipeline(lowPriorityQueue, channels[i]);
-    }
+        if (lengthBefore == channels[i].alreadyPipelinedRequests.length())
+            break; // did not process anything
+    }
+
+
 }
 
@@ -682 +715 @@
 
 
+
+
+
 void QHttpNetworkConnectionPrivate::_q_startNextRequest()
 {
@@ -689 +725 @@
             channels[i].resendCurrent = false;
             channels[i].state = QHttpNetworkConnectionChannel::IdleState;
-            if (channels[i].reply)
-                channels[i].sendRequest();
+
+            // if this is not possible, error will be emitted and connection terminated
+            if (!channels[i].resetUploadData())
+                continue;
+            channels[i].sendRequest();
         }
     }
@@ -696 +735 @@
     // dequeue new ones
 
-    QAbstractSocket *socket = 0;
+    // return fast if there is nothing to do
+    if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
+        return;
+    // try to get a free AND connected socket
     for (int i = 0; i < channelCount; ++i) {
-        QAbstractSocket *chSocket = channels[i].socket;
-        // try to get a free AND connected socket
         if (!channels[i].isSocketBusy() && channels[i].socket->state() == QAbstractSocket::ConnectedState) {
-            socket = chSocket;
-            dequeueAndSendRequest(socket);
-            break;
-        }
-    }
-
-    if (!socket) {
-        for (int i = 0; i < channelCount; ++i) {
-            QAbstractSocket *chSocket = channels[i].socket;
-            // try to get a free unconnected socket
-            if (!channels[i].isSocketBusy()) {
-                socket = chSocket;
-                dequeueAndSendRequest(socket);
-                break;
-            }
+            dequeueAndSendRequest(channels[i].socket);
+        }
+    }
+
+    // return fast if there is nothing to do
+    if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
+        return;
+    // try to get a free unconnected socket
+    for (int i = 0; i < channelCount; ++i) {
+        if (!channels[i].isSocketBusy()) {
+            dequeueAndSendRequest(channels[i].socket);
         }
     }
@@ -729 +765 @@
     if (highPriorityQueue.isEmpty() && lowPriorityQueue.isEmpty())
         return;
-    for (int j = 0; j < channelCount; j++)
-        fillPipeline(channels[j].socket);
+    for (int i = 0; i < channelCount; i++)
+        if (channels[i].socket->state() == QAbstractSocket::ConnectedState)
+            fillPipeline(channels[i].socket);
 }
 
@@ -856 +893 @@
 // SSL support below
 #ifndef QT_NO_OPENSSL
-QSslConfiguration QHttpNetworkConnectionPrivate::sslConfiguration(const QHttpNetworkReply &reply) const
-{
-    if (!encrypt)
-        return QSslConfiguration();
-
-    for (int i = 0; i < channelCount; ++i)
-        if (channels[i].reply == &reply)
-            return static_cast<QSslSocket *>(channels[0].socket)->sslConfiguration();
-    return QSslConfiguration(); // pending or done request
-}
-
 void QHttpNetworkConnection::setSslConfiguration(const QSslConfiguration &config)
 {

trunk/src/network/access/qhttpnetworkconnection_p.h

@@ -157 +157 @@
     static const int defaultChannelCount;
     static const int defaultPipelineLength;
+
 
     QHttpNetworkConnectionPrivate(const QString &hostName, quint16 port, bool encrypt);
@@ -211 +212 @@
     bool handleAuthenticateChallenge(QAbstractSocket *socket, QHttpNetworkReply *reply, bool isProxy, bool &resend);
 
-
-#ifndef QT_NO_OPENSSL
-    QSslConfiguration sslConfiguration(const QHttpNetworkReply &reply) const;
-#endif
-
 #ifndef QT_NO_NETWORKPROXY
     QNetworkProxy networkProxy;

trunk/src/network/access/qhttpnetworkconnectionchannel.cpp

@@ -59 +59 @@
 // TODO: Put channel specific stuff here so it does not polute qhttpnetworkconnection.cpp
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void QHttpNetworkConnectionChannel::init()
 {
@@ -125 +147 @@
 bool QHttpNetworkConnectionChannel::sendRequest()
 {
+
+
+
+
+
+
+
     switch (state) {
     case QHttpNetworkConnectionChannel::IdleState: { // write the header
@@ -135 +164 @@
         written = 0; // excluding the header
         bytesTotal = 0;
-        if (reply) {
-            reply->d_func()->clear();
-            reply->d_func()->connection = connection;
-            reply->d_func()->autoDecompress = request.d->autoDecompress;
-            reply->d_func()->pipeliningUsed = false;
-        }
-        state = QHttpNetworkConnectionChannel::WritingState;
+
+        reply->d_func()->clear();
+        reply->d_func()->connection = connection;
+        s;
+        ;
+        
+
         pendingEncrypt = false;
         // if the url contains authentication parameters, use the new ones
@@ -175 +204 @@
 
             bytesTotal = request.contentLength();
+
+
+
         } else {
-            state = QHttpNetworkConnectionChannel::WaitingState;
-            sendRequest();
-            break;
-        }
-        // write the initial chunk together with the headers
-        // fall through
+            state = QHttpNetworkConnectionChannel::WaitingState; // now wait for response
+            sendRequest(); //recurse
+        }
+
+        break;
     }
     case QHttpNetworkConnectionChannel::WritingState:
@@ -191 +222 @@
                 emit reply->dataSendProgress(written, bytesTotal);
             state = QHttpNetworkConnectionChannel::WaitingState; // now wait for response
-            sendRequest();
+            sendRequest();
             break;
         }
@@ -255 +286 @@
 
         // HTTP pipelining
-        connection->d_func()->fillPipeline(socket);
-        socket->flush();
+        connection->d_func()->fillPipeline(socket);
+        socket->flush();
 
         // ensure we try to receive a reply in all cases, even if _q_readyRead_ hat not been called
         // this is needed if the sends an reply before we have finished sending the request. In that
         // case receiveReply had been called before but ignored the server reply
-        QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
+        if (socket->bytesAvailable())
+            QMetaObject::invokeMethod(this, "_q_receiveReply", Qt::QueuedConnection);
         break;
     }
@@ -279 +311 @@
     Q_ASSERT(socket);
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     qint64 bytes = 0;
     QAbstractSocket::SocketState socketState = socket->state();
@@ -284 +331 @@
     // connection might be closed to signal the end of data
     if (socketState == QAbstractSocket::UnconnectedState) {
-        if (!socket->bytesAvailable()) {
-            if (reply && reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {
+        if (socket->bytesAvailable() <= 0) {
+            if (reply->d_func()->state == QHttpNetworkReplyPrivate::ReadingDataState) {
+                // finish this reply. this case happens when the server did not send a content length
                 reply->d_func()->state = QHttpNetworkReplyPrivate::AllDoneState;
-                this->state = QHttpNetworkConnectionChannel::IdleState;
                 allDone();
+
             } else {
-                // try to reconnect/resend before sending an error.
-                if (reconnectAttempts-- > 0) {
-                    closeAndResendCurrentRequest();
-                } else if (reply) {
-                    reply->d_func()->errorString = connection->d_func()->errorDetail(QNetworkReply::RemoteHostClosedError, socket);
-                    emit reply->finishedWithError(QNetworkReply::RemoteHostClosedError, reply->d_func()->errorString);
-                    QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
-                }
-            }
+                handleUnexpectedEOF();
+                return;
+            }
+        } else {
+            // socket not connected but still bytes for reading.. just continue in this function
         }
     }
@@ -304 +348 @@
     // read loop for the response
     while (socket->bytesAvailable()) {
-        QHttpNetworkReplyPrivate::ReplyState state = reply ? reply->d_func()->state : QHttpNetworkReplyPrivate::AllDoneState;
+        QHttpNetworkReplyPrivate::ReplyState state = replytate;
         switch (state) {
-        case QHttpNetworkReplyPrivate::NothingDoneState:
+        case QHttpNetworkReplyPrivate::NothingDoneState: {
+            // only eat whitespace on the first call
+            eatWhitespace();
+            state = reply->d_func()->state = QHttpNetworkReplyPrivate::ReadingStatusState;
+            // fallthrough
+        }
         case QHttpNetworkReplyPrivate::ReadingStatusState: {
-            eatWhitespace();
             qint64 statusBytes = reply->d_func()->readStatus(socket);
-            if (statusBytes == -1 && reconnectAttempts <= 0) {
-                // too many errors reading/receiving/parsing the status, close the socket and emit error
-                close();
-                reply->d_func()->errorString = connection->d_func()->errorDetail(QNetworkReply::ProtocolFailure, socket);
-                emit reply->finishedWithError(QNetworkReply::ProtocolFailure, reply->d_func()->errorString);
-                QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
-                break;
-            } else if (statusBytes == -1) {
-                reconnectAttempts--;
-                reply->d_func()->clear();
-                closeAndResendCurrentRequest();
-                break;
+            if (statusBytes == -1) {
+                // connection broke while reading status. also handled if later _q_disconnected is called
+                handleUnexpectedEOF();
+                return;
             }
             bytes += statusBytes;
@@ -329 +369 @@
         case QHttpNetworkReplyPrivate::ReadingHeaderState: {
             QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();
-            bytes += replyPrivate->readHeader(socket);
+            qint64 headerBytes = replyPrivate->readHeader(socket);
+            if (headerBytes == -1) {
+                // connection broke while reading headers. also handled if later _q_disconnected is called
+                handleUnexpectedEOF();
+                return;
+            }
+            bytes += headerBytes;
             if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState) {
                 if (replyPrivate->isGzipped() && replyPrivate->autoDecompress) {
@@ -338 +384 @@
                 }
                 if (replyPrivate->statusCode == 100) {
+
                     replyPrivate->state = QHttpNetworkReplyPrivate::ReadingStatusState;
                     break; // ignore
@@ -345 +392 @@
                 if (!replyPrivate->expectContent()) {
                     replyPrivate->state = QHttpNetworkReplyPrivate::AllDoneState;
-                    this->state = QHttpNetworkConnectionChannel::IdleState;
                     allDone();
-                    return;
+                    ;
                 }
             }
@@ -417 +463 @@
                 }
             }
+
             if (replyPrivate->state == QHttpNetworkReplyPrivate::ReadingDataState)
                 break;
+
             // everything done, fall through
             }
       case QHttpNetworkReplyPrivate::AllDoneState:
-            this->state = QHttpNetworkConnectionChannel::IdleState;
             allDone();
             break;
@@ -428 +475 @@
             break;
         }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
     }
 }
@@ -557 +623 @@
     // ### at this point there should be no more data on the socket
     // close if server requested
-    if (reply->d_func()->isConnectionCloseEnabled())
+    bool connectionCloseEnabled = reply->d_func()->isConnectionCloseEnabled();
+    if (connectionCloseEnabled)
         close();
     // queue the finished signal, this is required since we might send new requests from
@@ -570 +637 @@
     detectPipeliningSupport();
 
+
+
+
+
+
+
+
+
+
+
+
     // move next from pipeline to current request
     if (!alreadyPipelinedRequests.isEmpty()) {
-        if (resendCurrent || reply->d_func()->isConnectionCloseEnabled() || socket->state() != QAbstractSocket::ConnectedState) {
+        if (resendCurrent ||  || socket->state() != QAbstractSocket::ConnectedState) {
             // move the pipelined ones back to the main queue
             requeueCurrentlyPipelinedRequests();
@@ -592 +670 @@
 
             // continue reading
-            _q_receiveReply();
+            //_q_receiveReply();
+            // this was wrong, allDone gets called from that function anyway.
         }
     } else if (alreadyPipelinedRequests.isEmpty() && socket->bytesAvailable() > 0) {
@@ -608 +687 @@
 {
     // detect HTTP Pipelining support
-    QByteArray serverHeaderField = reply->headerField("Server");
+    QByteArray serverHeaderField;
     if (
-            // check for broken servers in server reply header
-            // this is adapted from http://mxr.mozilla.org/firefox/ident?i=SupportsPipelining
-            (!serverHeaderField.contains("Microsoft-IIS/4."))
-            && (!serverHeaderField.contains("Microsoft-IIS/5."))
-            && (!serverHeaderField.contains("Netscape-Enterprise/3."))
             // check for HTTP/1.1
-            && (reply->d_func()->majorVersion == 1 && reply->d_func()->minorVersion == 1)
+            (reply->d_func()->majorVersion == 1 && reply->d_func()->minorVersion == 1)
             // check for not having connection close
             && (!reply->d_func()->isConnectionCloseEnabled())
             // check if it is still connected
             && (socket->state() == QAbstractSocket::ConnectedState)
+
+
+
+
+
+
+
             ) {
         pipeliningSupported = QHttpNetworkConnectionChannel::PipeliningProbablySupported;
@@ -635 +716 @@
     alreadyPipelinedRequests.clear();
 
-    QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
+    // only run when the QHttpNetworkConnection is not currently being destructed, e.g.
+    // this function is called from _q_disconnected which is called because
+    // of ~QHttpNetworkConnectionPrivate
+    if (qobject_cast<QHttpNetworkConnection*>(connection))
+        QMetaObject::invokeMethod(connection, "_q_startNextRequest", Qt::QueuedConnection);
 }
 
@@ -675 +760 @@
         if (connection->d_func()->handleAuthenticateChallenge(socket, reply, (statusCode == 407), resend)) {
             if (resend) {
-                QNonContiguousByteDevice* uploadByteDevice = request.uploadByteDevice();
-                if (uploadByteDevice) {
-                    if (uploadByteDevice->reset()) {
-                        written = 0;
-                    } else {
-                        connection->d_func()->emitReplyError(socket, reply, QNetworkReply::ContentReSendError);
-                        break;
-                    }
-                }
+                if (!resetUploadData())
+                    break;
 
                 reply->d_func()->eraseData();
@@ -713 +791 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 void  QHttpNetworkConnectionChannel::pipelineInto(HttpMessagePair &pair)
 {
@@ -719 +813 @@
     QHttpNetworkRequest &request = pair.first;
     QHttpNetworkReply *reply = pair.second;
-    if (reply) {
-        reply->d_func()->clear();
-        reply->d_func()->connection = connection;
-        reply->d_func()->autoDecompress = request.d->autoDecompress;
-        reply->d_func()->pipeliningUsed = true;
-    }
+    reply->d_func()->clear();
+    reply->d_func()->connection = connection;
+    reply->d_func()->connectionChannel = this;
+    reply->d_func()->autoDecompress = request.d->autoDecompress;
+    reply->d_func()->pipeliningUsed = true;
 
 #ifndef QT_NO_NETWORKPROXY
@@ -788 +881 @@
     // read the available data before closing
     if (isSocketWaiting() || isSocketReading()) {
-        state = QHttpNetworkConnectionChannel::ReadingState;
-        if (reply)
+        
+        
             _q_receiveReply();
+
     } else if (state == QHttpNetworkConnectionChannel::IdleState && resendCurrent) {
         // re-sending request because the socket was in ClosingState
@@ -805 +899 @@
 {
     // improve performance since we get the request sent by the kernel ASAP
-    socket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
+    //socket->setSocketOption(QAbstractSocket::LowDelayOption, 1);
+    // We have this commented out now. It did not have the effect we wanted. If we want to
+    // do this properly, Qt has to combine multiple HTTP requests into one buffer
+    // and send this to the kernel in one syscall and then the kernel immediately sends
+    // it as one TCP packet because of TCP_NODELAY.
+    // However, this code is currently not in Qt, so we rely on the kernel combining
+    // the requests into one TCP packet.
+
     // not sure yet if it helps, but it makes sense
     socket->setSocketOption(QAbstractSocket::KeepAliveOption, 1);
@@ -872 +973 @@
         break;
     }
-    QPointer<QObject> that = connection;
+    QPointer<Q> that = connection;
     QString errorString = connection->d_func()->errorDetail(errorCode, socket, socket->errorString());
     if (send2Reply) {
@@ -927 +1028 @@
     // otherwise we do nothing
 }
-#endif
+
+#endif
+
+void QHttpNetworkConnectionChannel::setConnection(QHttpNetworkConnection *c)
+{
+    // Inlining this function in the header leads to compiler error on
+    // release-armv5, on at least timebox 9.2 and 10.1.
+    connection = c;
+}
 
 QT_END_NAMESPACE

trunk/src/network/access/qhttpnetworkconnectionchannel_p.h

@@ -66 +66 @@
 #include <private/qhttpnetworkreply_p.h>
 
+
 
 #ifndef QT_NO_HTTP
@@ -81 +82 @@
 class QHttpNetworkReply;
 class QByteArray;
-class QHttpNetworkConnection;
 
 #ifndef HttpMessagePair
@@ -128 +128 @@
 
 
-    QHttpNetworkConnectionChannel() : socket(0), state(IdleState), reply(0), written(0), bytesTotal(0), resendCurrent(false),
-    lastStatus(0), pendingEncrypt(false), reconnectAttempts(2),
-    authMehtod(QAuthenticatorPrivate::None), proxyAuthMehtod(QAuthenticatorPrivate::None)
-#ifndef QT_NO_OPENSSL
-    , ignoreAllSslErrors(false)
-#endif
-    , pipeliningSupported(PipeliningSupportUnknown)
-    , connection(0)
-    {}
-
-    void setConnection(QHttpNetworkConnection *c) {connection = c;}
-    QHttpNetworkConnection *connection;
+    QHttpNetworkConnectionChannel();
+    
+    void setConnection(QHttpNetworkConnection *c);
+    QPointer<QHttpNetworkConnection> connection;
 
     void init();
@@ -152 +144 @@
     void handleStatus(); // called from allDone()
 
+
+
     void pipelineInto(HttpMessagePair &pair);
     void requeueCurrentlyPipelinedRequests();
     void detectPipeliningSupport();
 
+
     void closeAndResendCurrentRequest();
 
@@ -185 +180 @@
 };
 
-
-
 QT_END_NAMESPACE
 

trunk/src/network/access/qhttpnetworkheader.cpp

@@ -81 +81 @@
     QByteArray result;
     bool first = true;
-    foreach (QByteArray value, allValues) {
+    foreach (value, allValues) {
         if (!first)
             result += ", ";

trunk/src/network/access/qhttpnetworkreply.cpp

@@ -180 +180 @@
 {
     Q_D(QHttpNetworkReply);
+
+
+
     // we'll take the last buffer, so schedule another read from http
     if (d->downstreamLimited && d->responseData.bufferCount() == 1)
@@ -220 +223 @@
 }
 
-void QHttpNetworkReplyPrivate::clear()
+void QHttpNetworkReplyPrivate::clear()
 {
     state = NothingDoneState;
@@ -230 +233 @@
     currentChunkRead = 0;
     connectionCloseEnabled = true;
-    connection = 0;
 #ifndef QT_NO_COMPRESS
     if (initInflate)
@@ -237 +239 @@
     initInflate = false;
     streamEnd = false;
+
+
+
+
+
+
+
+
     autoDecompress = false;
-    fields.clear();
+    ();
 }
 
@@ -424 +434 @@
 qint64 QHttpNetworkReplyPrivate::readStatus(QAbstractSocket *socket)
 {
+
+
+
+
+
     qint64 bytes = 0;
     char c;
-
-    while (socket->bytesAvailable()) {
+    qint64 haveRead = 0;
+
+    do {
+        haveRead = socket->read(&c, 1);
+        if (haveRead == -1)
+            return -1; // unexpected EOF
+        else if (haveRead == 0)
+            break; // read more later
+
+        bytes++;
+
         // allow both CRLF & LF (only) line endings
-        if (socket->peek(&c, 1) == 1 && c == '\n') {
-            bytes += socket->read(&c, 1); // read the "n"
+        if (c == '\n') {
             // remove the CR at the end
             if (fragment.endsWith('\r')) {
@@ -443 +466 @@
             break;
         } else {
-            c = 0;
-            int haveRead = socket->read(&c, 1);
-            if (haveRead == -1)
-                return -1;
-            bytes += haveRead;
             fragment.append(c);
         }
@@ -457 +475 @@
             return -1;
         }
-
-    }
+    } while (haveRead == 1);
 
     return bytes;
@@ -501 +518 @@
 qint64 QHttpNetworkReplyPrivate::readHeader(QAbstractSocket *socket)
 {
+
+
+
+
+
+
+
     qint64 bytes = 0;
     char c = 0;
     bool allHeaders = false;
-    while (!allHeaders && socket->bytesAvailable()) {
-        if (socket->peek(&c, 1) == 1 && c == '\n') {
-            // check for possible header endings. As per HTTP rfc,
-            // the header endings will be marked by CRLFCRLF. But
-            // we will allow CRLFLF, LFLF & CRLFCRLF
-            if (fragment.endsWith("\n\r") || fragment.endsWith('\n'))
-                allHeaders = true;
-        }
-        bytes += socket->read(&c, 1);
-        fragment.append(c);
-    }
+    qint64 haveRead = 0;
+    do {
+        haveRead = socket->read(&c, 1);
+        if (haveRead == 0) {
+            // read more later
+            break;
+        } else if (haveRead == -1) {
+            // connection broke down
+            return -1;
+        } else {
+            fragment.append(c);
+            bytes++;
+
+            if (c == '\n') {
+                // check for possible header endings. As per HTTP rfc,
+                // the header endings will be marked by CRLFCRLF. But
+                // we will allow CRLFCRLF, CRLFLF, LFLF
+                if (fragment.endsWith("\r\n\r\n")
+                    || fragment.endsWith("\r\n\n")
+                    || fragment.endsWith("\n\n"))
+                    allHeaders = true;
+
+                // there is another case: We have no headers. Then the fragment equals just the line ending
+                if ((fragment.length() == 2 && fragment.endsWith("\r\n"))
+                    || (fragment.length() == 1 && fragment.endsWith("\n")))
+                    allHeaders = true;
+            }
+        }
+    } while (!allHeaders && haveRead > 0);
+
     // we received all headers now parse them
     if (allHeaders) {
@@ -776 +819 @@
 {
     Q_D(const QHttpNetworkReply);
-    if (d->connection)
-        return d->connection->d_func()->sslConfiguration(*this);
-    return QSslConfiguration();
+
+    if (!d->connectionChannel)
+        return QSslConfiguration();
+
+    QSslSocket *sslSocket = qobject_cast<QSslSocket*>(d->connectionChannel->socket);
+    if (!sslSocket)
+        return QSslConfiguration();
+
+    return sslSocket->sslConfiguration();
 }
 

trunk/src/network/access/qhttpnetworkreply_p.h

@@ -87 +87 @@
 
 class QHttpNetworkConnection;
+
 class QHttpNetworkRequest;
 class QHttpNetworkConnectionPrivate;
@@ -172 +173 @@
     QAuthenticatorPrivate::Method authenticationMethod(bool isProxy) const;
     void clear();
+
 
     qint64 readReplyBodyRaw(QIODevice *in, QByteDataBuffer *out, qint64 size);
@@ -219 +221 @@
     qint64 currentChunkRead;
     QPointer<QHttpNetworkConnection> connection;
+
     bool initInflate;
     bool streamEnd;

trunk/src/network/access/qnetworkaccessbackend.cpp

@@ -73 +73 @@
 {
     QMutexLocker locker(&factoryData()->mutex);
-    factoryData()->prepend(this);
+    factoryData()->pend(this);
 }
 

trunk/src/network/access/qnetworkaccesshttpbackend.cpp

@@ -681 +681 @@
 
     while (httpReply->bytesAvailable() != 0 && nextDownstreamBlockSize() != 0 && nextDownstreamBlockSize() > list.byteAmount()) {
-        QByteArray data = httpReply->readAny();
-        list.append(data);
+        list.append(httpReply->readAny());
     }
 
@@ -754 +753 @@
         if (!value.isEmpty()) {
             if (qstricmp(it->first.constData(), "set-cookie") == 0)
-                value += "\n";
+                value += ;
             else
                 value += ", ";
@@ -977 +976 @@
         // write to disk when only the date changes).
         // However, without the date we cannot calculate the age of the page
-        // anymore. Consider a proper fix of that problem for 4.6.1.
+        // anymore.
         //if (header == "date")
             //continue;

trunk/src/network/access/qnetworkaccesshttpbackend_p.h

@@ -95 +95 @@
     QNetworkCacheMetaData fetchCacheMetaData(const QNetworkCacheMetaData &metaData) const;
 
-    qint64 deviceReadData(char *buffer, qint64 maxlen);
-
     // we return true since HTTP needs to send PUT/POST data again after having authenticated
     bool needsResetableUploadData() { return true; }

trunk/src/network/access/qnetworkaccessmanager.cpp

@@ -108 +108 @@
     it sends. It contains the proxy and cache configuration, as well as the
     signals related to such issues, and reply signals that can be used to
-    monitor the progress of a network operation.
+    monitor the progress of a network operation. One QNetworkAccessManager
+    should be enough for the whole Qt application.
 
     Once a QNetworkAccessManager object has been created, the application can
@@ -119 +120 @@
     \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 0
 
+
     When the \tt replyFinished slot above is called, the parameter it
     takes is the QNetworkReply object containing the downloaded data
@@ -128 +130 @@
     deleteLater() function.
 
+
+
+
+
+
     A more involved example, assuming the manager is already existent,
     can be:
     \snippet doc/src/snippets/code/src_network_access_qnetworkaccessmanager.cpp 1
+
+
+
+
+
+
+
+
+
+
 
     \sa QNetworkRequest, QNetworkReply, QNetworkProxy
@@ -550 +567 @@
 /*!
     Posts a request to obtain the network headers for \a request
-    and returns a new QNetworkReply object which will contain such headers
+    and returns a new QNetworkReply object which will contain such headers
 
     The function is named after the HTTP request associated (HEAD).

trunk/src/network/access/qnetworkcookie.h

@@ -115 +115 @@
 
 // ### Qt5 remove this include
-#include "qnetworkcookiejar.h"
+#include 
 
 Q_DECLARE_METATYPE(QNetworkCookie)

trunk/src/network/access/qnetworkcookiejar.h

@@ -47 +47 @@
 
 // ### Qt5 remove this include
-#include "qnetworkcookie.h"
+#include 
 
 QT_BEGIN_HEADER

trunk/src/network/access/qnetworkdiskcache.cpp

@@ -42 +42 @@
 //#define QNETWORKDISKCACHE_DEBUG
 
-#ifndef QT_NO_NETWORKDISKCACHE
 
 #include "qnetworkdiskcache.h"
@@ -60 +59 @@
 #define CACHE_POSTFIX QLatin1String(".cache")
 #define MAX_COMPRESSION_SIZE (1024 * 1024 * 3)
+
+
 
 QT_BEGIN_NAMESPACE

trunk/src/network/access/qnetworkdiskcache_p.h

@@ -60 +60 @@
 #include <qtemporaryfile.h>
 
+
+
 QT_BEGIN_NAMESPACE
 
@@ -120 +122 @@
 QT_END_NAMESPACE
 
+
+
 #endif // QNETWORKDISKCACHE_P_H

trunk/src/network/access/qnetworkreplyimpl.cpp

@@ -404 +404 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // we received downstream data and send this to the cache
 // and to our readBuffer (which in turn gets read by the user of QNetworkReply)
@@ -413 +444 @@
 
     if (cacheEnabled && !cacheSaveDevice) {
-        // save the meta data
-        QNetworkCacheMetaData metaData;
-        metaData.setUrl(url);
-        metaData = backend->fetchCacheMetaData(metaData);
-
-        // save the redirect request also in the cache
-        QVariant redirectionTarget = q->attribute(QNetworkRequest::RedirectionTargetAttribute);
-        if (redirectionTarget.isValid()) {
-            QNetworkCacheMetaData::AttributesMap attributes = metaData.attributes();
-            attributes.insert(QNetworkRequest::RedirectionTargetAttribute, redirectionTarget);
-            metaData.setAttributes(attributes);
-        }
-
-        cacheSaveDevice = networkCache()->prepare(metaData);
-
-        if (!cacheSaveDevice || (cacheSaveDevice && !cacheSaveDevice->isOpen())) {
-            if (cacheSaveDevice && !cacheSaveDevice->isOpen())
-                qCritical("QNetworkReplyImpl: network cache returned a device that is not open -- "
-                      "class %s probably needs to be fixed",
-                      networkCache()->metaObject()->className());
-
-            networkCache()->remove(url);
-            cacheSaveDevice = 0;
-            cacheEnabled = false;
-        }
+        initCacheSaveDevice();
     }
 
     qint64 bytesWritten = 0;
     for (int i = 0; i < data.bufferCount(); i++) {
-        QByteArray item = data[i];
+        QByteArray item = data[i];
 
         if (cacheSaveDevice)
@@ -454 +461 @@
     bytesDownloaded += bytesWritten;
     lastBytesDownloaded = bytesDownloaded;
+
+
+
+
+
+
+
 
     QPointer<QNetworkReplyImpl> qq = q;
@@ -496 +510 @@
 }
 
+
+
+
+
+
+
+
+
+
 void QNetworkReplyImplPrivate::finished()
 {
@@ -581 +604 @@
 {
     Q_D(QNetworkReplyImpl);
+
+
+
+
     if (d->isCachingEnabled())
         d->networkCache()->remove(url());
+
     if (d->outgoingDataBuffer)
         delete d->outgoingDataBuffer;

trunk/src/network/access/qnetworkreplyimpl_p.h

@@ -146 +146 @@
     void emitUploadProgress(qint64 bytesSent, qint64 bytesTotal);
     qint64 nextDownstreamBlockSize() const;
+
+
+
     void appendDownstreamData(QByteDataBuffer &data);
     void appendDownstreamData(QIODevice *data);
+
+
     void finished();
     void error(QNetworkReply::NetworkError code, const QString &errorString);

trunk/src/network/access/qnetworkrequest.cpp

@@ -139 +139 @@
         determine if the requested redirection should be allowed,
         according to its security policies.
+
+
 
     \value ConnectionEncryptedAttribute
@@ -650 +652 @@
     QList<QNetworkCookie> result;
     QList<QByteArray> cookieList = raw.split(';');
-    foreach (QByteArray cookie, cookieList) {
+    foreach (cookie, cookieList) {
         QList<QNetworkCookie> parsed = QNetworkCookie::parseCookies(cookie.trimmed());
         if (parsed.count() != 1)

trunk/src/network/kernel/qauthenticator.cpp

@@ -271 +271 @@
     case Ntlm:
         // #### extract from header
-        realm = QString();
+        realm();
         break;
     case DigestMd5: {
@@ -282 +282 @@
     }
     default:
-        realm = QString();
+        realm();
         challenge = QByteArray();
         phase = Invalid;

trunk/src/network/kernel/qhostinfo.cpp

@@ -45 +45 @@
 #include "QtCore/qscopedpointer.h"
 #include <qabstracteventdispatcher.h>
-#include <private/qunicodetables_p.h>
 #include <qcoreapplication.h>
 #include <qmetaobject.h>
-#include <qregexp.h>
-#include <private/qnativesocketengine_p.h>
 #include <qstringlist.h>
 #include <qthread.h>
-#include <qtimer.h>
 #include <qurl.h>
 
@@ -112 +108 @@
     To retrieve the name of the local host, use the static
     QHostInfo::localHostName() function.
+
+
+
+
+
+
+
 
     \sa QAbstractSocket, {http://www.rfc-editor.org/rfc/rfc3492.txt}{RFC 3492}
@@ -182 +185 @@
     result.data()->emitResultsReady(hostInfo);
 #else
-    QHostInfoRunnable* runnable = new QHostInfoRunnable(name, id);
-    QObject::connect(&runnable->resultEmitter, SIGNAL(resultsReady(QHostInfo)), receiver, member, Qt::QueuedConnection);
-    theHostInfoLookupManager()->scheduleLookup(runnable);
+    QHostInfoLookupManager *manager = theHostInfoLookupManager();
+    if (manager) {
+        // the application is still alive
+        if (manager->cache.isEnabled()) {
+            // check cache first
+            bool valid = false;
+            QHostInfo info = manager->cache.get(name, &valid);
+            if (valid) {
+                info.setLookupId(id);
+                QHostInfoResult result;
+                QObject::connect(&result, SIGNAL(resultsReady(QHostInfo)), receiver, member, Qt::QueuedConnection);
+                result.emitResultsReady(info);
+                return id;
+            }
+        }
+        // cache is not enabled or it was not in the cache, do normal lookup
+        QHostInfoRunnable* runnable = new QHostInfoRunnable(name, id);
+        QObject::connect(&runnable->resultEmitter, SIGNAL(resultsReady(QHostInfo)), receiver, member, Qt::QueuedConnection);
+        manager->scheduleLookup(runnable);
+    }
 #endif
 
@@ -419 +439 @@
     }
 
-    // check cache
-    // FIXME
-
-    // if not in cache: OS lookup
-    QHostInfo hostInfo = QHostInfoAgent::fromName(toBeLookedUp);
-
-    // save to cache
-    // FIXME
+    QHostInfo hostInfo;
+
+    // QHostInfo::lookupHost already checks the cache. However we need to check
+    // it here too because it might have been cache saved by another QHostInfoRunnable
+    // in the meanwhile while this QHostInfoRunnable was scheduled but not running
+    if (manager->cache.isEnabled()) {
+        // check the cache first
+        bool valid = false;
+        hostInfo = manager->cache.get(toBeLookedUp, &valid);
+        if (!valid) {
+            // not in cache, we need to do the lookup and store the result in the cache
+            hostInfo = QHostInfoAgent::fromName(toBeLookedUp);
+            manager->cache.put(toBeLookedUp, hostInfo);
+        }
+    } else {
+        // cache is not enabled, just do the lookup and continue
+        hostInfo = QHostInfoAgent::fromName(toBeLookedUp);
+    }
 
     // check aborted again
@@ -446 +476 @@
 {
     moveToThread(QCoreApplicationPrivate::mainThread());
+
     threadPool.setMaxThreadCount(5); // do 5 DNS lookups in parallel
 }
@@ -452 +483 @@
 {
     wasDeleted = true;
+
+
+
+
+
 }
 
@@ -512 +548 @@
             }
 
-            if (scheduled && threadPool.tryStart(scheduled)) {
+            if (scheduled && )) {
                 // runnable now running in new thread, track this in currentLookups
+
                 iterator.remove();
                 currentLookups.append(scheduled);
-            } else if (scheduled) {
-                // wanted to start, but could not because thread pool is busy
-                break;
             } else {
                 // was postponed, continue iterating
@@ -571 +605 @@
 }
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 #endif // QT_NO_THREAD
 

trunk/src/network/kernel/qhostinfo_p.h

@@ -69 +69 @@
 #include "QtCore/qlist.h"
 #include "QtCore/qqueue.h"
+
+
 #endif
 
@@ -112 +114 @@
 
 #ifndef QT_NO_THREAD
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 // the following classes are used for the (normal) case: We use multiple threads to lookup DNS
 
@@ -142 +172 @@
     bool wasAborted(int id);
 
+
 protected:
     QList<QHostInfoRunnable*> currentLookups; // in progress
@@ -154 +185 @@
 
     bool wasDeleted;
+
+
+
 };
+
 #endif
 

trunk/src/network/kernel/qhostinfo_unix.cpp

@@ -45 +45 @@
 
 #include "qhostinfo_p.h"
+
 #include "qiodevice.h"
 #include <qbytearray.h>

trunk/src/network/kernel/qhostinfo_win.cpp

@@ -51 +51 @@
 #include <ws2tcpip.h>
 #include <qlibrary.h>
-#include <qtimer.h>
 #include <qmutex.h>
 #include <qurl.h>

trunk/src/network/kernel/qnetworkinterface.cpp

@@ -542 +542 @@
     QList<QSharedDataPointer<QNetworkInterfacePrivate> > privs = manager()->allInterfaces();
     QList<QNetworkInterface> result;
-    foreach (QSharedDataPointer<QNetworkInterfacePrivate> p, privs) {
+    foreach (p, privs) {
         QNetworkInterface item;
         item.d = p;
@@ -561 +561 @@
     QList<QSharedDataPointer<QNetworkInterfacePrivate> > privs = manager()->allInterfaces();
     QList<QHostAddress> result;
-    foreach (const QSharedDataPointer<QNetworkInterfacePrivate> p, privs) {
+    foreach (const QSharedDataPointer<QNetworkInterfacePrivate> p, privs) {
         foreach (const QNetworkAddressEntry &entry, p->addressEntries)
             result += entry.ip();

trunk/src/network/socket/qabstractsocket.cpp

@@ -156 +156 @@
     examples for an overview of both approaches.
 
+
+
+
     QAbstractSocket can be used with QTextStream and QDataStream's
     stream operators (operator<<() and operator>>()). There is one
@@ -170 +173 @@
     the host lookup has succeeded.
 
+
+
+
+
     \sa connected()
 */
@@ -178 +185 @@
     This signal is emitted after connectToHost() has been called and
     a connection has been successfully established.
+
+
+
+
 
     \sa connectToHost(), disconnected()
@@ -352 +363 @@
 #include "qabstractsocket_p.h"
 
+
+
 #include <qabstracteventdispatcher.h>
 #include <qdatetime.h>
@@ -1367 +1380 @@
 #endif
     } else {
-        if (d->threadData->eventDispatcher)
-            d->hostLookupId = QHostInfo::lookupHost(hostName, this, SLOT(_q_startConnecting(QHostInfo)));
+        if (d->threadData->eventDispatcher) {
+            // this internal API for QHostInfo either immediatly gives us the desired
+            // QHostInfo from cache or later calls the _q_startConnecting slot.
+            bool immediateResultValid = false;
+            QHostInfo hostInfo = qt_qhostinfo_lookup(hostName,
+                                                     this,
+                                                     SLOT(_q_startConnecting(QHostInfo)),
+                                                     &immediateResultValid,
+                                                     &d->hostLookupId);
+            if (immediateResultValid) {
+                d->hostLookupId = -1;
+                d->_q_startConnecting(hostInfo);
+            }
+        }
     }
 
@@ -1683 +1708 @@
     If msecs is -1, this function will not time out.
 
-    Note: This function may wait slightly longer than \a msecs,
+     This function may wait slightly longer than \a msecs,
     depending on the time it takes to complete the host lookup.
+
+
+
 
     \sa connectToHost(), connected()
@@ -1723 +1751 @@
     }
     if (state() == UnconnectedState)
-        return false;
+        return false;
 
     bool timedOut = true;
@@ -2355 +2383 @@
         qDebug("QAbstractSocket::disconnectFromHost() aborting immediately");
 #endif
+
+
+
+
     } else {
         // Perhaps emit closing()

trunk/src/network/socket/qlocalserver.cpp

@@ -123 +123 @@
     d->pendingConnections.clear();
     d->closeServer();
-    d->serverName = QString();
-    d->fullServerName = QString();
-    d->errorString = QString();
+    d->serverName();
+    d->fullServerName();
+    d->errorString();
     d->error = QAbstractSocket::UnknownSocketError;
 }
@@ -229 +229 @@
 
     if (!d->listen(name)) {
-        d->serverName = QString();
-        d->fullServerName = QString();
+        d->serverName();
+        d->fullServerName();
         return false;
     }

trunk/src/network/socket/qlocalserver_win.cpp

@@ -168 +168 @@
         } else {
             if (GetLastError() != ERROR_IO_INCOMPLETE) {
+
                 setError(QLatin1String("QLocalServerPrivate::_q_onNewConnection"));
-                closeServer();
                 return;
             }

trunk/src/network/socket/qlocalsocket_p.h

@@ -129 +129 @@
     void _q_error(QAbstractSocket::SocketError newError);
 #elif defined(Q_OS_WIN)
-    ~QLocalSocketPrivate() {
-        CloseHandle(overlapped.hEvent);
-    }
-
+    ~QLocalSocketPrivate();
+    void destroyPipeHandles();
     void setErrorString(const QString &function);
     void _q_notified();

trunk/src/network/socket/qlocalsocket_tcp.cpp

@@ -103 +103 @@
     case QAbstractSocket::UnconnectedState:
         state = QLocalSocket::UnconnectedState;
-        serverName = QString();
-        fullServerName = QString();
+        serverName();
+        fullServerName();
         break;
     case QAbstractSocket::ConnectingState:
@@ -219 +219 @@
         return;
 
-    d->errorString = QString();
+    d->errorString();
     d->state = ConnectingState;
     emit stateChanged(d->state);
@@ -334 +334 @@
     Q_D(QLocalSocket);
     d->tcpSocket->close();
-    d->serverName = QString();
-    d->fullServerName = QString();
+    d->serverName();
+    d->fullServerName();
     QIODevice::close();
 }

trunk/src/network/socket/qlocalsocket_unix.cpp

@@ -110 +110 @@
     case QAbstractSocket::UnconnectedState:
         state = QLocalSocket::UnconnectedState;
-        serverName = QString();
-        fullServerName = QString();
+        serverName();
+        fullServerName();
         break;
     case QAbstractSocket::ConnectingState:
@@ -226 +226 @@
         return;
 
-    d->errorString = QString();
+    d->errorString();
     d->unixSocket.setSocketState(QAbstractSocket::ConnectingState);
     d->state = ConnectingState;
@@ -342 +342 @@
     }
     connectingSocket = -1;
-    connectingName = QString();
+    connectingName();
     connectingOpenMode = 0;
 }
@@ -439 +439 @@
         ::close(d->connectingSocket);
     d->connectingSocket = -1;
-    d->connectingName = QString();
+    d->connectingName();
     d->connectingOpenMode = 0;
-    d->serverName = QString();
-    d->fullServerName = QString();
+    d->serverName();
+    d->fullServerName();
     QIODevice::close();
 }

trunk/src/network/socket/qlocalsocket_win.cpp

@@ -40 +40 @@
 ****************************************************************************/
 
-#include "qlocalsocket.h"
 #include "qlocalsocket_p.h"
 
@@ -109 +108 @@
        state(QLocalSocket::UnconnectedState)
 {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }
 
@@ -389 +402 @@
     d->pendingReadyRead = false;
     d->pipeClosed = false;
-    DisconnectNamedPipe(d->handle);
-    CloseHandle(d->handle);
+    d->destroyPipeHandles();
     d->handle = INVALID_HANDLE_VALUE;
     ResetEvent(d->overlapped.hEvent);
@@ -413 +425 @@
 {
     Q_D(QLocalSocket);
+
+
+
+
+
+
+
+
+
     flush();
     if (d->pipeWriter && d->pipeWriter->bytesToWrite() != 0) {
@@ -525 +546 @@
 {
     Q_D(const QLocalSocket);
-    return (d->handle != INVALID_HANDLE_VALUE);
+    if (d->handle == INVALID_HANDLE_VALUE)
+        return false;
+
+    return PeekNamedPipe(d->handle, NULL, 0, NULL, NULL, NULL);
 }
 

trunk/src/network/socket/qnativesocketengine.cpp

@@ -780 +780 @@
         return -1;
     } else if (readBytes == -1) {
-        d->setError(QAbstractSocket::NetworkError,
-                    QNativeSocketEnginePrivate::ReadErrorString);
+        if (!d->hasSetSocketError) {
+            d->hasSetSocketError = true;
+            d->socketError = QAbstractSocket::NetworkError;
+            d->socketErrorString = qt_error_string();
+        }
         close();
         return -1;

trunk/src/network/socket/qnativesocketengine_unix.cpp

@@ -602 +602 @@
     // well be 0, so we can't check recvfrom's return value.
     ssize_t readBytes;
+
+
+
+
     do {
         char c;
         readBytes = ::recvfrom(socketDescriptor, &c, 1, MSG_PEEK, &storage.a, &storageSize);
     } while (readBytes == -1 && errno == EINTR);
+
 
     // If there's no error, or if our buffer was too small, there must be a
@@ -662 +667 @@
 
     ssize_t recvFromResult = 0;
+
+
+
+
+
     do {
         char c;
@@ -667 +677 @@
                                     0, &aa.a, &sz);
     } while (recvFromResult == -1 && errno == EINTR);
+
 
     if (recvFromResult == -1) {
@@ -833 +844 @@
     qt_ignore_sigpipe();
 
-    // loop while ::write() returns -1 and errno == EINTR, in case
-    // of an interrupting signal.
     ssize_t writtenBytes;
-    do {
-#ifdef Q_OS_SYMBIAN
-            writtenBytes = ::write(socketDescriptor, data, len);
-#else
-        writtenBytes = qt_safe_write(socketDescriptor, data, len);
-#endif
-        // writtenBytes = QT_WRITE(socketDescriptor, data, len); ### TODO S60: Should this line be removed or the one above it?
-    } while (writtenBytes < 0 && errno == EINTR);
+#ifdef Q_OS_SYMBIAN
+    // Symbian does not support signals natively and Open C returns EINTR when moving to offline
+    writtenBytes = ::write(socketDescriptor, data, len);
+#else
+    writtenBytes = qt_safe_write(socketDescriptor, data, len);
+#endif
 
     if (writtenBytes < 0) {
@@ -883 +890 @@
 
     ssize_t r = 0;
-    do {
-#ifdef Q_OS_SYMBIAN
-        r = ::read(socketDescriptor, data, maxSize);
-#else
-        r = qt_safe_read(socketDescriptor, data, maxSize);
-#endif
-    } while (r == -1 && errno == EINTR);
+#ifdef Q_OS_SYMBIAN
+    r = ::read(socketDescriptor, data, maxSize);
+#else
+    r = qt_safe_read(socketDescriptor, data, maxSize);
+#endif
 
     if (r < 0) {
@@ -904 +909 @@
         case EINVAL:
         case EIO:
-            setError(QAbstractSocket::NetworkError, ReadErrorString);
+            
             break;
 #ifdef Q_OS_SYMBIAN

trunk/src/network/socket/qnativesocketengine_win.cpp

@@ -1069 +1069 @@
         case WSAEBADF:
         case WSAEINVAL:
-            setError(QAbstractSocket::NetworkError, ReadErrorString);
+            
             break;
         case WSAECONNRESET:

trunk/src/network/socket/qtcpserver.cpp

@@ -79 +79 @@
     use waitForNewConnection(), which blocks until either a
     connection is available or a timeout expires.
+
+
+
+
+
+
+
+
+
+
 
     \sa QTcpSocket, {Fortune Server Example}, {Threaded Fortune Server Example},
@@ -514 +524 @@
     connections.
 
+
+
+
+
     \sa hasPendingConnections()
 */
@@ -543 +557 @@
     may not be usable with native socket functions, and should only be
     used with QTcpSocket::setSocketDescriptor().
+
+
+
+
+
 
     \sa newConnection(), nextPendingConnection()

trunk/src/network/socket/qtcpsocket.cpp

@@ -61 +61 @@
     \bold{Note:} TCP sockets cannot be opened in QIODevice::Unbuffered mode.
 
+
+
+
+
+
+
+
+
+
+
     \sa QTcpServer, QUdpSocket, QFtp, QNetworkAccessManager,
     {Fortune Server Example}, {Fortune Client Example},

trunk/src/network/socket/qudpsocket.cpp

@@ -86 +86 @@
     \l{network/broadcastreceiver}{Broadcast Receiver} examples
     illustrate how to use QUdpSocket in applications.
+
+
+
+
+
+
+
+
+
+
 
     \sa QTcpSocket

trunk/src/network/ssl/qsslcertificate.cpp

@@ -635 +635 @@
     for (int i = 0; i <= array.size() - 64; i += 64) {
         tmp += QByteArray::fromRawData(array.data() + i, 64);
-        tmp += "\n";
+        tmp += ;
     }
     if (int remainder = array.size() % 64) {
         tmp += QByteArray::fromRawData(array.data() + array.size() - remainder, remainder);
-        tmp += "\n";
+        tmp += ;
     }
 

trunk/src/network/ssl/qsslkey.cpp

@@ -120 +120 @@
         return;
 
-    void *phrase = passPhrase.isEmpty()
-        ? (void *)0
-        : (void *)passPhrase.constData();
+    void *phrase = (void *)passPhrase.constData();
 
     if (algorithm == QSsl::Rsa) {

trunk/src/network/ssl/qsslsocket.cpp

@@ -157 +157 @@
     will get emitted as soon as data has been written to the TCP socket.
 
+
+
+
+
+
+
+
+
+
+
     \sa QSslCertificate, QSslCipher, QSslError
 */
@@ -1110 +1120 @@
     Q_D(QSslSocket);
     d->configuration.ciphers.clear();
-    foreach (QString cipherName, ciphers.split(QLatin1String(":"),QString::SkipEmptyParts)) {
+    foreach (cipherName, ciphers.split(QLatin1String(":"),QString::SkipEmptyParts)) {
         for (int i = 0; i < 3; ++i) {
             // ### Crude

trunk/src/network/ssl/qsslsocket_openssl.cpp

@@ -819 +819 @@
             if (!regexp.exactMatch(peerName)) {
                 bool matched = false;
-                foreach (QString altName, configuration.peerCertificate
+                foreach (altName, configuration.peerCertificate
                          .alternateSubjectNames().values(QSsl::DnsEntry)) {
                     regexp.setPattern(altName);

trunk/src/network/ssl/qsslsocket_openssl_symbols.cpp

@@ -743 +743 @@
 bool q_resolveOpenSslSymbols()
 {
-#ifdef QT_NO_SSL
+#ifdef QT_NO_SSL
     return false;
 #endif