mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

refactor: replace tr_info with tr_torrent_metainfo (#2397) 

* refactor: replace tr_info with tr_torrent_metafo
This commit is contained in:
Charles Kerr 2022-01-15 13:33:57 -06:00 committed by GitHub
parent 3a96a5c316
commit db23ca4c6b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 367 additions and 1472 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Transmission.xcodeproj/project.pbxproj
View File

@ -313,8 +313,6 @@
BEFC1E450C07861A00B0BB3C /* net.h in Headers */ = {isa = PBXBuildFile; fileRef = BEFC1E0C0C07861A00B0BB3C /* net.h */; };
BEFC1E460C07861A00B0BB3C /* net.cc in Sources */ = {isa = PBXBuildFile; fileRef = BEFC1E0D0C07861A00B0BB3C /* net.cc */; };
BEFC1E480C07861A00B0BB3C /* natpmp.cc in Sources */ = {isa = PBXBuildFile; fileRef = BEFC1E0F0C07861A00B0BB3C /* natpmp.cc */; };
BEFC1E490C07861A00B0BB3C /* metainfo.h in Headers */ = {isa = PBXBuildFile; fileRef = BEFC1E100C07861A00B0BB3C /* metainfo.h */; };
BEFC1E4A0C07861A00B0BB3C /* metainfo.cc in Sources */ = {isa = PBXBuildFile; fileRef = BEFC1E110C07861A00B0BB3C /* metainfo.cc */; };
BEFC1E4D0C07861A00B0BB3C /* session.h in Headers */ = {isa = PBXBuildFile; fileRef = BEFC1E140C07861A00B0BB3C /* session.h */; };
BEFC1E4E0C07861A00B0BB3C /* inout.h in Headers */ = {isa = PBXBuildFile; fileRef = BEFC1E150C07861A00B0BB3C /* inout.h */; };
BEFC1E4F0C07861A00B0BB3C /* inout.cc in Sources */ = {isa = PBXBuildFile; fileRef = BEFC1E160C07861A00B0BB3C /* inout.cc */; };
@ -977,8 +975,6 @@
BEFC1E0C0C07861A00B0BB3C /* net.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = net.h; sourceTree = "<group>"; };
BEFC1E0D0C07861A00B0BB3C /* net.cc */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = net.cc; sourceTree = "<group>"; };
BEFC1E0F0C07861A00B0BB3C /* natpmp.cc */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = natpmp.cc; sourceTree = "<group>"; };
BEFC1E100C07861A00B0BB3C /* metainfo.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = metainfo.h; sourceTree = "<group>"; };
BEFC1E110C07861A00B0BB3C /* metainfo.cc */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = metainfo.cc; sourceTree = "<group>"; };
BEFC1E140C07861A00B0BB3C /* session.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = session.h; sourceTree = "<group>"; };
BEFC1E150C07861A00B0BB3C /* inout.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = inout.h; sourceTree = "<group>"; };
BEFC1E160C07861A00B0BB3C /* inout.cc */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = inout.cc; sourceTree = "<group>"; };
@ -1482,8 +1478,6 @@
BEFC1E0D0C07861A00B0BB3C /* net.cc */,
A2EE726E14DCCC950093C99A /* natpmp_local.h */,
BEFC1E0F0C07861A00B0BB3C /* natpmp.cc */,
BEFC1E100C07861A00B0BB3C /* metainfo.h */,
BEFC1E110C07861A00B0BB3C /* metainfo.cc */,
BEFC1E150C07861A00B0BB3C /* inout.h */,
BEFC1E160C07861A00B0BB3C /* inout.cc */,
BEFC1E190C07861A00B0BB3C /* fdlimit.h */,
@ -1851,7 +1845,6 @@
C1425B371EE9C705001DB85F /* tr-macros.h in Headers */,
C1425B381EE9C805001DB85F /* peer-socket.h in Headers */,
BEFC1E450C07861A00B0BB3C /* net.h in Headers */,
BEFC1E490C07861A00B0BB3C /* metainfo.h in Headers */,
BEFC1E4D0C07861A00B0BB3C /* session.h in Headers */,
C1FEE5771C3223CC00D62832 /* watchdir-common.h in Headers */,
BEFC1E4E0C07861A00B0BB3C /* inout.h in Headers */,
@ -2448,7 +2441,6 @@
C1033E091A3279B800EF44D8 /* crypto-utils.cc in Sources */,
BEFC1E480C07861A00B0BB3C /* natpmp.cc in Sources */,
C1077A4E183EB29600634C22 /* error.cc in Sources */,
BEFC1E4A0C07861A00B0BB3C /* metainfo.cc in Sources */,
BEFC1E4F0C07861A00B0BB3C /* inout.cc in Sources */,
BEFC1E530C07861A00B0BB3C /* fdlimit.cc in Sources */,
C1FEE5781C3223CC00D62832 /* watchdir-generic.cc in Sources */,

2
libtransmission/CMakeLists.txt
View File

@ -35,7 +35,6 @@ set(PROJECT_FILES
log.cc
magnet-metainfo.cc
makemeta.cc
metainfo.cc
natpmp.cc
net.cc
peer-io.cc
@ -163,7 +162,6 @@ set(${PROJECT_NAME}_PRIVATE_HEADERS
history.h
inout.h
magnet-metainfo.h
metainfo.h
mime-types.h
natpmp_local.h
net.h

22
libtransmission/announce-list.cc
View File

@ -14,11 +14,13 @@
#include "transmission.h"
#include "announce-list.h"
#include "metainfo.h"
#include "quark.h"
#include "torrent-metainfo.h"
#include "utils.h"
#include "variant.h"
using namespace std::literals;
size_t tr_announce_list::set(char const* const* announce_urls, tr_tracker_tier_t const* tiers, size_t n)
{
trackers_.clear();
@ -87,10 +89,7 @@ bool tr_announce_list::add(tr_tracker_tier_t tier, std::string_view announce_url
tracker.announce = *tr_urlParseTracker(tracker.announce_str.sv());
tracker.tier = getTier(tier, *announce);
tracker.id = nextUniqueId();
auto host = std::string{ tracker.announce.host };
host += ':';
host += tracker.announce.portstr;
tracker.host = host;
tracker.host = tr_strvJoin(tracker.announce.host, ":"sv, tracker.announce.portstr);
auto const scrape_str = announceToScrape(announce_url_sv);
if (scrape_str)
@ -206,11 +205,11 @@ bool tr_announce_list::canAdd(tr_url_parsed_t const& announce)
return std::none_of(std::begin(trackers_), std::end(trackers_), is_same);
}
bool tr_announce_list::save(std::string_view torrent_file, tr_error** error) const
bool tr_announce_list::save(std::string const& torrent_file, tr_error** error) const
{
// load the .torrent file
auto metainfo = tr_variant{};
if (!tr_variantFromFile(&metainfo, TR_VARIANT_PARSE_BENC, torrent_file, error))
if (!tr_variantFromFile(&metainfo, TR_VARIANT_PARSE_BENC, std::string{ torrent_file }, error))
{
return false;
}
@ -244,14 +243,15 @@ bool tr_announce_list::save(std::string_view torrent_file, tr_error** error) con
}
// confirm that it's good by parsing it back again
if (!tr_metainfoParse(nullptr, &metainfo, error))
auto const contents = tr_variantToStr(&metainfo, TR_VARIANT_FMT_BENC);
tr_variantFree(&metainfo);
auto tm = tr_torrent_metainfo{};
if (!tm.parseBenc(contents))
{
tr_variantFree(&metainfo);
return false;
}
// save it
auto const contents = tr_variantToStr(&metainfo, TR_VARIANT_FMT_BENC);
tr_variantFree(&metainfo);
return tr_saveFile(torrent_file, contents, error);
}

2
libtransmission/announce-list.h
View File

@ -105,7 +105,7 @@ public:
return trackers_.clear();
}
bool save(std::string_view torrent_file, tr_error** error = nullptr) const;
bool save(std::string const& torrent_file, tr_error** error = nullptr) const;
static std::optional<std::string> announceToScrape(std::string_view announce);
static tr_quark announceToScrape(tr_quark announce);

9
libtransmission/file-piece-map.cc
View File

@ -13,6 +13,7 @@
#include "block-info.h"
#include "file-piece-map.h"
#include "torrent-metainfo.h"
#include "tr-assert.h"
void tr_file_piece_map::reset(tr_block_info const& block_info, uint64_t const* file_sizes, size_t n_files)
@ -51,15 +52,15 @@ void tr_file_piece_map::reset(tr_block_info const& block_info, uint64_t const* f
}
}
void tr_file_piece_map::reset(tr_info const& info)
void tr_file_piece_map::reset(tr_torrent_metainfo const& tm)
{
auto const n = info.fileCount();
auto const n = tm.fileCount();
auto file_sizes = std::vector<uint64_t>(n);
for (tr_file_index_t i = 0; i < n; ++i)
{
file_sizes[i] = info.fileSize(i);
file_sizes[i] = tm.fileSize(i);
}
reset({ info.totalSize(), info.pieceSize() }, std::data(file_sizes), std::size(file_sizes));
reset({ tm.totalSize(), tm.pieceSize() }, std::data(file_sizes), std::size(file_sizes));
}
tr_file_piece_map::piece_span_t tr_file_piece_map::pieceSpan(tr_file_index_t file) const

7
libtransmission/file-piece-map.h
View File

