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

**

** All rights reserved.

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

**

** This file is part of the QtNetwork module 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$

**

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

//#define QNATIVESOCKETENGINE_DEBUG

/*! \class QNativeSocketEngine

    \internal

    \brief The QNativeSocketEngine class provides low level access to a socket.

    \reentrant

    \ingroup network

    \inmodule QtNetwork

    QtSocketLayer provides basic socket functionality provided by the

    operating system. It also keeps track of what state the socket is

    in, and which errors that occur.

    The classes QTcpSocket, QUdpSocket and QTcpServer provide a

    higher level API, and are in general more useful for the common

    application.

    There are two main ways of initializing the a QNativeSocketEngine; either

    create a new socket by passing the socket type (TcpSocket or

    UdpSocket) and network layer protocol (IPv4Protocol or

    IPv6Protocol) to initialize(), or pass an existing socket

    descriptor and have QNativeSocketEngine determine the type and protocol

    itself. The native socket descriptor can later be fetched by

    calling socketDescriptor(). The socket is made non-blocking, but

    blocking behavior can still be achieved by calling waitForRead()

    and waitForWrite(). isValid() can be called to check if the socket

    has been successfully initialized and is ready to use.

    To connect to a host, determine its address and pass this and the

    port number to connectToHost(). The socket can then be used as a

    TCP or UDP client. Otherwise; bind(), listen() and accept() are

    used to have the socket function as a TCP or UDP server. Call

    close() to close the socket.

    bytesAvailable() is called to determine how much data is available

    for reading. read() and write() are used by both TCP and UDP

    clients to exchange data with the connected peer. UDP clients can

    also call hasMoreDatagrams(), nextDatagramSize(),

    readDatagram(), and writeDatagram().

    Call state() to determine the state of the socket, for

    example, ListeningState or ConnectedState. socketType() tells

    whether the socket is a TCP socket or a UDP socket, or if the

    socket type is unknown. protocol() is used to determine the

    socket's network layer protocol.

    localAddress(), localPort() are called to find the address and

    port that are currently bound to the socket. If the socket is

    connected, peerAddress() and peerPort() determine the address and

    port of the connected peer.

    Finally, if any function should fail, error() and

    errorString() can be called to determine the cause of the error.

*/

#include <qabstracteventdispatcher.h>

#include <qsocketnotifier.h>

#include "qnativesocketengine_p.h"

#include <private/qthread_p.h>

#include <private/qobject_p.h>

#if !defined(QT_NO_NETWORKPROXY)

# include "qnetworkproxy.h"

# include "qabstractsocket.h"

# include "qtcpserver.h"

#endif

QT_BEGIN_NAMESPACE

//#define QNATIVESOCKETENGINE_DEBUG

#define Q_VOID

// Common constructs

#define Q_CHECK_VALID_SOCKETLAYER(function, returnValue) do { \

    if (!isValid()) { \

        qWarning(""#function" was called on an uninitialized socket device"); \

        return returnValue; \

    } } while (0)

#define Q_CHECK_INVALID_SOCKETLAYER(function, returnValue) do { \

    if (isValid()) { \

        qWarning(""#function" was called on an already initialized socket device"); \

        return returnValue; \

    } } while (0)

#define Q_CHECK_STATE(function, checkState, returnValue) do { \

    if (d->socketState != (checkState)) { \

        qWarning(""#function" was not called in "#checkState); \

        return (returnValue); \

    } } while (0)

#define Q_CHECK_NOT_STATE(function, checkState, returnValue) do { \

    if (d->socketState == (checkState)) { \

        qWarning(""#function" was called in "#checkState); \

        return (returnValue); \

    } } while (0)

#define Q_CHECK_STATES(function, state1, state2, returnValue) do { \

    if (d->socketState != (state1) && d->socketState != (state2)) { \

        qWarning(""#function" was called" \

                 " not in "#state1" or "#state2); \

        return (returnValue); \

    } } while (0)

#define Q_CHECK_TYPE(function, type, returnValue) do { \

    if (d->socketType != (type)) { \

        qWarning(#function" was called by a" \

                 " socket other than "#type""); \

        return (returnValue); \

    } } while (0)

#define Q_TR(a) QT_TRANSLATE_NOOP(QNativeSocketEngine, a)

/*! \internal

    Constructs the private class and initializes all data members.

    On Windows, WSAStartup is called "recursively" for every

    concurrent QNativeSocketEngine. This is safe, because WSAStartup and

    WSACleanup are reference counted.

*/

