qabstractsocket.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Copyright (C) 2022 The Qt Company Ltd.
** Copyright (C) 2016 Intel Corporation.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the QtNetwork module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
 
//#define QABSTRACTSOCKET_DEBUG
 
#include <QtNetwork/private/qtnetworkglobal_p.h>
 
#include "qabstractsocket.h"
#include "qabstractsocket_p.h"
 
#include "private/qhostinfo_p.h"
 
#include <qabstracteventdispatcher.h>
#include <qhostaddress.h>
#include <qhostinfo.h>
#include <qmetaobject.h>
#include <qpointer.h>
#include <qtimer.h>
#include <qelapsedtimer.h>
#include <qscopedvaluerollback.h>
#include <qvarlengtharray.h>
 
#include <private/qthread_p.h>
 
#ifdef QABSTRACTSOCKET_DEBUG
#include <qdebug.h>
#include <private/qdebug_p.h>
#endif
 
#include <time.h>
 
#define Q_CHECK_SOCKETENGINE(returnValue) do { \
    if (!d->socketEngine) { \
        return returnValue; \
    } } while (0)
 
#ifndef QABSTRACTSOCKET_BUFFERSIZE
#define QABSTRACTSOCKET_BUFFERSIZE 32768
#endif
#define QT_TRANSFER_TIMEOUT 120000
 
QT_BEGIN_NAMESPACE
 
static const int DefaultConnectTimeout = 30000;
 
static bool isProxyError(QAbstractSocket::SocketError error)
{
    switch (error) {
    case QAbstractSocket::ProxyAuthenticationRequiredError:
    case QAbstractSocket::ProxyConnectionRefusedError:
    case QAbstractSocket::ProxyConnectionClosedError:
    case QAbstractSocket::ProxyConnectionTimeoutError:
    case QAbstractSocket::ProxyNotFoundError:
    case QAbstractSocket::ProxyProtocolError:
        return true;
    default:
        return false;
    }
}
 
QAbstractSocketPrivate::QAbstractSocketPrivate()
    : emittedReadyRead(false),
      emittedBytesWritten(false),
      abortCalled(false),
      pendingClose(false),
      pauseMode(QAbstractSocket::PauseNever),
      port(0),
      localPort(0),
      peerPort(0),
      socketEngine(nullptr),
      cachedSocketDescriptor(-1),
      readBufferMaxSize(0),
      isBuffered(false),
      hasPendingData(false),
      connectTimer(nullptr),
      hostLookupId(-1),
      socketType(QAbstractSocket::UnknownSocketType),
      state(QAbstractSocket::UnconnectedState),
      socketError(QAbstractSocket::UnknownSocketError),
      preferredNetworkLayerProtocol(QAbstractSocket::UnknownNetworkLayerProtocol)
{
    writeBufferChunkSize = QABSTRACTSOCKET_BUFFERSIZE;
}
 
QAbstractSocketPrivate::~QAbstractSocketPrivate()
{
}
 
void QAbstractSocketPrivate::resetSocketLayer()
{
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::resetSocketLayer()");
#endif
 
    hasPendingData = false;
    if (socketEngine) {
        socketEngine->close();
        socketEngine->disconnect();
        delete socketEngine;
        socketEngine = nullptr;
        cachedSocketDescriptor = -1;
    }
    if (connectTimer)
        connectTimer->stop();
}
 
bool QAbstractSocketPrivate::initSocketLayer(QAbstractSocket::NetworkLayerProtocol protocol)
{
#ifdef QT_NO_NETWORKPROXY
    // this is here to avoid a duplication of the call to createSocketEngine below
    static const QNetworkProxy &proxyInUse = *(QNetworkProxy *)0;
#endif
 
    Q_Q(QAbstractSocket);
#if defined (QABSTRACTSOCKET_DEBUG)
    QString typeStr;
    if (q->socketType() == QAbstractSocket::TcpSocket) typeStr = QLatin1String("TcpSocket");
    else if (q->socketType() == QAbstractSocket::UdpSocket) typeStr = QLatin1String("UdpSocket");
    else if (q->socketType() == QAbstractSocket::SctpSocket) typeStr = QLatin1String("SctpSocket");
    else typeStr = QLatin1String("UnknownSocketType");
    QString protocolStr;
    if (protocol == QAbstractSocket::IPv4Protocol) protocolStr = QLatin1String("IPv4Protocol");
    else if (protocol == QAbstractSocket::IPv6Protocol) protocolStr = QLatin1String("IPv6Protocol");
    else protocolStr = QLatin1String("UnknownNetworkLayerProtocol");
#endif
 
    resetSocketLayer();
    socketEngine = QAbstractSocketEngine::createSocketEngine(q->socketType(), proxyInUse, q);
    if (!socketEngine) {
        setError(QAbstractSocket::UnsupportedSocketOperationError,
                 QAbstractSocket::tr("Operation on socket is not supported"));
        return false;
    }
    if (!socketEngine->initialize(q->socketType(), protocol)) {
#if defined (QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::initSocketLayer(%s, %s) failed (%s)",
               typeStr.toLatin1().constData(), protocolStr.toLatin1().constData(),
               socketEngine->errorString().toLatin1().constData());
#endif
        setError(socketEngine->error(), socketEngine->errorString());
        return false;
    }
 
    configureCreatedSocket();
 
    if (threadData.loadRelaxed()->hasEventDispatcher())
        socketEngine->setReceiver(this);
 
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::initSocketLayer(%s, %s) success",
           typeStr.toLatin1().constData(), protocolStr.toLatin1().constData());
#endif
    return true;
}
 
void QAbstractSocketPrivate::configureCreatedSocket()
{
#ifndef QT_NO_SCTP
    Q_Q(QAbstractSocket);
    // Set single stream mode for unbuffered SCTP socket
    if (socketEngine && q->socketType() == QAbstractSocket::SctpSocket)
        socketEngine->setOption(QAbstractSocketEngine::MaxStreamsSocketOption, 1);
#endif
}
 
bool QAbstractSocketPrivate::canReadNotification()
{
    Q_Q(QAbstractSocket);
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::canReadNotification()");
#endif
 
    // If buffered, read data from the socket into the read buffer
    if (isBuffered) {
        const qint64 oldBufferSize = buffer.size();
 
        // Return if there is no space in the buffer
        if (readBufferMaxSize && oldBufferSize >= readBufferMaxSize) {
            socketEngine->setReadNotificationEnabled(false);
#if defined (QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocketPrivate::canReadNotification() buffer is full");
#endif
            return false;
        }
 
        // If reading from the socket fails after getting a read
        // notification, close the socket.
        if (!readFromSocket()) {
#if defined (QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocketPrivate::canReadNotification() disconnecting socket");
#endif
            q->disconnectFromHost();
            return false;
        }
 
        // Return if there is no new data available.
        if (buffer.size() == oldBufferSize) {
            // If the socket is opened only for writing, return true
            // to indicate that the data was discarded.
            return !q->isReadable();
        }
    } else {
        if (hasPendingData) {
            socketEngine->setReadNotificationEnabled(false);
            return true;
        }
        hasPendingData = true;
    }
 
    emitReadyRead();
 
#if defined (QABSTRACTSOCKET_DEBUG)
    // If we were closed as a result of the readyRead() signal.
    if (state == QAbstractSocket::UnconnectedState || state == QAbstractSocket::ClosingState)
        qDebug("QAbstractSocketPrivate::canReadNotification() socket is closing - returning");
#endif
 
    return true;
}
 
