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

**

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

** 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

#include "qnativesocketengine_p.h"

#include "private/qnet_unix_p.h"

#include "qiodevice.h"

#include "qhostaddress.h"

#include "qvarlengtharray.h"

#include "qdatetime.h"

#include <time.h>

#include <errno.h>

#include <fcntl.h>

#ifndef QT_NO_IPV6IFNAME

#include <net/if.h>

#endif

#ifndef QT_NO_IPV6IFNAME

#include <net/if.h>

#endif

#ifdef QT_LINUXBASE

#include <arpa/inet.h>

#endif

#if defined QNATIVESOCKETENGINE_DEBUG

#include <qstring.h>

#include <ctype.h>

#endif

#ifdef Q_OS_SYMBIAN // ### TODO: Are these headers right?

#include <sys/socket.h>

#include <netinet/in.h>

#else

#include <netinet/tcp.h>

#endif

QT_BEGIN_NAMESPACE

#if defined QNATIVESOCKETENGINE_DEBUG

/*

    Returns a human readable representation of the first \a len

    characters in \a data.

*/

static QByteArray qt_prettyDebug(const char *data, int len, int maxSize)

{

    if (!data) return "(null)";

    QByteArray out;

    for (int i = 0; i < len; ++i) {

        char c = data[i];

        if (isprint(c)) {

            out += c;

        } else switch (c) {

        case '\n': out += "\\n"; break;

        case '\r': out += "\\r"; break;

        case '\t': out += "\\t"; break;

        default:

            QString tmp;

            tmp.sprintf("\\%o", c);

            out += tmp.toLatin1();

        }

    }

    if (len < maxSize)

        out += "...";

    return out;

}

#endif

static void qt_ignore_sigpipe()

{

#ifndef Q_NO_POSIX_SIGNALS

    // Set to ignore SIGPIPE once only.

    static QBasicAtomicInt atom = Q_BASIC_ATOMIC_INITIALIZER(0);

    if (atom.testAndSetRelaxed(0, 1)) {

        struct sigaction noaction;

        memset(&noaction, 0, sizeof(noaction));

        noaction.sa_handler = SIG_IGN;

        ::sigaction(SIGPIPE, &noaction, 0);

    }

#else

    // Posix signals are not supported by the underlying platform

    // so we don't need to ignore sigpipe signal explicitly

#endif

}

/*

    Extracts the port and address from a sockaddr, and stores them in

    \a port and \a addr if they are non-null.

*/

static inline void qt_socket_getPortAndAddress(const qt_sockaddr *s, quint16 *port, QHostAddress *addr)

{

#if !defined(QT_NO_IPV6)

    if (s->a.sa_family == AF_INET6) {

        Q_IPV6ADDR tmp;

        memcpy(&tmp, &s->a6.sin6_addr, sizeof(tmp));

        if (addr) {

            QHostAddress tmpAddress;

            tmpAddress.setAddress(tmp);

            *addr = tmpAddress;

#ifndef QT_NO_IPV6IFNAME

            char scopeid[IFNAMSIZ];

            if (::if_indextoname(s->a6.sin6_scope_id, scopeid)) {

                addr->setScopeId(QLatin1String(scopeid));

            } else

#endif

            addr->setScopeId(QString::number(s->a6.sin6_scope_id));

        }

        if (port)

            *port = ntohs(s->a6.sin6_port);

        return;

    }

#endif

    if (port)

        *port = ntohs(s->a4.sin_port);

    if (addr) {

        QHostAddress tmpAddress;

        tmpAddress.setAddress(ntohl(s->a4.sin_addr.s_addr));

        *addr = tmpAddress;

    }

}

/*! \internal

    Creates and returns a new socket descriptor of type \a socketType

    and \a socketProtocol.  Returns -1 on failure.

*/

bool QNativeSocketEnginePrivate::createNewSocket(QAbstractSocket::SocketType socketType,

                                         QAbstractSocket::NetworkLayerProtocol socketProtocol)

