/*

Copyright (c) 2003-2022, Arvid Norberg

Copyright (c) 2016-2018, Alden Torres

Copyright (c) 2016, 2019, Andrei Kurushin

Copyright (c) 2016-2017, Pavel Pimenov

Copyright (c) 2016-2019, Steven Siloti

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions

are met:

    * Redistributions of source code must retain the above copyright

      notice, this list of conditions and the following disclaimer.

    * Redistributions in binary form must reproduce the above copyright

      notice, this list of conditions and the following disclaimer in

      the documentation and/or other materials provided with the distribution.

    * Neither the name of the author nor the names of its

      contributors may be used to endorse or promote products derived

      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

*/

#include "libtorrent/config.hpp"

#include "libtorrent/torrent_info.hpp"

#include "libtorrent/string_util.hpp" // is_space, is_i2p_url

#include "libtorrent/bencode.hpp"

#include "libtorrent/hasher.hpp"

#include "libtorrent/entry.hpp"

#include "libtorrent/aux_/path.hpp"

#include "libtorrent/aux_/open_mode.hpp"

#include "libtorrent/utf8.hpp"

#include "libtorrent/time.hpp"

#include "libtorrent/random.hpp"

#include "libtorrent/aux_/invariant_check.hpp"

#include "libtorrent/aux_/escape_string.hpp" // maybe_url_encode

#include "libtorrent/aux_/merkle.hpp" // for merkle_*

#include "libtorrent/aux_/throw.hpp"

#include "libtorrent/add_torrent_params.hpp"

#include "libtorrent/magnet_uri.hpp"

#include "libtorrent/announce_entry.hpp"

#include "libtorrent/hex.hpp" // to_hex

#include "libtorrent/aux_/numeric_cast.hpp"

#include "libtorrent/aux_/file_pointer.hpp"

#include "libtorrent/disk_interface.hpp" // for default_block_size

#include "libtorrent/span.hpp"

#include "libtorrent/aux_/disable_warnings_push.hpp"

#include <boost/crc.hpp>

#include "libtorrent/aux_/disable_warnings_pop.hpp"

#include <unordered_map>

#include <unordered_set>

#include <cstdint>

#include <cstdio>

#include <cinttypes>

#include <iterator>

#include <algorithm>

#include <set>

#include <ctime>

#include <array>

namespace libtorrent {

  TORRENT_EXPORT from_span_t from_span;

  constexpr torrent_info_flags_t torrent_info::multifile;

  constexpr torrent_info_flags_t torrent_info::private_torrent;

  constexpr torrent_info_flags_t torrent_info::i2p;

  constexpr torrent_info_flags_t torrent_info::ssl_torrent;

  constexpr torrent_info_flags_t torrent_info::v2_has_piece_hashes;

  namespace {

  // Which characters are valid is primarily determined by the

  // filesystem, so this logic is an approximation. Note that forward- and

  // backslash are filtered unconditionally and separately from this function.

  bool valid_path_character(std::int32_t const c)

  {

#ifdef TORRENT_WINDOWS

    // On windows, both the filesystem and the operating system impose

    // restrictions.

    static const char invalid_chars[] = "?<>\"|\b*:";

#elif defined TORRENT_ANDROID

    // The Android kernel probably has similar restrictions as Linux (i.e.

    // very few) but it appears some user-space system libraries impose

    // additional restrictions, and it's probably more common to use FAT32

    // style filesystems, which also further restricts valid characters

    // https://cs.android.com/android/platform/superproject/+/master:frameworks/base/core/java/android/os/FileUtils.java;l=997?q=isValidFatFilenameChar

    static const char invalid_chars[] = "\"*:<>?|";

#else

    static const char invalid_chars[] = "";

#endif

    if (c < 32) return false;

    if (c > 127) return true;

    return std::strchr(invalid_chars, static_cast<char>(c)) == nullptr;

  }

  bool filter_path_character(std::int32_t const c)

  {

    // these unicode characters change the writing direction of the

    // string and can be used for attacks:

    // https://security.stackexchange.com/questions/158802/how-can-this-executable-have-an-avi-extension

    static const std::array<std::int32_t, 7> bad_cp = {{0x202a, 0x202b, 0x202c, 0x202d, 0x202e, 0x200e, 0x200f}};

    if (std::find(bad_cp.begin(), bad_cp.end(), c) != bad_cp.end()) return true;

    static const char invalid_chars[] = "/\\";

    if (c > 127) return false;

    return std::strchr(invalid_chars, static_cast<char>(c)) != nullptr;

  }

  } // anonymous namespace

namespace aux {