QNativeSocketEnginePrivate::QNativeSocketEnginePrivate()

{

    socketDescriptor = -1;

    readNotifier = 0;

    writeNotifier = 0;

    exceptNotifier = 0;

}

/*! \internal

    Destructs the private class.

*/

QNativeSocketEnginePrivate::~QNativeSocketEnginePrivate()

{

}

/*! \internal

    Sets the error and error string if not set already. The only

    interesting error is the first one that occurred, and not the last

    one.

*/

void QNativeSocketEnginePrivate::setError(QAbstractSocket::SocketError error, ErrorString errorString) const

{

    if (hasSetSocketError) {

        // Only set socket errors once for one engine; expect the

        // socket to recreate its engine after an error. Note: There's

        // one exception: SocketError(11) bypasses this as it's purely

        // a temporary internal error condition.

        return;

    }

    if (error != QAbstractSocket::SocketError(11))

        hasSetSocketError = true;

    socketError = error;

    switch (errorString) {

    case NonBlockingInitFailedErrorString:

        socketErrorString = QNativeSocketEngine::tr("Unable to initialize non-blocking socket");

        break;

    case BroadcastingInitFailedErrorString:

        socketErrorString = QNativeSocketEngine::tr("Unable to initialize broadcast socket");

        break;

    case NoIpV6ErrorString:

        socketErrorString = QNativeSocketEngine::tr("Attempt to use IPv6 socket on a platform with no IPv6 support");

        break;

    case RemoteHostClosedErrorString:

        socketErrorString = QNativeSocketEngine::tr("The remote host closed the connection");

        break;

    case TimeOutErrorString:

        socketErrorString = QNativeSocketEngine::tr("Network operation timed out");

        break;

    case ResourceErrorString:

        socketErrorString = QNativeSocketEngine::tr("Out of resources");

        break;

    case OperationUnsupportedErrorString:

        socketErrorString = QNativeSocketEngine::tr("Unsupported socket operation");

        break;

    case ProtocolUnsupportedErrorString:

        socketErrorString = QNativeSocketEngine::tr("Protocol type not supported");

        break;

    case InvalidSocketErrorString:

        socketErrorString = QNativeSocketEngine::tr("Invalid socket descriptor");

        break;

    case HostUnreachableErrorString:

        socketErrorString = QNativeSocketEngine::tr("Host unreachable");

        break;

    case NetworkUnreachableErrorString:

        socketErrorString = QNativeSocketEngine::tr("Network unreachable");

        break;

    case AccessErrorString:

        socketErrorString = QNativeSocketEngine::tr("Permission denied");

        break;

    case ConnectionTimeOutErrorString:

        socketErrorString = QNativeSocketEngine::tr("Connection timed out");

        break;

    case ConnectionRefusedErrorString:

        socketErrorString = QNativeSocketEngine::tr("Connection refused");

        break;

    case AddressInuseErrorString:

        socketErrorString = QNativeSocketEngine::tr("The bound address is already in use");

        break;

    case AddressNotAvailableErrorString:

        socketErrorString = QNativeSocketEngine::tr("The address is not available");

        break;

    case AddressProtectedErrorString:

        socketErrorString = QNativeSocketEngine::tr("The address is protected");

        break;

    case DatagramTooLargeErrorString:

        socketErrorString = QNativeSocketEngine::tr("Datagram was too large to send");

        break;

    case SendDatagramErrorString:

        socketErrorString = QNativeSocketEngine::tr("Unable to send a message");

        break;

    case ReceiveDatagramErrorString:

        socketErrorString = QNativeSocketEngine::tr("Unable to receive a message");

        break;

    case WriteErrorString:

        socketErrorString = QNativeSocketEngine::tr("Unable to write");

        break;

    case ReadErrorString:

        socketErrorString = QNativeSocketEngine::tr("Network error");

        break;

    case PortInuseErrorString:

        socketErrorString = QNativeSocketEngine::tr("Another socket is already listening on the same port");

        break;

    case NotSocketErrorString:

        socketErrorString = QNativeSocketEngine::tr("Operation on non-socket");

        break;

    case InvalidProxyTypeString:

        socketErrorString = QNativeSocketEngine::tr("The proxy type is invalid for this operation");

        break;

    case UnknownSocketErrorString:

        socketErrorString = QNativeSocketEngine::tr("Unknown error");

        break;

    }

}