{

#ifndef QT_NO_IPV6

    int protocol = (socketProtocol == QAbstractSocket::IPv6Protocol) ? AF_INET6 : AF_INET;

#else

    Q_UNUSED(socketProtocol);

    int protocol = AF_INET;

#endif

    int type = (socketType == QAbstractSocket::UdpSocket) ? SOCK_DGRAM : SOCK_STREAM;

#ifdef Q_OS_SYMBIAN

    int socket = ::socket(protocol, type, 0);

#else

	int socket = qt_safe_socket(protocol, type, 0);

#endif

    if (socket <= 0) {

        switch (errno) {

        case EPROTONOSUPPORT:

        case EAFNOSUPPORT:

        case EINVAL:

            setError(QAbstractSocket::UnsupportedSocketOperationError, ProtocolUnsupportedErrorString);

            break;

        case ENFILE:

        case EMFILE:

        case ENOBUFS:

        case ENOMEM:

            setError(QAbstractSocket::SocketResourceError, ResourceErrorString);

            break;

        case EACCES:

            setError(QAbstractSocket::SocketAccessError, AccessErrorString);

            break;

        default:

            break;

        }

        return false;

    }

    // Ensure that the socket is closed on exec*().

    ::fcntl(socket, F_SETFD, FD_CLOEXEC);

    socketDescriptor = socket;

    return true;

}

/*

    Returns the value of the socket option \a opt.

*/

int QNativeSocketEnginePrivate::option(QNativeSocketEngine::SocketOption opt) const

{

    Q_Q(const QNativeSocketEngine);

    if (!q->isValid())

        return -1;

    int n = -1;

    int level = SOL_SOCKET; // default

    switch (opt) {

    case QNativeSocketEngine::ReceiveBufferSocketOption:

        n = SO_RCVBUF;

        break;

    case QNativeSocketEngine::SendBufferSocketOption:

        n = SO_SNDBUF;

        break;

    case QNativeSocketEngine::NonBlockingSocketOption:

        break;

    case QNativeSocketEngine::BroadcastSocketOption:

        break;

    case QNativeSocketEngine::AddressReusable:

        n = SO_REUSEADDR;

        break;

    case QNativeSocketEngine::BindExclusively:

        return true;

    case QNativeSocketEngine::ReceiveOutOfBandData:

        n = SO_OOBINLINE;

        break;

    case QNativeSocketEngine::LowDelayOption:

        level = IPPROTO_TCP;

        n = TCP_NODELAY;

        break;

    case QNativeSocketEngine::KeepAliveOption:

        n = SO_KEEPALIVE;

        break;

    }

    int v = -1;

    QT_SOCKOPTLEN_T len = sizeof(v);

    if (::getsockopt(socketDescriptor, level, n, (char *) &v, &len) != -1)

        return v;

    return -1;

}

/*

    Sets the socket option \a opt to \a v.

*/

bool QNativeSocketEnginePrivate::setOption(QNativeSocketEngine::SocketOption opt, int v)

