1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the test suite of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 

    43 // Just to get Q_OS_SYMBIAN

    44 #include <qglobal.h>

    45 

    46 #if defined(_WIN32) && !defined(Q_OS_SYMBIAN)

    47 #include <winsock2.h>

    48 #else

    49 #include <sys/types.h>

    50 #include <sys/socket.h>

    51 #include <fcntl.h>

    52 #include <unistd.h>

    53 #define SOCKET int

    54 #define INVALID_SOCKET -1

    55 #endif

    56 

    57 #include <qplatformdefs.h>

    58 

    59 #include <QtTest/QtTest>

    60 

    61 #include <QAuthenticator>

    62 #include <QCoreApplication>

    63 #include <QEventLoop>

    64 #include <QFile>

    65 #include <QHostAddress>

    66 #include <QHostInfo>

    67 #include <QMap>

    68 #ifndef Q_OS_VXWORKS

    69 #include <QMessageBox>

    70 #include <QPushButton>

    71 #endif

    72 #include <QPointer>

    73 #include <QProcess>

    74 #include <QStringList>

    75 #include <QTcpServer>

    76 #include <QTcpSocket>

    77 #ifndef QT_NO_OPENSSL

    78 #include <QSslSocket>

    79 #endif

    80 #include <QTextStream>

    81 #include <QThread>

    82 #include <QTime>

    83 #include <QTimer>

    84 #include <QDebug>

    85 #ifndef TEST_QNETWORK_PROXY

    86 #define TEST_QNETWORK_PROXY

    87 #endif

    88 // RVCT compiles also unused inline methods

    89 # include <QNetworkProxy>

    90 

    91 #ifdef Q_OS_LINUX

    92 #include <stdio.h>

    93 #include <stdlib.h>

    94 #include <sys/stat.h>

    95 #include <unistd.h>

    96 #endif

    97 

    98 #include "../network-settings.h"

    99 

   100 Q_DECLARE_METATYPE(QAbstractSocket::SocketError)

   101 Q_DECLARE_METATYPE(QAbstractSocket::SocketState)

   102 Q_DECLARE_METATYPE(QNetworkProxy)

   103 Q_DECLARE_METATYPE(QList<QNetworkProxy>)

   104 

   105 //TESTED_CLASS=

   106 //TESTED_FILES=

   107 

   108 QT_FORWARD_DECLARE_CLASS(QTcpSocket)

   109 

   110 class tst_QTcpSocket : public QObject

   111 {

   112     Q_OBJECT

   113 

   114 public:

   115     tst_QTcpSocket();

   116     virtual ~tst_QTcpSocket();

   117 

   118     static void enterLoop(int secs)

   119     {

   120         ++loopLevel;

   121         QTestEventLoop::instance().enterLoop(secs);

   122         --loopLevel;

   123     }

   124     static void exitLoop()

   125     {

   126         // Safe exit - if we aren't in an event loop, don't

   127         // exit one.

   128         if (loopLevel > 0)

   129             QTestEventLoop::instance().exitLoop();

   130     }

   131     static bool timeout()

   132     {

   133         return QTestEventLoop::instance().timeout();

   134     }

   135 

   136 public slots:

   137     void initTestCase_data();

   138     void init();

   139     void cleanup();

   140 private slots:

   141     void constructing();

   142     void setInvalidSocketDescriptor();

   143     void setSocketDescriptor();

   144     void socketDescriptor();

   145     void blockingIMAP();

   146     void nonBlockingIMAP();

   147     void hostNotFound();

   148     void timeoutConnect();

   149     void delayedClose();

   150     void partialRead();

   151     void unget();

   152     void readAllAfterClose();

   153     void openCloseOpenClose();

   154     void connectDisconnectConnectDisconnect();

   155     void disconnectWhileConnecting_data();

   156     void disconnectWhileConnecting();

   157     void disconnectWhileConnectingNoEventLoop_data();

   158     void disconnectWhileConnectingNoEventLoop();

   159     void disconnectWhileLookingUp_data();

   160     void disconnectWhileLookingUp();

   161     void downloadBigFile();

   162     void readLine();

   163     void readLineString();

   164     void readChunks();

   165     void waitForBytesWritten();

   166     void waitForReadyRead();

   167     void flush();

   168     void synchronousApi();

   169     void dontCloseOnTimeout();

   170     void recursiveReadyRead();

   171     void atEnd();

   172     void socketInAThread();

   173     void socketsInThreads();

   174     void waitForReadyReadInASlot();

   175     void remoteCloseError();

   176     void openMessageBoxInErrorSlot();

   177 #ifndef Q_OS_WIN

   178     void connectToLocalHostNoService();

   179 #endif

   180     void waitForConnectedInHostLookupSlot();

   181     void waitForConnectedInHostLookupSlot2();

   182     void readyReadSignalsAfterWaitForReadyRead();

   183 #ifdef Q_OS_LINUX

   184     void linuxKernelBugLocalSocket();

   185 #endif

   186     void abortiveClose();

   187     void localAddressEmptyOnBSD();

   188     void zeroAndMinusOneReturns();

   189     void connectionRefused();

   190     void suddenRemoteDisconnect_data();

   191     void suddenRemoteDisconnect();

   192     void connectToMultiIP();

   193     void moveToThread0();

   194     void increaseReadBufferSize();

   195 #ifdef TEST_QNETWORK_PROXY

   196     void invalidProxy_data();

   197     void invalidProxy();

   198     void proxyFactory_data();

   199     void proxyFactory();

   200 #endif

   201 

   202 protected slots:

   203     void nonBlockingIMAP_hostFound();

   204     void nonBlockingIMAP_connected();

   205     void nonBlockingIMAP_closed();

   206     void nonBlockingIMAP_readyRead();

   207     void nonBlockingIMAP_bytesWritten(qint64);

   208     void readRegularFile_readyRead();

   209     void exitLoopSlot();

   210     void downloadBigFileSlot();

   211     void recursiveReadyReadSlot();

   212     void waitForReadyReadInASlotSlot();

   213     void messageBoxSlot();

   214     void hostLookupSlot();

   215     void abortiveClose_abortSlot();

   216     void remoteCloseErrorSlot();

   217     void proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth);

   218 

   219 private:

   220     QTcpSocket *newSocket() const;

   221     QTcpSocket *nonBlockingIMAP_socket;

   222     QStringList nonBlockingIMAP_data;

   223     qint64 nonBlockingIMAP_totalWritten;

   224 

   225     QTcpSocket *tmpSocket;

   226     qint64 bytesAvailable;

   227     qint64 expectedLength;

   228     bool readingBody;

   229     QTime timer;

   230 

   231     mutable int proxyAuthCalled;

   232 

   233     bool gotClosedSignal;

   234     int numConnections;

   235     static int loopLevel;

   236 };

   237 

   238 enum ProxyTests {

   239     NoProxy = 0x00,

   240     Socks5Proxy = 0x01,

   241     HttpProxy = 0x02,

   242     TypeMask = 0x0f,

   243 

   244     NoAuth = 0x00,

   245     AuthBasic = 0x10,

   246     AuthNtlm = 0x20,

   247     AuthMask = 0xf0

   248 };

   249 

   250 int tst_QTcpSocket::loopLevel = 0;

   251 

   252 tst_QTcpSocket::tst_QTcpSocket()

   253 {

   254     Q_SET_DEFAULT_IAP

   255     tmpSocket = 0;

   256 }

   257 

   258 tst_QTcpSocket::~tst_QTcpSocket()

   259 {

   260 

   261 }

   262 

   263 void tst_QTcpSocket::initTestCase_data()

   264 {

   265     QTest::addColumn<bool>("setProxy");

   266     QTest::addColumn<int>("proxyType");

   267     QTest::addColumn<bool>("ssl");

   268 

   269     qDebug() << QtNetworkSettings::serverName();

   270     QTest::newRow("WithoutProxy") << false << 0 << false;

   271 #ifdef TEST_QNETWORK_PROXY

   272     QTest::newRow("WithSocks5Proxy") << true << int(Socks5Proxy) << false;

   273     QTest::newRow("WithSocks5ProxyAuth") << true << int(Socks5Proxy | AuthBasic) << false;

   274 

   275     QTest::newRow("WithHttpProxy") << true << int(HttpProxy) << false;

   276     QTest::newRow("WithHttpProxyBasicAuth") << true << int(HttpProxy | AuthBasic) << false;

   277 //    QTest::newRow("WithHttpProxyNtlmAuth") << true << int(HttpProxy | AuthNtlm) << false;

   278 #endif

   279 #ifndef QT_NO_OPENSSL

   280     QTest::newRow("WithoutProxy SSL") << false << 0 << true;

   281 #ifdef TEST_QNETWORK_PROXY

   282     QTest::newRow("WithSocks5Proxy SSL") << true << int(Socks5Proxy) << true;

   283     QTest::newRow("WithSocks5AuthProxy SSL") << true << int(Socks5Proxy | AuthBasic) << true;

   284 

   285     QTest::newRow("WithHttpProxy SSL") << true << int(HttpProxy) << true;

   286     QTest::newRow("WithHttpProxyBasicAuth SSL") << true << int(HttpProxy | AuthBasic) << true;

   287 //    QTest::newRow("WithHttpProxyNtlmAuth SSL") << true << int(HttpProxy | AuthNtlm) << true;

   288 #endif

   289 #endif

   290 }

   291 

   292 void tst_QTcpSocket::init()

   293 {

   294     QFETCH_GLOBAL(bool, setProxy);

   295     if (setProxy) {

   296 #ifdef TEST_QNETWORK_PROXY

   297         QFETCH_GLOBAL(int, proxyType);

   298         QString fluke = QHostInfo::fromName(QtNetworkSettings::serverName()).addresses().first().toString();

   299         QNetworkProxy proxy;

   300 

   301         switch (proxyType) {

   302         case Socks5Proxy:

   303             proxy = QNetworkProxy(QNetworkProxy::Socks5Proxy, fluke, 1080);

   304             break;

   305 

   306         case Socks5Proxy | AuthBasic:

   307             proxy = QNetworkProxy(QNetworkProxy::Socks5Proxy, fluke, 1081);

   308             break;

   309 

   310         case HttpProxy | NoAuth:

   311             proxy = QNetworkProxy(QNetworkProxy::HttpProxy, fluke, 3128);

   312             break;

   313 

   314         case HttpProxy | AuthBasic:

   315             proxy = QNetworkProxy(QNetworkProxy::HttpProxy, fluke, 3129);

   316             break;

   317 

   318         case HttpProxy | AuthNtlm:

   319             proxy = QNetworkProxy(QNetworkProxy::HttpProxy, fluke, 3130);

   320             break;

   321         }

   322         QNetworkProxy::setApplicationProxy(proxy);

   323 #endif

   324     }

   325 }

   326 

   327 QTcpSocket *tst_QTcpSocket::newSocket() const

   328 {

   329     QTcpSocket *socket;

   330 #ifndef QT_NO_OPENSSL

   331     QFETCH_GLOBAL(bool, ssl);

   332     socket = ssl ? new QSslSocket : new QTcpSocket;

   333 #else

   334     socket = new QTcpSocket;

   335 #endif

   336 

   337     proxyAuthCalled = 0;

   338     connect(socket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

   339             SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

   340             Qt::DirectConnection);

   341     return socket;

   342 }

   343 

   344 void tst_QTcpSocket::cleanup()

   345 {

   346 #ifdef TEST_QNETWORK_PROXY

   347     QNetworkProxy::setApplicationProxy(QNetworkProxy::DefaultProxy);

   348 #endif

   349 }

   350 

   351 void tst_QTcpSocket::proxyAuthenticationRequired(const QNetworkProxy &, QAuthenticator *auth)

   352 {

   353     ++proxyAuthCalled;

   354     auth->setUser("qsockstest");

   355     auth->setPassword("password");

   356 }

   357 

   358 //----------------------------------------------------------------------------------

   359 

   360 void tst_QTcpSocket::constructing()

   361 {

   362     QTcpSocket *socket = newSocket();

   363 

   364     // Check the initial state of the QTcpSocket.

   365     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   366     QVERIFY(socket->isSequential());

   367     QVERIFY(!socket->isOpen());

   368     QVERIFY(!socket->isValid());

   369     QCOMPARE(socket->socketType(), QTcpSocket::TcpSocket);

   370 

   371     char c;

   372     QTest::ignoreMessage(QtWarningMsg, "QIODevice::getChar: Closed device");

   373     QCOMPARE(socket->getChar(&c), false);

   374     QCOMPARE((int) socket->bytesAvailable(), 0);

   375     QCOMPARE(socket->canReadLine(), false);

   376     QCOMPARE(socket->readLine(), QByteArray());

   377     QCOMPARE(socket->socketDescriptor(), -1);

   378     QCOMPARE((int) socket->localPort(), 0);

   379     QVERIFY(socket->localAddress() == QHostAddress());

   380     QCOMPARE((int) socket->peerPort(), 0);

   381     QVERIFY(socket->peerAddress() == QHostAddress());

   382     QCOMPARE(socket->error(), QTcpSocket::UnknownSocketError);

   383     QCOMPARE(socket->errorString(), QString("Unknown error"));

   384 

   385     // Check the state of the socket layer?

   386     delete socket;

   387 }

   388 

   389 //----------------------------------------------------------------------------------

   390 

   391 void tst_QTcpSocket::setInvalidSocketDescriptor()

   392 {

   393     QTcpSocket *socket = newSocket();

   394     QCOMPARE(socket->socketDescriptor(), -1);

   395     QVERIFY(!socket->setSocketDescriptor(-5, QTcpSocket::UnconnectedState));

   396     QCOMPARE(socket->socketDescriptor(), -1);

   397 

   398     QCOMPARE(socket->error(), QTcpSocket::UnsupportedSocketOperationError);

   399 

   400     delete socket;

   401 }

   402 

   403 //----------------------------------------------------------------------------------

   404 

   405 void tst_QTcpSocket::setSocketDescriptor()

   406 {

   407     QFETCH_GLOBAL(bool, setProxy);

   408     if (setProxy)

   409         return;                 // this test doesn't make sense with proxies

   410 

   411 #ifdef Q_OS_WIN

   412     // need the dummy to ensure winsock is started

   413     QTcpSocket *dummy = newSocket();

   414     dummy->connectToHost(QtNetworkSettings::serverName(), 143);

   415     QVERIFY(dummy->waitForConnected());

   416 

   417     SOCKET sock = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

   418     if (sock == INVALID_SOCKET) {

   419         qErrnoWarning(WSAGetLastError(), "INVALID_SOCKET");

   420     }

   421 #else

   422     SOCKET sock = ::socket(AF_INET, SOCK_STREAM, 0);

   423 

   424     // artificially increase the value of sock

   425     SOCKET sock2 = ::fcntl(sock, F_DUPFD, sock + 50);

   426     ::close(sock);

   427     sock = sock2;

   428 #endif

   429 

   430     QVERIFY(sock != INVALID_SOCKET);

   431     QTcpSocket *socket = newSocket();

   432     QVERIFY(socket->setSocketDescriptor(sock, QTcpSocket::UnconnectedState));

   433     QCOMPARE(socket->socketDescriptor(), (int)sock);

   434 

   435     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   436     QCOMPARE(socket->state(), QTcpSocket::HostLookupState);

   437     QCOMPARE(socket->socketDescriptor(), (int)sock);

   438     QVERIFY(socket->waitForConnected(10000));

   439     // skip this, it has been broken for years, see task 260735

   440     // if somebody complains, consider fixing it, but it might break existing applications.

   441     QEXPECT_FAIL("", "bug has been around for years, will not fix without need", Continue);

   442     QCOMPARE(socket->socketDescriptor(), (int)sock);

   443     delete socket;

   444 #ifdef Q_OS_WIN

   445     delete dummy;

   446 #endif

   447 }

   448 

   449 //----------------------------------------------------------------------------------

   450 

   451 void tst_QTcpSocket::socketDescriptor()

   452 {

   453     QTcpSocket *socket = newSocket();

   454 

   455     QCOMPARE(socket->socketDescriptor(), -1);

   456     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   457     QVERIFY((socket->state() == QAbstractSocket::HostLookupState && socket->socketDescriptor() == -1) ||

   458             (socket->state() == QAbstractSocket::ConnectingState && socket->socketDescriptor() != -1));

   459     QVERIFY(socket->waitForConnected(10000));

   460     QVERIFY(socket->state() == QAbstractSocket::ConnectedState);

   461     QVERIFY(socket->socketDescriptor() != -1);

   462 

   463     delete socket;

   464 }

   465 

   466 //----------------------------------------------------------------------------------

   467 

   468 void tst_QTcpSocket::blockingIMAP()

   469 {

   470     QTcpSocket *socket = newSocket();

   471 

   472     // Connect

   473     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   474     QVERIFY(socket->waitForConnected(10000));

   475     QCOMPARE(socket->state(), QTcpSocket::ConnectedState);

   476     QVERIFY(socket->isValid());

   477 

   478     // Read greeting

   479     QVERIFY(socket->waitForReadyRead(5000));

   480     QString s = socket->readLine();

   481     // only test if an OK was returned, to make the test compatible between different

   482     // IMAP server versions

   483     QCOMPARE(s.left(4).toLatin1().constData(), "* OK");

   484 

   485     // Write NOOP

   486     QCOMPARE((int) socket->write("1 NOOP\r\n", 8), 8);

   487     QCOMPARE((int) socket->write("2 NOOP\r\n", 8), 8);

   488 

   489     if (!socket->canReadLine())

   490         QVERIFY(socket->waitForReadyRead(5000));

   491 

   492     // Read response

   493     s = socket->readLine();

   494     QCOMPARE(s.toLatin1().constData(), "1 OK Completed\r\n");

   495 

   496     // Write a third NOOP to verify that write doesn't clear the read buffer

   497     QCOMPARE((int) socket->write("3 NOOP\r\n", 8), 8);

   498 

   499     // Read second response

   500     if (!socket->canReadLine())

   501         QVERIFY(socket->waitForReadyRead(5000));

   502     s = socket->readLine();

   503     QCOMPARE(s.toLatin1().constData(), "2 OK Completed\r\n");

   504 

   505     // Read third response

   506     if (!socket->canReadLine())

   507         QVERIFY(socket->waitForReadyRead(5000));

   508     s = socket->readLine();

   509     QCOMPARE(s.toLatin1().constData(), "3 OK Completed\r\n");

   510 

   511 

   512     // Write LOGOUT

   513     QCOMPARE((int) socket->write("4 LOGOUT\r\n", 10), 10);

   514 

   515     if (!socket->canReadLine())

   516         QVERIFY(socket->waitForReadyRead(5000));

   517 

   518     // Read two lines of respose

   519     s = socket->readLine();

   520     QCOMPARE(s.toLatin1().constData(), "* BYE LOGOUT received\r\n");

   521 

   522     if (!socket->canReadLine())

   523         QVERIFY(socket->waitForReadyRead(5000));

   524 

   525     s = socket->readLine();

   526     QCOMPARE(s.toLatin1().constData(), "4 OK Completed\r\n");

   527 

   528     // Close the socket

   529     socket->close();

   530 

   531     // Check that it's closed

   532     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   533 

   534     delete socket;

   535 }

   536 

   537 //----------------------------------------------------------------------------------

   538 

   539 void tst_QTcpSocket::hostNotFound()

   540 {

   541     QTcpSocket *socket = newSocket();

   542 

   543     socket->connectToHost("nosuchserver.troll.no", 80);

   544     QVERIFY(!socket->waitForConnected());

   545     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   546     QCOMPARE(int(socket->error()), int(QTcpSocket::HostNotFoundError));

   547 

   548     delete socket;

   549 }

   550 

   551 //----------------------------------------------------------------------------------

   552 

   553 void tst_QTcpSocket::timeoutConnect()

   554 {

   555     QTcpSocket *socket = newSocket();

   556 

   557     // Outgoing port 53 is firewalled in the Oslo office.

   558     socket->connectToHost("cisco.com", 53);

   559     QVERIFY(!socket->waitForConnected(200));

   560     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   561     QCOMPARE(int(socket->error()), int(QTcpSocket::SocketTimeoutError));

   562 

   563     socket->connectToHost("cisco.com", 53);

   564     QTest::qSleep(50);

   565     socket->abort();

   566     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   567     QCOMPARE(socket->openMode(), QIODevice::NotOpen);

   568 

   569     delete socket;

   570 }

   571 

   572 //----------------------------------------------------------------------------------

   573 

   574 void tst_QTcpSocket::nonBlockingIMAP()

   575 {

   576     QTcpSocket *socket = newSocket();

   577     connect(socket, SIGNAL(hostFound()), SLOT(nonBlockingIMAP_hostFound()));

   578     connect(socket, SIGNAL(connected()), SLOT(nonBlockingIMAP_connected()));

   579     connect(socket, SIGNAL(disconnected()), SLOT(nonBlockingIMAP_closed()));

   580     connect(socket, SIGNAL(bytesWritten(qint64)), SLOT(nonBlockingIMAP_bytesWritten(qint64)));

   581     connect(socket, SIGNAL(readyRead()), SLOT(nonBlockingIMAP_readyRead()));

   582     nonBlockingIMAP_socket = socket;

   583 

   584     // Connect

   585     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   586     QVERIFY(socket->state() == QTcpSocket::HostLookupState ||

   587             socket->state() == QTcpSocket::ConnectingState);

   588 

   589     enterLoop(30);

   590     if (timeout()) {

   591         QFAIL("Timed out");

   592     }

   593 

   594     if (socket->state() == QTcpSocket::ConnectingState) {

   595         enterLoop(30);

   596         if (timeout()) {

   597             QFAIL("Timed out");

   598         }

   599     }

   600 

   601     QCOMPARE(socket->state(), QTcpSocket::ConnectedState);

   602 

   603     enterLoop(30);

   604     if (timeout()) {

   605         QFAIL("Timed out");

   606     }

   607 

   608     // Read greeting

   609     QVERIFY(!nonBlockingIMAP_data.isEmpty());

   610 //    QCOMPARE(nonBlockingIMAP_data.at(0).toLatin1().constData(),

   611 //            "* OK fluke Cyrus IMAP4 v2.2.12 server ready\r\n");

   612     QCOMPARE(nonBlockingIMAP_data.at(0).left(4).toLatin1().constData(), "* OK");

   613     nonBlockingIMAP_data.clear();

   614 

   615     nonBlockingIMAP_totalWritten = 0;

   616 

   617     // Write NOOP

   618     QCOMPARE((int) socket->write("1 NOOP\r\n", 8), 8);

   619 

   620 

   621     enterLoop(30);

   622     if (timeout()) {

   623         QFAIL("Timed out");

   624     }

   625 

   626     QVERIFY(nonBlockingIMAP_totalWritten == 8);

   627 

   628 

   629     enterLoop(30);

   630     if (timeout()) {

   631         QFAIL("Timed out");

   632     }

   633 

   634 

   635     // Read response

   636     QVERIFY(!nonBlockingIMAP_data.isEmpty());

   637     QCOMPARE(nonBlockingIMAP_data.at(0).toLatin1().constData(), "1 OK Completed\r\n");

   638     nonBlockingIMAP_data.clear();

   639 

   640 

   641     nonBlockingIMAP_totalWritten = 0;

   642 

   643     // Write LOGOUT

   644     QCOMPARE((int) socket->write("2 LOGOUT\r\n", 10), 10);

   645 

   646     enterLoop(30);

   647     if (timeout()) {

   648         QFAIL("Timed out");

   649     }

   650 

   651     QVERIFY(nonBlockingIMAP_totalWritten == 10);

   652 

   653     // Wait for greeting

   654     enterLoop(30);

   655     if (timeout()) {

   656         QFAIL("Timed out");

   657     }

   658 

   659     // Read two lines of respose

   660     QCOMPARE(nonBlockingIMAP_data.at(0).toLatin1().constData(), "* BYE LOGOUT received\r\n");

   661     QCOMPARE(nonBlockingIMAP_data.at(1).toLatin1().constData(), "2 OK Completed\r\n");

   662     nonBlockingIMAP_data.clear();

   663 

   664     // Close the socket

   665     socket->close();

   666 

   667     // Check that it's closed

   668     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   669 

   670     delete socket;

   671 }

   672 

   673 void tst_QTcpSocket::nonBlockingIMAP_hostFound()

   674 {

   675     exitLoop();

   676 }

   677 

   678 void tst_QTcpSocket::nonBlockingIMAP_connected()

   679 {

   680     exitLoop();

   681 }

   682 

   683 void tst_QTcpSocket::nonBlockingIMAP_readyRead()

   684 {

   685     while (nonBlockingIMAP_socket->canReadLine())

   686         nonBlockingIMAP_data.append(nonBlockingIMAP_socket->readLine());

   687 

   688     exitLoop();

   689 }

   690 

   691 void tst_QTcpSocket::nonBlockingIMAP_bytesWritten(qint64 written)

   692 {

   693     nonBlockingIMAP_totalWritten += written;

   694     exitLoop();

   695 }

   696 

   697 void tst_QTcpSocket::nonBlockingIMAP_closed()

   698 {

   699 }

   700 

   701 //----------------------------------------------------------------------------------

   702 

   703 void tst_QTcpSocket::delayedClose()

   704 {

   705     QTcpSocket *socket = newSocket();

   706     connect(socket, SIGNAL(connected()), SLOT(nonBlockingIMAP_connected()));

   707     connect(socket, SIGNAL(disconnected()), SLOT(exitLoopSlot()));

   708 

   709     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   710 

   711     enterLoop(30);

   712     if (timeout())

   713         QFAIL("Timed out");

   714 

   715     QCOMPARE(socket->state(), QTcpSocket::ConnectedState);

   716 

   717     QCOMPARE((int) socket->write("1 LOGOUT\r\n", 10), 10);

   718 

   719     // Add a huge bulk of data to be written after the logout

   720     // command. The server will shut down after receiving the LOGOUT,

   721     // so this data will not be read. But our close call should

   722     // schedule a delayed close because all the data can not be

   723     // written in one go.

   724     QCOMPARE((int) socket->write(QByteArray(100000, '\n'), 100000), 100000);

   725 

   726     socket->close();

   727 

   728     QCOMPARE((int) socket->state(), (int) QTcpSocket::ClosingState);

   729 

   730     enterLoop(10);

   731     if (timeout())

   732         QFAIL("Timed out");

   733 

   734     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   735 

   736     delete socket;

   737 }

   738 

   739 //----------------------------------------------------------------------------------

   740 

   741 void tst_QTcpSocket::partialRead()

   742 {

   743     QTcpSocket *socket = newSocket();

   744     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   745     QVERIFY(socket->waitForConnected(10000));

   746     QVERIFY(socket->state() == QTcpSocket::ConnectedState);

   747     char buf[512];

   748 

   749 //    QByteArray greeting = "* OK fluke Cyrus IMAP4 v2.2.12 server ready";

   750     QByteArray greeting = "* OK [CAPABILITY IMAP4rev1 UIDPLUS CHILDREN NAMESPACE";

   751 

   752     for (int i = 0; i < 10; i += 2) {

   753         while (socket->bytesAvailable() < 2)

   754             QVERIFY(socket->waitForReadyRead(5000));

   755         QVERIFY(socket->read(buf, 2) == 2);

   756         buf[2] = '\0';

   757         QCOMPARE((char *)buf, greeting.mid(i, 2).data());

   758     }

   759 

   760     delete socket;

   761 }

   762 

   763 //----------------------------------------------------------------------------------

   764 

   765 void tst_QTcpSocket::unget()

   766 {

   767     QTcpSocket *socket = newSocket();

   768     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   769     QVERIFY(socket->waitForConnected(10000));

   770     QVERIFY(socket->state() == QTcpSocket::ConnectedState);

   771     char buf[512];

   772 

   773 //    QByteArray greeting = "* OK fluke Cyrus IMAP4 v2.2.12 server ready";

   774     QByteArray greeting = "* OK [CAPABILITY IMAP4rev1 UIDPLUS CHILDREN NAMESPACE";

   775 

   776     for (int i = 0; i < 10; i += 2) {

   777         while (socket->bytesAvailable() < 2)

   778             QVERIFY(socket->waitForReadyRead(5000));

   779         int bA = socket->bytesAvailable();

   780         QVERIFY(socket->read(buf, 2) == 2);

   781         buf[2] = '\0';

   782         QCOMPARE((char *)buf, greeting.mid(i, 2).data());

   783         QCOMPARE((int)socket->bytesAvailable(), bA - 2);

   784         socket->ungetChar(buf[1]);

   785         socket->ungetChar(buf[0]);

   786         QCOMPARE((int)socket->bytesAvailable(), bA);

   787         QVERIFY(socket->read(buf, 2) == 2);

   788         buf[2] = '\0';

   789         QCOMPARE((char *)buf, greeting.mid(i, 2).data());

   790     }

   791 

   792     delete socket;

   793 }

   794 

   795 //----------------------------------------------------------------------------------

   796 void tst_QTcpSocket::readRegularFile_readyRead()

   797 {

   798     exitLoop();

   799 }

   800 

   801 //----------------------------------------------------------------------------------

   802 void tst_QTcpSocket::readAllAfterClose()

   803 {

   804     QTcpSocket *socket = newSocket();

   805     socket->connectToHost(QtNetworkSettings::serverName(), 143);

   806     connect(socket, SIGNAL(readyRead()), SLOT(readRegularFile_readyRead()));

   807     enterLoop(10);

   808     if (timeout())

   809         QFAIL("Network operation timed out");

   810 

   811     socket->close();

   812     QByteArray array = socket->readAll();

   813     QCOMPARE(array.size(), 0);

   814 

   815     delete socket;

   816 }

   817 

   818 //----------------------------------------------------------------------------------

   819 void tst_QTcpSocket::openCloseOpenClose()

   820 {

   821     QTcpSocket *socket = newSocket();

   822 

   823     for (int i = 0; i < 3; ++i) {

   824         QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   825         QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));

   826         QVERIFY(socket->isSequential());

   827         QVERIFY(!socket->isOpen());

   828         QVERIFY(socket->socketType() == QTcpSocket::TcpSocket);

   829 

   830         char c;

   831         QTest::ignoreMessage(QtWarningMsg, "QIODevice::getChar: Closed device");

   832         QCOMPARE(socket->getChar(&c), false);

   833         QCOMPARE((int) socket->bytesAvailable(), 0);

   834         QCOMPARE(socket->canReadLine(), false);

   835         QCOMPARE(socket->readLine(), QByteArray());

   836         QCOMPARE(socket->socketDescriptor(), -1);

   837         QCOMPARE((int) socket->localPort(), 0);

   838         QVERIFY(socket->localAddress() == QHostAddress());

   839         QCOMPARE((int) socket->peerPort(), 0);

   840         QVERIFY(socket->peerAddress() == QHostAddress());

   841         QCOMPARE(socket->error(), QTcpSocket::UnknownSocketError);

   842         QCOMPARE(socket->errorString(), QString("Unknown error"));

   843 

   844         QVERIFY(socket->state() == QTcpSocket::UnconnectedState);

   845 

   846         socket->connectToHost(QtNetworkSettings::serverName(), 143);

   847         QVERIFY(socket->waitForConnected(10000));

   848         socket->close();

   849     }

   850 

   851     delete socket;

   852 }

   853 

   854 //----------------------------------------------------------------------------------

   855 void tst_QTcpSocket::connectDisconnectConnectDisconnect()

   856 {

   857     QTcpSocket *socket = newSocket();

   858 

   859     for (int i = 0; i < 3; ++i) {

   860         QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);

   861         QVERIFY(socket->socketType() == QTcpSocket::TcpSocket);

   862 

   863         socket->connectToHost(QtNetworkSettings::serverName(), 143);

   864         QVERIFY(socket->waitForReadyRead(10000));

   865         QCOMPARE(QString::fromLatin1(socket->read(4)), QString("* OK"));

   866 

   867         socket->disconnectFromHost();

   868         if (socket->state() != QTcpSocket::UnconnectedState)

   869             QVERIFY(socket->waitForDisconnected(10000));

   870         QCOMPARE(int(socket->openMode()), int(QIODevice::ReadWrite));

   871     }

   872 

   873     delete socket;

   874 }

   875 

   876 //----------------------------------------------------------------------------------

   877 void tst_QTcpSocket::disconnectWhileConnecting_data()

   878 {

   879     QTest::addColumn<QByteArray>("data");

   880     QTest::addColumn<bool>("closeDirectly");

   881 

   882     QTest::newRow("without-data") << QByteArray() << false;

   883     QTest::newRow("without-data+close") << QByteArray() << true;

   884     QTest::newRow("with-data") << QByteArray("Hello, world!") << false;

   885     QTest::newRow("with-data+close") << QByteArray("Hello, world!") << true;

   886 

   887     QByteArray bigData(1024*1024, '@');

   888     QTest::newRow("with-big-data") << bigData << false;

   889     QTest::newRow("with-big-data+close") << bigData << true;

   890 }

   891 

   892 void tst_QTcpSocket::disconnectWhileConnecting()

   893 {

   894     QFETCH(QByteArray, data);

   895 

   896     QTcpServer server;

   897     QVERIFY(server.listen(QHostAddress::LocalHost));

   898 

   899     // proceed to the connect-write-disconnect

   900     QTcpSocket *socket = newSocket();

   901     socket->connectToHost("127.0.0.1", server.serverPort());

   902     if (!data.isEmpty())

   903         socket->write(data);

   904     if (socket->state() == QAbstractSocket::ConnectedState)

   905         QSKIP("localhost connections are immediate, test case is invalid", SkipSingle);

   906 

   907     QFETCH(bool, closeDirectly);

   908     if (closeDirectly) {

   909         socket->close();

   910         QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));

   911     } else {

   912         socket->disconnectFromHost();

   913     }

   914 

   915     connect(socket, SIGNAL(disconnected()), SLOT(exitLoopSlot()));

   916 #ifndef Q_OS_SYMBIAN

   917     enterLoop(10);

   918 #else

   919     enterLoop(30);

   920 #endif

   921     QVERIFY2(!timeout(), "Network timeout");

   922     QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);

   923     if (!closeDirectly) {

   924         QCOMPARE(int(socket->openMode()), int(QIODevice::ReadWrite));

   925         socket->close();

   926     }

   927     QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));

   928 

   929     // accept the other side and verify that it was sent properly:

   930     QVERIFY(server.hasPendingConnections() || server.waitForNewConnection(0));

   931     QTcpSocket *othersocket = server.nextPendingConnection();

   932     if (othersocket->state() != QAbstractSocket::UnconnectedState)

   933         QVERIFY2(othersocket->waitForDisconnected(10000), "Network timeout");

   934     QVERIFY(othersocket->state() == QAbstractSocket::UnconnectedState);

   935     QCOMPARE(othersocket->readAll(), data);

   936 

   937     delete socket;

   938     delete othersocket;

   939 }

   940 

   941 //----------------------------------------------------------------------------------

   942 class ReceiverThread: public QThread

   943 {

   944     QTcpServer *server;

   945 public:

   946     int serverPort;

   947     bool ok;

   948     QByteArray receivedData;

   949     volatile bool quit;

   950 

   951     ReceiverThread()

   952         : server(0), ok(false), quit(false)

   953     { }

   954 

   955     ~ReceiverThread() { /*delete server;*/ terminate(); wait();  }

   956 

   957     bool listen()

   958     {

   959         server = new QTcpServer;

   960         if (!server->listen(QHostAddress::LocalHost))

   961             return false;

   962         serverPort = server->serverPort();

   963         server->moveToThread(this);

   964         return true;

   965     }

   966 

   967 protected:

   968     void run()

   969     {

   970         bool timedOut = false;

   971         while (!quit) {

   972 #ifndef Q_OS_SYMBIAN

   973             if (server->waitForNewConnection(500, &timedOut))

   974 #else

   975             if (server->waitForNewConnection(5000, &timedOut))

   976 #endif

   977                 break;

   978             if (!timedOut)

   979                 return;

   980         }

   981 

   982         QTcpSocket *socket = server->nextPendingConnection();

   983         while (!quit) {

   984 #ifndef Q_OS_SYMBIAN

   985             if (socket->waitForDisconnected(500))

   986 #else

   987             if (socket->waitForDisconnected(5000))

   988 #endif

   989                 break;

   990             if (socket->error() != QAbstractSocket::SocketTimeoutError)

   991                 return;

   992         }

   993 

   994         if (!quit) {

   995             receivedData = socket->readAll();

   996             ok = true;

   997         }

   998         delete socket;

   999         delete server;

  1000         server = 0;

  1001     }

  1002 };

  1003 

  1004 void tst_QTcpSocket::disconnectWhileConnectingNoEventLoop_data()

  1005 {

  1006     disconnectWhileConnecting_data();

  1007 }

  1008 

  1009 void tst_QTcpSocket::disconnectWhileConnectingNoEventLoop()

  1010 {

  1011     QFETCH(QByteArray, data);

  1012 

  1013     ReceiverThread thread;

  1014     QVERIFY(thread.listen());

  1015     thread.start();

  1016 

  1017     // proceed to the connect-write-disconnect

  1018     QTcpSocket *socket = newSocket();

  1019     socket->connectToHost("127.0.0.1", thread.serverPort);

  1020     if (!data.isEmpty())

  1021         socket->write(data);

  1022     if (socket->state() == QAbstractSocket::ConnectedState) {

  1023         thread.quit = true;

  1024         thread.wait();

  1025         QSKIP("localhost connections are immediate, test case is invalid", SkipSingle);

  1026     }

  1027 

  1028     QFETCH(bool, closeDirectly);

  1029     if (closeDirectly) {

  1030         socket->close();

  1031         QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));

  1032     } else {

  1033         socket->disconnectFromHost();

  1034     }

  1035 

  1036 #ifndef Q_OS_SYMBIAN

  1037     QVERIFY2(socket->waitForDisconnected(10000), "Network timeout");

  1038 #else

  1039     QVERIFY2(socket->waitForDisconnected(30000), "Network timeout");

  1040 #endif

  1041     QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);

  1042     if (!closeDirectly) {

  1043         QCOMPARE(int(socket->openMode()), int(QIODevice::ReadWrite));

  1044         socket->close();

  1045     }

  1046     QCOMPARE(int(socket->openMode()), int(QIODevice::NotOpen));

  1047     delete socket;

  1048 

  1049     // check if the other side received everything ok

  1050     QVERIFY(thread.wait(30000));

  1051     QVERIFY(thread.ok);

  1052     QCOMPARE(thread.receivedData, data);

  1053 }

  1054 

  1055 //----------------------------------------------------------------------------------

  1056 void tst_QTcpSocket::disconnectWhileLookingUp_data()

  1057 {

  1058     QTest::addColumn<bool>("doClose");

  1059 

  1060     QTest::newRow("disconnect") << false;

  1061     QTest::newRow("close") << true;

  1062 }

  1063 

  1064 void tst_QTcpSocket::disconnectWhileLookingUp()

  1065 {

  1066     QFETCH_GLOBAL(bool, setProxy);

  1067     if (setProxy)

  1068         return;                 // we let the proxies do the lookup now

  1069 

  1070     // just connect and disconnect, then make sure nothing weird happened

  1071     QTcpSocket *socket = newSocket();

  1072     socket->connectToHost(QtNetworkSettings::serverName(), 21);

  1073     QVERIFY(socket->state() == QAbstractSocket::HostLookupState);

  1074 

  1075     QFETCH(bool, doClose);

  1076     if (doClose) {

  1077         socket->close();

  1078         QVERIFY(socket->openMode() == QIODevice::NotOpen);

  1079     } else {

  1080         socket->disconnectFromHost();

  1081         QVERIFY(socket->openMode() == QIODevice::ReadWrite);

  1082     }

  1083 

  1084     // let anything queued happen

  1085     QEventLoop loop;

  1086 #ifndef Q_OS_SYMBIAN

  1087     QTimer::singleShot(50, &loop, SLOT(quit()));

  1088 #else

  1089     QTimer::singleShot(5000, &loop, SLOT(quit()));

  1090 #endif

  1091     loop.exec();

  1092 

  1093     // recheck

  1094     if (doClose) {

  1095         QVERIFY(socket->openMode() == QIODevice::NotOpen);

  1096     } else {

  1097         QVERIFY(socket->openMode() == QIODevice::ReadWrite);

  1098     }

  1099 

  1100     QVERIFY(socket->state() == QAbstractSocket::UnconnectedState);

  1101 }

  1102 

  1103 //----------------------------------------------------------------------------------

  1104 void tst_QTcpSocket::downloadBigFile()

  1105 {

  1106     if (tmpSocket)

  1107         delete tmpSocket;

  1108     tmpSocket = newSocket();

  1109 

  1110     connect(tmpSocket, SIGNAL(connected()), SLOT(exitLoopSlot()));

  1111     connect(tmpSocket, SIGNAL(readyRead()), SLOT(downloadBigFileSlot()));

  1112 

  1113     tmpSocket->connectToHost(QtNetworkSettings::serverName(), 80);

  1114 

  1115     enterLoop(30);

  1116     if (timeout()) {

  1117         delete tmpSocket;

  1118         tmpSocket = 0;

  1119         QFAIL("Network operation timed out");

  1120     }

  1121 

  1122     QByteArray hostName = QtNetworkSettings::serverName().toLatin1();

  1123     QVERIFY(tmpSocket->state() == QAbstractSocket::ConnectedState);

  1124     QVERIFY(tmpSocket->write("GET /mediumfile HTTP/1.0\r\n") > 0);

  1125     QVERIFY(tmpSocket->write("HOST: ") > 0);

  1126     QVERIFY(tmpSocket->write(hostName.data()) > 0);

  1127     QVERIFY(tmpSocket->write("\r\n") > 0);

  1128     QVERIFY(tmpSocket->write("\r\n") > 0);

  1129 

  1130     bytesAvailable = 0;

  1131     expectedLength = 0;

  1132     readingBody = false;

  1133 

  1134     QTime stopWatch;