bool QNativeSocketEnginePrivate::checkProxy(const QHostAddress &address)

{

    if (address == QHostAddress::LocalHost || address == QHostAddress::LocalHostIPv6)

        return true;

#if !defined(QT_NO_NETWORKPROXY)

    QObject *parent = q_func()->parent();

    QNetworkProxy proxy;

    if (QAbstractSocket *socket = qobject_cast<QAbstractSocket *>(parent)) {

        proxy = socket->proxy();

    } else if (QTcpServer *server = qobject_cast<QTcpServer *>(parent)) {

        proxy = server->proxy();

    } else {

        // no parent -> no proxy

        return true;

    }

    if (proxy.type() == QNetworkProxy::DefaultProxy)

        proxy = QNetworkProxy::applicationProxy();

    if (proxy.type() != QNetworkProxy::DefaultProxy &&

        proxy.type() != QNetworkProxy::NoProxy) {

        // QNativeSocketEngine doesn't do proxies

        setError(QAbstractSocket::UnsupportedSocketOperationError,

                 QNativeSocketEnginePrivate::InvalidProxyTypeString);

        return false;

    }

#endif

    return true;

}

/*!

    Constructs a QNativeSocketEngine.

    \sa initialize()

*/

QNativeSocketEngine::QNativeSocketEngine(QObject *parent)

    : QAbstractSocketEngine(*new QNativeSocketEnginePrivate(), parent)

{

}

/*!

    Destructs a QNativeSocketEngine.

*/

QNativeSocketEngine::~QNativeSocketEngine()

{

    close();

}

/*!

    Initializes a QNativeSocketEngine by creating a new socket of type \a

    socketType and network layer protocol \a protocol. Returns true on

    success; otherwise returns false.

    If the socket was already initialized, this function closes the

    socket before reeinitializing it.

    The new socket is non-blocking, and for UDP sockets it's also

    broadcast enabled.

*/

bool QNativeSocketEngine::initialize(QAbstractSocket::SocketType socketType, QAbstractSocket::NetworkLayerProtocol protocol)

{

    Q_D(QNativeSocketEngine);

    if (isValid())

        close();

#if defined(QT_NO_IPV6)

    if (protocol == QAbstractSocket::IPv6Protocol) {

        d->setError(QAbstractSocket::UnsupportedSocketOperationError,

                    QNativeSocketEnginePrivate::NoIpV6ErrorString);

        return false;

    }

#endif

    // Create the socket

    if (!d->createNewSocket(socketType, protocol)) {

#if defined (QNATIVESOCKETENGINE_DEBUG)

        QString typeStr = QLatin1String("UnknownSocketType");

        if (socketType == QAbstractSocket::TcpSocket) typeStr = QLatin1String("TcpSocket");

        else if (socketType == QAbstractSocket::UdpSocket) typeStr = QLatin1String("UdpSocket");

        QString protocolStr = QLatin1String("UnknownProtocol");

        if (protocol == QAbstractSocket::IPv4Protocol) protocolStr = QLatin1String("IPv4Protocol");

        else if (protocol == QAbstractSocket::IPv6Protocol) protocolStr = QLatin1String("IPv6Protocol");

        qDebug("QNativeSocketEngine::initialize(type == %s, protocol == %s) failed: %s",

               typeStr.toLatin1().constData(), protocolStr.toLatin1().constData(), d->socketErrorString.toLatin1().constData());

#endif

        return false;

    }

    // Make the socket nonblocking.

    if (!setOption(NonBlockingSocketOption, 1)) {

        d->setError(QAbstractSocket::UnsupportedSocketOperationError,

                    QNativeSocketEnginePrivate::NonBlockingInitFailedErrorString);

        close();

        return false;

    }

    // Set the broadcasting flag if it's a UDP socket.

    if (socketType == QAbstractSocket::UdpSocket

        && !setOption(BroadcastSocketOption, 1)) {

        d->setError(QAbstractSocket::UnsupportedSocketOperationError,

                    QNativeSocketEnginePrivate::BroadcastingInitFailedErrorString);

        close();

        return false;

    }

    // Make sure we receive out-of-band data

    // On Symbian OS this works only with native IP stack, not with WinSock

    if (socketType == QAbstractSocket::TcpSocket

        && !setOption(ReceiveOutOfBandData, 1)) {

        qWarning("QNativeSocketEngine::initialize unable to inline out-of-band data");

    }

    // Before Qt 4.6, we always set the send and receive buffer size to 49152 as

    // this was found to be an optimal value. However, modern OS

    // all have some kind of auto tuning for this and we therefore don't set

    // this explictly anymore.

    // If it introduces any performance regressions for Qt 4.6.x (x > 0) then

    // it will be put back in.

    //

    // You can use tests/manual/qhttpnetworkconnection to test HTTP download speed

    // with this.

    //

    // pre-4.6:

    // setReceiveBufferSize(49152);

    // setSendBufferSize(49152);

    d->socketType = socketType;

    d->socketProtocol = protocol;

    return true;

}