{

    Q_Q(QNativeSocketEngine);

    if (!q->isValid())

        return false;

    int n = 0;

    int level = SOL_SOCKET; // default

    switch (opt) {

    case QNativeSocketEngine::ReceiveBufferSocketOption:

        n = SO_RCVBUF;

        break;

    case QNativeSocketEngine::SendBufferSocketOption:

        n = SO_SNDBUF;

        break;

    case QNativeSocketEngine::BroadcastSocketOption:

        n = SO_BROADCAST;

        break;

    case QNativeSocketEngine::NonBlockingSocketOption: {

        // Make the socket nonblocking.

#if !defined(Q_OS_VXWORKS)

        int flags = ::fcntl(socketDescriptor, F_GETFL, 0);

        if (flags == -1) {

#ifdef QNATIVESOCKETENGINE_DEBUG

            perror("QNativeSocketEnginePrivate::setOption(): fcntl(F_GETFL) failed");

#endif

            return false;

        }

        if (::fcntl(socketDescriptor, F_SETFL, flags | O_NONBLOCK) == -1) {

#ifdef QNATIVESOCKETENGINE_DEBUG

            perror("QNativeSocketEnginePrivate::setOption(): fcntl(F_SETFL) failed");

#endif

            return false;

        }

#else // Q_OS_VXWORKS

        int onoff = 1;

#ifdef Q_OS_SYMBIAN

        if (::ioctl(socketDescriptor, FIONBIO, &onoff) < 0) {

#else

        if (qt_safe_ioctl(socketDescriptor, FIONBIO, &onoff) < 0) {

#endif

#ifdef QNATIVESOCKETENGINE_DEBUG

            perror("QNativeSocketEnginePrivate::setOption(): ioctl(FIONBIO, 1) failed");

#endif

            return false;

        }

#endif // Q_OS_VXWORKS

        return true;

    }

    case QNativeSocketEngine::AddressReusable:

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

        n = SO_REUSEPORT;

#else

        n = SO_REUSEADDR;

#endif

        break;

    case QNativeSocketEngine::BindExclusively:

        return true;

    case QNativeSocketEngine::ReceiveOutOfBandData:

        n = SO_OOBINLINE;

        break;

    case QNativeSocketEngine::LowDelayOption:

        level = IPPROTO_TCP;

        n = TCP_NODELAY;

        break;

    case QNativeSocketEngine::KeepAliveOption:

        n = SO_KEEPALIVE;

        break;

    }

    return ::setsockopt(socketDescriptor, level, n, (char *) &v, sizeof(v)) == 0;

}

bool QNativeSocketEnginePrivate::nativeConnect(const QHostAddress &addr, quint16 port)

{

#ifdef QNATIVESOCKETENGINE_DEBUG

    qDebug("QNativeSocketEnginePrivate::nativeConnect() : %d ", socketDescriptor);

#endif

    struct sockaddr_in sockAddrIPv4;

    struct sockaddr *sockAddrPtr = 0;

    QT_SOCKLEN_T sockAddrSize = 0;

#if !defined(QT_NO_IPV6)

    struct sockaddr_in6 sockAddrIPv6;

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

        memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6));

        sockAddrIPv6.sin6_family = AF_INET6;

        sockAddrIPv6.sin6_port = htons(port);

#ifndef QT_NO_IPV6IFNAME

        sockAddrIPv6.sin6_scope_id = ::if_nametoindex(addr.scopeId().toLatin1().data());

#else

        sockAddrIPv6.sin6_scope_id = addr.scopeId().toInt();

#endif

        Q_IPV6ADDR ip6 = addr.toIPv6Address();

        memcpy(&sockAddrIPv6.sin6_addr.s6_addr, &ip6, sizeof(ip6));

        sockAddrSize = sizeof(sockAddrIPv6);

        sockAddrPtr = (struct sockaddr *) &sockAddrIPv6;

    } else

#if 0

    {}

#endif

#endif

    if (addr.protocol() == QAbstractSocket::IPv4Protocol) {

        memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4));

        sockAddrIPv4.sin_family = AF_INET;

        sockAddrIPv4.sin_port = htons(port);

        sockAddrIPv4.sin_addr.s_addr = htonl(addr.toIPv4Address());

        sockAddrSize = sizeof(sockAddrIPv4);

        sockAddrPtr = (struct sockaddr *) &sockAddrIPv4;

    } else {

        // unreachable

    }

#ifdef Q_OS_SYMBIAN

    int connectResult = ::connect(socketDescriptor, sockAddrPtr, sockAddrSize);

#else

    int connectResult = qt_safe_connect(socketDescriptor, sockAddrPtr, sockAddrSize);

#endif

    if (connectResult == -1) {

        switch (errno) {

        case EISCONN:

            socketState = QAbstractSocket::ConnectedState;

            break;

        case ECONNREFUSED:

        case EINVAL:

            setError(QAbstractSocket::ConnectionRefusedError, ConnectionRefusedErrorString);

            socketState = QAbstractSocket::UnconnectedState;

            break;

        case ETIMEDOUT:

            setError(QAbstractSocket::NetworkError, ConnectionTimeOutErrorString);

            break;

        case EHOSTUNREACH:

            setError(QAbstractSocket::NetworkError, HostUnreachableErrorString);

            socketState = QAbstractSocket::UnconnectedState;

            break;

        case ENETUNREACH:

            setError(QAbstractSocket::NetworkError, NetworkUnreachableErrorString);

            socketState = QAbstractSocket::UnconnectedState;

            break;

        case EADDRINUSE:

            setError(QAbstractSocket::NetworkError, AddressInuseErrorString);

            break;

        case EINPROGRESS:

        case EALREADY:

            setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString);

            socketState = QAbstractSocket::ConnectingState;

            break;

        case EAGAIN:

            setError(QAbstractSocket::UnfinishedSocketOperationError, InvalidSocketErrorString);

            setError(QAbstractSocket::SocketResourceError, ResourceErrorString);

            break;

        case EACCES:

        case EPERM:

            setError(QAbstractSocket::SocketAccessError, AccessErrorString);

            socketState = QAbstractSocket::UnconnectedState;

            break;

        case EAFNOSUPPORT:

        case EBADF:

        case EFAULT:

        case ENOTSOCK:

            socketState = QAbstractSocket::UnconnectedState;

        default:

            break;

        }

        if (socketState != QAbstractSocket::ConnectedState) {

#if defined (QNATIVESOCKETENGINE_DEBUG)

            qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == false (%s)",

                   addr.toString().toLatin1().constData(), port,

                   socketState == QAbstractSocket::ConnectingState

                   ? "Connection in progress" : socketErrorString.toLatin1().constData());