  // fixes invalid UTF-8 sequences

  bool verify_encoding(std::string& target)

  {

    if (target.empty()) return true;

    std::string tmp_path;

    tmp_path.reserve(target.size()+5);

    bool valid_encoding = true;

    string_view ptr = target;

    while (!ptr.empty())

    {

      std::int32_t codepoint;

      int len;

      // decode a single utf-8 character

      std::tie(codepoint, len) = parse_utf8_codepoint(ptr);

      // this was the last character, and nothing was

      // written to the destination buffer (i.e. the source character was

      // truncated)

      if (codepoint == -1)

      {

        codepoint = '_';

        valid_encoding = false;

      }

      ptr = ptr.substr(std::min(std::size_t(len), ptr.size()));

      // encode codepoint into utf-8

      append_utf8_codepoint(tmp_path, codepoint);

    }

    // the encoding was not valid utf-8

    // save the original encoding and replace the

    // commonly used path with the correctly

    // encoded string

    if (!valid_encoding) target = tmp_path;

    return valid_encoding;

  }

  // it's important that every call adds a path element to the path, even if

  // the name is invalid. It can never be empty. Empty files have special

  // meaning in v2 torrents (it means the previous path element was the

  // filename). Also, If we're adding the torrent name as the first path

  // element, in a multi-file torrent, we must have a directory name.

  void sanitize_append_path_element(std::string& path, string_view element, bool const force_element)

  {

    if (element.size() == 1 && element[0] == '.' && !force_element) return;

#ifdef TORRENT_WINDOWS

#define TORRENT_SEPARATOR '\\'

#else

#define TORRENT_SEPARATOR '/'

#endif

    path.reserve(path.size() + element.size() + 2);

    int added_separator = 0;

    if (!path.empty())

    {

      path += TORRENT_SEPARATOR;

      added_separator = 1;

    }

    if (element.empty())

    {

      path += "_";

      return;

    }

#if !TORRENT_USE_UNC_PATHS && defined TORRENT_WINDOWS

#pragma message ("building for windows without UNC paths is deprecated")

    // if we're not using UNC paths on windows, there

    // are certain filenames we're not allowed to use

    static const char const* reserved_names[] =

    {

      "con", "prn", "aux", "clock$", "nul",

      "com0", "com1", "com2", "com3", "com4",

      "com5", "com6", "com7", "com8", "com9",

      "lpt0", "lpt1", "lpt2", "lpt3", "lpt4",

      "lpt5", "lpt6", "lpt7", "lpt8", "lpt9"

    };

    int num_names = sizeof(reserved_names)/sizeof(reserved_names[0]);

    // this is not very efficient, but it only affects some specific

    // windows builds for now anyway (not even the default windows build)

    std::string pe = element.to_string();

    char const* file_end = strrchr(pe.c_str(), '.');

    std::string name = file_end

      ? std::string(pe.data(), file_end)

      : pe;

    std::transform(name.begin(), name.end(), name.begin(), &to_lower);

    char const** str = std::find(reserved_names, reserved_names + num_names, name);

    if (str != reserved_names + num_names)

    {

      pe = "_" + pe;

      element = string_view();

    }

#endif

#ifdef TORRENT_WINDOWS

    // this counts the number of unicode characters

    // we've added (which is different from the number

    // of bytes)

    int unicode_chars = 0;

#endif

    int added = 0;

    // the number of dots we've added

    char num_dots = 0;

    bool found_extension = false;

    int seq_len = 0;

    for (std::size_t i = 0; i < element.size(); i += std::size_t(seq_len))

    {

      std::int32_t code_point;

      std::tie(code_point, seq_len) = parse_utf8_codepoint(element.substr(i));

      if (code_point >= 0 && filter_path_character(code_point))

      {

        continue;

      }

      if (code_point < 0 || !valid_path_character(code_point))

      {

        // invalid utf8 sequence, replace with "_"

        path += '_';

        ++added;

#ifdef TORRENT_WINDOWS

        ++unicode_chars;

#endif

        continue;

      }

      // validation passed, add it to the output string

      for (std::size_t k = i; k < i + std::size_t(seq_len); ++k)

      {

        TORRENT_ASSERT(element[k] != 0);

        path.push_back(element[k]);

      }

      if (code_point == '.') ++num_dots;

      added += seq_len;

#ifdef TORRENT_WINDOWS

      ++unicode_chars;

#endif

      // any given path element should not

      // be more than 255 characters

      // if we exceed 240, pick up any potential

      // file extension and add that too

#ifdef TORRENT_WINDOWS

      if (unicode_chars >= 240 && !found_extension)

#else

      if (added >= 240 && !found_extension)

#endif

      {

        int dot = -1;

        for (int j = int(element.size()) - 1;

          j > std::max(int(element.size()) - 10, int(i)); --j)

        {

          if (element[aux::numeric_cast<std::size_t>(j)] != '.') continue;

          dot = j;

          break;

        }

        // there is no extension

        if (dot == -1) break;

        found_extension = true;

        TORRENT_ASSERT(dot > 0);

        i = std::size_t(dot - seq_len);

      }

    }

    if (added == num_dots && added <= 2)

    {

      if (force_element)

      {

        // revert the invalid filename and replace it with an underscore

        path.erase(path.end() - added, path.end());

        path += "_";

      }

      else

      {

        // revert everything

        path.erase(path.end() - added - added_separator, path.end());

      }

      return;

    }

#ifdef TORRENT_WINDOWS

    // remove trailing spaces and dots. These aren't allowed in filenames on windows

    for (int i = int(path.size()) - 1; i >= 0; --i)

    {

      if (path[i] != ' ' && path[i] != '.') break;

      path.resize(i);

      --added;

      TORRENT_ASSERT(added >= 0);

    }

    if (force_element && added == 0)

    {

      path += "_";

    }

    else if (added == 0 && added_separator)

    {

      // remove the separator added at the beginning

      path.erase(path.end() - 1);

      return;

    }

#endif

    if (path.empty()) path = "_";

  }

}

namespace {

