premiere
/
premiere-libtorrent
2
2
Fork 1
Code Issues Pull Requests Releases Wiki Activity

remove the IPv6 enable/disable build config

This commit is contained in:
Arvid Norberg 2018-08-15 00:02:37 +02:00 committed by Arvid Norberg
parent fef1b947f3
commit b90564d418
72 changed files with 16 additions and 604 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -628,8 +628,6 @@ target_optional_compile_definitions(torrent-rasterbar PUBLIC FEATURE NAME extens
DESCRIPTION "Enables protocol extensions" DISABLED TORRENT_DISABLE_EXTENSIONS)
target_optional_compile_definitions(torrent-rasterbar PUBLIC FEATURE NAME i2p DEFAULT ON
DESCRIPTION "build with I2P support" DISABLED TORRENT_USE_I2P=0)
target_optional_compile_definitions(torrent-rasterbar PUBLIC FEATURE NAME ipv6 DEFAULT ON
DESCRIPTION "build with IPv6 support" DISABLED TORRENT_USE_IPV6=0)
target_optional_compile_definitions(torrent-rasterbar PUBLIC FEATURE NAME logging DEFAULT ON
DESCRIPTION "build with logging" DISABLED TORRENT_DISABLE_LOGGING)
target_optional_compile_definitions(torrent-rasterbar PUBLIC FEATURE NAME mutable-torrents DEFAULT ON

7
Jamfile
View File

@ -417,9 +417,6 @@ rule openssl-include-path ( properties * )
feature openssl-lib : : free path ;
feature openssl-include : : free path ;
feature ipv6 : on off : composite propagated link-incompatible ;
feature.compose <ipv6>off : <define>TORRENT_USE_IPV6=0 ;
feature sanitize : off address memory undefined thread rtc : composite propagated link-incompatible ;
# sanitize is a clang and GCC feature
feature.compose <sanitize>undefined : <cflags>-fsanitize=undefined <cflags>-fsanitize-undefined-trap-on-error <linkflags>-fsanitize=undefined <linkflags>-fsanitize-undefined-trap-on-error ;
@ -538,12 +535,12 @@ variant test_debug : debug
<export-extra>on <threading>multi <asserts>on
;
variant test_barebones : debug
: <ipv6>off <dht>off <extensions>off <logging>off <boost-link>shared
: <dht>off <extensions>off <logging>off <boost-link>shared
<deprecated-functions>off <invariant-checks>off
<export-extra>on <threading>multi <asserts>on
;
variant test_arm : debug
: <ipv6>off <dht>off <extensions>off <logging>off
: <dht>off <extensions>off <logging>off
<deprecated-functions>off <invariant-checks>off
<export-extra>on <asserts>on
;

2
docs/gen_reference_doc.py
View File

@ -626,7 +626,7 @@ def consume_comment(lno, lines):
def trim_define(line):
return line.replace('#ifndef', '').replace('#ifdef', '') \
.replace('#if', '').replace('defined', '') \
.replace('TORRENT_USE_IPV6', '').replace('TORRENT_ABI_VERSION == 1', '') \
.replace('TORRENT_ABI_VERSION == 1', '') \
.replace('||', '').replace('&&', '').replace('(', '').replace(')', '') \
.replace('!', '').replace('\\', '').strip()

6
examples/client_test.cpp
View File

@ -81,9 +81,7 @@ using lt::torrent_flags_t;
using lt::seconds;
using lt::operator""_sv;
using lt::address_v4;
#if TORRENT_USE_IPV6
using lt::address_v6;
#endif
using std::chrono::duration_cast;
@ -283,11 +281,9 @@ std::string print_endpoint(lt::tcp::endpoint const& ep)
lt::error_code ec;
char buf[200];
address const& addr = ep.address();
#if TORRENT_USE_IPV6
if (addr.is_v6())
std::snprintf(buf, sizeof(buf), "[%s]:%d", addr.to_string(ec).c_str(), ep.port());
else
#endif
std::snprintf(buf, sizeof(buf), "%s:%d", addr.to_string(ec).c_str(), ep.port());
return buf;
}
@ -1260,10 +1256,8 @@ example alert_masks:
pcf.add_rule(address_v4::from_string("0.0.0.0")
, address_v4::from_string("255.255.255.255")
, 1 << static_cast<std::uint32_t>(lt::session::global_peer_class_id));
#if TORRENT_USE_IPV6
pcf.add_rule(address_v6::from_string("::")
, address_v6::from_string("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), 1);
#endif
ses.set_peer_class_filter(pcf);
}

2
examples/connection_tester.cpp
View File

@ -430,12 +430,10 @@ struct peer_conn
char ep_str[200];
address const& addr = s.local_endpoint(e).address();
#if TORRENT_USE_IPV6
if (addr.is_v6())
std::snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str()
, s.local_endpoint(e).port());
else
#endif
std::snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str()
, s.local_endpoint(e).port());
std::printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n"

8
include/libtorrent/address.hpp
View File

