libtorrent Examples

Author: Arvid Norberg, arvid@libtorrent.org
Version: 1.1.10

examples

Except for the example programs in this manual, there's also a bigger example of a (little bit) more complete client, client_test. There are separate instructions for how to use it here if you'd like to try it. Note that building client_test also requires boost.regex and boost.program_options library.

simple client

This is a simple client. It doesn't have much output to keep it simple:

#include <stdlib.h>
#include <boost/make_shared.hpp>
#include "libtorrent/entry.hpp"
#include "libtorrent/bencode.hpp"
#include "libtorrent/session.hpp"
#include "libtorrent/torrent_info.hpp"

int main(int argc, char* argv[]) try
{
  if (argc != 2)
  {
    std::cerr << "usage: ./simple_client torrent-file\n"
      "to stop the client, press return.\n";
    return 1;
  }

  lt::session s;
  lt::add_torrent_params p;
  p.save_path = "./";
  lt::error_code ec;
  p.ti = boost::make_shared<lt::torrent_info>(std::string(argv[1]), 0);
  s.add_torrent(p);

  // wait for the user to end
  char a;
  scanf("%c\n", &a);
  return 0;
}
catch (std::exception const& e)
{
  std::cerr << "ERROR: " << e.what() << "\n";
}

make_torrent

Shows how to create a torrent from a directory tree:

#include "libtorrent/entry.hpp"
#include "libtorrent/bencode.hpp"
#include "libtorrent/torrent_info.hpp"
#include "libtorrent/file.hpp"
#include "libtorrent/storage.hpp"
#include "libtorrent/hasher.hpp"
#include "libtorrent/create_torrent.hpp"
#include "libtorrent/file.hpp"
#include "libtorrent/file_pool.hpp"
#include "libtorrent/hex.hpp" // for from_hex

#include <boost/bind.hpp>
#include <fstream>

#ifdef TORRENT_WINDOWS
#include <direct.h> // for _getcwd
#endif

std::vector<char> load_file(std::string const& filename)
{
  std::vector<char> ret;
  std::fstream in;
  in.exceptions(std::ifstream::failbit);
  in.open(filename.c_str(), std::ios_base::in | std::ios_base::binary);
  in.seekg(0, std::ios_base::end);
  size_t const size = in.tellg();
  in.seekg(0, std::ios_base::beg);
  ret.resize(size);
  in.read(ret.data(), ret.size());
  return ret;
}

std::string branch_path(std::string const& f)
{
  if (f.empty()) return f;

#ifdef TORRENT_WINDOWS
  if (f == "\\\\") return "";
#endif
  if (f == "/") return "";

  int len = f.size();
  // if the last character is / or \ ignore it
  if (f[len-1] == '/' || f[len-1] == '\\') --len;
  while (len > 0)
  {
    --len;
    if (f[len] == '/' || f[len] == '\\')
      break;
  }

  if (f[len] == '/' || f[len] == '\\') ++len;
  return std::string(f.c_str(), len);
}

// do not include files and folders whose
// name starts with a .
bool file_filter(std::string const& f)
{
  if (f.empty()) return false;

  char const* first = f.c_str();
  char const* sep = strrchr(first, '/');
#if defined(TORRENT_WINDOWS) || defined(TORRENT_OS2)
  char const* altsep = strrchr(first, '\\');
  if (sep == NULL || altsep > sep) sep = altsep;
#endif
  // if there is no parent path, just set 'sep'
  // to point to the filename.
  // if there is a parent path, skip the '/' character
  if (sep == NULL) sep = first;
  else ++sep;

  // return false if the first character of the filename is a .
  if (sep[0] == '.') return false;

  fprintf(stderr, "%s\n", f.c_str());
  return true;
}

void print_progress(int i, int num)
{
  fprintf(stderr, "\r%d/%d", i+1, num);
}

