qudpsocket.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
//#define QUDPSOCKET_DEBUG
 
#include "qudpsocket.h"
#include "qhostaddress.h"
#include "qnetworkdatagram.h"
#include "qnetworkinterface.h"
#include "qabstractsocket_p.h"
 
QT_BEGIN_NAMESPACE
 
#ifndef QT_NO_UDPSOCKET
 
#define QT_CHECK_BOUND(function, a) do { \
    if (!isValid()) { \
        qWarning(function" called on a QUdpSocket when not in QUdpSocket::BoundState"); \
        return (a); \
    } } while (0)
 
class QUdpSocketPrivate : public QAbstractSocketPrivate
{
    Q_DECLARE_PUBLIC(QUdpSocket)
 
    bool doEnsureInitialized(const QHostAddress &bindAddress, quint16 bindPort,
                             const QHostAddress &remoteAddress);
public:
    inline bool ensureInitialized(const QHostAddress &bindAddress, quint16 bindPort)
    { return doEnsureInitialized(bindAddress, bindPort, QHostAddress()); }
 
    inline bool ensureInitialized(const QHostAddress &remoteAddress)
    { return doEnsureInitialized(QHostAddress(), 0, remoteAddress); }
};
 
bool QUdpSocketPrivate::doEnsureInitialized(const QHostAddress &bindAddress, quint16 bindPort,
                                            const QHostAddress &remoteAddress)
{
    const QHostAddress *address = &bindAddress;
    QAbstractSocket::NetworkLayerProtocol proto = address->protocol();
    if (proto == QUdpSocket::UnknownNetworkLayerProtocol) {
        address = &remoteAddress;
        proto = address->protocol();
    }
 
    // now check if the socket engine is initialized and to the right type
    if (!socketEngine || !socketEngine->isValid()) {
        resolveProxy(remoteAddress.toString(), bindPort);
        if (!initSocketLayer(address->protocol()))
            return false;
    }
 
    return true;
}
 
QUdpSocket::QUdpSocket(QObject *parent)
    : QAbstractSocket(UdpSocket, *new QUdpSocketPrivate, parent)
{
    d_func()->isBuffered = false;
}
 
QUdpSocket::~QUdpSocket()
{
}
 
#ifndef QT_NO_NETWORKINTERFACE
 
bool QUdpSocket::joinMulticastGroup(const QHostAddress &groupAddress)
{
    return joinMulticastGroup(groupAddress, QNetworkInterface());
}
 
bool QUdpSocket::joinMulticastGroup(const QHostAddress &groupAddress,
                                    const QNetworkInterface &iface)
{
    Q_D(QUdpSocket);
    QT_CHECK_BOUND("QUdpSocket::joinMulticastGroup()", false);
    return d->socketEngine->joinMulticastGroup(groupAddress, iface);
}
 
bool QUdpSocket::leaveMulticastGroup(const QHostAddress &groupAddress)
{
    return leaveMulticastGroup(groupAddress, QNetworkInterface());
}
 
bool QUdpSocket::leaveMulticastGroup(const QHostAddress &groupAddress,
                                     const QNetworkInterface &iface)
{
    QT_CHECK_BOUND("QUdpSocket::leaveMulticastGroup()", false);
    return d_func()->socketEngine->leaveMulticastGroup(groupAddress, iface);
}
 
QNetworkInterface QUdpSocket::multicastInterface() const
{
    Q_D(const QUdpSocket);
    QT_CHECK_BOUND("QUdpSocket::multicastInterface()", QNetworkInterface());
    return d->socketEngine->multicastInterface();
}
 
void QUdpSocket::setMulticastInterface(const QNetworkInterface &iface)
{
    Q_D(QUdpSocket);
    if (!isValid()) {
        qWarning("QUdpSocket::setMulticastInterface() called on a QUdpSocket when not in QUdpSocket::BoundState");
        return;
    }
    d->socketEngine->setMulticastInterface(iface);
}
 
#endif // QT_NO_NETWORKINTERFACE
 
bool QUdpSocket::hasPendingDatagrams() const
{
    QT_CHECK_BOUND("QUdpSocket::hasPendingDatagrams()", false);
    return d_func()->socketEngine->hasPendingDatagrams();
}
 
qint64 QUdpSocket::pendingDatagramSize() const
{
    QT_CHECK_BOUND("QUdpSocket::pendingDatagramSize()", -1);
    return d_func()->socketEngine->pendingDatagramSize();
}
 
