Merge branch 'symbian-socket-engine' into staging-master

25 files changed, 585 insertions, 66 deletions

diff --git a/src/corelib/kernel/qeventdispatcher_symbian.cpp b/src/corelib/kernel/qeventdispatcher_symbian.cpp
index e0eeb08..bd12726 100644
--- a/src/corelib/kernel/qeventdispatcher_symbian.cpp
+++ b/src/corelib/kernel/qeventdispatcher_symbian.cpp
@@ -1111,6 +1111,12 @@ bool QEventDispatcherSymbian::hasPendingEvents()
 
 void QEventDispatcherSymbian::registerSocketNotifier ( QSocketNotifier * notifier )
 {
+    //check socket descriptor is usable
+    if (notifier->socket() >= FD_SETSIZE || notifier->socket() < 0) {
+        //same warning message as the unix event dispatcher for easy testing
+        qWarning("QSocketNotifier: Internal error");
+        return;
+    }
     //note - this is only for "open C" file descriptors
     //for native sockets, an active object in the symbian socket engine handles this
     QSocketActiveObject *socketAO = new QSocketActiveObject(this, notifier);
diff --git a/src/network/access/qhttpnetworkconnection.cpp b/src/network/access/qhttpnetworkconnection.cpp
index 07dd729..a471559 100644
--- a/src/network/access/qhttpnetworkconnection.cpp
+++ b/src/network/access/qhttpnetworkconnection.cpp
@@ -519,6 +519,15 @@ bool QHttpNetworkConnectionPrivate::dequeueRequest(QAbstractSocket *socket)
     return false;
 }
 
+QHttpNetworkRequest QHttpNetworkConnectionPrivate::predictNextRequest()
+{
+    if (!highPriorityQueue.isEmpty())
+        return highPriorityQueue.last().first;
+    if (!lowPriorityQueue.isEmpty())
+        return lowPriorityQueue.last().first;
+    return QHttpNetworkRequest();
+}
+
 // this is called from _q_startNextRequest and when a request has been sent down a socket from the channel
 void QHttpNetworkConnectionPrivate::fillPipeline(QAbstractSocket *socket)
 {
diff --git a/src/network/access/qhttpnetworkconnection_p.h b/src/network/access/qhttpnetworkconnection_p.h
index adb779f4..329d3626 100644
--- a/src/network/access/qhttpnetworkconnection_p.h
+++ b/src/network/access/qhttpnetworkconnection_p.h
@@ -169,6 +169,7 @@ public:
     void requeueRequest(const HttpMessagePair &pair); // e.g. after pipeline broke
     bool dequeueRequest(QAbstractSocket *socket);
     void prepareRequest(HttpMessagePair &request);
+    QHttpNetworkRequest predictNextRequest();
 
     void fillPipeline(QAbstractSocket *socket);
     bool fillPipeline(QList<HttpMessagePair> &queue, QHttpNetworkConnectionChannel &channel);
diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
index 6fbc6f8..f440101 100644
--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
@@ -579,6 +579,17 @@ bool QHttpNetworkConnectionChannel::ensureConnection()
             connectHost = connection->d_func()->networkProxy.hostName();
             connectPort = connection->d_func()->networkProxy.port();
         }
+        if (socket->proxy().type() == QNetworkProxy::HttpProxy) {
+            // Make user-agent field available to HTTP proxy socket engine (QTBUG-17223)
+            QByteArray value;
+            // ensureConnection is called before any request has been assigned, but can also be called again if reconnecting
+            if (request.url().isEmpty())
+                value = connection->d_func()->predictNextRequest().headerField("user-agent");
+            else
+                value = request.headerField("user-agent");
+            if (!value.isEmpty())
+                socket->setProperty("_q_user-agent", value);
+        }
 #endif
         if (ssl) {
 #ifndef QT_NO_OPENSSL
diff --git a/src/network/access/qnetworkaccessbackend.cpp b/src/network/access/qnetworkaccessbackend.cpp
index 6220abe..2aea350 100644
--- a/src/network/access/qnetworkaccessbackend.cpp
+++ b/src/network/access/qnetworkaccessbackend.cpp
@@ -41,6 +41,7 @@
 
 #include "qnetworkaccessbackend_p.h"
 #include "qnetworkaccessmanager_p.h"
+#include "qnetworkconfigmanager.h"
 #include "qnetworkrequest.h"
 #include "qnetworkreply.h"
 #include "qnetworkreply_p.h"
@@ -343,8 +344,6 @@ void QNetworkAccessBackend::sslErrors(const QList<QSslError> &errors)
 #endif
 }
 
-#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
@@ -352,31 +351,62 @@ void QNetworkAccessBackend::sslErrors(const QList<QSslError> &errors)
 */
 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;
+#ifndef QT_NO_BEARERMANAGEMENT
+    // For bearer, check if session start is required
+    if (manager->networkSession) {
+        // session required
+        if (manager->networkSession->isOpen() &&
+            manager->networkSession->state() == QNetworkSession::Connected) {
+            // Session is already open and ready to use.
+            // copy network session down to the backend
+            setProperty("_q_networksession", QVariant::fromValue(manager->networkSession));
+        } else {
+            // Session not ready, but can skip for loopback connections
+
+            // 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.
+            } else {
+                // need to wait for session to be opened
+                return false;
+            }
+        }
     }
+#endif
 
-    if (manager->networkSession->isOpen() &&
-        manager->networkSession->state() == QNetworkSession::Connected) {
-        //copy network session down to the backend
-        setProperty("_q_networksession", QVariant::fromValue(manager->networkSession));
-        open();
-        return true;
+#ifndef QT_NO_NETWORKPROXY
+#ifndef QT_NO_BEARERMANAGEMENT
+    // Get the proxy settings from the network session (in the case of service networks,
+    // the proxy settings change depending which AP was activated)
+    QNetworkSession *session = manager->networkSession.data();
+    QNetworkConfiguration config;
+    if (session) {
+        QNetworkConfigurationManager configManager;
+        // The active configuration tells us what IAP is in use
+        QVariant v = session->sessionProperty(QLatin1String("ActiveConfiguration"));
+        if (v.isValid())
+            config = configManager.configurationFromIdentifier(qvariant_cast<QString>(v));
+        // Fallback to using the configuration if no active configuration
+        if (!config.isValid())
+            config = session->configuration();
+        // or unspecified configuration if that is no good either
+        if (!config.isValid())
+            config = QNetworkConfiguration();
     }
+    reply->proxyList = manager->queryProxy(QNetworkProxyQuery(config, url()));
+#else // QT_NO_BEARERMANAGEMENT
+    // Without bearer management, the proxy depends only on the url
+    reply->proxyList = manager->queryProxy(QNetworkProxyQuery(url()));
+#endif
+#endif
 
-    return false;
+    // now start the request
+    open();
+    return true;
 }
-#endif
 
 QT_END_NAMESPACE
diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index 0d7b52a..55d6a7c 100644
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@@ -986,10 +986,6 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
     // third step: find a backend
     priv->backend = d->findBackend(op, request);
 
