qt-everywhere-src-5.15.1/qtbase/examples/network/torrent/trackerclient.cpp - orbit - Git at Google

 /****************************************************************************
 **
 ** 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)
 {
     connect(&http, &QNetworkAccessManager::finished,
             this, &TrackerClient::httpRequestDone);
 }

 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, &QNetworkAccessManager::authenticationRequired,
                 this, &TrackerClient::provideAuthentication);
     }
     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.userType() == QMetaType::QVariantList) {
             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);
 }
	/****************************************************************************
	**
	** 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)
	{
	connect(&http, &QNetworkAccessManager::finished,
	this, &TrackerClient::httpRequestDone);
	}

	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, &QNetworkAccessManager::authenticationRequired,
	this, &TrackerClient::provideAuthentication);
	}
	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.userType() == QMetaType::QVariantList) {
	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);
	}