src/base/bittorrent/torrentinfo.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2015  Vladimir Golovnev <glassez@yandex.ru>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  *
  19  * In addition, as a special exception, the copyright holders give permission to
  20  * link this program with the OpenSSL project's "OpenSSL" library (or with
  21  * modified versions of it that use the same license as the "OpenSSL" library),
  22  * and distribute the linked executables. You must obey the GNU General Public
  23  * License in all respects for all of the code used other than "OpenSSL".  If you
  24  * modify file(s), you may extend this exception to your version of the file(s),
  25  * but you are not obligated to do so. If you do not wish to do so, delete this
  26  * exception statement from your version.
  27  */
  28
  29 #include "torrentinfo.h"
  30
  31 #include <libtorrent/bencode.hpp>
  32 #include <libtorrent/create_torrent.hpp>
  33 #include <libtorrent/error_code.hpp>
  34
  35 #include <QByteArray>
  36 #include <QDateTime>
  37 #include <QDebug>
  38 #include <QDir>
  39 #include <QString>
  40 #include <QStringList>
  41 #include <QUrl>
  42 #include <QVector>
  43
  44 #include "base/exceptions.h"
  45 #include "base/global.h"
  46 #include "base/utils/fs.h"
  47 #include "base/utils/io.h"
  48 #include "base/utils/misc.h"
  49 #include "infohash.h"
  50 #include "trackerentry.h"
  51
  52 using namespace BitTorrent;
  53
  54 namespace
  55 {
  56     QString getRootFolder(const QStringList &filePaths)
  57     {
  58         QString rootFolder;
  59         for (const QString &filePath : filePaths)
  60         {
  61             if (QDir::isAbsolutePath(filePath)) continue;
  62
  63             const auto filePathElements = QStringView(filePath).split(u'/');
  64             // if at least one file has no root folder, no common root folder exists
  65             if (filePathElements.count() <= 1) return {};
  66
  67             if (rootFolder.isEmpty())
  68                 rootFolder = filePathElements.at(0).toString();
  69             else if (rootFolder != filePathElements.at(0))
  70                 return {};
  71         }
  72
  73         return rootFolder;
  74     }
  75 }
  76
  77 const int torrentInfoId = qRegisterMetaType<TorrentInfo>();
  78
  79 TorrentInfo::TorrentInfo(std::shared_ptr<const lt::torrent_info> nativeInfo)
  80 {
  81     m_nativeInfo = std::const_pointer_cast<lt::torrent_info>(nativeInfo);
  82 }
  83
  84 TorrentInfo::TorrentInfo(const TorrentInfo &other)
  85     : m_nativeInfo(other.m_nativeInfo)
  86 {
  87 }
  88
  89 TorrentInfo &TorrentInfo::operator=(const TorrentInfo &other)
  90 {
  91     m_nativeInfo = other.m_nativeInfo;
  92     return *this;
  93 }
  94
  95 TorrentInfo TorrentInfo::load(const QByteArray &data, QString *error) noexcept
  96 {
  97     // 2-step construction to overcome default limits of `depth_limit` & `token_limit` which are
  98     // used in `torrent_info()` constructor
  99     const int depthLimit = 100;
 100     const int tokenLimit = 10000000;
 101
 102     lt::error_code ec;
 103     const lt::bdecode_node node = lt::bdecode(data, ec
 104         , nullptr, depthLimit, tokenLimit);
 105     if (ec)
 106     {
 107         if (error)
 108             *error = QString::fromStdString(ec.message());
 109         return TorrentInfo();
 110     }
 111
 112     TorrentInfo info {std::shared_ptr<lt::torrent_info>(new lt::torrent_info(node, ec))};
 113     if (ec)
 114     {
 115         if (error)
 116             *error = QString::fromStdString(ec.message());
 117         return TorrentInfo();
 118     }
 119
 120     return info;
 121 }
 122
 123 TorrentInfo TorrentInfo::loadFromFile(const QString &path, QString *error) noexcept
 124 {
 125     if (error)
 126         error->clear();
 127
 128     QFile file {path};
 129     if (!file.open(QIODevice::ReadOnly))
 130     {
 131         if (error)
 132             *error = file.errorString();
 133         return TorrentInfo();
 134     }
 135
 136     if (file.size() > MAX_TORRENT_SIZE)
 137     {
 138         if (error)
 139             *error = tr("File size exceeds max limit %1").arg(Utils::Misc::friendlyUnit(MAX_TORRENT_SIZE));
 140         return TorrentInfo();
 141     }
 142
 143     QByteArray data;
 144     try
 145     {
 146         data = file.readAll();
 147     }
 148     catch (const std::bad_alloc &e)
 149     {
 150         if (error)
 151             *error = tr("Torrent file read error: %1").arg(e.what());
 152         return TorrentInfo();
 153     }
 154     if (data.size() != file.size())
 155     {
 156         if (error)
 157             *error = tr("Torrent file read error: size mismatch");
 158         return TorrentInfo();
 159     }
 160
 161     file.close();
 162
 163     return load(data, error);
 164 }
 165
 166 void TorrentInfo::saveToFile(const QString &path) const
 167 {
 168     if (!isValid())
 169         throw RuntimeError {tr("Invalid metadata")};
 170
 171     try
 172     {
 173         const auto torrentCreator = lt::create_torrent(*nativeInfo());
 174         const lt::entry torrentEntry = torrentCreator.generate();
 175
 176         QFile torrentFile {path};
 177         if (!torrentFile.open(QIODevice::WriteOnly))
 178             throw RuntimeError(torrentFile.errorString());
 179
 180         lt::bencode(Utils::IO::FileDeviceOutputIterator {torrentFile}, torrentEntry);
 181         if (torrentFile.error() != QFileDevice::NoError)
 182             throw RuntimeError(torrentFile.errorString());
 183     }
 184     catch (const lt::system_error &err)
 185     {
 186         throw RuntimeError(QString::fromLocal8Bit(err.what()));
 187     }
 188 }
 189
 190 bool TorrentInfo::isValid() const
 191 {
 192     return (m_nativeInfo && m_nativeInfo->is_valid() && (m_nativeInfo->num_files() > 0));
 193 }
 194
 195 InfoHash TorrentInfo::infoHash() const
 196 {
 197     if (!isValid()) return {};
 198
 199 #ifdef QBT_USES_LIBTORRENT2
 200     return m_nativeInfo->info_hashes();
 201 #else
 202     return m_nativeInfo->info_hash();
 203 #endif
 204 }
 205
 206 QString TorrentInfo::name() const
 207 {
 208     if (!isValid()) return {};
 209     return QString::fromStdString(m_nativeInfo->orig_files().name());
 210 }
 211
 212 QDateTime TorrentInfo::creationDate() const
 213 {
 214     if (!isValid()) return {};
 215
 216     const std::time_t date = m_nativeInfo->creation_date();
 217     return ((date != 0) ? QDateTime::fromSecsSinceEpoch(date) : QDateTime());
 218 }
 219
 220 QString TorrentInfo::creator() const
 221 {
 222     if (!isValid()) return {};
 223     return QString::fromStdString(m_nativeInfo->creator());
 224 }
 225
 226 QString TorrentInfo::comment() const
 227 {
 228     if (!isValid()) return {};
 229     return QString::fromStdString(m_nativeInfo->comment());
 230 }
 231
 232 bool TorrentInfo::isPrivate() const
 233 {
 234     if (!isValid()) return false;
 235     return m_nativeInfo->priv();
 236 }
 237
 238 qlonglong TorrentInfo::totalSize() const
 239 {
 240     if (!isValid()) return -1;
 241     return m_nativeInfo->total_size();
 242 }
 243
 244 int TorrentInfo::filesCount() const
 245 {
 246     if (!isValid()) return -1;
 247     return m_nativeInfo->num_files();
 248 }
 249
 250 int TorrentInfo::pieceLength() const
 251 {
 252     if (!isValid()) return -1;
 253     return m_nativeInfo->piece_length();
 254 }
 255
 256 int TorrentInfo::pieceLength(const int index) const
 257 {
 258     if (!isValid()) return -1;
 259     return m_nativeInfo->piece_size(lt::piece_index_t {index});
 260 }
 261
 262 int TorrentInfo::piecesCount() const
 263 {
 264     if (!isValid()) return -1;
 265     return m_nativeInfo->num_pieces();
 266 }
 267
 268 QString TorrentInfo::filePath(const int index) const
 269 {
 270     if (!isValid()) return {};
 271     return Utils::Fs::toUniformPath(
 272                 QString::fromStdString(m_nativeInfo->files().file_path(lt::file_index_t {index})));
 273 }
 274
 275 QStringList TorrentInfo::filePaths() const
 276 {
 277     QStringList list;
 278     for (int i = 0; i < filesCount(); ++i)
 279         list << filePath(i);
 280
 281     return list;
 282 }
 283
 284 QString TorrentInfo::fileName(const int index) const
 285 {
 286     return Utils::Fs::fileName(filePath(index));
 287 }
 288
 289 QString TorrentInfo::origFilePath(const int index) const
 290 {
 291     if (!isValid()) return {};
 292     return Utils::Fs::toUniformPath(
 293                 QString::fromStdString(m_nativeInfo->orig_files().file_path(lt::file_index_t {index})));
 294 }
 295
 296 qlonglong TorrentInfo::fileSize(const int index) const
 297 {
 298     if (!isValid()) return -1;
 299     return m_nativeInfo->files().file_size(lt::file_index_t {index});
 300 }
 301
 302 qlonglong TorrentInfo::fileOffset(const int index) const
 303 {
 304     if (!isValid()) return -1;
 305     return m_nativeInfo->files().file_offset(lt::file_index_t {index});
 306 }
 307
 308 QVector<TrackerEntry> TorrentInfo::trackers() const
 309 {
 310     if (!isValid()) return {};
 311
 312     const std::vector<lt::announce_entry> trackers = m_nativeInfo->trackers();
 313
 314     QVector<TrackerEntry> ret;
 315     ret.reserve(static_cast<decltype(ret)::size_type>(trackers.size()));
 316
 317     for (const lt::announce_entry &tracker : trackers)
 318         ret.append({QString::fromStdString(tracker.url)});
 319
 320     return ret;
 321 }
 322
 323 QVector<QUrl> TorrentInfo::urlSeeds() const
 324 {
 325     if (!isValid()) return {};
 326
 327     const std::vector<lt::web_seed_entry> &nativeWebSeeds = m_nativeInfo->web_seeds();
 328
 329     QVector<QUrl> urlSeeds;
 330     urlSeeds.reserve(static_cast<decltype(urlSeeds)::size_type>(nativeWebSeeds.size()));
 331
 332     for (const lt::web_seed_entry &webSeed : nativeWebSeeds)
 333     {
 334         if (webSeed.type == lt::web_seed_entry::url_seed)
 335             urlSeeds.append(QUrl(webSeed.url.c_str()));
 336     }
 337
 338     return urlSeeds;
 339 }
 340
 341 QByteArray TorrentInfo::metadata() const
 342 {
 343     if (!isValid()) return {};
 344 #ifdef QBT_USES_LIBTORRENT2
 345     const lt::span<const char> infoSection {m_nativeInfo->info_section()};
 346     return {infoSection.data(), static_cast<int>(infoSection.size())};
 347 #else
 348     return {m_nativeInfo->metadata().get(), m_nativeInfo->metadata_size()};
 349 #endif
 350 }
 351
 352 QStringList TorrentInfo::filesForPiece(const int pieceIndex) const
 353 {
 354     // no checks here because fileIndicesForPiece() will return an empty list
 355     const QVector<int> fileIndices = fileIndicesForPiece(pieceIndex);
 356
 357     QStringList res;
 358     res.reserve(fileIndices.size());
 359     std::transform(fileIndices.begin(), fileIndices.end(), std::back_inserter(res),
 360         [this](int i) { return filePath(i); });
 361
 362     return res;
 363 }
 364
 365 QVector<int> TorrentInfo::fileIndicesForPiece(const int pieceIndex) const
 366 {
 367     if (!isValid() || (pieceIndex < 0) || (pieceIndex >= piecesCount()))
 368         return {};
 369
 370     const std::vector<lt::file_slice> files = nativeInfo()->map_block(
 371                 lt::piece_index_t {pieceIndex}, 0, nativeInfo()->piece_size(lt::piece_index_t {pieceIndex}));
 372     QVector<int> res;
 373     res.reserve(static_cast<decltype(res)::size_type>(files.size()));
 374     std::transform(files.begin(), files.end(), std::back_inserter(res),
 375         [](const lt::file_slice &s) { return static_cast<int>(s.file_index); });
 376
 377     return res;
 378 }
 379
 380 QVector<QByteArray> TorrentInfo::pieceHashes() const
 381 {
 382     if (!isValid())
 383         return {};
 384
 385     const int count = piecesCount();
 386     QVector<QByteArray> hashes;
 387     hashes.reserve(count);
 388
 389     for (int i = 0; i < count; ++i)
 390         hashes += {m_nativeInfo->hash_for_piece_ptr(lt::piece_index_t {i}), SHA1Hash::length()};
 391
 392     return hashes;
 393 }
 394
 395 TorrentInfo::PieceRange TorrentInfo::filePieces(const QString &file) const
 396 {
 397     if (!isValid()) // if we do not check here the debug message will be printed, which would be not correct
 398         return {};
 399
 400     const int index = fileIndex(file);
 401     if (index == -1)
 402     {
 403         qDebug() << "Filename" << file << "was not found in torrent" << name();
 404         return {};
 405     }
 406     return filePieces(index);
 407 }
 408
 409 TorrentInfo::PieceRange TorrentInfo::filePieces(const int fileIndex) const
 410 {
 411     if (!isValid())
 412         return {};
 413
 414     if ((fileIndex < 0) || (fileIndex >= filesCount()))
 415     {
 416         qDebug() << "File index (" << fileIndex << ") is out of range for torrent" << name();
 417         return {};
 418     }
 419
 420     const lt::file_storage &files = nativeInfo()->files();
 421     const auto fileSize = files.file_size(lt::file_index_t {fileIndex});
 422     const auto fileOffset = files.file_offset(lt::file_index_t {fileIndex});
 423
 424     const int beginIdx = (fileOffset / pieceLength());
 425     const int endIdx = ((fileOffset + fileSize - 1) / pieceLength());
 426
 427     if (fileSize <= 0)
 428         return {beginIdx, 0};
 429     return makeInterval(beginIdx, endIdx);
 430 }
 431
 432 void TorrentInfo::renameFile(const int index, const QString &newPath)
 433 {
 434     if (!isValid()) return;
 435     nativeInfo()->rename_file(lt::file_index_t {index}, Utils::Fs::toNativePath(newPath).toStdString());
 436 }
 437
 438 int TorrentInfo::fileIndex(const QString &fileName) const
 439 {
 440     // the check whether the object is valid is not needed here
 441     // because if filesCount() returns -1 the loop exits immediately
 442     for (int i = 0; i < filesCount(); ++i)
 443         if (fileName == filePath(i))
 444             return i;
 445
 446     return -1;
 447 }
 448
 449 QString TorrentInfo::rootFolder() const
 450 {
 451     return getRootFolder(filePaths());
 452 }
 453
 454 bool TorrentInfo::hasRootFolder() const
 455 {
 456     return !rootFolder().isEmpty();
 457 }
 458
 459 void TorrentInfo::setContentLayout(const TorrentContentLayout layout)
 460 {
 461     switch (layout)
 462     {
 463     case TorrentContentLayout::Original:
 464         setContentLayout(defaultContentLayout());
 465         break;
 466     case TorrentContentLayout::Subfolder:
 467         if (rootFolder().isEmpty())
 468             addRootFolder();
 469         break;
 470     case TorrentContentLayout::NoSubfolder:
 471         if (!rootFolder().isEmpty())
 472             stripRootFolder();
 473         break;
 474     }
 475 }
 476
 477 void TorrentInfo::stripRootFolder()
 478 {
 479     lt::file_storage files = m_nativeInfo->files();
 480
 481     // Solution for case of renamed root folder
 482     const QString path = filePath(0);
 483     const std::string newName = path.left(path.indexOf('/')).toStdString();
 484     if (files.name() != newName)
 485     {
 486         files.set_name(newName);
 487         for (int i = 0; i < files.num_files(); ++i)
 488             files.rename_file(lt::file_index_t {i}, files.file_path(lt::file_index_t {i}));
 489     }
 490
 491     files.set_name("");
 492     m_nativeInfo->remap_files(files);
 493 }
 494
 495 void TorrentInfo::addRootFolder()
 496 {
 497     const QString originalName = name();
 498     Q_ASSERT(!originalName.isEmpty());
 499
 500     const QString extension = Utils::Fs::fileExtension(originalName);
 501     const QString rootFolder = extension.isEmpty()
 502             ? originalName
 503             : originalName.chopped(extension.size() + 1);
 504     const std::string rootPrefix = Utils::Fs::toNativePath(rootFolder + QLatin1Char {'/'}).toStdString();
 505     lt::file_storage files = m_nativeInfo->files();
 506     files.set_name(rootFolder.toStdString());
 507     for (int i = 0; i < files.num_files(); ++i)
 508         files.rename_file(lt::file_index_t {i}, rootPrefix + files.file_path(lt::file_index_t {i}));
 509     m_nativeInfo->remap_files(files);
 510 }
 511
 512 TorrentContentLayout TorrentInfo::defaultContentLayout() const
 513 {
 514     QStringList origFilePaths;
 515     origFilePaths.reserve(filesCount());
 516     for (int i = 0; i < filesCount(); ++i)
 517         origFilePaths << origFilePath(i);
 518
 519     const QString origRootFolder = getRootFolder(origFilePaths);
 520     return (origRootFolder.isEmpty()
 521             ? TorrentContentLayout::NoSubfolder
 522             : TorrentContentLayout::Subfolder);
 523 }
 524
 525 std::shared_ptr<lt::torrent_info> TorrentInfo::nativeInfo() const
 526 {
 527     return m_nativeInfo;
 528 }