codex-storage
/
deluge
mirror of https://github.com/codex-storage/deluge.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

sync with asio 1.0 release and update lt 2147

This commit is contained in:
Marcos Pinto 2008-04-06 21:12:32 +00:00
parent 642569f4bc
commit fecd9132ce
29 changed files with 164 additions and 183 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
libtorrent/include/asio/detail/socket_ops.hpp
View File

@ -698,40 +698,40 @@ inline const char* inet_ntop(int af, const void* src, char* dest, size_t length,
return 0; return 0;
} }
sockaddr_storage_type address; union
{
socket_addr_type base;
sockaddr_storage_type storage;
sockaddr_in4_type v4;
sockaddr_in6_type v6;
} address;
DWORD address_length; DWORD address_length;
if (af == AF_INET) if (af == AF_INET)
{ {
address_length = sizeof(sockaddr_in4_type); address_length = sizeof(sockaddr_in4_type);
sockaddr_in4_type* ipv4_address = address.v4.sin_family = AF_INET;
reinterpret_cast<sockaddr_in4_type*>(&address); address.v4.sin_port = 0;
ipv4_address->sin_family = AF_INET; memcpy(&address.v4.sin_addr, src, sizeof(in4_addr_type));
ipv4_address->sin_port = 0;
memcpy(&ipv4_address->sin_addr, src, sizeof(in4_addr_type));
} }
else // AF_INET6 else // AF_INET6
{ {
address_length = sizeof(sockaddr_in6_type); address_length = sizeof(sockaddr_in6_type);
sockaddr_in6_type* ipv6_address = address.v6.sin6_family = AF_INET6;
reinterpret_cast<sockaddr_in6_type*>(&address); address.v6.sin6_port = 0;
ipv6_address->sin6_family = AF_INET6; address.v6.sin6_flowinfo = 0;
ipv6_address->sin6_port = 0; address.v6.sin6_scope_id = scope_id;
ipv6_address->sin6_flowinfo = 0; memcpy(&address.v6.sin6_addr, src, sizeof(in6_addr_type));
ipv6_address->sin6_scope_id = scope_id;
memcpy(&ipv6_address->sin6_addr, src, sizeof(in6_addr_type));
} }
DWORD string_length = static_cast<DWORD>(length); DWORD string_length = static_cast<DWORD>(length);
#if defined(BOOST_NO_ANSI_APIS) #if defined(BOOST_NO_ANSI_APIS)
LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR)); LPWSTR string_buffer = (LPWSTR)_alloca(length * sizeof(WCHAR));
int result = error_wrapper(::WSAAddressToStringW( int result = error_wrapper(::WSAAddressToStringW(&address.base,
reinterpret_cast<sockaddr*>(&address),
address_length, 0, string_buffer, &string_length), ec); address_length, 0, string_buffer, &string_length), ec);
::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1, dest, length, 0, 0); ::WideCharToMultiByte(CP_ACP, 0, string_buffer, -1, dest, length, 0, 0);
#else #else
int result = error_wrapper(::WSAAddressToStringA( int result = error_wrapper(::WSAAddressToStringA(
reinterpret_cast<sockaddr*>(&address), &address.base, address_length, 0, dest, &string_length), ec);
address_length, 0, dest, &string_length), ec);
#endif #endif
// Windows may set error code on success. // Windows may set error code on success.
@ -774,30 +774,30 @@ inline int inet_pton(int af, const char* src, void* dest,
return -1; return -1;
} }
sockaddr_storage_type address; union
{
socket_addr_type base;
sockaddr_storage_type storage;
sockaddr_in4_type v4;
sockaddr_in6_type v6;
} address;
int address_length = sizeof(sockaddr_storage_type); int address_length = sizeof(sockaddr_storage_type);
#if defined(BOOST_NO_ANSI_APIS) #if defined(BOOST_NO_ANSI_APIS)
int num_wide_chars = strlen(src) + 1; int num_wide_chars = strlen(src) + 1;
LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR)); LPWSTR wide_buffer = (LPWSTR)_alloca(num_wide_chars * sizeof(WCHAR));
::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars); ::MultiByteToWideChar(CP_ACP, 0, src, -1, wide_buffer, num_wide_chars);
int result = error_wrapper(::WSAStringToAddressW( int result = error_wrapper(::WSAStringToAddressW(
wide_buffer, af, 0, wide_buffer, af, 0, &address.base, &address_length), ec);
reinterpret_cast<sockaddr*>(&address),
&address_length), ec);
#else #else
int result = error_wrapper(::WSAStringToAddressA( int result = error_wrapper(::WSAStringToAddressA(
const_cast<char*>(src), af, 0, const_cast<char*>(src), af, 0, &address.base, &address_length), ec);
reinterpret_cast<sockaddr*>(&address),
&address_length), ec);
#endif #endif
if (af == AF_INET) if (af == AF_INET)
{ {
if (result != socket_error_retval) if (result != socket_error_retval)
{ {
sockaddr_in4_type* ipv4_address = memcpy(dest, &address.v4.sin_addr, sizeof(in4_addr_type));
reinterpret_cast<sockaddr_in4_type*>(&address);
memcpy(dest, &ipv4_address->sin_addr, sizeof(in4_addr_type));
clear_error(ec); clear_error(ec);
} }
else if (strcmp(src, "255.255.255.255") == 0) else if (strcmp(src, "255.255.255.255") == 0)
@ -810,11 +810,9 @@ inline int inet_pton(int af, const char* src, void* dest,
{ {
if (result != socket_error_retval) if (result != socket_error_retval)
{ {
sockaddr_in6_type* ipv6_address = memcpy(dest, &address.v6.sin6_addr, sizeof(in6_addr_type));
reinterpret_cast<sockaddr_in6_type*>(&address);
memcpy(dest, &ipv6_address->sin6_addr, sizeof(in6_addr_type));
if (scope_id) if (scope_id)
*scope_id = ipv6_address->sin6_scope_id; *scope_id = address.v6.sin6_scope_id;
clear_error(ec); clear_error(ec);
} }
} }

6
libtorrent/include/asio/detail/strand_service.hpp
View File

@ -427,10 +427,9 @@ public:
if (impl->current_handler_ == 0) if (impl->current_handler_ == 0)
{ {
// This handler now has the lock, so can be dispatched immediately. // This handler now has the lock, so can be dispatched immediately.
impl->current_handler_ = ptr.get(); impl->current_handler_ = ptr.release();
lock.unlock(); lock.unlock();
this->get_io_service().dispatch(invoke_current_handler(*this, impl)); this->get_io_service().dispatch(invoke_current_handler(*this, impl));
ptr.release();
} }
else else
{ {
@ -467,10 +466,9 @@ public:
if (impl->current_handler_ == 0) if (impl->current_handler_ == 0)
{ {
// This handler now has the lock, so can be dispatched immediately. // This handler now has the lock, so can be dispatched immediately.
impl->current_handler_ = ptr.get(); impl->current_handler_ = ptr.release();
lock.unlock(); lock.unlock();
this->get_io_service().post(invoke_current_handler(*this, impl)); this->get_io_service().post(invoke_current_handler(*this, impl));
ptr.release();
} }
else else
{ {

2
libtorrent/include/asio/detail/win_iocp_io_service.hpp
View File

@ -392,7 +392,7 @@ private:
&timer_thread_, this_thread_id, 0) == 0); &timer_thread_, this_thread_id, 0) == 0);
// Calculate timeout for GetQueuedCompletionStatus call. // Calculate timeout for GetQueuedCompletionStatus call.
DWORD timeout = INFINITE; DWORD timeout = max_timeout;
if (dispatching_timers) if (dispatching_timers)
{ {
asio::detail::mutex::scoped_lock lock(timer_mutex_); asio::detail::mutex::scoped_lock lock(timer_mutex_);

116
libtorrent/include/asio/ip/basic_endpoint.hpp
View File

@ -65,11 +65,9 @@ public:
basic_endpoint() basic_endpoint()
: data_() : data_()
{ {
asio::detail::sockaddr_in4_type& data data_.v4.sin_family = AF_INET;
= reinterpret_cast<asio::detail::sockaddr_in4_type&>(data_); data_.v4.sin_port = 0;
data.sin_family = AF_INET; data_.v4.sin_addr.s_addr = INADDR_ANY;
data.sin_port = 0;
data.sin_addr.s_addr = INADDR_ANY;
} }
/// Construct an endpoint using a port number, specified in the host's byte /// Construct an endpoint using a port number, specified in the host's byte
@ -94,24 +92,20 @@ public:
using namespace std; // For memcpy. using namespace std; // For memcpy.
if (protocol.family() == PF_INET) if (protocol.family() == PF_INET)
{ {
asio::detail::sockaddr_in4_type& data data_.v4.sin_family = AF_INET;
= reinterpret_cast<asio::detail::sockaddr_in4_type&>(data_); data_.v4.sin_port =
data.sin_family = AF_INET;
data.sin_port =
asio::detail::socket_ops::host_to_network_short(port_num); asio::detail::socket_ops::host_to_network_short(port_num);
data.sin_addr.s_addr = INADDR_ANY; data_.v4.sin_addr.s_addr = INADDR_ANY;
} }
else else
{ {
asio::detail::sockaddr_in6_type& data data_.v6.sin6_family = AF_INET6;
= reinterpret_cast<asio::detail::sockaddr_in6_type&>(data_); data_.v6.sin6_port =
data.sin6_family = AF_INET6;
data.sin6_port =
asio::detail::socket_ops::host_to_network_short(port_num); asio::detail::socket_ops::host_to_network_short(port_num);
data.sin6_flowinfo = 0; data_.v6.sin6_flowinfo = 0;
asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT; asio::detail::in6_addr_type tmp_addr = IN6ADDR_ANY_INIT;
data.sin6_addr = tmp_addr; data_.v6.sin6_addr = tmp_addr;
data.sin6_scope_id = 0; data_.v6.sin6_scope_id = 0;
} }
} }
@ -124,27 +118,23 @@ public:
using namespace std; // For memcpy. using namespace std; // For memcpy.
if (addr.is_v4()) if (addr.is_v4())
{ {
asio::detail::sockaddr_in4_type& data data_.v4.sin_family = AF_INET;
= reinterpret_cast<asio::detail::sockaddr_in4_type&>(data_); data_.v4.sin_port =
data.sin_family = AF_INET;
data.sin_port =
asio::detail::socket_ops::host_to_network_short(port_num); asio::detail::socket_ops::host_to_network_short(port_num);
data.sin_addr.s_addr = data_.v4.sin_addr.s_addr =
asio::detail::socket_ops::host_to_network_long( asio::detail::socket_ops::host_to_network_long(
addr.to_v4().to_ulong()); addr.to_v4().to_ulong());
} }
else else
{ {
asio::detail::sockaddr_in6_type& data data_.v6.sin6_family = AF_INET6;
= reinterpret_cast<asio::detail::sockaddr_in6_type&>(data_); data_.v6.sin6_port =
data.sin6_family = AF_INET6;
data.sin6_port =
asio::detail::socket_ops::host_to_network_short(port_num); asio::detail::socket_ops::host_to_network_short(port_num);
data.sin6_flowinfo = 0; data_.v6.sin6_flowinfo = 0;
asio::ip::address_v6 v6_addr = addr.to_v6(); asio::ip::address_v6 v6_addr = addr.to_v6();
asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes(); asio::ip::address_v6::bytes_type bytes = v6_addr.to_bytes();
memcpy(data.sin6_addr.s6_addr, bytes.elems, 16); memcpy(data_.v6.sin6_addr.s6_addr, bytes.elems, 16);
data.sin6_scope_id = v6_addr.scope_id(); data_.v6.sin6_scope_id = v6_addr.scope_id();
} }
} }
@ -164,7 +154,7 @@ public:
/// The protocol associated with the endpoint. /// The protocol associated with the endpoint.
protocol_type protocol() const protocol_type protocol() const
{ {
if (is_v4(data_)) if (is_v4())
return InternetProtocol::v4(); return InternetProtocol::v4();
return InternetProtocol::v6(); return InternetProtocol::v6();
} }
@ -172,19 +162,19 @@ public:
/// Get the underlying endpoint in the native type. /// Get the underlying endpoint in the native type.
data_type* data() data_type* data()
{ {
return reinterpret_cast<data_type*>(&data_); return &data_.base;
} }
/// Get the underlying endpoint in the native type. /// Get the underlying endpoint in the native type.
const data_type* data() const const data_type* data() const
{ {
return reinterpret_cast<const data_type*>(&data_); return &data_.base;
} }
/// Get the underlying size of the endpoint in the native type. /// Get the underlying size of the endpoint in the native type.
std::size_t size() const std::size_t size() const
{ {
if (is_v4(data_)) if (is_v4())
return sizeof(asio::detail::sockaddr_in4_type); return sizeof(asio::detail::sockaddr_in4_type);
else else
return sizeof(asio::detail::sockaddr_in6_type); return sizeof(asio::detail::sockaddr_in6_type);
@ -193,7 +183,7 @@ public:
/// Set the underlying size of the endpoint in the native type. /// Set the underlying size of the endpoint in the native type.
void resize(std::size_t size) void resize(std::size_t size)
{ {
if (size > sizeof(data_)) if (size > sizeof(asio::detail::sockaddr_storage_type))
{ {
asio::system_error e(asio::error::invalid_argument); asio::system_error e(asio::error::invalid_argument);
boost::throw_exception(e); boost::throw_exception(e);
@ -203,24 +193,22 @@ public:
/// Get the capacity of the endpoint in the native type. /// Get the capacity of the endpoint in the native type.
std::size_t capacity() const std::size_t capacity() const
{ {
return sizeof(data_); return sizeof(asio::detail::sockaddr_storage_type);
} }
/// Get the port associated with the endpoint. The port number is always in /// Get the port associated with the endpoint. The port number is always in
/// the host's byte order. /// the host's byte order.
unsigned short port() const unsigned short port() const
{ {
if (is_v4(data_)) if (is_v4())
{ {
return asio::detail::socket_ops::network_to_host_short( return asio::detail::socket_ops::network_to_host_short(
reinterpret_cast<const asio::detail::sockaddr_in4_type&>( data_.v4.sin_port);
data_).sin_port);
} }
else else
{ {
return asio::detail::socket_ops::network_to_host_short( return asio::detail::socket_ops::network_to_host_short(
reinterpret_cast<const asio::detail::sockaddr_in6_type&>( data_.v6.sin6_port);
data_).sin6_port);
} }
} }
@ -228,14 +216,14 @@ public:
/// the host's byte order. /// the host's byte order.
void port(unsigned short port_num) void port(unsigned short port_num)
{ {
if (is_v4(data_)) if (is_v4())
{ {
reinterpret_cast<asio::detail::sockaddr_in4_type&>(data_).sin_port data_.v4.sin_port
= asio::detail::socket_ops::host_to_network_short(port_num); = asio::detail::socket_ops::host_to_network_short(port_num);
} }
else else
{ {
reinterpret_cast<asio::detail::sockaddr_in6_type&>(data_).sin6_port data_.v6.sin6_port
= asio::detail::socket_ops::host_to_network_short(port_num); = asio::detail::socket_ops::host_to_network_short(port_num);
} }
} }
@ -244,23 +232,17 @@ public:
asio::ip::address address() const asio::ip::address address() const
{ {
using namespace std; // For memcpy. using namespace std; // For memcpy.
if (is_v4(data_)) if (is_v4())
{ {
const asio::detail::sockaddr_in4_type& data
= reinterpret_cast<const asio::detail::sockaddr_in4_type&>(
data_);
return asio::ip::address_v4( return asio::ip::address_v4(
asio::detail::socket_ops::network_to_host_long( asio::detail::socket_ops::network_to_host_long(
data.sin_addr.s_addr)); data_.v4.sin_addr.s_addr));
} }
else else
{ {
const asio::detail::sockaddr_in6_type& data
= reinterpret_cast<const asio::detail::sockaddr_in6_type&>(
data_);
asio::ip::address_v6::bytes_type bytes; asio::ip::address_v6::bytes_type bytes;
memcpy(bytes.elems, data.sin6_addr.s6_addr, 16); memcpy(bytes.elems, data_.v6.sin6_addr.s6_addr, 16);
return asio::ip::address_v6(bytes, data.sin6_scope_id); return asio::ip::address_v6(bytes, data_.v6.sin6_scope_id);
} }
} }
@ -298,29 +280,19 @@ public:
private: private:
// Helper function to determine whether the endpoint is IPv4. // Helper function to determine whether the endpoint is IPv4.
#if defined(_AIX) bool is_v4() const
template <typename T, unsigned char (T::*)> struct is_v4_helper {};
template <typename T>
static bool is_v4(const T& ss, is_v4_helper<T, &T::ss_family>* = 0)
{ {
return ss.ss_family == AF_INET; return data_.base.sa_family == AF_INET;
} }
template <typename T>
static bool is_v4(const T& ss, is_v4_helper<T, &T::__ss_family>* = 0)
{
return ss.__ss_family == AF_INET;
}
#else
static bool is_v4(const asio::detail::sockaddr_storage_type& ss)
{
return ss.ss_family == AF_INET;
}
#endif
// The underlying IP socket address. // The underlying IP socket address.
asio::detail::sockaddr_storage_type data_; union data_union
{
asio::detail::socket_addr_type base;
asio::detail::sockaddr_storage_type storage;
asio::detail::sockaddr_in4_type v4;
asio::detail::sockaddr_in6_type v6;
} data_;
}; };
/// Output an endpoint as a string. /// Output an endpoint as a string.

2
libtorrent/include/asio/version.hpp
View File

@ -18,6 +18,6 @@
// ASIO_VERSION % 100 is the sub-minor version // ASIO_VERSION % 100 is the sub-minor version
// ASIO_VERSION / 100 % 1000 is the minor version // ASIO_VERSION / 100 % 1000 is the minor version
// ASIO_VERSION / 100000 is the major version // ASIO_VERSION / 100000 is the major version
#define ASIO_VERSION 309 // 0.3.9 #define ASIO_VERSION 100000 // 1.0.0
#endif // ASIO_VERSION_HPP #endif // ASIO_VERSION_HPP

5
libtorrent/include/libtorrent/bandwidth_manager.hpp
View File

@ -158,7 +158,6 @@ struct bandwidth_manager
INVARIANT_CHECK; INVARIANT_CHECK;
if (m_abort) return; if (m_abort) return;
TORRENT_ASSERT(blk > 0); TORRENT_ASSERT(blk > 0);
TORRENT_ASSERT(!peer->ignore_bandwidth_limits());
// make sure this peer isn't already in line // make sure this peer isn't already in line
// waiting for bandwidth // waiting for bandwidth
@ -264,7 +263,7 @@ private:
catch (std::exception&) {} catch (std::exception&) {}
} }
void hand_out_bandwidth(boost::mutex::scoped_lock& l) throw() void hand_out_bandwidth(boost::mutex::scoped_lock& l)
{ {
TORRENT_ASSERT(l.locked()); TORRENT_ASSERT(l.locked());
// if we're already handing out bandwidth, just return back // if we're already handing out bandwidth, just return back
@ -380,7 +379,7 @@ private:
} }
if (!tmp.empty()) m_queue.insert(m_queue.begin(), tmp.begin(), tmp.end()); if (!tmp.empty()) m_queue.insert(m_queue.begin(), tmp.begin(), tmp.end());
} }
catch (std::exception& e) catch (std::exception&)
{ {
m_in_hand_out_bandwidth = false; m_in_hand_out_bandwidth = false;
throw; throw;

2
libtorrent/include/libtorrent/disk_io_thread.hpp
View File

@ -74,7 +74,7 @@ namespace libtorrent
action_t action; action_t action;
char* buffer; char* buffer;
size_type buffer_size; int buffer_size;
boost::intrusive_ptr<piece_manager> storage; boost::intrusive_ptr<piece_manager> storage;
// arguments used for read and write // arguments used for read and write
int piece, offset; int piece, offset;

8
libtorrent/include/libtorrent/time.hpp
View File

@ -293,13 +293,13 @@ namespace libtorrent
inline int total_seconds(time_duration td) inline int total_seconds(time_duration td)
{ {
return aux::performance_counter_to_microseconds(td.diff) return int(aux::performance_counter_to_microseconds(td.diff)
/ 1000000; / 1000000);
} }
inline int total_milliseconds(time_duration td) inline int total_milliseconds(time_duration td)
{ {
return aux::performance_counter_to_microseconds(td.diff) return int(aux::performance_counter_to_microseconds(td.diff)
/ 1000; / 1000);
} }
inline boost::int64_t total_microseconds(time_duration td) inline boost::int64_t total_microseconds(time_duration td)
{ {

1
libtorrent/include/libtorrent/torrent_handle.hpp
View File

@ -281,7 +281,6 @@ namespace libtorrent
torrent_handle(): m_ses(0), m_chk(0), m_info_hash(0) {} torrent_handle(): m_ses(0), m_chk(0), m_info_hash(0) {}
void get_peer_info(std::vector<peer_info>& v) const; void get_peer_info(std::vector<peer_info>& v) const;
bool send_chat_message(tcp::endpoint ip, std::string message) const;
torrent_status status() const; torrent_status status() const;
void get_download_queue(std::vector<partial_piece_info>& queue) const; void get_download_queue(std::vector<partial_piece_info>& queue) const;

6
libtorrent/include/libtorrent/torrent_info.hpp
View File

@ -198,7 +198,7 @@ namespace libtorrent
const std::vector<announce_entry>& trackers() const { return m_urls; } const std::vector<announce_entry>& trackers() const { return m_urls; }
size_type total_size() const { TORRENT_ASSERT(m_piece_length > 0); return m_total_size; } 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 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; } 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 sha1_hash& info_hash() const { return m_info_hash; }
const std::string& name() const { TORRENT_ASSERT(m_piece_length > 0); return m_name; } const std::string& name() const { TORRENT_ASSERT(m_piece_length > 0); return m_name; }
@ -215,7 +215,7 @@ namespace libtorrent
void convert_file_names(); void convert_file_names();
size_type piece_size(int index) const; int piece_size(int index) const;
const sha1_hash& hash_for_piece(int index) const const sha1_hash& hash_for_piece(int index) const
{ {
@ -267,7 +267,7 @@ namespace libtorrent
// the length of one piece // the length of one piece
// if this is 0, the torrent_info is // if this is 0, the torrent_info is
// in an uninitialized state // in an uninitialized state
size_type m_piece_length; int m_piece_length;
// the sha-1 hashes of each piece // the sha-1 hashes of each piece
std::vector<sha1_hash> m_piece_hash; std::vector<sha1_hash> m_piece_hash;

2
libtorrent/src/alert.cpp
View File

@ -95,7 +95,7 @@ namespace libtorrent {
nsec -= 1000000000; nsec -= 1000000000;
xt.sec += 1; xt.sec += 1;
} }
xt.nsec = nsec; xt.nsec = boost::xtime::xtime_nsec_t(nsec);
if (!m_condition.timed_wait(lock, xt)) return 0; if (!m_condition.timed_wait(lock, xt)) return 0;
TORRENT_ASSERT(!m_alerts.empty()); TORRENT_ASSERT(!m_alerts.empty());
if (m_alerts.empty()) return 0; if (m_alerts.empty()) return 0;

5
libtorrent/src/bt_peer_connection.cpp
View File

@ -1177,6 +1177,7 @@ namespace libtorrent
} }
catch (std::exception& exc) catch (std::exception& exc)
{ {
(void)exc;
#ifdef TORRENT_VERBOSE_LOGGING #ifdef TORRENT_VERBOSE_LOGGING
(*m_logger) << "invalid extended handshake: " << exc.what() << "\n"; (*m_logger) << "invalid extended handshake: " << exc.what() << "\n";
#endif #endif
@ -1208,7 +1209,7 @@ namespace libtorrent
if (listen_port->type() == entry::int_t if (listen_port->type() == entry::int_t
&& peer_info_struct() != 0) && peer_info_struct() != 0)
{ {
t->get_policy().update_peer_port(listen_port->integer() t->get_policy().update_peer_port(int(listen_port->integer())
, peer_info_struct(), peer_info::incoming); , peer_info_struct(), peer_info::incoming);
} }
} }
@ -1224,7 +1225,7 @@ namespace libtorrent
if (entry* reqq = root.find_key("reqq")) if (entry* reqq = root.find_key("reqq"))
{ {
if (reqq->type() == entry::int_t) if (reqq->type() == entry::int_t)
m_max_out_request_queue = reqq->integer(); m_max_out_request_queue = int(reqq->integer());
if (m_max_out_request_queue < 1) if (m_max_out_request_queue < 1)
m_max_out_request_queue = 1; m_max_out_request_queue = 1;
} }

4
libtorrent/src/disk_io_thread.cpp
View File

@ -281,8 +281,8 @@ namespace libtorrent
break; break;
} }
} }
ret = j.storage->read_impl(j.buffer, j.piece, j.offset ret = int(j.storage->read_impl(j.buffer, j.piece, j.offset
, j.buffer_size); , j.buffer_size));
// simulates slow drives // simulates slow drives
// usleep(300); // usleep(300);

