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 QtNetwork 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 //#define QABSTRACTSOCKET_DEBUG

    43 

    44 /*!

    45     \class QAbstractSocket

    46 

    47     \brief The QAbstractSocket class provides the base functionality

    48     common to all socket types.

    49 

    50     \reentrant

    51     \ingroup network

    52     \inmodule QtNetwork

    53 

    54     QAbstractSocket is the base class for QTcpSocket and QUdpSocket

    55     and contains all common functionality of these two classes. If

    56     you need a socket, you have two options:

    57 

    58     \list

    59     \i  Instantiate QTcpSocket or QUdpSocket.

    60     \i  Create a native socket descriptor, instantiate

    61         QAbstractSocket, and call setSocketDescriptor() to wrap the

    62         native socket.

    63     \endlist

    64 

    65     TCP (Transmission Control Protocol) is a reliable,

    66     stream-oriented, connection-oriented transport protocol. UDP

    67     (User Datagram Protocol) is an unreliable, datagram-oriented,

    68     connectionless protocol. In practice, this means that TCP is

    69     better suited for continuous transmission of data, whereas the

    70     more lightweight UDP can be used when reliability isn't

    71     important.

    72 

    73     QAbstractSocket's API unifies most of the differences between the

    74     two protocols. For example, although UDP is connectionless,

    75     connectToHost() establishes a virtual connection for UDP sockets,

    76     enabling you to use QAbstractSocket in more or less the same way

    77     regardless of the underlying protocol. Internally,

    78     QAbstractSocket remembers the address and port passed to

    79     connectToHost(), and functions like read() and write() use these

    80     values.

    81 

    82     At any time, QAbstractSocket has a state (returned by

    83     state()). The initial state is UnconnectedState. After

    84     calling connectToHost(), the socket first enters

    85     HostLookupState. If the host is found, QAbstractSocket enters

    86     ConnectingState and emits the hostFound() signal. When the

    87     connection has been established, it enters ConnectedState and

    88     emits connected(). If an error occurs at any stage, error() is

    89     emitted. Whenever the state changes, stateChanged() is emitted.

    90     For convenience, isValid() returns true if the socket is ready for

    91     reading and writing, but note that the socket's state must be

    92     ConnectedState before reading and writing can occur.

    93 

    94     Read or write data by calling read() or write(), or use the

    95     convenience functions readLine() and readAll(). QAbstractSocket

    96     also inherits getChar(), putChar(), and ungetChar() from

    97     QIODevice, which work on single bytes. The bytesWritten() signal

    98     is emitted when data has been written to the socket (i.e., when

    99     the client has read the data). Note that Qt does not limit the

   100     write buffer size. You can monitor its size by listening to this

   101     signal.

   102 

   103     The readyRead() signal is emitted every time a new chunk of data

   104     has arrived. bytesAvailable() then returns the number of bytes

   105     that are available for reading. Typically, you would connect the

   106     readyRead() signal to a slot and read all available data there.

   107     If you don't read all the data at once, the remaining data will

   108     still be available later, and any new incoming data will be

   109     appended to QAbstractSocket's internal read buffer. To limit the

   110     size of the read buffer, call setReadBufferSize().

   111 

   112     To close the socket, call disconnectFromHost(). QAbstractSocket enters

   113     QAbstractSocket::ClosingState. After all pending data has been written to

   114     the socket, QAbstractSocket actually closes the socket, enters

   115     QAbstractSocket::ClosedState, and emits disconnected(). If you want to

   116     abort a connection immediately, discarding all pending data, call abort()

   117     instead. If the remote host closes the connection, QAbstractSocket will

   118     emit error(QAbstractSocket::RemoteHostClosedError), during which the socket

   119     state will still be ConnectedState, and then the disconnected() signal

   120     will be emitted.

   121 

   122     The port and address of the connected peer is fetched by calling

   123     peerPort() and peerAddress(). peerName() returns the host name of

   124     the peer, as passed to connectToHost(). localPort() and

   125     localAddress() return the port and address of the local socket.

   126 

   127     QAbstractSocket provides a set of functions that suspend the

   128     calling thread until certain signals are emitted. These functions

   129     can be used to implement blocking sockets:

   130 

   131     \list

   132     \o waitForConnected() blocks until a connection has been established.

   133 

   134     \o waitForReadyRead() blocks until new data is available for

   135     reading.

   136 

   137     \o waitForBytesWritten() blocks until one payload of data has been

   138     written to the socket.

   139 

   140     \o waitForDisconnected() blocks until the connection has closed.

   141     \endlist

   142 

   143     We show an example:

   144 

   145     \snippet doc/src/snippets/network/tcpwait.cpp 0

   146 

   147     If \l{QIODevice::}{waitForReadyRead()} returns false, the

   148     connection has been closed or an error has occurred.

   149 

   150     Programming with a blocking socket is radically different from

   151     programming with a non-blocking socket. A blocking socket doesn't

   152     require an event loop and typically leads to simpler code.

   153     However, in a GUI application, blocking sockets should only be

   154     used in non-GUI threads, to avoid freezing the user interface.

   155     See the \l network/fortuneclient and \l network/blockingfortuneclient

   156     examples for an overview of both approaches.

   157 

   158     QAbstractSocket can be used with QTextStream and QDataStream's

   159     stream operators (operator<<() and operator>>()). There is one

   160     issue to be aware of, though: You must make sure that enough data

   161     is available before attempting to read it using operator>>().

   162 

   163     \sa QFtp, QNetworkAccessManager, QTcpServer

   164 */

   165 

   166 /*!

   167     \fn void QAbstractSocket::hostFound()

   168 

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

   170     the host lookup has succeeded.

   171 

   172     \sa connected()

   173 */

   174 

   175 /*!

   176     \fn void QAbstractSocket::connected()

   177 

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

   179     a connection has been successfully established.

   180 

   181     \sa connectToHost(), disconnected()

   182 */

   183 

   184 /*!

   185     \fn void QAbstractSocket::disconnected()

   186 

   187     This signal is emitted when the socket has been disconnected.

   188     

   189     \warning If you need to delete the sender() of this signal in a slot connected

   190     to it, use the \l{QObject::deleteLater()}{deleteLater()} function.

   191 

   192     \sa connectToHost(), disconnectFromHost(), abort()

   193 */

   194 

   195 /*!

   196     \fn void QAbstractSocket::error(QAbstractSocket::SocketError socketError)

   197 

   198     This signal is emitted after an error occurred. The \a socketError

   199     parameter describes the type of error that occurred.

   200 

   201     QAbstractSocket::SocketError is not a registered metatype, so for queued

   202     connections, you will have to register it with Q_DECLARE_METATYPE() and

   203     qRegisterMetaType().

   204 

   205     \sa error(), errorString(), {Creating Custom Qt Types}

   206 */

   207 

   208 /*!

   209     \fn void QAbstractSocket::stateChanged(QAbstractSocket::SocketState socketState)

   210 

   211     This signal is emitted whenever QAbstractSocket's state changes.

   212     The \a socketState parameter is the new state.

   213 

   214     QAbstractSocket::SocketState is not a registered metatype, so for queued

   215     connections, you will have to register it with Q_REGISTER_METATYPE() and

   216     qRegisterMetaType().

   217 

   218     \sa state(), {Creating Custom Qt Types}

   219 */

   220 

   221 /*!

   222     \fn void QAbstractSocket::proxyAuthenticationRequired(const QNetworkProxy &proxy, QAuthenticator *authenticator)

   223     \since 4.3

   224 

   225     This signal can be emitted when a \a proxy that requires

   226     authentication is used. The \a authenticator object can then be

   227     filled in with the required details to allow authentication and

   228     continue the connection.

   229 

   230     \note It is not possible to use a QueuedConnection to connect to

   231     this signal, as the connection will fail if the authenticator has

   232     not been filled in with new information when the signal returns.

   233 

   234     \sa QAuthenticator, QNetworkProxy

   235 */

   236 

   237 /*!

   238     \enum QAbstractSocket::NetworkLayerProtocol

   239 

   240     This enum describes the network layer protocol values used in Qt.

   241 

   242     \value IPv4Protocol IPv4

   243     \value IPv6Protocol IPv6

   244     \value UnknownNetworkLayerProtocol Other than IPv4 and IPv6

   245 

   246     \sa QHostAddress::protocol()

   247 */

   248 

   249 /*!

   250     \enum QAbstractSocket::SocketType

   251 

   252     This enum describes the transport layer protocol.

   253 

   254     \value TcpSocket TCP

   255     \value UdpSocket UDP

   256     \value UnknownSocketType Other than TCP and UDP

   257 

   258     \sa QAbstractSocket::socketType()

   259 */

   260 

   261 /*!

   262     \enum QAbstractSocket::SocketError

   263 

   264     This enum describes the socket errors that can occur.

   265 

   266     \value ConnectionRefusedError The connection was refused by the

   267            peer (or timed out).

   268     \value RemoteHostClosedError The remote host closed the

   269            connection. Note that the client socket (i.e., this socket)

   270            will be closed after the remote close notification has

   271            been sent.

   272     \value HostNotFoundError The host address was not found.

   273     \value SocketAccessError The socket operation failed because the

   274            application lacked the required privileges.

   275     \value SocketResourceError The local system ran out of resources

   276            (e.g., too many sockets).

   277     \value SocketTimeoutError The socket operation timed out.

   278     \value DatagramTooLargeError The datagram was larger than the

   279            operating system's limit (which can be as low as 8192

   280            bytes).

   281     \value NetworkError An error occurred with the network (e.g., the

   282            network cable was accidentally plugged out).

   283     \value AddressInUseError The address specified to QUdpSocket::bind() is

   284            already in use and was set to be exclusive.

   285     \value SocketAddressNotAvailableError The address specified to

   286            QUdpSocket::bind() does not belong to the host.

   287     \value UnsupportedSocketOperationError The requested socket operation is

   288            not supported by the local operating system (e.g., lack of

   289            IPv6 support).

   290     \value ProxyAuthenticationRequiredError The socket is using a proxy, and

   291            the proxy requires authentication.

   292     \value SslHandshakeFailedError The SSL/TLS handshake failed, so

   293            the connection was closed (only used in QSslSocket)

   294     \value UnfinishedSocketOperationError Used by QAbstractSocketEngine only,

   295            The last operation attempted has not finished yet (still in progress in

   296             the background).

   297     \value ProxyConnectionRefusedError Could not contact the proxy server because

   298            the connection to that server was denied

   299     \value ProxyConnectionClosedError The connection to the proxy server was closed

   300            unexpectedly (before the connection to the final peer was established)

   301     \value ProxyConnectionTimeoutError The connection to the proxy server timed out

   302            or the proxy server stopped responding in the authentication phase.

   303     \value ProxyNotFoundError The proxy address set with setProxy() (or the application

   304            proxy) was not found.

   305     \value ProxyProtocolError The connection negotiation with the proxy server

   306            because the response from the proxy server could not be understood.

   307 

   308     \value UnknownSocketError An unidentified error occurred.

   309     \sa QAbstractSocket::error()

   310 */

   311 

   312 /*!

   313     \enum QAbstractSocket::SocketState

   314 

   315     This enum describes the different states in which a socket can be.

   316 

   317     \value UnconnectedState The socket is not connected.

   318     \value HostLookupState The socket is performing a host name lookup.

   319     \value ConnectingState The socket has started establishing a connection.

   320     \value ConnectedState A connection is established.

   321     \value BoundState The socket is bound to an address and port (for servers).

   322     \value ClosingState The socket is about to close (data may still

   323     be waiting to be written).

   324     \value ListeningState For internal use only.

   325     \omitvalue Idle

   326     \omitvalue HostLookup

   327     \omitvalue Connecting

   328     \omitvalue Connected

   329     \omitvalue Closing

   330     \omitvalue Connection

   331 

   332     \sa QAbstractSocket::state()

   333 */

   334 

   335 /*!

   336     \enum QAbstractSocket::SocketOption

   337     \since 4.6

   338 

   339     This enum represents the options that can be set on a socket.

   340     If desired, they can be set after having received the connected() signal from

   341     the socket or after having received a new socket from a QTcpServer.

   342 

   343     \value LowDelayOption Try to optimize the socket for low latency. For a QTcpSocket

   344     this would set the TCP_NODELAY option and disable Nagle's algorithm. Set this to 1

   345     to enable.

   346     \value KeepAliveOption Set this to 1 to enable the SO_KEEPALIVE socket option

   347 

   348     \sa QAbstractSocket::setSocketOption(), QAbstractSocket::socketOption()

   349 */

   350 

   351 #include "qabstractsocket.h"

   352 #include "qabstractsocket_p.h"

   353 

   354 #include <qabstracteventdispatcher.h>

   355 #include <qdatetime.h>

   356 #include <qhostaddress.h>

   357 #include <qhostinfo.h>

   358 #include <qmetaobject.h>

   359 #include <qpointer.h>

   360 #include <qtimer.h>

   361 

   362 #ifndef QT_NO_OPENSSL

   363 #include <QtNetwork/qsslsocket.h>

   364 #endif

   365 

   366 #include <private/qthread_p.h>

   367 

   368 #ifdef QABSTRACTSOCKET_DEBUG

   369 #include <qdebug.h>

   370 #endif

   371 

   372 #include <time.h>

   373 

   374 #define Q_CHECK_SOCKETENGINE(returnValue) do { \

   375     if (!d->socketEngine) { \

   376         return returnValue; \

   377     } } while (0)

   378 

   379 #ifndef QABSTRACTSOCKET_BUFFERSIZE

   380 #define QABSTRACTSOCKET_BUFFERSIZE 32768

   381 #endif

   382 #define QT_CONNECT_TIMEOUT 30000

   383 #define QT_TRANSFER_TIMEOUT 120000

   384 

   385 QT_BEGIN_NAMESPACE

   386 

   387 #if defined QABSTRACTSOCKET_DEBUG

   388 QT_BEGIN_INCLUDE_NAMESPACE

   389 #include <qstring.h>

   390 #include <ctype.h>

   391 QT_END_INCLUDE_NAMESPACE

   392 

   393 /*

   394     Returns a human readable representation of the first \a len

   395     characters in \a data.

   396 */

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

   398 {

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

   400     QByteArray out;

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

   402         char c = data[i];

   403         if (isprint(int(uchar(c)))) {

   404             out += c;

   405         } else switch (c) {

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

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

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

   409         default:

   410             QString tmp;

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

   412             out += tmp.toLatin1();

   413         }

   414     }

   415 

   416     if (len < maxLength)

   417         out += "...";

   418 

   419     return out;

   420 }

   421 #endif

   422 

   423 static bool isProxyError(QAbstractSocket::SocketError error)

   424 {

   425     switch (error) {

   426     case QAbstractSocket::ProxyAuthenticationRequiredError:

   427     case QAbstractSocket::ProxyConnectionRefusedError:

   428     case QAbstractSocket::ProxyConnectionClosedError:

   429     case QAbstractSocket::ProxyConnectionTimeoutError:

   430     case QAbstractSocket::ProxyNotFoundError:

   431     case QAbstractSocket::ProxyProtocolError:

   432         return true;

   433     default:

   434         return false;

   435     }

   436 }

   437 

   438 /*! \internal

   439 

   440     Constructs a QAbstractSocketPrivate. Initializes all members.

   441 */

   442 QAbstractSocketPrivate::QAbstractSocketPrivate()

   443     : readSocketNotifierCalled(false),

   444       readSocketNotifierState(false),

   445       readSocketNotifierStateSet(false),

   446       emittedReadyRead(false),

   447       emittedBytesWritten(false),

   448       abortCalled(false),

   449       closeCalled(false),

   450       pendingClose(false),

   451       port(0),

   452       localPort(0),

   453       peerPort(0),

   454       socketEngine(0),

   455       cachedSocketDescriptor(-1),

   456 #ifdef Q_OS_LINUX

   457       addToBytesAvailable(0),

   458 #endif

   459       readBufferMaxSize(0),

   460       readBuffer(QABSTRACTSOCKET_BUFFERSIZE),

   461       writeBuffer(QABSTRACTSOCKET_BUFFERSIZE),

   462       isBuffered(false),

   463       blockingTimeout(30000),

   464       connectTimer(0),

   465       connectTimeElapsed(0),

   466       hostLookupId(-1),

   467       socketType(QAbstractSocket::UnknownSocketType),

   468       state(QAbstractSocket::UnconnectedState),

   469       socketError(QAbstractSocket::UnknownSocketError)

   470 {

   471 }

   472 

   473 /*! \internal

   474 

   475     Destructs the QAbstractSocket. If the socket layer is open, it

   476     will be reset.

   477 */

   478 QAbstractSocketPrivate::~QAbstractSocketPrivate()

   479 {

   480 }

   481 

   482 /*! \internal

   483 

   484     Resets the socket layer, clears the read and write buffers and

   485     deletes any socket notifiers.

   486 */

   487 void QAbstractSocketPrivate::resetSocketLayer()

   488 {

   489 #if defined (QABSTRACTSOCKET_DEBUG)

   490     qDebug("QAbstractSocketPrivate::resetSocketLayer()");

   491 #endif

   492 

   493     if (socketEngine) {

   494         socketEngine->close();

   495         socketEngine->disconnect();

   496         delete socketEngine;

   497         socketEngine = 0;

   498         cachedSocketDescriptor = -1;

   499     }

   500     if (connectTimer) {

   501         connectTimer->stop();

   502     }

   503 }

   504 

   505 /*! \internal

   506 

   507     Initializes the socket layer to by of type \a type, using the

   508     network layer protocol \a protocol. Resets the socket layer first

   509     if it's already initialized. Sets up the socket notifiers.

   510 */

   511 bool QAbstractSocketPrivate::initSocketLayer(QAbstractSocket::NetworkLayerProtocol protocol)

   512 {

   513 #ifdef QT_NO_NETWORKPROXY

   514     // this is here to avoid a duplication of the call to createSocketEngine below

   515     static const QNetworkProxy &proxyInUse = *(QNetworkProxy *)0;

   516 #endif

   517 

   518     Q_Q(QAbstractSocket);

   519 #if defined (QABSTRACTSOCKET_DEBUG)

   520     QString typeStr;

   521     if (q->socketType() == QAbstractSocket::TcpSocket) typeStr = "TcpSocket";

   522     else if (q->socketType() == QAbstractSocket::UdpSocket) typeStr = "UdpSocket";

   523     else typeStr = "UnknownSocketType";

   524     QString protocolStr;

   525     if (protocol == QAbstractSocket::IPv4Protocol) protocolStr = "IPv4Protocol";

   526     else if (protocol == QAbstractSocket::IPv6Protocol) protocolStr = "IPv6Protocol";

   527     else protocolStr = "UnknownNetworkLayerProtocol";

   528 #endif

   529 

   530     resetSocketLayer();

   531     socketEngine = QAbstractSocketEngine::createSocketEngine(q->socketType(), proxyInUse, q);

   532     if (!socketEngine) {

   533         socketError = QAbstractSocket::UnsupportedSocketOperationError;

   534         q->setErrorString(QAbstractSocket::tr("Operation on socket is not supported"));

   535         return false;

   536     }

   537     if (!socketEngine->initialize(q->socketType(), protocol)) {

   538 #if defined (QABSTRACTSOCKET_DEBUG)

   539         qDebug("QAbstractSocketPrivate::initSocketLayer(%s, %s) failed (%s)",

   540                typeStr.toLatin1().constData(), protocolStr.toLatin1().constData(),

   541                socketEngine->errorString().toLatin1().constData());

   542 #endif

   543         socketError = socketEngine->error();

   544 	q->setErrorString(socketEngine->errorString());

   545         return false;

   546     }

   547 

   548     if (threadData->eventDispatcher)

   549         socketEngine->setReceiver(this);

   550 

   551 #if defined (QABSTRACTSOCKET_DEBUG)

   552     qDebug("QAbstractSocketPrivate::initSocketLayer(%s, %s) success",

   553            typeStr.toLatin1().constData(), protocolStr.toLatin1().constData());

   554 #endif

   555     return true;

   556 }

   557 

   558 /*! \internal

   559 

   560     Slot connected to the read socket notifier. This slot is called

   561     when new data is available for reading, or when the socket has

   562     been closed. Handles recursive calls.

   563 */

   564 bool QAbstractSocketPrivate::canReadNotification()

   565 {

   566     Q_Q(QAbstractSocket);

   567 #if defined (QABSTRACTSOCKET_DEBUG)

   568     qDebug("QAbstractSocketPrivate::canReadNotification()");

   569 #endif

   570 

   571     // Prevent recursive calls

   572     if (readSocketNotifierCalled) {

   573         if (!readSocketNotifierStateSet) {

   574             readSocketNotifierStateSet = true;

   575             readSocketNotifierState = socketEngine->isReadNotificationEnabled();

   576             socketEngine->setReadNotificationEnabled(false);

   577         }

   578     }

   579     readSocketNotifierCalled = true;

   580 

   581     if (!isBuffered)

   582         socketEngine->setReadNotificationEnabled(false);

   583 

   584     // If buffered, read data from the socket into the read buffer

   585     qint64 newBytes = 0;

   586     if (isBuffered) {

   587         // Return if there is no space in the buffer

   588         if (readBufferMaxSize && readBuffer.size() >= readBufferMaxSize) {

   589 #if defined (QABSTRACTSOCKET_DEBUG)

   590             qDebug("QAbstractSocketPrivate::canReadNotification() buffer is full");

   591 #endif

   592             readSocketNotifierCalled = false;

   593             return false;

   594         }

   595 

   596         // If reading from the socket fails after getting a read

   597         // notification, close the socket.

   598         newBytes = readBuffer.size();

   599         if (!readFromSocket()) {

   600 #if defined (QABSTRACTSOCKET_DEBUG)

   601             qDebug("QAbstractSocketPrivate::canReadNotification() disconnecting socket");

   602 #endif

   603             q->disconnectFromHost();

   604             readSocketNotifierCalled = false;

   605             return false;

   606         }

   607         newBytes = readBuffer.size() - newBytes;

   608 

   609         // If read buffer is full, disable the read socket notifier.

   610         if (readBufferMaxSize && readBuffer.size() == readBufferMaxSize) {

   611             socketEngine->setReadNotificationEnabled(false);

   612         }

   613     }

   614 

   615     // only emit readyRead() when not recursing, and only if there is data available

   616     bool hasData = newBytes > 0

   617 #ifndef QT_NO_UDPSOCKET

   618         || (!isBuffered && socketEngine && socketEngine->hasPendingDatagrams())

   619 #endif

   620         ;

   621 

   622     if (!emittedReadyRead && hasData) {

   623         emittedReadyRead = true;

   624         emit q->readyRead();

   625         emittedReadyRead = false;

   626     }

   627 

   628     // If we were closed as a result of the readyRead() signal,

   629     // return.

   630     if (state == QAbstractSocket::UnconnectedState || state == QAbstractSocket::ClosingState) {

   631 #if defined (QABSTRACTSOCKET_DEBUG)

   632         qDebug("QAbstractSocketPrivate::canReadNotification() socket is closing - returning");

   633 #endif

   634         readSocketNotifierCalled = false;

   635         return true;

   636     }

   637 

   638     if (!hasData && socketEngine)

   639         socketEngine->setReadNotificationEnabled(true);

   640 

   641     // reset the read socket notifier state if we reentered inside the

   642     // readyRead() connected slot.

   643     if (readSocketNotifierStateSet && socketEngine &&

   644         readSocketNotifierState != socketEngine->isReadNotificationEnabled()) {

   645         socketEngine->setReadNotificationEnabled(readSocketNotifierState);

   646         readSocketNotifierStateSet = false;

   647     }

   648     readSocketNotifierCalled = false;

   649     return true;

   650 }

   651 

   652 /*! \internal

   653 

   654     Slot connected to the write socket notifier. It's called during a

   655     delayed connect or when the socket is ready for writing.

   656 */

   657 bool QAbstractSocketPrivate::canWriteNotification()

   658 {

   659 #if defined (Q_OS_WIN)

   660     if (socketEngine && socketEngine->isWriteNotificationEnabled())

   661         socketEngine->setWriteNotificationEnabled(false);

   662 #endif

   663 

   664 #if defined (QABSTRACTSOCKET_DEBUG)

   665     qDebug("QAbstractSocketPrivate::canWriteNotification() flushing");

   666 #endif

   667     int tmp = writeBuffer.size();

   668     flush();

   669 

   670     if (socketEngine) {

   671 #if defined (Q_OS_WIN)

   672 	if (!writeBuffer.isEmpty())

   673 	    socketEngine->setWriteNotificationEnabled(true);

   674 #else

   675 	if (writeBuffer.isEmpty())

   676 	    socketEngine->setWriteNotificationEnabled(false);

   677 #endif

   678     }

   679 

   680     return (writeBuffer.size() < tmp);

   681 }

   682 

   683 /*! \internal

   684 

   685     Slot connected to a notification of connection status

   686     change. Either we finished connecting or we failed to connect.

   687 */

   688 void QAbstractSocketPrivate::connectionNotification()

   689 {

   690     // If in connecting state, check if the connection has been

   691     // established, otherwise flush pending data.

   692     if (state == QAbstractSocket::ConnectingState) {

   693 #if defined (QABSTRACTSOCKET_DEBUG)

   694         qDebug("QAbstractSocketPrivate::connectionNotification() testing connection");

   695 #endif

   696         _q_testConnection();

   697     }

   698 }

   699 

   700 /*! \internal

   701 

   702     Writes pending data in the write buffers to the socket. The

   703     function writes as much as it can without blocking.

   704 

   705     It is usually invoked by canWriteNotification after one or more

   706     calls to write().

   707 

   708     Emits bytesWritten().

   709 */

   710 bool QAbstractSocketPrivate::flush()

   711 {

   712     Q_Q(QAbstractSocket);

   713     if (!socketEngine || !socketEngine->isValid() || writeBuffer.isEmpty()) {

   714 #if defined (QABSTRACTSOCKET_DEBUG)

   715     qDebug("QAbstractSocketPrivate::flush() nothing to do: valid ? %s, writeBuffer.isEmpty() ? %s",

   716            socketEngine->isValid() ? "yes" : "no", writeBuffer.isEmpty() ? "yes" : "no");

   717 #endif

   718         return false;

   719     }

   720 

   721     int nextSize = writeBuffer.nextDataBlockSize();

   722     const char *ptr = writeBuffer.readPointer();

   723 

   724     // Attempt to write it all in one chunk.

   725     qint64 written = socketEngine->write(ptr, nextSize);

   726     if (written < 0) {

   727         socketError = socketEngine->error();

   728         q->setErrorString(socketEngine->errorString());

   729         emit q->error(socketError);

   730         // an unexpected error so close the socket.

   731 #if defined (QABSTRACTSOCKET_DEBUG)

   732         qDebug() << "QAbstractSocketPrivate::flush() write error, aborting." << socketEngine->errorString();

   733 #endif

   734         q->abort();

   735         return false;

   736     }

   737 

   738 #if defined (QABSTRACTSOCKET_DEBUG)

   739     qDebug("QAbstractSocketPrivate::flush() %lld bytes written to the network",

   740            written);

   741 #endif

   742 

   743     // Remove what we wrote so far.

   744     writeBuffer.free(written);

   745     if (written > 0) {

   746         // Don't emit bytesWritten() recursively.

   747         if (!emittedBytesWritten) {

   748             emittedBytesWritten = true;

   749             emit q->bytesWritten(written);

   750             emittedBytesWritten = false;

   751         }

   752     }

   753 

   754     if (writeBuffer.isEmpty() && socketEngine && socketEngine->isWriteNotificationEnabled())

   755         socketEngine->setWriteNotificationEnabled(false);

   756     if (state == QAbstractSocket::ClosingState)

   757         q->disconnectFromHost();

   758 

   759     return true;

   760 }

   761 

   762 #ifndef QT_NO_NETWORKPROXY

   763 /*! \internal

   764 

   765     Resolve the proxy to its final value.

   766 */

   767 void QAbstractSocketPrivate::resolveProxy(const QString &hostname, quint16 port)

   768 {

   769     QHostAddress parsed;

   770     if (hostname == QLatin1String("localhost")

   771         || hostname.startsWith(QLatin1String("localhost."))

   772         || (parsed.setAddress(hostname)

   773             && (parsed == QHostAddress::LocalHost

   774                 || parsed == QHostAddress::LocalHostIPv6))) {

   775         proxyInUse = QNetworkProxy::NoProxy;

   776         return;

   777     }

   778 

   779     QList<QNetworkProxy> proxies;

   780 

   781     if (proxy.type() != QNetworkProxy::DefaultProxy) {

   782         // a non-default proxy was set with setProxy

   783         proxies << proxy;

   784     } else {

   785         // try the application settings instead

   786         QNetworkProxyQuery query(hostname, port, QString(),

   787                                  socketType == QAbstractSocket::TcpSocket ?

   788                                  QNetworkProxyQuery::TcpSocket :

   789                                  QNetworkProxyQuery::UdpSocket);

   790         proxies = QNetworkProxyFactory::proxyForQuery(query);

   791     }

   792 

   793     // return the first that we can use

   794     foreach (const QNetworkProxy &p, proxies) {

   795         if (socketType == QAbstractSocket::UdpSocket &&

   796             (p.capabilities() & QNetworkProxy::UdpTunnelingCapability) == 0)

   797             continue;

   798 

   799         if (socketType == QAbstractSocket::TcpSocket &&

   800             (p.capabilities() & QNetworkProxy::TunnelingCapability) == 0)

   801             continue;

   802 

   803         proxyInUse = p;

   804         return;

   805     }

   806 

   807     // no proxy found

   808     // DefaultProxy here will raise an error

   809     proxyInUse = QNetworkProxy();

   810 }

   811 

   812 /*!

   813     \internal

   814 

   815     Starts the connection to \a host, like _q_startConnecting below,

   816     but without hostname resolution.

   817 */

   818 void QAbstractSocketPrivate::startConnectingByName(const QString &host)

   819 {

   820     Q_Q(QAbstractSocket);

   821     if (state == QAbstractSocket::ConnectingState || state == QAbstractSocket::ConnectedState)

   822         return;

   823 

   824 #if defined(QABSTRACTSOCKET_DEBUG)

   825     qDebug("QAbstractSocketPrivate::startConnectingByName(host == %s)", qPrintable(host));

   826 #endif

   827 

   828     // ### Let the socket engine drive this?

   829     state = QAbstractSocket::ConnectingState;

   830     emit q->stateChanged(state);

   831 

   832     connectTimeElapsed = 0;

   833 

   834     if (initSocketLayer(QAbstractSocket::UnknownNetworkLayerProtocol)) {

   835         if (socketEngine->connectToHostByName(host, port) ||

   836             socketEngine->state() == QAbstractSocket::ConnectingState) {

   837             cachedSocketDescriptor = socketEngine->socketDescriptor();

   838 

   839             return;

   840         }

   841 

   842         // failed to connect

   843         socketError = socketEngine->error();

   844         q->setErrorString(socketEngine->errorString());

   845     }

   846 

   847     state = QAbstractSocket::UnconnectedState;

   848     emit q->error(socketError);

   849     emit q->stateChanged(state);

   850 }

   851 

   852 #endif

   853 

   854 /*! \internal

   855 

   856     Slot connected to QHostInfo::lookupHost() in connectToHost(). This

   857     function starts the process of connecting to any number of

   858     candidate IP addresses for the host, if it was found. Calls

   859     _q_connectToNextAddress().

   860 */

   861 void QAbstractSocketPrivate::_q_startConnecting(const QHostInfo &hostInfo)

   862 {

   863     Q_Q(QAbstractSocket);

   864     if (state != QAbstractSocket::HostLookupState)

   865         return;

   866 

   867     addresses = hostInfo.addresses();

   868 

   869 #if defined(QABSTRACTSOCKET_DEBUG)

   870     QString s = "{";

   871     for (int i = 0; i < addresses.count(); ++i) {

   872         if (i != 0) s += ", ";

   873         s += addresses.at(i).toString();

   874     }

   875     s += '}';

   876     qDebug("QAbstractSocketPrivate::_q_startConnecting(hostInfo == %s)", s.toLatin1().constData());

   877 #endif

   878 

   879     // Try all addresses twice.

   880     addresses += addresses;

   881 

   882     // If there are no addresses in the host list, report this to the

   883     // user.

   884     if (addresses.isEmpty()) {

   885 #if defined(QABSTRACTSOCKET_DEBUG)

   886         qDebug("QAbstractSocketPrivate::_q_startConnecting(), host not found");

   887 #endif

   888         state = QAbstractSocket::UnconnectedState;

   889         socketError = QAbstractSocket::HostNotFoundError;

   890         q->setErrorString(QAbstractSocket::tr("Host not found"));

   891         emit q->stateChanged(state);

   892         emit q->error(QAbstractSocket::HostNotFoundError);

   893         return;

   894     }

   895 

   896     // Enter Connecting state (see also sn_write, which is called by

   897     // the write socket notifier after connect())

   898     state = QAbstractSocket::ConnectingState;

   899     emit q->stateChanged(state);

   900 

   901     // Report the successful host lookup

   902     emit q->hostFound();

   903 

   904     // Reset the total time spent connecting.

   905     connectTimeElapsed = 0;

   906 

   907     // The addresses returned by the lookup will be tested one after

   908     // another by _q_connectToNextAddress().

   909     _q_connectToNextAddress();

   910 }

   911 

   912 /*! \internal

   913 

   914     Called by a queued or direct connection from _q_startConnecting() or

   915     _q_testConnection(), this function takes the first address of the

   916     pending addresses list and tries to connect to it. If the

   917     connection succeeds, QAbstractSocket will emit

   918     connected(). Otherwise, error(ConnectionRefusedError) or

   919     error(SocketTimeoutError) is emitted.

   920 */

   921 void QAbstractSocketPrivate::_q_connectToNextAddress()

   922 {

   923     Q_Q(QAbstractSocket);

   924     do {

   925         // Check for more pending addresses

   926         if (addresses.isEmpty()) {

   927 #if defined(QABSTRACTSOCKET_DEBUG)

   928             qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), all addresses failed.");

   929 #endif

   930             state = QAbstractSocket::UnconnectedState;

   931             if (socketEngine) {

   932                 if ((socketEngine->error() == QAbstractSocket::UnknownSocketError

   933 #ifdef Q_OS_AIX

   934                      // On AIX, the second connect call will result in EINVAL and not

   935                      // ECONNECTIONREFUSED; although the meaning is the same.

   936                      || socketEngine->error() == QAbstractSocket::UnsupportedSocketOperationError

   937 #endif

   938                     ) && socketEngine->state() == QAbstractSocket::ConnectingState) {

   939                     socketError = QAbstractSocket::ConnectionRefusedError;

   940                     q->setErrorString(QAbstractSocket::tr("Connection refused"));

   941                 } else {

   942                     socketError = socketEngine->error();

   943                     q->setErrorString(socketEngine->errorString());

   944                 }

   945             } else {

   946 //                socketError = QAbstractSocket::ConnectionRefusedError;

   947 //                q->setErrorString(QAbstractSocket::tr("Connection refused"));

   948             }

   949             emit q->stateChanged(state);

   950             emit q->error(socketError);

   951             return;

   952         }

   953 

   954         // Pick the first host address candidate

   955         host = addresses.takeFirst();

   956 #if defined(QABSTRACTSOCKET_DEBUG)

   957         qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), connecting to %s:%i, %d left to try",

   958                host.toString().toLatin1().constData(), port, addresses.count());

   959 #endif

   960 

   961 #if defined(QT_NO_IPV6)

   962         if (host.protocol() == QAbstractSocket::IPv6Protocol) {

   963             // If we have no IPv6 support, then we will not be able to

   964             // connect. So we just pretend we didn't see this address.

   965 #if defined(QABSTRACTSOCKET_DEBUG)

   966             qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), skipping IPv6 entry");

   967 #endif

   968             continue;

   969         }

   970 #endif

   971 

   972         if (!initSocketLayer(host.protocol())) {

   973             // hope that the next address is better

   974 #if defined(QABSTRACTSOCKET_DEBUG)

   975             qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), failed to initialize sock layer");

   976 #endif

   977             continue;

   978         }

   979 

   980         // Tries to connect to the address. If it succeeds immediately

   981         // (localhost address on BSD or any UDP connect), emit

   982         // connected() and return.

   983         if (socketEngine->connectToHost(host, port)) {

   984             //_q_testConnection();

   985             fetchConnectionParameters();

   986             return;

   987         }

   988 

   989         // cache the socket descriptor even if we're not fully connected yet

   990         cachedSocketDescriptor = socketEngine->socketDescriptor();

   991 

   992         // Check that we're in delayed connection state. If not, try

   993         // the next address

   994         if (socketEngine->state() != QAbstractSocket::ConnectingState) {

   995 #if defined(QABSTRACTSOCKET_DEBUG)

   996             qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), connection failed (%s)",

   997                    socketEngine->errorString().toLatin1().constData());

   998 #endif

   999             continue;

  1000         }

  1001 

  1002         // Start the connect timer.

  1003         if (threadData->eventDispatcher) {

  1004             if (!connectTimer) {

  1005                 connectTimer = new QTimer(q);

  1006                 QObject::connect(connectTimer, SIGNAL(timeout()),

  1007                                  q, SLOT(_q_abortConnectionAttempt()),

  1008                                  Qt::DirectConnection);

  1009             }

  1010             connectTimer->start(QT_CONNECT_TIMEOUT);

  1011         }

  1012 

  1013         // Wait for a write notification that will eventually call

  1014         // _q_testConnection().

  1015         socketEngine->setWriteNotificationEnabled(true);

  1016         break;

  1017     } while (state != QAbstractSocket::ConnectedState);

  1018 }

  1019 

  1020 /*! \internal

  1021 

  1022     Tests if a connection has been established. If it has, connected()

  1023     is emitted. Otherwise, _q_connectToNextAddress() is invoked.

  1024 */

  1025 void QAbstractSocketPrivate::_q_testConnection()

  1026 {

  1027     if (socketEngine) {

  1028         if (threadData->eventDispatcher) {

  1029             if (connectTimer)

  1030                 connectTimer->stop();

  1031         }

  1032 

  1033         if (socketEngine->state() == QAbstractSocket::ConnectedState) {

  1034             // Fetch the parameters if our connection is completed;

  1035             // otherwise, fall out and try the next address.

  1036             fetchConnectionParameters();

  1037             if (pendingClose) {

  1038                 q_func()->disconnectFromHost();

  1039                 pendingClose = false;

  1040             }

  1041             return;

  1042         }

  1043 

  1044         // don't retry the other addresses if we had a proxy error

  1045         if (isProxyError(socketEngine->error()))

  1046             addresses.clear();

  1047     }

  1048 

  1049     if (threadData->eventDispatcher) {

  1050         if (connectTimer)

  1051             connectTimer->stop();

  1052     }

  1053 

  1054 #if defined(QABSTRACTSOCKET_DEBUG)

  1055     qDebug("QAbstractSocketPrivate::_q_testConnection() connection failed,"

  1056            " checking for alternative addresses");

  1057 #endif

  1058     _q_connectToNextAddress();

  1059 }

  1060 

  1061 /*! \internal

  1062 

  1063     This function is called after a certain number of seconds has

  1064     passed while waiting for a connection. It simply tests the

  1065     connection, and continues to the next address if the connection

  1066     failed.

  1067 */

  1068 void QAbstractSocketPrivate::_q_abortConnectionAttempt()

  1069 {

  1070     Q_Q(QAbstractSocket);

  1071 #if defined(QABSTRACTSOCKET_DEBUG)

  1072     qDebug("QAbstractSocketPrivate::_q_abortConnectionAttempt() (timed out)");

  1073 #endif

  1074     if (socketEngine)

  1075         socketEngine->setWriteNotificationEnabled(false);

  1076 

  1077     connectTimer->stop();

  1078 

  1079     if (addresses.isEmpty()) {

  1080         state = QAbstractSocket::UnconnectedState;

  1081         socketError = QAbstractSocket::SocketTimeoutError;

  1082         q->setErrorString(QAbstractSocket::tr("Connection timed out"));

  1083         emit q->stateChanged(state);

  1084         emit q->error(socketError);

  1085     } else {

  1086         _q_connectToNextAddress();

  1087     }

  1088 }

  1089 

  1090 /*! \internal

  1091 

  1092     Reads data from the socket layer into the read buffer. Returns

  1093     true on success; otherwise false.

  1094 */

  1095 bool QAbstractSocketPrivate::readFromSocket()

  1096 {

  1097     Q_Q(QAbstractSocket);

  1098     // Find how many bytes we can read from the socket layer.

  1099     qint64 bytesToRead = socketEngine->bytesAvailable();

  1100 #ifdef Q_OS_LINUX

  1101     if (bytesToRead > 0) // ### See setSocketDescriptor()

  1102         bytesToRead += addToBytesAvailable;

  1103 #endif

  1104     if (bytesToRead == 0) {

  1105         // Under heavy load, certain conditions can trigger read notifications

  1106         // for socket notifiers on which there is no activity. If we continue

  1107         // to read 0 bytes from the socket, we will trigger behavior similar

  1108         // to that which signals a remote close. When we hit this condition,

  1109         // we try to read 4k of data from the socket, which will give us either

  1110         // an EAGAIN/EWOULDBLOCK if the connection is alive (i.e., the remote

  1111         // host has _not_ disappeared).

  1112         bytesToRead = 4096;

  1113     }

  1114     if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - readBuffer.size()))

  1115         bytesToRead = readBufferMaxSize - readBuffer.size();

  1116 

  1117 #if defined(QABSTRACTSOCKET_DEBUG)

  1118     qDebug("QAbstractSocketPrivate::readFromSocket() about to read %d bytes",

  1119            int(bytesToRead));

  1120 #endif

  1121 

  1122     // Read from the socket, store data in the read buffer.

  1123     char *ptr = readBuffer.reserve(bytesToRead);

  1124     qint64 readBytes = socketEngine->read(ptr, bytesToRead);

  1125     if (readBytes == -2) {

  1126         // No bytes currently available for reading.

  1127         readBuffer.chop(bytesToRead);

  1128         return true;

  1129     }

  1130     readBuffer.chop(int(bytesToRead - (readBytes < 0 ? qint64(0) : readBytes)));

  1131 #if defined(QABSTRACTSOCKET_DEBUG)

  1132     qDebug("QAbstractSocketPrivate::readFromSocket() got %d bytes, buffer size = %d",

  1133            int(readBytes), readBuffer.size());

  1134 #endif