src/torrent_handle.cpp

   1 /*
   2
   3 Copyright (c) 2003, Arvid Norberg
   4 All rights reserved.
   5
   6 Redistribution and use in source and binary forms, with or without
   7 modification, are permitted provided that the following conditions
   8 are met:
   9
  10     * Redistributions of source code must retain the above copyright
  11       notice, this list of conditions and the following disclaimer.
  12     * Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in
  14       the documentation and/or other materials provided with the distribution.
  15     * Neither the name of the author nor the names of its
  16       contributors may be used to endorse or promote products derived
  17       from this software without specific prior written permission.
  18
  19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  20 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  21 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  22 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  23 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29 POSSIBILITY OF SUCH DAMAGE.
  30
  31 */
  32
  33 #include "libtorrent/pch.hpp"
  34
  35 #include <ctime>
  36 #include <iostream>
  37 #include <fstream>
  38 #include <iomanip>
  39 #include <iterator>
  40 #include <algorithm>
  41 #include <set>
  42 #include <cctype>
  43 #include <algorithm>
  44
  45 #ifdef _MSC_VER
  46 #pragma warning(push, 1)
  47 #endif
  48
  49 #include <boost/lexical_cast.hpp>
  50 #include <boost/filesystem/convenience.hpp>
  51 #include <boost/optional.hpp>
  52 #include <boost/bind.hpp>
  53
  54 #ifdef _MSC_VER
  55 #pragma warning(pop)
  56 #endif
  57
  58 #include "libtorrent/peer_id.hpp"
  59 #include "libtorrent/bt_peer_connection.hpp"
  60 #include "libtorrent/torrent_info.hpp"
  61 #include "libtorrent/tracker_manager.hpp"
  62 #include "libtorrent/bencode.hpp"
  63 #include "libtorrent/hasher.hpp"
  64 #include "libtorrent/entry.hpp"
  65 #include "libtorrent/session.hpp"
  66 #include "libtorrent/aux_/session_impl.hpp"
  67 #include "libtorrent/invariant_check.hpp"
  68
  69 #if defined(_MSC_VER) && _MSC_VER < 1300
  70 namespace std
  71 {
  72         using ::srand;
  73         using ::isalnum;
  74 };
  75 #endif
  76
  77 using boost::bind;
  78 using boost::mutex;
  79 using libtorrent::aux::session_impl;
  80
  81 #ifdef BOOST_NO_EXCEPTIONS
  82
  83 #define TORRENT_FORWARD(call) \
  84         boost::shared_ptr<torrent> t = m_torrent.lock(); \
  85         if (!t) return; \
  86         session_impl::mutex_t::scoped_lock l(t->session().m_mutex); \
  87         t->call
  88
  89 #define TORRENT_FORWARD_RETURN(call, def) \
  90         boost::shared_ptr<torrent> t = m_torrent.lock(); \
  91         if (!t) return def; \
  92         session_impl::mutex_t::scoped_lock l(t->session().m_mutex); \
  93         return t->call
  94
  95 #define TORRENT_FORWARD_RETURN2(call, def) \
  96         boost::shared_ptr<torrent> t = m_torrent.lock(); \
  97         if (!t) return def; \
  98         session_impl::mutex_t::scoped_lock l(t->session().m_mutex); \
  99         t->call
 100
 101 #else
 102
 103 #define TORRENT_FORWARD(call) \
 104         boost::shared_ptr<torrent> t = m_torrent.lock(); \
 105         if (!t) throw_invalid_handle(); \
 106         session_impl::mutex_t::scoped_lock l(t->session().m_mutex); \
 107         t->call
 108
 109 #define TORRENT_FORWARD_RETURN(call, def) \
 110         boost::shared_ptr<torrent> t = m_torrent.lock(); \
 111         if (!t) throw_invalid_handle(); \
 112         session_impl::mutex_t::scoped_lock l(t->session().m_mutex); \
 113         return t->call
 114
 115 #define TORRENT_FORWARD_RETURN2(call, def) \
 116         boost::shared_ptr<torrent> t = m_torrent.lock(); \
 117         if (!t) throw_invalid_handle(); \
 118         session_impl::mutex_t::scoped_lock l(t->session().m_mutex); \
 119         t->call
 120
 121 #endif
 122
 123 namespace libtorrent
 124 {
 125         namespace fs = boost::filesystem;
 126
 127         namespace
 128         {
 129 #ifndef BOOST_NO_EXCEPTIONS
 130                 void throw_invalid_handle()
 131                 {
 132                         throw invalid_handle();
 133                 }
 134 #endif
 135         }
 136
 137 #ifndef NDEBUG
 138
 139         void torrent_handle::check_invariant() const
 140         {}
 141
 142 #endif
 143
 144         sha1_hash torrent_handle::info_hash() const
 145         {
 146                 INVARIANT_CHECK;
 147                 const static sha1_hash empty;
 148                 TORRENT_FORWARD_RETURN(torrent_file().info_hash(), empty);
 149         }
 150
 151         void torrent_handle::set_max_uploads(int max_uploads) const
 152         {
 153                 INVARIANT_CHECK;
 154                 TORRENT_ASSERT(max_uploads >= 2 || max_uploads == -1);
 155                 TORRENT_FORWARD(set_max_uploads(max_uploads));
 156         }
 157
 158         void torrent_handle::use_interface(const char* net_interface) const
 159         {
 160                 INVARIANT_CHECK;
 161                 TORRENT_FORWARD(use_interface(net_interface));
 162         }
 163
 164         void torrent_handle::set_max_connections(int max_connections) const
 165         {
 166                 INVARIANT_CHECK;
 167                 TORRENT_ASSERT(max_connections >= 2 || max_connections == -1);
 168                 TORRENT_FORWARD(set_max_connections(max_connections));
 169         }
 170
 171         void torrent_handle::set_peer_upload_limit(tcp::endpoint ip, int limit) const
 172         {
 173                 INVARIANT_CHECK;
 174                 TORRENT_ASSERT(limit >= -1);
 175                 TORRENT_FORWARD(set_peer_upload_limit(ip, limit));
 176         }
 177
 178         void torrent_handle::set_peer_download_limit(tcp::endpoint ip, int limit) const
 179         {
 180                 INVARIANT_CHECK;
 181                 TORRENT_ASSERT(limit >= -1);
 182                 TORRENT_FORWARD(set_peer_download_limit(ip, limit));
 183         }
 184
 185         void torrent_handle::set_upload_limit(int limit) const
 186         {
 187                 INVARIANT_CHECK;
 188                 TORRENT_ASSERT(limit >= -1);
 189                 TORRENT_FORWARD(set_upload_limit(limit));
 190         }
 191
 192         int torrent_handle::upload_limit() const
 193         {
 194                 INVARIANT_CHECK;
 195                 TORRENT_FORWARD_RETURN(upload_limit(), 0);
 196         }
 197
 198         void torrent_handle::set_download_limit(int limit) const
 199         {
 200                 INVARIANT_CHECK;
 201                 TORRENT_ASSERT(limit >= -1);
 202                 TORRENT_FORWARD(set_download_limit(limit));
 203         }
 204
 205         int torrent_handle::download_limit() const
 206         {
 207                 INVARIANT_CHECK;
 208                 TORRENT_FORWARD_RETURN(download_limit(), 0);
 209         }
 210
 211         void torrent_handle::move_storage(
 212                 fs::path const& save_path) const
 213         {
 214                 INVARIANT_CHECK;
 215                 TORRENT_FORWARD(move_storage(save_path));
 216         }
 217
 218         void torrent_handle::rename_file(int index, fs::path const& new_name) const
 219         {
 220                 INVARIANT_CHECK;
 221                 TORRENT_FORWARD(rename_file(index, new_name.string()));
 222         }
 223
 224         void torrent_handle::add_extension(
 225                 boost::function<boost::shared_ptr<torrent_plugin>(torrent*, void*)> const& ext
 226                 , void* userdata)
 227         {
 228                 INVARIANT_CHECK;
 229                 TORRENT_FORWARD(add_extension(ext, userdata));
 230         }
 231
 232         bool torrent_handle::has_metadata() const
 233         {
 234                 INVARIANT_CHECK;
 235                 TORRENT_FORWARD_RETURN(valid_metadata(), false);
 236         }
 237
 238         bool torrent_handle::is_seed() const
 239         {
 240                 INVARIANT_CHECK;
 241                 TORRENT_FORWARD_RETURN(is_seed(), false);
 242         }
 243
 244         bool torrent_handle::is_finished() const
 245         {
 246                 INVARIANT_CHECK;
 247                 TORRENT_FORWARD_RETURN(is_finished(), false);
 248         }
 249
 250         bool torrent_handle::is_paused() const
 251         {
 252                 INVARIANT_CHECK;
 253                 TORRENT_FORWARD_RETURN(is_paused(), false);
 254         }
 255
 256         void torrent_handle::pause() const
 257         {
 258                 INVARIANT_CHECK;
 259                 TORRENT_FORWARD(pause());
 260         }
 261
 262         void torrent_handle::save_resume_data() const
 263         {
 264                 INVARIANT_CHECK;
 265                 TORRENT_FORWARD(save_resume_data());
 266         }
 267
 268         void torrent_handle::force_recheck() const
 269         {
 270                 INVARIANT_CHECK;
 271                 TORRENT_FORWARD(force_recheck());
 272         }
 273
 274         void torrent_handle::resume() const
 275         {
 276                 INVARIANT_CHECK;
 277                 TORRENT_FORWARD(resume());
 278         }
 279
 280         bool torrent_handle::is_auto_managed() const
 281         {
 282                 INVARIANT_CHECK;
 283                 TORRENT_FORWARD_RETURN(is_auto_managed(), true);
 284         }
 285
 286         void torrent_handle::auto_managed(bool m) const
 287         {
 288                 INVARIANT_CHECK;
 289                 TORRENT_FORWARD(auto_managed(m));
 290         }
 291
 292         int torrent_handle::queue_position() const
 293         {
 294                 INVARIANT_CHECK;
 295                 TORRENT_FORWARD_RETURN(queue_position(), -1);
 296         }
 297
 298         void torrent_handle::queue_position_up() const
 299         {
 300                 INVARIANT_CHECK;
 301                 TORRENT_FORWARD(set_queue_position(t->queue_position() - 1));
 302         }
 303
 304         void torrent_handle::queue_position_down() const
 305         {
 306                 INVARIANT_CHECK;
 307                 TORRENT_FORWARD(set_queue_position(t->queue_position() + 1));
 308         }
 309
 310         void torrent_handle::queue_position_top() const
 311         {
 312                 INVARIANT_CHECK;
 313                 TORRENT_FORWARD(set_queue_position(0));
 314         }
 315
 316         void torrent_handle::queue_position_bottom() const
 317         {
 318                 INVARIANT_CHECK;
 319                 TORRENT_FORWARD(set_queue_position((std::numeric_limits<int>::max)()));
 320         }
 321
 322         void torrent_handle::clear_error() const
 323         {
 324                 INVARIANT_CHECK;
 325                 TORRENT_FORWARD(clear_error());
 326         }
 327
 328         void torrent_handle::set_tracker_login(std::string const& name
 329                 , std::string const& password) const
 330         {
 331                 INVARIANT_CHECK;
 332                 TORRENT_FORWARD(set_tracker_login(name, password));
 333         }
 334
 335         void torrent_handle::file_progress(std::vector<float>& progress) const
 336         {
 337                 INVARIANT_CHECK;
 338                 TORRENT_FORWARD(file_progress(progress));
 339         }
 340
 341         void torrent_handle::file_progress(std::vector<size_type>& progress) const
 342         {
 343                 INVARIANT_CHECK;
 344                 TORRENT_FORWARD(file_progress(progress));
 345         }
 346
 347         torrent_status torrent_handle::status() const
 348         {
 349                 INVARIANT_CHECK;
 350                 TORRENT_FORWARD_RETURN(status(), torrent_status());
 351         }
 352
 353         void torrent_handle::set_sequential_download(bool sd) const
 354         {
 355                 INVARIANT_CHECK;
 356                 TORRENT_FORWARD(set_sequential_download(sd));
 357         }
 358
 359         bool torrent_handle::is_sequential_download() const
 360         {
 361                 INVARIANT_CHECK;
 362                 TORRENT_FORWARD_RETURN(is_sequential_download(), false);
 363         }
 364
 365         std::string torrent_handle::name() const
 366         {
 367                 INVARIANT_CHECK;
 368                 TORRENT_FORWARD_RETURN(name(), "");
 369         }
 370
 371         void torrent_handle::piece_availability(std::vector<int>& avail) const
 372         {
 373                 INVARIANT_CHECK;
 374                 TORRENT_FORWARD(piece_availability(avail));
 375         }
 376
 377         void torrent_handle::piece_priority(int index, int priority) const
 378         {
 379                 INVARIANT_CHECK;
 380                 TORRENT_FORWARD(set_piece_priority(index, priority));
 381         }
 382
 383         int torrent_handle::piece_priority(int index) const
 384         {
 385                 INVARIANT_CHECK;
 386                 TORRENT_FORWARD_RETURN(piece_priority(index), 0);
 387         }
 388
 389         void torrent_handle::prioritize_pieces(std::vector<int> const& pieces) const
 390         {
 391                 INVARIANT_CHECK;
 392                 TORRENT_FORWARD(prioritize_pieces(pieces));
 393         }
 394
 395         std::vector<int> torrent_handle::piece_priorities() const
 396         {
 397                 INVARIANT_CHECK;
 398                 std::vector<int> ret;
 399                 TORRENT_FORWARD_RETURN2(piece_priorities(ret), ret);
 400                 return ret;
 401         }
 402
 403         void torrent_handle::file_priority(int index, int priority) const
 404         {
 405                 INVARIANT_CHECK;
 406                 TORRENT_FORWARD(set_file_priority(index, priority));
 407         }
 408
 409         int torrent_handle::file_priority(int index) const
 410         {
 411                 INVARIANT_CHECK;
 412                 TORRENT_FORWARD_RETURN(file_priority(index), 0);
 413         }
 414
 415         void torrent_handle::prioritize_files(std::vector<int> const& files) const
 416         {
 417                 INVARIANT_CHECK;
 418                 TORRENT_FORWARD(prioritize_files(files));
 419         }
 420
 421         std::vector<int> torrent_handle::file_priorities() const
 422         {
 423                 INVARIANT_CHECK;
 424                 std::vector<int> ret;
 425                 TORRENT_FORWARD_RETURN2(file_priorities(ret), ret);
 426                 return ret;
 427         }
 428
 429 // ============ start deprecation ===============
 430
 431         void torrent_handle::filter_piece(int index, bool filter) const
 432         {
 433                 INVARIANT_CHECK;
 434                 TORRENT_FORWARD(filter_piece(index, filter));
 435         }
 436
 437         void torrent_handle::filter_pieces(std::vector<bool> const& pieces) const
 438         {
 439                 INVARIANT_CHECK;
 440                 TORRENT_FORWARD(filter_pieces(pieces));
 441         }
 442
 443         bool torrent_handle::is_piece_filtered(int index) const
 444         {
 445                 INVARIANT_CHECK;
 446                 TORRENT_FORWARD_RETURN(is_piece_filtered(index), false);
 447         }
 448
 449         std::vector<bool> torrent_handle::filtered_pieces() const
 450         {
 451                 INVARIANT_CHECK;
 452                 std::vector<bool> ret;
 453                 TORRENT_FORWARD_RETURN2(filtered_pieces(ret), ret);
 454                 return ret;
 455         }
 456
 457         void torrent_handle::filter_files(std::vector<bool> const& files) const
 458         {
 459                 INVARIANT_CHECK;
 460                 TORRENT_FORWARD(filter_files(files));
 461         }
 462
 463 // ============ end deprecation ===============
 464
 465
 466         std::vector<announce_entry> const& torrent_handle::trackers() const
 467         {
 468                 INVARIANT_CHECK;
 469                 const static std::vector<announce_entry> empty;
 470                 TORRENT_FORWARD_RETURN(trackers(), empty);
 471         }
 472
 473         void torrent_handle::add_url_seed(std::string const& url) const
 474         {
 475                 INVARIANT_CHECK;
 476                 TORRENT_FORWARD(add_url_seed(url));
 477         }
 478
 479         void torrent_handle::remove_url_seed(std::string const& url) const
 480         {
 481                 INVARIANT_CHECK;
 482                 TORRENT_FORWARD(remove_url_seed(url));
 483         }
 484
 485         std::set<std::string> torrent_handle::url_seeds() const
 486         {
 487                 INVARIANT_CHECK;
 488                 const static std::set<std::string> empty;
 489                 TORRENT_FORWARD_RETURN(url_seeds(), empty);
 490         }
 491
 492         void torrent_handle::replace_trackers(
 493                 std::vector<announce_entry> const& urls) const
 494         {
 495                 INVARIANT_CHECK;
 496                 TORRENT_FORWARD(replace_trackers(urls));
 497         }
 498
 499         torrent_info const& torrent_handle::get_torrent_info() const
 500         {
 501                 INVARIANT_CHECK;
 502 #ifdef BOOST_NO_EXCEPTIONS
 503                 const static torrent_info empty;
 504 #endif
 505                 boost::shared_ptr<torrent> t = m_torrent.lock();
 506                 if (!t)
 507 #ifdef BOOST_NO_EXCEPTIONS
 508                         return empty;
 509 #else
 510                         throw_invalid_handle();
 511 #endif
 512                 session_impl::mutex_t::scoped_lock l(t->session().m_mutex);
 513                 if (!t->valid_metadata())
 514 #ifdef BOOST_NO_EXCEPTIONS
 515                         return empty;
 516 #else
 517                         throw_invalid_handle();
 518 #endif
 519                 return t->torrent_file();
 520         }
 521
 522         bool torrent_handle::is_valid() const
 523         {
 524                 INVARIANT_CHECK;
 525                 return !m_torrent.expired();
 526         }
 527
 528         entry torrent_handle::write_resume_data() const
 529         {
 530                 INVARIANT_CHECK;
 531
 532                 entry ret(entry::dictionary_t);
 533                 TORRENT_FORWARD(write_resume_data(ret));
 534                 t->filesystem().write_resume_data(ret);
 535
 536                 return ret;
 537         }
 538
 539
 540         fs::path torrent_handle::save_path() const
 541         {
 542                 INVARIANT_CHECK;
 543                 TORRENT_FORWARD_RETURN(save_path(), fs::path());
 544         }
 545
 546         void torrent_handle::connect_peer(tcp::endpoint const& adr, int source) const
 547         {
 548                 INVARIANT_CHECK;
 549
 550                 boost::shared_ptr<torrent> t = m_torrent.lock();
 551                 if (!t)
 552 #ifdef BOOST_NO_EXCEPTIONS
 553                         return;
 554 #else
 555                         throw_invalid_handle();
 556 #endif
 557                 session_impl::mutex_t::scoped_lock l(t->session().m_mutex);
 558
 559                 peer_id id;
 560                 std::fill(id.begin(), id.end(), 0);
 561                 t->get_policy().peer_from_tracker(adr, id, source, 0);
 562         }
 563
 564         void torrent_handle::force_reannounce(
 565                 boost::posix_time::time_duration duration) const
 566         {
 567                 INVARIANT_CHECK;
 568                 TORRENT_FORWARD(force_tracker_request(time_now() + seconds(duration.total_seconds())));
 569         }
 570
 571         void torrent_handle::force_reannounce() const
 572         {
 573                 INVARIANT_CHECK;
 574                 TORRENT_FORWARD(force_tracker_request());
 575         }
 576
 577         void torrent_handle::scrape_tracker() const
 578         {
 579                 INVARIANT_CHECK;
 580                 TORRENT_FORWARD(scrape_tracker());
 581         }
 582
 583         void torrent_handle::set_ratio(float ratio) const
 584         {
 585                 INVARIANT_CHECK;
 586
 587                 TORRENT_ASSERT(ratio >= 0.f);
 588                 if (ratio < 1.f && ratio > 0.f)
 589                         ratio = 1.f;
 590                 TORRENT_FORWARD(set_ratio(ratio));
 591         }
 592
 593 #ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES
 594         void torrent_handle::resolve_countries(bool r)
 595         {
 596                 INVARIANT_CHECK;
 597                 TORRENT_FORWARD(resolve_countries(r));
 598         }
 599
 600         bool torrent_handle::resolve_countries() const
 601         {
 602                 INVARIANT_CHECK;
 603                 TORRENT_FORWARD_RETURN(resolving_countries(), false);
 604         }
 605 #endif
 606
 607         void torrent_handle::get_full_peer_list(std::vector<peer_list_entry>& v) const
 608         {
 609                 INVARIANT_CHECK;
 610                 TORRENT_FORWARD(get_full_peer_list(v));
 611         }
 612
 613         void torrent_handle::get_peer_info(std::vector<peer_info>& v) const
 614         {
 615                 INVARIANT_CHECK;
 616                 TORRENT_FORWARD(get_peer_info(v));
 617         }
 618
 619         void torrent_handle::get_download_queue(std::vector<partial_piece_info>& queue) const
 620         {
 621                 INVARIANT_CHECK;
 622                 TORRENT_FORWARD(get_download_queue(queue));
 623         }
 624
 625 }
 626