2
libtorrent/src/http_connection.cpp
View File

@ -266,7 +266,7 @@ void http_connection::on_read(asio::error_code const& e
{ {
m_parser.incoming(rcv_buf); m_parser.incoming(rcv_buf);
} }
catch (std::exception& e) catch (std::exception&)
{ {
m_timer.cancel(); m_timer.cancel();
m_handler(asio::error::fault, m_parser, 0, 0); m_handler(asio::error::fault, m_parser, 0, 0);

15
libtorrent/src/http_tracker_connection.cpp
View File

@ -222,12 +222,13 @@ namespace libtorrent
if (value.find(' ') != std::string::npos) if (value.find(' ') != std::string::npos)
range_str >> bytes; range_str >> bytes;
range_str >> range_start >> dummy >> range_end; range_str >> range_start >> dummy >> range_end;
if (!range_str || range_end < range_start) if (!range_str || range_end < range_start
|| range_end - range_start + 1 >= (std::numeric_limits<int>::max)())
{ {
throw std::runtime_error("invalid content-range in HTTP response: " + range_str.str()); throw std::runtime_error("invalid content-range in HTTP response: " + range_str.str());
} }
// the http range is inclusive // the http range is inclusive
m_content_length = range_end - range_start + 1; m_content_length = int(range_end - range_start + 1);
} }
TORRENT_ASSERT(m_recv_pos <= (int)recv_buffer.left()); TORRENT_ASSERT(m_recv_pos <= (int)recv_buffer.left());
@ -914,15 +915,15 @@ namespace libtorrent
entry const* complete_ent = scrape_data.find_key("complete"); entry const* complete_ent = scrape_data.find_key("complete");
if (complete_ent && complete_ent->type() == entry::int_t) if (complete_ent && complete_ent->type() == entry::int_t)
complete = complete_ent->integer(); complete = int(complete_ent->integer());
entry const* incomplete_ent = scrape_data.find_key("incomplete"); entry const* incomplete_ent = scrape_data.find_key("incomplete");
if (incomplete_ent && incomplete_ent->type() == entry::int_t) if (incomplete_ent && incomplete_ent->type() == entry::int_t)
incomplete = incomplete_ent->integer(); incomplete = int(incomplete_ent->integer());
entry const* downloaded_ent = scrape_data.find_key("downloaded"); entry const* downloaded_ent = scrape_data.find_key("downloaded");
if (downloaded_ent && downloaded_ent->type() == entry::int_t) if (downloaded_ent && downloaded_ent->type() == entry::int_t)
downloaded = downloaded_ent->integer(); downloaded = int(downloaded_ent->integer());
cb->tracker_scrape_response(tracker_req(), complete cb->tracker_scrape_response(tracker_req(), complete
, incomplete, downloaded); , incomplete, downloaded);
@ -977,10 +978,10 @@ namespace libtorrent
int complete = -1; int complete = -1;
int incomplete = -1; int incomplete = -1;
try { complete = e["complete"].integer(); } try { complete = int(e["complete"].integer()); }
catch(type_error&) {} catch(type_error&) {}
try { incomplete = e["incomplete"].integer(); } try { incomplete = int(e["incomplete"].integer()); }
catch(type_error&) {} catch(type_error&) {}
cb->tracker_response(tracker_req(), peer_list, interval, complete cb->tracker_response(tracker_req(), peer_list, interval, complete

2
libtorrent/src/kademlia/closest_nodes.cpp
View File

@ -112,7 +112,7 @@ void closest_nodes::done()
std::vector<node_entry> results; std::vector<node_entry> results;
int num_results = m_max_results; int num_results = m_max_results;
for (std::vector<result>::iterator i = m_results.begin() for (std::vector<result>::iterator i = m_results.begin()
, end(m_results.end()); i != end && num_results >= 0; ++i) , end(m_results.end()); i != end && num_results > 0; ++i)
{ {
if (i->flags & result::no_id) continue; if (i->flags & result::no_id) continue;
if ((i->flags & result::queried) == 0) continue; if ((i->flags & result::queried) == 0) continue;

4
libtorrent/src/kademlia/traversal_algorithm.cpp
View File

@ -88,7 +88,9 @@ boost::pool<>& traversal_algorithm::allocator() const
void traversal_algorithm::traverse(node_id const& id, udp::endpoint addr) void traversal_algorithm::traverse(node_id const& id, udp::endpoint addr)
{ {
TORRENT_ASSERT(!id.is_all_zeros()); #ifdef TORRENT_DHT_VERBOSE_LOGGING
TORRENT_LOG(traversal) << "node returned a list which included a node with id 0";
#endif
add_entry(id, addr, 0); add_entry(id, addr, 0);
} }

2
libtorrent/src/metadata_transfer.cpp
View File

@ -275,7 +275,7 @@ namespace libtorrent { namespace
entry const& messages = h["m"]; entry const& messages = h["m"];
if (entry const* index = messages.find_key("LT_metadata")) if (entry const* index = messages.find_key("LT_metadata"))
{ {
m_message_index = index->integer(); m_message_index = int(index->integer());
return true; return true;
} }
else else

16
libtorrent/src/peer_connection.cpp
View File

@ -245,7 +245,7 @@ namespace libtorrent
t->get_policy().peer_is_interesting(*this); t->get_policy().peer_is_interesting(*this);
} }
// may throw an asio error if socket has disconnected // may throw an asio error if socket has disconnected
catch (std::exception& e) {} catch (std::exception&) {}
TORRENT_ASSERT(is_interesting() == interested); TORRENT_ASSERT(is_interesting() == interested);
} }
@ -1107,7 +1107,7 @@ namespace libtorrent
"s: " << r.start << " | " "s: " << r.start << " | "
"l: " << r.length << " | " "l: " << r.length << " | "
"i: " << m_peer_interested << " | " "i: " << m_peer_interested << " | "
"t: " << (int)t->torrent_file().piece_size(r.piece) << " | " "t: " << t->torrent_file().piece_size(r.piece) << " | "
"n: " << t->torrent_file().num_pieces() << " ]\n"; "n: " << t->torrent_file().num_pieces() << " ]\n";
#endif #endif
write_reject_request(r); write_reject_request(r);
@ -1127,7 +1127,7 @@ namespace libtorrent
"s: " << r.start << " | " "s: " << r.start << " | "
"l: " << r.length << " | " "l: " << r.length << " | "
"i: " << m_peer_interested << " | " "i: " << m_peer_interested << " | "
"t: " << (int)t->torrent_file().piece_size(r.piece) << " | " "t: " << t->torrent_file().piece_size(r.piece) << " | "
"n: " << t->torrent_file().num_pieces() << " ]\n"; "n: " << t->torrent_file().num_pieces() << " ]\n";
(*m_logger) << time_now_string() (*m_logger) << time_now_string()
@ -1194,7 +1194,7 @@ namespace libtorrent
"s: " << r.start << " | " "s: " << r.start << " | "
"l: " << r.length << " | " "l: " << r.length << " | "
"i: " << m_peer_interested << " | " "i: " << m_peer_interested << " | "
"t: " << (int)t->torrent_file().piece_size(r.piece) << " | " "t: " << t->torrent_file().piece_size(r.piece) << " | "
"n: " << t->torrent_file().num_pieces() << " | " "n: " << t->torrent_file().num_pieces() << " | "
"h: " << t->have_piece(r.piece) << " | " "h: " << t->have_piece(r.piece) << " | "
"block_limit: " << t->block_size() << " ]\n"; "block_limit: " << t->block_size() << " ]\n";
@ -1785,7 +1785,7 @@ namespace libtorrent
int block_offset = block.block_index * t->block_size(); int block_offset = block.block_index * t->block_size();
int block_size int block_size
= (std::min)((int)t->torrent_file().piece_size(block.piece_index)-block_offset, = (std::min)(t->torrent_file().piece_size(block.piece_index)-block_offset,
t->block_size()); t->block_size());
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= t->block_size()); TORRENT_ASSERT(block_size <= t->block_size());
@ -1897,7 +1897,7 @@ namespace libtorrent
piece_block block = m_request_queue.front(); piece_block block = m_request_queue.front();
int block_offset = block.block_index * t->block_size(); int block_offset = block.block_index * t->block_size();
int block_size = (std::min)((int)t->torrent_file().piece_size( int block_size = (std::min)(t->torrent_file().piece_size(
block.piece_index) - block_offset, t->block_size()); block.piece_index) - block_offset, t->block_size());
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= t->block_size()); TORRENT_ASSERT(block_size <= t->block_size());
@ -1943,7 +1943,7 @@ namespace libtorrent
#endif #endif
block_offset = block.block_index * t->block_size(); block_offset = block.block_index * t->block_size();
block_size = (std::min)((int)t->torrent_file().piece_size( block_size = (std::min)(t->torrent_file().piece_size(
block.piece_index) - block_offset, t->block_size()); block.piece_index) - block_offset, t->block_size());
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= t->block_size()); TORRENT_ASSERT(block_size <= t->block_size());
@ -1988,7 +1988,7 @@ namespace libtorrent
void close_socket_ignore_error(boost::shared_ptr<socket_type> s) void close_socket_ignore_error(boost::shared_ptr<socket_type> s)
{ {
try { s->close(); } catch (std::exception& e) {} try { s->close(); } catch (std::exception&) {}
} }
void peer_connection::timed_out() void peer_connection::timed_out()

