| relevance 3 | ../src/http_tracker_connection.cpp:85 | take tracker_req().auth into account. Use it when making the request |
take tracker_req().auth into account. Use it when making the
+request../src/http_tracker_connection.cpp:85using namespace libtorrent;
+
+namespace libtorrent
{
+#if TORRENT_USE_I2P
+ // defined in torrent_info.cpp
+ bool is_i2p_url(std::string const& url);
+#endif
+
+ http_tracker_connection::http_tracker_connection(
+ io_service& ios
+ , tracker_manager& man
+ , tracker_request const& req
+ , boost::weak_ptr<request_callback> c)
+ : tracker_connection(man, req, ios, c)
+ , m_man(man)
+ {}
+
+ void http_tracker_connection::start()
+ {
+ std::string url = tracker_req().url;
+
+ if (tracker_req().kind == tracker_request::scrape_request)
+ {
+ // find and replace "announce" with "scrape"
+ // in request
+
+ std::size_t pos = url.find("announce");
+ if (pos == std::string::npos)
+ {
+ tracker_connection::fail(error_code(errors::scrape_not_available));
+ return;
+ }
+ url.replace(pos, 8, "scrape");
+ }
+
+#if TORRENT_USE_I2P
+ bool i2p = is_i2p_url(url);
+#else
+ static const bool i2p = false;
+#endif
+
+ aux::session_settings const& settings = m_man.settings();
+
+ // if request-string already contains
+ // some parameters, append an ampersand instead
+ // of a question mark
+ size_t arguments_start = url.find('?');
+ if (arguments_start != std::string::npos)
+ url += "&";
+ else
+ | ||
| relevance 3 | ../src/peer_connection.cpp:869 | this may cause a priority inversion! making a snubbed peer open up a new piece may cause that piece to become the highest priority. Unless there is some way to mark pieces as low-priority this is probably not a good idea. We just want to make all snubbed peers pick the same common piece. |
this may cause a priority inversion! making a snubbed peer
+open up a new piece may cause that piece to become the highest
+priority. Unless there is some way to mark pieces as low-priority
+this is probably not a good idea. We just want to make all snubbed
+peers pick the same common piece.../src/peer_connection.cpp:869 ret |= piece_picker::sequential;
+ }
+ else if (t->num_have() < m_settings.get_int(settings_pack::initial_picker_threshold))
+ {
+ // if we have fewer pieces than a certain threshols
+ // don't pick rare pieces, just pick random ones,
+ // and prioritize finishing them
+ ret |= piece_picker::prioritize_partials;
+ }
+ else
+ {
+ ret |= piece_picker::rarest_first | piece_picker::speed_affinity;
+ }
+
+ if (m_snubbed)
+ {
+ // snubbed peers should request
+ // the common pieces first, just to make
+ // it more likely for all snubbed peers to
+ // request blocks from the same piece
+ ret |= piece_picker::reverse;
+ }
+
+ if (m_settings.get_bool(settings_pack::prioritize_partial_pieces))
+ ret |= piece_picker::prioritize_partials;
+
+ if (on_parole()) ret |= piece_picker::on_parole
+ | piece_picker::prioritize_partials;
+
+ // only one of rarest_first and sequential can be set.
+ TORRENT_ASSERT((ret & piece_picker::rarest_first) ? 1 : 0
+ + (ret & piece_picker::sequential) ? 1 : 0 <= 1);
+ return ret;
+ }
+
+ void peer_connection::fast_reconnect(bool r)
+ {
+ TORRENT_ASSERT(is_single_thread());
+ if (!peer_info_struct() || peer_info_struct()->fast_reconnects > 1)
+ return;
+ m_fast_reconnect = r;
+ peer_info_struct()->last_connected = (boost::uint16_t)m_ses.session_time();
+ int rewind = m_settings.get_int(settings_pack::min_reconnect_time)
+ * m_settings.get_int(settings_pack::max_failcount);
+ if (peer_info_struct()->last_connected < rewind) peer_info_struct()->last_connected = 0;
+ else peer_info_struct()->last_connected -= rewind;
+
+ if (peer_info_struct()->fast_reconnects < 15)
+ ++peer_info_struct()->fast_reconnects;
+ }
+
+ | ||
| relevance 3 | ../src/kademlia/get_item.cpp:220 | we don't support CAS errors here! we need a custom observer |
we don't support CAS errors here! we need a custom observer../src/kademlia/get_item.cpp:220 TORRENT_LOG(node) << "sending put [ v: \"" << m_data.value()
+ << "\" seq: " << (m_data.is_mutable() ? m_data.seq() : -1)
+ << " nodes: " << v.size() << " ]" ;
+#endif
+
+ // create a dummy traversal_algorithm
+ boost::intrusive_ptr<traversal_algorithm> algo(
+ new traversal_algorithm(m_node, (node_id::min)()));
+
+ // store on the first k nodes
+ for (std::vector<std::pair<node_entry, std::string> >::const_iterator i = v.begin()
+ , end(v.end()); i != end; ++i)
+ {
+#ifdef TORRENT_DHT_VERBOSE_LOGGING
+ TORRENT_LOG(node) << " put-distance: " << (160 - distance_exp(m_target, i->first.id));
+#endif
+
+ void* ptr = m_node.m_rpc.allocate_observer();
+ if (ptr == 0) return;
+
+ observer_ptr o(new (ptr) announce_observer(algo, i->first.ep(), i->first.id));
+ #if TORRENT_USE_ASSERTS
+ o->m_in_constructor = false;
+#endif
+ entry e;
+ e["y"] = "q";
+ e["q"] = "put";
+ entry& a = e["a"];
+ a["v"] = m_data.value();
+ a["token"] = i->second;
+ if (m_data.is_mutable())
+ {
+ a["k"] = std::string(m_data.pk().data(), item_pk_len);
+ a["seq"] = m_data.seq();
+ a["sig"] = std::string(m_data.sig().data(), item_sig_len);
+ if (!m_data.salt().empty())
+ {
+ a["salt"] = m_data.salt();
+ }
+ }
+ m_node.m_rpc.invoke(e, i->first.ep(), o);
+ }
}
-void lsd::start()
+void get_item_observer::reply(msg const& m)
{
-#if defined TORRENT_LOGGING
- m_log = fopen("lsd.log", "w+");
- if (m_log == NULL)
- {
- fprintf(stderr, "failed to open 'lsd.log': (%d) %s"
- , errno, strerror(errno));
- }
-#endif
+ char const* pk = NULL;
+ char const* sig = NULL;
+ boost::uint64_t seq = 0;
- error_code ec;
- m_socket.open(boost::bind(&lsd::on_announce, self(), _1, _2, _3)
- , m_broadcast_timer.get_io_service(), ec);
-
-#if defined TORRENT_LOGGING
- if (ec)
- {
- if (m_log) fprintf(m_log, "FAILED TO OPEN SOCKET: (%d) %s\n"
- , ec.value(), ec.message().c_str());
- }
+ lazy_entry const* r = m.message.dict_find_dict("r");
+ | ||
| relevance 3 | ../include/libtorrent/piece_picker.hpp:145 | perhaps the piece_state feature could be removed. It's not obvious that it has any effect |
perhaps the piece_state feature could be removed. It's not
+obvious that it has any effect../include/libtorrent/piece_picker.hpp:145 // downloaded from. This is a pointer to
+ // a torrent_peer object
+ void* peer;
+ // the number of peers that has this block in their
+ // download or request queues
+ unsigned num_peers:14;
+ // the state of this block
+ enum { state_none, state_requested, state_writing, state_finished };
+ unsigned state:2;
+#if TORRENT_USE_ASSERTS
+ // to allow verifying the invariant of blocks belonging to the right piece
+ int piece_index;
+ std::set<void*> peers;
#endif
+ };
-#if TORRENT_USE_IPV6
- m_socket6.open(boost::bind(&lsd::on_announce, self(), _1, _2, _3)
- , m_broadcast_timer.get_io_service(), ec);
-#if defined TORRENT_LOGGING
- if (ec)
- {
- if (m_log) fprintf(m_log, "FAILED TO OPEN SOCKET6: (%d) %s\n"
- , ec.value(), ec.message().c_str());
- }
-#endif
-#endif
- | ||
| relevance 3 | ../src/peer_list.cpp:460 | settings_pack::max_failcount should be used here, not 3 |
settings_pack::max_failcount should be used here, not 3../src/peer_list.cpp:460 INVARIANT_CHECK;
+ // the peers that are downloading this piece
+ // are considered fast peers or slow peers.
+ // none is set if the blocks were downloaded
+ // in a previous session
+ enum piece_state_t
+ { none, slow, medium, fast };
- TORRENT_ASSERT(p->in_use);
- const bool was_conn_cand = is_connect_candidate(*p);
- p->failcount = f;
- if (was_conn_cand != is_connect_candidate(*p))
+ enum options_t
{
- update_connect_candidates(was_conn_cand ? -1 : 1);
+ // pick rarest first
+ rarest_first = 1,
+ // pick the most common first, or the last pieces if sequential
+ reverse = 2,
+ // only pick pieces exclusively requested from this peer
+ on_parole = 4,
+ // always pick partial pieces before any other piece
+ prioritize_partials = 8,
+ // pick pieces in sequential order
+ sequential = 16,
+ // have affinity to pieces with the same speed category
+ speed_affinity = 32,
+ // treat pieces with priority 6 and below as filtered
+ // to trigger end-game mode until all prio 7 pieces are
+ // completed
+ time_critical_mode = 64,
+ // only expands pieces (when prefer contiguous blocks is set)
+ // within properly aligned ranges, not the largest possible
+ // range of pieces.
+ align_expanded_pieces = 128
+ };
+
+ struct downloading_piece
+ {
+ downloading_piece() : info(NULL), index(-1)
+ , finished(0), state(none), writing(0)
+ | ||
| relevance 2 | ../src/peer_connection.cpp:2997 | since we throw away the queue entry once we issue the disk job, this may happen. Instead, we should keep the queue entry around, mark it as having been requested from disk and once the disk job comes back, discard it if it has been cancelled. Maybe even be able to cancel disk jobs? |
since we throw away the queue entry once we issue
+the disk job, this may happen. Instead, we should keep the
+queue entry around, mark it as having been requested from
+disk and once the disk job comes back, discard it if it has
+been cancelled. Maybe even be able to cancel disk jobs?../src/peer_connection.cpp:2997
+ std::vector<peer_request>::iterator i
+ = std::find(m_requests.begin(), m_requests.end(), r);
+
+ if (i != m_requests.end())
+ {
+ m_counters.inc_stats_counter(counters::cancelled_piece_requests);
+ m_requests.erase(i);
+
+ if (m_requests.empty())
+ m_counters.inc_stats_counter(counters::num_peers_up_requests, -1);
+
+#if defined TORRENT_LOGGING
+ peer_log("==> REJECT_PIECE [ piece: %d s: %x l: %x ] cancelled"
+ , r.piece , r.start , r.length);
+#endif
+ write_reject_request(r);
+ }
+ else
+ {
+#if defined TORRENT_LOGGING
+ peer_log("*** GOT CANCEL NOT IN THE QUEUE");
+#endif
}
}
- bool peer_list::is_connect_candidate(torrent_peer const& p) const
- {
- TORRENT_ASSERT(is_single_thread());
- TORRENT_ASSERT(p.in_use);
- if (p.connection
- || p.banned
- || p.web_seed
- || !p.connectable
- || (p.seed && m_finished)
- || int(p.failcount) >= 3)
- return false;
-
- return true;
- }
+ // -----------------------------
+ // --------- DHT PORT ----------
+ // -----------------------------
- void peer_list::find_connect_candidates(std::vector<torrent_peer*>& peers, int session_time, torrent_state* state)
+ void peer_connection::incoming_dht_port(int listen_port)
{
TORRENT_ASSERT(is_single_thread());
INVARIANT_CHECK;
- const int candidate_count = 10;
- peers.reserve(candidate_count);
+#if defined TORRENT_LOGGING
+ peer_log("<== DHT_PORT [ p: %d ]", listen_port);
+#endif
+#ifndef TORRENT_DISABLE_DHT
+ m_ses.add_dht_node(udp::endpoint(
+ m_remote.address(), listen_port));
+#endif
+ }
- int erase_candidate = -1;
+ // -----------------------------
+ // --------- HAVE ALL ----------
+ // -----------------------------
- if (m_finished != state->is_finished)
- recalculate_connect_candidates(state);
+ void peer_connection::incoming_have_all()
+ {
+ TORRENT_ASSERT(is_single_thread());
+ | ||
| relevance 2 | ../src/peer_connection.cpp:4602 | use a deadline_timer for timeouts. Don't rely on second_tick()! Hook this up to connect timeout as well. This would improve performance because of less work in second_tick(), and might let use remove ticking entirely eventually |
use a deadline_timer for timeouts. Don't rely on second_tick()!
+Hook this up to connect timeout as well. This would improve performance
+because of less work in second_tick(), and might let use remove ticking
+entirely eventually../src/peer_connection.cpp:4602 if (is_i2p(*m_socket))
+ connect_timeout += 20;
+#endif
- external_ip const& external = *state->ip;
- int external_port = state->port;
+ if (d > seconds(connect_timeout)
+ && can_disconnect(error_code(errors::timed_out, get_libtorrent_category())))
+ {
+#if defined TORRENT_LOGGING
+ peer_log("*** CONNECT FAILED [ waited %d seconds ] ***", int(total_seconds(d)));
+#endif
+ connect_failed(errors::timed_out);
+ return;
+ }
+ }
- if (m_round_robin >= int(m_peers.size())) m_round_robin = 0;
+ // if we can't read, it means we're blocked on the rate-limiter
+ // or the disk, not the peer itself. In this case, don't blame
+ // the peer and disconnect it
+ bool may_timeout = (m_channel_state[download_channel] & peer_info::bw_network) != 0;
- int max_peerlist_size = state->max_peerlist_size;
-
- for (int iterations = (std::min)(int(m_peers.size()), 300);
- iterations > 0; --iterations)
+ if (may_timeout && d > seconds(timeout()) && !m_connecting && m_reading_bytes == 0
+ && can_disconnect(error_code(errors::timed_out_inactivity, get_libtorrent_category())))
{
- ++state->loop_counter;
+#if defined TORRENT_LOGGING
+ peer_log("*** LAST ACTIVITY [ %d seconds ago ] ***", int(total_seconds(d)));
+#endif
+ disconnect(errors::timed_out_inactivity, op_bittorrent);
+ return;
+ }
- | ||
| relevance 3 | ../src/web_peer_connection.cpp:628 | just make this peer not have the pieces associated with the file we just requested. Only when it doesn't have any of the file do the following |
just make this peer not have the pieces
+ // do not stall waiting for a handshake
+ if (may_timeout
+ && !m_connecting
+ && in_handshake()
+ && d > seconds(m_settings.get_int(settings_pack::handshake_timeout)))
+ {
+#if defined TORRENT_LOGGING
+ peer_log("*** NO HANDSHAKE [ waited %d seconds ] ***", int(total_seconds(d)));
+#endif
+ disconnect(errors::timed_out_no_handshake, op_bittorrent);
+ return;
+ }
+
+ // disconnect peers that we unchoked, but
+ // they didn't send a request within 60 seconds.
+ // but only if we're a seed
+ d = now - (std::max)(m_last_unchoke, m_last_incoming_request);
+ if (may_timeout
+ && !m_connecting
+ && m_requests.empty()
+ && m_reading_bytes == 0
+ | ||
| relevance 2 | ../src/piece_picker.cpp:2484 | the first_block returned here is the largest free range, not the first-fit range, which would be better |
the first_block returned here is the largest free range, not
+the first-fit range, which would be better../src/piece_picker.cpp:2484 TORRENT_ASSERT(i->peer == 0 || static_cast<torrent_peer*>(i->peer)->in_use);
+ }
+ }
+#endif
+
+ void piece_picker::clear_peer(void* peer)
+ {
+ for (std::vector<block_info>::iterator i = m_block_info.begin()
+ , end(m_block_info.end()); i != end; ++i)
+ {
+ if (i->peer == peer) i->peer = 0;
+ }
+ }
+
+ namespace
+ {
+ // the first bool is true if this is the only peer that has requested and downloaded
+ // blocks from this piece.
+ // the second bool is true if this is the only active peer that is requesting
+ // and downloading blocks from this piece. Active means having a connection.
+ boost::tuple<bool, bool, int, int> requested_from(
+ piece_picker::downloading_piece const& p
+ , int num_blocks_in_piece, void* peer)
+ {
+ bool exclusive = true;
+ bool exclusive_active = true;
+ int contiguous_blocks = 0;
+ int max_contiguous = 0;
+ int first_block = 0;
+ for (int j = 0; j < num_blocks_in_piece; ++j)
+ {
+ piece_picker::block_info const& info = p.info[j];
+ TORRENT_ASSERT(info.peer == 0 || static_cast<torrent_peer*>(info.peer)->in_use);
+ TORRENT_ASSERT(info.piece_index == p.index);
+ if (info.state == piece_picker::block_info::state_none)
+ {
+ ++contiguous_blocks;
+ continue;
+ }
+ if (contiguous_blocks > max_contiguous)
+ {
+ max_contiguous = contiguous_blocks;
+ first_block = j - contiguous_blocks;
+ }
+ contiguous_blocks = 0;
+ if (info.peer != peer)
+ {
+ exclusive = false;
+ if (info.state == piece_picker::block_info::state_requested
+ && info.peer != 0)
+ {
+ | ||
| relevance 2 | ../src/piece_picker.cpp:3303 | it would be nice if this could be folded into lock_piece() the main distinction is that this also maintains the m_num_passed counter and the passed_hash_check member |
it would be nice if this could be folded into lock_piece()
+the main distinction is that this also maintains the m_num_passed
+counter and the passed_hash_check member../src/piece_picker.cpp:3303 int state = m_piece_map[piece].download_queue();
+ if (state == piece_pos::piece_open) return;
+ std::vector<downloading_piece>::iterator i = find_dl_piece(state, piece);
+ if (i == m_downloads[state].end()) return;
+
+ TORRENT_ASSERT(i->passed_hash_check == false);
+ if (i->passed_hash_check)
+ {
+ // it's not clear why this would happen,
+ // but it seems reasonable to not break the
+ // accounting over it.
+ i->passed_hash_check = false;
+ TORRENT_ASSERT(m_num_passed > 0);
+ --m_num_passed;
+ }
+
+ // prevent this piece from being picked until it's restored
+ i->locked = true;
+ }
+
+ void piece_picker::write_failed(piece_block block)
+ {
+ TORRENT_PIECE_PICKER_INVARIANT_CHECK;
+
+#if TORRENT_USE_INVARIANT_CHECKS
+ check_piece_state();
+#endif
+
+#ifdef TORRENT_PICKER_LOG
+ std::cerr << "[" << this << "] " << "write_failed( {" << block.piece_index << ", " << block.block_index << "} )" << std::endl;
+#endif
+
+ int state = m_piece_map[block.piece_index].download_queue();
+ if (state == piece_pos::piece_open) return;
+ std::vector<downloading_piece>::iterator i = find_dl_piece(state, block.piece_index);
+ if (i == m_downloads[state].end()) return;
+
+ block_info& info = i->info[block.block_index];
+ TORRENT_ASSERT(&info >= &m_block_info[0]);
+ TORRENT_ASSERT(&info < &m_block_info[0] + m_block_info.size());
+ TORRENT_ASSERT(info.piece_index == block.piece_index);
+ TORRENT_ASSERT(info.state == block_info::state_writing);
+ TORRENT_ASSERT(info.num_peers == 0);
+
+ TORRENT_ASSERT(i->writing > 0);
+ TORRENT_ASSERT(info.state == block_info::state_writing);
+
+ if (info.state == block_info::state_finished) return;
+ if (info.state == block_info::state_writing) --i->writing;
+
+ info.peer = 0;
+ | ||
| relevance 2 | ../src/session_impl.cpp:216 | find a better place for this function |
find a better place for this function../src/session_impl.cpp:216 *j.vec, j.peer->make_write_handler(boost::bind(
+ &peer_connection::on_send_data, j.peer, _1, _2)));
+ }
+ else
+ {
+ if (j.recv_buf)
+ {
+ j.peer->get_socket()->async_read_some(asio::buffer(j.recv_buf, j.buf_size)
+ , j.peer->make_read_handler(boost::bind(
+ &peer_connection::on_receive_data, j.peer, _1, _2)));
+ }
+ else
+ {
+ j.peer->get_socket()->async_read_some(j.read_vec
+ , j.peer->make_read_handler(boost::bind(
+ &peer_connection::on_receive_data, j.peer, _1, _2)));
+ }
+ }
+}
+
+proxy_settings::proxy_settings(aux::session_settings const& sett)
+ {
+ hostname = sett.get_str(settings_pack::proxy_hostname);
+ username = sett.get_str(settings_pack::proxy_username);
+ password = sett.get_str(settings_pack::proxy_password);
+ type = sett.get_int(settings_pack::proxy_type);
+ port = sett.get_int(settings_pack::proxy_port);
+ proxy_hostnames = sett.get_bool(settings_pack::proxy_hostnames);
+ proxy_peer_connections = sett.get_bool(
+ settings_pack::proxy_peer_connections);
+}
+
+namespace aux {
+
+ void session_impl::init_peer_class_filter(bool unlimited_local)
+ {
+ // set the default peer_class_filter to use the local peer class
+ // for peers on local networks
+ boost::uint32_t lfilter = 1 << m_local_peer_class;
+ boost::uint32_t gfilter = 1 << m_global_class;
+
+ struct class_mapping
+ {
+ char const* first;
+ char const* last;
+ boost::uint32_t filter;
+ };
+
+ const static class_mapping v4_classes[] =
+ {
+ // everything
+ | ||
| relevance 2 | ../src/session_impl.cpp:1813 | the udp socket(s) should be using the same generic mechanism and not be restricted to a single one we should open a one listen socket for each entry in the listen_interfaces list |
the udp socket(s) should be using the same generic
+mechanism and not be restricted to a single one
+we should open a one listen socket for each entry in the
+listen_interfaces list../src/session_impl.cpp:1813 }
+#endif // TORRENT_USE_OPENSSL
+ }
+#endif // TORRENT_USE_IPV6
+
+ // set our main IPv4 and IPv6 interfaces
+ // used to send to the tracker
+ std::vector<ip_interface> ifs = enum_net_interfaces(m_io_service, ec);
+ for (std::vector<ip_interface>::const_iterator i = ifs.begin()
+ , end(ifs.end()); i != end; ++i)
+ {
+ address const& addr = i->interface_address;
+ if (addr.is_v6() && !is_local(addr) && !is_loopback(addr))
+ m_ipv6_interface = tcp::endpoint(addr, m_listen_interface.port());
+ else if (addr.is_v4() && !is_local(addr) && !is_loopback(addr))
+ m_ipv4_interface = tcp::endpoint(addr, m_listen_interface.port());
+ }
+ }
+ else
+ {
+ for (int i = 0; i < m_listen_interfaces.size(); ++i)
+ {
+ std::string const& device = m_listen_interfaces[i].first;
+ int port = m_listen_interfaces[i].second;
+
+ int num_device_fails = 0;
+
+#if TORRENT_USE_IPV6
+ const int first_family = 0;
+#else
+ const int first_family = 1;
+#endif
+ for (int address_family = first_family; address_family < 2; ++address_family)
+ {
+ error_code err;
+ address test_family = address::from_string(device.c_str(), err);
+ if (!err && test_family.is_v4() != address_family)
+ continue;
+
+ listen_socket_t s = setup_listener(device, address_family, port
+ , m_listen_port_retries, flags, ec);
+
+ if (ec == error_code(boost::system::errc::no_such_device, generic_category()))
+ {
+ ++num_device_fails;
+ continue;
+ }
+
+ if (s.sock)
+ {
+ TORRENT_ASSERT(!m_abort);
+ | ||
| relevance 2 | ../src/session_impl.cpp:1915 | use bind_to_device in udp_socket |
use bind_to_device in udp_socket../src/session_impl.cpp:1915 if (m_listen_port_retries > 0)
+ {
+ m_listen_interface.port(m_listen_interface.port() + 1);
+ --m_listen_port_retries;
+ goto retry;
+ }
+ if (m_alerts.should_post<listen_failed_alert>())
+ m_alerts.post_alert(listen_failed_alert(print_endpoint(m_listen_interface)
+ , listen_failed_alert::bind, ec, listen_failed_alert::udp));
+ return;
+ }
+
+#ifdef TORRENT_USE_OPENSSL
+ int ssl_port = m_settings.get_int(settings_pack::ssl_listen);
+
+ // if ssl port is 0, we don't want to listen on an SSL port
+ if (ssl_port != 0)
+ {
+ udp::endpoint ssl_bind_if(m_listen_interface.address(), ssl_port);
+
+ m_ssl_udp_socket.bind(ssl_bind_if, ec);
+ if (ec)
+ {
+#if defined TORRENT_LOGGING
+ session_log("SSL: cannot bind to UDP interface \"%s\": %s"
+ , print_endpoint(m_listen_interface).c_str(), ec.message().c_str());
+#endif
+ if (m_alerts.should_post<listen_failed_alert>())
+ {
+ error_code err;
+ m_alerts.post_alert(listen_failed_alert(print_endpoint(ssl_bind_if)
+ , listen_failed_alert::bind, ec, listen_failed_alert::utp_ssl));
+ }
+ ec.clear();
+ }
+ else
+ {
+ if (m_alerts.should_post<listen_succeeded_alert>())
+ m_alerts.post_alert(listen_succeeded_alert(
+ tcp::endpoint(ssl_bind_if.address(), ssl_bind_if.port())
+ , listen_succeeded_alert::utp_ssl));
+ }
+ }
+#endif // TORRENT_USE_OPENSSL
+
+ | ||
| relevance 2 | ../src/session_impl.cpp:1941 | use bind_to_device in udp_socket |
use bind_to_device in udp_socket../src/session_impl.cpp:1941 , print_endpoint(m_listen_interface).c_str(), ec.message().c_str());
+#endif
+ if (m_alerts.should_post<listen_failed_alert>())
+ {
+ error_code err;
+ m_alerts.post_alert(listen_failed_alert(print_endpoint(ssl_bind_if)
+ , listen_failed_alert::bind, ec, listen_failed_alert::utp_ssl));
+ }
+ ec.clear();
+ }
+ else
+ {
+ if (m_alerts.should_post<listen_succeeded_alert>())
+ m_alerts.post_alert(listen_succeeded_alert(
+ tcp::endpoint(ssl_bind_if.address(), ssl_bind_if.port())
+ , listen_succeeded_alert::utp_ssl));
+ }
+ }
+#endif // TORRENT_USE_OPENSSL
+
+ m_udp_socket.bind(udp::endpoint(m_listen_interface.address(), m_listen_interface.port()), ec);
+ if (ec)
+ {
+#if defined TORRENT_LOGGING
+ session_log("cannot bind to UDP interface \"%s\": %s"
+ , print_endpoint(m_listen_interface).c_str(), ec.message().c_str());
+#endif
+ if (m_listen_port_retries > 0)
+ {
+ m_listen_interface.port(m_listen_interface.port() + 1);
+ --m_listen_port_retries;
+ goto retry;
+ }
+ if (m_alerts.should_post<listen_failed_alert>())
+ {
+ error_code err;
+ m_alerts.post_alert(listen_failed_alert(print_endpoint(m_listen_interface)
+ , listen_failed_alert::bind, ec, listen_failed_alert::udp));
+ }
+ return;
+ }
+ else
+ {
+ m_external_udp_port = m_udp_socket.local_port();
+ maybe_update_udp_mapping(0, m_listen_interface.port(), m_listen_interface.port());
+ maybe_update_udp_mapping(1, m_listen_interface.port(), m_listen_interface.port());
+ if (m_alerts.should_post<listen_succeeded_alert>())
+ m_alerts.post_alert(listen_succeeded_alert(m_listen_interface, listen_succeeded_alert::udp));
+ }
+
+ if (m_settings.get_int(settings_pack::peer_tos) != 0)
+ | ||
| relevance 2 | ../src/session_impl.cpp:3388 | make a list for torrents that want to be announced on the DHT so we don't have to loop over all torrents, just to find the ones that want to announce |
make a list for torrents that want to be announced on the DHT so we
+don't have to loop over all torrents, just to find the ones that want to announce../src/session_impl.cpp:3388 if (!m_dht_torrents.empty())
+ {
+ boost::shared_ptr<torrent> t;
+ do
+ {
+ t = m_dht_torrents.front().lock();
+ m_dht_torrents.pop_front();
+ } while (!t && !m_dht_torrents.empty());
+
+ if (t)
+ {
+ t->dht_announce();
+ return;
+ }
+ }
+ if (m_torrents.empty()) return;
+
+ if (m_next_dht_torrent == m_torrents.end())
+ m_next_dht_torrent = m_torrents.begin();
+ m_next_dht_torrent->second->dht_announce();
+ ++m_next_dht_torrent;
+ if (m_next_dht_torrent == m_torrents.end())
+ m_next_dht_torrent = m_torrents.begin();
+ }
+#endif
+
+ void session_impl::on_lsd_announce(error_code const& e)
+ {
+#if defined TORRENT_ASIO_DEBUGGING
+ complete_async("session_impl::on_lsd_announce");
+#endif
+ m_stats_counters.inc_stats_counter(counters::on_lsd_counter);
+ TORRENT_ASSERT(is_single_thread());
+ if (e) return;
+
+ if (m_abort) return;
+
+#if defined TORRENT_ASIO_DEBUGGING
+ add_outstanding_async("session_impl::on_lsd_announce");
+#endif
+ // announce on local network every 5 minutes
+ int delay = (std::max)(m_settings.get_int(settings_pack::local_service_announce_interval)
+ / (std::max)(int(m_torrents.size()), 1), 1);
+ error_code ec;
+ m_lsd_announce_timer.expires_from_now(seconds(delay), ec);
+ m_lsd_announce_timer.async_wait(
+ bind(&session_impl::on_lsd_announce, this, _1));
+
+ if (m_torrents.empty()) return;
+
+ if (m_next_lsd_torrent == m_torrents.end())
+ | ||
| relevance 2 | ../src/torrent.cpp:719 | post alert |
post alert../src/torrent.cpp:719 state_updated();
+
+ set_state(torrent_status::downloading);
+
+ m_override_resume_data = true;
+ init();
+ }
+
+#endif // if 0
+
+ void torrent::leave_seed_mode(bool seed)
+ {
+ if (!m_seed_mode) return;
+
+ if (!seed)
+ {
+ // this means the user promised we had all the
+ // files, but it turned out we didn't. This is
+ // an error.
+
+
+ #if defined TORRENT_LOGGING
+ debug_log("*** FAILED SEED MODE, rechecking");
+#endif
+ }
+
+#if defined TORRENT_LOGGING
+ debug_log("*** LEAVING SEED MODE (%s)", seed ? "as seed" : "as non-seed");
+#endif
+ m_seed_mode = false;
+ // seed is false if we turned out not
+ // to be a seed after all
+ if (!seed)
+ {
+ m_have_all = false;
+ set_state(torrent_status::downloading);
+ force_recheck();
+ }
+ m_num_verified = 0;
+ m_verified.clear();
+ m_verifying.clear();
+
+ m_need_save_resume_data = true;
+ }
+
+ void torrent::verified(int piece)
+ {
+ TORRENT_ASSERT(piece < int(m_verified.size()));
+ TORRENT_ASSERT(piece >= 0);
+ TORRENT_ASSERT(m_verified.get_bit(piece) == false);
+ ++m_num_verified;
+ | ||
| relevance 2 | ../src/torrent.cpp:4728 | abort lookups this torrent has made via the session host resolver interface |
abort lookups this torrent has made via the
+session host resolver interface../src/torrent.cpp:4728 // files belonging to the torrents
+ disconnect_all(errors::torrent_aborted, peer_connection_interface::op_bittorrent);
+
+ // post a message to the main thread to destruct
+ // the torrent object from there
+ if (m_storage.get())
+ {
+ inc_refcount("release_files");
+ m_ses.disk_thread().async_stop_torrent(m_storage.get()
+ , boost::bind(&torrent::on_cache_flushed, shared_from_this(), _1));
+ }
+ else
+ {
+ TORRENT_ASSERT(m_abort);
+ if (alerts().should_post<cache_flushed_alert>())
+ alerts().post_alert(cache_flushed_alert(get_handle()));
+ }
+
+ m_storage.reset();
+
+
+ if (!m_apply_ip_filter)
+ {
+ inc_stats_counter(counters::non_filter_torrents, -1);
+ m_apply_ip_filter = true;
+ }
+
+ m_allow_peers = false;
+ m_auto_managed = false;
+ for (int i = 0; i < aux::session_interface::num_torrent_lists; ++i)
+ {
+ if (!m_links[i].in_list()) continue;
+ m_links[i].unlink(m_ses.torrent_list(i), i);
+ }
+ // don't re-add this torrent to the state-update list
+ m_state_subscription = false;
+ }
+
+ void torrent::super_seeding(bool on)
+ {
+ if (on == m_super_seeding) return;
+
+ m_super_seeding = on;
+ m_need_save_resume_data = true;
+
+ if (m_super_seeding) return;
+
+ // disable super seeding for all peers
+ for (peer_iterator i = begin(); i != end(); ++i)
+ {
+ (*i)->superseed_piece(-1, -1);
+ | ||
| relevance 2 | ../src/torrent.cpp:7722 | if peer is a really good peer, maybe we shouldn't disconnect it |
if peer is a really good peer, maybe we shouldn't disconnect it../src/torrent.cpp:7722#if defined TORRENT_LOGGING
+ debug_log("incoming peer (%d)", int(m_connections.size()));
+#endif
+
+#ifdef TORRENT_DEBUG
+ error_code ec;
+ TORRENT_ASSERT(p->remote() == p->get_socket()->remote_endpoint(ec) || ec);
+#endif
+
+ TORRENT_ASSERT(p->peer_info_struct() != NULL);
+
+ // we need to do this after we've added the peer to the peer_list
+ // since that's when the peer is assigned its peer_info object,
+ // which holds the rank
+ if (maybe_replace_peer)
+ {
+ // now, find the lowest rank peer and disconnect that
+ // if it's lower rank than the incoming connection
+ peer_connection* peer = find_lowest_ranking_peer();
+
+ if (peer && peer->peer_rank() < p->peer_rank())
+ {
+ peer->disconnect(errors::too_many_connections, peer_connection_interface::op_bittorrent);
+ p->peer_disconnected_other();
+ }
+ else
+ {
+ p->disconnect(errors::too_many_connections, peer_connection_interface::op_bittorrent);
+ // we have to do this here because from the peer's point of
+ // it wasn't really attached to the torrent, but we do need
+ // to let peer_list know we're removing it
+ remove_peer(p);
+ return false;
+ }
+ }
+
+#if TORRENT_USE_INVARIANT_CHECKS
+ if (m_peer_list) m_peer_list->check_invariant();
+#endif
+
+ if (m_share_mode)
+ recalc_share_mode();
+
+ return true;
+ }
+
+ bool torrent::want_tick() const
+ {
+ if (m_abort) return false;
+
+ if (!m_connections.empty()) return true;
+ | ||
| relevance 2 | ../src/tracker_manager.cpp:196 | some of these arguments could probably be moved to the tracker request itself. like the ip_filter and settings |
some of these arguments could probably be moved to the
+tracker request itself. like the ip_filter and settings../src/tracker_manager.cpp:196 , interval == 0 ? min_interval : interval);
+ close();
+ }
+
+ void tracker_connection::sent_bytes(int bytes)
+ {
+ m_man.sent_bytes(bytes);
+ }
+
+ void tracker_connection::received_bytes(int bytes)
+ {
+ m_man.received_bytes(bytes);
+ }
+
+ void tracker_connection::close()
+ {
+ cancel();
+ m_man.remove_request(this);
+ }
+
+ tracker_manager::tracker_manager(class udp_socket& sock
+ , counters& stats_counters
+ , resolver_interface& resolver
+ , struct ip_filter& ipf
+ , aux::session_settings const& sett
+#if defined TORRENT_LOGGING || TORRENT_USE_ASSERTS
+ , aux::session_logger& ses
+#endif
+ )
+ : m_ip_filter(ipf)
+ , m_udp_socket(sock)
+ , m_host_resolver(resolver)
+ , m_settings(sett)
+ , m_stats_counters(stats_counters)
+#if defined TORRENT_LOGGING || TORRENT_USE_ASSERTS
+ , m_ses(ses)
+#endif
+ , m_abort(false)
+ {}
+
+ tracker_manager::~tracker_manager()
+ {
+ TORRENT_ASSERT(m_abort);
+ abort_all_requests(true);
+ }
+
+ void tracker_manager::sent_bytes(int bytes)
+ {
+ TORRENT_ASSERT(m_ses.is_single_thread());
+ m_stats_counters.inc_stats_counter(counters::sent_tracker_bytes, bytes);
+ }
+ | ||
| relevance 2 | ../src/udp_tracker_connection.cpp:86 | support authentication here. tracker_req().auth |
support authentication here. tracker_req().auth../src/udp_tracker_connection.cpp:86 udp_tracker_connection::m_connection_cache;
+
+ mutex udp_tracker_connection::m_cache_mutex;
+
+ udp_tracker_connection::udp_tracker_connection(
+ io_service& ios
+ , tracker_manager& man
+ , tracker_request const& req
+ , boost::weak_ptr<request_callback> c)
+ : tracker_connection(man, req, ios, c)
+ , m_transaction_id(0)
+ , m_attempts(0)
+ , m_state(action_error)
+ , m_abort(false)
+ {
+ update_transaction_id();
+ }
+
+ void udp_tracker_connection::start()
+ {
+ std::string hostname;
+ std::string protocol;
+ int port;
+ error_code ec;
+
+ using boost::tuples::ignore;
+ boost::tie(protocol, ignore, hostname, port, ignore)
+ = parse_url_components(tracker_req().url, ec);
+ if (port == -1) port = protocol == "http" ? 80 : 443;
+
+ if (ec)
+ {
+ tracker_connection::fail(ec);
+ return;
+ }
+
+ aux::session_settings const& settings = m_man.settings();
+
+ if (settings.get_bool(settings_pack::proxy_hostnames)
+ && (settings.get_int(settings_pack::proxy_type) == settings_pack::socks5
+ || settings.get_int(settings_pack::proxy_type) == settings_pack::socks5_pw))
+ {
+ m_hostname = hostname;
+ m_target.port(port);
+ start_announce();
+ }
+ else
+ {
+#if defined TORRENT_ASIO_DEBUGGING
+ add_outstanding_async("udp_tracker_connection::name_lookup");
+#endif
+ | ||
| relevance 2 | ../src/utp_stream.cpp:348 | it would be nice if not everything would have to be public here |
it would be nice if not everything would have to be public here../src/utp_stream.cpp:348 void incoming(boost::uint8_t const* buf, int size, packet* p, ptime now);
+ void do_ledbat(int acked_bytes, int delay, int in_flight);
+ int packet_timeout() const;
+ bool test_socket_state();
+ void maybe_trigger_receive_callback();
+ void maybe_trigger_send_callback();
+ bool cancel_handlers(error_code const& ec, bool kill);
+ bool consume_incoming_data(
+ utp_header const* ph, boost::uint8_t const* ptr, int payload_size, ptime now);
+ void update_mtu_limits();
+ void experienced_loss(int seq_nr);
+
+ void set_state(int s);
+
+private:
+
+ // non-copyable
+ utp_socket_impl(utp_socket_impl const&);
+ utp_socket_impl const& operator=(utp_socket_impl const&);
+
+public:
+
+ void check_receive_buffers() const;
+
+#if TORRENT_USE_INVARIANT_CHECKS
+ void check_invariant() const;
+#endif
+
+ utp_socket_manager* m_sm;
+
+ // userdata pointer passed along
+ // with any callback. This is initialized to 0
+ // then set to point to the utp_stream when
+ // hooked up, and then reset to 0 once the utp_stream
+ // detaches. This is used to know whether or not
+ // the socket impl is still attached to a utp_stream
+ // object. When it isn't, we'll never be able to
+ // signal anything back to the client, and in case
+ // of errors, we just have to delete ourselves
+ // i.e. transition to the UTP_STATE_DELETED state
+ void* m_userdata;
+
+ // This is a platform-independent replacement
+ // for the regular iovec type in posix. Since
+ // it's not used in any system call, we might as
+ // well define our own type instead of wrapping
+ // the system's type.
+ struct iovec_t
+ {
+ iovec_t(void* b, size_t l): buf(b), len(l) {}
+ void* buf;
+ | ||
| relevance 2 | ../src/web_peer_connection.cpp:628 | just make this peer not have the pieces associated with the file we just requested. Only when it doesn't have any of the file do the following |
just make this peer not have the pieces
associated with the file we just requested. Only
when it doesn't have any of the file do the following../src/web_peer_connection.cpp:628 {
++m_num_responses;
@@ -181,885 +1064,6 @@ when it doesn't have any of the file do the following../src/web_peer_co
{
// we should not try this server again.
t->remove_web_seed(this, errors::missing_location, op_bittorrent, 2);
- | ||
| relevance 3 | ../src/kademlia/get_item.cpp:220 | we don't support CAS errors here! we need a custom observer |
we don't support CAS errors here! we need a custom observer../src/kademlia/get_item.cpp:220 TORRENT_LOG(node) << "sending put [ v: \"" << m_data.value()
- << "\" seq: " << (m_data.is_mutable() ? m_data.seq() : -1)
- << " nodes: " << v.size() << " ]" ;
-#endif
-
- // create a dummy traversal_algorithm
- boost::intrusive_ptr<traversal_algorithm> algo(
- new traversal_algorithm(m_node, (node_id::min)()));
-
- // store on the first k nodes
- for (std::vector<std::pair<node_entry, std::string> >::const_iterator i = v.begin()
- , end(v.end()); i != end; ++i)
- {
-#ifdef TORRENT_DHT_VERBOSE_LOGGING
- TORRENT_LOG(node) << " put-distance: " << (160 - distance_exp(m_target, i->first.id));
-#endif
-
- void* ptr = m_node.m_rpc.allocate_observer();
- if (ptr == 0) return;
-
- observer_ptr o(new (ptr) announce_observer(algo, i->first.ep(), i->first.id));
- #if TORRENT_USE_ASSERTS
- o->m_in_constructor = false;
-#endif
- entry e;
- e["y"] = "q";
- e["q"] = "put";
- entry& a = e["a"];
- a["v"] = m_data.value();
- a["token"] = i->second;
- if (m_data.is_mutable())
- {
- a["k"] = std::string(m_data.pk().data(), item_pk_len);
- a["seq"] = m_data.seq();
- a["sig"] = std::string(m_data.sig().data(), item_sig_len);
- if (!m_data.salt().empty())
- {
- a["salt"] = m_data.salt();
- }
- }
- m_node.m_rpc.invoke(e, i->first.ep(), o);
- }
-}
-
-void get_item_observer::reply(msg const& m)
-{
- char const* pk = NULL;
- char const* sig = NULL;
- boost::uint64_t seq = 0;
-
- lazy_entry const* r = m.message.dict_find_dict("r");
- | ||
| relevance 3 | ../include/libtorrent/file_storage.hpp:49 | the file_entry should be deprecated and add_file() should be thought through a bit better |
the file_entry should be deprecated and add_file() should be
-thought through a bit better../include/libtorrent/file_storage.hpp:49POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-#ifndef TORRENT_FILE_STORAGE_HPP_INCLUDED
-#define TORRENT_FILE_STORAGE_HPP_INCLUDED
-
-#include <string>
-#include <vector>
-#include <ctime>
-#include <boost/cstdint.hpp>
-
-#include "libtorrent/assert.hpp"
-#include "libtorrent/peer_request.hpp"
-#include "libtorrent/peer_id.hpp"
-
-namespace libtorrent
-{
- struct file;
-
-
- // information about a file in a file_storage
- struct TORRENT_EXPORT file_entry
- {
- // hidden
- file_entry();
- // hidden
- ~file_entry();
-
- // the full path of this file. The paths are unicode strings
- // encoded in UTF-8.
- std::string path;
-
- // the path which this is a symlink to, or empty if this is
- // not a symlink. This field is only used if the ``symlink_attribute`` is set.
- std::string symlink_path;
-
- // the offset of this file inside the torrent
- boost::int64_t offset;
-
- // the size of the file (in bytes) and ``offset`` is the byte offset
- // of the file within the torrent. i.e. the sum of all the sizes of the files
- // before it in the list.
- boost::int64_t size;
-
- // the offset in the file where the storage should start. The normal
- // case is to have this set to 0, so that the storage starts saving data at the start
- // if the file. In cases where multiple files are mapped into the same file though,
- // the ``file_base`` should be set to an offset so that the different regions do
- // not overlap. This is used when mapping "unselected" files into a so-called part
- // file.
- | ||
| relevance 3 | ../include/libtorrent/session_status.hpp:87 | add accessors to query the DHT state (post the result as an alert) holds dht routing table stats |
add accessors to query the DHT state (post the result as an alert)
-holds dht routing table stats../include/libtorrent/session_status.hpp:87
- // the number of nodes left that could be queries for this
- // lookup. Many of these are likely to be part of the trail
- // while performing the lookup and would never end up actually
- // being queried.
- int nodes_left;
-
- // the number of seconds ago the
- // last message was sent that's still
- // outstanding
- int last_sent;
-
- // the number of outstanding requests
- // that have exceeded the short timeout
- // and are considered timed out in the
- // sense that they increased the branch
- // factor
- int first_timeout;
- };
-
- struct TORRENT_EXPORT dht_routing_bucket
- {
- // the total number of nodes and replacement nodes
- // in the routing table
- int num_nodes;
- int num_replacements;
-
- // number of seconds since last activity
- int last_active;
- };
-
-#ifndef TORRENT_NO_DEPRECATE
- // holds counters and gauges for the uTP sockets
- // deprecated in 1.1 in favor of session_stats counters, which is a more
- // flexible, extensible and perfromant mechanism for stats.
- struct TORRENT_EXPORT utp_status
- {
- // gauges. These are snapshots of the number of
- // uTP sockets in each respective state
- int num_idle;
- int num_syn_sent;
- int num_connected;
- int num_fin_sent;
- int num_close_wait;
-
- // These are monotonically increasing
- // and cumulative counters for their respective event.
- boost::uint64_t packet_loss;
- boost::uint64_t timeout;
- boost::uint64_t packets_in;
- boost::uint64_t packets_out;
- | ||
| relevance 2 | ../src/disk_io_thread.cpp:838 | should this be allocated on the stack? |
should this be allocated on the stack?../src/disk_io_thread.cpp:838 // if we're also flushing the read cache, this piece
- // should be removed as soon as all write jobs finishes
- // otherwise it will turn into a read piece
- }
-
- // mark_for_deletion may erase the piece from the cache, that's
- // why we don't have the 'i' iterator referencing it at this point
- if (flags & (flush_read_cache | flush_delete_cache))
- {
- fail_jobs_impl(storage_error(boost::asio::error::operation_aborted), pe->jobs, completed_jobs);
- m_disk_cache.mark_for_deletion(pe);
- }
- }
-
- void disk_io_thread::flush_cache(piece_manager* storage, boost::uint32_t flags
- , tailqueue& completed_jobs, mutex::scoped_lock& l)
- {
- if (storage)
- {
- boost::unordered_set<cached_piece_entry*> const& pieces = storage->cached_pieces();
- std::vector<int> piece_index;
- piece_index.reserve(pieces.size());
- for (boost::unordered_set<cached_piece_entry*>::const_iterator i = pieces.begin()
- , end(pieces.end()); i != end; ++i)
- {
- if ((*i)->get_storage() != storage) continue;
- piece_index.push_back((*i)->piece);
- }
-
- for (std::vector<int>::iterator i = piece_index.begin()
- , end(piece_index.end()); i != end; ++i)
- {
- cached_piece_entry* pe = m_disk_cache.find_piece(storage, *i);
- if (pe == NULL) continue;
- TORRENT_PIECE_ASSERT(pe->storage.get() == storage, pe);
- flush_piece(pe, flags, completed_jobs, l);
- }
-#if TORRENT_USE_ASSERTS
- TORRENT_ASSERT(l.locked());
- // if the user asked to delete the cache for this storage
- // we really should not have any pieces left. This is only called
- // from disk_io_thread::do_delete, which is a fence job and should
- // have any other jobs active, i.e. there should not be any references
- // keeping pieces or blocks alive
- if ((flags & flush_delete_cache) && (flags & flush_expect_clear))
- {
- boost::unordered_set<cached_piece_entry*> const& storage_pieces = storage->cached_pieces();
- for (boost::unordered_set<cached_piece_entry*>::const_iterator i = storage_pieces.begin()
- , end(storage_pieces.end()); i != end; ++i)
- {
- cached_piece_entry* pe = m_disk_cache.find_piece(storage, (*i)->piece);
- | ||
| relevance 2 | ../src/file_storage.cpp:482 | it would be nice if file_entry::filehash could be taken into account as well, and if the file_storage object could actually hold copies of filehash |
it would be nice if file_entry::filehash could be taken into
-account as well, and if the file_storage object could actually hold
-copies of filehash../src/file_storage.cpp:482 e.executable_attribute = (flags & attribute_executable) != 0;
- if ((flags & attribute_symlink) && m_symlinks.size() < internal_file_entry::not_a_symlink - 1)
- {
- e.symlink_attribute = 1;
- e.symlink_index = m_symlinks.size();
- m_symlinks.push_back(symlink_path);
- }
- else
- e.symlink_attribute = 0;
-
- if (mtime)
- {
- if (m_mtime.size() < m_files.size()) m_mtime.resize(m_files.size());
- m_mtime[m_files.size() - 1] = mtime;
- }
-
- update_path_index(e);
- m_total_size += size;
- }
-
- void file_storage::add_file(file_entry const& ent, char const* filehash)
- {
- TORRENT_ASSERT_PRECOND(ent.size >= 0);
- if (!has_parent_path(ent.path))
- {
- // you have already added at least one file with a
- // path to the file (branch_path), which means that
- // all the other files need to be in the same top
- // directory as the first file.
- TORRENT_ASSERT_PRECOND(m_files.empty());
- m_name = ent.path;
- }
- else
- {
- if (m_files.empty())
- m_name = split_path(ent.path).c_str();
- }
- internal_file_entry ife(ent);
- int file_index = m_files.size();
- m_files.push_back(ife);
- ++m_num_files;
- internal_file_entry& e = m_files.back();
- e.offset = m_total_size;
- m_total_size += e.size;
- if (filehash)
- {
- if (m_file_hashes.size() < m_files.size()) m_file_hashes.resize(m_files.size());
- m_file_hashes[m_files.size() - 1] = filehash;
- }
- if (!ent.symlink_path.empty() && m_symlinks.size() < internal_file_entry::not_a_symlink - 1)
- {
- | ||
| relevance 2 | ../src/peer_connection.cpp:2992 | since we throw away the queue entry once we issue the disk job, this may happen. Instead, we should keep the queue entry around, mark it as having been requested from disk and once the disk job comes back, discard it if it has been cancelled. Maybe even be able to cancel disk jobs? |
since we throw away the queue entry once we issue
-the disk job, this may happen. Instead, we should keep the
-queue entry around, mark it as having been requested from
-disk and once the disk job comes back, discard it if it has
-been cancelled. Maybe even be able to cancel disk jobs?../src/peer_connection.cpp:2992
- std::vector<peer_request>::iterator i
- = std::find(m_requests.begin(), m_requests.end(), r);
-
- if (i != m_requests.end())
- {
- m_counters.inc_stats_counter(counters::cancelled_piece_requests);
- m_requests.erase(i);
-
- if (m_requests.empty())
- m_counters.inc_stats_counter(counters::num_peers_up_requests, -1);
-
-#if defined TORRENT_LOGGING
- peer_log("==> REJECT_PIECE [ piece: %d s: %x l: %x ] cancelled"
- , r.piece , r.start , r.length);
-#endif
- write_reject_request(r);
- }
- else
- {
-#if defined TORRENT_LOGGING
- peer_log("*** GOT CANCEL NOT IN THE QUEUE");
-#endif
- }
- }
-
- // -----------------------------
- // --------- DHT PORT ----------
- // -----------------------------
-
- void peer_connection::incoming_dht_port(int listen_port)
- {
- TORRENT_ASSERT(is_single_thread());
- INVARIANT_CHECK;
-
-#if defined TORRENT_LOGGING
- peer_log("<== DHT_PORT [ p: %d ]", listen_port);
-#endif
-#ifndef TORRENT_DISABLE_DHT
- m_ses.add_dht_node(udp::endpoint(
- m_remote.address(), listen_port));
-#endif
- }
-
- // -----------------------------
- // --------- HAVE ALL ----------
- // -----------------------------
-
- void peer_connection::incoming_have_all()
- {
- TORRENT_ASSERT(is_single_thread());
- | ||
| relevance 2 | ../src/peer_connection.cpp:4596 | use a deadline_timer for timeouts. Don't rely on second_tick()! Hook this up to connect timeout as well. This would improve performance because of less work in second_tick(), and might let use remove ticking entirely eventually |
use a deadline_timer for timeouts. Don't rely on second_tick()!
-Hook this up to connect timeout as well. This would improve performance
-because of less work in second_tick(), and might let use remove ticking
-entirely eventually../src/peer_connection.cpp:4596 if (is_i2p(*m_socket))
- connect_timeout += 20;
-#endif
-
- if (d > seconds(connect_timeout)
- && can_disconnect(error_code(errors::timed_out, get_libtorrent_category())))
- {
-#if defined TORRENT_LOGGING
- peer_log("*** CONNECT FAILED [ waited %d seconds ] ***", int(total_seconds(d)));
-#endif
- connect_failed(errors::timed_out);
- return;
- }
- }
-
- // if we can't read, it means we're blocked on the rate-limiter
- // or the disk, not the peer itself. In this case, don't blame
- // the peer and disconnect it
- bool may_timeout = (m_channel_state[download_channel] & peer_info::bw_network) != 0;
-
- if (may_timeout && d > seconds(timeout()) && !m_connecting && m_reading_bytes == 0
- && can_disconnect(error_code(errors::timed_out_inactivity, get_libtorrent_category())))
- {
-#if defined TORRENT_LOGGING
- peer_log("*** LAST ACTIVITY [ %d seconds ago ] ***", int(total_seconds(d)));
-#endif
- disconnect(errors::timed_out_inactivity, op_bittorrent);
- return;
- }
-
- // do not stall waiting for a handshake
- if (may_timeout
- && !m_connecting
- && in_handshake()
- && d > seconds(m_settings.get_int(settings_pack::handshake_timeout)))
- {
-#if defined TORRENT_LOGGING
- peer_log("*** NO HANDSHAKE [ waited %d seconds ] ***", int(total_seconds(d)));
-#endif
- disconnect(errors::timed_out_no_handshake, op_bittorrent);
- return;
- }
-
- // disconnect peers that we unchoked, but
- // they didn't send a request within 60 seconds.
- // but only if we're a seed
- d = now - (std::max)(m_last_unchoke, m_last_incoming_request);
- if (may_timeout
- && !m_connecting
- && m_requests.empty()
- && m_reading_bytes == 0
- | ||
| relevance 2 | ../src/piece_picker.cpp:3166 | it would be nice if this could be folded into lock_piece() the main distinction is that this also maintains the m_num_passed counter and the passed_hash_check member |
it would be nice if this could be folded into lock_piece()
-the main distinction is that this also maintains the m_num_passed
-counter and the passed_hash_check member../src/piece_picker.cpp:3166 int state = m_piece_map[piece].state;
- if (state == piece_pos::piece_open) return;
- std::vector<downloading_piece>::iterator i = find_dl_piece(state - 1, piece);
- if (i == m_downloads[state - 1].end()) return;
-
- TORRENT_ASSERT(i->passed_hash_check == false);
- if (i->passed_hash_check)
- {
- // it's not clear why this would happen,
- // but it seems reasonable to not break the
- // accounting over it.
- i->passed_hash_check = false;
- TORRENT_ASSERT(m_num_passed > 0);
- --m_num_passed;
- }
-
- // prevent this piece from being picked until it's restored
- i->locked = true;
- }
-
- void piece_picker::write_failed(piece_block block)
- {
- TORRENT_PIECE_PICKER_INVARIANT_CHECK;
-
-#if TORRENT_USE_INVARIANT_CHECKS
- check_piece_state();
-#endif
-
-#ifdef TORRENT_PICKER_LOG
- std::cerr << "[" << this << "] " << "write_failed( {" << block.piece_index << ", " << block.block_index << "} )" << std::endl;
-#endif
-
- int state = m_piece_map[block.piece_index].state;
- if (state == piece_pos::piece_open) return;
- std::vector<downloading_piece>::iterator i = find_dl_piece(state - 1, block.piece_index);
- if (i == m_downloads[state - 1].end()) return;
-
- block_info& info = i->info[block.block_index];
- TORRENT_ASSERT(&info >= &m_block_info[0]);
- TORRENT_ASSERT(&info < &m_block_info[0] + m_block_info.size());
- TORRENT_ASSERT(info.piece_index == block.piece_index);
- TORRENT_ASSERT(info.state == block_info::state_writing);
- TORRENT_ASSERT(info.num_peers == 0);
-
- TORRENT_ASSERT(i->writing > 0);
- TORRENT_ASSERT(info.state == block_info::state_writing);
-
- if (info.state == block_info::state_finished) return;
- if (info.state == block_info::state_writing) --i->writing;
-
- info.peer = 0;
- | ||
| relevance 2 | ../src/session_impl.cpp:216 | find a better place for this function |
find a better place for this function../src/session_impl.cpp:216 *j.vec, j.peer->make_write_handler(boost::bind(
- &peer_connection::on_send_data, j.peer, _1, _2)));
- }
- else
- {
- if (j.recv_buf)
- {
- j.peer->get_socket()->async_read_some(asio::buffer(j.recv_buf, j.buf_size)
- , j.peer->make_read_handler(boost::bind(
- &peer_connection::on_receive_data, j.peer, _1, _2)));
- }
- else
- {
- j.peer->get_socket()->async_read_some(j.read_vec
- , j.peer->make_read_handler(boost::bind(
- &peer_connection::on_receive_data, j.peer, _1, _2)));
- }
- }
-}
-
-proxy_settings::proxy_settings(aux::session_settings const& sett)
- {
- hostname = sett.get_str(settings_pack::proxy_hostname);
- username = sett.get_str(settings_pack::proxy_username);
- password = sett.get_str(settings_pack::proxy_password);
- type = sett.get_int(settings_pack::proxy_type);
- port = sett.get_int(settings_pack::proxy_port);
- proxy_hostnames = sett.get_bool(settings_pack::proxy_hostnames);
- proxy_peer_connections = sett.get_bool(
- settings_pack::proxy_peer_connections);
-}
-
-namespace aux {
-
- void session_impl::init_peer_class_filter(bool unlimited_local)
- {
- // set the default peer_class_filter to use the local peer class
- // for peers on local networks
- boost::uint32_t lfilter = 1 << m_local_peer_class;
- boost::uint32_t gfilter = 1 << m_global_class;
-
- struct class_mapping
- {
- char const* first;
- char const* last;
- boost::uint32_t filter;
- };
-
- const static class_mapping v4_classes[] =
- {
- // everything
- | ||
| relevance 2 | ../src/session_impl.cpp:1808 | the udp socket(s) should be using the same generic mechanism and not be restricted to a single one we should open a one listen socket for each entry in the listen_interfaces list |
the udp socket(s) should be using the same generic
-mechanism and not be restricted to a single one
-we should open a one listen socket for each entry in the
-listen_interfaces list../src/session_impl.cpp:1808 }
-#endif // TORRENT_USE_OPENSSL
- }
-#endif // TORRENT_USE_IPV6
-
- // set our main IPv4 and IPv6 interfaces
- // used to send to the tracker
- std::vector<ip_interface> ifs = enum_net_interfaces(m_io_service, ec);
- for (std::vector<ip_interface>::const_iterator i = ifs.begin()
- , end(ifs.end()); i != end; ++i)
- {
- address const& addr = i->interface_address;
- if (addr.is_v6() && !is_local(addr) && !is_loopback(addr))
- m_ipv6_interface = tcp::endpoint(addr, m_listen_interface.port());
- else if (addr.is_v4() && !is_local(addr) && !is_loopback(addr))
- m_ipv4_interface = tcp::endpoint(addr, m_listen_interface.port());
- }
- }
- else
- {
- for (int i = 0; i < m_listen_interfaces.size(); ++i)
- {
- std::string const& device = m_listen_interfaces[i].first;
- int port = m_listen_interfaces[i].second;
-
- int num_device_fails = 0;
-
-#if TORRENT_USE_IPV6
- const int first_family = 0;
-#else
- const int first_family = 1;
-#endif
- for (int address_family = first_family; address_family < 2; ++address_family)
- {
- error_code err;
- address test_family = address::from_string(device.c_str(), err);
- if (!err && test_family.is_v4() != address_family)
- continue;
-
- listen_socket_t s = setup_listener(device, address_family, port
- , m_listen_port_retries, flags, ec);
-
- if (ec == error_code(boost::system::errc::no_such_device, generic_category()))
- {
- ++num_device_fails;
- continue;
- }
-
- if (s.sock)
- {
- TORRENT_ASSERT(!m_abort);
- | ||
| relevance 2 | ../src/session_impl.cpp:1910 | use bind_to_device in udp_socket |
use bind_to_device in udp_socket../src/session_impl.cpp:1910 if (m_listen_port_retries > 0)
- {
- m_listen_interface.port(m_listen_interface.port() + 1);
- --m_listen_port_retries;
- goto retry;
- }
- if (m_alerts.should_post<listen_failed_alert>())
- m_alerts.post_alert(listen_failed_alert(print_endpoint(m_listen_interface)
- , listen_failed_alert::bind, ec, listen_failed_alert::udp));
- return;
- }
-
-#ifdef TORRENT_USE_OPENSSL
- int ssl_port = m_settings.get_int(settings_pack::ssl_listen);
-
- // if ssl port is 0, we don't want to listen on an SSL port
- if (ssl_port != 0)
- {
- udp::endpoint ssl_bind_if(m_listen_interface.address(), ssl_port);
-
- m_ssl_udp_socket.bind(ssl_bind_if, ec);
- if (ec)
- {
-#if defined TORRENT_LOGGING
- session_log("SSL: cannot bind to UDP interface \"%s\": %s"
- , print_endpoint(m_listen_interface).c_str(), ec.message().c_str());
-#endif
- if (m_alerts.should_post<listen_failed_alert>())
- {
- error_code err;
- m_alerts.post_alert(listen_failed_alert(print_endpoint(ssl_bind_if)
- , listen_failed_alert::bind, ec, listen_failed_alert::utp_ssl));
- }
- ec.clear();
- }
- else
- {
- if (m_alerts.should_post<listen_succeeded_alert>())
- m_alerts.post_alert(listen_succeeded_alert(
- tcp::endpoint(ssl_bind_if.address(), ssl_bind_if.port())
- , listen_succeeded_alert::utp_ssl));
- }
- }
-#endif // TORRENT_USE_OPENSSL
-
- | ||
| relevance 2 | ../src/session_impl.cpp:1936 | use bind_to_device in udp_socket |
use bind_to_device in udp_socket../src/session_impl.cpp:1936 , print_endpoint(m_listen_interface).c_str(), ec.message().c_str());
-#endif
- if (m_alerts.should_post<listen_failed_alert>())
- {
- error_code err;
- m_alerts.post_alert(listen_failed_alert(print_endpoint(ssl_bind_if)
- , listen_failed_alert::bind, ec, listen_failed_alert::utp_ssl));
- }
- ec.clear();
- }
- else
- {
- if (m_alerts.should_post<listen_succeeded_alert>())
- m_alerts.post_alert(listen_succeeded_alert(
- tcp::endpoint(ssl_bind_if.address(), ssl_bind_if.port())
- , listen_succeeded_alert::utp_ssl));
- }
- }
-#endif // TORRENT_USE_OPENSSL
-
- m_udp_socket.bind(udp::endpoint(m_listen_interface.address(), m_listen_interface.port()), ec);
- if (ec)
- {
-#if defined TORRENT_LOGGING
- session_log("cannot bind to UDP interface \"%s\": %s"
- , print_endpoint(m_listen_interface).c_str(), ec.message().c_str());
-#endif
- if (m_listen_port_retries > 0)
- {
- m_listen_interface.port(m_listen_interface.port() + 1);
- --m_listen_port_retries;
- goto retry;
- }
- if (m_alerts.should_post<listen_failed_alert>())
- {
- error_code err;
- m_alerts.post_alert(listen_failed_alert(print_endpoint(m_listen_interface)
- , listen_failed_alert::bind, ec, listen_failed_alert::udp));
- }
- return;
- }
- else
- {
- m_external_udp_port = m_udp_socket.local_port();
- maybe_update_udp_mapping(0, m_listen_interface.port(), m_listen_interface.port());
- maybe_update_udp_mapping(1, m_listen_interface.port(), m_listen_interface.port());
- if (m_alerts.should_post<listen_succeeded_alert>())
- m_alerts.post_alert(listen_succeeded_alert(m_listen_interface, listen_succeeded_alert::udp));
- }
-
- if (m_settings.get_int(settings_pack::peer_tos) != 0)
- | ||
| relevance 2 | ../src/session_impl.cpp:3401 | make a list for torrents that want to be announced on the DHT so we don't have to loop over all torrents, just to find the ones that want to announce |
make a list for torrents that want to be announced on the DHT so we
-don't have to loop over all torrents, just to find the ones that want to announce../src/session_impl.cpp:3401 if (!m_dht_torrents.empty())
- {
- boost::shared_ptr<torrent> t;
- do
- {
- t = m_dht_torrents.front().lock();
- m_dht_torrents.pop_front();
- } while (!t && !m_dht_torrents.empty());
-
- if (t)
- {
- t->dht_announce();
- return;
- }
- }
- if (m_torrents.empty()) return;
-
- if (m_next_dht_torrent == m_torrents.end())
- m_next_dht_torrent = m_torrents.begin();
- m_next_dht_torrent->second->dht_announce();
- ++m_next_dht_torrent;
- if (m_next_dht_torrent == m_torrents.end())
- m_next_dht_torrent = m_torrents.begin();
- }
-#endif
-
- void session_impl::on_lsd_announce(error_code const& e)
- {
-#if defined TORRENT_ASIO_DEBUGGING
- complete_async("session_impl::on_lsd_announce");
-#endif
- m_stats_counters.inc_stats_counter(counters::on_lsd_counter);
- TORRENT_ASSERT(is_single_thread());
- if (e) return;
-
- if (m_abort) return;
-
-#if defined TORRENT_ASIO_DEBUGGING
- add_outstanding_async("session_impl::on_lsd_announce");
-#endif
- // announce on local network every 5 minutes
- int delay = (std::max)(m_settings.get_int(settings_pack::local_service_announce_interval)
- / (std::max)(int(m_torrents.size()), 1), 1);
- error_code ec;
- m_lsd_announce_timer.expires_from_now(seconds(delay), ec);
- m_lsd_announce_timer.async_wait(
- bind(&session_impl::on_lsd_announce, this, _1));
-
- if (m_torrents.empty()) return;
-
- if (m_next_lsd_torrent == m_torrents.end())
- | ||
| relevance 2 | ../src/torrent.cpp:718 | post alert |
post alert../src/torrent.cpp:718 state_updated();
-
- set_state(torrent_status::downloading);
-
- m_override_resume_data = true;
- init();
- }
-
-#endif // if 0
-
- void torrent::leave_seed_mode(bool seed)
- {
- if (!m_seed_mode) return;
-
- if (!seed)
- {
- // this means the user promised we had all the
- // files, but it turned out we didn't. This is
- // an error.
-
-
- #if defined TORRENT_LOGGING
- debug_log("*** FAILED SEED MODE, rechecking");
-#endif
- }
-
-#if defined TORRENT_LOGGING
- debug_log("*** LEAVING SEED MODE (%s)", seed ? "as seed" : "as non-seed");
-#endif
- m_seed_mode = false;
- // seed is false if we turned out not
- // to be a seed after all
- if (!seed)
- {
- m_have_all = false;
- set_state(torrent_status::downloading);
- force_recheck();
- }
- m_num_verified = 0;
- m_verified.clear();
- m_verifying.clear();
-
- m_need_save_resume_data = true;
- }
-
- void torrent::verified(int piece)
- {
- TORRENT_ASSERT(piece < int(m_verified.size()));
- TORRENT_ASSERT(piece >= 0);
- TORRENT_ASSERT(m_verified.get_bit(piece) == false);
- ++m_num_verified;
- | ||
| relevance 2 | ../src/torrent.cpp:4719 | abort lookups this torrent has made via the session host resolver interface |
abort lookups this torrent has made via the
-session host resolver interface../src/torrent.cpp:4719 // files belonging to the torrents
- disconnect_all(errors::torrent_aborted, peer_connection_interface::op_bittorrent);
-
- // post a message to the main thread to destruct
- // the torrent object from there
- if (m_storage.get())
- {
- inc_refcount("release_files");
- m_ses.disk_thread().async_stop_torrent(m_storage.get()
- , boost::bind(&torrent::on_cache_flushed, shared_from_this(), _1));
- }
- else
- {
- TORRENT_ASSERT(m_abort);
- if (alerts().should_post<cache_flushed_alert>())
- alerts().post_alert(cache_flushed_alert(get_handle()));
- }
-
- m_storage.reset();
-
-
- if (!m_apply_ip_filter)
- {
- inc_stats_counter(counters::non_filter_torrents, -1);
- m_apply_ip_filter = true;
- }
-
- m_allow_peers = false;
- m_auto_managed = false;
- for (int i = 0; i < aux::session_interface::num_torrent_lists; ++i)
- {
- if (!m_links[i].in_list()) continue;
- m_links[i].unlink(m_ses.torrent_list(i), i);
- }
- // don't re-add this torrent to the state-update list
- m_state_subscription = false;
- }
-
- void torrent::super_seeding(bool on)
- {
- if (on == m_super_seeding) return;
-
- m_super_seeding = on;
- m_need_save_resume_data = true;
-
- if (m_super_seeding) return;
-
- // disable super seeding for all peers
- for (peer_iterator i = begin(); i != end(); ++i)
- {
- (*i)->superseed_piece(-1, -1);
- | ||
| relevance 2 | ../src/torrent.cpp:7713 | if peer is a really good peer, maybe we shouldn't disconnect it |
if peer is a really good peer, maybe we shouldn't disconnect it../src/torrent.cpp:7713#if defined TORRENT_LOGGING
- debug_log("incoming peer (%d)", int(m_connections.size()));
-#endif
-
-#ifdef TORRENT_DEBUG
- error_code ec;
- TORRENT_ASSERT(p->remote() == p->get_socket()->remote_endpoint(ec) || ec);
-#endif
-
- TORRENT_ASSERT(p->peer_info_struct() != NULL);
-
- // we need to do this after we've added the peer to the peer_list
- // since that's when the peer is assigned its peer_info object,
- // which holds the rank
- if (maybe_replace_peer)
- {
- // now, find the lowest rank peer and disconnect that
- // if it's lower rank than the incoming connection
- peer_connection* peer = find_lowest_ranking_peer();
-
- if (peer && peer->peer_rank() < p->peer_rank())
- {
- peer->disconnect(errors::too_many_connections, peer_connection_interface::op_bittorrent);
- p->peer_disconnected_other();
- }
- else
- {
- p->disconnect(errors::too_many_connections, peer_connection_interface::op_bittorrent);
- // we have to do this here because from the peer's point of
- // it wasn't really attached to the torrent, but we do need
- // to let peer_list know we're removing it
- remove_peer(p);
- return false;
- }
- }
-
-#if TORRENT_USE_INVARIANT_CHECKS
- if (m_peer_list) m_peer_list->check_invariant();
-#endif
-
- if (m_share_mode)
- recalc_share_mode();
-
- return true;
- }
-
- bool torrent::want_tick() const
- {
- if (m_abort) return false;
-
- if (!m_connections.empty()) return true;
- | ||
| relevance 2 | ../src/utp_stream.cpp:348 | it would be nice if not everything would have to be public here |
it would be nice if not everything would have to be public here../src/utp_stream.cpp:348 void incoming(boost::uint8_t const* buf, int size, packet* p, ptime now);
- void do_ledbat(int acked_bytes, int delay, int in_flight);
- int packet_timeout() const;
- bool test_socket_state();
- void maybe_trigger_receive_callback();
- void maybe_trigger_send_callback();
- bool cancel_handlers(error_code const& ec, bool kill);
- bool consume_incoming_data(
- utp_header const* ph, boost::uint8_t const* ptr, int payload_size, ptime now);
- void update_mtu_limits();
- void experienced_loss(int seq_nr);
-
- void set_state(int s);
-
-private:
-
- // non-copyable
- utp_socket_impl(utp_socket_impl const&);
- utp_socket_impl const& operator=(utp_socket_impl const&);
-
-public:
-
- void check_receive_buffers() const;
-
-#if TORRENT_USE_INVARIANT_CHECKS
- void check_invariant() const;
-#endif
-
- utp_socket_manager* m_sm;
-
- // userdata pointer passed along
- // with any callback. This is initialized to 0
- // then set to point to the utp_stream when
- // hooked up, and then reset to 0 once the utp_stream
- // detaches. This is used to know whether or not
- // the socket impl is still attached to a utp_stream
- // object. When it isn't, we'll never be able to
- // signal anything back to the client, and in case
- // of errors, we just have to delete ourselves
- // i.e. transition to the UTP_STATE_DELETED state
- void* m_userdata;
-
- // This is a platform-independent replacement
- // for the regular iovec type in posix. Since
- // it's not used in any system call, we might as
- // well define our own type instead of wrapping
- // the system's type.
- struct iovec_t
- {
- iovec_t(void* b, size_t l): buf(b), len(l) {}
- void* buf;
| ||
| relevance 2 | ../src/web_peer_connection.cpp:687 | create a mapping of file-index to redirection URLs. Use that to form URLs instead. Support to reconnect to a new server without destructing this peer_connection |
create a mapping of file-index to redirection URLs. Use that to form
URLs instead. Support to reconnect to a new server without destructing this
peer_connection../src/web_peer_connection.cpp:687 == dl_target);
@@ -1137,10 +1141,6 @@ using detail::write_endpoint;
#ifdef TORRENT_DHT_VERBOSE_LOGGING
TORRENT_DEFINE_LOG(node)
-
-extern int g_failed_announces;
-extern int g_announces;
-
#endif
// remove peers that have timed out
@@ -1164,8 +1164,12 @@ void purge_peers(std::set<peer_entry>& peers)
void nop() {}
- | ||
| relevance 2 | ../src/kademlia/node.cpp:495 | it would be nice to have a bias towards node-id prefixes that are missing in the bucket |
it would be nice to have a bias towards node-id prefixes that
-are missing in the bucket../src/kademlia/node.cpp:495 // this shouldn't happen
+node_impl::node_impl(alert_dispatcher* alert_disp
+ , udp_socket_interface* sock
+ , dht_settings const& settings, node_id nid, address const& external_address
+ , dht_observer* observer
+ | ||
| relevance 2 | ../src/kademlia/node.cpp:491 | it would be nice to have a bias towards node-id prefixes that are missing in the bucket |
it would be nice to have a bias towards node-id prefixes that
+are missing in the bucket../src/kademlia/node.cpp:491 // this shouldn't happen
TORRENT_ASSERT(m_id != ne->id);
if (ne->id == m_id) return;
@@ -1216,7 +1220,58 @@ void node_impl::send_single_refresh(udp::endpoint const& ep, int bucket
time_duration node_impl::connection_timeout()
{
time_duration d = m_rpc.tick();
- | ||
| relevance 2 | ../src/kademlia/node.cpp:894 | find_node should write directly to the response entry |
find_node should write directly to the response entry../src/kademlia/node.cpp:894 TORRENT_LOG(node) << " values: " << reply["values"].list().size();
+ | ||
| relevance 2 | ../src/kademlia/node.cpp:581 | use the non deprecated function instead of this one |
use the non deprecated function instead of this one../src/kademlia/node.cpp:581 return d;
+}
+
+void node_impl::status(std::vector<dht_routing_bucket>& table
+ , std::vector<dht_lookup>& requests)
+{
+ mutex_t::scoped_lock l(m_mutex);
+
+ m_table.status(table);
+
+ for (std::set<traversal_algorithm*>::iterator i = m_running_requests.begin()
+ , end(m_running_requests.end()); i != end; ++i)
+ {
+ requests.push_back(dht_lookup());
+ dht_lookup& l = requests.back();
+ (*i)->status(l);
+ }
+}
+
+#ifndef TORRENT_NO_DEPRECATE
+void node_impl::status(session_status& s)
+ {
+ mutex_t::scoped_lock l(m_mutex);
+
+ m_table.status(s);
+ s.dht_torrents = int(m_map.size());
+ s.active_requests.clear();
+ s.dht_total_allocations = m_rpc.num_allocated_observers();
+ for (std::set<traversal_algorithm*>::iterator i = m_running_requests.begin()
+ , end(m_running_requests.end()); i != end; ++i)
+ {
+ s.active_requests.push_back(dht_lookup());
+ dht_lookup& l = s.active_requests.back();
+ (*i)->status(l);
+ }
+}
+#endif
+
+void node_impl::lookup_peers(sha1_hash const& info_hash, entry& reply
+ , bool noseed, bool scrape) const
+{
+ if (m_post_alert)
+ {
+ alert* a = new dht_get_peers_alert(info_hash);
+ if (!m_post_alert->post_alert(a)) delete a;
+ }
+
+ table_t::const_iterator i = m_map.lower_bound(info_hash);
+ if (i == m_map.end()) return;
+ if (i->first != info_hash) return;
+
+ | ||
| relevance 2 | ../src/kademlia/node.cpp:909 | find_node should write directly to the response entry |
find_node should write directly to the response entry../src/kademlia/node.cpp:909 TORRENT_LOG(node) << " values: " << reply["values"].list().size();
}
#endif
}
@@ -1254,9 +1309,7 @@ time_duration node_impl::connection_timeout()
lazy_entry const* msg_keys[6];
if (!verify_message(arg_ent, msg_desc, msg_keys, 6, error_string, sizeof(error_string)))
{
-#ifdef TORRENT_DHT_VERBOSE_LOGGING
- ++g_failed_announces;
-#endif
+ m_counters.inc_stats_counter(counters::dht_invalid_announce);
incoming_error(e, error_string);
return;
}
@@ -1267,7 +1320,60 @@ time_duration node_impl::connection_timeout()
// listen port and instead use the source port of the packet?
if (msg_keys[5] && msg_keys[5]->int_value() != 0)
port = m.addr.port();
- | ||
| relevance 2 | ../src/kademlia/routing_table.cpp:886 | move the lowest priority nodes to the replacement bucket |
move the lowest priority nodes to the replacement bucket../src/kademlia/routing_table.cpp:886 bucket_t& b = m_buckets[bucket_index].live_nodes;
+
+ if (port < 0 || port >= 65536)
+ | ||
| relevance 2 | ../src/kademlia/routing_table.cpp:110 | use the non deprecated function instead of this one |
use the non deprecated function instead of this one../src/kademlia/routing_table.cpp:110
+ const static int size_exceptions[] = {16, 8, 4, 2};
+ if (bucket < int(sizeof(size_exceptions)/sizeof(size_exceptions[0])))
+ return m_bucket_size * size_exceptions[bucket];
+ return m_bucket_size;
+}
+
+void routing_table::status(std::vector<dht_routing_bucket>& s) const
+{
+ for (table_t::const_iterator i = m_buckets.begin()
+ , end(m_buckets.end()); i != end; ++i)
+ {
+ dht_routing_bucket b;
+ b.num_nodes = i->live_nodes.size();
+ b.num_replacements = i->replacements.size();
+ s.push_back(b);
+ }
+}
+
+#ifndef TORRENT_NO_DEPRECATE
+void routing_table::status(session_status& s) const
+ {
+ int ignore;
+ boost::tie(s.dht_nodes, s.dht_node_cache, ignore) = size();
+ s.dht_global_nodes = num_global_nodes();
+
+ for (table_t::const_iterator i = m_buckets.begin()
+ , end(m_buckets.end()); i != end; ++i)
+ {
+ dht_routing_bucket b;
+ b.num_nodes = i->live_nodes.size();
+ b.num_replacements = i->replacements.size();
+#ifndef TORRENT_NO_DEPRECATE
+ b.last_active = 0;
+#endif
+ s.dht_routing_table.push_back(b);
+ }
+}
+#endif
+
+boost::tuple<int, int, int> routing_table::size() const
+{
+ int nodes = 0;
+ int replacements = 0;
+ int confirmed = 0;
+ for (table_t::const_iterator i = m_buckets.begin()
+ , end(m_buckets.end()); i != end; ++i)
+ {
+ nodes += i->live_nodes.size();
+ for (bucket_t::const_iterator k = i->live_nodes.begin()
+ , end(i->live_nodes.end()); k != end; ++k)
+ | ||
| relevance 2 | ../src/kademlia/routing_table.cpp:900 | move the lowest priority nodes to the replacement bucket |
move the lowest priority nodes to the replacement bucket../src/kademlia/routing_table.cpp:900 bucket_t& b = m_buckets[bucket_index].live_nodes;
bucket_t& rb = m_buckets[bucket_index].replacements;
// move any node whose (160 - distane_exp(m_id, id)) >= (i - m_buckets.begin())
@@ -1318,7 +1424,7 @@ time_duration node_impl::connection_timeout()
else
new_replacement_bucket.push_back(*j);
}
- | ||
| relevance 2 | ../include/libtorrent/enum_net.hpp:137 | this could be done more efficiently by just looking up the interface with the given name, maybe even with if_nametoindex() |
this could be done more efficiently by just looking up
+ | ||
| relevance 2 | ../include/libtorrent/enum_net.hpp:137 | this could be done more efficiently by just looking up the interface with the given name, maybe even with if_nametoindex() |
this could be done more efficiently by just looking up
the interface with the given name, maybe even with if_nametoindex()../include/libtorrent/enum_net.hpp:137
address ip = address::from_string(device_name, ec);
if (!ec)
@@ -1370,7 +1476,59 @@ the interface with the given name, maybe even with if_nametoindex()../i
// returns true if the given device exists
TORRENT_EXTRA_EXPORT bool has_interface(char const* name, io_service& ios
- | ||
| relevance 2 | ../include/libtorrent/proxy_base.hpp:257 | use the resolver interface that has a built-in cache |
use the resolver interface that has a built-in cache../include/libtorrent/proxy_base.hpp:257 return m_sock.lowest_layer();
+ | ||
| relevance 2 | ../include/libtorrent/piece_picker.hpp:599 | having 8 priority levels is probably excessive. It should probably be changed to 3 levels + dont-download |
having 8 priority levels is probably excessive. It should
+probably be changed to 3 levels + dont-download../include/libtorrent/piece_picker.hpp:599 // the number of peers that has this piece
+ // (availability)
+#if TORRENT_OPTIMIZE_MEMORY_USAGE
+ boost::uint32_t peer_count : 9;
+#else
+ boost::uint32_t peer_count : 16;
+#endif
+
+ // one of the enums from state_t. This indicates whether this piece
+ // is currently being downloaded or not, and what state it's in if
+ // it is. Specifically, as an optimization, pieces that have all blocks
+ // requested from them are separated out into separate lists to make
+ // lookups quicker. The main oddity is that whether a downloading piece
+ // has only been requested from peers that are reverse, that's
+ // recorded as piece_downloading_reverse, which really means the same
+ // as piece_downloading, it just saves space to also indicate that it
+ // has a bit lower priority. The reverse bit is only relevant if the
+ // state is piece_downloadin.
+ boost::uint32_t download_state : 3;
+
+
+ // is 0 if the piece is filtered (not to be downloaded)
+ // 1 is low priority
+ // 2 is low priority
+ // 3 is mid priority
+ // 4 is default priority
+ // 5 is mid priority
+ // 6 is high priority
+ // 7 is high priority
+ boost::uint32_t piece_priority : 3;
+
+ // index in to the piece_info vector
+#if TORRENT_OPTIMIZE_MEMORY_USAGE
+ boost::uint32_t index : 17;
+#else
+ boost::uint32_t index;
+#endif
+
+#ifdef TORRENT_DEBUG_REFCOUNTS
+ // all the peers that have this piece
+ std::set<const void*> have_peers;
+#endif
+
+ enum
+ {
+ // index is set to this to indicate that we have the
+ // piece. There is no entry for the piece in the
+ // buckets if this is the case.
+#if TORRENT_OPTIMIZE_MEMORY_USAGE
+ we_have_index = 0x3ffff,
+#else
+ | ||
| relevance 2 | ../include/libtorrent/proxy_base.hpp:257 | use the resolver interface that has a built-in cache |
use the resolver interface that has a built-in cache../include/libtorrent/proxy_base.hpp:257 return m_sock.lowest_layer();
}
next_layer_type& next_layer()
@@ -1397,7 +1555,7 @@ protected:
#endif
- | ||
| relevance 2 | ../include/libtorrent/session.hpp:271 | the ip filter should probably be saved here too |
the ip filter should probably be saved here too../include/libtorrent/session.hpp:271
+ | ||
| relevance 2 | ../include/libtorrent/session.hpp:271 | the ip filter should probably be saved here too |
the ip filter should probably be saved here too../include/libtorrent/session.hpp:271
if ((flags & start_default_features) == 0)
{
pack.set_bool(settings_pack::enable_upnp, false);
@@ -1448,7 +1606,7 @@ protected:
save_dht_proxy = save_proxy,
save_peer_proxy = save_proxy,
save_web_proxy = save_proxy,
- | ||
| relevance 2 | ../include/libtorrent/session_settings.hpp:55 | this type is only used internally now. move it to an internal header and make this type properly deprecated. |
this type is only used internally now. move it to an internal
+ | ||
| relevance 2 | ../include/libtorrent/session_settings.hpp:55 | this type is only used internally now. move it to an internal header and make this type properly deprecated. |
this type is only used internally now. move it to an internal
header and make this type properly deprecated.../include/libtorrent/session_settings.hpp:55
#include "libtorrent/version.hpp"
#include "libtorrent/config.hpp"
@@ -1500,7 +1658,7 @@ namespace libtorrent
// proxy_settings::type field.
enum proxy_type
{
- | ||
| relevance 2 | ../include/libtorrent/socks5_stream.hpp:131 | add async_connect() that takes a hostname and port as well |
add async_connect() that takes a hostname and port as well../include/libtorrent/socks5_stream.hpp:131 if (m_dst_name.size() > 255)
+ | ||
| relevance 2 | ../include/libtorrent/socks5_stream.hpp:131 | add async_connect() that takes a hostname and port as well |
add async_connect() that takes a hostname and port as well../include/libtorrent/socks5_stream.hpp:131 if (m_dst_name.size() > 255)
m_dst_name.resize(255);
}
@@ -1551,7 +1709,7 @@ namespace libtorrent
m_resolver.async_resolve(q, boost::bind(
&socks5_stream::name_lookup, this, _1, _2, h));
}
- | ||
| relevance 2 | ../include/libtorrent/tracker_manager.hpp:269 | this class probably doesn't need to have virtual functions. |
this class probably doesn't need to have virtual functions.../include/libtorrent/tracker_manager.hpp:269 int m_completion_timeout;
+ | ||
| relevance 2 | ../include/libtorrent/tracker_manager.hpp:278 | this class probably doesn't need to have virtual functions. |
this class probably doesn't need to have virtual functions.../include/libtorrent/tracker_manager.hpp:278 int m_completion_timeout;
typedef mutex mutex_t;
mutable mutex_t m_mutex;
@@ -1602,26 +1760,26 @@ namespace libtorrent
boost::shared_ptr<tracker_connection> shared_from_this()
{
- | ||
| relevance 2 | ../include/libtorrent/aux_/session_interface.hpp:104 | the IP voting mechanism should be factored out to its own class, not part of the session |
the IP voting mechanism should be factored out
-to its own class, not part of the session../include/libtorrent/aux_/session_interface.hpp:104 class port_filter;
- struct settings_pack;
- struct torrent_peer_allocator_interface;
- struct counters;
- struct resolver_interface;
+ | ||
| relevance 2 | ../include/libtorrent/aux_/session_interface.hpp:130 | the IP voting mechanism should be factored out to its own class, not part of the session |
the IP voting mechanism should be factored out
+to its own class, not part of the session../include/libtorrent/aux_/session_interface.hpp:130#endif
-#ifndef TORRENT_DISABLE_DHT
- namespace dht
- {
- struct dht_tracker;
- }
+#if TORRENT_USE_ASSERTS
+ virtual bool is_single_thread() const = 0;
+ virtual bool has_peer(peer_connection const* p) const = 0;
+ virtual bool any_torrent_has_peer(peer_connection const* p) const = 0;
+ virtual bool is_posting_torrent_updates() const = 0;
#endif
-}
+ };
+#endif // TORRENT_LOGGING || TORRENT_USE_ASSERTS
-namespace libtorrent { namespace aux
-{
- // TOOD: make this interface a lot smaller
+ // TOOD: 2 make this interface a lot smaller. It could be split up into
+ // several smaller interfaces. Each subsystem could then limit the size
+ // of the mock object to test it.
struct session_interface
: buffer_allocator_interface
+#if defined TORRENT_LOGGING || TORRENT_USE_ASSERTS
+ , session_logger
+#endif
{
enum
{
@@ -1645,8 +1803,29 @@ namespace libtorrent { namespace aux
typedef boost::function<void(error_code const&, std::vector<address> const&)>
callback_t;
- virtual void async_resolve(std::string const& host, int flags
- , callback_t const& h) = 0;
+
+ | ||
| relevance 2 | ../include/libtorrent/aux_/session_interface.hpp:155 | remove this. There's already get_resolver() |
remove this. There's already get_resolver()../include/libtorrent/aux_/session_interface.hpp:155 source_peer = 2,
+ source_tracker = 4,
+ source_router = 8
+ };
+
+ virtual void set_external_address(address const& ip
+ , int source_type, address const& source) = 0;
+ virtual external_ip const& external_address() const = 0;
+
+ virtual disk_interface& disk_thread() = 0;
+
+ virtual alert_manager& alerts() = 0;
+
+ virtual torrent_peer_allocator_interface* get_peer_allocator() = 0;
+ virtual io_service& get_io_service() = 0;
+ virtual resolver_interface& get_resolver() = 0;
+
+ typedef boost::function<void(error_code const&, std::vector<address> const&)>
+ callback_t;
+
+ virtual void async_resolve(std::string const& host, int flags
+ , callback_t const& h) = 0;
virtual bool has_connection(peer_connection* p) const = 0;
virtual void insert_peer(boost::shared_ptr<peer_connection> const& c) = 0;
@@ -1654,7 +1833,67 @@ namespace libtorrent { namespace aux
virtual void queue_async_resume_data(boost::shared_ptr<torrent> const& t) = 0;
virtual void done_async_resume() = 0;
virtual void evict_torrent(torrent* t) = 0;
- | ||
| relevance 1 | ../src/disk_io_thread.cpp:233 | it would be nice to have the number of threads be set dynamically |
it would be nice to have the number of threads be set dynamically../src/disk_io_thread.cpp:233 std::pair<block_cache::iterator, block_cache::iterator> pieces
+
+ virtual void remove_torrent(torrent_handle const& h, int options = 0) = 0;
+ virtual void remove_torrent_impl(boost::shared_ptr<torrent> tptr, int options) = 0;
+
+ // ip and port filter
+ virtual ip_filter& get_ip_filter() = 0;
+ virtual port_filter const& get_port_filter() const = 0;
+
+ virtual boost::int64_t session_time() const = 0;
+
+ virtual bool is_paused() const = 0;
+ virtual bool is_aborted() const = 0;
+ virtual int num_uploads() const = 0;
+ virtual bool preemptive_unchoke() const = 0;
+ virtual void trigger_optimistic_unchoke() = 0;
+ virtual void trigger_unchoke() = 0;
+
+ virtual boost::weak_ptr<torrent> find_torrent(sha1_hash const& info_hash) const = 0;
+ virtual boost::weak_ptr<torrent> find_disconnect_candidate_torrent() const = 0;
+ virtual boost::shared_ptr<torrent> delay_load_torrent(sha1_hash const& info_hash
+ , peer_connection* pc) = 0;
+ virtual void insert_torrent(sha1_hash const& ih, boost::shared_ptr<torrent> const& t
+ | ||
| relevance 2 | ../include/libtorrent/aux_/session_interface.hpp:210 | factor out the thread pool for socket jobs into a separate class used to (potentially) issue socket write calls onto multiple threads |
factor out the thread pool for socket jobs into a separate
+class
+used to (potentially) issue socket write calls onto multiple threads../include/libtorrent/aux_/session_interface.hpp:210 virtual int num_torrents() const = 0;
+
+ virtual peer_id const& get_peer_id() const = 0;
+
+ // cork a peer and schedule a delayed uncork
+ // does nothing if the peer is already corked
+ virtual void cork_burst(peer_connection* p) = 0;
+
+ virtual void close_connection(peer_connection* p, error_code const& ec) = 0;
+ virtual int num_connections() const = 0;
+
+ virtual char* allocate_buffer() = 0;
+ virtual void free_buffer(char* buf) = 0;
+ virtual int send_buffer_size() const = 0;
+
+ virtual void deferred_submit_jobs() = 0;
+
+ virtual boost::uint16_t listen_port() const = 0;
+ virtual boost::uint16_t ssl_listen_port() const = 0;
+
+ virtual void post_socket_job(socket_job& j) = 0;
+
+ // load the specified torrent. also evict one torrent, except
+ // for the one specified, if we are at the limit of loaded torrents
+ virtual bool load_torrent(torrent* t) = 0;
+
+ // bump the specified torrent to make it the most recently used one
+ // in the torrent LRU (i.e. the least likely to get unloaded)
+ virtual void bump_torrent(torrent* t, bool back = true) = 0;
+
+ // ask for which interface and port to bind outgoing peer connections on
+ virtual tcp::endpoint bind_outgoing_socket(socket_type& s, address const&
+ remote_address, error_code& ec) const = 0;
+ virtual bool verify_bound_address(address const& addr, bool utp
+ , error_code& ec) = 0;
+
+ | ||
| relevance 1 | ../src/disk_io_thread.cpp:233 | it would be nice to have the number of threads be set dynamically |
it would be nice to have the number of threads be set dynamically../src/disk_io_thread.cpp:233 std::pair<block_cache::iterator, block_cache::iterator> pieces
= m_disk_cache.all_pieces();
TORRENT_ASSERT(pieces.first == pieces.second);
#endif
@@ -1705,7 +1944,7 @@ namespace libtorrent { namespace aux
m_threads.resize(m_num_threads);
}
}
- | ||
| relevance 1 | ../src/http_seed_connection.cpp:124 | in chunked encoding mode, this assert won't hold. the chunk headers should be subtracted from the receive_buffer_size |
in chunked encoding mode, this assert won't hold.
+ | ||
| relevance 1 | ../src/http_seed_connection.cpp:124 | in chunked encoding mode, this assert won't hold. the chunk headers should be subtracted from the receive_buffer_size |
in chunked encoding mode, this assert won't hold.
the chunk headers should be subtracted from the receive_buffer_size../src/http_seed_connection.cpp:124 boost::optional<piece_block_progress>
http_seed_connection::downloading_piece_progress() const
{
@@ -1757,8 +1996,8 @@ the chunk headers should be subtracted from the receive_buffer_size../s
std::string request;
request.reserve(400);
- | ||
| relevance 1 | ../src/session_impl.cpp:5203 | report the proper address of the router as the source IP of this understanding of our external address, instead of the empty address |
report the proper address of the router as the source IP of
-this understanding of our external address, instead of the empty address../src/session_impl.cpp:5203 void session_impl::on_port_mapping(int mapping, address const& ip, int port
+ | ||
| relevance 1 | ../src/session_impl.cpp:5210 | report the proper address of the router as the source IP of this understanding of our external address, instead of the empty address |
report the proper address of the router as the source IP of
+this understanding of our external address, instead of the empty address../src/session_impl.cpp:5210 void session_impl::on_port_mapping(int mapping, address const& ip, int port
, error_code const& ec, int map_transport)
{
TORRENT_ASSERT(is_single_thread());
@@ -1809,9 +2048,9 @@ this understanding of our external address, instead of the empty address | ||
| relevance 1 | ../src/session_impl.cpp:6387 | we only need to do this if our global IPv4 address has changed since the DHT (currently) only supports IPv4. Since restarting the DHT is kind of expensive, it would be nice to not do it unnecessarily |
we only need to do this if our global IPv4 address has changed
+ | ||
| relevance 1 | ../src/session_impl.cpp:6412 | we only need to do this if our global IPv4 address has changed since the DHT (currently) only supports IPv4. Since restarting the DHT is kind of expensive, it would be nice to not do it unnecessarily |
we only need to do this if our global IPv4 address has changed
since the DHT (currently) only supports IPv4. Since restarting the DHT
-is kind of expensive, it would be nice to not do it unnecessarily../src/session_impl.cpp:6387#endif
+is kind of expensive, it would be nice to not do it unnecessarily../src/session_impl.cpp:6412#endif
if (!m_external_ip.cast_vote(ip, source_type, source)) return;
@@ -1862,11 +2101,11 @@ is kind of expensive, it would be nice to not do it unnecessarily../src
, boost::function<void(char*)> const& handler)
{
return m_disk_thread.async_allocate_disk_buffer(category, handler);
- | ||
| relevance 1 | ../src/torrent.cpp:1156 | make this depend on the error and on the filesystem the files are being downloaded to. If the error is no_space_left_on_device and the filesystem doesn't support sparse files, only zero the priorities of the pieces that are at the tails of all files, leaving everything up to the highest written piece in each file |
make this depend on the error and on the filesystem the
+ | ||
| relevance 1 | ../src/torrent.cpp:1157 | make this depend on the error and on the filesystem the files are being downloaded to. If the error is no_space_left_on_device and the filesystem doesn't support sparse files, only zero the priorities of the pieces that are at the tails of all files, leaving everything up to the highest written piece in each file |
make this depend on the error and on the filesystem the
files are being downloaded to. If the error is no_space_left_on_device
and the filesystem doesn't support sparse files, only zero the priorities
of the pieces that are at the tails of all files, leaving everything
-up to the highest written piece in each file../src/torrent.cpp:1156 alerts().post_alert(file_error_alert(j->error.ec
+up to the highest written piece in each file../src/torrent.cpp:1157 alerts().post_alert(file_error_alert(j->error.ec
, resolve_filename(j->error.file), j->error.operation_str(), get_handle()));
// put the torrent in an error-state
@@ -1917,8 +2156,8 @@ up to the highest written piece in each file../src/torrent.cpp:1156 | ||
| relevance 1 | ../src/torrent.cpp:6865 | save the send_stats state instead of throwing them away it may pose an issue when downgrading though |
save the send_stats state instead of throwing them away
-it may pose an issue when downgrading though../src/torrent.cpp:6865 for (int k = 0; k < bits; ++k)
+ | ||
| relevance 1 | ../src/torrent.cpp:6874 | save the send_stats state instead of throwing them away it may pose an issue when downgrading though |
save the send_stats state instead of throwing them away
+it may pose an issue when downgrading though../src/torrent.cpp:6874 for (int k = 0; k < bits; ++k)
v |= (i->info[j*8+k].state == piece_picker::block_info::state_finished)
? (1 << k) : 0;
bitmask.append(1, v);
@@ -1969,9 +2208,9 @@ it may pose an issue when downgrading though../src/torrent.cpp:6865 | ||
| relevance 1 | ../src/torrent.cpp:7958 | should disconnect all peers that have the pieces we have not just seeds. It would be pretty expensive to check all pieces for all peers though |
should disconnect all peers that have the pieces we have
+ | ||
| relevance 1 | ../src/torrent.cpp:7967 | should disconnect all peers that have the pieces we have not just seeds. It would be pretty expensive to check all pieces for all peers though |
should disconnect all peers that have the pieces we have
not just seeds. It would be pretty expensive to check all pieces
-for all peers though../src/torrent.cpp:7958 set_state(torrent_status::finished);
+for all peers though../src/torrent.cpp:7967 set_state(torrent_status::finished);
set_queue_position(-1);
m_became_finished = m_ses.session_time();
@@ -2022,7 +2261,7 @@ for all peers though../src/torrent.cpp:7958| relevance 1 | ../include/libtorrent/ip_voter.hpp:122 | instead, have one instance per possible subnet, global IPv4, global IPv6, loopback, 192.168.x.x, 10.x.x.x, etc. |
|
instead, have one instance per possible subnet, global IPv4, global IPv6, loopback, 192.168.x.x, 10.x.x.x, etc.../include/libtorrent/ip_voter.hpp:122 // away all the votes and started from scratch, in case
+ | ||
| relevance 1 | ../include/libtorrent/ip_voter.hpp:122 | instead, have one instance per possible subnet, global IPv4, global IPv6, loopback, 192.168.x.x, 10.x.x.x, etc. |
instead, have one instance per possible subnet, global IPv4, global IPv6, loopback, 192.168.x.x, 10.x.x.x, etc.../include/libtorrent/ip_voter.hpp:122 // away all the votes and started from scratch, in case
// our IP has changed
ptime m_last_rotate;
};
@@ -2049,7 +2288,7 @@ for all peers though../src/torrent.cpp:7958| relevance 1 | ../include/libtorrent/web_peer_connection.hpp:122 | if we make this be a disk_buffer_holder instead we would save a copy sometimes use allocate_disk_receive_buffer and release_disk_receive_buffer |
|
if we make this be a disk_buffer_holder instead
+ | ||
| relevance 1 | ../include/libtorrent/web_peer_connection.hpp:122 | if we make this be a disk_buffer_holder instead we would save a copy sometimes use allocate_disk_receive_buffer and release_disk_receive_buffer |
if we make this be a disk_buffer_holder instead
we would save a copy sometimes
use allocate_disk_receive_buffer and release_disk_receive_buffer../include/libtorrent/web_peer_connection.hpp:122
// returns the block currently being
@@ -2102,7 +2341,7 @@ use allocate_disk_receive_buffer and release_disk_receive_buffer../incl
};
}
- | ||
| relevance 0 | ../test/test_block_cache.cpp:475 | test try_evict_blocks |
test try_evict_blocks../test/test_block_cache.cpp:475 | ||
| relevance 0 | ../test/test_block_cache.cpp:476 | test evicting volatile pieces, to see them be removed |
test evicting volatile pieces, to see them be removed../test/test_block_cache.cpp:476 | ||
| relevance 0 | ../test/test_block_cache.cpp:477 | test evicting dirty pieces |
test evicting dirty pieces../test/test_block_cache.cpp:477 | ||
| relevance 0 | ../test/test_block_cache.cpp:478 | test free_piece |
test free_piece../test/test_block_cache.cpp:478 | ||
| relevance 0 | ../test/test_block_cache.cpp:479 | test abort_dirty |
test abort_dirty../test/test_block_cache.cpp:479 | ||
| relevance 0 | ../test/test_block_cache.cpp:480 | test unaligned reads |
test unaligned reads../test/test_block_cache.cpp:480 // it's supposed to be a cache hit
+ | ||
| relevance 0 | ../test/test_block_cache.cpp:475 | test try_evict_blocks |
test try_evict_blocks../test/test_block_cache.cpp:475 | ||
| relevance 0 | ../test/test_block_cache.cpp:476 | test evicting volatile pieces, to see them be removed |
test evicting volatile pieces, to see them be removed../test/test_block_cache.cpp:476 | ||
| relevance 0 | ../test/test_block_cache.cpp:477 | test evicting dirty pieces |
test evicting dirty pieces../test/test_block_cache.cpp:477 | ||
| relevance 0 | ../test/test_block_cache.cpp:478 | test free_piece |
test free_piece../test/test_block_cache.cpp:478 | ||
| relevance 0 | ../test/test_block_cache.cpp:479 | test abort_dirty |
test abort_dirty../test/test_block_cache.cpp:479 | ||
| relevance 0 | ../test/test_block_cache.cpp:480 | test unaligned reads |
test unaligned reads../test/test_block_cache.cpp:480 // it's supposed to be a cache hit
TEST_CHECK(ret >= 0);
// return the reference to the buffer we just read
RETURN_BUFFER;
@@ -2125,7 +2364,7 @@ int test_main()
return 0;
}
- | ||
| relevance 0 | ../test/test_dht.cpp:436 | test obfuscated_get_peers |
test obfuscated_get_peers../test/test_dht.cpp:436 g_got_peers.insert(g_got_peers.end(), peers.begin(), peers.end());
+ | ||
| relevance 0 | ../test/test_dht.cpp:436 | test obfuscated_get_peers |
test obfuscated_get_peers../test/test_dht.cpp:436 g_got_peers.insert(g_got_peers.end(), peers.begin(), peers.end());
}
std::vector<dht::item> g_got_items;
@@ -2176,7 +2415,7 @@ bool get_item_cb(dht::item& i)
fprintf(stderr, "msg: %s\n", print_entry(response).c_str());
ret = dht::verify_message(&response, pong_desc, parsed, 4, error_string, sizeof(error_string));
- | ||
| relevance 0 | ../test/test_metadata_extension.cpp:87 | it would be nice to test reversing which session is making the connection as well |
it would be nice to test reversing
+ | ||
| relevance 0 | ../test/test_metadata_extension.cpp:87 | it would be nice to test reversing which session is making the connection as well |
it would be nice to test reversing
which session is making the connection as well../test/test_metadata_extension.cpp:87 , boost::shared_ptr<libtorrent::torrent_plugin> (*constructor)(libtorrent::torrent*, void*)
, int timeout)
{
@@ -2228,31 +2467,32 @@ which session is making the connection as well../test/test_metadata_ext
ses1.apply_settings(pack);
ses2.apply_settings(pack);
- | ||
| relevance 0 | ../test/test_peer_list.cpp:419 | test applying a port_filter |
test applying a port_filter../test/test_peer_list.cpp:419 | ||
| relevance 0 | ../test/test_peer_list.cpp:420 | test erasing peers |
test erasing peers../test/test_peer_list.cpp:420 | ||
| relevance 0 | ../test/test_peer_list.cpp:421 | test using port and ip filter |
test using port and ip filter../test/test_peer_list.cpp:421 | ||
| relevance 0 | ../test/test_peer_list.cpp:422 | test incrementing failcount (and make sure we no longer consider the peer a connect canidate) |
test incrementing failcount (and make sure we no longer consider the peer a connect canidate)../test/test_peer_list.cpp:422 | ||
| relevance 0 | ../test/test_peer_list.cpp:423 | test max peerlist size |
test max peerlist size../test/test_peer_list.cpp:423 | ||
| relevance 0 | ../test/test_peer_list.cpp:424 | test logic for which connection to keep when receiving an incoming connection to the same peer as we just made an outgoing connection to |
test logic for which connection to keep when receiving an incoming connection to the same peer as we just made an outgoing connection to../test/test_peer_list.cpp:424 | ||
| relevance 0 | ../test/test_peer_list.cpp:425 | test update_peer_port with allow_multiple_connections_per_ip |
test update_peer_port with allow_multiple_connections_per_ip../test/test_peer_list.cpp:425 | ||
| relevance 0 | ../test/test_peer_list.cpp:426 | test set_seed |
test set_seed../test/test_peer_list.cpp:426 | ||
| relevance 0 | ../test/test_peer_list.cpp:427 | test has_peer |
test has_peer../test/test_peer_list.cpp:427 | ||
| relevance 0 | ../test/test_peer_list.cpp:428 | test insert_peer with a full list |
test insert_peer with a full list../test/test_peer_list.cpp:428 | ||
| relevance 0 | ../test/test_peer_list.cpp:429 | test add i2p peers |
test add i2p peers../test/test_peer_list.cpp:429 | ||
| relevance 0 | ../test/test_peer_list.cpp:430 | test allow_i2p_mixed |
test allow_i2p_mixed../test/test_peer_list.cpp:430 | ||
| relevance 0 | ../test/test_peer_list.cpp:431 | test insert_peer failing |
test insert_peer failing../test/test_peer_list.cpp:431 | ||
| relevance 0 | ../test/test_peer_list.cpp:432 | test IPv6 |
test IPv6../test/test_peer_list.cpp:432 | ||
| relevance 0 | ../test/test_peer_list.cpp:433 | test connect_to_peer() failing |
test connect_to_peer() failing../test/test_peer_list.cpp:433 | ||
| relevance 0 | ../test/test_peer_list.cpp:434 | test connection_closed |
test connection_closed../test/test_peer_list.cpp:434 | ||
| relevance 0 | ../test/test_peer_list.cpp:435 | test recalculate connect candidates |
test recalculate connect candidates../test/test_peer_list.cpp:435 | ||
| relevance 0 | ../test/test_peer_list.cpp:436 | add tests here |
add tests here../test/test_peer_list.cpp:436 for (int i = 0; i < 100; ++i)
- {
- torrent_peer* peer = p.add_peer(rand_tcp_ep(), 0, 0, &st);
- TEST_EQUAL(st.erased.size(), 0);
- st.erased.clear();
- TEST_CHECK(peer);
- if (peer == NULL || st.erased.size() > 0)
- {
- fprintf(stderr, "unexpected rejection of peer: %d in list. added peer %p, erased %d peers\n"
- , p.num_peers(), peer, int(st.erased.size()));
- }
- }
- TEST_EQUAL(p.num_peers(), 100);
+ | ||
| relevance 0 | ../test/test_peer_list.cpp:581 | test erasing peers |
test erasing peers../test/test_peer_list.cpp:581 | ||
| relevance 0 | ../test/test_peer_list.cpp:582 | test logic for which connection to keep when receiving an incoming connection to the same peer as we just made an outgoing connection to |
test logic for which connection to keep when receiving an incoming
+connection to the same peer as we just made an outgoing connection to../test/test_peer_list.cpp:582 | ||
| relevance 0 | ../test/test_peer_list.cpp:584 | test update_peer_port with allow_multiple_connections_per_ip and without |
test update_peer_port with allow_multiple_connections_per_ip and without../test/test_peer_list.cpp:584 | ||
| relevance 0 | ../test/test_peer_list.cpp:585 | test add i2p peers |
test add i2p peers../test/test_peer_list.cpp:585 | ||
| relevance 0 | ../test/test_peer_list.cpp:586 | test allow_i2p_mixed |
test allow_i2p_mixed../test/test_peer_list.cpp:586 | ||
| relevance 0 | ../test/test_peer_list.cpp:587 | test insert_peer failing with all error conditions |
test insert_peer failing with all error conditions../test/test_peer_list.cpp:587 | ||
| relevance 0 | ../test/test_peer_list.cpp:588 | test IPv6 |
test IPv6../test/test_peer_list.cpp:588 | ||
| relevance 0 | ../test/test_peer_list.cpp:589 | test connect_to_peer() failing |
test connect_to_peer() failing../test/test_peer_list.cpp:589 | ||
| relevance 0 | ../test/test_peer_list.cpp:590 | test connection_closed |
test connection_closed../test/test_peer_list.cpp:590 TEST_EQUAL(p.num_peers(), 2);
+ TEST_EQUAL(p.num_connect_candidates(), 2);
- // trigger the eviction of one peer
- torrent_peer* peer = p.add_peer(rand_tcp_ep(), 0, 0, &st);
- // we either removed an existing peer, or rejected this one
- TEST_CHECK(st.erased.size() == 1 || peer == NULL);
+ TEST_EQUAL(p.has_peer(peer1), true);
+ TEST_EQUAL(p.has_peer(peer2), true);
+
+ ip_filter filter;
+ filter.add_rule(address_v4::from_string("10.10.0.1")
+ , address_v4::from_string("10.10.0.1"), ip_filter::blocked);
+ p.apply_ip_filter(filter, &st, banned);
+ TEST_EQUAL(st.erased.size(), 1);
+ st.erased.clear();
+
+ TEST_EQUAL(p.num_peers(), 1);
+ TEST_EQUAL(p.num_connect_candidates(), 1);
+
+ TEST_EQUAL(p.has_peer(peer1), false);
+ TEST_EQUAL(p.has_peer(peer2), true);
}
return 0;
}
- | ||
| relevance 0 | ../test/test_primitives.cpp:213 | test the case where we have > 120 samples (and have the base delay actually be updated) |
test the case where we have > 120 samples (and have the base delay actually be updated)../test/test_primitives.cpp:213 | ||
| relevance 0 | ../test/test_primitives.cpp:214 | test the case where a sample is lower than the history entry but not lower than the base |
test the case where a sample is lower than the history entry but not lower than the base../test/test_primitives.cpp:214 TEST_CHECK(!filter.find(k3));
+ | ||
| relevance 0 | ../test/test_primitives.cpp:213 | test the case where we have > 120 samples (and have the base delay actually be updated) |
test the case where we have > 120 samples (and have the base delay actually be updated)../test/test_primitives.cpp:213 | ||
| relevance 0 | ../test/test_primitives.cpp:214 | test the case where a sample is lower than the history entry but not lower than the base |
test the case where a sample is lower than the history entry but not lower than the base../test/test_primitives.cpp:214 TEST_CHECK(!filter.find(k3));
TEST_CHECK(filter.find(k4));
// test timestamp_history
@@ -2303,9 +2543,9 @@ which session is making the connection as well../test/test_metadata_ext
sanitize_append_path_element(path, "a...b", 5);
TEST_EQUAL(path, "a...b");
- | ||
| relevance 0 | ../test/test_resume.cpp:331 | test all other resume flags here too. This would require returning more than just the torrent_status from test_resume_flags. Also http seeds and trackers for instance |
test all other resume flags here too. This would require returning
+ | ||
| relevance 0 | ../test/test_resume.cpp:340 | test all other resume flags here too. This would require returning more than just the torrent_status from test_resume_flags. Also http seeds and trackers for instance |
test all other resume flags here too. This would require returning
more than just the torrent_status from test_resume_flags. Also http seeds
-and trackers for instance../test/test_resume.cpp:331 // resume data overrides the paused flag
+and trackers for instance../test/test_resume.cpp:340 // resume data overrides the paused flag
fprintf(stderr, "flags: paused\n");
s = test_resume_flags(add_torrent_params::flag_paused);
default_tests(s);
@@ -2329,7 +2569,7 @@ and trackers for instance../test/test_resume.cpp:331| relevance 0 | ../test/test_rss.cpp:135 | verify some key state is saved in 'state' |
|
verify some key state is saved in 'state'../test/test_rss.cpp:135 feed_status st;
+ | ||
| relevance 0 | ../test/test_rss.cpp:135 | verify some key state is saved in 'state' |
verify some key state is saved in 'state'../test/test_rss.cpp:135 feed_status st;
f->get_feed_status(&st);
TEST_CHECK(!st.error);
@@ -2364,7 +2604,7 @@ int test_main()
return 0;
}
- | ||
| relevance 0 | ../test/test_ssl.cpp:377 | test using a signed certificate with the wrong info-hash in DN |
test using a signed certificate with the wrong info-hash in DN../test/test_ssl.cpp:377 // in verifying peers
+ | ||
| relevance 0 | ../test/test_ssl.cpp:377 | test using a signed certificate with the wrong info-hash in DN |
test using a signed certificate with the wrong info-hash in DN../test/test_ssl.cpp:377 // in verifying peers
ctx.set_verify_mode(context::verify_none, ec);
if (ec)
{
@@ -2415,7 +2655,7 @@ int test_main()
return false;
}
fprintf(stderr, "use_tmp_dh_file \"%s\"\n", dh_params.c_str());
- | ||
| relevance 0 | ../test/test_ssl.cpp:475 | also test using a hash that refers to a valid torrent but that differs from the SNI hash |
also test using a hash that refers to a valid torrent
+ | ||
| relevance 0 | ../test/test_ssl.cpp:475 | also test using a hash that refers to a valid torrent but that differs from the SNI hash |
also test using a hash that refers to a valid torrent
but that differs from the SNI hash../test/test_ssl.cpp:475 print_alerts(ses1, "ses1", true, true, true, &on_alert);
if (ec)
{
@@ -2467,7 +2707,7 @@ but that differs from the SNI hash../test/test_ssl.cpp:475 | ||
| relevance 0 | ../test/test_torrent.cpp:133 | wait for an alert rather than just waiting 10 seconds. This is kind of silly |
wait for an alert rather than just waiting 10 seconds. This is kind of silly../test/test_torrent.cpp:133 TEST_EQUAL(h.file_priorities().size(), info->num_files());
+ | ||
| relevance 0 | ../test/test_torrent.cpp:133 | wait for an alert rather than just waiting 10 seconds. This is kind of silly |
wait for an alert rather than just waiting 10 seconds. This is kind of silly../test/test_torrent.cpp:133 TEST_EQUAL(h.file_priorities().size(), info->num_files());
TEST_EQUAL(h.file_priorities()[0], 0);
if (info->num_files() > 1)
TEST_EQUAL(h.file_priorities()[1], 0);
@@ -2518,17 +2758,17 @@ but that differs from the SNI hash../test/test_ssl.cpp:475 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:116 | test remap_files |
test remap_files../test/test_torrent_parse.cpp:116 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:117 | merkle torrents. specifically torrent_info::add_merkle_nodes and torrent with "root hash" |
merkle torrents. specifically torrent_info::add_merkle_nodes and torrent with "root hash"../test/test_torrent_parse.cpp:117 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:118 | torrent with 'p' (padfile) attribute |
torrent with 'p' (padfile) attribute../test/test_torrent_parse.cpp:118 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:119 | torrent with 'h' (hidden) attribute |
torrent with 'h' (hidden) attribute../test/test_torrent_parse.cpp:119 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:120 | torrent with 'x' (executable) attribute |
torrent with 'x' (executable) attribute../test/test_torrent_parse.cpp:120 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:121 | torrent with 'l' (symlink) attribute |
torrent with 'l' (symlink) attribute../test/test_torrent_parse.cpp:121 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:122 | creating a merkle torrent (torrent_info::build_merkle_list) |
creating a merkle torrent (torrent_info::build_merkle_list)../test/test_torrent_parse.cpp:122 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:123 | torrent with multiple trackers in multiple tiers, making sure we shuffle them (how do you test shuffling?, load it multiple times and make sure it's in different order at least once) |
torrent with multiple trackers in multiple tiers, making sure we shuffle them (how do you test shuffling?, load it multiple times and make sure it's in different order at least once)../test/test_torrent_parse.cpp:123 { "invalid_info.torrent", errors::torrent_missing_info },
+ | ||
| relevance 0 | ../test/test_torrent_parse.cpp:116 | test remap_files |
test remap_files../test/test_torrent_parse.cpp:116 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:117 | merkle torrents. specifically torrent_info::add_merkle_nodes and torrent with "root hash" |
merkle torrents. specifically torrent_info::add_merkle_nodes and torrent with "root hash"../test/test_torrent_parse.cpp:117 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:118 | torrent with 'p' (padfile) attribute |
torrent with 'p' (padfile) attribute../test/test_torrent_parse.cpp:118 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:119 | torrent with 'h' (hidden) attribute |
torrent with 'h' (hidden) attribute../test/test_torrent_parse.cpp:119 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:120 | torrent with 'x' (executable) attribute |
torrent with 'x' (executable) attribute../test/test_torrent_parse.cpp:120 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:121 | torrent with 'l' (symlink) attribute |
torrent with 'l' (symlink) attribute../test/test_torrent_parse.cpp:121 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:122 | creating a merkle torrent (torrent_info::build_merkle_list) |
creating a merkle torrent (torrent_info::build_merkle_list)../test/test_torrent_parse.cpp:122 | ||
| relevance 0 | ../test/test_torrent_parse.cpp:123 | torrent with multiple trackers in multiple tiers, making sure we shuffle them (how do you test shuffling?, load it multiple times and make sure it's in different order at least once) |
torrent with multiple trackers in multiple tiers, making sure we shuffle them (how do you test shuffling?, load it multiple times and make sure it's in different order at least once)../test/test_torrent_parse.cpp:123 { "invalid_info.torrent", errors::torrent_missing_info },
{ "string.torrent", errors::torrent_is_no_dict },
{ "negative_size.torrent", errors::torrent_invalid_length },
- { "negative_file_size.torrent", errors::torrent_file_parse_failed },
- { "invalid_path_list.torrent", errors::torrent_file_parse_failed },
- { "missing_path_list.torrent", errors::torrent_file_parse_failed },
+ { "negative_file_size.torrent", errors::torrent_invalid_length },
+ { "invalid_path_list.torrent", errors::torrent_missing_name},
+ { "missing_path_list.torrent", errors::torrent_missing_name },
{ "invalid_pieces.torrent", errors::torrent_missing_pieces },
{ "unaligned_pieces.torrent", errors::torrent_invalid_hashes },
{ "invalid_root_hash.torrent", errors::torrent_invalid_hashes },
- { "invalid_root_hash2.torrent", errors::torrent_missing_pieces},
- { "invalid_file_size.torrent", errors::torrent_file_parse_failed },
+ { "invalid_root_hash2.torrent", errors::torrent_missing_pieces },
+ { "invalid_file_size.torrent", errors::torrent_invalid_length },
};
namespace libtorrent
@@ -2569,7 +2809,7 @@ namespace libtorrent
TEST_EQUAL(merkle_num_leafs(15), 16);
TEST_EQUAL(merkle_num_leafs(16), 16);
TEST_EQUAL(merkle_num_leafs(17), 32);
- | ||
| relevance 0 | ../test/test_tracker.cpp:198 | test parse peers6 |
test parse peers6../test/test_tracker.cpp:198 | ||
| relevance 0 | ../test/test_tracker.cpp:199 | test parse tracker-id |
test parse tracker-id../test/test_tracker.cpp:199 | ||
| relevance 0 | ../test/test_tracker.cpp:200 | test parse failure-reason |
test parse failure-reason../test/test_tracker.cpp:200 | ||
| relevance 0 | ../test/test_tracker.cpp:201 | test all failure paths, including invalid bencoding not a dictionary no files entry in scrape response no info-hash entry in scrape response malformed peers in peer list of dictionaries uneven number of bytes in peers and peers6 string responses |
test all failure paths, including
+ | ||
| relevance 0 | ../test/test_tracker.cpp:198 | test parse peers6 |
test parse peers6../test/test_tracker.cpp:198 | ||
| relevance 0 | ../test/test_tracker.cpp:199 | test parse tracker-id |
test parse tracker-id../test/test_tracker.cpp:199 | ||
| relevance 0 | ../test/test_tracker.cpp:200 | test parse failure-reason |
test parse failure-reason../test/test_tracker.cpp:200 | ||
| relevance 0 | ../test/test_tracker.cpp:201 | test all failure paths, including invalid bencoding not a dictionary no files entry in scrape response no info-hash entry in scrape response malformed peers in peer list of dictionaries uneven number of bytes in peers and peers6 string responses |
test all failure paths, including
invalid bencoding
not a dictionary
no files entry in scrape response
@@ -2626,7 +2866,7 @@ int test_main()
snprintf(tracker_url, sizeof(tracker_url), "http://127.0.0.1:%d/announce", http_port);
t->add_tracker(tracker_url, 0);
- | ||
| relevance 0 | ../test/test_transfer.cpp:288 | factor out the disk-full test into its own unit test |
factor out the disk-full test into its own unit test../test/test_transfer.cpp:288 print_alerts(ses1, "ses1", true, true, true, &on_alert);
+ | ||
| relevance 0 | ../test/test_transfer.cpp:288 | factor out the disk-full test into its own unit test |
factor out the disk-full test into its own unit test../test/test_transfer.cpp:288 print_alerts(ses1, "ses1", true, true, true, &on_alert);
print_alerts(ses2, "ses2", true, true, true, &on_alert);
if (i % 10 == 0)
@@ -2677,7 +2917,7 @@ int test_main()
fprintf(stderr, "%s: discovered disk full mode. Raise limit and disable upload-mode\n", time_now_string());
peer_disconnects = 0;
continue;
- | ||
| relevance 0 | ../test/test_upnp.cpp:100 | store the log and verify that some key messages are there |
store the log and verify that some key messages are there../test/test_upnp.cpp:100 "USN:uuid:000f-66d6-7296000099dc::upnp:rootdevice\r\n"
+ | ||
| relevance 0 | ../test/test_upnp.cpp:100 | store the log and verify that some key messages are there |
store the log and verify that some key messages are there../test/test_upnp.cpp:100 "USN:uuid:000f-66d6-7296000099dc::upnp:rootdevice\r\n"
"Location: http://127.0.0.1:%d/upnp.xml\r\n"
"Server: Custom/1.0 UPnP/1.0 Proc/Ver\r\n"
"EXT:\r\n"
@@ -2728,7 +2968,7 @@ int run_upnp_test(char const* root_filename, char const* router_model, char cons
error_code ec;
load_file(root_filename, buf, ec);
buf.push_back(0);
- | ||
| relevance 0 | ../test/web_seed_suite.cpp:366 | file hashes don't work with the new torrent creator reading async |
file hashes don't work with the new torrent creator reading async../test/web_seed_suite.cpp:366 // corrupt the files now, so that the web seed will be banned
+ | ||
| relevance 0 | ../test/web_seed_suite.cpp:366 | file hashes don't work with the new torrent creator reading async |
file hashes don't work with the new torrent creator reading async../test/web_seed_suite.cpp:366 // corrupt the files now, so that the web seed will be banned
if (test_url_seed)
{
create_random_files(combine_path(save_path, "torrent_dir"), file_sizes, sizeof(file_sizes)/sizeof(file_sizes[0]));
@@ -2779,7 +3019,7 @@ int run_upnp_test(char const* root_filename, char const* router_model, char cons
test_transfer(ses, torrent_file, proxy, port, protocol, test_url_seed
, chunked_encoding, test_ban, keepalive);
- | ||
| relevance 0 | ../src/block_cache.cpp:884 | it's somewhat expensive to iterate over this linked list. Presumably because of the random access of memory. It would be nice if pieces with no evictable blocks weren't in this list |
it's somewhat expensive
+ | ||
| relevance 0 | ../src/block_cache.cpp:884 | it's somewhat expensive to iterate over this linked list. Presumably because of the random access of memory. It would be nice if pieces with no evictable blocks weren't in this list |
it's somewhat expensive
to iterate over this linked list. Presumably because of the random
access of memory. It would be nice if pieces with no evictable blocks
weren't in this list../src/block_cache.cpp:884 }
@@ -2833,7 +3073,7 @@ weren't in this list../src/block_cache.cpp:884| relevance 0 | ../src/block_cache.cpp:948 | this should probably only be done every n:th time |
|
this should probably only be done every n:th time../src/block_cache.cpp:948 }
+ | ||
| relevance 0 | ../src/block_cache.cpp:948 | this should probably only be done every n:th time |
this should probably only be done every n:th time../src/block_cache.cpp:948 }
if (pe->ok_to_evict())
{
@@ -2884,7 +3124,7 @@ weren't in this list../src/block_cache.cpp:884| relevance 0 | ../src/block_cache.cpp:1720 | create a holder for refcounts that automatically decrement |
|
create a holder for refcounts that automatically decrement../src/block_cache.cpp:1720 }
+ | ||
| relevance 0 | ../src/block_cache.cpp:1720 | create a holder for refcounts that automatically decrement |
create a holder for refcounts that automatically decrement../src/block_cache.cpp:1720 }
j->buffer = allocate_buffer("send buffer");
if (j->buffer == 0) return -2;
@@ -2935,7 +3175,7 @@ bool block_cache::maybe_free_piece(cached_piece_entry* pe)
boost::shared_ptr<piece_manager> s = pe->storage;
- | ||
| relevance 0 | ../src/bt_peer_connection.cpp:663 | this could be optimized using knuth morris pratt |
this could be optimized using knuth morris pratt../src/bt_peer_connection.cpp:663 {
+ | ||
| relevance 0 | ../src/bt_peer_connection.cpp:663 | this could be optimized using knuth morris pratt |
this could be optimized using knuth morris pratt../src/bt_peer_connection.cpp:663 {
disconnect(errors::no_memory, op_encryption);
return;
}
@@ -2986,7 +3226,7 @@ bool block_cache::maybe_free_piece(cached_piece_entry* pe)
// }
// no complete sync
- | ||
| relevance 0 | ../src/bt_peer_connection.cpp:2204 | if we're finished, send upload_only message |
if we're finished, send upload_only message../src/bt_peer_connection.cpp:2204 if (msg[5 + k / 8] & (0x80 >> (k % 8))) bitfield_string[k] = '1';
+ | ||
| relevance 0 | ../src/bt_peer_connection.cpp:2204 | if we're finished, send upload_only message |
if we're finished, send upload_only message../src/bt_peer_connection.cpp:2204 if (msg[5 + k / 8] & (0x80 >> (k % 8))) bitfield_string[k] = '1';
else bitfield_string[k] = '0';
}
peer_log("==> BITFIELD [ %s ]", bitfield_string.c_str());
@@ -3037,7 +3277,7 @@ bool block_cache::maybe_free_piece(cached_piece_entry* pe)
? m_settings.get_str(settings_pack::user_agent)
: m_settings.get_str(settings_pack::handshake_client_version);
}
- | ||
| relevance 0 | ../src/choker.cpp:332 | optimize this using partial_sort or something. We don't need to sort the entire list |
optimize this using partial_sort or something. We don't need
+ | ||
| relevance 0 | ../src/choker.cpp:332 | optimize this using partial_sort or something. We don't need to sort the entire list |
optimize this using partial_sort or something. We don't need
to sort the entire list../src/choker.cpp:332 return upload_slots;
}
@@ -3059,7 +3299,7 @@ to sort the entire list../src/choker.cpp:332
- | ||
| relevance 0 | ../src/choker.cpp:335 | make the comparison function a free function and move it into this cpp file |
make the comparison function a free function and move it
+ | ||
| relevance 0 | ../src/choker.cpp:335 | make the comparison function a free function and move it into this cpp file |
make the comparison function a free function and move it
into this cpp file../src/choker.cpp:335 }
// ==== rate-based ====
@@ -3083,7 +3323,7 @@ into this cpp file../src/choker.cpp:335 std::sort(peers.begin(), peers.end()
, boost::bind(&upload_rate_compare, _1, _2));
- | ||
| relevance 0 | ../src/choker.cpp:340 | make configurable |
make configurable../src/choker.cpp:340 //
+ | ||
| relevance 0 | ../src/choker.cpp:340 | make configurable |
make configurable../src/choker.cpp:340 //
// The rate based unchoker looks at our upload rate to peers, and find
// a balance between number of upload slots and the rate we achieve. The
// intention is to not spread upload bandwidth too thin, but also to not
@@ -3116,7 +3356,7 @@ into this cpp file../src/choker.cpp:335| relevance 0 | ../src/choker.cpp:354 | make configurable |
|
make configurable../src/choker.cpp:354 // it purely based on the current state of our peers.
+ | ||
| relevance 0 | ../src/choker.cpp:354 | make configurable |
make configurable../src/choker.cpp:354 // it purely based on the current state of our peers.
upload_slots = 0;
@@ -3167,8 +3407,8 @@ into this cpp file../src/choker.cpp:335| relevance 0 | ../src/disk_io_thread.cpp:880 | it would be nice to optimize this by having the cache pieces also ordered by |
|
it would be nice to optimize this by having the cache
-pieces also ordered by../src/disk_io_thread.cpp:880 // from disk_io_thread::do_delete, which is a fence job and should
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:879 | it would be nice to optimize this by having the cache pieces also ordered by |
it would be nice to optimize this by having the cache
+pieces also ordered by../src/disk_io_thread.cpp:879 // from disk_io_thread::do_delete, which is a fence job and should
// have any other jobs active, i.e. there should not be any references
// keeping pieces or blocks alive
if ((flags & flush_delete_cache) && (flags & flush_expect_clear))
@@ -3219,8 +3459,8 @@ pieces also ordered by../src/disk_io_thread.cpp:880| relevance 0 | ../src/disk_io_thread.cpp:923 | instead of doing a lookup each time through the loop, save cached_piece_entry pointers with piece_refcount incremented to pin them |
|
instead of doing a lookup each time through the loop, save
-cached_piece_entry pointers with piece_refcount incremented to pin them../src/disk_io_thread.cpp:923 // this is why we pass in 1 as cont_block to the flushing functions
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:922 | instead of doing a lookup each time through the loop, save cached_piece_entry pointers with piece_refcount incremented to pin them |
instead of doing a lookup each time through the loop, save
+cached_piece_entry pointers with piece_refcount incremented to pin them../src/disk_io_thread.cpp:922 // this is why we pass in 1 as cont_block to the flushing functions
void disk_io_thread::try_flush_write_blocks(int num, tailqueue& completed_jobs
, mutex::scoped_lock& l)
{
@@ -3271,10 +3511,10 @@ cached_piece_entry pointers with piece_refcount incremented to pin them
cached_piece_entry* pe = m_disk_cache.find_piece(i->first, i->second);
if (pe == NULL) continue;
if (pe->num_dirty == 0) continue;
- | ||
| relevance 0 | ../src/disk_io_thread.cpp:1134 | instead of doing this. pass in the settings to each storage_interface call. Each disk thread could hold its most recent understanding of the settings in a shared_ptr, and update it every time it wakes up from a job. That way each access to the settings won't require a mutex to be held. |
instead of doing this. pass in the settings to each storage_interface
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:1133 | instead of doing this. pass in the settings to each storage_interface call. Each disk thread could hold its most recent understanding of the settings in a shared_ptr, and update it every time it wakes up from a job. That way each access to the settings won't require a mutex to be held. |
instead of doing this. pass in the settings to each storage_interface
call. Each disk thread could hold its most recent understanding of the settings
in a shared_ptr, and update it every time it wakes up from a job. That way
-each access to the settings won't require a mutex to be held.../src/disk_io_thread.cpp:1134 {
+each access to the settings won't require a mutex to be held.../src/disk_io_thread.cpp:1133 {
INVARIANT_CHECK;
TORRENT_ASSERT(j->next == 0);
TORRENT_ASSERT((j->flags & disk_io_job::in_progress) || !j->storage);
@@ -3318,9 +3558,9 @@ each access to the settings won't require a mutex to be held.../src/dis
// our quanta in case there aren't any other
// jobs to run in between
- | ||
| relevance 0 | ../src/disk_io_thread.cpp:1162 | a potentially more efficient solution would be to have a special queue for retry jobs, that's only ever run when a job completes, in any thread. It would only work if counters::num_running_disk_jobs > 0 |
a potentially more efficient solution would be to have a special
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:1161 | a potentially more efficient solution would be to have a special queue for retry jobs, that's only ever run when a job completes, in any thread. It would only work if counters::num_running_disk_jobs > 0 |
a potentially more efficient solution would be to have a special
queue for retry jobs, that's only ever run when a job completes, in
-any thread. It would only work if counters::num_running_disk_jobs > 0../src/disk_io_thread.cpp:1162
+any thread. It would only work if counters::num_running_disk_jobs > 0../src/disk_io_thread.cpp:1161
ptime start_time = time_now_hires();
m_stats_counters.inc_stats_counter(counters::num_running_disk_jobs, 1);
@@ -3351,7 +3591,7 @@ any thread. It would only work if counters::num_running_disk_jobs > 0..
}
#if TORRENT_USE_ASSERT
- | ||
| relevance 0 | ../src/disk_io_thread.cpp:1176 | it should clear the hash state even when there's an error, right? |
it should clear the hash state even when there's an error, right?../src/disk_io_thread.cpp:1176 m_stats_counters.inc_stats_counter(counters::num_running_disk_jobs, -1);
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:1175 | it should clear the hash state even when there's an error, right? |
it should clear the hash state even when there's an error, right?../src/disk_io_thread.cpp:1175 m_stats_counters.inc_stats_counter(counters::num_running_disk_jobs, -1);
if (ret == retry_job)
{
@@ -3402,8 +3642,8 @@ any thread. It would only work if counters::num_running_disk_jobs > 0..
j->error.operation = storage_error::alloc_cache_piece;
return -1;
}
- | ||
| relevance 0 | ../src/disk_io_thread.cpp:1871 | maybe the tailqueue_iterator should contain a pointer-pointer instead and have an unlink function |
maybe the tailqueue_iterator should contain a pointer-pointer
-instead and have an unlink function../src/disk_io_thread.cpp:1871 j->callback = handler;
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:1870 | maybe the tailqueue_iterator should contain a pointer-pointer instead and have an unlink function |
maybe the tailqueue_iterator should contain a pointer-pointer
+instead and have an unlink function../src/disk_io_thread.cpp:1870 j->callback = handler;
add_fence_job(storage, j);
}
@@ -3454,8 +3694,8 @@ instead and have an unlink function../src/disk_io_thread.cpp:1871<
if (completed_jobs.size())
add_completed_jobs(completed_jobs);
}
- | ||
| relevance 0 | ../src/disk_io_thread.cpp:2126 | this is potentially very expensive. One way to solve it would be to have a fence for just this one piece. |
this is potentially very expensive. One way to solve
-it would be to have a fence for just this one piece.../src/disk_io_thread.cpp:2126 }
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:2125 | this is potentially very expensive. One way to solve it would be to have a fence for just this one piece. |
this is potentially very expensive. One way to solve
+it would be to have a fence for just this one piece.../src/disk_io_thread.cpp:2125 }
void disk_io_thread::async_clear_piece(piece_manager* storage, int index
, boost::function<void(disk_io_job const*)> const& handler)
@@ -3506,7 +3746,7 @@ it would be to have a fence for just this one piece.../src/disk_io_thre
if (!pe->hash) return;
if (pe->hashing) return;
- | ||
| relevance 0 | ../src/disk_io_thread.cpp:2387 | we should probably just hang the job on the piece and make sure the hasher gets kicked |
we should probably just hang the job on the piece and make sure the hasher gets kicked../src/disk_io_thread.cpp:2387 if (pe == NULL)
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:2386 | we should probably just hang the job on the piece and make sure the hasher gets kicked |
we should probably just hang the job on the piece and make sure the hasher gets kicked../src/disk_io_thread.cpp:2386 if (pe == NULL)
{
int cache_state = (j->flags & disk_io_job::volatile_read)
? cached_piece_entry::volatile_read_lru
@@ -3557,8 +3797,8 @@ it would be to have a fence for just this one piece.../src/disk_io_thre
// increment the refcounts of all
// blocks up front, and then hash them without holding the lock
- | ||
| relevance 0 | ../src/disk_io_thread.cpp:2457 | introduce a holder class that automatically increments and decrements the piece_refcount |
introduce a holder class that automatically increments
-and decrements the piece_refcount../src/disk_io_thread.cpp:2457 for (int i = ph->offset / block_size; i < blocks_in_piece; ++i)
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:2456 | introduce a holder class that automatically increments and decrements the piece_refcount |
introduce a holder class that automatically increments
+and decrements the piece_refcount../src/disk_io_thread.cpp:2456 for (int i = ph->offset / block_size; i < blocks_in_piece; ++i)
{
iov.iov_len = (std::min)(block_size, piece_size - ph->offset);
@@ -3609,8 +3849,8 @@ and decrements the piece_refcount../src/disk_io_thread.cpp:2457 | ||
| relevance 0 | ../src/disk_io_thread.cpp:2699 | it would be nice to not have to lock the mutex every turn through this loop |
it would be nice to not have to lock the mutex every
-turn through this loop../src/disk_io_thread.cpp:2699 {
+ | ||
| relevance 0 | ../src/disk_io_thread.cpp:2698 | it would be nice to not have to lock the mutex every turn through this loop |
it would be nice to not have to lock the mutex every
+turn through this loop../src/disk_io_thread.cpp:2698 {
j->error.ec = error::no_memory;
j->error.operation = storage_error::alloc_cache_piece;
return -1;
@@ -3661,66 +3901,15 @@ turn through this loop../src/disk_io_thread.cpp:2699| relevance 0 | ../src/http_tracker_connection.cpp:93 | support authentication (i.e. user name and password) in the URL |
|
support authentication (i.e. user name and password) in the URL../src/http_tracker_connection.cpp:93
- http_tracker_connection::http_tracker_connection(
- io_service& ios
- , tracker_manager& man
- , tracker_request const& req
- , boost::weak_ptr<request_callback> c
- , std::string const& auth
-#if TORRENT_USE_I2P
- , i2p_connection* i2p_conn
-#endif
- )
- : tracker_connection(man, req, ios, c)
- , m_man(man)
-#if TORRENT_USE_I2P
- , m_i2p_conn(i2p_conn)
-#endif
- {}
-
- void http_tracker_connection::start()
- {
- std::string url = tracker_req().url;
-
- if (tracker_req().kind == tracker_request::scrape_request)
- {
- // find and replace "announce" with "scrape"
- // in request
-
- std::size_t pos = url.find("announce");
- if (pos == std::string::npos)
- {
- tracker_connection::fail(error_code(errors::scrape_not_available));
- return;
- }
- url.replace(pos, 8, "scrape");
- }
-
-#if TORRENT_USE_I2P
- bool i2p = is_i2p_url(url);
-#else
- static const bool i2p = false;
-#endif
-
- aux::session_settings const& settings = m_man.settings();
-
- // if request-string already contains
- // some parameters, append an ampersand instead
- // of a question mark
- size_t arguments_start = url.find('?');
- if (arguments_start != std::string::npos)
- url += "&";
- else
- | ||
| relevance 0 | ../src/http_tracker_connection.cpp:194 | support this somehow |
support this somehow../src/http_tracker_connection.cpp:194 url += escape_string(id.c_str(), id.length());
+ | ||
| relevance 0 | ../src/http_tracker_connection.cpp:187 | support this somehow |
support this somehow../src/http_tracker_connection.cpp:187 url += escape_string(id.c_str(), id.length());
}
#if TORRENT_USE_I2P
- if (i2p)
+ if (i2p && tracker_req().i2pconn)
{
url += "&ip=";
- url += escape_string(m_i2p_conn->local_endpoint().c_str()
- , m_i2p_conn->local_endpoint().size());
+ url += escape_string(tracker_req().i2pconn->local_endpoint().c_str()
+ , tracker_req().i2pconn->local_endpoint().size());
url += ".i2p";
}
else
@@ -3763,7 +3952,7 @@ turn through this loop../src/disk_io_thread.cpp:2699| relevance 0 | ../src/metadata_transfer.cpp:359 | this is not safe. The torrent could be unloaded while we're still sending the metadata |
|
this is not safe. The torrent could be unloaded while
+ | ||
| relevance 0 | ../src/metadata_transfer.cpp:359 | this is not safe. The torrent could be unloaded while we're still sending the metadata |
this is not safe. The torrent could be unloaded while
we're still sending the metadata../src/metadata_transfer.cpp:359 std::pair<int, int> offset
= req_to_offset(req, (int)m_tp.metadata().left());
@@ -3815,7 +4004,7 @@ we're still sending the metadata../src/metadata_transfer.cpp:359 | ||
| relevance 0 | ../src/packet_buffer.cpp:176 | use compare_less_wrap for this comparison as well |
use compare_less_wrap for this comparison as well../src/packet_buffer.cpp:176 while (new_size < size)
+ | ||
| relevance 0 | ../src/packet_buffer.cpp:176 | use compare_less_wrap for this comparison as well |
use compare_less_wrap for this comparison as well../src/packet_buffer.cpp:176 while (new_size < size)
new_size <<= 1;
void** new_storage = (void**)malloc(sizeof(void*) * new_size);
@@ -3866,7 +4055,7 @@ we're still sending the metadata../src/metadata_transfer.cpp:359 | ||
| relevance 0 | ../src/part_file.cpp:252 | what do we do if someone is currently reading from the disk from this piece? does it matter? Since we won't actively erase the data from disk, but it may be overwritten soon, it's probably not that big of a deal |
what do we do if someone is currently reading from the disk
+ | ||
| relevance 0 | ../src/part_file.cpp:252 | what do we do if someone is currently reading from the disk from this piece? does it matter? Since we won't actively erase the data from disk, but it may be overwritten soon, it's probably not that big of a deal |
what do we do if someone is currently reading from the disk
from this piece? does it matter? Since we won't actively erase the
data from disk, but it may be overwritten soon, it's probably not that
big of a deal../src/part_file.cpp:252 if (((mode & file::rw_mask) != file::read_only)
@@ -3920,7 +4109,7 @@ big of a deal../src/part_file.cpp:252| relevance 0 | ../src/part_file.cpp:344 | instead of rebuilding the whole file header and flushing it, update the slot entries as we go |
|
instead of rebuilding the whole file header
+ | ||
| relevance 0 | ../src/part_file.cpp:344 | instead of rebuilding the whole file header and flushing it, update the slot entries as we go |
instead of rebuilding the whole file header
and flushing it, update the slot entries as we go../src/part_file.cpp:344 if (block_to_copy == m_piece_size)
{
m_free_slots.push_back(i->second);
@@ -3972,7 +4161,7 @@ and flushing it, update the slot entries as we go../src/part_file.cpp:3
write_uint32(m_max_pieces, ptr);
write_uint32(m_piece_size, ptr);
- | ||
| relevance 0 | ../src/peer_connection.cpp:1022 | this should be the global download rate |
this should be the global download rate../src/peer_connection.cpp:1022
+ | ||
| relevance 0 | ../src/peer_connection.cpp:1027 | this should be the global download rate |
this should be the global download rate../src/peer_connection.cpp:1027
int rate = 0;
// if we haven't received any data recently, the current download rate
@@ -4023,7 +4212,7 @@ and flushing it, update the slot entries as we go../src/part_file.cpp:3
if (m_ignore_stats) return;
boost::shared_ptr<torrent> t = m_torrent.lock();
if (!t) return;
- | ||
| relevance 0 | ../src/peer_connection.cpp:3229 | sort the allowed fast set in priority order |
sort the allowed fast set in priority order../src/peer_connection.cpp:3229
+ | ||
| relevance 0 | ../src/peer_connection.cpp:3234 | sort the allowed fast set in priority order |
sort the allowed fast set in priority order../src/peer_connection.cpp:3234
// if the peer has the piece and we want
// to download it, request it
if (int(m_have_piece.size()) > index
@@ -4074,8 +4263,8 @@ and flushing it, update the slot entries as we go../src/part_file.cpp:3
boost::shared_ptr<torrent> t = m_torrent.lock();
TORRENT_ASSERT(t);
TORRENT_ASSERT(t->has_picker());
- | ||
| relevance 0 | ../src/peer_connection.cpp:5891 | The stats checks can not be honored when authenticated encryption is in use because we may have encrypted data which we cannot authenticate yet |
The stats checks can not be honored when authenticated encryption is in use
-because we may have encrypted data which we cannot authenticate yet../src/peer_connection.cpp:5891#if defined TORRENT_LOGGING
+ | ||
| relevance 0 | ../src/peer_connection.cpp:5897 | The stats checks can not be honored when authenticated encryption is in use because we may have encrypted data which we cannot authenticate yet |
The stats checks can not be honored when authenticated encryption is in use
+because we may have encrypted data which we cannot authenticate yet../src/peer_connection.cpp:5897#if defined TORRENT_LOGGING
peer_log("<<< read %d bytes", int(bytes_transferred));
#endif
// correct the dl quota usage, if not all of the buffer was actually read
@@ -4126,8 +4315,8 @@ because we may have encrypted data which we cannot authenticate yet../s
}
if (num_loops > read_loops) break;
- | ||
| relevance 0 | ../src/piece_picker.cpp:2407 | when expanding pieces for cache stripe reasons, the !downloading condition doesn't make much sense |
when expanding pieces for cache stripe reasons,
-the !downloading condition doesn't make much sense../src/piece_picker.cpp:2407 TORRENT_ASSERT(index < (int)m_piece_map.size() || m_piece_map.empty());
+ | ||
| relevance 0 | ../src/piece_picker.cpp:2452 | when expanding pieces for cache stripe reasons, the !downloading condition doesn't make much sense |
when expanding pieces for cache stripe reasons,
+the !downloading condition doesn't make much sense../src/piece_picker.cpp:2452 TORRENT_ASSERT(index < (int)m_piece_map.size() || m_piece_map.empty());
if (index+1 == (int)m_piece_map.size())
return m_blocks_in_last_piece;
else
@@ -4177,9 +4366,8 @@ the !downloading condition doesn't make much sense../src/piece_picker.c
// blocks from this piece.
// the second bool is true if this is the only active peer that is requesting
// and downloading blocks from this piece. Active means having a connection.
- boost::tuple<bool, bool> requested_from(piece_picker::downloading_piece const& p
- | ||
| relevance 0 | ../src/session_impl.cpp:507 | there's no rule here to make uTP connections not have the global or local rate limits apply to it. This used to be the default. |
there's no rule here to make uTP connections not have the global or
-local rate limits apply to it. This used to be the default.../src/session_impl.cpp:507 m_global_class = m_classes.new_peer_class("global");
+ | ||
| relevance 0 | ../src/session_impl.cpp:512 | there's no rule here to make uTP connections not have the global or local rate limits apply to it. This used to be the default. |
there's no rule here to make uTP connections not have the global or
+local rate limits apply to it. This used to be the default.../src/session_impl.cpp:512 m_global_class = m_classes.new_peer_class("global");
m_tcp_peer_class = m_classes.new_peer_class("tcp");
m_local_peer_class = m_classes.new_peer_class("local");
// local peers are always unchoked
@@ -4230,9 +4418,9 @@ local rate limits apply to it. This used to be the default.../src/sessi
, int(rl.rlim_cur * 8 / 10)));
// 20% goes towards regular files (see disk_io_thread)
#if defined TORRENT_LOGGING
- | ||
| relevance 0 | ../src/session_impl.cpp:1722 | instead of having a special case for this, just make the default listen interfaces be "0.0.0.0:6881,[::1]:6881" and use the generic path. That would even allow for not listening at all. |
instead of having a special case for this, just make the
+ | ||
| relevance 0 | ../src/session_impl.cpp:1727 | instead of having a special case for this, just make the default listen interfaces be "0.0.0.0:6881,[::1]:6881" and use the generic path. That would even allow for not listening at all. |
instead of having a special case for this, just make the
default listen interfaces be "0.0.0.0:6881,[::1]:6881" and use
-the generic path. That would even allow for not listening at all.../src/session_impl.cpp:1722
+the generic path. That would even allow for not listening at all.../src/session_impl.cpp:1727
// reset the retry counter
m_listen_port_retries = m_settings.get_int(settings_pack::max_retry_port_bind);
@@ -4283,7 +4471,7 @@ retry:
if (s.sock)
{
TORRENT_ASSERT(!m_abort);
- | ||
| relevance 0 | ../src/session_impl.cpp:2615 | should this function take a shared_ptr instead? |
should this function take a shared_ptr instead?../src/session_impl.cpp:2615 {
+ | ||
| relevance 0 | ../src/session_impl.cpp:2620 | should this function take a shared_ptr instead? |
should this function take a shared_ptr instead?../src/session_impl.cpp:2620 {
#if defined TORRENT_ASIO_DEBUGGING
complete_async("session_impl::on_socks_accept");
#endif
@@ -4334,7 +4522,7 @@ retry:
TORRENT_ASSERT(sp.use_count() > 0);
connection_map::iterator i = m_connections.find(sp);
- | ||
| relevance 0 | ../src/session_impl.cpp:2980 | have a separate list for these connections, instead of having to loop through all of them |
have a separate list for these connections, instead of having to loop through all of them../src/session_impl.cpp:2980 if (m_auto_manage_time_scaler < 0)
+ | ||
| relevance 0 | ../src/session_impl.cpp:2985 | have a separate list for these connections, instead of having to loop through all of them |
have a separate list for these connections, instead of having to loop through all of them../src/session_impl.cpp:2985 if (m_auto_manage_time_scaler < 0)
{
INVARIANT_CHECK;
m_auto_manage_time_scaler = settings().get_int(settings_pack::auto_manage_interval);
@@ -4383,9 +4571,18 @@ retry:
if (!t.want_tick()) --i;
}
-#ifndef TORRENT_DISABLE_DHT
- int dht_down = 0;
- | ||
| relevance 0 | ../src/session_impl.cpp:3021 | this should apply to all bandwidth channels |
this should apply to all bandwidth channels../src/session_impl.cpp:3021 t.second_tick(tick_interval_ms, m_tick_residual / 1000);
+ | ||
| relevance 0 | ../src/session_impl.cpp:3015 | this should apply to all bandwidth channels |
this should apply to all bandwidth channels../src/session_impl.cpp:3015#if TORRENT_DEBUG_STREAMING > 0
+ printf("\033[2J\033[0;0H");
+#endif
+
+ std::vector<torrent*>& want_tick = m_torrent_lists[torrent_want_tick];
+ for (int i = 0; i < int(want_tick.size()); ++i)
+ {
+ torrent& t = *want_tick[i];
+ TORRENT_ASSERT(t.want_tick());
+ TORRENT_ASSERT(!t.is_aborted());
+
+ t.second_tick(tick_interval_ms, m_tick_residual / 1000);
// if the call to second_tick caused the torrent
// to no longer want to be ticked (i.e. it was
@@ -4394,26 +4591,8 @@ retry:
if (!t.want_tick()) --i;
}
-#ifndef TORRENT_DISABLE_DHT
- int dht_down = 0;
- int dht_up = 0;
- if (m_dht)
- {
- m_dht->network_stats(dht_up, dht_down);
- m_stats_counters.inc_stats_counter(counters::sent_dht_bytes, dht_up);
- m_stats_counters.inc_stats_counter(counters::recv_dht_bytes, dht_down);
- }
-#endif
-
if (m_settings.get_bool(settings_pack::rate_limit_ip_overhead))
{
- peer_class* gpc = m_classes.at(m_global_class);
-
-#ifndef TORRENT_DISABLE_DHT
- gpc->channel[peer_connection::download_channel].use_quota(dht_down);
- gpc->channel[peer_connection::upload_channel].use_quota(dht_up);
-#endif
-
int up_limit = upload_rate_limit(m_global_class);
int down_limit = download_rate_limit(m_global_class);
@@ -4436,7 +4615,14 @@ retry:
m_peak_up_rate = (std::max)(m_stat.upload_rate(), m_peak_up_rate);
m_peak_down_rate = (std::max)(m_stat.download_rate(), m_peak_down_rate);
- | ||
| relevance 0 | ../src/session_impl.cpp:3509 | these vectors could be copied from m_torrent_lists, if we would maintain them. That way the first pass over all torrents could be avoided. It would be especially efficient if most torrents are not auto-managed whenever we receive a scrape response (or anything that may change the rank of a torrent) that one torrent could re-sort itself in a list that's kept sorted at all times. That way, this pass over all torrents could be avoided alltogether. |
these vectors could be copied from m_torrent_lists,
+
+ m_stat.second_tick(tick_interval_ms);
+
+ // --------------------------------------------------------------
+ // scrape paused torrents that are auto managed
+ // (unless the session is paused)
+ // --------------------------------------------------------------
+ | ||
| relevance 0 | ../src/session_impl.cpp:3496 | these vectors could be copied from m_torrent_lists, if we would maintain them. That way the first pass over all torrents could be avoided. It would be especially efficient if most torrents are not auto-managed whenever we receive a scrape response (or anything that may change the rank of a torrent) that one torrent could re-sort itself in a list that's kept sorted at all times. That way, this pass over all torrents could be avoided alltogether. |
these vectors could be copied from m_torrent_lists,
if we would maintain them. That way the first pass over
all torrents could be avoided. It would be especially
efficient if most torrents are not auto-managed
@@ -4444,7 +4630,7 @@ whenever we receive a scrape response (or anything
that may change the rank of a torrent) that one torrent
could re-sort itself in a list that's kept sorted at all
times. That way, this pass over all torrents could be
-avoided alltogether.../src/session_impl.cpp:3509#if defined TORRENT_LOGGING
+avoided alltogether.../src/session_impl.cpp:3496#if defined TORRENT_LOGGING
if (t->allows_peers())
t->log_to_all_peers("AUTO MANAGER PAUSING TORRENT");
#endif
@@ -4495,7 +4681,7 @@ avoided alltogether.../src/session_impl.cpp:3509| relevance 0 | ../src/session_impl.cpp:3586 | allow extensions to sort torrents for queuing |
|
allow extensions to sort torrents for queuing../src/session_impl.cpp:3586 if (t->is_finished())
+ | ||
| relevance 0 | ../src/session_impl.cpp:3573 | allow extensions to sort torrents for queuing |
allow extensions to sort torrents for queuing../src/session_impl.cpp:3573 if (t->is_finished())
seeds.push_back(t);
else
downloaders.push_back(t);
@@ -4546,9 +4732,9 @@ avoided alltogether.../src/session_impl.cpp:3509| relevance 0 | ../src/session_impl.cpp:3759 | use a lower limit than m_settings.connections_limit to allocate the to 10% or so of connection slots for incoming connections |
|
use a lower limit than m_settings.connections_limit
+ | ||
| relevance 0 | ../src/session_impl.cpp:3746 | use a lower limit than m_settings.connections_limit to allocate the to 10% or so of connection slots for incoming connections |
use a lower limit than m_settings.connections_limit
to allocate the to 10% or so of connection slots for incoming
-connections../src/session_impl.cpp:3759 // robin fashion, so that every torrent is equally likely to connect to a
+connections../src/session_impl.cpp:3746 // robin fashion, so that every torrent is equally likely to connect to a
// peer
// boost connections are connections made by torrent connection
@@ -4599,8 +4785,8 @@ connections../src/session_impl.cpp:3759| relevance 0 | ../src/session_impl.cpp:3902 | post a message to have this happen immediately instead of waiting for the next tick |
|
post a message to have this happen
-immediately instead of waiting for the next tick../src/session_impl.cpp:3902 torrent* t = p->associated_torrent().lock().get();
+ | ||
| relevance 0 | ../src/session_impl.cpp:3889 | post a message to have this happen immediately instead of waiting for the next tick |
post a message to have this happen
+immediately instead of waiting for the next tick../src/session_impl.cpp:3889 torrent* t = p->associated_torrent().lock().get();
torrent_peer* pi = p->peer_info_struct();
if (p->ignore_unchoke_slots() || t == 0 || pi == 0
@@ -4651,7 +4837,7 @@ immediately instead of waiting for the next tick../src/session_impl.cpp
int num_opt_unchoke = m_settings.get_int(settings_pack::num_optimistic_unchoke_slots);
if (num_opt_unchoke == 0) num_opt_unchoke = (std::max)(1, allowed_upload_slots / 5);
- | ||
| relevance 0 | ../src/session_impl.cpp:3949 | this should be called for all peers! |
this should be called for all peers!../src/session_impl.cpp:3949 , unchoke_interval, m_settings);
+ | ||
| relevance 0 | ../src/session_impl.cpp:3936 | this should be called for all peers! |
this should be called for all peers!../src/session_impl.cpp:3936 , unchoke_interval, m_settings);
m_stats_counters.set_value(counters::num_unchoke_slots
, allowed_upload_slots);
@@ -4702,14 +4888,14 @@ immediately instead of waiting for the next tick../src/session_impl.cpp
{
// no, this peer should be choked
TORRENT_ASSERT(p->peer_info_struct());
- | ||
| relevance 0 | ../src/session_impl.cpp:4341 | it might be a nice feature here to limit the number of torrents to send in a single update. By just posting the first n torrents, they would nicely be round-robined because the torrent lists are always pushed back |
it might be a nice feature here to limit the number of torrents
+ | ||
| relevance 0 | ../src/session_impl.cpp:4327 | it might be a nice feature here to limit the number of torrents to send in a single update. By just posting the first n torrents, they would nicely be round-robined because the torrent lists are always pushed back |
it might be a nice feature here to limit the number of torrents
to send in a single update. By just posting the first n torrents, they
would nicely be round-robined because the torrent lists are always
-pushed back../src/session_impl.cpp:4341 t->status(&*i, flags);
+pushed back../src/session_impl.cpp:4327 t->status(&*i, flags);
}
}
- void session_impl::post_torrent_updates()
+ void session_impl::post_torrent_updates(boost::uint32_t flags)
{
INVARIANT_CHECK;
@@ -4735,7 +4921,7 @@ pushed back../src/session_impl.cpp:4341 | ||
| relevance 0 | ../src/storage.cpp:716 | make this more generic to not just work if files have been renamed, but also if they have been merged into a single file for instance maybe use the same format as .torrent files and reuse some code from torrent_info |
make this more generic to not just work if files have been
+ | ||
| relevance 0 | ../src/storage.cpp:716 | make this more generic to not just work if files have been renamed, but also if they have been merged into a single file for instance maybe use the same format as .torrent files and reuse some code from torrent_info |
make this more generic to not just work if files have been
renamed, but also if they have been merged into a single file for instance
maybe use the same format as .torrent files and reuse some code from torrent_info../src/storage.cpp:716 for (;;)
{
@@ -4809,7 +4995,7 @@ maybe use the same format as .torrent files and reuse some code from torrent_inf
if (file_sizes_ent->list_size() == 0)
{
ec.ec = errors::no_files_in_resume_data;
- | ||
| relevance 0 | ../src/storage.cpp:1012 | if everything moves OK, except for the partfile we currently won't update the save path, which breaks things. it would probably make more sense to give up on the partfile |
if everything moves OK, except for the partfile
+ | ||
| relevance 0 | ../src/storage.cpp:1012 | if everything moves OK, except for the partfile we currently won't update the save path, which breaks things. it would probably make more sense to give up on the partfile |
if everything moves OK, except for the partfile
we currently won't update the save path, which breaks things.
it would probably make more sense to give up on the partfile../src/storage.cpp:1012 if (ec)
{
@@ -4862,8 +5048,8 @@ it would probably make more sense to give up on the partfile../src/stor
{
fileop op = { &file::writev
, file::read_write | flags };
- | ||
| relevance 0 | ../src/torrent.cpp:507 | if the existing torrent doesn't have metadata, insert the metadata we just downloaded into it. |
if the existing torrent doesn't have metadata, insert
-the metadata we just downloaded into it.../src/torrent.cpp:507
+ | ||
| relevance 0 | ../src/torrent.cpp:508 | if the existing torrent doesn't have metadata, insert the metadata we just downloaded into it. |
if the existing torrent doesn't have metadata, insert
+the metadata we just downloaded into it.../src/torrent.cpp:508
m_torrent_file = tf;
// now, we might already have this torrent in the session.
@@ -4914,8 +5100,8 @@ the metadata we just downloaded into it.../src/torrent.cpp:507 | ||
| relevance 0 | ../src/torrent.cpp:658 | if the existing torrent doesn't have metadata, insert the metadata we just downloaded into it. |
if the existing torrent doesn't have metadata, insert
-the metadata we just downloaded into it.../src/torrent.cpp:658 m_torrent_file = tf;
+ | ||
| relevance 0 | ../src/torrent.cpp:659 | if the existing torrent doesn't have metadata, insert the metadata we just downloaded into it. |
if the existing torrent doesn't have metadata, insert
+the metadata we just downloaded into it.../src/torrent.cpp:659 m_torrent_file = tf;
m_info_hash = tf->info_hash();
// now, we might already have this torrent in the session.
@@ -4966,12 +5152,12 @@ the metadata we just downloaded into it.../src/torrent.cpp:658 | ||
| relevance 0 | ../src/torrent.cpp:1460 | is verify_peer_cert called once per certificate in the chain, and this function just tells us which depth we're at right now? If so, the comment makes sense. any certificate that isn't the leaf (i.e. the one presented by the peer) should be accepted automatically, given preverified is true. The leaf certificate need to be verified to make sure its DN matches the info-hash |
is verify_peer_cert called once per certificate in the chain, and
+ | ||
| relevance 0 | ../src/torrent.cpp:1461 | is verify_peer_cert called once per certificate in the chain, and this function just tells us which depth we're at right now? If so, the comment makes sense. any certificate that isn't the leaf (i.e. the one presented by the peer) should be accepted automatically, given preverified is true. The leaf certificate need to be verified to make sure its DN matches the info-hash |
is verify_peer_cert called once per certificate in the chain, and
this function just tells us which depth we're at right now? If so, the comment
makes sense.
any certificate that isn't the leaf (i.e. the one presented by the peer)
should be accepted automatically, given preverified is true. The leaf certificate
-need to be verified to make sure its DN matches the info-hash../src/torrent.cpp:1460 if (pp) p->add_extension(pp);
+need to be verified to make sure its DN matches the info-hash../src/torrent.cpp:1461 if (pp) p->add_extension(pp);
}
// if files are checked for this torrent, call the extension
@@ -5022,8 +5208,8 @@ need to be verified to make sure its DN matches the info-hash../src/tor
{
#if defined TORRENT_LOGGING
match = true;
- | ||
| relevance 0 | ../src/torrent.cpp:1864 | instead of creating the picker up front here, maybe this whole section should move to need_picker() |
instead of creating the picker up front here,
-maybe this whole section should move to need_picker()../src/torrent.cpp:1864 {
+ | ||
| relevance 0 | ../src/torrent.cpp:1865 | instead of creating the picker up front here, maybe this whole section should move to need_picker() |
instead of creating the picker up front here,
+maybe this whole section should move to need_picker()../src/torrent.cpp:1865 {
m_have_all = true;
m_ses.get_io_service().post(boost::bind(&torrent::files_checked, shared_from_this()));
m_resume_data.reset();
@@ -5074,10 +5260,10 @@ maybe this whole section should move to need_picker()../src/torrent.cpp
// need to consider it finished
std::vector<piece_picker::downloading_piece> dq
- | ||
| relevance 0 | ../src/torrent.cpp:2060 | there may be peer extensions relying on the torrent extension still being alive. Only do this if there are no peers. And when the last peer is disconnected, if the torrent is unloaded, clear the extensions m_extensions.clear(); |
there may be peer extensions relying on the torrent extension
+ | ||
| relevance 0 | ../src/torrent.cpp:2061 | there may be peer extensions relying on the torrent extension still being alive. Only do this if there are no peers. And when the last peer is disconnected, if the torrent is unloaded, clear the extensions m_extensions.clear(); |
there may be peer extensions relying on the torrent extension
still being alive. Only do this if there are no peers. And when the last peer
is disconnected, if the torrent is unloaded, clear the extensions
-m_extensions.clear();../src/torrent.cpp:2060 // pinned torrents are not allowed to be swapped out
+m_extensions.clear();../src/torrent.cpp:2061 // pinned torrents are not allowed to be swapped out
TORRENT_ASSERT(!m_pinned);
m_should_be_loaded = false;
@@ -5128,9 +5314,9 @@ m_extensions.clear();../src/torrent.cpp:2060| relevance 0 | ../src/torrent.cpp:2735 | this pattern is repeated in a few places. Factor this into a function and generalize the concept of a torrent having a dedicated listen port |
|
this pattern is repeated in a few places. Factor this into
+ | ||
| relevance 0 | ../src/torrent.cpp:2736 | this pattern is repeated in a few places. Factor this into a function and generalize the concept of a torrent having a dedicated listen port |
this pattern is repeated in a few places. Factor this into
a function and generalize the concept of a torrent having a
-dedicated listen port../src/torrent.cpp:2735 // if the files haven't been checked yet, we're
+dedicated listen port../src/torrent.cpp:2736 // if the files haven't been checked yet, we're
// not ready for peers. Except, if we don't have metadata,
// we need peers to download from
if (!m_files_checked && valid_metadata()) return;
@@ -5181,7 +5367,7 @@ dedicated listen port../src/torrent.cpp:2735 | ||
| relevance 0 | ../src/torrent.cpp:3508 | add one peer per IP the hostname resolves to |
add one peer per IP the hostname resolves to../src/torrent.cpp:3508#endif
+ | ||
| relevance 0 | ../src/torrent.cpp:3515 | add one peer per IP the hostname resolves to |
add one peer per IP the hostname resolves to../src/torrent.cpp:3515#endif
void torrent::on_peer_name_lookup(error_code const& e
, std::vector<address> const& host_list, int port)
@@ -5232,7 +5418,7 @@ dedicated listen port../src/torrent.cpp:2735| relevance 0 | ../src/torrent.cpp:4499 | update suggest_piece? |
|
update suggest_piece?../src/torrent.cpp:4499
+ | ||
| relevance 0 | ../src/torrent.cpp:4508 | update suggest_piece? |
update suggest_piece?../src/torrent.cpp:4508
void torrent::peer_has_all(peer_connection const* peer)
{
if (has_picker())
@@ -5283,8 +5469,8 @@ dedicated listen port../src/torrent.cpp:2735| relevance 0 | ../src/torrent.cpp:4642 | really, we should just keep the picker around in this case to maintain the availability counters |
|
really, we should just keep the picker around
-in this case to maintain the availability counters../src/torrent.cpp:4642 pieces.reserve(cs.pieces.size());
+ | ||
| relevance 0 | ../src/torrent.cpp:4651 | really, we should just keep the picker around in this case to maintain the availability counters |
really, we should just keep the picker around
+in this case to maintain the availability counters../src/torrent.cpp:4651 pieces.reserve(cs.pieces.size());
// sort in ascending order, to get most recently used first
std::sort(cs.pieces.begin(), cs.pieces.end()
@@ -5335,12 +5521,12 @@ in this case to maintain the availability counters../src/torrent.cpp:46
}
void torrent::abort()
- | ||
| relevance 0 | ../src/torrent.cpp:6614 | make this more generic to not just work if files have been renamed, but also if they have been merged into a single file for instance maybe use the same format as .torrent files and reuse some code from torrent_info The mapped_files needs to be read both in the network thread and in the disk thread, since they both have their own mapped files structures which are kept in sync |
make this more generic to not just work if files have been
+ | ||
| relevance 0 | ../src/torrent.cpp:6623 | make this more generic to not just work if files have been renamed, but also if they have been merged into a single file for instance maybe use the same format as .torrent files and reuse some code from torrent_info The mapped_files needs to be read both in the network thread and in the disk thread, since they both have their own mapped files structures which are kept in sync |
make this more generic to not just work if files have been
renamed, but also if they have been merged into a single file for instance
maybe use the same format as .torrent files and reuse some code from torrent_info
The mapped_files needs to be read both in the network thread
and in the disk thread, since they both have their own mapped files structures
-which are kept in sync../src/torrent.cpp:6614 m_last_upload = tmp == -1 ? (std::numeric_limits<boost::int16_t>::min)() : now - tmp;
+which are kept in sync../src/torrent.cpp:6623 m_last_upload = tmp == -1 ? (std::numeric_limits<boost::int16_t>::min)() : now - tmp;
if (m_use_resume_save_path)
{
@@ -5391,12 +5577,12 @@ which are kept in sync../src/torrent.cpp:6614| relevance 0 | ../src/torrent.cpp:6732 | if this is a merkle torrent and we can't restore the tree, we need to wipe all the bits in the have array, but not necessarily we might want to do a full check to see if we have all the pieces. This is low priority since almost no one uses merkle torrents |
|
if this is a merkle torrent and we can't
+ | ||
| relevance 0 | ../src/torrent.cpp:6741 | if this is a merkle torrent and we can't restore the tree, we need to wipe all the bits in the have array, but not necessarily we might want to do a full check to see if we have all the pieces. This is low priority since almost no one uses merkle torrents |
if this is a merkle torrent and we can't
restore the tree, we need to wipe all the
bits in the have array, but not necessarily
we might want to do a full check to see if we have
all the pieces. This is low priority since almost
-no one uses merkle torrents../src/torrent.cpp:6732 add_web_seed(url, web_seed_entry::http_seed);
+no one uses merkle torrents../src/torrent.cpp:6741 add_web_seed(url, web_seed_entry::http_seed);
}
}
@@ -5447,9 +5633,9 @@ no one uses merkle torrents../src/torrent.cpp:6732 | ||
| relevance 0 | ../src/torrent.cpp:6922 | make this more generic to not just work if files have been renamed, but also if they have been merged into a single file for instance. using file_base |
make this more generic to not just work if files have been
+ | ||
| relevance 0 | ../src/torrent.cpp:6931 | make this more generic to not just work if files have been renamed, but also if they have been merged into a single file for instance. using file_base |
make this more generic to not just work if files have been
renamed, but also if they have been merged into a single file for instance.
-using file_base../src/torrent.cpp:6922 pieces.resize(m_torrent_file->num_pieces());
+using file_base../src/torrent.cpp:6931 pieces.resize(m_torrent_file->num_pieces());
if (!has_picker())
{
std::memset(&pieces[0], m_have_all, pieces.size());
@@ -5500,9 +5686,9 @@ using file_base../src/torrent.cpp:6922| relevance 0 | ../src/torrent.cpp:8924 | add a flag to ignore stats, and only care about resume data for content. For unchanged files, don't trigger a load of the metadata just to save an empty resume data file |
|
add a flag to ignore stats, and only care about resume data for
+ | ||
| relevance 0 | ../src/torrent.cpp:8933 | add a flag to ignore stats, and only care about resume data for content. For unchanged files, don't trigger a load of the metadata just to save an empty resume data file |
add a flag to ignore stats, and only care about resume data for
content. For unchanged files, don't trigger a load of the metadata
-just to save an empty resume data file../src/torrent.cpp:8924 if (m_complete != 0xffffff) seeds = m_complete;
+just to save an empty resume data file../src/torrent.cpp:8933 if (m_complete != 0xffffff) seeds = m_complete;
else seeds = m_peer_list ? m_peer_list->num_seeds() : 0;
if (m_incomplete != 0xffffff) downloaders = m_incomplete;
@@ -5553,10 +5739,10 @@ just to save an empty resume data file../src/torrent.cpp:8924 | ||
| relevance 0 | ../src/torrent.cpp:9886 | go through the pieces we have and count the total number of downloaders we have. Only count peers that are interested in us since some peers might not send have messages for pieces we have it num_interested == 0, we need to pick a new piece |
go through the pieces we have and count the total number
+ | ||
| relevance 0 | ../src/torrent.cpp:9895 | go through the pieces we have and count the total number of downloaders we have. Only count peers that are interested in us since some peers might not send have messages for pieces we have it num_interested == 0, we need to pick a new piece |
go through the pieces we have and count the total number
of downloaders we have. Only count peers that are interested in us
since some peers might not send have messages for pieces we have
-it num_interested == 0, we need to pick a new piece../src/torrent.cpp:9886 }
+it num_interested == 0, we need to pick a new piece../src/torrent.cpp:9895 }
rarest_pieces.clear();
rarest_rarity = pp.peer_count;
@@ -5607,8 +5793,8 @@ it num_interested == 0, we need to pick a new piece../src/torrent.cpp:9
if (num_cache_pieces > m_torrent_file->num_pieces())
num_cache_pieces = m_torrent_file->num_pieces();
- | ||
| relevance 0 | ../src/torrent.cpp:10532 | instead of resorting the whole list, insert the peers directly into the right place |
instead of resorting the whole list, insert the peers
-directly into the right place../src/torrent.cpp:10532 printf("timed out [average-piece-time: %d ms ]\n"
+ | ||
| relevance 0 | ../src/torrent.cpp:10541 | instead of resorting the whole list, insert the peers directly into the right place |
instead of resorting the whole list, insert the peers
+directly into the right place../src/torrent.cpp:10541 printf("timed out [average-piece-time: %d ms ]\n"
, m_average_piece_time);
#endif
}
@@ -5659,7 +5845,7 @@ directly into the right place../src/torrent.cpp:10532| relevance 0 | ../src/torrent_peer.cpp:176 | how do we deal with our external address changing? |
|
how do we deal with our external address changing?../src/torrent_peer.cpp:176 , is_v6_addr(false)
+ | ||
| relevance 0 | ../src/torrent_peer.cpp:176 | how do we deal with our external address changing? |
how do we deal with our external address changing?../src/torrent_peer.cpp:176 , is_v6_addr(false)
#endif
#if TORRENT_USE_I2P
, is_i2p_addr(false)
@@ -5710,7 +5896,7 @@ directly into the right place../src/torrent.cpp:10532| relevance 0 | ../src/udp_socket.cpp:286 | it would be nice to detect this on posix systems also |
|
it would be nice to detect this on posix systems also../src/udp_socket.cpp:286 --m_v6_outstanding;
+ | ||
| relevance 0 | ../src/udp_socket.cpp:286 | it would be nice to detect this on posix systems also |
it would be nice to detect this on posix systems also../src/udp_socket.cpp:286 --m_v6_outstanding;
}
else
#endif
@@ -5761,7 +5947,7 @@ void udp_socket::call_handler(error_code const& ec, udp::endpoint const&
ret = (*i)->incoming_packet(ec, ep, buf, size);
} TORRENT_CATCH (std::exception&) {}
if (*i == NULL) i = m_observers.erase(i);
- | ||
| relevance 0 | ../src/udp_socket.cpp:777 | use the system resolver_interface here |
use the system resolver_interface here../src/udp_socket.cpp:777
+ | ||
| relevance 0 | ../src/udp_socket.cpp:777 | use the system resolver_interface here |
use the system resolver_interface here../src/udp_socket.cpp:777
void udp_socket::set_proxy_settings(proxy_settings const& ps)
{
CHECK_MAGIC;
@@ -5812,7 +5998,7 @@ void udp_socket::on_name_lookup(error_code const& e, tcp::resolver::iterator
+ m_outstanding_socks);
if (m_abort) return;
- | ||
| relevance 0 | ../src/upnp.cpp:71 | listen_interface is not used. It's meant to bind the broadcast socket |
listen_interface is not used. It's meant to bind the broadcast socket../src/upnp.cpp:71#include <asio/ip/multicast.hpp>
+ | ||
| relevance 0 | ../src/upnp.cpp:71 | listen_interface is not used. It's meant to bind the broadcast socket |
listen_interface is not used. It's meant to bind the broadcast socket../src/upnp.cpp:71#include <asio/ip/multicast.hpp>
#else
#include <boost/asio/ip/host_name.hpp>
#include <boost/asio/ip/multicast.hpp>
@@ -5863,7 +6049,7 @@ void upnp::start(void* state)
if (state)
{
upnp_state_t* s = (upnp_state_t*)state;
- | ||
| relevance 0 | ../src/ut_metadata.cpp:316 | we really need to increment the refcounter on the torrent while this buffer is still in the peer's send buffer |
we really need to increment the refcounter on the torrent
+ | ||
| relevance 0 | ../src/ut_metadata.cpp:316 | we really need to increment the refcounter on the torrent while this buffer is still in the peer's send buffer |
we really need to increment the refcounter on the torrent
while this buffer is still in the peer's send buffer../src/ut_metadata.cpp:316 if (!m_tp.need_loaded()) return;
metadata = m_tp.metadata().begin + offset;
metadata_piece_size = (std::min)(
@@ -5915,7 +6101,7 @@ while this buffer is still in the peer's send buffer../src/ut_metadata.
#ifdef TORRENT_LOGGING
m_pc.peer_log("<== UT_METADATA [ not a dictionary ]");
#endif
- | ||
| relevance 0 | ../src/utp_stream.cpp:1644 | this loop may not be very efficient |
this loop may not be very efficient../src/utp_stream.cpp:1644
+ | ||
| relevance 0 | ../src/utp_stream.cpp:1644 | this loop may not be very efficient |
this loop may not be very efficient../src/utp_stream.cpp:1644
char* m_buf;
};
@@ -5966,7 +6152,7 @@ bool utp_socket_impl::send_pkt(int flags)
if (sack > 32) sack = 32;
}
- | ||
| relevance 0 | ../src/web_connection_base.cpp:73 | introduce a web-seed default class which has a low download priority |
introduce a web-seed default class which has a low download priority../src/web_connection_base.cpp:73{
+ | ||
| relevance 0 | ../src/web_connection_base.cpp:73 | introduce a web-seed default class which has a low download priority |
introduce a web-seed default class which has a low download priority../src/web_connection_base.cpp:73{
web_connection_base::web_connection_base(
peer_connection_args const& pack
, web_seed_t& web)
@@ -6017,8 +6203,8 @@ bool utp_socket_impl::send_pkt(int flags)
// according to the settings.
return m_settings.get_int(settings_pack::urlseed_timeout);
}
- | ||
| relevance 0 | ../src/kademlia/dht_tracker.cpp:437 | ideally this function would be called when the put completes |
ideally this function would be called when the
-put completes../src/kademlia/dht_tracker.cpp:437 // since it controls whether we re-put the content
+ | ||
| relevance 0 | ../src/kademlia/dht_tracker.cpp:295 | ideally this function would be called when the put completes |
ideally this function would be called when the
+put completes../src/kademlia/dht_tracker.cpp:295 // since it controls whether we re-put the content
TORRENT_ASSERT(!it.is_mutable());
f(it);
return false;
@@ -6069,7 +6255,7 @@ put completes../src/kademlia/dht_tracker.cpp:437| relevance 0 | ../include/libtorrent/bitfield.hpp:158 | rename to data() ? |
|
rename to data() ?../include/libtorrent/bitfield.hpp:158 if (m_buf[i] != 0) return false;
+ | ||
| relevance 0 | ../include/libtorrent/bitfield.hpp:158 | rename to data() ? |
rename to data() ?../include/libtorrent/bitfield.hpp:158 if (m_buf[i] != 0) return false;
}
return true;
}
@@ -6120,7 +6306,7 @@ put completes../src/kademlia/dht_tracker.cpp:437| relevance 0 | ../include/libtorrent/block_cache.hpp:213 | make this 32 bits and to count seconds since the block cache was created |
|
make this 32 bits and to count seconds since the block cache was created../include/libtorrent/block_cache.hpp:213
+ | ||
| relevance 0 | ../include/libtorrent/block_cache.hpp:213 | make this 32 bits and to count seconds since the block cache was created |
make this 32 bits and to count seconds since the block cache was created../include/libtorrent/block_cache.hpp:213
bool operator==(cached_piece_entry const& rhs) const
{ return storage.get() == rhs.storage.get() && piece == rhs.piece; }
@@ -6171,7 +6357,7 @@ put completes../src/kademlia/dht_tracker.cpp:437| relevance 0 | ../include/libtorrent/config.hpp:334 | Make this count Unicode characters instead of bytes on windows |
|
Make this count Unicode characters instead of bytes on windows../include/libtorrent/config.hpp:334#pragma message ( "unknown OS, assuming BSD" )
+ | ||
| relevance 0 | ../include/libtorrent/config.hpp:334 | Make this count Unicode characters instead of bytes on windows |
Make this count Unicode characters instead of bytes on windows../include/libtorrent/config.hpp:334#pragma message ( "unknown OS, assuming BSD" )
#else
#warning "unknown OS, assuming BSD"
#endif
@@ -6222,7 +6408,7 @@ put completes../src/kademlia/dht_tracker.cpp:437| relevance 0 | ../include/libtorrent/disk_buffer_pool.hpp:128 | try to remove the observers, only using the async_allocate handlers |
|
try to remove the observers, only using the async_allocate handlers../include/libtorrent/disk_buffer_pool.hpp:128
+ | ||
| relevance 0 | ../include/libtorrent/disk_buffer_pool.hpp:128 | try to remove the observers, only using the async_allocate handlers |
try to remove the observers, only using the async_allocate handlers../include/libtorrent/disk_buffer_pool.hpp:128
// number of bytes per block. The BitTorrent
// protocol defines the block size to 16 KiB.
const int m_block_size;
@@ -6273,7 +6459,7 @@ put completes../src/kademlia/dht_tracker.cpp:437| relevance 0 | ../include/libtorrent/file.hpp:168 | move this into a separate header file, TU pair |
|
move this into a separate header file, TU pair../include/libtorrent/file.hpp:168 TORRENT_EXTRA_EXPORT bool is_root_path(std::string const& f);
+ | ||
| relevance 0 | ../include/libtorrent/file.hpp:168 | move this into a separate header file, TU pair |
move this into a separate header file, TU pair../include/libtorrent/file.hpp:168 TORRENT_EXTRA_EXPORT bool is_root_path(std::string const& f);
// internal used by create_torrent.hpp
@@ -6324,7 +6510,7 @@ put completes../src/kademlia/dht_tracker.cpp:437| relevance 0 | ../include/libtorrent/peer_connection.hpp:205 | make this a raw pointer (to save size in the first cache line) and make the constructor take a raw pointer. torrent objects should always outlive their peers |
|
make this a raw pointer (to save size in
+ | ||
| relevance 0 | ../include/libtorrent/peer_connection.hpp:205 | make this a raw pointer (to save size in the first cache line) and make the constructor take a raw pointer. torrent objects should always outlive their peers |
make this a raw pointer (to save size in
the first cache line) and make the constructor
take a raw pointer. torrent objects should always
outlive their peers../include/libtorrent/peer_connection.hpp:205 , m_connecting(!t.expired())
@@ -6378,7 +6564,7 @@ outlive their peers../include/libtorrent/peer_connection.hpp:205 | ||
| relevance 0 | ../include/libtorrent/peer_connection.hpp:1058 | factor this out into its own class with a virtual interface torrent and session should implement this interface |
factor this out into its own class with a virtual interface
+ | ||
| relevance 0 | ../include/libtorrent/peer_connection.hpp:1058 | factor this out into its own class with a virtual interface torrent and session should implement this interface |
factor this out into its own class with a virtual interface
torrent and session should implement this interface../include/libtorrent/peer_connection.hpp:1058
// the local endpoint for this peer, i.e. our address
// and our port. If this is set for outgoing connections
@@ -6430,7 +6616,7 @@ torrent and session should implement this interface../include/libtorren
// we have got from this peer. If the request
// queue gets empty, and there have been
// invalid requests, we can assume the
- | ||
| relevance 0 | ../include/libtorrent/peer_connection_interface.hpp:45 | make this interface smaller! |
make this interface smaller!../include/libtorrent/peer_connection_interface.hpp:45SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ | ||
| relevance 0 | ../include/libtorrent/peer_connection_interface.hpp:45 | make this interface smaller! |
make this interface smaller!../include/libtorrent/peer_connection_interface.hpp:45SUBSTITUTE 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
@@ -6481,7 +6667,7 @@ namespace libtorrent
virtual tcp::endpoint const& remote() const = 0;
virtual tcp::endpoint local_endpoint() const = 0;
virtual void disconnect(error_code const& ec, operation_t op, int error = 0) = 0;
- | ||
| relevance 0 | ../include/libtorrent/performance_counters.hpp:132 | should keepalives be in here too? how about dont-have, share-mode, upload-only |
should keepalives be in here too?
+ | ||
| relevance 0 | ../include/libtorrent/performance_counters.hpp:132 | should keepalives be in here too? how about dont-have, share-mode, upload-only |
should keepalives be in here too?
how about dont-have, share-mode, upload-only../include/libtorrent/performance_counters.hpp:132 // a connect candidate
connection_attempt_loops,
// successful incoming connections (not rejected for any reason)
@@ -6533,9 +6719,9 @@ how about dont-have, share-mode, upload-only../include/libtorrent/perfo
num_outgoing_cancel,
num_outgoing_dht_port,
num_outgoing_suggest,
- | ||
| relevance 0 | ../include/libtorrent/performance_counters.hpp:439 | some space could be saved here by making gauges 32 bits |
some space could be saved here by making gauges 32 bits../include/libtorrent/performance_counters.hpp:439 | ||
| relevance 0 | ../include/libtorrent/performance_counters.hpp:440 | restore these to regular integers. Instead have one copy of the counters per thread and collect them at convenient synchronization points |
restore these to regular integers. Instead have one copy
+ | ||
| relevance 0 | ../include/libtorrent/performance_counters.hpp:442 | some space could be saved here by making gauges 32 bits |
some space could be saved here by making gauges 32 bits../include/libtorrent/performance_counters.hpp:442 | ||
| relevance 0 | ../include/libtorrent/performance_counters.hpp:443 | restore these to regular integers. Instead have one copy of the counters per thread and collect them at convenient synchronization points |
restore these to regular integers. Instead have one copy
of the counters per thread and collect them at convenient
-synchronization points../include/libtorrent/performance_counters.hpp:440 num_utp_deleted,
+synchronization points../include/libtorrent/performance_counters.hpp:443 num_utp_deleted,
num_counters,
num_gauge_counters = num_counters - num_stats_counters
@@ -6568,15 +6754,15 @@ synchronization points../include/libtorrent/performance_counters.hpp:44
#endif
- | ||
| relevance 0 | ../include/libtorrent/piece_picker.hpp:668 | should this be allocated lazily? |
should this be allocated lazily?../include/libtorrent/piece_picker.hpp:668 std::vector<downloading_piece>::const_iterator find_dl_piece(int queue, int index) const;
+ | ||
| relevance 0 | ../include/libtorrent/piece_picker.hpp:762 | should this be allocated lazily? |
should this be allocated lazily?../include/libtorrent/piece_picker.hpp:762
+ std::vector<downloading_piece>::const_iterator find_dl_piece(int queue, int index) const;
std::vector<downloading_piece>::iterator find_dl_piece(int queue, int index);
// returns an iterator to the downloading piece, whichever
// download list it may live in now
- std::vector<downloading_piece>::iterator update_piece_state(std::vector<downloading_piece>::iterator dp);
+ std::vector<downloading_piece>::iterator update_piece_state(
+ std::vector<downloading_piece>::iterator dp);
- // some compilers (e.g. gcc 2.95, does not inherit access
- // privileges to nested classes)
private:
// the following vectors are mutable because they sometimes may
@@ -6607,19 +6793,19 @@ synchronization points../include/libtorrent/performance_counters.hpp:44
// 0, priority 1 starts at m_priority_boundries[0] etc.
mutable std::vector<int> m_priority_boundries;
- // each piece that's currently being downloaded
- // has an entry in this list with block allocations.
- // i.e. it says wich parts of the piece that
- // is being downloaded. This list is ordered
- // by piece index to make lookups efficient
- // there are 3 buckets of downloading pieces, each
- // is individually sorted by piece index.
- // 0: downloading pieces with unrequested blocks
- // 1: downloading pieces where every block is busy
- // and some are still in the requested state
- // 2: downloading pieces where every block is
- // finished or writing
- | ||
| relevance 0 | ../include/libtorrent/proxy_base.hpp:171 | it would be nice to remember the bind port and bind once we know where the proxy is m_sock.bind(endpoint, ec); |
it would be nice to remember the bind port and bind once we know where the proxy is
+ // each piece that's currently being downloaded has an entry in this list
+ // with block allocations. i.e. it says wich parts of the piece that is
+ // being downloaded. This list is ordered by piece index to make lookups
+ // efficient there are as many buckets as there are piece states. See
+ // piece_pos::state_t. The only download state that does not have a
+ // corresponding downloading_piece vector is piece_open and
+ // piece_downloading_reverse (the latter uses the same as
+ // piece_downloading).
+ std::vector<downloading_piece> m_downloads[piece_pos::num_download_categories];
+
+ // this holds the information of the
+ // blocks in partially downloaded pieces.
+ | ||
| relevance 0 | ../include/libtorrent/proxy_base.hpp:171 | it would be nice to remember the bind port and bind once we know where the proxy is m_sock.bind(endpoint, ec); |
it would be nice to remember the bind port and bind once we know where the proxy is
m_sock.bind(endpoint, ec);../include/libtorrent/proxy_base.hpp:171 void bind(endpoint_type const& /* endpoint */)
{
// m_sock.bind(endpoint);
@@ -6671,7 +6857,7 @@ m_sock.bind(endpoint, ec);../include/libtorrent/proxy_base.hpp:171
m_sock.close(ec);
m_resolver.cancel();
}
- | ||
| relevance 0 | ../include/libtorrent/receive_buffer.hpp:255 | Detect when the start of the next crpyto packet is aligned with the start of piece data and the crpyto packet is at least as large as the piece data. With a little extra work we could receive directly into a disk buffer in that case. |
Detect when the start of the next crpyto packet is aligned
+ | ||
| relevance 0 | ../include/libtorrent/receive_buffer.hpp:255 | Detect when the start of the next crpyto packet is aligned with the start of piece data and the crpyto packet is at least as large as the piece data. With a little extra work we could receive directly into a disk buffer in that case. |
Detect when the start of the next crpyto packet is aligned
with the start of piece data and the crpyto packet is at least
as large as the piece data. With a little extra work
we could receive directly into a disk buffer in that case.../include/libtorrent/receive_buffer.hpp:255
@@ -6711,7 +6897,7 @@ private:
} // namespace libtorrent
#endif // #ifndef TORRENT_RECEIVE_BUFFER_HPP_INCLUDED
- | ||
| relevance 0 | ../include/libtorrent/session.hpp:856 | add get_peer_class_type_filter() as well |
add get_peer_class_type_filter() as well../include/libtorrent/session.hpp:856 //
+ | ||
| relevance 0 | ../include/libtorrent/session.hpp:861 | add get_peer_class_type_filter() as well |
add get_peer_class_type_filter() as well../include/libtorrent/session.hpp:861 //
// The ``peer_class`` argument cannot be greater than 31. The bitmasks
// representing peer classes in the ``peer_class_filter`` are 32 bits.
//
@@ -6762,7 +6948,7 @@ private:
// destructs.
//
// For more information on peer classes, see peer-classes_.
- | ||
| relevance 0 | ../include/libtorrent/settings_pack.hpp:1099 | deprecate this ``max_rejects`` is the number of piece requests we will reject in a row while a peer is choked before the peer is considered abusive and is disconnected. |
deprecate this
+ | ||
| relevance 0 | ../include/libtorrent/settings_pack.hpp:1099 | deprecate this ``max_rejects`` is the number of piece requests we will reject in a row while a peer is choked before the peer is considered abusive and is disconnected. |
deprecate this
``max_rejects`` is the number of piece requests we will reject in a
row while a peer is choked before the peer is considered abusive
and is disconnected.../include/libtorrent/settings_pack.hpp:1099 auto_manage_startup,
@@ -6816,7 +7002,7 @@ and is disconnected.../include/libtorrent/settings_pack.hpp:1099 | ||
| relevance 0 | ../include/libtorrent/torrent.hpp:1254 | this wastes 5 bits per file |
this wastes 5 bits per file../include/libtorrent/torrent.hpp:1254 typedef std::list<boost::shared_ptr<torrent_plugin> > extension_list_t;
+ | ||
| relevance 0 | ../include/libtorrent/torrent.hpp:1260 | this wastes 5 bits per file |
this wastes 5 bits per file../include/libtorrent/torrent.hpp:1260 typedef std::list<boost::shared_ptr<torrent_plugin> > extension_list_t;
extension_list_t m_extensions;
#endif
@@ -6867,7 +7053,7 @@ and is disconnected.../include/libtorrent/settings_pack.hpp:1099 | ||
| relevance 0 | ../include/libtorrent/torrent.hpp:1313 | These two bitfields should probably be coalesced into one |
These two bitfields should probably be coalesced into one../include/libtorrent/torrent.hpp:1313 // the .torrent file from m_url
+ | ||
| relevance 0 | ../include/libtorrent/torrent.hpp:1319 | These two bitfields should probably be coalesced into one |
These two bitfields should probably be coalesced into one../include/libtorrent/torrent.hpp:1319 // the .torrent file from m_url
// std::vector<char> m_torrent_file_buf;
// this is a list of all pieces that we have announced
@@ -6918,7 +7104,7 @@ and is disconnected.../include/libtorrent/settings_pack.hpp:1099 | ||
| relevance 0 | ../include/libtorrent/torrent_info.hpp:123 | include the number of peers received from this tracker, at last announce |
include the number of peers received from this tracker, at last
+ | ||
| relevance 0 | ../include/libtorrent/torrent_info.hpp:123 | include the number of peers received from this tracker, at last announce |
include the number of peers received from this tracker, at last
announce../include/libtorrent/torrent_info.hpp:123
// if this tracker failed the last time it was contacted
// this error code specifies what error occurred
@@ -6970,7 +7156,7 @@ announce../include/libtorrent/torrent_info.hpp:123| relevance 0 | ../include/libtorrent/torrent_info.hpp:270 | there may be some opportunities to optimize the size if torrent_info. specifically to turn some std::string and std::vector into pointers |
|
there may be some opportunities to optimize the size if torrent_info.
+ | ||
| relevance 0 | ../include/libtorrent/torrent_info.hpp:270 | there may be some opportunities to optimize the size if torrent_info. specifically to turn some std::string and std::vector into pointers |
there may be some opportunities to optimize the size if torrent_info.
specifically to turn some std::string and std::vector into pointers../include/libtorrent/torrent_info.hpp:270 // The URL of the web seed
std::string url;
@@ -7022,7 +7208,7 @@ specifically to turn some std::string and std::vector into pointers../i
// error occur, they will simply set the error code to describe what went
// wrong and not fully initialize the torrent_info object. The overloads
// that do not take the extra error_code parameter will always throw if
- | ||
| relevance 0 | ../include/libtorrent/tracker_manager.hpp:366 | this should be unique_ptr in the future |
this should be unique_ptr in the future../include/libtorrent/tracker_manager.hpp:366 // this is only used for SOCKS packets, since
+ | ||
| relevance 0 | ../include/libtorrent/tracker_manager.hpp:382 | this should be unique_ptr in the future |
this should be unique_ptr in the future../include/libtorrent/tracker_manager.hpp:382 // this is only used for SOCKS packets, since
// they may be addressed to hostname
virtual bool incoming_packet(error_code const& e, char const* hostname
, char const* buf, int size);
@@ -7049,20 +7235,22 @@ specifically to turn some std::string and std::vector into pointers../i
typedef std::vector<boost::shared_ptr<http_tracker_connection> > http_conns_t;
http_conns_t m_http_conns;
- aux::session_impl& m_ses;
-
struct ip_filter const& m_ip_filter;
class udp_socket& m_udp_socket;
resolver_interface& m_host_resolver;
aux::session_settings const& m_settings;
counters& m_stats_counters;
+#if defined TORRENT_LOGGING || TORRENT_USE_ASSERTS
+ aux::session_logger& m_ses;
+#endif
+
bool m_abort;
};
}
#endif // TORRENT_TRACKER_MANAGER_HPP_INCLUDED
- | ||
| relevance 0 | ../include/libtorrent/upnp.hpp:108 | support using the windows API for UPnP operations as well |
support using the windows API for UPnP operations as well../include/libtorrent/upnp.hpp:108 external_port_must_be_wildcard = 727
+ | ||
| relevance 0 | ../include/libtorrent/upnp.hpp:108 | support using the windows API for UPnP operations as well |
support using the windows API for UPnP operations as well../include/libtorrent/upnp.hpp:108 external_port_must_be_wildcard = 727
};
// hidden
@@ -7113,7 +7301,7 @@ public:
// to refer to mappings that fails or succeeds in the portmap_error_alert_ and
// portmap_alert_ respectively. If The mapping fails immediately, the return value
// is -1, which means failure. There will not be any error alert notification for
- | ||
| relevance 0 | ../include/libtorrent/utp_stream.hpp:395 | implement blocking write. Low priority since it's not used (yet) |
implement blocking write. Low priority since it's not used (yet)../include/libtorrent/utp_stream.hpp:395 for (typename Mutable_Buffers::const_iterator i = buffers.begin()
+ | ||
| relevance 0 | ../include/libtorrent/utp_stream.hpp:395 | implement blocking write. Low priority since it's not used (yet) |
implement blocking write. Low priority since it's not used (yet)../include/libtorrent/utp_stream.hpp:395 for (typename Mutable_Buffers::const_iterator i = buffers.begin()
, end(buffers.end()); i != end; ++i)
{
using asio::buffer_cast;
@@ -7164,7 +7352,7 @@ public:
if (m_impl == 0)
{
m_io_service.post(boost::bind<void>(handler, asio::error::not_connected, 0));
- | ||
| relevance 0 | ../include/libtorrent/kademlia/item.hpp:61 | since this is a public function, it should probably be moved out of this header and into one with other public functions. |
since this is a public function, it should probably be moved
+ | ||
| relevance 0 | ../include/libtorrent/kademlia/item.hpp:61 | since this is a public function, it should probably be moved out of this header and into one with other public functions. |
since this is a public function, it should probably be moved
out of this header and into one with other public functions.../include/libtorrent/kademlia/item.hpp:61#include <boost/array.hpp>
namespace libtorrent { namespace dht
@@ -7216,58 +7404,7 @@ public:
item(entry const& v
, std::pair<char const*, int> salt
, boost::uint64_t seq, char const* pk, char const* sk);
- | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:367 | move the login info into the tracker_request object |
move the login info into the tracker_request object../include/libtorrent/aux_/session_impl.hpp:367
- void on_lsd_announce(error_code const& e);
-
- // called when a port mapping is successful, or a router returns
- // a failure to map a port
- void on_port_mapping(int mapping, address const& ip, int port
- , error_code const& ec, int nat_transport);
-
- bool is_aborted() const { return m_abort; }
- bool is_paused() const { return m_paused; }
-
- void pause();
- void resume();
-
- void set_ip_filter(ip_filter const& f);
- ip_filter& get_ip_filter();
-
- void set_port_filter(port_filter const& f);
- port_filter const& get_port_filter() const;
-
- void queue_tracker_request(tracker_request& req
- , std::string login, boost::weak_ptr<request_callback> c
- , boost::uint32_t key);
-
- // ==== peer class operations ====
-
- // implements session_interface
- void set_peer_classes(peer_class_set* s, address const& a, int st);
- peer_class_pool const& peer_classes() const { return m_classes; }
- peer_class_pool& peer_classes() { return m_classes; }
- bool ignore_unchoke_slots_set(peer_class_set const& set) const;
- int copy_pertinent_channels(peer_class_set const& set
- , int channel, bandwidth_channel** dst, int max);
- int use_quota_overhead(peer_class_set& set, int amount_down, int amount_up);
- bool use_quota_overhead(bandwidth_channel* ch, int channel, int amount);
-
- int create_peer_class(char const* name);
- void delete_peer_class(int cid);
- void set_peer_class_filter(ip_filter const& f);
- ip_filter const& get_peer_class_filter() const;
-
- void set_peer_class_type_filter(peer_class_type_filter f);
- peer_class_type_filter get_peer_class_type_filter();
-
- peer_class_info get_peer_class(int cid);
- void set_peer_class(int cid, peer_class_info const& pci);
-
- bool is_listening() const;
-
-#ifndef TORRENT_DISABLE_EXTENSIONS
- void add_extensions_to_torrent(
- | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:833 | should this be renamed m_outgoing_interfaces? |
should this be renamed m_outgoing_interfaces?../include/libtorrent/aux_/session_impl.hpp:833 // listen socket. For each retry the port number
+ | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:836 | should this be renamed m_outgoing_interfaces? |
should this be renamed m_outgoing_interfaces?../include/libtorrent/aux_/session_impl.hpp:836 // listen socket. For each retry the port number
// is incremented by one
int m_listen_port_retries;
@@ -7318,7 +7455,7 @@ public:
// round-robin index into m_net_interfaces
mutable boost::uint8_t m_interface_index;
- | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:884 | replace this by a proper asio timer |
replace this by a proper asio timer../include/libtorrent/aux_/session_impl.hpp:884
+ | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:887 | replace this by a proper asio timer |
replace this by a proper asio timer../include/libtorrent/aux_/session_impl.hpp:887
void open_new_incoming_socks_connection();
enum listen_on_flags_t
@@ -7342,7 +7479,7 @@ public:
// this is used to decide when to recalculate which
// torrents to keep queued and which to activate
- | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:889 | replace this by a proper asio timer |
replace this by a proper asio timer../include/libtorrent/aux_/session_impl.hpp:889 {
+ | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:892 | replace this by a proper asio timer |
replace this by a proper asio timer../include/libtorrent/aux_/session_impl.hpp:892 {
open_ssl_socket = 0x10
};
@@ -7368,7 +7505,7 @@ public:
// is only decresed when the unchoke set
// is recomputed, and when it reaches zero,
// the optimistic unchoke is moved to another peer.
- | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:896 | replace this by a proper asio timer |
replace this by a proper asio timer../include/libtorrent/aux_/session_impl.hpp:896
+ | ||
| relevance 0 | ../include/libtorrent/aux_/session_impl.hpp:899 | replace this by a proper asio timer |
replace this by a proper asio timer../include/libtorrent/aux_/session_impl.hpp:899
#ifndef TORRENT_DISABLE_DHT
entry m_dht_state;
#endif
@@ -7419,10 +7556,10 @@ public:
int m_suggest_timer;
// statistics gathered from all torrents.
- | ||
| relevance 0 | ../include/libtorrent/aux_/session_interface.hpp:199 | it would be nice to not have this be part of session_interface |
it would be nice to not have this be part of session_interface../include/libtorrent/aux_/session_interface.hpp:199 virtual boost::uint16_t listen_port() const = 0;
+ | ||
| relevance 0 | ../include/libtorrent/aux_/session_interface.hpp:229 | it would be nice to not have this be part of session_interface |
it would be nice to not have this be part of session_interface../include/libtorrent/aux_/session_interface.hpp:229
+ virtual boost::uint16_t listen_port() const = 0;
virtual boost::uint16_t ssl_listen_port() const = 0;
- // used to (potentially) issue socket write calls onto multiple threads
virtual void post_socket_job(socket_job& j) = 0;
// load the specified torrent. also evict one torrent, except
@@ -7457,8 +7594,7 @@ public:
virtual session_settings const& settings() const = 0;
virtual void queue_tracker_request(tracker_request& req
- , std::string login, boost::weak_ptr<request_callback> c
- , boost::uint32_t key) = 0;
+ , boost::weak_ptr<request_callback> c) = 0;
// peer-classes
virtual void set_peer_classes(peer_class_set* s, address const& a, int st) = 0;
@@ -7470,7 +7606,8 @@ public:
virtual int use_quota_overhead(peer_class_set& set, int amount_down, int amount_up) = 0;
virtual bandwidth_manager* get_bandwidth_manager(int channel) = 0;
- | ||
| relevance 0 | ../include/libtorrent/aux_/session_settings.hpp:78 | make this a bitfield |
make this a bitfield../include/libtorrent/aux_/session_settings.hpp:78 if ((name & settings_pack::type_mask) != settings_pack:: type ## _type_base) return default_val; \
+
+ | ||
| relevance 0 | ../include/libtorrent/aux_/session_settings.hpp:78 | make this a bitfield |
make this a bitfield../include/libtorrent/aux_/session_settings.hpp:78 if ((name & settings_pack::type_mask) != settings_pack:: type ## _type_base) return default_val; \
return m_ ## type ## s[name - settings_pack:: type ## _type_base]
struct TORRENT_EXTRA_EXPORT session_settings
| ||