  file_flags_t get_file_attributes(bdecode_node const& dict)

  {

    file_flags_t file_flags = {};

    bdecode_node const attr = dict.dict_find_string("attr");

    if (attr)

    {

      for (char const c : attr.string_value())

      {

        switch (c)

        {

          case 'l': file_flags |= file_storage::flag_symlink; break;

          case 'x': file_flags |= file_storage::flag_executable; break;

          case 'h': file_flags |= file_storage::flag_hidden; break;

          case 'p': file_flags |= file_storage::flag_pad_file; break;

        }

      }

    }

    return file_flags;

  }

  // iterates an array of strings and returns the sum of the lengths of all

  // strings + one additional character per entry (to account for the presumed

  // forward- or backslash to separate directory entries)

  int path_length(bdecode_node const& p, error_code& ec)

  {

    int ret = 0;

    int const len = p.list_size();

    for (int i = 0; i < len; ++i)

    {

      bdecode_node const e = p.list_at(i);

      if (e.type() != bdecode_node::string_t)

      {

        ec = errors::torrent_invalid_name;

        return -1;

      }

      ret += e.string_length();

    }

    return ret + len;

  }

  bool extract_single_file2(bdecode_node const& dict, file_storage& files

    , std::string const& path, string_view const name

    , std::ptrdiff_t const info_offset, char const* info_buffer

    , error_code& ec)

