qnetworkdatagram.cpp

Go to the documentation of this file.

// 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
 
#include "qnetworkdatagram.h"
#include "qnetworkdatagram_p.h"
 
#ifndef QT_NO_UDPSOCKET
 
QT_BEGIN_NAMESPACE
 
QT_IMPL_METATYPE_EXTERN(QNetworkDatagram)
 
 
QNetworkDatagram::QNetworkDatagram()
    : d(new QNetworkDatagramPrivate)
{
}
 
QNetworkDatagram::QNetworkDatagram(const QByteArray &data, const QHostAddress &destinationAddress, quint16 port)
    : d(new QNetworkDatagramPrivate(data, destinationAddress, port))
{
}
 
QNetworkDatagram::QNetworkDatagram(const QNetworkDatagram &other)
    : d(new QNetworkDatagramPrivate(*other.d))
{
}
 
QNetworkDatagram::QNetworkDatagram(QNetworkDatagramPrivate &dd)
    : d(&dd)
{
}
 
QNetworkDatagram &QNetworkDatagram::operator=(const QNetworkDatagram &other)
{
    *d = *other.d;
    return *this;
}
 
void QNetworkDatagram::clear()
{
    d->data.clear();
    d->header.senderAddress.clear();
    d->header.destinationAddress.clear();
    d->header.hopLimit = -1;
    d->header.ifindex = 0;
}
 
bool QNetworkDatagram::isValid() const
{
    return d->header.senderAddress.protocol() != QAbstractSocket::UnknownNetworkLayerProtocol ||
           d->header.destinationAddress.protocol() != QAbstractSocket::UnknownNetworkLayerProtocol;
}
 
QHostAddress QNetworkDatagram::senderAddress() const
{
    return d->header.senderAddress;
}
 
QHostAddress QNetworkDatagram::destinationAddress() const
{
    return d->header.destinationAddress;
}
 
int QNetworkDatagram::senderPort() const
{
    return d->header.senderAddress.protocol() == QAbstractSocket::UnknownNetworkLayerProtocol
            ? -1 : d->header.senderPort;
}
 
int QNetworkDatagram::destinationPort() const
{
    return d->header.destinationAddress.protocol() == QAbstractSocket::UnknownNetworkLayerProtocol
            ? -1 : d->header.destinationPort;
}
 
void QNetworkDatagram::setSender(const QHostAddress &address, quint16 port)
{
    d->header.senderAddress = address;
    d->header.senderPort = port;
}
 
void QNetworkDatagram::setDestination(const QHostAddress &address, quint16 port)
{
    d->header.destinationAddress = address;
    d->header.destinationPort = port;
}
 
int QNetworkDatagram::hopLimit() const
{
    return d->header.hopLimit;
}
 
void QNetworkDatagram::setHopLimit(int count)
{
    d->header.hopLimit = count;
}
 
uint QNetworkDatagram::interfaceIndex() const
{
    return d->header.ifindex;
}
 
void QNetworkDatagram::setInterfaceIndex(uint index)
{
    d->header.ifindex = index;
}
 
QByteArray QNetworkDatagram::data() const
{
    return d->data;
}
 
void QNetworkDatagram::setData(const QByteArray &data)
{
    d->data = data;
}
 
static bool isNonMulticast(const QHostAddress &addr)
{
    // is it a multicast address?
    return !addr.isMulticast();
}
 
QNetworkDatagram QNetworkDatagram::makeReply_helper(const QByteArray &data) const
{
    QNetworkDatagramPrivate *x = new QNetworkDatagramPrivate(data, d->header.senderAddress, d->header.senderPort);
    x->header.ifindex = d->header.ifindex;
    if (isNonMulticast(d->header.destinationAddress)) {
        x->header.senderAddress = d->header.destinationAddress;
        x->header.senderPort = d->header.destinationPort;
    }
    return QNetworkDatagram(*x);
}
 
void QNetworkDatagram::makeReply_helper_inplace(const QByteArray &data)
{
    d->data = data;
    d->header.hopLimit = -1;
    qSwap(d->header.destinationPort, d->header.senderPort);
    qSwap(d->header.destinationAddress, d->header.senderAddress);
    if (!isNonMulticast(d->header.senderAddress))
        d->header.senderAddress.clear();
}
 
void QNetworkDatagram::destroy(QNetworkDatagramPrivate *d)
{
    Q_ASSERT(d);
    delete d;
}
 
QT_END_NAMESPACE
 
#endif // QT_NO_UDPSOCKET