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

**

** 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 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 "q3socketdevice.h"

#include "qwindowdefs.h"

#include "qdatetime.h"

#include <qcoreapplication.h>

#include <string.h>

#if defined (QT_NO_IPV6)

#  include <winsock.h>

#else

#  if defined (Q_CC_BOR) || defined (Q_CC_GNU)

#    include <winsock2.h>

#  else

#    include <winsock.h>

#  endif

// Use our own defines and structs which we know are correct

#  define QT_SS_MAXSIZE 128

#  define QT_SS_ALIGNSIZE (sizeof(__int64))

#  define QT_SS_PAD1SIZE (QT_SS_ALIGNSIZE - sizeof (short))

#  define QT_SS_PAD2SIZE (QT_SS_MAXSIZE - (sizeof (short) + QT_SS_PAD1SIZE + QT_SS_ALIGNSIZE))

QT_BEGIN_NAMESPACE

struct qt_sockaddr_storage {

      short ss_family;

      char __ss_pad1[QT_SS_PAD1SIZE];

      __int64 __ss_align;

      char __ss_pad2[QT_SS_PAD2SIZE];

};

// sockaddr_in6 size changed between old and new SDK

// Only the new version is the correct one, so always

// use this structure.

struct qt_in6_addr {

    u_char qt_s6_addr[16];

};

typedef struct {

    short   sin6_family;            /* AF_INET6 */

    u_short sin6_port;              /* Transport level port number */

    u_long  sin6_flowinfo;          /* IPv6 flow information */

    struct  qt_in6_addr sin6_addr;  /* IPv6 address */

    u_long  sin6_scope_id;          /* set of interfaces for a scope */

} qt_sockaddr_in6;

#endif

#ifndef AF_INET6

#define AF_INET6        23              /* Internetwork Version 6 */

#endif

#ifndef NO_ERRNO_H

QT_BEGIN_INCLUDE_NAMESPACE

#  if defined(Q_OS_WINCE)

#     include "qfunctions_wince.h"

#  else

#     include <errno.h>

#  endif

QT_END_INCLUDE_NAMESPACE

#endif

#if defined(SOCKLEN_T)

#undef SOCKLEN_T

#endif

#define SOCKLEN_T int // #### Winsock 1.1

static int initialized = 0x00; // Holds the Winsock version

static void cleanupWinSock() // post-routine

{

    WSACleanup();

    initialized = 0x00;

}

static inline void qt_socket_getportaddr( struct sockaddr *sa,

					  quint16 *port, QHostAddress *addr )

{

#if !defined (QT_NO_IPV6)

    if (sa->sa_family == AF_INET6) {

	qt_sockaddr_in6 *sa6 = (qt_sockaddr_in6 *)sa;

	Q_IPV6ADDR tmp;

	for ( int i = 0; i < 16; ++i )

	    tmp.c[i] = sa6->sin6_addr.qt_s6_addr[i];

	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 = a;

}

void Q3SocketDevice::init()

{

#if !defined(QT_NO_IPV6)

    if ( !initialized ) {

	WSAData wsadata;

	// IPv6 requires Winsock v2.0 or better.

	if ( WSAStartup( MAKEWORD(2,0), &wsadata ) != 0 ) {

#  if defined(QSOCKETDEVICE_DEBUG)

	    qDebug( "Q3SocketDevice: WinSock v2.0 initialization failed, disabling IPv6 support." );

#  endif

	} else {

	    qAddPostRoutine( cleanupWinSock );

	    initialized = 0x20;

	    return;

	}

    }

#endif

    if (!initialized) {

	WSAData wsadata;

	if ( WSAStartup( MAKEWORD(1,1), &wsadata ) != 0 ) {

#if defined(QT_CHECK_NULL)

	    qWarning( "Q3SocketDevice: WinSock initialization failed" );

#endif

#if defined(QSOCKETDEVICE_DEBUG)

	    qDebug( "Q3SocketDevice: WinSock initialization failed"  );

#endif

	    return;

	}

	qAddPostRoutine( cleanupWinSock );

	initialized = 0x11;

    }

}

Q3SocketDevice::Protocol Q3SocketDevice::getProtocol() const

{

    if ( isValid() ) {

#if !defined (QT_NO_IPV6)

	struct qt_sockaddr_storage sa;

#else

	struct sockaddr_in sa;

#endif

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

	SOCKLEN_T sz = sizeof( sa );

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

#if !defined (QT_NO_IPV6)

	    switch ( sa.ss_family ) {

		case AF_INET:

		    return IPv4;

		case AF_INET6:

		    return IPv6;

		default:

		    return Unknown;

	    }

#else

	    switch ( sa.sin_family ) {

		case AF_INET:

		    return IPv4;

		default:

		    return Unknown;

	    }

#endif

	}

    }

    return Unknown;

}

int Q3SocketDevice::createNewSocket( )