void QAbstractSocketPrivate::canCloseNotification()
{
    Q_Q(QAbstractSocket);
    // Note that this method is only called on Windows. Other platforms close in the canReadNotification()
 
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::canCloseNotification()");
#endif
 
    qint64 newBytes = 0;
    if (isBuffered) {
        // Try to read to the buffer, if the read fail we can close the socket.
        newBytes = buffer.size();
        qint64 oldReadBufferMaxSize = readBufferMaxSize;
        readBufferMaxSize = 0; // temporarily disable max read buffer, we want to empty the OS buffer
        bool hadReadFromSocket = readFromSocket();
        readBufferMaxSize = oldReadBufferMaxSize;
        if (!hadReadFromSocket) {
            q->disconnectFromHost();
            return;
        }
        newBytes = buffer.size() - newBytes;
        if (newBytes) {
            // If there was still some data to be read from the socket
            // then we could get another FD_READ. The disconnect will
            // then occur when we read from the socket again and fail
            // in canReadNotification or by the manually created
            // closeNotification below.
            emitReadyRead();
 
            QMetaObject::invokeMethod(socketEngine, "closeNotification", Qt::QueuedConnection);
        }
    } else if ((socketType == QAbstractSocket::TcpSocket ||
                socketType == QAbstractSocket::SctpSocket) && socketEngine) {
        emitReadyRead();
    }
}
 
 
bool QAbstractSocketPrivate::canWriteNotification()
{
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::canWriteNotification() flushing");
#endif
 
    return writeToSocket();
}
 
void QAbstractSocketPrivate::connectionNotification()
{
    // If in connecting state, check if the connection has been
    // established, otherwise flush pending data.
    if (state == QAbstractSocket::ConnectingState) {
#if defined (QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::connectionNotification() testing connection");
#endif
        _q_testConnection();
    }
}
 
bool QAbstractSocketPrivate::writeToSocket()
{
    Q_Q(QAbstractSocket);
    if (!socketEngine || !socketEngine->isValid() || (writeBuffer.isEmpty()
        && socketEngine->bytesToWrite() == 0)) {
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::writeToSocket() nothing to do: valid ? %s, writeBuffer.isEmpty() ? %s",
           (socketEngine && socketEngine->isValid()) ? "yes" : "no", writeBuffer.isEmpty() ? "yes" : "no");
#endif
 
        // this covers the case when the buffer was empty, but we had to wait for the socket engine to finish
        if (state == QAbstractSocket::ClosingState) {
            q->disconnectFromHost();
        } else {
            if (socketEngine)
                socketEngine->setWriteNotificationEnabled(false);
        }
 
        return false;
    }
 
    qint64 nextSize = writeBuffer.nextDataBlockSize();
    const char *ptr = writeBuffer.readPointer();
 
    // Attempt to write it all in one chunk.
    qint64 written = nextSize ? socketEngine->write(ptr, nextSize) : Q_INT64_C(0);
    if (written < 0) {
#if defined (QABSTRACTSOCKET_DEBUG)
        qDebug() << "QAbstractSocketPrivate::writeToSocket() write error, aborting."
                 << socketEngine->errorString();
#endif
        setErrorAndEmit(socketEngine->error(), socketEngine->errorString());
        // an unexpected error so close the socket.
        q->abort();
        return false;
    }
 
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::writeToSocket() %lld bytes written to the network",
           written);
#endif
 
    if (written > 0) {
        // Remove what we wrote so far.
        writeBuffer.free(written);
 
        // Emit notifications.
        emitBytesWritten(written);
    }
 
    if (writeBuffer.isEmpty() && socketEngine && !socketEngine->bytesToWrite())
        socketEngine->setWriteNotificationEnabled(false);
    if (state == QAbstractSocket::ClosingState)
        q->disconnectFromHost();
 
    return written > 0;
}
 
bool QAbstractSocketPrivate::flush()
{
    bool dataWasWritten = false;
 
    while (!allWriteBuffersEmpty() && writeToSocket())
        dataWasWritten = true;
 
    return dataWasWritten;
}
 
#ifndef QT_NO_NETWORKPROXY
void QAbstractSocketPrivate::resolveProxy(const QString &hostname, quint16 port)
{
    QList<QNetworkProxy> proxies;
 
    if (proxy.type() != QNetworkProxy::DefaultProxy) {
        // a non-default proxy was set with setProxy
        proxies << proxy;
    } else {
        // try the application settings instead
        QNetworkProxyQuery query(hostname, port, protocolTag,
                                 socketType == QAbstractSocket::TcpSocket ?
                                 QNetworkProxyQuery::TcpSocket :
                                 socketType == QAbstractSocket::SctpSocket ?
                                 QNetworkProxyQuery::SctpSocket :
                                 QNetworkProxyQuery::UdpSocket);
        proxies = QNetworkProxyFactory::proxyForQuery(query);
    }
 
    // return the first that we can use
    for (const QNetworkProxy &p : qAsConst(proxies)) {
        if (socketType == QAbstractSocket::UdpSocket &&
            (p.capabilities() & QNetworkProxy::UdpTunnelingCapability) == 0)
            continue;
 
        if (socketType == QAbstractSocket::TcpSocket &&
            (p.capabilities() & QNetworkProxy::TunnelingCapability) == 0)
            continue;
 
        if (socketType == QAbstractSocket::SctpSocket &&
            (p.capabilities() & QNetworkProxy::SctpTunnelingCapability) == 0)
            continue;
 
        proxyInUse = p;
        return;
    }
 
    // no proxy found
    // DefaultProxy here will raise an error
    proxyInUse = QNetworkProxy();
}
#endif // !QT_NO_NETWORKPROXY
 
#if !defined(QT_NO_NETWORKPROXY)
void QAbstractSocketPrivate::startConnectingByName(const QString &host)
{
    Q_Q(QAbstractSocket);
    if (state == QAbstractSocket::ConnectingState || state == QAbstractSocket::ConnectedState)
        return;
 
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::startConnectingByName(host == %s)", qPrintable(host));
#endif
 
    // ### Let the socket engine drive this?
    state = QAbstractSocket::ConnectingState;
    emit q->stateChanged(state);
 
    if (cachedSocketDescriptor != -1 || initSocketLayer(QAbstractSocket::UnknownNetworkLayerProtocol)) {
        // Try to connect to the host. If it succeeds immediately
        // (e.g. QSocks5SocketEngine in UDPASSOCIATE mode), emit
        // connected() and return.
        if (socketEngine->connectToHostByName(host, port)) {
            fetchConnectionParameters();
            return;
        }
 
        if (socketEngine->state() == QAbstractSocket::ConnectingState)
            return;
 
        // failed to connect
        setError(socketEngine->error(), socketEngine->errorString());
    }
 
    state = QAbstractSocket::UnconnectedState;
    emit q->errorOccurred(socketError);
    emit q->stateChanged(state);
}
 
#endif // !QT_NO_NETWORKPROXY
 
void QAbstractSocketPrivate::_q_startConnecting(const QHostInfo &hostInfo)
{
    Q_Q(QAbstractSocket);
    addresses.clear();
    if (state != QAbstractSocket::HostLookupState)
        return;
 
    if (hostLookupId != -1 && hostLookupId != hostInfo.lookupId()) {
        qWarning("QAbstractSocketPrivate::_q_startConnecting() received hostInfo for wrong lookup ID %d expected %d", hostInfo.lookupId(), hostLookupId);
    }
 
    // Only add the addresses for the preferred network layer.
    // Or all if preferred network layer is not set.
    if (preferredNetworkLayerProtocol == QAbstractSocket::UnknownNetworkLayerProtocol || preferredNetworkLayerProtocol == QAbstractSocket::AnyIPProtocol) {
        addresses = hostInfo.addresses();
    } else {
        const auto candidates = hostInfo.addresses();
        for (const QHostAddress &address : candidates) {
            if (address.protocol() == preferredNetworkLayerProtocol)
                addresses += address;
        }
    }
 
 
#if defined(QABSTRACTSOCKET_DEBUG)
    QString s = QLatin1String("{");
    for (int i = 0; i < addresses.count(); ++i) {
        if (i != 0) s += QLatin1String(", ");
        s += addresses.at(i).toString();
    }
    s += QLatin1Char('}');
    qDebug("QAbstractSocketPrivate::_q_startConnecting(hostInfo == %s)", s.toLatin1().constData());
#endif
 
    // Try all addresses twice.
    addresses += addresses;
 
    // If there are no addresses in the host list, report this to the
    // user.
    if (addresses.isEmpty()) {
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::_q_startConnecting(), host not found");
#endif
        state = QAbstractSocket::UnconnectedState;
        setError(QAbstractSocket::HostNotFoundError, QAbstractSocket::tr("Host not found"));
        emit q->stateChanged(state);
        emit q->errorOccurred(QAbstractSocket::HostNotFoundError);
        return;
    }
 
    // Enter Connecting state (see also sn_write, which is called by
    // the write socket notifier after connect())
    state = QAbstractSocket::ConnectingState;
    emit q->stateChanged(state);
 
    // Report the successful host lookup
    emit q->hostFound();
 
    // The addresses returned by the lookup will be tested one after
    // another by _q_connectToNextAddress().
    _q_connectToNextAddress();
}
 