@ -20,6 +20,7 @@
#include "bitfield.h"
struct tr_block_info;
struct tr_torrent_metainfo;
class tr_file_piece_map
{
@ -42,16 +43,16 @@ public:
using file_offset_t = offset_t<tr_file_index_t>;
explicit tr_file_piece_map(tr_info const& info)
explicit tr_file_piece_map(tr_torrent_metainfo const& tm)
{
reset(info);
reset(tm);
}
tr_file_piece_map(tr_block_info const& block_info, uint64_t const* file_sizes, size_t n_files)
{
reset(block_info, file_sizes, n_files);
}
void reset(tr_block_info const& block_info, uint64_t const* file_sizes, size_t n_files);
void reset(tr_info const& info);
void reset(tr_torrent_metainfo const& tm);
[[nodiscard]] piece_span_t pieceSpan(tr_file_index_t file) const;
[[nodiscard]] file_span_t fileSpan(tr_piece_index_t piece) const;

69
libtransmission/magnet-metainfo.cc
View File

@ -114,11 +114,6 @@ void base32_to_sha1(uint8_t* out, char const* in, size_t const inlen)
****
***/
void tr_magnet_metainfo::clear()
{
*this = tr_magnet_metainfo{};
}
std::string tr_magnet_metainfo::magnet() const
{
auto s = std::string{};
@ -209,67 +204,3 @@ bool tr_magnet_metainfo::parseMagnet(std::string_view magnet_link, tr_error** er
return got_checksum;
}
void tr_magnet_metainfo::toVariant(tr_variant* top) const
{
tr_variantInitDict(top, 4);
// announce list
auto n = std::size(this->announceList());
if (n == 1)
{
tr_variantDictAddQuark(top, TR_KEY_announce, this->announceList().at(0).announce_str.quark());
}
else
{
auto current_tier = tr_tracker_tier_t{};
tr_variant* tracker_list = nullptr;
auto* tier_list = tr_variantDictAddList(top, TR_KEY_announce_list, n);
for (auto const& tracker : this->announceList())
{
if (tracker_list == nullptr || current_tier != tracker.tier)
{
tracker_list = tr_variantListAddList(tier_list, 1);
current_tier = tracker.tier;
}
tr_variantListAddQuark(tracker_list, tracker.announce_str.quark());
}
}
// webseeds
n = this->webseedCount();
if (n != 0)
{
tr_variant* list = tr_variantDictAddList(top, TR_KEY_url_list, n);
for (size_t i = 0; i < n; ++i)
{
tr_variantListAddStr(list, this->webseed(i));
}
}
// nonstandard keys
auto* const d = tr_variantDictAddDict(top, TR_KEY_magnet_info, 2);
tr_variantDictAddRaw(d, TR_KEY_info_hash, std::data(this->infoHash()), std::size(this->infoHash()));
if (!std::empty(this->name()))
{
tr_variantDictAddStr(d, TR_KEY_display_name, this->name());
}
}
std::string tr_magnet_metainfo::makeFilename(
std::string_view dirname,
std::string_view name,
std::string_view info_hash_string,
BasenameFormat format,
std::string_view suffix)
{
// `${dirname}/${name}.${info_hash}${suffix}`
// `${dirname}/${info_hash}${suffix}`
return format == BasenameFormat::Hash ? tr_strvJoin(dirname, "/"sv, info_hash_string, suffix) :
tr_strvJoin(dirname, "/"sv, name, "."sv, info_hash_string.substr(0, 16), suffix);
}

23
libtransmission/magnet-metainfo.h
View File

@ -24,7 +24,6 @@ class tr_magnet_metainfo
public:
bool parseMagnet(std::string_view magnet_link, tr_error** error = nullptr);
std::string magnet() const;
virtual ~tr_magnet_metainfo() = default;
auto const& infoHash() const
{
@ -60,33 +59,11 @@ public:
return info_hash_str_;
}
virtual void clear();
void setName(std::string_view name)
{
name_ = name;
}
void toVariant(tr_variant* top) const;
enum class BasenameFormat
{
Hash,
NameAndPartialHash
};
static std::string makeFilename(
std::string_view dirname,
std::string_view name,
std::string_view info_hash_string,
BasenameFormat format,
std::string_view suffix);
std::string makeFilename(std::string_view dirname, BasenameFormat format, std::string_view suffix) const
{
return makeFilename(dirname, name(), infoHashString(), format, suffix);
}
protected:
tr_announce_list announce_list_;
std::vector<std::string> webseed_urls_;

525
libtransmission/metainfo.cc
View File

@ -1,525 +0,0 @@
/*
* This file Copyright (C) 2007-2014 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
*
*/
#include <algorithm>
#include <array>
#include <cctype>
#include <iterator>
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include <event2/util.h> // evutil_ascii_strncasecmp()
#include "transmission.h"
#include "crypto-utils.h" /* tr_sha1 */
#include "error.h"
#include "error-types.h"
#include "file.h"
#include "log.h"
#include "metainfo.h"
#include "platform.h" /* tr_getTorrentDir() */
#include "session.h"
#include "torrent.h"
#include "utils.h"
#include "variant.h"
#include "magnet-metainfo.h"
#include "web-utils.h"
using namespace std::literals;
/***
****
***/
static std::string getTorrentFilename(tr_session const* session, tr_info const* inf, tr_magnet_metainfo::BasenameFormat format)
{
return tr_magnet_metainfo::makeFilename(
tr_getTorrentDir(session),
inf->name(),
inf->infoHashString(),
format,
".torrent"sv);
}
/***
****
***/
bool tr_metainfoAppendSanitizedPathComponent(std::string& out, std::string_view in)
{
auto const original_out_len = std::size(out);
// remove leading spaces
auto constexpr leading_test = [](auto ch)
{
return isspace(ch);
};
auto const it = std::find_if_not(std::begin(in), std::end(in), leading_test);
in.remove_prefix(std::distance(std::begin(in), it));
// remove trailing spaces and '.'
auto constexpr trailing_test = [](auto ch)
{
return isspace(ch) || ch == '.';
};
auto const rit = std::find_if_not(std::rbegin(in), std::rend(in), trailing_test);
in.remove_suffix(std::distance(std::rbegin(in), rit));
// munge banned characters
// https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file
auto constexpr ensure_legal_char = [](auto ch)
{
auto constexpr Banned = std::string_view{ "<>:\"/\\|?*" };
auto const banned = tr_strvContains(Banned, ch) || (unsigned char)ch < 0x20;
return banned ? '_' : ch;
};
auto const old_out_len = std::size(out);
std::transform(std::begin(in), std::end(in), std::back_inserter(out), ensure_legal_char);
// munge banned filenames
// https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file
auto constexpr ReservedNames = std::array<std::string_view, 22>{
"CON"sv, "PRN"sv, "AUX"sv, "NUL"sv, "COM1"sv, "COM2"sv, "COM3"sv, "COM4"sv, "COM5"sv, "COM6"sv, "COM7"sv,
"COM8"sv, "COM9"sv, "LPT1"sv, "LPT2"sv, "LPT3"sv, "LPT4"sv, "LPT5"sv, "LPT6"sv, "LPT7"sv, "LPT8"sv, "LPT9"sv,
};
for (auto const& name : ReservedNames)
{
size_t const name_len = std::size(name);
if (evutil_ascii_strncasecmp(out.c_str() + old_out_len, std::data(name), name_len) != 0 ||
(out[old_out_len + name_len] != '\0' && out[old_out_len + name_len] != '.'))
{
continue;
}
out.insert(std::begin(out) + old_out_len + name_len, '_');
break;
}
return std::size(out) > original_out_len;
}
static bool getfile(std::string* setme, std::string_view root, tr_variant* path, std::string& buf)
{
bool success = false;
setme->clear();
if (tr_variantIsList(path))
{
success = true;
buf = root;
for (int i = 0, n = tr_variantListSize(path); i < n; i++)
{
auto raw = std::string_view{};
if (!tr_variantGetStrView(tr_variantListChild(path, i), &raw))
{
success = false;
break;
}
auto const pos = std::size(buf);
if (!tr_metainfoAppendSanitizedPathComponent(buf, raw))
{
continue;
}
buf.insert(std::begin(buf) + pos, TR_PATH_DELIMITER);
}
}
if (success && std::size(buf) <= std::size(root))
{
success = false;
}
if (success)
{
*setme = tr_strvUtf8Clean(buf);
}
return success;
}
static char const* parseFiles(tr_info* inf, tr_variant* files, tr_variant const* length)
{
int64_t len = 0;
inf->total_size_ = 0;
auto root_name = std::string{};
if (!tr_metainfoAppendSanitizedPathComponent(root_name, inf->name()))
{
return "path";
}
char const* errstr = nullptr;
if (tr_variantIsList(files)) /* multi-file mode */
{
auto buf = std::string{};
errstr = nullptr;
tr_file_index_t const n = tr_variantListSize(files);
inf->files.resize(n);
for (tr_file_index_t i = 0; i < n; ++i)
{
auto* const file = tr_variantListChild(files, i);
if (!tr_variantIsDict(file))
{
errstr = "files";
break;
}
tr_variant* path = nullptr;
if (!tr_variantDictFindList(file, TR_KEY_path_utf_8, &path) && !tr_variantDictFindList(file, TR_KEY_path, &path))
{
errstr = "path";
break;
}
if (!getfile(&inf->files[i].subpath_, root_name, path, buf))
{
errstr = "path";
break;
}
if (!tr_variantDictFindInt(file, TR_KEY_length, &len))
{
errstr = "length";
break;
}
inf->files[i].size_ = len;
inf->total_size_ += len;
}
}
else if (tr_variantGetInt(length, &len)) /* single-file mode */
{
inf->files.resize(1);
inf->files[0].subpath_ = root_name;
inf->files[0].size_ = len;
inf->total_size_ += len;
}
else
{
errstr = "length";
}
return errstr;
}
static char const* getannounce(tr_info* inf, tr_variant* meta)
{
inf->announce_list = std::make_shared<tr_announce_list>();
// tr_tracker_info* trackers = nullptr;
// int trackerCount = 0;
auto url = std::string_view{};
/* Announce-list */
tr_variant* tiers = nullptr;
if (tr_variantDictFindList(meta, TR_KEY_announce_list, &tiers))
{
for (size_t i = 0, in = tr_variantListSize(tiers); i < in; ++i)
{
tr_variant* tier_list = tr_variantListChild(tiers, i);
if (tier_list == nullptr)
{
continue;
}
for (size_t j = 0, jn = tr_variantListSize(tier_list); j < jn; ++j)
{
if (!tr_variantGetStrView(tr_variantListChild(tier_list, j), &url))
{
continue;
}
inf->announce_list->add(i, url);
}
}
}
/* Regular announce value */
if (std::empty(*inf->announce_list) && tr_variantDictFindStrView(meta, TR_KEY_announce, &url))
{
inf->announce_list->add(0, url);
}
return nullptr;
}
/**
* @brief Ensure that the URLs for multfile torrents end in a slash.
*
* See http://bittorrent.org/beps/bep_0019.html#metadata-extension
* for background on how the trailing slash is used for "url-list"
* fields.
*
* This function is to workaround some .torrent generators, such as
* mktorrent and very old versions of utorrent, that don't add the
* trailing slash for multifile torrents if omitted by the end user.
*/
static char* fix_webseed_url(tr_info const* inf, std::string_view url)
{
url = tr_strvStrip(url);
if (!tr_urlIsValid(url))
{
return nullptr;
}
if (inf->fileCount() > 1 && !std::empty(url) && url.back() != '/')
{
return tr_strvDup(tr_strvJoin(url, "/"sv));
}
return tr_strvDup(url);
}
static void geturllist(tr_info* inf, tr_variant* meta)
{
inf->webseeds_.clear();
auto url = std::string_view{};
tr_variant* urls = nullptr;
if (tr_variantDictFindList(meta, TR_KEY_url_list, &urls))
{
int const n = tr_variantListSize(urls);
for (int i = 0; i < n; ++i)
{
if (tr_variantGetStrView(tr_variantListChild(urls, i), &url))
{
char* const fixed_url = fix_webseed_url(inf, url);
if (fixed_url != nullptr)
{
inf->webseeds_.emplace_back(fixed_url);
}
}
}
}
else if (tr_variantDictFindStrView(meta, TR_KEY_url_list, &url)) /* handle single items in webseeds */
{
char* const fixed_url = fix_webseed_url(inf, url);
if (fixed_url != nullptr)
{
inf->webseeds_.emplace_back(fixed_url);
}
}
}
static char const* tr_metainfoParseImpl(
tr_session const* session,
tr_info* inf,
std::vector<tr_sha1_digest_t>* pieces,
uint64_t* info_dict_size,
tr_variant const* meta_in)
{
int64_t i = 0;
auto sv = std::string_view{};
tr_variant* const meta = const_cast<tr_variant*>(meta_in);
bool isMagnet = false;
/* info_hash: urlencoded 20-byte SHA1 hash of the value of the info key
* from the Metainfo file. Note that the value will be a bencoded
* dictionary, given the definition of the info key above. */
tr_variant* infoDict = nullptr;
if (bool b = tr_variantDictFindDict(meta, TR_KEY_info, &infoDict); !b)
{
/* no info dictionary... is this a magnet link? */
if (tr_variant* d = nullptr; tr_variantDictFindDict(meta, TR_KEY_magnet_info, &d))
{
isMagnet = true;
// get the info-hash
if (!tr_variantDictFindStrView(d, TR_KEY_info_hash, &sv))
{
return "info_hash";
}
if (std::size(sv) != std::size(inf->hash_))
{
return "info_hash";
}
std::copy(std::begin(sv), std::end(sv), reinterpret_cast<char*>(std::data(inf->hash_)));
inf->info_hash_string_ = tr_sha1_to_string(inf->hash_);
// maybe get the display name
tr_variantDictFindStrView(d, TR_KEY_display_name, &sv);
inf->setName(!std::empty(sv) ? sv : inf->info_hash_string_);
}
else // not a magnet link and has no info dict...
{
return "info";
}
}
else
{
auto const benc = tr_variantToStr(infoDict, TR_VARIANT_FMT_BENC);
auto const hash = tr_sha1(benc);
if (!hash)
{
return "hash";
}
inf->hash_ = *hash;
inf->info_hash_string_ = tr_sha1_to_string(inf->hash_);
if (info_dict_size != nullptr)
{
*info_dict_size = std::size(benc);
}
}
/* name */
if (!isMagnet)
{
if (!tr_variantDictFindStrView(infoDict, TR_KEY_name_utf_8, &sv) &&
!tr_variantDictFindStrView(infoDict, TR_KEY_name, &sv))
{
sv = ""sv;
}
if (std::empty(sv))
{
return "name";
}
inf->name_ = tr_strvUtf8Clean(sv);
}
/* comment */
if (!tr_variantDictFindStrView(meta, TR_KEY_comment_utf_8, &sv) && !tr_variantDictFindStrView(meta, TR_KEY_comment, &sv))
{
sv = ""sv;
}
inf->comment_ = tr_strvUtf8Clean(sv);
/* created by */
if (!tr_variantDictFindStrView(meta, TR_KEY_created_by_utf_8, &sv) &&
!tr_variantDictFindStrView(meta, TR_KEY_created_by, &sv))
{
sv = ""sv;
}
inf->creator_ = tr_strvUtf8Clean(sv);
/* creation date */
i = 0;
(void)!tr_variantDictFindInt(meta, TR_KEY_creation_date, &i);
inf->date_created_ = i;
/* private */
if (!tr_variantDictFindInt(infoDict, TR_KEY_private, &i) && !tr_variantDictFindInt(meta, TR_KEY_private, &i))
{
i = 0;
}
inf->is_private_ = i != 0;
/* source */
if (!tr_variantDictFindStrView(infoDict, TR_KEY_source, &sv) && !tr_variantDictFindStrView(meta, TR_KEY_source, &sv))
{
sv = ""sv;
}
inf->source_ = tr_strvUtf8Clean(sv);
/* piece length */
if (!isMagnet)
{
if (!tr_variantDictFindInt(infoDict, TR_KEY_piece_length, &i) || (i < 1))
{
return "piece length";
}
inf->piece_size_ = i;
}
/* pieces and files */
if (!isMagnet)
{
if (!tr_variantDictFindStrView(infoDict, TR_KEY_pieces, &sv))
{
return "pieces";
}
if (std::size(sv) % std::size(tr_sha1_digest_t{}) != 0)
{
return "pieces";
}
auto const n_pieces = std::size(sv) / std::size(tr_sha1_digest_t{});
inf->piece_count_ = n_pieces;
pieces->resize(n_pieces);
std::copy_n(std::data(sv), std::size(sv), reinterpret_cast<uint8_t*>(std::data(*pieces)));
auto const* const errstr = parseFiles(
inf,
tr_variantDictFind(infoDict, TR_KEY_files),
tr_variantDictFind(infoDict, TR_KEY_length));
if (errstr != nullptr)
{
return errstr;
}
if (inf->fileCount() == 0 || inf->total_size_ == 0)
{
return "files";
}
if ((uint64_t)inf->piece_count_ != (inf->total_size_ + inf->piece_size_ - 1) / inf->piece_size_)
{
return "files";
}
}
/* get announce or announce-list */
auto const* const errstr = getannounce(inf, meta);
if (errstr != nullptr)
{
return errstr;
}
/* get the url-list */
geturllist(inf, meta);
/* filename of Transmission's copy */
inf->torrent_file_ = session != nullptr ? getTorrentFilename(session, inf, tr_magnet_metainfo::BasenameFormat::Hash) : ""sv;
return nullptr;
}
std::optional<tr_metainfo_parsed> tr_metainfoParse(tr_session const* session, tr_variant const* meta_in, tr_error** error)
{
auto out = tr_metainfo_parsed{};
char const* bad_tag = tr_metainfoParseImpl(session, &out.info, &out.pieces, &out.info_dict_size, meta_in);
if (bad_tag != nullptr)
{
tr_error_set(error, TR_ERROR_EINVAL, tr_strvJoin("Error parsing metainfo: "sv, bad_tag));
tr_metainfoFree(&out.info);
return {};
}
return std::optional<tr_metainfo_parsed>{ std::move(out) };
}
void tr_metainfoFree(tr_info* inf)
{
inf->webseeds_.clear();
inf->announce_list.reset();
}

59
libtransmission/metainfo.h
View File

@ -1,59 +0,0 @@
/*
* This file Copyright (C) 2005-2014 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
*
*/
#pragma once
#ifndef __TRANSMISSION__
#error only libtransmission should #include this header.
#endif
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
#include "transmission.h"
#include "bitfield.h"
#include "torrent.h"
#include "tr-macros.h"
struct tr_error;
struct tr_variant;
struct tr_metainfo_parsed
{
tr_info info = {};
uint64_t info_dict_size = 0;
std::vector<tr_sha1_digest_t> pieces;
tr_bitfield files_renamed = tr_bitfield{ 0 };
tr_metainfo_parsed() = default;
tr_metainfo_parsed(tr_metainfo_parsed&& that) noexcept
{
std::swap(this->info, that.info);
std::swap(this->pieces, that.pieces);
std::swap(this->info_dict_size, that.info_dict_size);
}
tr_metainfo_parsed(tr_metainfo_parsed const&) = delete;
tr_metainfo_parsed& operator=(tr_metainfo_parsed const&) = delete;
~tr_metainfo_parsed()
{
tr_metainfoFree(&info);
}
};
std::optional<tr_metainfo_parsed> tr_metainfoParse(tr_session const* session, tr_variant const* variant, tr_error** error);
/** @brief Private function that's exposed here only for unit tests */
bool tr_metainfoAppendSanitizedPathComponent(std::string& out, std::string_view in);

7
libtransmission/mime-types.h
View File

@ -1,5 +1,5 @@
/*
* This file Copyright (C) 2021 Mnemosyne LLC
* This file Copyright (C) 2022 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
@ -16,7 +16,7 @@ struct mime_type_suffix
std::string_view mime_type;
};
inline auto constexpr mime_type_suffixes = std::array<mime_type_suffix, 1211>{
inline auto constexpr mime_type_suffixes = std::array<mime_type_suffix, 1214>{
{ { "123", "application/vnd.lotus-1-2-3" },
{ "1km", "application/vnd.1000minds.decision-model+xml" },
{ "3dml", "text/vnd.in3d.3dml" },
@ -42,6 +42,7 @@ inline auto constexpr mime_type_suffixes = std::array<mime_type_suffix, 1211>{
{ "aep", "application/vnd.audiograph" },
{ "afm", "application/x-font-type1" },
{ "afp", "application/vnd.ibm.modcap" },
{ "age", "application/vnd.age" },
{ "ahead", "application/vnd.ahead.space" },
{ "ai", "application/postscript" },
{ "aif", "audio/x-aiff" },
@ -330,6 +331,7 @@ inline auto constexpr mime_type_suffixes = std::array<mime_type_suffix, 1211>{
{ "gca", "application/x-gca-compressed" },
{ "gdl", "model/vnd.gdl" },
{ "gdoc", "application/vnd.google-apps.document" },
{ "ged", "text/vnd.familysearch.gedcom" },
{ "geo", "application/vnd.dynageo" },
{ "geojson", "application/geo+json" },
{ "gex", "application/vnd.geometry-explorer" },
@ -599,6 +601,7 @@ inline auto constexpr mime_type_suffixes = std::array<mime_type_suffix, 1211>{
{ "mpkg", "application/vnd.apple.installer+xml" },
{ "mpm", "application/vnd.blueice.multipass" },
{ "mpn", "application/vnd.mophun.application" },
{ "mpp", "application/dash-patch+xml" },
{ "mpp", "application/vnd.ms-project" },
{ "mpt", "application/vnd.ms-project" },
{ "mpy", "application/vnd.ibm.minipay" },

5
libtransmission/quark.cc
View File

@ -21,7 +21,7 @@ using namespace std::literals;
namespace
{
auto constexpr my_static = std::array<std::string_view, 392>{ ""sv,
auto constexpr my_static = std::array<std::string_view, 389>{ ""sv,
"activeTorrentCount"sv,
"activity-date"sv,
"activityDate"sv,
@ -83,7 +83,6 @@ auto constexpr my_static = std::array<std::string_view, 392>{ ""sv,
"details-window-height"sv,
"details-window-width"sv,
"dht-enabled"sv,
"display-name"sv,
"dnd"sv,
"done-date"sv,
"doneDate"sv,
@ -153,7 +152,6 @@ auto constexpr my_static = std::array<std::string_view, 392>{ ""sv,
"incomplete-dir"sv,
"incomplete-dir-enabled"sv,
"info"sv,
"info_hash"sv,
"inhibit-desktop-hibernation"sv,
"interval"sv,
"ip"sv,
@ -186,7 +184,6 @@ auto constexpr my_static = std::array<std::string_view, 392>{ ""sv,
"location"sv,
"lpd-enabled"sv,
"m"sv,
"magnet-info"sv,
"magnetLink"sv,
"main-window-height"sv,
"main-window-is-maximized"sv,

3
libtransmission/quark.h
View File

@ -85,7 +85,6 @@ enum
TR_KEY_details_window_height,
TR_KEY_details_window_width,
TR_KEY_dht_enabled,
TR_KEY_display_name,
TR_KEY_dnd,
TR_KEY_done_date,
TR_KEY_doneDate,
@ -155,7 +154,6 @@ enum
TR_KEY_incomplete_dir,
TR_KEY_incomplete_dir_enabled,
TR_KEY_info,
TR_KEY_info_hash,
TR_KEY_inhibit_desktop_hibernation,
TR_KEY_interval,
TR_KEY_ip,
@ -188,7 +186,6 @@ enum
TR_KEY_location,
TR_KEY_lpd_enabled,
TR_KEY_m,
TR_KEY_magnet_info,
TR_KEY_magnetLink,
TR_KEY_main_window_height,
TR_KEY_main_window_is_maximized,

63
libtransmission/resume.cc
View File

@ -18,7 +18,6 @@
#include "file.h"
#include "log.h"
#include "magnet-metainfo.h"
#include "metainfo.h" /* tr_metainfoGetBasename() */
#include "peer-mgr.h" /* pex */
#include "platform.h" /* tr_getResumeDir() */
#include "resume.h"
@ -37,16 +36,6 @@ constexpr int MAX_REMEMBERED_PEERS = 200;
} // unnamed namespace
static std::string getResumeFilename(tr_torrent const* tor, tr_magnet_metainfo::BasenameFormat format)
{
return tr_magnet_metainfo::makeFilename(
tr_getResumeDir(tor->session),
tr_torrentName(tor),
tor->infoHashString(),
format,
".resume"sv);
}
/***
****
***/
@ -693,8 +682,7 @@ void tr_torrentSaveResume(tr_torrent* tor)
saveName(&top, tor);
saveLabels(&top, tor);
auto const filename = getResumeFilename(tor, tr_magnet_metainfo::BasenameFormat::Hash);
auto const err = tr_variantToFile(&top, TR_VARIANT_FMT_BENC, filename.c_str());
auto const err = tr_variantToFile(&top, TR_VARIANT_FMT_BENC, tor->makeResumeFilename());
if (err != 0)
{
tor->setLocalError(tr_strvJoin("Unable to save resume file: ", tr_strerror(err)));
@ -703,26 +691,22 @@ void tr_torrentSaveResume(tr_torrent* tor)
tr_variantFree(&top);
}
static uint64_t loadFromFile(tr_torrent* tor, uint64_t fieldsToLoad, bool* didRenameToHashOnlyName)
static uint64_t loadFromFile(tr_torrent* tor, uint64_t fieldsToLoad, bool* did_migrate_filename)
{
TR_ASSERT(tr_isTorrent(tor));
auto boolVal = false;
auto const wasDirty = tor->isDirty;
auto fieldsLoaded = uint64_t{};
auto i = int64_t{};
auto top = tr_variant{};
auto sv = std::string_view{};
tr_error* error = nullptr;
if (didRenameToHashOnlyName != nullptr)
auto const migrated = tor->metainfo_.migrateFile(tor->session->resume_dir, tor->name(), tor->infoHashString(), ".resume"sv);
if (did_migrate_filename != nullptr)
{
*didRenameToHashOnlyName = false;
*did_migrate_filename = migrated;
}
std::string const filename = getResumeFilename(tor, tr_magnet_metainfo::BasenameFormat::Hash);
std::string const filename = tor->makeResumeFilename();
auto buf = std::vector<char>{};
tr_error* error = nullptr;
auto top = tr_variant{};
if (!tr_loadFile(buf, filename, &error) ||
!tr_variantFromBuf(
&top,
@ -733,29 +717,16 @@ static uint64_t loadFromFile(tr_torrent* tor, uint64_t fieldsToLoad, bool* didRe
{
tr_logAddTorDbg(tor, "Couldn't read \"%s\": %s", filename.c_str(), error->message);
tr_error_clear(&error);
std::string const old_filename = getResumeFilename(tor, tr_magnet_metainfo::BasenameFormat::NameAndPartialHash);
if (!tr_variantFromFile(&top, TR_VARIANT_PARSE_BENC, old_filename.c_str(), &error))
{
tr_logAddTorDbg(tor, "Couldn't read \"%s\" either: %s", old_filename.c_str(), error->message);
tr_error_free(error);
return fieldsLoaded;
}
if (tr_sys_path_rename(old_filename.c_str(), filename.c_str(), nullptr))
{
tr_logAddTorDbg(tor, "Migrated resume file from \"%s\" to \"%s\"", old_filename.c_str(), filename.c_str());
if (didRenameToHashOnlyName != nullptr)
{
*didRenameToHashOnlyName = true;
}
}
return 0;
}
tr_logAddTorDbg(tor, "Read resume file \"%s\"", filename.c_str());
auto fieldsLoaded = uint64_t{};
auto boolVal = false;
auto i = int64_t{};
auto sv = std::string_view{};
if ((fieldsToLoad & TR_FR_CORRUPT) != 0 && tr_variantDictFindInt(&top, TR_KEY_corrupt, &i))
{
tor->corruptPrev = i;
@ -970,9 +941,5 @@ uint64_t tr_torrentLoadResume(tr_torrent* tor, uint64_t fieldsToLoad, tr_ctor co
void tr_torrentRemoveResume(tr_torrent const* tor)
{
std::string filename = getResumeFilename(tor, tr_magnet_metainfo::BasenameFormat::Hash);
tr_sys_path_remove(filename.c_str(), nullptr);
filename = getResumeFilename(tor, tr_magnet_metainfo::BasenameFormat::NameAndPartialHash);
tr_sys_path_remove(filename.c_str(), nullptr);
tr_sys_path_remove(tor->makeResumeFilename().c_str(), nullptr);
}

12
libtransmission/session.cc
View File

@ -495,7 +495,7 @@ bool tr_sessionLoadSettings(tr_variant* dict, char const* config_dir, char const
auto fileSettings = tr_variant{};
auto const filename = tr_strvPath(config_dir, "settings.json"sv);
auto success = bool{};
if (tr_error* error = nullptr; tr_variantFromFile(&fileSettings, TR_VARIANT_PARSE_JSON, filename.c_str(), &error))
if (tr_error* error = nullptr; tr_variantFromFile(&fileSettings, TR_VARIANT_PARSE_JSON, filename, &error))
{
tr_variantMergeDicts(dict, &fileSettings);
tr_variantFree(&fileSettings);
@ -524,7 +524,7 @@ void tr_sessionSaveSettings(tr_session* session, char const* config_dir, tr_vari
{
tr_variant fileSettings;
if (tr_variantFromFile(&fileSettings, TR_VARIANT_PARSE_JSON, filename.c_str(), nullptr))
if (tr_variantFromFile(&fileSettings, TR_VARIANT_PARSE_JSON, filename, nullptr))
{
tr_variantMergeDicts(&settings, &fileSettings);
tr_variantFree(&fileSettings);
@ -544,7 +544,7 @@ void tr_sessionSaveSettings(tr_session* session, char const* config_dir, tr_vari
}
/* save the result */
tr_variantToFile(&settings, TR_VARIANT_FMT_JSON, filename.c_str());
tr_variantToFile(&settings, TR_VARIANT_FMT_JSON, filename);
/* cleanup */
tr_variantFree(&settings);
@ -2021,8 +2021,6 @@ static void sessionLoadTorrents(void* vdata)
auto* data = static_cast<struct sessionLoadTorrentsData*>(vdata);
TR_ASSERT(tr_isSession(data->session));
tr_ctorSetSave(data->ctor, false); /* since we already have them */
tr_sys_path_info info;
char const* const dirname = tr_getTorrentDir(data->session);
tr_sys_dir_t odir = (tr_sys_path_get_info(dirname, 0, &info, nullptr) && info.type == TR_SYS_PATH_IS_DIRECTORY) ?
@ -2038,13 +2036,13 @@ static void sessionLoadTorrents(void* vdata)
char const* name = nullptr;
while ((name = tr_sys_dir_read_name(odir, nullptr)) != nullptr)
{
if (!tr_str_has_suffix(name, ".torrent"))
if (!tr_strvEndsWith(name, ".torrent"sv))
{
continue;
}
tr_buildBuf(path, dirname_sv, "/", name);
tr_ctorSetMetainfoFromFile(data->ctor, path.c_str(), nullptr);
tr_ctorSetMetainfoFromFile(data->ctor, path, nullptr);
if (tr_torrent* const tor = tr_torrentNew(data->ctor, nullptr); tor != nullptr)
{
torrents.push_back(tor);

6
libtransmission/stats.cc
View File

@ -46,12 +46,12 @@ static void loadCumulativeStats(tr_session const* session, tr_session_stats* set
auto top = tr_variant{};
auto filename = getFilename(session);
bool loaded = tr_variantFromFile(&top, TR_VARIANT_PARSE_JSON, filename.c_str(), nullptr);
bool loaded = tr_variantFromFile(&top, TR_VARIANT_PARSE_JSON, filename, nullptr);
if (!loaded)
{
filename = getOldFilename(session);
loaded = tr_variantFromFile(&top, TR_VARIANT_PARSE_BENC, filename.c_str(), nullptr);
loaded = tr_variantFromFile(&top, TR_VARIANT_PARSE_BENC, filename, nullptr);
}
if (loaded)
@ -103,7 +103,7 @@ static void saveCumulativeStats(tr_session const* session, tr_session_stats cons
tr_logAddDeep(__FILE__, __LINE__, nullptr, "Saving stats to \"%s\"", filename.c_str());
}
tr_variantToFile(&top, TR_VARIANT_FMT_JSON, filename.c_str());
tr_variantToFile(&top, TR_VARIANT_FMT_JSON, filename);
tr_variantFree(&top);
}

31
libtransmission/torrent-ctor.cc
View File

@ -38,7 +38,6 @@ struct optional_args
struct tr_ctor
{
tr_session const* const session;
bool saveInOurTorrentsDir = false;
std::optional<bool> delete_source;
tr_torrent_metainfo metainfo = {};
@ -68,9 +67,9 @@ struct tr_ctor
****
***/
bool tr_ctorSetMetainfoFromFile(tr_ctor* ctor, char const* filename, tr_error** error)
bool tr_ctorSetMetainfoFromFile(tr_ctor* ctor, std::string const& filename, tr_error** error)
{
if (filename == nullptr)
if (std::empty(filename))
{
tr_error_set(error, EINVAL, "no filename specified"sv);
return false;
@ -81,14 +80,17 @@ bool tr_ctorSetMetainfoFromFile(tr_ctor* ctor, char const* filename, tr_error**
return false;
}
ctor->metainfo.clear();
auto const contents_sv = std::string_view{ std::data(ctor->contents), std::size(ctor->contents) };
return ctor->metainfo.parseBenc(contents_sv, error);
}
bool tr_ctorSetMetainfoFromFile(tr_ctor* ctor, char const* filename, tr_error** error)
{
return tr_ctorSetMetainfoFromFile(ctor, std::string{ filename ? filename : "" }, error);
}
bool tr_ctorSetMetainfo(tr_ctor* ctor, char const* metainfo, size_t len, tr_error** error)
{
ctor->metainfo.clear();
ctor->contents.assign(metainfo, metainfo + len);
auto const contents_sv = std::string_view{ std::data(ctor->contents), std::size(ctor->contents) };
return ctor->metainfo.parseBenc(contents_sv, error);
@ -96,7 +98,6 @@ bool tr_ctorSetMetainfo(tr_ctor* ctor, char const* metainfo, size_t len, tr_erro
bool tr_ctorSetMetainfoFromMagnetLink(tr_ctor* ctor, char const* magnet_link, tr_error** error)
{
ctor->metainfo.clear();
return ctor->metainfo.parseMagnet(magnet_link ? magnet_link : "", error);
}
@ -110,7 +111,7 @@ char const* tr_ctorGetSourceFile(tr_ctor const* ctor)
return ctor->metainfo.torrentFile().c_str();
}
bool tr_ctorSaveContents(tr_ctor const* ctor, std::string_view filename, tr_error** error)
bool tr_ctorSaveContents(tr_ctor const* ctor, std::string const& filename, tr_error** error)
{
TR_ASSERT(ctor != nullptr);
TR_ASSERT(!std::empty(filename));
@ -194,16 +195,6 @@ bool tr_ctorGetDeleteSource(tr_ctor const* ctor, bool* setme)
****
***/
void tr_ctorSetSave(tr_ctor* ctor, bool saveInOurTorrentsDir)
{
ctor->saveInOurTorrentsDir = saveInOurTorrentsDir;
}
bool tr_ctorGetSave(tr_ctor const* ctor)
{
return ctor != nullptr && ctor->saveInOurTorrentsDir;
}
void tr_ctorSetPaused(tr_ctor* ctor, tr_ctorMode mode, bool paused)
{
TR_ASSERT(ctor != nullptr);
@ -297,6 +288,11 @@ bool tr_ctorGetIncompleteDir(tr_ctor const* ctor, char const** setme)
return true;
}
tr_torrent_metainfo&& tr_ctorStealMetainfo(tr_ctor* ctor)
{
return std::move(ctor->metainfo);
}
tr_torrent_metainfo const* tr_ctorGetMetainfo(tr_ctor const* ctor)
{
return !std::empty(ctor->metainfo.infoHashString()) ? &ctor->metainfo : nullptr;
@ -342,7 +338,6 @@ tr_ctor* tr_ctorNew(tr_session const* session)
tr_ctorSetPeerLimit(ctor, TR_FALLBACK, session->peerLimitPerTorrent);
tr_ctorSetDownloadDir(ctor, TR_FALLBACK, tr_sessionGetDownloadDir(session));
tr_ctorSetSave(ctor, true);
return ctor;
}

119
libtransmission/torrent-magnet.cc
View File

@ -21,7 +21,6 @@
#include "file.h"
#include "log.h"
#include "magnet-metainfo.h"
#include "metainfo.h"
#include "resume.h"
#include "torrent-magnet.h"
#include "torrent-metainfo.h"
@ -116,50 +115,6 @@ bool tr_torrentSetMetadataSizeHint(tr_torrent* tor, int64_t size)
return true;
}
static size_t findInfoDictOffset(tr_torrent const* tor)
{
// load the torrent's .torrent file
auto benc = std::vector<char>{};
if (!tr_loadFile(benc, tor->torrentFile()) || std::empty(benc))
{
return {};
}
// parse the benc
auto top = tr_variant{};
auto const benc_sv = std::string_view{ std::data(benc), std::size(benc) };
if (!tr_variantFromBuf(&top, TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE, benc_sv))
{
return {};
}
auto offset = size_t{};
tr_variant* info_dict = nullptr;
if (tr_variantDictFindDict(&top, TR_KEY_info, &info_dict))
{
auto const info_dict_benc = tr_variantToStr(info_dict, TR_VARIANT_FMT_BENC);
auto const it = std::search(std::begin(benc), std::end(benc), std::begin(info_dict_benc), std::end(info_dict_benc));
if (it != std::end(benc))
{
offset = std::distance(std::begin(benc), it);
}
}
tr_variantFree(&top);
return offset;
}
static void ensureInfoDictOffsetIsCached(tr_torrent* tor)
{
TR_ASSERT(tor->hasMetadata());
if (!tor->info_dict_offset_is_cached)
{
tor->info_dict_offset = findInfoDictOffset(tor);
tor->info_dict_offset_is_cached = true;
}
}
void* tr_torrentGetMetadataPiece(tr_torrent* tor, int piece, size_t* len)
{
TR_ASSERT(tr_isTorrent(tor));
@ -177,8 +132,6 @@ void* tr_torrentGetMetadataPiece(tr_torrent* tor, int piece, size_t* len)
return nullptr;
}
ensureInfoDictOffsetIsCached(tor);
auto const info_dict_size = tor->infoDictSize();
TR_ASSERT(info_dict_size > 0);
@ -229,7 +182,7 @@ static int getPieceLength(struct tr_incomplete_metadata const* m, int piece)
METADATA_PIECE_SIZE;
}
static void tr_buildMetainfoExceptInfoDict(tr_info const& tm, tr_variant* top)
static void tr_buildMetainfoExceptInfoDict(tr_torrent_metainfo const& tm, tr_variant* top)
{
tr_variantInitDict(top, 6);
@ -285,21 +238,6 @@ static void tr_buildMetainfoExceptInfoDict(tr_info const& tm, tr_variant* top)
tr_variantListAddStr(webseeds_variant, tm.webseed(i));
}
}
if (tm.fileCount() == 0)
{
// local transmission extensions.
// these temporary placeholders are used for magnets until we have the info dict.
auto* const magnet_info = tr_variantDictAddDict(top, TR_KEY_magnet_info, 2);
tr_variantDictAddStr(
magnet_info,
TR_KEY_info_hash,
std::string_view{ reinterpret_cast<char const*>(std::data(tm.infoHash())), std::size(tm.infoHash()) });
if (auto const& val = tm.name(); !std::empty(val))
{
tr_variantDictAddStr(magnet_info, TR_KEY_display_name, val);
}
}
}
static bool useNewMetainfo(tr_torrent* tor, tr_incomplete_metadata* m, tr_error** error)
@ -321,36 +259,29 @@ static bool useNewMetainfo(tr_torrent* tor, tr_incomplete_metadata* m, tr_error*
// yay we have an info dict. Let's make a .torrent file
auto top_v = tr_variant{};
tr_buildMetainfoExceptInfoDict(tor->info, &top_v);
tr_buildMetainfoExceptInfoDict(tor->metainfo_, &top_v);
tr_variantMergeDicts(tr_variantDictAddDict(&top_v, TR_KEY_info, 0), &info_dict_v);
auto const benc = tr_variantToStr(&top_v, TR_VARIANT_FMT_BENC);
// does this synthetic .torrent file parse?
auto parsed = tr_metainfoParse(tor->session, &top_v, error);
tr_variantFree(&top_v);
tr_variantFree(&info_dict_v);
if (!parsed)
// does this synthetic .torrent file parse?
auto metainfo = tr_torrent_metainfo{};
if (!metainfo.parseBenc(benc))
{
return false;
}
// save it
auto const& torrent_dir = tor->session->torrent_dir;
auto const filename = tr_magnet_metainfo::makeFilename(
torrent_dir,
tor->name(),
tor->infoHashString(),
tr_magnet_metainfo::BasenameFormat::Hash,
".torrent"sv);
auto const filename = tor->makeTorrentFilename();
if (!tr_saveFile(filename, benc, error))
{
return false;
}
// tor should keep this metainfo
tor->swapMetainfo(*parsed);
tr_torrentGotNewInfoDict(tor);
tor->setDirty();
metainfo.setTorrentFile(filename);
tor->setMetainfo(metainfo);
return true;
}
@ -469,37 +400,7 @@ double tr_torrentGetMetadataPercent(tr_torrent const* tor)
return m == nullptr || m->pieceCount == 0 ? 0.0 : (m->pieceCount - m->piecesNeededCount) / (double)m->pieceCount;
}
/* TODO: this should be renamed tr_metainfoGetMagnetLink() and moved to metainfo.c for consistency */
char* tr_torrentInfoGetMagnetLink(tr_info const* inf)
{
auto buf = std::string{};
buf += "magnet:?xt=urn:btih:"sv;
buf += inf->infoHashString();
auto const& name = inf->name();
if (!std::empty(name))
{
buf += "&dn="sv;
tr_http_escape(buf, name, true);
}
for (size_t i = 0, n = std::size(*inf->announce_list); i < n; ++i)
{
buf += "&tr="sv;
tr_http_escape(buf, inf->announce_list->at(i).announce.full, true);
}
for (size_t i = 0, n = inf->webseedCount(); i < n; ++i)
{
buf += "&ws="sv;
tr_http_escape(buf, inf->webseed(i), true);
}
return tr_strvDup(buf);
}
char* tr_torrentGetMagnetLink(tr_torrent const* tor)
{
return tr_torrentInfoGetMagnetLink(&tor->info);
return tr_strvDup(tor->metainfo_.magnet());
}

87
libtransmission/torrent-metainfo.cc
View File

@ -21,6 +21,8 @@
#include "crypto-utils.h"
#include "error-types.h"
#include "error.h"
#include "file.h"
#include "log.h"
#include "quark.h"
#include "torrent-metainfo.h"
#include "utils.h"
@ -131,11 +133,6 @@ tr_torrent_metainfo_tracker_info* tr_torrentMetainfoTracker(
****
***/
void tr_torrent_metainfo::clear()
{
*this = tr_torrent_metainfo{};
}
/**
* @brief Ensure that the URLs for multfile torrents end in a slash.
*
@ -239,38 +236,39 @@ static bool appendSanitizedComponent(std::string& out, std::string_view in, bool
return std::size(out) > original_out_len;
}
std::string tr_torrent_metainfo::parsePath(std::string_view root, tr_variant* path, std::string& buf)
bool tr_torrent_metainfo::parsePath(std::string_view root, tr_variant* path, std::string& setme)
{
if (!tr_variantIsList(path))
{
return {};
return false;
}
buf = root;
setme = root;
for (size_t i = 0, n = tr_variantListSize(path); i < n; ++i)
{
auto raw = std::string_view{};
if (!tr_variantGetStrView(tr_variantListChild(path, i), &raw))
{
return {};
return false;
}
auto is_component_adjusted = bool{};
auto const pos = std::size(buf);
if (!appendSanitizedComponent(buf, raw, &is_component_adjusted))
auto const pos = std::size(setme);
if (!appendSanitizedComponent(setme, raw, &is_component_adjusted))
{
continue;
}
buf.insert(std::begin(buf) + pos, TR_PATH_DELIMITER);
setme.insert(std::begin(setme) + pos, TR_PATH_DELIMITER);
}
if (std::size(buf) <= std::size(root))
if (std::size(setme) <= std::size(root))
{
return {};
return false;
}
return tr_strvUtf8Clean(buf);
tr_strvUtf8Clean(setme, setme);
return true;
}
std::string_view tr_torrent_metainfo::parseFiles(tr_torrent_metainfo& setme, tr_variant* info_dict, uint64_t* setme_total_size)
@ -313,9 +311,10 @@ std::string_view tr_torrent_metainfo::parseFiles(tr_torrent_metainfo& setme, tr_
// In the multifile case, the name key is the name of a directory.
else if (tr_variantDictFindList(info_dict, TR_KEY_files, &files_entry))
{
auto buf = std::string{};
buf.reserve(1024); // arbitrary
auto const n_files = size_t{ tr_variantListSize(files_entry) };
setme.files_.reserve(n_files);
for (size_t i = 0; i < n_files; ++i)
{
auto* const file_entry = tr_variantListChild(files_entry, i);
@ -336,13 +335,12 @@ std::string_view tr_torrent_metainfo::parseFiles(tr_torrent_metainfo& setme, tr_
return "path";
}
auto const path = parsePath(root_name, path_variant, buf);
if (std::empty(path))
if (!parsePath(root_name, path_variant, buf))
{
return "path";
}
setme.files_.emplace_back(path, len);
setme.files_.emplace_back(buf, len);
total_size += len;
}
}
@ -444,7 +442,7 @@ std::string_view tr_torrent_metainfo::parseImpl(tr_torrent_metainfo& setme, tr_v
// name
if (tr_variantDictFindStrView(info_dict, TR_KEY_name_utf_8, &sv) || tr_variantDictFindStrView(info_dict, TR_KEY_name, &sv))
{
setme.setName(tr_strvUtf8Clean(sv));
tr_strvUtf8Clean(sv, setme.name_);
}
else
{
@ -455,7 +453,7 @@ std::string_view tr_torrent_metainfo::parseImpl(tr_torrent_metainfo& setme, tr_v
setme.comment_.clear();
if (tr_variantDictFindStrView(meta, TR_KEY_comment_utf_8, &sv) || tr_variantDictFindStrView(meta, TR_KEY_comment, &sv))
{
setme.comment_ = tr_strvUtf8Clean(sv);
tr_strvUtf8Clean(sv, setme.comment_);
}
// created by (optional)
@ -463,7 +461,7 @@ std::string_view tr_torrent_metainfo::parseImpl(tr_torrent_metainfo& setme, tr_v
if (tr_variantDictFindStrView(meta, TR_KEY_created_by_utf_8, &sv) ||
tr_variantDictFindStrView(meta, TR_KEY_created_by, &sv))
{
setme.creator_ = tr_strvUtf8Clean(sv);
tr_strvUtf8Clean(sv, setme.creator_);
}
// creation date (optional)
@ -478,7 +476,7 @@ std::string_view tr_torrent_metainfo::parseImpl(tr_torrent_metainfo& setme, tr_v
setme.source_.clear();
if (tr_variantDictFindStrView(info_dict, TR_KEY_source, &sv) || tr_variantDictFindStrView(meta, TR_KEY_source, &sv))
{
setme.source_ = tr_strvUtf8Clean(sv);
tr_strvUtf8Clean(sv, setme.source_);
}
// piece length
@ -551,11 +549,50 @@ bool tr_torrent_metainfo::parseTorrentFile(std::string_view filename, std::vecto
}
auto const sz_filename = std::string{ filename };
return tr_loadFile(*contents, sz_filename.c_str(), error) &&
parseBenc({ std::data(*contents), std::size(*contents) }, error);
return tr_loadFile(*contents, sz_filename, error) && parseBenc({ std::data(*contents), std::size(*contents) }, error);
}
tr_sha1_digest_t const& tr_torrent_metainfo::pieceHash(tr_piece_index_t piece) const
{
return this->pieces_[piece];
}
std::string tr_torrent_metainfo::makeFilename(
std::string_view dirname,
std::string_view name,
std::string_view info_hash_string,
BasenameFormat format,
std::string_view suffix)
{
// `${dirname}/${name}.${info_hash}${suffix}`
// `${dirname}/${info_hash}${suffix}`
return format == BasenameFormat::Hash ? tr_strvJoin(dirname, "/"sv, info_hash_string, suffix) :
tr_strvJoin(dirname, "/"sv, name, "."sv, info_hash_string.substr(0, 16), suffix);
}
bool tr_torrent_metainfo::migrateFile(
std::string_view dirname,
std::string_view name,
std::string_view info_hash_string,
std::string_view suffix)
{
auto const old_filename = makeFilename(dirname, name, info_hash_string, BasenameFormat::NameAndPartialHash, suffix);
if (!tr_sys_path_exists(old_filename.c_str(), nullptr))
{
return false;
}
auto const new_filename = makeFilename(dirname, name, info_hash_string, BasenameFormat::Hash, suffix);
if (!tr_sys_path_rename(old_filename.c_str(), new_filename.c_str(), nullptr))
{
return false;
}
auto const name_sz = std::string{ name };
tr_logAddNamedError(
name_sz.c_str(),
"Migrated torrent file from \"%s\" to \"%s\"",
old_filename.c_str(),
new_filename.c_str());
return true;
}

56
libtransmission/torrent-metainfo.h
View File

@ -24,9 +24,6 @@ struct tr_info;
struct tr_torrent_metainfo : public tr_magnet_metainfo
{
public:
tr_torrent_metainfo() = default;
~tr_torrent_metainfo() override = default;
[[nodiscard]] auto empty() const
{
return std::empty(files_);
@ -121,6 +118,10 @@ public:
{
return files_.at(i).path();
}
void setFileSubpath(tr_file_index_t i, std::string_view subpath)
{
files_.at(i).setSubpath(subpath);
}
auto fileSize(tr_file_index_t i) const
{
return files_.at(i).size();
@ -136,6 +137,11 @@ public:
return torrent_file_;
}
void setTorrentFile(std::string_view filename)
{
torrent_file_ = filename;
}
[[nodiscard]] tr_sha1_digest_t const& pieceHash(tr_piece_index_t piece) const;
[[nodiscard]] auto const& dateCreated() const
@ -143,8 +149,6 @@ public:
return date_created_;
}
void clear() final;
[[nodiscard]] std::string benc() const;
[[nodiscard]] auto infoDictSize() const
@ -157,14 +161,48 @@ public:
return info_dict_offset_;
}
std::string makeTorrentFilename(std::string_view torrent_dir) const
{
return makeFilename(torrent_dir, name(), infoHashString(), BasenameFormat::Hash, ".torrent");
}
std::string makeResumeFilename(std::string_view resume_dir) const
{
return makeFilename(resume_dir, name(), infoHashString(), BasenameFormat::Hash, ".resume");
}
bool migrateFile(
std::string_view dirname,
std::string_view name,
std::string_view info_hash_string,
std::string_view suffix);
private:
static std::string parsePath(std::string_view root, tr_variant* path, std::string& buf);
static bool parsePath(std::string_view root, tr_variant* path, std::string& setme);
static std::string fixWebseedUrl(tr_torrent_metainfo const& tm, std::string_view url);
static std::string_view parseFiles(tr_torrent_metainfo& setme, tr_variant* info_dict, uint64_t* setme_total_size);
static std::string_view parseImpl(tr_torrent_metainfo& setme, tr_variant* meta, std::string_view benc);
static std::string_view parseAnnounce(tr_torrent_metainfo& setme, tr_variant* meta);
static void parseWebseeds(tr_torrent_metainfo& setme, tr_variant* meta);
enum class BasenameFormat
{
Hash,
NameAndPartialHash
};
static std::string makeFilename(
std::string_view dirname,
std::string_view name,
std::string_view info_hash_string,
BasenameFormat format,
std::string_view suffix);
std::string makeFilename(std::string_view dirname, BasenameFormat format, std::string_view suffix) const
{
return makeFilename(dirname, name(), infoHashString(), format, suffix);
}
struct file_t
{
public:
@ -172,6 +210,12 @@ private:
{
return path_;
}
void setSubpath(std::string_view subpath)
{
path_ = subpath;
}
uint64_t size() const
{
return size_;

158
libtransmission/torrent.cc
View File

@ -44,7 +44,6 @@
#include "inout.h" /* tr_ioTestPiece() */
#include "log.h"
#include "magnet-metainfo.h"
#include "metainfo.h"
#include "peer-common.h" /* MAX_BLOCK_SIZE */
#include "peer-mgr.h"
#include "platform.h" /* TR_PATH_DELIMITER_STR */
@ -560,8 +559,7 @@ static void tr_torrentFireMetadataCompleted(tr_torrent* tor);
static void torrentInitFromInfoDict(tr_torrent* tor)
{
tor->block_info.initSizes(tor->info.totalSize(), tor->info.pieceSize());
tor->completion = tr_completion{ tor, &tor->block_info };
tor->completion = tr_completion{ tor, &tor->blockInfo() };
auto const obfuscated = tr_sha1("req2"sv, tor->infoHash());
if (obfuscated)
{
@ -574,18 +572,21 @@ static void torrentInitFromInfoDict(tr_torrent* tor)
tor->obfuscated_hash = tr_sha1_digest_t{};
}
tor->fpm_.reset(tor->info);
tor->fpm_.reset(tor->metainfo_);
tor->file_mtimes_.resize(tor->fileCount());
tor->file_priorities_.reset(&tor->fpm_);
tor->files_wanted_.reset(&tor->fpm_);
tor->checked_pieces_ = tr_bitfield{ size_t(tor->pieceCount()) };
}
void tr_torrentGotNewInfoDict(tr_torrent* tor)
void tr_torrent::setMetainfo(tr_torrent_metainfo const& tm)
{
torrentInitFromInfoDict(tor);
tr_peerMgrOnTorrentGotMetainfo(tor);
tr_torrentFireMetadataCompleted(tor);
metainfo_ = tm;
torrentInitFromInfoDict(this);
tr_peerMgrOnTorrentGotMetainfo(this);
tr_torrentFireMetadataCompleted(this);
this->setDirty();
}
static bool hasAnyLocalData(tr_torrent const* tor)
@ -631,29 +632,6 @@ static void callScriptIfEnabled(tr_torrent const* tor, TrScript type)
static void refreshCurrentDir(tr_torrent* tor);
static void migrateFile(
tr_torrent const* tor,
tr_magnet_metainfo::BasenameFormat old_format,
tr_magnet_metainfo::BasenameFormat new_format)
{
auto const torrent_dir = tor->session->torrent_dir;
auto const& name = tor->name();
auto const& hash_string = tor->infoHashString();
auto const suffix = "torrent"sv;
auto const old_filename = tr_magnet_metainfo::makeFilename(torrent_dir, name, hash_string, old_format, suffix);
auto const new_filename = tr_magnet_metainfo::makeFilename(torrent_dir, name, hash_string, new_format, suffix);
if (tr_sys_path_rename(old_filename.c_str(), new_filename.c_str(), nullptr))
{
tr_logAddNamedError(
tor->name().c_str(),
"Migrated torrent file from \"%s\" to \"%s\"",
old_filename.c_str(),
new_filename.c_str());
}
}
static void torrentInit(tr_torrent* tor, tr_ctor const* ctor)
{
static auto next_unique_id = int{ 1 };
@ -704,18 +682,16 @@ static void torrentInit(tr_torrent* tor, tr_ctor const* ctor)
// the same ones that would be saved back again, so don't let them
// affect the 'is dirty' flag.
auto const was_dirty = tor->isDirty;
bool didRenameResumeFileToHashOnlyName = false;
auto const loaded = tr_torrentLoadResume(tor, ~(uint64_t)0, ctor, &didRenameResumeFileToHashOnlyName);
bool resume_file_was_migrated = false;
auto const loaded = tr_torrentLoadResume(tor, ~(uint64_t)0, ctor, &resume_file_was_migrated);
tor->isDirty = was_dirty;
if (didRenameResumeFileToHashOnlyName)
if (resume_file_was_migrated)
{
/* Rename torrent file as well */
migrateFile(tor, tr_magnet_metainfo::BasenameFormat::NameAndPartialHash, tr_magnet_metainfo::BasenameFormat::Hash);
tor->metainfo_.migrateFile(session->torrent_dir, tor->name(), tor->infoHashString(), ".torrent");
}
tor->completeness = tor->completion.status();
setLocalErrorIfFilesDisappeared(tor);
tr_ctorInitTorrentPriorities(ctor, tor);
tr_ctorInitTorrentWanted(ctor, tor);
@ -748,14 +724,17 @@ static void torrentInit(tr_torrent* tor, tr_ctor const* ctor)
tr_sessionAddTorrent(session, tor);
/* if we don't have a local .torrent file already, assume the torrent is new */
bool const isNewTorrent = !tr_sys_path_exists(tor->torrentFile().c_str(), nullptr);
/* maybe save our own copy of the metainfo */
if (tr_ctorGetSave(ctor))
// if we don't have a local .torrent file already, assume the torrent is new
auto filename = tor->makeTorrentFilename();
bool const is_new_torrent = !tr_sys_path_exists(filename.c_str(), nullptr);
if (is_new_torrent)
{
tr_error* error = nullptr;
if (!tr_ctorSaveContents(ctor, tor->torrentFile(), &error))
if (tr_ctorSaveContents(ctor, filename, &error))
{
tor->setTorrentFile(filename);
}
else
{
tor->setLocalError(
tr_strvJoin("Unable to save torrent file: ", error->message, " ("sv, std::to_string(error->code), ")"sv));
@ -765,7 +744,7 @@ static void torrentInit(tr_torrent* tor, tr_ctor const* ctor)
tor->announcer_tiers = tr_announcerAddTorrent(tor, onTrackerResponse, nullptr);
if (isNewTorrent)
if (is_new_torrent)
{
if (tor->hasMetadata())
{
@ -787,23 +766,27 @@ static void torrentInit(tr_torrent* tor, tr_ctor const* ctor)
{
tr_torrentStart(tor);
}
else
{
setLocalErrorIfFilesDisappeared(tor);
}
}
tr_torrent* tr_torrentNew(tr_ctor const* ctor, tr_torrent** setme_duplicate_of)
tr_torrent* tr_torrentNew(tr_ctor* ctor, tr_torrent** setme_duplicate_of)
{
TR_ASSERT(ctor != nullptr);
auto* const session = tr_ctorGetSession(ctor);
TR_ASSERT(tr_isSession(session));
// is the metainfo valid?
auto const* metainfo = tr_ctorGetMetainfo(ctor);
if (metainfo == nullptr)
auto metainfo = tr_ctorStealMetainfo(ctor);
if (std::empty(metainfo.infoHashString()))
{
return nullptr;
}
// is it a duplicate?
if (auto* const duplicate_of = session->getTorrent(metainfo->infoHash()); duplicate_of != nullptr)
if (auto* const duplicate_of = session->getTorrent(metainfo.infoHash()); duplicate_of != nullptr)
{
if (setme_duplicate_of != nullptr)
{
@ -813,29 +796,7 @@ tr_torrent* tr_torrentNew(tr_ctor const* ctor, tr_torrent** setme_duplicate_of)
return nullptr;
}
// build a variant to parse
auto top_variant = tr_variant{};
if (std::empty(*metainfo))
{
metainfo->toVariant(&top_variant);
}
else
{
tr_variantFromBuf(&top_variant, TR_VARIANT_PARSE_BENC, tr_ctorGetContents(ctor), nullptr, nullptr);
}
// parse the metainfo
tr_error* error = nullptr;
auto parsed = tr_metainfoParse(session, &top_variant, &error);
tr_variantFree(&top_variant);
if (!parsed)
{
return nullptr;
}
// add it
auto* const tor = new tr_torrent{ parsed->info };
tor->swapMetainfo(*parsed);
auto* const tor = new tr_torrent{ std::move(metainfo) };
torrentInit(tor, ctor);
return tor;
}
@ -1269,7 +1230,6 @@ static void freeTorrent(tr_torrent* tor)
TR_ASSERT(!tor->isRunning);
tr_session* session = tor->session;
tr_info* inf = &tor->info;
tr_peerMgrRemoveTorrent(tor);
@ -1294,8 +1254,6 @@ static void freeTorrent(tr_torrent* tor)
}
delete tor->bandwidth;
tr_metainfoFree(inf);
delete tor;
}
@ -2061,7 +2019,7 @@ bool tr_torrentSetAnnounceList(tr_torrent* tor, char const* const* announce_urls
return false;
}
std::swap(*tor->info.announce_list, announce_list);
tor->metainfo_.announceList() = announce_list;
tor->markEdited();
/* if we had a tracker-related error on this torrent,
@ -3106,13 +3064,6 @@ void tr_torrentRenamePath(
tor->renamePath(oldpath, newname, callback, callback_user_data);
}
void tr_torrent::swapMetainfo(tr_metainfo_parsed& parsed)
{
std::swap(this->info, parsed.info);
std::swap(this->piece_checksums_, parsed.pieces);
std::swap(this->info_dict_size, parsed.info_dict_size);
}
void tr_torrentSetFilePriorities(
tr_torrent* tor,
tr_file_index_t const* files,
@ -3148,17 +3099,44 @@ void tr_torrent::setBlocks(tr_bitfield blocks)
this->completion.setBlocks(std::move(blocks));
}
void tr_torrent::setName(std::string_view name)
[[nodiscard]] bool tr_torrent::ensurePieceIsChecked(tr_piece_index_t piece)
{
this->info.setName(name);
TR_ASSERT(piece < this->pieceCount());
if (checked_pieces_.test(piece))
{
return true;
}
bool const checked = checkPiece(piece);
this->markChanged();
this->setDirty();
checked_pieces_.set(piece, checked);
return checked;
}
void tr_torrent::setFileSubpath(tr_file_index_t i, std::string_view subpath)
void tr_torrent::initCheckedPieces(tr_bitfield const& checked, time_t const* mtimes /*fileCount()*/)
{
this->info.setFileSubpath(i, subpath);
}
TR_ASSERT(std::size(checked) == this->pieceCount());
checked_pieces_ = checked;
void tr_info::setAnnounceList(tr_announce_list const& list)
{
this->announce_list = std::make_shared<tr_announce_list>(list);
auto const n = this->fileCount();
this->file_mtimes_.resize(n);
auto filename = std::string{};
for (size_t i = 0; i < n; ++i)
{
auto const found = this->findFile(filename, i);
auto const mtime = found ? found->last_modified_at : 0;
this->file_mtimes_[i] = mtime;
// if a file has changed, mark its pieces as unchecked
if (mtime == 0 || mtime != mtimes[i])
{
auto const [begin, end] = piecesInFile(i);
checked_pieces_.unsetSpan(begin, end);
}
}
}

154
libtransmission/torrent.h
View File

@ -31,7 +31,7 @@
#include "file-piece-map.h"
#include "interned-string.h"
#include "session.h"
#include "tr-assert.h"
#include "torrent-metainfo.h"
#include "tr-macros.h"
class tr_swarm;
@ -48,15 +48,11 @@ struct tr_announcer_tiers;
void tr_torrentFree(tr_torrent* tor);
void tr_ctorSetSave(tr_ctor* ctor, bool saveMetadataInOurTorrentsDir);
bool tr_ctorGetSave(tr_ctor const* ctor);
void tr_ctorInitTorrentPriorities(tr_ctor const* ctor, tr_torrent* tor);
void tr_ctorInitTorrentWanted(tr_ctor const* ctor, tr_torrent* tor);
bool tr_ctorSaveContents(tr_ctor const* ctor, std::string_view filename, tr_error** error);
bool tr_ctorSaveContents(tr_ctor const* ctor, std::string const& filename, tr_error** error);
std::string_view tr_ctorGetContents(tr_ctor const* ctor);
@ -107,9 +103,9 @@ struct tr_incomplete_metadata;
struct tr_torrent : public tr_completion::torrent_view
{
public:
explicit tr_torrent(tr_info const& inf)
: block_info{ inf.totalSize(), inf.pieceSize() }
, completion{ this, &this->block_info }
explicit tr_torrent(tr_torrent_metainfo&& tm)
: metainfo_{ std::move(tm) }
, completion{ this, &this->metainfo_.blockInfo() }
{
}
@ -129,16 +125,14 @@ public:
tr_sha1_digest_t pieceHash(tr_piece_index_t i) const
{
TR_ASSERT(i < std::size(this->piece_checksums_));
return this->piece_checksums_[i];
return metainfo_.pieceHash(i);
}
// these functions should become private when possible,
// but more refactoring is needed before that can happen
// because much of tr_torrent's impl is in the non-member C bindings
//
// private:
void swapMetainfo(tr_metainfo_parsed& parsed);
void setMetainfo(tr_torrent_metainfo const& tm);
auto unique_lock() const
{
@ -155,7 +149,7 @@ public:
[[nodiscard]] constexpr auto const& blockInfo() const
{
return block_info;
return metainfo_.blockInfo();
}
[[nodiscard]] constexpr auto blockCount() const
@ -371,20 +365,23 @@ public:
[[nodiscard]] tr_file_index_t fileCount() const
{
return std::size(info.files);
return metainfo_.fileCount();
}
[[nodiscard]] std::string const& fileSubpath(tr_file_index_t i) const
{
return info.fileSubpath(i);
return metainfo_.fileSubpath(i);
}
[[nodiscard]] auto fileSize(tr_file_index_t i) const
{
return info.fileSize(i);
return metainfo_.fileSize(i);
}
void setFileSubpath(tr_file_index_t i, std::string_view subpath);
void setFileSubpath(tr_file_index_t i, std::string_view subpath)
{
metainfo_.setFileSubpath(i, subpath);
}
struct tr_found_file_t : public tr_sys_path_info
{
@ -407,12 +404,12 @@ public:
[[nodiscard]] auto const& announceList() const
{
return *this->info.announce_list;
return metainfo_.announceList();
}
[[nodiscard]] auto& announceList()
{
return *this->info.announce_list;
return metainfo_.announceList();
}
[[nodiscard]] auto trackerCount() const
@ -434,31 +431,34 @@ public:
[[nodiscard]] auto webseedCount() const
{
return info.webseedCount();
return metainfo_.webseedCount();
}
[[nodiscard]] auto const& webseed(size_t i) const
{
return info.webseed(i);
return metainfo_.webseed(i);
}
/// METAINFO - OTHER
void setName(std::string_view name);
void setName(std::string_view name)
{
metainfo_.setName(name);
}
[[nodiscard]] auto const& name() const
{
return this->info.name();
return metainfo_.name();
}
[[nodiscard]] auto const& infoHash() const
{
return this->info.infoHash();
return metainfo_.infoHash();
}
[[nodiscard]] auto isPrivate() const
{
return this->info.isPrivate();
return metainfo_.isPrivate();
}
[[nodiscard]] auto isPublic() const
@ -468,32 +468,37 @@ public:
[[nodiscard]] auto const& infoHashString() const
{
return this->info.infoHashString();
return metainfo_.infoHashString();
}
[[nodiscard]] auto dateCreated() const
{
return this->info.dateCreated();
return metainfo_.dateCreated();
}
[[nodiscard]] auto const& torrentFile() const
{
return this->info.torrentFile();
return metainfo_.torrentFile();
}
void setTorrentFile(std::string_view filename)
{
metainfo_.setTorrentFile(filename);
}
[[nodiscard]] auto const& comment() const
{
return this->info.comment();
return metainfo_.comment();
}
[[nodiscard]] auto const& creator() const
{
return this->info.creator();
return metainfo_.creator();
}
[[nodiscard]] auto const& source() const
{
return this->info.source();
return metainfo_.source();
}
[[nodiscard]] auto hasMetadata() const
@ -503,57 +508,29 @@ public:
[[nodiscard]] auto infoDictSize() const
{
return this->info_dict_size;
return metainfo_.infoDictSize();
}
[[nodiscard]] auto infoDictOffset() const
{
return this->info_dict_offset;
return metainfo_.infoDictOffset();
}
[[nodiscard]] auto makeTorrentFilename() const
{
return metainfo_.makeTorrentFilename(this->session->torrent_dir);
}
[[nodiscard]] auto makeResumeFilename() const
{
return metainfo_.makeResumeFilename(this->session->resume_dir);
}
/// METAINFO - CHECKSUMS
[[nodiscard]] bool ensurePieceIsChecked(tr_piece_index_t piece)
{
TR_ASSERT(piece < this->pieceCount());
[[nodiscard]] bool ensurePieceIsChecked(tr_piece_index_t piece);
if (checked_pieces_.test(piece))
{
return true;
}
bool const checked = checkPiece(piece);
this->markChanged();
this->setDirty();
checked_pieces_.set(piece, checked);
return checked;
}
void initCheckedPieces(tr_bitfield const& checked, time_t const* mtimes /*fileCount()*/)
{
TR_ASSERT(std::size(checked) == this->pieceCount());
checked_pieces_ = checked;
auto const n = this->fileCount();
this->file_mtimes_.resize(n);
auto filename = std::string{};
for (size_t i = 0; i < n; ++i)
{
auto const found = this->findFile(filename, i);
auto const mtime = found ? found->last_modified_at : 0;
this->file_mtimes_[i] = mtime;
// if a file has changed, mark its pieces as unchecked
if (mtime == 0 || mtime != mtimes[i])
{
auto const [begin, end] = piecesInFile(i);
checked_pieces_.unsetSpan(begin, end);
}
}
}
void initCheckedPieces(tr_bitfield const& checked, time_t const* mtimes /*fileCount()*/);
///
@ -609,12 +586,10 @@ public:
torrent's content than any other mime-type. */
std::string_view primaryMimeType() const;
tr_info info = {};
tr_torrent_metainfo metainfo_;
tr_bitfield checked_pieces_ = tr_bitfield{ 0 };
tr_block_info block_info;
// TODO(ckerr): make private once some of torrent.cc's `tr_torrentFoo()` methods are member functions
tr_completion completion;
@ -668,17 +643,6 @@ public:
// Will equal either download_dir or incomplete_dir
tr_interned_string current_dir;
/* Length, in bytes, of the "info" dict in the .torrent file. */
uint64_t info_dict_size = 0;
/* Offset, in bytes, of the beginning of the "info" dict in the .torrent file.
*
* Used by the torrent-magnet code for serving metainfo to peers.
* This field is lazy-generated and might not be initialized yet. */
uint64_t info_dict_offset = 0;
bool info_dict_offset_is_cached = false;
tr_completeness completeness = TR_LEECH;
time_t dhtAnnounceAt = 0;
@ -765,7 +729,7 @@ public:
static auto constexpr MagicNumber = int{ 95549 };
tr_file_piece_map fpm_ = tr_file_piece_map{ info };
tr_file_piece_map fpm_ = tr_file_piece_map{ metainfo_ };
tr_file_priorities file_priorities_{ &fpm_ };
tr_files_wanted files_wanted_{ &fpm_ };
@ -785,8 +749,6 @@ private:
recheckCompleteness();
}
}
mutable std::vector<tr_sha1_digest_t> piece_checksums_;
};
/***
@ -824,11 +786,11 @@ bool tr_torrentFindFile2(tr_torrent const*, tr_file_index_t fileNo, char const**
* a la Firefox. */
char* tr_torrentBuildPartial(tr_torrent const*, tr_file_index_t fileNo);
/* for when the info dict has been fundamentally changed wrt files,
* piece size, etc. such as in BEP 9 where peers exchange metadata */
void tr_torrentGotNewInfoDict(tr_torrent* tor);
tr_peer_id_t const& tr_torrentGetPeerId(tr_torrent* tor);
/** @brief free a metainfo */
void tr_metainfoFree(tr_info* inf);
tr_torrent_metainfo&& tr_ctorStealMetainfo(tr_ctor* ctor);
bool tr_ctorSetMetainfoFromFile(tr_ctor* ctor, std::string const& filename, tr_error** error);

146
libtransmission/transmission.h
View File

@ -20,11 +20,6 @@
****
***/
#include <memory>
#include <string>
#include <string_view>
#include <vector>
#include <stdbool.h> /* bool */
#include <stddef.h> /* size_t */
#include <stdint.h> /* uintN_t */
@ -58,7 +53,6 @@ class tr_announce_list;
struct tr_ctor;
struct tr_error;
struct tr_info;
struct tr_session;
struct tr_torrent;
struct tr_torrent_metainfo;
@ -925,7 +919,7 @@ enum tr_parse_result
* @param setme_duplicate_of If the torrent couldn't be created because it's a duplicate,
* this is set to point to the original torrent.
*/
tr_torrent* tr_torrentNew(tr_ctor const* ctor, tr_torrent** setme_duplicate_of);
tr_torrent* tr_torrentNew(tr_ctor* ctor, tr_torrent** setme_duplicate_of);
/** @} */
@ -1173,8 +1167,6 @@ char const* tr_torrentGetDownloadDir(tr_torrent const* torrent);
*/
char const* tr_torrentGetCurrentDir(tr_torrent const* tor);
char* tr_torrentInfoGetMagnetLink(tr_info const* inf);
/**
* Returns a newly-allocated string with a magnet link of the torrent.
* Use tr_free() to free the string when done.
@ -1498,140 +1490,6 @@ using tr_verify_done_func = void (*)(tr_torrent* torrent, bool aborted, void* us
*/
void tr_torrentVerify(tr_torrent* torrent, tr_verify_done_func callback_func_or_nullptr, void* callback_data_or_nullptr);
/***********************************************************************
* tr_info
**********************************************************************/
/** @brief a part of tr_info that represents a single file of the torrent's content */
struct tr_file
{
// public
std::string subpath_; /* Path to the file */
uint64_t size_; /* Length of the file, in bytes */
};
/** @brief information about a torrent that comes from its metainfo file */
struct tr_info
{
auto totalSize() const
{
return total_size_;
}
auto pieceSize() const
{
return piece_size_;
}
auto pieceCount() const
{
return piece_count_;
}
auto dateCreated() const
{
return date_created_;
}
auto const& infoHash() const
{
return hash_;
}
auto const& infoHashString() const
{
return info_hash_string_;
}
auto const& name() const
{
return name_;
}
void setName(std::string_view name)
{
name_ = name;
}
auto const& creator() const
{
return creator_;
}
auto const& comment() const
{
return comment_;
}
auto const& source() const
{
return source_;
}
auto const& torrentFile() const
{
return torrent_file_;
}
tr_file_index_t fileCount() const
{
return std::size(files);
}
auto fileSize(tr_file_index_t i) const
{
return files[i].size_;
}
std::string const& fileSubpath(tr_file_index_t i) const
{
return files[i].subpath_;
}
void setFileSubpath(tr_file_index_t i, std::string_view subpath)
{
files[i].subpath_ = subpath;
}
auto webseedCount() const
{
return std::size(webseeds_);
}
auto const& webseed(size_t i) const
{
return webseeds_[i];
}
auto isPrivate() const
{
return is_private_;
}
void setAnnounceList(tr_announce_list const& list);
tr_announce_list const& announceList() const
{
return *announce_list;
}
tr_sha1_digest_t hash_;
std::shared_ptr<tr_announce_list> announce_list;
std::vector<tr_file> files;
std::vector<std::string> webseeds_;
std::string comment_;
std::string creator_;
std::string info_hash_string_;
std::string name_;
std::string source_;
std::string torrent_file_;
uint64_t total_size_ = 0;
tr_piece_index_t piece_count_ = 0;
time_t date_created_ = 0;
uint32_t piece_size_ = 0;
bool is_private_ = false;
};
bool tr_torrentHasMetadata(tr_torrent const* tor);
/**
@ -1820,7 +1678,7 @@ struct tr_stat
time_t activityDate;
/** The last time during this session that a rarely-changing field
changed -- e.g. any tr_info field (trackers, filenames, name)
changed -- e.g. any tr_torrent_metainfo field (trackers, filenames, name)
or download directory. RPC clients can monitor this to know when
to reload fields that rarely change. */
time_t editDate;

43
libtransmission/utils.cc
View File

@ -14,7 +14,7 @@
#include <algorithm> // std::sort
#include <array> // std::array
#include <cctype> /* isdigit(), tolower() */
#include <cctype> /* isdigit() */
#include <cerrno>
#include <cfloat> /* DBL_DIG */
#include <clocale> /* localeconv() */
@ -312,10 +312,9 @@ uint8_t* tr_loadFile(char const* path, size_t* size, tr_error** error)
return buf;
}
bool tr_loadFile(std::vector<char>& setme, std::string_view path_sv, tr_error** error)
bool tr_loadFile(std::vector<char>& setme, std::string const& path, tr_error** error)
{
char const* const err_fmt = _("Couldn't read \"%1$s\": %2$s");
auto const path = std::string{ path_sv };
auto const* const path_sz = path.c_str();
/* try to stat the file */
@ -357,16 +356,16 @@ bool tr_loadFile(std::vector<char>& setme, std::string_view path_sv, tr_error**
return true;
}
bool tr_saveFile(std::string_view filename_in, std::string_view contents, tr_error** error)
bool tr_saveFile(std::string const& filename, std::string_view contents, tr_error** error)
{
auto filename = std::string{ filename_in };
// follow symlinks to find the "real" file, to make sure the temporary
// we build with tr_sys_file_open_temp() is created on the right partition
if (char* real_filename = tr_sys_path_resolve(filename.c_str(), nullptr); real_filename != nullptr)
{
filename = real_filename;
tr_free(real_filename);
if (auto const rfsv = std::string_view{ real_filename }; rfsv != filename)
{
return tr_saveFile(real_filename, contents, error);
}
}
// Write it to a temp file first.
@ -820,17 +819,20 @@ static char* to_utf8(std::string_view sv)
return strip_non_utf8(sv);
}
std::string tr_strvUtf8Clean(std::string_view sv)
std::string& tr_strvUtf8Clean(std::string_view cleanme, std::string& setme)
{
if (tr_utf8_validate(sv, nullptr))
if (tr_utf8_validate(cleanme, nullptr))
{
return std::string{ sv };
setme = cleanme;
}
else
{
auto* const tmp = to_utf8(cleanme);
setme.assign(tmp ? tmp : "");
tr_free(tmp);
}
auto* const tmp = to_utf8(sv);
auto ret = std::string{ tmp ? tmp : "" };
tr_free(tmp);
return ret;
return setme;
}
#ifdef _WIN32
@ -1579,16 +1581,7 @@ std::string_view tr_get_mime_type_for_filename(std::string_view filename)
if (auto const pos = filename.rfind('.'); pos != std::string_view::npos)
{
// make a lowercase copy of the file suffix
filename.remove_prefix(pos + 1);
auto suffix_lc = std::string{};
std::transform(
std::begin(filename),
std::end(filename),
std::back_inserter(suffix_lc),
[](auto c) { return std::tolower(c); });
// find it
auto const suffix_lc = tr_strlower(filename.substr(pos + 1));
auto const it = std::lower_bound(std::begin(mime_type_suffixes), std::end(mime_type_suffixes), suffix_lc, compare);
if (it != std::end(mime_type_suffixes) && suffix_lc == it->suffix)
{

6
libtransmission/utils.h
View File

@ -78,9 +78,9 @@ bool tr_wildmat(char const* text, char const* pattern) TR_GNUC_NONNULL(1, 2);
*/
uint8_t* tr_loadFile(char const* filename, size_t* size, struct tr_error** error) TR_GNUC_MALLOC TR_GNUC_NONNULL(1);
bool tr_loadFile(std::vector<char>& setme, std::string_view filename, tr_error** error = nullptr);
bool tr_loadFile(std::vector<char>& setme, std::string const& filename, tr_error** error = nullptr);
bool tr_saveFile(std::string_view filename, std::string_view contents, tr_error** error = nullptr);
bool tr_saveFile(std::string const& filename, std::string_view contents, tr_error** error = nullptr);
template<typename... T, typename std::enable_if_t<(std::is_convertible_v<T, std::string_view> && ...), bool> = true>
std::string& tr_buildBuf(std::string& setme, T... args)
@ -382,7 +382,7 @@ std::string_view tr_strvStrip(std::string_view sv);
char* tr_strvDup(std::string_view) TR_GNUC_MALLOC;
std::string tr_strvUtf8Clean(std::string_view sv);
std::string& tr_strvUtf8Clean(std::string_view cleanme, std::string& setme);
/***
****

4
libtransmission/variant.cc
View File

@ -1208,7 +1208,7 @@ std::string tr_variantToStr(tr_variant const* v, tr_variant_fmt fmt)
return evbuffer_free_to_str(tr_variantToBuf(v, fmt));
}
int tr_variantToFile(tr_variant const* v, tr_variant_fmt fmt, std::string_view filename)
int tr_variantToFile(tr_variant const* v, tr_variant_fmt fmt, std::string const& filename)
{
auto error_code = int{ 0 };
auto const contents = tr_variantToStr(v, fmt);
@ -1253,7 +1253,7 @@ bool tr_variantFromBuf(tr_variant* setme, int opts, std::string_view buf, char c
return true;
}
bool tr_variantFromFile(tr_variant* setme, tr_variant_parse_opts opts, std::string_view filename, tr_error** error)
bool tr_variantFromFile(tr_variant* setme, tr_variant_parse_opts opts, std::string const& filename, tr_error** error)
{
// can't do inplace when this function is allocating & freeing the memory...
TR_ASSERT((opts & TR_VARIANT_PARSE_INPLACE) == 0);

4
libtransmission/variant.h
View File

@ -107,7 +107,7 @@ enum tr_variant_fmt
TR_VARIANT_FMT_JSON_LEAN /* saves bandwidth by omitting all whitespace. */
};
int tr_variantToFile(tr_variant const* variant, tr_variant_fmt fmt, std::string_view filename);
int tr_variantToFile(tr_variant const* variant, tr_variant_fmt fmt, std::string const& filename);
std::string tr_variantToStr(tr_variant const* variant, tr_variant_fmt fmt);
@ -123,7 +123,7 @@ enum tr_variant_parse_opts
bool tr_variantFromFile(
tr_variant* setme,
tr_variant_parse_opts opts,
std::string_view filename,
std::string const& filename,
struct tr_error** error = nullptr);
bool tr_variantFromBuf(

1
tests/libtransmission/CMakeLists.txt
View File

@ -16,7 +16,6 @@ add_executable(libtransmission-test
json-test.cc
magnet-metainfo-test.cc
makemeta-test.cc
metainfo-test.cc
move-test.cc
peer-mgr-active-requests-test.cc
peer-mgr-wishlist-test.cc

38
tests/libtransmission/announce-list-test.cc
View File

@ -16,7 +16,7 @@
#include "announce-list.h"
#include "error.h"
#include "metainfo.h"
#include "torrent-metainfo.h"
#include "utils.h"
#include "variant.h"
@ -348,7 +348,7 @@ TEST_F(AnnounceListTest, save)
tr_error* error = nullptr;
EXPECT_TRUE(tr_loadFile(original_content, OriginalFile, &error));
EXPECT_EQ(nullptr, error);
EXPECT_TRUE(tr_saveFile(test_file.c_str(), { std::data(original_content), std::size(original_content) }, &error));
EXPECT_TRUE(tr_saveFile(test_file, { std::data(original_content), std::size(original_content) }, &error));
EXPECT_EQ(nullptr, error);
// make an announce_list for it
@ -364,41 +364,29 @@ TEST_F(AnnounceListTest, save)
tr_error_clear(&error);
// now save to a real .torrent fi le
EXPECT_TRUE(announce_list.save(test_file.c_str(), &error));
EXPECT_TRUE(announce_list.save(test_file, &error));
EXPECT_EQ(nullptr, error);
// load the original
auto metainfo = tr_variant{};
EXPECT_TRUE(tr_variantFromBuf(
&metainfo,
TR_VARIANT_PARSE_BENC | TR_VARIANT_PARSE_INPLACE,
{ std::data(original_content), std::size(original_content) },
nullptr,
nullptr));
auto original = tr_metainfoParse(nullptr, &metainfo, nullptr);
EXPECT_TRUE(original);
tr_variantFree(&metainfo);
auto original_tm = tr_torrent_metainfo{};
EXPECT_TRUE(original_tm.parseBenc({ std::data(original_content), std::size(original_content) }));
// load the scratch that we saved to
metainfo = tr_variant{};
EXPECT_TRUE(tr_variantFromFile(&metainfo, TR_VARIANT_PARSE_BENC, test_file.c_str(), nullptr));
auto saved = tr_metainfoParse(nullptr, &metainfo, nullptr);
EXPECT_TRUE(saved);
tr_variantFree(&metainfo);
auto modified_tm = tr_torrent_metainfo{};
EXPECT_TRUE(modified_tm.parseTorrentFile(test_file));
// test that non-announce parts of the metainfo are the same
EXPECT_EQ(original->info.name(), saved->info.name());
EXPECT_EQ(original->info.fileCount(), saved->info.fileCount());
EXPECT_EQ(original->info.dateCreated(), saved->info.dateCreated());
EXPECT_EQ(original->pieces, saved->pieces);
EXPECT_EQ(original_tm.name(), modified_tm.name());
EXPECT_EQ(original_tm.fileCount(), modified_tm.fileCount());
EXPECT_EQ(original_tm.dateCreated(), modified_tm.dateCreated());
EXPECT_EQ(original_tm.pieceCount(), modified_tm.pieceCount());
// test that the saved version has the updated announce list
EXPECT_EQ(std::size(announce_list), std::size(*saved->info.announce_list));
EXPECT_TRUE(std::equal(
std::begin(announce_list),
std::end(announce_list),
std::begin(*saved->info.announce_list),
std::end(*saved->info.announce_list)));
std::begin(modified_tm.announceList()),
std::end(modified_tm.announceList())));
// cleanup
std::remove(test_file.c_str());

140
tests/libtransmission/metainfo-test.cc
View File

@ -1,140 +0,0 @@
/*
* This file Copyright (C) 2013-2014 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
*
*/
#include "transmission.h"
#include "error.h"
#include "metainfo.h"
#include "torrent.h"
#include "utils.h"
#include "test-fixtures.h"
#include <array>
#include <cerrno>
#include <cstring>
#include <string_view>
#define BEFORE_PATH \
"d10:created by25:Transmission/2.82 (14160)13:creation datei1402280218e8:encoding5:UTF-84:infod5:filesld6:lengthi2e4:pathl"
#define AFTER_PATH \
"eed6:lengthi2e4:pathl5:b.txteee4:name3:foo12:piece lengthi32768e6:pieces20:ÞÉ`âM‘‹Šs¡Å;˺¬.åÂà7:privatei0eee"
using namespace std::literals;
namespace libtransmission
{
namespace test
{
using MetainfoTest = SessionTest;
TEST_F(MetainfoTest, sanitize)
{
struct LocalTest
{
std::string_view input;
std::string_view expected_output;
};
auto const tests = std::array<LocalTest, 29>{
// skipped
LocalTest{ ""sv, ""sv },
{ "."sv, ""sv },
{ ".."sv, ""sv },
{ "....."sv, ""sv },
{ " "sv, ""sv },
{ " . "sv, ""sv },
{ ". . ."sv, ""sv },
// replaced with '_'
{ "/"sv, "_"sv },
{ "////"sv, "____"sv },
{ "\\\\"sv, "__"sv },
{ "/../"sv, "_.._"sv },
{ "foo<bar:baz/boo"sv, "foo_bar_baz_boo"sv },
{ "t\0e\x01s\tt\ri\nn\fg"sv, "t_e_s_t_i_n_g"sv },
// appended with '_'
{ "con"sv, "con_"sv },
{ "cOm4"sv, "cOm4_"sv },
{ "LPt9.txt"sv, "LPt9_.txt"sv },
{ "NUL.tar.gz"sv, "NUL_.tar.gz"sv },
// trimmed
{ " foo"sv, "foo"sv },
{ "foo "sv, "foo"sv },
{ " foo "sv, "foo"sv },
{ "foo."sv, "foo"sv },
{ "foo..."sv, "foo"sv },
{ " foo... "sv, "foo"sv },
// unmodified
{ "foo"sv, "foo"sv },
{ ".foo"sv, ".foo"sv },
{ "..foo"sv, "..foo"sv },
{ "foo.bar.baz"sv, "foo.bar.baz"sv },
{ "null"sv, "null"sv },
{ "compass"sv, "compass"sv },
};
auto out = std::string{};
for (auto const& test : tests)
{
out.clear();
auto const success = tr_metainfoAppendSanitizedPathComponent(out, test.input);
EXPECT_EQ(!std::empty(out), success);
EXPECT_EQ(test.expected_output, out);
}
}
TEST_F(MetainfoTest, AndroidTorrent)
{
auto const filename = tr_strvJoin(LIBTRANSMISSION_TEST_ASSETS_DIR, "/Android-x86 8.1 r6 iso.torrent"sv);
auto* ctor = tr_ctorNew(session_);
EXPECT_TRUE(tr_ctorSetMetainfoFromFile(ctor, filename.c_str(), nullptr));
tr_ctorFree(ctor);
}
TEST_F(MetainfoTest, ctorSaveContents)
{
auto const src_filename = tr_strvJoin(LIBTRANSMISSION_TEST_ASSETS_DIR, "/Android-x86 8.1 r6 iso.torrent"sv);
auto const tgt_filename = tr_strvJoin(::testing::TempDir(), "save-contents-test.torrent");
// try saving without passing any metainfo.
auto* ctor = tr_ctorNew(session_);
tr_error* error = nullptr;
EXPECT_FALSE(tr_ctorSaveContents(ctor, tgt_filename.c_str(), &error));
EXPECT_NE(nullptr, error);
if (error != nullptr)
{
EXPECT_EQ(EINVAL, error->code);
tr_error_clear(&error);
}
// now try saving _with_ metainfo
EXPECT_TRUE(tr_ctorSetMetainfoFromFile(ctor, src_filename.c_str(), &error));
EXPECT_EQ(nullptr, error);
EXPECT_TRUE(tr_ctorSaveContents(ctor, tgt_filename.c_str(), &error));
EXPECT_EQ(nullptr, error);
// the saved contents should match the source file's contents
auto src_contents = std::vector<char>{};
EXPECT_TRUE(tr_loadFile(src_contents, src_filename.c_str(), &error));
auto tgt_contents = std::vector<char>{};
EXPECT_TRUE(tr_loadFile(tgt_contents, tgt_filename.c_str(), &error));
EXPECT_EQ(src_contents, tgt_contents);
// cleanup
EXPECT_TRUE(tr_sys_path_remove(tgt_filename.c_str(), &error));
EXPECT_EQ(nullptr, error);
tr_error_clear(&error);
tr_ctorFree(ctor);
}
} // namespace test
} // namespace libtransmission

11
tests/libtransmission/torrent-metainfo-test.cc
View File

@ -14,7 +14,6 @@
#include "transmission.h"
#include "error.h"
#include "metainfo.h"
#include "torrent-metainfo.h"
#include "torrent.h"
#include "utils.h"
@ -88,6 +87,7 @@ TEST_F(TorrentMetainfoTest, bucket)
}
}
#if 0
TEST_F(TorrentMetainfoTest, sanitize)
{
struct LocalTest
@ -142,6 +142,7 @@ TEST_F(TorrentMetainfoTest, sanitize)
EXPECT_EQ(test.expected_output, out);
}
}
#endif
TEST_F(TorrentMetainfoTest, AndroidTorrent)
{
@ -162,7 +163,7 @@ TEST_F(TorrentMetainfoTest, ctorSaveContents)
// try saving without passing any metainfo.
auto* ctor = tr_ctorNew(session_);
tr_error* error = nullptr;
EXPECT_FALSE(tr_ctorSaveContents(ctor, tgt_filename.c_str(), &error));
EXPECT_FALSE(tr_ctorSaveContents(ctor, tgt_filename, &error));
EXPECT_NE(nullptr, error);
if (error != nullptr)
{
@ -173,14 +174,14 @@ TEST_F(TorrentMetainfoTest, ctorSaveContents)
// now try saving _with_ metainfo
EXPECT_TRUE(tr_ctorSetMetainfoFromFile(ctor, src_filename.c_str(), &error));
EXPECT_EQ(nullptr, error);
EXPECT_TRUE(tr_ctorSaveContents(ctor, tgt_filename.c_str(), &error));
EXPECT_TRUE(tr_ctorSaveContents(ctor, tgt_filename, &error));
EXPECT_EQ(nullptr, error);
// the saved contents should match the source file's contents
auto src_contents = std::vector<char>{};
EXPECT_TRUE(tr_loadFile(src_contents, src_filename.c_str(), &error));
EXPECT_TRUE(tr_loadFile(src_contents, src_filename, &error));
auto tgt_contents = std::vector<char>{};
EXPECT_TRUE(tr_loadFile(tgt_contents, tgt_filename.c_str(), &error));
EXPECT_TRUE(tr_loadFile(tgt_contents, tgt_filename, &error));
EXPECT_EQ(src_contents, tgt_contents);
// cleanup

19
tests/libtransmission/utils-test.cc
View File

@ -161,22 +161,23 @@ TEST_F(UtilsTest, trStrvPath)
TEST_F(UtilsTest, trStrvUtf8Clean)
{
auto in = "hello world"sv;
auto out = tr_strvUtf8Clean(in);
auto out = std::string{};
tr_strvUtf8Clean(in, out);
EXPECT_EQ(in, out);
in = "hello world"sv;
out = tr_strvUtf8Clean(in.substr(0, 5));
tr_strvUtf8Clean(in.substr(0, 5), out);
EXPECT_EQ("hello"sv, out);
// this version is not utf-8 (but cp866)
in = "\x92\xE0\xE3\xA4\xAD\xAE \xA1\xEB\xE2\xEC \x81\xAE\xA3\xAE\xAC"sv;
out = tr_strvUtf8Clean(in);
tr_strvUtf8Clean(in, out);
EXPECT_TRUE(std::size(out) == 17 || std::size(out) == 33);
EXPECT_TRUE(tr_utf8_validate(out, nullptr));
// same string, but utf-8 clean
in = "Трудно быть Богом"sv;
out = tr_strvUtf8Clean(in);
tr_strvUtf8Clean(in, out);
EXPECT_NE(nullptr, out.data());
EXPECT_TRUE(tr_utf8_validate(out, nullptr));
EXPECT_EQ(in, out);
@ -187,13 +188,13 @@ TEST_F(UtilsTest, trStrvUtf8Clean)
// to wait until https://github.com/transmission/transmission/issues/612
// is resolved before revisiting this.
in = "\xF4\x00\x81\x82"sv;
out = tr_strvUtf8Clean(in);
tr_strvUtf8Clean(in, out);
EXPECT_NE(nullptr, out.data());
EXPECT_TRUE(out.size() == 1 || out.size() == 2);
EXPECT_TRUE(tr_utf8_validate(out, nullptr));
in = "\xF4\x33\x81\x82"sv;
out = tr_strvUtf8Clean(in);
tr_strvUtf8Clean(in, out);
EXPECT_NE(nullptr, out.data());
EXPECT_TRUE(out.size() == 4 || out.size() == 7);
EXPECT_TRUE(tr_utf8_validate(out, nullptr));
@ -423,12 +424,12 @@ TEST_F(UtilsTest, saveFile)
auto filename = tr_strvJoin(::testing::TempDir(), "filename.txt");
auto contents = "these are the contents"sv;
tr_error* error = nullptr;
EXPECT_TRUE(tr_saveFile(filename.c_str(), contents, &error));
EXPECT_TRUE(tr_saveFile(filename, contents, &error));
EXPECT_EQ(nullptr, error);
// now read the file back in and confirm the contents are the same
auto buf = std::vector<char>{};
EXPECT_TRUE(tr_loadFile(buf, filename.c_str(), &error));
EXPECT_TRUE(tr_loadFile(buf, filename, &error));
EXPECT_EQ(nullptr, error);
auto sv = std::string_view{ std::data(buf), std::size(buf) };
EXPECT_EQ(contents, sv);
@ -439,7 +440,7 @@ TEST_F(UtilsTest, saveFile)
// try saving a file to a path that doesn't exist
filename = "/this/path/does/not/exist/foo.txt";
EXPECT_FALSE(tr_saveFile(filename.c_str(), contents, &error));
EXPECT_FALSE(tr_saveFile(filename, contents, &error));
ASSERT_NE(nullptr, error);
EXPECT_NE(0, error->code);
tr_error_clear(&error);