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