  {

    if (dict.type() != bdecode_node::dict_t) return false;

    file_flags_t file_flags = get_file_attributes(dict);

    if (file_flags & file_storage::flag_pad_file)

    {

      ec = errors::torrent_invalid_pad_file;

      return false;

    }

    // symlinks have an implied "size" of zero. i.e. they use up 0 bytes of

    // the torrent payload space

    std::int64_t const file_size = (file_flags & file_storage::flag_symlink)

      ? 0 : dict.dict_find_int_value("length", -1);

    // if a file is too big, it will cause integer overflow in our

    // calculations of the size of the merkle tree (which is all 'int'

    // indices)

    if (file_size < 0

      || (file_size / default_block_size) >= file_storage::max_num_pieces

      || file_size > file_storage::max_file_size)

    {

      ec = errors::torrent_invalid_length;

      return false;

    }

    std::time_t const mtime = std::time_t(dict.dict_find_int_value("mtime", 0));

    char const* pieces_root = nullptr;

    std::string symlink_path;

    if (file_flags & file_storage::flag_symlink)

    {

      if (bdecode_node const s_p = dict.dict_find_list("symlink path"))

      {

        auto const preallocate = static_cast<std::size_t>(path_length(s_p, ec));

        if (ec) return false;

        symlink_path.reserve(preallocate);

        for (int i = 0, end(s_p.list_size()); i < end; ++i)

        {

          auto pe = s_p.list_at(i).string_value();

          aux::sanitize_append_path_element(symlink_path, pe);

        }

      }

    }

    if (symlink_path.empty() && file_size > 0)

    {

      bdecode_node const root = dict.dict_find_string("pieces root");

      if (!root || root.type() != bdecode_node::string_t

        || root.string_length() != sha256_hash::size())

      {

        ec = errors::torrent_missing_pieces_root;

        return false;

      }

      pieces_root = info_buffer + (root.string_offset() - info_offset);

      if (sha256_hash(pieces_root).is_all_zeros())

      {

        ec = errors::torrent_missing_pieces_root;

        return false;

      }

    }

    files.add_file_borrow(ec, name, path, file_size, file_flags, nullptr

      , mtime, symlink_path, pieces_root);

    return !ec;

  }

  // 'top_level' is extracting the file for a single-file torrent. The

  // distinction is that the filename is found in "name" rather than

  // "path"

  // root_dir is the name of the torrent, unless this is a single file

  // torrent, in which case it's empty.

  bool extract_single_file(bdecode_node const& dict, file_storage& files

    , std::string const& root_dir, std::ptrdiff_t const info_offset

    , char const* info_buffer, bool const top_level, error_code& ec)

  {

    if (dict.type() != bdecode_node::dict_t) return false;

    file_flags_t file_flags = get_file_attributes(dict);

    // symlinks have an implied "size" of zero. i.e. they use up 0 bytes of

    // the torrent payload space

    std::int64_t const file_size = (file_flags & file_storage::flag_symlink)

      ? 0 : dict.dict_find_int_value("length", -1);

    // if a file is too big, it will cause integer overflow in our

    // calculations of the size of the merkle tree (which is all 'int'

    // indices)

    if (file_size < 0

      || (file_size / default_block_size) >= std::numeric_limits<int>::max() / 2

      || file_size > file_storage::max_file_size)

    {

      ec = errors::torrent_invalid_length;

      return false;

    }

    std::time_t const mtime = std::time_t(dict.dict_find_int_value("mtime", 0));

    std::string path = root_dir;

    string_view filename;

    if (top_level)

    {

      // prefer the name.utf-8 because if it exists, it is more likely to be

      // correctly encoded

      bdecode_node p = dict.dict_find_string("name.utf-8");

      if (!p) p = dict.dict_find_string("name");

      if (!p || p.string_length() == 0)

      {

        ec = errors::torrent_missing_name;

        return false;

      }

      filename = { info_buffer + (p.string_offset() - info_offset)

        , static_cast<std::size_t>(p.string_length())};

      while (!filename.empty() && filename.front() == TORRENT_SEPARATOR)

        filename.remove_prefix(1);

      aux::sanitize_append_path_element(path, p.string_value());

      if (path.empty())

      {

        ec = errors::torrent_missing_name;

        return false;

      }

    }

    else

    {

      bdecode_node p = dict.dict_find_list("path.utf-8");

      if (!p) p = dict.dict_find_list("path");

      if (p && p.list_size() > 0)

      {

        std::size_t const preallocate = path.size() + std::size_t(path_length(p, ec));

        if (ec) return false;

        path.reserve(preallocate);

        for (int i = 0, end(p.list_size()); i < end; ++i)

        {

          bdecode_node const e = p.list_at(i);

          if (i == end - 1)

          {

            filename = {info_buffer + (e.string_offset() - info_offset)

              , static_cast<std::size_t>(e.string_length()) };

            while (!filename.empty() && filename.front() == TORRENT_SEPARATOR)

              filename.remove_prefix(1);

          }

          aux::sanitize_append_path_element(path, e.string_value(), true);

        }

      }

      else if (file_flags & file_storage::flag_pad_file)

      {

        // pad files don't need a path element, we'll just store them

        // under the .pad directory

        char cnt[20];

        std::snprintf(cnt, sizeof(cnt), "%" PRIu64, file_size);

        path = combine_path(".pad", cnt);

      }

      else

      {

        ec = errors::torrent_missing_name;

        return false;

      }

    }

    // bitcomet pad file

    if (path.find("_____padding_file_") != std::string::npos)

      file_flags |= file_storage::flag_pad_file;

    bdecode_node const fh = dict.dict_find_string("sha1");

    char const* filehash = nullptr;

    if (fh && fh.string_length() == 20)

      filehash = info_buffer + (fh.string_offset() - info_offset);

    std::string symlink_path;

    if (file_flags & file_storage::flag_symlink)

    {

      if (bdecode_node const s_p = dict.dict_find_list("symlink path"))

      {

        auto const preallocate = static_cast<std::size_t>(path_length(s_p, ec));

        if (ec) return false;

        symlink_path.reserve(preallocate);

        for (int i = 0, end(s_p.list_size()); i < end; ++i)

        {

          auto pe = s_p.list_at(i).string_value();

          aux::sanitize_append_path_element(symlink_path, pe);

        }

      }

      else

      {

        // technically this is an invalid torrent. "symlink path" must exist

        file_flags &= ~file_storage::flag_symlink;

      }

      // symlink targets are validated later, as it may point to a file or

      // directory we haven't parsed yet

    }

    if (filename.size() > path.length()

      || path.substr(path.size() - filename.size()) != filename)

    {

      // if the filename was sanitized and differ, clear it to just use path

      filename = {};

    }

    files.add_file_borrow(ec, filename, path, file_size, file_flags, filehash

      , mtime, symlink_path);

    return !ec;

  }