void QAbstractSocketPrivate::_q_connectToNextAddress()
{
    Q_Q(QAbstractSocket);
    do {
        // Check for more pending addresses
        if (addresses.isEmpty()) {
#if defined(QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), all addresses failed.");
#endif
            state = QAbstractSocket::UnconnectedState;
            if (socketEngine) {
                if ((socketEngine->error() == QAbstractSocket::UnknownSocketError
#ifdef Q_OS_AIX
                     // On AIX, the second connect call will result in EINVAL and not
                     // ECONNECTIONREFUSED; although the meaning is the same.
                     || socketEngine->error() == QAbstractSocket::UnsupportedSocketOperationError
#endif
                    ) && socketEngine->state() == QAbstractSocket::ConnectingState) {
                    setError(QAbstractSocket::ConnectionRefusedError,
                             QAbstractSocket::tr("Connection refused"));
                } else {
                    setError(socketEngine->error(), socketEngine->errorString());
                }
            } else {
//                socketError = QAbstractSocket::ConnectionRefusedError;
//                q->setErrorString(QAbstractSocket::tr("Connection refused"));
            }
            emit q->stateChanged(state);
            emit q->errorOccurred(socketError);
            return;
        }
 
        // Pick the first host address candidate
        host = addresses.takeFirst();
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), connecting to %s:%i, %d left to try",
               host.toString().toLatin1().constData(), port, addresses.count());
#endif
 
        if (cachedSocketDescriptor == -1 && !initSocketLayer(host.protocol())) {
            // hope that the next address is better
#if defined(QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), failed to initialize sock layer");
#endif
            continue;
        }
 
        // Tries to connect to the address. If it succeeds immediately
        // (localhost address on BSD or any UDP connect), emit
        // connected() and return.
        if (
            socketEngine->connectToHost(host, port)) {
                //_q_testConnection();
                fetchConnectionParameters();
                return;
        }
 
        // Check that we're in delayed connection state. If not, try
        // the next address
        if (socketEngine->state() != QAbstractSocket::ConnectingState) {
#if defined(QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocketPrivate::_q_connectToNextAddress(), connection failed (%s)",
                   socketEngine->errorString().toLatin1().constData());
#endif
            continue;
        }
 
        // Start the connect timer.
        if (threadData.loadRelaxed()->hasEventDispatcher()) {
            if (!connectTimer) {
                connectTimer = new QTimer(q);
                QObject::connect(connectTimer, SIGNAL(timeout()),
                                 q, SLOT(_q_abortConnectionAttempt()),
                                 Qt::DirectConnection);
            }
            int connectTimeout = DefaultConnectTimeout;
            connectTimer->start(connectTimeout);
        }
 
        // Wait for a write notification that will eventually call
        // _q_testConnection().
        socketEngine->setWriteNotificationEnabled(true);
        break;
    } while (state != QAbstractSocket::ConnectedState);
}
 
void QAbstractSocketPrivate::_q_testConnection()
{
    if (connectTimer)
        connectTimer->stop();
 
    if (socketEngine) {
        if (socketEngine->state() == QAbstractSocket::ConnectedState) {
            // Fetch the parameters if our connection is completed;
            // otherwise, fall out and try the next address.
            fetchConnectionParameters();
            if (pendingClose) {
                q_func()->disconnectFromHost();
                pendingClose = false;
            }
            return;
        }
 
        // don't retry the other addresses if we had a proxy error
        if (isProxyError(socketEngine->error()))
            addresses.clear();
    }
 
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::_q_testConnection() connection failed,"
           " checking for alternative addresses");
#endif
    _q_connectToNextAddress();
}
 
void QAbstractSocketPrivate::_q_abortConnectionAttempt()
{
    Q_Q(QAbstractSocket);
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::_q_abortConnectionAttempt() (timed out)");
#endif
    if (socketEngine)
        socketEngine->setWriteNotificationEnabled(false);
 
    connectTimer->stop();
 
    if (addresses.isEmpty()) {
        state = QAbstractSocket::UnconnectedState;
        setError(QAbstractSocket::SocketTimeoutError,
                 QAbstractSocket::tr("Connection timed out"));
        emit q->stateChanged(state);
        emit q->errorOccurred(socketError);
    } else {
        _q_connectToNextAddress();
    }
}
 
bool QAbstractSocketPrivate::readFromSocket()
{
    Q_Q(QAbstractSocket);
    // Find how many bytes we can read from the socket layer.
    qint64 bytesToRead = socketEngine->bytesAvailable();
    if (bytesToRead == 0) {
        // Under heavy load, certain conditions can trigger read notifications
        // for socket notifiers on which there is no activity. If we continue
        // to read 0 bytes from the socket, we will trigger behavior similar
        // to that which signals a remote close. When we hit this condition,
        // we try to read 4k of data from the socket, which will give us either
        // an EAGAIN/EWOULDBLOCK if the connection is alive (i.e., the remote
        // host has _not_ disappeared).
        bytesToRead = 4096;
    }
 
    if (q->isReadable()) {
        if (readBufferMaxSize && bytesToRead > (readBufferMaxSize - buffer.size()))
            bytesToRead = readBufferMaxSize - buffer.size();
 
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::readFromSocket() about to read %lld bytes",
               bytesToRead);
#endif
 
        // Read from the socket, store data in the read buffer.
        char *ptr = buffer.reserve(bytesToRead);
        qint64 readBytes = socketEngine->read(ptr, bytesToRead);
        if (readBytes == -2) {
            // No bytes currently available for reading.
            buffer.chop(bytesToRead);
            return true;
        }
        buffer.chop(bytesToRead - (readBytes < 0 ? qint64(0) : readBytes));
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::readFromSocket() got %lld bytes, buffer size = %lld",
               readBytes, buffer.size());
#endif
    } else {
        // Discard unwanted data if opened in WriteOnly mode
        QVarLengthArray<char, 4096> discardBuffer(bytesToRead);
 
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::readFromSocket() about to discard %lld bytes",
               bytesToRead);
#endif
        socketEngine->read(discardBuffer.data(), bytesToRead);
    }
 
    if (!socketEngine->isValid()) {
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocketPrivate::readFromSocket() read failed: %s",
               socketEngine->errorString().toLatin1().constData());
#endif
        setErrorAndEmit(socketEngine->error(), socketEngine->errorString());
        resetSocketLayer();
        return false;
    }
 
    return true;
}
 
void QAbstractSocketPrivate::emitReadyRead(int channel)
{
    Q_Q(QAbstractSocket);
    // Only emit readyRead() when not recursing.
    if (!emittedReadyRead && channel == currentReadChannel) {
        QScopedValueRollback<bool> r(emittedReadyRead);
        emittedReadyRead = true;
        emit q->readyRead();
    }
    // channelReadyRead() can be emitted recursively - even for the same channel.
    emit q->channelReadyRead(channel);
}
 
void QAbstractSocketPrivate::emitBytesWritten(qint64 bytes, int channel)
{
    Q_Q(QAbstractSocket);
    // Only emit bytesWritten() when not recursing.
    if (!emittedBytesWritten && channel == currentWriteChannel) {
        QScopedValueRollback<bool> r(emittedBytesWritten);
        emittedBytesWritten = true;
        emit q->bytesWritten(bytes);
    }
    // channelBytesWritten() can be emitted recursively - even for the same channel.
    emit q->channelBytesWritten(channel, bytes);
}
 