void print_usage()
{
  fputs("usage: make_torrent FILE [OPTIONS]\n"
    "\n"
    "Generates a torrent file from the specified file\n"
    "or directory and writes it to standard out\n\n"
    "OPTIONS:\n"
    "-m file       generate a merkle hash tree torrent.\n"
    "              merkle torrents require client support\n"
    "              the resulting full merkle tree is written to\n"
    "              the specified file\n"
    "-w url        adds a web seed to the torrent with\n"
    "              the specified url\n"
    "-t url        adds the specified tracker to the\n"
    "              torrent. For multiple trackers, specify more\n"
    "              -t options\n"
    "-c comment    sets the comment to the specified string\n"
    "-C creator    sets the created-by field to the specified string\n"
    "-p bytes      enables padding files. Files larger\n"
    "              than bytes will be piece-aligned\n"
    "-s bytes      specifies a piece size for the torrent\n"
    "              This has to be a multiple of 16 kiB\n"
    "-l            Don't follow symlinks, instead encode them as\n"
    "              links in the torrent file\n"
    "-o file       specifies the output filename of the torrent file\n"
    "              If this is not specified, the torrent file is\n"
    "              printed to the standard out, except on windows\n"
    "              where the filename defaults to a.torrent\n"
    "-r file       add root certificate to the torrent, to verify\n"
    "              the HTTPS tracker\n"
    "-S info-hash  add a similar torrent by info-hash. The similar\n"
    "              torrent is expected to share some files with this one\n"
    "-L collection add a collection name to this torrent. Other torrents\n"
    "              in the same collection is expected to share files\n"
    "              with this one.\n"
    "-M            make the torrent compatible with mutable torrents\n"
    "              this means aligning large files and pad them in order\n"
    "              for piece hashes to uniquely indentify a file without\n"
    "              overlap\n"
    , stderr);
}

