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

**

** All rights reserved.

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

**

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

**

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

#include "qplatformdefs.h"

// Almost always the same. If not, specify in qplatformdefs.h.

#if !defined(QT_SOCKOPTLEN_T)

# define QT_SOCKOPTLEN_T QT_SOCKLEN_T

#endif

// Tru64 redefines accept -> _accept with _XOPEN_SOURCE_EXTENDED

static inline int qt_socket_accept(int s, struct sockaddr *addr, QT_SOCKLEN_T *addrlen)

{ return ::accept(s, addr, addrlen); }

#if defined(accept)

# undef accept

#endif

// UnixWare 7 redefines listen -> _listen

static inline int qt_socket_listen(int s, int backlog)

{ return ::listen(s, backlog); }

#if defined(listen)

# undef listen

#endif

// UnixWare 7 redefines socket -> _socket

static inline int qt_socket_socket(int domain, int type, int protocol)

{ return ::socket(domain, type, protocol); }

#if defined(socket)

# undef socket

#endif

#include "q3socketdevice.h"

#ifndef QT_NO_NETWORK

#include "qwindowdefs.h"

#include <errno.h>

#include <sys/types.h>

QT_BEGIN_NAMESPACE

static inline void qt_socket_getportaddr( struct sockaddr *sa,

					  Q_UINT16 *port, QHostAddress *addr )

{

#if !defined(QT_NO_IPV6)

    if ( sa->sa_family == AF_INET6 ) {

	struct sockaddr_in6 *sa6 = ( struct sockaddr_in6 * )sa;

	Q_IPV6ADDR tmp;

	memcpy( &tmp, &sa6->sin6_addr.s6_addr, sizeof(tmp) );

	QHostAddress a( tmp );

	*addr = a;

	*port = ntohs( sa6->sin6_port );

	return;

    }

#endif

    struct sockaddr_in *sa4 = (struct sockaddr_in *)sa;

    QHostAddress a( ntohl( sa4->sin_addr.s_addr ) );

    *port = ntohs( sa4->sin_port );

    *addr = QHostAddress( ntohl( sa4->sin_addr.s_addr ) );

    return;

}

//#define QSOCKETDEVICE_DEBUG

// internal

void Q3SocketDevice::init()

{

}

Q3SocketDevice::Protocol Q3SocketDevice::getProtocol() const

{

    if ( isValid() ) {

#if !defined (QT_NO_IPV6)

	struct sockaddr_storage sa;

#else

	struct sockaddr sa;

#endif

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

	QT_SOCKLEN_T sz = sizeof( sa );

#if !defined (QT_NO_IPV6)

	struct sockaddr *sap = reinterpret_cast<struct sockaddr *>(&sa);

	if ( !::getsockname(fd, sap, &sz) ) {

	    switch ( sap->sa_family ) {

		case AF_INET:

		    return IPv4;

		case AF_INET6:

		    return IPv6;

		default:

		    return Unknown;

	    }

	}

#else

	if ( !::getsockname(fd, &sa, &sz) ) {

	    switch ( sa.sa_family ) {

		case AF_INET:

		    return IPv4;

		default:

		    return Unknown;

	    }

	}

#endif

    }

    return Unknown;

}

int Q3SocketDevice::createNewSocket()

{

#if !defined(QT_NO_IPV6)

    int s = qt_socket_socket( protocol() == IPv6 ? AF_INET6 : AF_INET,

			      t == Datagram ? SOCK_DGRAM : SOCK_STREAM, 0 );

#else

    int s = qt_socket_socket( AF_INET, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );

#endif

    if ( s < 0 ) {

	switch( errno ) {

	case EPROTONOSUPPORT:

	    e = InternalError; // 0 is supposed to work for both types

	    break;

	case ENFILE:

	    e = NoFiles; // special case for this

	    break;

	case EACCES:

	    e = Inaccessible;

	    break;

	case ENOBUFS:

	case ENOMEM:

	    e = NoResources;

	    break;

	case EINVAL:

	    e = Impossible;

	    break;

	default:

	    e = UnknownError;

	    break;

	}

    } else {

	return s;

    }

    return -1;

}

void Q3SocketDevice::close()