void QAbstractSocketPrivate::fetchConnectionParameters()
{
    Q_Q(QAbstractSocket);
 
    peerName = hostName;
    if (socketEngine) {
        if (q->isReadable()) {
            const int inboundStreamCount = socketEngine->inboundStreamCount();
            setReadChannelCount(qMax(1, inboundStreamCount));
            if (inboundStreamCount == 0)
                readChannelCount = 0;
        }
        if (q->isWritable()) {
            const int outboundStreamCount = socketEngine->outboundStreamCount();
            setWriteChannelCount(qMax(1, outboundStreamCount));
            if (outboundStreamCount == 0)
                writeChannelCount = 0;
        }
        socketEngine->setReadNotificationEnabled(true);
        socketEngine->setWriteNotificationEnabled(true);
        localPort = socketEngine->localPort();
        peerPort = socketEngine->peerPort();
        localAddress = socketEngine->localAddress();
        peerAddress = socketEngine->peerAddress();
        cachedSocketDescriptor = socketEngine->socketDescriptor();
    }
 
    state = QAbstractSocket::ConnectedState;
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocketPrivate::fetchConnectionParameters() connection to %s:%i established",
           host.toString().toLatin1().constData(), port);
#endif
    emit q->stateChanged(state);
    emit q->connected();
}
 
qint64 QAbstractSocket::skipData(qint64 maxSize)
{
    Q_D(const QAbstractSocket);
 
    // if we're not connected, return -1 indicating EOF
    if (!d->socketEngine || !d->socketEngine->isValid()
        || d->state != QAbstractSocket::ConnectedState)
        return -1;
 
    // Caller, QIODevice::skip(), has ensured buffer is empty. So, wait
    // for more data in buffered mode.
    if (d->isBuffered)
        return 0;
 
    return QIODevice::skipData(maxSize);
}
 
void QAbstractSocketPrivate::pauseSocketNotifiers(QAbstractSocket *socket)
{
    QAbstractSocketEngine *socketEngine = socket->d_func()->socketEngine;
    if (!socketEngine)
        return;
    bool read = socketEngine->isReadNotificationEnabled();
    bool write = socketEngine->isWriteNotificationEnabled();
    bool except = socketEngine->isExceptionNotificationEnabled();
 
#ifdef QABSTRACTSOCKET_DEBUG
    qDebug() << socketEngine->socketDescriptor()
             << "pause notifiers, storing 'true' states, currently read:" << read
             << "write:" << write << "except:" << except;
#endif
    // We do this if-check to avoid accidentally overwriting any previously stored state
    // It will reset to false once the socket is re-enabled.
    if (read) {
        socket->d_func()->prePauseReadSocketNotifierState = true;
        socketEngine->setReadNotificationEnabled(false);
    }
    if (write) {
        socket->d_func()->prePauseWriteSocketNotifierState = true;
        socketEngine->setWriteNotificationEnabled(false);
    }
    if (except) {
        socket->d_func()->prePauseExceptionSocketNotifierState = true;
        socketEngine->setExceptionNotificationEnabled(false);
    }
}
 
void QAbstractSocketPrivate::resumeSocketNotifiers(QAbstractSocket *socket)
{
    QAbstractSocketEngine *socketEngine = socket->d_func()->socketEngine;
    if (!socketEngine)
        return;
    QAbstractSocketPrivate *priv = socket->d_func();
#ifdef QABSTRACTSOCKET_DEBUG
    qDebug() << socketEngine->socketDescriptor()
             << "Maybe resume notifiers, read:" << priv->prePauseReadSocketNotifierState
             << "write:" << priv->prePauseWriteSocketNotifierState
             << "exception:" << priv->prePauseExceptionSocketNotifierState;
#endif
    if (std::exchange(priv->prePauseReadSocketNotifierState, false))
        socketEngine->setReadNotificationEnabled(true);
    if (std::exchange(priv->prePauseWriteSocketNotifierState, false))
        socketEngine->setWriteNotificationEnabled(true);
    if (std::exchange(priv->prePauseExceptionSocketNotifierState, false))
        socketEngine->setExceptionNotificationEnabled(true);
}
 
QAbstractSocketEngine* QAbstractSocketPrivate::getSocketEngine(QAbstractSocket *socket)
{
    return socket->d_func()->socketEngine;
}
 
void QAbstractSocketPrivate::setError(QAbstractSocket::SocketError errorCode,
                                      const QString &errStr)
{
    socketError = errorCode;
    errorString = errStr;
}
 
void QAbstractSocketPrivate::setErrorAndEmit(QAbstractSocket::SocketError errorCode,
                                             const QString &errorString)
{
    Q_Q(QAbstractSocket);
    setError(errorCode, errorString);
    emit q->errorOccurred(errorCode);
}
 
QAbstractSocket::QAbstractSocket(SocketType socketType,
                                 QAbstractSocketPrivate &dd, QObject *parent)
    : QIODevice(dd, parent)
{
    Q_D(QAbstractSocket);
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::QAbstractSocket(%sSocket, QAbstractSocketPrivate == %p, parent == %p)",
           socketType == TcpSocket ? "Tcp" : socketType == UdpSocket ? "Udp"
           : socketType == SctpSocket ? "Sctp" : "Unknown", &dd, parent);
#endif
    d->socketType = socketType;
}
 
QAbstractSocket::QAbstractSocket(SocketType socketType, QObject *parent)
    : QAbstractSocket(socketType, *new QAbstractSocketPrivate, parent)
{
}
 
QAbstractSocket::~QAbstractSocket()
{
    Q_D(QAbstractSocket);
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::~QAbstractSocket()");
#endif
    if (d->state != UnconnectedState)
        abort();
}
 
void QAbstractSocket::resume()
{
    QAbstractSocketPrivate::resumeSocketNotifiers(this);
}
 
QAbstractSocket::PauseModes QAbstractSocket::pauseMode() const
{
    return d_func()->pauseMode;
}
 
 
void QAbstractSocket::setPauseMode(PauseModes pauseMode)
{
    d_func()->pauseMode = pauseMode;
}
 
bool QAbstractSocket::bind(const QHostAddress &address, quint16 port, BindMode mode)
{
    Q_D(QAbstractSocket);
    return d->bind(address, port, mode);
}
 
bool QAbstractSocketPrivate::bind(const QHostAddress &address, quint16 port, QAbstractSocket::BindMode mode)
{
    Q_Q(QAbstractSocket);
 
    // now check if the socket engine is initialized and to the right type
    if (!socketEngine || !socketEngine->isValid()) {
        QHostAddress nullAddress;
        resolveProxy(nullAddress.toString(), port);
 
        QAbstractSocket::NetworkLayerProtocol protocol = address.protocol();
        if (protocol == QAbstractSocket::UnknownNetworkLayerProtocol)
            protocol = nullAddress.protocol();
 
        if (!initSocketLayer(protocol))
            return false;
    }
 
    if (mode != QAbstractSocket::DefaultForPlatform) {
#ifdef Q_OS_UNIX
    if ((mode & QAbstractSocket::ShareAddress) || (mode & QAbstractSocket::ReuseAddressHint))
        socketEngine->setOption(QAbstractSocketEngine::AddressReusable, 1);
    else
        socketEngine->setOption(QAbstractSocketEngine::AddressReusable, 0);
#endif
#ifdef Q_OS_WIN
    if (mode & QAbstractSocket::ReuseAddressHint)
        socketEngine->setOption(QAbstractSocketEngine::AddressReusable, 1);
    else
        socketEngine->setOption(QAbstractSocketEngine::AddressReusable, 0);
    if (mode & QAbstractSocket::DontShareAddress)
        socketEngine->setOption(QAbstractSocketEngine::BindExclusively, 1);
    else
        socketEngine->setOption(QAbstractSocketEngine::BindExclusively, 0);
#endif
    }
    bool result = socketEngine->bind(address, port);
    cachedSocketDescriptor = socketEngine->socketDescriptor();
 
    if (!result) {
        setErrorAndEmit(socketEngine->error(), socketEngine->errorString());
        return false;
    }
 
    state = QAbstractSocket::BoundState;
    localAddress = socketEngine->localAddress();
    localPort = socketEngine->localPort();
 
    emit q->stateChanged(state);
    // A slot attached to stateChanged() signal can break our invariant:
    // by closing the socket it will reset its socket engine - thus we
    // have additional check (isValid()) ...
    if (q->isValid() && socketType == QAbstractSocket::UdpSocket)
        socketEngine->setReadNotificationEnabled(true);
    return true;
}
 
