From 9ad5c7b5e23b4940e7a3ea3ca3a6fb77e6a8fab0 Mon Sep 17 00:00:00 2001 From: tpearson Date: Wed, 20 Jan 2010 02:37:40 +0000 Subject: Updated to final KDE3 ktorrent release (2.2.6) git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/ktorrent@1077377 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- libktorrent/torrent/torrentcontrol.cpp | 1770 ++++++++++++++++++++++++++++++++ 1 file changed, 1770 insertions(+) create mode 100644 libktorrent/torrent/torrentcontrol.cpp (limited to 'libktorrent/torrent/torrentcontrol.cpp') diff --git a/libktorrent/torrent/torrentcontrol.cpp b/libktorrent/torrent/torrentcontrol.cpp new file mode 100644 index 0000000..71b4e64 --- /dev/null +++ b/libktorrent/torrent/torrentcontrol.cpp @@ -0,0 +1,1770 @@ +/*************************************************************************** + * Copyright (C) 2005 by * + * Joris Guisson * + * Ivan Vasic * + * * + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "downloader.h" +#include "uploader.h" +#include "peersourcemanager.h" +#include "chunkmanager.h" +#include "torrent.h" +#include "peermanager.h" + +#include "torrentfile.h" +#include "torrentcontrol.h" + +#include "peer.h" +#include "choker.h" + +#include "globals.h" +#include "server.h" +#include "packetwriter.h" +#include "httptracker.h" +#include "udptracker.h" +#include "downloadcap.h" +#include "uploadcap.h" +#include "queuemanager.h" +#include "statsfile.h" +#include "announcelist.h" +#include "preallocationthread.h" +#include "timeestimator.h" +#include "settings.h" + +#include + + +using namespace kt; + +namespace bt +{ + + + + TorrentControl::TorrentControl() + : tor(0),psman(0),cman(0),pman(0),down(0),up(0),choke(0),tmon(0),prealloc(false) + { + istats.last_announce = 0; + stats.imported_bytes = 0; + stats.trk_bytes_downloaded = 0; + stats.trk_bytes_uploaded = 0; + stats.running = false; + stats.started = false; + stats.stopped_by_error = false; + stats.session_bytes_downloaded = 0; + stats.session_bytes_uploaded = 0; + istats.session_bytes_uploaded = 0; + old_datadir = QString::null; + stats.status = NOT_STARTED; + stats.autostart = true; + stats.user_controlled = false; + stats.priv_torrent = false; + stats.seeders_connected_to = stats.seeders_total = 0; + stats.leechers_connected_to = stats.leechers_total = 0; + istats.running_time_dl = istats.running_time_ul = 0; + istats.prev_bytes_dl = 0; + istats.prev_bytes_ul = 0; + istats.trk_prev_bytes_dl = istats.trk_prev_bytes_ul = 0; + istats.io_error = false; + istats.priority = 0; + stats.max_share_ratio = 0.00f; + istats.custom_output_name = false; + istats.diskspace_warning_emitted = false; + stats.max_seed_time = 0; + updateStats(); + prealoc_thread = 0; + dcheck_thread = 0; + istats.dht_on = false; + stats.num_corrupted_chunks = 0; + + m_eta = new TimeEstimator(this); + // by default no torrent limits + upload_gid = download_gid = 0; + upload_limit = download_limit = 0; + moving_files = false; + } + + + + + TorrentControl::~TorrentControl() + { + if (stats.running) + stop(false); + + if (tmon) + tmon->destroyed(); + delete choke; + delete down; + delete up; + delete cman; + delete pman; + delete psman; + delete tor; + delete m_eta; + } + + void TorrentControl::update() + { + UpdateCurrentTime(); + if (stats.status == kt::CHECKING_DATA || moving_files) + return; + + if (istats.io_error) + { + stop(false); + emit stoppedByError(this, error_msg); + return; + } + + if (prealoc_thread) + { + if (prealoc_thread->isDone()) + { + // thread done + if (prealoc_thread->errorHappened()) + { + // upon error just call onIOError and return + onIOError(prealoc_thread->errorMessage()); + delete prealoc_thread; + prealoc_thread = 0; + prealloc = true; // still need to do preallocation + return; + } + else + { + // continue the startup of the torrent + delete prealoc_thread; + prealoc_thread = 0; + prealloc = false; + stats.status = kt::NOT_STARTED; + saveStats(); + continueStart(); + } + } + else + return; // preallocation still going on, so just return + } + + + try + { + // first update peermanager + pman->update(); + bool comp = stats.completed; + + //helper var, check if needed to move completed files somewhere + bool moveCompleted = false; + + // then the downloader and uploader + up->update(choke->getOptimisticlyUnchokedPeerID()); + down->update(); + + stats.completed = cman->completed(); + if (stats.completed && !comp) + { + pman->killSeeders(); + QDateTime now = QDateTime::currentDateTime(); + istats.running_time_dl += istats.time_started_dl.secsTo(now); + updateStatusMsg(); + updateStats(); + + // download has just been completed + // only sent completed to tracker when we have all chunks (so no excluded chunks) + if (cman->haveAllChunks()) + psman->completed(); + + finished(this); + + //Move completed download to specified directory if needed + if(Settings::useCompletedDir()) + { + moveCompleted = true; + } + } + else if (!stats.completed && comp) + { + // restart download if necesarry + // when user selects that files which were previously excluded, + // should now be downloaded + if (!psman->isStarted()) + psman->start(); + else + psman->manualUpdate(); + istats.last_announce = bt::GetCurrentTime(); + istats.time_started_dl = QDateTime::currentDateTime(); + } + updateStatusMsg(); + + // get rid of dead Peers + Uint32 num_cleared = pman->clearDeadPeers(); + + // we may need to update the choker + if (choker_update_timer.getElapsedSinceUpdate() >= 10000 || num_cleared > 0) + { + // also get rid of seeders & uninterested when download is finished + // no need to keep them around, but also no need to do this + // every update, so once every 10 seconds is fine + if (stats.completed) + { + pman->killSeeders(); + } + + doChoking(); + choker_update_timer.update(); + // a good opportunity to make sure we are not keeping to much in memory + cman->checkMemoryUsage(); + } + + // to satisfy people obsessed with their share ratio + if (stats_save_timer.getElapsedSinceUpdate() >= 5*60*1000) + { + saveStats(); + stats_save_timer.update(); + } + + // Update DownloadCap + updateStats(); + + if (stats.download_rate > 0) + stalled_timer.update(); + + // do a manual update if we are stalled for more then 2 minutes + // we do not do this for private torrents + if (stalled_timer.getElapsedSinceUpdate() > 120000 && !stats.completed && + !stats.priv_torrent) + { + Out(SYS_TRK|LOG_NOTICE) << "Stalled for too long, time to get some fresh blood" << endl; + psman->manualUpdate(); + stalled_timer.update(); + } + + if(overMaxRatio() || overMaxSeedTime()) + { + if(istats.priority!=0) //if it's queued make sure to dequeue it + { + setPriority(0); + stats.user_controlled = true; + } + + stop(true); + emit seedingAutoStopped(this, overMaxRatio() ? kt::MAX_RATIO_REACHED : kt::MAX_SEED_TIME_REACHED); + } + + //Update diskspace if needed (every 1 min) + if(!stats.completed && stats.running && bt::GetCurrentTime() - last_diskspace_check >= 60 * 1000) + { + checkDiskSpace(true); + } + + //Move completed files if needed: + if (moveCompleted) + { + QString outdir = Settings::completedDir(); + if(!outdir.endsWith(bt::DirSeparator())) + outdir += bt::DirSeparator(); + + changeOutputDir(outdir); + } + } + catch (Error & e) + { + onIOError(e.toString()); + } + } + + void TorrentControl::onIOError(const QString & msg) + { + Out(SYS_DIO|LOG_IMPORTANT) << "Error : " << msg << endl; + stats.stopped_by_error = true; + stats.status = ERROR; + error_msg = msg; + istats.io_error = true; + } + + void TorrentControl::start() + { + // do not start running torrents + if (stats.running || stats.status == kt::ALLOCATING_DISKSPACE || moving_files) + return; + + stats.stopped_by_error = false; + istats.diskspace_warning_emitted = false; + istats.io_error = false; + try + { + bool ret = true; + aboutToBeStarted(this,ret); + if (!ret) + return; + } + catch (Error & err) + { + // something went wrong when files were recreated, set error and rethrow + onIOError(err.toString()); + return; + } + + try + { + cman->start(); + } + catch (Error & e) + { + onIOError(e.toString()); + throw; + } + + istats.time_started_ul = istats.time_started_dl = QDateTime::currentDateTime(); + resetTrackerStats(); + + if (prealloc) + { + // only start preallocation if we are allowed by the settings + if (Settings::diskPrealloc() && !cman->haveAllChunks()) + { + Out(SYS_GEN|LOG_NOTICE) << "Pre-allocating diskspace" << endl; + prealoc_thread = new PreallocationThread(cman); + stats.running = true; + stats.status = kt::ALLOCATING_DISKSPACE; + prealoc_thread->start(); + return; + } + else + { + prealloc = false; + } + } + + continueStart(); + } + + void TorrentControl::continueStart() + { + // continues start after the prealoc_thread has finished preallocation + pman->start(); + pman->loadPeerList(datadir + "peer_list"); + try + { + down->loadDownloads(datadir + "current_chunks"); + } + catch (Error & e) + { + // print out warning in case of failure + // we can still continue the download + Out(SYS_GEN|LOG_NOTICE) << "Warning : " << e.toString() << endl; + } + + loadStats(); + stats.running = true; + stats.started = true; + stats.autostart = true; + choker_update_timer.update(); + stats_save_timer.update(); + + + stalled_timer.update(); + psman->start(); + istats.last_announce = bt::GetCurrentTime(); + stalled_timer.update(); + } + + + void TorrentControl::stop(bool user,WaitJob* wjob) + { + QDateTime now = QDateTime::currentDateTime(); + if(!stats.completed) + istats.running_time_dl += istats.time_started_dl.secsTo(now); + istats.running_time_ul += istats.time_started_ul.secsTo(now); + istats.time_started_ul = istats.time_started_dl = now; + + // stop preallocation thread if necesarry + if (prealoc_thread) + { + prealoc_thread->stop(); + prealoc_thread->wait(); + + if (prealoc_thread->errorHappened() || prealoc_thread->isNotFinished()) + { + delete prealoc_thread; + prealoc_thread = 0; + prealloc = true; + saveStats(); // save stats, so that we will start preallocating the next time + } + else + { + delete prealoc_thread; + prealoc_thread = 0; + prealloc = false; + } + } + + if (stats.running) + { + psman->stop(wjob); + + if (tmon) + tmon->stopped(); + + try + { + down->saveDownloads(datadir + "current_chunks"); + } + catch (Error & e) + { + // print out warning in case of failure + // it doesn't corrupt the data, so just a couple of lost chunks + Out(SYS_GEN|LOG_NOTICE) << "Warning : " << e.toString() << endl; + } + + down->clearDownloads(); + if (user) + { + //make this torrent user controlled + setPriority(0); + stats.autostart = false; + } + } + pman->savePeerList(datadir + "peer_list"); + pman->stop(); + pman->closeAllConnections(); + pman->clearDeadPeers(); + cman->stop(); + + stats.running = false; + saveStats(); + updateStatusMsg(); + updateStats(); + stats.trk_bytes_downloaded = 0; + stats.trk_bytes_uploaded = 0; + + emit torrentStopped(this); + } + + void TorrentControl::setMonitor(kt::MonitorInterface* tmo) + { + tmon = tmo; + down->setMonitor(tmon); + if (tmon) + { + for (Uint32 i = 0;i < pman->getNumConnectedPeers();i++) + tmon->peerAdded(pman->getPeer(i)); + } + } + + + void TorrentControl::init(QueueManager* qman, + const QString & torrent, + const QString & tmpdir, + const QString & ddir, + const QString & default_save_dir) + { + // first load the torrent file + tor = new Torrent(); + try + { + tor->load(torrent,false); + } + catch (...) + { + delete tor; + tor = 0; + throw Error(i18n("An error occurred while loading the torrent." + " The torrent is probably corrupt or is not a torrent file.\n%1").arg(torrent)); + } + + initInternal(qman,tmpdir,ddir,default_save_dir,torrent.startsWith(tmpdir)); + + // copy torrent in tor dir + QString tor_copy = datadir + "torrent"; + if (tor_copy != torrent) + { + bt::CopyFile(torrent,tor_copy); + } + + } + + + void TorrentControl::init(QueueManager* qman, const QByteArray & data,const QString & tmpdir, + const QString & ddir,const QString & default_save_dir) + { + // first load the torrent file + tor = new Torrent(); + try + { + tor->load(data,false); + } + catch (...) + { + delete tor; + tor = 0; + throw Error(i18n("An error occurred while loading the torrent." + " The torrent is probably corrupt or is not a torrent file.")); + } + + initInternal(qman,tmpdir,ddir,default_save_dir,true); + // copy data into torrent file + QString tor_copy = datadir + "torrent"; + QFile fptr(tor_copy); + if (!fptr.open(IO_WriteOnly)) + throw Error(i18n("Unable to create %1 : %2") + .arg(tor_copy).arg(fptr.errorString())); + + fptr.writeBlock(data.data(),data.size()); + } + + void TorrentControl::checkExisting(QueueManager* qman) + { + // check if we haven't already loaded the torrent + // only do this when qman isn't 0 + if (qman && qman->allreadyLoaded(tor->getInfoHash())) + { + if (!stats.priv_torrent) + { + qman->mergeAnnounceList(tor->getInfoHash(),tor->getTrackerList()); + + throw Error(i18n("You are already downloading this torrent %1, the list of trackers of both torrents has been merged.").arg(tor->getNameSuggestion())); + } + else + { + throw Error(i18n("You are already downloading the torrent %1") + .arg(tor->getNameSuggestion())); + } + } + } + + void TorrentControl::setupDirs(const QString & tmpdir,const QString & ddir) + { + datadir = tmpdir; + + if (!datadir.endsWith(DirSeparator())) + datadir += DirSeparator(); + + outputdir = ddir.stripWhiteSpace(); + if (outputdir.length() > 0 && !outputdir.endsWith(DirSeparator())) + outputdir += DirSeparator(); + + if (!bt::Exists(datadir)) + { + bt::MakeDir(datadir); + } + } + + void TorrentControl::setupStats() + { + stats.completed = false; + stats.running = false; + stats.torrent_name = tor->getNameSuggestion(); + stats.multi_file_torrent = tor->isMultiFile(); + stats.total_bytes = tor->getFileLength(); + stats.priv_torrent = tor->isPrivate(); + + // check the stats file for the custom_output_name variable + StatsFile st(datadir + "stats"); + if (st.hasKey("CUSTOM_OUTPUT_NAME") && st.readULong("CUSTOM_OUTPUT_NAME") == 1) + { + istats.custom_output_name = true; + } + + // load outputdir if outputdir is null + if (outputdir.isNull() || outputdir.length() == 0) + loadOutputDir(); + } + + void TorrentControl::setupData(const QString & ddir) + { + // create PeerManager and Tracker + pman = new PeerManager(*tor); + //Out() << "Tracker url " << url << " " << url.protocol() << " " << url.prettyURL() << endl; + psman = new PeerSourceManager(this,pman); + connect(psman,SIGNAL(statusChanged( const QString& )), + this,SLOT(trackerStatusChanged( const QString& ))); + + + // Create chunkmanager, load the index file if it exists + // else create all the necesarry files + cman = new ChunkManager(*tor,datadir,outputdir,istats.custom_output_name); + // outputdir is null, see if the cache has figured out what it is + if (outputdir.length() == 0) + outputdir = cman->getDataDir(); + + // store the outputdir into the output_path variable, so others can access it + + connect(cman,SIGNAL(updateStats()),this,SLOT(updateStats())); + if (bt::Exists(datadir + "index")) + cman->loadIndexFile(); + + stats.completed = cman->completed(); + + // create downloader,uploader and choker + down = new Downloader(*tor,*pman,*cman); + connect(down,SIGNAL(ioError(const QString& )), + this,SLOT(onIOError(const QString& ))); + up = new Uploader(*cman,*pman); + choke = new Choker(*pman,*cman); + + + connect(pman,SIGNAL(newPeer(Peer* )),this,SLOT(onNewPeer(Peer* ))); + connect(pman,SIGNAL(peerKilled(Peer* )),this,SLOT(onPeerRemoved(Peer* ))); + connect(cman,SIGNAL(excluded(Uint32, Uint32 )),down,SLOT(onExcluded(Uint32, Uint32 ))); + connect(cman,SIGNAL(included( Uint32, Uint32 )),down,SLOT(onIncluded( Uint32, Uint32 ))); + connect(cman,SIGNAL(corrupted( Uint32 )),this,SLOT(corrupted( Uint32 ))); + } + + void TorrentControl::initInternal(QueueManager* qman, + const QString & tmpdir, + const QString & ddir, + const QString & default_save_dir, + bool first_time) + { + checkExisting(qman); + setupDirs(tmpdir,ddir); + setupStats(); + + if (!first_time) + { + // if we do not need to copy the torrent, it is an existing download and we need to see + // if it is not an old download + try + { + migrateTorrent(default_save_dir); + } + catch (Error & err) + { + + throw Error( + i18n("Cannot migrate %1 : %2") + .arg(tor->getNameSuggestion()).arg(err.toString())); + } + } + setupData(ddir); + + updateStatusMsg(); + + // to get rid of phantom bytes we need to take into account + // the data from downloads already in progress + try + { + Uint64 db = down->bytesDownloaded(); + Uint64 cb = down->getDownloadedBytesOfCurrentChunksFile(datadir + "current_chunks"); + istats.prev_bytes_dl = db + cb; + + // Out() << "Downloaded : " << kt::BytesToString(db) << endl; + // Out() << "current_chunks : " << kt::BytesToString(cb) << endl; + } + catch (Error & e) + { + // print out warning in case of failure + Out() << "Warning : " << e.toString() << endl; + istats.prev_bytes_dl = down->bytesDownloaded(); + } + + loadStats(); + updateStats(); + saveStats(); + stats.output_path = cman->getOutputPath(); + /* if (stats.output_path.isNull()) + { + cman->createFiles(); + stats.output_path = cman->getOutputPath(); + }*/ + Out() << "OutputPath = " << stats.output_path << endl; + } + + + + bool TorrentControl::announceAllowed() + { + if(istats.last_announce == 0) + return true; + + if (psman && psman->getNumFailures() == 0) + return bt::GetCurrentTime() - istats.last_announce >= 60 * 1000; + else + return true; + } + + void TorrentControl::updateTracker() + { + if (stats.running && announceAllowed()) + { + psman->manualUpdate(); + istats.last_announce = bt::GetCurrentTime(); + } + } + + void TorrentControl::onNewPeer(Peer* p) + { + connect(p,SIGNAL(gotPortPacket( const QString&, Uint16 )), + this,SLOT(onPortPacket( const QString&, Uint16 ))); + + if (p->getStats().fast_extensions) + { + const BitSet & bs = cman->getBitSet(); + if (bs.allOn()) + p->getPacketWriter().sendHaveAll(); + else if (bs.numOnBits() == 0) + p->getPacketWriter().sendHaveNone(); + else + p->getPacketWriter().sendBitSet(bs); + } + else + { + p->getPacketWriter().sendBitSet(cman->getBitSet()); + } + + if (!stats.completed) + p->getPacketWriter().sendInterested(); + + if (!stats.priv_torrent) + { + if (p->isDHTSupported()) + p->getPacketWriter().sendPort(Globals::instance().getDHT().getPort()); + else + // WORKAROUND so we can contact µTorrent's DHT + // They do not properly support the standard and do not turn on + // the DHT bit in the handshake, so we just ping each peer by default. + p->emitPortPacket(); + } + + // set group ID's for traffic shaping + p->setGroupIDs(upload_gid,download_gid); + + if (tmon) + tmon->peerAdded(p); + } + + void TorrentControl::onPeerRemoved(Peer* p) + { + disconnect(p,SIGNAL(gotPortPacket( const QString&, Uint16 )), + this,SLOT(onPortPacket( const QString&, Uint16 ))); + if (tmon) + tmon->peerRemoved(p); + } + + void TorrentControl::doChoking() + { + choke->update(stats.completed,stats); + } + + bool TorrentControl::changeDataDir(const QString & new_dir) + { + int pos = datadir.findRev(bt::DirSeparator(),-2); + if (pos == -1) + { + Out(SYS_GEN|LOG_DEBUG) << "Could not find torX part in " << datadir << endl; + return false; + } + + QString ndatadir = new_dir + datadir.mid(pos + 1); + + Out(SYS_GEN|LOG_DEBUG) << datadir << " -> " << ndatadir << endl; + try + { + bt::Move(datadir,ndatadir); + old_datadir = datadir; + datadir = ndatadir; + } + catch (Error & err) + { + Out(SYS_GEN|LOG_IMPORTANT) << "Could not move " << datadir << " to " << ndatadir << endl; + return false; + } + + cman->changeDataDir(datadir); + return true; + } + + bool TorrentControl::changeOutputDir(const QString & new_dir, bool moveFiles) + { + if (moving_files) + return false; + + Out(SYS_GEN|LOG_NOTICE) << "Moving data for torrent " << stats.torrent_name << " to " << new_dir << endl; + + restart_torrent_after_move_data_files = false; + + //check if torrent is running and stop it before moving data + if(stats.running) + { + restart_torrent_after_move_data_files = true; + this->stop(false); + } + + moving_files = true; + try + { + QString nd; + if (istats.custom_output_name) + { + int slash_pos = stats.output_path.findRev(bt::DirSeparator(),-2); + nd = new_dir + stats.output_path.mid(slash_pos + 1); + } + else + { + nd = new_dir + tor->getNameSuggestion(); + } + + if (stats.output_path != nd) + { + KIO::Job* j = 0; + if(moveFiles) + { + if (stats.multi_file_torrent) + j = cman->moveDataFiles(nd); + else + j = cman->moveDataFiles(new_dir); + } + + move_data_files_destination_path = nd; + if (j) + { + connect(j,SIGNAL(result(KIO::Job*)),this,SLOT(moveDataFilesJobDone(KIO::Job*))); + return true; + } + else + { + moveDataFilesJobDone(0); + } + } + else + { + Out(SYS_GEN|LOG_NOTICE) << "Source is the same as destination, so doing nothing" << endl; + } + } + catch (Error& err) + { + Out(SYS_GEN|LOG_IMPORTANT) << "Could not move " << stats.output_path << " to " << new_dir << ". Exception: " << err.toString() << endl; + moving_files = false; + return false; + } + + moving_files = false; + if (restart_torrent_after_move_data_files) + { + this->start(); + } + + return true; + } + + void TorrentControl::moveDataFilesJobDone(KIO::Job* job) + { + if (job) + cman->moveDataFilesCompleted(job); + + if (!job || (job && !job->error())) + { + cman->changeOutputPath(move_data_files_destination_path); + outputdir = stats.output_path = move_data_files_destination_path; + istats.custom_output_name = true; + + saveStats(); + Out(SYS_GEN|LOG_NOTICE) << "Data directory changed for torrent " << "'" << stats.torrent_name << "' to: " << move_data_files_destination_path << endl; + } + else if (job->error()) + { + Out(SYS_GEN|LOG_IMPORTANT) << "Could not move " << stats.output_path << " to " << move_data_files_destination_path << endl; + } + + moving_files = false; + if (restart_torrent_after_move_data_files) + { + this->start(); + } + } + + + void TorrentControl::rollback() + { + try + { + bt::Move(datadir,old_datadir); + datadir = old_datadir; + cman->changeDataDir(datadir); + } + catch (Error & err) + { + Out(SYS_GEN|LOG_IMPORTANT) << "Could not move " << datadir << " to " << old_datadir << endl; + } + } + + void TorrentControl::updateStatusMsg() + { + if (stats.stopped_by_error) + stats.status = kt::ERROR; + else if (!stats.started) + stats.status = kt::NOT_STARTED; + else if(!stats.running && !stats.user_controlled) + stats.status = kt::QUEUED; + else if (!stats.running && stats.completed && (overMaxRatio() || overMaxSeedTime())) + stats.status = kt::SEEDING_COMPLETE; + else if (!stats.running && stats.completed) + stats.status = kt::DOWNLOAD_COMPLETE; + else if (!stats.running) + stats.status = kt::STOPPED; + else if (stats.running && stats.completed) + stats.status = kt::SEEDING; + else if (stats.running) + // protocol messages are also included in speed calculation, so lets not compare with 0 + stats.status = down->downloadRate() > 100 ? + kt::DOWNLOADING : kt::STALLED; + } + + const BitSet & TorrentControl::downloadedChunksBitSet() const + { + if (cman) + return cman->getBitSet(); + else + return BitSet::null; + } + + const BitSet & TorrentControl::availableChunksBitSet() const + { + if (!pman) + return BitSet::null; + else + return pman->getAvailableChunksBitSet(); + } + + const BitSet & TorrentControl::excludedChunksBitSet() const + { + if (!cman) + return BitSet::null; + else + return cman->getExcludedBitSet(); + } + + const BitSet & TorrentControl::onlySeedChunksBitSet() const + { + if (!cman) + return BitSet::null; + else + return cman->getOnlySeedBitSet(); + } + + void TorrentControl::saveStats() + { + StatsFile st(datadir + "stats"); + + st.write("OUTPUTDIR", cman->getDataDir()); + + if (cman->getDataDir() != outputdir) + outputdir = cman->getDataDir(); + + st.write("UPLOADED", QString::number(up->bytesUploaded())); + + if (stats.running) + { + QDateTime now = QDateTime::currentDateTime(); + st.write("RUNNING_TIME_DL",QString("%1").arg(istats.running_time_dl + istats.time_started_dl.secsTo(now))); + st.write("RUNNING_TIME_UL",QString("%1").arg(istats.running_time_ul + istats.time_started_ul.secsTo(now))); + } + else + { + st.write("RUNNING_TIME_DL", QString("%1").arg(istats.running_time_dl)); + st.write("RUNNING_TIME_UL", QString("%1").arg(istats.running_time_ul)); + } + + st.write("PRIORITY", QString("%1").arg(istats.priority)); + st.write("AUTOSTART", QString("%1").arg(stats.autostart)); + st.write("IMPORTED", QString("%1").arg(stats.imported_bytes)); + st.write("CUSTOM_OUTPUT_NAME",istats.custom_output_name ? "1" : "0"); + st.write("MAX_RATIO", QString("%1").arg(stats.max_share_ratio,0,'f',2)); + st.write("MAX_SEED_TIME",QString::number(stats.max_seed_time)); + st.write("RESTART_DISK_PREALLOCATION",prealloc ? "1" : "0"); + + if(!stats.priv_torrent) + { + //save dht and pex + st.write("DHT", isFeatureEnabled(kt::DHT_FEATURE) ? "1" : "0"); + st.write("UT_PEX", isFeatureEnabled(kt::UT_PEX_FEATURE) ? "1" : "0"); + } + + st.write("UPLOAD_LIMIT",QString::number(upload_limit)); + st.write("DOWNLOAD_LIMIT",QString::number(download_limit)); + + st.writeSync(); + } + + void TorrentControl::loadStats() + { + StatsFile st(datadir + "stats"); + + Uint64 val = st.readUint64("UPLOADED"); + // stats.session_bytes_uploaded will be calculated based upon prev_bytes_ul + // seeing that this will change here, we need to save it + istats.session_bytes_uploaded = stats.session_bytes_uploaded; + istats.prev_bytes_ul = val; + up->setBytesUploaded(val); + + this->istats.running_time_dl = st.readULong("RUNNING_TIME_DL"); + this->istats.running_time_ul = st.readULong("RUNNING_TIME_UL"); + outputdir = st.readString("OUTPUTDIR").stripWhiteSpace(); + if (st.hasKey("CUSTOM_OUTPUT_NAME") && st.readULong("CUSTOM_OUTPUT_NAME") == 1) + { + istats.custom_output_name = true; + } + + setPriority(st.readInt("PRIORITY")); + stats.user_controlled = istats.priority == 0 ? true : false; + stats.autostart = st.readBoolean("AUTOSTART"); + + stats.imported_bytes = st.readUint64("IMPORTED"); + float rat = st.readFloat("MAX_RATIO"); + stats.max_share_ratio = rat; + if (st.hasKey("RESTART_DISK_PREALLOCATION")) + prealloc = st.readString("RESTART_DISK_PREALLOCATION") == "1"; + + stats.max_seed_time = st.readFloat("MAX_SEED_TIME"); + + if (!stats.priv_torrent) + { + if(st.hasKey("DHT")) + istats.dht_on = st.readBoolean("DHT"); + else + istats.dht_on = true; + + setFeatureEnabled(kt::DHT_FEATURE,istats.dht_on); + if (st.hasKey("UT_PEX")) + setFeatureEnabled(kt::UT_PEX_FEATURE,st.readBoolean("UT_PEX")); + } + + net::SocketMonitor & smon = net::SocketMonitor::instance(); + + Uint32 nl = st.readInt("UPLOAD_LIMIT"); + if (nl != upload_limit) + { + if (nl > 0) + { + if (upload_gid) + smon.setGroupLimit(net::SocketMonitor::UPLOAD_GROUP,upload_gid,nl); + else + upload_gid = smon.newGroup(net::SocketMonitor::UPLOAD_GROUP,nl); + } + else + { + smon.removeGroup(net::SocketMonitor::UPLOAD_GROUP,upload_gid); + upload_gid = 0; + } + } + upload_limit = nl; + + nl = st.readInt("DOWNLOAD_LIMIT"); + if (nl != download_limit) + { + if (nl > 0) + { + if (download_gid) + smon.setGroupLimit(net::SocketMonitor::DOWNLOAD_GROUP,download_gid,nl); + else + download_gid = smon.newGroup(net::SocketMonitor::DOWNLOAD_GROUP,nl); + } + else + { + smon.removeGroup(net::SocketMonitor::DOWNLOAD_GROUP,download_gid); + download_gid = 0; + } + } + download_limit = nl; + } + + void TorrentControl::loadOutputDir() + { + StatsFile st(datadir + "stats"); + if (!st.hasKey("OUTPUTDIR")) + return; + + outputdir = st.readString("OUTPUTDIR").stripWhiteSpace(); + if (st.hasKey("CUSTOM_OUTPUT_NAME") && st.readULong("CUSTOM_OUTPUT_NAME") == 1) + { + istats.custom_output_name = true; + } + } + + bool TorrentControl::readyForPreview(int start_chunk, int end_chunk) + { + if ( !tor->isMultimedia() && !tor->isMultiFile()) return false; + + const BitSet & bs = downloadedChunksBitSet(); + for(int i = start_chunk; igetTimeToNextUpdate(); + else + return 0; + } + + void TorrentControl::updateStats() + { + stats.num_chunks_downloading = down ? down->numActiveDownloads() : 0; + stats.num_peers = pman ? pman->getNumConnectedPeers() : 0; + stats.upload_rate = up && stats.running ? up->uploadRate() : 0; + stats.download_rate = down && stats.running ? down->downloadRate() : 0; + stats.bytes_left = cman ? cman->bytesLeft() : 0; + stats.bytes_left_to_download = cman ? cman->bytesLeftToDownload() : 0; + stats.bytes_uploaded = up ? up->bytesUploaded() : 0; + stats.bytes_downloaded = down ? down->bytesDownloaded() : 0; + stats.total_chunks = tor ? tor->getNumChunks() : 0; + stats.num_chunks_downloaded = cman ? cman->chunksDownloaded() : 0; + stats.num_chunks_excluded = cman ? cman->chunksExcluded() : 0; + stats.chunk_size = tor ? tor->getChunkSize() : 0; + stats.num_chunks_left = cman ? cman->chunksLeft() : 0; + stats.total_bytes_to_download = (tor && cman) ? tor->getFileLength() - cman->bytesExcluded() : 0; + + if (stats.bytes_downloaded >= istats.prev_bytes_dl) + stats.session_bytes_downloaded = stats.bytes_downloaded - istats.prev_bytes_dl; + else + stats.session_bytes_downloaded = 0; + + if (stats.bytes_uploaded >= istats.prev_bytes_ul) + stats.session_bytes_uploaded = (stats.bytes_uploaded - istats.prev_bytes_ul) + istats.session_bytes_uploaded; + else + stats.session_bytes_uploaded = istats.session_bytes_uploaded; + /* + Safety check, it is possible that stats.bytes_downloaded gets subtracted in Downloader. + Which can cause stats.bytes_downloaded to be smaller the istats.trk_prev_bytes_dl. + This can screw up your download ratio. + */ + if (stats.bytes_downloaded >= istats.trk_prev_bytes_dl) + stats.trk_bytes_downloaded = stats.bytes_downloaded - istats.trk_prev_bytes_dl; + else + stats.trk_bytes_downloaded = 0; + + if (stats.bytes_uploaded >= istats.trk_prev_bytes_ul) + stats.trk_bytes_uploaded = stats.bytes_uploaded - istats.trk_prev_bytes_ul; + else + stats.trk_bytes_uploaded = 0; + + getSeederInfo(stats.seeders_total,stats.seeders_connected_to); + getLeecherInfo(stats.leechers_total,stats.leechers_connected_to); + } + + void TorrentControl::getSeederInfo(Uint32 & total,Uint32 & connected_to) const + { + total = 0; + connected_to = 0; + if (!pman || !psman) + return; + + for (Uint32 i = 0;i < pman->getNumConnectedPeers();i++) + { + if (pman->getPeer(i)->isSeeder()) + connected_to++; + } + total = psman->getNumSeeders(); + if (total == 0) + total = connected_to; + } + + void TorrentControl::getLeecherInfo(Uint32 & total,Uint32 & connected_to) const + { + total = 0; + connected_to = 0; + if (!pman || !psman) + return; + + for (Uint32 i = 0;i < pman->getNumConnectedPeers();i++) + { + if (!pman->getPeer(i)->isSeeder()) + connected_to++; + } + total = psman->getNumLeechers(); + if (total == 0) + total = connected_to; + } + + Uint32 TorrentControl::getRunningTimeDL() const + { + if (!stats.running || stats.completed) + return istats.running_time_dl; + else + return istats.running_time_dl + istats.time_started_dl.secsTo(QDateTime::currentDateTime()); + } + + Uint32 TorrentControl::getRunningTimeUL() const + { + if (!stats.running) + return istats.running_time_ul; + else + return istats.running_time_ul + istats.time_started_ul.secsTo(QDateTime::currentDateTime()); + } + + Uint32 TorrentControl::getNumFiles() const + { + if (tor && tor->isMultiFile()) + return tor->getNumFiles(); + else + return 0; + } + + TorrentFileInterface & TorrentControl::getTorrentFile(Uint32 index) + { + if (tor) + return tor->getFile(index); + else + return TorrentFile::null; + } + + void TorrentControl::migrateTorrent(const QString & default_save_dir) + { + if (bt::Exists(datadir + "current_chunks") && bt::IsPreMMap(datadir + "current_chunks")) + { + // in case of error copy torX dir to migrate-failed-tor + QString dd = datadir; + int pos = dd.findRev("tor"); + if (pos != - 1) + { + dd = dd.replace(pos,3,"migrate-failed-tor"); + Out() << "Copying " << datadir << " to " << dd << endl; + bt::CopyDir(datadir,dd,true); + } + + bt::MigrateCurrentChunks(*tor,datadir + "current_chunks"); + if (outputdir.isNull() && bt::IsCacheMigrateNeeded(*tor,datadir + "cache")) + { + // if the output dir is NULL + if (default_save_dir.isNull()) + { + KMessageBox::information(0, + i18n("The torrent %1 was started with a previous version of KTorrent." + " To make sure this torrent still works with this version of KTorrent, " + "we will migrate this torrent. You will be asked for a location to save " + "the torrent to. If you press cancel, we will select your home directory.") + .arg(tor->getNameSuggestion())); + outputdir = KFileDialog::getExistingDirectory(QString::null, 0,i18n("Select Folder to Save To")); + if (outputdir.isNull()) + outputdir = QDir::homeDirPath(); + } + else + { + outputdir = default_save_dir; + } + + if (!outputdir.endsWith(bt::DirSeparator())) + outputdir += bt::DirSeparator(); + + bt::MigrateCache(*tor,datadir + "cache",outputdir); + } + + // delete backup + if (pos != - 1) + bt::Delete(dd); + } + } + + void TorrentControl::setPriority(int p) + { + istats.priority = p; + stats.user_controlled = p == 0 ? true : false; + if(p) + stats.status = kt::QUEUED; + else + updateStatusMsg(); + + saveStats(); + } + + void TorrentControl::setMaxShareRatio(float ratio) + { + if(ratio == 1.00f) + { + if (stats.max_share_ratio != ratio) + stats.max_share_ratio = ratio; + } + else + stats.max_share_ratio = ratio; + + if(stats.completed && !stats.running && !stats.user_controlled && (kt::ShareRatio(stats) >= stats.max_share_ratio)) + setPriority(0); //dequeue it + + saveStats(); + emit maxRatioChanged(this); + } + + void TorrentControl::setMaxSeedTime(float hours) + { + stats.max_seed_time = hours; + saveStats(); + } + + bool TorrentControl::overMaxRatio() + { + if(stats.completed && stats.bytes_uploaded != 0 && stats.bytes_downloaded != 0 && stats.max_share_ratio > 0) + { + if(kt::ShareRatio(stats) >= stats.max_share_ratio) + return true; + } + + return false; + } + + bool TorrentControl::overMaxSeedTime() + { + if(stats.completed && stats.bytes_uploaded != 0 && stats.bytes_downloaded != 0 && stats.max_seed_time > 0) + { + Uint32 dl = getRunningTimeDL(); + Uint32 ul = getRunningTimeUL(); + if ((ul - dl) / 3600.0f > stats.max_seed_time) + return true; + } + + return false; + } + + + QString TorrentControl::statusToString() const + { + switch (stats.status) + { + case kt::NOT_STARTED : + return i18n("Not started"); + case kt::DOWNLOAD_COMPLETE : + return i18n("Download completed"); + case kt::SEEDING_COMPLETE : + return i18n("Seeding completed"); + case kt::SEEDING : + return i18n("Seeding"); + case kt::DOWNLOADING: + return i18n("Downloading"); + case kt::STALLED: + return i18n("Stalled"); + case kt::STOPPED: + return i18n("Stopped"); + case kt::ERROR : + return i18n("Error: ") + getShortErrorMessage(); + case kt::ALLOCATING_DISKSPACE: + return i18n("Allocating diskspace"); + case kt::QUEUED: + return i18n("Queued"); + case kt::CHECKING_DATA: + return i18n("Checking data"); + case kt::NO_SPACE_LEFT: + return i18n("Stopped. No space left on device."); + } + return QString::null; + } + + TrackersList* TorrentControl::getTrackersList() + { + return psman; + } + + const TrackersList* TorrentControl::getTrackersList() const + { + return psman; + } + + void TorrentControl::onPortPacket(const QString & ip,Uint16 port) + { + if (Globals::instance().getDHT().isRunning() && !stats.priv_torrent) + Globals::instance().getDHT().portRecieved(ip,port); + } + + void TorrentControl::startDataCheck(bt::DataCheckerListener* lst,bool auto_import) + { + if (stats.status == kt::ALLOCATING_DISKSPACE) + return; + + + DataChecker* dc = 0; + stats.status = kt::CHECKING_DATA; + stats.num_corrupted_chunks = 0; // reset the number of corrupted chunks found + if (stats.multi_file_torrent) + dc = new MultiDataChecker(); + else + dc = new SingleDataChecker(); + + dc->setListener(lst); + + dcheck_thread = new DataCheckerThread(dc,stats.output_path,*tor,datadir + "dnd" + bt::DirSeparator()); + + // dc->check(stats.output_path,*tor,datadir + "dnd" + bt::DirSeparator()); + dcheck_thread->start(); + } + + void TorrentControl::afterDataCheck() + { + DataChecker* dc = dcheck_thread->getDataChecker(); + DataCheckerListener* lst = dc->getListener(); + + bool err = !dcheck_thread->getError().isNull(); + if (err) + { + // show a queued error message when an error has occurred + KMessageBox::queuedMessageBox(0,KMessageBox::Error,dcheck_thread->getError()); + lst->stop(); + } + + if (lst && !lst->isStopped()) + { + down->dataChecked(dc->getDownloaded()); + // update chunk manager + cman->dataChecked(dc->getDownloaded()); + if (lst->isAutoImport()) + { + down->recalcDownloaded(); + stats.imported_bytes = down->bytesDownloaded(); + if (cman->haveAllChunks()) + stats.completed = true; + } + else + { + Uint64 downloaded = stats.bytes_downloaded; + down->recalcDownloaded(); + updateStats(); + if (stats.bytes_downloaded > downloaded) + stats.imported_bytes = stats.bytes_downloaded - downloaded; + + if (cman->haveAllChunks()) + stats.completed = true; + } + } + + stats.status = kt::NOT_STARTED; + // update the status + updateStatusMsg(); + updateStats(); + if (lst) + lst->finished(); + delete dcheck_thread; + dcheck_thread = 0; + } + + bool TorrentControl::isCheckingData(bool & finished) const + { + if (dcheck_thread) + { + finished = !dcheck_thread->isRunning(); + return true; + } + return false; + } + + bool TorrentControl::hasExistingFiles() const + { + return cman->hasExistingFiles(); + } + + bool TorrentControl::hasMissingFiles(QStringList & sl) + { + return cman->hasMissingFiles(sl); + } + + void TorrentControl::recreateMissingFiles() + { + try + { + cman->recreateMissingFiles(); + prealloc = true; // set prealloc to true so files will be truncated again + down->dataChecked(cman->getBitSet()); // update chunk selector + } + catch (Error & err) + { + onIOError(err.toString()); + throw; + } + } + + void TorrentControl::dndMissingFiles() + { + try + { + cman->dndMissingFiles(); + prealloc = true; // set prealloc to true so files will be truncated again + missingFilesMarkedDND(this); + down->dataChecked(cman->getBitSet()); // update chunk selector + } + catch (Error & err) + { + onIOError(err.toString()); + throw; + } + } + + void TorrentControl::handleError(const QString & err) + { + onIOError(err); + } + + Uint32 TorrentControl::getNumDHTNodes() const + { + return tor->getNumDHTNodes(); + } + + const kt::DHTNode & TorrentControl::getDHTNode(Uint32 i) const + { + return tor->getDHTNode(i); + } + + void TorrentControl::deleteDataFiles() + { + cman->deleteDataFiles(); + } + + const bt::SHA1Hash & TorrentControl::getInfoHash() const + { + return tor->getInfoHash(); + } + + void TorrentControl::resetTrackerStats() + { + istats.trk_prev_bytes_dl = stats.bytes_downloaded, + istats.trk_prev_bytes_ul = stats.bytes_uploaded, + stats.trk_bytes_downloaded = 0; + stats.trk_bytes_uploaded = 0; + } + + void TorrentControl::trackerStatusChanged(const QString & ns) + { + stats.trackerstatus = ns; + } + + void TorrentControl::addPeerSource(kt::PeerSource* ps) + { + if (psman) + psman->addPeerSource(ps); + } + + void TorrentControl::removePeerSource(kt::PeerSource* ps) + { + if (psman) + psman->removePeerSource(ps); + } + + void TorrentControl::corrupted(Uint32 chunk) + { + // make sure we will redownload the chunk + down->corrupted(chunk); + if (stats.completed) + stats.completed = false; + + // emit signal to show a systray message + stats.num_corrupted_chunks++; + corruptedDataFound(this); + } + + Uint32 TorrentControl::getETA() + { + return m_eta->estimate(); + } + + + + const bt::PeerID & TorrentControl::getOwnPeerID() const + { + return tor->getPeerID(); + } + + + bool TorrentControl::isFeatureEnabled(TorrentFeature tf) + { + switch (tf) + { + case kt::DHT_FEATURE: + return psman->dhtStarted(); + case kt::UT_PEX_FEATURE: + return pman->isPexEnabled(); + default: + return false; + } + } + + void TorrentControl::setFeatureEnabled(TorrentFeature tf,bool on) + { + switch (tf) + { + case kt::DHT_FEATURE: + if (on) + { + if(!stats.priv_torrent) + { + psman->addDHT(); + istats.dht_on = psman->dhtStarted(); + saveStats(); + } + } + else + { + psman->removeDHT(); + istats.dht_on = false; + saveStats(); + } + break; + case kt::UT_PEX_FEATURE: + if (on) + { + if (!stats.priv_torrent && !pman->isPexEnabled()) + { + pman->setPexEnabled(true); + } + } + else + { + pman->setPexEnabled(false); + } + break; + } + } + + void TorrentControl::createFiles() + { + cman->createFiles(true); + stats.output_path = cman->getOutputPath(); + } + + bool TorrentControl::checkDiskSpace(bool emit_sig) + { + last_diskspace_check = bt::GetCurrentTime(); + + //calculate free disk space + Uint64 bytes_free = 0; + if (FreeDiskSpace(getDataDir(),bytes_free)) + { + Uint64 bytes_to_download = stats.total_bytes_to_download; + Uint64 downloaded = 0; + try + { + downloaded = cman->diskUsage(); + } + catch (bt::Error & err) + { + Out(SYS_GEN|LOG_DEBUG) << "Error : " << err.toString() << endl; + } + Uint64 remaining = 0; + if (downloaded <= bytes_to_download) + remaining = bytes_to_download - downloaded; + + if (remaining > bytes_free) + { + bool toStop = bytes_free < (Uint64) Settings::minDiskSpace() * 1024 * 1024; + + // if we don't need to stop the torrent, only emit the signal once + // so that we do bother the user continously + if (emit_sig && (toStop || !istats.diskspace_warning_emitted)) + { + emit diskSpaceLow(this, toStop); + istats.diskspace_warning_emitted = true; + } + + if (!stats.running) + { + stats.status = NO_SPACE_LEFT; + } + + return false; + } + } + + return true; + } + + void TorrentControl::setTrafficLimits(Uint32 up,Uint32 down) + { + net::SocketMonitor & smon = net::SocketMonitor::instance(); + if (up && !upload_gid) + { + // create upload group + upload_gid = smon.newGroup(net::SocketMonitor::UPLOAD_GROUP,up); + upload_limit = up; + } + else if (up && upload_gid) + { + // change existing group limit + smon.setGroupLimit(net::SocketMonitor::UPLOAD_GROUP,upload_gid,up); + upload_limit = up; + } + else if (!up && !upload_gid) + { + upload_limit = up; + } + else // !up && upload_gid + { + // remove existing group + smon.removeGroup(net::SocketMonitor::UPLOAD_GROUP,upload_gid); + upload_gid = upload_limit = 0; + } + + if (down && !download_gid) + { + // create download grodown + download_gid = smon.newGroup(net::SocketMonitor::DOWNLOAD_GROUP,down); + download_limit = down; + } + else if (down && download_gid) + { + // change existing grodown limit + smon.setGroupLimit(net::SocketMonitor::DOWNLOAD_GROUP,download_gid,down); + download_limit = down; + } + else if (!down && !download_gid) + { + download_limit = down; + } + else // !down && download_gid + { + // remove existing grodown + smon.removeGroup(net::SocketMonitor::DOWNLOAD_GROUP,download_gid); + download_gid = download_limit = 0; + } + + saveStats(); + pman->setGroupIDs(upload_gid,download_gid); + } + + void TorrentControl::getTrafficLimits(Uint32 & up,Uint32 & down) + { + up = upload_limit; + down = download_limit; + } + + const PeerManager * TorrentControl::getPeerMgr() const + { + return pman; + } +} + +#include "torrentcontrol.moc" -- cgit v1.2.1