-#ifndef QT_NO_NETWORKPROXY
-    QList<QNetworkProxy> proxyList = d->queryProxy(QNetworkProxyQuery(request.url()));
-    priv->proxyList = proxyList;
-#endif
     if (priv->backend) {
         priv->backend->setParent(reply);
         priv->backend->reply = priv;
diff --git a/src/network/access/qnetworkreplyimpl.cpp b/src/network/access/qnetworkreplyimpl.cpp
index 9eb505d..34fd7a7 100644
--- a/src/network/access/qnetworkreplyimpl.cpp
+++ b/src/network/access/qnetworkreplyimpl.cpp
@@ -90,10 +90,10 @@ void QNetworkReplyImplPrivate::_q_startOperation()
         return;
     }
 
+    if (!backend->start()) {
 #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
+        // QNetworkAccessManager will call _q_startOperation again for us when the session
         // state changes.
         state = WaitingForSession;
 
@@ -109,11 +109,20 @@ void QNetworkReplyImplPrivate::_q_startOperation()
                 session->open();
         } else {
             qWarning("Backend is waiting for QNetworkSession to connect, but there is none!");
+            state = Working;
+            error(QNetworkReplyImpl::UnknownNetworkError,
+                  QCoreApplication::translate("QNetworkReply", "Network session error."));
+            finished();
         }
-
+#else
+        qWarning("Backend start failed");
+        state = Working;
+        error(QNetworkReplyImpl::UnknownNetworkError,
+              QCoreApplication::translate("QNetworkReply", "backend start error."));
+        finished();
+#endif
         return;
     }
-#endif
 
     if (backend && backend->isSynchronous()) {
         state = Finished;
diff --git a/src/network/kernel/qnetworkproxy.cpp b/src/network/kernel/qnetworkproxy.cpp
index 68ff955..14db913 100644
--- a/src/network/kernel/qnetworkproxy.cpp
+++ b/src/network/kernel/qnetworkproxy.cpp
@@ -228,6 +228,10 @@
 #include "qmutex.h"
 #include "qurl.h"
 
+#ifndef QT_NO_BEARERMANAGEMENT
+#include <QtNetwork/QNetworkConfiguration>
+#endif
+
 QT_BEGIN_NAMESPACE
 
 class QSocks5SocketEngineHandler;
@@ -716,6 +720,9 @@ public:
     QUrl remote;
     int localPort;
     QNetworkProxyQuery::QueryType type;
+#ifndef QT_NO_BEARERMANAGEMENT
+    QNetworkConfiguration config;
+#endif
 };
 
 template<> void QSharedDataPointer<QNetworkProxyQueryPrivate>::detach()
@@ -777,6 +784,11 @@ template<> void QSharedDataPointer<QNetworkProxyQueryPrivate>::detach()
     like choosing an caching HTTP proxy for HTTP-based connections,
     but a more powerful SOCKSv5 proxy for all others.
 
+    The network configuration specifies which configuration to use,
+    when bearer management is used. For example on a mobile phone
+    the proxy settings are likely to be different for the cellular
+    network vs WLAN.
+
     Some of the criteria may not make sense in all of the types of
     query. The following table lists the criteria that are most
     commonly used, according to the type of query.
@@ -902,6 +914,68 @@ QNetworkProxyQuery::QNetworkProxyQuery(quint16 bindPort, const QString &protocol
     d->type = queryType;
 }
 
+#ifndef QT_NO_BEARERMANAGEMENT
+/*!
+    Constructs a QNetworkProxyQuery with the URL \a requestUrl and
+    sets the query type to \a queryType. The specified \a networkConfiguration
+    is used to resolve the proxy settings.
+
+    \sa protocolTag(), peerHostName(), peerPort(), networkConfiguration()
+*/
+QNetworkProxyQuery::QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
+                                       const QUrl &requestUrl, QueryType queryType)
+{
+    d->config = networkConfiguration;
+    d->remote = requestUrl;
+    d->type = queryType;
+}
+
+/*!
+    Constructs a QNetworkProxyQuery of type \a queryType and sets the
+    protocol tag to be \a protocolTag. This constructor is suitable
+    for QNetworkProxyQuery::TcpSocket queries, because it sets the
+    peer hostname to \a hostname and the peer's port number to \a
+    port. The specified \a networkConfiguration
+    is used to resolve the proxy settings.
+
+    \sa networkConfiguration()
+*/
+QNetworkProxyQuery::QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
+                                       const QString &hostname, int port,
+                                       const QString &protocolTag,
+                                       QueryType queryType)
+{
+    d->config = networkConfiguration;
+    d->remote.setScheme(protocolTag);
+    d->remote.setHost(hostname);
+    d->remote.setPort(port);
+    d->type = queryType;
+}
+
+/*!
+    Constructs a QNetworkProxyQuery of type \a queryType and sets the
+    protocol tag to be \a protocolTag. This constructor is suitable
+    for QNetworkProxyQuery::TcpSocket queries because it sets the
+    local port number to \a bindPort. The specified \a networkConfiguration
+    is used to resolve the proxy settings.
+
+    Note that \a bindPort is of type quint16 to indicate the exact
+    port number that is requested. The value of -1 (unknown) is not
+    allowed in this context.
+
+    \sa localPort(), networkConfiguration()
+*/
+QNetworkProxyQuery::QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
+                                       quint16 bindPort, const QString &protocolTag,
+                                       QueryType queryType)
+{
+    d->config = networkConfiguration;
+    d->remote.setScheme(protocolTag);
+    d->localPort = bindPort;
+    d->type = queryType;
+}
+#endif
+
 /*!
     Constructs a QNetworkProxyQuery object that is a copy of \a other.
 */
@@ -1116,6 +1190,30 @@ void QNetworkProxyQuery::setUrl(const QUrl &url)
     d->remote = url;
 }
 