#if QT_VERSION < QT_VERSION_CHECK(7, 0, 0)
bool QAbstractSocket::bind(quint16 port, BindMode mode)
{
    return bind(QHostAddress::Any, port, mode);
}
#endif
 
bool QAbstractSocket::isValid() const
{
    return d_func()->socketEngine ? d_func()->socketEngine->isValid() : isOpen();
}
 
void QAbstractSocket::connectToHost(const QString &hostName, quint16 port,
                                    OpenMode openMode,
                                    NetworkLayerProtocol protocol)
{
    Q_D(QAbstractSocket);
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::connectToHost(\"%s\", %i, %i)...", qPrintable(hostName), port,
           (int) openMode);
#endif
 
    if (d->state == ConnectedState || d->state == ConnectingState
        || d->state == ClosingState || d->state == HostLookupState) {
        qWarning("QAbstractSocket::connectToHost() called when already looking up or connecting/connected to \"%s\"", qPrintable(hostName));
        d->setErrorAndEmit(OperationError, tr("Trying to connect while connection is in progress"));
        return;
    }
 
    d->preferredNetworkLayerProtocol = protocol;
    d->hostName = hostName;
    d->port = port;
    d->setReadChannelCount(0);
    d->setWriteChannelCount(0);
    d->abortCalled = false;
    d->pendingClose = false;
    if (d->state != BoundState) {
        d->state = UnconnectedState;
        d->localPort = 0;
        d->localAddress.clear();
    }
    d->peerPort = 0;
    d->peerAddress.clear();
    d->peerName = hostName;
    if (d->hostLookupId != -1) {
        QHostInfo::abortHostLookup(d->hostLookupId);
        d->hostLookupId = -1;
    }
 
#ifndef QT_NO_NETWORKPROXY
    // Get the proxy information
    d->resolveProxy(hostName, port);
    if (d->proxyInUse.type() == QNetworkProxy::DefaultProxy) {
        // failed to setup the proxy
        d->setErrorAndEmit(UnsupportedSocketOperationError,
                           tr("Operation on socket is not supported"));
        return;
    }
#endif
 
    // Sync up with error string, which open() shall clear.
    d->socketError = UnknownSocketError;
    if (openMode & QIODevice::Unbuffered)
        d->isBuffered = false;
    else if (!d_func()->isBuffered)
        openMode |= QAbstractSocket::Unbuffered;
 
    QIODevice::open(openMode);
    d->readChannelCount = d->writeChannelCount = 0;
 
    d->state = HostLookupState;
    emit stateChanged(d->state);
 
    QHostAddress temp;
    if (temp.setAddress(hostName)) {
        QHostInfo info;
        info.setAddresses(QList<QHostAddress>() << temp);
        d->_q_startConnecting(info);
#ifndef QT_NO_NETWORKPROXY
    } else if (d->proxyInUse.capabilities() & QNetworkProxy::HostNameLookupCapability) {
        // the proxy supports connection by name, so use it
        d->startConnectingByName(hostName);
        return;
#endif
    } else {
        if (d->threadData.loadRelaxed()->hasEventDispatcher()) {
            // this internal API for QHostInfo either immediately gives us the desired
            // QHostInfo from cache or later calls the _q_startConnecting slot.
            bool immediateResultValid = false;
            QHostInfo hostInfo = qt_qhostinfo_lookup(hostName,
                                                     this,
                                                     SLOT(_q_startConnecting(QHostInfo)),
                                                     &immediateResultValid,
                                                     &d->hostLookupId);
            if (immediateResultValid) {
                d->hostLookupId = -1;
                d->_q_startConnecting(hostInfo);
            }
        }
    }
 
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::connectToHost(\"%s\", %i) == %s%s", hostName.toLatin1().constData(), port,
           (d->state == ConnectedState) ? "true" : "false",
           (d->state == ConnectingState || d->state == HostLookupState)
           ? " (connection in progress)" : "");
#endif
}
 
void QAbstractSocket::connectToHost(const QHostAddress &address, quint16 port,
                                    OpenMode openMode)
{
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::connectToHost([%s], %i, %i)...",
           address.toString().toLatin1().constData(), port, (int) openMode);
#endif
    connectToHost(address.toString(), port, openMode);
}
 
qint64 QAbstractSocket::bytesToWrite() const
{
    const qint64 pendingBytes = QIODevice::bytesToWrite();
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::bytesToWrite() == %lld", pendingBytes);
#endif
    return pendingBytes;
}
 
qint64 QAbstractSocket::bytesAvailable() const
{
    Q_D(const QAbstractSocket);
    qint64 available = QIODevice::bytesAvailable();
 
    if (!d->isBuffered && d->socketEngine && d->socketEngine->isValid())
        available += d->socketEngine->bytesAvailable();
 
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::bytesAvailable() == %lld", available);
#endif
    return available;
}
 
quint16 QAbstractSocket::localPort() const
{
    Q_D(const QAbstractSocket);
    return d->localPort;
}
 
QHostAddress QAbstractSocket::localAddress() const
{
    Q_D(const QAbstractSocket);
    return d->localAddress;
}
 
quint16 QAbstractSocket::peerPort() const
{
    Q_D(const QAbstractSocket);
    return d->peerPort;
}
 
QHostAddress QAbstractSocket::peerAddress() const
{
    Q_D(const QAbstractSocket);
    return d->peerAddress;
}
 
QString QAbstractSocket::peerName() const
{
    Q_D(const QAbstractSocket);
    return d->peerName.isEmpty() ? d->hostName : d->peerName;
}
 
qintptr QAbstractSocket::socketDescriptor() const
{
    Q_D(const QAbstractSocket);
    return d->cachedSocketDescriptor;
}
 
bool QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, SocketState socketState,
                                          OpenMode openMode)
{
    Q_D(QAbstractSocket);
 
    d->resetSocketLayer();
    d->setReadChannelCount(0);
    d->setWriteChannelCount(0);
    d->socketEngine = QAbstractSocketEngine::createSocketEngine(socketDescriptor, this);
    if (!d->socketEngine) {
        d->setError(UnsupportedSocketOperationError, tr("Operation on socket is not supported"));
        return false;
    }
    bool result = d->socketEngine->initialize(socketDescriptor, socketState);
    if (!result) {
        d->setError(d->socketEngine->error(), d->socketEngine->errorString());
        return false;
    }
 
    // Sync up with error string, which open() shall clear.
    d->socketError = UnknownSocketError;
    if (d->threadData.loadRelaxed()->hasEventDispatcher())
        d->socketEngine->setReceiver(d);
 
    QIODevice::open(openMode);
 
    if (socketState == ConnectedState) {
        if (isReadable()) {
            const int inboundStreamCount = d->socketEngine->inboundStreamCount();
            d->setReadChannelCount(qMax(1, inboundStreamCount));
            if (inboundStreamCount == 0)
                d->readChannelCount = 0;
        }
        if (isWritable()) {
            const int outboundStreamCount = d->socketEngine->outboundStreamCount();
            d->setWriteChannelCount(qMax(1, outboundStreamCount));
            if (outboundStreamCount == 0)
                d->writeChannelCount = 0;
        }
    } else {
        d->readChannelCount = d->writeChannelCount = 0;
    }
 
    if (d->state != socketState) {
        d->state = socketState;
        emit stateChanged(d->state);
    }
 
    d->pendingClose = false;
    d->socketEngine->setReadNotificationEnabled(true);
    d->localPort = d->socketEngine->localPort();
    d->peerPort = d->socketEngine->peerPort();
    d->localAddress = d->socketEngine->localAddress();
    d->peerAddress = d->socketEngine->peerAddress();
    d->cachedSocketDescriptor = socketDescriptor;
 
    return true;
}
 