9
libtorrent/src/policy.cpp
View File

@ -1111,15 +1111,6 @@ namespace libtorrent
if (flags & 0x01) i->second.pe_support = true; if (flags & 0x01) i->second.pe_support = true;
#endif #endif
if (flags & 0x02) i->second.seed = true; if (flags & 0x02) i->second.seed = true;
// try to send a DHT ping to this peer
// as well, to figure out if it supports
// DHT (uTorrent and BitComet doesn't
// advertise support)
#ifndef TORRENT_DISABLE_DHT
udp::endpoint node(remote.address(), remote.port());
m_torrent->session().add_dht_node(node);
#endif
} }
else else
{ {

11
libtorrent/src/session_impl.cpp
View File

@ -1024,6 +1024,15 @@ namespace detail
async_accept(listener); async_accept(listener);
return; return;
} }
#endif
#ifdef TORRENT_BSD
// Leopard sometimes generates an "invalid argument" error. It seems to be
// non-fatal and we have to do another async_accept.
if (e.value() == EINVAL)
{
async_accept(listener);
return;
}
#endif #endif
if (m_alerts.should_post(alert::fatal)) if (m_alerts.should_post(alert::fatal))
{ {
@ -1603,7 +1612,7 @@ namespace detail
nsec -= 1000000000; nsec -= 1000000000;
xt.sec += 1; xt.sec += 1;
} }
xt.nsec = nsec; xt.nsec = boost::xtime::xtime_nsec_t(nsec);
boost::thread::sleep(xt); boost::thread::sleep(xt);
} }