+#ifndef QT_NO_BEARERMANAGEMENT
+QNetworkConfiguration QNetworkProxyQuery::networkConfiguration() const
+{
+    return d ? d->config : QNetworkConfiguration();
+}
+
+/*!
+    Sets the network configuration component of this QNetworkProxyQuery
+    object to be \a networkConfiguration. The network configuration can
+    be used to return different proxy settings based on the network in
+    use, for example WLAN vs cellular networks on a mobile phone.
+
+    In the case of "user choice" or "service network" configurations,
+    you should first start the QNetworkSession and obtain the active
+    configuration from its properties.
+
+    \sa networkConfiguration
+*/
+void QNetworkProxyQuery::setNetworkConfiguration(const QNetworkConfiguration &networkConfiguration)
+{
+    d->config = networkConfiguration;
+}
+#endif
+
 /*!
     \class QNetworkProxyFactory
     \brief The QNetworkProxyFactory class provides fine-grained proxy selection.
diff --git a/src/network/kernel/qnetworkproxy.h b/src/network/kernel/qnetworkproxy.h
index 26562d5..e16b29e 100644
--- a/src/network/kernel/qnetworkproxy.h
+++ b/src/network/kernel/qnetworkproxy.h
@@ -54,6 +54,7 @@ QT_BEGIN_NAMESPACE
 QT_MODULE(Network)
 
 class QUrl;
+class QNetworkConfiguration;
 
 class QNetworkProxyQueryPrivate;
 class Q_NETWORK_EXPORT QNetworkProxyQuery
@@ -73,6 +74,16 @@ public:
     QNetworkProxyQuery(quint16 bindPort, const QString &protocolTag = QString(),
                        QueryType queryType = TcpServer);
     QNetworkProxyQuery(const QNetworkProxyQuery &other);
+#ifndef QT_NO_BEARERMANAGEMENT
+    QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
+                       const QUrl &requestUrl, QueryType queryType = UrlRequest);
+    QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
+                       const QString &hostname, int port, const QString &protocolTag = QString(),
+                       QueryType queryType = TcpSocket);
+    QNetworkProxyQuery(const QNetworkConfiguration &networkConfiguration,
+                       quint16 bindPort, const QString &protocolTag = QString(),
+                       QueryType queryType = TcpServer);
+#endif
     ~QNetworkProxyQuery();
     QNetworkProxyQuery &operator=(const QNetworkProxyQuery &other);
     bool operator==(const QNetworkProxyQuery &other) const;
@@ -97,6 +108,11 @@ public:
     QUrl url() const;
     void setUrl(const QUrl &url);
 
+#ifndef QT_NO_BEARERMANAGEMENT
+    QNetworkConfiguration networkConfiguration() const;
+    void setNetworkConfiguration(const QNetworkConfiguration &networkConfiguration);
+#endif
+
 private:
     QSharedDataPointer<QNetworkProxyQueryPrivate> d;
 };
diff --git a/src/network/kernel/qnetworkproxy_symbian.cpp b/src/network/kernel/qnetworkproxy_symbian.cpp
index 79dfb27..4ba14c0 100644
--- a/src/network/kernel/qnetworkproxy_symbian.cpp
+++ b/src/network/kernel/qnetworkproxy_symbian.cpp
@@ -58,6 +58,7 @@
 #include <commsdattypeinfov1_1.h> // CCDIAPRecord, CCDProxiesRecord
 #include <commsdattypesv1_1.h> // KCDTIdIAPRecord, KCDTIdProxiesRecord
 #include <QtNetwork/QNetworkConfigurationManager>
+#include <QtNetwork/QNetworkConfiguration>
 #include <QFlags>
 
 using namespace CommsDat;
@@ -88,7 +89,7 @@ class SymbianProxyQuery
 {
 public:
     static QNetworkConfiguration findCurrentConfiguration(QNetworkConfigurationManager& configurationManager);
-    static SymbianIapId getIapId(QNetworkConfigurationManager& configurationManager);
+    static SymbianIapId getIapId(QNetworkConfigurationManager &configurationManager, const QNetworkProxyQuery &query);
     static CCDIAPRecord *getIapRecordLC(TUint32 aIAPId, CMDBSession &aDb);
     static CMDBRecordSet<CCDProxiesRecord> *prepareQueryLC(TUint32 serviceId, TDesC& serviceType);
     static QList<QNetworkProxy> proxyQueryL(TUint32 aIAPId, const QNetworkProxyQuery &query);
@@ -137,11 +138,15 @@ QNetworkConfiguration SymbianProxyQuery::findCurrentConfiguration(QNetworkConfig
     return currentConfig;
 }
 
-SymbianIapId SymbianProxyQuery::getIapId(QNetworkConfigurationManager& configurationManager)
+SymbianIapId SymbianProxyQuery::getIapId(QNetworkConfigurationManager& configurationManager, const QNetworkProxyQuery &query)
 {
     SymbianIapId iapId;
 
-    QNetworkConfiguration currentConfig = findCurrentConfiguration(configurationManager);
+    QNetworkConfiguration currentConfig = query.networkConfiguration();
+    if (!currentConfig.isValid()) {
+        //If config is not specified, then try to find out an active or default one
+        currentConfig = findCurrentConfiguration(configurationManager);
+    }
     if (currentConfig.isValid()) {
         // Note: the following code assumes that the identifier is in format
         // I_xxxx where xxxx is the identifier of IAP. This is meant as a
@@ -249,7 +254,7 @@ QList<QNetworkProxy> QNetworkProxyFactory::systemProxyForQuery(const QNetworkPro
     SymbianIapId iapId;
     TInt error;
     QNetworkConfigurationManager manager;
-    iapId = SymbianProxyQuery::getIapId(manager);
+    iapId = SymbianProxyQuery::getIapId(manager, query);
     if (iapId.isValid()) {
         TRAP(error, proxies = SymbianProxyQuery::proxyQueryL(iapId.iapId(), query))
         if (error != KErrNone) {
diff --git a/src/network/socket/qabstractsocket.cpp b/src/network/socket/qabstractsocket.cpp
index cfb1413..fc0bb85 100644
--- a/src/network/socket/qabstractsocket.cpp
+++ b/src/network/socket/qabstractsocket.cpp
@@ -547,15 +547,19 @@ bool QAbstractSocketPrivate::initSocketLayer(QAbstractSocket::NetworkLayerProtoc
 
     resetSocketLayer();
     socketEngine = QAbstractSocketEngine::createSocketEngine(q->socketType(), proxyInUse, q);
-#ifndef QT_NO_BEARERMANAGEMENT
-    //copy network session down to the socket engine (if it has been set)
-    socketEngine->setProperty("_q_networksession", q->property("_q_networksession"));
-#endif
     if (!socketEngine) {
         socketError = QAbstractSocket::UnsupportedSocketOperationError;
         q->setErrorString(QAbstractSocket::tr("Operation on socket is not supported"));
         return false;
     }
+#ifndef QT_NO_BEARERMANAGEMENT
+    //copy network session down to the socket engine (if it has been set)
+    socketEngine->setProperty("_q_networksession", q->property("_q_networksession"));
+#endif
+#ifndef QT_NO_NETWORKPROXY
+    //copy user agent to socket engine (if it has been set)
+    socketEngine->setProperty("_q_user-agent", q->property("_q_user-agent"));
+#endif
     if (!socketEngine->initialize(q->socketType(), protocol)) {
 #if defined (QABSTRACTSOCKET_DEBUG)
         qDebug("QAbstractSocketPrivate::initSocketLayer(%s, %s) failed (%s)",
@@ -1605,15 +1609,15 @@ bool QAbstractSocket::setSocketDescriptor(int socketDescriptor, SocketState sock
 
     d->resetSocketLayer();
     d->socketEngine = QAbstractSocketEngine::createSocketEngine(socketDescriptor, this);
-#ifndef QT_NO_BEARERMANAGEMENT
-    //copy network session down to the socket engine (if it has been set)
-    d->socketEngine->setProperty("_q_networksession", property("_q_networksession"));
-#endif
     if (!d->socketEngine) {
         d->socketError = UnsupportedSocketOperationError;
         setErrorString(tr("Operation on socket is not supported"));
         return false;
     }
+#ifndef QT_NO_BEARERMANAGEMENT
+    //copy network session down to the socket engine (if it has been set)
+    d->socketEngine->setProperty("_q_networksession", property("_q_networksession"));
+#endif
     bool result = d->socketEngine->initialize(socketDescriptor, socketState);
     if (!result) {
         d->socketError = d->socketEngine->error();
diff --git a/src/network/socket/qhttpsocketengine.cpp b/src/network/socket/qhttpsocketengine.cpp
index 7846056..a8a11a7 100644
--- a/src/network/socket/qhttpsocketengine.cpp
+++ b/src/network/socket/qhttpsocketengine.cpp
@@ -501,7 +501,13 @@ void QHttpSocketEngine::slotSocketConnected()
     data += path;
     data += " HTTP/1.1\r\n";
     data += "Proxy-Connection: keep-alive\r\n"
-            "User-Agent: Mozilla/5.0\r\n"
+            "User-Agent: ";
+    QVariant v = property("_q_user-agent");
+    if (v.isValid())
+        data += v.toByteArray();
+    else
+        data += "Mozilla/5.0";
+    data += "\r\n"
             "Host: " + peerAddress + "\r\n";
     QAuthenticatorPrivate *priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
     //qDebug() << "slotSocketConnected: priv=" << priv << (priv ? (int)priv->method : -1);
diff --git a/src/network/socket/qsocks5socketengine.cpp b/src/network/socket/qsocks5socketengine.cpp
index c365635..88b5aca 100644
--- a/src/network/socket/qsocks5socketengine.cpp
+++ b/src/network/socket/qsocks5socketengine.cpp
@@ -1540,8 +1540,13 @@ qint64 QSocks5SocketEngine::write(const char *data, qint64 len)
             // ### Handle this error.
         }
 
-        d->data->controlSocket->write(sealedBuf);
+        qint64 written = d->data->controlSocket->write(sealedBuf);
+        if (written <= 0) {
+            QSOCKS5_Q_DEBUG << "native write returned" << written;
+            return written;
+        }
         d->data->controlSocket->waitForBytesWritten(0);
+        //NB: returning len rather than written for the OK case, because the "sealing" may increase the length
         return len;
 #ifndef QT_NO_UDPSOCKET
     } else if (d->mode == QSocks5SocketEnginePrivate::UdpAssociateMode) {
diff --git a/src/network/socket/qsymbiansocketengine.cpp b/src/network/socket/qsymbiansocketengine.cpp
index f1b2982..b6d12fe 100644
--- a/src/network/socket/qsymbiansocketengine.cpp
+++ b/src/network/socket/qsymbiansocketengine.cpp
@@ -251,7 +251,8 @@ QSymbianSocketEnginePrivate::QSymbianSocketEnginePrivate() :
     readNotificationsEnabled(false),
     writeNotificationsEnabled(false),
     exceptNotificationsEnabled(false),
-    asyncSelect(0)
+    asyncSelect(0),
+    hasReceivedBufferedDatagram(false)
 {
 }
 
@@ -781,21 +782,34 @@ qint64 QSymbianSocketEngine::pendingDatagramSize() const
     Q_D(const QSymbianSocketEngine);
     Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::pendingDatagramSize(), false);
     Q_CHECK_TYPE(QSymbianSocketEngine::hasPendingDatagrams(), QAbstractSocket::UdpSocket, false);
-    int nbytes;
+    //can only buffer one datagram at a time
+    if (d->hasReceivedBufferedDatagram)
+        return d->receivedDataBuffer.size();
+    int nbytes = 0;
     TInt err = d->nativeSocket.GetOpt(KSOReadBytesPending,KSOLSocket, nbytes);
     if (nbytes > 0) {
         //nbytes includes IP header, which is of variable length (IPv4 with or without options, IPv6...)
-        QByteArray next(nbytes,0);
-        TPtr8 buffer((TUint8*)next.data(), next.size());
+        //therefore read the datagram into a buffer to find its true size
+        d->receivedDataBuffer.resize(nbytes);
+        TPtr8 buffer((TUint8*)d->receivedDataBuffer.data(), nbytes);
+        //nbytes = size including IP header, buffer is a pointer descriptor backed by the receivedDataBuffer
         TInetAddr addr;
         TRequestStatus status;
-        //TODO: rather than peek, should we save this for next call to readDatagram?
-        //what if calls don't match though?
-        d->nativeSocket.RecvFrom(buffer, addr, KSockReadPeek, status);
+        //RecvFrom copies only the payload (we don't want the header so don't specify the option to retrieve it)
+        d->nativeSocket.RecvFrom(buffer, addr, 0, status);
         User::WaitForRequest(status);
-        if (status.Int())
+        if (status != KErrNone) {
+            d->receivedDataBuffer.clear();
             return 0;
-        return buffer.Length();
+        }
+        nbytes = buffer.Length();
+        //nbytes = size of payload, resize the receivedDataBuffer to the final size
+        d->receivedDataBuffer.resize(nbytes);
+        d->hasReceivedBufferedDatagram = true;
+        //now receivedDataBuffer contains one datagram, which has been removed from the socket's internal buffer
+#if defined (QNATIVESOCKETENGINE_DEBUG)
+        qDebug() << "QSymbianSocketEngine::pendingDatagramSize buffering" << nbytes << "bytes";
+#endif
     }
     return qint64(nbytes);
 }
@@ -807,6 +821,19 @@ qint64 QSymbianSocketEngine::readDatagram(char *data, qint64 maxSize,
     Q_D(QSymbianSocketEngine);
     Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::readDatagram(), -1);
     Q_CHECK_TYPE(QSymbianSocketEngine::readDatagram(), QAbstractSocket::UdpSocket, false);
+
+    // if a datagram was buffered in pendingDatagramSize(), return it now
+    if (d->hasReceivedBufferedDatagram) {
+        qint64 size = qMin(maxSize, (qint64)d->receivedDataBuffer.size());
+        memcpy(data, d->receivedDataBuffer.constData(), size);
+        d->receivedDataBuffer.clear();
+        d->hasReceivedBufferedDatagram = false;
+#if defined (QNATIVESOCKETENGINE_DEBUG)
+        qDebug() << "QSymbianSocketEngine::readDatagram returning" << size << "bytes from buffer";
+#endif
+        return size;
+    }
+
     TPtr8 buffer((TUint8*)data, (int)maxSize);
     TInetAddr addr;
     TRequestStatus status;
@@ -985,6 +1012,9 @@ void QSymbianSocketEngine::close()
     d->localAddress.clear();
     d->peerPort = 0;
     d->peerAddress.clear();
+
+    d->hasReceivedBufferedDatagram = false;
+    d->receivedDataBuffer.clear();
 }
 
 qint64 QSymbianSocketEngine::write(const char *data, qint64 len)
@@ -1036,6 +1066,18 @@ qint64 QSymbianSocketEngine::read(char *data, qint64 maxSize)
     Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::read(), -1);
     Q_CHECK_STATES(QSymbianSocketEngine::read(), QAbstractSocket::ConnectedState, QAbstractSocket::BoundState, -1);
 
+    // if a datagram was buffered in pendingDatagramSize(), return it now
+    if (d->hasReceivedBufferedDatagram) {
+        qint64 size = qMin(maxSize, (qint64)d->receivedDataBuffer.size());
+        memcpy(data, d->receivedDataBuffer.constData(), size);
+        d->receivedDataBuffer.clear();
+        d->hasReceivedBufferedDatagram = false;
+#if defined (QNATIVESOCKETENGINE_DEBUG)
+        qDebug() << "QSymbianSocketEngine::read returning" << size << "bytes from buffer";
+#endif
+        return size;
+    }
+
     TPtr8 buffer((TUint8*)data, (int)maxSize);
     TSockXfrLength received = 0;
     TRequestStatus status;
@@ -1440,6 +1482,7 @@ void QSymbianSocketEngine::startNotifications()
         qDebug() << "QSymbianSocketEngine::startNotifications" << d->readNotificationsEnabled << d->writeNotificationsEnabled << d->exceptNotificationsEnabled;
 #endif
     if (!d->asyncSelect && (d->readNotificationsEnabled || d->writeNotificationsEnabled || d->exceptNotificationsEnabled)) {
+        Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::startNotifications(), Q_VOID);
         if (d->threadData->eventDispatcher) {
             d->asyncSelect = q_check_ptr(new QAsyncSelect(
                 static_cast<QEventDispatcherSymbian*> (d->threadData->eventDispatcher), d->nativeSocket,
@@ -1456,14 +1499,12 @@ void QSymbianSocketEngine::startNotifications()
 bool QSymbianSocketEngine::isReadNotificationEnabled() const
 {
     Q_D(const QSymbianSocketEngine);
-    Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::isReadNotificationEnabled(), false);
     return d->readNotificationsEnabled;
 }
 
 void QSymbianSocketEngine::setReadNotificationEnabled(bool enable)
 {
     Q_D(QSymbianSocketEngine);
-    Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::setReadNotificationEnabled(), Q_VOID);
 #ifdef QNATIVESOCKETENGINE_DEBUG
     qDebug() << "QSymbianSocketEngine::setReadNotificationEnabled" << enable << "socket" << d->socketDescriptor;
 #endif
@@ -1474,14 +1515,12 @@ void QSymbianSocketEngine::setReadNotificationEnabled(bool enable)
 bool QSymbianSocketEngine::isWriteNotificationEnabled() const
 {
     Q_D(const QSymbianSocketEngine);
-    Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::isWriteNotificationEnabled(), false);
     return d->writeNotificationsEnabled;
 }
 
 void QSymbianSocketEngine::setWriteNotificationEnabled(bool enable)
 {
     Q_D(QSymbianSocketEngine);
-    Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::setWriteNotificationEnabled(), Q_VOID);
 #ifdef QNATIVESOCKETENGINE_DEBUG
     qDebug() << "QSymbianSocketEngine::setWriteNotificationEnabled" << enable << "socket" << d->socketDescriptor;
 #endif
@@ -1492,7 +1531,6 @@ void QSymbianSocketEngine::setWriteNotificationEnabled(bool enable)
 bool QSymbianSocketEngine::isExceptionNotificationEnabled() const
 {
     Q_D(const QSymbianSocketEngine);
-    Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::isExceptionNotificationEnabled(), false);
     return d->exceptNotificationsEnabled;
     return false;
 }
@@ -1500,7 +1538,6 @@ bool QSymbianSocketEngine::isExceptionNotificationEnabled() const
 void QSymbianSocketEngine::setExceptionNotificationEnabled(bool enable)
 {
     Q_D(QSymbianSocketEngine);
-    Q_CHECK_VALID_SOCKETLAYER(QSymbianSocketEngine::setExceptionNotificationEnabled(), Q_VOID);
 #ifdef QNATIVESOCKETENGINE_DEBUG
     qDebug() << "QSymbianSocketEngine::setExceptionNotificationEnabled" << enable << "socket" << d->socketDescriptor;
 #endif
@@ -1660,6 +1697,9 @@ void QAsyncSelect::run()
     //when event loop disabled socket events, defer until later
     if (maybeDeferSocketEvent())
         return;
+#if defined (QNATIVESOCKETENGINE_DEBUG)
+    qDebug() << "QAsyncSelect::run" << m_selectBuf() << m_selectFlags;
+#endif
     m_inSocketEvent = true;
     m_selectBuf() &= m_selectFlags; //the select ioctl reports everything, so mask to only what we requested
     //KSockSelectReadContinuation is for reading datagrams in a mode that doesn't discard when the
diff --git a/src/network/socket/qsymbiansocketengine_p.h b/src/network/socket/qsymbiansocketengine_p.h
index 85ab54a..2e7c155 100644
--- a/src/network/socket/qsymbiansocketengine_p.h
+++ b/src/network/socket/qsymbiansocketengine_p.h
@@ -196,6 +196,8 @@ public:
     bool exceptNotificationsEnabled;
     QAsyncSelect* asyncSelect;
 
+    mutable QByteArray receivedDataBuffer;
+    mutable bool hasReceivedBufferedDatagram;
     // FIXME this is duplicated from qnativesocketengine_p.h
     enum ErrorString {
         NonBlockingInitFailedErrorString,
diff --git a/src/network/socket/qtcpserver.cpp b/src/network/socket/qtcpserver.cpp
index 5a60764..026ceb4 100644
--- a/src/network/socket/qtcpserver.cpp
+++ b/src/network/socket/qtcpserver.cpp
@@ -416,6 +416,11 @@ bool QTcpServer::setSocketDescriptor(int socketDescriptor)
     if (d->socketEngine)
         delete d->socketEngine;
     d->socketEngine = QAbstractSocketEngine::createSocketEngine(socketDescriptor, this);
+    if (!d->socketEngine) {
+        d->serverSocketError = QAbstractSocket::UnsupportedSocketOperationError;
+        d->serverSocketErrorString = tr("Operation on socket is not supported");
+        return false;
+    }
 #ifndef QT_NO_BEARERMANAGEMENT
     //copy network session down to the socket engine (if it has been set)
     d->socketEngine->setProperty("_q_networksession", property("_q_networksession"));
diff --git a/src/network/ssl/qsslsocket.cpp b/src/network/ssl/qsslsocket.cpp
index 0dbf4b5..2695df1 100644
--- a/src/network/ssl/qsslsocket.cpp
+++ b/src/network/ssl/qsslsocket.cpp
@@ -1736,6 +1736,8 @@ void QSslSocket::connectToHostImplementation(const QString &hostName, quint16 po
     }
 #ifndef QT_NO_NETWORKPROXY
     d->plainSocket->setProxy(proxy());
+    //copy user agent down to the plain socket (if it has been set)
+    d->plainSocket->setProperty("_q_user-agent", property("_q_user-agent"));
 #endif
     QIODevice::open(openMode);
     d->plainSocket->connectToHost(hostName, port, openMode);
diff --git a/tests/auto/qnetworkproxyfactory/qnetworkproxyfactory.pro b/tests/auto/qnetworkproxyfactory/qnetworkproxyfactory.pro
index f05c423..17ad403 100644
--- a/tests/auto/qnetworkproxyfactory/qnetworkproxyfactory.pro
+++ b/tests/auto/qnetworkproxyfactory/qnetworkproxyfactory.pro
@@ -7,5 +7,5 @@ QT = core network
 
 SOURCES += tst_qnetworkproxyfactory.cpp
 
-symbian: TARGET.CAPABILITY = NetworkServices
+symbian: TARGET.CAPABILITY = NetworkServices ReadUserData
 
diff --git a/tests/auto/qnetworkproxyfactory/tst_qnetworkproxyfactory.cpp b/tests/auto/qnetworkproxyfactory/tst_qnetworkproxyfactory.cpp
index 2baee27..82a4193 100644
--- a/tests/auto/qnetworkproxyfactory/tst_qnetworkproxyfactory.cpp
+++ b/tests/auto/qnetworkproxyfactory/tst_qnetworkproxyfactory.cpp
@@ -41,20 +41,60 @@
 
 
 #include <QtTest/QTest>
+#include <QtTest/QTestEventLoop>
 
 #include <qcoreapplication.h>
 #include <qdebug.h>
 #include <qnetworkproxy.h>
+#include <QNetworkConfiguration>
+#include <QNetworkConfigurationManager>
+#include <QNetworkSession>
+#include <QNetworkAccessManager>
+#include <QNetworkReply>
+#include <QNetworkRequest>
+#include <QList>
+
+Q_DECLARE_METATYPE(QNetworkConfiguration);
+Q_DECLARE_METATYPE(QList<QNetworkProxy>);
 
 class tst_QNetworkProxyFactory : public QObject {
     Q_OBJECT
+
+public:
+    tst_QNetworkProxyFactory();
+
+    class QDebugProxyFactory : public QNetworkProxyFactory
+    {
+    public:
+        virtual QList<QNetworkProxy> queryProxy(const QNetworkProxyQuery &query = QNetworkProxyQuery())
+        {
+            returnedList = QNetworkProxyFactory::systemProxyForQuery(query);
+            requestCounter++;
+            return returnedList;
+        }
+        QList<QNetworkProxy> returnedList;
+        int requestCounter;
+    };
+
 private slots:
     void systemProxyForQuery() const;
+#ifndef QT_NO_BEARERMANAGEMENT
+    void fromConfigurations();
+    void inNetworkAccessManager_data();
+    void inNetworkAccessManager();
+#endif
 
 private:
     QString formatProxyName(const QNetworkProxy & proxy) const;
+    QDebugProxyFactory *factory;
 };
 
+tst_QNetworkProxyFactory::tst_QNetworkProxyFactory()
+{
+    factory = new QDebugProxyFactory;
+    QNetworkProxyFactory::setApplicationProxyFactory(factory);
+}
+
 QString tst_QNetworkProxyFactory::formatProxyName(const QNetworkProxy & proxy) const
 {
     QString proxyName;
@@ -96,5 +136,109 @@ void tst_QNetworkProxyFactory::systemProxyForQuery() const
         QFAIL("One or more system proxy lookup failures occurred.");
 }
 
+#ifndef QT_NO_BEARERMANAGEMENT
+
+//Purpose of this test is just to check systemProxyForQuery doesn't hang or crash
+//with any given configuration including no configuration.
+//We can't test it returns the right proxies without implementing the native proxy code
+//again here, which would be testing our implementation against itself.
+//Therefore it's just testing that something valid is returned (at least a NoProxy entry)
+void tst_QNetworkProxyFactory::fromConfigurations()
+{
+    QNetworkConfigurationManager manager;
+    QList<QNetworkProxy> proxies;
+    QUrl url(QLatin1String("http://qt.nokia.com"));
+    //get from known configurations
+    foreach (QNetworkConfiguration config, manager.allConfigurations()) {
+        QNetworkProxyQuery query(config, url, QNetworkProxyQuery::UrlRequest);
+        proxies = QNetworkProxyFactory::systemProxyForQuery(query);
+        QVERIFY(!proxies.isEmpty());
+        foreach (QNetworkProxy proxy, proxies) {
+            qDebug() << config.name() << " - " << config.identifier() << " - " << formatProxyName(proxy);
+        }
+    }
+
+    //get from default configuration
+    QNetworkProxyQuery defaultquery(url, QNetworkProxyQuery::UrlRequest);
+    proxies = QNetworkProxyFactory::systemProxyForQuery(defaultquery);
+    QVERIFY(!proxies.isEmpty());
+    foreach (QNetworkProxy proxy, proxies) {
+        qDebug() << "default - " << formatProxyName(proxy);
+    }
+
+    //get from active configuration
+    QNetworkSession session(manager.defaultConfiguration());
+    session.open();
+    QVERIFY(session.waitForOpened(30000));
+    proxies = QNetworkProxyFactory::systemProxyForQuery(defaultquery);
+    QVERIFY(!proxies.isEmpty());
+    foreach (QNetworkProxy proxy, proxies) {
+        qDebug() << "active - " << formatProxyName(proxy);
+    }
+
+    //get from known configurations while there is one active
+    foreach (QNetworkConfiguration config, manager.allConfigurations()) {
+        QNetworkProxyQuery query(config, url, QNetworkProxyQuery::UrlRequest);
+        proxies = QNetworkProxyFactory::systemProxyForQuery(query);
+        QVERIFY(!proxies.isEmpty());
+        foreach (QNetworkProxy proxy, proxies) {
+            qDebug() << config.name() << " - " << config.identifier() << " - " << formatProxyName(proxy);
+        }
+    }
+}
+
+void tst_QNetworkProxyFactory::inNetworkAccessManager_data()
+{
+    QTest::addColumn<QNetworkConfiguration>("config");
+    QTest::addColumn<QList<QNetworkProxy> >("proxies");
+    QNetworkConfigurationManager manager;
+    //get from known configurations
+    foreach (QNetworkConfiguration config, manager.allConfigurations()) {
+        QNetworkProxyQuery query(config, QUrl(QString("http://qt.nokia.com")), QNetworkProxyQuery::UrlRequest);
+        QList<QNetworkProxy> proxies = QNetworkProxyFactory::systemProxyForQuery(query);
+        QTest::newRow(config.name().toUtf8()) << config << proxies;
+    }
+}
+
+//Purpose of this test is to check that QNetworkAccessManager uses the proxy from the configuration it
+//has been given. Needs two or more working configurations to be a good test.
+void tst_QNetworkProxyFactory::inNetworkAccessManager()
+{
+    QFETCH(QNetworkConfiguration, config);
+    QFETCH(QList<QNetworkProxy>, proxies);
+
+    int count = factory->requestCounter;
+
+    QNetworkAccessManager manager;
+    manager.setConfiguration(config);
+
+    //using an internet server, because cellular APs won't have a route to the test server.
+    QNetworkRequest req(QUrl(QString("http://qt.nokia.com")));
+    QNetworkReply *reply = manager.get(req);
+    connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    QTestEventLoop::instance().enterLoop(30);
+    delete reply;
+
+    if (count == factory->requestCounter) {
+        //RND phones are preconfigured with several test access points which won't work without a matching SIM
+        //If the network fails to start, QNAM won't ask the factory for proxies so we can't test.
+        QSKIP("network configuration didn't start", SkipSingle);
+    }
+
+    qDebug() << "testing network configuration for" << config.name();
+    foreach (QNetworkProxy proxy, factory->returnedList) {
+        qDebug() << formatProxyName(proxy);
+    }
+    qDebug() << " <vs> ";
+    foreach (QNetworkProxy proxy, proxies) {
+        qDebug() << formatProxyName(proxy);
+    }
+    if (config.type() != QNetworkConfiguration::InternetAccessPoint)
+        QEXPECT_FAIL("","QNetworkProxyFactory::systemProxyForQuery doesn't work for service networks yet", Continue);
+    QCOMPARE(factory->returnedList, proxies);
+}
+
+#endif //QT_NO_BEARERMANAGEMENT
+
 QTEST_MAIN(tst_QNetworkProxyFactory)
 #include "tst_qnetworkproxyfactory.moc"
diff --git a/tests/auto/qnetworkreply/tst_qnetworkreply.cpp b/tests/auto/qnetworkreply/tst_qnetworkreply.cpp
index bf1feaf..feb8204 100644
--- a/tests/auto/qnetworkreply/tst_qnetworkreply.cpp
+++ b/tests/auto/qnetworkreply/tst_qnetworkreply.cpp
@@ -4103,6 +4103,7 @@ void tst_QNetworkReply::ioPostToHttpFromMiddleOfQBufferFiveBytes()
 
     QUrl url = "http://" + QtNetworkSettings::serverName() + "/qtest/protected/cgi-bin/md5sum.cgi";
     QNetworkRequest request(url);
+    request.setRawHeader("Content-Type", "application/octet-stream");
     QNetworkReplyPtr reply = manager.post(request, &uploadBuffer);
 
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
@@ -4353,6 +4354,7 @@ void tst_QNetworkReply::ioPostToHttpUploadProgress()
     // create the request
     QUrl url = QUrl(QString("http://127.0.0.1:%1/").arg(server.serverPort()));
     QNetworkRequest request(url);
+    request.setRawHeader("Content-Type", "application/octet-stream");
     QNetworkReplyPtr reply = manager.post(request, &sourceFile);
     QSignalSpy spy(reply, SIGNAL(uploadProgress(qint64,qint64)));
     connect(&server, SIGNAL(newConnection()), &QTestEventLoop::instance(), SLOT(exitLoop()));
@@ -4964,17 +4966,24 @@ void tst_QNetworkReply::httpProxyCommands()
     QNetworkProxy proxy(QNetworkProxy::HttpProxy, "127.0.0.1", proxyServer.serverPort());
 
     manager.setProxy(proxy);
-    QNetworkReplyPtr reply = manager.get(QNetworkRequest(url));
-    manager.setProxy(QNetworkProxy());
+    QNetworkRequest request(url);
+    request.setRawHeader("User-Agent", "QNetworkReplyAutoTest/1.0");
+    QNetworkReplyPtr reply = manager.get(request);
+    //clearing the proxy here causes the test to fail.
+    //the proxy isn't used until after the bearer has been started
+    //which is correct in general, because system proxy isn't known until that time.
+    //removing this line is safe, as the proxy is also reset by the cleanup() function
+    //manager.setProxy(QNetworkProxy());
 
     // wait for the finished signal
     connect(reply, SIGNAL(finished()), &QTestEventLoop::instance(), SLOT(exitLoop()));
 
-    QTestEventLoop::instance().enterLoop(1);
+    QTestEventLoop::instance().enterLoop(15);
 
     QVERIFY(!QTestEventLoop::instance().timeout());
 
     //qDebug() << reply->error() << reply->errorString();
+    //qDebug() << proxyServer.receivedData;
 
     // we don't really care if the request succeeded
     // especially since it won't succeed in the HTTPS case
@@ -4982,6 +4991,12 @@ void tst_QNetworkReply::httpProxyCommands()
 
     QString receivedHeader = proxyServer.receivedData.left(expectedCommand.length());
     QCOMPARE(receivedHeader, expectedCommand);
+
+    //QTBUG-17223 - make sure the user agent from the request is sent to proxy server even for CONNECT
+    int uapos = proxyServer.receivedData.indexOf("User-Agent");
+    int uaend = proxyServer.receivedData.indexOf("\r\n", uapos);
+    QByteArray uaheader = proxyServer.receivedData.mid(uapos, uaend - uapos);
+    QCOMPARE(uaheader, QByteArray("User-Agent: QNetworkReplyAutoTest/1.0"));
 }
 
 class ProxyChangeHelper : public QObject {
diff --git a/tests/auto/qsocketnotifier/qsocketnotifier.pro b/tests/auto/qsocketnotifier/qsocketnotifier.pro
index c43c96a..27484c8 100644
--- a/tests/auto/qsocketnotifier/qsocketnotifier.pro
+++ b/tests/auto/qsocketnotifier/qsocketnotifier.pro
@@ -4,7 +4,7 @@ QT = core network
 
 requires(contains(QT_CONFIG,private_tests))
 
-include(../qnativesocketengine/qsocketengine.pri)
+include(../platformsocketengine/platformsocketengine.pri)
 
 symbian: TARGET.CAPABILITY = NetworkServices
 
diff --git a/tests/auto/qsocketnotifier/tst_qsocketnotifier.cpp b/tests/auto/qsocketnotifier/tst_qsocketnotifier.cpp
index 5594dc3..f966e7f 100644
--- a/tests/auto/qsocketnotifier/tst_qsocketnotifier.cpp
+++ b/tests/auto/qsocketnotifier/tst_qsocketnotifier.cpp
@@ -53,6 +53,11 @@
 #include <private/qnativesocketengine_p.h>
 #define NATIVESOCKETENGINE QNativeSocketEngine
 #endif
+#ifdef Q_OS_UNIX
+#include <private/qnet_unix_p.h>
+#endif
+#include <limits>
+#include <select.h>
 
 class tst_QSocketNotifier : public QObject
 {
@@ -64,6 +69,8 @@ public:
 private slots:
     void unexpectedDisconnection();
     void mixingWithTimers();
+    void posixSockets();
+    void bogusFds();
 };
 
 tst_QSocketNotifier::tst_QSocketNotifier()
@@ -114,6 +121,9 @@ signals:
 
 void tst_QSocketNotifier::unexpectedDisconnection()
 {
+#ifdef Q_OS_SYMBIAN
+    QSKIP("Symbian socket engine pseudo descriptors can't be used for QSocketNotifier", SkipAll);
+#else
     /*
       Given two sockets and two QSocketNotifiers registered on each
       their socket. If both sockets receive data, and the first slot
@@ -163,10 +173,14 @@ void tst_QSocketNotifier::unexpectedDisconnection()
 
     UnexpectedDisconnectTester tester(&readEnd1, &readEnd2);
 
+    QTimer timer;
+    timer.setSingleShot(true);
+    timer.start(30000);
     do {
         // we have to wait until sequence value changes
         // as any event can make us jump out processing
         QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
+        QVERIFY(timer.isActive); //escape if test would hang
     }  while(tester.sequence <= 0);
 
     QVERIFY(readEnd1.state() == QAbstractSocket::ConnectedState);
@@ -179,6 +193,7 @@ void tst_QSocketNotifier::unexpectedDisconnection()
     writeEnd1->close();
     writeEnd2->close();
     server.close();
+#endif
 }
 
 class MixingWithTimersHelper : public QObject
@@ -243,5 +258,99 @@ void tst_QSocketNotifier::mixingWithTimers()
     QCOMPARE(helper.socketActivated, true);
 }
 
+void tst_QSocketNotifier::posixSockets()
+{
+#ifndef Q_OS_UNIX
+    QSKIP("test only for posix", SkipAll);
+#else
+
+    QTcpServer server;
+    QVERIFY(server.listen(QHostAddress::LocalHost, 0));
+
+    int posixSocket = qt_safe_socket(AF_INET, SOCK_STREAM, 0);
+    sockaddr_in addr;
+    addr.sin_addr.s_addr = htonl(0x7f000001);
+    addr.sin_family = AF_INET;
+    addr.sin_port = htons(server.serverPort());
+    qt_safe_connect(posixSocket, (const struct sockaddr*)&addr, sizeof(sockaddr_in));
+    QVERIFY(server.waitForNewConnection(5000));
+    QScopedPointer<QTcpSocket> passive(server.nextPendingConnection());
+
+    ::fcntl(posixSocket, F_SETFL, ::fcntl(posixSocket, F_GETFL) | O_NONBLOCK);
+
+    {
+        QSocketNotifier rn(posixSocket, QSocketNotifier::Read);
+        connect(&rn, SIGNAL(activated(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+        QSignalSpy readSpy(&rn, SIGNAL(activated(int)));
+        QSocketNotifier wn(posixSocket, QSocketNotifier::Write);
+        connect(&wn, SIGNAL(activated(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+        QSignalSpy writeSpy(&wn, SIGNAL(activated(int)));
+        QSocketNotifier en(posixSocket, QSocketNotifier::Exception);
+        connect(&en, SIGNAL(activated(int)), &QTestEventLoop::instance(), SLOT(exitLoop()));
+        QSignalSpy errorSpy(&en, SIGNAL(activated(int)));
+
+        passive->write("hello",6);
+        passive->waitForBytesWritten(5000);
+
+        QTestEventLoop::instance().enterLoop(3);
+        QCOMPARE(readSpy.count(), 1);
+        QCOMPARE(writeSpy.count(), 0);
+        QCOMPARE(errorSpy.count(), 0);
+
+        char buffer[100];
+        qt_safe_read(posixSocket, buffer, 100);
+        QCOMPARE(buffer, "hello");
+
+        qt_safe_write(posixSocket, "goodbye", 8);
+
+        QTestEventLoop::instance().enterLoop(3);
+        QCOMPARE(readSpy.count(), 1);
+        QCOMPARE(writeSpy.count(), 1);
+        QCOMPARE(errorSpy.count(), 0);
+        QCOMPARE(passive->readAll(), QByteArray("goodbye",8));
+    }
+    qt_safe_close(posixSocket);
+#endif
+}
+
+void tst_QSocketNotifier::bogusFds()
+{
+#ifndef Q_OS_WIN
+    QTest::ignoreMessage(QtWarningMsg, "QSocketNotifier: Internal error");
+#endif
+    QSocketNotifier max(std::numeric_limits<int>::max(), QSocketNotifier::Read);
+    QTest::ignoreMessage(QtWarningMsg, "QSocketNotifier: Invalid socket specified");
+#ifndef Q_OS_WIN
+    QTest::ignoreMessage(QtWarningMsg, "QSocketNotifier: Internal error");
+#endif
+    QSocketNotifier min(std::numeric_limits<int>::min(), QSocketNotifier::Write);
+#ifndef Q_OS_WIN
+    QTest::ignoreMessage(QtWarningMsg, "QSocketNotifier: Internal error");
+#endif
+    //bogus magic number is the first pseudo socket descriptor from symbian socket engine.
+    QSocketNotifier bogus(0x40000000, QSocketNotifier::Exception);
+    QSocketNotifier largestlegal(FD_SETSIZE - 1, QSocketNotifier::Read);
+
+    QSignalSpy maxspy(&max, SIGNAL(activated(int)));
+    QSignalSpy minspy(&min, SIGNAL(activated(int)));
+    QSignalSpy bogspy(&bogus, SIGNAL(activated(int)));
+    QSignalSpy llspy(&largestlegal, SIGNAL(activated(int)));
+
+    //generate some unrelated socket activity
+    QTcpServer server;
+    QVERIFY(server.listen(QHostAddress::LocalHost));
+    connect(&server, SIGNAL(newConnection()), &QTestEventLoop::instance(), SLOT(exitLoop()));
+    QTcpSocket client;
+    client.connectToHost(QHostAddress::LocalHost, server.serverPort());
+    QTestEventLoop::instance().enterLoop(5);
+    QVERIFY(server.hasPendingConnections());
+
+    //check no activity on bogus notifiers
+    QCOMPARE(maxspy.count(), 0);
+    QCOMPARE(minspy.count(), 0);
+    QCOMPARE(bogspy.count(), 0);
+    QCOMPARE(llspy.count(), 0);
+}
+
 QTEST_MAIN(tst_QSocketNotifier)
 #include <tst_qsocketnotifier.moc>
diff --git a/tests/auto/qtcpserver/tst_qtcpserver.cpp b/tests/auto/qtcpserver/tst_qtcpserver.cpp
index 9cddc00..2cd870f 100644
--- a/tests/auto/qtcpserver/tst_qtcpserver.cpp
+++ b/tests/auto/qtcpserver/tst_qtcpserver.cpp
@@ -430,6 +430,9 @@ void tst_QTcpServer::waitForConnectionTest()
 void tst_QTcpServer::setSocketDescriptor()
 {
     QTcpServer server;
+#ifdef Q_OS_SYMBIAN
+    QTest::ignoreMessage(QtWarningMsg, "QSymbianSocketEngine::initialize - socket descriptor not found");
+#endif
     QVERIFY(!server.setSocketDescriptor(42));
     QCOMPARE(server.serverError(), QAbstractSocket::UnsupportedSocketOperationError);
 #ifndef Q_OS_SYMBIAN
diff --git a/tests/auto/qtcpsocket/test/test.pro b/tests/auto/qtcpsocket/test/test.pro
index f4207d6..7bf5ba0 100644
--- a/tests/auto/qtcpsocket/test/test.pro
+++ b/tests/auto/qtcpsocket/test/test.pro
@@ -13,7 +13,7 @@ vxworks:QT -= gui
 
 symbian: {
     TARGET.EPOCHEAPSIZE="0x100 0x3000000"
-    TARGET.CAPABILITY = NetworkServices
+    TARGET.CAPABILITY = NetworkServices ReadUserData
 }
 
 TARGET = tst_qtcpsocket
diff --git a/tests/auto/qtcpsocket/tst_qtcpsocket.cpp b/tests/auto/qtcpsocket/tst_qtcpsocket.cpp
index 623e02b..f83c4cf 100644
--- a/tests/auto/qtcpsocket/tst_qtcpsocket.cpp
+++ b/tests/auto/qtcpsocket/tst_qtcpsocket.cpp
@@ -476,6 +476,9 @@ void tst_QTcpSocket::setInvalidSocketDescriptor()
 {
     QTcpSocket *socket = newSocket();
     QCOMPARE(socket->socketDescriptor(), -1);
+#ifdef Q_OS_SYMBIAN
+    QTest::ignoreMessage(QtWarningMsg, "QSymbianSocketEngine::initialize - socket descriptor not found");
+#endif
     QVERIFY(!socket->setSocketDescriptor(-5, QTcpSocket::UnconnectedState));
     QCOMPARE(socket->socketDescriptor(), -1);