  bool extract_files2(bdecode_node const& tree, file_storage& target

    , std::string const& root_dir, ptrdiff_t const info_offset

    , char const* info_buffer

    , bool const has_files, int const depth, error_code& ec)

  {

    if (tree.type() != bdecode_node::dict_t)

    {

      ec = errors::torrent_file_parse_failed;

      return false;

    }

    // since we're parsing this recursively, we have to be careful not to blow

    // up the stack. 100 levels of sub directories should be enough. This

    // could be improved by an iterative parser, keeping the state on a more

    // compact side-stack

    if (depth > 100)

    {

      ec = errors::torrent_file_parse_failed;

      return false;

    }

    for (int i = 0; i < tree.dict_size(); ++i)

    {

      auto e = tree.dict_at_node(i);

      if (e.second.type() != bdecode_node::dict_t || e.first.string_value().empty())

      {

        ec = errors::torrent_file_parse_failed;

        return false;

      }

      string_view filename = { info_buffer + (e.first.string_offset() - info_offset)

        , static_cast<size_t>(e.first.string_length()) };

      while (!filename.empty() && filename.front() == TORRENT_SEPARATOR)

        filename.remove_prefix(1);

      bool const leaf_node = e.second.dict_size() == 1 && e.second.dict_at(0).first.empty();

      bool const single_file = leaf_node && !has_files && tree.dict_size() == 1;

      std::string path = single_file ? std::string() : root_dir;

      aux::sanitize_append_path_element(path, filename, true);

      if (leaf_node)

      {

        if (filename.size() > path.length()

          || path.substr(path.size() - filename.size()) != filename)

        {

          // if the filename was sanitized and differ, clear it to just use path

          filename = {};

        }

        if (!extract_single_file2(e.second.dict_at(0).second, target

          , path, filename, info_offset, info_buffer, ec))

        {

          return false;

        }

        continue;

      }

      if (!extract_files2(e.second, target, path, info_offset, info_buffer

        , true, depth + 1, ec))

      {

        return false;

      }

    }

    return true;

  }

  // root_dir is the name of the torrent, unless this is a single file

  // torrent, in which case it's empty.

  bool extract_files(bdecode_node const& list, file_storage& target

    , std::string const& root_dir, std::ptrdiff_t info_offset

    , char const* info_buffer, error_code& ec)

  {

    if (list.type() != bdecode_node::list_t)

    {

      ec = errors::torrent_file_parse_failed;

      return false;

    }

    target.reserve(list.list_size());

    for (int i = 0, end(list.list_size()); i < end; ++i)

    {

      if (!extract_single_file(list.list_at(i), target, root_dir

        , info_offset, info_buffer, false, ec))

        return false;

    }

    // this rewrites invalid symlinks to point to themselves

    target.sanitize_symlinks();

    return true;

  }