10
libtorrent/src/storage.cpp
View File

@ -541,9 +541,9 @@ namespace libtorrent
for (entry::list_type::iterator i = l.begin(); for (entry::list_type::iterator i = l.begin();
i != l.end(); ++i) i != l.end(); ++i)
{ {
file_sizes.push_back(std::pair<size_type, std::time_t>( file_sizes.push_back(std::make_pair(
i->list().front().integer() i->list().front().integer()
, i->list().back().integer())); , std::time_t(i->list().back().integer())));
} }
if (file_sizes.empty()) if (file_sizes.empty())
@ -818,7 +818,7 @@ namespace libtorrent
== file_iter->path); == file_iter->path);
#endif #endif
size_type actual_read = in->read(buf + buf_pos, read_bytes); int actual_read = int(in->read(buf + buf_pos, read_bytes));
if (read_bytes != actual_read) if (read_bytes != actual_read)
{ {
@ -1702,8 +1702,8 @@ namespace libtorrent
m_piece_data.resize(int(m_info->piece_length())); m_piece_data.resize(int(m_info->piece_length()));
int piece_size = int(m_info->piece_size(m_current_slot)); int piece_size = int(m_info->piece_size(m_current_slot));
int num_read = m_storage->read(&m_piece_data[0] int num_read = int(m_storage->read(&m_piece_data[0]
, m_current_slot, 0, piece_size); , m_current_slot, 0, piece_size));
// if the file is incomplete, skip the rest of it // if the file is incomplete, skip the rest of it
if (num_read != piece_size) if (num_read != piece_size)

31
libtorrent/src/torrent.cpp
View File

@ -102,7 +102,7 @@ namespace
// if pieces are too small, adjust the block size // if pieces are too small, adjust the block size
if (i.piece_length() < default_block_size) if (i.piece_length() < default_block_size)
{ {
return static_cast<int>(i.piece_length()); return i.piece_length();
} }
// otherwise, go with the default // otherwise, go with the default
@ -337,7 +337,7 @@ namespace libtorrent
peer_request torrent::to_req(piece_block const& p) peer_request torrent::to_req(piece_block const& p)
{ {
int block_offset = p.block_index * m_block_size; int block_offset = p.block_index * m_block_size;
int block_size = (std::min)((int)torrent_file().piece_size( int block_size = (std::min)(torrent_file().piece_size(
p.piece_index) - block_offset, m_block_size); p.piece_index) - block_offset, m_block_size);
TORRENT_ASSERT(block_size > 0); TORRENT_ASSERT(block_size > 0);
TORRENT_ASSERT(block_size <= m_block_size); TORRENT_ASSERT(block_size <= m_block_size);
@ -403,8 +403,8 @@ namespace libtorrent
m_storage = m_owning_storage.get(); m_storage = m_owning_storage.get();
m_block_size = calculate_block_size(*m_torrent_file, m_default_block_size); m_block_size = calculate_block_size(*m_torrent_file, m_default_block_size);
m_picker.reset(new piece_picker( m_picker.reset(new piece_picker(
static_cast<int>(m_torrent_file->piece_length() / m_block_size) m_torrent_file->piece_length() / m_block_size
, static_cast<int>((m_torrent_file->total_size()+m_block_size-1)/m_block_size))); , int((m_torrent_file->total_size()+m_block_size-1)/m_block_size)));
std::vector<std::string> const& url_seeds = m_torrent_file->url_seeds(); std::vector<std::string> const& url_seeds = m_torrent_file->url_seeds();
std::copy(url_seeds.begin(), url_seeds.end(), std::inserter(m_web_seeds std::copy(url_seeds.begin(), url_seeds.end(), std::inserter(m_web_seeds
@ -775,8 +775,7 @@ namespace libtorrent
const std::vector<piece_picker::downloading_piece>& dl_queue const std::vector<piece_picker::downloading_piece>& dl_queue
= m_picker->get_download_queue(); = m_picker->get_download_queue();
const int blocks_per_piece = static_cast<int>( const int blocks_per_piece = piece_size / m_block_size;
piece_size / m_block_size);
for (std::vector<piece_picker::downloading_piece>::const_iterator i = for (std::vector<piece_picker::downloading_piece>::const_iterator i =
dl_queue.begin(); i != dl_queue.end(); ++i) dl_queue.begin(); i != dl_queue.end(); ++i)
@ -1702,7 +1701,7 @@ namespace libtorrent
m_host_resolver.async_resolve(q, m_ses.m_strand.wrap( m_host_resolver.async_resolve(q, m_ses.m_strand.wrap(
bind(&torrent::on_name_lookup, shared_from_this(), _1, _2, url, a))); bind(&torrent::on_name_lookup, shared_from_this(), _1, _2, url, a)));
} }
catch (std::exception& exc) catch (std::exception&)
{ {
TORRENT_ASSERT(false); TORRENT_ASSERT(false);
}; };
@ -1987,7 +1986,7 @@ namespace libtorrent
pi.finished = (int)i->finished; pi.finished = (int)i->finished;
pi.writing = (int)i->writing; pi.writing = (int)i->writing;
pi.requested = (int)i->requested; pi.requested = (int)i->requested;
int piece_size = torrent_file().piece_size(i->index); int piece_size = int(torrent_file().piece_size(i->index));
for (int j = 0; j < pi.blocks_in_piece; ++j) for (int j = 0; j < pi.blocks_in_piece; ++j)
{ {
block_info& bi = pi.blocks[j]; block_info& bi = pi.blocks[j];
@ -2178,7 +2177,7 @@ namespace libtorrent
#endif #endif
m_policy.new_connection(*p); m_policy.new_connection(*p);
} }
catch (std::exception& e) catch (std::exception&)
{ {
throw; throw;
} }
@ -2864,6 +2863,13 @@ namespace libtorrent
m_storage->async_release_files( m_storage->async_release_files(
bind(&torrent::on_torrent_paused, shared_from_this(), _1, _2)); bind(&torrent::on_torrent_paused, shared_from_this(), _1, _2));
} }
else
{
if (alerts().should_post(alert::warning))
{
alerts().post_alert(torrent_paused_alert(get_handle(), "torrent paused"));
}
}
} }
void torrent::resume() void torrent::resume()
@ -2967,6 +2973,7 @@ namespace libtorrent
} }
catch (std::exception& e) catch (std::exception& e)
{ {
(void)e;
#ifdef TORRENT_VERBOSE_LOGGING #ifdef TORRENT_VERBOSE_LOGGING
(*p->m_logger) << "**ERROR**: " << e.what() << "\n"; (*p->m_logger) << "**ERROR**: " << e.what() << "\n";
#endif #endif
@ -3053,8 +3060,8 @@ namespace libtorrent
size_type done = 0; size_type done = 0;
while (size > 0) while (size > 0)
{ {
size_type bytes_step = (std::min)(m_torrent_file->piece_size(ret.piece) size_type bytes_step = (std::min)(size_type(m_torrent_file->piece_size(ret.piece)
- ret.start, size); - ret.start), size);
if (m_have_pieces[ret.piece]) done += bytes_step; if (m_have_pieces[ret.piece]) done += bytes_step;
++ret.piece; ++ret.piece;
ret.start = 0; ret.start = 0;
@ -3177,7 +3184,7 @@ namespace libtorrent
if (st.total_wanted == 0) st.progress = 1.f; if (st.total_wanted == 0) st.progress = 1.f;
else st.progress = st.total_wanted_done else st.progress = st.total_wanted_done
/ static_cast<double>(st.total_wanted); / static_cast<float>(st.total_wanted);
st.pieces = &m_have_pieces; st.pieces = &m_have_pieces;
st.num_pieces = m_num_pieces; st.num_pieces = m_num_pieces;

2
libtorrent/src/torrent_handle.cpp
View File

@ -485,7 +485,7 @@ namespace libtorrent
session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex); session_impl::mutex_t::scoped_lock l1(m_ses->m_mutex);
mutex::scoped_lock l2(m_chk->m_mutex); mutex::scoped_lock l2(m_chk->m_mutex);
torrent* t = find_torrent(m_ses, m_chk, m_info_hash); torrent* t = find_torrent(m_ses, m_chk, m_info_hash);
return t; return t != 0;
} }
entry torrent_handle::write_resume_data() const entry torrent_handle::write_resume_data() const

15
libtorrent/src/torrent_info.cpp
View File

@ -340,7 +340,7 @@ namespace libtorrent
m_info_hash = h.final(); m_info_hash = h.final();
// extract piece length // extract piece length
m_piece_length = (int)info["piece length"].integer(); m_piece_length = int(info["piece length"].integer());
if (m_piece_length <= 0) throw std::runtime_error("invalid torrent. piece length <= 0"); if (m_piece_length <= 0) throw std::runtime_error("invalid torrent. piece length <= 0");
// extract file name (or the directory name if it's a multifile libtorrent) // extract file name (or the directory name if it's a multifile libtorrent)
@ -497,7 +497,7 @@ namespace libtorrent
std::string const& hostname = iter->string(); std::string const& hostname = iter->string();
++iter; ++iter;
int port = 6881; int port = 6881;
if (l.end() != iter) port = iter->integer(); if (l.end() != iter) port = int(iter->integer());
m_nodes.push_back(std::make_pair(hostname, port)); m_nodes.push_back(std::make_pair(hostname, port));
} }
} }
@ -817,7 +817,7 @@ namespace libtorrent
// ------- end deprecation ------- // ------- end deprecation -------
size_type torrent_info::piece_size(int index) const int torrent_info::piece_size(int index) const
{ {
TORRENT_ASSERT(index >= 0 && index < num_pieces()); TORRENT_ASSERT(index >= 0 && index < num_pieces());
if (index == num_pieces()-1) if (index == num_pieces()-1)
@ -826,7 +826,7 @@ namespace libtorrent
- (num_pieces() - 1) * piece_length(); - (num_pieces() - 1) * piece_length();
TORRENT_ASSERT(size > 0); TORRENT_ASSERT(size > 0);
TORRENT_ASSERT(size <= piece_length()); TORRENT_ASSERT(size <= piece_length());
return size; return int(size);
} }
else else
return piece_length(); return piece_length();
@ -882,12 +882,13 @@ namespace libtorrent
} }
std::vector<file_slice> torrent_info::map_block(int piece, size_type offset std::vector<file_slice> torrent_info::map_block(int piece, size_type offset
, int size, bool storage) const , int size_, bool storage) const
{ {
TORRENT_ASSERT(num_files() > 0); TORRENT_ASSERT(num_files() > 0);
std::vector<file_slice> ret; std::vector<file_slice> ret;
size_type start = piece * (size_type)m_piece_length + offset; size_type start = piece * (size_type)m_piece_length + offset;
size_type size = size_;
TORRENT_ASSERT(start + size <= m_total_size); TORRENT_ASSERT(start + size <= m_total_size);
// find the file iterator and file offset // find the file iterator and file offset
@ -926,8 +927,8 @@ namespace libtorrent
size_type offset = file_offset + file_at(file_index, storage).offset; size_type offset = file_offset + file_at(file_index, storage).offset;
peer_request ret; peer_request ret;
ret.piece = offset / piece_length(); ret.piece = int(offset / piece_length());
ret.start = offset - ret.piece * piece_length(); ret.start = int(offset - ret.piece * piece_length());
ret.length = size; ret.length = size;
return ret; return ret;
} }