void QAbstractSocket::setSocketOption(QAbstractSocket::SocketOption option, const QVariant &value)
{
    if (!d_func()->socketEngine)
        return;
 
    switch (option) {
        case LowDelayOption:
            d_func()->socketEngine->setOption(QAbstractSocketEngine::LowDelayOption, value.toInt());
            break;
 
        case KeepAliveOption:
            d_func()->socketEngine->setOption(QAbstractSocketEngine::KeepAliveOption, value.toInt());
            break;
 
        case MulticastTtlOption:
                d_func()->socketEngine->setOption(QAbstractSocketEngine::MulticastTtlOption, value.toInt());
                break;
 
        case MulticastLoopbackOption:
                d_func()->socketEngine->setOption(QAbstractSocketEngine::MulticastLoopbackOption, value.toInt());
                break;
 
        case TypeOfServiceOption:
            d_func()->socketEngine->setOption(QAbstractSocketEngine::TypeOfServiceOption, value.toInt());
            break;
 
        case SendBufferSizeSocketOption:
            d_func()->socketEngine->setOption(QAbstractSocketEngine::SendBufferSocketOption, value.toInt());
            break;
 
        case ReceiveBufferSizeSocketOption:
            d_func()->socketEngine->setOption(QAbstractSocketEngine::ReceiveBufferSocketOption, value.toInt());
            break;
 
        case PathMtuSocketOption:
            d_func()->socketEngine->setOption(QAbstractSocketEngine::PathMtuInformation, value.toInt());
            break;
    }
}
 
QVariant QAbstractSocket::socketOption(QAbstractSocket::SocketOption option)
{
    if (!d_func()->socketEngine)
        return QVariant();
 
    int ret = -1;
    switch (option) {
        case LowDelayOption:
            ret = d_func()->socketEngine->option(QAbstractSocketEngine::LowDelayOption);
            break;
 
        case KeepAliveOption:
            ret = d_func()->socketEngine->option(QAbstractSocketEngine::KeepAliveOption);
            break;
 
        case MulticastTtlOption:
                ret = d_func()->socketEngine->option(QAbstractSocketEngine::MulticastTtlOption);
                break;
        case MulticastLoopbackOption:
                ret = d_func()->socketEngine->option(QAbstractSocketEngine::MulticastLoopbackOption);
                break;
 
        case TypeOfServiceOption:
                ret = d_func()->socketEngine->option(QAbstractSocketEngine::TypeOfServiceOption);
                break;
 
        case SendBufferSizeSocketOption:
                ret = d_func()->socketEngine->option(QAbstractSocketEngine::SendBufferSocketOption);
                break;
 
        case ReceiveBufferSizeSocketOption:
                ret = d_func()->socketEngine->option(QAbstractSocketEngine::ReceiveBufferSocketOption);
                break;
 
        case PathMtuSocketOption:
                ret = d_func()->socketEngine->option(QAbstractSocketEngine::PathMtuInformation);
                break;
    }
    if (ret == -1)
        return QVariant();
    else
        return QVariant(ret);
}
 
bool QAbstractSocket::waitForConnected(int msecs)
{
    Q_D(QAbstractSocket);
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::waitForConnected(%i)", msecs);
#endif
 
    if (state() == ConnectedState) {
#if defined (QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::waitForConnected(%i) already connected", msecs);
#endif
        return true;
    }
 
    bool wasPendingClose = d->pendingClose;
    d->pendingClose = false;
    QElapsedTimer stopWatch;
    stopWatch.start();
 
    if (d->state == HostLookupState) {
#if defined (QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::waitForConnected(%i) doing host name lookup", msecs);
#endif
        QHostInfo::abortHostLookup(d->hostLookupId);
        d->hostLookupId = -1;
        QHostAddress temp;
        if (temp.setAddress(d->hostName)) {
            QHostInfo info;
            info.setAddresses(QList<QHostAddress>() << temp);
            d->_q_startConnecting(info);
        } else {
            d->_q_startConnecting(QHostInfo::fromName(d->hostName));
        }
    }
    if (state() == UnconnectedState)
        return false; // connect not im progress anymore!
 
    int connectTimeout = DefaultConnectTimeout;
    bool timedOut = true;
#if defined (QABSTRACTSOCKET_DEBUG)
    int attempt = 1;
#endif
    while (state() == ConnectingState && (msecs == -1 || stopWatch.elapsed() < msecs)) {
        int timeout = qt_subtract_from_timeout(msecs, stopWatch.elapsed());
        if (msecs != -1 && timeout > connectTimeout)
            timeout = connectTimeout;
#if defined (QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::waitForConnected(%i) waiting %.2f secs for connection attempt #%i",
               msecs, timeout / 1000.0, attempt++);
#endif
        timedOut = false;
 
        if (d->socketEngine && d->socketEngine->waitForWrite(timeout, &timedOut) && !timedOut) {
            d->_q_testConnection();
        } else {
            d->_q_connectToNextAddress();
        }
    }
 
    if ((timedOut && state() != ConnectedState) || state() == ConnectingState) {
        d->setError(SocketTimeoutError, tr("Socket operation timed out"));
        d->state = UnconnectedState;
        emit stateChanged(d->state);
        d->resetSocketLayer();
    }
 
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::waitForConnected(%i) == %s", msecs,
           state() == ConnectedState ? "true" : "false");
#endif
    if (state() != ConnectedState)
        return false;
    if (wasPendingClose)
        disconnectFromHost();
    return true;
}
 
bool QAbstractSocket::waitForReadyRead(int msecs)
{
    Q_D(QAbstractSocket);
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::waitForReadyRead(%i)", msecs);
#endif
 
    // require calling connectToHost() before waitForReadyRead()
    if (state() == UnconnectedState) {
        /* If all you have is a QIODevice pointer to an abstractsocket, you cannot check
           this, so you cannot avoid this warning. */
//        qWarning("QAbstractSocket::waitForReadyRead() is not allowed in UnconnectedState");
        return false;
    }
 
    QElapsedTimer stopWatch;
    stopWatch.start();
 
    // handle a socket in connecting state
    if (state() == HostLookupState || state() == ConnectingState) {
        if (!waitForConnected(msecs))
            return false;
    }
 
    do {
        if (state() != ConnectedState && state() != BoundState)
            return false;
        Q_ASSERT(d->socketEngine);
 
        bool readyToRead = false;
        bool readyToWrite = false;
        if (!d->socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite, true, !d->writeBuffer.isEmpty(),
                                               qt_subtract_from_timeout(msecs, stopWatch.elapsed()))) {
#if defined (QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::waitForReadyRead(%i) failed (%i, %s)",
                   msecs, d->socketEngine->error(), d->socketEngine->errorString().toLatin1().constData());
#endif
            d->setErrorAndEmit(d->socketEngine->error(), d->socketEngine->errorString());
            if (d->socketError != SocketTimeoutError)
                close();
            return false;
        }
 
        if (readyToRead) {
            if (d->canReadNotification())
                return true;
        }
 
        if (readyToWrite)
            d->canWriteNotification();
    } while (msecs == -1 || qt_subtract_from_timeout(msecs, stopWatch.elapsed()) > 0);
    return false;
}
 