int main(int argc, char* argv[]) try
{
  std::string creator_str = "libtorrent";
  std::string comment_str;

  if (argc < 2) {
    print_usage();
    return 1;
  }

  std::vector<std::string> web_seeds;
  std::vector<std::string> trackers;
  std::vector<std::string> collections;
  std::vector<lt::sha1_hash> similar;
  int pad_file_limit = -1;
  int piece_size = 0;
  int flags = 0;
  std::string root_cert;

  std::string outfile;
  std::string merklefile;
#ifdef TORRENT_WINDOWS
  // don't ever write binary data to the console on windows
  // it will just be interpreted as text and corrupted
  outfile = "a.torrent";
#endif

  std::string full_path = argv[1];
  argv += 2;
  argc -= 2;

  for (; argc > 0; --argc, ++argv) {
    if (argv[0][0] != '-') {
      print_usage();
      return 1;
    }

    char const flag = argv[0][1];

    switch (flag)
    {
      case 'M':
        flags |= lt::create_torrent::mutable_torrent_support;
        pad_file_limit = 0x4000;
        continue;
      case 'l':
        flags |= lt::create_torrent::symlinks;
        continue;
    }

    if (argc < 2) {
      print_usage();
      return 1;
    }

    switch (flag)
    {
      case 'w': web_seeds.push_back(argv[1]); break;
      case 't': trackers.push_back(argv[1]); break;
      case 's': piece_size = atoi(argv[1]); break;
      case 'o': outfile = argv[1]; break;
      case 'C': creator_str = argv[1]; break;
      case 'c': comment_str = argv[1]; break;
      case 'r': root_cert = argv[1]; break;
      case 'L': collections.push_back(argv[1]); break;
      case 'p':
        pad_file_limit = atoi(argv[1]);
        flags |= lt::create_torrent::optimize_alignment;
        break;
      case 'm':
        merklefile = argv[1];
        flags |= lt::create_torrent::merkle;
        break;
      case 'S':
        {
        if (strlen(argv[1]) != 40)
        {
          std::cerr << "invalid info-hash for -S. "
            "Expected 40 hex characters\n";
          print_usage();
          return 1;
        }
        lt::sha1_hash ih;
        if (!lt::from_hex(argv[1], 40, ih.data()))
        {
          std::cerr << "invalid info-hash for -S\n";
          print_usage();
          return 1;
        }
        similar.push_back(ih);
        }
        break;
      default:
        print_usage();
        return 1;
    }
    ++argv;
    --argc;
  }

  lt::file_storage fs;
#ifdef TORRENT_WINDOWS
  if (full_path[1] != ':')
#else
  if (full_path[0] != '/')
#endif
  {
    char cwd[TORRENT_MAX_PATH];
#ifdef TORRENT_WINDOWS
    _getcwd(cwd, sizeof(cwd));
    full_path = cwd + ("\\" + full_path);
#else
    getcwd(cwd, sizeof(cwd));
    full_path = cwd + ("/" + full_path);
#endif
  }

  lt::add_files(fs, full_path, file_filter, flags);
  if (fs.num_files() == 0) {
    std::cerr << "no files specified.\n";
    return 1;
  }

  lt::create_torrent t(fs, piece_size, pad_file_limit, flags);
  int tier = 0;
  for (std::vector<std::string>::iterator i = trackers.begin()
    , end(trackers.end()); i != end; ++i, ++tier)
    t.add_tracker(*i, tier);

  for (std::vector<std::string>::iterator i = web_seeds.begin()
    , end(web_seeds.end()); i != end; ++i)
    t.add_url_seed(*i);

  for (std::vector<std::string>::iterator i = collections.begin()
    , end(collections.end()); i != end; ++i)
    t.add_collection(*i);

  for (std::vector<lt::sha1_hash>::iterator i = similar.begin()
    , end(similar.end()); i != end; ++i)
    t.add_similar_torrent(*i);

  lt::error_code ec;
  set_piece_hashes(t, branch_path(full_path)
    , boost::bind(&print_progress, _1, t.num_pieces()), ec);
  if (ec) {
    std::cerr << ec.message() << "\n";
    return 1;
  }

  fprintf(stderr, "\n");
  t.set_creator(creator_str.c_str());
  if (!comment_str.empty()) {
    t.set_comment(comment_str.c_str());
  }

  if (!root_cert.empty()) {
    std::vector<char> const pem = load_file(root_cert);
    t.set_root_cert(std::string(&pem[0], pem.size()));
  }

  // create the torrent and print it to stdout
  std::vector<char> torrent;
  lt::bencode(back_inserter(torrent), t.generate());
  if (!outfile.empty()) {
    std::fstream out;
    out.exceptions(std::ifstream::failbit);
    out.open(outfile.c_str(), std::ios_base::out | std::ios_base::binary);
    out.write(&torrent[0], torrent.size());
  }
  else {
    std::cout.write(&torrent[0], torrent.size());
  }

  if (!merklefile.empty()) {
    std::fstream merkle;
    merkle.exceptions(std::ifstream::failbit);
    merkle.open(merklefile.c_str(), std::ios_base::out | std::ios_base::binary);
    merkle.write(reinterpret_cast<char const*>(&t.merkle_tree()[0]), t.merkle_tree().size() * 20);
  }
  return 0;
}
catch (std::exception& e) {
  std::cerr << "ERROR: " << e.what() << "\n";
  return 1;
}

dump_torrent

This is an example of a program that will take a torrent-file as a parameter and print information about it to std out:

#include "libtorrent/entry.hpp"
#include "libtorrent/bencode.hpp"
#include "libtorrent/torrent_info.hpp"
#include "libtorrent/announce_entry.hpp"
#include "libtorrent/bdecode.hpp"
#include "libtorrent/magnet_uri.hpp"

#include <fstream>

std::vector<char> load_file(std::string const& filename)
{
  std::vector<char> ret;
  std::fstream in;
  in.exceptions(std::ifstream::failbit);
  in.open(filename.c_str(), std::ios_base::in | std::ios_base::binary);
  in.seekg(0, std::ios_base::end);
  size_t const size = in.tellg();
  in.seekg(0, std::ios_base::beg);
  ret.resize(size);
  in.read(ret.data(), ret.size());
  return ret;
}

