qtcpserver.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
//#define QTCPSERVER_DEBUG
 
#include "qtcpserver.h"
#include "qtcpserver_p.h"
 
#include "qalgorithms.h"
#include "qhostaddress.h"
#include "qlist.h"
#include "qpointer.h"
#include "qabstractsocketengine_p.h"
#include "qtcpsocket.h"
#include "qnetworkproxy.h"
 
QT_BEGIN_NAMESPACE
 
#define Q_CHECK_SOCKETENGINE(returnValue) do { \
    if (!d->socketEngine) { \
        return returnValue; \
    } } while (0)
 
QTcpServerPrivate::QTcpServerPrivate()
 : port(0)
 , socketType(QAbstractSocket::UnknownSocketType)
 , state(QAbstractSocket::UnconnectedState)
 , socketEngine(nullptr)
 , serverSocketError(QAbstractSocket::UnknownSocketError)
 , maxConnections(30)
{
}
 
QTcpServerPrivate::~QTcpServerPrivate()
{
}
 
#ifndef QT_NO_NETWORKPROXY
QNetworkProxy QTcpServerPrivate::resolveProxy(const QHostAddress &address, quint16 port)
{
    if (address.isLoopback())
        return QNetworkProxy::NoProxy;
 
    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(port, QString(),
                                 socketType == QAbstractSocket::SctpSocket ?
                                 QNetworkProxyQuery::SctpServer :
                                 QNetworkProxyQuery::TcpServer);
        proxies = QNetworkProxyFactory::proxyForQuery(query);
    }
 
    // return the first that we can use
    for (const QNetworkProxy &p : std::as_const(proxies)) {
        if (socketType == QAbstractSocket::TcpSocket &&
            (p.capabilities() & QNetworkProxy::ListeningCapability) != 0)
            return p;
 
        if (socketType == QAbstractSocket::SctpSocket &&
            (p.capabilities() & QNetworkProxy::SctpListeningCapability) != 0)
            return p;
    }
 
    // no proxy found
    // DefaultProxy will raise an error
    return QNetworkProxy(QNetworkProxy::DefaultProxy);
}
#endif
 
void QTcpServerPrivate::configureCreatedSocket()
{
#if defined(Q_OS_UNIX)
    // Under Unix, we want to be able to bind to the port, even if a socket on
    // the same address-port is in TIME_WAIT. Under Windows this is possible
    // anyway -- furthermore, the meaning of reusable on Windows is different:
    // it means that you can use the same address-port for multiple listening
    // sockets.
    // Don't abort though if we can't set that option. For example the socks
    // engine doesn't support that option, but that shouldn't prevent us from
    // trying to bind/listen.
    socketEngine->setOption(QAbstractSocketEngine::AddressReusable, 1);
#endif
}
 
void QTcpServerPrivate::readNotification()
{
    Q_Q(QTcpServer);
    for (;;) {
        if (totalPendingConnections() >= maxConnections) {
#if defined (QTCPSERVER_DEBUG)
            qDebug("QTcpServerPrivate::_q_processIncomingConnection() too many connections");
#endif
            if (socketEngine->isReadNotificationEnabled())
                socketEngine->setReadNotificationEnabled(false);
            return;
        }
 
        qintptr descriptor = socketEngine->accept();
        if (descriptor == -1) {
            if (socketEngine->error() != QAbstractSocket::TemporaryError) {
                q->pauseAccepting();
                serverSocketError = socketEngine->error();
                serverSocketErrorString = socketEngine->errorString();
                emit q->acceptError(serverSocketError);
            }
            break;
        }
#if defined (QTCPSERVER_DEBUG)
        qDebug("QTcpServerPrivate::_q_processIncomingConnection() accepted socket %i", descriptor);
#endif
        QPointer<QTcpServer> that = q;
        q->incomingConnection(descriptor);
 
        if (that)
            emit q->newConnection();
 
        if (!that || !q->isListening())
            return;
    }
}
 
int QTcpServerPrivate::totalPendingConnections() const
{
    return int(pendingConnections.size());
}
 
QTcpServer::QTcpServer(QObject *parent)
    : QObject(*new QTcpServerPrivate, parent)
{
    Q_D(QTcpServer);
#if defined(QTCPSERVER_DEBUG)
    qDebug("QTcpServer::QTcpServer(%p)", parent);
#endif
    d->socketType = QAbstractSocket::TcpSocket;
}
 
QTcpServer::~QTcpServer()
{
#if defined(QTCPSERVER_DEBUG)
    qDebug("QTcpServer::~QTcpServer()");
#endif
    close();
}
 