2
libtorrent/src/tracker_manager.cpp
View File

@ -352,7 +352,7 @@ namespace libtorrent
m_timeout.async_wait(m_strand.wrap( m_timeout.async_wait(m_strand.wrap(
bind(&timeout_handler::timeout_callback, self(), _1))); bind(&timeout_handler::timeout_callback, self(), _1)));
} }
catch (std::exception& e) catch (std::exception&)
{ {
TORRENT_ASSERT(false); TORRENT_ASSERT(false);
} }

3
libtorrent/src/upnp.cpp
View File

@ -216,6 +216,7 @@ try
} }
catch (std::exception& e) catch (std::exception& e)
{ {
(void)e;
#ifdef TORRENT_UPNP_LOGGING #ifdef TORRENT_UPNP_LOGGING
m_log << time_now_string() m_log << time_now_string()
<< " *** Connection failed to: " << d.url << " *** Connection failed to: " << d.url
@ -302,6 +303,7 @@ try
} }
catch (std::exception& e) catch (std::exception& e)
{ {
(void)e;
#ifdef TORRENT_UPNP_LOGGING #ifdef TORRENT_UPNP_LOGGING
m_log << time_now_string() m_log << time_now_string()
<< " <== (" << from << ") Rootdevice responded with incorrect HTTP packet. Ignoring device (" << e.what() << ")" << std::endl; << " <== (" << from << ") Rootdevice responded with incorrect HTTP packet. Ignoring device (" << e.what() << ")" << std::endl;
@ -449,6 +451,7 @@ try
} }
catch (std::exception& e) catch (std::exception& e)
{ {
(void)e;
#ifdef TORRENT_UPNP_LOGGING #ifdef TORRENT_UPNP_LOGGING
m_log << time_now_string() m_log << time_now_string()
<< " *** Connection failed to: " << d.url << " *** Connection failed to: " << d.url

2
libtorrent/src/ut_pex.cpp
View File

@ -202,7 +202,7 @@ namespace libtorrent { namespace
if (entry const* index = messages.find_key(extension_name)) if (entry const* index = messages.find_key(extension_name))
{ {
m_message_index = index->integer(); m_message_index = int(index->integer());
return true; return true;
} }
else else

2
libtorrent/src/web_peer_connection.cpp
View File

@ -486,7 +486,7 @@ namespace libtorrent
int file_index = m_file_requests.front(); int file_index = m_file_requests.front();
peer_request in_range = info.map_file(file_index, range_start peer_request in_range = info.map_file(file_index, range_start
, range_end - range_start); , int(range_end - range_start));
peer_request front_request = m_requests.front(); peer_request front_request = m_requests.front();