{

    if ( fd == -1 || !isOpen() )		// already closed

	return;

    resetStatus();

    setOpenMode(NotOpen);

    ::close( fd );

#if defined(QSOCKETDEVICE_DEBUG)

    qDebug( "Q3SocketDevice::close: Closed socket %x", fd );

#endif

    fd = -1;

    fetchConnectionParameters();

    QIODevice::close();

}

bool Q3SocketDevice::blocking() const

{

    if ( !isValid() )

	return true;

    int s = fcntl(fd, F_GETFL, 0);

    return !(s >= 0 && ((s & O_NDELAY) != 0));

}

void Q3SocketDevice::setBlocking( bool enable )

{

#if defined(QSOCKETDEVICE_DEBUG)

    qDebug( "Q3SocketDevice::setBlocking( %d )", enable );

#endif

    if ( !isValid() )

	return;

    int tmp = ::fcntl(fd, F_GETFL, 0);

    if ( tmp >= 0 )

	tmp = ::fcntl( fd, F_SETFL, enable ? (tmp&~O_NDELAY) : (tmp|O_NDELAY) );

    if ( tmp >= 0 )

	return;

    if ( e )

	return;

    switch( errno ) {

    case EACCES:

    case EBADF:

	e = Impossible;

	break;

    case EFAULT:

    case EAGAIN:

#if EAGAIN != EWOULDBLOCK

    case EWOULDBLOCK:

#endif

    case EDEADLK:

    case EINTR:

    case EINVAL:

    case EMFILE:

    case ENOLCK:

    case EPERM:

    default:

	e = UnknownError;

    }

}

int Q3SocketDevice::option( Option opt ) const

{

    if ( !isValid() )

	return -1;

    int n = -1;

    int v = -1;

    switch ( opt ) {

    case Broadcast:

	n = SO_BROADCAST;

	break;

    case ReceiveBuffer:

	n = SO_RCVBUF;

	break;

    case ReuseAddress:

	n = SO_REUSEADDR;

	break;

    case SendBuffer:

	n = SO_SNDBUF;

	break;

    }

    if ( n != -1 ) {

	QT_SOCKOPTLEN_T len;

	len = sizeof(v);

	int r = ::getsockopt( fd, SOL_SOCKET, n, (char*)&v, &len );

	if ( r >= 0 )

	    return v;

	if ( !e ) {

	    Q3SocketDevice *that = (Q3SocketDevice*)this; // mutable function

	    switch( errno ) {

	    case EBADF:

	    case ENOTSOCK:

		that->e = Impossible;

		break;

	    case EFAULT:

		that->e = InternalError;

		break;

	    default:

		that->e = UnknownError;

		break;

	    }

	}

	return -1;

    }

    return v;

}

void Q3SocketDevice::setOption( Option opt, int v )

{

    if ( !isValid() )

	return;

    int n = -1; // for really, really bad compilers

    switch ( opt ) {

    case Broadcast:

	n = SO_BROADCAST;

	break;

    case ReceiveBuffer:

	n = SO_RCVBUF;

	break;

    case ReuseAddress:

	n = SO_REUSEADDR;

	break;

    case SendBuffer:

	n = SO_SNDBUF;

	break;

    default:

	return;

    }

    if ( ::setsockopt( fd, SOL_SOCKET, n, (char*)&v, sizeof(v)) < 0 &&

	 e == NoError ) {

	switch( errno ) {

	case EBADF:

	case ENOTSOCK:

	    e = Impossible;

	    break;

	case EFAULT:

	    e = InternalError;

	    break;

	default:

	    e = UnknownError;

	    break;

	}

    }

}

bool Q3SocketDevice::connect( const QHostAddress &addr, Q_UINT16 port )