/*! \overload

    Initializes the socket using \a socketDescriptor instead of

    creating a new one. The socket type and network layer protocol are

    determined automatically. The socket's state is set to \a

    socketState.

    If the socket type is either TCP or UDP, it is made non-blocking.

    UDP sockets are also broadcast enabled.

 */

bool QNativeSocketEngine::initialize(int socketDescriptor, QAbstractSocket::SocketState socketState)

{

    Q_D(QNativeSocketEngine);

    if (isValid())

        close();

    d->socketDescriptor = socketDescriptor;

    // determine socket type and protocol

    if (!d->fetchConnectionParameters()) {

#if defined (QNATIVESOCKETENGINE_DEBUG)

        qDebug("QNativeSocketEngine::initialize(socketDescriptor == %i) failed: %s",

               socketDescriptor, d->socketErrorString.toLatin1().constData());

#endif

        d->socketDescriptor = -1;

        return false;

    }

    if (d->socketType != QAbstractSocket::UnknownSocketType) {

        // Make the socket nonblocking.

        if (!setOption(NonBlockingSocketOption, 1)) {

            d->setError(QAbstractSocket::UnsupportedSocketOperationError,

                QNativeSocketEnginePrivate::NonBlockingInitFailedErrorString);

            close();

            return false;

        }

        // Set the broadcasting flag if it's a UDP socket.

        if (d->socketType == QAbstractSocket::UdpSocket

            && !setOption(BroadcastSocketOption, 1)) {

            d->setError(QAbstractSocket::UnsupportedSocketOperationError,

                QNativeSocketEnginePrivate::BroadcastingInitFailedErrorString);

            close();

            return false;

        }

    }

    d->socketState = socketState;

    return true;

}

/*!

    Returns true if the socket is valid; otherwise returns false. A

    socket is valid if it has not been successfully initialized, or if

    it has been closed.

*/

bool QNativeSocketEngine::isValid() const

{

    Q_D(const QNativeSocketEngine);

    return d->socketDescriptor != -1;

}

/*!

    Returns the native socket descriptor. Any use of this descriptor

    stands the risk of being non-portable.

*/

int QNativeSocketEngine::socketDescriptor() const

{

    Q_D(const QNativeSocketEngine);

    return d->socketDescriptor;

}

/*!

    Connects to the IP address and port specified by \a address and \a

    port. If the connection is established, this function returns true

    and the socket enters ConnectedState. Otherwise, false is

    returned.

    If false is returned, state() should be called to see if the

    socket is in ConnectingState. If so, a delayed TCP connection is

    taking place, and connectToHost() must be called again later to

    determine if the connection was established successfully or

    not. The second connection attempt must be made when the socket is

    ready for writing. This state can be determined either by

    connecting a QSocketNotifier to the socket descriptor returned by

    socketDescriptor(), or by calling the blocking function

    waitForWrite().

    Example:

    \snippet doc/src/snippets/code/src_network_socket_qnativesocketengine.cpp 0

    Otherwise, error() should be called to determine the cause of the

    error.

*/

bool QNativeSocketEngine::connectToHost(const QHostAddress &address, quint16 port)

{

    Q_D(QNativeSocketEngine);

    Q_CHECK_VALID_SOCKETLAYER(QNativeSocketEngine::connectToHost(), false);

#if defined (QT_NO_IPV6)

    if (address.protocol() == QAbstractSocket::IPv6Protocol) {

        d->setError(QAbstractSocket::UnsupportedSocketOperationError,

                    QNativeSocketEnginePrivate::NoIpV6ErrorString);

        return false;

    }

#endif

    if (!d->checkProxy(address))

        return false;

    Q_CHECK_STATES(QNativeSocketEngine::connectToHost(),

                   QAbstractSocket::UnconnectedState, QAbstractSocket::ConnectingState, false);