#endif

            return false;

        }

    }

#if defined (QNATIVESOCKETENGINE_DEBUG)

    qDebug("QNativeSocketEnginePrivate::nativeConnect(%s, %i) == true",

           addr.toString().toLatin1().constData(), port);

#endif

    socketState = QAbstractSocket::ConnectedState;

    return true;

}

bool QNativeSocketEnginePrivate::nativeBind(const QHostAddress &address, quint16 port)

{

    struct sockaddr_in sockAddrIPv4;

    struct sockaddr *sockAddrPtr = 0;

    QT_SOCKLEN_T sockAddrSize = 0;

#if !defined(QT_NO_IPV6)

    struct sockaddr_in6 sockAddrIPv6;

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

        memset(&sockAddrIPv6, 0, sizeof(sockAddrIPv6));

        sockAddrIPv6.sin6_family = AF_INET6;

        sockAddrIPv6.sin6_port = htons(port);

#ifndef QT_NO_IPV6IFNAME

        sockAddrIPv6.sin6_scope_id = ::if_nametoindex(address.scopeId().toLatin1().data());

#else

        sockAddrIPv6.sin6_scope_id = address.scopeId().toInt();

#endif

        Q_IPV6ADDR tmp = address.toIPv6Address();

        memcpy(&sockAddrIPv6.sin6_addr.s6_addr, &tmp, sizeof(tmp));

        sockAddrSize = sizeof(sockAddrIPv6);

        sockAddrPtr = (struct sockaddr *) &sockAddrIPv6;

    } else

#endif

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

            memset(&sockAddrIPv4, 0, sizeof(sockAddrIPv4));

            sockAddrIPv4.sin_family = AF_INET;

            sockAddrIPv4.sin_port = htons(port);

            sockAddrIPv4.sin_addr.s_addr = htonl(address.toIPv4Address());

            sockAddrSize = sizeof(sockAddrIPv4);

            sockAddrPtr = (struct sockaddr *) &sockAddrIPv4;

        } else {

            // unreachable

        }

    int bindResult = QT_SOCKET_BIND(socketDescriptor, sockAddrPtr, sockAddrSize);

    if (bindResult < 0) {

        switch(errno) {

        case EADDRINUSE:

            setError(QAbstractSocket::AddressInUseError, AddressInuseErrorString);

            break;

        case EACCES:

            setError(QAbstractSocket::SocketAccessError, AddressProtectedErrorString);

            break;

        case EINVAL:

            setError(QAbstractSocket::UnsupportedSocketOperationError, OperationUnsupportedErrorString);

            break;

        case EADDRNOTAVAIL:

            setError(QAbstractSocket::SocketAddressNotAvailableError, AddressNotAvailableErrorString);

            break;

        default:

            break;

        }

#if defined (QNATIVESOCKETENGINE_DEBUG)

        qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == false (%s)",

               address.toString().toLatin1().constData(), port, socketErrorString.toLatin1().constData());

#endif

        return false;

    }

#if defined (QNATIVESOCKETENGINE_DEBUG)

    qDebug("QNativeSocketEnginePrivate::nativeBind(%s, %i) == true",

           address.toString().toLatin1().constData(), port);

#endif

    socketState = QAbstractSocket::BoundState;

    return true;

}

bool QNativeSocketEnginePrivate::nativeListen(int backlog)

{