{

#if !defined(QT_NO_IPV6)

    SOCKET s;

    // Support IPv6 for Winsock v2.0++

    if ( initialized >= 0x20 && protocol() == IPv6 ) {

	s = ::socket( AF_INET6, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );

    } else {

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

    }

#else

    SOCKET s = ::socket( AF_INET, t==Datagram?SOCK_DGRAM:SOCK_STREAM, 0 );

#endif

    if ( s == INVALID_SOCKET ) {

	switch( WSAGetLastError() ) {

	    case WSANOTINITIALISED:

		e = Impossible;

		break;

	    case WSAENETDOWN:

		// ### what to use here?

		e = NetworkFailure;

		//e = Inaccessible;

		break;

	    case WSAEMFILE:

		e = NoFiles; // special case for this

		break;

	    case WSAEINPROGRESS:

	    case WSAENOBUFS:

		e = NoResources;

		break;

	    case WSAEAFNOSUPPORT:

	    case WSAEPROTOTYPE:

	    case WSAEPROTONOSUPPORT:

	    case WSAESOCKTNOSUPPORT:

		e = InternalError;

		break;

	    default:

		e = UnknownError;

		break;

	}

    } else {

	return s;

    }

    return -1;

}

void Q3SocketDevice::close()

{

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

	return;

    resetStatus();

    setOpenMode(NotOpen);

    ::closesocket( fd );

#if defined(QSOCKETDEVICE_DEBUG)

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

#endif

    fd = -1;

    fetchConnectionParameters();

    QIODevice::close();

}

bool Q3SocketDevice::blocking() const

{

    return true;

}

void Q3SocketDevice::setBlocking( bool enable )

{

#if defined(QSOCKETDEVICE_DEBUG)

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

#endif

    if ( !isValid() )

	return;

    unsigned long dummy = enable ? 0 : 1;

    ioctlsocket( fd, FIONBIO, &dummy );

}

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 ) {

	SOCKLEN_T len = sizeof(v);

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

	if ( r != SOCKET_ERROR )

	    return v;

	if ( !e ) {

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

	    switch( WSAGetLastError() ) {

		case WSANOTINITIALISED:

		    that->e = Impossible;

		    break;

		case WSAENETDOWN:

		    that->e = NetworkFailure;

		    break;

		case WSAEFAULT:

		case WSAEINVAL:

		case WSAENOPROTOOPT:

		    that->e = InternalError;

		    break;

		case WSAEINPROGRESS:

		    that->e = NoResources;

		    break;

		case WSAENOTSOCK:

		    that->e = Impossible;

		    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;

    }

    int r = ::setsockopt( fd, SOL_SOCKET, n, (char*)&v, sizeof(v) );

    if ( r == SOCKET_ERROR && e == NoError ) {

	switch( WSAGetLastError() ) {

	    case WSANOTINITIALISED:

		e = Impossible;

		break;

	    case WSAENETDOWN:

		e = NetworkFailure;

		break;

	    case WSAEFAULT:

	    case WSAEINVAL:

	    case WSAENOPROTOOPT:

		e = InternalError;

		break;

	    case WSAEINPROGRESS:

		e = NoResources;

		break;

	    case WSAENETRESET:

	    case WSAENOTCONN:

		e =  Impossible; // ### ?

		break;

	    case WSAENOTSOCK:

		e = Impossible;

		break;

	    default:

		e = UnknownError;

		break;

	}

    }

}

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

{

    if ( !isValid() )

	return false;

    pa = addr;

    pp = port;

    struct sockaddr_in a4;

    struct sockaddr *aa;

    SOCKLEN_T aalen;

#if !defined(QT_NO_IPV6)

    qt_sockaddr_in6 a6;

    if ( initialized >= 0x20 && 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.qt_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 = ::connect( fd, aa, aalen );

    if ( r == SOCKET_ERROR )

    {

	switch( WSAGetLastError() ) {

	    case WSANOTINITIALISED:

		e = Impossible;

		break;

	    case WSAENETDOWN:

		e = NetworkFailure;

		break;

	    case WSAEADDRINUSE:

	    case WSAEINPROGRESS:

	    case WSAENOBUFS:

		e = NoResources;

		break;

	    case WSAEINTR:

		e = UnknownError; // ### ?

		break;

	    case WSAEALREADY:

		// ### ?

		break;

	    case WSAEADDRNOTAVAIL:

		e = ConnectionRefused; // ### ?

		break;

	    case WSAEAFNOSUPPORT:

	    case WSAEFAULT:

		e = InternalError;

		break;

	    case WSAEINVAL:

		break;

	    case WSAECONNREFUSED:

		e = ConnectionRefused;

		break;

	    case WSAEISCONN:

		goto successful;

	    case WSAENETUNREACH:

	    case WSAETIMEDOUT:

		e = NetworkFailure;

		break;

	    case WSAENOTSOCK:

		e = Impossible;

		break;

	    case WSAEWOULDBLOCK:

		break;

	    case WSAEACCES:

		e = Inaccessible;

		break;

	    case 10107:

		// Workaround for a problem with the WinSock Proxy Server. See

		// also support/arc-12/25557 for details on the problem.

		goto successful;

	    default:

		e = UnknownError;

		break;

	}

	return false;

    }

successful:

    fetchConnectionParameters();

    return true;

}

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

{

    if ( !isValid() )

	return false;

    int r;

    struct sockaddr_in a4;

#if !defined(QT_NO_IPV6)

    qt_sockaddr_in6 a6;

    if ( initialized >= 0x20 && 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.qt_s6_addr, &tmp, sizeof(tmp) );

	r = ::bind( fd, (struct sockaddr *)&a6, sizeof(struct qt_sockaddr_storage) );

    } 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 = ::bind( fd, (struct sockaddr*)&a4, sizeof(struct sockaddr_in) );

    } else {

	e = Impossible;

	return false;

    }