From 94fd3c0f379ffb85afa133682f90389d0a8b530c Mon Sep 17 00:00:00 2001 From: Marcos Pinto Date: Sat, 6 Oct 2007 04:22:06 +0000 Subject: [PATCH] lt sync 1649 --- libtorrent/include/libtorrent/alert_types.hpp | 8 +- libtorrent/include/libtorrent/assert.hpp | 22 +- .../include/libtorrent/aux_/session_impl.hpp | 4 +- .../include/libtorrent/bandwidth_manager.hpp | 46 +- libtorrent/include/libtorrent/bencode.hpp | 10 +- .../include/libtorrent/bt_peer_connection.hpp | 6 +- libtorrent/include/libtorrent/buffer.hpp | 20 +- .../include/libtorrent/chained_buffer.hpp | 24 +- libtorrent/include/libtorrent/fingerprint.hpp | 14 +- libtorrent/include/libtorrent/hasher.hpp | 12 +- .../include/libtorrent/http_connection.hpp | 2 +- .../include/libtorrent/intrusive_ptr_base.hpp | 8 +- .../include/libtorrent/invariant_check.hpp | 4 +- libtorrent/include/libtorrent/ip_filter.hpp | 22 +- .../libtorrent/kademlia/routing_table.hpp | 6 +- .../include/libtorrent/peer_connection.hpp | 12 +- libtorrent/include/libtorrent/peer_id.hpp | 6 +- .../include/libtorrent/piece_picker.hpp | 12 +- .../include/libtorrent/random_sample.hpp | 2 +- .../include/libtorrent/session_impl.hpp | 594 ++++++++++++++++++ libtorrent/include/libtorrent/stat.hpp | 28 +- libtorrent/include/libtorrent/time.hpp | 12 +- libtorrent/include/libtorrent/torrent.hpp | 30 +- .../include/libtorrent/torrent_handle.hpp | 4 +- .../include/libtorrent/torrent_info.hpp | 24 +- .../include/libtorrent/variant_stream.hpp | 42 +- .../libtorrent/web_peer_connection.hpp | 2 +- libtorrent/include/libtorrent/xml_parse.hpp | 4 +- libtorrent/src/alert.cpp | 2 +- libtorrent/src/assert.cpp | 4 + libtorrent/src/broadcast_socket.cpp | 2 +- libtorrent/src/bt_peer_connection.cpp | 285 ++++----- libtorrent/src/connection_queue.cpp | 8 +- libtorrent/src/disk_io_thread.cpp | 10 +- libtorrent/src/entry.cpp | 12 +- libtorrent/src/escape_string.cpp | 8 +- libtorrent/src/file.cpp | 21 +- libtorrent/src/file_pool.cpp | 16 +- libtorrent/src/file_win.cpp | 27 +- libtorrent/src/http_connection.cpp | 8 +- libtorrent/src/http_tracker_connection.cpp | 24 +- libtorrent/src/identify_client.cpp | 2 +- libtorrent/src/ip_filter.cpp | 8 +- libtorrent/src/kademlia/closest_nodes.cpp | 2 +- libtorrent/src/kademlia/dht_tracker.cpp | 34 +- libtorrent/src/kademlia/find_data.cpp | 2 +- libtorrent/src/kademlia/node.cpp | 8 +- libtorrent/src/kademlia/node_id.cpp | 2 +- libtorrent/src/kademlia/routing_table.cpp | 36 +- libtorrent/src/kademlia/rpc_manager.cpp | 42 +- .../src/kademlia/traversal_algorithm.cpp | 6 +- libtorrent/src/metadata_transfer.cpp | 62 +- libtorrent/src/natpmp.cpp | 4 +- libtorrent/src/pe_crypto.cpp | 4 +- libtorrent/src/peer_connection.cpp | 260 ++++---- libtorrent/src/piece_picker.cpp | 432 ++++++------- libtorrent/src/policy.cpp | 148 ++--- libtorrent/src/session.cpp | 14 +- libtorrent/src/session_impl.cpp | 162 ++--- libtorrent/src/socks5_stream.cpp | 2 +- libtorrent/src/storage.cpp | 312 ++++----- libtorrent/src/torrent.cpp | 296 ++++----- libtorrent/src/torrent_handle.cpp | 118 ++-- libtorrent/src/torrent_info.cpp | 48 +- libtorrent/src/tracker_manager.cpp | 12 +- libtorrent/src/udp_tracker_connection.cpp | 2 +- libtorrent/src/upnp.cpp | 8 +- libtorrent/src/ut_pex.cpp | 4 +- libtorrent/src/web_peer_connection.cpp | 48 +- 69 files changed, 2048 insertions(+), 1437 deletions(-) diff --git a/libtorrent/include/libtorrent/alert_types.hpp b/libtorrent/include/libtorrent/alert_types.hpp index 2f1998aae..a46eb7817 100755 --- a/libtorrent/include/libtorrent/alert_types.hpp +++ b/libtorrent/include/libtorrent/alert_types.hpp @@ -115,7 +115,7 @@ namespace libtorrent , std::string const& msg) : torrent_alert(h, alert::info, msg) , piece_index(index) - { assert(index >= 0);} + { TORRENT_ASSERT(index >= 0);} virtual std::auto_ptr clone() const { return std::auto_ptr(new hash_failed_alert(*this)); } @@ -193,7 +193,7 @@ namespace libtorrent , const std::string& msg) : torrent_alert(h, alert::debug, msg) , piece_index(piece_num) - { assert(piece_index >= 0);} + { TORRENT_ASSERT(piece_index >= 0);} int piece_index; @@ -211,7 +211,7 @@ namespace libtorrent : torrent_alert(h, alert::debug, msg) , block_index(block_num) , piece_index(piece_num) - { assert(block_index >= 0 && piece_index >= 0);} + { TORRENT_ASSERT(block_index >= 0 && piece_index >= 0);} int block_index; int piece_index; @@ -232,7 +232,7 @@ namespace libtorrent , peer_speedmsg(speedmsg) , block_index(block_num) , piece_index(piece_num) - { assert(block_index >= 0 && piece_index >= 0);} + { TORRENT_ASSERT(block_index >= 0 && piece_index >= 0);} std::string peer_speedmsg; int block_index; diff --git a/libtorrent/include/libtorrent/assert.hpp b/libtorrent/include/libtorrent/assert.hpp index 6577acc46..246e3b51b 100644 --- a/libtorrent/include/libtorrent/assert.hpp +++ b/libtorrent/include/libtorrent/assert.hpp @@ -30,25 +30,19 @@ POSSIBILITY OF SUCH DAMAGE. */ -#include - -#ifndef NDEBUG -#if (defined __linux__ || defined __MACH__) && defined __GNUC__ -#ifdef assert -#undef assert -#endif +#ifndef TORRENT_ASSERT #include "libtorrent/config.hpp" +#include + +#if (defined __linux__ || defined __MACH__) && defined __GNUC__ && !defined(NDEBUG) TORRENT_EXPORT void assert_fail(const char* expr, int line, char const* file, char const* function); - -#define assert(x) if (x) {} else assert_fail(#x, __LINE__, __FILE__, __PRETTY_FUNCTION__) - -#endif +#define TORRENT_ASSERT(x) if (x) {} else assert_fail(#x, __LINE__, __FILE__, __PRETTY_FUNCTION__) #else -#ifndef assert -#define assert(x) (void) -#endif +#define TORRENT_ASSERT(x) assert(x) +#endif + #endif diff --git a/libtorrent/include/libtorrent/aux_/session_impl.hpp b/libtorrent/include/libtorrent/aux_/session_impl.hpp index 6b76b43f9..d069d73e3 100644 --- a/libtorrent/include/libtorrent/aux_/session_impl.hpp +++ b/libtorrent/include/libtorrent/aux_/session_impl.hpp @@ -297,7 +297,7 @@ namespace libtorrent void unchoke_peer(peer_connection& c) { torrent* t = c.associated_torrent().lock().get(); - assert(t); + TORRENT_ASSERT(t); if (t->unchoke_peer(c)) ++m_num_unchoked; } @@ -345,7 +345,7 @@ namespace libtorrent send_buffer_capacity += i->second->send_buffer_capacity(); used_send_buffer += i->second->send_buffer_size(); } - assert(send_buffer_capacity >= used_send_buffer); + TORRENT_ASSERT(send_buffer_capacity >= used_send_buffer); m_buffer_usage_logger << log_time() << " send_buffer_size: " << send_buffer_capacity << std::endl; m_buffer_usage_logger << log_time() << " used_send_buffer: " << used_send_buffer << std::endl; m_buffer_usage_logger << log_time() << " send_buffer_utilization: " diff --git a/libtorrent/include/libtorrent/bandwidth_manager.hpp b/libtorrent/include/libtorrent/bandwidth_manager.hpp index 38aa67f43..83df5b371 100644 --- a/libtorrent/include/libtorrent/bandwidth_manager.hpp +++ b/libtorrent/include/libtorrent/bandwidth_manager.hpp @@ -111,14 +111,14 @@ struct bandwidth_limit void assign(int amount) throw() { - assert(amount > 0); + TORRENT_ASSERT(amount > 0); m_current_rate += amount; m_quota_left += amount; } void use_quota(int amount) throw() { - assert(amount <= m_quota_left); + TORRENT_ASSERT(amount <= m_quota_left); m_quota_left -= amount; } @@ -129,7 +129,7 @@ struct bandwidth_limit void expire(int amount) throw() { - assert(amount >= 0); + TORRENT_ASSERT(amount >= 0); m_current_rate -= amount; } @@ -165,7 +165,7 @@ private: template T clamp(T val, T ceiling, T floor) throw() { - assert(ceiling >= floor); + TORRENT_ASSERT(ceiling >= floor); if (val >= ceiling) return ceiling; else if (val <= floor) return floor; return val; @@ -186,7 +186,7 @@ struct bandwidth_manager void throttle(int limit) throw() { mutex_t::scoped_lock l(m_mutex); - assert(limit >= 0); + TORRENT_ASSERT(limit >= 0); m_limit = limit; } @@ -204,9 +204,9 @@ struct bandwidth_manager , bool non_prioritized) throw() { INVARIANT_CHECK; - assert(blk > 0); + TORRENT_ASSERT(blk > 0); - assert(!peer->ignore_bandwidth_limits()); + TORRENT_ASSERT(!peer->ignore_bandwidth_limits()); // make sure this peer isn't already in line // waiting for bandwidth @@ -214,11 +214,11 @@ struct bandwidth_manager for (typename queue_t::iterator i = m_queue.begin() , end(m_queue.end()); i != end; ++i) { - assert(i->peer < peer || peer < i->peer); + TORRENT_ASSERT(i->peer < peer || peer < i->peer); } #endif - assert(peer->max_assignable_bandwidth(m_channel) > 0); + TORRENT_ASSERT(peer->max_assignable_bandwidth(m_channel) > 0); boost::shared_ptr t = peer->associated_torrent().lock(); m_queue.push_back(bw_queue_entry(peer, blk, non_prioritized)); if (!non_prioritized) @@ -257,7 +257,7 @@ struct bandwidth_manager current_quota += i->amount; } - assert(current_quota == m_current_quota); + TORRENT_ASSERT(current_quota == m_current_quota); } #endif @@ -279,7 +279,7 @@ private: m_history_timer.async_wait(bind(&bandwidth_manager::on_history_expire, this, _1)); #ifndef NDEBUG } - catch (std::exception&) { assert(false); } + catch (std::exception&) { TORRENT_ASSERT(false); } #endif } @@ -292,7 +292,7 @@ private: if (e) return; - assert(!m_history.empty()); + TORRENT_ASSERT(!m_history.empty()); ptime now(time_now()); while (!m_history.empty() && m_history.back().expires_at <= now) @@ -300,7 +300,7 @@ private: history_entry e = m_history.back(); m_history.pop_back(); m_current_quota -= e.amount; - assert(m_current_quota >= 0); + TORRENT_ASSERT(m_current_quota >= 0); intrusive_ptr c = e.peer; shared_ptr t = e.tor.lock(); if (!c->is_disconnecting()) c->expire_bandwidth(m_channel, e.amount); @@ -322,7 +322,7 @@ private: } catch (std::exception&) { - assert(false); + TORRENT_ASSERT(false); } #endif } @@ -356,9 +356,9 @@ private: while (!m_queue.empty() && amount > 0) { - assert(amount == limit - m_current_quota); + TORRENT_ASSERT(amount == limit - m_current_quota); bw_queue_entry qe = m_queue.front(); - assert(qe.max_block_size > 0); + TORRENT_ASSERT(qe.max_block_size > 0); m_queue.pop_front(); shared_ptr t = qe.peer->associated_torrent().lock(); @@ -366,7 +366,7 @@ private: if (qe.peer->is_disconnecting()) { t->expire_bandwidth(m_channel, qe.max_block_size); - assert(amount == limit - m_current_quota); + TORRENT_ASSERT(amount == limit - m_current_quota); continue; } @@ -380,7 +380,7 @@ private: if (max_assignable == 0) { t->expire_bandwidth(m_channel, qe.max_block_size); - assert(amount == limit - m_current_quota); + TORRENT_ASSERT(amount == limit - m_current_quota); continue; } @@ -434,20 +434,20 @@ private: // than the max_bandwidth_block_size int hand_out_amount = (std::min)((std::min)(block_size, max_assignable) , amount); - assert(hand_out_amount > 0); - assert(amount == limit - m_current_quota); + TORRENT_ASSERT(hand_out_amount > 0); + TORRENT_ASSERT(amount == limit - m_current_quota); amount -= hand_out_amount; - assert(hand_out_amount <= qe.max_block_size); + TORRENT_ASSERT(hand_out_amount <= qe.max_block_size); t->assign_bandwidth(m_channel, hand_out_amount, qe.max_block_size); qe.peer->assign_bandwidth(m_channel, hand_out_amount); add_history_entry(history_entry( qe.peer, t, hand_out_amount, now + bw_window_size)); - assert(amount == limit - m_current_quota); + TORRENT_ASSERT(amount == limit - m_current_quota); } #ifndef NDEBUG } catch (std::exception& e) - { assert(false); }; + { TORRENT_ASSERT(false); }; #endif m_in_hand_out_bandwidth = false; } diff --git a/libtorrent/include/libtorrent/bencode.hpp b/libtorrent/include/libtorrent/bencode.hpp index 9e670c10b..66da191ab 100755 --- a/libtorrent/include/libtorrent/bencode.hpp +++ b/libtorrent/include/libtorrent/bencode.hpp @@ -151,7 +151,7 @@ namespace libtorrent template void read_string(InIt& in, InIt end, int len, std::string& str) { - assert(len >= 0); + TORRENT_ASSERT(len >= 0); for (int i = 0; i < len; ++i) { if (in == end) throw invalid_encoding(); @@ -214,7 +214,7 @@ namespace libtorrent { ++in; // 'i' std::string val = read_until(in, end, 'e'); - assert(*in == 'e'); + TORRENT_ASSERT(*in == 'e'); ++in; // 'e' ret = entry(entry::int_t); ret.integer() = boost::lexical_cast(val); @@ -233,7 +233,7 @@ namespace libtorrent bdecode_recursive(in, end, e); if (in == end) throw invalid_encoding(); } - assert(*in == 'e'); + TORRENT_ASSERT(*in == 'e'); ++in; // 'e' } break; @@ -251,7 +251,7 @@ namespace libtorrent bdecode_recursive(in, end, e); if (in == end) throw invalid_encoding(); } - assert(*in == 'e'); + TORRENT_ASSERT(*in == 'e'); ++in; // 'e' } break; @@ -261,7 +261,7 @@ namespace libtorrent if (isdigit((unsigned char)*in)) { std::string len_s = read_until(in, end, ':'); - assert(*in == ':'); + TORRENT_ASSERT(*in == ':'); ++in; // ':' int len = std::atoi(len_s.c_str()); ret = entry(entry::string_t); diff --git a/libtorrent/include/libtorrent/bt_peer_connection.hpp b/libtorrent/include/libtorrent/bt_peer_connection.hpp index 53e9667fc..dc5237a7d 100755 --- a/libtorrent/include/libtorrent/bt_peer_connection.hpp +++ b/libtorrent/include/libtorrent/bt_peer_connection.hpp @@ -342,8 +342,8 @@ namespace libtorrent : start(s) , length(l) { - assert(s >= 0); - assert(l > 0); + TORRENT_ASSERT(s >= 0); + TORRENT_ASSERT(l > 0); } int start; int length; @@ -375,7 +375,7 @@ namespace libtorrent int m_sync_bytes_read; // hold information about latest allocated send buffer - // need to check for non zero (begin, end) for operations with this + // need to check for non zero (begin, end) for operations with this buffer::interval m_enc_send_buffer; // initialized during write_pe1_2_dhkey, and destroyed on diff --git a/libtorrent/include/libtorrent/buffer.hpp b/libtorrent/include/libtorrent/buffer.hpp index 6af8817e2..55ab99d9f 100644 --- a/libtorrent/include/libtorrent/buffer.hpp +++ b/libtorrent/include/libtorrent/buffer.hpp @@ -51,11 +51,11 @@ public: char operator[](int index) const { - assert(begin + index < end); + TORRENT_ASSERT(begin + index < end); return begin[index]; } - int left() const { assert(end >= begin); return end - begin; } + int left() const { TORRENT_ASSERT(end >= begin); return end - begin; } char* begin; char* end; @@ -70,7 +70,7 @@ public: char operator[](int index) const { - assert(begin + index < end); + TORRENT_ASSERT(begin + index < end); return begin[index]; } @@ -80,7 +80,7 @@ public: && end == p_interval.end); } - int left() const { assert(end >= begin); return end - begin; } + int left() const { TORRENT_ASSERT(end >= begin); return end - begin; } char const* begin; char const* end; @@ -142,9 +142,9 @@ public: void erase(char* begin, char* end) { - assert(end <= m_end); - assert(begin >= m_begin); - assert(begin <= end); + TORRENT_ASSERT(end <= m_end); + TORRENT_ASSERT(begin >= m_begin); + TORRENT_ASSERT(begin <= end); if (end == m_end) { resize(begin - m_begin); @@ -160,7 +160,7 @@ public: void reserve(std::size_t n) { if (n <= capacity()) return; - assert(n > 0); + TORRENT_ASSERT(n > 0); char* buf = (char*)::operator new(n); std::size_t s = size(); @@ -172,8 +172,8 @@ public: } bool empty() const { return m_begin == m_end; } - char& operator[](std::size_t i) { assert(i >= 0 && i < size()); return m_begin[i]; } - char const& operator[](std::size_t i) const { assert(i >= 0 && i < size()); return m_begin[i]; } + char& operator[](std::size_t i) { TORRENT_ASSERT(i >= 0 && i < size()); return m_begin[i]; } + char const& operator[](std::size_t i) const { TORRENT_ASSERT(i >= 0 && i < size()); return m_begin[i]; } char* begin() { return m_begin; } char const* begin() const { return m_begin; } diff --git a/libtorrent/include/libtorrent/chained_buffer.hpp b/libtorrent/include/libtorrent/chained_buffer.hpp index ba5e1ab2f..82fcb65c5 100644 --- a/libtorrent/include/libtorrent/chained_buffer.hpp +++ b/libtorrent/include/libtorrent/chained_buffer.hpp @@ -60,7 +60,7 @@ namespace libtorrent void pop_front(int bytes_to_pop) { - assert(bytes_to_pop <= m_bytes); + TORRENT_ASSERT(bytes_to_pop <= m_bytes); while (bytes_to_pop > 0 && !m_vec.empty()) { buffer_t& b = m_vec.front(); @@ -69,9 +69,9 @@ namespace libtorrent b.start += bytes_to_pop; b.used_size -= bytes_to_pop; m_bytes -= bytes_to_pop; - assert(m_bytes <= m_capacity); - assert(m_bytes >= 0); - assert(m_capacity >= 0); + TORRENT_ASSERT(m_bytes <= m_capacity); + TORRENT_ASSERT(m_bytes >= 0); + TORRENT_ASSERT(m_capacity >= 0); break; } @@ -79,9 +79,9 @@ namespace libtorrent m_bytes -= b.used_size; m_capacity -= b.size; bytes_to_pop -= b.used_size; - assert(m_bytes >= 0); - assert(m_capacity >= 0); - assert(m_bytes <= m_capacity); + TORRENT_ASSERT(m_bytes >= 0); + TORRENT_ASSERT(m_capacity >= 0); + TORRENT_ASSERT(m_bytes <= m_capacity); m_vec.pop_front(); } } @@ -89,7 +89,7 @@ namespace libtorrent template void append_buffer(char* buffer, int size, int used_size, D const& destructor) { - assert(size >= used_size); + TORRENT_ASSERT(size >= used_size); buffer_t b; b.buf = buffer; b.size = size; @@ -100,7 +100,7 @@ namespace libtorrent m_bytes += used_size; m_capacity += size; - assert(m_bytes <= m_capacity); + TORRENT_ASSERT(m_bytes <= m_capacity); } // returns the number of bytes available at the @@ -134,7 +134,7 @@ namespace libtorrent if (insert + size > b.buf + b.size) return 0; b.used_size += size; m_bytes += size; - assert(m_bytes <= m_capacity); + TORRENT_ASSERT(m_bytes <= m_capacity); return insert; } @@ -147,11 +147,11 @@ namespace libtorrent { if (i->used_size > to_send) { - assert(to_send > 0); + TORRENT_ASSERT(to_send > 0); m_tmp_vec.push_back(asio::const_buffer(i->start, to_send)); break; } - assert(i->used_size > 0); + TORRENT_ASSERT(i->used_size > 0); m_tmp_vec.push_back(asio::const_buffer(i->start, i->used_size)); to_send -= i->used_size; } diff --git a/libtorrent/include/libtorrent/fingerprint.hpp b/libtorrent/include/libtorrent/fingerprint.hpp index 712be6979..237fef065 100755 --- a/libtorrent/include/libtorrent/fingerprint.hpp +++ b/libtorrent/include/libtorrent/fingerprint.hpp @@ -50,12 +50,12 @@ namespace libtorrent , revision_version(revision) , tag_version(tag) { - assert(id_string); - assert(major >= 0); - assert(minor >= 0); - assert(revision >= 0); - assert(tag >= 0); - assert(std::strlen(id_string) == 2); + TORRENT_ASSERT(id_string); + TORRENT_ASSERT(major >= 0); + TORRENT_ASSERT(minor >= 0); + TORRENT_ASSERT(revision >= 0); + TORRENT_ASSERT(tag >= 0); + TORRENT_ASSERT(std::strlen(id_string) == 2); name[0] = id_string[0]; name[1] = id_string[1]; } @@ -83,7 +83,7 @@ namespace libtorrent { if (v >= 0 && v < 10) return '0' + v; else if (v >= 10) return 'A' + (v - 10); - assert(false); + TORRENT_ASSERT(false); return '0'; } diff --git a/libtorrent/include/libtorrent/hasher.hpp b/libtorrent/include/libtorrent/hasher.hpp index 71b7f9ede..f1dba7d1a 100755 --- a/libtorrent/include/libtorrent/hasher.hpp +++ b/libtorrent/include/libtorrent/hasher.hpp @@ -70,8 +70,8 @@ namespace libtorrent void update(const char* data, int len) { - assert(data != 0); - assert(len > 0); + TORRENT_ASSERT(data != 0); + TORRENT_ASSERT(len > 0); m_adler = adler32(m_adler, (const Bytef*)data, len); } unsigned long final() const { return m_adler; } @@ -91,14 +91,14 @@ namespace libtorrent hasher(const char* data, int len) { SHA1_Init(&m_context); - assert(data != 0); - assert(len > 0); + TORRENT_ASSERT(data != 0); + TORRENT_ASSERT(len > 0); SHA1_Update(&m_context, reinterpret_cast(data), len); } void update(const char* data, int len) { - assert(data != 0); - assert(len > 0); + TORRENT_ASSERT(data != 0); + TORRENT_ASSERT(len > 0); SHA1_Update(&m_context, reinterpret_cast(data), len); } diff --git a/libtorrent/include/libtorrent/http_connection.hpp b/libtorrent/include/libtorrent/http_connection.hpp index ccc145413..4a70a902c 100644 --- a/libtorrent/include/libtorrent/http_connection.hpp +++ b/libtorrent/include/libtorrent/http_connection.hpp @@ -82,7 +82,7 @@ struct http_connection : boost::enable_shared_from_this, boost: , m_connection_ticket(-1) , m_cc(cc) { - assert(!m_handler.empty()); + TORRENT_ASSERT(!m_handler.empty()); } void rate_limit(int limit); diff --git a/libtorrent/include/libtorrent/intrusive_ptr_base.hpp b/libtorrent/include/libtorrent/intrusive_ptr_base.hpp index b78aea7b0..c7fbe46ad 100644 --- a/libtorrent/include/libtorrent/intrusive_ptr_base.hpp +++ b/libtorrent/include/libtorrent/intrusive_ptr_base.hpp @@ -49,15 +49,15 @@ namespace libtorrent friend void intrusive_ptr_add_ref(intrusive_ptr_base const* s) { - assert(s->m_refs >= 0); - assert(s != 0); + TORRENT_ASSERT(s->m_refs >= 0); + TORRENT_ASSERT(s != 0); ++s->m_refs; } friend void intrusive_ptr_release(intrusive_ptr_base const* s) { - assert(s->m_refs > 0); - assert(s != 0); + TORRENT_ASSERT(s->m_refs > 0); + TORRENT_ASSERT(s != 0); if (--s->m_refs == 0) delete static_cast(s); } diff --git a/libtorrent/include/libtorrent/invariant_check.hpp b/libtorrent/include/libtorrent/invariant_check.hpp index 3eaacf34c..3075b8975 100755 --- a/libtorrent/include/libtorrent/invariant_check.hpp +++ b/libtorrent/include/libtorrent/invariant_check.hpp @@ -40,7 +40,7 @@ namespace libtorrent } catch (...) { - assert(false); + TORRENT_ASSERT(false); } } @@ -52,7 +52,7 @@ namespace libtorrent } catch (...) { - assert(false); + TORRENT_ASSERT(false); } } diff --git a/libtorrent/include/libtorrent/ip_filter.hpp b/libtorrent/include/libtorrent/ip_filter.hpp index 7b8cc0e17..eee76cdc4 100644 --- a/libtorrent/include/libtorrent/ip_filter.hpp +++ b/libtorrent/include/libtorrent/ip_filter.hpp @@ -156,16 +156,16 @@ namespace detail using boost::next; using boost::prior; - assert(!m_access_list.empty()); - assert(first < last || first == last); + TORRENT_ASSERT(!m_access_list.empty()); + TORRENT_ASSERT(first < last || first == last); typename range_t::iterator i = m_access_list.upper_bound(first); typename range_t::iterator j = m_access_list.upper_bound(last); if (i != m_access_list.begin()) --i; - assert(j != m_access_list.begin()); - assert(j != i); + TORRENT_ASSERT(j != m_access_list.begin()); + TORRENT_ASSERT(j != i); int first_access = i->access; int last_access = prior(j)->access; @@ -179,8 +179,8 @@ namespace detail --i; first_access = i->access; } - assert(!m_access_list.empty()); - assert(i != m_access_list.end()); + TORRENT_ASSERT(!m_access_list.empty()); + TORRENT_ASSERT(i != m_access_list.end()); if (i != j) m_access_list.erase(next(i), j); if (i->start == first) @@ -200,22 +200,22 @@ namespace detail || (j == m_access_list.end() && last != max_addr())) { - assert(j == m_access_list.end() || last < minus_one(j->start)); + TORRENT_ASSERT(j == m_access_list.end() || last < minus_one(j->start)); if (last_access != flags) j = m_access_list.insert(j, range(plus_one(last), last_access)); } if (j != m_access_list.end() && j->access == flags) m_access_list.erase(j); - assert(!m_access_list.empty()); + TORRENT_ASSERT(!m_access_list.empty()); } int access(Addr const& addr) const { - assert(!m_access_list.empty()); + TORRENT_ASSERT(!m_access_list.empty()); typename range_t::const_iterator i = m_access_list.upper_bound(addr); if (i != m_access_list.begin()) --i; - assert(i != m_access_list.end()); - assert(i->start <= addr && (boost::next(i) == m_access_list.end() + TORRENT_ASSERT(i != m_access_list.end()); + TORRENT_ASSERT(i->start <= addr && (boost::next(i) == m_access_list.end() || addr < boost::next(i)->start)); return i->access; } diff --git a/libtorrent/include/libtorrent/kademlia/routing_table.hpp b/libtorrent/include/libtorrent/kademlia/routing_table.hpp index 9e10a3483..acb4c1885 100644 --- a/libtorrent/include/libtorrent/kademlia/routing_table.hpp +++ b/libtorrent/include/libtorrent/kademlia/routing_table.hpp @@ -123,7 +123,7 @@ namespace aux void increment() { - assert(m_bucket_iterator != m_bucket_end); + TORRENT_ASSERT(m_bucket_iterator != m_bucket_end); ++m_iterator; while (m_iterator == m_bucket_iterator->first.end()) { @@ -135,7 +135,7 @@ namespace aux node_entry const& dereference() const { - assert(m_bucket_iterator != m_bucket_end); + TORRENT_ASSERT(m_bucket_iterator != m_bucket_end); return *m_iterator; } @@ -194,7 +194,7 @@ public: int bucket_size(int bucket) { - assert(bucket >= 0 && bucket < 160); + TORRENT_ASSERT(bucket >= 0 && bucket < 160); return (int)m_buckets[bucket].first.size(); } int bucket_size() const { return m_bucket_size; } diff --git a/libtorrent/include/libtorrent/peer_connection.hpp b/libtorrent/include/libtorrent/peer_connection.hpp index ce7e61ec5..2ea3c7d34 100755 --- a/libtorrent/include/libtorrent/peer_connection.hpp +++ b/libtorrent/include/libtorrent/peer_connection.hpp @@ -176,6 +176,9 @@ namespace libtorrent void set_non_prioritized(bool b) { m_non_prioritized = b; } + void fast_reconnect(bool r) { m_fast_reconnect = r; } + bool fast_reconnect() const { return m_fast_reconnect; } + // this adds an announcement in the announcement queue // it will let the peer know that we have the given piece void announce_piece(int index); @@ -380,7 +383,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES void set_country(char const* c) { - assert(strlen(c) == 2); + TORRENT_ASSERT(strlen(c) == 2); m_country[0] = c[0]; m_country[1] = c[1]; } @@ -732,6 +735,13 @@ namespace libtorrent // the number of bytes send to the disk-io // thread that hasn't yet been completely written. int m_outstanding_writing_bytes; + + // if this is true, the disconnection + // timestamp is not updated when the connection + // is closed. This means the time until we can + // reconnect to this peer is shorter, and likely + // immediate. + bool m_fast_reconnect; #ifndef NDEBUG public: diff --git a/libtorrent/include/libtorrent/peer_id.hpp b/libtorrent/include/libtorrent/peer_id.hpp index 57303e2fd..13d857f99 100755 --- a/libtorrent/include/libtorrent/peer_id.hpp +++ b/libtorrent/include/libtorrent/peer_id.hpp @@ -58,7 +58,7 @@ namespace libtorrent big_number(std::string const& s) { - assert(s.size() >= 20); + TORRENT_ASSERT(s.size() >= 20); int sl = int(s.size()) < size ? int(s.size()) : size; std::memcpy(m_number, &s[0], sl); } @@ -126,10 +126,10 @@ namespace libtorrent } unsigned char& operator[](int i) - { assert(i >= 0 && i < number_size); return m_number[i]; } + { TORRENT_ASSERT(i >= 0 && i < number_size); return m_number[i]; } unsigned char const& operator[](int i) const - { assert(i >= 0 && i < number_size); return m_number[i]; } + { TORRENT_ASSERT(i >= 0 && i < number_size); return m_number[i]; } typedef const unsigned char* const_iterator; typedef unsigned char* iterator; diff --git a/libtorrent/include/libtorrent/piece_picker.hpp b/libtorrent/include/libtorrent/piece_picker.hpp index 64f6203d5..ec6fc5bd3 100755 --- a/libtorrent/include/libtorrent/piece_picker.hpp +++ b/libtorrent/include/libtorrent/piece_picker.hpp @@ -282,7 +282,7 @@ namespace libtorrent // functor that compares indices on downloading_pieces struct has_index { - has_index(int i): index(i) { assert(i >= 0); } + has_index(int i): index(i) { TORRENT_ASSERT(i >= 0); } bool operator()(const downloading_piece& p) const { return p.index == index; } int index; @@ -308,8 +308,8 @@ namespace libtorrent , piece_priority(1) , index(index_) { - assert(peer_count_ >= 0); - assert(index_ >= 0); + TORRENT_ASSERT(peer_count_ >= 0); + TORRENT_ASSERT(index_ >= 0); } // the number of peers that has this piece @@ -341,7 +341,7 @@ namespace libtorrent }; bool have() const { return index == we_have_index; } - void set_have() { index = we_have_index; assert(have()); } + void set_have() { index = we_have_index; TORRENT_ASSERT(have()); } bool filtered() const { return piece_priority == filter_priority; } void filtered(bool f) { piece_priority = f ? filter_priority : 0; } @@ -447,8 +447,8 @@ namespace libtorrent inline int piece_picker::blocks_in_piece(int index) const { - assert(index >= 0); - assert(index < (int)m_piece_map.size()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_map.size()); if (index+1 == (int)m_piece_map.size()) return m_blocks_in_last_piece; else diff --git a/libtorrent/include/libtorrent/random_sample.hpp b/libtorrent/include/libtorrent/random_sample.hpp index 8d85080df..1eaaec1e3 100644 --- a/libtorrent/include/libtorrent/random_sample.hpp +++ b/libtorrent/include/libtorrent/random_sample.hpp @@ -49,7 +49,7 @@ namespace libtorrent Distance m = 0; Distance N = std::distance(start, end); - assert(N >= n); + TORRENT_ASSERT(N >= n); while (m < n) { diff --git a/libtorrent/include/libtorrent/session_impl.hpp b/libtorrent/include/libtorrent/session_impl.hpp index e69de29bb..67c3fef1d 100644 --- a/libtorrent/include/libtorrent/session_impl.hpp +++ b/libtorrent/include/libtorrent/session_impl.hpp @@ -0,0 +1,594 @@ +/* + +Copyright (c) 2006, Arvid Norberg +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the distribution. + * Neither the name of the author nor the names of its + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + +*/ + +#ifndef TORRENT_SESSION_IMPL_HPP_INCLUDED +#define TORRENT_SESSION_IMPL_HPP_INCLUDED + +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(push, 1) +#endif + +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(pop) +#endif + +#include "libtorrent/torrent_handle.hpp" +#include "libtorrent/entry.hpp" +#include "libtorrent/torrent_info.hpp" +#include "libtorrent/socket.hpp" +#include "libtorrent/peer_connection.hpp" +#include "libtorrent/peer_id.hpp" +#include "libtorrent/policy.hpp" +#include "libtorrent/tracker_manager.hpp" +#include "libtorrent/peer_info.hpp" +#include "libtorrent/alert.hpp" +#include "libtorrent/fingerprint.hpp" +#include "libtorrent/debug.hpp" +#include "libtorrent/peer_request.hpp" +#include "libtorrent/piece_block_progress.hpp" +#include "libtorrent/ip_filter.hpp" +#include "libtorrent/config.hpp" +#include "libtorrent/session_settings.hpp" +#include "libtorrent/kademlia/dht_tracker.hpp" +#include "libtorrent/session_status.hpp" +#include "libtorrent/session.hpp" +#include "libtorrent/stat.hpp" +#include "libtorrent/file_pool.hpp" +#include "libtorrent/bandwidth_manager.hpp" +#include "libtorrent/natpmp.hpp" +#include "libtorrent/upnp.hpp" +#include "libtorrent/lsd.hpp" +#include "libtorrent/socket_type.hpp" +#include "libtorrent/connection_queue.hpp" +#include "libtorrent/disk_io_thread.hpp" + +namespace libtorrent +{ + + namespace fs = boost::filesystem; + + namespace aux + { + struct session_impl; + + // this data is shared between the main thread and the + // thread that initialize pieces + struct piece_checker_data + { + piece_checker_data() + : processing(false), progress(0.f), abort(false) {} + + boost::shared_ptr torrent_ptr; + fs::path save_path; + + sha1_hash info_hash; + + void parse_resume_data( + const entry& rd + , const torrent_info& info + , std::string& error); + + std::vector piece_map; + std::vector unfinished_pieces; + std::vector block_info; + std::vector peers; + entry resume_data; + + // this is true if this torrent is being processed (checked) + // if it is not being processed, then it can be removed from + // the queue without problems, otherwise the abort flag has + // to be set. + bool processing; + + // is filled in by storage::initialize_pieces() + // and represents the progress. It should be a + // value in the range [0, 1] + float progress; + + // abort defaults to false and is typically + // filled in by torrent_handle when the user + // aborts the torrent + bool abort; + }; + + struct checker_impl: boost::noncopyable + { + checker_impl(session_impl& s): m_ses(s), m_abort(false) {} + void operator()(); + piece_checker_data* find_torrent(const sha1_hash& info_hash); + void remove_torrent(sha1_hash const& info_hash); + +#ifndef NDEBUG + void check_invariant() const; +#endif + + // when the files has been checked + // the torrent is added to the session + session_impl& m_ses; + + mutable boost::mutex m_mutex; + boost::condition m_cond; + + // a list of all torrents that are currently in queue + // or checking their files + std::deque > m_torrents; + std::deque > m_processing; + + bool m_abort; + }; + +#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) + struct tracker_logger; +#endif + + // this is the link between the main thread and the + // thread started to run the main downloader loop + struct session_impl: boost::noncopyable + { +#ifndef NDEBUG + friend class ::libtorrent::peer_connection; +#endif + friend struct checker_impl; + friend class invariant_access; + typedef std::map + , boost::intrusive_ptr > + connection_map; + typedef std::map > torrent_map; + + session_impl( + std::pair listen_port_range + , fingerprint const& cl_fprint + , char const* listen_interface = "0.0.0.0"); + ~session_impl(); + +#ifndef TORRENT_DISABLE_EXTENSIONS + void add_extension(boost::function(torrent*)> ext); +#endif + void operator()(); + + void open_listen_port(); + + void async_accept(); + void on_incoming_connection(boost::shared_ptr const& s + , boost::weak_ptr const& as, asio::error_code const& e); + + // must be locked to access the data + // in this struct + typedef boost::recursive_mutex mutex_t; + mutable mutex_t m_mutex; + + boost::weak_ptr find_torrent(const sha1_hash& info_hash); + peer_id const& get_peer_id() const { return m_peer_id; } + + void close_connection(boost::intrusive_ptr const& p); + void connection_failed(boost::shared_ptr const& s + , tcp::endpoint const& a, char const* message); + + void set_settings(session_settings const& s); + session_settings const& settings() const { return m_settings; } + +#ifndef TORRENT_DISABLE_DHT + void add_dht_node(std::pair const& node); + void add_dht_node(udp::endpoint n); + void add_dht_router(std::pair const& node); + void set_dht_settings(dht_settings const& s); + dht_settings const& get_dht_settings() const { return m_dht_settings; } + void start_dht(entry const& startup_state); + void stop_dht(); + entry dht_state() const; +#endif + +#ifndef TORRENT_DISABLE_ENCRYPTION + void set_pe_settings(pe_settings const& settings); + pe_settings const& get_pe_settings() const { return m_pe_settings; } +#endif + + // called when a port mapping is successful, or a router returns + // a failure to map a port + void on_port_mapping(int tcp_port, int udp_port, std::string const& errmsg); + + bool is_aborted() const { return m_abort; } + + void set_ip_filter(ip_filter const& f); + void set_port_filter(port_filter const& f); + + bool listen_on( + std::pair const& port_range + , const char* net_interface = 0); + bool is_listening() const; + + torrent_handle add_torrent( + torrent_info const& ti + , fs::path const& save_path + , entry const& resume_data + , bool compact_mode + , int block_size + , storage_constructor_type sc); + + torrent_handle add_torrent( + char const* tracker_url + , sha1_hash const& info_hash + , char const* name + , fs::path const& save_path + , entry const& resume_data + , bool compact_mode + , int block_size + , storage_constructor_type sc); + + void remove_torrent(torrent_handle const& h); + + std::vector get_torrents(); + + void set_severity_level(alert::severity_t s); + std::auto_ptr pop_alert(); + + int upload_rate_limit() const; + int download_rate_limit() const; + + void set_download_rate_limit(int bytes_per_second); + void set_upload_rate_limit(int bytes_per_second); + void set_max_half_open_connections(int limit); + void set_max_connections(int limit); + void set_max_uploads(int limit); + + int max_connections() const { return m_max_connections; } + int max_uploads() const { return m_max_uploads; } + + int num_uploads() const { return m_num_unchoked; } + int num_connections() const + { return m_connections.size(); } + + void unchoke_peer(peer_connection& c) + { + c.send_unchoke(); + ++m_num_unchoked; + } + + session_status status() const; + void set_peer_id(peer_id const& id); + void set_key(int key); + unsigned short listen_port() const; + + void abort(); + + torrent_handle find_torrent_handle(sha1_hash const& info_hash); + + void announce_lsd(sha1_hash const& ih); + + void set_peer_proxy(proxy_settings const& s) + { m_peer_proxy = s; } + void set_web_seed_proxy(proxy_settings const& s) + { m_web_seed_proxy = s; } + void set_tracker_proxy(proxy_settings const& s) + { m_tracker_proxy = s; } + + proxy_settings const& peer_proxy() const + { return m_peer_proxy; } + proxy_settings const& web_seed_proxy() const + { return m_web_seed_proxy; } + proxy_settings const& tracker_proxy() const + { return m_tracker_proxy; } + +#ifndef TORRENT_DISABLE_DHT + void set_dht_proxy(proxy_settings const& s) + { m_dht_proxy = s; } + proxy_settings const& dht_proxy() const + { return m_dht_proxy; } +#endif + + void start_lsd(); + void start_natpmp(); + void start_upnp(); + + void stop_lsd(); + void stop_natpmp(); + void stop_upnp(); + + // handles delayed alerts + alert_manager m_alerts; + +// private: + + void on_lsd_peer(tcp::endpoint peer, sha1_hash const& ih); + + // this is where all active sockets are stored. + // the selector can sleep while there's no activity on + // them + io_service m_io_service; + asio::strand m_strand; + + // the file pool that all storages in this session's + // torrents uses. It sets a limit on the number of + // open files by this session. + // file pool must be destructed after the torrents + // since they will still have references to it + // when they are destructed. + file_pool m_files; + + // handles disk io requests asynchronously + disk_io_thread m_disk_thread; + + // this is a list of half-open tcp connections + // (only outgoing connections) + // this has to be one of the last + // members to be destructed + connection_queue m_half_open; + + // the bandwidth manager is responsible for + // handing out bandwidth to connections that + // asks for it, it can also throttle the + // rate. + bandwidth_manager m_download_channel; + bandwidth_manager m_upload_channel; + + bandwidth_manager* m_bandwidth_manager[2]; + + tracker_manager m_tracker_manager; + torrent_map m_torrents; + + // this maps sockets to their peer_connection + // object. It is the complete list of all connected + // peers. + connection_map m_connections; + + // filters incoming connections + ip_filter m_ip_filter; + + // filters outgoing connections + port_filter m_port_filter; + + // the peer id that is generated at the start of the session + peer_id m_peer_id; + + // the key is an id that is used to identify the + // client with the tracker only. It is randomized + // at startup + int m_key; + + // the range of ports we try to listen on + std::pair m_listen_port_range; + + // the ip-address of the interface + // we are supposed to listen on. + // if the ip is set to zero, it means + // that we should let the os decide which + // interface to listen on + tcp::endpoint m_listen_interface; + + // this is typically set to the same as the local + // listen port. In case a NAT port forward was + // successfully opened, this will be set to the + // port that is open on the external (NAT) interface + // on the NAT box itself. This is the port that has + // to be published to peers, since this is the port + // the client is reachable through. + int m_external_listen_port; + + boost::shared_ptr m_listen_socket; + + // the settings for the client + session_settings m_settings; + // the proxy settings for different + // kinds of connections + proxy_settings m_peer_proxy; + proxy_settings m_web_seed_proxy; + proxy_settings m_tracker_proxy; +#ifndef TORRENT_DISABLE_DHT + proxy_settings m_dht_proxy; +#endif + + // set to true when the session object + // is being destructed and the thread + // should exit + volatile bool m_abort; + + int m_max_uploads; + int m_max_connections; + + // the number of unchoked peers + int m_num_unchoked; + + // this is initialized to the unchoke_interval + // session_setting and decreased every second. + // when it reaches zero, it is reset to the + // unchoke_interval and the unchoke set is + // recomputed. + int m_unchoke_time_scaler; + + // works like unchoke_time_scaler but it + // is only decresed when the unchoke set + // is recomputed, and when it reaches zero, + // the optimistic unchoke is moved to another peer. + int m_optimistic_unchoke_time_scaler; + + // works like unchoke_time_scaler. Each time + // it reaches 0, and all the connections are + // used, the worst connection will be disconnected + // from the torrent with the most peers + int m_disconnect_time_scaler; + + // statistics gathered from all torrents. + stat m_stat; + + // is false by default and set to true when + // the first incoming connection is established + // this is used to know if the client is behind + // NAT or not. + bool m_incoming_connection; + + void second_tick(asio::error_code const& e); + ptime m_last_tick; + +#ifndef TORRENT_DISABLE_DHT + boost::intrusive_ptr m_dht; + dht_settings m_dht_settings; + // if this is set to true, the dht listen port + // will be set to the same as the tcp listen port + // and will be synchronlized with it as it changes + // it defaults to true + bool m_dht_same_port; + + // see m_external_listen_port. This is the same + // but for the udp port used by the DHT. + int m_external_udp_port; +#endif + +#ifndef TORRENT_DISABLE_ENCRYPTION + pe_settings m_pe_settings; +#endif + + boost::shared_ptr m_natpmp; + boost::shared_ptr m_upnp; + boost::shared_ptr m_lsd; + + // the timer used to fire the second_tick + deadline_timer m_timer; + + // the index of the torrent that will be offered to + // connect to a peer next time second_tick is called. + // This implements a round robin. + int m_next_connect_torrent; +#ifndef NDEBUG + void check_invariant(const char *place = 0); +#endif + +#ifdef TORRENT_STATS + // logger used to write bandwidth usage statistics + std::ofstream m_stats_logger; + int m_second_counter; +#endif +#if defined(TORRENT_VERBOSE_LOGGING) || defined(TORRENT_LOGGING) + boost::shared_ptr create_log(std::string const& name + , int instance, bool append = true); + + // this list of tracker loggers serves as tracker_callbacks when + // shutting down. This list is just here to keep them alive during + // whe shutting down process + std::list > m_tracker_loggers; + + public: + boost::shared_ptr m_logger; + private: +#endif + +#ifndef TORRENT_DISABLE_EXTENSIONS + typedef std::list(torrent*)> > extension_list_t; + + extension_list_t m_extensions; +#endif + + // data shared between the main thread + // and the checker thread + checker_impl m_checker_impl; + + // the main working thread + boost::scoped_ptr m_thread; + + // the thread that calls initialize_pieces() + // on all torrents before they start downloading + boost::scoped_ptr m_checker_thread; + }; + +#if defined(TORRENT_LOGGING) || defined(TORRENT_VERBOSE_LOGGING) + struct tracker_logger : request_callback + { + tracker_logger(session_impl& ses): m_ses(ses) {} + void tracker_warning(std::string const& str) + { + debug_log("*** tracker warning: " + str); + } + + void tracker_response(tracker_request const& + , std::vector& peers + , int interval + , int complete + , int incomplete) + { + std::stringstream s; + s << "TRACKER RESPONSE:\n" + "interval: " << interval << "\n" + "peers:\n"; + for (std::vector::const_iterator i = peers.begin(); + i != peers.end(); ++i) + { + s << " " << std::setfill(' ') << std::setw(16) << i->ip + << " " << std::setw(5) << std::dec << i->port << " "; + if (!i->pid.is_all_zeros()) s << " " << i->pid; + s << "\n"; + } + debug_log(s.str()); + } + + void tracker_request_timed_out( + tracker_request const&) + { + debug_log("*** tracker timed out"); + } + + void tracker_request_error( + tracker_request const& + , int response_code + , const std::string& str) + { + debug_log(std::string("*** tracker error: ") + + boost::lexical_cast(response_code) + ": " + + str); + } + + void debug_log(const std::string& line) + { + (*m_ses.m_logger) << line << "\n"; + } + session_impl& m_ses; + }; +#endif + + } +} + + +#endif + diff --git a/libtorrent/include/libtorrent/stat.hpp b/libtorrent/include/libtorrent/stat.hpp index 24e477a37..ef9b7780b 100755 --- a/libtorrent/include/libtorrent/stat.hpp +++ b/libtorrent/include/libtorrent/stat.hpp @@ -90,8 +90,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(bytes_payload >= 0); - assert(bytes_protocol >= 0); + TORRENT_ASSERT(bytes_payload >= 0); + TORRENT_ASSERT(bytes_protocol >= 0); m_downloaded_payload += bytes_payload; m_total_download_payload += bytes_payload; @@ -103,8 +103,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(bytes_payload >= 0); - assert(bytes_protocol >= 0); + TORRENT_ASSERT(bytes_payload >= 0); + TORRENT_ASSERT(bytes_protocol >= 0); m_uploaded_payload += bytes_payload; m_total_upload_payload += bytes_payload; @@ -132,8 +132,8 @@ namespace libtorrent // transfers from earlier connections. void add_stat(size_type downloaded, size_type uploaded) { - assert(downloaded >= 0); - assert(uploaded >= 0); + TORRENT_ASSERT(downloaded >= 0); + TORRENT_ASSERT(uploaded >= 0); m_total_download_payload += downloaded; m_total_upload_payload += uploaded; } @@ -143,14 +143,14 @@ namespace libtorrent #ifndef NDEBUG void check_invariant() const { - assert(m_mean_upload_rate >= 0); - assert(m_mean_download_rate >= 0); - assert(m_mean_upload_payload_rate >= 0); - assert(m_mean_download_payload_rate >= 0); - assert(m_total_upload_payload >= 0); - assert(m_total_download_payload >= 0); - assert(m_total_upload_protocol >= 0); - assert(m_total_download_protocol >= 0); + TORRENT_ASSERT(m_mean_upload_rate >= 0); + TORRENT_ASSERT(m_mean_download_rate >= 0); + TORRENT_ASSERT(m_mean_upload_payload_rate >= 0); + TORRENT_ASSERT(m_mean_download_payload_rate >= 0); + TORRENT_ASSERT(m_total_upload_payload >= 0); + TORRENT_ASSERT(m_total_download_payload >= 0); + TORRENT_ASSERT(m_total_upload_protocol >= 0); + TORRENT_ASSERT(m_total_download_protocol >= 0); } #endif diff --git a/libtorrent/include/libtorrent/time.hpp b/libtorrent/include/libtorrent/time.hpp index d3470c89d..1aae81d3a 100644 --- a/libtorrent/include/libtorrent/time.hpp +++ b/libtorrent/include/libtorrent/time.hpp @@ -188,7 +188,7 @@ namespace libtorrent if (timebase_info.denom == 0) mach_timebase_info(&timebase_info); // make sure we don't overflow - assert((at >= 0 && at >= at / 1000 * timebase_info.numer / timebase_info.denom) + TORRENT_ASSERT((at >= 0 && at >= at / 1000 * timebase_info.numer / timebase_info.denom) || (at < 0 && at < at / 1000 * timebase_info.numer / timebase_info.denom)); return at / 1000 * timebase_info.numer / timebase_info.denom; } @@ -199,11 +199,11 @@ namespace libtorrent if (timebase_info.denom == 0) { mach_timebase_info(&timebase_info); - assert(timebase_info.numer > 0); - assert(timebase_info.denom > 0); + TORRENT_ASSERT(timebase_info.numer > 0); + TORRENT_ASSERT(timebase_info.denom > 0); } // make sure we don't overflow - assert((ms >= 0 && ms <= ms * timebase_info.denom / timebase_info.numer * 1000) + TORRENT_ASSERT((ms >= 0 && ms <= ms * timebase_info.denom / timebase_info.numer * 1000) || (ms < 0 && ms > ms * timebase_info.denom / timebase_info.numer * 1000)); return ms * timebase_info.denom / timebase_info.numer * 1000; } @@ -269,7 +269,7 @@ namespace libtorrent #ifndef NDEBUG // make sure we don't overflow boost::int64_t ret = (pc * 1000 / performace_counter_frequency.QuadPart) * 1000; - assert((pc >= 0 && pc >= ret) || (pc < 0 && pc < ret)); + TORRENT_ASSERT((pc >= 0 && pc >= ret) || (pc < 0 && pc < ret)); #endif return (pc * 1000 / performace_counter_frequency.QuadPart) * 1000; } @@ -282,7 +282,7 @@ namespace libtorrent #ifndef NDEBUG // make sure we don't overflow boost::int64_t ret = (ms / 1000) * performace_counter_frequency.QuadPart / 1000; - assert((ms >= 0 && ms <= ret) + TORRENT_ASSERT((ms >= 0 && ms <= ret) || (ms < 0 && ms > ret)); #endif return (ms / 1000) * performace_counter_frequency.QuadPart / 1000; diff --git a/libtorrent/include/libtorrent/torrent.hpp b/libtorrent/include/libtorrent/torrent.hpp index 90ebfea31..4bb68436c 100755 --- a/libtorrent/include/libtorrent/torrent.hpp +++ b/libtorrent/include/libtorrent/torrent.hpp @@ -152,7 +152,7 @@ namespace libtorrent void set_sequenced_download_threshold(int threshold); bool verify_resume_data(entry& rd, std::string& error) - { assert(m_storage); return m_storage->verify_resume_data(rd, error); } + { TORRENT_ASSERT(m_storage); return m_storage->verify_resume_data(rd, error); } void second_tick(stat& accumulator, float tick_interval); @@ -205,7 +205,7 @@ namespace libtorrent peer_connection* connect_to_peer(policy::peer* peerinfo); void set_ratio(float ratio) - { assert(ratio >= 0.0f); m_ratio = ratio; } + { TORRENT_ASSERT(ratio >= 0.0f); m_ratio = ratio; } float ratio() const { return m_ratio; } @@ -362,7 +362,7 @@ namespace libtorrent // returns true if we have downloaded the given piece bool have_piece(int index) const { - assert(index >= 0 && index < (signed)m_have_pieces.size()); + TORRENT_ASSERT(index >= 0 && index < (signed)m_have_pieces.size()); return m_have_pieces[index]; } @@ -377,14 +377,14 @@ namespace libtorrent { if (m_picker.get()) { - assert(!is_seed()); - assert(index >= 0 && index < (signed)m_have_pieces.size()); + TORRENT_ASSERT(!is_seed()); + TORRENT_ASSERT(index >= 0 && index < (signed)m_have_pieces.size()); m_picker->inc_refcount(index); } #ifndef NDEBUG else { - assert(is_seed()); + TORRENT_ASSERT(is_seed()); } #endif } @@ -393,13 +393,13 @@ namespace libtorrent { if (m_picker.get()) { - assert(!is_seed()); + TORRENT_ASSERT(!is_seed()); m_picker->inc_refcount_all(); } #ifndef NDEBUG else { - assert(is_seed()); + TORRENT_ASSERT(is_seed()); } #endif } @@ -409,19 +409,19 @@ namespace libtorrent { if (m_picker.get()) { - assert(!is_seed()); - assert(index >= 0 && index < (signed)m_have_pieces.size()); + TORRENT_ASSERT(!is_seed()); + TORRENT_ASSERT(index >= 0 && index < (signed)m_have_pieces.size()); m_picker->dec_refcount(index); } #ifndef NDEBUG else { - assert(is_seed()); + TORRENT_ASSERT(is_seed()); } #endif } - int block_size() const { assert(m_block_size > 0); return m_block_size; } + int block_size() const { TORRENT_ASSERT(m_block_size > 0); return m_block_size; } // this will tell all peers that we just got his piece // and also let the piece picker know that we have this piece @@ -464,7 +464,7 @@ namespace libtorrent void piece_finished(int index, bool passed_hash_check); void piece_failed(int index); void received_redundant_data(int num_bytes) - { assert(num_bytes > 0); m_total_redundant_bytes += num_bytes; } + { TORRENT_ASSERT(num_bytes > 0); m_total_redundant_bytes += num_bytes; } // this is true if we have all the pieces bool is_seed() const @@ -485,7 +485,7 @@ namespace libtorrent alert_manager& alerts() const; piece_picker& picker() { - assert(m_picker.get()); + TORRENT_ASSERT(m_picker.get()); return *m_picker; } bool has_picker() const @@ -494,7 +494,7 @@ namespace libtorrent } policy& get_policy() { - assert(m_policy); + TORRENT_ASSERT(m_policy); return *m_policy; } piece_manager& filesystem(); diff --git a/libtorrent/include/libtorrent/torrent_handle.hpp b/libtorrent/include/libtorrent/torrent_handle.hpp index 287c57305..ec2d60ea5 100755 --- a/libtorrent/include/libtorrent/torrent_handle.hpp +++ b/libtorrent/include/libtorrent/torrent_handle.hpp @@ -398,8 +398,8 @@ namespace libtorrent , m_chk(c) , m_info_hash(h) { - assert(m_ses != 0); - assert(m_chk != 0); + TORRENT_ASSERT(m_ses != 0); + TORRENT_ASSERT(m_chk != 0); } #ifndef NDEBUG diff --git a/libtorrent/include/libtorrent/torrent_info.hpp b/libtorrent/include/libtorrent/torrent_info.hpp index 492fda48d..89744d0af 100755 --- a/libtorrent/include/libtorrent/torrent_info.hpp +++ b/libtorrent/include/libtorrent/torrent_info.hpp @@ -126,7 +126,7 @@ namespace libtorrent std::vector const& url_seeds() const { - assert(!m_half_metadata); + TORRENT_ASSERT(!m_half_metadata); return m_url_seeds; } @@ -168,7 +168,7 @@ namespace libtorrent int num_files(bool storage = false) const { - assert(m_piece_length > 0); + TORRENT_ASSERT(m_piece_length > 0); if (!storage || m_remapped_files.empty()) return (int)m_files.size(); else @@ -179,23 +179,23 @@ namespace libtorrent { if (!storage || m_remapped_files.empty()) { - assert(index >= 0 && index < (int)m_files.size()); + TORRENT_ASSERT(index >= 0 && index < (int)m_files.size()); return m_files[index]; } else { - assert(index >= 0 && index < (int)m_remapped_files.size()); + TORRENT_ASSERT(index >= 0 && index < (int)m_remapped_files.size()); return m_remapped_files[index]; } } const std::vector& trackers() const { return m_urls; } - size_type total_size() const { assert(m_piece_length > 0); return m_total_size; } - size_type piece_length() const { assert(m_piece_length > 0); return m_piece_length; } - int num_pieces() const { assert(m_piece_length > 0); return m_num_pieces; } + size_type total_size() const { TORRENT_ASSERT(m_piece_length > 0); return m_total_size; } + size_type piece_length() const { TORRENT_ASSERT(m_piece_length > 0); return m_piece_length; } + int num_pieces() const { TORRENT_ASSERT(m_piece_length > 0); return m_num_pieces; } const sha1_hash& info_hash() const { return m_info_hash; } - const std::string& name() const { assert(m_piece_length > 0); return m_name; } + const std::string& name() const { TORRENT_ASSERT(m_piece_length > 0); return m_name; } // ------- start deprecation ------- // this functionaily will be removed in a future version @@ -213,9 +213,9 @@ namespace libtorrent const sha1_hash& hash_for_piece(int index) const { - assert(index >= 0); - assert(index < (int)m_piece_hash.size()); - assert(!m_half_metadata); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_hash.size()); + TORRENT_ASSERT(!m_half_metadata); return m_piece_hash[index]; } @@ -232,7 +232,7 @@ namespace libtorrent nodes_t const& nodes() const { - assert(!m_half_metadata); + TORRENT_ASSERT(!m_half_metadata); return m_nodes; } diff --git a/libtorrent/include/libtorrent/variant_stream.hpp b/libtorrent/include/libtorrent/variant_stream.hpp index 4b32c9349..4f45f5e01 100644 --- a/libtorrent/include/libtorrent/variant_stream.hpp +++ b/libtorrent/include/libtorrent/variant_stream.hpp @@ -534,7 +534,7 @@ public: template std::size_t read_some(Mutable_Buffers const& buffers, asio::error_code& ec) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor( aux::read_some_visitor_ec(buffers, ec) , m_variant @@ -544,7 +544,7 @@ public: template std::size_t read_some(Mutable_Buffers const& buffers) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor( aux::read_some_visitor(buffers) , m_variant @@ -554,7 +554,7 @@ public: template void async_read_some(Mutable_Buffers const& buffers, Handler const& handler) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::async_read_some_visitor(buffers, handler) , m_variant @@ -564,7 +564,7 @@ public: template void async_write_some(Const_Buffers const& buffers, Handler const& handler) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::async_write_some_visitor(buffers, handler) , m_variant @@ -574,7 +574,7 @@ public: template void async_connect(endpoint_type const& endpoint, Handler const& handler) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::async_connect_visitor(endpoint, handler), m_variant ); @@ -583,7 +583,7 @@ public: template void io_control(IO_Control_Command& ioc) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::io_control_visitor(ioc), m_variant ); @@ -592,7 +592,7 @@ public: template void io_control(IO_Control_Command& ioc, asio::error_code& ec) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::io_control_visitor_ec(ioc, ec) , m_variant @@ -601,14 +601,14 @@ public: void bind(endpoint_type const& endpoint) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor(aux::bind_visitor(endpoint), m_variant); } template void bind(endpoint_type const& endpoint, Error_Handler const& error_handler) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::bind_visitor(endpoint, error_handler), m_variant ); @@ -616,14 +616,14 @@ public: void open(protocol_type const& p) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor(aux::open_visitor(p), m_variant); } template void open(protocol_type const& p, Error_Handler const& error_handler) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::open_visitor(p, error_handler), m_variant ); @@ -631,14 +631,14 @@ public: void close() { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor(aux::close_visitor<>(), m_variant); } template void close(Error_Handler const& error_handler) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); boost::apply_visitor( aux::close_visitor(error_handler), m_variant ); @@ -646,14 +646,14 @@ public: std::size_t in_avail() { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor(aux::in_avail_visitor<>(), m_variant); } template std::size_t in_avail(Error_Handler const& error_handler) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor( aux::in_avail_visitor(error_handler), m_variant ); @@ -661,13 +661,13 @@ public: endpoint_type remote_endpoint() { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor(aux::remote_endpoint_visitor(), m_variant); } endpoint_type remote_endpoint(asio::error_code& ec) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor( aux::remote_endpoint_visitor_ec(ec), m_variant ); @@ -675,13 +675,13 @@ public: endpoint_type local_endpoint() { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor(aux::local_endpoint_visitor(), m_variant); } endpoint_type local_endpoint(asio::error_code& ec) { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor( aux::local_endpoint_visitor_ec(ec), m_variant ); @@ -689,7 +689,7 @@ public: asio::io_service& io_service() { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor( aux::io_service_visitor(), m_variant ); @@ -697,7 +697,7 @@ public: lowest_layer_type& lowest_layer() { - assert(instantiated()); + TORRENT_ASSERT(instantiated()); return boost::apply_visitor( aux::lowest_layer_visitor(), m_variant ); diff --git a/libtorrent/include/libtorrent/web_peer_connection.hpp b/libtorrent/include/libtorrent/web_peer_connection.hpp index 8c9360e8f..8871ad8ec 100755 --- a/libtorrent/include/libtorrent/web_peer_connection.hpp +++ b/libtorrent/include/libtorrent/web_peer_connection.hpp @@ -122,7 +122,7 @@ namespace libtorrent void write_request(peer_request const& r); void write_cancel(peer_request const& r) {} void write_have(int index) {} - void write_piece(peer_request const& r, char* buffer) { assert(false); } + void write_piece(peer_request const& r, char* buffer) { TORRENT_ASSERT(false); } void write_keepalive() {} void on_connected(); void write_reject_request(peer_request const&) {} diff --git a/libtorrent/include/libtorrent/xml_parse.hpp b/libtorrent/include/libtorrent/xml_parse.hpp index 67ae406f0..aaf71a816 100644 --- a/libtorrent/include/libtorrent/xml_parse.hpp +++ b/libtorrent/include/libtorrent/xml_parse.hpp @@ -68,7 +68,7 @@ namespace libtorrent { if (p != end) { - assert(*p == '<'); + TORRENT_ASSERT(*p == '<'); *p = 0; } token = xml_string; @@ -98,7 +98,7 @@ namespace libtorrent break; } - assert(*p == '>'); + TORRENT_ASSERT(*p == '>'); // save the character that terminated the tag name // it could be both '>' and ' '. char save = *tag_name_end; diff --git a/libtorrent/src/alert.cpp b/libtorrent/src/alert.cpp index 80ae6ead8..1401a5e4a 100755 --- a/libtorrent/src/alert.cpp +++ b/libtorrent/src/alert.cpp @@ -96,7 +96,7 @@ namespace libtorrent { { boost::mutex::scoped_lock lock(m_mutex); - assert(!m_alerts.empty()); + TORRENT_ASSERT(!m_alerts.empty()); alert* result = m_alerts.front(); m_alerts.pop(); diff --git a/libtorrent/src/assert.cpp b/libtorrent/src/assert.cpp index b4f011978..1073e05a3 100644 --- a/libtorrent/src/assert.cpp +++ b/libtorrent/src/assert.cpp @@ -69,5 +69,9 @@ void assert_fail(char const* expr, int line, char const* file, char const* funct abort(); } +#else + +void assert_fail(char const* expr, int line, char const* file, char const* function) {} + #endif diff --git a/libtorrent/src/broadcast_socket.cpp b/libtorrent/src/broadcast_socket.cpp index 8872b59b1..4c2e9397c 100644 --- a/libtorrent/src/broadcast_socket.cpp +++ b/libtorrent/src/broadcast_socket.cpp @@ -106,7 +106,7 @@ namespace libtorrent : m_multicast_endpoint(multicast_endpoint) , m_on_receive(handler) { - assert(is_multicast(m_multicast_endpoint.address())); + TORRENT_ASSERT(is_multicast(m_multicast_endpoint.address())); using namespace asio::ip::multicast; diff --git a/libtorrent/src/bt_peer_connection.cpp b/libtorrent/src/bt_peer_connection.cpp index 56d9307a9..21deec1d4 100755 --- a/libtorrent/src/bt_peer_connection.cpp +++ b/libtorrent/src/bt_peer_connection.cpp @@ -192,7 +192,7 @@ namespace libtorrent } else if (out_enc_policy == pe_settings::enabled) { - assert(peer_info_struct()); + TORRENT_ASSERT(peer_info_struct()); policy::peer* pi = peer_info_struct(); if (pi->pe_support == true) @@ -205,6 +205,7 @@ namespace libtorrent // if this fails, we need to reconnect // fast. pi->connected = time_now() - seconds(m_ses.settings().min_reconnect_time); + fast_reconnect(true); write_pe1_2_dhkey(); m_state = read_pe_dhkey; @@ -237,7 +238,7 @@ namespace libtorrent void bt_peer_connection::on_metadata() { boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); write_bitfield(t->pieces()); #ifndef TORRENT_DISABLE_DHT if (m_supports_dht_port && m_ses.m_dht) @@ -249,7 +250,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << time_now_string() @@ -264,7 +265,7 @@ namespace libtorrent void bt_peer_connection::write_have_all() { INVARIANT_CHECK; - assert(m_sent_handshake && !m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && !m_sent_bitfield); #ifndef NDEBUG m_sent_bitfield = true; #endif @@ -279,7 +280,7 @@ namespace libtorrent void bt_peer_connection::write_have_none() { INVARIANT_CHECK; - assert(m_sent_handshake && !m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && !m_sent_bitfield); #ifndef NDEBUG m_sent_bitfield = true; #endif @@ -295,8 +296,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); - assert(associated_torrent().lock()->valid_metadata()); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(associated_torrent().lock()->valid_metadata()); char msg[] = {0,0,0,13, msg_reject_request,0,0,0,0, 0,0,0,0, 0,0,0,0}; char* ptr = msg + 5; @@ -310,8 +311,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); - assert(associated_torrent().lock()->valid_metadata()); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(associated_torrent().lock()->valid_metadata()); char msg[] = {0,0,0,5, msg_allowed_fast, 0, 0, 0, 0}; char* ptr = msg + 5; @@ -321,7 +322,7 @@ namespace libtorrent void bt_peer_connection::get_specific_peer_info(peer_info& p) const { - assert(!associated_torrent().expired()); + TORRENT_ASSERT(!associated_torrent().expired()); if (is_interesting()) p.flags |= peer_info::interesting; if (is_choked()) p.flags |= peer_info::choked; @@ -360,10 +361,10 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!m_encrypted); - assert(!m_rc4_encrypted); - assert(!m_DH_key_exchange.get()); - assert(!m_sent_handshake); + TORRENT_ASSERT(!m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted); + TORRENT_ASSERT(!m_DH_key_exchange.get()); + TORRENT_ASSERT(!m_sent_handshake); #ifdef TORRENT_VERBOSE_LOGGING if (is_local()) @@ -380,7 +381,7 @@ namespace libtorrent buffer::interval send_buf = allocate_send_buffer(dh_key_len + pad_size); - std::copy (m_DH_key_exchange->get_local_key(), + std::copy(m_DH_key_exchange->get_local_key(), m_DH_key_exchange->get_local_key() + dh_key_len, send_buf.begin); @@ -396,13 +397,13 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!m_encrypted); - assert(!m_rc4_encrypted); - assert(is_local()); - assert(!m_sent_handshake); + TORRENT_ASSERT(!m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted); + TORRENT_ASSERT(is_local()); + TORRENT_ASSERT(!m_sent_handshake); boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); hasher h; sha1_hash const& info_hash = t->torrent_file().info_hash(); @@ -443,7 +444,7 @@ namespace libtorrent m_DH_key_exchange.reset(); // secret should be invalid at this point // write the verification constant and crypto field - assert(send_buf.left() == 8 + 4 + 2 + pad_size + 2); + TORRENT_ASSERT(send_buf.left() == 8 + 4 + 2 + pad_size + 2); int encrypt_size = send_buf.left(); int crypto_provide = 0; @@ -469,7 +470,7 @@ namespace libtorrent write_pe_vc_cryptofield(send_buf, crypto_provide, pad_size); m_RC4_handler->encrypt(send_buf.end - encrypt_size, encrypt_size); - assert(send_buf.begin == send_buf.end); + TORRENT_ASSERT(send_buf.begin == send_buf.end); setup_send(); } @@ -477,11 +478,11 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!is_local()); - assert(!m_encrypted); - assert(!m_rc4_encrypted); - assert(crypto_select == 0x02 || crypto_select == 0x01); - assert(!m_sent_handshake); + TORRENT_ASSERT(!is_local()); + TORRENT_ASSERT(!m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted); + TORRENT_ASSERT(crypto_select == 0x02 || crypto_select == 0x01); + TORRENT_ASSERT(!m_sent_handshake); int pad_size = 0; // rand() % 512; // Keep 0 for now @@ -512,12 +513,12 @@ namespace libtorrent { INVARIANT_CHECK; - assert(crypto_field <= 0x03 && crypto_field > 0); - assert(pad_size == 0); // pad not used yet + TORRENT_ASSERT(crypto_field <= 0x03 && crypto_field > 0); + TORRENT_ASSERT(pad_size == 0); // pad not used yet // vc,crypto_field,len(pad),pad, (len(ia)) - assert( (write_buf.left() == 8+4+2+pad_size+2 && is_local()) || + TORRENT_ASSERT( (write_buf.left() == 8+4+2+pad_size+2 && is_local()) || (write_buf.left() == 8+4+2+pad_size && !is_local()) ); - assert(!m_sent_handshake); + TORRENT_ASSERT(!m_sent_handshake); // encrypt(vc, crypto_provide/select, len(Pad), len(IA)) // len(pad) is zero for now, len(IA) only for outgoing connections @@ -544,7 +545,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(secret); + TORRENT_ASSERT(secret); hasher h; static const char keyA[] = "keyA"; @@ -570,8 +571,8 @@ namespace libtorrent h.update((char const*)stream_key.begin(), 20); const sha1_hash remote_key = h.final(); - assert(!m_RC4_handler.get()); - m_RC4_handler.reset (new RC4_handler (local_key, remote_key)); + TORRENT_ASSERT(!m_RC4_handler.get()); + m_RC4_handler.reset(new RC4_handler (local_key, remote_key)); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << " computed RC4 keys\n"; @@ -580,9 +581,9 @@ namespace libtorrent void bt_peer_connection::send_buffer(char* buf, int size) { - assert(buf); - assert(size > 0); - assert(!m_rc4_encrypted || m_encrypted); + TORRENT_ASSERT(buf); + TORRENT_ASSERT(size > 0); + TORRENT_ASSERT(!m_rc4_encrypted || m_encrypted); if (m_rc4_encrypted) m_RC4_handler->encrypt(buf, size); @@ -592,11 +593,11 @@ namespace libtorrent buffer::interval bt_peer_connection::allocate_send_buffer(int size) { - assert(!m_rc4_encrypted || m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted || m_encrypted); if (m_rc4_encrypted) { - assert(m_enc_send_buffer.left() == 0); + TORRENT_ASSERT(m_enc_send_buffer.left() == 0); m_enc_send_buffer = peer_connection::allocate_send_buffer(size); return m_enc_send_buffer; } @@ -609,12 +610,12 @@ namespace libtorrent void bt_peer_connection::setup_send() { - assert(!m_rc4_encrypted || m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted || m_encrypted); if (m_rc4_encrypted && m_enc_send_buffer.left()) { - assert(m_enc_send_buffer.begin); - assert(m_enc_send_buffer.end); + TORRENT_ASSERT(m_enc_send_buffer.begin); + TORRENT_ASSERT(m_enc_send_buffer.end); m_RC4_handler->encrypt(m_enc_send_buffer.begin, m_enc_send_buffer.left()); m_enc_send_buffer.end = m_enc_send_buffer.begin; @@ -625,10 +626,10 @@ namespace libtorrent int bt_peer_connection::get_syncoffset(char const* src, int src_size, char const* target, int target_size) const { - assert(target_size >= src_size); - assert(src_size > 0); - assert(src); - assert(target); + TORRENT_ASSERT(target_size >= src_size); + TORRENT_ASSERT(src_size > 0); + TORRENT_ASSERT(src); + TORRENT_ASSERT(target); int traverse_limit = target_size - src_size; @@ -672,13 +673,13 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!m_sent_handshake); + TORRENT_ASSERT(!m_sent_handshake); #ifndef NDEBUG m_sent_handshake = true; #endif boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); // add handshake to the send buffer const char version_string[] = "BitTorrent protocol"; @@ -725,7 +726,7 @@ namespace libtorrent , m_ses.get_peer_id().end() , i.begin); i.begin += 20; - assert(i.begin == i.end); + TORRENT_ASSERT(i.begin == i.end); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << time_now_string() << " ==> HANDSHAKE\n"; @@ -736,7 +737,7 @@ namespace libtorrent boost::optional bt_peer_connection::downloading_piece_progress() const { boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); buffer::const_interval recv_buffer = receive_buffer(); // are we currently receiving a 'piece' message? @@ -790,7 +791,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 1) throw protocol_error("'choke' message size != 1"); m_statistics.received_bytes(0, received); @@ -800,7 +801,7 @@ namespace libtorrent if (!m_supports_fast) { boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); while (!request_queue().empty()) { piece_block const& b = request_queue().front(); @@ -821,7 +822,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 1) throw protocol_error("'unchoke' message size != 1"); m_statistics.received_bytes(0, received); @@ -838,7 +839,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 1) throw protocol_error("'interested' message size != 1"); m_statistics.received_bytes(0, received); @@ -855,7 +856,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 1) throw protocol_error("'not interested' message size != 1"); m_statistics.received_bytes(0, received); @@ -872,7 +873,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 5) throw protocol_error("'have' message size != 5"); m_statistics.received_bytes(0, received); @@ -894,10 +895,10 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); // if we don't have the metedata, we cannot // verify the bitfield size @@ -935,7 +936,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 13) throw protocol_error("'request' message size != 13"); m_statistics.received_bytes(0, received); @@ -960,7 +961,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); buffer::const_interval recv_buffer = receive_buffer(); int recv_pos = recv_buffer.end - recv_buffer.begin; @@ -976,9 +977,9 @@ namespace libtorrent else { // received a bit of both - assert(recv_pos - received < 9); - assert(recv_pos > 9); - assert(9 - (recv_pos - received) <= 9); + TORRENT_ASSERT(recv_pos - received < 9); + TORRENT_ASSERT(recv_pos > 9); + TORRENT_ASSERT(9 - (recv_pos - received) <= 9); m_statistics.received_bytes( recv_pos - 9 , 9 - (recv_pos - received)); @@ -1004,7 +1005,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 13) throw protocol_error("'cancel' message size != 13"); m_statistics.received_bytes(0, received); @@ -1032,7 +1033,7 @@ namespace libtorrent if (!m_supports_dht_port) throw protocol_error("got 'dht_port' message from peer that doesn't support it"); - assert(received > 0); + TORRENT_ASSERT(received > 0); if (packet_size() != 3) throw protocol_error("'dht_port' message size != 3"); m_statistics.received_bytes(0, received); @@ -1128,7 +1129,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); m_statistics.received_bytes(0, received); if (packet_size() < 2) throw protocol_error("'extended' message smaller than 2 bytes"); @@ -1139,7 +1140,7 @@ namespace libtorrent buffer::const_interval recv_buffer = receive_buffer(); if (recv_buffer.left() < 2) return; - assert(*recv_buffer.begin == msg_extended); + TORRENT_ASSERT(*recv_buffer.begin == msg_extended); ++recv_buffer.begin; int extended_id = detail::read_uint8(recv_buffer.begin); @@ -1169,7 +1170,7 @@ namespace libtorrent if (!packet_finished()) return; boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); buffer::const_interval recv_buffer = receive_buffer(); @@ -1237,7 +1238,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(received > 0); + TORRENT_ASSERT(received > 0); // this means the connection has been closed already if (associated_torrent().expired()) return false; @@ -1265,7 +1266,7 @@ namespace libtorrent + " size: " + boost::lexical_cast(packet_size())); } - assert(m_message_handler[packet_type] != 0); + TORRENT_ASSERT(m_message_handler[packet_type] != 0); // call the correct handler for this packet type (this->*m_message_handler[packet_type])(received); @@ -1277,7 +1278,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); char msg[] = {0,0,0,0}; send_buffer(msg, sizeof(msg)); @@ -1287,8 +1288,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); - assert(associated_torrent().lock()->valid_metadata()); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(associated_torrent().lock()->valid_metadata()); char msg[17] = {0,0,0,13, msg_cancel}; char* ptr = msg + 5; @@ -1302,8 +1303,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); - assert(associated_torrent().lock()->valid_metadata()); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(associated_torrent().lock()->valid_metadata()); char msg[17] = {0,0,0,13, msg_request}; char* ptr = msg + 5; @@ -1319,12 +1320,12 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = associated_torrent().lock(); - assert(t); - assert(m_sent_handshake && !m_sent_bitfield); - assert(t->valid_metadata()); + TORRENT_ASSERT(t); + TORRENT_ASSERT(m_sent_handshake && !m_sent_bitfield); + TORRENT_ASSERT(t->valid_metadata()); // in this case, have_all or have_none should be sent instead - assert(!m_supports_fast || !t->is_seed() || t->num_pieces() != 0); + TORRENT_ASSERT(!m_supports_fast || !t->is_seed() || t->num_pieces() != 0); if (m_supports_fast && t->is_seed()) { @@ -1344,7 +1345,7 @@ namespace libtorrent int num_lazy_pieces = 0; int lazy_piece = 0; - assert(t->is_seed() == (std::count(bitfield.begin(), bitfield.end(), true) == num_pieces)); + TORRENT_ASSERT(t->is_seed() == (std::count(bitfield.begin(), bitfield.end(), true) == num_pieces)); if (t->is_seed() && m_ses.settings().lazy_bitfields) { num_lazy_pieces = (std::min)(50, num_pieces / 10); @@ -1354,7 +1355,7 @@ namespace libtorrent if (rand() % (num_pieces - i) >= num_lazy_pieces - lazy_piece) continue; lazy_pieces[lazy_piece++] = i; } - assert(lazy_piece == num_lazy_pieces); + TORRENT_ASSERT(lazy_piece == num_lazy_pieces); lazy_piece = 0; } @@ -1397,7 +1398,7 @@ namespace libtorrent if (bitfield[c]) i.begin[c >> 3] |= 1 << (7 - (c & 7)); } - assert(i.end - i.begin == (num_pieces + 7) / 8); + TORRENT_ASSERT(i.end - i.begin == (num_pieces + 7) / 8); #ifndef NDEBUG m_sent_bitfield = true; @@ -1428,8 +1429,8 @@ namespace libtorrent #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << time_now_string() << " ==> EXTENSIONS\n"; #endif - assert(m_supports_extensions); - assert(m_sent_handshake); + TORRENT_ASSERT(m_supports_extensions); + TORRENT_ASSERT(m_sent_handshake); entry handshake(entry::dictionary_t); entry extension_list(entry::dictionary_t); @@ -1478,7 +1479,7 @@ namespace libtorrent std::copy(msg.begin(), msg.end(), i.begin); i.begin += msg.size(); - assert(i.begin == i.end); + TORRENT_ASSERT(i.begin == i.end); #ifdef TORRENT_VERBOSE_LOGGING std::stringstream ext; @@ -1494,7 +1495,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); if (is_choked()) return; char msg[] = {0,0,0,1,msg_choke}; @@ -1505,7 +1506,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); char msg[] = {0,0,0,1,msg_unchoke}; send_buffer(msg, sizeof(msg)); @@ -1515,7 +1516,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); char msg[] = {0,0,0,1,msg_interested}; send_buffer(msg, sizeof(msg)); @@ -1525,7 +1526,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); char msg[] = {0,0,0,1,msg_not_interested}; send_buffer(msg, sizeof(msg)); @@ -1534,10 +1535,10 @@ namespace libtorrent void bt_peer_connection::write_have(int index) { INVARIANT_CHECK; - assert(associated_torrent().lock()->valid_metadata()); - assert(index >= 0); - assert(index < associated_torrent().lock()->torrent_file().num_pieces()); - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(associated_torrent().lock()->valid_metadata()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < associated_torrent().lock()->torrent_file().num_pieces()); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); char msg[] = {0,0,0,5,msg_have,0,0,0,0}; char* ptr = msg + 5; @@ -1549,14 +1550,14 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_sent_handshake && m_sent_bitfield); + TORRENT_ASSERT(m_sent_handshake && m_sent_bitfield); boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); char msg[4 + 1 + 4 + 4]; char* ptr = msg; - assert(r.length <= 16 * 1024); + TORRENT_ASSERT(r.length <= 16 * 1024); detail::write_int32(r.length + 1 + 4 + 4, ptr); detail::write_uint8(msg_piece, ptr); detail::write_int32(r.piece, ptr); @@ -1582,7 +1583,7 @@ namespace libtorrent { match_peer_id(peer_id const& id, peer_connection const* pc) : m_id(id), m_pc(pc) - { assert(pc); } + { TORRENT_ASSERT(pc); } bool operator()(std::pair const& p) const { @@ -1615,7 +1616,7 @@ namespace libtorrent m_statistics.received_bytes(0, bytes_transferred); #ifndef TORRENT_DISABLE_ENCRYPTION - assert(in_handshake() || !m_rc4_encrypted || m_encrypted); + TORRENT_ASSERT(in_handshake() || !m_rc4_encrypted || m_encrypted); if (m_rc4_encrypted && m_encrypted) { buffer::interval wr_buf = wr_recv_buffer(); @@ -1682,17 +1683,17 @@ namespace libtorrent // synchash,skeyhash,vc,crypto_provide,len(pad),pad,encrypt(handshake) reset_recv_buffer(20+20+8+4+2+0+handshake_len); } - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); return; } // cannot fall through into if (m_state == read_pe_synchash) { - assert(!m_encrypted); - assert(!m_rc4_encrypted); - assert(!is_local()); - assert(recv_buffer == receive_buffer()); + TORRENT_ASSERT(!m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted); + TORRENT_ASSERT(!is_local()); + TORRENT_ASSERT(recv_buffer == receive_buffer()); if (recv_buffer.left() < 20) { @@ -1706,7 +1707,7 @@ namespace libtorrent if (!m_sync_hash.get()) { - assert(m_sync_bytes_read == 0); + TORRENT_ASSERT(m_sync_bytes_read == 0); hasher h; // compute synchash (hash('req1',S)) @@ -1729,7 +1730,7 @@ namespace libtorrent cut_receive_buffer(bytes_processed, (std::min)(packet_size(), (512+20) - m_sync_bytes_read)); - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); return; } // found complete sync @@ -1749,10 +1750,10 @@ namespace libtorrent if (m_state == read_pe_skey_vc) { - assert(!m_encrypted); - assert(!m_rc4_encrypted); - assert(!is_local()); - assert(packet_size() == 28); + TORRENT_ASSERT(!m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted); + TORRENT_ASSERT(!is_local()); + TORRENT_ASSERT(packet_size() == 28); if (!packet_finished()) return; @@ -1793,7 +1794,7 @@ namespace libtorrent { attach_to_torrent(info_hash); t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); } init_pe_RC4_handler(m_DH_key_exchange->get_secret(), info_hash); @@ -1828,10 +1829,10 @@ namespace libtorrent // cannot fall through into if (m_state == read_pe_syncvc) { - assert(is_local()); - assert(!m_encrypted); - assert(!m_rc4_encrypted); - assert(recv_buffer == receive_buffer()); + TORRENT_ASSERT(is_local()); + TORRENT_ASSERT(!m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted); + TORRENT_ASSERT(recv_buffer == receive_buffer()); if (recv_buffer.left() < 8) { @@ -1846,14 +1847,14 @@ namespace libtorrent // generate the verification constant if (!m_sync_vc.get()) { - assert(m_sync_bytes_read == 0); + TORRENT_ASSERT(m_sync_bytes_read == 0); m_sync_vc.reset (new char[8]); std::fill(m_sync_vc.get(), m_sync_vc.get() + 8, 0); m_RC4_handler->decrypt(m_sync_vc.get(), 8); } - assert(m_sync_vc.get()); + TORRENT_ASSERT(m_sync_vc.get()); int syncoffset = get_syncoffset(m_sync_vc.get(), 8 , recv_buffer.begin, recv_buffer.left()); @@ -1867,7 +1868,7 @@ namespace libtorrent cut_receive_buffer(bytes_processed, (std::min)(packet_size(), (512+8) - m_sync_bytes_read)); - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); return; } // found complete sync @@ -1889,9 +1890,9 @@ namespace libtorrent if (m_state == read_pe_cryptofield) // local/remote { - assert(!m_encrypted); - assert(!m_rc4_encrypted); - assert(packet_size() == 4+2); + TORRENT_ASSERT(!m_encrypted); + TORRENT_ASSERT(!m_rc4_encrypted); + TORRENT_ASSERT(packet_size() == 4+2); if (!packet_finished()) return; @@ -2001,7 +2002,7 @@ namespace libtorrent if (m_state == read_pe_pad) { - assert(!m_encrypted); + TORRENT_ASSERT(!m_encrypted); if (!packet_finished()) return; int pad_size = is_local() ? packet_size() : packet_size() - 2; @@ -2043,8 +2044,8 @@ namespace libtorrent if (m_state == read_pe_ia) { - assert(!is_local()); - assert(!m_encrypted); + TORRENT_ASSERT(!is_local()); + TORRENT_ASSERT(!m_encrypted); if (!packet_finished()) return; @@ -2073,7 +2074,7 @@ namespace libtorrent if (m_state == init_bt_handshake) { - assert(m_encrypted); + TORRENT_ASSERT(m_encrypted); // decrypt remaining received bytes if (m_rc4_encrypted) @@ -2103,7 +2104,7 @@ namespace libtorrent m_ses.get_pe_settings().out_enc_policy == pe_settings::enabled) { policy::peer* pi = peer_info_struct(); - assert(pi); + TORRENT_ASSERT(pi); pi->pe_support = true; } @@ -2137,7 +2138,7 @@ namespace libtorrent #endif m_state = read_pe_dhkey; cut_receive_buffer(0, dh_key_len); - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); return; } @@ -2166,7 +2167,7 @@ namespace libtorrent // fall through if (m_state == read_info_hash) { - assert(packet_size() == 28); + TORRENT_ASSERT(packet_size() == 28); if (!packet_finished()) return; recv_buffer = receive_buffer(); @@ -2230,7 +2231,7 @@ namespace libtorrent } t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); // if this is a local connection, we have already // sent the handshake @@ -2238,7 +2239,7 @@ namespace libtorrent // if (t->valid_metadata()) // write_bitfield(t->pieces()); - assert(t->get_policy().has_connection(this)); + TORRENT_ASSERT(t->get_policy().has_connection(this)); m_state = read_peer_id; reset_recv_buffer(20); @@ -2249,10 +2250,10 @@ namespace libtorrent { if (!t) { - assert(!packet_finished()); // TODO + TORRENT_ASSERT(!packet_finished()); // TODO return; } - assert(packet_size() == 20); + TORRENT_ASSERT(packet_size() == 20); if (!packet_finished()) return; recv_buffer = receive_buffer(); @@ -2285,7 +2286,7 @@ namespace libtorrent , match_peer_id(pid, this)); if (i != p.end_peer()) { - assert(i->second.connection->pid() == pid); + TORRENT_ASSERT(i->second.connection->pid() == pid); // we found another connection with the same peer-id // which connection should be closed in order to be // sure that the other end closes the same connection? @@ -2352,7 +2353,7 @@ namespace libtorrent m_ses.get_pe_settings().out_enc_policy == pe_settings::enabled) { policy::peer* pi = peer_info_struct(); - assert(pi); + TORRENT_ASSERT(pi); pi->pe_support = false; } @@ -2369,7 +2370,7 @@ namespace libtorrent #endif } - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); return; } @@ -2407,24 +2408,24 @@ namespace libtorrent m_state = read_packet; reset_recv_buffer(packet_size); } - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); return; } if (m_state == read_packet) { - assert(recv_buffer == receive_buffer()); + TORRENT_ASSERT(recv_buffer == receive_buffer()); if (!t) return; if (dispatch_message(bytes_transferred)) { m_state = read_packet_size; reset_recv_buffer(4); } - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); return; } - assert(!packet_finished()); + TORRENT_ASSERT(!packet_finished()); } // -------------------------- @@ -2469,7 +2470,7 @@ namespace libtorrent std::remove_if(m_payloads.begin(), m_payloads.end(), range_below_zero) , m_payloads.end()); - assert(amount_payload <= (int)bytes_transferred); + TORRENT_ASSERT(amount_payload <= (int)bytes_transferred); m_statistics.sent_bytes(amount_payload, bytes_transferred - amount_payload); } @@ -2477,10 +2478,10 @@ namespace libtorrent void bt_peer_connection::check_invariant() const { #ifndef TORRENT_DISABLE_ENCRYPTION - assert( (bool(m_state != read_pe_dhkey) || m_DH_key_exchange.get()) + TORRENT_ASSERT( (bool(m_state != read_pe_dhkey) || m_DH_key_exchange.get()) || !is_local()); - assert(!m_rc4_encrypted || m_RC4_handler.get()); + TORRENT_ASSERT(!m_rc4_encrypted || m_RC4_handler.get()); #endif if (!m_in_constructor) peer_connection::check_invariant(); @@ -2490,7 +2491,7 @@ namespace libtorrent for (std::deque::const_iterator i = m_payloads.begin(); i != m_payloads.end() - 1; ++i) { - assert(i->start + i->length <= (i+1)->start); + TORRENT_ASSERT(i->start + i->length <= (i+1)->start); } } } diff --git a/libtorrent/src/connection_queue.cpp b/libtorrent/src/connection_queue.cpp index 0b3f5ff54..1caeb99fc 100644 --- a/libtorrent/src/connection_queue.cpp +++ b/libtorrent/src/connection_queue.cpp @@ -102,7 +102,7 @@ namespace libtorrent { if (i->connecting) ++num_connecting; } - assert(num_connecting == m_num_connecting); + TORRENT_ASSERT(num_connecting == m_num_connecting); } #endif @@ -118,7 +118,7 @@ namespace libtorrent , m_queue.end(), boost::bind(&entry::connecting, _1) == false); while (i != m_queue.end()) { - assert(i->connecting == false); + TORRENT_ASSERT(i->connecting == false); ptime expire = time_now() + i->timeout; if (m_num_connecting == 0) { @@ -143,7 +143,7 @@ namespace libtorrent #ifndef NDEBUG struct function_guard { - function_guard(bool& v): val(v) { assert(!val); val = true; } + function_guard(bool& v): val(v) { TORRENT_ASSERT(!val); val = true; } ~function_guard() { val = false; } bool& val; @@ -159,7 +159,7 @@ namespace libtorrent function_guard guard_(m_in_timeout_function); #endif - assert(!e || e == asio::error::operation_aborted); + TORRENT_ASSERT(!e || e == asio::error::operation_aborted); if (e) return; ptime next_expire = max_time(); diff --git a/libtorrent/src/disk_io_thread.cpp b/libtorrent/src/disk_io_thread.cpp index ea177b58d..b6b2e20a7 100644 --- a/libtorrent/src/disk_io_thread.cpp +++ b/libtorrent/src/disk_io_thread.cpp @@ -124,7 +124,7 @@ namespace libtorrent void disk_io_thread::add_job(disk_io_job const& j , boost::function const& f) { - assert(!j.callback); + TORRENT_ASSERT(!j.callback); boost::mutex::scoped_lock l(m_mutex); std::deque::reverse_iterator i = m_jobs.rbegin(); @@ -174,7 +174,7 @@ namespace libtorrent k->callback.swap(const_cast&>(f)); if (j.action == disk_io_job::write) m_queue_buffer_size += j.buffer_size; - assert(j.storage.get()); + TORRENT_ASSERT(j.storage.get()); m_signal.notify_all(); } @@ -239,7 +239,7 @@ namespace libtorrent ++m_allocations; #endif l.unlock(); - assert(j.buffer_size <= m_block_size); + TORRENT_ASSERT(j.buffer_size <= m_block_size); if (j.buffer == 0) { ret = -1; @@ -257,8 +257,8 @@ namespace libtorrent #ifdef TORRENT_DISK_STATS m_log << log_time() << " write " << j.buffer_size << std::endl; #endif - assert(j.buffer); - assert(j.buffer_size <= m_block_size); + TORRENT_ASSERT(j.buffer); + TORRENT_ASSERT(j.buffer_size <= m_block_size); j.storage->write_impl(j.buffer, j.piece, j.offset , j.buffer_size); diff --git a/libtorrent/src/entry.cpp b/libtorrent/src/entry.cpp index 16dffc275..50c6967cc 100755 --- a/libtorrent/src/entry.cpp +++ b/libtorrent/src/entry.cpp @@ -50,7 +50,7 @@ namespace template void call_destructor(T* o) { - assert(o); + TORRENT_ASSERT(o); o->~T(); } @@ -206,7 +206,7 @@ namespace libtorrent case dictionary_t: return dict() == e.dict(); default: - assert(m_type == undefined_t); + TORRENT_ASSERT(m_type == undefined_t); return true; } } @@ -229,7 +229,7 @@ namespace libtorrent new (data) dictionary_type; break; default: - assert(m_type == undefined_t); + TORRENT_ASSERT(m_type == undefined_t); m_type = undefined_t; } } @@ -273,7 +273,7 @@ namespace libtorrent call_destructor(reinterpret_cast(data)); break; default: - assert(m_type == undefined_t); + TORRENT_ASSERT(m_type == undefined_t); break; } } @@ -281,12 +281,12 @@ namespace libtorrent void entry::swap(entry& e) { // not implemented - assert(false); + TORRENT_ASSERT(false); } void entry::print(std::ostream& os, int indent) const { - assert(indent >= 0); + TORRENT_ASSERT(indent >= 0); for (int i = 0; i < indent; ++i) os << " "; switch (m_type) { diff --git a/libtorrent/src/escape_string.cpp b/libtorrent/src/escape_string.cpp index faff3de95..323a3e12b 100755 --- a/libtorrent/src/escape_string.cpp +++ b/libtorrent/src/escape_string.cpp @@ -87,8 +87,8 @@ namespace libtorrent std::string escape_string(const char* str, int len) { - assert(str != 0); - assert(len >= 0); + TORRENT_ASSERT(str != 0); + TORRENT_ASSERT(len >= 0); // http://www.ietf.org/rfc/rfc2396.txt // section 2.3 // some trackers seems to require that ' is escaped @@ -121,8 +121,8 @@ namespace libtorrent std::string escape_path(const char* str, int len) { - assert(str != 0); - assert(len >= 0); + TORRENT_ASSERT(str != 0); + TORRENT_ASSERT(len >= 0); static const char unreserved_chars[] = "/-_.!~*()" "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" "0123456789"; diff --git a/libtorrent/src/file.cpp b/libtorrent/src/file.cpp index 72876d528..53288b2e5 100755 --- a/libtorrent/src/file.cpp +++ b/libtorrent/src/file.cpp @@ -31,6 +31,7 @@ POSSIBILITY OF SUCH DAMAGE. */ #include "libtorrent/pch.hpp" +#include "libtorrent/assert.hpp" #ifdef _WIN32 // windows part @@ -91,7 +92,7 @@ namespace if (m == (mode_in | mode_out)) return O_RDWR | O_CREAT | O_BINARY | O_RANDOM; if (m == mode_out) return O_WRONLY | O_CREAT | O_BINARY | O_RANDOM; if (m == mode_in) return O_RDONLY | O_BINARY | O_RANDOM; - assert(false); + TORRENT_ASSERT(false); return 0; } @@ -157,7 +158,7 @@ namespace libtorrent void open(fs::path const& path, int mode) { - assert(path.is_complete()); + TORRENT_ASSERT(path.is_complete()); close(); #if defined(_WIN32) && defined(UNICODE) std::wstring wpath(safe_convert(path.native_file_string())); @@ -204,8 +205,8 @@ namespace libtorrent size_type read(char* buf, size_type num_bytes) { - assert(m_open_mode & mode_in); - assert(m_fd != -1); + TORRENT_ASSERT(m_open_mode & mode_in); + TORRENT_ASSERT(m_fd != -1); #ifdef _WIN32 size_type ret = ::_read(m_fd, buf, num_bytes); @@ -223,8 +224,8 @@ namespace libtorrent size_type write(const char* buf, size_type num_bytes) { - assert(m_open_mode & mode_out); - assert(m_fd != -1); + TORRENT_ASSERT(m_open_mode & mode_out); + TORRENT_ASSERT(m_fd != -1); // TODO: Test this a bit more, what happens with random failures in // the files? @@ -261,8 +262,8 @@ namespace libtorrent size_type seek(size_type offset, int m = 1) { - assert(m_open_mode); - assert(m_fd != -1); + TORRENT_ASSERT(m_open_mode); + TORRENT_ASSERT(m_fd != -1); int seekdir = (m == 1)?SEEK_SET:SEEK_END; #ifdef _WIN32 @@ -288,8 +289,8 @@ namespace libtorrent size_type tell() { - assert(m_open_mode); - assert(m_fd != -1); + TORRENT_ASSERT(m_open_mode); + TORRENT_ASSERT(m_fd != -1); #ifdef _WIN32 return _telli64(m_fd); diff --git a/libtorrent/src/file_pool.cpp b/libtorrent/src/file_pool.cpp index ab4ea8d6c..7bdf24085 100644 --- a/libtorrent/src/file_pool.cpp +++ b/libtorrent/src/file_pool.cpp @@ -43,9 +43,9 @@ namespace libtorrent boost::shared_ptr file_pool::open_file(void* st, fs::path const& p, file::open_mode m) { - assert(st != 0); - assert(p.is_complete()); - assert(m == file::in || m == (file::in | file::out)); + TORRENT_ASSERT(st != 0); + TORRENT_ASSERT(p.is_complete()); + TORRENT_ASSERT(m == file::in || m == (file::in | file::out)); boost::mutex::scoped_lock l(m_mutex); typedef nth_index::type path_view; path_view& pt = get<0>(m_files); @@ -69,7 +69,7 @@ namespace libtorrent // close the file before we open it with // the new read/write privilages i->file_ptr.reset(); - assert(e.file_ptr.unique()); + TORRENT_ASSERT(e.file_ptr.unique()); e.file_ptr.reset(); e.file_ptr.reset(new file(p, m)); e.mode = m; @@ -86,7 +86,7 @@ namespace libtorrent lru_view& lt = get<1>(m_files); lru_view::iterator i = lt.begin(); // the first entry in this view is the least recently used - assert(lt.size() == 1 || (i->last_use <= boost::next(i)->last_use)); + TORRENT_ASSERT(lt.size() == 1 || (i->last_use <= boost::next(i)->last_use)); lt.erase(i); } lru_file_entry e(boost::shared_ptr(new file(p, m))); @@ -100,7 +100,7 @@ namespace libtorrent void file_pool::release(void* st) { boost::mutex::scoped_lock l(m_mutex); - assert(st != 0); + TORRENT_ASSERT(st != 0); using boost::tie; typedef nth_index::type key_view; @@ -113,7 +113,7 @@ namespace libtorrent void file_pool::resize(int size) { - assert(size > 0); + TORRENT_ASSERT(size > 0); if (size == m_size) return; boost::mutex::scoped_lock l(m_mutex); m_size = size; @@ -126,7 +126,7 @@ namespace libtorrent while (int(m_files.size()) > m_size) { // the first entry in this view is the least recently used - assert(lt.size() == 1 || (i->last_use <= boost::next(i)->last_use)); + TORRENT_ASSERT(lt.size() == 1 || (i->last_use <= boost::next(i)->last_use)); lt.erase(i++); } } diff --git a/libtorrent/src/file_win.cpp b/libtorrent/src/file_win.cpp index 9d2c2f4bf..7fde0028f 100644 --- a/libtorrent/src/file_win.cpp +++ b/libtorrent/src/file_win.cpp @@ -32,6 +32,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/file.hpp" #include "libtorrent/utf8.hpp" +#include "libtorrent/assert.hpp" #ifdef UNICODE #include "libtorrent/storage.hpp" @@ -136,8 +137,8 @@ namespace libtorrent void open(const char *file_name, open_flags flags) { - assert(file_name); - assert(flags & (read_flag | write_flag)); + TORRENT_ASSERT(file_name); + TORRENT_ASSERT(flags & (read_flag | write_flag)); DWORD access_mask = 0; if (flags & read_flag) @@ -145,7 +146,7 @@ namespace libtorrent if (flags & write_flag) access_mask |= GENERIC_WRITE; - assert(access_mask & (GENERIC_READ | GENERIC_WRITE)); + TORRENT_ASSERT(access_mask & (GENERIC_READ | GENERIC_WRITE)); #ifdef UNICODE std::wstring wfile_name(safe_convert(file_name)); @@ -198,8 +199,8 @@ namespace libtorrent size_type write(const char* buffer, size_type num_bytes) { - assert(buffer); - assert((DWORD)num_bytes == num_bytes); + TORRENT_ASSERT(buffer); + TORRENT_ASSERT((DWORD)num_bytes == num_bytes); DWORD bytes_written = 0; if (num_bytes != 0) { @@ -218,9 +219,9 @@ namespace libtorrent size_type read(char* buffer, size_type num_bytes) { - assert(buffer); - assert(num_bytes >= 0); - assert((DWORD)num_bytes == num_bytes); + TORRENT_ASSERT(buffer); + TORRENT_ASSERT(num_bytes >= 0); + TORRENT_ASSERT((DWORD)num_bytes == num_bytes); DWORD bytes_read = 0; if (num_bytes != 0) @@ -250,8 +251,8 @@ namespace libtorrent size_type seek(size_type pos, seek_mode from_where) { - assert(pos >= 0 || from_where != seek_begin); - assert(pos <= 0 || from_where != seek_end); + TORRENT_ASSERT(pos >= 0 || from_where != seek_begin); + TORRENT_ASSERT(pos <= 0 || from_where != seek_end); LARGE_INTEGER offs; offs.QuadPart = pos; if (FALSE == SetFilePointerEx( @@ -281,7 +282,7 @@ namespace libtorrent } size_type pos = offs.QuadPart; - assert(pos >= 0); + TORRENT_ASSERT(pos >= 0); return pos; } /* @@ -294,7 +295,7 @@ namespace libtorrent } size_type size = s.QuadPart; - assert(size >= 0); + TORRENT_ASSERT(size >= 0); return size; } */ @@ -330,7 +331,7 @@ namespace libtorrent void file::open(boost::filesystem::path const& p, open_mode m) { - assert(p.is_complete()); + TORRENT_ASSERT(p.is_complete()); m_impl->open(p.native_file_string().c_str(), impl::open_flags(m.m_mask)); } diff --git a/libtorrent/src/http_connection.cpp b/libtorrent/src/http_connection.cpp index 5dd568655..08be387cc 100644 --- a/libtorrent/src/http_connection.cpp +++ b/libtorrent/src/http_connection.cpp @@ -148,7 +148,7 @@ void http_connection::on_resolve(asio::error_code const& e m_handler(e, m_parser, 0, 0); return; } - assert(i != tcp::resolver::iterator()); + TORRENT_ASSERT(i != tcp::resolver::iterator()); m_cc.enqueue(bind(&http_connection::connect, shared_from_this(), _1, *i) , bind(&http_connection::on_connect_timeout, shared_from_this()) , m_timeout); @@ -225,7 +225,7 @@ void http_connection::on_read(asio::error_code const& e if (m_rate_limit) { m_download_quota -= bytes_transferred; - assert(m_download_quota >= 0); + TORRENT_ASSERT(m_download_quota >= 0); } if (e == asio::error::eof) @@ -254,7 +254,7 @@ void http_connection::on_read(asio::error_code const& e } m_read_pos += bytes_transferred; - assert(m_read_pos <= int(m_recvbuffer.size())); + TORRENT_ASSERT(m_read_pos <= int(m_recvbuffer.size())); // having a nonempty path means we should handle redirects if (m_redirect && m_parser.header_finished()) @@ -306,7 +306,7 @@ void http_connection::on_read(asio::error_code const& e } else { - assert(!m_bottled); + TORRENT_ASSERT(!m_bottled); m_handler(e, m_parser, &m_recvbuffer[0], m_read_pos); m_read_pos = 0; m_last_receive = time_now(); diff --git a/libtorrent/src/http_tracker_connection.cpp b/libtorrent/src/http_tracker_connection.cpp index 8c54cf7ff..de1783b58 100755 --- a/libtorrent/src/http_tracker_connection.cpp +++ b/libtorrent/src/http_tracker_connection.cpp @@ -119,7 +119,7 @@ namespace libtorrent boost::tuple http_parser::incoming(buffer::const_interval recv_buffer) { - assert(recv_buffer.left() >= m_recv_buffer.left()); + TORRENT_ASSERT(recv_buffer.left() >= m_recv_buffer.left()); boost::tuple ret(0, 0); // early exit if there's nothing new in the receive buffer @@ -129,7 +129,7 @@ namespace libtorrent char const* pos = recv_buffer.begin + m_recv_pos; if (m_state == read_status) { - assert(!m_finished); + TORRENT_ASSERT(!m_finished); char const* newline = std::find(pos, recv_buffer.end, '\n'); // if we don't have a full line yet, wait. if (newline == recv_buffer.end) return ret; @@ -166,7 +166,7 @@ namespace libtorrent if (m_state == read_header) { - assert(!m_finished); + TORRENT_ASSERT(!m_finished); char const* newline = std::find(pos, recv_buffer.end, '\n'); std::string line; @@ -226,7 +226,7 @@ namespace libtorrent m_content_length = range_end - range_start + 1; } - assert(m_recv_pos <= (int)recv_buffer.left()); + TORRENT_ASSERT(m_recv_pos <= (int)recv_buffer.left()); newline = std::find(pos, recv_buffer.end, '\n'); } } @@ -238,7 +238,7 @@ namespace libtorrent && m_content_length >= 0) incoming = m_content_length - m_recv_pos + m_body_start_pos; - assert(incoming >= 0); + TORRENT_ASSERT(incoming >= 0); m_recv_pos += incoming; boost::get<0>(ret) += incoming; @@ -253,7 +253,7 @@ namespace libtorrent buffer::const_interval http_parser::get_body() const { - assert(m_state == read_body); + TORRENT_ASSERT(m_state == read_body); if (m_content_length >= 0) return buffer::const_interval(m_recv_buffer.begin + m_body_start_pos , m_recv_buffer.begin + (std::min)(m_recv_pos @@ -534,7 +534,7 @@ namespace libtorrent != bind_interface().is_v4(); ++target); if (target == end) { - assert(target_address.address().is_v4() != bind_interface().is_v4()); + TORRENT_ASSERT(target_address.address().is_v4() != bind_interface().is_v4()); if (cb) { std::string tracker_address_type = target_address.address().is_v4() ? "IPv4" : "IPv6"; @@ -619,7 +619,7 @@ namespace libtorrent if (cb) cb->debug_log("tracker send data completed"); #endif restart_read_timeout(); - assert(m_buffer.size() - m_recv_pos > 0); + TORRENT_ASSERT(m_buffer.size() - m_recv_pos > 0); m_socket->async_read_some(asio::buffer(&m_buffer[m_recv_pos] , m_buffer.size() - m_recv_pos), bind(&http_tracker_connection::receive , self(), _1, _2)); @@ -650,7 +650,7 @@ namespace libtorrent } restart_read_timeout(); - assert(bytes_transferred > 0); + TORRENT_ASSERT(bytes_transferred > 0); #if defined(TORRENT_VERBOSE_LOGGING) || defined(TORRENT_LOGGING) boost::shared_ptr cb = requester(); if (cb) cb->debug_log("tracker connection reading " @@ -669,7 +669,7 @@ namespace libtorrent fail(200, "too large tracker response"); return; } - assert(http_buffer_size > 0); + TORRENT_ASSERT(http_buffer_size > 0); if ((int)m_buffer.size() + http_buffer_size > m_settings.tracker_maximum_response_length) m_buffer.resize(m_settings.tracker_maximum_response_length); @@ -700,7 +700,7 @@ namespace libtorrent return; } - assert(m_buffer.size() - m_recv_pos > 0); + TORRENT_ASSERT(m_buffer.size() - m_recv_pos > 0); m_socket->async_read_some(asio::buffer(&m_buffer[m_recv_pos] , m_buffer.size() - m_recv_pos), bind(&http_tracker_connection::receive , self(), _1, _2)); @@ -816,7 +816,7 @@ namespace libtorrent #ifndef NDEBUG catch (...) { - assert(false); + TORRENT_ASSERT(false); } #endif } diff --git a/libtorrent/src/identify_client.cpp b/libtorrent/src/identify_client.cpp index 7fa808f20..4888f4a95 100755 --- a/libtorrent/src/identify_client.cpp +++ b/libtorrent/src/identify_client.cpp @@ -267,7 +267,7 @@ namespace #ifndef NDEBUG for (int i = 1; i < size; ++i) { - assert(compare_id(name_map[i-1] + TORRENT_ASSERT(compare_id(name_map[i-1] , name_map[i])); } #endif diff --git a/libtorrent/src/ip_filter.cpp b/libtorrent/src/ip_filter.cpp index cf368c4d1..05334e578 100644 --- a/libtorrent/src/ip_filter.cpp +++ b/libtorrent/src/ip_filter.cpp @@ -43,23 +43,23 @@ namespace libtorrent { if (first.is_v4()) { - assert(last.is_v4()); + TORRENT_ASSERT(last.is_v4()); m_filter4.add_rule(first.to_v4(), last.to_v4(), flags); } else if (first.is_v6()) { - assert(last.is_v6()); + TORRENT_ASSERT(last.is_v6()); m_filter6.add_rule(first.to_v6(), last.to_v6(), flags); } else - assert(false); + TORRENT_ASSERT(false); } int ip_filter::access(address const& addr) const { if (addr.is_v4()) return m_filter4.access(addr.to_v4()); - assert(addr.is_v6()); + TORRENT_ASSERT(addr.is_v6()); return m_filter6.access(addr.to_v6()); } diff --git a/libtorrent/src/kademlia/closest_nodes.cpp b/libtorrent/src/kademlia/closest_nodes.cpp index a3849ed69..3fbbef07d 100644 --- a/libtorrent/src/kademlia/closest_nodes.cpp +++ b/libtorrent/src/kademlia/closest_nodes.cpp @@ -51,7 +51,7 @@ void closest_nodes_observer::reply(msg const& in) { if (!m_algorithm) { - assert(false); + TORRENT_ASSERT(false); return; } diff --git a/libtorrent/src/kademlia/dht_tracker.cpp b/libtorrent/src/kademlia/dht_tracker.cpp index c9908a163..b2981f7cd 100644 --- a/libtorrent/src/kademlia/dht_tracker.cpp +++ b/libtorrent/src/kademlia/dht_tracker.cpp @@ -126,15 +126,15 @@ namespace libtorrent { namespace dht void intrusive_ptr_add_ref(dht_tracker const* c) { - assert(c != 0); - assert(c->m_refs >= 0); + TORRENT_ASSERT(c != 0); + TORRENT_ASSERT(c->m_refs >= 0); ++c->m_refs; } void intrusive_ptr_release(dht_tracker const* c) { - assert(c != 0); - assert(c->m_refs > 0); + TORRENT_ASSERT(c != 0); + TORRENT_ASSERT(c->m_refs > 0); if (--c->m_refs == 0) delete c; } @@ -247,7 +247,7 @@ namespace libtorrent { namespace dht #ifndef NDEBUG std::cerr << "exception-type: " << typeid(exc).name() << std::endl; std::cerr << "what: " << exc.what() << std::endl; - assert(false); + TORRENT_ASSERT(false); #endif }; @@ -263,7 +263,7 @@ namespace libtorrent { namespace dht } catch (std::exception&) { - assert(false); + TORRENT_ASSERT(false); }; void dht_tracker::rebind(asio::ip::address listen_interface, int listen_port) @@ -375,7 +375,7 @@ namespace libtorrent { namespace dht } catch (std::exception&) { - assert(false); + TORRENT_ASSERT(false); }; void dht_tracker::announce(sha1_hash const& ih, int listen_port @@ -411,7 +411,7 @@ namespace libtorrent { namespace dht using libtorrent::entry; using libtorrent::bdecode; - assert(bytes_transferred > 0); + TORRENT_ASSERT(bytes_transferred > 0); entry e = bdecode(m_in_buf[current_buffer].begin() , m_in_buf[current_buffer].end()); @@ -654,7 +654,7 @@ namespace libtorrent { namespace dht } TORRENT_LOG(dht_tracker) << e; #endif - assert(m.message_id != messages::error); + TORRENT_ASSERT(m.message_id != messages::error); m_dht.incoming(m); } catch (std::exception& e) @@ -670,7 +670,7 @@ namespace libtorrent { namespace dht } catch (std::exception& e) { - assert(false); + TORRENT_ASSERT(false); }; entry dht_tracker::state() const @@ -725,7 +725,7 @@ namespace libtorrent { namespace dht } catch (std::exception&) { - assert(false); + TORRENT_ASSERT(false); }; void dht_tracker::add_router_node(std::pair const& node) @@ -744,7 +744,7 @@ namespace libtorrent { namespace dht } catch (std::exception&) { - assert(false); + TORRENT_ASSERT(false); }; void dht_tracker::on_bootstrap() @@ -800,7 +800,7 @@ namespace libtorrent { namespace dht using libtorrent::bencode; using libtorrent::entry; entry e(entry::dictionary_t); - assert(!m.transaction_id.empty() || m.message_id == messages::error); + TORRENT_ASSERT(!m.transaction_id.empty() || m.message_id == messages::error); e["t"] = m.transaction_id; static char const version_str[] = {'L', 'T' , LIBTORRENT_VERSION_MAJOR, LIBTORRENT_VERSION_MINOR}; @@ -814,10 +814,10 @@ namespace libtorrent { namespace dht if (m.message_id == messages::error) { - assert(m.reply); + TORRENT_ASSERT(m.reply); e["y"] = "e"; entry error_list(entry::list_t); - assert(m.error_code > 200 && m.error_code <= 204); + TORRENT_ASSERT(m.error_code > 200 && m.error_code <= 204); error_list.list().push_back(entry(m.error_code)); error_list.list().push_back(entry(m.error_msg)); e["e"] = error_list; @@ -891,7 +891,7 @@ namespace libtorrent { namespace dht if (m.write_token.type() != entry::undefined_t) a["token"] = m.write_token; - assert(m.message_id <= messages::error); + TORRENT_ASSERT(m.message_id <= messages::error); e["q"] = messages::ids[m.message_id]; #ifdef TORRENT_DHT_VERBOSE_LOGGING @@ -973,7 +973,7 @@ namespace libtorrent { namespace dht // m_send may fail with "no route to host" // but it shouldn't throw since an error code // is passed in instead - assert(false); + TORRENT_ASSERT(false); } }} diff --git a/libtorrent/src/kademlia/find_data.cpp b/libtorrent/src/kademlia/find_data.cpp index 4ada42fb3..5db80fe80 100644 --- a/libtorrent/src/kademlia/find_data.cpp +++ b/libtorrent/src/kademlia/find_data.cpp @@ -49,7 +49,7 @@ void find_data_observer::reply(msg const& m) { if (!m_algorithm) { - assert(false); + TORRENT_ASSERT(false); return; } diff --git a/libtorrent/src/kademlia/node.cpp b/libtorrent/src/kademlia/node.cpp index 74641ec43..be42c8635 100644 --- a/libtorrent/src/kademlia/node.cpp +++ b/libtorrent/src/kademlia/node.cpp @@ -219,7 +219,7 @@ void node_impl::new_write_key() void node_impl::refresh_bucket(int bucket) try { - assert(bucket >= 0 && bucket < 160); + TORRENT_ASSERT(bucket >= 0 && bucket < 160); // generate a random node_id within the given bucket node_id target = generate_id(); @@ -243,7 +243,7 @@ void node_impl::refresh_bucket(int bucket) try target[(num_bits - 1) / 8] |= (~(m_id[(num_bits - 1) / 8])) & (0x80 >> ((num_bits - 1) % 8)); - assert(distance_exp(m_id, target) == bucket); + TORRENT_ASSERT(distance_exp(m_id, target) == bucket); std::vector start; start.reserve(m_table.bucket_size()); @@ -323,7 +323,7 @@ time_duration node_impl::refresh_timeout() } if (next < now) { - assert(refresh > -1); + TORRENT_ASSERT(refresh > -1); #ifdef TORRENT_DHT_VERBOSE_LOGGING TORRENT_LOG(node) << "refreshing bucket: " << refresh; #endif @@ -484,7 +484,7 @@ void node_impl::incoming_request(msg const& m) on_announce(m, reply); break; default: - assert(false); + TORRENT_ASSERT(false); }; if (m_table.need_node(m.id)) diff --git a/libtorrent/src/kademlia/node_id.cpp b/libtorrent/src/kademlia/node_id.cpp index ad06c515d..52a5c766a 100644 --- a/libtorrent/src/kademlia/node_id.cpp +++ b/libtorrent/src/kademlia/node_id.cpp @@ -80,7 +80,7 @@ int distance_exp(node_id const& n1, node_id const& n2) for (node_id::const_iterator i = n1.begin(), j = n2.begin() , end(n1.end()); i != end; ++i, ++j, --byte) { - assert(byte >= 0); + TORRENT_ASSERT(byte >= 0); boost::uint8_t t = *i ^ *j; if (t == 0) continue; // we have found the first non-zero byte diff --git a/libtorrent/src/kademlia/routing_table.cpp b/libtorrent/src/kademlia/routing_table.cpp index 45091481c..02a7ffb12 100644 --- a/libtorrent/src/kademlia/routing_table.cpp +++ b/libtorrent/src/kademlia/routing_table.cpp @@ -164,8 +164,8 @@ void routing_table::touch_bucket(int bucket) ptime routing_table::next_refresh(int bucket) { - assert(bucket < 160); - assert(bucket >= 0); + TORRENT_ASSERT(bucket < 160); + TORRENT_ASSERT(bucket >= 0); // lower than or equal to since a refresh of bucket 0 will // effectively refresh the lowest active bucket as well if (bucket < m_lowest_active_bucket && bucket > 0) @@ -186,8 +186,8 @@ void routing_table::replacement_cache(bucket_t& nodes) const bool routing_table::need_node(node_id const& id) { int bucket_index = distance_exp(m_id, id); - assert(bucket_index < (int)m_buckets.size()); - assert(bucket_index >= 0); + TORRENT_ASSERT(bucket_index < (int)m_buckets.size()); + TORRENT_ASSERT(bucket_index >= 0); bucket_t& b = m_buckets[bucket_index].first; bucket_t& rb = m_buckets[bucket_index].second; @@ -209,8 +209,8 @@ bool routing_table::need_node(node_id const& id) void routing_table::node_failed(node_id const& id) { int bucket_index = distance_exp(m_id, id); - assert(bucket_index < (int)m_buckets.size()); - assert(bucket_index >= 0); + TORRENT_ASSERT(bucket_index < (int)m_buckets.size()); + TORRENT_ASSERT(bucket_index >= 0); bucket_t& b = m_buckets[bucket_index].first; bucket_t& rb = m_buckets[bucket_index].second; @@ -228,7 +228,7 @@ void routing_table::node_failed(node_id const& id) if (i->fail_count >= m_settings.max_fail_count) { b.erase(i); - assert(m_lowest_active_bucket <= bucket_index); + TORRENT_ASSERT(m_lowest_active_bucket <= bucket_index); while (m_buckets[m_lowest_active_bucket].first.empty() && m_lowest_active_bucket < 160) { @@ -259,8 +259,8 @@ bool routing_table::node_seen(node_id const& id, udp::endpoint addr) { if (m_router_nodes.find(addr) != m_router_nodes.end()) return false; int bucket_index = distance_exp(m_id, id); - assert(bucket_index < (int)m_buckets.size()); - assert(bucket_index >= 0); + TORRENT_ASSERT(bucket_index < (int)m_buckets.size()); + TORRENT_ASSERT(bucket_index >= 0); bucket_t& b = m_buckets[bucket_index].first; bucket_t::iterator i = std::find_if(b.begin(), b.end() @@ -274,7 +274,7 @@ bool routing_table::node_seen(node_id const& id, udp::endpoint addr) { // TODO: what do we do if we see a node with // the same id as a node at a different address? -// assert(i->addr == addr); +// TORRENT_ASSERT(i->addr == addr); // we already have the node in our bucket // just move it to the back since it was @@ -371,11 +371,11 @@ void routing_table::find_node(node_id const& target // vector. std::remove_copy_if(b.begin(), b.end(), std::back_inserter(l) , bind(&node_entry::fail_count, _1)); - assert((int)l.size() <= count); + TORRENT_ASSERT((int)l.size() <= count); if ((int)l.size() == count) { - assert(std::count_if(l.begin(), l.end() + TORRENT_ASSERT(std::count_if(l.begin(), l.end() , boost::bind(&node_entry::fail_count, _1) != 0) == 0); return; } @@ -399,7 +399,7 @@ void routing_table::find_node(node_id const& target std::copy(tmpb.begin(), tmpb.begin() + to_copy , std::back_inserter(l)); - assert((int)l.size() <= m_bucket_size); + TORRENT_ASSERT((int)l.size() <= m_bucket_size); // return if we have enough nodes or if the bucket index // is the biggest index available (there are no more buckets) @@ -407,7 +407,7 @@ void routing_table::find_node(node_id const& target if ((int)l.size() == count || bucket_index == (int)m_buckets.size() - 1) { - assert(std::count_if(l.begin(), l.end() + TORRENT_ASSERT(std::count_if(l.begin(), l.end() , boost::bind(&node_entry::fail_count, _1) != 0) == 0); return; } @@ -421,16 +421,16 @@ void routing_table::find_node(node_id const& target if ((int)l.size() >= count) { l.erase(l.begin() + count, l.end()); - assert(std::count_if(l.begin(), l.end() + TORRENT_ASSERT(std::count_if(l.begin(), l.end() , boost::bind(&node_entry::fail_count, _1) != 0) == 0); return; } } - assert((int)l.size() == count + TORRENT_ASSERT((int)l.size() == count || std::distance(l.begin(), l.end()) < m_bucket_size); - assert((int)l.size() <= count); + TORRENT_ASSERT((int)l.size() <= count); - assert(std::count_if(l.begin(), l.end() + TORRENT_ASSERT(std::count_if(l.begin(), l.end() , boost::bind(&node_entry::fail_count, _1) != 0) == 0); } diff --git a/libtorrent/src/kademlia/rpc_manager.cpp b/libtorrent/src/kademlia/rpc_manager.cpp index 247c79a0f..086b8fc44 100644 --- a/libtorrent/src/kademlia/rpc_manager.cpp +++ b/libtorrent/src/kademlia/rpc_manager.cpp @@ -70,15 +70,15 @@ TORRENT_DEFINE_LOG(rpc) void intrusive_ptr_add_ref(observer const* o) { - assert(o->m_refs >= 0); - assert(o != 0); + TORRENT_ASSERT(o->m_refs >= 0); + TORRENT_ASSERT(o != 0); ++o->m_refs; } void intrusive_ptr_release(observer const* o) { - assert(o->m_refs > 0); - assert(o != 0); + TORRENT_ASSERT(o->m_refs > 0); + TORRENT_ASSERT(o != 0); if (--o->m_refs == 0) { boost::pool<>& p = o->pool_allocator; @@ -138,16 +138,16 @@ rpc_manager::~rpc_manager() #ifndef NDEBUG void rpc_manager::check_invariant() const { - assert(m_oldest_transaction_id >= 0); - assert(m_oldest_transaction_id < max_transactions); - assert(m_next_transaction_id >= 0); - assert(m_next_transaction_id < max_transactions); - assert(!m_transactions[m_next_transaction_id]); + TORRENT_ASSERT(m_oldest_transaction_id >= 0); + TORRENT_ASSERT(m_oldest_transaction_id < max_transactions); + TORRENT_ASSERT(m_next_transaction_id >= 0); + TORRENT_ASSERT(m_next_transaction_id < max_transactions); + TORRENT_ASSERT(!m_transactions[m_next_transaction_id]); for (int i = (m_next_transaction_id + 1) % max_transactions; i != m_oldest_transaction_id; i = (i + 1) % max_transactions) { - assert(!m_transactions[i]); + TORRENT_ASSERT(!m_transactions[i]); } } #endif @@ -246,7 +246,7 @@ bool rpc_manager::incoming(msg const& m) } else { - assert(m.message_id != messages::error); + TORRENT_ASSERT(m.message_id != messages::error); // this is an incoming request m_incoming(m); } @@ -268,8 +268,8 @@ time_duration rpc_manager::tick() for (;m_next_transaction_id != m_oldest_transaction_id; m_oldest_transaction_id = (m_oldest_transaction_id + 1) % max_transactions) { - assert(m_oldest_transaction_id >= 0); - assert(m_oldest_transaction_id < max_transactions); + TORRENT_ASSERT(m_oldest_transaction_id >= 0); + TORRENT_ASSERT(m_oldest_transaction_id < max_transactions); observer_ptr o = m_transactions[m_oldest_transaction_id]; if (!o) continue; @@ -311,9 +311,9 @@ unsigned int rpc_manager::new_transaction_id(observer_ptr o) // since that would break the invariant m_aborted_transactions.push_back(m_transactions[m_next_transaction_id]); m_transactions[m_next_transaction_id] = 0; - assert(m_oldest_transaction_id == m_next_transaction_id); + TORRENT_ASSERT(m_oldest_transaction_id == m_next_transaction_id); } - assert(!m_transactions[tid]); + TORRENT_ASSERT(!m_transactions[tid]); m_transactions[tid] = o; if (m_oldest_transaction_id == m_next_transaction_id) { @@ -332,7 +332,7 @@ void rpc_manager::update_oldest_transaction_id() { INVARIANT_CHECK; - assert(m_oldest_transaction_id != m_next_transaction_id); + TORRENT_ASSERT(m_oldest_transaction_id != m_next_transaction_id); while (!m_transactions[m_oldest_transaction_id]) { m_oldest_transaction_id = (m_oldest_transaction_id + 1) @@ -358,7 +358,7 @@ void rpc_manager::invoke(int message_id, udp::endpoint target_addr m.reply = false; m.id = m_our_id; m.addr = target_addr; - assert(!m_transactions[m_next_transaction_id]); + TORRENT_ASSERT(!m_transactions[m_next_transaction_id]); #ifndef NDEBUG int potential_new_id = m_next_transaction_id; #endif @@ -383,7 +383,7 @@ void rpc_manager::invoke(int message_id, udp::endpoint target_addr catch (std::exception& e) { // m_send may fail with "no route to host" - assert(potential_new_id == m_next_transaction_id); + TORRENT_ASSERT(potential_new_id == m_next_transaction_id); o->abort(); } } @@ -394,7 +394,7 @@ void rpc_manager::reply(msg& m) if (m_destructing) return; - assert(m.reply); + TORRENT_ASSERT(m.reply); m.piggy_backed_ping = false; m.id = m_our_id; @@ -406,7 +406,7 @@ void rpc_manager::reply_with_ping(msg& m) INVARIANT_CHECK; if (m_destructing) return; - assert(m.reply); + TORRENT_ASSERT(m.reply); m.piggy_backed_ping = true; m.id = m_our_id; @@ -416,7 +416,7 @@ void rpc_manager::reply_with_ping(msg& m) io::write_uint16(m_next_transaction_id, out); observer_ptr o(new (allocator().malloc()) null_observer(allocator())); - assert(!m_transactions[m_next_transaction_id]); + TORRENT_ASSERT(!m_transactions[m_next_transaction_id]); o->sent = time_now(); o->target_addr = m.addr; diff --git a/libtorrent/src/kademlia/traversal_algorithm.cpp b/libtorrent/src/kademlia/traversal_algorithm.cpp index ceb977f19..b0d3c5e74 100644 --- a/libtorrent/src/kademlia/traversal_algorithm.cpp +++ b/libtorrent/src/kademlia/traversal_algorithm.cpp @@ -67,7 +67,7 @@ void traversal_algorithm::add_entry(node_id const& id, udp::endpoint addr, unsig if (i == m_results.end() || i->id != id) { - assert(std::find_if(m_results.begin(), m_results.end() + TORRENT_ASSERT(std::find_if(m_results.begin(), m_results.end() , bind(&result::id, _1) == id) == m_results.end()); #ifdef TORRENT_DHT_VERBOSE_LOGGING TORRENT_LOG(traversal) << "adding result: " << id << " " << addr; @@ -110,11 +110,11 @@ void traversal_algorithm::failed(node_id const& id, bool prevent_request) ) ); - assert(i != m_results.end()); + TORRENT_ASSERT(i != m_results.end()); if (i != m_results.end()) { - assert(i->flags & result::queried); + TORRENT_ASSERT(i->flags & result::queried); m_failed.insert(i->addr); #ifdef TORRENT_DHT_VERBOSE_LOGGING TORRENT_LOG(traversal) << "failed: " << i->id << " " << i->addr; diff --git a/libtorrent/src/metadata_transfer.cpp b/libtorrent/src/metadata_transfer.cpp index 0623b156f..e02a2d758 100644 --- a/libtorrent/src/metadata_transfer.cpp +++ b/libtorrent/src/metadata_transfer.cpp @@ -65,10 +65,10 @@ namespace libtorrent { namespace std::pair req_to_offset(std::pair req, int total_size) { - assert(req.first >= 0); - assert(req.second > 0); - assert(req.second <= 256); - assert(req.first + req.second <= 256); + TORRENT_ASSERT(req.first >= 0); + TORRENT_ASSERT(req.second > 0); + TORRENT_ASSERT(req.second <= 256); + TORRENT_ASSERT(req.first + req.second <= 256); int start = div_round_up(req.first * total_size, 256); int size = div_round_up((req.first + req.second) * total_size, 256) - start; @@ -82,15 +82,15 @@ namespace libtorrent { namespace std::pair ret(start, size); - assert(start >= 0); - assert(size > 0); - assert(start <= 256); - assert(start + size <= 256); + TORRENT_ASSERT(start >= 0); + TORRENT_ASSERT(size > 0); + TORRENT_ASSERT(start <= 256); + TORRENT_ASSERT(start + size <= 256); // assert the identity of this function #ifndef NDEBUG std::pair identity = req_to_offset(ret, total_size); - assert(offset == identity); + TORRENT_ASSERT(offset == identity); #endif return ret; } @@ -124,10 +124,10 @@ namespace libtorrent { namespace bencode(std::back_inserter(m_metadata) , m_torrent.torrent_file().create_info_metadata()); - assert(hasher(&m_metadata[0], m_metadata.size()).final() + TORRENT_ASSERT(hasher(&m_metadata[0], m_metadata.size()).final() == m_torrent.torrent_file().info_hash()); } - assert(!m_metadata.empty()); + TORRENT_ASSERT(!m_metadata.empty()); return m_metadata; } @@ -149,7 +149,7 @@ namespace libtorrent { namespace std::pair req = offset_to_req(std::make_pair(offset, size) , total_size); - assert(req.first + req.second <= (int)m_have_metadata.size()); + TORRENT_ASSERT(req.first + req.second <= (int)m_have_metadata.size()); std::fill( m_have_metadata.begin() + req.first @@ -203,7 +203,7 @@ namespace libtorrent { namespace { for (int i = req.first; i < req.first + req.second; ++i) { - assert(m_requested_metadata[i] > 0); + TORRENT_ASSERT(m_requested_metadata[i] > 0); if (m_requested_metadata[i] > 0) --m_requested_metadata[i]; } @@ -288,11 +288,11 @@ namespace libtorrent { namespace void write_metadata_request(std::pair req) { - assert(req.first >= 0); - assert(req.second > 0); - assert(req.first + req.second <= 256); - assert(!m_pc.associated_torrent().expired()); - assert(!m_pc.associated_torrent().lock()->valid_metadata()); + TORRENT_ASSERT(req.first >= 0); + TORRENT_ASSERT(req.second > 0); + TORRENT_ASSERT(req.first + req.second <= 256); + TORRENT_ASSERT(!m_pc.associated_torrent().expired()); + TORRENT_ASSERT(!m_pc.associated_torrent().lock()->valid_metadata()); int start = req.first; int size = req.second; @@ -309,17 +309,17 @@ namespace libtorrent { namespace detail::write_uint8(0, i.begin); detail::write_uint8(start, i.begin); detail::write_uint8(size - 1, i.begin); - assert(i.begin == i.end); + TORRENT_ASSERT(i.begin == i.end); m_pc.setup_send(); } void write_metadata(std::pair req) { - assert(req.first >= 0); - assert(req.second > 0); - assert(req.second <= 256); - assert(req.first + req.second <= 256); - assert(!m_pc.associated_torrent().expired()); + TORRENT_ASSERT(req.first >= 0); + TORRENT_ASSERT(req.second > 0); + TORRENT_ASSERT(req.second <= 256); + TORRENT_ASSERT(req.first + req.second <= 256); + TORRENT_ASSERT(!m_pc.associated_torrent().expired()); // abort if the peer doesn't support the metadata extension if (m_message_index == 0) return; @@ -344,7 +344,7 @@ namespace libtorrent { namespace std::copy(metadata.begin() + offset.first , metadata.begin() + offset.first + offset.second, i.begin); i.begin += offset.second; - assert(i.begin == i.end); + TORRENT_ASSERT(i.begin == i.end); } else { @@ -356,7 +356,7 @@ namespace libtorrent { namespace detail::write_uint8(m_message_index, i.begin); // means 'have no data' detail::write_uint8(2, i.begin); - assert(i.begin == i.end); + TORRENT_ASSERT(i.begin == i.end); } m_pc.setup_send(); } @@ -521,7 +521,7 @@ namespace libtorrent { namespace // the number of blocks to request int num_blocks = 256 / (peers + 1); if (num_blocks < 1) num_blocks = 1; - assert(num_blocks <= 128); + TORRENT_ASSERT(num_blocks <= 128); int min_element = (std::numeric_limits::max)(); int best_index = 0; @@ -543,10 +543,10 @@ namespace libtorrent { namespace for (int i = ret.first; i < ret.first + ret.second; ++i) m_requested_metadata[i]++; - assert(ret.first >= 0); - assert(ret.second > 0); - assert(ret.second <= 256); - assert(ret.first + ret.second <= 256); + TORRENT_ASSERT(ret.first >= 0); + TORRENT_ASSERT(ret.second > 0); + TORRENT_ASSERT(ret.second <= 256); + TORRENT_ASSERT(ret.first + ret.second <= 256); return ret; } diff --git a/libtorrent/src/natpmp.cpp b/libtorrent/src/natpmp.cpp index 38ae52413..42cf89e37 100644 --- a/libtorrent/src/natpmp.cpp +++ b/libtorrent/src/natpmp.cpp @@ -168,7 +168,7 @@ void natpmp::send_map_request(int i) try { using namespace libtorrent::detail; - assert(m_currently_mapping == -1 + TORRENT_ASSERT(m_currently_mapping == -1 || m_currently_mapping == i); m_currently_mapping = i; mapping& m = m_mappings[i]; @@ -232,7 +232,7 @@ void natpmp::on_reply(asio::error_code const& e m_send_timer.cancel(); - assert(m_currently_mapping >= 0); + TORRENT_ASSERT(m_currently_mapping >= 0); int i = m_currently_mapping; mapping& m = m_mappings[i]; diff --git a/libtorrent/src/pe_crypto.cpp b/libtorrent/src/pe_crypto.cpp index 981eca63d..955a7fea0 100644 --- a/libtorrent/src/pe_crypto.cpp +++ b/libtorrent/src/pe_crypto.cpp @@ -66,7 +66,7 @@ namespace libtorrent { int len_dh = sizeof(m_dh_prime); // must equal DH_size(m_DH) if (key_size != len_dh) { - assert(key_size > 0 && key_size < len_dh); + TORRENT_ASSERT(key_size > 0 && key_size < len_dh); int pad_zero_size = len_dh - key_size; std::fill(m_dh_local_key, m_dh_local_key + pad_zero_size, 0); @@ -100,7 +100,7 @@ namespace libtorrent { if (secret_size != 96) { - assert(secret_size < 96 && secret_size > 0); + TORRENT_ASSERT(secret_size < 96 && secret_size > 0); std::fill(m_dh_secret, m_dh_secret + 96 - secret_size, 0); } std::copy(dh_secret, dh_secret + secret_size, m_dh_secret + 96 - secret_size); diff --git a/libtorrent/src/peer_connection.cpp b/libtorrent/src/peer_connection.cpp index 327bb2074..9b975ab11 100755 --- a/libtorrent/src/peer_connection.cpp +++ b/libtorrent/src/peer_connection.cpp @@ -119,6 +119,7 @@ namespace libtorrent , m_remote_dl_rate(0) , m_remote_dl_update(time_now()) , m_outstanding_writing_bytes(0) + , m_fast_reconnect(false) #ifndef NDEBUG , m_in_constructor(true) #endif @@ -133,7 +134,7 @@ namespace libtorrent #endif boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); std::fill(m_peer_id.begin(), m_peer_id.end(), 0); if (t->ready_for_connections()) @@ -195,6 +196,7 @@ namespace libtorrent , m_remote_dl_rate(0) , m_remote_dl_update(time_now()) , m_outstanding_writing_bytes(0) + , m_fast_reconnect(false) #ifndef NDEBUG , m_in_constructor(true) #endif @@ -207,7 +209,7 @@ namespace libtorrent m_remote = m_socket->remote_endpoint(); #ifdef TORRENT_VERBOSE_LOGGING - assert(m_socket->remote_endpoint() == remote()); + TORRENT_ASSERT(m_socket->remote_endpoint() == remote()); m_logger = m_ses.create_log(remote().address().to_string() + "_" + boost::lexical_cast(remote().port()), m_ses.listen_port()); (*m_logger) << "*** INCOMING CONNECTION\n"; @@ -221,7 +223,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); bool interested = false; const std::vector& we_have = t->pieces(); @@ -245,7 +247,7 @@ namespace libtorrent // may throw an asio error if socket has disconnected catch (std::exception& e) {} - assert(is_interesting() == interested); + TORRENT_ASSERT(is_interesting() == interested); } #ifndef TORRENT_DISABLE_EXTENSIONS @@ -260,7 +262,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); int num_allowed_pieces = m_ses.settings().allowed_fast_set_size; int num_pieces = t->torrent_file().num_pieces(); @@ -321,9 +323,9 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); - assert(t->valid_metadata()); - assert(t->ready_for_connections()); + TORRENT_ASSERT(t); + TORRENT_ASSERT(t->valid_metadata()); + TORRENT_ASSERT(t->ready_for_connections()); m_have_piece.resize(t->torrent_file().num_pieces(), m_have_all); @@ -374,7 +376,7 @@ namespace libtorrent peer_connection::~peer_connection() { // INVARIANT_CHECK; - assert(m_disconnecting); + TORRENT_ASSERT(m_disconnecting); #ifdef TORRENT_VERBOSE_LOGGING if (m_logger) @@ -385,10 +387,10 @@ namespace libtorrent #endif #ifndef NDEBUG if (m_peer_info) - assert(m_peer_info->connection == 0); + TORRENT_ASSERT(m_peer_info->connection == 0); boost::shared_ptr t = m_torrent.lock(); - if (t) assert(t->connection_for(remote()) != this); + if (t) TORRENT_ASSERT(t->connection_for(remote()) != this); #endif } @@ -414,8 +416,8 @@ namespace libtorrent write_have(index); #ifndef NDEBUG boost::shared_ptr t = m_torrent.lock(); - assert(t); - assert(t->have_piece(index)); + TORRENT_ASSERT(t); + TORRENT_ASSERT(t->have_piece(index)); #endif } @@ -424,10 +426,10 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); - assert(t->valid_metadata()); - assert(i >= 0); - assert(i < t->torrent_file().num_pieces()); + TORRENT_ASSERT(t); + TORRENT_ASSERT(t->valid_metadata()); + TORRENT_ASSERT(i >= 0); + TORRENT_ASSERT(i < t->torrent_file().num_pieces()); return m_have_piece[i]; } @@ -514,9 +516,9 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); - assert(t->valid_metadata()); + TORRENT_ASSERT(t->valid_metadata()); torrent_info const& ti = t->torrent_file(); return p.piece >= 0 @@ -539,8 +541,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!m_disconnecting); - assert(m_torrent.expired()); + TORRENT_ASSERT(!m_disconnecting); + TORRENT_ASSERT(m_torrent.expired()); boost::weak_ptr wpt = m_ses.find_torrent(ih); boost::shared_ptr t = wpt.lock(); @@ -578,27 +580,27 @@ namespace libtorrent throw std::runtime_error("connection rejected by paused torrent"); } - assert(m_torrent.expired()); + TORRENT_ASSERT(m_torrent.expired()); // check to make sure we don't have another connection with the same // info_hash and peer_id. If we do. close this connection. t->attach_peer(this); m_torrent = wpt; - assert(!m_torrent.expired()); + TORRENT_ASSERT(!m_torrent.expired()); // if the torrent isn't ready to accept // connections yet, we'll have to wait with // our initialization if (t->ready_for_connections()) init(); - assert(!m_torrent.expired()); + TORRENT_ASSERT(!m_torrent.expired()); // assume the other end has no pieces // if we don't have valid metadata yet, // leave the vector unallocated - assert(m_num_pieces == 0); + TORRENT_ASSERT(m_num_pieces == 0); std::fill(m_have_piece.begin(), m_have_piece.end(), false); - assert(!m_torrent.expired()); + TORRENT_ASSERT(!m_torrent.expired()); } // message handlers @@ -625,7 +627,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -681,7 +683,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -801,7 +803,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -827,7 +829,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -862,16 +864,12 @@ namespace libtorrent m_became_uninterested = time_now(); - // clear the request queue if the client isn't interested - m_requests.clear(); -// setup_send(); - #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << time_now_string() << " <== NOT_INTERESTED\n"; #endif boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); m_peer_interested = false; t->get_policy().not_interested(*this); @@ -886,7 +884,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -944,7 +942,7 @@ namespace libtorrent if (is_seed()) { - assert(m_peer_info); + TORRENT_ASSERT(m_peer_info); m_peer_info->seed = true; if (t->is_finished()) { @@ -963,7 +961,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -1006,7 +1004,7 @@ namespace libtorrent return; } - assert(t->valid_metadata()); + TORRENT_ASSERT(t->valid_metadata()); int num_pieces = std::count(bitfield.begin(), bitfield.end(), true); if (num_pieces == int(m_have_piece.size())) @@ -1087,7 +1085,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -1225,7 +1223,7 @@ namespace libtorrent for (std::vector::const_iterator i = dl_queue.begin(); i != dl_queue.end(); ++i) { - assert(i->finished <= blocks_per_piece); + TORRENT_ASSERT(i->finished <= blocks_per_piece); } } } @@ -1244,7 +1242,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifndef TORRENT_DISABLE_EXTENSIONS for (extension_list_t::iterator i = m_extensions.begin() @@ -1292,8 +1290,8 @@ namespace libtorrent std::vector finished_blocks; piece_block block_finished(p.piece, p.start / t->block_size()); - assert(p.start % t->block_size() == 0); - assert(p.length == t->block_size() + TORRENT_ASSERT(p.start % t->block_size() == 0); + TORRENT_ASSERT(p.length == t->block_size() || p.length == t->torrent_file().total_size() % t->block_size()); std::deque::iterator b @@ -1366,7 +1364,7 @@ namespace libtorrent fs.async_write(p, data, bind(&peer_connection::on_disk_write_complete , self(), _1, _2, p, t)); m_outstanding_writing_bytes += p.length; - assert(!m_reading); + TORRENT_ASSERT(!m_reading); picker.mark_as_writing(block_finished, peer_info_struct()); } @@ -1376,7 +1374,7 @@ namespace libtorrent session_impl::mutex_t::scoped_lock l(m_ses.m_mutex); m_outstanding_writing_bytes -= p.length; - assert(m_outstanding_writing_bytes >= 0); + TORRENT_ASSERT(m_outstanding_writing_bytes >= 0); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << " *** on_disk_write_complete() " << p.length << "\n"; @@ -1406,8 +1404,8 @@ namespace libtorrent piece_picker& picker = t->picker(); - assert(p.piece == j.piece); - assert(p.start == j.offset); + TORRENT_ASSERT(p.piece == j.piece); + TORRENT_ASSERT(p.start == j.offset); piece_block block_finished(p.piece, p.start / t->block_size()); picker.mark_as_finished(block_finished, peer_info_struct()); if (t->alerts().should_post(alert::debug)) @@ -1443,7 +1441,7 @@ namespace libtorrent catch (std::exception const& e) { std::cerr << e.what() << std::endl; - assert(false); + TORRENT_ASSERT(false); } #endif } @@ -1511,7 +1509,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << time_now_string() << " <== HAVE_ALL\n"; @@ -1549,7 +1547,7 @@ namespace libtorrent if (t->is_finished()) throw protocol_error("seed to seed connection redundant, disconnecting"); - assert(!m_have_piece.empty()); + TORRENT_ASSERT(!m_have_piece.empty()); std::fill(m_have_piece.begin(), m_have_piece.end(), true); m_num_pieces = m_have_piece.size(); @@ -1567,7 +1565,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << time_now_string() << " <== HAVE_NONE\n"; @@ -1582,7 +1580,7 @@ namespace libtorrent #endif if (m_peer_info) m_peer_info->seed = false; - assert(!m_have_piece.empty() || !t->ready_for_connections()); + TORRENT_ASSERT(!m_have_piece.empty() || !t->ready_for_connections()); } // ----------------------------- @@ -1594,7 +1592,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << time_now_string() << " <== ALLOWED_FAST [ " << index << " ]\n"; @@ -1641,7 +1639,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); m_allowed_fast.erase(std::remove_if(m_allowed_fast.begin() , m_allowed_fast.end(), bind(&torrent::have_piece, t, _1)) @@ -1656,15 +1654,15 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); - assert(t->valid_metadata()); - assert(block.piece_index >= 0); - assert(block.piece_index < t->torrent_file().num_pieces()); - assert(block.block_index >= 0); - assert(block.block_index < t->torrent_file().piece_size(block.piece_index)); - assert(!t->picker().is_requested(block) || (t->picker().num_peers(block) > 0)); - assert(!t->have_piece(block.piece_index)); + TORRENT_ASSERT(t->valid_metadata()); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.piece_index < t->torrent_file().num_pieces()); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.block_index < t->torrent_file().piece_size(block.piece_index)); + TORRENT_ASSERT(!t->picker().is_requested(block) || (t->picker().num_peers(block) > 0)); + TORRENT_ASSERT(!t->have_piece(block.piece_index)); piece_picker::piece_state_t state; peer_speed_t speed = peer_speed(); @@ -1702,14 +1700,14 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); - assert(t->valid_metadata()); + TORRENT_ASSERT(t->valid_metadata()); - assert(block.piece_index >= 0); - assert(block.piece_index < t->torrent_file().num_pieces()); - assert(block.block_index >= 0); - assert(block.block_index < t->torrent_file().piece_size(block.piece_index)); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.piece_index < t->torrent_file().num_pieces()); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.block_index < t->torrent_file().piece_size(block.piece_index)); // if all the peers that requested this block has been // cancelled, then just ignore the cancel. @@ -1741,8 +1739,8 @@ namespace libtorrent int block_size = (std::min)((int)t->torrent_file().piece_size(block.piece_index)-block_offset, t->block_size()); - assert(block_size > 0); - assert(block_size <= t->block_size()); + TORRENT_ASSERT(block_size > 0); + TORRENT_ASSERT(block_size <= t->block_size()); peer_request r; r.piece = block.piece_index; @@ -1762,7 +1760,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!m_peer_info || !m_peer_info->optimistically_unchoked); + TORRENT_ASSERT(!m_peer_info || !m_peer_info->optimistically_unchoked); if (m_choked) return; write_choke(); @@ -1775,6 +1773,10 @@ namespace libtorrent m_last_choke = time_now(); #endif m_num_invalid_requests = 0; + + // reject the requests we have in the queue + std::for_each(m_requests.begin(), m_requests.end() + , bind(&peer_connection::write_reject_request, this, _1)); m_requests.clear(); } @@ -1825,7 +1827,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); if ((int)m_download_queue.size() >= m_desired_queue_size) return; @@ -1837,8 +1839,8 @@ namespace libtorrent int block_offset = block.block_index * t->block_size(); int block_size = (std::min)((int)t->torrent_file().piece_size( block.piece_index) - block_offset, t->block_size()); - assert(block_size > 0); - assert(block_size <= t->block_size()); + TORRENT_ASSERT(block_size > 0); + TORRENT_ASSERT(block_size <= t->block_size()); peer_request r; r.piece = block.piece_index; @@ -1883,14 +1885,14 @@ namespace libtorrent block_offset = block.block_index * t->block_size(); block_size = (std::min)((int)t->torrent_file().piece_size( block.piece_index) - block_offset, t->block_size()); - assert(block_size > 0); - assert(block_size <= t->block_size()); + TORRENT_ASSERT(block_size > 0); + TORRENT_ASSERT(block_size <= t->block_size()); r.length += block_size; } } - assert(verify_piece(r)); + TORRENT_ASSERT(verify_piece(r)); #ifndef TORRENT_DISABLE_EXTENSIONS bool handled = false; @@ -1982,7 +1984,7 @@ namespace libtorrent void peer_connection::set_upload_limit(int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (limit == -1) limit = (std::numeric_limits::max)(); if (limit < 10) limit = 10; m_upload_limit = limit; @@ -1991,7 +1993,7 @@ namespace libtorrent void peer_connection::set_download_limit(int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (limit == -1) limit = (std::numeric_limits::max)(); if (limit < 10) limit = 10; m_download_limit = limit; @@ -2003,7 +2005,7 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); float ratio = t->ratio(); @@ -2028,7 +2030,7 @@ namespace libtorrent void peer_connection::get_peer_info(peer_info& p) const { - assert(!associated_torrent().expired()); + TORRENT_ASSERT(!associated_torrent().expired()); p.down_speed = statistics().download_rate(); p.up_speed = statistics().upload_rate(); @@ -2111,10 +2113,10 @@ namespace libtorrent { INVARIANT_CHECK; - assert(packet_size > 0); - assert(int(m_recv_buffer.size()) >= size); - assert(int(m_recv_buffer.size()) >= m_recv_pos); - assert(m_recv_pos >= size); + TORRENT_ASSERT(packet_size > 0); + TORRENT_ASSERT(int(m_recv_buffer.size()) >= size); + TORRENT_ASSERT(int(m_recv_buffer.size()) >= m_recv_pos); + TORRENT_ASSERT(m_recv_pos >= size); if (size > 0) std::memmove(&m_recv_buffer[0], &m_recv_buffer[0] + size, m_recv_pos - size); @@ -2139,7 +2141,7 @@ namespace libtorrent ptime now(time_now()); boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); on_tick(); @@ -2168,7 +2170,7 @@ namespace libtorrent // torrent for it const int block_size = m_request_large_blocks ? t->torrent_file().piece_length() : t->block_size(); - assert(block_size > 0); + TORRENT_ASSERT(block_size > 0); m_desired_queue_size = static_cast(queue_time * statistics().download_rate() / block_size); @@ -2302,14 +2304,14 @@ namespace libtorrent && (send_buffer_size() + m_reading_bytes < buffer_size_watermark) && !m_choked) { - assert(t->valid_metadata()); + TORRENT_ASSERT(t->valid_metadata()); peer_request& r = m_requests.front(); - assert(r.piece >= 0); - assert(r.piece < (int)m_have_piece.size()); - assert(t->have_piece(r.piece)); - assert(r.start + r.length <= t->torrent_file().piece_size(r.piece)); - assert(r.length > 0 && r.start >= 0); + TORRENT_ASSERT(r.piece >= 0); + TORRENT_ASSERT(r.piece < (int)m_have_piece.size()); + TORRENT_ASSERT(t->have_piece(r.piece)); + TORRENT_ASSERT(r.start + r.length <= t->torrent_file().piece_size(r.piece)); + TORRENT_ASSERT(r.length > 0 && r.start >= 0); t->filesystem().async_read(r, bind(&peer_connection::on_disk_read_complete , self(), _1, _2, r)); @@ -2369,13 +2371,13 @@ namespace libtorrent m_bandwidth_limit[channel].assign(amount); if (channel == upload_channel) { - assert(m_writing); + TORRENT_ASSERT(m_writing); m_writing = false; setup_send(); } else if (channel == download_channel) { - assert(m_reading); + TORRENT_ASSERT(m_reading); m_reading = false; setup_receive(); } @@ -2415,14 +2417,14 @@ namespace libtorrent // in this case, we have data to send, but no // bandwidth. So, we simply request bandwidth // from the torrent - assert(t); + TORRENT_ASSERT(t); if (m_bandwidth_limit[upload_channel].max_assignable() > 0) { #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << "req bandwidth [ " << upload_channel << " ]\n"; #endif - assert(!m_writing); + TORRENT_ASSERT(!m_writing); // peers that we are not interested in are non-prioritized m_writing = true; t->request_bandwidth(upload_channel, self() @@ -2433,7 +2435,7 @@ namespace libtorrent if (!can_write()) return; - assert(!m_writing); + TORRENT_ASSERT(!m_writing); // send the actual buffer if (!m_send_buffer.empty()) @@ -2443,7 +2445,7 @@ namespace libtorrent if (!m_ignore_bandwidth_limits && amount_to_send > quota_left) amount_to_send = quota_left; - assert(amount_to_send > 0); + TORRENT_ASSERT(amount_to_send > 0); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << "async_write " << amount_to_send << " bytes\n"; @@ -2486,7 +2488,7 @@ namespace libtorrent if (!can_read()) return; - assert(m_packet_size > 0); + TORRENT_ASSERT(m_packet_size > 0); int max_receive = m_packet_size - m_recv_pos; int quota_left = m_bandwidth_limit[download_channel].quota_left(); if (!m_ignore_bandwidth_limits && max_receive > quota_left) @@ -2494,10 +2496,10 @@ namespace libtorrent if (max_receive == 0) return; - assert(m_recv_pos >= 0); - assert(m_packet_size > 0); + TORRENT_ASSERT(m_recv_pos >= 0); + TORRENT_ASSERT(m_packet_size > 0); - assert(can_read()); + TORRENT_ASSERT(can_read()); #ifdef TORRENT_VERBOSE_LOGGING (*m_logger) << "async_read " << max_receive << " bytes\n"; #endif @@ -2508,7 +2510,7 @@ namespace libtorrent void peer_connection::reset_recv_buffer(int packet_size) { - assert(packet_size > 0); + TORRENT_ASSERT(packet_size > 0); if (m_recv_pos > m_packet_size) { cut_receive_buffer(m_packet_size, packet_size); @@ -2538,7 +2540,7 @@ namespace libtorrent if (size <= 0) return; std::pair buffer = m_ses.allocate_buffer(size); - assert(buffer.second >= size); + TORRENT_ASSERT(buffer.second >= size); std::memcpy(buffer.first, buf, size); m_send_buffer.append_buffer(buffer.first, buffer.second, size , bind(&session_impl::free_buffer, boost::ref(m_ses), _1, buffer.second)); @@ -2557,7 +2559,7 @@ namespace libtorrent if (insert == 0) { std::pair buffer = m_ses.allocate_buffer(size); - assert(buffer.second >= size); + TORRENT_ASSERT(buffer.second >= size); m_send_buffer.append_buffer(buffer.first, buffer.second, size , bind(&session_impl::free_buffer, boost::ref(m_ses), _1, buffer.second)); buffer::interval ret(buffer.first, buffer.first + size); @@ -2601,7 +2603,7 @@ namespace libtorrent INVARIANT_CHECK; - assert(m_reading); + TORRENT_ASSERT(m_reading); m_reading = false; if (error) @@ -2624,16 +2626,16 @@ namespace libtorrent if (m_disconnecting) return; - assert(m_packet_size > 0); - assert(bytes_transferred > 0); + TORRENT_ASSERT(m_packet_size > 0); + TORRENT_ASSERT(bytes_transferred > 0); m_last_receive = time_now(); m_recv_pos += bytes_transferred; - assert(m_recv_pos <= int(m_recv_buffer.size())); + TORRENT_ASSERT(m_recv_pos <= int(m_recv_buffer.size())); on_receive(error, bytes_transferred); - assert(m_packet_size > 0); + TORRENT_ASSERT(m_packet_size > 0); if (m_peer_choked && m_recv_pos == 0 @@ -2686,7 +2688,7 @@ namespace libtorrent catch (...) { // all exceptions should derive from std::exception - assert(false); + TORRENT_ASSERT(false); session_impl::mutex_t::scoped_lock l(m_ses.m_mutex); m_ses.connection_failed(m_socket, remote(), "connection failed for unknown reason"); } @@ -2731,10 +2733,10 @@ namespace libtorrent m_connection_ticket = ticket; boost::shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); m_queued = false; - assert(m_connecting); + TORRENT_ASSERT(m_connecting); m_socket->open(t->get_interface().protocol()); // set the socket to non-blocking, so that we can @@ -2794,7 +2796,7 @@ namespace libtorrent catch (...) { // all exceptions should derive from std::exception - assert(false); + TORRENT_ASSERT(false); session_impl::mutex_t::scoped_lock l(m_ses.m_mutex); m_ses.connection_failed(m_socket, remote(), "connection failed for unkown reason"); } @@ -2811,7 +2813,7 @@ namespace libtorrent INVARIANT_CHECK; - assert(m_writing); + TORRENT_ASSERT(m_writing); m_send_buffer.pop_front(bytes_transferred); @@ -2833,8 +2835,8 @@ namespace libtorrent } if (m_disconnecting) return; - assert(!m_connecting); - assert(bytes_transferred > 0); + TORRENT_ASSERT(!m_connecting); + TORRENT_ASSERT(bytes_transferred > 0); m_last_sent = time_now(); @@ -2851,7 +2853,7 @@ namespace libtorrent catch (...) { // all exceptions should derive from std::exception - assert(false); + TORRENT_ASSERT(false); session_impl::mutex_t::scoped_lock l(m_ses.m_mutex); m_ses.connection_failed(m_socket, remote(), "connection failed for unknown reason"); } @@ -2862,11 +2864,11 @@ namespace libtorrent { if (m_peer_info) { - assert(m_peer_info->connection == this + TORRENT_ASSERT(m_peer_info->connection == this || m_peer_info->connection == 0); if (m_peer_info->optimistically_unchoked) - assert(!is_choked()); + TORRENT_ASSERT(!is_choked()); } boost::shared_ptr t = m_torrent.lock(); @@ -2877,17 +2879,17 @@ namespace libtorrent for (torrent_map::iterator i = m.begin(), end(m.end()); i != end; ++i) { torrent& t = *i->second; - assert(t.connection_for(m_remote) != this); + TORRENT_ASSERT(t.connection_for(m_remote) != this); } return; } - assert(t->connection_for(remote()) != 0 || m_in_constructor); + TORRENT_ASSERT(t->connection_for(remote()) != 0 || m_in_constructor); if (!m_in_constructor && t->connection_for(remote()) != this && !m_ses.settings().allow_multiple_connections_per_ip) { - assert(false); + TORRENT_ASSERT(false); } // expensive when using checked iterators @@ -2898,7 +2900,7 @@ namespace libtorrent , m_have_piece.end(), true); if (m_num_pieces != piece_count) { - assert(false); + TORRENT_ASSERT(false); } } */ @@ -2923,11 +2925,11 @@ namespace libtorrent std::find(m_download_queue.begin(), m_download_queue.end() , piece_block(i->index, j)) != m_download_queue.end()) { - assert(i->info[j].peer == m_remote); + TORRENT_ASSERT(i->info[j].peer == m_remote); } else { - assert(i->info[j].peer != m_remote || i->info[j].finished); + TORRENT_ASSERT(i->info[j].peer != m_remote || i->info[j].finished); } } } @@ -2997,7 +2999,7 @@ namespace libtorrent peer_connection::peer_speed_t peer_connection::peer_speed() { shared_ptr t = m_torrent.lock(); - assert(t); + TORRENT_ASSERT(t); int download_rate = int(statistics().download_payload_rate()); int torrent_download_rate = int(t->statistics().download_payload_rate()); diff --git a/libtorrent/src/piece_picker.cpp b/libtorrent/src/piece_picker.cpp index 398573d33..652426806 100755 --- a/libtorrent/src/piece_picker.cpp +++ b/libtorrent/src/piece_picker.cpp @@ -62,8 +62,8 @@ namespace libtorrent , m_num_have(0) , m_sequenced_download_threshold(100) { - assert(blocks_per_piece > 0); - assert(total_num_blocks >= 0); + TORRENT_ASSERT(blocks_per_piece > 0); + TORRENT_ASSERT(total_num_blocks >= 0); #ifndef NDEBUG m_files_checked_called = false; #endif @@ -77,7 +77,7 @@ namespace libtorrent m_blocks_in_last_piece = total_num_blocks % blocks_per_piece; if (m_blocks_in_last_piece == 0) m_blocks_in_last_piece = blocks_per_piece; - assert(m_blocks_in_last_piece <= m_blocks_per_piece); + TORRENT_ASSERT(m_blocks_in_last_piece <= m_blocks_per_piece); // allocate the piece_map to cover all pieces // and make them invalid (as if though we already had every piece) @@ -133,15 +133,15 @@ namespace libtorrent { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(index >= 0); - assert(index < int(m_piece_map.size())); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < int(m_piece_map.size())); if (m_piece_map[index].downloading) { std::vector::const_iterator piece = std::find_if( m_downloads.begin(), m_downloads.end() , bind(&downloading_piece::index, _1) == index); - assert(piece != m_downloads.end()); + TORRENT_ASSERT(piece != m_downloads.end()); st = *piece; st.info = 0; return; @@ -166,7 +166,7 @@ namespace libtorrent if (sequenced_download_threshold == m_sequenced_download_threshold) return; - assert(sequenced_download_threshold > 0); + TORRENT_ASSERT(sequenced_download_threshold > 0); if (sequenced_download_threshold <= 0) return; int old_limit = m_sequenced_download_threshold; @@ -201,7 +201,7 @@ namespace libtorrent , end(in.end()); i != end; ++i) { m_piece_map[*i].index = c++; - assert(m_piece_map[*i].priority(old_limit) == old_limit * 2); + TORRENT_ASSERT(m_piece_map[*i].priority(old_limit) == old_limit * 2); } } } @@ -214,7 +214,7 @@ namespace libtorrent , end(in.end()); i != end; ++i) { m_piece_map[*i].index = c++; - assert(m_piece_map[*i].priority( + TORRENT_ASSERT(m_piece_map[*i].priority( sequenced_download_threshold) == sequenced_download_threshold * 2); } } @@ -254,7 +254,7 @@ namespace libtorrent m_downloads.begin(), m_downloads.end() , bind(&downloading_piece::info, _1) == &m_block_info[(m_downloads.size() - 1) * m_blocks_per_piece]); - assert(other != m_downloads.end()); + TORRENT_ASSERT(other != m_downloads.end()); if (i != other) { @@ -269,22 +269,22 @@ namespace libtorrent void piece_picker::verify_pick(std::vector const& picked , std::vector const& bitfield) const { - assert(bitfield.size() == m_piece_map.size()); + TORRENT_ASSERT(bitfield.size() == m_piece_map.size()); for (std::vector::const_iterator i = picked.begin() , end(picked.end()); i != end; ++i) { - assert(i->piece_index >= 0); - assert(i->piece_index < int(bitfield.size())); - assert(bitfield[i->piece_index]); - assert(!m_piece_map[i->piece_index].have()); + TORRENT_ASSERT(i->piece_index >= 0); + TORRENT_ASSERT(i->piece_index < int(bitfield.size())); + TORRENT_ASSERT(bitfield[i->piece_index]); + TORRENT_ASSERT(!m_piece_map[i->piece_index].have()); } } void piece_picker::check_invariant(const torrent* t) const { - assert(sizeof(piece_pos) == 4); + TORRENT_ASSERT(sizeof(piece_pos) == 4); - assert(m_piece_info.empty() || m_piece_info[0].empty()); + TORRENT_ASSERT(m_piece_info.empty() || m_piece_info[0].empty()); if (!m_downloads.empty()) { @@ -293,15 +293,15 @@ namespace libtorrent { downloading_piece const& dp = *i; downloading_piece const& next = *(i + 1); - assert(dp.finished + dp.writing >= next.finished + next.writing); + TORRENT_ASSERT(dp.finished + dp.writing >= next.finished + next.writing); } } if (t != 0) - assert((int)m_piece_map.size() == t->torrent_file().num_pieces()); + TORRENT_ASSERT((int)m_piece_map.size() == t->torrent_file().num_pieces()); for (int i = m_sequenced_download_threshold * 2 + 1; i < int(m_piece_info.size()); ++i) - assert(m_piece_info[i].empty()); + TORRENT_ASSERT(m_piece_info[i].empty()); for (std::vector::const_iterator i = m_downloads.begin() , end(m_downloads.end()); i != end; ++i) @@ -328,10 +328,10 @@ namespace libtorrent ++num_writing; } } - assert(blocks_requested == (i->state != none)); - assert(num_requested == i->requested); - assert(num_writing == i->writing); - assert(num_finished == i->finished); + TORRENT_ASSERT(blocks_requested == (i->state != none)); + TORRENT_ASSERT(num_requested == i->requested); + TORRENT_ASSERT(num_writing == i->writing); + TORRENT_ASSERT(num_finished == i->finished); } @@ -362,7 +362,7 @@ namespace libtorrent if (peer->second->has_piece(index)) actual_peer_count++; } - assert((int)i->peer_count == actual_peer_count); + TORRENT_ASSERT((int)i->peer_count == actual_peer_count); /* int num_downloaders = 0; for (std::vector::const_iterator peer = t->begin(); @@ -377,11 +377,11 @@ namespace libtorrent if (i->downloading) { - assert(num_downloaders == 1); + TORRENT_ASSERT(num_downloaders == 1); } else { - assert(num_downloaders == 0); + TORRENT_ASSERT(num_downloaders == 0); } */ } @@ -389,8 +389,8 @@ namespace libtorrent if (i->index == piece_pos::we_have_index) { - assert(t == 0 || t->have_piece(index)); - assert(i->downloading == 0); + TORRENT_ASSERT(t == 0 || t->have_piece(index)); + TORRENT_ASSERT(i->downloading == 0); /* // make sure there's no entry // with this index. (there shouldn't @@ -399,7 +399,7 @@ namespace libtorrent { for (int j = 0; j < int(m_piece_info[i].size()); ++j) { - assert(m_piece_info[i][j] != index); + TORRENT_ASSERT(m_piece_info[i][j] != index); } } */ @@ -407,22 +407,22 @@ namespace libtorrent else { if (t != 0) - assert(!t->have_piece(index)); + TORRENT_ASSERT(!t->have_piece(index)); int prio = i->priority(m_sequenced_download_threshold); - assert(prio < int(m_piece_info.size())); + TORRENT_ASSERT(prio < int(m_piece_info.size())); if (prio > 0) { const std::vector& vec = m_piece_info[prio]; assert (i->index < vec.size()); - assert(vec[i->index] == index); + TORRENT_ASSERT(vec[i->index] == index); } /* for (int k = 0; k < int(m_piece_info.size()); ++k) { for (int j = 0; j < int(m_piece_info[k].size()); ++j) { - assert(int(m_piece_info[k][j]) != index + TORRENT_ASSERT(int(m_piece_info[k][j]) != index || (prio > 0 && prio == k && int(i->index) == j)); } } @@ -433,16 +433,16 @@ namespace libtorrent , has_index(index)); if (i->downloading == 1) { - assert(count == 1); + TORRENT_ASSERT(count == 1); } else { - assert(count == 0); + TORRENT_ASSERT(count == 0); } } - assert(num_have == m_num_have); - assert(num_filtered == m_num_filtered); - assert(num_have_filtered == m_num_have_filtered); + TORRENT_ASSERT(num_have == m_num_have); + TORRENT_ASSERT(num_filtered == m_num_filtered); + TORRENT_ASSERT(num_have_filtered == m_num_have_filtered); } #endif @@ -474,34 +474,34 @@ namespace libtorrent } else { - assert(peer_count > min_availability); + TORRENT_ASSERT(peer_count > min_availability); ++fraction_part; } } - assert(integer_part + fraction_part == num_pieces); + TORRENT_ASSERT(integer_part + fraction_part == num_pieces); return float(min_availability) + (fraction_part / num_pieces); } void piece_picker::add(int index) { - assert(index >= 0); - assert(index < int(m_piece_map.size())); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < int(m_piece_map.size())); piece_pos& p = m_piece_map[index]; - assert(!p.filtered()); - assert(!p.have()); + TORRENT_ASSERT(!p.filtered()); + TORRENT_ASSERT(!p.have()); int priority = p.priority(m_sequenced_download_threshold); - assert(priority > 0); + TORRENT_ASSERT(priority > 0); if (int(m_piece_info.size()) <= priority) m_piece_info.resize(priority + 1); - assert(int(m_piece_info.size()) > priority); + TORRENT_ASSERT(int(m_piece_info.size()) > priority); if (is_ordered(priority)) { // the piece should be inserted ordered, not randomly std::vector& v = m_piece_info[priority]; -// assert(is_sorted(v.begin(), v.end()/*, std::greater()*/)); +// TORRENT_ASSERT(is_sorted(v.begin(), v.end()/*, std::greater()*/)); std::vector::iterator i = std::lower_bound(v.begin(), v.end() , index/*, std::greater()*/); p.index = i - v.begin(); @@ -510,9 +510,9 @@ namespace libtorrent for (;i != v.end(); ++i) { ++m_piece_map[*i].index; - assert(v[m_piece_map[*i].index] == *i); + TORRENT_ASSERT(v[m_piece_map[*i].index] == *i); } -// assert(is_sorted(v.begin(), v.end()/*, std::greater()*/)); +// TORRENT_ASSERT(is_sorted(v.begin(), v.end()/*, std::greater()*/)); } else if (m_piece_info[priority].size() < 2) { @@ -542,17 +542,17 @@ namespace libtorrent // to place it at the correct position in the vectors. void piece_picker::move(int priority, int elem_index) { - assert(priority > 0); - assert(elem_index >= 0); - assert(m_files_checked_called); + TORRENT_ASSERT(priority > 0); + TORRENT_ASSERT(elem_index >= 0); + TORRENT_ASSERT(m_files_checked_called); - assert(int(m_piece_info.size()) > priority); - assert(int(m_piece_info[priority].size()) > elem_index); + TORRENT_ASSERT(int(m_piece_info.size()) > priority); + TORRENT_ASSERT(int(m_piece_info[priority].size()) > elem_index); int index = m_piece_info[priority][elem_index]; // update the piece_map piece_pos& p = m_piece_map[index]; - assert(int(p.index) == elem_index || p.have()); + TORRENT_ASSERT(int(p.index) == elem_index || p.have()); int new_priority = p.priority(m_sequenced_download_threshold); @@ -562,7 +562,7 @@ namespace libtorrent && new_priority > 0) { m_piece_info.resize(new_priority + 1); - assert(int(m_piece_info.size()) > new_priority); + TORRENT_ASSERT(int(m_piece_info.size()) > new_priority); } if (new_priority == 0) @@ -573,7 +573,7 @@ namespace libtorrent { // the piece should be inserted ordered, not randomly std::vector& v = m_piece_info[new_priority]; -// assert(is_sorted(v.begin(), v.end()/*, std::greater()*/)); +// TORRENT_ASSERT(is_sorted(v.begin(), v.end()/*, std::greater()*/)); std::vector::iterator i = std::lower_bound(v.begin(), v.end() , index/*, std::greater()*/); p.index = i - v.begin(); @@ -582,9 +582,9 @@ namespace libtorrent for (;i != v.end(); ++i) { ++m_piece_map[*i].index; - assert(v[m_piece_map[*i].index] == *i); + TORRENT_ASSERT(v[m_piece_map[*i].index] == *i); } -// assert(is_sorted(v.begin(), v.end()/*, std::greater()*/)); +// TORRENT_ASSERT(is_sorted(v.begin(), v.end()/*, std::greater()*/)); } else if (m_piece_info[new_priority].size() < 2) { @@ -608,8 +608,8 @@ namespace libtorrent p.index = dst_index; m_piece_info[new_priority][p.index] = index; } - assert(new_priority == 0 || p.index < m_piece_info[p.priority(m_sequenced_download_threshold)].size()); - assert(new_priority == 0 || m_piece_info[p.priority(m_sequenced_download_threshold)][p.index] == index); + TORRENT_ASSERT(new_priority == 0 || p.index < m_piece_info[p.priority(m_sequenced_download_threshold)].size()); + TORRENT_ASSERT(new_priority == 0 || m_piece_info[p.priority(m_sequenced_download_threshold)][p.index] == index); if (is_ordered(priority)) { @@ -620,7 +620,7 @@ namespace libtorrent i != v.end(); ++i) { --m_piece_map[*i].index; - assert(v[m_piece_map[*i].index] == *i); + TORRENT_ASSERT(v[m_piece_map[*i].index] == *i); } } else @@ -633,16 +633,16 @@ namespace libtorrent // update the entry we moved from the back m_piece_map[replace_index].index = elem_index; - assert(int(m_piece_info[priority].size()) > elem_index); + TORRENT_ASSERT(int(m_piece_info[priority].size()) > elem_index); // this may not necessarily be the case. If we've just updated the threshold and are updating // the piece map -// assert((int)m_piece_map[replace_index].priority(m_sequenced_download_threshold) == priority); - assert(int(m_piece_map[replace_index].index) == elem_index); - assert(m_piece_info[priority][elem_index] == replace_index); +// TORRENT_ASSERT((int)m_piece_map[replace_index].priority(m_sequenced_download_threshold) == priority); + TORRENT_ASSERT(int(m_piece_map[replace_index].index) == elem_index); + TORRENT_ASSERT(m_piece_info[priority][elem_index] == replace_index); } else { - assert(int(m_piece_info[priority].size()) == elem_index+1); + TORRENT_ASSERT(int(m_piece_info[priority].size()) == elem_index+1); } m_piece_info[priority].pop_back(); @@ -651,13 +651,13 @@ namespace libtorrent void piece_picker::sort_piece(std::vector::iterator dp) { - assert(m_piece_map[dp->index].downloading); + TORRENT_ASSERT(m_piece_map[dp->index].downloading); if (dp == m_downloads.begin()) return; int complete = dp->writing + dp->finished; for (std::vector::iterator i = dp, j(dp-1); i != m_downloads.begin(); --i, --j) { - assert(j >= m_downloads.begin()); + TORRENT_ASSERT(j >= m_downloads.begin()); if (j->finished + j->writing >= complete) return; using std::swap; swap(*j, *i); @@ -669,17 +669,17 @@ namespace libtorrent { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(index >= 0); - assert(index < (int)m_piece_map.size()); - assert(m_files_checked_called); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_map.size()); + TORRENT_ASSERT(m_files_checked_called); - assert(m_piece_map[index].downloading == 1); + TORRENT_ASSERT(m_piece_map[index].downloading == 1); std::vector::iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); erase_download_piece(i); piece_pos& p = m_piece_map[index]; @@ -702,7 +702,7 @@ namespace libtorrent void piece_picker::inc_refcount_all() { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(m_files_checked_called); + TORRENT_ASSERT(m_files_checked_called); // in general priority = availability * 2 // see piece_block::priority() @@ -716,16 +716,16 @@ namespace libtorrent { m_piece_info.push_back(std::vector()); } - assert(m_piece_info.rbegin()->empty()); - assert((m_piece_info.rbegin()+1)->empty()); + TORRENT_ASSERT(m_piece_info.rbegin()->empty()); + TORRENT_ASSERT((m_piece_info.rbegin()+1)->empty()); typedef std::vector > piece_info_t; for (piece_info_t::reverse_iterator i = m_piece_info.rbegin(), j(i+1) , k(j+1), end(m_piece_info.rend()); k != end; ++i, ++j, ++k) { k->swap(*i); } - assert(m_piece_info.begin()->empty()); - assert((m_piece_info.begin()+1)->empty()); + TORRENT_ASSERT(m_piece_info.begin()->empty()); + TORRENT_ASSERT((m_piece_info.begin()+1)->empty()); // if we have some priorities that are clamped to the // sequenced download, move that vector back down @@ -757,14 +757,14 @@ namespace libtorrent , end(m_piece_map.end()); i != end; ++i) { int prev_prio = i->priority(m_sequenced_download_threshold); - assert(prev_prio < int(m_piece_info.size())); + TORRENT_ASSERT(prev_prio < int(m_piece_info.size())); ++i->peer_count; // if the assumption that the priority would // increase by 2 when increasing the availability // by one isn't true for this particular piece, correct it. // that assumption is true for all pieces with priority 0 or 1 int new_prio = i->priority(m_sequenced_download_threshold); - assert(new_prio <= cap_index); + TORRENT_ASSERT(new_prio <= cap_index); if (prev_prio == 0 && new_prio > 0) { add(i - m_piece_map.begin()); @@ -772,17 +772,17 @@ namespace libtorrent } if (new_prio == 0) { - assert(prev_prio == 0); + TORRENT_ASSERT(prev_prio == 0); continue; } if (prev_prio == cap_index) { - assert(new_prio == cap_index); + TORRENT_ASSERT(new_prio == cap_index); continue; } if (new_prio == prev_prio + 2 && new_prio != cap_index) { - assert(new_prio != cap_index); + TORRENT_ASSERT(new_prio != cap_index); continue; } if (prev_prio + 2 >= cap_index) @@ -791,8 +791,8 @@ namespace libtorrent // passed the sequenced download threshold ++prev_prio; } - assert(prev_prio + 2 != cap_index); - assert(prev_prio + 2 != new_prio); + TORRENT_ASSERT(prev_prio + 2 != cap_index); + TORRENT_ASSERT(prev_prio + 2 != new_prio); move(prev_prio + 2, i->index); } } @@ -800,9 +800,9 @@ namespace libtorrent void piece_picker::dec_refcount_all() { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(m_files_checked_called); - assert(m_piece_info.size() >= 2); - assert(m_piece_info.front().empty()); + TORRENT_ASSERT(m_files_checked_called); + TORRENT_ASSERT(m_piece_info.size() >= 2); + TORRENT_ASSERT(m_piece_info.front().empty()); // swap all vectors two steps down if (m_piece_info.size() > 2) { @@ -824,14 +824,14 @@ namespace libtorrent // the last two to get the same layout in both cases m_piece_info[last_index].swap(m_piece_info[last_index-1]); } - assert(m_piece_info.back().empty()); + TORRENT_ASSERT(m_piece_info.back().empty()); int pushed_out_index = m_piece_info.size() - 2; int cap_index = m_sequenced_download_threshold * 2; - assert(m_piece_info[last_index].empty()); + TORRENT_ASSERT(m_piece_info[last_index].empty()); if (last_index >= cap_index) { - assert(pushed_out_index == cap_index - 1 + TORRENT_ASSERT(pushed_out_index == cap_index - 1 || m_piece_info[cap_index - 1].empty()); m_piece_info[cap_index].swap(m_piece_info[cap_index - 2]); if (cap_index == pushed_out_index) @@ -847,9 +847,9 @@ namespace libtorrent , end(m_piece_map.end()); i != end; ++i) { int prev_prio = i->priority(m_sequenced_download_threshold); - assert(prev_prio < int(m_piece_info.size())); - assert(pushed_out_index < int(m_piece_info.size())); - assert(i->peer_count > 0); + TORRENT_ASSERT(prev_prio < int(m_piece_info.size())); + TORRENT_ASSERT(pushed_out_index < int(m_piece_info.size())); + TORRENT_ASSERT(i->peer_count > 0); --i->peer_count; // if the assumption that the priority would // decrease by 2 when decreasing the availability @@ -857,7 +857,7 @@ namespace libtorrent // that assumption is true for all pieces with priority 0 or 1 if (prev_prio == 0) { - assert(i->priority(m_sequenced_download_threshold) == 0); + TORRENT_ASSERT(i->priority(m_sequenced_download_threshold) == 0); continue; } @@ -875,7 +875,7 @@ namespace libtorrent { // if this piece was pushed down to priority 0, it was // removed - assert(new_prio > 0); + TORRENT_ASSERT(new_prio > 0); add(i - m_piece_map.begin()); continue; } @@ -893,18 +893,18 @@ namespace libtorrent void piece_picker::inc_refcount(int i) { // TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(i >= 0); - assert(i < (int)m_piece_map.size()); - assert(m_files_checked_called); + TORRENT_ASSERT(i >= 0); + TORRENT_ASSERT(i < (int)m_piece_map.size()); + TORRENT_ASSERT(m_files_checked_called); piece_pos& p = m_piece_map[i]; int index = p.index; int prev_priority = p.priority(m_sequenced_download_threshold); - assert(prev_priority < int(m_piece_info.size())); + TORRENT_ASSERT(prev_priority < int(m_piece_info.size())); - assert(p.peer_count < piece_pos::max_peer_count); + TORRENT_ASSERT(p.peer_count < piece_pos::max_peer_count); p.peer_count++; - assert(p.peer_count != 0); + TORRENT_ASSERT(p.peer_count != 0); // if we have the piece or if it's filtered // we don't have to move any entries in the piece_info vector @@ -929,15 +929,15 @@ namespace libtorrent { // TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(m_files_checked_called); - assert(i >= 0); - assert(i < (int)m_piece_map.size()); + TORRENT_ASSERT(m_files_checked_called); + TORRENT_ASSERT(i >= 0); + TORRENT_ASSERT(i < (int)m_piece_map.size()); piece_pos& p = m_piece_map[i]; int prev_priority = p.priority(m_sequenced_download_threshold); - assert(prev_priority < int(m_piece_info.size())); + TORRENT_ASSERT(prev_priority < int(m_piece_info.size())); int index = p.index; - assert(p.peer_count > 0); + TORRENT_ASSERT(p.peer_count > 0); if (p.peer_count > 0) p.peer_count--; @@ -954,26 +954,26 @@ namespace libtorrent void piece_picker::we_have(int index) { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(index >= 0); - assert(index < (int)m_piece_map.size()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_map.size()); piece_pos& p = m_piece_map[index]; int info_index = p.index; int priority = p.priority(m_sequenced_download_threshold); - assert(priority < int(m_piece_info.size())); + TORRENT_ASSERT(priority < int(m_piece_info.size())); - assert(p.downloading == 1); - assert(!p.have()); + TORRENT_ASSERT(p.downloading == 1); + TORRENT_ASSERT(!p.have()); std::vector::iterator i = std::find_if(m_downloads.begin() , m_downloads.end() , has_index(index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); erase_download_piece(i); p.downloading = 0; - assert(std::find_if(m_downloads.begin(), m_downloads.end() + TORRENT_ASSERT(std::find_if(m_downloads.begin(), m_downloads.end() , has_index(index)) == m_downloads.end()); if (p.have()) return; @@ -985,7 +985,7 @@ namespace libtorrent ++m_num_have; p.set_have(); if (priority == 0) return; - assert(p.priority(m_sequenced_download_threshold) == 0); + TORRENT_ASSERT(p.priority(m_sequenced_download_threshold) == 0); move(priority, info_index); } @@ -993,10 +993,10 @@ namespace libtorrent bool piece_picker::set_piece_priority(int index, int new_piece_priority) { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(new_piece_priority >= 0); - assert(new_piece_priority <= 7); - assert(index >= 0); - assert(index < (int)m_piece_map.size()); + TORRENT_ASSERT(new_piece_priority >= 0); + TORRENT_ASSERT(new_piece_priority <= 7); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_map.size()); piece_pos& p = m_piece_map[index]; @@ -1004,7 +1004,7 @@ namespace libtorrent if (new_piece_priority == int(p.piece_priority)) return false; int prev_priority = p.priority(m_sequenced_download_threshold); - assert(prev_priority < int(m_piece_info.size())); + TORRENT_ASSERT(prev_priority < int(m_piece_info.size())); bool ret = false; if (new_piece_priority == piece_pos::filter_priority @@ -1023,12 +1023,12 @@ namespace libtorrent else --m_num_filtered; ret = true; } - assert(m_num_filtered >= 0); - assert(m_num_have_filtered >= 0); + TORRENT_ASSERT(m_num_filtered >= 0); + TORRENT_ASSERT(m_num_have_filtered >= 0); p.piece_priority = new_piece_priority; int new_priority = p.priority(m_sequenced_download_threshold); - assert(prev_priority < int(m_piece_info.size())); + TORRENT_ASSERT(prev_priority < int(m_piece_info.size())); if (new_priority == prev_priority) return false; @@ -1045,8 +1045,8 @@ namespace libtorrent int piece_picker::piece_priority(int index) const { - assert(index >= 0); - assert(index < (int)m_piece_map.size()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_map.size()); return m_piece_map[index].piece_priority; } @@ -1099,11 +1099,11 @@ namespace libtorrent , bool on_parole, std::vector const& suggested_pieces) const { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(num_blocks > 0); - assert(pieces.size() == m_piece_map.size()); - assert(m_files_checked_called); + TORRENT_ASSERT(num_blocks > 0); + TORRENT_ASSERT(pieces.size() == m_piece_map.size()); + TORRENT_ASSERT(m_files_checked_called); - assert(m_piece_info.begin() != m_piece_info.end()); + TORRENT_ASSERT(m_piece_info.begin() != m_piece_info.end()); // this will be filled with blocks that we should not request // unless we can't find num_blocks among the other ones. @@ -1151,8 +1151,8 @@ namespace libtorrent for (std::vector::const_iterator i = suggested_pieces.begin() , end(suggested_pieces.end()); i != end; ++i) { - assert(*i >= 0); - assert(*i < int(m_piece_map.size())); + TORRENT_ASSERT(*i >= 0); + TORRENT_ASSERT(*i < int(m_piece_map.size())); if (!can_pick(*i, pieces)) continue; if (m_piece_map[*i].priority(m_sequenced_download_threshold) == bucket_index) suggested_bucket.push_back(*i); @@ -1168,7 +1168,7 @@ namespace libtorrent num_blocks = add_blocks(*bucket, pieces , interesting_blocks, num_blocks , prefer_whole_pieces, peer, suggested_bucket); - assert(num_blocks >= 0); + TORRENT_ASSERT(num_blocks >= 0); } } else @@ -1201,8 +1201,8 @@ namespace libtorrent boost::tie(start, end) = expand_piece(piece, prefer_whole_pieces, pieces); for (int k = start; k < end; ++k) { - assert(m_piece_map[piece].downloading == false); - assert(m_piece_map[k].priority(m_sequenced_download_threshold) > 0); + TORRENT_ASSERT(m_piece_map[piece].downloading == false); + TORRENT_ASSERT(m_piece_map[k].priority(m_sequenced_download_threshold) > 0); int num_blocks_in_piece = blocks_in_piece(k); if (prefer_whole_pieces == 0 && num_blocks_in_piece > num_blocks) num_blocks_in_piece = num_blocks; @@ -1229,7 +1229,7 @@ namespace libtorrent bool piece_picker::can_pick(int piece, std::vector const& bitmask) const { - assert(piece >= 0 && piece < int(m_piece_map.size())); + TORRENT_ASSERT(piece >= 0 && piece < int(m_piece_map.size())); return bitmask[piece] && !m_piece_map[piece].have() && !m_piece_map[piece].downloading @@ -1282,8 +1282,8 @@ namespace libtorrent for (std::vector::const_iterator i = piece_list.begin(); i != piece_list.end(); ++i) { - assert(*i >= 0); - assert(*i < (int)m_piece_map.size()); + TORRENT_ASSERT(*i >= 0); + TORRENT_ASSERT(*i < (int)m_piece_map.size()); // if the peer doesn't have the piece // skip it @@ -1293,12 +1293,12 @@ namespace libtorrent if (std::find(ignore.begin(), ignore.end(), *i) != ignore.end()) continue; // skip the piece is the priority is 0 - assert(m_piece_map[*i].priority(m_sequenced_download_threshold) > 0); + TORRENT_ASSERT(m_piece_map[*i].priority(m_sequenced_download_threshold) > 0); int num_blocks_in_piece = blocks_in_piece(*i); - assert(m_piece_map[*i].downloading == 0); - assert(m_piece_map[*i].priority(m_sequenced_download_threshold) > 0); + TORRENT_ASSERT(m_piece_map[*i].downloading == 0); + TORRENT_ASSERT(m_piece_map[*i].priority(m_sequenced_download_threshold) > 0); // pick a new piece if (prefer_whole_pieces == 0) @@ -1315,7 +1315,7 @@ namespace libtorrent boost::tie(start, end) = expand_piece(*i, prefer_whole_pieces, pieces); for (int k = start; k < end; ++k) { - assert(m_piece_map[k].priority(m_sequenced_download_threshold) > 0); + TORRENT_ASSERT(m_piece_map[k].priority(m_sequenced_download_threshold) > 0); num_blocks_in_piece = blocks_in_piece(k); for (int j = 0; j < num_blocks_in_piece; ++j) { @@ -1379,7 +1379,7 @@ namespace libtorrent if (info.state != block_info::state_none) continue; - assert(i->info[j].state == block_info::state_none); + TORRENT_ASSERT(i->info[j].state == block_info::state_none); // if the piece is fast and the peer is slow, or vice versa, // add the block as a backup. @@ -1402,13 +1402,13 @@ namespace libtorrent // if we prefer whole pieces, continue picking from this // piece even though we have num_blocks if (prefer_whole_pieces > 0) continue; - assert(num_blocks >= 0); + TORRENT_ASSERT(num_blocks >= 0); if (num_blocks <= 0) break; } if (num_blocks <= 0) break; } - assert(num_blocks >= 0 || prefer_whole_pieces > 0); + TORRENT_ASSERT(num_blocks >= 0 || prefer_whole_pieces > 0); #ifndef NDEBUG verify_pick(interesting_blocks, pieces); @@ -1500,7 +1500,7 @@ namespace libtorrent std::cerr << std::endl; } - assert(false); + TORRENT_ASSERT(false); } } #endif @@ -1541,7 +1541,7 @@ namespace libtorrent && can_pick(start, have)) --start; ++start; - assert(start >= 0); + TORRENT_ASSERT(start >= 0); int end = piece + 1; int upper_limit = start + whole_pieces; if (upper_limit > int(m_piece_map.size())) upper_limit = int(m_piece_map.size()); @@ -1553,38 +1553,38 @@ namespace libtorrent bool piece_picker::is_piece_finished(int index) const { - assert(index < (int)m_piece_map.size()); - assert(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_map.size()); + TORRENT_ASSERT(index >= 0); if (m_piece_map[index].downloading == 0) { - assert(std::find_if(m_downloads.begin(), m_downloads.end() + TORRENT_ASSERT(std::find_if(m_downloads.begin(), m_downloads.end() , has_index(index)) == m_downloads.end()); return false; } std::vector::const_iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(index)); - assert(i != m_downloads.end()); - assert((int)i->finished <= m_blocks_per_piece); + TORRENT_ASSERT(i != m_downloads.end()); + TORRENT_ASSERT((int)i->finished <= m_blocks_per_piece); int max_blocks = blocks_in_piece(index); if ((int)i->finished < max_blocks) return false; #ifndef NDEBUG for (int k = 0; k < max_blocks; ++k) { - assert(i->info[k].state == block_info::state_finished); + TORRENT_ASSERT(i->info[k].state == block_info::state_finished); } #endif - assert((int)i->finished == max_blocks); + TORRENT_ASSERT((int)i->finished == max_blocks); return true; } bool piece_picker::is_requested(piece_block block) const { - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); if (m_piece_map[block.piece_index].downloading == 0) return false; std::vector::const_iterator i @@ -1593,36 +1593,36 @@ namespace libtorrent , m_downloads.end() , has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); return i->info[block.block_index].state == block_info::state_requested; } bool piece_picker::is_downloaded(piece_block block) const { - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); if (m_piece_map[block.piece_index].index == piece_pos::we_have_index) return true; if (m_piece_map[block.piece_index].downloading == 0) return false; std::vector::const_iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); return i->info[block.block_index].state == block_info::state_finished || i->info[block.block_index].state == block_info::state_writing; } bool piece_picker::is_finished(piece_block block) const { - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); if (m_piece_map[block.piece_index].index == piece_pos::we_have_index) return true; if (m_piece_map[block.piece_index].downloading == 0) return false; std::vector::const_iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); return i->info[block.block_index].state == block_info::state_finished; } @@ -1632,18 +1632,18 @@ namespace libtorrent { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); - assert(block.block_index < blocks_in_piece(block.piece_index)); - assert(!m_piece_map[block.piece_index].have()); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.block_index < blocks_in_piece(block.piece_index)); + TORRENT_ASSERT(!m_piece_map[block.piece_index].have()); piece_pos& p = m_piece_map[block.piece_index]; if (p.downloading == 0) { int prio = p.priority(m_sequenced_download_threshold); - assert(prio < int(m_piece_info.size())); - assert(prio > 0); + TORRENT_ASSERT(prio < int(m_piece_info.size())); + TORRENT_ASSERT(prio > 0); p.downloading = 1; move(prio, p.index); @@ -1660,12 +1660,12 @@ namespace libtorrent { std::vector::iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); block_info& info = i->info[block.block_index]; if (info.state == block_info::state_writing || info.state == block_info::state_finished) return false; - assert(info.state == block_info::state_none + TORRENT_ASSERT(info.state == block_info::state_none || (info.state == block_info::state_requested && (info.num_peers > 0))); info.peer = peer; @@ -1682,17 +1682,17 @@ namespace libtorrent int piece_picker::num_peers(piece_block block) const { - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); - assert(block.block_index < blocks_in_piece(block.piece_index)); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.block_index < blocks_in_piece(block.piece_index)); piece_pos const& p = m_piece_map[block.piece_index]; if (!p.downloading) return 0; std::vector::const_iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); block_info const& info = i->info[block.block_index]; return info.num_peers; @@ -1713,26 +1713,26 @@ namespace libtorrent { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); - assert(block.block_index < blocks_in_piece(block.piece_index)); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.block_index < blocks_in_piece(block.piece_index)); - assert(m_piece_map[block.piece_index].downloading); + TORRENT_ASSERT(m_piece_map[block.piece_index].downloading); std::vector::iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); block_info& info = i->info[block.block_index]; info.peer = peer; - assert(info.state == block_info::state_requested); + TORRENT_ASSERT(info.state == block_info::state_requested); if (info.state == block_info::state_requested) --i->requested; - assert(i->requested >= 0); - assert(info.state != block_info::state_writing); + TORRENT_ASSERT(i->requested >= 0); + TORRENT_ASSERT(info.state != block_info::state_writing); ++i->writing; info.state = block_info::state_writing; if (info.num_peers > 0) --info.num_peers; - assert(info.num_peers >= 0); + TORRENT_ASSERT(info.num_peers >= 0); if (i->requested == 0) { @@ -1745,10 +1745,10 @@ namespace libtorrent void piece_picker::mark_as_finished(piece_block block, void* peer) { - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); - assert(block.block_index < blocks_in_piece(block.piece_index)); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.block_index < blocks_in_piece(block.piece_index)); piece_pos& p = m_piece_map[block.piece_index]; @@ -1756,19 +1756,19 @@ namespace libtorrent { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(peer == 0); + TORRENT_ASSERT(peer == 0); int prio = p.priority(m_sequenced_download_threshold); - assert(prio < int(m_piece_info.size())); + TORRENT_ASSERT(prio < int(m_piece_info.size())); p.downloading = 1; if (prio > 0) move(prio, p.index); - else assert(p.priority(m_sequenced_download_threshold) == 0); + else TORRENT_ASSERT(p.priority(m_sequenced_download_threshold) == 0); downloading_piece& dp = add_download_piece(); dp.state = none; dp.index = block.piece_index; block_info& info = dp.info[block.block_index]; info.peer = peer; - assert(info.state == block_info::state_none); + TORRENT_ASSERT(info.state == block_info::state_none); if (info.state != block_info::state_finished) { ++dp.finished; @@ -1782,12 +1782,12 @@ namespace libtorrent std::vector::iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); block_info& info = i->info[block.block_index]; info.peer = peer; - assert(info.state == block_info::state_writing + TORRENT_ASSERT(info.state == block_info::state_writing || peer == 0); - assert(i->writing >= 0); + TORRENT_ASSERT(i->writing >= 0); ++i->finished; if (info.state == block_info::state_writing) { @@ -1804,10 +1804,10 @@ namespace libtorrent void piece_picker::get_downloaders(std::vector& d, int index) const { - assert(index >= 0 && index <= (int)m_piece_map.size()); + TORRENT_ASSERT(index >= 0 && index <= (int)m_piece_map.size()); std::vector::const_iterator i = std::find_if(m_downloads.begin(), m_downloads.end(), has_index(index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); d.clear(); for (int j = 0; j < blocks_in_piece(index); ++j) @@ -1825,7 +1825,7 @@ namespace libtorrent if (i == m_downloads.end()) return 0; - assert(block.block_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); if (i->info[block.block_index].state == block_info::state_none) return 0; @@ -1837,25 +1837,25 @@ namespace libtorrent { TORRENT_PIECE_PICKER_INVARIANT_CHECK; - assert(block.piece_index >= 0); - assert(block.block_index >= 0); - assert(block.piece_index < (int)m_piece_map.size()); - assert(block.block_index < blocks_in_piece(block.piece_index)); + TORRENT_ASSERT(block.piece_index >= 0); + TORRENT_ASSERT(block.block_index >= 0); + TORRENT_ASSERT(block.piece_index < (int)m_piece_map.size()); + TORRENT_ASSERT(block.block_index < blocks_in_piece(block.piece_index)); if (m_piece_map[block.piece_index].downloading == 0) { - assert(std::find_if(m_downloads.begin(), m_downloads.end() + TORRENT_ASSERT(std::find_if(m_downloads.begin(), m_downloads.end() , has_index(block.piece_index)) == m_downloads.end()); return; } std::vector::iterator i = std::find_if(m_downloads.begin() , m_downloads.end(), has_index(block.piece_index)); - assert(i != m_downloads.end()); + TORRENT_ASSERT(i != m_downloads.end()); block_info& info = i->info[block.block_index]; --info.num_peers; - assert(info.num_peers >= 0); + TORRENT_ASSERT(info.num_peers >= 0); if (info.num_peers > 0) return; if (i->info[block.block_index].state == block_info::state_finished @@ -1864,8 +1864,8 @@ namespace libtorrent return; } - assert(block.block_index < blocks_in_piece(block.piece_index)); - assert(i->info[block.block_index].state == block_info::state_requested); + TORRENT_ASSERT(block.block_index < blocks_in_piece(block.piece_index)); + TORRENT_ASSERT(i->info[block.block_index].state == block_info::state_requested); // clear this block as being downloaded info.state = block_info::state_none; @@ -1881,13 +1881,13 @@ namespace libtorrent erase_download_piece(i); piece_pos& p = m_piece_map[block.piece_index]; int prev_prio = p.priority(m_sequenced_download_threshold); - assert(prev_prio < int(m_piece_info.size())); + TORRENT_ASSERT(prev_prio < int(m_piece_info.size())); p.downloading = 0; int prio = p.priority(m_sequenced_download_threshold); if (prev_prio == 0 && prio > 0) add(block.piece_index); else if (prio > 0) move(prio, p.index); - assert(std::find_if(m_downloads.begin(), m_downloads.end() + TORRENT_ASSERT(std::find_if(m_downloads.begin(), m_downloads.end() , has_index(block.piece_index)) == m_downloads.end()); } else if (i->requested == 0) diff --git a/libtorrent/src/policy.cpp b/libtorrent/src/policy.cpp index 212e09f3c..5c69ea3bd 100755 --- a/libtorrent/src/policy.cpp +++ b/libtorrent/src/policy.cpp @@ -83,16 +83,16 @@ namespace // (and we should not consider it free). If the share diff is // negative, there's no free download to get from this peer. size_type diff = i->second->share_diff(); - assert(diff < (std::numeric_limits::max)()); + TORRENT_ASSERT(diff < (std::numeric_limits::max)()); if (i->second->is_peer_interested() || diff <= 0) continue; - assert(diff > 0); + TORRENT_ASSERT(diff > 0); i->second->add_free_upload(-diff); accumulator += diff; - assert(accumulator > 0); + TORRENT_ASSERT(accumulator > 0); } - assert(accumulator >= 0); + TORRENT_ASSERT(accumulator >= 0); return accumulator; } @@ -110,7 +110,7 @@ namespace for (torrent::peer_iterator i = start; i != end; ++i) { size_type d = i->second->share_diff(); - assert(d < (std::numeric_limits::max)()); + TORRENT_ASSERT(d < (std::numeric_limits::max)()); total_diff += d; if (!i->second->is_peer_interested() || i->second->share_diff() >= 0) continue; ++num_peers; @@ -191,8 +191,8 @@ namespace libtorrent { if (t.is_seed()) return; - assert(t.valid_metadata()); - assert(c.peer_info_struct() != 0 || !dynamic_cast(&c)); + TORRENT_ASSERT(t.valid_metadata()); + TORRENT_ASSERT(c.peer_info_struct() != 0 || !dynamic_cast(&c)); int num_requests = c.desired_queue_size() - (int)c.download_queue().size() - (int)c.request_queue().size(); @@ -200,7 +200,7 @@ namespace libtorrent #ifdef TORRENT_VERBOSE_LOGGING (*c.m_logger) << time_now_string() << " PIECE_PICKER [ req: " << num_requests << " ]\n"; #endif - assert(c.desired_queue_size() > 0); + TORRENT_ASSERT(c.desired_queue_size() > 0); // if our request queue is already full, we // don't have to make any new requests yet if (num_requests <= 0) return; @@ -224,7 +224,7 @@ namespace libtorrent // the number of blocks we want, but it will try to make the picked // blocks be from whole pieces, possibly by returning more blocks // than we requested. - assert(c.remote() == c.get_socket()->remote_endpoint()); + TORRENT_ASSERT(c.remote() == c.get_socket()->remote_endpoint()); piece_picker::piece_state_t state; peer_connection::peer_speed_t speed = c.peer_speed(); @@ -298,13 +298,13 @@ namespace libtorrent continue; } - assert(p.num_peers(*i) == 0); + TORRENT_ASSERT(p.num_peers(*i) == 0); // ok, we found a piece that's not being downloaded // by somebody else. request it from this peer // and return c.add_request(*i); - assert(p.num_peers(*i) == 1); - assert(p.is_requested(*i)); + TORRENT_ASSERT(p.num_peers(*i) == 1); + TORRENT_ASSERT(p.is_requested(*i)); num_requests--; } @@ -331,7 +331,7 @@ namespace libtorrent #ifndef NDEBUG piece_picker::downloading_piece st; p.piece_info(i->piece_index, st); - assert(st.requested + st.finished + st.writing == p.blocks_in_piece(i->piece_index)); + TORRENT_ASSERT(st.requested + st.finished + st.writing == p.blocks_in_piece(i->piece_index)); #endif c.add_request(*i); c.send_block_requests(); @@ -341,7 +341,7 @@ namespace libtorrent : m_torrent(t) , m_available_free_upload(0) // , m_last_optimistic_disconnect(min_time()) - { assert(t); } + { TORRENT_ASSERT(t); } // disconnects and removes all peers that are now filtered void policy::ip_filter_updated() @@ -367,7 +367,7 @@ namespace libtorrent ses.m_alerts.post_alert(peer_blocked_alert(i->second.ip.address() , "disconnected blocked peer")); } - assert(i->second.connection == 0 + TORRENT_ASSERT(i->second.connection == 0 || i->second.connection->peer_info_struct() == 0); } else @@ -427,7 +427,7 @@ namespace libtorrent worst_peer = i; continue; } - assert(unchoked_counter == 0); + TORRENT_ASSERT(unchoked_counter == 0); return worst_peer; } @@ -538,7 +538,7 @@ namespace libtorrent if (ses.m_port_filter.access(i->second.ip.port()) & port_filter::blocked) continue; - assert(i->second.connected <= now); + TORRENT_ASSERT(i->second.connected <= now); if (i->second.connected <= min_connect_time) { @@ -547,7 +547,7 @@ namespace libtorrent } } - assert(min_connect_time <= now); + TORRENT_ASSERT(min_connect_time <= now); return candidate; } @@ -556,7 +556,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_num_unchoked > 0); + TORRENT_ASSERT(m_num_unchoked > 0); // first choice candidate. // it is a candidate we owe nothing to and which has been unchoked // the longest. @@ -604,7 +604,7 @@ namespace libtorrent } } if (candidate != m_peers.end()) return candidate; - assert(second_candidate != m_peers.end()); + TORRENT_ASSERT(second_candidate != m_peers.end()); return second_candidate; } @@ -637,7 +637,7 @@ namespace libtorrent iterator p = find_seed_unchoke_candidate(); if (p != m_peers.end()) { - assert(p->connection->is_choked()); + TORRENT_ASSERT(p->connection->is_choked()); p->connection->send_unchoke(); p->last_optimistically_unchoked = time_now(); ++m_num_unchoked; @@ -652,7 +652,7 @@ namespace libtorrent iterator p = find_seed_choke_candidate(); if (p != m_peers.end()) { - assert(!p->connection->is_choked()); + TORRENT_ASSERT(!p->connection->is_choked()); p->connection->send_choke(); --m_num_unchoked; } @@ -730,7 +730,7 @@ namespace libtorrent { bool ret = disconnect_one_peer(); (void)ret; - assert(ret); + TORRENT_ASSERT(ret); --num_connected_peers; } } @@ -777,10 +777,10 @@ namespace libtorrent { iterator p = find_seed_choke_candidate(); --m_num_unchoked; - assert(p != m_peers.end()); + TORRENT_ASSERT(p != m_peers.end()); if (p == m_peers.end()) break; - assert(!p->connection->is_choked()); + TORRENT_ASSERT(!p->connection->is_choked()); p->connection->send_choke(); } while (m_num_unchoked > m_torrent->m_uploads_quota.given); } @@ -790,11 +790,11 @@ namespace libtorrent // unchoked peer with one of the choked // TODO: This rotation should happen // far less frequent than this! - assert(m_num_unchoked <= m_torrent->num_peers()); + TORRENT_ASSERT(m_num_unchoked <= m_torrent->num_peers()); iterator p = find_seed_unchoke_candidate(); if (p != m_peers.end()) { - assert(p->connection->is_choked()); + TORRENT_ASSERT(p->connection->is_choked()); seed_choke_one_peer(); p->connection->send_unchoke(); ++m_num_unchoked; @@ -841,7 +841,7 @@ namespace libtorrent if (m_torrent->m_uploads_quota.given < m_torrent->num_peers()) { - assert(m_torrent->m_uploads_quota.given >= 0); + TORRENT_ASSERT(m_torrent->m_uploads_quota.given >= 0); // make sure we don't have too many // unchoked peers @@ -851,8 +851,8 @@ namespace libtorrent { iterator p = find_choke_candidate(); if (p == m_peers.end()) break; - assert(p != m_peers.end()); - assert(!p->connection->is_choked()); + TORRENT_ASSERT(p != m_peers.end()); + TORRENT_ASSERT(!p->connection->is_choked()); p->connection->send_choke(); --m_num_unchoked; } while (m_num_unchoked > m_torrent->m_uploads_quota.given); @@ -864,11 +864,11 @@ namespace libtorrent { // optimistic unchoke. trade the 'worst' // unchoked peer with one of the choked - assert(m_num_unchoked <= m_torrent->num_peers()); + TORRENT_ASSERT(m_num_unchoked <= m_torrent->num_peers()); iterator p = find_unchoke_candidate(); if (p != m_peers.end()) { - assert(p->connection->is_choked()); + TORRENT_ASSERT(p->connection->is_choked()); choke_one_peer(); p->connection->send_unchoke(); ++m_num_unchoked; @@ -902,7 +902,7 @@ namespace libtorrent void policy::new_connection(peer_connection& c) { - assert(!c.is_local()); + TORRENT_ASSERT(!c.is_local()); INVARIANT_CHECK; @@ -912,7 +912,7 @@ namespace libtorrent // TODO: only allow _one_ connection to use this // override at a time - assert(c.remote() == c.get_socket()->remote_endpoint()); + TORRENT_ASSERT(c.remote() == c.get_socket()->remote_endpoint()); if (m_torrent->num_peers() >= m_torrent->max_connections() && m_torrent->session().num_connections() >= m_torrent->session().max_connections() @@ -949,7 +949,7 @@ namespace libtorrent if (i->second.connection != 0) { - assert(i->second.connection != &c); + TORRENT_ASSERT(i->second.connection != &c); // the new connection is a local (outgoing) connection // or the current one is already connected if (!i->second.connection->is_connecting() || c.is_local()) @@ -971,21 +971,21 @@ namespace libtorrent { // we don't have any info about this peer. // add a new entry - assert(c.remote() == c.get_socket()->remote_endpoint()); + TORRENT_ASSERT(c.remote() == c.get_socket()->remote_endpoint()); peer p(c.remote(), peer::not_connectable, 0); i = m_peers.insert(std::make_pair(c.remote().address(), p)); } - assert(m_torrent->connection_for(c.remote()) == &c); + TORRENT_ASSERT(m_torrent->connection_for(c.remote()) == &c); c.set_peer_info(&i->second); - assert(i->second.connection == 0); + TORRENT_ASSERT(i->second.connection == 0); c.add_stat(i->second.prev_amount_download, i->second.prev_amount_upload); i->second.prev_amount_download = 0; i->second.prev_amount_upload = 0; i->second.connection = &c; - assert(i->second.connection); + TORRENT_ASSERT(i->second.connection); i->second.connected = time_now(); // m_last_optimistic_disconnect = time_now(); } @@ -1094,7 +1094,7 @@ namespace libtorrent + boost::lexical_cast(remote.port()) + " " + boost::lexical_cast(i->second.connection->pid())); - assert(i->second.connection->associated_torrent().lock().get() == m_torrent); + TORRENT_ASSERT(i->second.connection->associated_torrent().lock().get() == m_torrent); } #endif } @@ -1122,7 +1122,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(index >= 0 && index < m_torrent->torrent_file().num_pieces()); + TORRENT_ASSERT(index >= 0 && index < m_torrent->torrent_file().num_pieces()); if (successfully_verified) { @@ -1157,7 +1157,7 @@ namespace libtorrent { // INVARIANT_CHECK; - assert(std::find_if(m_peers.begin(), m_peers.end() + TORRENT_ASSERT(std::find_if(m_peers.begin(), m_peers.end() , boost::bind(std::equal_to(), bind(&peer::connection , bind(&iterator::value_type::second, _1)), &c)) != m_peers.end()); @@ -1213,7 +1213,7 @@ namespace libtorrent if (m_torrent->ratio() != 0.f) { - assert(c.share_diff() < (std::numeric_limits::max)()); + TORRENT_ASSERT(c.share_diff() < (std::numeric_limits::max)()); size_type diff = c.share_diff(); if (diff > 0 && c.is_seed()) { @@ -1242,10 +1242,10 @@ namespace libtorrent iterator p = find_unchoke_candidate(); if (p == m_peers.end()) return false; - assert(p->connection); - assert(!p->connection->is_disconnecting()); + TORRENT_ASSERT(p->connection); + TORRENT_ASSERT(!p->connection->is_disconnecting()); - assert(p->connection->is_choked()); + TORRENT_ASSERT(p->connection->is_choked()); p->connection->send_unchoke(); p->last_optimistically_unchoked = time_now(); ++m_num_unchoked; @@ -1258,9 +1258,9 @@ namespace libtorrent iterator p = find_choke_candidate(); if (p == m_peers.end()) return; - assert(p->connection); - assert(!p->connection->is_disconnecting()); - assert(!p->connection->is_choked()); + TORRENT_ASSERT(p->connection); + TORRENT_ASSERT(!p->connection->is_disconnecting()); + TORRENT_ASSERT(!p->connection->is_choked()); p->connection->send_choke(); --m_num_unchoked; } @@ -1269,20 +1269,20 @@ namespace libtorrent { // INVARIANT_CHECK; - assert(m_torrent->want_more_peers()); + TORRENT_ASSERT(m_torrent->want_more_peers()); iterator p = find_connect_candidate(); if (p == m_peers.end()) return false; - assert(!p->second.banned); - assert(!p->second.connection); - assert(p->second.type == peer::connectable); + TORRENT_ASSERT(!p->second.banned); + TORRENT_ASSERT(!p->second.connection); + TORRENT_ASSERT(p->second.type == peer::connectable); try { p->second.connected = time_now(); p->second.connection = m_torrent->connect_to_peer(&p->second); - assert(p->second.connection == m_torrent->connection_for(p->second.ip)); + TORRENT_ASSERT(p->second.connection == m_torrent->connection_for(p->second.ip)); if (p->second.connection == 0) { ++p->second.failcount; @@ -1326,7 +1326,7 @@ namespace libtorrent peer* p = c.peer_info_struct(); - assert((std::find_if( + TORRENT_ASSERT((std::find_if( m_peers.begin() , m_peers.end() , match_peer_connection(c)) @@ -1335,12 +1335,16 @@ namespace libtorrent // if we couldn't find the connection in our list, just ignore it. if (p == 0) return; - assert(p->connection == &c); + TORRENT_ASSERT(p->connection == &c); p->connection = 0; p->optimistically_unchoked = false; - p->connected = time_now(); + // if fast reconnect is true, we won't + // update the timestamp, and it will remain + // the time when we initiated the connection. + if (!c.fast_reconnect()) + p->connected = time_now(); if (c.failed()) { @@ -1353,8 +1357,8 @@ namespace libtorrent // because it isn't necessary. if (m_torrent->ratio() != 0.f) { - assert(c.associated_torrent().lock().get() == m_torrent); - assert(c.share_diff() < (std::numeric_limits::max)()); + TORRENT_ASSERT(c.associated_torrent().lock().get() == m_torrent); + TORRENT_ASSERT(c.share_diff() < (std::numeric_limits::max)()); m_available_free_upload += c.share_diff(); } p->prev_amount_download += c.statistics().total_payload_download(); @@ -1378,8 +1382,8 @@ namespace libtorrent // too expensive // INVARIANT_CHECK; - assert(c); - try { assert(c->remote() == c->get_socket()->remote_endpoint()); } + TORRENT_ASSERT(c); + try { TORRENT_ASSERT(c->remote() == c->get_socket()->remote_endpoint()); } catch (std::exception&) {} return std::find_if( @@ -1403,11 +1407,11 @@ namespace libtorrent peer const& p = i->second; if (!m_torrent->settings().allow_multiple_connections_per_ip) { - assert(m_peers.count(p.ip.address()) == 1); + TORRENT_ASSERT(m_peers.count(p.ip.address()) == 1); } else { - assert(unique_test.count(p.ip) == 0); + TORRENT_ASSERT(unique_test.count(p.ip) == 0); unique_test.insert(p.ip); } ++total_connections; @@ -1419,16 +1423,16 @@ namespace libtorrent { std::vector conns; m_torrent->connection_for(p.ip.address(), conns); - assert(std::find_if(conns.begin(), conns.end() + TORRENT_ASSERT(std::find_if(conns.begin(), conns.end() , boost::bind(std::equal_to(), _1, p.connection)) != conns.end()); } if (p.optimistically_unchoked) { - assert(p.connection); - assert(!p.connection->is_choked()); + TORRENT_ASSERT(p.connection); + TORRENT_ASSERT(!p.connection->is_choked()); } - assert(p.connection->peer_info_struct() == 0 + TORRENT_ASSERT(p.connection->peer_info_struct() == 0 || p.connection->peer_info_struct() == &p); ++nonempty_connections; if (!p.connection->is_disconnecting()) @@ -1466,7 +1470,7 @@ namespace libtorrent { policy::peer* p = static_cast(*i); if (p == 0) continue; - assert(std::find_if(m_peers.begin(), m_peers.end() + TORRENT_ASSERT(std::find_if(m_peers.begin(), m_peers.end() , match_peer_connection(*p->connection)) != m_peers.end()); } } @@ -1480,7 +1484,7 @@ namespace libtorrent // be added to the torrent and then to the policy. // that's why the two second cases are in there. /* - assert(connected_peers == num_torrent_peers + TORRENT_ASSERT(connected_peers == num_torrent_peers || (connected_peers == num_torrent_peers + 1 && connected_peers > 0) || (connected_peers + 1 == num_torrent_peers @@ -1509,14 +1513,14 @@ namespace libtorrent , source(src) , connection(0) { - assert(connected < time_now()); + TORRENT_ASSERT(connected < time_now()); } size_type policy::peer::total_download() const { if (connection != 0) { - assert(prev_amount_download == 0); + TORRENT_ASSERT(prev_amount_download == 0); return connection->statistics().total_payload_download(); } else @@ -1529,7 +1533,7 @@ namespace libtorrent { if (connection != 0) { - assert(prev_amount_upload == 0); + TORRENT_ASSERT(prev_amount_upload == 0); return connection->statistics().total_payload_upload(); } else diff --git a/libtorrent/src/session.cpp b/libtorrent/src/session.cpp index 478c6fe93..68cbd619f 100755 --- a/libtorrent/src/session.cpp +++ b/libtorrent/src/session.cpp @@ -110,14 +110,14 @@ namespace libtorrent : m_impl(new session_impl(listen_port_range, id, listen_interface)) { // turn off the filename checking in boost.filesystem - assert(listen_port_range.first > 0); - assert(listen_port_range.first < listen_port_range.second); + TORRENT_ASSERT(listen_port_range.first > 0); + TORRENT_ASSERT(listen_port_range.first < listen_port_range.second); #ifndef NDEBUG // this test was added after it came to my attention // that devstudios managed c++ failed to generate // correct code for boost.function boost::function0 test = boost::ref(*m_impl); - assert(!test.empty()); + TORRENT_ASSERT(!test.empty()); #endif } @@ -126,13 +126,13 @@ namespace libtorrent { #ifndef NDEBUG boost::function0 test = boost::ref(*m_impl); - assert(!test.empty()); + TORRENT_ASSERT(!test.empty()); #endif } session::~session() { - assert(m_impl); + TORRENT_ASSERT(m_impl); // if there is at least one destruction-proxy // abort the session and let the destructor // of the proxy to syncronize @@ -190,7 +190,7 @@ namespace libtorrent , bool paused , storage_constructor_type sc) { - assert(!ti.m_half_metadata); + TORRENT_ASSERT(!ti.m_half_metadata); boost::intrusive_ptr tip(new torrent_info(ti)); return m_impl->add_torrent(tip, save_path, resume_data , compact_mode, sc, paused, 0); @@ -205,7 +205,7 @@ namespace libtorrent , storage_constructor_type sc , void* userdata) { - assert(!ti->m_half_metadata); + TORRENT_ASSERT(!ti->m_half_metadata); return m_impl->add_torrent(ti, save_path, resume_data , compact_mode, sc, paused, userdata); } diff --git a/libtorrent/src/session_impl.cpp b/libtorrent/src/session_impl.cpp index 4001b35d7..6f42438b0 100755 --- a/libtorrent/src/session_impl.cpp +++ b/libtorrent/src/session_impl.cpp @@ -223,8 +223,8 @@ namespace detail { INVARIANT_CHECK; - assert(!m_torrents.empty()); - assert(m_torrents.front() == t); + TORRENT_ASSERT(!m_torrents.empty()); + TORRENT_ASSERT(m_torrents.front() == t); t->torrent_ptr->files_checked(t->unfinished_pieces); m_torrents.pop_front(); @@ -275,7 +275,7 @@ namespace detail // move the torrent from // m_torrents to m_processing - assert(m_torrents.front() == t); + TORRENT_ASSERT(m_torrents.front() == t); m_torrents.pop_front(); m_processing.push_back(t); @@ -303,7 +303,7 @@ namespace detail } t->torrent_ptr->abort(); - assert(!m_torrents.empty()); + TORRENT_ASSERT(!m_torrents.empty()); m_torrents.pop_front(); } catch(...) @@ -312,16 +312,16 @@ namespace detail std::cerr << "error while checking resume data\n"; #endif mutex::scoped_lock l(m_mutex); - assert(!m_torrents.empty()); + TORRENT_ASSERT(!m_torrents.empty()); m_torrents.pop_front(); - assert(false); + TORRENT_ASSERT(false); } if (!processing) continue; try { - assert(processing); + TORRENT_ASSERT(processing); float finished = false; float progress = 0.f; @@ -335,8 +335,8 @@ namespace detail processing->progress = progress; if (processing->abort) { - assert(!m_processing.empty()); - assert(m_processing.front() == processing); + TORRENT_ASSERT(!m_processing.empty()); + TORRENT_ASSERT(m_processing.front() == processing); processing->torrent_ptr->abort(); @@ -358,8 +358,8 @@ namespace detail INVARIANT_CHECK; - assert(!m_processing.empty()); - assert(m_processing.front() == processing); + TORRENT_ASSERT(!m_processing.empty()); + TORRENT_ASSERT(m_processing.front() == processing); // TODO: factor out the adding of torrents to the session // and to the checker thread to avoid duplicating the @@ -426,7 +426,7 @@ namespace detail processing->torrent_ptr->get_handle() , e.what())); } - assert(!m_processing.empty()); + TORRENT_ASSERT(!m_processing.empty()); processing->torrent_ptr->abort(); @@ -444,7 +444,7 @@ namespace detail std::cerr << "error while checking files\n"; #endif mutex::scoped_lock l(m_mutex); - assert(!m_processing.empty()); + TORRENT_ASSERT(!m_processing.empty()); processing.reset(); m_processing.pop_front(); @@ -454,7 +454,7 @@ namespace detail processing->processing = true; } - assert(false); + TORRENT_ASSERT(false); } } } @@ -484,7 +484,7 @@ namespace detail { if ((*i)->info_hash == info_hash) { - assert((*i)->processing == false); + TORRENT_ASSERT((*i)->processing == false); m_torrents.erase(i); return; } @@ -494,13 +494,13 @@ namespace detail { if ((*i)->info_hash == info_hash) { - assert((*i)->processing == false); + TORRENT_ASSERT((*i)->processing == false); m_processing.erase(i); return; } } - assert(false); + TORRENT_ASSERT(false); } #ifndef NDEBUG @@ -509,14 +509,14 @@ namespace detail for (std::deque >::const_iterator i = m_torrents.begin(); i != m_torrents.end(); ++i) { - assert(*i); - assert((*i)->torrent_ptr); + TORRENT_ASSERT(*i); + TORRENT_ASSERT((*i)->torrent_ptr); } for (std::deque >::const_iterator i = m_processing.begin(); i != m_processing.end(); ++i) { - assert(*i); - assert((*i)->torrent_ptr); + TORRENT_ASSERT(*i); + TORRENT_ASSERT((*i)->torrent_ptr); } } #endif @@ -593,7 +593,7 @@ namespace detail m_key = rand() + (rand() << 15) + (rand() << 30); std::string print = cl_fprint.to_string(); - assert(print.length() <= 20); + TORRENT_ASSERT(print.length() <= 20); // the client's fingerprint std::copy( @@ -638,7 +638,7 @@ namespace detail void session_impl::abort() { mutex_t::scoped_lock l(m_mutex); - assert(!m_abort); + TORRENT_ASSERT(!m_abort); // abort the main thread m_abort = true; m_io_service.stop(); @@ -676,11 +676,11 @@ namespace detail INVARIANT_CHECK; - assert(s.connection_speed > 0); - assert(s.file_pool_size > 0); + TORRENT_ASSERT(s.connection_speed > 0); + TORRENT_ASSERT(s.file_pool_size > 0); // less than 5 seconds unchoke interval is insane - assert(s.unchoke_interval >= 5); + TORRENT_ASSERT(s.unchoke_interval >= 5); m_settings = s; m_files.resize(m_settings.file_pool_size); // replace all occurances of '\n' with ' '. @@ -706,7 +706,7 @@ namespace detail while (ec && retries > 0) { ec = asio::error_code(); - assert(!ec); + TORRENT_ASSERT(!ec); --retries; ep.port(ep.port() + 1); s.sock->bind(ep, ec); @@ -992,7 +992,7 @@ namespace detail #ifndef NDEBUG catch (...) { - assert(false); + TORRENT_ASSERT(false); }; #endif @@ -1003,7 +1003,7 @@ namespace detail // too expensive // INVARIANT_CHECK; - assert(p->is_disconnecting()); + TORRENT_ASSERT(p->is_disconnecting()); connection_map::iterator i = m_connections.find(p->get_socket()); if (i != m_connections.end()) { @@ -1124,7 +1124,7 @@ namespace detail ++i; if (i == m_torrents.end()) { - assert(m_next_connect_torrent == num_torrents); + TORRENT_ASSERT(m_next_connect_torrent == num_torrents); i = m_torrents.begin(); m_next_connect_torrent = 0; } @@ -1183,7 +1183,7 @@ namespace detail i != m_torrents.end();) { torrent& t = *i->second; - assert(!t.is_aborted()); + TORRENT_ASSERT(!t.is_aborted()); if (t.should_request()) { tracker_request req = t.generate_tracker_request(); @@ -1269,9 +1269,9 @@ namespace detail , end(peers.end()); i != end; ++i) { peer_connection* p = *i; - assert(p); + TORRENT_ASSERT(p); torrent* t = p->associated_torrent().lock().get(); - assert(t); + TORRENT_ASSERT(t); if (unchoke_set_size > 0) { if (p->is_choked()) @@ -1283,7 +1283,7 @@ namespace detail --unchoke_set_size; ++m_num_unchoked; - assert(p->peer_info_struct()); + TORRENT_ASSERT(p->peer_info_struct()); if (p->peer_info_struct()->optimistically_unchoked) { // force a new optimistic unchoke @@ -1293,7 +1293,7 @@ namespace detail } else { - assert(p->peer_info_struct()); + TORRENT_ASSERT(p->peer_info_struct()); if (!p->is_choked() && !p->peer_info_struct()->optimistically_unchoked) t->choke_peer(*p); if (!p->is_choked()) @@ -1317,7 +1317,7 @@ namespace detail , end(m_connections.end()); i != end; ++i) { peer_connection* p = i->second.get(); - assert(p); + TORRENT_ASSERT(p); policy::peer* pi = p->peer_info_struct(); if (!pi) continue; torrent* t = p->associated_torrent().lock().get(); @@ -1325,8 +1325,8 @@ namespace detail if (pi->optimistically_unchoked) { - assert(!p->is_choked()); - assert(current_optimistic_unchoke == m_connections.end()); + TORRENT_ASSERT(!p->is_choked()); + TORRENT_ASSERT(current_optimistic_unchoke == m_connections.end()); current_optimistic_unchoke = i; } @@ -1348,7 +1348,7 @@ namespace detail if (current_optimistic_unchoke != m_connections.end()) { torrent* t = current_optimistic_unchoke->second->associated_torrent().lock().get(); - assert(t); + TORRENT_ASSERT(t); current_optimistic_unchoke->second->peer_info_struct()->optimistically_unchoked = false; t->choke_peer(*current_optimistic_unchoke->second); } @@ -1358,9 +1358,9 @@ namespace detail } torrent* t = optimistic_unchoke_candidate->second->associated_torrent().lock().get(); - assert(t); + TORRENT_ASSERT(t); bool ret = t->unchoke_peer(*optimistic_unchoke_candidate->second); - assert(ret); + TORRENT_ASSERT(ret); optimistic_unchoke_candidate->second->peer_info_struct()->optimistically_unchoked = true; } } @@ -1382,7 +1382,7 @@ namespace detail , bind(&torrent::num_peers, bind(&torrent_map::value_type::second, _1)) < bind(&torrent::num_peers, bind(&torrent_map::value_type::second, _2))); - assert(i != m_torrents.end()); + TORRENT_ASSERT(i != m_torrents.end()); i->second->get_policy().disconnect_one_peer(); } } @@ -1391,7 +1391,7 @@ namespace detail { #ifndef NDEBUG std::cerr << exc.what() << std::endl; - assert(false); + TORRENT_ASSERT(false); #endif }; // msvc 7.1 seems to require this @@ -1411,7 +1411,7 @@ namespace detail try { m_io_service.run(); - assert(m_abort == true); + TORRENT_ASSERT(m_abort == true); } catch (std::exception& e) { @@ -1419,7 +1419,7 @@ namespace detail std::cerr << e.what() << "\n"; std::string err = e.what(); #endif - assert(false); + TORRENT_ASSERT(false); } } while (!m_abort); @@ -1455,7 +1455,7 @@ namespace detail && !i->second->trackers().empty()) { tracker_request req = i->second->generate_tracker_request(); - assert(!m_listen_sockets.empty()); + TORRENT_ASSERT(!m_listen_sockets.empty()); req.listen_port = 0; if (!m_listen_sockets.empty()) req.listen_port = m_listen_sockets.front().external_port; @@ -1501,7 +1501,7 @@ namespace detail #endif l.lock(); - assert(m_abort); + TORRENT_ASSERT(m_abort); m_abort = true; #if defined(TORRENT_VERBOSE_LOGGING) || defined(TORRENT_LOGGING) @@ -1514,7 +1514,7 @@ namespace detail for (torrent_map::iterator i = m_torrents.begin(); i != m_torrents.end(); ++i) { - assert(i->second->num_peers() == 0); + TORRENT_ASSERT(i->second->num_peers() == 0); } #endif @@ -1523,8 +1523,8 @@ namespace detail #endif m_torrents.clear(); - assert(m_torrents.empty()); - assert(m_connections.empty()); + TORRENT_ASSERT(m_torrents.empty()); + TORRENT_ASSERT(m_connections.empty()); } @@ -1539,7 +1539,7 @@ namespace detail = m_torrents.begin(); j != m_torrents.end(); ++j) { torrent* p = boost::get_pointer(j->second); - assert(p); + TORRENT_ASSERT(p); } #endif if (i != m_torrents.end()) return i->second; @@ -1603,7 +1603,7 @@ namespace detail , bool paused , void* userdata) { - assert(!save_path.empty()); + TORRENT_ASSERT(!save_path.empty()); if (ti->begin_files() == ti->end_files()) throw std::runtime_error("no files in torrent"); @@ -1683,7 +1683,7 @@ namespace detail { // TODO: support resume data in this case - assert(!save_path.empty()); + TORRENT_ASSERT(!save_path.empty()); { // lock the checker_thread mutex::scoped_lock l(m_checker_impl.m_mutex); @@ -1703,7 +1703,7 @@ namespace detail throw duplicate_torrent(); // you cannot add new torrents to a session that is closing down - assert(!is_aborted()); + TORRENT_ASSERT(!is_aborted()); // create the torrent and the data associated with // the checker thread and store it before starting @@ -1732,8 +1732,8 @@ namespace detail void session_impl::remove_torrent(const torrent_handle& h) { if (h.m_ses != this) return; - assert(h.m_chk == &m_checker_impl || h.m_chk == 0); - assert(h.m_ses != 0); + TORRENT_ASSERT(h.m_chk == &m_checker_impl || h.m_chk == 0); + TORRENT_ASSERT(h.m_ses != 0); mutex_t::scoped_lock l(m_mutex); @@ -1750,8 +1750,8 @@ namespace detail && !t.torrent_file().trackers().empty()) { tracker_request req = t.generate_tracker_request(); - assert(req.event == tracker_request::stopped); - assert(!m_listen_sockets.empty()); + TORRENT_ASSERT(req.event == tracker_request::stopped); + TORRENT_ASSERT(!m_listen_sockets.empty()); req.listen_port = 0; if (!m_listen_sockets.empty()) req.listen_port = m_listen_sockets.front().external_port; @@ -1778,7 +1778,7 @@ namespace detail sha1_hash i_hash = t.torrent_file().info_hash(); #endif m_torrents.erase(i); - assert(m_torrents.find(i_hash) == m_torrents.end()); + TORRENT_ASSERT(m_torrents.find(i_hash) == m_torrents.end()); return; } @@ -1985,7 +1985,7 @@ namespace detail // basically, make sure you call listen_on() before // start_dht(). See documentation for listen_on() for // more information. - assert(m_listen_interface.port() > 0); + TORRENT_ASSERT(m_listen_interface.port() > 0); m_dht_settings.service_port = m_listen_interface.port(); } m_external_udp_port = m_dht_settings.service_port; @@ -2035,21 +2035,21 @@ namespace detail entry session_impl::dht_state() const { - assert(m_dht); + TORRENT_ASSERT(m_dht); mutex_t::scoped_lock l(m_mutex); return m_dht->state(); } void session_impl::add_dht_node(std::pair const& node) { - assert(m_dht); + TORRENT_ASSERT(m_dht); mutex_t::scoped_lock l(m_mutex); m_dht->add_node(node); } void session_impl::add_dht_router(std::pair const& node) { - assert(m_dht); + TORRENT_ASSERT(m_dht); mutex_t::scoped_lock l(m_mutex); m_dht->add_router_node(node); } @@ -2090,7 +2090,7 @@ namespace detail #endif m_thread->join(); - assert(m_torrents.empty()); + TORRENT_ASSERT(m_torrents.empty()); // it's important that the main thread is closed completely before // the checker thread is terminated. Because all the connections @@ -2117,8 +2117,8 @@ namespace detail #endif m_checker_thread->join(); - assert(m_torrents.empty()); - assert(m_connections.empty()); + TORRENT_ASSERT(m_torrents.empty()); + TORRENT_ASSERT(m_connections.empty()); #if defined(TORRENT_VERBOSE_LOGGING) || defined(TORRENT_LOGGING) (*m_logger) << time_now_string() << " shutdown complete!\n"; #endif @@ -2126,7 +2126,7 @@ namespace detail void session_impl::set_max_uploads(int limit) { - assert(limit > 0 || limit == -1); + TORRENT_ASSERT(limit > 0 || limit == -1); mutex_t::scoped_lock l(m_mutex); INVARIANT_CHECK; @@ -2137,7 +2137,7 @@ namespace detail void session_impl::set_max_connections(int limit) { - assert(limit > 0 || limit == -1); + TORRENT_ASSERT(limit > 0 || limit == -1); mutex_t::scoped_lock l(m_mutex); INVARIANT_CHECK; @@ -2148,7 +2148,7 @@ namespace detail void session_impl::set_max_half_open_connections(int limit) { - assert(limit > 0 || limit == -1); + TORRENT_ASSERT(limit > 0 || limit == -1); mutex_t::scoped_lock l(m_mutex); INVARIANT_CHECK; @@ -2159,7 +2159,7 @@ namespace detail void session_impl::set_download_rate_limit(int bytes_per_second) { - assert(bytes_per_second > 0 || bytes_per_second == -1); + TORRENT_ASSERT(bytes_per_second > 0 || bytes_per_second == -1); mutex_t::scoped_lock l(m_mutex); INVARIANT_CHECK; @@ -2170,7 +2170,7 @@ namespace detail void session_impl::set_upload_rate_limit(int bytes_per_second) { - assert(bytes_per_second > 0 || bytes_per_second == -1); + TORRENT_ASSERT(bytes_per_second > 0 || bytes_per_second == -1); mutex_t::scoped_lock l(m_mutex); INVARIANT_CHECK; @@ -2303,11 +2303,11 @@ namespace detail void session_impl::free_buffer(char* buf, int size) { - assert(size % send_buffer_size == 0); + TORRENT_ASSERT(size % send_buffer_size == 0); int num_buffers = size / send_buffer_size; #ifdef TORRENT_STATS m_buffer_allocations -= num_buffers; - assert(m_buffer_allocations >= 0); + TORRENT_ASSERT(m_buffer_allocations >= 0); m_buffer_usage_logger << log_time() << " protocol_buffer: " << (m_buffer_allocations * send_buffer_size) << std::endl; #endif @@ -2317,14 +2317,14 @@ namespace detail #ifndef NDEBUG void session_impl::check_invariant() const { - assert(m_max_connections > 0); - assert(m_max_uploads > 0); + TORRENT_ASSERT(m_max_connections > 0); + TORRENT_ASSERT(m_max_uploads > 0); int unchokes = 0; int num_optimistic = 0; for (connection_map::const_iterator i = m_connections.begin(); i != m_connections.end(); ++i) { - assert(i->second); + TORRENT_ASSERT(i->second); boost::shared_ptr t = i->second->associated_torrent().lock(); if (!i->second->is_choked()) ++unchokes; @@ -2332,17 +2332,17 @@ namespace detail && i->second->peer_info_struct()->optimistically_unchoked) { ++num_optimistic; - assert(!i->second->is_choked()); + TORRENT_ASSERT(!i->second->is_choked()); } if (t && i->second->peer_info_struct()) { - assert(t->get_policy().has_connection(boost::get_pointer(i->second))); + TORRENT_ASSERT(t->get_policy().has_connection(boost::get_pointer(i->second))); } } - assert(num_optimistic == 0 || num_optimistic == 1); + TORRENT_ASSERT(num_optimistic == 0 || num_optimistic == 1); if (m_num_unchoked != unchokes) { - assert(false); + TORRENT_ASSERT(false); } } #endif @@ -2508,7 +2508,7 @@ namespace detail return; } - assert(*slot_iter == p.index); + TORRENT_ASSERT(*slot_iter == p.index); int slot_index = static_cast(slot_iter - tmp_pieces.begin()); unsigned long adler = torrent_ptr->filesystem().piece_crc( diff --git a/libtorrent/src/socks5_stream.cpp b/libtorrent/src/socks5_stream.cpp index a6b5544e4..a40cd33d0 100644 --- a/libtorrent/src/socks5_stream.cpp +++ b/libtorrent/src/socks5_stream.cpp @@ -211,7 +211,7 @@ namespace libtorrent write_uint8(m_remote_endpoint.address().is_v4()?1:4, p); // address type write_address(m_remote_endpoint.address(), p); write_uint16(m_remote_endpoint.port(), p); - assert(p - &m_buffer[0] == int(m_buffer.size())); + TORRENT_ASSERT(p - &m_buffer[0] == int(m_buffer.size())); asio::async_write(m_sock, asio::buffer(m_buffer) , boost::bind(&socks5_stream::connect1, this, _1, h)); diff --git a/libtorrent/src/storage.cpp b/libtorrent/src/storage.cpp index 53d8379a0..f855dce8b 100755 --- a/libtorrent/src/storage.cpp +++ b/libtorrent/src/storage.cpp @@ -355,9 +355,9 @@ namespace libtorrent : m_info(info) , m_files(fp) { - assert(info->begin_files(true) != info->end_files(true)); + TORRENT_ASSERT(info->begin_files(true) != info->end_files(true)); m_save_path = fs::complete(path); - assert(m_save_path.is_complete()); + TORRENT_ASSERT(m_save_path.is_complete()); } void release_files(); @@ -400,7 +400,7 @@ namespace libtorrent partial.update(&m_scratch_buffer[0], ph.offset); whole.update(&m_scratch_buffer[0], slot_size1); hasher partial_copy = ph.h; - assert(ph.offset == 0 || partial_copy.final() == partial.final()); + TORRENT_ASSERT(ph.offset == 0 || partial_copy.final() == partial.final()); #endif int slot_size = piece_size - ph.offset; if (slot_size > 0) @@ -411,7 +411,7 @@ namespace libtorrent } #ifndef NDEBUG sha1_hash ret = ph.h.final(); - assert(ret == whole.final()); + TORRENT_ASSERT(ret == whole.final()); return ret; #else return ph.h.final(); @@ -690,20 +690,20 @@ namespace libtorrent , int size , bool fill_zero) { - assert(buf != 0); - assert(slot >= 0 && slot < m_info->num_pieces()); - assert(offset >= 0); - assert(offset < m_info->piece_size(slot)); - assert(size > 0); + TORRENT_ASSERT(buf != 0); + TORRENT_ASSERT(slot >= 0 && slot < m_info->num_pieces()); + TORRENT_ASSERT(offset >= 0); + TORRENT_ASSERT(offset < m_info->piece_size(slot)); + TORRENT_ASSERT(size > 0); #ifndef NDEBUG std::vector slices = m_info->map_block(slot, offset, size, true); - assert(!slices.empty()); + TORRENT_ASSERT(!slices.empty()); #endif size_type start = slot * (size_type)m_info->piece_length() + offset; - assert(start + size <= m_info->total_size()); + TORRENT_ASSERT(start + size <= m_info->total_size()); // find the file iterator and file offset size_type file_offset = start; @@ -722,9 +722,9 @@ namespace libtorrent boost::shared_ptr in(m_files.open_file( this, m_save_path / file_iter->path, file::in)); - assert(file_offset < file_iter->size); + TORRENT_ASSERT(file_offset < file_iter->size); - assert(slices[0].offset == file_offset); + TORRENT_ASSERT(slices[0].offset == file_offset); size_type new_pos = in->seek(file_offset); if (new_pos != file_offset) @@ -738,7 +738,7 @@ namespace libtorrent #ifndef NDEBUG size_type in_tell = in->tell(); - assert(in_tell == file_offset); + TORRENT_ASSERT(in_tell == file_offset); #endif int left_to_read = size; @@ -747,7 +747,7 @@ namespace libtorrent if (offset + left_to_read > slot_size) left_to_read = slot_size - offset; - assert(left_to_read >= 0); + TORRENT_ASSERT(left_to_read >= 0); size_type result = left_to_read; @@ -764,10 +764,10 @@ namespace libtorrent if (read_bytes > 0) { #ifndef NDEBUG - assert(int(slices.size()) > counter); + TORRENT_ASSERT(int(slices.size()) > counter); size_type slice_size = slices[counter].size; - assert(slice_size == read_bytes); - assert(m_info->file_at(slices[counter].file_index, true).path + TORRENT_ASSERT(slice_size == read_bytes); + TORRENT_ASSERT(m_info->file_at(slices[counter].file_index, true).path == file_iter->path); #endif @@ -785,7 +785,7 @@ namespace libtorrent left_to_read -= read_bytes; buf_pos += read_bytes; - assert(buf_pos >= 0); + TORRENT_ASSERT(buf_pos >= 0); file_offset += read_bytes; } @@ -815,16 +815,16 @@ namespace libtorrent , int offset , int size) { - assert(buf != 0); - assert(slot >= 0); - assert(slot < m_info->num_pieces()); - assert(offset >= 0); - assert(size > 0); + TORRENT_ASSERT(buf != 0); + TORRENT_ASSERT(slot >= 0); + TORRENT_ASSERT(slot < m_info->num_pieces()); + TORRENT_ASSERT(offset >= 0); + TORRENT_ASSERT(size > 0); #ifndef NDEBUG std::vector slices = m_info->map_block(slot, offset, size, true); - assert(!slices.empty()); + TORRENT_ASSERT(!slices.empty()); #endif size_type start = slot * (size_type)m_info->piece_length() + offset; @@ -840,15 +840,15 @@ namespace libtorrent file_offset -= file_iter->size; ++file_iter; - assert(file_iter != m_info->end_files(true)); + TORRENT_ASSERT(file_iter != m_info->end_files(true)); } fs::path p(m_save_path / file_iter->path); boost::shared_ptr out = m_files.open_file( this, p, file::out | file::in); - assert(file_offset < file_iter->size); - assert(slices[0].offset == file_offset); + TORRENT_ASSERT(file_offset < file_iter->size); + TORRENT_ASSERT(slices[0].offset == file_offset); size_type pos = out->seek(file_offset); @@ -865,7 +865,7 @@ namespace libtorrent if (offset + left_to_write > slot_size) left_to_write = slot_size - offset; - assert(left_to_write >= 0); + TORRENT_ASSERT(left_to_write >= 0); int buf_pos = 0; #ifndef NDEBUG @@ -876,19 +876,19 @@ namespace libtorrent int write_bytes = left_to_write; if (file_offset + write_bytes > file_iter->size) { - assert(file_iter->size >= file_offset); + TORRENT_ASSERT(file_iter->size >= file_offset); write_bytes = static_cast(file_iter->size - file_offset); } if (write_bytes > 0) { - assert(int(slices.size()) > counter); - assert(slices[counter].size == write_bytes); - assert(m_info->file_at(slices[counter].file_index, true).path + TORRENT_ASSERT(int(slices.size()) > counter); + TORRENT_ASSERT(slices[counter].size == write_bytes); + TORRENT_ASSERT(m_info->file_at(slices[counter].file_index, true).path == file_iter->path); - assert(buf_pos >= 0); - assert(write_bytes >= 0); + TORRENT_ASSERT(buf_pos >= 0); + TORRENT_ASSERT(write_bytes >= 0); size_type written = out->write(buf + buf_pos, write_bytes); if (written != write_bytes) @@ -900,9 +900,9 @@ namespace libtorrent left_to_write -= write_bytes; buf_pos += write_bytes; - assert(buf_pos >= 0); + TORRENT_ASSERT(buf_pos >= 0); file_offset += write_bytes; - assert(file_offset <= file_iter->size); + TORRENT_ASSERT(file_offset <= file_iter->size); } if (left_to_write > 0) @@ -912,7 +912,7 @@ namespace libtorrent #endif ++file_iter; - assert(file_iter != m_info->end_files(true)); + TORRENT_ASSERT(file_iter != m_info->end_files(true)); fs::path p = m_save_path / file_iter->path; file_offset = 0; out = m_files.open_file( @@ -931,7 +931,7 @@ namespace libtorrent bool supports_sparse_files(fs::path const& p) { - assert(p.is_complete()); + TORRENT_ASSERT(p.is_complete()); #if defined(_WIN32) // assume windows API is available DWORD max_component_len = 0; @@ -1105,7 +1105,7 @@ namespace libtorrent j.priority = priority; // if a buffer is not specified, only one block can be read // since that is the size of the pool allocator's buffers - assert(r.length <= 16 * 1024 || buffer != 0); + TORRENT_ASSERT(r.length <= 16 * 1024 || buffer != 0); m_io_thread.add_job(j, handler); } @@ -1114,7 +1114,7 @@ namespace libtorrent , char const* buffer , boost::function const& handler) { - assert(r.length <= 16 * 1024); + TORRENT_ASSERT(r.length <= 16 * 1024); disk_io_job j; j.storage = this; @@ -1157,7 +1157,7 @@ namespace libtorrent } int slot = m_piece_to_slot[piece]; - assert(slot != has_no_slot); + TORRENT_ASSERT(slot != has_no_slot); return m_storage->hash_for_slot(slot, ph, m_info->piece_size(piece)); } @@ -1204,12 +1204,12 @@ namespace libtorrent INVARIANT_CHECK; - assert(piece_index >= 0 && piece_index < (int)m_piece_to_slot.size()); - assert(m_piece_to_slot[piece_index] >= 0); + TORRENT_ASSERT(piece_index >= 0 && piece_index < (int)m_piece_to_slot.size()); + TORRENT_ASSERT(m_piece_to_slot[piece_index] >= 0); int slot_index = m_piece_to_slot[piece_index]; - assert(slot_index >= 0); + TORRENT_ASSERT(slot_index >= 0); m_slot_to_piece[slot_index] = unassigned; m_piece_to_slot[piece_index] = has_no_slot; @@ -1218,7 +1218,7 @@ namespace libtorrent int piece_manager::slot_for_piece(int piece_index) const { - assert(piece_index >= 0 && piece_index < m_info->num_pieces()); + TORRENT_ASSERT(piece_index >= 0 && piece_index < m_info->num_pieces()); return m_piece_to_slot[piece_index]; } @@ -1228,9 +1228,9 @@ namespace libtorrent , piece_picker::block_info const* bi) try { - assert(slot_index >= 0); - assert(slot_index < m_info->num_pieces()); - assert(block_size > 0); + TORRENT_ASSERT(slot_index >= 0); + TORRENT_ASSERT(slot_index < m_info->num_pieces()); + TORRENT_ASSERT(block_size > 0); adler32_crc crc; std::vector buf(block_size); @@ -1270,14 +1270,14 @@ namespace libtorrent , int offset , int size) { - assert(buf); - assert(offset >= 0); - assert(size > 0); - assert(piece_index >= 0 && piece_index < (int)m_piece_to_slot.size()); - assert(m_piece_to_slot[piece_index] >= 0 + TORRENT_ASSERT(buf); + TORRENT_ASSERT(offset >= 0); + TORRENT_ASSERT(size > 0); + TORRENT_ASSERT(piece_index >= 0 && piece_index < (int)m_piece_to_slot.size()); + TORRENT_ASSERT(m_piece_to_slot[piece_index] >= 0 && m_piece_to_slot[piece_index] < (int)m_slot_to_piece.size()); int slot = m_piece_to_slot[piece_index]; - assert(slot >= 0 && slot < (int)m_slot_to_piece.size()); + TORRENT_ASSERT(slot >= 0 && slot < (int)m_slot_to_piece.size()); return m_storage->read(buf, slot, offset, size); } @@ -1287,15 +1287,15 @@ namespace libtorrent , int offset , int size) { - assert(buf); - assert(offset >= 0); - assert(size > 0); - assert(piece_index >= 0 && piece_index < (int)m_piece_to_slot.size()); + TORRENT_ASSERT(buf); + TORRENT_ASSERT(offset >= 0); + TORRENT_ASSERT(size > 0); + TORRENT_ASSERT(piece_index >= 0 && piece_index < (int)m_piece_to_slot.size()); if (offset == 0) { partial_hash& ph = m_piece_hasher[piece_index]; - assert(ph.offset == 0); + TORRENT_ASSERT(ph.offset == 0); ph.offset = size; ph.h.update(buf, size); } @@ -1304,8 +1304,8 @@ namespace libtorrent std::map::iterator i = m_piece_hasher.find(piece_index); if (i != m_piece_hasher.end()) { - assert(i->second.offset > 0); - assert(offset >= i->second.offset); + TORRENT_ASSERT(i->second.offset > 0); + TORRENT_ASSERT(offset >= i->second.offset); if (offset == i->second.offset) { i->second.offset += size; @@ -1315,7 +1315,7 @@ namespace libtorrent } int slot = allocate_slot_for_piece(piece_index); - assert(slot >= 0 && slot < (int)m_slot_to_piece.size()); + TORRENT_ASSERT(slot >= 0 && slot < (int)m_slot_to_piece.size()); m_storage->write(buf, slot, offset, size); } @@ -1329,13 +1329,13 @@ namespace libtorrent { // INVARIANT_CHECK; - assert((int)have_pieces.size() == m_info->num_pieces()); + TORRENT_ASSERT((int)have_pieces.size() == m_info->num_pieces()); const int piece_size = static_cast(m_info->piece_length()); const int last_piece_size = static_cast(m_info->piece_size( m_info->num_pieces() - 1)); - assert((int)piece_data.size() >= last_piece_size); + TORRENT_ASSERT((int)piece_data.size() >= last_piece_size); // calculate a small digest, with the same // size as the last piece. And a large digest @@ -1343,7 +1343,7 @@ namespace libtorrent hasher small_digest; small_digest.update(&piece_data[0], last_piece_size); hasher large_digest(small_digest); - assert(piece_size - last_piece_size >= 0); + TORRENT_ASSERT(piece_size - last_piece_size >= 0); if (piece_size - last_piece_size > 0) { large_digest.update( @@ -1395,7 +1395,7 @@ namespace libtorrent // we have already found a piece with // this index. int other_slot = m_piece_to_slot[piece_index]; - assert(other_slot >= 0); + TORRENT_ASSERT(other_slot >= 0); // take one of the other matching pieces // that hasn't already been assigned @@ -1410,7 +1410,7 @@ namespace libtorrent if (other_piece >= 0) { // replace the old slot with 'other_piece' - assert(have_pieces[other_piece] == false); + TORRENT_ASSERT(have_pieces[other_piece] == false); have_pieces[other_piece] = true; m_slot_to_piece[other_slot] = other_piece; m_piece_to_slot[other_piece] = other_slot; @@ -1426,8 +1426,8 @@ namespace libtorrent m_slot_to_piece[other_slot] = unassigned; m_free_slots.push_back(other_slot); } - assert(m_piece_to_slot[piece_index] != current_slot); - assert(m_piece_to_slot[piece_index] >= 0); + TORRENT_ASSERT(m_piece_to_slot[piece_index] != current_slot); + TORRENT_ASSERT(m_piece_to_slot[piece_index] >= 0); m_piece_to_slot[piece_index] = has_no_slot; #ifndef NDEBUG // to make the assert happy, a few lines down @@ -1439,8 +1439,8 @@ namespace libtorrent ++num_pieces; } - assert(have_pieces[piece_index] == false); - assert(m_piece_to_slot[piece_index] == has_no_slot); + TORRENT_ASSERT(have_pieces[piece_index] == false); + TORRENT_ASSERT(m_piece_to_slot[piece_index] == has_no_slot); have_pieces[piece_index] = true; return piece_index; @@ -1462,8 +1462,8 @@ namespace libtorrent // lock because we're writing to have_pieces boost::recursive_mutex::scoped_lock l(mutex); - assert(have_pieces[free_piece] == false); - assert(m_piece_to_slot[free_piece] == has_no_slot); + TORRENT_ASSERT(have_pieces[free_piece] == false); + TORRENT_ASSERT(m_piece_to_slot[free_piece] == has_no_slot); have_pieces[free_piece] = true; ++num_pieces; @@ -1471,7 +1471,7 @@ namespace libtorrent } else { - assert(free_piece == unassigned); + TORRENT_ASSERT(free_piece == unassigned); return unassigned; } } @@ -1489,7 +1489,7 @@ namespace libtorrent INVARIANT_CHECK; - assert(m_info->piece_length() > 0); + TORRENT_ASSERT(m_info->piece_length() > 0); m_compact_mode = compact_mode; @@ -1539,7 +1539,7 @@ namespace libtorrent } else { - assert(data.piece_map[i] == unallocated); + TORRENT_ASSERT(data.piece_map[i] == unallocated); m_unallocated_slots.push_back(i); } } @@ -1600,7 +1600,7 @@ namespace libtorrent std::pair piece_manager::check_files( std::vector& pieces, int& num_pieces, boost::recursive_mutex& mutex) { - assert(num_pieces == std::count(pieces.begin(), pieces.end(), true)); + TORRENT_ASSERT(num_pieces == std::count(pieces.begin(), pieces.end(), true)); if (m_state == state_allocating) { @@ -1622,7 +1622,7 @@ namespace libtorrent // if we're not in compact mode, make sure the // pieces are spread out and placed at their // final position. - assert(!m_unallocated_slots.empty()); + TORRENT_ASSERT(!m_unallocated_slots.empty()); if (!m_fill_mode) { @@ -1649,7 +1649,7 @@ namespace libtorrent if (!m_unallocated_slots.empty() && !m_compact_mode) { - assert(!m_fill_mode); + TORRENT_ASSERT(!m_fill_mode); std::vector().swap(m_unallocated_slots); std::fill(m_slot_to_piece.begin(), m_slot_to_piece.end(), int(unassigned)); m_free_slots.resize(m_info->num_pieces()); @@ -1661,7 +1661,7 @@ namespace libtorrent return std::make_pair(true, 1.f); } - assert(m_state == state_full_check); + TORRENT_ASSERT(m_state == state_full_check); // ------------------------ // DO THE FULL CHECK @@ -1692,8 +1692,8 @@ namespace libtorrent int piece_index = identify_data(m_piece_data, m_current_slot , pieces, num_pieces, m_hash_to_piece, mutex); - assert(num_pieces == std::count(pieces.begin(), pieces.end(), true)); - assert(piece_index == unassigned || piece_index >= 0); + TORRENT_ASSERT(num_pieces == std::count(pieces.begin(), pieces.end(), true)); + TORRENT_ASSERT(piece_index == unassigned || piece_index >= 0); const bool this_should_move = piece_index >= 0 && m_slot_to_piece[piece_index] != unallocated; const bool other_should_move = m_piece_to_slot[m_current_slot] != has_no_slot; @@ -1727,10 +1727,10 @@ namespace libtorrent // case 1 if (this_should_move && !other_should_move) { - assert(piece_index != m_current_slot); + TORRENT_ASSERT(piece_index != m_current_slot); const int other_slot = piece_index; - assert(other_slot >= 0); + TORRENT_ASSERT(other_slot >= 0); int other_piece = m_slot_to_piece[other_slot]; m_slot_to_piece[other_slot] = piece_index; @@ -1742,7 +1742,7 @@ namespace libtorrent { std::vector::iterator i = std::find(m_free_slots.begin(), m_free_slots.end(), other_slot); - assert(i != m_free_slots.end()); + TORRENT_ASSERT(i != m_free_slots.end()); m_free_slots.erase(i); m_free_slots.push_back(m_current_slot); } @@ -1752,17 +1752,17 @@ namespace libtorrent else m_storage->move_slot(m_current_slot, other_slot); - assert(m_slot_to_piece[m_current_slot] == unassigned + TORRENT_ASSERT(m_slot_to_piece[m_current_slot] == unassigned || m_piece_to_slot[m_slot_to_piece[m_current_slot]] == m_current_slot); } // case 2 else if (!this_should_move && other_should_move) { - assert(piece_index != m_current_slot); + TORRENT_ASSERT(piece_index != m_current_slot); const int other_piece = m_current_slot; const int other_slot = m_piece_to_slot[other_piece]; - assert(other_slot >= 0); + TORRENT_ASSERT(other_slot >= 0); m_slot_to_piece[m_current_slot] = other_piece; m_slot_to_piece[other_slot] = piece_index; @@ -1780,27 +1780,27 @@ namespace libtorrent { m_storage->move_slot(other_slot, m_current_slot); } - assert(m_slot_to_piece[m_current_slot] == unassigned + TORRENT_ASSERT(m_slot_to_piece[m_current_slot] == unassigned || m_piece_to_slot[m_slot_to_piece[m_current_slot]] == m_current_slot); } else if (this_should_move && other_should_move) { - assert(piece_index != m_current_slot); - assert(piece_index >= 0); + TORRENT_ASSERT(piece_index != m_current_slot); + TORRENT_ASSERT(piece_index >= 0); const int piece1 = m_slot_to_piece[piece_index]; const int piece2 = m_current_slot; const int slot1 = piece_index; const int slot2 = m_piece_to_slot[piece2]; - assert(slot1 >= 0); - assert(slot2 >= 0); - assert(piece2 >= 0); + TORRENT_ASSERT(slot1 >= 0); + TORRENT_ASSERT(slot2 >= 0); + TORRENT_ASSERT(piece2 >= 0); if (slot1 == slot2) { // this means there are only two pieces involved in the swap - assert(piece1 >= 0); + TORRENT_ASSERT(piece1 >= 0); // movement diagram: // +-------------------------------+ @@ -1813,18 +1813,18 @@ namespace libtorrent m_piece_to_slot[piece_index] = slot1; m_piece_to_slot[piece1] = m_current_slot; - assert(piece1 == m_current_slot); - assert(piece_index == slot1); + TORRENT_ASSERT(piece1 == m_current_slot); + TORRENT_ASSERT(piece_index == slot1); m_storage->swap_slots(m_current_slot, slot1); - assert(m_slot_to_piece[m_current_slot] == unassigned + TORRENT_ASSERT(m_slot_to_piece[m_current_slot] == unassigned || m_piece_to_slot[m_slot_to_piece[m_current_slot]] == m_current_slot); } else { - assert(slot1 != slot2); - assert(piece1 != piece2); + TORRENT_ASSERT(slot1 != slot2); + TORRENT_ASSERT(piece1 != piece2); // movement diagram: // +-----------------------------------------+ @@ -1842,7 +1842,7 @@ namespace libtorrent { std::vector::iterator i = std::find(m_free_slots.begin(), m_free_slots.end(), slot1); - assert(i != m_free_slots.end()); + TORRENT_ASSERT(i != m_free_slots.end()); m_free_slots.erase(i); m_free_slots.push_back(slot2); } @@ -1858,15 +1858,15 @@ namespace libtorrent m_storage->move_slot(slot2, m_current_slot); } - assert(m_slot_to_piece[m_current_slot] == unassigned + TORRENT_ASSERT(m_slot_to_piece[m_current_slot] == unassigned || m_piece_to_slot[m_slot_to_piece[m_current_slot]] == m_current_slot); } } else { - assert(m_piece_to_slot[m_current_slot] == has_no_slot || piece_index != m_current_slot); - assert(m_slot_to_piece[m_current_slot] == unallocated); - assert(piece_index == unassigned || m_piece_to_slot[piece_index] == has_no_slot); + TORRENT_ASSERT(m_piece_to_slot[m_current_slot] == has_no_slot || piece_index != m_current_slot); + TORRENT_ASSERT(m_slot_to_piece[m_current_slot] == unallocated); + TORRENT_ASSERT(piece_index == unassigned || m_piece_to_slot[piece_index] == has_no_slot); // the slot was identified as piece 'piece_index' if (piece_index != unassigned) @@ -1876,7 +1876,7 @@ namespace libtorrent m_slot_to_piece[m_current_slot] = piece_index; - assert(m_slot_to_piece[m_current_slot] == unassigned + TORRENT_ASSERT(m_slot_to_piece[m_current_slot] == unassigned || m_piece_to_slot[m_slot_to_piece[m_current_slot]] == m_current_slot); } } @@ -1892,14 +1892,14 @@ namespace libtorrent if (file_offset > current_offset) break; } - assert(file_offset > current_offset); + TORRENT_ASSERT(file_offset > current_offset); int skip_blocks = static_cast( (file_offset - current_offset + m_info->piece_length() - 1) / m_info->piece_length()); for (int i = m_current_slot; i < m_current_slot + skip_blocks; ++i) { - assert(m_slot_to_piece[i] == unallocated); + TORRENT_ASSERT(m_slot_to_piece[i] == unallocated); m_unallocated_slots.push_back(i); } @@ -1910,17 +1910,17 @@ namespace libtorrent if (m_current_slot >= m_info->num_pieces()) { - assert(m_current_slot == m_info->num_pieces()); + TORRENT_ASSERT(m_current_slot == m_info->num_pieces()); // clear the memory we've been using std::vector().swap(m_piece_data); std::multimap().swap(m_hash_to_piece); m_state = state_allocating; - assert(num_pieces == std::count(pieces.begin(), pieces.end(), true)); + TORRENT_ASSERT(num_pieces == std::count(pieces.begin(), pieces.end(), true)); return std::make_pair(false, 1.f); } - assert(num_pieces == std::count(pieces.begin(), pieces.end(), true)); + TORRENT_ASSERT(num_pieces == std::count(pieces.begin(), pieces.end(), true)); return std::make_pair(false, (float)m_current_slot / m_info->num_pieces()); } @@ -1931,23 +1931,23 @@ namespace libtorrent // INVARIANT_CHECK; - assert(piece_index >= 0); - assert(piece_index < (int)m_piece_to_slot.size()); - assert(m_piece_to_slot.size() == m_slot_to_piece.size()); + TORRENT_ASSERT(piece_index >= 0); + TORRENT_ASSERT(piece_index < (int)m_piece_to_slot.size()); + TORRENT_ASSERT(m_piece_to_slot.size() == m_slot_to_piece.size()); int slot_index = m_piece_to_slot[piece_index]; if (slot_index != has_no_slot) { - assert(slot_index >= 0); - assert(slot_index < (int)m_slot_to_piece.size()); + TORRENT_ASSERT(slot_index >= 0); + TORRENT_ASSERT(slot_index < (int)m_slot_to_piece.size()); return slot_index; } if (m_free_slots.empty()) { allocate_slots(1); - assert(!m_free_slots.empty()); + TORRENT_ASSERT(!m_free_slots.empty()); } std::vector::iterator iter( @@ -1958,8 +1958,8 @@ namespace libtorrent if (iter == m_free_slots.end()) { - assert(m_slot_to_piece[piece_index] != unassigned); - assert(!m_free_slots.empty()); + TORRENT_ASSERT(m_slot_to_piece[piece_index] != unassigned); + TORRENT_ASSERT(!m_free_slots.empty()); iter = m_free_slots.end() - 1; // special case to make sure we don't use the last slot @@ -1968,7 +1968,7 @@ namespace libtorrent { if (m_free_slots.size() == 1) allocate_slots(1); - assert(m_free_slots.size() > 1); + TORRENT_ASSERT(m_free_slots.size() > 1); // assumes that all allocated slots // are put at the end of the free_slots vector iter = m_free_slots.end() - 1; @@ -1978,7 +1978,7 @@ namespace libtorrent slot_index = *iter; m_free_slots.erase(iter); - assert(m_slot_to_piece[slot_index] == unassigned); + TORRENT_ASSERT(m_slot_to_piece[slot_index] == unassigned); m_slot_to_piece[slot_index] = piece_index; m_piece_to_slot[piece_index] = slot_index; @@ -2007,7 +2007,7 @@ namespace libtorrent #endif int piece_at_our_slot = m_slot_to_piece[piece_index]; - assert(m_piece_to_slot[piece_at_our_slot] == piece_index); + TORRENT_ASSERT(m_piece_to_slot[piece_at_our_slot] == piece_index); std::swap( m_slot_to_piece[piece_index] @@ -2019,8 +2019,8 @@ namespace libtorrent m_storage->move_slot(piece_index, slot_index); - assert(m_slot_to_piece[piece_index] == piece_index); - assert(m_piece_to_slot[piece_index] == piece_index); + TORRENT_ASSERT(m_slot_to_piece[piece_index] == piece_index); + TORRENT_ASSERT(m_piece_to_slot[piece_index] == piece_index); slot_index = piece_index; @@ -2029,20 +2029,20 @@ namespace libtorrent #endif } - assert(slot_index >= 0); - assert(slot_index < (int)m_slot_to_piece.size()); + TORRENT_ASSERT(slot_index >= 0); + TORRENT_ASSERT(slot_index < (int)m_slot_to_piece.size()); return slot_index; } bool piece_manager::allocate_slots(int num_slots, bool abort_on_disk) { - assert(num_slots > 0); + TORRENT_ASSERT(num_slots > 0); boost::recursive_mutex::scoped_lock lock(m_mutex); // INVARIANT_CHECK; - assert(!m_unallocated_slots.empty()); + TORRENT_ASSERT(!m_unallocated_slots.empty()); const int stack_buffer_size = 16*1024; char zeroes[stack_buffer_size]; @@ -2055,8 +2055,8 @@ namespace libtorrent // INVARIANT_CHECK; int pos = m_unallocated_slots.front(); - assert(m_slot_to_piece[pos] == unallocated); - assert(m_piece_to_slot[pos] != pos); + TORRENT_ASSERT(m_slot_to_piece[pos] == unallocated); + TORRENT_ASSERT(m_piece_to_slot[pos] != pos); int new_free_slot = pos; if (m_piece_to_slot[pos] != has_no_slot) @@ -2085,7 +2085,7 @@ namespace libtorrent if (abort_on_disk && written) return true; } - assert(m_free_slots.size() > 0); + TORRENT_ASSERT(m_free_slots.size() > 0); return written; } @@ -2095,26 +2095,26 @@ namespace libtorrent boost::recursive_mutex::scoped_lock lock(m_mutex); if (m_piece_to_slot.empty()) return; - assert((int)m_piece_to_slot.size() == m_info->num_pieces()); - assert((int)m_slot_to_piece.size() == m_info->num_pieces()); + TORRENT_ASSERT((int)m_piece_to_slot.size() == m_info->num_pieces()); + TORRENT_ASSERT((int)m_slot_to_piece.size() == m_info->num_pieces()); for (std::vector::const_iterator i = m_free_slots.begin(); i != m_free_slots.end(); ++i) { - assert(*i < (int)m_slot_to_piece.size()); - assert(*i >= 0); - assert(m_slot_to_piece[*i] == unassigned); - assert(std::find(i+1, m_free_slots.end(), *i) + TORRENT_ASSERT(*i < (int)m_slot_to_piece.size()); + TORRENT_ASSERT(*i >= 0); + TORRENT_ASSERT(m_slot_to_piece[*i] == unassigned); + TORRENT_ASSERT(std::find(i+1, m_free_slots.end(), *i) == m_free_slots.end()); } for (std::vector::const_iterator i = m_unallocated_slots.begin(); i != m_unallocated_slots.end(); ++i) { - assert(*i < (int)m_slot_to_piece.size()); - assert(*i >= 0); - assert(m_slot_to_piece[*i] == unallocated); - assert(std::find(i+1, m_unallocated_slots.end(), *i) + TORRENT_ASSERT(*i < (int)m_slot_to_piece.size()); + TORRENT_ASSERT(*i >= 0); + TORRENT_ASSERT(m_slot_to_piece[*i] == unallocated); + TORRENT_ASSERT(std::find(i+1, m_unallocated_slots.end(), *i) == m_unallocated_slots.end()); } @@ -2123,46 +2123,46 @@ namespace libtorrent // Check domain of piece_to_slot's elements if (m_piece_to_slot[i] != has_no_slot) { - assert(m_piece_to_slot[i] >= 0); - assert(m_piece_to_slot[i] < (int)m_slot_to_piece.size()); + TORRENT_ASSERT(m_piece_to_slot[i] >= 0); + TORRENT_ASSERT(m_piece_to_slot[i] < (int)m_slot_to_piece.size()); } // Check domain of slot_to_piece's elements if (m_slot_to_piece[i] != unallocated && m_slot_to_piece[i] != unassigned) { - assert(m_slot_to_piece[i] >= 0); - assert(m_slot_to_piece[i] < (int)m_piece_to_slot.size()); + TORRENT_ASSERT(m_slot_to_piece[i] >= 0); + TORRENT_ASSERT(m_slot_to_piece[i] < (int)m_piece_to_slot.size()); } // do more detailed checks on piece_to_slot if (m_piece_to_slot[i] >= 0) { - assert(m_slot_to_piece[m_piece_to_slot[i]] == i); + TORRENT_ASSERT(m_slot_to_piece[m_piece_to_slot[i]] == i); if (m_piece_to_slot[i] != i) { - assert(m_slot_to_piece[i] == unallocated); + TORRENT_ASSERT(m_slot_to_piece[i] == unallocated); } } else { - assert(m_piece_to_slot[i] == has_no_slot); + TORRENT_ASSERT(m_piece_to_slot[i] == has_no_slot); } // do more detailed checks on slot_to_piece if (m_slot_to_piece[i] >= 0) { - assert(m_slot_to_piece[i] < (int)m_piece_to_slot.size()); - assert(m_piece_to_slot[m_slot_to_piece[i]] == i); + TORRENT_ASSERT(m_slot_to_piece[i] < (int)m_piece_to_slot.size()); + TORRENT_ASSERT(m_piece_to_slot[m_slot_to_piece[i]] == i); #ifdef TORRENT_STORAGE_DEBUG - assert( + TORRENT_ASSERT( std::find( m_unallocated_slots.begin() , m_unallocated_slots.end() , i) == m_unallocated_slots.end() ); - assert( + TORRENT_ASSERT( std::find( m_free_slots.begin() , m_free_slots.end() @@ -2173,7 +2173,7 @@ namespace libtorrent else if (m_slot_to_piece[i] == unallocated) { #ifdef TORRENT_STORAGE_DEBUG - assert(m_unallocated_slots.empty() + TORRENT_ASSERT(m_unallocated_slots.empty() || (std::find( m_unallocated_slots.begin() , m_unallocated_slots.end() @@ -2184,7 +2184,7 @@ namespace libtorrent else if (m_slot_to_piece[i] == unassigned) { #ifdef TORRENT_STORAGE_DEBUG - assert( + TORRENT_ASSERT( std::find( m_free_slots.begin() , m_free_slots.end() @@ -2194,7 +2194,7 @@ namespace libtorrent } else { - assert(false && "m_slot_to_piece[i] is invalid"); + TORRENT_ASSERT(false && "m_slot_to_piece[i] is invalid"); } } } diff --git a/libtorrent/src/torrent.cpp b/libtorrent/src/torrent.cpp index 33fbe9b40..840525c8a 100755 --- a/libtorrent/src/torrent.cpp +++ b/libtorrent/src/torrent.cpp @@ -114,7 +114,7 @@ namespace find_peer_by_ip(tcp::endpoint const& a, const torrent* t) : ip(a) , tor(t) - { assert(t != 0); } + { TORRENT_ASSERT(t != 0); } bool operator()(const session_impl::connection_map::value_type& c) const { @@ -309,7 +309,7 @@ namespace libtorrent // been closed by the time the torrent is destructed. And they are // supposed to be closed. So we can still do the invariant check. - assert(m_connections.empty()); + TORRENT_ASSERT(m_connections.empty()); INVARIANT_CHECK; @@ -321,7 +321,7 @@ namespace libtorrent } #endif - assert(m_abort); + TORRENT_ASSERT(m_abort); if (!m_connections.empty()) disconnect_all(); } @@ -344,9 +344,9 @@ namespace libtorrent // shared_from_this() void torrent::init() { - assert(m_torrent_file->is_valid()); - assert(m_torrent_file->num_files() > 0); - assert(m_torrent_file->total_size() >= 0); + TORRENT_ASSERT(m_torrent_file->is_valid()); + TORRENT_ASSERT(m_torrent_file->num_files() > 0); + TORRENT_ASSERT(m_torrent_file->total_size() >= 0); m_have_pieces.resize(m_torrent_file->num_pieces(), false); // the shared_from_this() will create an intentional @@ -423,7 +423,7 @@ namespace libtorrent catch (std::exception& e) { std::cerr << e.what() << std::endl; - assert(false); + TORRENT_ASSERT(false); }; #endif @@ -662,7 +662,7 @@ namespace libtorrent size_type total_done = m_num_pieces * m_torrent_file->piece_length(); - assert(m_num_pieces < m_torrent_file->num_pieces()); + TORRENT_ASSERT(m_num_pieces < m_torrent_file->num_pieces()); // if we have the last piece, we have to correct // the amount we have, since the first calculation @@ -676,8 +676,8 @@ namespace libtorrent wanted_done += corr; } - assert(total_done <= m_torrent_file->total_size()); - assert(wanted_done <= m_torrent_file->total_size()); + TORRENT_ASSERT(total_done <= m_torrent_file->total_size()); + TORRENT_ASSERT(wanted_done <= m_torrent_file->total_size()); const std::vector& dl_queue = m_picker->get_download_queue(); @@ -690,22 +690,22 @@ namespace libtorrent { int corr = 0; int index = i->index; - assert(!m_have_pieces[index]); - assert(i->finished <= m_picker->blocks_in_piece(index)); + if (m_have_pieces[index]) continue; + TORRENT_ASSERT(i->finished <= m_picker->blocks_in_piece(index)); #ifndef NDEBUG for (std::vector::const_iterator j = boost::next(i); j != dl_queue.end(); ++j) { - assert(j->index != index); + TORRENT_ASSERT(j->index != index); } #endif for (int j = 0; j < blocks_per_piece; ++j) { - assert(m_picker->is_finished(piece_block(index, j)) == (i->info[j].state == piece_picker::block_info::state_finished)); + TORRENT_ASSERT(m_picker->is_finished(piece_block(index, j)) == (i->info[j].state == piece_picker::block_info::state_finished)); corr += (i->info[j].state == piece_picker::block_info::state_finished) * m_block_size; - assert(index != last_piece || j < m_picker->blocks_in_last_piece() + TORRENT_ASSERT(index != last_piece || j < m_picker->blocks_in_last_piece() || i->info[j].state != piece_picker::block_info::state_finished); } @@ -723,8 +723,8 @@ namespace libtorrent wanted_done += corr; } - assert(total_done <= m_torrent_file->total_size()); - assert(wanted_done <= m_torrent_file->total_size()); + TORRENT_ASSERT(total_done <= m_torrent_file->total_size()); + TORRENT_ASSERT(wanted_done <= m_torrent_file->total_size()); std::map downloading_piece; for (const_peer_iterator i = begin(); i != end(); ++i) @@ -753,13 +753,13 @@ namespace libtorrent downloading_piece[block] = p->bytes_downloaded; } #ifndef NDEBUG - assert(p->bytes_downloaded <= p->full_block_bytes); + TORRENT_ASSERT(p->bytes_downloaded <= p->full_block_bytes); int last_piece = m_torrent_file->num_pieces() - 1; if (p->piece_index == last_piece && p->block_index == m_torrent_file->piece_size(last_piece) / block_size()) - assert(p->full_block_bytes == m_torrent_file->piece_size(last_piece) % block_size()); + TORRENT_ASSERT(p->full_block_bytes == m_torrent_file->piece_size(last_piece) % block_size()); else - assert(p->full_block_bytes == block_size()); + TORRENT_ASSERT(p->full_block_bytes == block_size()); #endif } } @@ -806,12 +806,12 @@ namespace libtorrent } - assert(total_done <= m_torrent_file->total_size()); - assert(wanted_done <= m_torrent_file->total_size()); + TORRENT_ASSERT(total_done <= m_torrent_file->total_size()); + TORRENT_ASSERT(wanted_done <= m_torrent_file->total_size()); #endif - assert(total_done >= wanted_done); + TORRENT_ASSERT(total_done >= wanted_done); return make_tuple(total_done, wanted_done); } @@ -833,7 +833,7 @@ namespace libtorrent // the following call may cause picker to become invalid // in case we just became a seed announce_piece(index); - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); // if we just became a seed, picker is now invalid, since it // is deallocated by the torrent once it starts seeding if (!was_finished @@ -850,7 +850,7 @@ namespace libtorrent { #ifndef NDEBUG std::cerr << e.what() << std::endl; - assert(false); + TORRENT_ASSERT(false); #endif } } @@ -872,7 +872,7 @@ namespace libtorrent catch (std::exception const& e) { std::cerr << e.what() << std::endl; - assert(false); + TORRENT_ASSERT(false); } #endif @@ -883,7 +883,7 @@ namespace libtorrent if (!was_seed && is_seed()) { - assert(passed_hash_check); + TORRENT_ASSERT(passed_hash_check); completed(); } @@ -892,7 +892,7 @@ namespace libtorrent catch (std::exception const& e) { std::cerr << e.what() << std::endl; - assert(false); + TORRENT_ASSERT(false); } #endif @@ -907,11 +907,11 @@ namespace libtorrent // (total_done == m_torrent_file->total_size()) => is_seed() // INVARIANT_CHECK; - assert(m_storage); - assert(m_storage->refcount() > 0); - assert(m_picker.get()); - assert(index >= 0); - assert(index < m_torrent_file->num_pieces()); + TORRENT_ASSERT(m_storage); + TORRENT_ASSERT(m_storage->refcount() > 0); + TORRENT_ASSERT(m_picker.get()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < m_torrent_file->num_pieces()); if (m_ses.m_alerts.should_post(alert::info)) { @@ -949,7 +949,7 @@ namespace libtorrent { std::vector conns; connection_for(p->ip.address(), conns); - assert(p->connection == 0 + TORRENT_ASSERT(p->connection == 0 || std::find_if(conns.begin(), conns.end() , boost::bind(std::equal_to(), _1, p->connection)) != conns.end()); @@ -997,10 +997,10 @@ namespace libtorrent // start with redownloading the pieces that the client // that has sent the least number of pieces m_picker->restore_piece(index); - assert(m_storage); + TORRENT_ASSERT(m_storage); m_storage->mark_failed(index); - assert(m_have_pieces[index] == false); + TORRENT_ASSERT(m_have_pieces[index] == false); } void torrent::abort() @@ -1057,8 +1057,8 @@ namespace libtorrent { // INVARIANT_CHECK; - assert(index >= 0); - assert(index < m_torrent_file->num_pieces()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < m_torrent_file->num_pieces()); std::vector downloaders; m_picker->get_downloaders(downloaders, index); @@ -1072,7 +1072,7 @@ namespace libtorrent m_num_pieces++; m_have_pieces[index] = true; - assert(std::accumulate(m_have_pieces.begin(), m_have_pieces.end(), 0) + TORRENT_ASSERT(std::accumulate(m_have_pieces.begin(), m_have_pieces.end(), 0) == m_num_pieces); m_picker->we_have(index); @@ -1115,7 +1115,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) { avail.clear(); @@ -1129,13 +1129,13 @@ namespace libtorrent { // INVARIANT_CHECK; - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) return; // this call is only valid on torrents with metadata - assert(m_picker.get()); - assert(index >= 0); - assert(index < m_torrent_file->num_pieces()); + TORRENT_ASSERT(m_picker.get()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < m_torrent_file->num_pieces()); bool filter_updated = m_picker->set_piece_priority(index, priority); if (filter_updated) update_peer_interest(); @@ -1145,13 +1145,13 @@ namespace libtorrent { // INVARIANT_CHECK; - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) return 1; // this call is only valid on torrents with metadata - assert(m_picker.get()); - assert(index >= 0); - assert(index < m_torrent_file->num_pieces()); + TORRENT_ASSERT(m_picker.get()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < m_torrent_file->num_pieces()); return m_picker->piece_priority(index); } @@ -1161,18 +1161,18 @@ namespace libtorrent INVARIANT_CHECK; // this call is only valid on torrents with metadata - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) return; - assert(m_picker.get()); + TORRENT_ASSERT(m_picker.get()); int index = 0; bool filter_updated = false; for (std::vector::const_iterator i = pieces.begin() , end(pieces.end()); i != end; ++i, ++index) { - assert(*i >= 0); - assert(*i <= 7); + TORRENT_ASSERT(*i >= 0); + TORRENT_ASSERT(*i <= 7); filter_updated |= m_picker->set_piece_priority(index, *i); } if (filter_updated) update_peer_interest(); @@ -1183,7 +1183,7 @@ namespace libtorrent INVARIANT_CHECK; // this call is only valid on torrents with metadata - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) { pieces.clear(); @@ -1191,7 +1191,7 @@ namespace libtorrent return; } - assert(m_picker.get()); + TORRENT_ASSERT(m_picker.get()); m_picker->piece_priorities(pieces); } @@ -1212,7 +1212,7 @@ namespace libtorrent // the bitmask need to have exactly one bit for every file // in the torrent - assert(int(files.size()) == m_torrent_file->num_files()); + TORRENT_ASSERT(int(files.size()) == m_torrent_file->num_files()); size_type position = 0; @@ -1233,7 +1233,7 @@ namespace libtorrent // already set (to avoid problems with overlapping pieces) int start_piece = int(start / piece_length); int last_piece = int((position - 1) / piece_length); - assert(last_piece <= int(pieces.size())); + TORRENT_ASSERT(last_piece <= int(pieces.size())); // if one piece spans several files, we might // come here several times with the same start_piece, end_piece std::for_each(pieces.begin() + start_piece @@ -1255,13 +1255,13 @@ namespace libtorrent { INVARIANT_CHECK; - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) return; // this call is only valid on torrents with metadata - assert(m_picker.get()); - assert(index >= 0); - assert(index < m_torrent_file->num_pieces()); + TORRENT_ASSERT(m_picker.get()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < m_torrent_file->num_pieces()); m_picker->set_piece_priority(index, filter ? 1 : 0); update_peer_interest(); @@ -1272,10 +1272,10 @@ namespace libtorrent INVARIANT_CHECK; // this call is only valid on torrents with metadata - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) return; - assert(m_picker.get()); + TORRENT_ASSERT(m_picker.get()); int index = 0; for (std::vector::const_iterator i = bitmask.begin() @@ -1293,12 +1293,12 @@ namespace libtorrent bool torrent::is_piece_filtered(int index) const { // this call is only valid on torrents with metadata - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) return false; - assert(m_picker.get()); - assert(index >= 0); - assert(index < m_torrent_file->num_pieces()); + TORRENT_ASSERT(m_picker.get()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < m_torrent_file->num_pieces()); return m_picker->piece_priority(index) == 0; } @@ -1308,7 +1308,7 @@ namespace libtorrent INVARIANT_CHECK; // this call is only valid on torrents with metadata - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); if (is_seed()) { bitmask.clear(); @@ -1316,7 +1316,7 @@ namespace libtorrent return; } - assert(m_picker.get()); + TORRENT_ASSERT(m_picker.get()); m_picker->filtered_pieces(bitmask); } @@ -1329,7 +1329,7 @@ namespace libtorrent // the bitmask need to have exactly one bit for every file // in the torrent - assert((int)bitmask.size() == m_torrent_file->num_files()); + TORRENT_ASSERT((int)bitmask.size() == m_torrent_file->num_files()); size_type position = 0; @@ -1361,7 +1361,7 @@ namespace libtorrent void torrent::replace_trackers(std::vector const& urls) { - assert(!urls.empty()); + TORRENT_ASSERT(!urls.empty()); m_trackers = urls; if (m_currently_trying_tracker >= (int)m_trackers.size()) m_currently_trying_tracker = (int)m_trackers.size()-1; @@ -1372,7 +1372,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!m_trackers.empty()); + TORRENT_ASSERT(!m_trackers.empty()); m_next_request = time_now() + seconds(tracker_retry_delay_max); @@ -1408,8 +1408,8 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!c.is_choked()); - assert(m_num_uploads > 0); + TORRENT_ASSERT(!c.is_choked()); + TORRENT_ASSERT(m_num_uploads > 0); c.send_choke(); --m_num_uploads; } @@ -1418,7 +1418,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(c.is_choked()); + TORRENT_ASSERT(c.is_choked()); if (m_num_uploads >= m_max_uploads) return false; c.send_unchoke(); ++m_num_uploads; @@ -1438,24 +1438,24 @@ namespace libtorrent { // INVARIANT_CHECK; - assert(p != 0); + TORRENT_ASSERT(p != 0); peer_iterator i = m_connections.find(p->remote()); if (i == m_connections.end()) { - assert(false); + TORRENT_ASSERT(false); return; } if (ready_for_connections()) { - assert(p->associated_torrent().lock().get() == this); + TORRENT_ASSERT(p->associated_torrent().lock().get() == this); if (p->is_seed()) { if (m_picker.get()) { - assert(!is_seed()); + TORRENT_ASSERT(!is_seed()); m_picker->dec_refcount_all(); } } @@ -1487,7 +1487,7 @@ namespace libtorrent #ifndef NDEBUG std::string err = e.what(); #endif - assert(false); + TORRENT_ASSERT(false); }; void torrent::connect_to_url_seed(std::string const& url) @@ -1582,7 +1582,7 @@ namespace libtorrent } catch (std::exception& exc) { - assert(false); + TORRENT_ASSERT(false); }; void torrent::on_name_lookup(asio::error_code const& e, tcp::resolver::iterator host @@ -1667,10 +1667,10 @@ namespace libtorrent try { - assert(m_connections.find(a) == m_connections.end()); + TORRENT_ASSERT(m_connections.find(a) == m_connections.end()); // add the newly connected peer to this torrent's peer list - assert(m_connections.find(a) == m_connections.end()); + TORRENT_ASSERT(m_connections.find(a) == m_connections.end()); m_connections.insert( std::make_pair(a, boost::get_pointer(c))); m_ses.m_connections.insert(std::make_pair(s, c)); @@ -1698,7 +1698,7 @@ namespace libtorrent #ifndef NDEBUG std::cerr << exc.what() << std::endl; #endif - assert(false); + TORRENT_ASSERT(false); }; #ifndef TORRENT_DISABLE_RESOLVE_COUNTRIES @@ -1838,22 +1838,22 @@ namespace libtorrent { INVARIANT_CHECK; - assert(peerinfo); - assert(peerinfo->connection == 0); + TORRENT_ASSERT(peerinfo); + TORRENT_ASSERT(peerinfo->connection == 0); #ifndef NDEBUG // this asserts that we don't have duplicates in the policy's peer list peer_iterator i_ = m_connections.find(peerinfo->ip); - assert(i_ == m_connections.end() + TORRENT_ASSERT(i_ == m_connections.end() || i_->second->is_disconnecting() || dynamic_cast(i_->second) == 0 || m_ses.settings().allow_multiple_connections_per_ip); #endif - assert(want_more_peers()); - assert(m_ses.num_connections() < m_ses.max_connections()); + TORRENT_ASSERT(want_more_peers()); + TORRENT_ASSERT(m_ses.num_connections() < m_ses.max_connections()); tcp::endpoint const& a(peerinfo->ip); - assert((m_ses.m_ip_filter.access(a.address()) & ip_filter::blocked) == 0); + TORRENT_ASSERT((m_ses.m_ip_filter.access(a.address()) & ip_filter::blocked) == 0); boost::shared_ptr s = instantiate_connection(m_ses.m_io_service, m_ses.peer_proxy()); @@ -1875,7 +1875,7 @@ namespace libtorrent try { - assert(m_connections.find(a) == m_connections.end()); + TORRENT_ASSERT(m_connections.find(a) == m_connections.end()); // add the newly connected peer to this torrent's peer list m_connections.insert( @@ -1889,7 +1889,7 @@ namespace libtorrent } catch (std::exception& e) { - assert(false); + TORRENT_ASSERT(false); // TODO: post an error alert! std::map::iterator i = m_connections.find(a); if (i != m_connections.end()) m_connections.erase(i); @@ -1905,7 +1905,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(!m_torrent_file->is_valid()); + TORRENT_ASSERT(!m_torrent_file->is_valid()); m_torrent_file->parse_info_section(metadata); init(); @@ -1922,7 +1922,7 @@ namespace libtorrent typedef session_impl::torrent_map torrent_map; torrent_map::iterator i = m_ses.m_torrents.find( m_torrent_file->info_hash()); - assert(i != m_ses.m_torrents.end()); + TORRENT_ASSERT(i != m_ses.m_torrents.end()); m_ses.m_torrents.erase(i); // and notify the thread that it got another // job in its queue @@ -1939,14 +1939,14 @@ namespace libtorrent { // INVARIANT_CHECK; - assert(p != 0); - assert(!p->is_local()); + TORRENT_ASSERT(p != 0); + TORRENT_ASSERT(!p->is_local()); std::map::iterator c = m_connections.find(p->remote()); if (c != m_connections.end()) { - assert(p != c->second); + TORRENT_ASSERT(p != c->second); // we already have a peer_connection to this ip. // It may currently be waiting for completing a // connection attempt that might fail. So, @@ -1970,7 +1970,7 @@ namespace libtorrent throw protocol_error("session is closing"); } - assert(m_connections.find(p->remote()) == m_connections.end()); + TORRENT_ASSERT(m_connections.find(p->remote()) == m_connections.end()); peer_iterator ci = m_connections.insert( std::make_pair(p->remote(), p)).first; try @@ -1986,8 +1986,8 @@ namespace libtorrent if (pp) p->add_extension(pp); } #endif - assert(connection_for(p->remote()) == p); - assert(ci->second == p); + TORRENT_ASSERT(connection_for(p->remote()) == p); + TORRENT_ASSERT(ci->second == p); m_policy->new_connection(*ci->second); } catch (std::exception& e) @@ -1995,7 +1995,7 @@ namespace libtorrent m_connections.erase(ci); throw; } - assert(p->remote() == p->get_socket()->remote_endpoint()); + TORRENT_ASSERT(p->remote() == p->get_socket()->remote_endpoint()); #ifndef NDEBUG m_policy->check_invariant(); @@ -2018,7 +2018,7 @@ namespace libtorrent while (!m_connections.empty()) { peer_connection& p = *m_connections.begin()->second; - assert(p.associated_torrent().lock().get() == this); + TORRENT_ASSERT(p.associated_torrent().lock().get() == this); #if defined(TORRENT_VERBOSE_LOGGING) if (m_abort) @@ -2030,7 +2030,7 @@ namespace libtorrent std::size_t size = m_connections.size(); #endif p.disconnect(); - assert(m_connections.size() <= size); + TORRENT_ASSERT(m_connections.size() <= size); } } @@ -2043,7 +2043,7 @@ namespace libtorrent , boost::intrusive_ptr const& p , bool non_prioritized) { - assert(m_bandwidth_limit[channel].throttle() > 0); + TORRENT_ASSERT(m_bandwidth_limit[channel].throttle() > 0); int block_size = m_bandwidth_limit[channel].throttle() / 10; if (block_size <= 0) block_size = 1; @@ -2066,7 +2066,7 @@ namespace libtorrent { session_impl::mutex_t::scoped_lock l(m_ses.m_mutex); - assert(amount > 0); + TORRENT_ASSERT(amount > 0); m_bandwidth_limit[channel].expire(amount); while (!m_bandwidth_queue[channel].empty()) @@ -2094,8 +2094,8 @@ namespace libtorrent { session_impl::mutex_t::scoped_lock l(m_ses.m_mutex); - assert(amount > 0); - assert(amount <= blk); + TORRENT_ASSERT(amount > 0); + TORRENT_ASSERT(amount <= blk); if (amount < blk) expire_bandwidth(channel, blk - amount); } @@ -2119,7 +2119,7 @@ namespace libtorrent for (peer_iterator i = m_connections.begin(); i != m_connections.end(); ++i) { - assert(i->second->associated_torrent().lock().get() == this); + TORRENT_ASSERT(i->second->associated_torrent().lock().get() == this); if (i->second->is_seed()) { #if defined(TORRENT_VERBOSE_LOGGING) @@ -2131,7 +2131,7 @@ namespace libtorrent std::for_each(seeds.begin(), seeds.end() , bind(&peer_connection::disconnect, _1)); - assert(m_storage); + TORRENT_ASSERT(m_storage); // we need to keep the object alive during this operation m_storage->async_release_files( bind(&torrent::on_files_released, shared_from_this(), _1, _2)); @@ -2155,7 +2155,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(index >= 0); + TORRENT_ASSERT(index >= 0); if (index >= (int)m_trackers.size()) return (int)m_trackers.size()-1; while (index > 0 && m_trackers[index].tier == m_trackers[index-1].tier) @@ -2210,12 +2210,12 @@ namespace libtorrent { INVARIANT_CHECK; - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); bool done = true; try { - assert(m_storage); - assert(m_owning_storage.get()); + TORRENT_ASSERT(m_storage); + TORRENT_ASSERT(m_owning_storage.get()); done = m_storage->check_fastresume(data, m_have_pieces, m_num_pieces , m_compact_mode); } @@ -2239,15 +2239,15 @@ namespace libtorrent std::pair torrent::check_files() { - assert(m_torrent_file->is_valid()); + TORRENT_ASSERT(m_torrent_file->is_valid()); INVARIANT_CHECK; - assert(m_owning_storage.get()); + TORRENT_ASSERT(m_owning_storage.get()); std::pair progress(true, 1.f); try { - assert(m_storage); + TORRENT_ASSERT(m_storage); progress = m_storage->check_files(m_have_pieces, m_num_pieces , m_ses.m_mutex); } @@ -2275,7 +2275,7 @@ namespace libtorrent { session_impl::mutex_t::scoped_lock l(m_ses.m_mutex); - assert(m_torrent_file->is_valid()); + TORRENT_ASSERT(m_torrent_file->is_valid()); INVARIANT_CHECK; if (!is_seed()) @@ -2379,7 +2379,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_owning_storage.get()); + TORRENT_ASSERT(m_owning_storage.get()); return *m_owning_storage; } @@ -2413,53 +2413,53 @@ namespace libtorrent if (!p.is_choked()) ++num_uploads; torrent* associated_torrent = p.associated_torrent().lock().get(); if (associated_torrent != this) - assert(false); + TORRENT_ASSERT(false); } - assert(num_uploads == m_num_uploads); + TORRENT_ASSERT(num_uploads == m_num_uploads); if (has_picker()) { for (std::map::iterator i = num_requests.begin() , end(num_requests.end()); i != end; ++i) { - assert(m_picker->num_peers(i->first) == i->second); + TORRENT_ASSERT(m_picker->num_peers(i->first) == i->second); } } if (valid_metadata()) { - assert(m_abort || int(m_have_pieces.size()) == m_torrent_file->num_pieces()); + TORRENT_ASSERT(m_abort || int(m_have_pieces.size()) == m_torrent_file->num_pieces()); } else { - assert(m_abort || m_have_pieces.empty()); + TORRENT_ASSERT(m_abort || m_have_pieces.empty()); } /* for (policy::const_iterator i = m_policy->begin_peer() , end(m_policy->end_peer()); i != end; ++i) { - assert(i->connection == const_cast(this)->connection_for(i->ip)); + TORRENT_ASSERT(i->connection == const_cast(this)->connection_for(i->ip)); } */ size_type total_done = quantized_bytes_done(); if (m_torrent_file->is_valid()) { if (is_seed()) - assert(total_done == m_torrent_file->total_size()); + TORRENT_ASSERT(total_done == m_torrent_file->total_size()); else - assert(total_done != m_torrent_file->total_size()); + TORRENT_ASSERT(total_done != m_torrent_file->total_size()); } else { - assert(total_done == 0); + TORRENT_ASSERT(total_done == 0); } // This check is very expensive. - assert(m_num_pieces + TORRENT_ASSERT(m_num_pieces == std::count(m_have_pieces.begin(), m_have_pieces.end(), true)); - assert(!valid_metadata() || m_block_size > 0); - assert(!valid_metadata() || (m_torrent_file->piece_length() % m_block_size) == 0); -// if (is_seed()) assert(m_picker.get() == 0); + TORRENT_ASSERT(!valid_metadata() || m_block_size > 0); + TORRENT_ASSERT(!valid_metadata() || (m_torrent_file->piece_length() % m_block_size) == 0); +// if (is_seed()) TORRENT_ASSERT(m_picker.get() == 0); } #endif @@ -2478,21 +2478,21 @@ namespace libtorrent void torrent::set_max_uploads(int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (limit <= 0) limit = (std::numeric_limits::max)(); m_max_uploads = limit; } void torrent::set_max_connections(int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (limit <= 0) limit = (std::numeric_limits::max)(); m_max_connections = limit; } void torrent::set_peer_upload_limit(tcp::endpoint ip, int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); peer_connection* p = connection_for(ip); if (p == 0) return; p->set_upload_limit(limit); @@ -2500,7 +2500,7 @@ namespace libtorrent void torrent::set_peer_download_limit(tcp::endpoint ip, int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); peer_connection* p = connection_for(ip); if (p == 0) return; p->set_download_limit(limit); @@ -2508,7 +2508,7 @@ namespace libtorrent void torrent::set_upload_limit(int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (limit <= 0) limit = (std::numeric_limits::max)(); if (limit < num_peers() * 10) limit = num_peers() * 10; m_bandwidth_limit[peer_connection::upload_channel].throttle(limit); @@ -2523,7 +2523,7 @@ namespace libtorrent void torrent::set_download_limit(int limit) { - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (limit <= 0) limit = (std::numeric_limits::max)(); if (limit < num_peers() * 10) limit = num_peers() * 10; m_bandwidth_limit[peer_connection::download_channel].throttle(limit); @@ -2567,7 +2567,7 @@ namespace libtorrent // files and flush all cached data if (m_owning_storage.get()) { - assert(m_storage); + TORRENT_ASSERT(m_storage); m_storage->async_release_files( bind(&torrent::on_torrent_paused, shared_from_this(), _1, _2)); } @@ -2682,7 +2682,7 @@ namespace libtorrent bool torrent::try_connect_peer() { - assert(want_more_peers()); + TORRENT_ASSERT(want_more_peers()); return m_policy->connect_one_peer(); } @@ -2690,11 +2690,11 @@ namespace libtorrent { INVARIANT_CHECK; - assert(m_storage); - assert(m_storage->refcount() > 0); - assert(piece_index >= 0); - assert(piece_index < m_torrent_file->num_pieces()); - assert(piece_index < (int)m_have_pieces.size()); + TORRENT_ASSERT(m_storage); + TORRENT_ASSERT(m_storage->refcount() > 0); + TORRENT_ASSERT(piece_index >= 0); + TORRENT_ASSERT(piece_index < m_torrent_file->num_pieces()); + TORRENT_ASSERT(piece_index < (int)m_have_pieces.size()); m_storage->async_hash(piece_index, bind(&torrent::on_piece_verified , shared_from_this(), _1, _2, f)); @@ -2718,7 +2718,7 @@ namespace libtorrent void torrent::file_progress(std::vector& fp) const { - assert(valid_metadata()); + TORRENT_ASSERT(valid_metadata()); fp.clear(); fp.resize(m_torrent_file->num_files(), 0.f); @@ -2746,7 +2746,7 @@ namespace libtorrent ret.start = 0; size -= bytes_step; } - assert(size == 0); + TORRENT_ASSERT(size == 0); fp[i] = static_cast(done) / m_torrent_file->file_at(i).size; } @@ -2756,7 +2756,7 @@ namespace libtorrent { INVARIANT_CHECK; - assert(std::accumulate( + TORRENT_ASSERT(std::accumulate( m_have_pieces.begin() , m_have_pieces.end() , 0) == m_num_pieces); @@ -2852,7 +2852,7 @@ namespace libtorrent st.total_wanted -= filtered_pieces * m_torrent_file->piece_length(); } - assert(st.total_wanted >= st.total_wanted_done); + TORRENT_ASSERT(st.total_wanted >= st.total_wanted_done); if (st.total_wanted == 0) st.progress = 1.f; else st.progress = st.total_wanted_done @@ -2867,7 +2867,7 @@ namespace libtorrent } else if (is_seed()) { - assert(st.total_done == m_torrent_file->total_size()); + TORRENT_ASSERT(st.total_done == m_torrent_file->total_size()); st.state = torrent_status::seeding; } else if (st.total_wanted_done == st.total_wanted) diff --git a/libtorrent/src/torrent_handle.cpp b/libtorrent/src/torrent_handle.cpp index d52a18dd2..f6b5d47de 100755 --- a/libtorrent/src/torrent_handle.cpp +++ b/libtorrent/src/torrent_handle.cpp @@ -111,7 +111,7 @@ namespace libtorrent void torrent_handle::check_invariant() const { - assert((m_ses == 0 && m_chk == 0) || (m_ses != 0 && m_chk != 0)); + TORRENT_ASSERT((m_ses == 0 && m_chk == 0) || (m_ses != 0 && m_chk != 0)); } #endif @@ -121,9 +121,9 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); - assert(max_uploads >= 2 || max_uploads == -1); + TORRENT_ASSERT(max_uploads >= 2 || max_uploads == -1); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -135,7 +135,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -147,9 +147,9 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); - assert(max_connections >= 2 || max_connections == -1); + TORRENT_ASSERT(max_connections >= 2 || max_connections == -1); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -159,10 +159,10 @@ namespace libtorrent void torrent_handle::set_peer_upload_limit(tcp::endpoint ip, int limit) const { INVARIANT_CHECK; - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -172,10 +172,10 @@ namespace libtorrent void torrent_handle::set_peer_download_limit(tcp::endpoint ip, int limit) const { INVARIANT_CHECK; - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -187,9 +187,9 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -201,7 +201,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -213,9 +213,9 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); - assert(limit >= -1); + TORRENT_ASSERT(limit >= -1); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -227,7 +227,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -240,7 +240,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -252,7 +252,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -264,7 +264,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -276,7 +276,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -288,7 +288,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -300,7 +300,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -313,7 +313,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -325,7 +325,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -355,7 +355,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -391,7 +391,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -403,7 +403,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -416,7 +416,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -428,7 +428,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -440,7 +440,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -452,7 +452,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -464,7 +464,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); std::vector ret; session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); @@ -478,7 +478,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -492,7 +492,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -504,7 +504,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -516,7 +516,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -528,7 +528,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); std::vector ret; session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); @@ -542,7 +542,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -557,7 +557,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -569,7 +569,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -581,7 +581,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -593,7 +593,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -606,7 +606,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -618,7 +618,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -632,7 +632,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) return false; - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -653,7 +653,7 @@ namespace libtorrent std::vector piece_index; if (m_ses == 0) return entry(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); boost::shared_ptr t = m_ses->find_torrent(m_info_hash).lock(); @@ -718,11 +718,11 @@ namespace libtorrent v |= (i->info[j*8+k].state == piece_picker::block_info::state_finished) ? (1 << k) : 0; bitmask.insert(bitmask.end(), v); - assert(bits == 8 || j == num_bitmask_bytes - 1); + TORRENT_ASSERT(bits == 8 || j == num_bitmask_bytes - 1); } piece_struct["bitmask"] = bitmask; - assert(t->filesystem().slot_for_piece(i->index) >= 0); + TORRENT_ASSERT(t->filesystem().slot_for_piece(i->index) >= 0); unsigned long adler = t->filesystem().piece_crc( t->filesystem().slot_for_piece(i->index) @@ -781,7 +781,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -793,7 +793,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); boost::shared_ptr t = m_ses->find_torrent(m_info_hash).lock(); @@ -822,7 +822,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); boost::shared_ptr t = m_ses->find_torrent(m_info_hash).lock(); @@ -837,7 +837,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); boost::shared_ptr t = m_ses->find_torrent(m_info_hash).lock(); @@ -851,9 +851,9 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); - assert(ratio >= 0.f); + TORRENT_ASSERT(ratio >= 0.f); if (ratio < 1.f && ratio > 0.f) ratio = 1.f; @@ -868,7 +868,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -880,7 +880,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex); @@ -893,7 +893,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); v.clear(); @@ -927,7 +927,7 @@ namespace libtorrent INVARIANT_CHECK; if (m_ses == 0) throw_invalid_handle(); - assert(m_chk); + TORRENT_ASSERT(m_chk); session_impl::mutex_t::scoped_lock l(m_ses->m_mutex); boost::shared_ptr t = m_ses->find_torrent(m_info_hash).lock(); @@ -981,7 +981,7 @@ namespace libtorrent if (pbp && pbp->piece_index == i->index && pbp->block_index == j) { bi.bytes_progress = pbp->bytes_downloaded; - assert(bi.bytes_progress <= bi.block_size); + TORRENT_ASSERT(bi.bytes_progress <= bi.block_size); } else { diff --git a/libtorrent/src/torrent_info.cpp b/libtorrent/src/torrent_info.cpp index 76c10e572..3d30dadd5 100755 --- a/libtorrent/src/torrent_info.cpp +++ b/libtorrent/src/torrent_info.cpp @@ -208,7 +208,7 @@ namespace /* void remove_dir(fs::path& p) { - assert(p.begin() != p.end()); + TORRENT_ASSERT(p.begin() != p.end()); path tmp; for (path::iterator i = boost::next(p.begin()); i != p.end(); ++i) tmp /= *i; @@ -311,12 +311,12 @@ namespace libtorrent { if (size & (1 << i)) { - assert((size & ~(1 << i)) == 0); + TORRENT_ASSERT((size & ~(1 << i)) == 0); break; } } #endif - assert(!m_half_metadata); + TORRENT_ASSERT(!m_half_metadata); m_piece_length = size; m_num_pieces = static_cast( @@ -420,7 +420,7 @@ namespace libtorrent std::vector info_section_buf; entry gen_info_section = create_info_metadata(); bencode(std::back_inserter(info_section_buf), gen_info_section); - assert(hasher(&info_section_buf[0], info_section_buf.size()).final() + TORRENT_ASSERT(hasher(&info_section_buf[0], info_section_buf.size()).final() == m_info_hash); #endif } @@ -554,7 +554,7 @@ namespace libtorrent void torrent_info::add_file(fs::path file, size_type size) { -// assert(file.begin() != file.end()); +// TORRENT_ASSERT(file.begin() != file.end()); if (!file.has_branch_path()) { @@ -562,15 +562,15 @@ namespace libtorrent // 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. - assert(m_files.empty()); - assert(!m_multifile); + TORRENT_ASSERT(m_files.empty()); + TORRENT_ASSERT(!m_multifile); m_name = file.string(); } else { #ifndef NDEBUG if (!m_files.empty()) - assert(m_name == *file.begin()); + TORRENT_ASSERT(m_name == *file.begin()); #endif m_multifile = true; m_name = *file.begin(); @@ -616,7 +616,7 @@ namespace libtorrent entry torrent_info::create_info_metadata() const { // you have to add files to the torrent first - assert(!m_files.empty()); + TORRENT_ASSERT(!m_files.empty()); entry info(m_extra_info); @@ -644,8 +644,8 @@ namespace libtorrent fs::path const* file_path; if (i->orig_path) file_path = &(*i->orig_path); else file_path = &i->path; - assert(file_path->has_branch_path()); - assert(*file_path->begin() == m_name); + TORRENT_ASSERT(file_path->has_branch_path()); + TORRENT_ASSERT(*file_path->begin() == m_name); for (fs::path::iterator j = boost::next(file_path->begin()); j != file_path->end(); ++j) @@ -672,7 +672,7 @@ namespace libtorrent entry torrent_info::create_torrent() const { - assert(m_piece_length > 0); + TORRENT_ASSERT(m_piece_length > 0); if (m_files.empty()) { @@ -760,14 +760,14 @@ namespace libtorrent void torrent_info::set_hash(int index, const sha1_hash& h) { - assert(index >= 0); - assert(index < (int)m_piece_hash.size()); + TORRENT_ASSERT(index >= 0); + TORRENT_ASSERT(index < (int)m_piece_hash.size()); m_piece_hash[index] = h; } void torrent_info::convert_file_names() { - assert(false); + TORRENT_ASSERT(false); } void torrent_info::seed_free() @@ -806,13 +806,13 @@ namespace libtorrent size_type torrent_info::piece_size(int index) const { - assert(index >= 0 && index < num_pieces()); + TORRENT_ASSERT(index >= 0 && index < num_pieces()); if (index == num_pieces()-1) { size_type size = total_size() - (num_pieces() - 1) * piece_length(); - assert(size > 0); - assert(size <= piece_length()); + TORRENT_ASSERT(size > 0); + TORRENT_ASSERT(size <= piece_length()); return size; } else @@ -852,11 +852,11 @@ namespace libtorrent std::vector torrent_info::map_block(int piece, size_type offset , int size, bool storage) const { - assert(num_files() > 0); + TORRENT_ASSERT(num_files() > 0); std::vector ret; size_type start = piece * (size_type)m_piece_length + offset; - assert(start + size <= m_total_size); + TORRENT_ASSERT(start + size <= m_total_size); // find the file iterator and file offset // TODO: make a vector that can map piece -> file index in O(1) @@ -866,7 +866,7 @@ namespace libtorrent int counter = 0; for (file_iter = begin_files(storage);; ++counter, ++file_iter) { - assert(file_iter != end_files(storage)); + TORRENT_ASSERT(file_iter != end_files(storage)); if (file_offset < file_iter->size) { file_slice f; @@ -878,7 +878,7 @@ namespace libtorrent ret.push_back(f); } - assert(size >= 0); + TORRENT_ASSERT(size >= 0); if (size <= 0) break; file_offset -= file_iter->size; @@ -889,8 +889,8 @@ namespace libtorrent peer_request torrent_info::map_file(int file_index, size_type file_offset , int size, bool storage) const { - assert(file_index < num_files(storage)); - assert(file_index >= 0); + TORRENT_ASSERT(file_index < num_files(storage)); + TORRENT_ASSERT(file_index >= 0); size_type offset = file_offset + file_at(file_index, storage).offset; peer_request ret; diff --git a/libtorrent/src/tracker_manager.cpp b/libtorrent/src/tracker_manager.cpp index 981eb4caf..37dd941eb 100755 --- a/libtorrent/src/tracker_manager.cpp +++ b/libtorrent/src/tracker_manager.cpp @@ -84,8 +84,8 @@ namespace libtorrent // returns -1 if gzip header is invalid or the header size in bytes int gzip_header(const char* buf, int size) { - assert(buf != 0); - assert(size > 0); + TORRENT_ASSERT(buf != 0); + TORRENT_ASSERT(size > 0); const unsigned char* buffer = reinterpret_cast(buf); const int total_size = size; @@ -162,7 +162,7 @@ namespace libtorrent , request_callback* requester , int maximum_tracker_response_length) { - assert(maximum_tracker_response_length > 0); + TORRENT_ASSERT(maximum_tracker_response_length > 0); int header_len = gzip_header(&buffer[0], (int)buffer.size()); if (header_len < 0) @@ -349,7 +349,7 @@ namespace libtorrent } catch (std::exception& e) { - assert(false); + TORRENT_ASSERT(false); } tracker_connection::tracker_connection( @@ -490,11 +490,11 @@ namespace libtorrent , boost::weak_ptr c) { mutex_t::scoped_lock l(m_mutex); - assert(req.num_want >= 0); + TORRENT_ASSERT(req.num_want >= 0); if (req.event == tracker_request::stopped) req.num_want = 0; - assert(!m_abort || req.event == tracker_request::stopped); + TORRENT_ASSERT(!m_abort || req.event == tracker_request::stopped); if (m_abort && req.event != tracker_request::stopped) return; diff --git a/libtorrent/src/udp_tracker_connection.cpp b/libtorrent/src/udp_tracker_connection.cpp index cd500d98c..1ba50b3c6 100755 --- a/libtorrent/src/udp_tracker_connection.cpp +++ b/libtorrent/src/udp_tracker_connection.cpp @@ -126,7 +126,7 @@ namespace libtorrent != bind_interface().is_v4(); ++target); if (target == end) { - assert(target_address.address().is_v4() != bind_interface().is_v4()); + TORRENT_ASSERT(target_address.address().is_v4() != bind_interface().is_v4()); if (cb) { std::string tracker_address_type = target_address.address().is_v4() ? "IPv4" : "IPv6"; diff --git a/libtorrent/src/upnp.cpp b/libtorrent/src/upnp.cpp index f1ee92636..4bdc20987 100644 --- a/libtorrent/src/upnp.cpp +++ b/libtorrent/src/upnp.cpp @@ -222,7 +222,7 @@ try #ifndef NDEBUG catch (std::exception&) { - assert(false); + TORRENT_ASSERT(false); }; #endif @@ -413,7 +413,7 @@ try #ifndef NDEBUG catch (std::exception&) { - assert(false); + TORRENT_ASSERT(false); }; #endif @@ -476,8 +476,8 @@ void upnp::map_port(rootdevice& d, int i) return; } d.mapping[i].need_update = false; - assert(!d.upnp_connection); - assert(d.service_namespace); + TORRENT_ASSERT(!d.upnp_connection); + TORRENT_ASSERT(d.service_namespace); d.upnp_connection.reset(new http_connection(m_io_service , m_cc, m_strand.wrap(bind(&upnp::on_upnp_map_response, self(), _1, _2 diff --git a/libtorrent/src/ut_pex.cpp b/libtorrent/src/ut_pex.cpp index 18fe715ee..071407005 100644 --- a/libtorrent/src/ut_pex.cpp +++ b/libtorrent/src/ut_pex.cpp @@ -304,7 +304,7 @@ namespace libtorrent { namespace std::copy(pex_msg.begin(), pex_msg.end(), i.begin); i.begin += pex_msg.size(); - assert(i.begin == i.end); + TORRENT_ASSERT(i.begin == i.end); m_pc.setup_send(); } @@ -367,7 +367,7 @@ namespace libtorrent { namespace std::copy(pex_msg.begin(), pex_msg.end(), i.begin); i.begin += pex_msg.size(); - assert(i.begin == i.end); + TORRENT_ASSERT(i.begin == i.end); m_pc.setup_send(); } diff --git a/libtorrent/src/web_peer_connection.cpp b/libtorrent/src/web_peer_connection.cpp index bc09b4935..21208454e 100755 --- a/libtorrent/src/web_peer_connection.cpp +++ b/libtorrent/src/web_peer_connection.cpp @@ -75,7 +75,7 @@ namespace libtorrent // we only want left-over bandwidth set_non_prioritized(true); shared_ptr tor = t.lock(); - assert(tor); + TORRENT_ASSERT(tor); int blocks_per_piece = tor->torrent_file().piece_length() / tor->block_size(); // we always prefer downloading 1 MB chunks @@ -115,7 +115,7 @@ namespace libtorrent return boost::optional(); boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); piece_block_progress ret; @@ -148,7 +148,7 @@ namespace libtorrent void web_peer_connection::on_connected() { boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); // this is always a seed incoming_bitfield(std::vector( @@ -164,9 +164,9 @@ namespace libtorrent INVARIANT_CHECK; boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); - assert(t->valid_metadata()); + TORRENT_ASSERT(t->valid_metadata()); bool single_file_request = false; if (!m_path.empty() && m_path[m_path.size() - 1] != '/') @@ -288,7 +288,7 @@ namespace libtorrent request += "\r\nConnection: keep-alive"; request += "\r\n\r\n"; m_first_request = false; - assert(f.file_index >= 0); + TORRENT_ASSERT(f.file_index >= 0); m_file_requests.push_back(f.file_index); } } @@ -329,7 +329,7 @@ namespace libtorrent } boost::shared_ptr t = associated_torrent().lock(); - assert(t); + TORRENT_ASSERT(t); incoming_piece_fragment(); @@ -345,9 +345,9 @@ namespace libtorrent boost::tie(payload, protocol) = m_parser.incoming(recv_buffer); m_statistics.received_bytes(payload, protocol); - assert(recv_buffer.left() == 0 || *recv_buffer.begin == 'H'); + TORRENT_ASSERT(recv_buffer.left() == 0 || *recv_buffer.begin == 'H'); - assert(recv_buffer.left() <= packet_size()); + TORRENT_ASSERT(recv_buffer.left() <= packet_size()); // this means the entire status line hasn't been received yet if (m_parser.status_code() == -1) break; @@ -403,7 +403,7 @@ namespace libtorrent // add the redirected url and remove the current one if (!single_file_request) { - assert(!m_file_requests.empty()); + TORRENT_ASSERT(!m_file_requests.empty()); int file_index = m_file_requests.front(); torrent_info const& info = t->torrent_file(); @@ -493,7 +493,7 @@ namespace libtorrent // skip the http header and the blocks we've already read. The // http_body.begin is now in sync with the request at the front // of the request queue -// assert(in_range.start - int(m_piece.size()) <= front_request.start); +// TORRENT_ASSERT(in_range.start - int(m_piece.size()) <= front_request.start); // the http response body consists of 3 parts // 1. the middle of a block or the ending of a block @@ -520,14 +520,14 @@ namespace libtorrent int copy_size = (std::min)((std::min)(front_request.length - piece_size , recv_buffer.left()), int(range_end - range_start - m_received_body)); m_piece.resize(piece_size + copy_size); - assert(copy_size > 0); + TORRENT_ASSERT(copy_size > 0); std::memcpy(&m_piece[0] + piece_size, recv_buffer.begin, copy_size); - assert(int(m_piece.size()) <= front_request.length); + TORRENT_ASSERT(int(m_piece.size()) <= front_request.length); recv_buffer.begin += copy_size; m_received_body += copy_size; m_body_start += copy_size; - assert(m_received_body <= range_end - range_start); - assert(int(m_piece.size()) <= front_request.length); + TORRENT_ASSERT(m_received_body <= range_end - range_start); + TORRENT_ASSERT(int(m_piece.size()) <= front_request.length); if (int(m_piece.size()) == front_request.length) { // each call to incoming_piece() may result in us becoming @@ -541,9 +541,9 @@ namespace libtorrent cut_receive_buffer(m_body_start, t->block_size() + 1024); m_body_start = 0; recv_buffer = receive_buffer(); - assert(m_received_body <= range_end - range_start); + TORRENT_ASSERT(m_received_body <= range_end - range_start); m_piece.clear(); - assert(m_piece.empty()); + TORRENT_ASSERT(m_piece.empty()); } } @@ -554,13 +554,13 @@ namespace libtorrent { peer_request r = m_requests.front(); m_requests.pop_front(); - assert(recv_buffer.left() >= r.length); + TORRENT_ASSERT(recv_buffer.left() >= r.length); incoming_piece(r, recv_buffer.begin); if (associated_torrent().expired()) return; m_received_body += r.length; - assert(receive_buffer().begin + m_body_start == recv_buffer.begin); - assert(m_received_body <= range_end - range_start); + TORRENT_ASSERT(receive_buffer().begin + m_body_start == recv_buffer.begin); + TORRENT_ASSERT(m_received_body <= range_end - range_start); cut_receive_buffer(r.length + m_body_start, t->block_size() + 1024); m_body_start = 0; recv_buffer = receive_buffer(); @@ -577,7 +577,7 @@ namespace libtorrent int piece_size = int(m_piece.size()); int copy_size = (std::min)((std::min)(m_requests.front().length - piece_size , recv_buffer.left()), int(range_end - range_start - m_received_body)); - assert(copy_size >= 0); + TORRENT_ASSERT(copy_size >= 0); if (copy_size > 0) { m_piece.resize(piece_size + copy_size); @@ -586,11 +586,11 @@ namespace libtorrent m_received_body += copy_size; m_body_start += copy_size; } - assert(m_received_body == range_end - range_start); + TORRENT_ASSERT(m_received_body == range_end - range_start); } } - assert(m_received_body <= range_end - range_start); + TORRENT_ASSERT(m_received_body <= range_end - range_start); if (m_received_body == range_end - range_start) { cut_receive_buffer(recv_buffer.begin - receive_buffer().begin @@ -642,7 +642,7 @@ namespace libtorrent void web_peer_connection::check_invariant() const { /* - assert(m_num_pieces == std::count( + TORRENT_ASSERT(m_num_pieces == std::count( m_have_piece.begin() , m_have_piece.end() , true));