Qt 5.11 | Qt Network | Torrent Example | torrentclient.cpp Example File

Qt 5.11.3 Reference Documentation

# torrentclient.cpp Example File

torrent/torrentclient.cpp

      /****************************************************************************
      **
      ** Copyright (C) 2016 The Qt Company Ltd.
      ** Contact: https://www.qt.io/licensing/
      **
      ** This file is part of the examples of the Qt Toolkit.
      **
      ** $QT_BEGIN_LICENSE:BSD$
      ** Commercial License Usage
      ** Licensees holding valid commercial Qt licenses may use this file in
      ** accordance with the commercial license agreement provided with the
      ** Software or, alternatively, in accordance with the terms contained in
      ** a written agreement between you and The Qt Company. For licensing terms
      ** and conditions see https://www.qt.io/terms-conditions. For further
      ** information use the contact form at https://www.qt.io/contact-us.
      **
      ** BSD License Usage
      ** Alternatively, 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 "connectionmanager.h"
      #include "filemanager.h"
      #include "metainfo.h"
      #include "torrentclient.h"
      #include "torrentserver.h"
      #include "trackerclient.h"
      #include "peerwireclient.h"
      #include "ratecontroller.h"

      #include <QtCore>
      #include <QNetworkInterface>

      #include <algorithm>

      // These constants could also be configurable by the user.
      static const int ServerMinPort = 6881;
      static const int ServerMaxPort = /* 6889 */ 7000;
      static const int BlockSize = 16384;
      static const int MaxBlocksInProgress = 5;
      static const int MaxBlocksInMultiMode = 2;
      static const int MaxConnectionPerPeer = 1;
      static const int RateControlWindowLength = 10;
      static const int RateControlTimerDelay = 1000;
      static const int MinimumTimeBeforeRevisit = 30;
      static const int MaxUploads = 4;
      static const int UploadScheduleInterval = 10000;

      class TorrentPiece {
      public:
          int index;
          int length;
          QBitArray completedBlocks;
          QBitArray requestedBlocks;
          bool inProgress;
      };

      class TorrentClientPrivate
      {
      public:
          TorrentClientPrivate(TorrentClient *qq);

          // State / error
          void setError(TorrentClient::Error error);
          void setState(TorrentClient::State state);
          TorrentClient::Error error;
          TorrentClient::State state;
          QString errorString;
          QString stateString;

          // Where to save data
          QString destinationFolder;
          MetaInfo metaInfo;

          // Announce tracker and file manager
          QByteArray peerId;
          QByteArray infoHash;
          TrackerClient trackerClient;
          FileManager fileManager;

          // Connections
          QList<PeerWireClient *> connections;
          QList<TorrentPeer *> peers;
          bool schedulerCalled;
          void callScheduler();
          bool connectingToClients;
          void callPeerConnector();
          int uploadScheduleTimer;

          // Pieces
          QMap<int, PeerWireClient *> readIds;
          QMultiMap<PeerWireClient *, TorrentPiece *> payloads;
          QMap<int, TorrentPiece *> pendingPieces;
          QBitArray completedPieces;
          QBitArray incompletePieces;
          int pieceCount;

          // Progress
          int lastProgressValue;
          qint64 downloadedBytes;
          qint64 uploadedBytes;
          int downloadRate[RateControlWindowLength];
          int uploadRate[RateControlWindowLength];
          int transferRateTimer;

          TorrentClient *q;
      };

      TorrentClientPrivate::TorrentClientPrivate(TorrentClient *qq)
          : trackerClient(qq), q(qq)
      {
          error = TorrentClient::UnknownError;
          state = TorrentClient::Idle;
          errorString = QT_TRANSLATE_NOOP(TorrentClient, "Unknown error");
          stateString = QT_TRANSLATE_NOOP(TorrentClient, "Idle");
          schedulerCalled = false;
          connectingToClients = false;
          uploadScheduleTimer = 0;
          lastProgressValue = -1;
          pieceCount = 0;
          downloadedBytes = 0;
          uploadedBytes = 0;
          memset(downloadRate, 0, sizeof(downloadRate));
          memset(uploadRate, 0, sizeof(uploadRate));
          transferRateTimer = 0;
      }

      void TorrentClientPrivate::setError(TorrentClient::Error errorCode)
      {
          this->error = errorCode;
          switch (error) {
          case TorrentClient::UnknownError:
              errorString = QT_TRANSLATE_NOOP(TorrentClient, "Unknown error");
              break;
          case TorrentClient::TorrentParseError:
              errorString = QT_TRANSLATE_NOOP(TorrentClient, "Invalid torrent data");
              break;
          case TorrentClient::InvalidTrackerError:
              errorString = QT_TRANSLATE_NOOP(TorrentClient, "Unable to connect to tracker");
              break;
          case TorrentClient::FileError:
              errorString = QT_TRANSLATE_NOOP(TorrentClient, "File error");
              break;
          case TorrentClient::ServerError:
              errorString = QT_TRANSLATE_NOOP(TorrentClient, "Unable to initialize server");
              break;
          }
          emit q->error(errorCode);
      }

      void TorrentClientPrivate::setState(TorrentClient::State state)
      {
          this->state = state;
          switch (state) {
          case TorrentClient::Idle:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Idle");
              break;
          case TorrentClient::Paused:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Paused");
              break;
          case TorrentClient::Stopping:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Stopping");
              break;
          case TorrentClient::Preparing:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Preparing");
              break;
          case TorrentClient::Searching:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Searching");
              break;
          case TorrentClient::Connecting:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Connecting");
              break;
          case TorrentClient::WarmingUp:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Warming up");
              break;
          case TorrentClient::Downloading:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Downloading");
              break;
          case TorrentClient::Endgame:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Finishing");
              break;
          case TorrentClient::Seeding:
              stateString = QT_TRANSLATE_NOOP(TorrentClient, "Seeding");
              break;
          }
          emit q->stateChanged(state);
      }

      void TorrentClientPrivate::callScheduler()
      {
          if (!schedulerCalled) {
              schedulerCalled = true;
              QMetaObject::invokeMethod(q, "scheduleDownloads", Qt::QueuedConnection);
          }
      }

      void TorrentClientPrivate::callPeerConnector()
      {
          if (!connectingToClients) {
              connectingToClients = true;
              QTimer::singleShot(10000, q, SLOT(connectToPeers()));
          }
      }

      TorrentClient::TorrentClient(QObject *parent)
          : QObject(parent), d(new TorrentClientPrivate(this))
      {
          // Connect the file manager
          connect(&d->fileManager, SIGNAL(dataRead(int,int,int,QByteArray)),
                  this, SLOT(sendToPeer(int,int,int,QByteArray)));
          connect(&d->fileManager, SIGNAL(verificationProgress(int)),
                  this, SLOT(updateProgress(int)));
          connect(&d->fileManager, SIGNAL(verificationDone()),
                  this, SLOT(fullVerificationDone()));
          connect(&d->fileManager, SIGNAL(pieceVerified(int,bool)),
                  this, SLOT(pieceVerified(int,bool)));
          connect(&d->fileManager, SIGNAL(error()),
                  this, SLOT(handleFileError()));

          // Connect the tracker client
          connect(&d->trackerClient, SIGNAL(peerListUpdated(QList<TorrentPeer>)),
                  this, SLOT(addToPeerList(QList<TorrentPeer>)));
          connect(&d->trackerClient, SIGNAL(stopped()),
                  this, SIGNAL(stopped()));
      }

      TorrentClient::~TorrentClient()
      {
          qDeleteAll(d->peers);
          qDeleteAll(d->pendingPieces);
          delete d;
      }

      bool TorrentClient::setTorrent(const QString &fileName)
      {
          QFile file(fileName);
          if (!file.open(QIODevice::ReadOnly) || !setTorrent(file.readAll())) {
              d->setError(TorrentParseError);
              return false;
          }
          return true;
      }

      bool TorrentClient::setTorrent(const QByteArray &torrentData)
      {
          if (!d->metaInfo.parse(torrentData)) {
              d->setError(TorrentParseError);
              return false;
          }

          // Calculate SHA1 hash of the "info" section in the torrent
          QByteArray infoValue = d->metaInfo.infoValue();
          d->infoHash = QCryptographicHash::hash(infoValue, QCryptographicHash::Sha1);

          return true;
      }

      MetaInfo TorrentClient::metaInfo() const
      {
          return d->metaInfo;
      }

      void TorrentClient::setDestinationFolder(const QString &directory)
      {
          d->destinationFolder = directory;
      }

      QString TorrentClient::destinationFolder() const
      {
          return d->destinationFolder;
      }

      void TorrentClient::setDumpedState(const QByteArray &dumpedState)
      {
          // Recover partially completed pieces
          QDataStream stream(dumpedState);

          quint16 version = 0;
          stream >> version;
          if (version != 2)
              return;

          stream >> d->completedPieces;

          while (!stream.atEnd()) {
              int index;
              int length;
              QBitArray completed;
              stream >> index >> length >> completed;
              if (stream.status() != QDataStream::Ok) {
                  d->completedPieces.clear();
                  break;
              }

              TorrentPiece *piece = new TorrentPiece;
              piece->index = index;
              piece->length = length;
              piece->completedBlocks = completed;
              piece->requestedBlocks.resize(completed.size());
              piece->inProgress = false;
              d->pendingPieces[index] = piece;
          }
      }

      QByteArray TorrentClient::dumpedState() const
      {
          QByteArray partials;
          QDataStream stream(&partials, QIODevice::WriteOnly);

          stream << quint16(2);
          stream << d->completedPieces;

          // Save the state of all partially downloaded pieces into a format
          // suitable for storing in settings.
          QMap<int, TorrentPiece *>::ConstIterator it = d->pendingPieces.constBegin();
          while (it != d->pendingPieces.constEnd()) {
              TorrentPiece *piece = it.value();
              if (blocksLeftForPiece(piece) > 0 && blocksLeftForPiece(piece) < piece->completedBlocks.size()) {
                  stream << piece->index;
                  stream << piece->length;
                  stream << piece->completedBlocks;
              }
              ++it;
          }

          return partials;
      }

      qint64 TorrentClient::progress() const
      {
          return d->lastProgressValue;
      }

      void TorrentClient::setDownloadedBytes(qint64 bytes)
      {
          d->downloadedBytes = bytes;
      }

      qint64 TorrentClient::downloadedBytes() const
      {
          return d->downloadedBytes;
      }

      void TorrentClient::setUploadedBytes(qint64 bytes)
      {
          d->uploadedBytes = bytes;
      }

      qint64 TorrentClient::uploadedBytes() const
      {
          return d->uploadedBytes;
      }

      int TorrentClient::connectedPeerCount() const
      {
          int tmp = 0;
          foreach (PeerWireClient *client, d->connections) {
              if (client->state() == QAbstractSocket::ConnectedState)
                  ++tmp;
          }
          return tmp;
      }

      int TorrentClient::seedCount() const
      {
          int tmp = 0;
          foreach (PeerWireClient *client, d->connections) {
              if (client->availablePieces().count(true) == d->pieceCount)
                  ++tmp;
          }
          return tmp;
      }

      TorrentClient::State TorrentClient::state() const
      {
          return d->state;
      }

      QString TorrentClient::stateString() const
      {
          return d->stateString;
      }

      TorrentClient::Error TorrentClient::error() const
      {
          return d->error;
      }

      QString TorrentClient::errorString() const
      {
          return d->errorString;
      }

      QByteArray TorrentClient::peerId() const
      {
          return d->peerId;
      }

      QByteArray TorrentClient::infoHash() const
      {
          return d->infoHash;
      }

      void TorrentClient::start()
      {
          if (d->state != Idle)
              return;

          TorrentServer::instance()->addClient(this);

          // Initialize the file manager
          d->setState(Preparing);
          d->fileManager.setMetaInfo(d->metaInfo);
          d->fileManager.setDestinationFolder(d->destinationFolder);
          d->fileManager.setCompletedPieces(d->completedPieces);
          d->fileManager.start(QThread::LowestPriority);
          d->fileManager.startDataVerification();
      }

      void TorrentClient::stop()
      {
          if (d->state == Stopping)
              return;

          TorrentServer::instance()->removeClient(this);

          // Update the state
          State oldState = d->state;
          d->setState(Stopping);

          // Stop the timer
          if (d->transferRateTimer) {
              killTimer(d->transferRateTimer);
              d->transferRateTimer = 0;
          }

          // Abort all existing connections
          foreach (PeerWireClient *client, d->connections) {
              RateController::instance()->removeSocket(client);
              ConnectionManager::instance()->removeConnection(client);
              client->abort();
          }
          d->connections.clear();

          // Perhaps stop the tracker
          if (oldState > Preparing) {
              d->trackerClient.stop();
          } else {
              d->setState(Idle);
              emit stopped();
          }
      }

      void TorrentClient::setPaused(bool paused)
      {
          if (paused) {
              // Abort all connections, and set the max number of
              // connections to 0. Keep the list of peers, so we can quickly
              // resume later.
              d->setState(Paused);
              foreach (PeerWireClient *client, d->connections)
                  client->abort();
              d->connections.clear();
              TorrentServer::instance()->removeClient(this);
          } else {
              // Restore the max number of connections, and start the peer
              // connector. We should also quickly start receiving incoming
              // connections.
              d->setState(d->completedPieces.count(true) == d->fileManager.pieceCount()
                          ? Seeding : Searching);
              connectToPeers();
              TorrentServer::instance()->addClient(this);
          }
      }

      void TorrentClient::timerEvent(QTimerEvent *event)
      {
          if (event->timerId() == d->uploadScheduleTimer) {
              // Update the state of who's choked and who's not
              scheduleUploads();
              return;
          }

          if (event->timerId() != d->transferRateTimer) {
              QObject::timerEvent(event);
              return;
          }

          // Calculate average upload/download rate
          qint64 uploadBytesPerSecond = 0;
          qint64 downloadBytesPerSecond = 0;
          for (int i = 0; i < RateControlWindowLength; ++i) {
              uploadBytesPerSecond += d->uploadRate[i];
              downloadBytesPerSecond += d->downloadRate[i];
          }
          uploadBytesPerSecond /= qint64(RateControlWindowLength);
          downloadBytesPerSecond /= qint64(RateControlWindowLength);
          for (int i = RateControlWindowLength - 2; i >= 0; --i) {
              d->uploadRate[i + 1] = d->uploadRate[i];
              d->downloadRate[i + 1] = d->downloadRate[i];
          }
          d->uploadRate[0] = 0;
          d->downloadRate[0] = 0;
          emit uploadRateUpdated(int(uploadBytesPerSecond));
          emit downloadRateUpdated(int(downloadBytesPerSecond));

          // Stop the timer if there is no activity.
          if (downloadBytesPerSecond == 0 && uploadBytesPerSecond == 0) {
              killTimer(d->transferRateTimer);
              d->transferRateTimer = 0;
          }
      }

      void TorrentClient::sendToPeer(int readId, int pieceIndex, int begin, const QByteArray &data)
      {
          // Send the requested block to the peer if the client connection
          // still exists; otherwise do nothing. This slot is called by the
          // file manager after it has read a block of data.
          PeerWireClient *client = d->readIds.value(readId);
          if (client) {
              if ((client->peerWireState() & PeerWireClient::ChokingPeer) == 0)
                  client->sendBlock(pieceIndex, begin, data);
          }
          d->readIds.remove(readId);
      }

      void TorrentClient::fullVerificationDone()
      {
          // Update our list of completed and incomplete pieces.
          d->completedPieces = d->fileManager.completedPieces();
          d->incompletePieces.resize(d->completedPieces.size());
          d->pieceCount = d->completedPieces.size();
          for (int i = 0; i < d->fileManager.pieceCount(); ++i) {
              if (!d->completedPieces.testBit(i))
                  d->incompletePieces.setBit(i);
          }

          updateProgress();

          // If the checksums show that what the dumped state thought was
          // partial was in fact complete, then we trust the checksums.
          QMap<int, TorrentPiece *>::Iterator it = d->pendingPieces.begin();
          while (it != d->pendingPieces.end()) {
              if (d->completedPieces.testBit(it.key()))
                  it = d->pendingPieces.erase(it);
              else
                  ++it;
          }

          d->uploadScheduleTimer = startTimer(UploadScheduleInterval);

          // Start the server
          TorrentServer *server = TorrentServer::instance();
          if (!server->isListening()) {
              // Set up the peer wire server
              for (int i = ServerMinPort; i <= ServerMaxPort; ++i) {
                  if (server->listen(QHostAddress::Any, i))
                      break;
              }
              if (!server->isListening()) {
                  d->setError(ServerError);
                  return;
              }
          }

          d->setState(d->completedPieces.count(true) == d->pieceCount ? Seeding : Searching);

          // Start the tracker client
          d->trackerClient.start(d->metaInfo);
      }

      void TorrentClient::pieceVerified(int pieceIndex, bool ok)
      {
          TorrentPiece *piece = d->pendingPieces.value(pieceIndex);

          // Remove this piece from all payloads
          QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.begin();
          while (it != d->payloads.end()) {
              if (it.value()->index == pieceIndex)
                  it = d->payloads.erase(it);
              else
                  ++it;
          }

          if (!ok) {
              // If a piece did not pass the SHA1 check, we'll simply clear
              // its state, and the scheduler will re-request it
              piece->inProgress = false;
              piece->completedBlocks.fill(false);
              piece->requestedBlocks.fill(false);
              d->callScheduler();
              return;
          }

          // Update the peer list so we know who's still interesting.
          foreach (TorrentPeer *peer, d->peers) {
              if (!peer->interesting)
                  continue;
              bool interesting = false;
              for (int i = 0; i < d->pieceCount; ++i) {
                  if (peer->pieces.testBit(i) && d->incompletePieces.testBit(i)) {
                      interesting = true;
                      break;
                  }
              }
              peer->interesting = interesting;
          }

          // Delete the piece and update our structures.
          delete piece;
          d->pendingPieces.remove(pieceIndex);
          d->completedPieces.setBit(pieceIndex);
          d->incompletePieces.clearBit(pieceIndex);

          // Notify connected peers.
          foreach (PeerWireClient *client, d->connections) {
              if (client->state() == QAbstractSocket::ConnectedState
                  && !client->availablePieces().testBit(pieceIndex)) {
                  client->sendPieceNotification(pieceIndex);
              }
          }

          // Notify the tracker if we've entered Seeding status; otherwise
          // call the scheduler.
          int completed = d->completedPieces.count(true);
          if (completed == d->pieceCount) {
              if (d->state != Seeding) {
                  d->setState(Seeding);
                  d->trackerClient.startSeeding();
              }
          } else {
              if (completed == 1)
                  d->setState(Downloading);
              else if (d->incompletePieces.count(true) < 5 && d->pendingPieces.size() > d->incompletePieces.count(true))
                  d->setState(Endgame);
              d->callScheduler();
          }

          updateProgress();
      }

      void TorrentClient::handleFileError()
      {
          if (d->state == Paused)
              return;
          setPaused(true);
          emit error(FileError);
      }

      void TorrentClient::connectToPeers()
      {
          d->connectingToClients = false;

          if (d->state == Stopping || d->state == Idle || d->state == Paused)
              return;

          if (d->state == Searching)
              d->setState(Connecting);

          // Find the list of peers we are not currently connected to, where
          // the more interesting peers are listed more than once.
          QList<TorrentPeer *> weighedPeers = weighedFreePeers();

          // Start as many connections as we can
          while (!weighedPeers.isEmpty() && ConnectionManager::instance()->canAddConnection()
                 && (QRandomGenerator::global()->bounded(ConnectionManager::instance()->maxConnections() / 2))) {
              PeerWireClient *client = new PeerWireClient(ConnectionManager::instance()->clientId(), this);
              RateController::instance()->addSocket(client);
              ConnectionManager::instance()->addConnection(client);

              initializeConnection(client);
              d->connections << client;

              // Pick a random peer from the list of weighed peers.
              TorrentPeer *peer = weighedPeers.takeAt(QRandomGenerator::global()->bounded(weighedPeers.size()));
              weighedPeers.removeAll(peer);
              peer->connectStart = QDateTime::currentSecsSinceEpoch();
              peer->lastVisited = peer->connectStart;

              // Connect to the peer.
              client->setPeer(peer);
              client->connectToHost(peer->address, peer->port);
          }
      }

      QList<TorrentPeer *> TorrentClient::weighedFreePeers() const
      {
          QList<TorrentPeer *> weighedPeers;

          // Generate a list of peers that we want to connect to.
          qint64 now = QDateTime::currentSecsSinceEpoch();
          QList<TorrentPeer *> freePeers;
          QMap<QString, int> connectionsPerPeer;
          foreach (TorrentPeer *peer, d->peers) {
              bool busy = false;
              foreach (PeerWireClient *client, d->connections) {
                  if (client->state() == PeerWireClient::ConnectedState
                      && client->peerAddress() == peer->address
                      && client->peerPort() == peer->port) {
                      if (++connectionsPerPeer[peer->address.toString()] >= MaxConnectionPerPeer) {
                          busy = true;
                          break;
                      }
                  }
              }
              if (!busy && (now - peer->lastVisited) > uint(MinimumTimeBeforeRevisit))
                  freePeers << peer;
          }

          // Nothing to connect to
          if (freePeers.isEmpty())
              return weighedPeers;

          // Assign points based on connection speed and pieces available.
          QList<QPair<int, TorrentPeer *> > points;
          foreach (TorrentPeer *peer, freePeers) {
              int tmp = 0;
              if (peer->interesting) {
                  tmp += peer->numCompletedPieces;
                  if (d->state == Seeding)
                      tmp = d->pieceCount - tmp;
                  if (!peer->connectStart) // An unknown peer is as interesting as a seed
                      tmp += d->pieceCount;

                  // 1/5 of the total score for each second below 5 it takes to
                  // connect.
                  if (peer->connectTime < 5)
                      tmp += (d->pieceCount / 10) * (5 - peer->connectTime);
              }
              points << QPair<int, TorrentPeer *>(tmp, peer);
          }
          std::sort(points.begin(), points.end());

          // Minimize the list so the point difference is never more than 1.
          typedef QPair<int,TorrentPeer*> PointPair;
          QMultiMap<int, TorrentPeer *> pointMap;
          int lowestScore = 0;
          int lastIndex = 0;
          foreach (PointPair point, points) {
              if (point.first > lowestScore) {
                  lowestScore = point.first;
                  ++lastIndex;
              }
              pointMap.insert(lastIndex, point.second);
          }

          // Now make up a list of peers where the ones with more points are
          // listed many times.
          QMultiMap<int, TorrentPeer *>::ConstIterator it = pointMap.constBegin();
          while (it != pointMap.constEnd()) {
              for (int i = 0; i < it.key() + 1; ++i)
                  weighedPeers << it.value();
              ++it;
          }

          return weighedPeers;
      }

      void TorrentClient::setupIncomingConnection(PeerWireClient *client)
      {
          // Connect signals
          initializeConnection(client);

          // Initialize this client
          RateController::instance()->addSocket(client);
          d->connections << client;

          client->initialize(d->infoHash, d->pieceCount);
          client->sendPieceList(d->completedPieces);

          emit peerInfoUpdated();

          if (d->state == Searching || d->state == Connecting) {
              int completed = d->completedPieces.count(true);
              if (completed == 0)
                  d->setState(WarmingUp);
              else if (d->incompletePieces.count(true) < 5 && d->pendingPieces.size() > d->incompletePieces.count(true))
                  d->setState(Endgame);
          }

          if (d->connections.isEmpty())
              scheduleUploads();
      }

      void TorrentClient::setupOutgoingConnection()
      {
          PeerWireClient *client = qobject_cast<PeerWireClient *>(sender());

          // Update connection statistics.
          foreach (TorrentPeer *peer, d->peers) {
              if (peer->port == client->peerPort() && peer->address == client->peerAddress()) {
                  peer->connectTime = peer->lastVisited - peer->connectStart;
                  break;
              }
          }

          // Send handshake and piece list
          client->initialize(d->infoHash, d->pieceCount);
          client->sendPieceList(d->completedPieces);

          emit peerInfoUpdated();

          if (d->state == Searching || d->state == Connecting) {
              int completed = d->completedPieces.count(true);
              if (completed == 0)
                  d->setState(WarmingUp);
              else if (d->incompletePieces.count(true) < 5 && d->pendingPieces.size() > d->incompletePieces.count(true))
                  d->setState(Endgame);
          }
      }

      void TorrentClient::initializeConnection(PeerWireClient *client)
      {
          connect(client, SIGNAL(connected()),
                  this, SLOT(setupOutgoingConnection()));
          connect(client, SIGNAL(disconnected()),
                  this, SLOT(removeClient()));
          connect(client, SIGNAL(error(QAbstractSocket::SocketError)),
                  this, SLOT(removeClient()));
          connect(client, SIGNAL(piecesAvailable(QBitArray)),
                  this, SLOT(peerPiecesAvailable(QBitArray)));
          connect(client, SIGNAL(blockRequested(int,int,int)),
                  this, SLOT(peerRequestsBlock(int,int,int)));
          connect(client, SIGNAL(blockReceived(int,int,QByteArray)),
                  this, SLOT(blockReceived(int,int,QByteArray)));
          connect(client, SIGNAL(choked()),
                  this, SLOT(peerChoked()));
          connect(client, SIGNAL(unchoked()),
                  this, SLOT(peerUnchoked()));
          connect(client, SIGNAL(bytesWritten(qint64)),
                  this, SLOT(peerWireBytesWritten(qint64)));
          connect(client, SIGNAL(bytesReceived(qint64)),
                  this, SLOT(peerWireBytesReceived(qint64)));
      }

      void TorrentClient::removeClient()
      {
          PeerWireClient *client = static_cast<PeerWireClient *>(sender());

          // Remove the host from our list of known peers if the connection
          // failed.
          if (client->peer() && client->error() == QAbstractSocket::ConnectionRefusedError)
              d->peers.removeAll(client->peer());

          // Remove the client from RateController and all structures.
          RateController::instance()->removeSocket(client);
          d->connections.removeAll(client);
          QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.find(client);
          while (it != d->payloads.end() && it.key() == client) {
              TorrentPiece *piece = it.value();
              piece->inProgress = false;
              piece->requestedBlocks.fill(false);
              it = d->payloads.erase(it);
          }

          // Remove pending read requests.
          QMapIterator<int, PeerWireClient *> it2(d->readIds);
          while (it2.findNext(client))
              d->readIds.remove(it2.key());

          // Delete the client later.
          disconnect(client, SIGNAL(disconnected()), this, SLOT(removeClient()));
          client->deleteLater();
          ConnectionManager::instance()->removeConnection(client);

          emit peerInfoUpdated();
          d->callPeerConnector();
      }

      void TorrentClient::peerPiecesAvailable(const QBitArray &pieces)
      {
          PeerWireClient *client = qobject_cast<PeerWireClient *>(sender());

          // Find the peer in our list of announced peers. If it's there,
          // then we can use the piece list into to gather statistics that
          // help us decide what peers to connect to.
          TorrentPeer *peer = 0;
          QList<TorrentPeer *>::Iterator it = d->peers.begin();
          while (it != d->peers.end()) {
              if ((*it)->address == client->peerAddress() && (*it)->port == client->peerPort()) {
                  peer = *it;
                  break;
              }
              ++it;
          }

          // If the peer is a seed, and we are in seeding mode, then the
          // peer is uninteresting.
          if (pieces.count(true) == d->pieceCount) {
              if (peer)
                  peer->seed = true;
              emit peerInfoUpdated();
              if (d->state == Seeding) {
                  client->abort();
                  return;
              } else {
                  if (peer)
                      peer->interesting = true;
                  if ((client->peerWireState() & PeerWireClient::InterestedInPeer) == 0)
                      client->sendInterested();
                  d->callScheduler();
                  return;
              }
          }

          // Update our list of available pieces.
          if (peer) {
              peer->pieces = pieces;
              peer->numCompletedPieces = pieces.count(true);
          }

          // Check for interesting pieces, and tell the peer whether we are
          // interested or not.
          bool interested = false;
          int piecesSize = pieces.size();
          for (int pieceIndex = 0; pieceIndex < piecesSize; ++pieceIndex) {
              if (!pieces.testBit(pieceIndex))
                  continue;
              if (!d->completedPieces.testBit(pieceIndex)) {
                  interested = true;
                  if ((client->peerWireState() & PeerWireClient::InterestedInPeer) == 0) {
                      if (peer)
                          peer->interesting = true;
                      client->sendInterested();
                  }

                  QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.find(client);
                  int inProgress = 0;
                  while (it != d->payloads.end() && it.key() == client) {
                      if (it.value()->inProgress)
                          inProgress += it.value()->requestedBlocks.count(true);
                      ++it;
                  }
                  if (!inProgress)
                      d->callScheduler();
                  break;
              }
          }
          if (!interested && (client->peerWireState() & PeerWireClient::InterestedInPeer)) {
              if (peer)
                  peer->interesting = false;
              client->sendNotInterested();
          }
      }

      void TorrentClient::peerRequestsBlock(int pieceIndex, int begin, int length)
      {
          PeerWireClient *client = qobject_cast<PeerWireClient *>(sender());

          // Silently ignore requests from choked peers
          if (client->peerWireState() & PeerWireClient::ChokingPeer)
              return;

          // Silently ignore requests for pieces we don't have.
          if (!d->completedPieces.testBit(pieceIndex))
              return;

          // Request the block from the file manager
          d->readIds.insert(d->fileManager.read(pieceIndex, begin, length),
                            qobject_cast<PeerWireClient *>(sender()));
      }

      void TorrentClient::blockReceived(int pieceIndex, int begin, const QByteArray &data)
      {
          PeerWireClient *client = qobject_cast<PeerWireClient *>(sender());
          if (data.size() == 0) {
              client->abort();
              return;
          }

          // Ignore it if we already have this block.
          int blockBit = begin / BlockSize;
          TorrentPiece *piece = d->pendingPieces.value(pieceIndex);
          if (!piece || piece->completedBlocks.testBit(blockBit)) {
              // Discard blocks that we already have, and fill up the pipeline.
              requestMore(client);
              return;
          }

          // If we are in warmup or endgame mode, cancel all duplicate
          // requests for this block.
          if (d->state == WarmingUp || d->state == Endgame) {
              QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.begin();
              while (it != d->payloads.end()) {
                  PeerWireClient *otherClient = it.key();
                  if (otherClient != client && it.value()->index == pieceIndex) {
                      if (otherClient->incomingBlocks().contains(TorrentBlock(pieceIndex, begin, data.size())))
                          it.key()->cancelRequest(pieceIndex, begin, data.size());
                  }
                  ++it;
              }
          }

          if (d->state != Downloading && d->state != Endgame && d->completedPieces.count(true) > 0)
              d->setState(Downloading);

          // Store this block
          d->fileManager.write(pieceIndex, begin, data);
          piece->completedBlocks.setBit(blockBit);
          piece->requestedBlocks.clearBit(blockBit);

          if (blocksLeftForPiece(piece) == 0) {
              // Ask the file manager to verify the newly downloaded piece
              d->fileManager.verifyPiece(piece->index);

              // Remove this piece from all payloads
              QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.begin();
              while (it != d->payloads.end()) {
                  if (!it.value() || it.value()->index == piece->index)
                      it = d->payloads.erase(it);
                  else
                      ++it;
              }
          }

          // Fill up the pipeline.
          requestMore(client);
      }

      void TorrentClient::peerWireBytesWritten(qint64 size)
      {
          if (!d->transferRateTimer)
              d->transferRateTimer = startTimer(RateControlTimerDelay);

          d->uploadRate[0] += size;
          d->uploadedBytes += size;
          emit dataSent(size);
      }

      void TorrentClient::peerWireBytesReceived(qint64 size)
      {
          if (!d->transferRateTimer)
              d->transferRateTimer = startTimer(RateControlTimerDelay);

          d->downloadRate[0] += size;
          d->downloadedBytes += size;
          emit dataSent(size);
      }

      int TorrentClient::blocksLeftForPiece(const TorrentPiece *piece) const
      {
          int blocksLeft = 0;
          int completedBlocksSize = piece->completedBlocks.size();
          for (int i = 0; i < completedBlocksSize; ++i) {
              if (!piece->completedBlocks.testBit(i))
                  ++blocksLeft;
          }
          return blocksLeft;
      }

      void TorrentClient::scheduleUploads()
      {
          // Generate a list of clients sorted by their transfer
          // speeds.  When leeching, we sort by download speed, and when
          // seeding, we sort by upload speed. Seeds are left out; there's
          // no use in unchoking them.
          QList<PeerWireClient *> allClients = d->connections;
          QMultiMap<int, PeerWireClient *> transferSpeeds;
          foreach (PeerWireClient *client, allClients) {
              if (client->state() == QAbstractSocket::ConnectedState
                  && client->availablePieces().count(true) != d->pieceCount) {
                  if (d->state == Seeding) {
                      transferSpeeds.insert(client->uploadSpeed(), client);
                  } else {
                      transferSpeeds.insert(client->downloadSpeed(), client);
                  }
              }
          }

          // Unchoke the top 'MaxUploads' downloaders (peers that we are
          // uploading to) and choke all others.
          int maxUploaders = MaxUploads;
          QMapIterator<int, PeerWireClient *> it(transferSpeeds);
          it.toBack();
          while (it.hasPrevious()) {
              PeerWireClient *client = it.previous().value();
              bool interested = (client->peerWireState() & PeerWireClient::PeerIsInterested);

              if (maxUploaders) {
                  allClients.removeAll(client);
                  if (client->peerWireState() & PeerWireClient::ChokingPeer)
                      client->unchokePeer();
                  --maxUploaders;
                  continue;
              }

              if ((client->peerWireState() & PeerWireClient::ChokingPeer) == 0) {
                  if ((QRandomGenerator::global()->bounded(10)) == 0)
                      client->abort();
                  else
                      client->chokePeer();
                  allClients.removeAll(client);
              }
              if (!interested)
                  allClients.removeAll(client);
          }

          // Only interested peers are left in allClients. Unchoke one
          // random peer to allow it to compete for a position among the
          // downloaders.  (This is known as an "optimistic unchoke".)
          if (!allClients.isEmpty()) {
              PeerWireClient *client = allClients[QRandomGenerator::global()->bounded(allClients.size())];
              if (client->peerWireState() & PeerWireClient::ChokingPeer)
                  client->unchokePeer();
          }
      }

      void TorrentClient::scheduleDownloads()
      {
          d->schedulerCalled = false;

          if (d->state == Stopping || d->state == Paused || d->state == Idle)
              return;

          // Check what each client is doing, and assign payloads to those
          // who are either idle or done.
          foreach (PeerWireClient *client, d->connections)
              schedulePieceForClient(client);
      }

      void TorrentClient::schedulePieceForClient(PeerWireClient *client)
      {
          // Only schedule connected clients.
          if (client->state() != QTcpSocket::ConnectedState)
              return;

          // The peer has choked us; try again later.
          if (client->peerWireState() & PeerWireClient::ChokedByPeer)
              return;

          // Make a list of all the client's pending pieces, and count how
          // many blocks have been requested.
          QList<int> currentPieces;
          bool somePiecesAreNotInProgress = false;
          TorrentPiece *lastPendingPiece = 0;
          QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.find(client);
          while (it != d->payloads.end() && it.key() == client) {
              lastPendingPiece = it.value();
              if (lastPendingPiece->inProgress) {
                  currentPieces << lastPendingPiece->index;
              } else {
                  somePiecesAreNotInProgress = true;
              }
              ++it;
          }

          // Skip clients that already have too many blocks in progress.
          if (client->incomingBlocks().size() >= ((d->state == Endgame || d->state == WarmingUp)
                                                  ? MaxBlocksInMultiMode : MaxBlocksInProgress))
              return;

          // If all pieces are in progress, but we haven't filled up our
          // block requesting quota, then we need to schedule another piece.
          if (!somePiecesAreNotInProgress || client->incomingBlocks().size() > 0)
              lastPendingPiece = 0;
          TorrentPiece *piece = lastPendingPiece;

          // In warmup state, all clients request blocks from the same pieces.
          if (d->state == WarmingUp && d->pendingPieces.size() >= 4) {
              piece = d->payloads.value(client);
              if (!piece) {
                  QList<TorrentPiece *> values = d->pendingPieces.values();
                  piece = values.value(QRandomGenerator::global()->bounded(values.size()));
                  piece->inProgress = true;
                  d->payloads.insert(client, piece);
              }
              if (piece->completedBlocks.count(false) == client->incomingBlocks().size())
                  return;
          }

          // If no pieces are currently in progress, schedule a new one.
          if (!piece) {
              // Build up a list of what pieces that we have not completed
              // are available to this client.
              QBitArray incompletePiecesAvailableToClient = d->incompletePieces;

              // Remove all pieces that are marked as being in progress
              // already (i.e., pieces that this or other clients are
              // already waiting for). A special rule applies to warmup and
              // endgame mode; there, we allow several clients to request
              // the same piece. In endgame mode, this only applies to
              // clients that are currently uploading (more than 1.0KB/s).
              if ((d->state == Endgame && client->uploadSpeed() < 1024) || d->state != WarmingUp) {
                  QMap<int, TorrentPiece *>::ConstIterator it = d->pendingPieces.constBegin();
                  while (it != d->pendingPieces.constEnd()) {
                      if (it.value()->inProgress)
                          incompletePiecesAvailableToClient.clearBit(it.key());
                      ++it;
                  }
              }

              // Remove all pieces that the client cannot download.
              incompletePiecesAvailableToClient &= client->availablePieces();

              // Remove all pieces that this client has already requested.
              foreach (int i, currentPieces)
                  incompletePiecesAvailableToClient.clearBit(i);

              // Only continue if more pieces can be scheduled. If no pieces
              // are available and no blocks are in progress, just leave
              // the connection idle; it might become interesting later.
              if (incompletePiecesAvailableToClient.count(true) == 0)
                  return;

              // Check if any of the partially completed pieces can be
              // recovered, and if so, pick a random one of them.
              QList<TorrentPiece *> partialPieces;
              QMap<int, TorrentPiece *>::ConstIterator it = d->pendingPieces.constBegin();
              while (it != d->pendingPieces.constEnd()) {
                  TorrentPiece *tmp = it.value();
                  if (incompletePiecesAvailableToClient.testBit(it.key())) {
                      if (!tmp->inProgress || d->state == WarmingUp || d->state == Endgame) {
                          partialPieces << tmp;
                          break;
                      }
                  }
                  ++it;
              }
              if (!partialPieces.isEmpty())
                  piece = partialPieces.value(QRandomGenerator::global()->bounded(partialPieces.size()));

              if (!piece) {
                  // Pick a random piece 3 out of 4 times; otherwise, pick either
                  // one of the most common or the least common pieces available,
                  // depending on the state we're in.
                  int pieceIndex = 0;
                  if (d->state == WarmingUp || (QRandomGenerator::global()->generate() & 4) == 0) {
                      int *occurrences = new int[d->pieceCount];
                      memset(occurrences, 0, d->pieceCount * sizeof(int));

                      // Count how many of each piece are available.
                      foreach (PeerWireClient *peer, d->connections) {
                          QBitArray peerPieces = peer->availablePieces();
                          int peerPiecesSize = peerPieces.size();
                          for (int i = 0; i < peerPiecesSize; ++i) {
                              if (peerPieces.testBit(i))
                                  ++occurrences[i];
                          }
                      }

                      // Find the rarest or most common pieces.
                      int numOccurrences = d->state == WarmingUp ? 0 : 99999;
                      QList<int> piecesReadyForDownload;
                      for (int i = 0; i < d->pieceCount; ++i) {
                          if (d->state == WarmingUp) {
                              // Add common pieces
                              if (occurrences[i] >= numOccurrences
                                  && incompletePiecesAvailableToClient.testBit(i)) {
                                  if (occurrences[i] > numOccurrences)
                                      piecesReadyForDownload.clear();
                                  piecesReadyForDownload.append(i);
                                  numOccurrences = occurrences[i];
                              }
                          } else {
                              // Add rare pieces
                              if (occurrences[i] <= numOccurrences
                                  && incompletePiecesAvailableToClient.testBit(i)) {
                                  if (occurrences[i] < numOccurrences)
                                      piecesReadyForDownload.clear();
                                  piecesReadyForDownload.append(i);
                                  numOccurrences = occurrences[i];
                              }
                          }
                      }

                      // Select one piece randomly
                      pieceIndex = piecesReadyForDownload.at(QRandomGenerator::global()->bounded(piecesReadyForDownload.size()));
                      delete [] occurrences;
                  } else {
                      // Make up a list of available piece indices, and pick
                      // a random one.
                      QList<int> values;
                      int incompletePiecesAvailableToClientSize = incompletePiecesAvailableToClient.size();
                      for (int i = 0; i < incompletePiecesAvailableToClientSize; ++i) {
                          if (incompletePiecesAvailableToClient.testBit(i))
                              values << i;
                      }
                      pieceIndex = values.at(QRandomGenerator::global()->bounded(values.size()));
                  }

                  // Create a new TorrentPiece and fill in all initial
                  // properties.
                  piece = new TorrentPiece;
                  piece->index = pieceIndex;
                  piece->length = d->fileManager.pieceLengthAt(pieceIndex);
                  int numBlocks = piece->length / BlockSize;
                  if (piece->length % BlockSize)
                      ++numBlocks;
                  piece->completedBlocks.resize(numBlocks);
                  piece->requestedBlocks.resize(numBlocks);
                  d->pendingPieces.insert(pieceIndex, piece);
              }

              piece->inProgress = true;
              d->payloads.insert(client, piece);
          }

          // Request more blocks from all pending pieces.
          requestMore(client);
      }

      void TorrentClient::requestMore(PeerWireClient *client)
      {
          // Make a list of all pieces this client is currently waiting for,
          // and count the number of blocks in progress.
          QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.find(client);
          int numBlocksInProgress = client->incomingBlocks().size();
          QList<TorrentPiece *> piecesInProgress;
          while (it != d->payloads.end() && it.key() == client) {
              TorrentPiece *piece = it.value();
              if (piece->inProgress || (d->state == WarmingUp || d->state == Endgame))
                  piecesInProgress << piece;
              ++it;
          }

          // If no pieces are in progress, call the scheduler.
          if (piecesInProgress.isEmpty() && d->incompletePieces.count(true)) {
              d->callScheduler();
              return;
          }

          // If too many pieces are in progress, there's nothing to do.
          int maxInProgress = ((d->state == Endgame || d->state == WarmingUp)
                               ? MaxBlocksInMultiMode : MaxBlocksInProgress);
          if (numBlocksInProgress == maxInProgress)
              return;

          // Starting with the first piece that we're waiting for, request
          // blocks until the quota is filled up.
          foreach (TorrentPiece *piece, piecesInProgress) {
              numBlocksInProgress += requestBlocks(client, piece, maxInProgress - numBlocksInProgress);
              if (numBlocksInProgress == maxInProgress)
                  break;
          }

          // If we still didn't fill up the quota, we need to schedule more
          // pieces.
          if (numBlocksInProgress < maxInProgress && d->state != WarmingUp)
              d->callScheduler();
      }

      int TorrentClient::requestBlocks(PeerWireClient *client, TorrentPiece *piece, int maxBlocks)
      {
          // Generate the list of incomplete blocks for this piece.
          QVector<int> bits;
          int completedBlocksSize = piece->completedBlocks.size();
          for (int i = 0; i < completedBlocksSize; ++i) {
              if (!piece->completedBlocks.testBit(i) && !piece->requestedBlocks.testBit(i))
                  bits << i;
          }

          // Nothing more to request.
          if (bits.size() == 0) {
              if (d->state != WarmingUp && d->state != Endgame)
                  return 0;
              bits.clear();
              for (int i = 0; i < completedBlocksSize; ++i) {
                  if (!piece->completedBlocks.testBit(i))
                      bits << i;
              }
          }

          if (d->state == WarmingUp || d->state == Endgame) {
              // By randomizing the list of blocks to request, we
              // significantly speed up the warmup and endgame modes, where
              // the same blocks are requested from multiple peers. The
              // speedup comes from an increased chance of receiving
              // different blocks from the different peers.
              for (int i = 0; i < bits.size(); ++i) {
                  int a = QRandomGenerator::global()->bounded(bits.size());
                  int b = QRandomGenerator::global()->bounded(bits.size());
                  int tmp = bits[a];
                  bits[a] = bits[b];
                  bits[b] = tmp;
              }
          }

          // Request no more blocks than we've been asked to.
          int blocksToRequest = qMin(maxBlocks, bits.size());

          // Calculate the offset and size of each block, and send requests.
          for (int i = 0; i < blocksToRequest; ++i) {
              int blockSize = BlockSize;
              if ((piece->length % BlockSize) && bits.at(i) == completedBlocksSize - 1)
                  blockSize = piece->length % BlockSize;
              client->requestBlock(piece->index, bits.at(i) * BlockSize, blockSize);
              piece->requestedBlocks.setBit(bits.at(i));
          }

          return blocksToRequest;
      }

      void TorrentClient::peerChoked()
      {
          PeerWireClient *client = qobject_cast<PeerWireClient *>(sender());
          if (!client)
              return;

          // When the peer chokes us, we immediately forget about all blocks
          // we've requested from it. We also remove the piece from out
          // payload, making it available to other clients.
          QMultiMap<PeerWireClient *, TorrentPiece *>::Iterator it = d->payloads.find(client);
          while (it != d->payloads.end() && it.key() == client) {
              it.value()->inProgress = false;
              it.value()->requestedBlocks.fill(false);
              it = d->payloads.erase(it);
          }
      }

      void TorrentClient::peerUnchoked()
      {
          PeerWireClient *client = qobject_cast<PeerWireClient *>(sender());
          if (!client)
              return;

          // We got unchoked, which means we can request more blocks.
          if (d->state != Seeding)
              d->callScheduler();
      }

      void TorrentClient::addToPeerList(const QList<TorrentPeer> &peerList)
      {
          // Add peers we don't already know of to our list of peers.
          QList<QHostAddress> addresses =  QNetworkInterface::allAddresses();
          foreach (TorrentPeer peer, peerList) {
              if (addresses.contains(peer.address)
                  && peer.port == TorrentServer::instance()->serverPort()) {
                  // Skip our own server.
                  continue;
              }

              bool known = false;
              foreach (TorrentPeer *knownPeer, d->peers) {
                  if (knownPeer->port == peer.port
                      && knownPeer->address == peer.address) {
                      known = true;
                      break;
                  }
              }
              if (!known) {
                  TorrentPeer *newPeer = new TorrentPeer;
                  *newPeer = peer;
                  newPeer->interesting = true;
                  newPeer->seed = false;
                  newPeer->lastVisited = 0;
                  newPeer->connectStart = 0;
                  newPeer->connectTime = 999999;
                  newPeer->pieces.resize(d->pieceCount);
                  newPeer->numCompletedPieces = 0;
                  d->peers << newPeer;
              }
          }

          // If we've got more peers than we can connect to, we remove some
          // of the peers that have no (or low) activity.
          int maxPeers = ConnectionManager::instance()->maxConnections() * 3;
          if (d->peers.size() > maxPeers) {
              // Find what peers are currently connected & active
              QSet<TorrentPeer *> activePeers;
              foreach (TorrentPeer *peer, d->peers) {
                  foreach (PeerWireClient *client, d->connections) {
                      if (client->peer() == peer && (client->downloadSpeed() + client->uploadSpeed()) > 1024)
                          activePeers << peer;
                  }
              }

              // Remove inactive peers from the peer list until we're below
              // the max connections count.
              QList<int> toRemove;
              for (int i = 0; i < d->peers.size() && (d->peers.size() - toRemove.size()) > maxPeers; ++i) {
                  if (!activePeers.contains(d->peers.at(i)))
                      toRemove << i;
              }
              QListIterator<int> toRemoveIterator(toRemove);
              toRemoveIterator.toBack();
              while (toRemoveIterator.hasPrevious())
                  d->peers.removeAt(toRemoveIterator.previous());

              // If we still have too many peers, remove the oldest ones.
              while (d->peers.size() > maxPeers)
                  d->peers.takeFirst();
          }

          if (d->state != Paused && d->state != Stopping && d->state != Idle) {
              if (d->state == Searching || d->state == WarmingUp)
                  connectToPeers();
              else
                  d->callPeerConnector();
          }
      }

      void TorrentClient::trackerStopped()
      {
          d->setState(Idle);
          emit stopped();
      }

      void TorrentClient::updateProgress(int progress)
      {
          if (progress == -1 && d->pieceCount > 0) {
              int newProgress = (d->completedPieces.count(true) * 100) / d->pieceCount;
              if (d->lastProgressValue != newProgress) {
                  d->lastProgressValue = newProgress;
                  emit progressUpdated(newProgress);
              }
          } else if (d->lastProgressValue != progress) {
              d->lastProgressValue = progress;
              emit progressUpdated(progress);
          }
      }