qint64 QUdpSocket::writeDatagram(const char *data, qint64 size, const QHostAddress &address,
                                  quint16 port)
{
    Q_D(QUdpSocket);
#if defined QUDPSOCKET_DEBUG
    qDebug("QUdpSocket::writeDatagram(%p, %llu, \"%s\", %i)", data, size,
           address.toString().toLatin1().constData(), port);
#endif
    if (!d->doEnsureInitialized(QHostAddress::Any, 0, address))
        return -1;
    if (state() == UnconnectedState)
        bind();
 
    qint64 sent = d->socketEngine->writeDatagram(data, size, QIpPacketHeader(address, port));
    d->cachedSocketDescriptor = d->socketEngine->socketDescriptor();
 
    if (sent >= 0) {
        emit bytesWritten(sent);
    } else {
        if (sent == -2) {
            // Socket engine reports EAGAIN. Treat as a temporary error.
            d->setErrorAndEmit(QAbstractSocket::TemporaryError,
                               tr("Unable to send a datagram"));
            return -1;
        }
        d->setErrorAndEmit(d->socketEngine->error(), d->socketEngine->errorString());
    }
    return sent;
}
 
qint64 QUdpSocket::writeDatagram(const QNetworkDatagram &datagram)
{
    Q_D(QUdpSocket);
#if defined QUDPSOCKET_DEBUG
    qDebug("QUdpSocket::writeDatagram(%p, %i, \"%s\", %i)",
           datagram.d->data.constData(),
           datagram.d->data.size(),
           datagram.destinationAddress().toString().toLatin1().constData(),
           datagram.destinationPort());
#endif
    if (!d->doEnsureInitialized(QHostAddress::Any, 0, datagram.destinationAddress()))
        return -1;
    if (state() == UnconnectedState)
        bind();
 
    qint64 sent = d->socketEngine->writeDatagram(datagram.d->data.constData(),
                                                 datagram.d->data.size(),
                                                 datagram.d->header);
    d->cachedSocketDescriptor = d->socketEngine->socketDescriptor();
 
    if (sent >= 0) {
        emit bytesWritten(sent);
    } else {
        d->setErrorAndEmit(d->socketEngine->error(), d->socketEngine->errorString());
    }
    return sent;
}
 
QNetworkDatagram QUdpSocket::receiveDatagram(qint64 maxSize)
{
    Q_D(QUdpSocket);
 
#if defined QUDPSOCKET_DEBUG
    qDebug("QUdpSocket::receiveDatagram(%lld)", maxSize);
#endif
    QT_CHECK_BOUND("QUdpSocket::receiveDatagram()", QNetworkDatagram());
 
    if (maxSize < 0)
        maxSize = d->socketEngine->pendingDatagramSize();
    if (maxSize < 0)
        return QNetworkDatagram();
 
    QNetworkDatagram result(QByteArray(maxSize, Qt::Uninitialized));
    qint64 readBytes = d->socketEngine->readDatagram(result.d->data.data(), maxSize, &result.d->header,
                                                     QAbstractSocketEngine::WantAll);
    d->hasPendingData = false;
    d->hasPendingDatagram = false;
    d->socketEngine->setReadNotificationEnabled(true);
    if (readBytes < 0) {
        d->setErrorAndEmit(d->socketEngine->error(), d->socketEngine->errorString());
        readBytes = 0;
    }
 
    result.d->data.truncate(readBytes);
    return result;
}
 
qint64 QUdpSocket::readDatagram(char *data, qint64 maxSize, QHostAddress *address,
                                    quint16 *port)
{
    Q_D(QUdpSocket);
 
#if defined QUDPSOCKET_DEBUG
    qDebug("QUdpSocket::readDatagram(%p, %llu, %p, %p)", data, maxSize, address, port);
#endif
    QT_CHECK_BOUND("QUdpSocket::readDatagram()", -1);
 
    qint64 readBytes;
    if (address || port) {
        QIpPacketHeader header;
        readBytes = d->socketEngine->readDatagram(data, maxSize, &header,
                                                  QAbstractSocketEngine::WantDatagramSender);
        if (address)
            *address = header.senderAddress;
        if (port)
            *port = header.senderPort;
    } else {
        readBytes = d->socketEngine->readDatagram(data, maxSize);
    }
 
    d->hasPendingData = false;
    d->hasPendingDatagram = false;
    d->socketEngine->setReadNotificationEnabled(true);
    if (readBytes < 0) {
        if (readBytes == -2) {
            // No pending datagram. Treat as a temporary error.
            d->setErrorAndEmit(QAbstractSocket::TemporaryError,
                               tr("No datagram available for reading"));
            return -1;
        }
        d->setErrorAndEmit(d->socketEngine->error(), d->socketEngine->errorString());
    }
    return readBytes;
}
 
#endif // QT_NO_UDPSOCKET
 
QT_END_NAMESPACE
 
#include "moc_qudpsocket.cpp"