/****************************************************************************

**

** All rights reserved.

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

**

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

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

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

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

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

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

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

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

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

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

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

**

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

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

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

**

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

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

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

// Just to get Q_OS_SYMBIAN

#include <qglobal.h>

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

#include <winsock2.h>

#else

#include <sys/types.h>

#include <sys/socket.h>

#include <fcntl.h>

#include <unistd.h>

#define SOCKET int

#define INVALID_SOCKET -1

#endif

#include <qplatformdefs.h>

#include <QtTest/QtTest>

#include <QAuthenticator>

#include <QCoreApplication>

#include <QEventLoop>

#include <QFile>

#include <QHostAddress>

#include <QHostInfo>

#include <QMap>

#ifndef Q_OS_VXWORKS

#include <QMessageBox>

#include <QPushButton>

#endif

#include <QPointer>

#include <QProcess>

#include <QStringList>

#include <QTcpServer>

#include <QTcpSocket>

#ifndef QT_NO_OPENSSL

#include <QSslSocket>

#endif

#include <QTextStream>

#include <QThread>

#include <QTime>

#include <QTimer>

#include <QDebug>

// RVCT compiles also unused inline methods

# include <QNetworkProxy>

#ifdef Q_OS_LINUX

#include <stdio.h>

#include <stdlib.h>

#include <sys/stat.h>

#include <unistd.h>

#endif

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

Q_DECLARE_METATYPE(QAbstractSocket::SocketError)

Q_DECLARE_METATYPE(QAbstractSocket::SocketState)

Q_DECLARE_METATYPE(QNetworkProxy)

Q_DECLARE_METATYPE(QList<QNetworkProxy>)

//TESTED_CLASS=

//TESTED_FILES=

QT_FORWARD_DECLARE_CLASS(QTcpSocket)

class tst_QTcpSocket : public QObject

{

    Q_OBJECT

public:

    tst_QTcpSocket();

    virtual ~tst_QTcpSocket();

    static void enterLoop(int secs)

    {

        ++loopLevel;

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

        --loopLevel;

    }

    static void exitLoop()

    {

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

        // exit one.

        if (loopLevel > 0)

            QTestEventLoop::instance().exitLoop();

    }

    static bool timeout()

    {

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

    }

public slots:

    void initTestCase_data();

    void init();

    void cleanup();

private slots:

    void constructing();

    void setInvalidSocketDescriptor();

    void setSocketDescriptor();

    void socketDescriptor();

    void blockingIMAP();

    void nonBlockingIMAP();

    void hostNotFound();

    void timeoutConnect();

    void delayedClose();

    void partialRead();

    void unget();

    void readAllAfterClose();

    void openCloseOpenClose();

    void connectDisconnectConnectDisconnect();

    void disconnectWhileConnecting_data();

    void disconnectWhileConnecting();

    void disconnectWhileConnectingNoEventLoop_data();

    void disconnectWhileConnectingNoEventLoop();

    void disconnectWhileLookingUp_data();

    void disconnectWhileLookingUp();

    void downloadBigFile();

    void readLine();

    void readLineString();

    void readChunks();

    void waitForBytesWritten();

    void waitForReadyRead();

    void flush();

    void synchronousApi();

    void dontCloseOnTimeout();

    void recursiveReadyRead();

    void atEnd();

    void socketInAThread();

    void socketsInThreads();

    void waitForReadyReadInASlot();

    void remoteCloseError();

    void openMessageBoxInErrorSlot();

#ifndef Q_OS_WIN

    void connectToLocalHostNoService();

#endif

    void waitForConnectedInHostLookupSlot();

    void waitForConnectedInHostLookupSlot2();

    void readyReadSignalsAfterWaitForReadyRead();

#ifdef Q_OS_LINUX

    void linuxKernelBugLocalSocket();

#endif

    void abortiveClose();

    void localAddressEmptyOnBSD();

    void zeroAndMinusOneReturns();

    void connectionRefused();

    void suddenRemoteDisconnect_data();

    void suddenRemoteDisconnect();

    void connectToMultiIP();

    void moveToThread0();

    void increaseReadBufferSize();

    void taskQtBug5799ConnectionErrorWaitForConnected();

    void taskQtBug5799ConnectionErrorEventLoop();

    void invalidProxy_data();

    void invalidProxy();

    void proxyFactory_data();

    void proxyFactory();

protected slots:

    void nonBlockingIMAP_hostFound();

    void nonBlockingIMAP_connected();

    void nonBlockingIMAP_closed();

    void nonBlockingIMAP_readyRead();

    void nonBlockingIMAP_bytesWritten(qint64);

    void readRegularFile_readyRead();

    void exitLoopSlot();

    void downloadBigFileSlot();

    void recursiveReadyReadSlot();

    void waitForReadyReadInASlotSlot();

    void messageBoxSlot();

    void hostLookupSlot();

    void abortiveClose_abortSlot();

    void remoteCloseErrorSlot();

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

private:

    QTcpSocket *newSocket() const;

    QTcpSocket *nonBlockingIMAP_socket;

    QStringList nonBlockingIMAP_data;

    qint64 nonBlockingIMAP_totalWritten;

    QTcpSocket *tmpSocket;

    qint64 bytesAvailable;

    qint64 expectedLength;

    bool readingBody;

    QTime timer;

    mutable int proxyAuthCalled;

    bool gotClosedSignal;

    int numConnections;

    static int loopLevel;

};

enum ProxyTests {

    NoProxy = 0x00,

    Socks5Proxy = 0x01,

    HttpProxy = 0x02,

    TypeMask = 0x0f,

    NoAuth = 0x00,

    AuthBasic = 0x10,

    AuthNtlm = 0x20,

    AuthMask = 0xf0

};

int tst_QTcpSocket::loopLevel = 0;

tst_QTcpSocket::tst_QTcpSocket()

{

    Q_SET_DEFAULT_IAP

    tmpSocket = 0;

}

tst_QTcpSocket::~tst_QTcpSocket()

{

}

void tst_QTcpSocket::initTestCase_data()

{

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

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

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

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

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

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

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

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

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

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

#ifndef QT_NO_OPENSSL

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

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

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

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

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

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

#endif

}

void tst_QTcpSocket::init()

{

    QFETCH_GLOBAL(bool, setProxy);

    if (setProxy) {

        QFETCH_GLOBAL(int, proxyType);

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

        QNetworkProxy proxy;

        switch (proxyType) {

        case Socks5Proxy:

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

            break;

        case Socks5Proxy | AuthBasic:

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

            break;

        case HttpProxy | NoAuth:

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

            break;

        case HttpProxy | AuthBasic:

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

            break;

        case HttpProxy | AuthNtlm:

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

            break;

        }

        QNetworkProxy::setApplicationProxy(proxy);

    }

}

QTcpSocket *tst_QTcpSocket::newSocket() const

{

    QTcpSocket *socket;

#ifndef QT_NO_OPENSSL

    QFETCH_GLOBAL(bool, ssl);

    socket = ssl ? new QSslSocket : new QTcpSocket;

#else

    socket = new QTcpSocket;

#endif

    proxyAuthCalled = 0;

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

            SLOT(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),

            Qt::DirectConnection);

    return socket;

}

void tst_QTcpSocket::cleanup()

{

    QNetworkProxy::setApplicationProxy(QNetworkProxy::DefaultProxy);

}

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

{

    ++proxyAuthCalled;

    auth->setUser("qsockstest");

    auth->setPassword("password");

}

//----------------------------------------------------------------------------------

void tst_QTcpSocket::constructing()

{

    QTcpSocket *socket = newSocket();

    // Check the initial state of the QTcpSocket.

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

    QVERIFY(socket->isSequential());

    QVERIFY(!socket->isOpen());

    QVERIFY(!socket->isValid());

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

    char c;

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

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

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

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

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

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

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

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

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

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

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

    // Check the state of the socket layer?

    delete socket;

}

//----------------------------------------------------------------------------------

void tst_QTcpSocket::setInvalidSocketDescriptor()

{

    QTcpSocket *socket = newSocket();

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

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

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

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

    delete socket;

}

//----------------------------------------------------------------------------------

void tst_QTcpSocket::setSocketDescriptor()

{

    QFETCH_GLOBAL(bool, setProxy);

    if (setProxy)

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

#ifdef Q_OS_WIN

    // need the dummy to ensure winsock is started

    QTcpSocket *dummy = newSocket();

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

    QVERIFY(dummy->waitForConnected());

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

    if (sock == INVALID_SOCKET) {

        qErrnoWarning(WSAGetLastError(), "INVALID_SOCKET");

    }

#else

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

    // artificially increase the value of sock

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

    ::close(sock);

    sock = sock2;

#endif

    QVERIFY(sock != INVALID_SOCKET);

    QTcpSocket *socket = newSocket();

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

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

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

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

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

    QVERIFY(socket->waitForConnected(10000));

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

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

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

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

    delete socket;

#ifdef Q_OS_WIN

    delete dummy;

#endif

}

//----------------------------------------------------------------------------------

void tst_QTcpSocket::socketDescriptor()

{

    QTcpSocket *socket = newSocket();

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

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

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

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

    QVERIFY(socket->waitForConnected(10000));

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

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

    delete socket;

}

//----------------------------------------------------------------------------------

void tst_QTcpSocket::blockingIMAP()

{

    QTcpSocket *socket = newSocket();

    // Connect

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

    QVERIFY(socket->waitForConnected(10000));

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

    QVERIFY(socket->isValid());

    // Read greeting

    QVERIFY(socket->waitForReadyRead(5000));

    QString s = socket->readLine();

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

    // IMAP server versions

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

    // Write NOOP

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

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

    if (!socket->canReadLine())

        QVERIFY(socket->waitForReadyRead(5000));

    // Read response

    s = socket->readLine();

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

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

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

    // Read second response

    if (!socket->canReadLine())

        QVERIFY(socket->waitForReadyRead(5000));

    s = socket->readLine();

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

    // Read third response

    if (!socket->canReadLine())

        QVERIFY(socket->waitForReadyRead(5000));

    s = socket->readLine();

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

    // Write LOGOUT

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

    if (!socket->canReadLine())

        QVERIFY(socket->waitForReadyRead(5000));

    // Read two lines of respose

    s = socket->readLine();

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

    if (!socket->canReadLine())

        QVERIFY(socket->waitForReadyRead(5000));

    s = socket->readLine();

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

    // Close the socket

    socket->close();

    // Check that it's closed

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

    delete socket;

}

//----------------------------------------------------------------------------------