|  | Home · All Classes · All Functions · Overviews

# peermanager.cpp Example File
network/network-chat/peermanager.cpp

     /****************************************************************************
     **
     ** Copyright (C) 2010 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:LGPL$
     ** Commercial Usage
     ** Licensees holding valid Qt Commercial licenses may use this file in
     ** accordance with the Qt Commercial License Agreement provided with the
     ** Software or, alternatively, in accordance with the terms contained in
     ** a written agreement between you and Nokia.
     **
     ** GNU Lesser General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU Lesser
     ** General Public License version 2.1 as published by the Free Software
     ** Foundation and appearing in the file LICENSE.LGPL included in the
     ** packaging of this file.  Please review the following information to
     ** ensure the GNU Lesser General Public License version 2.1 requirements
     ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
     **
     ** In addition, as a special exception, Nokia gives you certain additional
     ** rights.  These rights are described in the Nokia Qt LGPL Exception
     ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
     **
     ** GNU General Public License Usage
     ** Alternatively, this file may be used under the terms of the GNU
     ** General Public License version 3.0 as published by the Free Software
     ** Foundation and appearing in the file LICENSE.GPL included in the
     ** packaging of this file.  Please review the following information to
     ** ensure the GNU General Public License version 3.0 requirements will be
     ** met: http://www.gnu.org/copyleft/gpl.html.
     **
     ** If you have questions regarding the use of this file, please contact
     ** Nokia at qt-info@nokia.com.
     ** $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();
                 }
             }
         }
     }