QTcpServer::QTcpServer(QAbstractSocket::SocketType socketType, QTcpServerPrivate &dd,
                       QObject *parent) : QObject(dd, parent)
{
    Q_D(QTcpServer);
#if defined(QTCPSERVER_DEBUG)
    qDebug("QTcpServer::QTcpServer(%sSocket, QTcpServerPrivate == %p, parent == %p)",
           socketType == QAbstractSocket::TcpSocket ? "Tcp"
           : socketType == QAbstractSocket::UdpSocket ? "Udp"
           : socketType == QAbstractSocket::SctpSocket ? "Sctp"
           : "Unknown", &dd, parent);
#endif
    d->socketType = socketType;
}
 
bool QTcpServer::listen(const QHostAddress &address, quint16 port)
{
    Q_D(QTcpServer);
    if (d->state == QAbstractSocket::ListeningState) {
        qWarning("QTcpServer::listen() called when already listening");
        return false;
    }
 
    QAbstractSocket::NetworkLayerProtocol proto = address.protocol();
    QHostAddress addr = address;
 
#ifdef QT_NO_NETWORKPROXY
    static const QNetworkProxy &proxy = *(QNetworkProxy *)0;
#else
    QNetworkProxy proxy = d->resolveProxy(addr, port);
#endif
 
    delete d->socketEngine;
    d->socketEngine = QAbstractSocketEngine::createSocketEngine(d->socketType, proxy, this);
    if (!d->socketEngine) {
        d->serverSocketError = QAbstractSocket::UnsupportedSocketOperationError;
        d->serverSocketErrorString = tr("Operation on socket is not supported");
        return false;
    }
    if (!d->socketEngine->initialize(d->socketType, proto)) {
        d->serverSocketError = d->socketEngine->error();
        d->serverSocketErrorString = d->socketEngine->errorString();
        return false;
    }
    proto = d->socketEngine->protocol();
    if (addr.protocol() == QAbstractSocket::AnyIPProtocol && proto == QAbstractSocket::IPv4Protocol)
        addr = QHostAddress::AnyIPv4;
 
    d->configureCreatedSocket();
 
    if (!d->socketEngine->bind(addr, port)) {
        d->serverSocketError = d->socketEngine->error();
        d->serverSocketErrorString = d->socketEngine->errorString();
        return false;
    }
 
    if (!d->socketEngine->listen(d->listenBacklog)) {
        d->serverSocketError = d->socketEngine->error();
        d->serverSocketErrorString = d->socketEngine->errorString();
        return false;
    }
 
    d->socketEngine->setReceiver(d);
    d->socketEngine->setReadNotificationEnabled(true);
 
    d->state = QAbstractSocket::ListeningState;
    d->address = d->socketEngine->localAddress();
    d->port = d->socketEngine->localPort();
 
#if defined (QTCPSERVER_DEBUG)
    qDebug("QTcpServer::listen(%i, \"%s\") == true (listening on port %i)", port,
           address.toString().toLatin1().constData(), d->socketEngine->localPort());
#endif
    return true;
}
 
bool QTcpServer::isListening() const
{
    Q_D(const QTcpServer);
    Q_CHECK_SOCKETENGINE(false);
    return d->socketEngine->state() == QAbstractSocket::ListeningState;
}
 
void QTcpServer::close()
{
    Q_D(QTcpServer);
 
    qDeleteAll(d->pendingConnections);
    d->pendingConnections.clear();
 
    if (d->socketEngine) {
        d->socketEngine->close();
        QT_TRY {
            d->socketEngine->deleteLater();
        } QT_CATCH(const std::bad_alloc &) {
            // in out of memory situations, the socketEngine
            // will be deleted in ~QTcpServer (it's a child-object of this)
        }
        d->socketEngine = nullptr;
    }
 
    d->state = QAbstractSocket::UnconnectedState;
}
 
qintptr QTcpServer::socketDescriptor() const
{
    Q_D(const QTcpServer);
    Q_CHECK_SOCKETENGINE(-1);
    return d->socketEngine->socketDescriptor();
}
 
