Qt Reference Documentation

# peermanager.cpp Example File

network/network-chat/peermanager.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies).
     ** All rights reserved.
     ** Contact: Nokia Corporation (qt-info@nokia.com)
     **
     ** 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 Nokia Corporation and its Subsidiary(-ies) 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())
     #ifndef Q_OS_SYMBIAN
             username = "unknown";
     #else
             username = "QtS60";
     #endif

         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();
                 }
             }
         }
     }