  int load_file(std::string const& filename, std::vector<char>& v

    , error_code& ec, int const max_buffer_size = 80000000)

  {

    ec.clear();

#ifdef TORRENT_WINDOWS

    aux::file_pointer f(::_wfopen(convert_to_native_path_string(filename).c_str(), L"rb"));

#else

    aux::file_pointer f(std::fopen(filename.c_str(), "rb"));

#endif

    if (f.file() == nullptr)

    {

      ec.assign(errno, generic_category());

      return -1;

    }

    if (std::fseek(f.file(), 0, SEEK_END) < 0)

    {

      ec.assign(errno, generic_category());

      return -1;

    }

    std::int64_t const s = std::ftell(f.file());

    if (s < 0)

    {

      ec.assign(errno, generic_category());

      return -1;

    }

    if (s > max_buffer_size)

    {

      ec = errors::metadata_too_large;

      return -1;

    }

    if (std::fseek(f.file(), 0, SEEK_SET) < 0)

    {

      ec.assign(errno, generic_category());

      return -1;

    }

    v.resize(std::size_t(s));

    if (s == 0) return 0;

    std::size_t const read = std::fread(v.data(), 1, v.size(), f.file());

    if (read != std::size_t(s))

    {

      if (std::feof(f.file()))

      {

        v.resize(read);

        return 0;

      }

      ec.assign(errno, generic_category());

      return -1;

    }

    return 0;

  }

} // anonymous namespace

  web_seed_entry::web_seed_entry(std::string url_, type_t type_

    , std::string auth_

    , headers_t extra_headers_)

    : url(std::move(url_))

    , auth(std::move(auth_))

    , extra_headers(std::move(extra_headers_))

    , type(std::uint8_t(type_))

  {

  }

TORRENT_VERSION_NAMESPACE_3

  torrent_info::torrent_info(torrent_info const&) = default;

  torrent_info& torrent_info::operator=(torrent_info&&) = default;

  void torrent_info::resolve_duplicate_filenames()

  {

    INVARIANT_CHECK;

    std::unordered_set<std::uint32_t> files;

    std::string const empty_str;

    // insert all directories first, to make sure no files

    // are allowed to collied with them

    m_files.all_path_hashes(files);

    for (auto const i : m_files.file_range())

    {

      // as long as this file already exists

      // increase the counter

      std::uint32_t const h = m_files.file_path_hash(i, empty_str);

      if (!files.insert(h).second)

      {

        // This filename appears to already exist!

        // If this happens, just start over and do it the slow way,

        // comparing full file names and come up with new names

        resolve_duplicate_filenames_slow();

        return;

      }

    }

  }

namespace {

  template <class CRC>

  void process_string_lowercase(CRC& crc, string_view str)

  {

    for (char const c : str)

      crc.process_byte(to_lower(c) & 0xff);

  }

  struct name_entry

  {

    file_index_t idx;

    int length;

  };

}

  void torrent_info::resolve_duplicate_filenames_slow()