@ -51,15 +51,11 @@ namespace libtorrent {
#if defined TORRENT_BUILD_SIMULATOR
using sim::asio::ip::address;
using sim::asio::ip::address_v4;
#if TORRENT_USE_IPV6
using sim::asio::ip::address_v6;
#endif
#else
using boost::asio::ip::address;
using boost::asio::ip::address_v4;
#if TORRENT_USE_IPV6
using boost::asio::ip::address_v6;
#endif
#endif // SIMULATOR
// the from_string member functions are deprecated starting
@ -67,19 +63,15 @@ namespace libtorrent {
#if BOOST_VERSION >= 106600 && !defined TORRENT_BUILD_SIMULATOR
using boost::asio::ip::make_address;
using boost::asio::ip::make_address_v4;
#if TORRENT_USE_IPV6
using boost::asio::ip::make_address_v6;
#endif
#else
inline address make_address(string_view str, boost::system::error_code& ec)
{ return address::from_string(str.data(), ec); }
inline address_v4 make_address_v4(string_view str, boost::system::error_code& ec)
{ return address_v4::from_string(str.data(), ec); }
#if TORRENT_USE_IPV6
inline address_v6 make_address_v6(string_view str, boost::system::error_code& ec)
{ return address_v6::from_string(str.data(), ec); }
#endif
#endif
}
#endif

2
include/libtorrent/bt_peer_connection.hpp
View File

@ -70,10 +70,8 @@ namespace libtorrent {
// cheap since the lists' size is limited
using peers4_t = std::vector<std::pair<address_v4::bytes_type, std::uint16_t>>;
peers4_t m_peers;
#if TORRENT_USE_IPV6
using peers6_t = std::vector<std::pair<address_v6::bytes_type, std::uint16_t>>;
peers6_t m_peers6;
#endif
bool was_introduced_by(tcp::endpoint const& ep);

14
include/libtorrent/config.hpp
View File

@ -122,7 +122,6 @@ POSSIBILITY OF SUCH DAMAGE.
// ==== AMIGA ===
#if defined __AMIGA__ || defined __amigaos__ || defined __AROS__
#define TORRENT_AMIGA
#define TORRENT_USE_IPV6 0
#define TORRENT_USE_IOSTREAM 0
// set this to 1 to disable all floating point operations
// (disables some float-dependent APIs)
@ -322,7 +321,6 @@ POSSIBILITY OF SUCH DAMAGE.
#define TORRENT_HAS_FALLOCATE 0
#define TORRENT_USE_IFCONF 1
#define TORRENT_USE_SYSCTL 1
#define TORRENT_USE_IPV6 0
#define TORRENT_USE_WRITEV 0
#define TORRENT_USE_READV 0
@ -468,10 +466,6 @@ POSSIBILITY OF SUCH DAMAGE.
#define TORRENT_USE_IFADDRS 0
#endif
#ifndef TORRENT_USE_IPV6
#define TORRENT_USE_IPV6 1
#endif
// if preadv() exists, we assume pwritev() does as well
#ifndef TORRENT_USE_PREADV
#define TORRENT_USE_PREADV 0
@ -615,14 +609,6 @@ constexpr std::size_t TORRENT_WRITE_HANDLER_MAX_SIZE = 342;
#endif
#endif // TORRENT_HAS_ARM_CRC32
#if TORRENT_USE_IPV6
#define TORRENT_IPV6_NAMESPACE inline namespace v6 {
#define TORRENT_IPV6_NAMESPACE_END }
#else
#define TORRENT_IPV6_NAMESPACE
#define TORRENT_IPV6_NAMESPACE_END
#endif
namespace libtorrent {}
// create alias

2
include/libtorrent/enum_net.hpp
View File

@ -120,13 +120,11 @@ namespace libtorrent {
address ip = make_address(device_name, ec);
if (!ec)
{
#if TORRENT_USE_IPV6
// this is to cover the case where "0.0.0.0" is considered any IPv4 or
// IPv6 address. If we're asking to be bound to an IPv6 address and
// providing 0.0.0.0 as the device, turn it into "::"
if (ip == address_v4::any() && protocol == boost::asio::ip::tcp::v6())
ip = address_v6::any();
#endif
bind_ep.address(ip);
// it appears to be an IP. Just bind to that address
sock.bind(bind_ep, ec);

4
include/libtorrent/fwd.hpp
View File

@ -188,9 +188,7 @@ class hasher;
class hasher512;
// include/libtorrent/ip_filter.hpp
TORRENT_IPV6_NAMESPACE
struct ip_filter;
TORRENT_IPV6_NAMESPACE_END
class port_filter;
// include/libtorrent/kademlia/dht_settings.hpp
@ -256,10 +254,8 @@ struct storage_interface;
struct storage_params;
// include/libtorrent/torrent_handle.hpp
TORRENT_IPV6_NAMESPACE
struct block_info;
struct partial_piece_info;
TORRENT_IPV6_NAMESPACE_END
struct torrent_handle;
// include/libtorrent/torrent_info.hpp

10
include/libtorrent/ip_filter.hpp
View File

@ -256,8 +256,6 @@ namespace detail {
}
TORRENT_IPV6_NAMESPACE
// The ``ip_filter`` class is a set of rules that uniquely categorizes all
// ip addresses as allowed or disallowed. The default constructor creates
// a single rule that allows all addresses (0.0.0.0 - 255.255.255.255 for
@ -296,12 +294,8 @@ struct TORRENT_EXPORT ip_filter
// the current filter.
std::uint32_t access(address const& addr) const;
#if TORRENT_USE_IPV6
using filter_tuple_t = std::tuple<std::vector<ip_range<address_v4>>
, std::vector<ip_range<address_v6>>>;
#else
using filter_tuple_t = std::vector<ip_range<address_v4>>;
#endif
// This function will return the current state of the filter in the minimum number of
// ranges possible. They are sorted from ranges in low addresses to high addresses. Each
@ -317,13 +311,9 @@ struct TORRENT_EXPORT ip_filter
private:
detail::filter_impl<address_v4::bytes_type> m_filter4;
#if TORRENT_USE_IPV6
detail::filter_impl<address_v6::bytes_type> m_filter6;
#endif
};
TORRENT_IPV6_NAMESPACE_END
// the port filter maps non-overlapping port ranges to flags. This
// is primarily used to indicate whether a range of ports should
// be connected to or not. The default is to have the full port

2
include/libtorrent/ip_voter.hpp
View File

@ -111,9 +111,7 @@ namespace libtorrent {
struct TORRENT_EXTRA_EXPORT external_ip
{
external_ip()
#if TORRENT_USE_IPV6
: m_addresses{{address_v4(), address_v6()}, {address_v4(), address_v6()}}
#endif
{}
external_ip(address const& local4, address const& global4

5
include/libtorrent/kademlia/io.hpp
View File

@ -47,17 +47,12 @@ namespace libtorrent { namespace dht {
template<class InIt>
node_endpoint read_node_endpoint(udp protocol, InIt&& in)
{
#if !TORRENT_USE_IPV6
TORRENT_UNUSED(protocol);
#endif
node_endpoint ep;
std::copy(in, in + 20, ep.id.begin());
in += 20;
#if TORRENT_USE_IPV6
if (protocol == udp::v6())
ep.ep = detail::read_v6_endpoint<udp::endpoint>(in);
else
#endif
ep.ep = detail::read_v4_endpoint<udp::endpoint>(in);
return ep;
}

2
include/libtorrent/kademlia/observer.hpp
View File

@ -126,9 +126,7 @@ private:
union addr_t
{
#if TORRENT_USE_IPV6
address_v6::bytes_type v6;
#endif
address_v4::bytes_type v4;
} m_addr;

10
include/libtorrent/kademlia/routing_table.hpp
View File

@ -70,7 +70,6 @@ struct ipv4_hash
}
};
#if TORRENT_USE_IPV6
struct ipv6_hash
{
using argument_type = address_v6::bytes_type;
@ -80,7 +79,6 @@ struct ipv6_hash
return std::hash<std::uint64_t>()(*reinterpret_cast<std::uint64_t const*>(&ip[0]));
}
};
#endif
struct ip_set
{
@ -91,26 +89,18 @@ struct ip_set
void clear()
{
m_ip4s.clear();
#if TORRENT_USE_IPV6
m_ip6s.clear();
#endif
}
bool operator==(ip_set const& rh)
{
#if TORRENT_USE_IPV6
return m_ip4s == rh.m_ip4s && m_ip6s == rh.m_ip6s;
#else
return m_ip4s == rh.m_ip4s;
#endif
}
// these must be multisets because there can be multiple routing table
// entries for a single IP when restrict_routing_ips is set to false
std::unordered_multiset<address_v4::bytes_type, ipv4_hash> m_ip4s;
#if TORRENT_USE_IPV6
std::unordered_multiset<address_v6::bytes_type, ipv6_hash> m_ip6s;
#endif
};
// differences in the implementation from the description in

2
include/libtorrent/kademlia/traversal_algorithm.hpp
View File

@ -140,9 +140,7 @@ private:
// the IP addresses of the nodes in m_results
std::set<std::uint32_t> m_peer4_prefixes;
#if TORRENT_USE_IPV6
std::set<std::uint64_t> m_peer6_prefixes;
#endif
#ifndef TORRENT_DISABLE_LOGGING
void log_timeout(observer_ptr const& o, char const* prefix) const;
#endif

4
include/libtorrent/lsd.hpp
View File

@ -67,9 +67,7 @@ private:
// the udp socket used to send and receive
// multicast messages on
broadcast_socket m_socket;
#if TORRENT_USE_IPV6
broadcast_socket m_socket6;
#endif
#ifndef TORRENT_DISABLE_LOGGING
bool should_log() const;
void debug_log(char const* fmt, ...) const TORRENT_FORMAT(2, 3);
@ -87,9 +85,7 @@ private:
int m_cookie;
bool m_disabled;
#if TORRENT_USE_IPV6
bool m_disabled6;
#endif
};
}

2
include/libtorrent/peer.hpp
View File

@ -59,13 +59,11 @@ namespace libtorrent {
std::uint16_t port;
};
#if TORRENT_USE_IPV6
struct ipv6_peer_entry
{
address_v6::bytes_type ip;
std::uint16_t port;
};
#endif
}

14
include/libtorrent/socket_io.hpp
View File

@ -60,31 +60,24 @@ namespace detail {
template <class Proto>
std::size_t address_size(Proto p)
{
TORRENT_UNUSED(p);
#if TORRENT_USE_IPV6
if (p == Proto::v6())
return std::tuple_size<address_v6::bytes_type>::value;
else
#endif
return std::tuple_size<address_v4::bytes_type>::value;
}
template<class OutIt>
void write_address(address const& a, OutIt&& out)
{
#if TORRENT_USE_IPV6
if (a.is_v4())
{
#endif
write_uint32(a.to_v4().to_ulong(), out);
#if TORRENT_USE_IPV6
}
else if (a.is_v6())
{
for (auto b : a.to_v6().to_bytes())
write_uint8(b, out);
}
#endif
}
template<class InIt>
@ -94,7 +87,6 @@ namespace detail {
return address_v4(ip);
}
#if TORRENT_USE_IPV6
template<class InIt>
address read_v6_address(InIt&& in)
{
@ -103,7 +95,6 @@ namespace detail {
b = read_uint8(in);
return address_v6(bytes);
}
#endif
template<class Endpoint, class OutIt>
void write_endpoint(Endpoint const& e, OutIt&& out)
@ -120,7 +111,6 @@ namespace detail {
return Endpoint(addr, port);
}
#if TORRENT_USE_IPV6
template<class Endpoint, class InIt>
Endpoint read_v6_endpoint(InIt&& in)
{
@ -128,7 +118,7 @@ namespace detail {
std::uint16_t port = read_uint16(in);
return Endpoint(addr, port);
}
#endif
template <class EndpointType>
std::vector<EndpointType> read_endpoint_list(libtorrent::bdecode_node const& n)
{
@ -142,10 +132,8 @@ namespace detail {
char const* in = e.string_ptr();
if (e.string_length() == 6)
ret.push_back(read_v4_endpoint<EndpointType>(in));
#if TORRENT_USE_IPV6
else if (e.string_length() == 18)
ret.push_back(read_v6_endpoint<EndpointType>(in));
#endif
}
return ret;
}

12
include/libtorrent/torrent_handle.hpp
View File

@ -82,8 +82,6 @@ namespace aux {
using resume_data_flags_t = flags::bitfield_flag<std::uint8_t, struct resume_data_flags_tag>;
using queue_position_t = aux::strong_typedef<int, struct queue_position_tag>;
TORRENT_IPV6_NAMESPACE
// holds the state of a block in a piece. Who we requested
// it from and how far along we are at downloading it.
struct TORRENT_EXPORT block_info
@ -106,9 +104,7 @@ TORRENT_IPV6_NAMESPACE
union addr_t
{
address_v4::bytes_type v4;
#if TORRENT_USE_IPV6
address_v6::bytes_type v6;
#endif
} addr;
std::uint16_t port;
@ -117,22 +113,18 @@ TORRENT_IPV6_NAMESPACE
// The peer is the ip address of the peer this block was downloaded from.
void set_peer(tcp::endpoint const& ep)
{
#if TORRENT_USE_IPV6
is_v6_addr = is_v6(ep);
if (is_v6_addr)
addr.v6 = ep.address().to_v6().to_bytes();
else
#endif
addr.v4 = ep.address().to_v4().to_bytes();
port = ep.port();
}
tcp::endpoint peer() const
{
#if TORRENT_USE_IPV6
if (is_v6_addr)
return tcp::endpoint(address_v6(addr.v6), port);
else
#endif
return tcp::endpoint(address_v4(addr.v4), port);
}
@ -150,10 +142,8 @@ TORRENT_IPV6_NAMESPACE
// by more peers in parallel to speed things up.
unsigned num_peers:14;
private:
#if TORRENT_USE_IPV6
// the type of the addr union
bool is_v6_addr:1;
#endif
};
// This class holds information about pieces that have outstanding requests
@ -216,8 +206,6 @@ TORRENT_IPV6_NAMESPACE
#endif
};
TORRENT_IPV6_NAMESPACE_END
// for std::hash (and to support using this type in unordered_map etc.)
TORRENT_EXPORT std::size_t hash_value(torrent_handle const& h);

4
include/libtorrent/torrent_peer.hpp
View File

@ -170,11 +170,9 @@ namespace libtorrent {
bool pe_support:1;
#endif
#if TORRENT_USE_IPV6
// this is true if the v6 union member in addr is
// the one to use, false if it's the v4 one
bool is_v6_addr:1;
#endif
#if TORRENT_USE_I2P
// set if the i2p_destination is in use in the addr union
bool is_i2p_addr:1;
@ -230,7 +228,6 @@ namespace libtorrent {
};
#endif
#if TORRENT_USE_IPV6
struct TORRENT_EXTRA_EXPORT ipv6_peer : torrent_peer
{
ipv6_peer(tcp::endpoint const& ip, bool connectable, peer_source_flags_t src);
@ -238,7 +235,6 @@ namespace libtorrent {
const address_v6::bytes_type addr;
};
#endif
struct peer_address_compare
{

2
include/libtorrent/torrent_peer_allocator.hpp
View File

@ -84,9 +84,7 @@ namespace libtorrent {
// saves significant overhead
boost::pool<> m_ipv4_peer_pool{sizeof(libtorrent::ipv4_peer), 500};
#if TORRENT_USE_IPV6
boost::pool<> m_ipv6_peer_pool{sizeof(libtorrent::ipv6_peer), 500};
#endif
#if TORRENT_USE_I2P
boost::pool<> m_i2p_peer_pool{sizeof(libtorrent::i2p_peer), 500};
#endif

4
include/libtorrent/tracker_manager.hpp
View File

@ -143,9 +143,7 @@ namespace libtorrent {
std::uint32_t key;
int num_want;
#if TORRENT_USE_IPV6
std::vector<address_v6> ipv6;
#endif
sha1_hash info_hash;
peer_id pid;
@ -181,9 +179,7 @@ namespace libtorrent {
// peers from the tracker, in various forms
std::vector<peer_entry> peers;
std::vector<ipv4_peer_entry> peers4;
#if TORRENT_USE_IPV6
std::vector<ipv6_peer_entry> peers6;
#endif
// our external IP address (if the tracker responded with ti, otherwise
// INADDR_ANY)
address external_ip;

19
include/libtorrent/union_endpoint.hpp
View File

@ -38,37 +38,27 @@ POSSIBILITY OF SUCH DAMAGE.
namespace libtorrent {
TORRENT_IPV6_NAMESPACE
struct union_address
{
union_address() { *this = address(); }
explicit union_address(address const& a) { *this = a; }
union_address& operator=(address const& a) &
{
#if TORRENT_USE_IPV6
v4 = a.is_v4();
if (v4)
addr.v4 = a.to_v4().to_bytes();
else
addr.v6 = a.to_v6().to_bytes();
#else
addr.v4 = a.to_v4().to_bytes();
#endif
return *this;
}
bool operator==(union_address const& rh) const
{
#if TORRENT_USE_IPV6
if (v4 != rh.v4) return false;
if (v4)
return addr.v4 == rh.addr.v4;
else
return addr.v6 == rh.addr.v6;
#else
return addr.v4 == rh.addr.v4;
#endif
}
bool operator!=(union_address const& rh) const
@ -78,24 +68,16 @@ TORRENT_IPV6_NAMESPACE
operator address() const
{
#if TORRENT_USE_IPV6
if (v4) return address(address_v4(addr.v4));
else return address(address_v6(addr.v6));
#else
return address(address_v4(addr.v4));
#endif
}
union addr_t
{
address_v4::bytes_type v4;
#if TORRENT_USE_IPV6
address_v6::bytes_type v6;
#endif
} addr;
#if TORRENT_USE_IPV6
bool v4:1;
#endif
};
struct union_endpoint
@ -126,7 +108,6 @@ TORRENT_IPV6_NAMESPACE
union_address addr;
std::uint16_t port;
};
TORRENT_IPV6_NAMESPACE_END
}
#endif

18
src/alert.cpp
View File

@ -2116,27 +2116,21 @@ namespace {
{
if (is_v4(endp))
m_v4_num_peers++;
#if TORRENT_USE_IPV6
else
m_v6_num_peers++;
#endif
}
m_v4_peers_idx = alloc.allocate(m_v4_num_peers * 6);
m_v6_peers_idx = alloc.allocate(m_v6_num_peers * 18);
char* v4_ptr = alloc.ptr(m_v4_peers_idx);
#if TORRENT_USE_IPV6
char* v6_ptr = alloc.ptr(m_v6_peers_idx);
#endif
for (auto const& endp : peers)
{
if (is_v4(endp))
detail::write_endpoint(endp, v4_ptr);
#if TORRENT_USE_IPV6
else
detail::write_endpoint(endp, v6_ptr);
#endif
}
}
@ -2169,11 +2163,9 @@ namespace {
char const* v4_ptr = m_alloc.get().ptr(m_v4_peers_idx);
for (int i = 0; i < m_v4_num_peers; i++)
peers.push_back(detail::read_v4_endpoint<tcp::endpoint>(v4_ptr));
#if TORRENT_USE_IPV6
char const* v6_ptr = m_alloc.get().ptr(m_v6_peers_idx);
for (int i = 0; i < m_v6_num_peers; i++)
peers.push_back(detail::read_v6_endpoint<tcp::endpoint>(v6_ptr));
#endif
return std::move(peers);
}
@ -2349,19 +2341,15 @@ namespace {
{
if (is_v4(n.second))
v4_num_nodes++;
#if TORRENT_USE_IPV6
else
v6_num_nodes++;
#endif
}
aux::allocation_slot const v4_nodes_idx = alloc.allocate(v4_num_nodes * (20 + 6));
aux::allocation_slot const v6_nodes_idx = alloc.allocate(v6_num_nodes * (20 + 18));
char* v4_ptr = alloc.ptr(v4_nodes_idx);
#if TORRENT_USE_IPV6
char* v6_ptr = alloc.ptr(v6_nodes_idx);
#endif
for (auto const& n : nodes)
{
udp::endpoint const& endp = n.second;
@ -2370,13 +2358,11 @@ namespace {
detail::write_string(n.first.to_string(), v4_ptr);
detail::write_endpoint(endp, v4_ptr);
}
#if TORRENT_USE_IPV6
else
{
detail::write_string(n.first.to_string(), v6_ptr);
detail::write_endpoint(endp, v6_ptr);
}
#endif
}
return nodes_slot{v4_num_nodes, v4_nodes_idx, v6_num_nodes, v6_nodes_idx};
@ -2398,7 +2384,6 @@ namespace {
v4_ptr += 20;
nodes.emplace_back(ih, detail::read_v4_endpoint<udp::endpoint>(v4_ptr));
}
#if TORRENT_USE_IPV6
char const* v6_ptr = alloc.ptr(v6_nodes_idx);
for (int i = 0; i < v6_num_nodes; i++)
{
@ -2407,9 +2392,6 @@ namespace {
v6_ptr += 20;
nodes.emplace_back(ih, detail::read_v6_endpoint<udp::endpoint>(v6_ptr));
}
#else
TORRENT_UNUSED(v6_nodes_idx);
#endif
return std::move(nodes);
}

25
src/broadcast_socket.cpp
View File

@ -56,7 +56,6 @@ namespace libtorrent {
bool is_local(address const& a)
{
TORRENT_TRY {
#if TORRENT_USE_IPV6
if (a.is_v6())
{
// NOTE: site local is deprecated but by
@ -73,7 +72,6 @@ namespace libtorrent {
// fc00::/7, unique local address
|| (a6.to_bytes()[0] & 0xfe) == 0xfc;
}
#endif
address_v4 a4 = a.to_v4();
unsigned long ip = a4.to_ulong();
return ((ip & 0xff000000) == 0x0a000000 // 10.x.x.x
@ -86,54 +84,39 @@ namespace libtorrent {
bool is_loopback(address const& addr)
{
#if TORRENT_USE_IPV6
TORRENT_TRY {
if (addr.is_v4())
return addr.to_v4() == address_v4::loopback();
else
return addr.to_v6() == address_v6::loopback();
} TORRENT_CATCH(std::exception const&) { return false; }
#else
return addr.to_v4() == address_v4::loopback();
#endif
}
bool is_any(address const& addr)
{
TORRENT_TRY {
#if TORRENT_USE_IPV6
if (addr.is_v4())
return addr.to_v4() == address_v4::any();
else if (addr.to_v6().is_v4_mapped())
return (addr.to_v6().to_v4() == address_v4::any());
else
return addr.to_v6() == address_v6::any();
#else
return addr.to_v4() == address_v4::any();
#endif
} TORRENT_CATCH(std::exception const&) { return false; }
}
bool is_teredo(address const& addr)
{
#if TORRENT_USE_IPV6
TORRENT_TRY {
if (!addr.is_v6()) return false;
static const std::uint8_t teredo_prefix[] = {0x20, 0x01, 0, 0};
address_v6::bytes_type b = addr.to_v6().to_bytes();
return std::memcmp(b.data(), teredo_prefix, 4) == 0;
} TORRENT_CATCH(std::exception const&) { return false; }
#else
TORRENT_UNUSED(addr);
return false;
#endif
}
bool supports_ipv6()
{
#if !TORRENT_USE_IPV6
return false;
#elif defined TORRENT_BUILD_SIMULATOR
#if defined TORRENT_BUILD_SIMULATOR
return true;
#elif defined TORRENT_WINDOWS
TORRENT_TRY {
@ -155,11 +138,7 @@ namespace libtorrent {
address ensure_v6(address const& a)
{
#if TORRENT_USE_IPV6
return a == address_v4() ? address_v6() : a;
#else
return a;
#endif
}
broadcast_socket::broadcast_socket(
@ -178,11 +157,9 @@ namespace libtorrent {
std::vector<ip_interface> interfaces = enum_net_interfaces(ios, ec);
#if TORRENT_USE_IPV6
if (is_v6(m_multicast_endpoint))
open_multicast_socket(ios, address_v6::any(), loopback, ec);
else
#endif
open_multicast_socket(ios, address_v4::any(), loopback, ec);
for (auto const& i : interfaces)

8
src/bt_peer_connection.cpp
View File

@ -123,14 +123,11 @@ namespace {
#ifndef TORRENT_DISABLE_EXTENSIONS
bool ut_pex_peer_store::was_introduced_by(tcp::endpoint const &ep)
{
#if TORRENT_USE_IPV6
if (is_v4(ep))
{
#endif
peers4_t::value_type const v(ep.address().to_v4().to_bytes(), ep.port());
auto const i = std::lower_bound(m_peers.begin(), m_peers.end(), v);
return i != m_peers.end() && *i == v;
#if TORRENT_USE_IPV6
}
else
{
@ -138,7 +135,6 @@ namespace {
auto const i = std::lower_bound(m_peers6.begin(), m_peers6.end(), v);
return i != m_peers6.end() && *i == v;
}
#endif
}
#endif // TORRENT_DISABLE_EXTENSIONS
@ -1354,14 +1350,12 @@ namespace {
// IPv4 address
ep = detail::read_v4_endpoint<tcp::endpoint>(ptr);
}
#if TORRENT_USE_IPV6
else if (addr_type == 1)
{
// IPv6 address
if (int(recv_buffer.size()) < 2 + 18 + 2) return;
ep = detail::read_v6_endpoint<tcp::endpoint>(ptr);
}
#endif
else
{
#ifndef TORRENT_DISABLE_LOGGING
@ -1750,7 +1744,6 @@ namespace {
, address_v4(bytes)
, aux::session_interface::source_peer, remote().address());
}
#if TORRENT_USE_IPV6
else if (myip.size() == std::tuple_size<address_v6::bytes_type>::value)
{
address_v6::bytes_type bytes;
@ -1765,7 +1758,6 @@ namespace {
, ipv6_address
, aux::session_interface::source_peer, remote().address());
}
#endif
}
// if we're finished and this peer is uploading only

28
src/enum_net.cpp
View File

@ -127,14 +127,12 @@ namespace {
return address_v4(b);
}
#if TORRENT_USE_IPV6
address_v6 inaddr6_to_address(in6_addr const* ina6, int const len = 16)
{
boost::asio::ip::address_v6::bytes_type b = {};
if (len > 0) std::memcpy(b.data(), ina6, std::min(std::size_t(len), b.size()));
return address_v6(b);
}
#endif
#if !TORRENT_USE_NETLINK
int sockaddr_len(sockaddr const* sin)
@ -151,7 +149,6 @@ namespace {
if (sin->sa_family == AF_INET || assume_family == AF_INET)
return inaddr_to_address(&reinterpret_cast<sockaddr_in const*>(sin)->sin_addr
, sockaddr_len(sin) - int(offsetof(sockaddr, sa_data)));
#if TORRENT_USE_IPV6
else if (sin->sa_family == AF_INET6 || assume_family == AF_INET6)
{
auto saddr = reinterpret_cast<sockaddr_in6 const*>(sin);
@ -160,7 +157,6 @@ namespace {
ret.scope_id(saddr->sin6_scope_id);
return ret;
}
#endif
return address();
}
#endif
@ -168,9 +164,7 @@ namespace {
bool valid_addr_family(int family)
{
return (family == AF_INET
#if TORRENT_USE_IPV6
|| family == AF_INET6
#endif
);
}
@ -193,7 +187,6 @@ namespace {
}
return address_v4(b);
}
#if TORRENT_USE_IPV6
else if (family == AF_INET6)
{
address_v6::bytes_type b;
@ -210,7 +203,6 @@ namespace {
}
return address_v6(b);
}
#endif
else
{
return address();
@ -299,7 +291,6 @@ namespace {
&& rt_msg->rtm_table != RT_TABLE_LOCAL))
return false;
#if TORRENT_USE_IPV6
// make sure the defaults have the right address family
// in case the attributes are not present
if (rt_msg->rtm_family == AF_INET6)
@ -307,7 +298,6 @@ namespace {
rt_info->gateway = address_v6();
rt_info->destination = address_v6();
}
#endif
int if_index = 0;
int rt_len = int(RTM_PAYLOAD(nl_hdr));
@ -324,25 +314,21 @@ namespace {
if_index = *reinterpret_cast<int*>(RTA_DATA(rt_attr));
break;
case RTA_GATEWAY:
#if TORRENT_USE_IPV6
if (rt_msg->rtm_family == AF_INET6)
{
rt_info->gateway = inaddr6_to_address(reinterpret_cast<in6_addr*>(RTA_DATA(rt_attr)));
}
else
#endif
{
rt_info->gateway = inaddr_to_address(reinterpret_cast<in_addr*>(RTA_DATA(rt_attr)));
}
break;
case RTA_DST:
#if TORRENT_USE_IPV6
if (rt_msg->rtm_family == AF_INET6)
{
rt_info->destination = inaddr6_to_address(reinterpret_cast<in6_addr*>(RTA_DATA(rt_attr)));
}
else
#endif
{
rt_info->destination = inaddr_to_address(reinterpret_cast<in_addr*>(RTA_DATA(rt_attr)));
}
@ -353,14 +339,12 @@ namespace {
#pragma clang diagnostic pop
#endif
#if TORRENT_USE_IPV6
if (rt_info->gateway.is_v6() && rt_info->gateway.to_v6().is_link_local())
{
address_v6 gateway6 = rt_info->gateway.to_v6();
gateway6.scope_id(std::uint32_t(if_index));
rt_info->gateway = gateway6;
}
#endif
ifreq req = {};
::if_indextoname(std::uint32_t(if_index), req.ifr_name);
@ -381,7 +365,6 @@ namespace {
ip_info->preferred = (addr_msg->ifa_flags & (IFA_F_DADFAILED | IFA_F_DEPRECATED | IFA_F_TENTATIVE)) == 0;
#if TORRENT_USE_IPV6
if (addr_msg->ifa_family == AF_INET6)
{
TORRENT_ASSERT(addr_msg->ifa_prefixlen <= 128);
@ -403,7 +386,6 @@ namespace {
}
}
else
#endif
{
TORRENT_ASSERT(addr_msg->ifa_prefixlen <= 32);
if (addr_msg->ifa_prefixlen != 0)
@ -432,7 +414,6 @@ namespace {
break;
BOOST_FALLTHROUGH;
case IFA_LOCAL:
#if TORRENT_USE_IPV6
if (addr_msg->ifa_family == AF_INET6)
{
address_v6 addr = inaddr6_to_address(reinterpret_cast<in6_addr*>(RTA_DATA(rt_attr)));
@ -441,7 +422,6 @@ namespace {
ip_info->interface_address = addr;
}
else
#endif
{
ip_info->interface_address = inaddr_to_address(reinterpret_cast<in_addr*>(RTA_DATA(rt_attr)));
}
@ -535,7 +515,6 @@ int _System __libsocket_sysctl(int* mib, u_int namelen, void *oldp, size_t *oldl
if (a1.is_v4() != a2.is_v4()) return false;
if (a1.is_v4() != mask.is_v4()) return false;
#if TORRENT_USE_IPV6
if (a1.is_v6())
{
address_v6::bytes_type b1 = a1.to_v6().to_bytes();
@ -546,9 +525,8 @@ int _System __libsocket_sysctl(int* mib, u_int namelen, void *oldp, size_t *oldl
b1[i] &= m[i];
b2[i] &= m[i];
}
return std::memcmp(b1.data(), b2.data(), b1.size()) == 0;
return b1 == b2;
}
#endif
return (a1.to_v4().to_ulong() & mask.to_v4().to_ulong())
== (a2.to_v4().to_ulong() & mask.to_v4().to_ulong());
}
@ -703,14 +681,12 @@ int _System __libsocket_sysctl(int* mib, u_int namelen, void *oldp, size_t *oldl
std::strncpy(req.ifr_name, item.ifr_name, IF_NAMESIZE - 1);
if (ioctl(s, SIOCGIFNETMASK, &req) < 0)
{
#if TORRENT_USE_IPV6
if (iface.interface_address.is_v6())
{
// this is expected to fail (at least on MacOS X)
iface.netmask = address_v6::any();
}
else
#endif
{
ec = error_code(errno, system_category());
::close(s);
@ -1142,7 +1118,6 @@ int _System __libsocket_sysctl(int* mib, u_int namelen, void *oldp, size_t *oldl
{
ip_route r;
r.gateway = sockaddr_to_address((const sockaddr*)&routes->Table[i].NextHop);
#if TORRENT_USE_IPV6
// The scope_id in NextHop is always zero because that would make
// things too easy apparently
if (r.gateway.is_v6() && r.gateway.to_v6().is_link_local())
@ -1151,7 +1126,6 @@ int _System __libsocket_sysctl(int* mib, u_int namelen, void *oldp, size_t *oldl
gateway6.scope_id(routes->Table[i].InterfaceIndex);
r.gateway = gateway6;
}
#endif
r.destination = sockaddr_to_address(
(const sockaddr*)&routes->Table[i].DestinationPrefix.Prefix);
r.netmask = build_netmask(routes->Table[i].DestinationPrefix.PrefixLength

8
src/http_tracker_connection.cpp
View File

@ -172,7 +172,6 @@ namespace libtorrent {
}
}
#if TORRENT_USE_IPV6
if (!tracker_req().ipv6.empty() && !i2p)
{
for (auto const& v6 : tracker_req().ipv6)
@ -184,7 +183,6 @@ namespace libtorrent {
url += escape_string(ip);
}
}
#endif
if (!tracker_req().outgoing_socket)
{
@ -540,7 +538,6 @@ namespace libtorrent {
peers_ent.clear();
}
#if TORRENT_USE_IPV6
bdecode_node ipv6_peers = e.dict_find_string("peers6");
if (ipv6_peers)
{
@ -561,9 +558,6 @@ namespace libtorrent {
{
ipv6_peers.clear();
}
#else
bdecode_node ipv6_peers;
#endif
/*
// if we didn't receive any peers. We don't care if we're stopping anyway
if (peers_ent == 0 && ipv6_peers == 0
@ -579,10 +573,8 @@ namespace libtorrent {
char const* p = ip_ent.string_ptr();
if (ip_ent.string_length() == std::tuple_size<address_v4::bytes_type>::value)
resp.external_ip = detail::read_v4_address(p);
#if TORRENT_USE_IPV6
else if (ip_ent.string_length() == std::tuple_size<address_v6::bytes_type>::value)
resp.external_ip = detail::read_v6_address(p);
#endif
}
return resp;

10
src/ip_filter.cpp
View File

@ -41,13 +41,11 @@ namespace libtorrent {
TORRENT_ASSERT(last.is_v4());
m_filter4.add_rule(first.to_v4().to_bytes(), last.to_v4().to_bytes(), flags);
}
#if TORRENT_USE_IPV6
else if (first.is_v6())
{
TORRENT_ASSERT(last.is_v6());
m_filter6.add_rule(first.to_v6().to_bytes(), last.to_v6().to_bytes(), flags);
}
#endif
else
TORRENT_ASSERT_FAIL();
}
@ -56,22 +54,14 @@ namespace libtorrent {
{
if (addr.is_v4())
return m_filter4.access(addr.to_v4().to_bytes());
#if TORRENT_USE_IPV6
TORRENT_ASSERT(addr.is_v6());
return m_filter6.access(addr.to_v6().to_bytes());
#else
return 0;
#endif
}
ip_filter::filter_tuple_t ip_filter::export_filter() const
{
#if TORRENT_USE_IPV6
return std::make_tuple(m_filter4.export_filter<address_v4>()
, m_filter6.export_filter<address_v6>());
#else
return m_filter4.export_filter<address_v4>();
#endif
}
void port_filter::add_rule(std::uint16_t first, std::uint16_t last, std::uint32_t flags)

4
src/ip_voter.cpp
View File

@ -177,10 +177,8 @@ namespace libtorrent {
, address const& local6, address const& global6)
: m_addresses{{global4, ensure_v6(global6)}, {local4, ensure_v6(local6)}}
{
#if TORRENT_USE_IPV6
TORRENT_ASSERT(m_addresses[0][1].is_v6());
TORRENT_ASSERT(m_addresses[1][1].is_v6());
#endif
TORRENT_ASSERT(m_addresses[0][0].is_v4());
TORRENT_ASSERT(m_addresses[1][0].is_v4());
}
@ -188,9 +186,7 @@ namespace libtorrent {
address external_ip::external_address(address const& ip) const
{
address ext = m_addresses[is_local(ip)][ip.is_v6()];
#if TORRENT_USE_IPV6
if (ip.is_v6() && ext == address_v4()) return address_v6();
#endif
return ext;
}
}

6
src/kademlia/dht_state.cpp
View File

@ -61,10 +61,8 @@ namespace libtorrent { namespace dht {
address addr;
if (nid.string_length() == 24)
addr = detail::read_v4_address(in);
#if TORRENT_USE_IPV6
else if (nid.string_length() == 36)
addr = detail::read_v6_address(in);
#endif
else
continue;
ret.emplace_back(addr, id);
@ -110,10 +108,8 @@ namespace {
if (bdecode_node const nodes = e.dict_find_list("nodes"))
ret.nodes = detail::read_endpoint_list<udp::endpoint>(nodes);
#if TORRENT_USE_IPV6
if (bdecode_node const nodes = e.dict_find_list("nodes6"))
ret.nodes6 = detail::read_endpoint_list<udp::endpoint>(nodes);
#endif
return ret;
}
@ -130,10 +126,8 @@ namespace {
}
entry const nodes = save_nodes(state.nodes);
if (!nodes.list().empty()) ret["nodes"] = nodes;
#if TORRENT_USE_IPV6
entry const nodes6 = save_nodes(state.nodes6);
if (!nodes6.list().empty()) ret["nodes6"] = nodes6;
#endif
return ret;
}
}}

12
src/kademlia/dht_tracker.cpp
View File

@ -119,13 +119,11 @@ namespace libtorrent { namespace dht {
if (s.is_ssl()) return;
address const local_address = s.get_local_endpoint().address();
#if TORRENT_USE_IPV6
// don't try to start dht nodes on non-global IPv6 addresses
// with IPv4 the interface might be behind NAT so we can't skip them based on the scope of the local address
// and we might not have the external address yet
if (local_address.is_v6() && is_local(local_address))
return;
#endif
auto stored_nid = std::find_if(m_state.nids.begin(), m_state.nids.end()
, [&](node_ids_t::value_type const& nid) { return nid.first == local_address; });
node_id const nid = stored_nid != m_state.nids.end() ? stored_nid->second : node_id();
@ -160,12 +158,10 @@ namespace libtorrent { namespace dht {
{
if (s.is_ssl()) return;
#if TORRENT_USE_IPV6
address local_address = s.get_local_endpoint().address();
// since we don't start nodes on local IPv6 interfaces we don't need to remove them either
if (local_address.is_v6() && is_local(local_address))
return;
#endif
TORRENT_ASSERT(m_nodes.count(s) == 1);
m_nodes.erase(s);
}
@ -181,11 +177,9 @@ namespace libtorrent { namespace dht {
n.second.connection_timer.expires_from_now(seconds(1), ec);
n.second.connection_timer.async_wait(
std::bind(&dht_tracker::connection_timeout, self(), n.first, _1));
#if TORRENT_USE_IPV6
if (is_v6(n.first.get_local_endpoint()))
n.second.dht.bootstrap(concat(m_state.nodes6, m_state.nodes), f);
else
#endif
n.second.dht.bootstrap(concat(m_state.nodes, m_state.nodes6), f);
}
@ -626,18 +620,12 @@ namespace libtorrent { namespace dht {
void dht_tracker::add_node(udp::endpoint const& node)
{
#if !TORRENT_USE_IPV6
TORRENT_ASSERT(is_v4(node));
#endif
for (auto& n : m_nodes)
n.second.dht.add_node(node);
}
void dht_tracker::add_router_node(udp::endpoint const& node)
{
#if !TORRENT_USE_IPV6
TORRENT_ASSERT(is_v4(node));
#endif
for (auto& n : m_nodes)
n.second.dht.add_router_node(node);
}

10
src/kademlia/node.cpp
View File

@ -223,10 +223,6 @@ void node::bootstrap(std::vector<udp::endpoint> const& nodes
for (auto const& n : nodes)
{
#if !TORRENT_USE_IPV6
if (is_v6(n)) continue;
#endif
#ifndef TORRENT_DISABLE_LOGGING
++count;
#endif
@ -282,7 +278,6 @@ void node::incoming(aux::listen_socket_handle const& s, msg const& m)
ext_ip = r.dict_find_string("ip");
}
#if TORRENT_USE_IPV6
if (ext_ip && ext_ip.string_length() >= 16)
{
// this node claims we use the wrong node-ID!
@ -291,9 +286,8 @@ void node::incoming(aux::listen_socket_handle const& s, msg const& m)
if (m_observer != nullptr)
m_observer->set_external_address(m_sock, address_v6(b)
, m.addr.address());
} else
#endif
if (ext_ip && ext_ip.string_length() >= 4)
}
else if (ext_ip && ext_ip.string_length() >= 4)
{
address_v4::bytes_type b{};
std::memcpy(&b[0], ext_ip.string_ptr(), 4);

4
src/kademlia/node_id.cpp
View File

@ -85,14 +85,11 @@ node_id generate_id_impl(address const& ip_, std::uint32_t r)
std::uint8_t* ip = nullptr;
static const std::uint8_t v4mask[] = { 0x03, 0x0f, 0x3f, 0xff };
#if TORRENT_USE_IPV6
static const std::uint8_t v6mask[] = { 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
#endif
std::uint8_t const* mask = nullptr;
int num_octets = 0;
address_v4::bytes_type b4{};
#if TORRENT_USE_IPV6
address_v6::bytes_type b6{};
if (ip_.is_v6())
{
@ -102,7 +99,6 @@ node_id generate_id_impl(address const& ip_, std::uint32_t r)
mask = v6mask;
}
else
#endif
{
b4 = ip_.to_v4().to_bytes();
ip = b4.data();

11
src/kademlia/routing_table.cpp
View File

@ -78,31 +78,25 @@ namespace {
void ip_set::insert(address const& addr)
{
#if TORRENT_USE_IPV6
if (addr.is_v6())
m_ip6s.insert(addr.to_v6().to_bytes());
else
#endif
m_ip4s.insert(addr.to_v4().to_bytes());
}
bool ip_set::exists(address const& addr) const
{
#if TORRENT_USE_IPV6
if (addr.is_v6())
return m_ip6s.find(addr.to_v6().to_bytes()) != m_ip6s.end();
else
#endif
return m_ip4s.find(addr.to_v4().to_bytes()) != m_ip4s.end();
}
void ip_set::erase(address const& addr)
{
#if TORRENT_USE_IPV6
if (addr.is_v6())
erase_one(m_ip6s, addr.to_v6().to_bytes());
else
#endif
erase_one(m_ip4s, addr.to_v4().to_bytes());
}
@ -315,7 +309,6 @@ bool compare_ip_cidr(address const& lhs, address const& rhs)
{
TORRENT_ASSERT(lhs.is_v4() == rhs.is_v4());
#if TORRENT_USE_IPV6
if (lhs.is_v6())
{
// if IPv6 addresses is in the same /64, they're too close and we won't
@ -331,7 +324,6 @@ bool compare_ip_cidr(address const& lhs, address const& rhs)
return mask == 0;
}
else
#endif
{
// if IPv4 addresses is in the same /24, they're too close and we won't
// trust the second one
@ -1021,9 +1013,6 @@ void routing_table::node_failed(node_id const& nid, udp::endpoint const& ep)
void routing_table::add_router_node(udp::endpoint const& router)
{
#if !TORRENT_USE_IPV6
TORRENT_ASSERT(is_v4(router));
#endif
m_router_nodes.insert(router);
}

4
src/kademlia/rpc_manager.cpp
View File

@ -83,14 +83,12 @@ void observer::set_target(udp::endpoint const& ep)
m_sent = clock_type::now();
m_port = ep.port();
#if TORRENT_USE_IPV6
if (is_v6(ep))
{
flags |= flag_ipv6_address;
m_addr.v6 = ep.address().to_v6().to_bytes();
}
else
#endif
{
flags &= ~flag_ipv6_address;
m_addr.v4 = ep.address().to_v4().to_bytes();
@ -99,11 +97,9 @@ void observer::set_target(udp::endpoint const& ep)
address observer::target_addr() const
{
#if TORRENT_USE_IPV6
if (flags & flag_ipv6_address)
return address_v6(m_addr.v6);
else
#endif
return address_v4(m_addr.v4);
}

2
src/kademlia/traversal_algorithm.cpp
View File

@ -182,7 +182,6 @@ void traversal_algorithm::add_entry(node_id const& id
if (m_node.settings().restrict_search_ips
&& !(flags & observer::flag_initial))
{
#if TORRENT_USE_IPV6
if (o->target_addr().is_v6())
{
address_v6::bytes_type addr_bytes = o->target_addr().to_v6().to_bytes();
@ -193,7 +192,6 @@ void traversal_algorithm::add_entry(node_id const& id
goto add_result;
}
else
#endif
{
// mask the lower octet
std::uint32_t const prefix4

20
src/lsd.cpp
View File

@ -69,15 +69,11 @@ static error_code dummy;
lsd::lsd(io_service& ios, aux::lsd_callback& cb)
: m_callback(cb)
, m_socket(udp::endpoint(make_address_v4("239.192.152.143", dummy), 6771))
#if TORRENT_USE_IPV6
, m_socket6(udp::endpoint(make_address_v6("ff15::efc0:988f", dummy), 6771))
#endif
, m_broadcast_timer(ios)
, m_cookie((random(0x7fffffff) ^ std::uintptr_t(this)) & 0x7fffffff)
, m_disabled(false)
#if TORRENT_USE_IPV6
, m_disabled6(false)
#endif
{
}
@ -107,10 +103,8 @@ void lsd::start(error_code& ec)
, m_broadcast_timer.get_io_service(), ec);
if (ec) return;
#if TORRENT_USE_IPV6
m_socket6.open(std::bind(&lsd::on_announce, self(), _1, _2)
, m_broadcast_timer.get_io_service(), ec);
#endif
}
lsd::~lsd() = default;
@ -123,11 +117,7 @@ void lsd::announce(sha1_hash const& ih, int listen_port, bool broadcast)
void lsd::announce_impl(sha1_hash const& ih, int const listen_port
, bool const broadcast, int retry_count)
{
#if TORRENT_USE_IPV6
if (m_disabled && m_disabled6) return;
#else
if (m_disabled) return;
#endif
char msg[200];
@ -154,7 +144,6 @@ void lsd::announce_impl(sha1_hash const& ih, int const listen_port
}
}
#if TORRENT_USE_IPV6
if (!m_disabled6)
{
int const msg_len = render_lsd_packet(msg, sizeof(msg), listen_port, aux::to_hex(ih).c_str()
@ -172,16 +161,11 @@ void lsd::announce_impl(sha1_hash const& ih, int const listen_port
#endif
}
}
#endif
++retry_count;
if (retry_count >= 3) return;
#if TORRENT_USE_IPV6
if (m_disabled && m_disabled6) return;
#else
if (m_disabled) return;
#endif
ADD_OUTSTANDING_ASYNC("lsd::resend_announce");
m_broadcast_timer.expires_from_now(seconds(2 * retry_count), ec);
@ -292,15 +276,11 @@ void lsd::on_announce(udp::endpoint const& from, span<char const> buf)
void lsd::close()
{
m_socket.close();
#if TORRENT_USE_IPV6
m_socket6.close();
#endif
error_code ec;
m_broadcast_timer.cancel(ec);
m_disabled = true;
#if TORRENT_USE_IPV6
m_disabled6 = true;
#endif
}
} // libtorrent namespace

5
src/natpmp.cpp
View File

@ -504,9 +504,6 @@ void natpmp::send_map_request(port_mapping_t const i)
else if (m_version == version_pcp)
{
// PCP requires the use of IPv6 addresses even for IPv4 messages
// reference asio's address_v6 class directly so that we can use it
// even if TORRENT_USE_IPV6 is false
using boost::asio::ip::address_v6;
write_uint8(m_version, out);
write_uint8(opcode_map, out);
write_uint16(0, out); // reserved
@ -763,14 +760,12 @@ void natpmp::on_reply(error_code const& e
if (version == version_natpmp)
lifetime = aux::numeric_cast<int>(read_uint32(in));
address external_addr;
#if TORRENT_USE_IPV6
if (version == version_pcp)
{
external_addr = read_v6_address(in);
if (external_addr.to_v6().is_v4_mapped())
external_addr = external_addr.to_v6().to_v4();
}
#endif
if (version == version_natpmp)
{

6
src/peer_connection.cpp
View File

@ -340,7 +340,7 @@ namespace libtorrent {
}
#endif
}
#if TORRENT_USE_IPV6 && defined IPV6_TCLASS
#if defined IPV6_TCLASS
else if (is_v6(m_remote) && m_settings.get_int(settings_pack::peer_tos) != 0)
{
m_socket->set_option(traffic_class(char(m_settings.get_int(settings_pack::peer_tos))), ec);
@ -649,13 +649,11 @@ namespace libtorrent {
address_v4::bytes_type bytes = addr.to_v4().to_bytes();
x.assign(reinterpret_cast<char*>(bytes.data()), bytes.size());
}
#if TORRENT_USE_IPV6
else
{
address_v6::bytes_type bytes = addr.to_v6().to_bytes();
x.assign(reinterpret_cast<char*>(bytes.data()), bytes.size());
}
#endif
x.append(t->torrent_file().info_hash().data(), 20);
sha1_hash hash = hasher(x).final();
@ -6131,7 +6129,7 @@ namespace libtorrent {
}
#endif
}
#if TORRENT_USE_IPV6 && defined IPV6_TCLASS
#if defined IPV6_TCLASS
else if (is_v6(m_remote) && m_settings.get_int(settings_pack::peer_tos) != 0)
{
error_code err;

14
src/peer_list.cpp
View File

@ -734,21 +734,15 @@ namespace libtorrent {
);
}
#if TORRENT_USE_IPV6
bool const is_v6 = lt::is_v6(c.remote());
#else
bool const is_v6 = false;
#endif
torrent_peer* p = m_peer_allocator.allocate_peer_entry(
is_v6 ? torrent_peer_allocator_interface::ipv6_peer_type
: torrent_peer_allocator_interface::ipv4_peer_type);
if (p == nullptr) return false;
#if TORRENT_USE_IPV6
if (is_v6)
new (p) ipv6_peer(c.remote(), false, {});
else
#endif
new (p) ipv4_peer(c.remote(), false, {});
iter = m_peers.insert(iter, p);
@ -1043,13 +1037,11 @@ namespace libtorrent {
if (remote_address == address() || remote.port() == 0)
return nullptr;
#if TORRENT_USE_IPV6
// don't allow link-local IPv6 addresses since they
// can't be used like normal addresses, they require an interface
// and will just cause connect() to fail with EINVAL
if (remote_address.is_v6() && remote_address.to_v6().is_link_local())
return nullptr;
#endif
iterator iter;
torrent_peer* p = nullptr;
@ -1075,21 +1067,15 @@ namespace libtorrent {
// we don't have any info about this peer.
// add a new entry
#if TORRENT_USE_IPV6
bool const is_v6 = remote_address.is_v6();
#else
bool const is_v6 = false;
#endif
p = m_peer_allocator.allocate_peer_entry(
is_v6 ? torrent_peer_allocator_interface::ipv6_peer_type
: torrent_peer_allocator_interface::ipv4_peer_type);
if (p == nullptr) return nullptr;
#if TORRENT_USE_IPV6
if (is_v6)
new (p) ipv6_peer(remote, true, src);
else
#endif
new (p) ipv4_peer(remote, true, src);
try

6
src/read_resume_data.cpp
View File

@ -292,9 +292,7 @@ namespace {
}
}
#if TORRENT_USE_IPV6
int const v6_size = 18;
#endif
int const v4_size = 6;
using namespace libtorrent::detail; // for read_*_endpoint()
if (bdecode_node const peers_entry = rd.dict_find_string("peers"))
@ -304,14 +302,12 @@ namespace {
ret.peers.push_back(read_v4_endpoint<tcp::endpoint>(ptr));
}
#if TORRENT_USE_IPV6
if (bdecode_node const peers_entry = rd.dict_find_string("peers6"))
{
char const* ptr = peers_entry.string_ptr();
for (int i = v6_size - 1; i < peers_entry.string_length(); i += v6_size)
ret.peers.push_back(read_v6_endpoint<tcp::endpoint>(ptr));
}
#endif
if (bdecode_node const peers_entry = rd.dict_find_string("banned_peers"))
{
@ -320,14 +316,12 @@ namespace {
ret.banned_peers.push_back(read_v4_endpoint<tcp::endpoint>(ptr));
}
#if TORRENT_USE_IPV6
if (bdecode_node const peers_entry = rd.dict_find_string("banned_peers6"))
{
char const* ptr = peers_entry.string_ptr();
for (int i = v6_size - 1; i < peers_entry.string_length(); i += v6_size)
ret.banned_peers.push_back(read_v6_endpoint<tcp::endpoint>(ptr));
}
#endif
// parse unfinished pieces
if (bdecode_node const unfinished_entry = rd.dict_find_list("unfinished"))

34
src/session_impl.cpp
View File

@ -301,7 +301,6 @@ namespace aux {
{"127.0.0.0", "127.255.255.255", lfilter},
};
#if TORRENT_USE_IPV6
static const class_mapping v6_classes[] =
{
// everything
@ -313,7 +312,6 @@ namespace aux {
// loop-back
{"::1", "::1", lfilter},
};
#endif
class_mapping const* p = v4_classes;
int len = sizeof(v4_classes) / sizeof(v4_classes[0]);
@ -326,7 +324,6 @@ namespace aux {
if (ec) continue;
m_peer_class_filter.add_rule(begin, end, p[i].filter);
}
#if TORRENT_USE_IPV6
p = v6_classes;
len = sizeof(v6_classes) / sizeof(v6_classes[0]);
if (!unlimited_local) len = 1;
@ -338,7 +335,6 @@ namespace aux {
if (ec) continue;
m_peer_class_filter.add_rule(begin, end, p[i].filter);
}
#endif
}
#if defined TORRENT_USE_OPENSSL && OPENSSL_VERSION_NUMBER >= 0x90812f
@ -1398,7 +1394,6 @@ namespace aux {
}
#endif // TORRENT_WINDOWS
#if TORRENT_USE_IPV6
if (is_v6(bind_ep))
{
error_code err; // ignore errors here
@ -1423,7 +1418,6 @@ namespace aux {
#endif // TORRENT_DISABLE_LOGGING
#endif // TORRENT_WINDOWS
}
#endif // TORRENT_USE_IPV6
if (!lep.device.empty())
{
@ -1716,10 +1710,7 @@ namespace aux {
address const adr = make_address(device.c_str(), err);
if (!err)
{
#if !TORRENT_USE_IPV6
if (adr.is_v4())
#endif
eps.emplace_back(adr, port, std::string(), ssl, incoming);
eps.emplace_back(adr, port, std::string(), ssl, incoming);
}
else
{
@ -1811,13 +1802,11 @@ namespace aux {
interface_to_endpoints(device, port, ssl, incoming, eps);
}
#if TORRENT_USE_IPV6
std::vector<ip_interface> const ifs = enum_net_interfaces(m_io_service, ec);
if (!ec)
{
expand_unspecified_address(ifs, eps);
}
#endif
// if no listen interfaces are specified, create sockets to use
// any interface
@ -1825,10 +1814,8 @@ namespace aux {
{
eps.emplace_back(address_v4(), 0, "", transport::plaintext
, duplex::only_outgoing);
#if TORRENT_USE_IPV6
eps.emplace_back(address_v6(), 0, "", transport::plaintext
, duplex::only_outgoing);
#endif
}
auto remove_iter = partition_listen_sockets(eps, m_listen_sockets);
@ -1984,14 +1971,10 @@ namespace aux {
if (eps.empty())
{
eps.emplace_back(address_v4(), 0, "", transport::plaintext);
#if TORRENT_USE_IPV6
eps.emplace_back(address_v6(), 0, "", transport::plaintext);
#endif
#ifdef TORRENT_USE_OPENSSL
eps.emplace_back(address_v4(), 0, "", transport::ssl);
#if TORRENT_USE_IPV6
eps.emplace_back(address_v6(), 0, "", transport::ssl);
#endif
#endif
}
@ -2111,13 +2094,11 @@ namespace aux {
if (map_handle != port_mapping_t{-1}) m.delete_mapping(map_handle);
map_handle = port_mapping_t{-1};
#if TORRENT_USE_IPV6
address const addr = ep.address();
// with IPv4 the interface might be behind NAT so we can't skip them
// based on the scope of the local address
if (addr.is_v6() && is_local(addr))
return;
#endif
// only update this mapping if we actually have a socket listening
if (ep != EndpointType())
@ -3575,10 +3556,6 @@ namespace aux {
void session_impl::add_dht_node(udp::endpoint const& n)
{
TORRENT_ASSERT(is_single_thread());
#if !TORRENT_USE_IPV6
if (!is_v4(n)) return;
#endif
if (m_dht) m_dht->add_node(n);
else m_dht_nodes.push_back(n);
}
@ -5063,11 +5040,9 @@ namespace aux {
// to the same protocol family as the target endpoint
if (is_any(bind_ep.address()))
{
#if TORRENT_USE_IPV6
if (remote_address.is_v6())
bind_ep.address(address_v6::any());
else
#endif
bind_ep.address(address_v4::any());
}
@ -5942,9 +5917,6 @@ namespace aux {
for (auto const& addr : addresses)
{
#if !TORRENT_USE_IPV6
if (!addr.is_v4()) continue;
#endif
// router nodes should be added before the DHT is started (and bootstrapped)
udp::endpoint ep(addr, std::uint16_t(port));
if (m_dht) m_dht->add_router_node(ep);
@ -6241,7 +6213,7 @@ namespace aux {
template <typename Socket>
void set_tos(Socket& s, int v, error_code& ec)
{
#if TORRENT_USE_IPV6 && defined IPV6_TCLASS
#if defined IPV6_TCLASS
if (is_v6(s.local_endpoint(ec)))
s.set_option(traffic_class(char(v)), ec);
else if (!ec)
@ -7162,12 +7134,10 @@ namespace aux {
{
debug_log(" %s:%d", print_address(address_v4(p.ip)).c_str(), p.port);
}
#if TORRENT_USE_IPV6
for (auto const& p : resp.peers6)
{
debug_log(" [%s]:%d", print_address(address_v6(p.ip)).c_str(), p.port);
}
#endif
}
void tracker_logger::tracker_request_error(tracker_request const&

4
src/settings_pack.cpp
View File

@ -118,11 +118,7 @@ constexpr int CLOSE_FILE_INTERVAL = 0;
DEPRECATED_SET_STR(mmap_cache, nullptr, nullptr),
SET(handshake_client_version, nullptr, nullptr),
SET(outgoing_interfaces, "", &session_impl::update_outgoing_interfaces),
#if !TORRENT_USE_IPV6
SET(listen_interfaces, "0.0.0.0:6881", &session_impl::update_listen_interfaces),
#else
SET(listen_interfaces, "0.0.0.0:6881,[::]:6881", &session_impl::update_listen_interfaces),
#endif
SET(proxy_hostname, "", &session_impl::update_proxy),
SET(proxy_username, "", &session_impl::update_proxy),
SET(proxy_password, "", &session_impl::update_proxy),

8
src/socket_io.cpp
View File

@ -68,11 +68,9 @@ namespace libtorrent {
{
error_code ec;
char buf[200];
#if TORRENT_USE_IPV6
if (addr.is_v6())
std::snprintf(buf, sizeof(buf), "[%s]:%d", addr.to_string(ec).c_str(), port);
else
#endif
std::snprintf(buf, sizeof(buf), "%s:%d", addr.to_string(ec).c_str(), port);
return buf;
}
@ -120,11 +118,7 @@ namespace libtorrent {
}
// shave off the ':'
port = port.substr(1);
#if TORRENT_USE_IPV6
ret.address(make_address_v6(addr.to_string(), ec));
#else
ec = boost::asio::error::address_family_not_supported;
#endif
if (ec) return ret;
}
else
@ -159,14 +153,12 @@ namespace libtorrent {
sha1_hash hash_address(address const& ip)
{
#if TORRENT_USE_IPV6
if (ip.is_v6())
{
address_v6::bytes_type b = ip.to_v6().to_bytes();
return hasher(reinterpret_cast<char const*>(b.data()), int(b.size())).final();
}
else
#endif
{
address_v4::bytes_type b = ip.to_v4().to_bytes();
return hasher(reinterpret_cast<char const*>(b.data()), int(b.size())).final();

17
src/string_util.cpp
View File

@ -177,7 +177,6 @@ namespace libtorrent {
{
if (!ret.empty()) ret += ',';
#if TORRENT_USE_IPV6
error_code ec;
make_address_v6(i.device, ec);
if (!ec)
@ -188,7 +187,6 @@ namespace libtorrent {
ret += ']';
}
else
#endif
{
ret += i.device;
}
@ -220,14 +218,8 @@ namespace libtorrent {
listen_interface_t iface;
iface.ssl = false;
#if !TORRENT_USE_IPV6
bool ipv6 = false;
#endif
if (in[start] == '[')
{
#if !TORRENT_USE_IPV6
ipv6 = true;
#endif
++start;
// IPv6 address
while (start < in.size() && in[start] != ']')
@ -285,14 +277,7 @@ namespace libtorrent {
while (start < in.size() && in[start] != ',')
++start;
if (iface.port >= 0
#if !TORRENT_USE_IPV6
&& ipv6 == false
#endif
)
{
out.push_back(iface);
}
if (iface.port >= 0) out.push_back(iface);
// skip the comma
if (start < in.size() && in[start] == ',')

18
src/torrent.cpp
View File

@ -2776,7 +2776,6 @@ bool is_downloading_state(int const st)
req.event = e;
#if TORRENT_USE_IPV6
// since sending our IPv6 address to the tracker may be sensitive. Only
// do that if we're not in anonymous mode and if it's a private torrent
if (!settings().get_bool(settings_pack::anonymous_mode)
@ -2792,7 +2791,6 @@ bool is_downloading_state(int const st)
req.ipv6.push_back(s.get_local_endpoint().address().to_v6());
});
}
#endif
// if we are aborting. we don't want any new peers
req.num_want = (req.event == tracker_request::stopped)
@ -3215,13 +3213,11 @@ bool is_downloading_state(int const st)
need_update |= bool(add_peer(a, peer_info::tracker) != nullptr);
}
#if TORRENT_USE_IPV6
for (auto const& i : resp.peers6)
{
tcp::endpoint a(address_v6(i.ip), i.port);
need_update |= bool(add_peer(a, peer_info::tracker) != nullptr);
}
#endif
if (need_update) state_updated();
update_want_peers();
@ -3232,9 +3228,7 @@ bool is_downloading_state(int const st)
{
m_ses.alerts().emplace_alert<tracker_reply_alert>(
get_handle(), local_endpoint, int(resp.peers.size() + resp.peers4.size())
#if TORRENT_USE_IPV6
+ int(resp.peers6.size())
#endif
, r.url);
}
@ -10068,18 +10062,6 @@ bool is_downloading_state(int const st)
{
TORRENT_ASSERT(is_single_thread());
#if !TORRENT_USE_IPV6
if (!is_v4(adr))
{
#ifndef TORRENT_DISABLE_LOGGING
error_code ec;
debug_log("add_peer() %s unsupported address family"
, adr.address().to_string(ec).c_str());
#endif
return nullptr;
}
#endif
#ifndef TORRENT_DISABLE_DHT
if (source != peer_info::resume_data)
{

13
src/torrent_peer.cpp
View File

@ -88,7 +88,6 @@ namespace libtorrent {
detail::write_uint16(e2.port(), ptr);
ret = crc32c_32(p);
}
#if TORRENT_USE_IPV6
else if (is_v6(e1))
{
static const std::uint8_t v6mask[][8] = {
@ -109,7 +108,6 @@ namespace libtorrent {
memcpy(&addrbuf[2], b2.data(), 16);
ret = crc32c(addrbuf, 4);
}
#endif
else
{
static const std::uint8_t v4mask[][4] = {
@ -158,9 +156,7 @@ namespace libtorrent {
// retry with encryption
, pe_support(false)
#endif
#if TORRENT_USE_IPV6
, is_v6_addr(false)
#endif
#if TORRENT_USE_I2P
, is_i2p_addr(false)
#endif
@ -228,9 +224,7 @@ namespace libtorrent {
: torrent_peer(ep.port(), c, src)
, addr(ep.address().to_v4())
{
#if TORRENT_USE_IPV6
is_v6_addr = false;
#endif
#if TORRENT_USE_I2P
is_i2p_addr = false;
#endif
@ -245,14 +239,11 @@ namespace libtorrent {
: torrent_peer(0, connectable, src)
, destination(dest)
{
#if TORRENT_USE_IPV6
is_v6_addr = false;
#endif
is_i2p_addr = true;
}
#endif // TORRENT_USE_I2P
#if TORRENT_USE_IPV6
ipv6_peer::ipv6_peer(tcp::endpoint const& ep, bool c
, peer_source_flags_t const src)
: torrent_peer(ep.port(), c, src)
@ -266,8 +257,6 @@ namespace libtorrent {
ipv6_peer::ipv6_peer(ipv6_peer const&) = default;
#endif // TORRENT_USE_IPV6
#if TORRENT_USE_I2P
string_view torrent_peer::dest() const
{
@ -279,12 +268,10 @@ namespace libtorrent {
libtorrent::address torrent_peer::address() const
{
#if TORRENT_USE_IPV6
if (is_v6_addr)
return libtorrent::address_v6(
static_cast<ipv6_peer const*>(this)->addr);
else
#endif
#if TORRENT_USE_I2P
if (is_i2p_addr) return libtorrent::address();
else

4
src/torrent_peer_allocator.cpp
View File

@ -52,7 +52,6 @@ namespace libtorrent {
++m_live_allocations;
++m_total_allocations;
break;
#if TORRENT_USE_IPV6
case torrent_peer_allocator_interface::ipv6_peer_type:
p = static_cast<torrent_peer*>(m_ipv6_peer_pool.malloc());
if (p == nullptr) return nullptr;
@ -62,7 +61,6 @@ namespace libtorrent {
++m_live_allocations;
++m_total_allocations;
break;
#endif
#if TORRENT_USE_I2P
case torrent_peer_allocator_interface::i2p_peer_type:
p = static_cast<torrent_peer*>(m_i2p_peer_pool.malloc());
@ -82,7 +80,6 @@ namespace libtorrent {
{
TORRENT_ASSERT(m_in_use);
TORRENT_ASSERT(p->in_use);
#if TORRENT_USE_IPV6
if (p->is_v6_addr)
{
TORRENT_ASSERT(m_ipv6_peer_pool.is_from(static_cast<libtorrent::ipv6_peer*>(p)));
@ -94,7 +91,6 @@ namespace libtorrent {
--m_live_allocations;
return;
}
#endif
#if TORRENT_USE_I2P
if (p->is_i2p_addr)
{

4
src/udp_socket.cpp
View File

@ -389,13 +389,11 @@ bool udp_socket::unwrap(udp::endpoint& from, span<char>& buf)
// IPv4
from = read_v4_endpoint<udp::endpoint>(p);
}
#if TORRENT_USE_IPV6
else if (atyp == 4)
{
// IPv6
from = read_v6_endpoint<udp::endpoint>(p);
}
#endif
else
{
int const len = read_uint8(p);
@ -443,7 +441,6 @@ void udp_socket::open(udp const& protocol, error_code& ec)
m_socket.open(protocol, ec);
if (ec) return;
#if TORRENT_USE_IPV6
if (protocol == udp::v6())
{
error_code err;
@ -454,7 +451,6 @@ void udp_socket::open(udp const& protocol, error_code& ec)
m_socket.set_option(v6_protection_level(PROTECTION_LEVEL_UNRESTRICTED), err);
#endif // TORRENT_WINDOWS
}
#endif
// this is best-effort. ignore errors
#ifdef TORRENT_WINDOWS

12
src/udp_tracker_connection.cpp
View File

@ -209,16 +209,12 @@ namespace libtorrent {
// we're listening on. To make sure the tracker get our
// correct listening address.
bool is_v4 = bind_address.is_v4();
#if TORRENT_USE_IPV6
auto scope = is_v4 ? 0 : bind_address.to_v6().scope_id();
#endif
for (auto const& addr : addresses)
{
if (addr.is_v4() != is_v4) continue;
#if TORRENT_USE_IPV6
if (addr.is_v6() && addr.to_v6().scope_id() != scope)
continue;
#endif
m_endpoints.emplace_back(addr, std::uint16_t(port));
}
@ -624,11 +620,7 @@ namespace libtorrent {
resp.incomplete = aux::read_int32(buf);
resp.complete = aux::read_int32(buf);
std::size_t const ip_stride =
#if TORRENT_USE_IPV6
is_v6(m_target) ? 18 :
#endif
6;
std::size_t const ip_stride = is_v6(m_target) ? 18 : 6;
std::size_t const num_peers = buf.size() / ip_stride;
if (buf.size() % ip_stride != 0)
@ -651,7 +643,6 @@ namespace libtorrent {
return true;
}
#if TORRENT_USE_IPV6
if (is_v6(m_target))
{
resp.peers6.reserve(num_peers);
@ -665,7 +656,6 @@ namespace libtorrent {
}
}
else
#endif
{
resp.peers4.reserve(num_peers);
for (std::size_t i = 0; i < num_peers; ++i)

13
src/ut_pex.cpp
View File

@ -113,14 +113,12 @@ namespace libtorrent { namespace {
std::back_insert_iterator<std::string> pla_out(pla);
std::back_insert_iterator<std::string> pld_out(pld);
std::back_insert_iterator<std::string> plf_out(plf);
#if TORRENT_USE_IPV6
std::string& pla6 = pex["added6"].string();
std::string& pld6 = pex["dropped6"].string();
std::string& plf6 = pex["added6.f"].string();
std::back_insert_iterator<std::string> pla6_out(pla6);
std::back_insert_iterator<std::string> pld6_out(pld6);
std::back_insert_iterator<std::string> plf6_out(plf6);
#endif
std::set<tcp::endpoint> dropped;
m_old_peers.swap(dropped);
@ -179,13 +177,11 @@ namespace libtorrent { namespace {
detail::write_endpoint(remote, pla_out);
detail::write_uint8(static_cast<std::uint8_t>(flags), plf_out);
}
#if TORRENT_USE_IPV6
else
{
detail::write_endpoint(remote, pla6_out);
detail::write_uint8(static_cast<std::uint8_t>(flags), plf6_out);
}
#endif
++num_added;
++m_peers_in_message;
}
@ -201,10 +197,8 @@ namespace libtorrent { namespace {
{
if (is_v4(i))
detail::write_endpoint(i, pld_out);
#if TORRENT_USE_IPV6
else
detail::write_endpoint(i, pld6_out);
#endif
++m_peers_in_message;
}
@ -352,8 +346,6 @@ namespace libtorrent { namespace {
}
}
#if TORRENT_USE_IPV6
bdecode_node p6 = pex_msg.dict_find("dropped6");
#ifndef TORRENT_DISABLE_LOGGING
if (p6) num_dropped += p6.string_length() / 18;
@ -403,7 +395,6 @@ namespace libtorrent { namespace {
peers_added = true;
}
}
#endif
#ifndef TORRENT_DISABLE_LOGGING
m_pc.peer_log(peer_log_alert::incoming_message, "PEX", "dropped: %d added: %d"
, num_dropped, num_added);
@ -524,13 +515,11 @@ namespace libtorrent { namespace {
std::back_insert_iterator<std::string> pla_out(pla);
std::back_insert_iterator<std::string> plf_out(plf);
#if TORRENT_USE_IPV6
pex["dropped6"].string();
std::string& pla6 = pex["added6"].string();
std::string& plf6 = pex["added6.f"].string();
std::back_insert_iterator<std::string> pla6_out(pla6);
std::back_insert_iterator<std::string> plf6_out(plf6);
#endif
int num_added = 0;
for (auto const peer : m_torrent)
@ -578,13 +567,11 @@ namespace libtorrent { namespace {
detail::write_endpoint(remote, pla_out);
detail::write_uint8(flags, plf_out);
}
#if TORRENT_USE_IPV6
else
{
detail::write_endpoint(remote, pla6_out);
detail::write_uint8(flags, plf6_out);
}
#endif
++num_added;
}
std::vector<char> pex_msg;

8
src/write_resume_data.cpp
View File

@ -190,16 +190,12 @@ namespace libtorrent {
if (!atp.peers.empty())
{
std::back_insert_iterator<entry::string_type> ptr(ret["peers"].string());
#if TORRENT_USE_IPV6
std::back_insert_iterator<entry::string_type> ptr6(ret["peers6"].string());
#endif
for (auto const& p : atp.peers)
{
#if TORRENT_USE_IPV6
if (is_v6(p))
write_endpoint(p, ptr6);
else
#endif
write_endpoint(p, ptr);
}
}
@ -207,16 +203,12 @@ namespace libtorrent {
if (!atp.banned_peers.empty())
{
std::back_insert_iterator<entry::string_type> ptr(ret["banned_peers"].string());
#if TORRENT_USE_IPV6
std::back_insert_iterator<entry::string_type> ptr6(ret["banned_peers6"].string());
#endif
for (auto const& p : atp.banned_peers)
{
#if TORRENT_USE_IPV6
if (is_v6(p))
write_endpoint(p, ptr6);
else
#endif
write_endpoint(p, ptr);
}
}

2
test/bittorrent_peer.cpp
View File

@ -272,12 +272,10 @@ void peer_conn::close(char const* fmt, error_code const& ec)
char ep_str[200];
address const& addr = s.local_endpoint(e).address();
#if TORRENT_USE_IPV6
if (addr.is_v6())
std::snprintf(ep_str, sizeof(ep_str), "[%s]:%d", addr.to_string(e).c_str()
, s.local_endpoint(e).port());
else
#endif
std::snprintf(ep_str, sizeof(ep_str), "%s:%d", addr.to_string(e).c_str()
, s.local_endpoint(e).port());
std::printf("%s ep: %s sent: %d received: %d duration: %d ms up: %.1fMB/s down: %.1fMB/s\n"

4
test/setup_transfer.cpp
View File

@ -126,7 +126,6 @@ sha1_hash to_hash(char const* s)
return ret;
}
#if TORRENT_USE_IPV6
address rand_v6()
{
address_v6::bytes_type bytes;
@ -134,7 +133,6 @@ address rand_v6()
bytes[static_cast<std::size_t>(i)] = std::uint8_t(lt::random(0xff));
return address_v6(bytes);
}
#endif
static std::uint16_t g_port = 0;
@ -1025,7 +1023,6 @@ lt::address_v4 addr4(char const* ip)
return ret;
}
#if TORRENT_USE_IPV6
lt::address_v6 addr6(char const* ip)
{
lt::error_code ec;
@ -1033,4 +1030,3 @@ lt::address_v6 addr6(char const* ip)
TEST_CHECK(!ec);
return ret;
}
#endif

4
test/setup_transfer.hpp
View File

@ -52,9 +52,7 @@ EXPORT void report_failure(char const* err, char const* file, int line);
EXPORT void init_rand_address();
EXPORT lt::address rand_v4();
#if TORRENT_USE_IPV6
EXPORT lt::address rand_v6();
#endif
EXPORT lt::tcp::endpoint rand_tcp_ep(lt::address(&rand_addr)() = rand_v4);
EXPORT lt::udp::endpoint rand_udp_ep(lt::address(&rand_addr)() = rand_v4);
@ -121,8 +119,6 @@ EXPORT lt::tcp::endpoint ep(char const* ip, int port);
EXPORT lt::udp::endpoint uep(char const* ip, int port);
EXPORT lt::address addr(char const* ip);
EXPORT lt::address_v4 addr4(char const* ip);
#if TORRENT_USE_IPV6
EXPORT lt::address_v6 addr6(char const* ip);
#endif
#endif

15
test/test_alert_types.cpp
View File

@ -194,13 +194,8 @@ TORRENT_TEST(dht_get_peers_reply_alert)
tcp::endpoint const ep1 = rand_tcp_ep(rand_v4);
tcp::endpoint const ep2 = rand_tcp_ep(rand_v4);
tcp::endpoint const ep3 = rand_tcp_ep(rand_v4);
#if TORRENT_USE_IPV6
tcp::endpoint const ep4 = rand_tcp_ep(rand_v6);
tcp::endpoint const ep5 = rand_tcp_ep(rand_v6);
#else
tcp::endpoint const ep4 = rand_tcp_ep(rand_v4);
tcp::endpoint const ep5 = rand_tcp_ep(rand_v4);
#endif
std::vector<tcp::endpoint> v = {ep1, ep2, ep3, ep4, ep5};
mgr.emplace_alert<dht_get_peers_reply_alert>(ih, v);
@ -232,13 +227,8 @@ TORRENT_TEST(dht_live_nodes_alert)
udp::endpoint const ep1 = rand_udp_ep(rand_v4);
udp::endpoint const ep2 = rand_udp_ep(rand_v4);
udp::endpoint const ep3 = rand_udp_ep(rand_v4);
#if TORRENT_USE_IPV6
udp::endpoint const ep4 = rand_udp_ep(rand_v6);
udp::endpoint const ep5 = rand_udp_ep(rand_v6);
#else
udp::endpoint const ep4 = rand_udp_ep(rand_v4);
udp::endpoint const ep5 = rand_udp_ep(rand_v4);
#endif
std::vector<std::pair<sha1_hash, udp::endpoint>> v;
v.emplace_back(h1, ep1);
v.emplace_back(h2, ep2);
@ -306,13 +296,8 @@ TORRENT_TEST(dht_sample_infohashes_alert)
udp::endpoint const nep1 = rand_udp_ep(rand_v4);
udp::endpoint const nep2 = rand_udp_ep(rand_v4);
udp::endpoint const nep3 = rand_udp_ep(rand_v4);
#if TORRENT_USE_IPV6
udp::endpoint const nep4 = rand_udp_ep(rand_v6);
udp::endpoint const nep5 = rand_udp_ep(rand_v6);
#else
udp::endpoint const nep4 = rand_udp_ep(rand_v4);
udp::endpoint const nep5 = rand_udp_ep(rand_v4);
#endif
std::vector<std::pair<sha1_hash, udp::endpoint>> nv;
nv.emplace_back(nh1, nep1);
nv.emplace_back(nh2, nep2);

26
test/test_dht.cpp
View File

@ -143,7 +143,6 @@ std::shared_ptr<aux::listen_socket_t> dummy_listen_socket4()
return ret;
}
#if TORRENT_USE_IPV6
std::shared_ptr<aux::listen_socket_t> dummy_listen_socket6()
{
auto ret = std::make_shared<aux::listen_socket_t>();
@ -152,7 +151,6 @@ std::shared_ptr<aux::listen_socket_t> dummy_listen_socket6()
, aux::session_interface::source_dht, rand_v6());
return ret;
}
#endif
node* get_foreign_node_stub(node_id const&, std::string const&)
{
@ -1038,13 +1036,11 @@ TORRENT_TEST(scrape_v4)
test_scrape(rand_v4);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(scrape_v6)
{
if (supports_ipv6())
test_scrape(rand_v6);
}
#endif
namespace {
@ -1148,13 +1144,11 @@ TORRENT_TEST(id_enforcement_v4)
test_id_enforcement(rand_v4);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(id_enforcement_v6)
{
if (supports_ipv6())
test_id_enforcement(rand_v6);
}
#endif
TORRENT_TEST(bloom_filter)
{
@ -1578,13 +1572,11 @@ TORRENT_TEST(put_v4)
test_put(rand_v4);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(put_v6)
{
if (supports_ipv6())
test_put(rand_v6);
}
#endif
namespace {
@ -1608,14 +1600,12 @@ void test_routing_table(address(&rand_addr)())
address node_addr;
address node_near_addr;
#if TORRENT_USE_IPV6
if (is_v6(t.source))
{
node_addr = addr6("2001:1111:1111:1111:1111:1111:1111:1111");
node_near_addr = addr6("2001:1111:1111:1111:eeee:eeee:eeee:eeee");
}
else
#endif
{
node_addr = addr4("4.4.4.4");
node_near_addr = addr4("4.4.4.5");
@ -1802,13 +1792,11 @@ TORRENT_TEST(routing_table_v4)
test_routing_table(rand_v4);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(routing_table_v6)
{
if (supports_ipv6())
test_routing_table(rand_v6);
}
#endif
namespace {
@ -1907,15 +1895,12 @@ TORRENT_TEST(bootstrap_v4)
test_bootstrap(rand_v4);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(bootstrap_v6)
{
if (supports_ipv6())
test_bootstrap(rand_v6);
}
#endif
#if TORRENT_USE_IPV6
namespace {
void test_bootstrap_want(address(&rand_addr)())
@ -1986,7 +1971,6 @@ TORRENT_TEST(bootstrap_want_v6)
{
test_bootstrap_want(rand_v6);
}
#endif
namespace {
@ -2070,13 +2054,11 @@ TORRENT_TEST(short_nodes_v4)
test_short_nodes(rand_v4);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(short_nodes_v6)
{
if (supports_ipv6())
test_short_nodes(rand_v6);
}
#endif
namespace {
@ -2208,13 +2190,11 @@ TORRENT_TEST(get_peers_v4)
test_get_peers(rand_v4);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(get_peers_v6)
{
if (supports_ipv6())
test_get_peers(rand_v6);
}
#endif
namespace {
@ -2316,7 +2296,6 @@ TORRENT_TEST(mutable_get_salt_v4)
test_mutable_get(rand_v4, true);
}
#if TORRENT_USE_IPV6
TORRENT_TEST(mutable_get_v6)
{
if (supports_ipv6())
@ -2328,7 +2307,6 @@ TORRENT_TEST(mutable_get_salt_v6)
if (supports_ipv6())
test_mutable_get(rand_v6, true);
}
#endif
TORRENT_TEST(immutable_get)
{
@ -2681,7 +2659,6 @@ TORRENT_TEST(traversal_done)
g_put_count = 0;
}
#if TORRENT_USE_IPV6
TORRENT_TEST(dht_dual_stack)
{
// TODO: 3 use dht_test_setup class to simplify the node setup
@ -2820,7 +2797,6 @@ TORRENT_TEST(dht_dual_stack)
TEST_ERROR(error_string);
}
}
#endif
TORRENT_TEST(multi_home)
{
@ -3657,7 +3633,6 @@ TORRENT_TEST(compare_ip_cidr)
addr4(std::get<0>(t)), addr4(std::get<1>(t))), std::get<2>(t));
}
#if TORRENT_USE_IPV6
std::vector<tst> const v6tests = {
tst{"::1", "::ffff:ffff:ffff:ffff", true},
tst{"::2:0000:0000:0000:0000", "::1:ffff:ffff:ffff:ffff", false},
@ -3676,7 +3651,6 @@ TORRENT_TEST(compare_ip_cidr)
TEST_EQUAL(compare_ip_cidr(
addr6(std::get<0>(t)), addr6(std::get<1>(t))), std::get<2>(t));
}
#endif
}
TORRENT_TEST(dht_state)

2
test/test_dht_storage.cpp
View File

@ -123,7 +123,6 @@ TORRENT_TEST(announce_peer)
TEST_CHECK(!peers.find_key("values"));
}
#if TORRENT_USE_IPV6
TORRENT_TEST(dual_stack)
{
dht::dht_settings sett = test_settings();
@ -149,7 +148,6 @@ TORRENT_TEST(dual_stack)
s->get_peers(n1, false, false, address_v6(), peers6);
TEST_EQUAL(peers6["values"].list().size(), 2);
}
#endif
TORRENT_TEST(put_items)
{

6
test/test_enum_net.cpp
View File

@ -54,13 +54,11 @@ TORRENT_TEST(is_loopback)
error_code ec;
TEST_CHECK(is_loopback(address::from_string("127.0.0.1", ec)));
TEST_CHECK(!ec);
#if TORRENT_USE_IPV6
if (supports_ipv6())
{
TEST_CHECK(is_loopback(address::from_string("::1", ec)));
TEST_CHECK(!ec);
}
#endif
}
TORRENT_TEST(is_any)
@ -69,13 +67,11 @@ TORRENT_TEST(is_any)
error_code ec;
TEST_CHECK(!is_any(address::from_string("31.53.21.64", ec)));
TEST_CHECK(!ec);
#if TORRENT_USE_IPV6
if (supports_ipv6())
{
TEST_CHECK(is_any(address_v6::any()));
TEST_CHECK(!ec);
}
#endif
}
TORRENT_TEST(match_addr_mask)
@ -105,8 +101,6 @@ TORRENT_TEST(is_ip_address)
TEST_EQUAL(is_ip_address("1.2.3.4"), true);
TEST_EQUAL(is_ip_address("a.b.c.d"), false);
TEST_EQUAL(is_ip_address("a:b:b:c"), false);
#if TORRENT_USE_IPV6
TEST_EQUAL(is_ip_address("::1"), true);
TEST_EQUAL(is_ip_address("2001:db8:85a3:0:0:8a2e:370:7334"), true);
#endif
}

31
test/test_ip_filter.cpp
View File

@ -90,11 +90,7 @@ TORRENT_TEST(session_get_ip_filter)
{
session ses(settings());
ip_filter const& ipf = ses.get_ip_filter();
#if TORRENT_USE_IPV6
TEST_EQUAL(std::get<0>(ipf.export_filter()).size(), 1);
#else
TEST_EQUAL(ipf.export_filter().size(), 1);
#endif
}
TORRENT_TEST(ip_filter)
@ -115,11 +111,7 @@ TORRENT_TEST(ip_filter)
f.add_rule(addr("1.0.0.0"), addr("2.0.0.0"), ip_filter::blocked);
f.add_rule(addr("2.0.0.1"), addr("3.0.0.0"), ip_filter::blocked);
#if TORRENT_USE_IPV6
range = std::get<0>(f.export_filter());
#else
range = f.export_filter();
#endif
test_rules_invariant(range, f);
TEST_CHECK(range.size() == 3);
@ -134,11 +126,7 @@ TORRENT_TEST(ip_filter)
f.add_rule(addr("2.0.0.1"), addr("3.0.0.0"), ip_filter::blocked);
f.add_rule(addr("1.0.0.0"), addr("2.0.0.0"), ip_filter::blocked);
#if TORRENT_USE_IPV6
range = std::get<0>(f.export_filter());
#else
range = f.export_filter();
#endif
test_rules_invariant(range, f);
TEST_CHECK(range.size() == 3);
@ -154,11 +142,7 @@ TORRENT_TEST(ip_filter)
f.add_rule(addr("2.0.0.1"), addr("3.0.0.0"), ip_filter::blocked);
f.add_rule(addr("1.0.0.0"), addr("2.4.0.0"), ip_filter::blocked);
#if TORRENT_USE_IPV6
range = std::get<0>(f.export_filter());
#else
range = f.export_filter();
#endif
test_rules_invariant(range, f);
TEST_CHECK(range.size() == 3);
@ -174,11 +158,7 @@ TORRENT_TEST(ip_filter)
f.add_rule(addr("1.0.0.0"), addr("2.4.0.0"), ip_filter::blocked);
f.add_rule(addr("2.0.0.1"), addr("3.0.0.0"), ip_filter::blocked);
#if TORRENT_USE_IPV6
range = std::get<0>(f.export_filter());
#else
range = f.export_filter();
#endif
test_rules_invariant(range, f);
TEST_CHECK(range.size() == 3);
@ -198,11 +178,7 @@ TORRENT_TEST(ip_filter)
f.add_rule(addr("1.0.1.0"), addr("9.0.0.0"), ip_filter::blocked);
#if TORRENT_USE_IPV6
range = std::get<0>(f.export_filter());
#else
range = f.export_filter();
#endif
test_rules_invariant(range, f);
TEST_CHECK(range.size() == 3);
@ -228,11 +204,7 @@ TORRENT_TEST(ip_filter)
f.add_rule(addr("0.0.1.0"), addr("7.0.4.0"), ip_filter::blocked);
#if TORRENT_USE_IPV6
range = std::get<0>(f.export_filter());
#else
range = f.export_filter();
#endif
test_rules_invariant(range, f);
TEST_CHECK(range.size() == 3);
@ -249,8 +221,6 @@ TORRENT_TEST(ip_filter)
// **** test IPv6 ****
#if TORRENT_USE_IPV6
ip_range<address_v6> expected2[] =
{
{addr6("::0"), addr6("0:ffff:ffff:ffff:ffff:ffff:ffff:ffff"), 0}
@ -270,7 +240,6 @@ TORRENT_TEST(ip_filter)
TEST_EQUAL(rangev6.size(), 3);
TEST_CHECK(std::equal(rangev6.begin(), rangev6.end(), expected2, &compare<address_v6>));
}
#endif
port_filter pf;

7
test/test_ip_voter.cpp
View File

@ -195,7 +195,6 @@ TORRENT_TEST(ip_voter_2)
address malicious2;
address real_external2;
address malicious_external2;
#if TORRENT_USE_IPV6
if (supports_ipv6())
{
malicious2 = address_v6::from_string("2f90::", ec);
@ -205,25 +204,19 @@ TORRENT_TEST(ip_voter_2)
malicious_external2 = address_v6::from_string("2f70::", ec);
TEST_CHECK(!ec);
}
#endif
for (int i = 0; i < 50; ++i)
{
ipv2.cast_vote(real_external1, aux::session_interface::source_dht, rand_v4());
ipv2.cast_vote(malicious_external, aux::session_interface::source_dht, malicious);
#if TORRENT_USE_IPV6
if (supports_ipv6())
{
ipv6.cast_vote(real_external2, aux::session_interface::source_dht, rand_v6());
ipv6.cast_vote(malicious_external2, aux::session_interface::source_dht, malicious2);
}
#endif
}
TEST_CHECK(ipv2.external_address() == real_external1);
#if TORRENT_USE_IPV6
if (supports_ipv6())
TEST_CHECK(ipv6.external_address() == real_external2);
#endif
}

5
test/test_magnet.cpp
View File

@ -307,14 +307,9 @@ TORRENT_TEST(parse_peer)
{
add_torrent_params p = parse_magnet_uri("magnet:?xt=urn:btih:cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"
"&dn=foo&x.pe=127.0.0.1:43&x.pe=<invalid1>&x.pe=<invalid2>:100&x.pe=[::1]:45");
#if TORRENT_USE_IPV6
TEST_EQUAL(p.peers.size(), 2);
TEST_EQUAL(p.peers[0], ep("127.0.0.1", 43));
TEST_EQUAL(p.peers[1], ep("::1", 45));
#else
TEST_EQUAL(p.peers.size(), 1);
TEST_EQUAL(p.peers[0], ep("127.0.0.1", 43));
#endif
}
#ifndef TORRENT_DISABLE_DHT

4
test/test_peer_classes.cpp
View File

@ -131,12 +131,8 @@ TORRENT_TEST(session_peer_class_filter)
, 1 << static_cast<std::uint32_t>(my_class));
ses.set_peer_class_filter(f);
#if TORRENT_USE_IPV6
TEST_CHECK(std::get<0>(ses.get_peer_class_filter().export_filter())
== std::get<0>(f.export_filter()));
#else
TEST_CHECK(ses.get_peer_class_filter().export_filter() == f.export_filter());
#endif
}
TORRENT_TEST(session_peer_class_type_filter)

2
test/test_primitives.cpp
View File

@ -122,10 +122,8 @@ TORRENT_TEST(address_endpoint_io)
TEST_EQUAL(print_endpoint(ep("127.0.0.1", 23)), "127.0.0.1:23");
TEST_EQUAL(print_address(addr4("241.124.23.5")), "241.124.23.5");
#if TORRENT_USE_IPV6
TEST_EQUAL(print_endpoint(ep("ff::1", 1214)), "[ff::1]:1214");
TEST_EQUAL(print_address(addr6("2001:ff::1")), "2001:ff::1");
#endif
// test address_to_bytes
TEST_EQUAL(address_to_bytes(addr4("10.11.12.13")), "\x0a\x0b\x0c\x0d");

4
test/test_session_params.cpp
View File

@ -113,10 +113,8 @@ TORRENT_TEST(dht_state)
s.nids.emplace_back(addr4("0.0.0.0"), to_hash("0000000000000000000000000000000000000001"));
s.nodes.push_back(uep("1.1.1.1", 1));
s.nodes.push_back(uep("2.2.2.2", 2));
#if TORRENT_USE_IPV6
// not important that IPv6 is disabled here
s.nids.emplace_back(addr6("::"), to_hash("0000000000000000000000000000000000000002"));
#endif
session_params params(p);
params.dht_settings = sett;
@ -141,11 +139,9 @@ TORRENT_TEST(dht_state)
// not a chance the nid will be the fake initial ones
TEST_CHECK(params1.dht_state.nids[0].second != s.nids[0].second);
#if TORRENT_USE_IPV6
// the host machine may not have IPv6 support in which case there will only be one entry
if (params1.dht_state.nids.size() > 1)
TEST_CHECK(params1.dht_state.nids[1].second != s.nids[1].second);
#endif
}
#endif

8
test/test_socket_io.cpp
View File

@ -67,7 +67,6 @@ TORRENT_TEST(read_v4_address)
TEST_EQUAL(ep4, uep("16.5.128.1", 1337));
}
#if TORRENT_USE_IPV6
TORRENT_TEST(read_v6_endpoint)
{
std::string buf;
@ -85,7 +84,6 @@ TORRENT_TEST(read_v6_endpoint)
udp::endpoint ep6 = read_v6_endpoint<udp::endpoint>(buf.begin());
TEST_EQUAL(ep6, uep("1000::ffff", 1337));
}
#endif
TORRENT_TEST(read_endpoint_list)
{
@ -97,12 +95,8 @@ TORRENT_TEST(read_endpoint_list)
TEST_CHECK(!ec);
std::vector<udp::endpoint> list = read_endpoint_list<udp::endpoint>(e);
#if TORRENT_USE_IPV6
TEST_EQUAL(list.size(), 2);
TEST_EQUAL(list[1], uep("1000::ffff", 1337));
#else
TEST_EQUAL(list.size(), 1);
#endif
TEST_EQUAL(list[0], uep("16.5.128.1", 1337));
}
@ -171,7 +165,6 @@ TORRENT_TEST(parse_valid_ip4_endpoint)
ec.clear();
}
#if TORRENT_USE_IPV6
TORRENT_TEST(parse_invalid_ipv6_endpoint)
{
error_code ec;
@ -221,5 +214,4 @@ TORRENT_TEST(parse_valid_ipv6_endpoint)
TEST_CHECK(!ec);
ec.clear();
}
#endif

11
test/test_string.cpp
View File

@ -388,26 +388,15 @@ TORRENT_TEST(parse_list)
TEST_EQUAL(list[5], "foobar");
TEST_EQUAL(list[6], "[::1]");
#if TORRENT_USE_IPV6
test_parse_interface(" a:4,b:35, c : 1000s, d: 351 ,e \t:42,foobar:1337s\n\r,[2001::1]:6881"
, {{"a", 4, false}, {"b", 35, false}, {"c", 1000, true}, {"d", 351, false}
, {"e", 42, false}, {"foobar", 1337, true}, {"2001::1", 6881, false}}
, "a:4,b:35,c:1000s,d:351,e:42,foobar:1337s,[2001::1]:6881");
#else
test_parse_interface(" a:4,b:35, c : 1000s, d: 351 ,e \t:42,foobar:1337s\n\r,[2001::1]:6881"
, {{"a", 4, false}, {"b", 35, false}, {"c", 1000, true}, {"d", 351, false}
, {"e", 42, false}, {"foobar", 1337, true}}
, "a:4,b:35,c:1000s,d:351,e:42,foobar:1337s");
#endif
// IPv6 address
#if TORRENT_USE_IPV6
test_parse_interface("[2001:ffff::1]:6882s"
, {{"2001:ffff::1", 6882, true}}
, "[2001:ffff::1]:6882s");
#else
test_parse_interface("[2001:ffff::1]:6882s", {}, "");
#endif
// IPv4 address
test_parse_interface("127.0.0.1:6882"

6
test/test_tracker.cpp
View File

@ -252,7 +252,6 @@ TORRENT_TEST(parse_external_ip)
TEST_EQUAL(resp.external_ip, addr4("1.2.3.4"));
}
#if TORRENT_USE_IPV6
TORRENT_TEST(parse_external_ip6)
{
char const response[] = "d5:peers0:11:external ip"
@ -265,7 +264,6 @@ TORRENT_TEST(parse_external_ip6)
TEST_EQUAL(resp.peers.size(), 0);
TEST_EQUAL(resp.external_ip, addr6("f102:0304::ffff"));
}
#endif
namespace {
peer_entry extract_peer(char const* peer_field, error_code expected_ec, bool expected_ret)
@ -416,7 +414,6 @@ TORRENT_TEST(udp_tracker_v4)
test_udp_tracker("127.0.0.1", address_v4::any(), ep("1.3.3.7", 1337));
}
#if TORRENT_USE_IPV6
TORRENT_TEST(udp_tracker_v6)
{
if (supports_ipv6())
@ -424,7 +421,6 @@ TORRENT_TEST(udp_tracker_v6)
test_udp_tracker("[::1]", address_v6::any(), ep("::1.3.3.7", 1337));
}
}
#endif
TORRENT_TEST(http_peers)
{
@ -483,9 +479,7 @@ TORRENT_TEST(http_peers)
std::set<tcp::endpoint> expected_peers;
expected_peers.insert(ep("65.65.65.65", 16962));
expected_peers.insert(ep("67.67.67.67", 17476));
#if TORRENT_USE_IPV6
expected_peers.insert(ep("4545:4545:4545:4545:4545:4545:4545:4545", 17990));
#endif
for (auto const& ip : ra->params.peers)
{
TEST_EQUAL(expected_peers.count(ip), 1);

2
test/udp_tracker.cpp
View File

@ -133,7 +133,6 @@ struct udp_tracker
detail::write_uint32(1, ptr); // incomplete
detail::write_uint32(1, ptr); // complete
// 1 peers
#if TORRENT_USE_IPV6
if (is_v6(*from))
{
detail::write_uint32(0, ptr);
@ -146,7 +145,6 @@ struct udp_tracker
detail::write_uint16(1337, ptr);
}
else
#endif
{
detail::write_uint8(1, ptr);
detail::write_uint8(3, ptr);

4
tools/gen_fwd.py
View File

@ -67,8 +67,8 @@ def print_classes(out, classes, keyword):
# also ignore any header in the aux_ directory, those are private
classes = [l for l in classes if l[0].endswith('.hpp') and not l[0].endswith('/fwd.hpp') and '/aux_/' not in l[0]]
namespaces = ['TORRENT_VERSION_NAMESPACE_2', 'TORRENT_IPV6_NAMESPACE',
'TORRENT_VERSION_NAMESPACE_2_END', 'TORRENT_IPV6_NAMESPACE_END']
namespaces = ['TORRENT_VERSION_NAMESPACE_2',
'TORRENT_VERSION_NAMESPACE_2_END']
# only include classes with the right kind of export
classes = [