{

    if ( !isValid() )

	return false;

    pa = addr;

    pp = port;

    struct sockaddr_in a4;

    struct sockaddr *aa;

    QT_SOCKLEN_T aalen;

#if !defined(QT_NO_IPV6)

    struct sockaddr_in6 a6;

    if ( addr.isIPv6Address() ) {

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

	a6.sin6_family = AF_INET6;

	a6.sin6_port = htons( port );

	Q_IPV6ADDR ip6 = addr.toIPv6Address();

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

	aalen = sizeof( a6 );

	aa = (struct sockaddr *)&a6;

    } else

#endif

    if ( addr.isIPv4Address() ) {

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

	a4.sin_family = AF_INET;

	a4.sin_port = htons( port );

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

	aalen = sizeof(a4);

	aa = (struct sockaddr *)&a4;

    } else {

	e = Impossible;

	return false;

    }

    int r = QT_SOCKET_CONNECT( fd, aa, aalen );

    if ( r == 0 ) {

	fetchConnectionParameters();

	return true;

    }

    if ( errno == EISCONN || errno == EALREADY || errno == EINPROGRESS ) {

	fetchConnectionParameters();

	return true;

    }

    if ( e != NoError || errno == EAGAIN || errno == EWOULDBLOCK ) {

	return false;

    }

    switch( errno ) {

    case EBADF:

    case ENOTSOCK:

	e = Impossible;

	break;

    case EFAULT:

    case EAFNOSUPPORT:

	e = InternalError;

	break;

    case ECONNREFUSED:

	e = ConnectionRefused;

	break;

    case ETIMEDOUT:

    case ENETUNREACH:

	e = NetworkFailure;

	break;

    case EADDRINUSE:

	e = NoResources;

	break;

    case EACCES:

    case EPERM:

	e = Inaccessible;

	break;

    default:

	e = UnknownError;

	break;

    }

    return false;

}

bool Q3SocketDevice::bind( const QHostAddress &address, Q_UINT16 port )

{

    if ( !isValid() )

	return false;

    int r;

    struct sockaddr_in a4;

#if !defined(QT_NO_IPV6)

    struct sockaddr_in6 a6;

    if ( address.isIPv6Address() ) {

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

	a6.sin6_family = AF_INET6;

	a6.sin6_port = htons( port );

	Q_IPV6ADDR tmp = address.toIPv6Address();

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

	r = QT_SOCKET_BIND( fd, (struct sockaddr *)&a6, sizeof(a6) );

    } else

#endif

    if ( address.isIPv4Address() ) {

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

	a4.sin_family = AF_INET;

	a4.sin_port = htons( port );

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

	r = QT_SOCKET_BIND( fd, (struct sockaddr*)&a4, sizeof(a4) );

    } else {

	e = Impossible;

	return false;

    }

    if ( r < 0 ) {

	switch( errno ) {

	case EINVAL:

	    e = AlreadyBound;

	    break;

	case EACCES:

	    e = Inaccessible;

	    break;

	case ENOMEM:

	    e = NoResources;

	    break;

	case EFAULT: // a was illegal

	case ENAMETOOLONG: // sz was wrong

	    e = InternalError;

	    break;

	case EBADF: // AF_UNIX only

	case ENOTSOCK: // AF_UNIX only

	case EROFS: // AF_UNIX only

	case ENOENT: // AF_UNIX only

	case ENOTDIR: // AF_UNIX only

	case ELOOP: // AF_UNIX only

	    e = Impossible;

	    break;

	default:

	    e = UnknownError;

	    break;

	}

	return false;

    }

    fetchConnectionParameters();

    return true;

}

bool Q3SocketDevice::listen( int backlog )

{

    if ( !isValid() )

	return false;

    if ( qt_socket_listen( fd, backlog ) >= 0 )

	return true;

    if ( !e )

	e = Impossible;

    return false;

}

int Q3SocketDevice::accept()

{

    if ( !isValid() )

	return -1;

#if !defined (QT_NO_IPV6)

    struct sockaddr_storage aa;

#else

    struct sockaddr aa;

#endif

    QT_SOCKLEN_T l = sizeof( aa );

    bool done;

    int s;

    do {

        s = qt_socket_accept( fd, (struct sockaddr*)&aa, &l );

        // we'll blithely throw away the stuff accept() wrote to aa

        done = true;

        if ( s < 0 && e == NoError ) {

            switch( errno ) {

            case EINTR:

                done = false;

                break;

#if defined(EPROTO)

	    case EPROTO:

#endif

#if defined(ENONET)

	    case ENONET:

#endif

	    case ENOPROTOOPT:

	    case EHOSTDOWN:

	    case EOPNOTSUPP:

	    case EHOSTUNREACH:

	    case ENETDOWN:

	    case ENETUNREACH:

	    case ETIMEDOUT:

		// in all these cases, an error happened during connection

		// setup.  we're not interested in what happened, so we

		// just treat it like the client-closed-quickly case.

	    case EPERM: