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

**

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

#ifndef QT_NO_NETWORK

#include "q3ptrlist.h"

#include "qtimer.h"

#include "q3socketdevice.h"

#include "q3dns.h"

#include "private/q3membuf_p.h"

#include <string.h>

#ifndef NO_ERRNO_H

#if defined(Q_OS_WINCE)

#include "qfunctions_wince.h"

#else

#include <errno.h>

#endif

#endif

QT_BEGIN_NAMESPACE

//#define Q3SOCKET_DEBUG

/*

  Perhaps this private functionality needs to be refactored.

  Comment from Robert D Gatlin (Intel):

    It would be nice to have the functionality inherent in Q3Socket available

    as a separate class as a standard part of the Qt library, something along

    the line of:

      class QByteBuffer : public QIODevice { ... }

    The same class could/would be used within Q3Socket for the Read/Write

    buffers.

    The above class could be used in the following way(s):

	buffer.open( IO_WriteOnly | IO_Append );

	buffer.writeBlock( a ); // a = QByteArray

	buffer.close();

	QByteArray b;

	b.resize( buffer.size() );

	buffer.open( IO_ReadOnly );

	buffer.readBlock( b.data(), b.size() );

	buffer.close();

    But would also be useable with QDataStream (via QIODevice) with:

	buffer.open( IO_WriteOnly | IO_Append );

	QDataStream is( &buffer );

	is << 100;

	buffer.close();

	buffer.open( IO_ReadOnly );

	QDataStream os( &buffer );

	Q_UINT32 x;

	os >> x;

	buffer.close();

    The real usefulness is with any situations where data (QByteArray) arrives

    incrementally (as in Q3Socket and filter case above).

    I tried using QBuffer, but QBuffer does not trim bytes from the front of

    the buffer in cases like:

	QBuffer buf;

	buf.open( IO_ReadOnly );

	QDataStream ds( &buf );

	Q_INT32 x;

	ds >> x;

	buf.close();

    In the above case, buf.size() will be identical before and after the

    operation with QDataStream. Based on the implementation of QBuffer, it

    does not appear well suited for this kind of operation.

*/

// Private class for Q3Socket

class Q3SocketPrivate {

public:

    Q3SocketPrivate();

   ~Q3SocketPrivate();

    void closeSocket();

    void close();

    void connectionClosed();

    void setSocketDevice( Q3Socket *q, Q3SocketDevice *device );

    Q3Socket::State	state;			// connection state

    QString		host;			// host name

    Q_UINT16		port;			// host port

    Q3SocketDevice      *socket;			// connection socket

    QSocketNotifier     *rsn, *wsn;		// socket notifiers

    Q3Membuf		rba;			// read buffer

    Q_ULONG		readBufferSize;		// limit for the read buffer size

    Q3PtrList<QByteArray> wba;			// list of write bufs

    QHostAddress	addr;			// connection address

    Q3ValueList<QHostAddress> addresses;		// alternatives looked up

    QIODevice::Offset	wsize;			// write total buf size

    QIODevice::Offset	windex;			// write index

#ifndef QT_NO_DNS

    Q3Dns	       *dns4;

    Q3Dns	       *dns6;

#endif

    static Q3PtrList<Q3Socket> sn_read_alreadyCalled; // used to avoid unwanted recursion

    Q3ValueList<QHostAddress> l4;

    Q3ValueList<QHostAddress> l6;

};

Q3PtrList<Q3Socket> Q3SocketPrivate::sn_read_alreadyCalled;

Q3SocketPrivate::Q3SocketPrivate()

    : state(Q3Socket::Idle), host(QString::fromLatin1("")), port(0),

      socket(0), rsn(0), wsn(0), readBufferSize(0), wsize(0), windex(0)

{

#ifndef QT_NO_DNS

    dns4 = 0;

    dns6 = 0;

#endif

    wba.setAutoDelete( true );

}

Q3SocketPrivate::~Q3SocketPrivate()

{

    close();

    delete socket;

#ifndef QT_NO_DNS

    delete dns4;

    delete dns6;

#endif

}

extern void qDeleteInEventHandler(QObject *o);

void Q3SocketPrivate::closeSocket()

{

    // Order is important here - the socket notifiers must go away

    // before the socket does, otherwise libc or the kernel will

    // become unhappy.

    if (rsn) {

        qDeleteInEventHandler(rsn);

        rsn = 0;

    }

    if (wsn) {

        qDeleteInEventHandler(wsn);

        wsn = 0;

    }

    if ( socket )

	socket->close();

}

void Q3SocketPrivate::close()

{

    closeSocket();

    wsize = 0;

    rba.clear(); wba.clear();

    windex = 0;

}

void Q3SocketPrivate::connectionClosed()

{

    // We keep the open state in case there's unread incoming data

    state = Q3Socket::Idle;

    closeSocket();

    wba.clear();

    windex = wsize = 0;

}

void Q3SocketPrivate::setSocketDevice( Q3Socket *q, Q3SocketDevice *device )

{

    delete socket;

    delete rsn;

    delete wsn;

    if ( device ) {

	socket = device;

    } else {

	socket = new Q3SocketDevice( Q3SocketDevice::Stream,

				    ( addr.isIPv4Address() ?

				      Q3SocketDevice::IPv4 :

				      Q3SocketDevice::IPv6 ), 0 );

	socket->setBlocking( false );

	socket->setAddressReusable( true );

    }

    rsn = new QSocketNotifier( socket->socket(),

			       QSocketNotifier::Read, q, "read" );

    wsn = new QSocketNotifier( socket->socket(),

			       QSocketNotifier::Write, q, "write" );

    QObject::connect( rsn, SIGNAL(activated(int)), q, SLOT(sn_read()) );

    rsn->setEnabled( false );

    QObject::connect( wsn, SIGNAL(activated(int)), q, SLOT(sn_write()) );

    wsn->setEnabled( false );

}

/*!

    \class Q3Socket

    \brief The Q3Socket class provides a buffered TCP connection.

    \compat

    It provides a totally non-blocking QIODevice, and modifies and

    extends the API of QIODevice with socket-specific code.

    The functions you're likely to call most are connectToHost(),

    bytesAvailable(), canReadLine() and the ones it inherits from

    QIODevice.

    connectToHost() is the most-used function. As its name implies,

    it opens a connection to a named host.

    Most network protocols are either packet-oriented or

    line-oriented. canReadLine() indicates whether a connection

    contains an entire unread line or not, and bytesAvailable()

    returns the number of bytes available for reading.

    The signals error(), connected(), readyRead() and

    connectionClosed() inform you of the progress of the connection.

    There are also some less commonly used signals. hostFound() is

    emitted when connectToHost() has finished its DNS lookup and is

    starting its TCP connection. delayedCloseFinished() is emitted

    when close() succeeds. bytesWritten() is emitted when Q3Socket

    moves data from its "to be written" queue into the TCP

    implementation.

    There are several access functions for the socket: state() returns

    whether the object is idle, is doing a DNS lookup, is connecting,

    has an operational connection, etc. address() and port() return

    the IP address and port used for the connection. The peerAddress()

    and peerPort() functions return the IP address and port used by

    the peer, and peerName() returns the name of the peer (normally

    the name that was passed to connectToHost()). socketDevice()

    returns a pointer to the Q3SocketDevice used for this socket.

    Q3Socket inherits QIODevice, and reimplements some functions. In

    general, you can treat it as a QIODevice for writing, and mostly

    also for reading. The match isn't perfect, since the QIODevice

    API is designed for devices that are controlled by the same

    machine, and an asynchronous peer-to-peer network connection isn't

    quite like that. For example, there is nothing that matches

    QIODevice::size() exactly. The documentation for open(), close(),

    flush(), size(), at(), atEnd(), readBlock(), writeBlock(),

    getch(), putch(), ungetch() and readLine() describes the

    differences in detail.

    \warning Q3Socket is not suitable for use in threads. If you need

    to uses sockets in threads use the lower-level Q3SocketDevice class.

    \sa Q3SocketDevice, QHostAddress, QSocketNotifier

*/

/*!

    Creates a Q3Socket object in Q3Socket::Idle state.

    The \a parent and \a name arguments are passed on to the QObject

    constructor.

*/

Q3Socket::Q3Socket( QObject *parent, const char *name )

    : QIODevice( parent )

{

    setObjectName(QLatin1String(name));

    d = new Q3SocketPrivate;

    setSocketDevice( 0 );

    resetStatus();

}

/*!

    Destroys the socket. Closes the connection if necessary.

    \sa close()

*/

Q3Socket::~Q3Socket()

{

#if defined(Q3SOCKET_DEBUG)

    qDebug( "Q3Socket (%s): Destroy", name() );

#endif

    if ( state() != Idle )

	close();

    Q_ASSERT( d != 0 );

    delete d;

}

/*!

    Returns a pointer to the internal socket device.

    There is normally no need to manipulate the socket device directly

    since this class does the necessary setup for most applications.

*/

Q3SocketDevice *Q3Socket::socketDevice()

{

    return d->socket;

}

/*!

    Sets the internal socket device to \a device. Passing a \a device

    of 0 will cause the internal socket device to be used. Any

    existing connection will be disconnected before using the new \a

    device.

    The new device should not be connected before being associated

    with a Q3Socket; after setting the socket call connectToHost() to

    make the connection.

    This function is useful if you need to subclass Q3SocketDevice and

    want to use the Q3Socket API, for example, to implement Unix domain

    sockets.

*/

void Q3Socket::setSocketDevice( Q3SocketDevice *device )

{

    if ( state() != Idle )

	close();

    d->setSocketDevice( this, device );

}

/*!

    \enum Q3Socket::State

    This enum defines the connection states:

    \value Idle if there is no connection

    \value HostLookup during a DNS lookup

    \value Connecting during TCP connection establishment

    \value Connected when there is an operational connection

    \value Closing if the socket is closing down, but is not yet closed.

    \omitvalue Connection

*/

