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

convert m_listen_sockets to a vector of shared_ptr

This commit is contained in:
Steven Siloti 2017-07-12 19:37:50 -07:00
parent 0f30815d8f
commit e0dcd34352
3 changed files with 153 additions and 160 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
include/libtorrent/aux_/session_impl.hpp
View File

@ -133,9 +133,9 @@ namespace aux {
TORRENT_EXTRA_EXPORT entry save_dht_settings(dht_settings const& settings);
#endif
struct listen_socket_impl
struct listen_socket_t final : aux::session_listen_socket
{
listen_socket_impl()
listen_socket_t()
{
tcp_port_mapping[0] = -1;
tcp_port_mapping[1] = -1;
@ -143,6 +143,20 @@ namespace aux {
udp_port_mapping[1] = -1;
}
listen_socket_t(listen_socket_t const&) = delete;
listen_socket_t(listen_socket_t&&) = delete;
listen_socket_t& operator=(listen_socket_t const&) = delete;
listen_socket_t& operator=(listen_socket_t&&) = delete;
address get_external_address() override
{ return external_address.external_address(); }
tcp::endpoint get_local_endpoint() override
{ return local_endpoint; }
bool is_ssl() override
{ return ssl == transport::ssl; }
// this may be empty but can be set
// to the WAN IP address of a NAT router
ip_voter external_address;
@ -185,27 +199,6 @@ namespace aux {
std::shared_ptr<aux::session_udp_socket> udp_sock;
};
struct listen_socket_t final : listen_socket_impl, aux::session_listen_socket
{
listen_socket_t(listen_socket_t const&) = delete;
listen_socket_t(listen_socket_t&&) = delete;
listen_socket_t& operator=(listen_socket_t const&) = delete;
listen_socket_t& operator=(listen_socket_t&&) = delete;
address get_external_address() override
{ return external_address.external_address(); }
tcp::endpoint get_local_endpoint() override
{ return local_endpoint; }
bool is_ssl() override
{ return ssl == transport::ssl; }
listen_socket_t(listen_socket_impl const& i) // NOLINT
: listen_socket_impl(i)
{}
};
struct TORRENT_EXTRA_EXPORT listen_endpoint_t
{
listen_endpoint_t(address adr, int p, std::string dev, transport s)
@ -226,10 +219,10 @@ namespace aux {
// all matched sockets are ordered before unmatched sockets
// matched endpoints are removed from the vector
// returns an iterator to the first unmatched socket
TORRENT_EXTRA_EXPORT std::list<listen_socket_t>::iterator
TORRENT_EXTRA_EXPORT std::vector<std::shared_ptr<aux::listen_socket_t>>::iterator
partition_listen_sockets(
std::vector<listen_endpoint_t>& eps
, std::list<listen_socket_t>& sockets);
, std::vector<std::shared_ptr<aux::listen_socket_t>>& sockets);
// expand [::] to all IPv6 interfaces for BEP 45 compliance
TORRENT_EXTRA_EXPORT void expand_unspecified_address(
@ -595,7 +588,7 @@ namespace aux {
{
for (auto& s : m_listen_sockets)
{
f(&s);
f(s.get());
}
}
@ -623,7 +616,7 @@ namespace aux {
{
for (auto const& s : m_listen_sockets)
{
if (s.udp_sock) return s.udp_external_port;
if (s->udp_sock) return s->udp_external_port;
}
return -1;
}
@ -948,7 +941,7 @@ namespace aux {
// since we might be listening on multiple interfaces
// we might need more than one listen socket
std::list<listen_socket_t> m_listen_sockets;
std::vector<std::shared_ptr<listen_socket_t>> m_listen_sockets;
outgoing_sockets m_outgoing_sockets;
@ -971,7 +964,7 @@ namespace aux {
open_ssl_socket = 0x10
};
listen_socket_impl setup_listener(std::string const& device
std::shared_ptr<listen_socket_t> setup_listener(std::string const& device
, tcp::endpoint bind_ep, int flags, error_code& ec);
#ifndef TORRENT_DISABLE_DHT

222
src/session_impl.cpp
View File

@ -260,20 +260,20 @@ namespace aux {
}
#endif // TORRENT_DISABLE_DHT
std::list<listen_socket_t>::iterator partition_listen_sockets(
std::vector<std::shared_ptr<listen_socket_t>>::iterator partition_listen_sockets(
std::vector<listen_endpoint_t>& eps
, std::list<listen_socket_t>& sockets)
, std::vector<std::shared_ptr<listen_socket_t>>& sockets)
{
return std::partition(sockets.begin(), sockets.end()
, [&eps](listen_socket_t const& sock)
, [&eps](std::shared_ptr<listen_socket_t> const& sock)
{
auto match = std::find_if(eps.begin(), eps.end()
, [&sock](listen_endpoint_t const& ep)
{
return ep.ssl == sock.ssl
&& ep.port == sock.original_port
&& ep.device == sock.device
&& ep.addr == sock.local_endpoint.address();
return ep.ssl == sock->ssl
&& ep.port == sock->original_port
&& ep.device == sock->device
&& ep.addr == sock->local_endpoint.address();
});
if (match != eps.end())
@ -1009,17 +1009,17 @@ namespace aux {
// close the listen sockets
for (auto const& l : m_listen_sockets)
{
if (l.sock)
if (l->sock)
{
l.sock->close(ec);
l->sock->close(ec);
TORRENT_ASSERT(!ec);
}
// TODO: 3 closing the udp sockets here means that
// the uTP connections cannot be closed gracefully
if (l.udp_sock)
if (l->udp_sock)
{
l.udp_sock->sock.close();
l->udp_sock->sock.close();
}
}
@ -1224,12 +1224,12 @@ namespace {
{
for (auto& ls : m_listen_sockets)
{
req.listen_port = listen_port(&ls);
req.listen_port = listen_port(ls.get());
#ifdef TORRENT_USE_OPENSSL
// SSL torrents use the SSL listen port
if (use_ssl) req.listen_port = ssl_listen_port(&ls);
#endif
req.outgoing_socket = &ls;
req.outgoing_socket = ls.get();
m_tracker_manager.queue_request(get_io_service(), req, c);
}
}
@ -1451,8 +1451,8 @@ namespace {
#if TORRENT_USE_IPV6
for (auto const& i : m_listen_sockets)
{
if (!i.local_endpoint.address().is_v6()) continue;
return tcp::endpoint(i.local_endpoint.address(), std::uint16_t(i.tcp_external_port));
if (!i->local_endpoint.address().is_v6()) continue;
return tcp::endpoint(i->local_endpoint.address(), std::uint16_t(i->tcp_external_port));
}
#endif
return tcp::endpoint();
@ -1462,15 +1462,15 @@ namespace {
{
for (auto const& i : m_listen_sockets)
{
if (!i.local_endpoint.address().is_v4()) continue;
return tcp::endpoint(i.local_endpoint.address(), std::uint16_t(i.tcp_external_port));
if (!i->local_endpoint.address().is_v4()) continue;
return tcp::endpoint(i->local_endpoint.address(), std::uint16_t(i->tcp_external_port));
}
return tcp::endpoint();
}
enum { listen_no_system_port = 0x02 };
listen_socket_impl session_impl::setup_listener(std::string const& device
std::shared_ptr<listen_socket_t> session_impl::setup_listener(std::string const& device
, tcp::endpoint bind_ep, int flags, error_code& ec)
{
int retries = m_settings.get_int(settings_pack::max_retry_port_bind);
@ -1483,9 +1483,9 @@ namespace {
}
#endif
listen_socket_impl ret;
ret.ssl = (flags & open_ssl_socket) != 0 ? transport::ssl : transport::plaintext;
ret.original_port = bind_ep.port();
auto ret = std::make_shared<listen_socket_t>();
ret->ssl = (flags & open_ssl_socket) != 0 ? transport::ssl : transport::plaintext;
ret->original_port = bind_ep.port();
operation_t last_op = operation_t::unknown;
socket_type_t const sock_type
= (flags & open_ssl_socket)
@ -1498,8 +1498,8 @@ namespace {
// separate function. At least most of it
if (!m_settings.get_bool(settings_pack::force_proxy))
{
ret.sock = std::make_shared<tcp::acceptor>(m_io_service);
ret.sock->open(bind_ep.protocol(), ec);
ret->sock = std::make_shared<tcp::acceptor>(m_io_service);
ret->sock->open(bind_ep.protocol(), ec);
last_op = operation_t::sock_open;
if (ec)
{
@ -1521,7 +1521,7 @@ namespace {
{
// this is best-effort. ignore errors
error_code err;
ret.sock->set_option(exclusive_address_use(true), err);
ret->sock->set_option(exclusive_address_use(true), err);
#ifndef TORRENT_DISABLE_LOGGING
if (err && should_log())
{
@ -1535,7 +1535,7 @@ namespace {
{
// this is best-effort. ignore errors
error_code err;
ret.sock->set_option(tcp::acceptor::reuse_address(true), err);
ret->sock->set_option(tcp::acceptor::reuse_address(true), err);
#ifndef TORRENT_DISABLE_LOGGING
if (err && should_log())
{
@ -1550,7 +1550,7 @@ namespace {
if (bind_ep.address().is_v6())
{
error_code err; // ignore errors here
ret.sock->set_option(boost::asio::ip::v6_only(true), err);
ret->sock->set_option(boost::asio::ip::v6_only(true), err);
#ifndef TORRENT_DISABLE_LOGGING
if (err && should_log())
{
@ -1561,7 +1561,7 @@ namespace {
#ifdef TORRENT_WINDOWS
// enable Teredo on windows
ret.sock->set_option(v6_protection_level(PROTECTION_LEVEL_UNRESTRICTED), err);
ret->sock->set_option(v6_protection_level(PROTECTION_LEVEL_UNRESTRICTED), err);
#ifndef TORRENT_DISABLE_LOGGING
if (err && should_log())
{
@ -1578,7 +1578,7 @@ namespace {
// we have an actual device we're interested in listening on, if we
// have SO_BINDTODEVICE functionality, use it now.
#if TORRENT_HAS_BINDTODEVICE
ret.sock->set_option(bind_to_device(device.c_str()), ec);
ret->sock->set_option(bind_to_device(device.c_str()), ec);
if (ec)
{
#ifndef TORRENT_DISABLE_LOGGING
@ -1600,7 +1600,7 @@ namespace {
#endif
}
ret.sock->bind(bind_ep, ec);
ret->sock->bind(bind_ep, ec);
last_op = operation_t::sock_bind;
while (ec == error_code(error::address_in_use) && retries > 0)
@ -1620,7 +1620,7 @@ namespace {
ec.clear();
--retries;
bind_ep.port(bind_ep.port() + 1);
ret.sock->bind(bind_ep, ec);
ret->sock->bind(bind_ep, ec);
}
if (ec == error_code(error::address_in_use)
@ -1630,7 +1630,7 @@ namespace {
// instead of giving up, try let the OS pick a port
bind_ep.port(0);
ec.clear();
ret.sock->bind(bind_ep, ec);
ret->sock->bind(bind_ep, ec);
last_op = operation_t::sock_bind;
}
@ -1653,11 +1653,11 @@ namespace {
m_alerts.emplace_alert<listen_failed_alert>(device, bind_ep
, last_op, ec, sock_type);
}
ret.sock.reset();
ret->sock.reset();
return ret;
}
ret.local_endpoint = ret.sock->local_endpoint(ec);
ret.device = device;
ret->local_endpoint = ret->sock->local_endpoint(ec);
ret->device = device;
last_op = operation_t::getname;
if (ec)
{
@ -1675,11 +1675,11 @@ namespace {
}
return ret;
}
ret.tcp_external_port = ret.local_endpoint.port();
TORRENT_ASSERT(ret.tcp_external_port == bind_ep.port()
ret->tcp_external_port = ret->local_endpoint.port();
TORRENT_ASSERT(ret->tcp_external_port == bind_ep.port()
|| bind_ep.port() == 0);
ret.sock->listen(m_settings.get_int(settings_pack::listen_queue_size), ec);
ret->sock->listen(m_settings.get_int(settings_pack::listen_queue_size), ec);
last_op = operation_t::sock_listen;
if (ec)
@ -1706,8 +1706,8 @@ namespace {
: socket_type_t::udp;
udp::endpoint const udp_bind_ep(bind_ep.address(), bind_ep.port());
ret.udp_sock = std::make_shared<session_udp_socket>(m_io_service);
ret.udp_sock->sock.open(udp_bind_ep.protocol(), ec);
ret->udp_sock = std::make_shared<session_udp_socket>(m_io_service);
ret->udp_sock->sock.open(udp_bind_ep.protocol(), ec);
if (ec)
{
#ifndef TORRENT_DISABLE_LOGGING
@ -1729,7 +1729,7 @@ namespace {
#if TORRENT_HAS_BINDTODEVICE
if (!device.empty())
{
ret.udp_sock->sock.set_option(bind_to_device(device.c_str()), ec);
ret->udp_sock->sock.set_option(bind_to_device(device.c_str()), ec);
if (ec)
{
#ifndef TORRENT_DISABLE_LOGGING
@ -1750,7 +1750,7 @@ namespace {
}
}
#endif
ret.udp_sock->sock.bind(udp_bind_ep, ec);
ret->udp_sock->sock.bind(udp_bind_ep, ec);
last_op = operation_t::sock_bind;
if (ec)
@ -1769,34 +1769,34 @@ namespace {
return ret;
}
ret.udp_external_port = ret.udp_sock->sock.local_port();
ret->udp_external_port = ret->udp_sock->sock.local_port();
error_code err;
set_socket_buffer_size(ret.udp_sock->sock, m_settings, err);
set_socket_buffer_size(ret->udp_sock->sock, m_settings, err);
if (err)
{
if (m_alerts.should_post<udp_error_alert>())
m_alerts.emplace_alert<udp_error_alert>(ret.udp_sock->sock.local_endpoint(ec), err);
m_alerts.emplace_alert<udp_error_alert>(ret->udp_sock->sock.local_endpoint(ec), err);
}
ret.udp_sock->sock.set_force_proxy(m_settings.get_bool(settings_pack::force_proxy));
ret->udp_sock->sock.set_force_proxy(m_settings.get_bool(settings_pack::force_proxy));
// this call is necessary here because, unless the settings actually
// change after the session is up and listening, at no other point
// set_proxy_settings is called with the correct proxy configuration,
// internally, this method handle the SOCKS5's connection logic
ret.udp_sock->sock.set_proxy_settings(proxy());
ret->udp_sock->sock.set_proxy_settings(proxy());
// TODO: 2 use a handler allocator here
ADD_OUTSTANDING_ASYNC("session_impl::on_udp_packet");
ret.udp_sock->sock.async_read(std::bind(&session_impl::on_udp_packet
, this, ret.udp_sock, ret.ssl, _1));
ret->udp_sock->sock.async_read(std::bind(&session_impl::on_udp_packet
, this, ret->udp_sock, ret->ssl, _1));
#ifndef TORRENT_DISABLE_LOGGING
if (should_log())
{
session_log(" listening on: %s TCP port: %d UDP port: %d"
, bind_ep.address().to_string().c_str()
, ret.tcp_external_port, ret.udp_external_port);
, ret->tcp_external_port, ret->udp_external_port);
}
#endif
return ret;
@ -1954,19 +1954,19 @@ namespace {
{
#ifndef TORRENT_DISABLE_DHT
if (m_dht)
m_dht->delete_socket(&*remove_iter);
m_dht->delete_socket(remove_iter->get());
#endif
#ifndef TORRENT_DISABLE_LOGGING
if (should_log())
{
session_log("closing listen socket for %s on device \"%s\""
, print_endpoint(remove_iter->local_endpoint).c_str()
, remove_iter->device.c_str());
, print_endpoint((*remove_iter)->local_endpoint).c_str()
, (*remove_iter)->device.c_str());
}
#endif
if (remove_iter->sock) remove_iter->sock->close(ec);
if (remove_iter->udp_sock) remove_iter->udp_sock->sock.close();
if ((*remove_iter)->sock) (*remove_iter)->sock->close(ec);
if ((*remove_iter)->udp_sock) (*remove_iter)->udp_sock->sock.close();
remove_iter = m_listen_sockets.erase(remove_iter);
}
@ -1974,17 +1974,17 @@ namespace {
// an existing socket
for (auto const& ep : eps)
{
listen_socket_impl const s = setup_listener(ep.device
std::shared_ptr<listen_socket_t> s = setup_listener(ep.device
, tcp::endpoint(ep.addr, std::uint16_t(ep.port))
, flags | (ep.ssl == transport::ssl ? open_ssl_socket : 0), ec);
if (!ec && (s.sock || s.udp_sock))
if (!ec && (s->sock || s->udp_sock))
{
m_listen_sockets.emplace_back(s);
#ifndef TORRENT_DISABLE_DHT
if (m_dht)
m_dht->new_socket(&m_listen_sockets.back());
m_dht->new_socket(m_listen_sockets.back().get());
#endif
}
}
@ -2005,13 +2005,13 @@ namespace {
for (auto const& l : m_listen_sockets)
{
error_code err;
if (l.sock)
if (l->sock)
{
tcp::endpoint const tcp_ep = l.sock->local_endpoint(err);
tcp::endpoint const tcp_ep = l->sock->local_endpoint(err);
if (!err)
{
socket_type_t const socket_type
= l.ssl == transport::ssl
= l->ssl == transport::ssl
? socket_type_t::tcp_ssl
: socket_type_t::tcp;
@ -2020,13 +2020,13 @@ namespace {
}
}
if (l.udp_sock)
if (l->udp_sock)
{
udp::endpoint const udp_ep = l.udp_sock->sock.local_endpoint(err);
if (!err && l.udp_sock->sock.is_open())
udp::endpoint const udp_ep = l->udp_sock->sock.local_endpoint(err);
if (!err && l->udp_sock->sock.is_open())
{
socket_type_t const socket_type
= l.ssl == transport::ssl
= l->ssl == transport::ssl
? socket_type_t::utp_ssl
: socket_type_t::udp;
@ -2047,8 +2047,8 @@ namespace {
// initiate accepting on the listen sockets
for (auto& s : m_listen_sockets)
{
if (s.sock) async_accept(s.sock, s.ssl);
remap_ports(remap_natpmp_and_upnp, s);
if (s->sock) async_accept(s->sock, s->ssl);
remap_ports(remap_natpmp_and_upnp, *s);
}
#if TORRENT_USE_I2P
@ -2393,15 +2393,15 @@ namespace {
s->write_blocked = false;
#ifdef TORRENT_USE_OPENSSL
std::list<listen_socket_t>::iterator i = std::find_if(
auto i = std::find_if(
m_listen_sockets.begin(), m_listen_sockets.end()
, [&s] (listen_socket_t const& ls) { return ls.udp_sock == s; });
, [&s] (std::shared_ptr<listen_socket_t> const& ls) { return ls->udp_sock == s; });
#endif
// notify the utp socket manager it can start sending on the socket again
struct utp_socket_manager& mgr =
#ifdef TORRENT_USE_OPENSSL
(i != m_listen_sockets.end() && i->ssl == transport::ssl) ? m_ssl_utp_socket_manager :
(i != m_listen_sockets.end() && (*i)->ssl == transport::ssl) ? m_ssl_utp_socket_manager :
#endif
m_utp_socket_manager;
@ -5298,7 +5298,7 @@ namespace {
void session_impl::update_proxy()
{
for (auto& i : m_listen_sockets)
i.udp_sock->sock.set_proxy_settings(proxy());
i->udp_sock->sock.set_proxy_settings(proxy());
m_outgoing_sockets.update_proxy(proxy());
}
@ -5384,7 +5384,7 @@ namespace {
if (m_settings.get_bool(settings_pack::force_proxy)) return 0;
if (m_listen_sockets.empty()) return 0;
if (sock) return std::uint16_t(sock->tcp_external_port);
return std::uint16_t(m_listen_sockets.front().tcp_external_port);
return std::uint16_t(m_listen_sockets.front()->tcp_external_port);
}
// TODO: 2 this function should be removed and users need to deal with the
@ -5405,7 +5405,7 @@ namespace {
if (m_settings.get_bool(settings_pack::force_proxy)) return 0;
for (auto const& s : m_listen_sockets)
{
if (s.ssl == transport::ssl) return std::uint16_t(s.tcp_external_port);
if (s->ssl == transport::ssl) return std::uint16_t(s->tcp_external_port);
}
#else
TORRENT_UNUSED(sock);
@ -5445,14 +5445,14 @@ namespace {
}
namespace {
bool find_tcp_port_mapping(int transport, int mapping, listen_socket_t const& ls)
bool find_tcp_port_mapping(int transport, int mapping, std::shared_ptr<listen_socket_t> const& ls)
{
return ls.tcp_port_mapping[transport] == mapping;
return ls->tcp_port_mapping[transport] == mapping;
}
bool find_udp_port_mapping(int transport, int mapping, listen_socket_t const& ls)
bool find_udp_port_mapping(int transport, int mapping, std::shared_ptr<listen_socket_t> const& ls)
{
return ls.udp_port_mapping[transport] == mapping;
return ls->udp_port_mapping[transport] == mapping;
}
}
@ -5476,7 +5476,7 @@ namespace {
// look through our listen sockets to see if this mapping is for one of
// them (it could also be a user mapping)
std::list<listen_socket_t>::iterator ls
auto ls
= std::find_if(m_listen_sockets.begin(), m_listen_sockets.end()
, std::bind(find_tcp_port_mapping, map_transport, mapping, _1));
@ -5494,11 +5494,11 @@ namespace {
{
// TODO: 1 report the proper address of the router as the source IP of
// this vote of our external address, instead of the empty address
ls->external_address.cast_vote(ip, source_router, address());
(*ls)->external_address.cast_vote(ip, source_router, address());
}
if (tcp) ls->tcp_external_port = port;
else ls->udp_external_port = port;
if (tcp) (*ls)->tcp_external_port = port;
else (*ls)->udp_external_port = port;
}
if (!ec && m_alerts.should_post<portmap_alert>())
@ -5690,7 +5690,7 @@ namespace {
, std::move(m_dht_state));
for (auto& s : m_listen_sockets)
m_dht->new_socket(&s);
m_dht->new_socket(s.get());
for (auto const& n : m_dht_router_nodes)
{
@ -6124,32 +6124,32 @@ namespace {
int const tos = m_settings.get_int(settings_pack::peer_tos);
for (auto const& l : m_listen_sockets)
{
if (l.sock)
if (l->sock)
{
error_code ec;
set_tos(*l.sock, tos, ec);
set_tos(*l->sock, tos, ec);
#ifndef TORRENT_DISABLE_LOGGING
if (should_log())
{
session_log(">>> SET_TOS [ tcp (%s %d) tos: %x e: %s ]"
, l.sock->local_endpoint().address().to_string().c_str()
, l.sock->local_endpoint().port(), tos, ec.message().c_str());
, l->sock->local_endpoint().address().to_string().c_str()
, l->sock->local_endpoint().port(), tos, ec.message().c_str());
}
#endif
}
if (l.udp_sock)
if (l->udp_sock)
{
error_code ec;
set_tos(l.udp_sock->sock, tos, ec);
set_tos(l->udp_sock->sock, tos, ec);
#ifndef TORRENT_DISABLE_LOGGING
if (should_log())
{
session_log(">>> SET_TOS [ udp (%s %d) tos: %x e: %s ]"
, l.udp_sock->sock.local_endpoint().address().to_string().c_str()
, l.udp_sock->sock.local_port()
, l->udp_sock->sock.local_endpoint().address().to_string().c_str()
, l->udp_sock->sock.local_port()
, tos, ec.message().c_str());
}
#endif
@ -6297,25 +6297,25 @@ namespace {
for (auto const& l : m_listen_sockets)
{
error_code ec;
set_socket_buffer_size(l.udp_sock->sock, m_settings, ec);
set_socket_buffer_size(l->udp_sock->sock, m_settings, ec);
#ifndef TORRENT_DISABLE_LOGGING
if (ec && should_log())
{
error_code err;
session_log("socket buffer size [ udp %s %d]: (%d) %s"
, l.udp_sock->sock.local_endpoint().address().to_string(err).c_str()
, l.udp_sock->sock.local_port(), ec.value(), ec.message().c_str());
, l->udp_sock->sock.local_endpoint().address().to_string(err).c_str()
, l->udp_sock->sock.local_port(), ec.value(), ec.message().c_str());
}
#endif
ec.clear();
set_socket_buffer_size(*l.sock, m_settings, ec);
set_socket_buffer_size(*l->sock, m_settings, ec);
#ifndef TORRENT_DISABLE_LOGGING
if (ec && should_log())
{
error_code err;
session_log("socket buffer size [ udp %s %d]: (%d) %s"
, l.sock->local_endpoint().address().to_string(err).c_str()
, l.sock->local_endpoint().port(), ec.value(), ec.message().c_str());
, l->sock->local_endpoint().address().to_string(err).c_str()
, l->sock->local_endpoint().port(), ec.value(), ec.message().c_str());
}
#endif
}
@ -6369,14 +6369,14 @@ namespace {
{
for (auto& i : m_listen_sockets)
{
i.udp_sock->sock.set_force_proxy(m_settings.get_bool(settings_pack::force_proxy));
i->udp_sock->sock.set_force_proxy(m_settings.get_bool(settings_pack::force_proxy));
// close the TCP listen sockets
if (i.sock)
if (i->sock)
{
error_code ec;
i.sock->close(ec);
i.sock.reset();
i->sock->close(ec);
i->sock.reset();
}
}
@ -6606,7 +6606,7 @@ namespace {
for (auto& s : m_listen_sockets)
{
remap_ports(remap_natpmp, s);
remap_ports(remap_natpmp, *s);
}
return m_natpmp.get();
}
@ -6629,7 +6629,7 @@ namespace {
for (auto& s : m_listen_sockets)
{
remap_ports(remap_upnp, s);
remap_ports(remap_upnp, *s);
}
return m_upnp.get();
}
@ -6665,8 +6665,8 @@ namespace {
m_natpmp->close();
for (auto& s : m_listen_sockets)
{
s.tcp_port_mapping[0] = -1;
s.udp_port_mapping[0] = -1;
s->tcp_port_mapping[0] = -1;
s->udp_port_mapping[0] = -1;
}
m_natpmp.reset();
@ -6679,8 +6679,8 @@ namespace {
m_upnp->close();
for (auto& s : m_listen_sockets)
{
s.tcp_port_mapping[1] = -1;
s.udp_port_mapping[1] = -1;
s->tcp_port_mapping[1] = -1;
s->udp_port_mapping[1] = -1;
}
m_upnp.reset();
}
@ -6692,10 +6692,10 @@ namespace {
// take the first IP we find which matches each category
for (auto const& i : m_listen_sockets)
{
address external_addr = i.external_address.external_address();
address external_addr = i->external_address.external_address();
if (ips[0][external_addr.is_v6()] == address())
ips[0][external_addr.is_v6()] = external_addr;
address local_addr = i.local_endpoint.address();
address local_addr = i->local_endpoint.address();
if (ips[is_local(local_addr)][local_addr.is_v6()] == address())
ips[is_local(local_addr)][local_addr.is_v6()] = local_addr;
}
@ -6812,10 +6812,10 @@ namespace {
// TODO: remove this function once all callers are updated to specify a listen socket
for (auto& i : m_listen_sockets)
{
if (i.local_endpoint.address().is_v4() != ip.is_v4())
if (i->local_endpoint.address().is_v4() != ip.is_v4())
continue;
set_external_address(i, ip, source_type, source);
set_external_address(*i, ip, source_type, source);
break;
}
}
@ -6825,10 +6825,10 @@ namespace {
, int const source_type, address const& source)
{
auto sock = std::find_if(m_listen_sockets.begin(), m_listen_sockets.end()
, [&](listen_socket_t const& v) { return v.local_endpoint == local_endpoint; });
, [&](std::shared_ptr<listen_socket_t> const& v) { return v->local_endpoint == local_endpoint; });
if (sock != m_listen_sockets.end())
set_external_address(*sock, ip, source_type, source);
set_external_address(**sock, ip, source_type, source);
}
void session_impl::set_external_address(listen_socket_t& sock

40
test/test_listen_socket.cpp
View File

@ -79,27 +79,27 @@ namespace
return aux::listen_endpoint_t(address::from_string(ip), port, device, ssl);
}
aux::listen_socket_impl sock(char const* ip, int const port
std::shared_ptr<aux::listen_socket_t> sock(char const* ip, int const port
, int const original_port, char const* device = "")
{
aux::listen_socket_impl s;
s.local_endpoint = tcp::endpoint(address::from_string(ip), port);
s.original_port = original_port;
s.device = device;
auto s = std::make_shared<aux::listen_socket_t>();
s->local_endpoint = tcp::endpoint(address::from_string(ip), port);
s->original_port = original_port;
s->device = device;
return s;
}
aux::listen_socket_impl sock(char const* ip, int const port, char const* dev)
std::shared_ptr<aux::listen_socket_t> sock(char const* ip, int const port, char const* dev)
{ return sock(ip, port, port, dev); }
aux::listen_socket_impl sock(char const* ip, int const port)
std::shared_ptr<aux::listen_socket_t> sock(char const* ip, int const port)
{ return sock(ip, port, port); }
} // anonymous namespace
TORRENT_TEST(partition_listen_sockets_wildcard2specific)
{
std::list<aux::listen_socket_t> sockets = {
std::vector<std::shared_ptr<aux::listen_socket_t>> sockets = {
sock("0.0.0.0", 6881), sock("4.4.4.4", 6881)
};
@ -112,14 +112,14 @@ TORRENT_TEST(partition_listen_sockets_wildcard2specific)
TEST_EQUAL(eps.size(), 1);
TEST_EQUAL(std::distance(sockets.begin(), remove_iter), 1);
TEST_EQUAL(std::distance(remove_iter, sockets.end()), 1);
test_equal(sockets.front(), address_v4::from_string("4.4.4.4"), 6881, "", tp::plaintext);
test_equal(sockets.back(), address_v4(), 6881, "", tp::plaintext);
test_equal(*sockets.front(), address_v4::from_string("4.4.4.4"), 6881, "", tp::plaintext);
test_equal(*sockets.back(), address_v4(), 6881, "", tp::plaintext);
test_equal(eps.front(), address_v4::from_string("4.4.4.5"), 6881, "", tp::plaintext);
}
TORRENT_TEST(partition_listen_sockets_port_change)
{
std::list<aux::listen_socket_t> sockets = {
std::vector<std::shared_ptr<aux::listen_socket_t>> sockets = {
sock("4.4.4.4", 6881), sock("4.4.4.5", 6881)
};
@ -134,7 +134,7 @@ TORRENT_TEST(partition_listen_sockets_port_change)
TORRENT_TEST(partition_listen_sockets_device_bound)
{
std::list<aux::listen_socket_t> sockets = {
std::vector<std::shared_ptr<aux::listen_socket_t>> sockets = {
sock("4.4.4.5", 6881), sock("0.0.0.0", 6881)
};
@ -148,14 +148,14 @@ TORRENT_TEST(partition_listen_sockets_device_bound)
auto remove_iter = aux::partition_listen_sockets(eps, sockets);
TEST_EQUAL(std::distance(sockets.begin(), remove_iter), 1);
TEST_EQUAL(std::distance(remove_iter, sockets.end()), 1);
test_equal(sockets.front(), address_v4::from_string("4.4.4.5"), 6881, "", tp::plaintext);
test_equal(sockets.back(), address_v4(), 6881, "", tp::plaintext);
test_equal(*sockets.front(), address_v4::from_string("4.4.4.5"), 6881, "", tp::plaintext);
test_equal(*sockets.back(), address_v4(), 6881, "", tp::plaintext);
TEST_EQUAL(eps.size(), 2);
}
TORRENT_TEST(partition_listen_sockets_device_ip_change)
{
std::list<aux::listen_socket_t> sockets = {
std::vector<std::shared_ptr<aux::listen_socket_t>> sockets = {
sock("10.10.10.10", 6881, "enp3s0")
, sock("4.4.4.4", 6881, "enp3s0")
};
@ -168,15 +168,15 @@ TORRENT_TEST(partition_listen_sockets_device_ip_change)
auto remove_iter = aux::partition_listen_sockets(eps, sockets);
TEST_EQUAL(std::distance(sockets.begin(), remove_iter), 1);
TEST_EQUAL(std::distance(remove_iter, sockets.end()), 1);
test_equal(sockets.front(), address_v4::from_string("10.10.10.10"), 6881, "enp3s0", tp::plaintext);
test_equal(sockets.back(), address_v4::from_string("4.4.4.4"), 6881, "enp3s0", tp::plaintext);
test_equal(*sockets.front(), address_v4::from_string("10.10.10.10"), 6881, "enp3s0", tp::plaintext);
test_equal(*sockets.back(), address_v4::from_string("4.4.4.4"), 6881, "enp3s0", tp::plaintext);
TEST_EQUAL(eps.size(), 1);
test_equal(eps.front(), address_v4::from_string("4.4.4.5"), 6881, "enp3s0", tp::plaintext);
}
TORRENT_TEST(partition_listen_sockets_original_port)
{
std::list<aux::listen_socket_t> sockets = {
std::vector<std::shared_ptr<aux::listen_socket_t>> sockets = {
sock("10.10.10.10", 6883, 6881), sock("4.4.4.4", 6883, 6881)
};
@ -193,7 +193,7 @@ TORRENT_TEST(partition_listen_sockets_original_port)
TORRENT_TEST(partition_listen_sockets_ssl)
{
std::list<aux::listen_socket_t> sockets = {
std::vector<std::shared_ptr<aux::listen_socket_t>> sockets = {
sock("10.10.10.10", 6881), sock("4.4.4.4", 6881)
};
@ -212,7 +212,7 @@ TORRENT_TEST(partition_listen_sockets_ssl)
TORRENT_TEST(partition_listen_sockets_op_ports)
{
std::list<aux::listen_socket_t> sockets = {
std::vector<std::shared_ptr<aux::listen_socket_t>> sockets = {
sock("10.10.10.10", 6881, 0), sock("4.4.4.4", 6881)
};