|  | Home · All Classes · Main Classes · Grouped Classes · Modules · Functions |

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

     /****************************************************************************
     **
     ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
     **
     ** This file is part of the documentation of the Qt Toolkit.
     **
     ** This file may be used under the terms of the GNU General Public
    ** License versions 2.0 or 3.0 as published by the Free Software
    ** Foundation and appearing in the files LICENSE.GPL2 and LICENSE.GPL3
    ** included in the packaging of this file.  Alternatively you may (at
    ** your option) use any later version of the GNU General Public
    ** License if such license has been publicly approved by Trolltech ASA
    ** (or its successors, if any) and the KDE Free Qt Foundation. In
    ** addition, as a special exception, Trolltech gives you certain
    ** additional rights. These rights are described in the Trolltech GPL
    ** Exception version 1.2, which can be found at
    ** http://www.trolltech.com/products/qt/gplexception/ and in the file
    ** GPL_EXCEPTION.txt in this package.
    **
    ** Please review the following information to ensure GNU General
    ** Public Licensing requirements will be met:
    ** http://trolltech.com/products/qt/licenses/licensing/opensource/. If
    ** you are unsure which license is appropriate for your use, please
    ** review the following information:
    ** http://trolltech.com/products/qt/licenses/licensing/licensingoverview
    ** or contact the sales department at sales@trolltech.com.
    **
    ** In addition, as a special exception, Trolltech, as the sole
    ** copyright holder for Qt Designer, grants users of the Qt/Eclipse
    ** Integration plug-in the right for the Qt/Eclipse Integration to
    ** link to functionality provided by Qt Designer and its related
    ** libraries.
    **
    ** This file is provided "AS IS" with NO WARRANTY OF ANY KIND,
    ** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR
    ** A PARTICULAR PURPOSE. Trolltech reserves all rights not expressly
    ** granted herein.
     **
     ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
     ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
     **
     ****************************************************************************/

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