/*!

    Returns the current state of the socket connection.

    \sa Q3Socket::State

*/

Q3Socket::State Q3Socket::state() const

{

    return d->state;

}

#ifndef QT_NO_DNS

/*!

    Attempts to make a connection to \a host on the specified \a port

    and return immediately.

    Any connection or pending connection is closed immediately, and

    Q3Socket goes into the \c HostLookup state. When the lookup

    succeeds, it emits hostFound(), starts a TCP connection and goes

    into the \c Connecting state. Finally, when the connection

    succeeds, it emits connected() and goes into the \c Connected

    state. If there is an error at any point, it emits error().

    \a host may be an IP address in string form, or it may be a DNS

    name. Q3Socket will do a normal DNS lookup if required. Note that

    \a port is in native byte order, unlike some other libraries.

    \sa state()

*/

void Q3Socket::connectToHost( const QString &host, Q_UINT16 port )

{

#if defined(Q3SOCKET_DEBUG)

    qDebug( "Q3Socket (%s)::connectToHost: host %s, port %d",

	    name(), host.ascii(), port );

#endif

    setSocketIntern( -1 );

    d->state = HostLookup;

    d->host = host;

    d->port = port;

    d->dns4 = new Q3Dns( host, Q3Dns::A );

    d->dns6 = new Q3Dns( host, Q3Dns::Aaaa );

    // try if the address is already available (for faster connecting...)

    tryConnecting();

    if ( d->state == HostLookup ) {

	connect( d->dns4, SIGNAL(resultsReady()),

		 this, SLOT(tryConnecting()) );

	connect( d->dns6, SIGNAL(resultsReady()),

		 this, SLOT(tryConnecting()) );

    }

}

#endif

/*!

    This private slots continues the connection process where

    connectToHost() leaves off.

*/

void Q3Socket::tryConnecting()

{

#if defined(Q3SOCKET_DEBUG)

    qDebug( "Q3Socket (%s)::tryConnecting()", name() );

#endif

    // ### this ifdef isn't correct - addresses() also does /etc/hosts and

    // numeric-address-as-string handling.

#ifndef QT_NO_DNS

    if ( d->dns4 ) {

	d->l4 = d->dns4->addresses();

	if ( !d->l4.isEmpty() || !d->dns4->isWorking() ) {

#if defined(Q3SOCKET_DEBUG)

	    qDebug( "Q3Socket (%s)::tryConnecting: host %s, port %d: "

		    "%d IPv4 addresses",

		    name(), d->host.ascii(), d->port, d->l4.count() );

#endif

	    delete d->dns4;

	    d->dns4 = 0;

	}

    }

    if ( d->dns6 ) {

	d->l6 = d->dns6->addresses();

	if ( !d->l6.isEmpty() || !d->dns6->isWorking() ) {

#if defined(Q3SOCKET_DEBUG)

	    qDebug( "Q3Socket (%s)::tryConnecting: host %s, port %d: "

		    "%d IPv6 addresses",

		    name(), d->host.ascii(), d->port, d->l6.count() );

#endif

	    delete d->dns6;

	    d->dns6 = 0;

	}

    }

    if ( d->state == HostLookup ) {

	if ( d->l4.isEmpty() && d->l6.isEmpty() &&

	     !d->dns4 && !d->dns6 ) {

	    // no results and we're not still looking: give up

	    d->state = Idle;

	    emit error( ErrHostNotFound );

	    return;

	}

	if ( d->l4.isEmpty() && d->l6.isEmpty() ) {

	    // no results (yet): try again later

	    return;

	}

	// we've found something. press on with that. if we later find

	// more, fine.

	emit hostFound();

	d->state = Connecting;

    }

    if ( d->state == Connecting ) {

	d->addresses += d->l4;

	d->addresses += d->l6;

	d->l4.clear();

	d->l6.clear();

	// try one address at a time, falling back to the next one if

	// there is a connection failure. (should also support a timeout,

	// or do multiple TCP-level connects at a time, with staggered

	// starts to avoid bandwidth waste and cause fewer

	// "connect-and-abort" errors. but that later.)

	bool stuck = true;

	while( stuck ) {

	    stuck = false;

	    if ( d->socket &&

		 d->socket->connect( d->addr, d->port ) == false ) {

		if ( d->socket->error() == Q3SocketDevice::NoError ) {

		    if ( d->wsn )

			d->wsn->setEnabled( true );

		    return; // not serious, try again later

		}

#if defined(Q3SOCKET_DEBUG)

		qDebug( "Q3Socket (%s)::tryConnecting: "

			"Gave up on IP address %s",

			name(), d->socket->peerAddress().toString().ascii() );

#endif

		delete d->wsn;

		d->wsn = 0;

		delete d->rsn;

		d->rsn = 0;

		delete d->socket;

		d->socket = 0;

                if(d->addresses.isEmpty()) {