1 /****************************************************************************

     2 **

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

     4 ** All rights reserved.

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

     6 **

     7 ** This file is part of the Qt3Support module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "q3socket.h"

    43 #ifndef QT_NO_NETWORK

    44 #include "q3ptrlist.h"

    45 #include "qtimer.h"

    46 #include "q3socketdevice.h"

    47 #include "q3dns.h"

    48 #include "private/q3membuf_p.h"

    49 

    50 #include <string.h>

    51 #ifndef NO_ERRNO_H

    52 #if defined(Q_OS_WINCE)

    53 #include "qfunctions_wince.h"

    54 #else

    55 #include <errno.h>

    56 #endif

    57 #endif

    58 

    59 QT_BEGIN_NAMESPACE

    60 

    61 //#define Q3SOCKET_DEBUG

    62 

    63 /*

    64   Perhaps this private functionality needs to be refactored.

    65 

    66   Comment from Robert D Gatlin (Intel):

    67 

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

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

    70     the line of:

    71 

    72       class QByteBuffer : public QIODevice { ... }

    73 

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

    75     buffers.

    76 

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

    78 

    79 	buffer.open( IO_WriteOnly | IO_Append );

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

    81 	buffer.close();

    82 

    83 	QByteArray b;

    84 	b.resize( buffer.size() );

    85 	buffer.open( IO_ReadOnly );

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

    87 	buffer.close();

    88 

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

    90 

    91 	buffer.open( IO_WriteOnly | IO_Append );

    92 	QDataStream is( &buffer );

    93 	is << 100;

    94 	buffer.close();

    95 

    96 	buffer.open( IO_ReadOnly );

    97 	QDataStream os( &buffer );

    98 	Q_UINT32 x;

    99 	os >> x;

   100 	buffer.close();

   101 

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

   103     incrementally (as in Q3Socket and filter case above).

   104 

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

   106     the buffer in cases like:

   107 

   108 	QBuffer buf;

   109 	buf.open( IO_ReadOnly );

   110 	QDataStream ds( &buf );

   111 	Q_INT32 x;

   112 	ds >> x;

   113 	buf.close();

   114 

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

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

   117     does not appear well suited for this kind of operation.

   118 */

   119 

   120 // Private class for Q3Socket

   121 

   122 class Q3SocketPrivate {

   123 public:

   124     Q3SocketPrivate();

   125    ~Q3SocketPrivate();

   126     void closeSocket();

   127     void close();

   128     void connectionClosed();

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

   130 

   131     Q3Socket::State	state;			// connection state

   132     QString		host;			// host name

   133     Q_UINT16		port;			// host port

   134     Q3SocketDevice      *socket;			// connection socket

   135     QSocketNotifier     *rsn, *wsn;		// socket notifiers

   136     Q3Membuf		rba;			// read buffer

   137     Q_ULONG		readBufferSize;		// limit for the read buffer size

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

   139     QHostAddress	addr;			// connection address

   140     Q3ValueList<QHostAddress> addresses;		// alternatives looked up

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

   142     QIODevice::Offset	windex;			// write index

   143 #ifndef QT_NO_DNS

   144     Q3Dns	       *dns4;

   145     Q3Dns	       *dns6;

   146 #endif

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

   148     Q3ValueList<QHostAddress> l4;

   149     Q3ValueList<QHostAddress> l6;

   150 };

   151 

   152 Q3PtrList<Q3Socket> Q3SocketPrivate::sn_read_alreadyCalled;

   153 

   154 Q3SocketPrivate::Q3SocketPrivate()

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

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

   157 {

   158 #ifndef QT_NO_DNS

   159     dns4 = 0;

   160     dns6 = 0;

   161 #endif

   162     wba.setAutoDelete( true );

   163 }

   164 

   165 Q3SocketPrivate::~Q3SocketPrivate()

   166 {

   167     close();

   168     delete socket;

   169 #ifndef QT_NO_DNS

   170     delete dns4;

   171     delete dns6;

   172 #endif

   173 }

   174 

   175 extern void qDeleteInEventHandler(QObject *o);

   176 void Q3SocketPrivate::closeSocket()

   177 {

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

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

   180     // become unhappy.

   181     if (rsn) {

   182         qDeleteInEventHandler(rsn);

   183         rsn = 0;

   184     }

   185     if (wsn) {

   186         qDeleteInEventHandler(wsn);

   187         wsn = 0;

   188     }

   189     if ( socket )

   190 	socket->close();

   191 }

   192 

   193 void Q3SocketPrivate::close()

   194 {

   195     closeSocket();

   196     wsize = 0;

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

   198     windex = 0;

   199 }

   200 

   201 void Q3SocketPrivate::connectionClosed()

   202 {

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

   204     state = Q3Socket::Idle;

   205     closeSocket();

   206     wba.clear();

   207     windex = wsize = 0;

   208 }

   209 

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

   211 {

   212     delete socket;

   213     delete rsn;

   214     delete wsn;

   215 

   216     if ( device ) {

   217 	socket = device;

   218     } else {

   219 	socket = new Q3SocketDevice( Q3SocketDevice::Stream,

   220 				    ( addr.isIPv4Address() ?

   221 				      Q3SocketDevice::IPv4 :

   222 				      Q3SocketDevice::IPv6 ), 0 );

   223 	socket->setBlocking( false );

   224 	socket->setAddressReusable( true );

   225     }

   226 

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

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

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

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

   231 

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

   233     rsn->setEnabled( false );

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

   235     wsn->setEnabled( false );

   236 }

   237 

   238 /*!

   239     \class Q3Socket

   240     \brief The Q3Socket class provides a buffered TCP connection.

   241 

   242     \compat

   243 

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

   245     extends the API of QIODevice with socket-specific code.

   246 

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

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

   249     QIODevice.

   250 

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

   252     it opens a connection to a named host.

   253 

   254     Most network protocols are either packet-oriented or

   255     line-oriented. canReadLine() indicates whether a connection

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

   257     returns the number of bytes available for reading.

   258 

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

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

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

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

   263     starting its TCP connection. delayedCloseFinished() is emitted

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

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

   266     implementation.

   267 

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

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

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

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

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

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

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

   275     returns a pointer to the Q3SocketDevice used for this socket.

   276 

   277     Q3Socket inherits QIODevice, and reimplements some functions. In

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

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

   280     API is designed for devices that are controlled by the same

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

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

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

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

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

   286     differences in detail.

   287 

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

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

   290 

   291     \sa Q3SocketDevice, QHostAddress, QSocketNotifier

   292 */

   293 

   294 

   295 /*!

   296     Creates a Q3Socket object in Q3Socket::Idle state.

   297 

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

   299     constructor.

   300 */

   301 

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

   303     : QIODevice( parent )

   304 {

   305     setObjectName(QLatin1String(name));

   306     d = new Q3SocketPrivate;

   307     setSocketDevice( 0 );

   308     resetStatus();

   309 }

   310 

   311 

   312 /*!

   313     Destroys the socket. Closes the connection if necessary.

   314 

   315     \sa close()

   316 */

   317 

   318 Q3Socket::~Q3Socket()

   319 {

   320 #if defined(Q3SOCKET_DEBUG)

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

   322 #endif

   323     if ( state() != Idle )

   324 	close();

   325     Q_ASSERT( d != 0 );

   326     delete d;

   327 }

   328 

   329 

   330 /*!

   331     Returns a pointer to the internal socket device.

   332 

   333     There is normally no need to manipulate the socket device directly

   334     since this class does the necessary setup for most applications.

   335 */

   336 

   337 Q3SocketDevice *Q3Socket::socketDevice()

   338 {

   339     return d->socket;

   340 }

   341 

   342 /*!

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

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

   345     existing connection will be disconnected before using the new \a

   346     device.

   347 

   348     The new device should not be connected before being associated

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

   350     make the connection.

   351 

   352     This function is useful if you need to subclass Q3SocketDevice and

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

   354     sockets.

   355 */

   356 

   357 void Q3Socket::setSocketDevice( Q3SocketDevice *device )

   358 {

   359     if ( state() != Idle )

   360 	close();

   361     d->setSocketDevice( this, device );

   362 }

   363 

   364 /*!

   365     \enum Q3Socket::State

   366 

   367     This enum defines the connection states:

   368 

   369     \value Idle if there is no connection

   370     \value HostLookup during a DNS lookup

   371     \value Connecting during TCP connection establishment

   372     \value Connected when there is an operational connection

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

   374     \omitvalue Connection

   375 */

   376 

   377 /*!

   378     Returns the current state of the socket connection.

   379 

   380     \sa Q3Socket::State

   381 */

   382 

   383 Q3Socket::State Q3Socket::state() const

   384 {

   385     return d->state;

   386 }

   387 

   388 

   389 #ifndef QT_NO_DNS

   390 

   391 /*!

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

   393     and return immediately.

   394 

   395     Any connection or pending connection is closed immediately, and

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

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

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

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

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

   401 

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

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

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

   405 

   406     \sa state()

   407 */

   408 

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

   410 {

   411 #if defined(Q3SOCKET_DEBUG)

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

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

   414 #endif

   415     setSocketIntern( -1 );

   416     d->state = HostLookup;

   417     d->host = host;

   418     d->port = port;

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

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

   421 

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

   423     tryConnecting();

   424     if ( d->state == HostLookup ) {

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

   426 		 this, SLOT(tryConnecting()) );

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

   428 		 this, SLOT(tryConnecting()) );

   429     }

   430 }

   431 

   432 #endif

   433 

   434 

   435 /*!

   436     This private slots continues the connection process where

   437     connectToHost() leaves off.

   438 */

   439 

   440 void Q3Socket::tryConnecting()

   441 {

   442 #if defined(Q3SOCKET_DEBUG)

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

   444 #endif

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

   446     // numeric-address-as-string handling.

   447 #ifndef QT_NO_DNS

   448 

   449     if ( d->dns4 ) {

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

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

   452 #if defined(Q3SOCKET_DEBUG)

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

   454 		    "%d IPv4 addresses",

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

   456 #endif

   457 	    delete d->dns4;

   458 	    d->dns4 = 0;

   459 	}

   460     }

   461 

   462     if ( d->dns6 ) {

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

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

   465 #if defined(Q3SOCKET_DEBUG)

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

   467 		    "%d IPv6 addresses",

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

   469 #endif

   470 	    delete d->dns6;

   471 	    d->dns6 = 0;

   472 	}

   473     }

   474 

   475     if ( d->state == HostLookup ) {

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

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

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

   479 	    d->state = Idle;

   480 	    emit error( ErrHostNotFound );

   481 	    return;

   482 	}

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

   484 	    // no results (yet): try again later

   485 	    return;

   486 	}

   487 

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

   489 	// more, fine.

   490 	emit hostFound();

   491 	d->state = Connecting;

   492     }

   493 

   494     if ( d->state == Connecting ) {

   495 	d->addresses += d->l4;

   496 	d->addresses += d->l6;

   497 	d->l4.clear();

   498 	d->l6.clear();

   499 

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

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

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

   503 	// starts to avoid bandwidth waste and cause fewer

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

   505 	bool stuck = true;

   506 	while( stuck ) {

   507 	    stuck = false;

   508 	    if ( d->socket &&

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

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

   511 		    if ( d->wsn )

   512 			d->wsn->setEnabled( true );

   513 		    return; // not serious, try again later

   514 		}

   515 

   516 #if defined(Q3SOCKET_DEBUG)

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

   518 			"Gave up on IP address %s",

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

   520 #endif

   521 		delete d->wsn;

   522 		d->wsn = 0;

   523 		delete d->rsn;

   524 		d->rsn = 0;

   525 		delete d->socket;

   526 		d->socket = 0;

   527 

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

   529                     emit error( ErrConnectionRefused );

   530                     return;

   531                 }

   532             }

   533 	    // if the host has more addresses, try another some.

   534 	    if ( d->socket == 0 && !d->addresses.isEmpty() ) {

   535 		d->addr = *d->addresses.begin();

   536 		d->addresses.remove( d->addresses.begin() );

   537 		d->setSocketDevice( this, 0 );

   538 		stuck = true;

   539 #if defined(Q3SOCKET_DEBUG)

   540 		qDebug( "Q3Socket (%s)::tryConnecting: Trying IP address %s",

   541 			name(), d->addr.toString().ascii() );

   542 #endif

   543 	    }

   544 	};

   545 

   546 	// The socket write notifier will fire when the connection succeeds

   547 	if ( d->wsn )

   548 	    d->wsn->setEnabled( true );

   549     }

   550 #endif

   551 }

   552 

   553 /*!

   554     \enum Q3Socket::Error

   555 

   556     This enum specifies the possible errors:

   557     \value ErrConnectionRefused if the connection was refused

   558     \value ErrHostNotFound if the host was not found

   559     \value ErrSocketRead if a read from the socket failed

   560 */

   561 

   562 /*!

   563     \fn void Q3Socket::error(int error)

   564 

   565     This signal is emitted after an error occurred. The \a error parameter is

   566     the \l Error value.

   567 */

   568 

   569 /*!

   570     \fn void Q3Socket::hostFound()

   571 

   572     This signal is emitted after connectToHost() has been called and

   573     the host lookup has succeeded.

   574 

   575     \sa connected()

   576 */

   577 

   578 

   579 /*!

   580     \fn void Q3Socket::connected()

   581 

   582     This signal is emitted after connectToHost() has been called and a

   583     connection has been successfully established.

   584 

   585     \sa connectToHost(), connectionClosed()

   586 */

   587 

   588 

   589 /*!

   590     \fn void Q3Socket::connectionClosed()

   591 

   592     This signal is emitted when the other end has closed the

   593     connection. The read buffers may contain buffered input data which

   594     you can read after the connection was closed.

   595 

   596     \sa connectToHost(), close()

   597 */

   598 

   599 

   600 /*!

   601     \fn void Q3Socket::delayedCloseFinished()

   602 

   603     This signal is emitted when a delayed close is finished.

   604 

   605     If you call close() and there is buffered output data to be

   606     written, Q3Socket goes into the Q3Socket::Closing state and

   607     returns immediately. It will then keep writing to the socket until

   608     all the data has been written. Then, the delayedCloseFinished()

   609     signal is emitted.

   610 

   611     \sa close()

   612 */

   613 

   614 

   615 /*!

   616     \fn void Q3Socket::readyRead()

   617 

   618     This signal is emitted every time there is new incoming data.

   619 

   620     Bear in mind that new incoming data is only reported once; if you do not

   621     read all the data, this class buffers the data and you can read it later,

   622     but no signal is emitted unless new data arrives. A good practice is to

   623     read all data in the slot connected to this signal unless you are sure that

   624     you need to receive more data to be able to process it.

   625 

   626     \sa readBlock(), readLine(), bytesAvailable()

   627 */

   628 

   629 

   630 /*!

   631     \fn void Q3Socket::bytesWritten( int nbytes )

   632 

   633     This signal is emitted when data has been written to the network.

   634     The \a nbytes parameter specifies how many bytes were written.

   635 

   636     The bytesToWrite() function is often used in the same context; it

   637     indicates how many buffered bytes there are left to write.

   638 

   639     \sa writeBlock(), bytesToWrite()

   640 */

   641 

   642 

   643 /*!

   644     Opens the socket using the specified QIODevice file mode \a m.

   645     This function is called automatically when needed and you should

   646     not call it yourself.

   647 

   648     \sa close()

   649 */

   650 

   651 bool Q3Socket::open( OpenMode m )

   652 {

   653     if ( isOpen() ) {

   654 #if defined(QT_CHECK_STATE)

   655 	qWarning( "Q3Socket::open: Already open" );

   656 #endif

   657 	return false;

   658     }

   659     QIODevice::setOpenMode( m & ReadWrite );

   660     return true;

   661 }

   662 

   663 /*!

   664     \fn bool Q3Socket::open(int m)

   665     \overload

   666 */

   667 

   668 /*!

   669     Closes the socket.

   670 

   671     The read buffer is cleared.

   672 

   673     If the output buffer is empty, the state is set to \c

   674     Q3Socket::Idle and the connection is terminated immediately. If the

   675     output buffer still contains data to be written, Q3Socket goes into

   676     the Q3Socket::Closing state and the rest of the data will be

   677     written. When all of the outgoing data have been written, the

   678     state is set to Q3Socket::Idle and the connection is terminated.

   679     At this point, the delayedCloseFinished() signal is emitted.

   680 

   681     If you don't want that the data of the output buffer is written, call

   682     clearPendingData() before you call close().

   683 

   684     \sa state(), bytesToWrite() clearPendingData()

   685 */

   686 

   687 void Q3Socket::close()

   688 {

   689     if ( !isOpen() || d->state == Idle )	// already closed

   690 	return;

   691     if ( d->state == Closing )

   692 	return;

   693     if ( !d->rsn || !d->wsn )

   694 	return;

   695 #if defined(Q3SOCKET_DEBUG)

   696     qDebug( "Q3Socket (%s): close socket", name() );

   697 #endif

   698     if ( d->socket && d->wsize ) {		// there's data to be written

   699 	d->state = Closing;

   700 	if ( d->rsn )

   701 	    d->rsn->setEnabled( false );

   702 	if ( d->wsn )

   703 	    d->wsn->setEnabled( true );

   704 	d->rba.clear();				// clear incoming data

   705 	return;

   706     }

   707     resetStatus();

   708     setOpenMode(NotOpen);

   709     d->close();

   710     d->state = Idle;

   711 }

   712 

   713 

   714 /*!

   715     This function consumes \a nbytes bytes of data from the write

   716     buffer.

   717 */

   718 

   719 bool Q3Socket::consumeWriteBuf( Q_ULONG nbytes )

   720 {

   721     if ( nbytes <= 0 || (qint64)nbytes > d->wsize )

   722 	return false;

   723 #if defined(Q3SOCKET_DEBUG)

   724     qDebug( "Q3Socket (%s): skipWriteBuf %d bytes", name(), (int)nbytes );

   725 #endif

   726     d->wsize -= nbytes;

   727     for ( ;; ) {

   728 	QByteArray *a = d->wba.first();

   729 	if ( (qint64)(d->windex + nbytes) >= a->size() ) {

   730 	    nbytes -= a->size() - d->windex;

   731 	    d->wba.remove();

   732 	    d->windex = 0;

   733 	    if ( nbytes == 0 )

   734 		break;

   735 	} else {

   736 	    d->windex += nbytes;

   737 	    break;

   738 	}

   739     }

   740     return true;

   741 }

   742 

   743 

   744 

   745 /*!

   746     Implementation of the abstract virtual QIODevice::flush() function.

   747     This function always returns true.

   748 */

   749 

   750 bool Q3Socket::flush()

   751 {

   752     if ( !d->socket )

   753         return true;

   754     bool osBufferFull = false;

   755     int consumed = 0;

   756     while ( !osBufferFull && d->state >= Connecting && d->wsize > 0 ) {

   757 #if defined(Q3SOCKET_DEBUG)

   758 	qDebug( "Q3Socket (%s): flush: Write data to the socket", name() );

   759 #endif

   760 	QByteArray *a = d->wba.first();

   761 	int nwritten;

   762 	int i = 0;

   763 	if ( (int)a->size() - d->windex < 1460 ) {

   764 	    // Concatenate many smaller blocks.  the first may be

   765 	    // partial, but each subsequent block is copied entirely

   766 	    // or not at all.  the sizes here are picked so that we

   767 	    // generally won't trigger nagle's algorithm in the tcp

   768 	    // implementation: we concatenate if we'd otherwise send

   769 	    // less than PMTU bytes (we assume PMTU is 1460 bytes),

   770 	    // and concatenate up to the largest payload TCP/IP can

   771 	    // carry.  with these precautions, nagle's algorithm

   772 	    // should apply only when really appropriate.

   773 	    QByteArray out( 65536 );

   774 	    int j = d->windex;

   775 	    int s = a->size() - j;

   776 	    while ( a && i+s < (int)out.size() ) {

   777 		memcpy( out.data()+i, a->data()+j, s );

   778 		j = 0;

   779 		i += s;

   780 		a = d->wba.next();

   781 		s = a ? a->size() : 0;

   782 	    }

   783 	    nwritten = d->socket->write( out.data(), i );

   784 	    if ( d->wsn )

   785 		d->wsn->setEnabled( false ); // the QSocketNotifier documentation says so

   786 	} else {

   787 	    // Big block, write it immediately

   788 	    i = a->size() - d->windex;

   789 	    nwritten = d->socket->write( a->data() + d->windex, i );

   790 	    if ( d->wsn )

   791 		d->wsn->setEnabled( false ); // the QSocketNotifier documentation says so

   792 	}

   793 	if ( nwritten > 0 ) {

   794 	    if ( consumeWriteBuf( nwritten ) )

   795 		consumed += nwritten;

   796 	}

   797 	if ( nwritten < i )

   798 	    osBufferFull = true;

   799     }

   800     if ( consumed > 0 ) {

   801 #if defined(Q3SOCKET_DEBUG)

   802 	qDebug( "Q3Socket (%s): flush: wrote %d bytes, %d left",

   803 		name(), consumed, (int)d->wsize );

   804 #endif

   805 	emit bytesWritten( consumed );

   806     }

   807     if ( d->state == Closing && d->wsize == 0 ) {

   808 #if defined(Q3SOCKET_DEBUG)

   809 	qDebug( "Q3Socket (%s): flush: Delayed close done. Terminating.",

   810 		name() );

   811 #endif

   812 	resetStatus();

   813 	setOpenMode(NotOpen);

   814 	d->close();

   815 	d->state = Idle;

   816 	emit delayedCloseFinished();

   817 	return true;

   818     }

   819     if ( !d->socket->isOpen() ) {

   820 	d->connectionClosed();

   821 	emit connectionClosed();

   822 	return true;

   823     }

   824     if ( d->wsn )

   825 	d->wsn->setEnabled( d->wsize > 0 ); // write if there's data

   826     return true;

   827 }

   828 

   829 

   830 /*!

   831     Returns the number of incoming bytes that can be read right now

   832     (like bytesAvailable()).

   833 */

   834 

   835 QIODevice::Offset Q3Socket::size() const

   836 {

   837     return (Offset)bytesAvailable();

   838 }

   839 

   840 

   841 /*!

   842     Returns the current read index. Since Q3Socket is a sequential

   843     device, the current read index is always zero.

   844 */

   845 

   846 QIODevice::Offset Q3Socket::at() const

   847 {

   848     return 0;

   849 }

   850 

   851 

   852 /*!

   853     \overload

   854 

   855     Moves the read index forward to \a index and returns true if the

   856     operation was successful; otherwise returns false. Moving the

   857     index forward means skipping incoming data.

   858 */

   859 

   860 bool Q3Socket::at( Offset index )

   861 {

   862     if ( index > d->rba.size() )

   863 	return false;

   864     d->rba.consumeBytes( (Q_ULONG)index, 0 );			// throw away data 0..index-1

   865     // After we read data from our internal buffer, if we use the

   866     // setReadBufferSize() to limit our buffer, we might now be able to

   867     // read more data in our buffer. So enable the read socket notifier,

   868     // but do this only if we are not in a slot connected to the

   869     // readyRead() signal since this might cause a bad recursive behavior.

   870     // We can test for this condition by looking at the

   871     // sn_read_alreadyCalled flag.

   872     if ( d->rsn && Q3SocketPrivate::sn_read_alreadyCalled.findRef(this) == -1 )

   873 	d->rsn->setEnabled( true );

   874     return true;

   875 }

   876 

   877 

   878 /*!

   879     Returns true if there is no more data to read; otherwise returns false.

   880 */

   881 

   882 bool Q3Socket::atEnd() const

   883 {

   884     if ( d->socket == 0 )

   885 	return true;

   886     Q3Socket * that = (Q3Socket *)this;

   887     if ( that->d->socket->bytesAvailable() )	// a little slow, perhaps...

   888 	that->sn_read();

   889     return that->d->rba.size() == 0;

   890 }

   891 

   892 

   893 /*!

   894     Returns the number of incoming bytes that can be read, i.e. the

   895     size of the input buffer. Equivalent to size().

   896 

   897     \sa bytesToWrite()

   898 */

   899 

   900 qint64 Q3Socket::bytesAvailable() const

   901 {

   902     if ( d->socket == 0 )

   903 	return 0;

   904     Q3Socket * that = (Q3Socket *)this;

   905     if ( that->d->socket->bytesAvailable() ) // a little slow, perhaps...

   906 	(void)that->sn_read();

   907     return that->d->rba.size() + QIODevice::bytesAvailable();

   908 }

   909 

   910 

   911 /*!

   912     Wait up to \a msecs milliseconds for more data to be available.

   913 

   914     If \a msecs is -1 the call will block indefinitely.

   915 

   916     Returns the number of bytes available.

   917 

   918     If \a timeout is non-null and no error occurred (i.e. it does not

   919     return -1): this function sets *\a timeout to true, if the reason

   920     for returning was that the timeout was reached; otherwise it sets

   921     *\a timeout to false. This is useful to find out if the peer

   922     closed the connection.

   923 

   924     \warning This is a blocking call and should be avoided in event

   925     driven applications.

   926 

   927     \sa bytesAvailable()

   928 */

   929 

   930 Q_ULONG Q3Socket::waitForMore( int msecs, bool *timeout ) const

   931 {

   932     if ( d->socket == 0 )

   933 	return 0;

   934     Q3Socket * that = (Q3Socket *)this;

   935     if ( that->d->socket->waitForMore( msecs, timeout ) > 0 )

   936 	(void)that->sn_read( true );

   937     return that->d->rba.size();

   938 }

   939 

   940 /*! \overload

   941 */

   942 

   943 Q_ULONG Q3Socket::waitForMore( int msecs ) const

   944 {

   945     return waitForMore( msecs, 0 );

   946 }

   947 

   948 /*!

   949     Returns the number of bytes that are waiting to be written, i.e.

   950     the size of the output buffer.

   951 

   952     \sa bytesAvailable() clearPendingData()

   953 */

   954 

   955 qint64 Q3Socket::bytesToWrite() const

   956 {

   957     return d->wsize;

   958 }

   959 

   960 /*!

   961     Deletes the data that is waiting to be written. This is useful if you want

   962     to close the socket without waiting for all the data to be written.

   963 

   964     \sa bytesToWrite() close() delayedCloseFinished()

   965 */

   966 

   967 void Q3Socket::clearPendingData()

   968 {

   969     d->wba.clear();

   970     d->windex = d->wsize = 0;

   971 }

   972 

   973 /*!

   974     Reads \a maxlen bytes from the socket into \a data and returns the

   975     number of bytes read. Returns -1 if an error occurred.

   976 */

   977 

   978 qint64 Q3Socket::readData( char *data, qint64 maxlen )

   979 {

   980     if ( data == 0 && maxlen != 0 ) {

   981 #if defined(QT_CHECK_NULL)

   982 	qWarning( "Q3Socket::readBlock: Null pointer error" );

   983 #endif

   984 	return -1;

   985     }

   986     if ( !isOpen() ) {

   987 #if defined(QT_CHECK_STATE)

   988 	qWarning( "Q3Socket::readBlock: Socket is not open" );

   989 #endif

   990 	return -1;

   991     }

   992     if ( maxlen >= d->rba.size() )

   993 	maxlen = d->rba.size();

   994 #if defined(Q3SOCKET_DEBUG)

   995     qDebug( "Q3Socket (%s): readBlock %d bytes", name(), (int)maxlen );

   996 #endif

   997     d->rba.consumeBytes( maxlen, data );

   998     // After we read data from our internal buffer, if we use the

   999     // setReadBufferSize() to limit our buffer, we might now be able to

  1000     // read more data in our buffer. So enable the read socket notifier,

  1001     // but do this only if we are not in a slot connected to the

  1002     // readyRead() signal since this might cause a bad recursive behavior.

  1003     // We can test for this condition by looking at the

  1004     // sn_read_alreadyCalled flag.

  1005     if ( d->rsn && Q3SocketPrivate::sn_read_alreadyCalled.findRef(this) == -1 )

  1006 	d->rsn->setEnabled( true );

  1007     return maxlen;

  1008 }

  1009 

  1010 

  1011 /*!

  1012     Writes \a len bytes to the socket from \a data and returns the

  1013     number of bytes written. Returns -1 if an error occurred.

  1014 */

  1015 

  1016 qint64 Q3Socket::writeData( const char *data, qint64 len )

  1017 {

  1018 #if defined(QT_CHECK_NULL)

  1019     if ( data == 0 && len != 0 ) {

  1020 	qWarning( "Q3Socket::writeBlock: Null pointer error" );

  1021     }

  1022 #endif

  1023 #if defined(QT_CHECK_STATE)

  1024     if ( !isOpen() ) {

  1025 	qWarning( "Q3Socket::writeBlock: Socket is not open" );

  1026 	return -1;

  1027     }

  1028 #endif

  1029 #if defined(QT_CHECK_STATE)

  1030     if ( d->state == Closing ) {

  1031 	qWarning( "Q3Socket::writeBlock: Cannot write, socket is closing" );

  1032     }

  1033 #endif

  1034     if ( len == 0 || d->state == Closing || d->state == Idle )

  1035 	return 0;

  1036     QByteArray *a = d->wba.last();

  1037 

  1038     // next bit is sensitive.  if we're writing really small chunks,

  1039     // try to buffer up since system calls are expensive, and nagle's

  1040     // algorithm is even more expensive.  but if anything even

  1041     // remotely large is being written, try to issue a write at once.

  1042 

  1043     bool writeNow = ( d->wsize + len >= 1400 || len > 512 );

  1044 

  1045     if ( a && a->size() + len < 128 ) {

  1046 	// small buffer, resize

  1047 	int i = a->size();

  1048 	a->resize( i+len );

  1049 	memcpy( a->data()+i, data, len );

  1050     } else {

  1051 	// append new buffer

  1052 	a = new QByteArray( len );

  1053 	memcpy( a->data(), data, len );

  1054 	d->wba.append( a );

  1055     }

  1056     d->wsize += len;

  1057     if ( writeNow )

  1058 	flush();

  1059     else if ( d->wsn )

  1060 	d->wsn->setEnabled( true );

  1061 #if defined(Q3SOCKET_DEBUG)

  1062     qDebug( "Q3Socket (%s): writeBlock %d bytes", name(), (int)len );

  1063 #endif

  1064     return len;

  1065 }

  1066 

  1067 

  1068 /*!

  1069     Reads a single byte/character from the internal read buffer.

  1070     Returns the byte/character read, or -1 if there is nothing to be

  1071     read.

  1072 

  1073     \sa bytesAvailable(), putch()

  1074 */

  1075 

  1076 int Q3Socket::getch()

  1077 {

  1078     if ( isOpen() && d->rba.size() > 0 ) {

  1079 	uchar c;

  1080 	d->rba.consumeBytes( 1, (char*)&c );

  1081 	// After we read data from our internal buffer, if we use the

  1082 	// setReadBufferSize() to limit our buffer, we might now be able to

  1083 	// read more data in our buffer. So enable the read socket notifier,

  1084 	// but do this only if we are not in a slot connected to the

  1085 	// readyRead() signal since this might cause a bad recursive behavior.

  1086 	// We can test for this condition by looking at the

  1087 	// sn_read_alreadyCalled flag.

  1088 	if ( d->rsn && Q3SocketPrivate::sn_read_alreadyCalled.findRef(this) == -1 )

  1089 	    d->rsn->setEnabled( true );

  1090 	return c;

  1091     }

  1092     return -1;

  1093 }

  1094 

  1095 

  1096 /*!

  1097     Writes the character \a ch to the output buffer.

  1098 

  1099     Returns \a ch, or -1 if an error occurred.

  1100 

  1101     \sa getch()

  1102 */

  1103 

  1104 int Q3Socket::putch( int ch )

  1105 {

  1106     char buf[2];

  1107     buf[0] = ch;

  1108     return writeBlock(buf, 1) == 1 ? ch : -1;

  1109 }

  1110 

  1111 

  1112 /*!

  1113     This implementation of the virtual function QIODevice::ungetch()

  1114     prepends the character \a ch to the read buffer so that the next

  1115     read returns this character as the first character of the output.

  1116 */

  1117 

  1118 int Q3Socket::ungetch( int ch )

  1119 {

  1120 #if defined(QT_CHECK_STATE)

  1121     if ( !isOpen() ) {

  1122 	qWarning( "Q3Socket::ungetch: Socket not open" );

  1123 	return -1;

  1124     }

  1125 #endif

  1126     return d->rba.ungetch( ch );

  1127 }

  1128 

  1129 

  1130 /*!

  1131     Returns true if it's possible to read an entire line of text from

  1132     this socket at this time; otherwise returns false.

  1133 

  1134     Note that if the peer closes the connection unexpectedly, this