bool QAbstractSocket::waitForBytesWritten(int msecs)
{
    Q_D(QAbstractSocket);
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::waitForBytesWritten(%i)", msecs);
#endif
 
    // require calling connectToHost() before waitForBytesWritten()
    if (state() == UnconnectedState) {
        qWarning("QAbstractSocket::waitForBytesWritten() is not allowed in UnconnectedState");
        return false;
    }
 
    if (d->writeBuffer.isEmpty())
        return false;
 
    QElapsedTimer stopWatch;
    stopWatch.start();
 
    // handle a socket in connecting state
    if (state() == HostLookupState || state() == ConnectingState) {
        if (!waitForConnected(msecs))
            return false;
    }
 
    forever {
        bool readyToRead = false;
        bool readyToWrite = false;
        if (!d->socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite,
                                  !d->readBufferMaxSize || d->buffer.size() < d->readBufferMaxSize,
                                  !d->writeBuffer.isEmpty(),
                                  qt_subtract_from_timeout(msecs, stopWatch.elapsed()))) {
#if defined (QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::waitForBytesWritten(%i) failed (%i, %s)",
                   msecs, d->socketEngine->error(), d->socketEngine->errorString().toLatin1().constData());
#endif
            d->setErrorAndEmit(d->socketEngine->error(), d->socketEngine->errorString());
            if (d->socketError != SocketTimeoutError)
                close();
            return false;
        }
 
        if (readyToRead) {
#if defined (QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::waitForBytesWritten calls canReadNotification");
#endif
            d->canReadNotification();
        }
 
 
        if (readyToWrite) {
            if (d->canWriteNotification()) {
#if defined (QABSTRACTSOCKET_DEBUG)
                qDebug("QAbstractSocket::waitForBytesWritten returns true");
#endif
                return true;
            }
        }
 
        if (state() != ConnectedState)
            return false;
    }
    return false;
}
 
bool QAbstractSocket::waitForDisconnected(int msecs)
{
    Q_D(QAbstractSocket);
 
    // require calling connectToHost() before waitForDisconnected()
    if (state() == UnconnectedState) {
        qWarning("QAbstractSocket::waitForDisconnected() is not allowed in UnconnectedState");
        return false;
    }
 
    QElapsedTimer stopWatch;
    stopWatch.start();
 
    // handle a socket in connecting state
    if (state() == HostLookupState || state() == ConnectingState) {
        if (!waitForConnected(msecs))
            return false;
        if (state() == UnconnectedState)
            return true;
    }
 
    forever {
        bool readyToRead = false;
        bool readyToWrite = false;
        if (!d->socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite, state() == ConnectedState,
                                               !d->writeBuffer.isEmpty(),
                                               qt_subtract_from_timeout(msecs, stopWatch.elapsed()))) {
#if defined (QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::waitForReadyRead(%i) failed (%i, %s)",
                   msecs, d->socketEngine->error(), d->socketEngine->errorString().toLatin1().constData());
#endif
            d->setErrorAndEmit(d->socketEngine->error(), d->socketEngine->errorString());
            if (d->socketError != SocketTimeoutError)
                close();
            return false;
        }
 
        if (readyToRead)
            d->canReadNotification();
        if (readyToWrite)
            d->canWriteNotification();
 
        if (state() == UnconnectedState)
            return true;
    }
    return false;
}
 
void QAbstractSocket::abort()
{
    Q_D(QAbstractSocket);
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::abort()");
#endif
    d->setWriteChannelCount(0);
    d->abortCalled = true;
    close();
}
 
bool QAbstractSocket::isSequential() const
{
    return true;
}
 
bool QAbstractSocket::flush()
{
    return d_func()->flush();
}
 
qint64 QAbstractSocket::readData(char *data, qint64 maxSize)
{
    Q_D(QAbstractSocket);
 
    // if we're not connected, return -1 indicating EOF
    if (!d->socketEngine || !d->socketEngine->isValid() || d->state != QAbstractSocket::ConnectedState)
        return maxSize ? qint64(-1) : qint64(0);
 
    qint64 readBytes = (maxSize && !d->isBuffered) ? d->socketEngine->read(data, maxSize)
                                                   : qint64(0);
    if (readBytes == -2) {
        // -2 from the engine means no bytes available (EAGAIN) so read more later
        readBytes = 0;
    }
    if (readBytes < 0) {
        d->setError(d->socketEngine->error(), d->socketEngine->errorString());
        d->resetSocketLayer();
        d->state = QAbstractSocket::UnconnectedState;
    } else {
        // Only do this when there was no error
        d->hasPendingData = false;
        d->socketEngine->setReadNotificationEnabled(true);
    }
 
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::readData(%p \"%s\", %lli) == %lld [engine]", data,
           QtDebugUtils::toPrintable(data, readBytes, 32).constData(), maxSize, readBytes);
#endif
    return readBytes;
}
 
qint64 QAbstractSocket::readLineData(char *data, qint64 maxlen)
{
    return QIODevice::readLineData(data, maxlen);
}
 
qint64 QAbstractSocket::writeData(const char *data, qint64 size)
{
    Q_D(QAbstractSocket);
    if (d->state == QAbstractSocket::UnconnectedState
        || (!d->socketEngine && d->socketType != TcpSocket && !d->isBuffered)) {
        d->setError(UnknownSocketError, tr("Socket is not connected"));
        return -1;
    }
 
    if (!d->isBuffered && d->socketType == TcpSocket
        && d->socketEngine && d->writeBuffer.isEmpty()) {
        // This code is for the new Unbuffered QTcpSocket use case
        qint64 written = size ? d->socketEngine->write(data, size) : Q_INT64_C(0);
        if (written < 0) {
            d->setError(d->socketEngine->error(), d->socketEngine->errorString());
        } else if (written < size) {
            // Buffer what was not written yet
            d->writeBuffer.append(data + written, size - written);
            written = size;
            d->socketEngine->setWriteNotificationEnabled(true);
        }
 
#if defined (QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::writeData(%p \"%s\", %lli) == %lli", data,
               QtDebugUtils::toPrintable(data, size, 32).constData(), size, written);
#endif
        return written; // written = actually written + what has been buffered
    } else if (!d->isBuffered && d->socketType != TcpSocket) {
        // This is for a QUdpSocket that was connect()ed
        qint64 written = d->socketEngine->write(data, size);
        if (written < 0)
            d->setError(d->socketEngine->error(), d->socketEngine->errorString());
 
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::writeData(%p \"%s\", %lli) == %lli", data,
           QtDebugUtils::toPrintable(data, size, 32).constData(), size, written);
#endif
        if (written >= 0)
            d->emitBytesWritten(written);
        return written;
    }
 
    // This is the code path for normal buffered QTcpSocket or
    // unbuffered QTcpSocket when there was already something in the
    // write buffer and therefore we could not do a direct engine write.
    // We just write to our write buffer and enable the write notifier
    // The write notifier then flush()es the buffer.
 
    d->write(data, size);
    qint64 written = size;
 
    if (d->socketEngine && !d->writeBuffer.isEmpty())
        d->socketEngine->setWriteNotificationEnabled(true);
 
#if defined (QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::writeData(%p \"%s\", %lli) == %lli", data,
           QtDebugUtils::toPrintable(data, size, 32).constData(), size, written);
#endif
    return written;
}
 
void QAbstractSocket::setLocalPort(quint16 port)
{
    Q_D(QAbstractSocket);
    d->localPort = port;
}
 
void QAbstractSocket::setLocalAddress(const QHostAddress &address)
{
    Q_D(QAbstractSocket);
    d->localAddress = address;
}
 
void QAbstractSocket::setPeerPort(quint16 port)
{
    Q_D(QAbstractSocket);
    d->peerPort = port;
}
 
void QAbstractSocket::setPeerAddress(const QHostAddress &address)
{
    Q_D(QAbstractSocket);
    d->peerAddress = address;
}
 
void QAbstractSocket::setPeerName(const QString &name)
{
    Q_D(QAbstractSocket);
    d->peerName = name;
}
 
void QAbstractSocket::close()
{
    Q_D(QAbstractSocket);
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::close()");
#endif
    QIODevice::close();
    if (d->state != UnconnectedState)
        disconnectFromHost();
}
 