  {

    INVARIANT_CHECK;

    // maps filename hash to file index

    // or, if the file_index is negative, maps into the paths vector

    std::unordered_multimap<std::uint32_t, name_entry> files;

    std::vector<std::string> const& paths = m_files.paths();

    files.reserve(paths.size() + aux::numeric_cast<std::size_t>(m_files.num_files()));

    // insert all directories first, to make sure no files

    // are allowed to collied with them

    {

      boost::crc_optimal<32, 0x1EDC6F41, 0xFFFFFFFF, 0xFFFFFFFF, true, true> crc;

      if (!m_files.name().empty())

      {

        process_string_lowercase(crc, m_files.name());

      }

      file_index_t path_index{-1};

      for (auto const& path : paths)

      {

        auto local_crc = crc;

        if (!path.empty()) local_crc.process_byte(TORRENT_SEPARATOR);

        int count = 0;

        for (char const c : path)

        {

          if (c == TORRENT_SEPARATOR)

            files.insert({local_crc.checksum(), {path_index, count}});

          local_crc.process_byte(to_lower(c) & 0xff);

          ++count;

        }

        files.insert({local_crc.checksum(), {path_index, int(path.size())}});

        --path_index;

      }

    }

    // keep track of the total number of name collisions. If there are too

    // many, it's probably a malicious torrent and we should just fail

    int num_collisions = 0;

    for (auto const i : m_files.file_range())

    {

      // as long as this file already exists

      // increase the counter

      std::uint32_t const hash = m_files.file_path_hash(i, "");

      auto range = files.equal_range(hash);

      auto const match = std::find_if(range.first, range.second, [&](std::pair<std::uint32_t, name_entry> const& o)

      {

        std::string const other_name = o.second.idx < file_index_t{}

          ? combine_path(m_files.name(), paths[std::size_t(-static_cast<int>(o.second.idx)-1)].substr(0, std::size_t(o.second.length)))

          : m_files.file_path(o.second.idx);

        return string_equal_no_case(other_name, m_files.file_path(i));

      });

      if (match == range.second)

      {

        files.insert({hash, {i, 0}});

        continue;

      }

      // pad files are allowed to collide with each-other, as long as they have

      // the same size.

      file_index_t const other_idx = match->second.idx;

      if (other_idx >= file_index_t{}

        && (m_files.file_flags(i) & file_storage::flag_pad_file)

        && (m_files.file_flags(other_idx) & file_storage::flag_pad_file)

        && m_files.file_size(i) == m_files.file_size(other_idx))

        continue;

      std::string filename = m_files.file_path(i);

      std::string base = remove_extension(filename);

      std::string ext = extension(filename);

      int cnt = 0;

      for (;;)

      {

        ++cnt;

        char new_ext[50];

        std::snprintf(new_ext, sizeof(new_ext), ".%d%s", cnt, ext.c_str());

        filename = base + new_ext;

        boost::crc_optimal<32, 0x1EDC6F41, 0xFFFFFFFF, 0xFFFFFFFF, true, true> crc;

        process_string_lowercase(crc, filename);

        std::uint32_t const new_hash = crc.checksum();

        if (files.find(new_hash) == files.end())

        {

          files.insert({new_hash, {i, 0}});

          break;

        }

        ++num_collisions;

        if (num_collisions > 100)

        {

        // TODO: this should be considered a failure, and the .torrent file

        // rejected

        }

      }

      copy_on_write();

      m_files.rename_file(i, filename);

    }

  }

  void torrent_info::remap_files(file_storage const& f)

  {

    INVARIANT_CHECK;

    TORRENT_ASSERT(is_loaded());

    // the new specified file storage must have the exact

    // same size as the current file storage

    TORRENT_ASSERT(m_files.total_size() == f.total_size());

    if (m_files.total_size() != f.total_size()) return;

    copy_on_write();

    m_files = f;

    m_files.set_num_pieces(m_orig_files->num_pieces());

    m_files.set_piece_length(m_orig_files->piece_length());

  }

#if TORRENT_ABI_VERSION == 1

  // standard constructor that parses a torrent file

  torrent_info::torrent_info(entry const& torrent_file)

  {

    std::vector<char> tmp;

    std::back_insert_iterator<std::vector<char>> out(tmp);

    bencode(out, torrent_file);

    bdecode_node e;

    error_code ec;

    if (tmp.empty() || bdecode(&tmp[0], &tmp[0] + tmp.size(), e, ec) != 0)

    {

#ifndef BOOST_NO_EXCEPTIONS

      aux::throw_ex<system_error>(ec);

#else

      return;

#endif

    }

#ifndef BOOST_NO_EXCEPTIONS

    if (!parse_torrent_file(e, ec, load_torrent_limits{}.max_pieces))

      aux::throw_ex<system_error>(ec);

#else

    parse_torrent_file(e, ec, load_torrent_limits{}.max_pieces);

#endif

    INVARIANT_CHECK;

  }

#endif // TORRENT_ABI_VERSION

#ifndef BOOST_NO_EXCEPTIONS

  torrent_info::torrent_info(bdecode_node const& torrent_file)

    : torrent_info(torrent_file, load_torrent_limits{})

  {}

  torrent_info::torrent_info(span<char const> buffer, from_span_t)

    : torrent_info(buffer, load_torrent_limits{}, from_span)

  {}

  torrent_info::torrent_info(std::string const& filename)

    : torrent_info(filename, load_torrent_limits{})

  {}

  torrent_info::torrent_info(bdecode_node const& torrent_file

    , load_torrent_limits const& cfg)

  {

    error_code ec;

    if (!parse_torrent_file(torrent_file, ec, cfg.max_pieces))

      aux::throw_ex<system_error>(ec);

    INVARIANT_CHECK;

  }