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

Qt 5.11.3 Reference Documentation

# trackerclient.cpp Example File

torrent/trackerclient.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 "bencodeparser.h"
      #include "connectionmanager.h"
      #include "torrentclient.h"
      #include "torrentserver.h"
      #include "trackerclient.h"

      #include <QtCore>
      #include <QNetworkRequest>

      TrackerClient::TrackerClient(TorrentClient *downloader, QObject *parent)
          : QObject(parent), torrentDownloader(downloader)
      {
          length = 0;
          requestInterval = 5 * 60;
          requestIntervalTimer = -1;
          firstTrackerRequest = true;
          lastTrackerRequest = false;
          firstSeeding = true;

          connect(&http, SIGNAL(finished(QNetworkReply*)), this, SLOT(httpRequestDone(QNetworkReply*)));
      }

      void TrackerClient::start(const MetaInfo &info)
      {
          metaInfo = info;
          QTimer::singleShot(0, this, SLOT(fetchPeerList()));

          if (metaInfo.fileForm() == MetaInfo::SingleFileForm) {
              length = metaInfo.singleFile().length;
          } else {
              QList<MetaInfoMultiFile> files = metaInfo.multiFiles();
              for (int i = 0; i < files.size(); ++i)
                  length += files.at(i).length;
          }
      }

      void TrackerClient::startSeeding()
      {
          firstSeeding = true;
          fetchPeerList();
      }

      void TrackerClient::stop()
      {
          lastTrackerRequest = true;
          fetchPeerList();
      }

      void TrackerClient::timerEvent(QTimerEvent *event)
      {
          if (event->timerId() == requestIntervalTimer) {
              fetchPeerList();
          } else {
              QObject::timerEvent(event);
          }
      }

      void TrackerClient::fetchPeerList()
      {
          QUrl url(metaInfo.announceUrl());

          // Base the query on announce url to include a passkey (if any)
          QUrlQuery query(url);

          // Percent encode the hash
          QByteArray infoHash = torrentDownloader->infoHash();
          QByteArray encodedSum;
          for (int i = 0; i < infoHash.size(); ++i) {
              encodedSum += '%';
              encodedSum += QByteArray::number(infoHash[i], 16).right(2).rightJustified(2, '0');
          }

          bool seeding = (torrentDownloader->state() == TorrentClient::Seeding);

          query.addQueryItem("info_hash", encodedSum);
          query.addQueryItem("peer_id", ConnectionManager::instance()->clientId());
          query.addQueryItem("port", QByteArray::number(TorrentServer::instance()->serverPort()));
          query.addQueryItem("compact", "1");
          query.addQueryItem("uploaded", QByteArray::number(torrentDownloader->uploadedBytes()));

          if (!firstSeeding) {
              query.addQueryItem("downloaded", "0");
              query.addQueryItem("left", "0");
          } else {
              query.addQueryItem("downloaded",
                                 QByteArray::number(torrentDownloader->downloadedBytes()));
              int left = qMax<int>(0, metaInfo.totalSize() - torrentDownloader->downloadedBytes());
              query.addQueryItem("left", QByteArray::number(seeding ? 0 : left));
          }

          if (seeding && firstSeeding) {
              query.addQueryItem("event", "completed");
              firstSeeding = false;
          } else if (firstTrackerRequest) {
              firstTrackerRequest = false;
              query.addQueryItem("event", "started");
          } else if(lastTrackerRequest) {
              query.addQueryItem("event", "stopped");
          }

          if (!trackerId.isEmpty())
              query.addQueryItem("trackerid", trackerId);

          url.setQuery(query);

          QNetworkRequest req(url);
          if (!url.userName().isEmpty()) {
              uname = url.userName();
              pwd = url.password();
              connect(&http, SIGNAL(authenticationRequired(QNetworkReply*,QAuthenticator*)),
                      this, SLOT(provideAuthentication(QNetworkReply*,QAuthenticator*)));
          }
          http.get(req);
      }

      void TrackerClient::httpRequestDone(QNetworkReply *reply)
      {
          reply->deleteLater();
          if (lastTrackerRequest) {
              emit stopped();
              return;
          }

          if (reply->error() != QNetworkReply::NoError) {
              emit connectionError(reply->error());
              return;
          }

          QByteArray response = reply->readAll();
          reply->abort();

          BencodeParser parser;
          if (!parser.parse(response)) {
              qWarning("Error parsing bencode response from tracker: %s",
                       qPrintable(parser.errorString()));
              return;
          }

          QMap<QByteArray, QVariant> dict = parser.dictionary();

          if (dict.contains("failure reason")) {
              // no other items are present
              emit failure(QString::fromUtf8(dict.value("failure reason").toByteArray()));
              return;
          }

          if (dict.contains("warning message")) {
              // continue processing
              emit warning(QString::fromUtf8(dict.value("warning message").toByteArray()));
          }

          if (dict.contains("tracker id")) {
              // store it
              trackerId = dict.value("tracker id").toByteArray();
          }

          if (dict.contains("interval")) {
              // Mandatory item
              if (requestIntervalTimer != -1)
                  killTimer(requestIntervalTimer);
              requestIntervalTimer = startTimer(dict.value("interval").toInt() * 1000);
          }

          if (dict.contains("peers")) {
              // store it
              peers.clear();
              QVariant peerEntry = dict.value("peers");
              if (peerEntry.type() == QVariant::List) {
                  QList<QVariant> peerTmp = peerEntry.toList();
                  for (int i = 0; i < peerTmp.size(); ++i) {
                      TorrentPeer tmp;
                      QMap<QByteArray, QVariant> peer = qvariant_cast<QMap<QByteArray, QVariant> >(peerTmp.at(i));
                      tmp.id = QString::fromUtf8(peer.value("peer id").toByteArray());
                      tmp.address.setAddress(QString::fromUtf8(peer.value("ip").toByteArray()));
                      tmp.port = peer.value("port").toInt();
                      peers << tmp;
                  }
              } else {
                  QByteArray peerTmp = peerEntry.toByteArray();
                  for (int i = 0; i < peerTmp.size(); i += 6) {
                      TorrentPeer tmp;
                      uchar *data = (uchar *)peerTmp.constData() + i;
                      tmp.port = (int(data[4]) << 8) + data[5];
                      uint ipAddress = 0;
                      ipAddress += uint(data[0]) << 24;
                      ipAddress += uint(data[1]) << 16;
                      ipAddress += uint(data[2]) << 8;
                      ipAddress += uint(data[3]);
                      tmp.address.setAddress(ipAddress);
                      peers << tmp;
                  }
              }
              emit peerListUpdated(peers);
          }
      }

      void TrackerClient::provideAuthentication(QNetworkReply *reply, QAuthenticator *auth)
      {
          Q_UNUSED(reply);
          auth->setUser(uname);
          auth->setPassword(pwd);
      }