bool QTcpServer::setSocketDescriptor(qintptr socketDescriptor)
{
    Q_D(QTcpServer);
    if (isListening()) {
        qWarning("QTcpServer::setSocketDescriptor() called when already listening");
        return false;
    }
 
    if (d->socketEngine)
        delete d->socketEngine;
    d->socketEngine = QAbstractSocketEngine::createSocketEngine(socketDescriptor, this);
    if (!d->socketEngine) {
        d->serverSocketError = QAbstractSocket::UnsupportedSocketOperationError;
        d->serverSocketErrorString = tr("Operation on socket is not supported");
        return false;
    }
    if (!d->socketEngine->initialize(socketDescriptor, QAbstractSocket::ListeningState)) {
        d->serverSocketError = d->socketEngine->error();
        d->serverSocketErrorString = d->socketEngine->errorString();
#if defined (QTCPSERVER_DEBUG)
        qDebug("QTcpServer::setSocketDescriptor(%i) failed (%s)", socketDescriptor,
               d->serverSocketErrorString.toLatin1().constData());
#endif
        return false;
    }
 
    d->socketEngine->setReceiver(d);
    d->socketEngine->setReadNotificationEnabled(true);
 
    d->state = d->socketEngine->state();
    d->address = d->socketEngine->localAddress();
    d->port = d->socketEngine->localPort();
 
#if defined (QTCPSERVER_DEBUG)
    qDebug("QTcpServer::setSocketDescriptor(%i) succeeded.", socketDescriptor);
#endif
    return true;
}
 
quint16 QTcpServer::serverPort() const
{
    Q_D(const QTcpServer);
    Q_CHECK_SOCKETENGINE(0);
    return d->socketEngine->localPort();
}
 
QHostAddress QTcpServer::serverAddress() const
{
    Q_D(const QTcpServer);
    Q_CHECK_SOCKETENGINE(QHostAddress(QHostAddress::Null));
    return d->socketEngine->localAddress();
}
 
bool QTcpServer::waitForNewConnection(int msec, bool *timedOut)
{
    Q_D(QTcpServer);
    if (d->state != QAbstractSocket::ListeningState)
        return false;
 
    if (!d->socketEngine->waitForRead(msec, timedOut)) {
        d->serverSocketError = d->socketEngine->error();
        d->serverSocketErrorString = d->socketEngine->errorString();
        return false;
    }
 
    if (timedOut && *timedOut)
        return false;
 
    d->readNotification();
 
    return true;
}
 
bool QTcpServer::hasPendingConnections() const
{
    return !d_func()->pendingConnections.isEmpty();
}
 
QTcpSocket *QTcpServer::nextPendingConnection()
{
    Q_D(QTcpServer);
    if (d->pendingConnections.isEmpty())
        return nullptr;
 
    if (!d->socketEngine) {
        qWarning("QTcpServer::nextPendingConnection() called while not listening");
    } else if (!d->socketEngine->isReadNotificationEnabled()) {
        d->socketEngine->setReadNotificationEnabled(true);
    }
 
    return d->pendingConnections.takeFirst();
}
 
void QTcpServer::incomingConnection(qintptr socketDescriptor)
{
#if defined (QTCPSERVER_DEBUG)
    qDebug("QTcpServer::incomingConnection(%i)", socketDescriptor);
#endif
 
    QTcpSocket *socket = new QTcpSocket(this);
    socket->setSocketDescriptor(socketDescriptor);
    addPendingConnection(socket);
}
 
void QTcpServer::addPendingConnection(QTcpSocket* socket)
{
    d_func()->pendingConnections.append(socket);
    emit pendingConnectionAvailable(QPrivateSignal());
}
 
void QTcpServer::setMaxPendingConnections(int numConnections)
{
    d_func()->maxConnections = numConnections;
}
 
int QTcpServer::maxPendingConnections() const
{
    return d_func()->maxConnections;
}
 
void QTcpServer::setListenBacklogSize(int size)
{
    d_func()->listenBacklog = size;
}
 
int QTcpServer::listenBacklogSize() const
{
    return d_func()->listenBacklog;
}
 
QAbstractSocket::SocketError QTcpServer::serverError() const
{
    return d_func()->serverSocketError;
}
 
QString QTcpServer::errorString() const
{
    return d_func()->serverSocketErrorString;
}
 
void QTcpServer::pauseAccepting()
{
    d_func()->socketEngine->setReadNotificationEnabled(false);
}
 
void QTcpServer::resumeAccepting()
{
    d_func()->socketEngine->setReadNotificationEnabled(true);
}
 
#ifndef QT_NO_NETWORKPROXY
void QTcpServer::setProxy(const QNetworkProxy &networkProxy)
{
    Q_D(QTcpServer);
    d->proxy = networkProxy;
}
 
QNetworkProxy QTcpServer::proxy() const
{
    Q_D(const QTcpServer);
    return d->proxy;
}
#endif // QT_NO_NETWORKPROXY
 
QT_END_NAMESPACE
 
#include "moc_qtcpserver.cpp"