void QAbstractSocket::disconnectFromHost()
{
    Q_D(QAbstractSocket);
#if defined(QABSTRACTSOCKET_DEBUG)
    qDebug("QAbstractSocket::disconnectFromHost()");
#endif
 
    if (d->state == UnconnectedState) {
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::disconnectFromHost() was called on an unconnected socket");
#endif
        return;
    }
 
    if (!d->abortCalled && (d->state == ConnectingState || d->state == HostLookupState)) {
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::disconnectFromHost() but we're still connecting");
#endif
        d->pendingClose = true;
        return;
    }
 
    // Disable and delete read notification
    if (d->socketEngine)
        d->socketEngine->setReadNotificationEnabled(false);
 
    if (d->abortCalled) {
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::disconnectFromHost() aborting immediately");
#endif
        if (d->state == HostLookupState) {
            QHostInfo::abortHostLookup(d->hostLookupId);
            d->hostLookupId = -1;
        }
    } else {
        // Perhaps emit closing()
        if (d->state != ClosingState) {
            d->state = ClosingState;
#if defined(QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::disconnectFromHost() emits stateChanged()(ClosingState)");
#endif
            emit stateChanged(d->state);
        } else {
#if defined(QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::disconnectFromHost() return from delayed close");
#endif
        }
 
        // Wait for pending data to be written.
        if (d->socketEngine && d->socketEngine->isValid() && (!d->allWriteBuffersEmpty()
            || d->socketEngine->bytesToWrite() > 0)) {
            d->socketEngine->setWriteNotificationEnabled(true);
 
#if defined(QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::disconnectFromHost() delaying disconnect");
#endif
            return;
        } else {
#if defined(QABSTRACTSOCKET_DEBUG)
            qDebug("QAbstractSocket::disconnectFromHost() disconnecting immediately");
#endif
        }
    }
 
    SocketState previousState = d->state;
    d->resetSocketLayer();
    d->state = UnconnectedState;
    emit stateChanged(d->state);
    emit readChannelFinished();       // we got an EOF
 
    // only emit disconnected if we were connected before
    if (previousState == ConnectedState || previousState == ClosingState)
        emit disconnected();
 
    d->localPort = 0;
    d->peerPort = 0;
    d->localAddress.clear();
    d->peerAddress.clear();
    d->peerName.clear();
    d->setWriteChannelCount(0);
 
#if defined(QABSTRACTSOCKET_DEBUG)
        qDebug("QAbstractSocket::disconnectFromHost() disconnected!");
#endif
 
}
 
qint64 QAbstractSocket::readBufferSize() const
{
    return d_func()->readBufferMaxSize;
}
 
void QAbstractSocket::setReadBufferSize(qint64 size)
{
    Q_D(QAbstractSocket);
 
    if (d->readBufferMaxSize == size)
        return;
    d->readBufferMaxSize = size;
 
    // Do not change the notifier unless we are connected.
    if (d->socketEngine && d->state == QAbstractSocket::ConnectedState) {
        // Ensure that the read notification is enabled if we've now got
        // room in the read buffer.
        d->socketEngine->setReadNotificationEnabled(size == 0 || d->buffer.size() < size);
    }
}
 
QAbstractSocket::SocketState QAbstractSocket::state() const
{
    return d_func()->state;
}
 
void QAbstractSocket::setSocketState(SocketState state)
{
    d_func()->state = state;
}
 
QAbstractSocket::SocketType QAbstractSocket::socketType() const
{
    return d_func()->socketType;
}
 
QAbstractSocket::SocketError QAbstractSocket::error() const
{
    return d_func()->socketError;
}
 
void QAbstractSocket::setSocketError(SocketError socketError)
{
    d_func()->socketError = socketError;
}
 
#ifndef QT_NO_NETWORKPROXY
void QAbstractSocket::setProxy(const QNetworkProxy &networkProxy)
{
    Q_D(QAbstractSocket);
    d->proxy = networkProxy;
}
 
QNetworkProxy QAbstractSocket::proxy() const
{
    Q_D(const QAbstractSocket);
    return d->proxy;
}
 
QString QAbstractSocket::protocolTag() const
{
    Q_D(const QAbstractSocket);
    return d->protocolTag;
}
 
void QAbstractSocket::setProtocolTag(const QString &tag)
{
    Q_D(QAbstractSocket);
    d->protocolTag = tag;
}
 
#endif // QT_NO_NETWORKPROXY
 
#ifndef QT_NO_DEBUG_STREAM
Q_NETWORK_EXPORT QDebug operator<<(QDebug debug, QAbstractSocket::SocketError error)
{
    QDebugStateSaver saver(debug);
    debug.resetFormat().nospace();
    switch (error) {
    case QAbstractSocket::ConnectionRefusedError:
        debug << "QAbstractSocket::ConnectionRefusedError";
        break;
    case QAbstractSocket::RemoteHostClosedError:
        debug << "QAbstractSocket::RemoteHostClosedError";
        break;
    case QAbstractSocket::HostNotFoundError:
        debug << "QAbstractSocket::HostNotFoundError";
        break;
    case QAbstractSocket::SocketAccessError:
        debug << "QAbstractSocket::SocketAccessError";
        break;
    case QAbstractSocket::SocketResourceError:
        debug << "QAbstractSocket::SocketResourceError";
        break;
    case QAbstractSocket::SocketTimeoutError:
        debug << "QAbstractSocket::SocketTimeoutError";
        break;
    case QAbstractSocket::DatagramTooLargeError:
        debug << "QAbstractSocket::DatagramTooLargeError";
        break;
    case QAbstractSocket::NetworkError:
        debug << "QAbstractSocket::NetworkError";
        break;
    case QAbstractSocket::AddressInUseError:
        debug << "QAbstractSocket::AddressInUseError";
        break;
    case QAbstractSocket::SocketAddressNotAvailableError:
        debug << "QAbstractSocket::SocketAddressNotAvailableError";
        break;
    case QAbstractSocket::UnsupportedSocketOperationError:
        debug << "QAbstractSocket::UnsupportedSocketOperationError";
        break;
    case QAbstractSocket::UnfinishedSocketOperationError:
        debug << "QAbstractSocket::UnfinishedSocketOperationError";
        break;
    case QAbstractSocket::ProxyAuthenticationRequiredError:
        debug << "QAbstractSocket::ProxyAuthenticationRequiredError";
        break;
    case QAbstractSocket::UnknownSocketError:
        debug << "QAbstractSocket::UnknownSocketError";
        break;
    case QAbstractSocket::ProxyConnectionRefusedError:
        debug << "QAbstractSocket::ProxyConnectionRefusedError";
        break;
    case QAbstractSocket::ProxyConnectionClosedError:
        debug << "QAbstractSocket::ProxyConnectionClosedError";
        break;
    case QAbstractSocket::ProxyConnectionTimeoutError:
        debug << "QAbstractSocket::ProxyConnectionTimeoutError";
        break;
    case QAbstractSocket::ProxyNotFoundError:
        debug << "QAbstractSocket::ProxyNotFoundError";
        break;
    case QAbstractSocket::ProxyProtocolError:
        debug << "QAbstractSocket::ProxyProtocolError";
        break;
    default:
        debug << "QAbstractSocket::SocketError(" << int(error) << ')';
        break;
    }
    return debug;
}
 
Q_NETWORK_EXPORT QDebug operator<<(QDebug debug, QAbstractSocket::SocketState state)
{
    QDebugStateSaver saver(debug);
    debug.resetFormat().nospace();
    switch (state) {
    case QAbstractSocket::UnconnectedState:
        debug << "QAbstractSocket::UnconnectedState";
        break;
    case QAbstractSocket::HostLookupState:
        debug << "QAbstractSocket::HostLookupState";
        break;
    case QAbstractSocket::ConnectingState:
        debug << "QAbstractSocket::ConnectingState";
        break;
    case QAbstractSocket::ConnectedState:
        debug << "QAbstractSocket::ConnectedState";
        break;
    case QAbstractSocket::BoundState:
        debug << "QAbstractSocket::BoundState";
        break;
    case QAbstractSocket::ListeningState:
        debug << "QAbstractSocket::ListeningState";
        break;
    case QAbstractSocket::ClosingState:
        debug << "QAbstractSocket::ClosingState";
        break;
    default:
        debug << "QAbstractSocket::SocketState(" << int(state) << ')';
        break;
    }
    return debug;
}
#endif
 
QT_END_NAMESPACE
 
#include "moc_qabstractsocket.cpp"