int main(int argc, char* argv[]) try
{
  if (argc < 2 || argc > 4) {
    fputs("usage: dump_torrent torrent-file [total-items-limit] [recursion-limit]\n", stderr);
    return 1;
  }

  int item_limit = 1000000;
  int depth_limit = 1000;

  if (argc > 2) item_limit = atoi(argv[2]);
  if (argc > 3) depth_limit = atoi(argv[3]);

  std::vector<char> buf = load_file(argv[1]);
  lt::bdecode_node e;
  int pos = -1;
  lt::error_code ec;
  std::cout << "decoding. recursion limit: " << depth_limit
    << " total item count limit: " << item_limit << "\n";
  int const ret = lt::bdecode(&buf[0], &buf[0] + buf.size(), e, ec, &pos
    , depth_limit, item_limit);

  printf("\n\n----- raw info -----\n\n%s\n", print_entry(e).c_str());

  if (ret != 0) {
    std::cerr << "failed to decode: '" << ec.message() << "' at character: " << pos<< "\n";
    return 1;
  }

  lt::torrent_info const t(e);
  e.clear();
  std::vector<char>().swap(buf);

  // print info about torrent
  printf("\n\n----- torrent file info -----\n\n"
    "nodes:\n");

  typedef std::vector<std::pair<std::string, int> > node_vec;
  node_vec const& nodes = t.nodes();
  for (node_vec::const_iterator i = nodes.begin(), end(nodes.end());
    i != end; ++i)
  {
    printf("%s: %d\n", i->first.c_str(), i->second);
  }
  puts("trackers:\n");
  for (std::vector<lt::announce_entry>::const_iterator i = t.trackers().begin();
    i != t.trackers().end(); ++i)
  {
    printf("%2d: %s\n", i->tier, i->url.c_str());
  }

  char ih[41];
  lt::to_hex(t.info_hash().data(), 20, ih);
  printf("number of pieces: %d\n"
    "piece length: %d\n"
    "info hash: %s\n"
    "comment: %s\n"
    "created by: %s\n"
    "magnet link: %s\n"
    "name: %s\n"
    "number of files: %d\n"
    "files:\n"
    , t.num_pieces()
    , t.piece_length()
    , ih
    , t.comment().c_str()
    , t.creator().c_str()
    , make_magnet_uri(t).c_str()
    , t.name().c_str()
    , t.num_files());
  lt::file_storage const& st = t.files();
  for (int i = 0; i < st.num_files(); ++i)
  {
    int const first = st.map_file(i, 0, 0).piece;
    int const last = st.map_file(i, (std::max)(boost::int64_t(st.file_size(i))-1, boost::int64_t(0)), 0).piece;
    int const flags = st.file_flags(i);
    printf(" %8" PRIx64 " %11" PRId64 " %c%c%c%c [ %5d, %5d ] %7u %s %s %s%s\n"
      , st.file_offset(i)
      , st.file_size(i)
      , ((flags & lt::file_storage::flag_pad_file)?'p':'-')
      , ((flags & lt::file_storage::flag_executable)?'x':'-')
      , ((flags & lt::file_storage::flag_hidden)?'h':'-')
      , ((flags & lt::file_storage::flag_symlink)?'l':'-')
      , first, last
      , boost::uint32_t(st.mtime(i))
      , st.hash(i) != lt::sha1_hash(0) ? lt::to_hex(st.hash(i).to_string()).c_str() : ""
      , st.file_path(i).c_str()
      , (flags & lt::file_storage::flag_symlink) ? "-> " : ""
      , (flags & lt::file_storage::flag_symlink) ? st.symlink(i).c_str() : "");
  }

  return 0;
}
catch (std::exception const& e)
{
  std::cerr << "ERROR: " << e.what() << "\n";
}