You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
557 lines
12 KiB
557 lines
12 KiB
/***************************************************************************
|
|
* Copyright (C) 2005 by Joris Guisson *
|
|
* joris.guisson@gmail.com *
|
|
* *
|
|
* This program is free software; you can redistribute it and/or modify *
|
|
* it under the terms of the GNU General Public License as published by *
|
|
* the Free Software Foundation; either version 2 of the License, or *
|
|
* (at your option) any later version. *
|
|
* *
|
|
* This program is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU General Public License *
|
|
* along with this program; if not, write to the *
|
|
* Free Software Foundation, Inc., *
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
|
|
***************************************************************************/
|
|
#include <tqfile.h>
|
|
#include <klocale.h>
|
|
#include <functions.h>
|
|
#include <util/log.h>
|
|
#include <torrent/globals.h>
|
|
#include <kademlia/dhtbase.h>
|
|
#include <kademlia/dhttrackerbackend.h>
|
|
#include "tracker.h"
|
|
#include "udptracker.h"
|
|
#include "httptracker.h"
|
|
#include "torrentcontrol.h"
|
|
#include "torrent.h"
|
|
#include "peermanager.h"
|
|
#include "peersourcemanager.h"
|
|
|
|
namespace bt
|
|
{
|
|
const Uint32 INITIAL_WAIT_TIME = 30;
|
|
const Uint32 LONGER_WAIT_TIME = 300;
|
|
const Uint32 FINAL_WAIT_TIME = 1800;
|
|
|
|
PeerSourceManager::PeerSourceManager(TorrentControl* tor,PeerManager* pman)
|
|
: tor(tor),pman(pman),curr(0),m_dht(0),started(false),pending(false)
|
|
{
|
|
failures = 0;
|
|
trackers.setAutoDelete(true);
|
|
no_save_custom_trackers = false;
|
|
|
|
const TrackerTier* t = tor->getTorrent().getTrackerList();
|
|
int tier = 1;
|
|
while (t)
|
|
{
|
|
// add all standard trackers
|
|
const KURL::List & tr = t->urls;
|
|
KURL::List::const_iterator i = tr.begin();
|
|
while (i != tr.end())
|
|
{
|
|
addTracker(*i,false,tier);
|
|
i++;
|
|
}
|
|
|
|
tier++;
|
|
t = t->next;
|
|
}
|
|
|
|
//load custom trackers
|
|
loadCustomURLs();
|
|
|
|
connect(&timer,TQT_SIGNAL(timeout()),this,TQT_SLOT(updateCurrentManually()));
|
|
}
|
|
|
|
PeerSourceManager::~PeerSourceManager()
|
|
{
|
|
saveCustomURLs();
|
|
additional.setAutoDelete(true);
|
|
TQPtrList<kt::PeerSource>::iterator itr = additional.begin();
|
|
while (itr != additional.end())
|
|
{
|
|
kt::PeerSource* ps = *itr;
|
|
ps->aboutToBeDestroyed();
|
|
itr++;
|
|
}
|
|
additional.clear();
|
|
}
|
|
|
|
void PeerSourceManager::addTracker(Tracker* trk)
|
|
{
|
|
trackers.insert(trk->trackerURL(),trk);
|
|
connect(trk,TQT_SIGNAL(peersReady( kt::PeerSource* )),
|
|
pman,TQT_SLOT(peerSourceReady( kt::PeerSource* )));
|
|
}
|
|
|
|
void PeerSourceManager::addPeerSource(kt::PeerSource* ps)
|
|
{
|
|
additional.append(ps);
|
|
connect(ps,TQT_SIGNAL(peersReady( kt::PeerSource* )),
|
|
pman,TQT_SLOT(peerSourceReady( kt::PeerSource* )));
|
|
}
|
|
|
|
void PeerSourceManager::removePeerSource(kt::PeerSource* ps)
|
|
{
|
|
disconnect(ps,TQT_SIGNAL(peersReady( kt::PeerSource* )),
|
|
pman,TQT_SLOT(peerSourceReady( kt::PeerSource* )));
|
|
additional.remove(ps);
|
|
}
|
|
|
|
void PeerSourceManager::start()
|
|
{
|
|
if (started)
|
|
return;
|
|
|
|
started = true;
|
|
TQPtrList<kt::PeerSource>::iterator i = additional.begin();
|
|
while (i != additional.end())
|
|
{
|
|
(*i)->start();
|
|
i++;
|
|
}
|
|
|
|
if (!curr)
|
|
{
|
|
if (trackers.count() > 0)
|
|
{
|
|
switchTracker(selectTracker());
|
|
tor->resetTrackerStats();
|
|
curr->start();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tor->resetTrackerStats();
|
|
curr->start();
|
|
}
|
|
}
|
|
|
|
void PeerSourceManager::stop(WaitJob* wjob)
|
|
{
|
|
if (!started)
|
|
return;
|
|
|
|
started = false;
|
|
TQPtrList<kt::PeerSource>::iterator i = additional.begin();
|
|
while (i != additional.end())
|
|
{
|
|
(*i)->stop();
|
|
i++;
|
|
}
|
|
|
|
if (curr)
|
|
curr->stop(wjob);
|
|
|
|
timer.stop();
|
|
statusChanged(i18n("Stopped"));
|
|
}
|
|
|
|
void PeerSourceManager::completed()
|
|
{
|
|
TQPtrList<kt::PeerSource>::iterator i = additional.begin();
|
|
while (i != additional.end())
|
|
{
|
|
(*i)->completed();
|
|
i++;
|
|
}
|
|
|
|
if (curr)
|
|
curr->completed();
|
|
}
|
|
|
|
void PeerSourceManager::manualUpdate()
|
|
{
|
|
TQPtrList<kt::PeerSource>::iterator i = additional.begin();
|
|
while (i != additional.end())
|
|
{
|
|
(*i)->manualUpdate();
|
|
i++;
|
|
}
|
|
|
|
if (curr)
|
|
{
|
|
timer.stop();
|
|
curr->manualUpdate();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
KURL PeerSourceManager::getTrackerURL() const
|
|
{
|
|
if (curr)
|
|
return curr->trackerURL();
|
|
else
|
|
return KURL();
|
|
}
|
|
|
|
KURL::List PeerSourceManager::getTrackerURLs()
|
|
{
|
|
KURL::List urls;
|
|
const TrackerTier* t = tor->getTorrent().getTrackerList();
|
|
while (t)
|
|
{
|
|
urls += t->urls;
|
|
t = t->next;
|
|
}
|
|
|
|
urls += custom_trackers;
|
|
return urls;
|
|
}
|
|
|
|
void PeerSourceManager::addTracker(KURL url, bool custom,int tier)
|
|
{
|
|
if (trackers.contains(url))
|
|
return;
|
|
|
|
Tracker* trk = 0;
|
|
if (url.protocol() == "udp")
|
|
trk = new UDPTracker(url,tor,tor->getTorrent().getPeerID(),tier);
|
|
else
|
|
trk = new HTTPTracker(url,tor,tor->getTorrent().getPeerID(),tier);
|
|
|
|
addTracker(trk);
|
|
if (custom)
|
|
{
|
|
custom_trackers.append(url);
|
|
if (!no_save_custom_trackers)
|
|
saveCustomURLs();
|
|
}
|
|
}
|
|
|
|
bool PeerSourceManager::removeTracker(KURL url)
|
|
{
|
|
if (!custom_trackers.contains(url))
|
|
return false;
|
|
|
|
custom_trackers.remove(url);
|
|
Tracker* trk = trackers.find(url);
|
|
if (curr == trk)
|
|
{
|
|
// do a timed delete on the tracker, so the stop signal
|
|
// has plenty of time to reach it
|
|
trk->stop();
|
|
trk->timedDelete(10 * 1000);
|
|
trackers.setAutoDelete(false);
|
|
trackers.erase(url);
|
|
trackers.setAutoDelete(true);
|
|
|
|
if (trackers.count() > 0)
|
|
{
|
|
switchTracker(selectTracker());
|
|
tor->resetTrackerStats();
|
|
curr->start();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// just delete if not the current one
|
|
trackers.erase(url);
|
|
}
|
|
saveCustomURLs();
|
|
return true;
|
|
}
|
|
|
|
void PeerSourceManager::setTracker(KURL url)
|
|
{
|
|
Tracker* trk = trackers.find(url);
|
|
if (!trk)
|
|
return;
|
|
|
|
if (curr != trk)
|
|
{
|
|
if (curr)
|
|
curr->stop();
|
|
switchTracker(trk);
|
|
tor->resetTrackerStats();
|
|
trk->start();
|
|
}
|
|
}
|
|
|
|
void PeerSourceManager::restoreDefault()
|
|
{
|
|
KURL::List::iterator i = custom_trackers.begin();
|
|
while (i != custom_trackers.end())
|
|
{
|
|
Tracker* t = trackers.find(*i);
|
|
if (t)
|
|
{
|
|
if (curr == t)
|
|
{
|
|
if (t->isStarted())
|
|
t->stop();
|
|
|
|
curr = 0;
|
|
trackers.erase(*i);
|
|
if (trackers.count() > 0)
|
|
{
|
|
switchTracker(trackers.begin()->second);
|
|
if (started)
|
|
{
|
|
tor->resetTrackerStats();
|
|
curr->start();
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
trackers.erase(*i);
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
|
|
custom_trackers.clear();
|
|
saveCustomURLs();
|
|
}
|
|
|
|
void PeerSourceManager::saveCustomURLs()
|
|
{
|
|
TQString trackers_file = tor->getTorDir() + "trackers";
|
|
TQFile file(trackers_file);
|
|
if(!file.open(IO_WriteOnly))
|
|
return;
|
|
|
|
TQTextStream stream(&file);
|
|
for (KURL::List::iterator i = custom_trackers.begin();i != custom_trackers.end();i++)
|
|
stream << (*i).prettyURL() << ::endl;
|
|
}
|
|
|
|
void PeerSourceManager::loadCustomURLs()
|
|
{
|
|
TQString trackers_file = tor->getTorDir() + "trackers";
|
|
TQFile file(trackers_file);
|
|
if(!file.open(IO_ReadOnly))
|
|
return;
|
|
|
|
no_save_custom_trackers = true;
|
|
TQTextStream stream(&file);
|
|
while (!stream.atEnd())
|
|
{
|
|
KURL url = stream.readLine();
|
|
addTracker(url,true);
|
|
}
|
|
no_save_custom_trackers = false;
|
|
}
|
|
|
|
Tracker* PeerSourceManager::selectTracker()
|
|
{
|
|
Tracker* n = 0;
|
|
PtrMap<KURL,Tracker>::iterator i = trackers.begin();
|
|
while (i != trackers.end())
|
|
{
|
|
Tracker* t = i->second;
|
|
if (!n)
|
|
n = t;
|
|
else if (t->failureCount() < n->failureCount())
|
|
n = t;
|
|
else if (t->failureCount() == n->failureCount())
|
|
n = t->getTier() < n->getTier() ? t : n;
|
|
i++;
|
|
}
|
|
|
|
if (n)
|
|
{
|
|
Out(SYS_TRK|LOG_DEBUG) << "Selected tracker " << n->trackerURL().prettyURL()
|
|
<< " (tier = " << n->getTier() << ")" << endl;
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|
|
void PeerSourceManager::onTrackerError(const TQString & err)
|
|
{
|
|
failures++;
|
|
pending = false;
|
|
if (started)
|
|
statusChanged(err);
|
|
|
|
if (!started)
|
|
return;
|
|
|
|
// select an other tracker
|
|
Tracker* trk = selectTracker();
|
|
|
|
if (!trk)
|
|
{
|
|
if (curr->failureCount() > 5)
|
|
{
|
|
// we failed to contact the only tracker 5 times in a row, so try again in
|
|
// 30 minutes
|
|
curr->setInterval(FINAL_WAIT_TIME);
|
|
timer.start(FINAL_WAIT_TIME * 1000,true);
|
|
request_time = TQDateTime::tqcurrentDateTime();
|
|
}
|
|
else if (curr->failureCount() > 2)
|
|
{
|
|
// we failed to contact the only tracker 3 times in a row, so try again in
|
|
// a minute or 5, no need for hammering every 30 seconds
|
|
curr->setInterval(LONGER_WAIT_TIME);
|
|
timer.start(LONGER_WAIT_TIME * 1000,true);
|
|
request_time = TQDateTime::tqcurrentDateTime();
|
|
}
|
|
else
|
|
{
|
|
// lets not hammer and wait 30 seconds
|
|
curr->setInterval(INITIAL_WAIT_TIME);
|
|
timer.start(INITIAL_WAIT_TIME * 1000,true);
|
|
request_time = TQDateTime::tqcurrentDateTime();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
curr->stop();
|
|
// switch to another one
|
|
switchTracker(trk);
|
|
if (trk->failureCount() == 0)
|
|
{
|
|
tor->resetTrackerStats();
|
|
curr->start();
|
|
}
|
|
else if (trk->failureCount() > 5)
|
|
{
|
|
curr->setInterval(FINAL_WAIT_TIME);
|
|
timer.start(FINAL_WAIT_TIME * 1000,true);
|
|
request_time = TQDateTime::tqcurrentDateTime();
|
|
}
|
|
else if (trk->failureCount() > 2)
|
|
{
|
|
// we tried everybody 3 times and it didn't work
|
|
// wait 5 minutes and try again
|
|
curr->setInterval(LONGER_WAIT_TIME);
|
|
timer.start(LONGER_WAIT_TIME * 1000,true);
|
|
request_time = TQDateTime::tqcurrentDateTime();
|
|
}
|
|
else
|
|
{
|
|
// wait 30 seconds and try again
|
|
curr->setInterval(INITIAL_WAIT_TIME);
|
|
timer.start(INITIAL_WAIT_TIME * 1000,true);
|
|
request_time = TQDateTime::tqcurrentDateTime();
|
|
}
|
|
}
|
|
}
|
|
|
|
void PeerSourceManager::onTrackerOK()
|
|
{
|
|
failures = 0;
|
|
if (started)
|
|
{
|
|
timer.start(curr->getInterval() * 1000,true);
|
|
curr->scrape();
|
|
}
|
|
pending = false;
|
|
if (started)
|
|
statusChanged(i18n("OK"));
|
|
request_time = TQDateTime::tqcurrentDateTime();
|
|
}
|
|
|
|
void PeerSourceManager::onTrackerRequestPending()
|
|
{
|
|
if (started)
|
|
statusChanged(i18n("Announcing"));
|
|
pending = true;
|
|
}
|
|
|
|
void PeerSourceManager::updateCurrentManually()
|
|
{
|
|
if (!curr)
|
|
return;
|
|
|
|
if (!curr->isStarted())
|
|
tor->resetTrackerStats();
|
|
|
|
curr->manualUpdate();
|
|
}
|
|
|
|
void PeerSourceManager::switchTracker(Tracker* trk)
|
|
{
|
|
if (curr == trk)
|
|
return;
|
|
|
|
if (curr)
|
|
{
|
|
disconnect(curr,TQT_SIGNAL(requestFailed( const TQString& )),
|
|
this,TQT_SLOT(onTrackerError( const TQString& )));
|
|
disconnect(curr,TQT_SIGNAL(requestOK()),this,TQT_SLOT(onTrackerOK()));
|
|
disconnect(curr,TQT_SIGNAL(requestPending()),this,TQT_SLOT(onTrackerRequestPending()));
|
|
curr = 0;
|
|
}
|
|
|
|
curr = trk;
|
|
if (curr)
|
|
{
|
|
Out(SYS_TRK|LOG_NOTICE) << "Switching to tracker " << trk->trackerURL() << endl;
|
|
TQObject::connect(curr,TQT_SIGNAL(requestFailed( const TQString& )),
|
|
this,TQT_SLOT(onTrackerError( const TQString& )));
|
|
|
|
TQObject::connect(curr,TQT_SIGNAL(requestOK()),
|
|
this,TQT_SLOT(onTrackerOK()));
|
|
|
|
TQObject::connect(curr,TQT_SIGNAL(requestPending()),
|
|
this,TQT_SLOT(onTrackerRequestPending()));
|
|
}
|
|
}
|
|
|
|
Uint32 PeerSourceManager::getTimeToNextUpdate() const
|
|
{
|
|
if (pending || !started || !curr)
|
|
return 0;
|
|
|
|
return curr->getInterval() - request_time.secsTo(TQDateTime::tqcurrentDateTime());
|
|
}
|
|
|
|
Uint32 PeerSourceManager::getNumSeeders() const
|
|
{
|
|
return curr ? curr->getNumSeeders() : 0;
|
|
}
|
|
|
|
|
|
Uint32 PeerSourceManager::getNumLeechers() const
|
|
{
|
|
return curr ? curr->getNumLeechers() : 0;
|
|
}
|
|
|
|
void PeerSourceManager::addDHT()
|
|
{
|
|
if(m_dht)
|
|
{
|
|
removePeerSource(m_dht);
|
|
delete m_dht;
|
|
}
|
|
|
|
m_dht = new dht::DHTTrackerBackend(Globals::instance().getDHT(),tor);
|
|
|
|
// add the DHT source
|
|
addPeerSource(m_dht);
|
|
}
|
|
|
|
void PeerSourceManager::removeDHT()
|
|
{
|
|
if(m_dht == 0)
|
|
{
|
|
removePeerSource(m_dht);
|
|
return;
|
|
}
|
|
|
|
removePeerSource(m_dht);
|
|
delete m_dht;
|
|
m_dht = 0;
|
|
}
|
|
|
|
bool PeerSourceManager::dhtStarted()
|
|
{
|
|
return m_dht != 0;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
#include "peersourcemanager.moc"
|