- Qt 5.5
- Qt Network
- Network Chat Example
- peermanager.cpp Example File
- Qt 5.5.1 Reference Documentation

# peermanager.cpp Example File

network-chat/peermanager.cpp

    /****************************************************************************
    **
    ** Copyright (C) 2015 The Qt Company Ltd.
    ** Contact: http://www.qt.io/licensing/
    **
    ** This file is part of the examples of the Qt Toolkit.
    **
    ** $QT_BEGIN_LICENSE:BSD$
    ** You may use this file under the terms of the BSD license as follows:
    **
    ** "Redistribution and use in source and binary forms, with or without
    ** modification, are permitted provided that the following conditions are
    ** met:
    **   * Redistributions of source code must retain the above copyright
    **     notice, this list of conditions and the following disclaimer.
    **   * Redistributions in binary form must reproduce the above copyright
    **     notice, this list of conditions and the following disclaimer in
    **     the documentation and/or other materials provided with the
    **     distribution.
    **   * Neither the name of The Qt Company Ltd nor the names of its
    **     contributors may be used to endorse or promote products derived
    **     from this software without specific prior written permission.
    **
    **
    ** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
    ** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
    ** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
    ** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
    ** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
    ** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
    ** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
    ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
    ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
    ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
    ** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
    **
    ** $QT_END_LICENSE$
    **
    ****************************************************************************/

    #include <QtNetwork>

    #include "client.h"
    #include "connection.h"
    #include "peermanager.h"

    static const qint32 BroadcastInterval = 2000;
    static const unsigned broadcastPort = 45000;

    PeerManager::PeerManager(Client *client)
        : QObject(client)
    {
        this->client = client;

        QStringList envVariables;
        envVariables << "USERNAME.*" << "USER.*" << "USERDOMAIN.*"
                     << "HOSTNAME.*" << "DOMAINNAME.*";

        QStringList environment = QProcess::systemEnvironment();
        foreach (QString string, envVariables) {
            int index = environment.indexOf(QRegExp(string));
            if (index != -1) {
                QStringList stringList = environment.at(index).split('=');
                if (stringList.size() == 2) {
                    username = stringList.at(1).toUtf8();
                    break;
                }
            }
        }

        if (username.isEmpty())
            username = "unknown";

        updateAddresses();
        serverPort = 0;

        broadcastSocket.bind(QHostAddress::Any, broadcastPort, QUdpSocket::ShareAddress
                             | QUdpSocket::ReuseAddressHint);
        connect(&broadcastSocket, SIGNAL(readyRead()),
                this, SLOT(readBroadcastDatagram()));

        broadcastTimer.setInterval(BroadcastInterval);
        connect(&broadcastTimer, SIGNAL(timeout()),
                this, SLOT(sendBroadcastDatagram()));
    }

    void PeerManager::setServerPort(int port)
    {
        serverPort = port;
    }

    QByteArray PeerManager::userName() const
    {
        return username;
    }

    void PeerManager::startBroadcasting()
    {
        broadcastTimer.start();
    }

    bool PeerManager::isLocalHostAddress(const QHostAddress &address)
    {
        foreach (QHostAddress localAddress, ipAddresses) {
            if (address == localAddress)
                return true;
        }
        return false;
    }

    void PeerManager::sendBroadcastDatagram()
    {
        QByteArray datagram(username);
        datagram.append('@');
        datagram.append(QByteArray::number(serverPort));

        bool validBroadcastAddresses = true;
        foreach (QHostAddress address, broadcastAddresses) {
            if (broadcastSocket.writeDatagram(datagram, address,
                                              broadcastPort) == -1)
                validBroadcastAddresses = false;
        }

        if (!validBroadcastAddresses)
            updateAddresses();
    }

    void PeerManager::readBroadcastDatagram()
    {
        while (broadcastSocket.hasPendingDatagrams()) {
            QHostAddress senderIp;
            quint16 senderPort;
            QByteArray datagram;
            datagram.resize(broadcastSocket.pendingDatagramSize());
            if (broadcastSocket.readDatagram(datagram.data(), datagram.size(),
                                             &senderIp, &senderPort) == -1)
                continue;

            QList<QByteArray> list = datagram.split('@');
            if (list.size() != 2)
                continue;

            int senderServerPort = list.at(1).toInt();
            if (isLocalHostAddress(senderIp) && senderServerPort == serverPort)
                continue;

            if (!client->hasConnection(senderIp)) {
                Connection *connection = new Connection(this);
                emit newConnection(connection);
                connection->connectToHost(senderIp, senderServerPort);
            }
        }
    }

    void PeerManager::updateAddresses()
    {
        broadcastAddresses.clear();
        ipAddresses.clear();
        foreach (QNetworkInterface interface, QNetworkInterface::allInterfaces()) {
            foreach (QNetworkAddressEntry entry, interface.addressEntries()) {
                QHostAddress broadcastAddress = entry.broadcast();
                if (broadcastAddress != QHostAddress::Null && entry.ip() != QHostAddress::LocalHost) {
                    broadcastAddresses << broadcastAddress;
                    ipAddresses << entry.ip();
                }
            }
        }
    }