2007-09-10 01:52:34 +02:00
|
|
|
/*
|
|
|
|
|
2018-04-09 09:04:33 +02:00
|
|
|
Copyright (c) 2007-2018, Arvid Norberg
|
2007-09-10 01:52:34 +02:00
|
|
|
All rights reserved.
|
|
|
|
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
|
|
modification, are permitted provided that the following conditions
|
|
|
|
are met:
|
|
|
|
|
|
|
|
* Redistributions of source code must retain the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above copyright
|
|
|
|
notice, this list of conditions and the following disclaimer in
|
|
|
|
the documentation and/or other materials provided with the distribution.
|
|
|
|
* Neither the name of the author nor the names of its
|
|
|
|
contributors may be used to endorse or promote products derived
|
|
|
|
from this software without specific prior written permission.
|
|
|
|
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
2008-02-18 01:36:17 +01:00
|
|
|
#include "libtorrent/config.hpp"
|
2008-04-28 02:20:59 +02:00
|
|
|
#include "libtorrent/enum_net.hpp"
|
|
|
|
#include "libtorrent/broadcast_socket.hpp"
|
2012-05-12 18:15:36 +02:00
|
|
|
#include "libtorrent/assert.hpp"
|
2018-01-28 11:48:21 +01:00
|
|
|
#include "libtorrent/aux_/socket_type.hpp"
|
2020-01-18 11:03:58 +01:00
|
|
|
#include "libtorrent/span.hpp"
|
2016-12-28 19:12:20 +01:00
|
|
|
#ifdef TORRENT_WINDOWS
|
|
|
|
#include "libtorrent/aux_/win_util.hpp"
|
|
|
|
#endif
|
2015-08-18 16:42:03 +02:00
|
|
|
|
2016-05-25 06:31:52 +02:00
|
|
|
#include <functional>
|
2016-07-10 05:17:55 +02:00
|
|
|
#include <cstdlib> // for wcstombscstombs
|
2016-05-25 06:31:52 +02:00
|
|
|
|
2015-08-18 16:42:03 +02:00
|
|
|
#include "libtorrent/aux_/disable_warnings_push.hpp"
|
|
|
|
|
2008-05-03 18:05:42 +02:00
|
|
|
#include <boost/asio/ip/host_name.hpp>
|
2018-07-29 09:05:50 +02:00
|
|
|
#include <boost/optional.hpp>
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2014-02-17 08:25:21 +01:00
|
|
|
#if TORRENT_USE_IFCONF
|
2007-09-10 01:52:34 +02:00
|
|
|
#include <sys/ioctl.h>
|
2008-03-04 05:29:03 +01:00
|
|
|
#include <sys/socket.h>
|
2007-09-10 01:52:34 +02:00
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <net/if.h>
|
2016-07-10 05:17:55 +02:00
|
|
|
#include <cstring>
|
2008-04-28 02:20:59 +02:00
|
|
|
#endif
|
|
|
|
|
2011-04-09 05:49:46 +02:00
|
|
|
#if TORRENT_USE_SYSCTL
|
2009-01-27 09:24:48 +01:00
|
|
|
#include <sys/sysctl.h>
|
2018-01-15 11:53:20 +01:00
|
|
|
#ifdef __APPLE__
|
|
|
|
#include "TargetConditionals.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined TARGET_IPHONE_SIMULATOR || defined TARGET_OS_IPHONE
|
|
|
|
// net/route.h is not included in the iphone sdk.
|
|
|
|
#include "libtorrent/aux_/route.h"
|
|
|
|
#else
|
2011-04-10 05:45:13 +02:00
|
|
|
#include <net/route.h>
|
2009-01-27 09:24:48 +01:00
|
|
|
#endif
|
2018-01-19 23:07:08 +01:00
|
|
|
#endif // TORRENT_USE_SYSCTL
|
2009-01-27 09:24:48 +01:00
|
|
|
|
2011-04-10 05:45:13 +02:00
|
|
|
#if TORRENT_USE_GETIPFORWARDTABLE || TORRENT_USE_GETADAPTERSADDRESSES
|
2018-11-20 16:05:40 +01:00
|
|
|
#include "libtorrent/aux_/windows.hpp"
|
2007-10-01 19:21:19 +02:00
|
|
|
#include <iphlpapi.h>
|
2008-04-28 02:20:59 +02:00
|
|
|
#endif
|
|
|
|
|
2011-04-10 05:45:13 +02:00
|
|
|
#if TORRENT_USE_NETLINK
|
|
|
|
#include <linux/netlink.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
2008-04-25 07:51:21 +02:00
|
|
|
#include <asm/types.h>
|
|
|
|
#include <netinet/ether.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <net/if.h>
|
2017-09-12 23:10:11 +02:00
|
|
|
#include <cstdio>
|
2008-04-25 07:51:21 +02:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <unistd.h>
|
2011-02-15 07:29:44 +01:00
|
|
|
#include <sys/types.h>
|
2018-03-09 22:37:21 +01:00
|
|
|
|
2018-03-12 11:36:29 +01:00
|
|
|
#if defined TORRENT_ANDROID && !defined IFA_F_DADFAILED
|
2018-03-09 22:37:21 +01:00
|
|
|
#define IFA_F_DADFAILED 8
|
|
|
|
#endif
|
|
|
|
|
2011-02-15 08:42:46 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#if TORRENT_USE_IFADDRS
|
2011-02-15 07:29:44 +01:00
|
|
|
#include <ifaddrs.h>
|
2008-04-28 02:20:59 +02:00
|
|
|
#endif
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2015-08-26 23:46:54 +02:00
|
|
|
#if TORRENT_USE_IFADDRS || TORRENT_USE_IFCONF || TORRENT_USE_NETLINK || TORRENT_USE_SYSCTL
|
2015-08-18 16:42:03 +02:00
|
|
|
// capture this here where warnings are disabled (the macro generates warnings)
|
2016-05-06 14:08:49 +02:00
|
|
|
const unsigned long siocgifmtu = SIOCGIFMTU;
|
2015-08-18 16:42:03 +02:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "libtorrent/aux_/disable_warnings_pop.hpp"
|
|
|
|
|
2012-10-21 17:19:23 +02:00
|
|
|
#if defined(TORRENT_OS2) && !defined(IF_NAMESIZE)
|
2012-09-24 18:13:57 +02:00
|
|
|
#define IF_NAMESIZE IFNAMSIZ
|
|
|
|
#endif
|
|
|
|
|
2017-08-03 12:57:15 +02:00
|
|
|
namespace libtorrent {
|
|
|
|
namespace {
|
2017-04-12 19:00:57 +02:00
|
|
|
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2016-06-06 04:13:01 +02:00
|
|
|
#if !defined TORRENT_BUILD_SIMULATOR
|
2020-01-04 21:20:41 +01:00
|
|
|
address_v4 inaddr_to_address(void const* ina, int const len = 4)
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
2017-08-16 02:13:32 +02:00
|
|
|
boost::asio::ip::address_v4::bytes_type b = {};
|
2017-01-15 00:53:25 +01:00
|
|
|
if (len > 0) std::memcpy(b.data(), ina, std::min(std::size_t(len), b.size()));
|
2008-04-28 02:20:59 +02:00
|
|
|
return address_v4(b);
|
|
|
|
}
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2020-01-04 21:20:41 +01:00
|
|
|
address_v6 inaddr6_to_address(void const* ina6, int const len = 16)
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
2017-08-16 02:13:32 +02:00
|
|
|
boost::asio::ip::address_v6::bytes_type b = {};
|
2017-01-15 00:53:25 +01:00
|
|
|
if (len > 0) std::memcpy(b.data(), ina6, std::min(std::size_t(len), b.size()));
|
2008-04-28 02:20:59 +02:00
|
|
|
return address_v6(b);
|
|
|
|
}
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2017-06-27 06:34:24 +02:00
|
|
|
#if !TORRENT_USE_NETLINK
|
2010-11-29 02:33:05 +01:00
|
|
|
int sockaddr_len(sockaddr const* sin)
|
2008-04-25 07:51:21 +02:00
|
|
|
{
|
2011-04-09 05:49:46 +02:00
|
|
|
#if TORRENT_HAS_SALEN
|
2010-11-29 02:33:05 +01:00
|
|
|
return sin->sa_len;
|
2011-04-09 05:49:46 +02:00
|
|
|
#else
|
|
|
|
return sin->sa_family == AF_INET ? sizeof(sockaddr_in) : sizeof(sockaddr_in6);
|
2010-11-29 02:33:05 +01:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
address sockaddr_to_address(sockaddr const* sin, int assume_family = -1)
|
|
|
|
{
|
|
|
|
if (sin->sa_family == AF_INET || assume_family == AF_INET)
|
2015-08-18 15:33:00 +02:00
|
|
|
return inaddr_to_address(&reinterpret_cast<sockaddr_in const*>(sin)->sin_addr
|
2017-01-15 00:53:25 +01:00
|
|
|
, sockaddr_len(sin) - int(offsetof(sockaddr, sa_data)));
|
2010-11-29 02:33:05 +01:00
|
|
|
else if (sin->sa_family == AF_INET6 || assume_family == AF_INET6)
|
2016-11-12 05:16:58 +01:00
|
|
|
{
|
|
|
|
auto saddr = reinterpret_cast<sockaddr_in6 const*>(sin);
|
|
|
|
auto ret = inaddr6_to_address(&saddr->sin6_addr
|
2017-01-15 00:53:25 +01:00
|
|
|
, sockaddr_len(sin) - int(offsetof(sockaddr, sa_data)));
|
2016-11-12 05:16:58 +01:00
|
|
|
ret.scope_id(saddr->sin6_scope_id);
|
|
|
|
return ret;
|
|
|
|
}
|
2008-04-28 02:20:59 +02:00
|
|
|
return address();
|
|
|
|
}
|
2017-06-27 06:34:24 +02:00
|
|
|
#endif
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2017-02-08 13:52:23 +01:00
|
|
|
bool valid_addr_family(int family)
|
|
|
|
{
|
|
|
|
return (family == AF_INET
|
|
|
|
|| family == AF_INET6
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
2011-04-09 05:49:46 +02:00
|
|
|
#if TORRENT_USE_NETLINK
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2017-06-27 06:34:24 +02:00
|
|
|
int read_nl_sock(int sock, span<char> buf, std::uint32_t const seq, std::uint32_t const pid)
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
|
|
|
nlmsghdr* nl_hdr;
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
int msg_len = 0;
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2017-06-25 16:29:32 +02:00
|
|
|
for (;;)
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
2018-11-01 23:05:30 +01:00
|
|
|
auto next_msg = buf.subspan(msg_len);
|
|
|
|
int const read_len = int(recv(sock, next_msg.data(), static_cast<std::size_t>(next_msg.size()), 0));
|
2008-04-28 02:20:59 +02:00
|
|
|
if (read_len < 0) return -1;
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2017-06-27 06:34:24 +02:00
|
|
|
nl_hdr = reinterpret_cast<nlmsghdr*>(next_msg.data());
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2016-12-18 16:59:41 +01:00
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic push
|
|
|
|
// NLMSG_OK uses signed/unsigned compare in the same expression
|
|
|
|
#pragma clang diagnostic ignored "-Wsign-compare"
|
|
|
|
#endif
|
2008-04-28 02:20:59 +02:00
|
|
|
if ((NLMSG_OK(nl_hdr, read_len) == 0) || (nl_hdr->nlmsg_type == NLMSG_ERROR))
|
|
|
|
return -1;
|
2016-12-18 16:59:41 +01:00
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic pop
|
|
|
|
#endif
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2017-06-25 16:29:32 +02:00
|
|
|
// this function doesn't handle multiple requests at the same time
|
|
|
|
// so report an error if the message does not have the expected seq and pid
|
|
|
|
if (nl_hdr->nlmsg_seq != seq || nl_hdr->nlmsg_pid != pid)
|
|
|
|
return -1;
|
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
if (nl_hdr->nlmsg_type == NLMSG_DONE) break;
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
msg_len += read_len;
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
if ((nl_hdr->nlmsg_flags & NLM_F_MULTI) == 0) break;
|
2017-06-25 16:29:32 +02:00
|
|
|
}
|
2008-04-28 02:20:59 +02:00
|
|
|
return msg_len;
|
|
|
|
}
|
|
|
|
|
2017-08-03 12:57:15 +02:00
|
|
|
constexpr int NL_BUFSIZE = 8192;
|
2017-06-27 06:34:24 +02:00
|
|
|
|
2017-06-29 17:05:20 +02:00
|
|
|
int nl_dump_request(int sock, std::uint16_t type, std::uint32_t seq, char family, span<char> msg, std::size_t msg_len)
|
2017-06-27 06:34:24 +02:00
|
|
|
{
|
|
|
|
nlmsghdr* nl_msg = reinterpret_cast<nlmsghdr*>(msg.data());
|
2017-07-03 17:55:22 +02:00
|
|
|
nl_msg->nlmsg_len = std::uint32_t(NLMSG_LENGTH(msg_len));
|
2017-06-27 06:34:24 +02:00
|
|
|
nl_msg->nlmsg_type = type;
|
|
|
|
nl_msg->nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST;
|
|
|
|
nl_msg->nlmsg_seq = seq;
|
|
|
|
// in theory nlmsg_pid should be set to the netlink port ID (NOT the process ID)
|
|
|
|
// of the sender, but the kernel ignores this field so it is typically set to
|
|
|
|
// zero
|
|
|
|
nl_msg->nlmsg_pid = 0;
|
|
|
|
// first byte of routing messages is always the family
|
|
|
|
msg[sizeof(nlmsghdr)] = family;
|
|
|
|
|
2017-09-12 23:10:11 +02:00
|
|
|
if (::send(sock, nl_msg, nl_msg->nlmsg_len, 0) < 0)
|
2017-06-27 06:34:24 +02:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get the socket's port ID so that we can verify it in the repsonse
|
|
|
|
sockaddr_nl sock_addr;
|
|
|
|
socklen_t sock_addr_len = sizeof(sock_addr);
|
2017-09-12 23:10:11 +02:00
|
|
|
if (::getsockname(sock, reinterpret_cast<sockaddr*>(&sock_addr), &sock_addr_len) < 0)
|
2017-06-27 06:34:24 +02:00
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return read_nl_sock(sock, msg, seq, sock_addr.nl_pid);
|
|
|
|
}
|
|
|
|
|
2020-01-04 21:20:41 +01:00
|
|
|
address to_address(int const address_family, void const* in)
|
|
|
|
{
|
|
|
|
if (address_family == AF_INET6) return inaddr6_to_address(in);
|
|
|
|
else return inaddr_to_address(in);
|
|
|
|
}
|
|
|
|
|
2010-11-29 02:33:05 +01:00
|
|
|
bool parse_route(int s, nlmsghdr* nl_hdr, ip_route* rt_info)
|
2008-04-25 07:51:21 +02:00
|
|
|
{
|
2016-08-03 06:35:40 +02:00
|
|
|
rtmsg* rt_msg = reinterpret_cast<rtmsg*>(NLMSG_DATA(nl_hdr));
|
2008-04-28 02:20:59 +02:00
|
|
|
|
2017-02-08 13:52:23 +01:00
|
|
|
if (!valid_addr_family(rt_msg->rtm_family) || (rt_msg->rtm_table != RT_TABLE_MAIN
|
2010-11-29 02:33:05 +01:00
|
|
|
&& rt_msg->rtm_table != RT_TABLE_LOCAL))
|
2008-04-28 03:23:11 +02:00
|
|
|
return false;
|
2008-04-28 02:20:59 +02:00
|
|
|
|
2018-05-29 02:15:02 +02:00
|
|
|
// make sure the defaults have the right address family
|
|
|
|
// in case the attributes are not present
|
|
|
|
if (rt_msg->rtm_family == AF_INET6)
|
|
|
|
{
|
|
|
|
rt_info->gateway = address_v6();
|
|
|
|
rt_info->destination = address_v6();
|
|
|
|
}
|
|
|
|
|
2010-11-29 02:33:05 +01:00
|
|
|
int if_index = 0;
|
2019-11-14 08:56:56 +01:00
|
|
|
auto rt_len = RTM_PAYLOAD(nl_hdr);
|
2016-08-03 06:35:40 +02:00
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic push
|
|
|
|
#pragma clang diagnostic ignored "-Wcast-align"
|
|
|
|
#endif
|
|
|
|
for (rtattr* rt_attr = reinterpret_cast<rtattr*>(RTM_RTA(rt_msg));
|
2017-03-09 13:46:52 +01:00
|
|
|
RTA_OK(rt_attr, rt_len); rt_attr = RTA_NEXT(rt_attr, rt_len))
|
2008-04-25 07:51:21 +02:00
|
|
|
{
|
2008-04-28 02:20:59 +02:00
|
|
|
switch(rt_attr->rta_type)
|
|
|
|
{
|
|
|
|
case RTA_OIF:
|
2016-08-03 06:35:40 +02:00
|
|
|
if_index = *reinterpret_cast<int*>(RTA_DATA(rt_attr));
|
2008-04-28 02:20:59 +02:00
|
|
|
break;
|
|
|
|
case RTA_GATEWAY:
|
2020-01-04 21:20:41 +01:00
|
|
|
rt_info->gateway = to_address(rt_msg->rtm_family, RTA_DATA(rt_attr));
|
2008-04-28 02:20:59 +02:00
|
|
|
break;
|
|
|
|
case RTA_DST:
|
2020-01-04 21:20:41 +01:00
|
|
|
rt_info->destination = to_address(rt_msg->rtm_family, RTA_DATA(rt_attr));
|
2008-04-28 02:20:59 +02:00
|
|
|
break;
|
2020-01-19 23:22:39 +01:00
|
|
|
case RTA_PREFSRC:
|
|
|
|
rt_info->source_hint = to_address(rt_msg->rtm_family, RTA_DATA(rt_attr));
|
|
|
|
break;
|
2008-04-28 02:20:59 +02:00
|
|
|
}
|
2008-04-25 07:51:21 +02:00
|
|
|
}
|
2016-08-03 06:35:40 +02:00
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic pop
|
|
|
|
#endif
|
2010-11-29 02:33:05 +01:00
|
|
|
|
2018-05-29 02:15:02 +02:00
|
|
|
if (rt_info->gateway.is_v6() && rt_info->gateway.to_v6().is_link_local())
|
|
|
|
{
|
|
|
|
address_v6 gateway6 = rt_info->gateway.to_v6();
|
2018-06-16 15:19:02 +02:00
|
|
|
gateway6.scope_id(std::uint32_t(if_index));
|
2018-05-29 02:15:02 +02:00
|
|
|
rt_info->gateway = gateway6;
|
|
|
|
}
|
|
|
|
|
2016-12-12 02:24:26 +01:00
|
|
|
ifreq req = {};
|
2017-09-12 23:10:11 +02:00
|
|
|
::if_indextoname(std::uint32_t(if_index), req.ifr_name);
|
2017-08-20 11:11:55 +02:00
|
|
|
static_assert(sizeof(rt_info->name) >= sizeof(req.ifr_name), "ip_route::name is too small");
|
|
|
|
std::memcpy(rt_info->name, req.ifr_name, sizeof(req.ifr_name));
|
2017-09-12 23:10:11 +02:00
|
|
|
::ioctl(s, ::siocgifmtu, &req);
|
2010-11-29 02:33:05 +01:00
|
|
|
rt_info->mtu = req.ifr_mtu;
|
2018-05-29 02:15:02 +02:00
|
|
|
rt_info->netmask = build_netmask(rt_msg->rtm_dst_len, rt_msg->rtm_family);
|
2008-04-28 03:23:11 +02:00
|
|
|
return true;
|
2008-04-25 07:51:21 +02:00
|
|
|
}
|
2017-06-27 06:34:24 +02:00
|
|
|
|
2017-08-20 10:55:59 +02:00
|
|
|
bool parse_nl_address(nlmsghdr* nl_hdr, ip_interface* ip_info)
|
2017-06-27 06:34:24 +02:00
|
|
|
{
|
|
|
|
ifaddrmsg* addr_msg = reinterpret_cast<ifaddrmsg*>(NLMSG_DATA(nl_hdr));
|
|
|
|
|
|
|
|
if (!valid_addr_family(addr_msg->ifa_family))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
ip_info->preferred = (addr_msg->ifa_flags & (IFA_F_DADFAILED | IFA_F_DEPRECATED | IFA_F_TENTATIVE)) == 0;
|
2020-01-06 10:57:34 +01:00
|
|
|
ip_info->netmask = build_netmask(addr_msg->ifa_prefixlen, addr_msg->ifa_family);
|
2017-06-27 06:34:24 +02:00
|
|
|
|
2018-05-17 00:54:46 +02:00
|
|
|
ip_info->interface_address = address();
|
2017-06-27 06:34:24 +02:00
|
|
|
int rt_len = int(IFA_PAYLOAD(nl_hdr));
|
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic push
|
|
|
|
#pragma clang diagnostic ignored "-Wcast-align"
|
|
|
|
#endif
|
|
|
|
for (rtattr* rt_attr = reinterpret_cast<rtattr*>(IFA_RTA(addr_msg));
|
|
|
|
RTA_OK(rt_attr, rt_len); rt_attr = RTA_NEXT(rt_attr, rt_len))
|
|
|
|
{
|
|
|
|
switch(rt_attr->rta_type)
|
|
|
|
{
|
|
|
|
case IFA_ADDRESS:
|
2018-05-17 00:54:46 +02:00
|
|
|
// if this is a point-to-point link then IFA_LOCAL holds
|
|
|
|
// the local address while IFA_ADDRESS is the destination
|
|
|
|
// don't overwrite the former with the latter
|
|
|
|
if (!ip_info->interface_address.is_unspecified())
|
|
|
|
break;
|
|
|
|
BOOST_FALLTHROUGH;
|
|
|
|
case IFA_LOCAL:
|
2017-06-27 06:34:24 +02:00
|
|
|
if (addr_msg->ifa_family == AF_INET6)
|
|
|
|
{
|
2020-01-04 21:20:41 +01:00
|
|
|
address_v6 addr = inaddr6_to_address(RTA_DATA(rt_attr));
|
2017-06-27 06:34:24 +02:00
|
|
|
if (addr_msg->ifa_scope == RT_SCOPE_LINK)
|
|
|
|
addr.scope_id(addr_msg->ifa_index);
|
|
|
|
ip_info->interface_address = addr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-01-04 21:20:41 +01:00
|
|
|
ip_info->interface_address = inaddr_to_address(RTA_DATA(rt_attr));
|
2017-06-27 06:34:24 +02:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic pop
|
|
|
|
#endif
|
|
|
|
|
2017-08-20 10:55:59 +02:00
|
|
|
static_assert(sizeof(ip_info->name) >= IF_NAMESIZE, "not enough space in ip_interface::name");
|
|
|
|
if_indextoname(addr_msg->ifa_index, ip_info->name);
|
2017-06-27 06:34:24 +02:00
|
|
|
return true;
|
|
|
|
}
|
2016-06-06 04:13:01 +02:00
|
|
|
#endif // TORRENT_USE_NETLINK
|
|
|
|
#endif // !BUILD_SIMULATOR
|
2007-09-10 01:52:34 +02:00
|
|
|
|
2015-09-02 07:30:40 +02:00
|
|
|
#if TORRENT_USE_SYSCTL && !defined TORRENT_BUILD_SIMULATOR
|
2012-09-24 18:13:57 +02:00
|
|
|
#ifdef TORRENT_OS2
|
|
|
|
int _System __libsocket_sysctl(int* mib, u_int namelen, void *oldp, size_t *oldlenp, void *newp, size_t newlen);
|
|
|
|
#endif
|
2007-09-10 01:52:34 +02:00
|
|
|
|
2017-08-20 11:11:55 +02:00
|
|
|
bool parse_route(int, rt_msghdr* rtm, ip_route* rt_info)
|
2007-09-10 01:52:34 +02:00
|
|
|
{
|
2008-04-28 02:20:59 +02:00
|
|
|
sockaddr* rti_info[RTAX_MAX];
|
2018-01-11 01:35:15 +01:00
|
|
|
auto* sa = reinterpret_cast<sockaddr*>(rtm + 1);
|
2008-04-28 02:20:59 +02:00
|
|
|
for (int i = 0; i < RTAX_MAX; ++i)
|
2008-04-25 07:51:21 +02:00
|
|
|
{
|
2008-04-28 02:20:59 +02:00
|
|
|
if ((rtm->rtm_addrs & (1 << i)) == 0)
|
|
|
|
{
|
2016-07-09 22:26:26 +02:00
|
|
|
rti_info[i] = nullptr;
|
2008-04-28 02:20:59 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
rti_info[i] = sa;
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
#define ROUNDUP(a) \
|
|
|
|
((a) > 0 ? (1 + (((a) - 1) | (sizeof(long) - 1))) : sizeof(long))
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2015-08-18 15:33:00 +02:00
|
|
|
sa = reinterpret_cast<sockaddr*>(reinterpret_cast<char*>(sa) + ROUNDUP(sa->sa_len));
|
2008-04-28 02:20:59 +02:00
|
|
|
|
|
|
|
#undef ROUNDUP
|
2008-01-11 07:49:37 +01:00
|
|
|
}
|
2008-01-12 10:35:11 +01:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
sa = rti_info[RTAX_GATEWAY];
|
2016-07-09 22:26:26 +02:00
|
|
|
if (sa == nullptr
|
|
|
|
|| rti_info[RTAX_DST] == nullptr
|
|
|
|
|| rti_info[RTAX_NETMASK] == nullptr
|
2017-02-08 13:52:23 +01:00
|
|
|
|| !valid_addr_family(sa->sa_family))
|
2008-04-28 02:20:59 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
rt_info->gateway = sockaddr_to_address(rti_info[RTAX_GATEWAY]);
|
|
|
|
rt_info->destination = sockaddr_to_address(rti_info[RTAX_DST]);
|
2010-11-29 02:33:05 +01:00
|
|
|
rt_info->netmask = sockaddr_to_address(rti_info[RTAX_NETMASK]
|
|
|
|
, rt_info->destination.is_v4() ? AF_INET : AF_INET6);
|
2008-04-28 02:20:59 +02:00
|
|
|
if_indextoname(rtm->rtm_index, rt_info->name);
|
2020-01-19 23:22:39 +01:00
|
|
|
if (rti_info[RTAX_IFA]) rt_info->source_hint = sockaddr_to_address(rti_info[RTAX_IFA]);
|
2008-04-28 02:20:59 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-09-02 07:30:40 +02:00
|
|
|
#if TORRENT_USE_IFADDRS && !defined TORRENT_BUILD_SIMULATOR
|
2015-05-18 07:04:55 +02:00
|
|
|
bool iface_from_ifaddrs(ifaddrs *ifa, ip_interface &rv)
|
2011-02-15 07:29:44 +01:00
|
|
|
{
|
2017-02-08 13:52:23 +01:00
|
|
|
if (!valid_addr_family(ifa->ifa_addr->sa_family))
|
2011-02-15 07:29:44 +01:00
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2020-02-15 11:08:04 +01:00
|
|
|
std::strncpy(rv.name, ifa->ifa_name, sizeof(rv.name) - 1);
|
2020-01-04 22:49:16 +01:00
|
|
|
rv.name[sizeof(rv.name) - 1] = '\0';
|
2011-02-15 07:29:44 +01:00
|
|
|
|
|
|
|
// determine address
|
|
|
|
rv.interface_address = sockaddr_to_address(ifa->ifa_addr);
|
|
|
|
// determine netmask
|
2016-06-20 17:32:06 +02:00
|
|
|
if (ifa->ifa_netmask != nullptr)
|
2011-02-15 07:29:44 +01:00
|
|
|
{
|
|
|
|
rv.netmask = sockaddr_to_address(ifa->ifa_netmask);
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2020-01-06 10:57:34 +01:00
|
|
|
void build_netmask_impl(span<unsigned char> mask, int prefix_bits)
|
|
|
|
{
|
|
|
|
TORRENT_ASSERT(prefix_bits <= mask.size() * 8);
|
2020-01-17 01:09:23 +01:00
|
|
|
TORRENT_ASSERT(prefix_bits >= 0);
|
2020-01-06 10:57:34 +01:00
|
|
|
int i = 0;
|
|
|
|
while (prefix_bits >= 8)
|
|
|
|
{
|
|
|
|
mask[i] = 0xff;
|
|
|
|
prefix_bits -= 8;
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
if (i < mask.size())
|
|
|
|
{
|
|
|
|
mask[i] = (0xff << (8 - prefix_bits)) & 0xff;
|
|
|
|
++i;
|
|
|
|
while (i < mask.size())
|
|
|
|
{
|
|
|
|
mask[i] = 0;
|
|
|
|
++i;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-03 12:57:15 +02:00
|
|
|
} // <anonymous>
|
2015-05-18 07:04:55 +02:00
|
|
|
|
2020-01-06 10:57:34 +01:00
|
|
|
address build_netmask(int prefix_bits, int const family)
|
|
|
|
{
|
|
|
|
if (family == AF_INET)
|
|
|
|
{
|
|
|
|
address_v4::bytes_type b;
|
|
|
|
build_netmask_impl(b, prefix_bits);
|
|
|
|
return address_v4(b);
|
|
|
|
}
|
|
|
|
else if (family == AF_INET6)
|
|
|
|
{
|
|
|
|
address_v6::bytes_type b;
|
|
|
|
build_netmask_impl(b, prefix_bits);
|
|
|
|
return address_v6(b);
|
|
|
|
}
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2010-11-29 02:33:05 +01:00
|
|
|
// return (a1 & mask) == (a2 & mask)
|
|
|
|
bool match_addr_mask(address const& a1, address const& a2, address const& mask)
|
2008-01-11 07:49:37 +01:00
|
|
|
{
|
2010-11-29 02:33:05 +01:00
|
|
|
// all 3 addresses needs to belong to the same family
|
|
|
|
if (a1.is_v4() != a2.is_v4()) return false;
|
|
|
|
if (a1.is_v4() != mask.is_v4()) return false;
|
|
|
|
|
|
|
|
if (a1.is_v6())
|
|
|
|
{
|
2020-01-06 10:11:21 +01:00
|
|
|
if (a1.to_v6().scope_id() != a2.to_v6().scope_id()) return false;
|
|
|
|
|
2017-08-16 02:13:32 +02:00
|
|
|
address_v6::bytes_type b1 = a1.to_v6().to_bytes();
|
|
|
|
address_v6::bytes_type b2 = a2.to_v6().to_bytes();
|
|
|
|
address_v6::bytes_type m = mask.to_v6().to_bytes();
|
2017-01-15 00:53:25 +01:00
|
|
|
for (std::size_t i = 0; i < b1.size(); ++i)
|
2014-03-10 06:53:49 +01:00
|
|
|
{
|
2010-11-29 02:33:05 +01:00
|
|
|
b1[i] &= m[i];
|
2014-03-10 06:53:49 +01:00
|
|
|
b2[i] &= m[i];
|
|
|
|
}
|
2018-08-15 00:02:37 +02:00
|
|
|
return b1 == b2;
|
2010-11-29 02:33:05 +01:00
|
|
|
}
|
|
|
|
return (a1.to_v4().to_ulong() & mask.to_v4().to_ulong())
|
|
|
|
== (a2.to_v4().to_ulong() & mask.to_v4().to_ulong());
|
2008-01-11 07:49:37 +01:00
|
|
|
}
|
2007-09-10 01:52:34 +02:00
|
|
|
|
2008-05-03 18:05:42 +02:00
|
|
|
std::vector<ip_interface> enum_net_interfaces(io_service& ios, error_code& ec)
|
2008-01-11 07:49:37 +01:00
|
|
|
{
|
2015-05-18 07:04:55 +02:00
|
|
|
TORRENT_UNUSED(ios); // this may be unused depending on configuration
|
2008-01-11 07:49:37 +01:00
|
|
|
std::vector<ip_interface> ret;
|
2017-05-23 05:44:00 +02:00
|
|
|
ec.clear();
|
2015-08-09 21:01:01 +02:00
|
|
|
#if defined TORRENT_BUILD_SIMULATOR
|
|
|
|
|
2015-10-24 21:57:22 +02:00
|
|
|
std::vector<address> ips = ios.get_ips();
|
|
|
|
|
2017-04-03 00:45:46 +02:00
|
|
|
for (auto const& ip : ips)
|
2015-10-24 21:57:22 +02:00
|
|
|
{
|
|
|
|
ip_interface wan;
|
2017-04-03 00:45:46 +02:00
|
|
|
wan.interface_address = ip;
|
2020-01-07 18:14:36 +01:00
|
|
|
if (ip.is_v4())
|
|
|
|
wan.netmask = address_v4::from_string("255.0.0.0");
|
|
|
|
else
|
|
|
|
wan.netmask = address_v6::from_string("ffff::");
|
2017-08-16 02:13:32 +02:00
|
|
|
std::strcpy(wan.name, "eth0");
|
2018-02-19 11:46:35 +01:00
|
|
|
std::strcpy(wan.friendly_name, "Ethernet");
|
|
|
|
std::strcpy(wan.description, "Simulator Ethernet Adapter");
|
2015-10-24 21:57:22 +02:00
|
|
|
ret.push_back(wan);
|
|
|
|
}
|
2017-06-27 06:34:24 +02:00
|
|
|
#elif TORRENT_USE_NETLINK
|
2017-09-12 23:10:11 +02:00
|
|
|
int sock = ::socket(PF_ROUTE, SOCK_DGRAM, NETLINK_ROUTE);
|
2017-06-27 06:34:24 +02:00
|
|
|
if (sock < 0)
|
|
|
|
{
|
|
|
|
ec = error_code(errno, system_category());
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-08-20 10:55:59 +02:00
|
|
|
char msg[NL_BUFSIZE] = {};
|
|
|
|
nlmsghdr* nl_msg = reinterpret_cast<nlmsghdr*>(msg);
|
|
|
|
int len = nl_dump_request(sock, RTM_GETADDR, 0, AF_PACKET, msg, sizeof(ifaddrmsg));
|
|
|
|
if (len < 0)
|
2017-06-27 06:34:24 +02:00
|
|
|
{
|
2017-08-20 10:55:59 +02:00
|
|
|
ec = error_code(errno, system_category());
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(sock);
|
2017-08-20 10:55:59 +02:00
|
|
|
return ret;
|
2017-06-27 06:34:24 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic push
|
|
|
|
#pragma clang diagnostic ignored "-Wcast-align"
|
|
|
|
// NLMSG_OK uses signed/unsigned compare in the same expression
|
|
|
|
#pragma clang diagnostic ignored "-Wsign-compare"
|
|
|
|
#endif
|
2017-08-20 10:55:59 +02:00
|
|
|
for (; NLMSG_OK(nl_msg, len); nl_msg = NLMSG_NEXT(nl_msg, len))
|
|
|
|
{
|
|
|
|
ip_interface iface;
|
|
|
|
if (parse_nl_address(nl_msg, &iface)) ret.push_back(iface);
|
|
|
|
}
|
2017-06-27 06:34:24 +02:00
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic pop
|
|
|
|
#endif
|
2015-08-09 21:01:01 +02:00
|
|
|
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(sock);
|
2015-08-09 21:01:01 +02:00
|
|
|
#elif TORRENT_USE_IFADDRS
|
2017-09-12 23:10:11 +02:00
|
|
|
int s = ::socket(AF_INET, SOCK_DGRAM, 0);
|
2011-02-15 07:29:44 +01:00
|
|
|
if (s < 0)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2011-02-15 07:29:44 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifaddrs *ifaddr;
|
|
|
|
if (getifaddrs(&ifaddr) == -1)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2011-02-15 07:29:44 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-08-16 02:13:32 +02:00
|
|
|
for (ifaddrs* ifa = ifaddr; ifa != nullptr; ifa = ifa->ifa_next)
|
2011-02-15 07:29:44 +01:00
|
|
|
{
|
2016-07-09 22:26:26 +02:00
|
|
|
if (ifa->ifa_addr == nullptr) continue;
|
2011-02-15 07:29:44 +01:00
|
|
|
if ((ifa->ifa_flags & IFF_UP) == 0) continue;
|
|
|
|
|
2017-02-08 13:52:23 +01:00
|
|
|
if (valid_addr_family(ifa->ifa_addr->sa_family))
|
2011-02-15 07:29:44 +01:00
|
|
|
{
|
|
|
|
ip_interface iface;
|
2015-05-18 07:04:55 +02:00
|
|
|
if (iface_from_ifaddrs(ifa, iface))
|
2011-02-15 07:29:44 +01:00
|
|
|
ret.push_back(iface);
|
|
|
|
}
|
|
|
|
}
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2011-02-15 07:29:44 +01:00
|
|
|
freeifaddrs(ifaddr);
|
|
|
|
// MacOS X, BSD and solaris
|
2011-04-09 05:49:46 +02:00
|
|
|
#elif TORRENT_USE_IFCONF
|
2017-09-12 23:10:11 +02:00
|
|
|
int s = ::socket(AF_INET, SOCK_DGRAM, 0);
|
2007-09-10 01:52:34 +02:00
|
|
|
if (s < 0)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2007-09-10 01:52:34 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ifconf ifc;
|
2012-05-12 18:15:36 +02:00
|
|
|
// make sure the buffer is aligned to hold ifreq structs
|
2012-05-13 06:43:22 +02:00
|
|
|
ifreq buf[40];
|
2007-09-10 01:52:34 +02:00
|
|
|
ifc.ifc_len = sizeof(buf);
|
2016-08-03 06:35:40 +02:00
|
|
|
ifc.ifc_buf = reinterpret_cast<char*>(buf);
|
2007-09-10 01:52:34 +02:00
|
|
|
if (ioctl(s, SIOCGIFCONF, &ifc) < 0)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2007-09-10 01:52:34 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-08-03 06:35:40 +02:00
|
|
|
char *ifr = reinterpret_cast<char*>(ifc.ifc_req);
|
2007-09-10 01:52:34 +02:00
|
|
|
int remaining = ifc.ifc_len;
|
|
|
|
|
2012-05-13 20:48:10 +02:00
|
|
|
while (remaining > 0)
|
2007-09-10 01:52:34 +02:00
|
|
|
{
|
|
|
|
ifreq const& item = *reinterpret_cast<ifreq*>(ifr);
|
2008-01-11 07:49:37 +01:00
|
|
|
|
2012-05-13 20:48:10 +02:00
|
|
|
#ifdef _SIZEOF_ADDR_IFREQ
|
|
|
|
int current_size = _SIZEOF_ADDR_IFREQ(item);
|
|
|
|
#elif defined TORRENT_BSD
|
|
|
|
int current_size = item.ifr_addr.sa_len + IFNAMSIZ;
|
|
|
|
#else
|
|
|
|
int current_size = sizeof(ifreq);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (remaining < current_size) break;
|
|
|
|
|
2017-02-08 13:52:23 +01:00
|
|
|
if (valid_addr_family(item.ifr_addr.sa_family))
|
2007-09-20 18:25:07 +02:00
|
|
|
{
|
2008-01-11 07:49:37 +01:00
|
|
|
ip_interface iface;
|
|
|
|
iface.interface_address = sockaddr_to_address(&item.ifr_addr);
|
2020-02-15 11:08:04 +01:00
|
|
|
std::strncpy(iface.name, item.ifr_name, sizeof(iface.name) - 1);
|
2020-01-04 22:49:16 +01:00
|
|
|
iface.name[sizeof(iface.name) - 1] = '\0';
|
2008-01-11 07:49:37 +01:00
|
|
|
|
2016-12-12 02:24:26 +01:00
|
|
|
ifreq req = {};
|
2017-08-16 02:13:32 +02:00
|
|
|
std::strncpy(req.ifr_name, item.ifr_name, IF_NAMESIZE - 1);
|
2010-11-29 02:33:05 +01:00
|
|
|
if (ioctl(s, SIOCGIFNETMASK, &req) < 0)
|
2008-01-11 07:49:37 +01:00
|
|
|
{
|
2008-01-11 08:56:52 +01:00
|
|
|
if (iface.interface_address.is_v6())
|
|
|
|
{
|
|
|
|
// this is expected to fail (at least on MacOS X)
|
|
|
|
iface.netmask = address_v6::any();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2008-01-11 08:56:52 +01:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-11-29 02:33:05 +01:00
|
|
|
iface.netmask = sockaddr_to_address(&req.ifr_addr, item.ifr_addr.sa_family);
|
2008-01-11 07:49:37 +01:00
|
|
|
}
|
|
|
|
ret.push_back(iface);
|
2007-09-10 01:52:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
ifr += current_size;
|
|
|
|
remaining -= current_size;
|
|
|
|
}
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2007-09-10 01:52:34 +02:00
|
|
|
|
2011-04-09 05:49:46 +02:00
|
|
|
#elif TORRENT_USE_GETADAPTERSADDRESSES
|
2007-09-10 01:52:34 +02:00
|
|
|
|
2010-12-01 06:47:18 +01:00
|
|
|
#if _WIN32_WINNT >= 0x0501
|
2018-03-22 17:01:38 +01:00
|
|
|
using GetAdaptersAddresses_t = ULONG (WINAPI *)(ULONG,ULONG,PVOID,PIP_ADAPTER_ADDRESSES,PULONG);
|
2016-12-27 07:45:48 +01:00
|
|
|
// Get GetAdaptersAddresses() pointer
|
|
|
|
auto GetAdaptersAddresses =
|
2016-12-28 19:12:20 +01:00
|
|
|
aux::get_library_procedure<aux::iphlpapi, GetAdaptersAddresses_t>("GetAdaptersAddresses");
|
2010-11-29 02:33:05 +01:00
|
|
|
|
2016-12-27 07:45:48 +01:00
|
|
|
if (GetAdaptersAddresses != nullptr)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ULONG buf_size = 10000;
|
|
|
|
std::vector<char> buffer(buf_size);
|
|
|
|
PIP_ADAPTER_ADDRESSES adapter_addresses
|
|
|
|
= reinterpret_cast<IP_ADAPTER_ADDRESSES*>(&buffer[0]);
|
|
|
|
|
2016-04-17 22:56:07 +02:00
|
|
|
DWORD res = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER
|
2016-06-20 17:32:06 +02:00
|
|
|
| GAA_FLAG_SKIP_ANYCAST, nullptr, adapter_addresses, &buf_size);
|
2016-04-17 22:56:07 +02:00
|
|
|
if (res == ERROR_BUFFER_OVERFLOW)
|
2016-02-05 05:58:50 +01:00
|
|
|
{
|
|
|
|
buffer.resize(buf_size);
|
2016-03-01 00:14:10 +01:00
|
|
|
adapter_addresses = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(&buffer[0]);
|
2016-04-17 22:56:07 +02:00
|
|
|
res = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER
|
2016-06-20 17:32:06 +02:00
|
|
|
| GAA_FLAG_SKIP_ANYCAST, nullptr, adapter_addresses, &buf_size);
|
2016-02-05 05:58:50 +01:00
|
|
|
}
|
2016-04-17 22:56:07 +02:00
|
|
|
if (res != NO_ERROR)
|
2016-02-05 05:58:50 +01:00
|
|
|
{
|
|
|
|
ec = error_code(WSAGetLastError(), system_category());
|
|
|
|
return std::vector<ip_interface>();
|
|
|
|
}
|
2010-11-29 02:33:05 +01:00
|
|
|
|
2016-02-05 05:58:50 +01:00
|
|
|
for (PIP_ADAPTER_ADDRESSES adapter = adapter_addresses;
|
|
|
|
adapter != 0; adapter = adapter->Next)
|
|
|
|
{
|
|
|
|
ip_interface r;
|
2020-02-15 11:08:04 +01:00
|
|
|
std::strncpy(r.name, adapter->AdapterName, sizeof(r.name) - 1);
|
2020-01-04 22:49:16 +01:00
|
|
|
r.name[sizeof(r.name) - 1] = '\0';
|
2018-02-19 11:46:35 +01:00
|
|
|
wcstombs(r.friendly_name, adapter->FriendlyName, sizeof(r.friendly_name));
|
2020-01-04 22:49:16 +01:00
|
|
|
r.friendly_name[sizeof(r.friendly_name) - 1] = '\0';
|
2018-02-19 11:46:35 +01:00
|
|
|
wcstombs(r.description, adapter->Description, sizeof(r.description));
|
2020-01-04 22:49:16 +01:00
|
|
|
r.description[sizeof(r.description) - 1] = '\0';
|
2017-02-11 21:47:22 +01:00
|
|
|
for (IP_ADAPTER_UNICAST_ADDRESS* unicast = adapter->FirstUnicastAddress;
|
|
|
|
unicast; unicast = unicast->Next)
|
2010-11-29 02:33:05 +01:00
|
|
|
{
|
2020-01-16 05:25:47 +01:00
|
|
|
auto const family = unicast->Address.lpSockaddr->sa_family;
|
|
|
|
if (!valid_addr_family(family))
|
2017-02-08 13:56:20 +01:00
|
|
|
continue;
|
2017-05-30 03:16:02 +02:00
|
|
|
r.preferred = unicast->DadState == IpDadStatePreferred;
|
2016-02-05 05:58:50 +01:00
|
|
|
r.interface_address = sockaddr_to_address(unicast->Address.lpSockaddr);
|
2020-01-16 05:25:47 +01:00
|
|
|
int const max_prefix_len = family == AF_INET ? 32 : 128;
|
2020-01-17 01:09:23 +01:00
|
|
|
|
|
|
|
if (unicast->Length <= offsetof(IP_ADAPTER_UNICAST_ADDRESS, OnLinkPrefixLength))
|
2020-01-16 05:25:47 +01:00
|
|
|
{
|
2020-01-17 01:09:23 +01:00
|
|
|
// OnLinkPrefixLength is only present on Vista and newer. If
|
|
|
|
// we're running on XP, we don't have the netmask.
|
|
|
|
r.netmask = (family == AF_INET)
|
|
|
|
? address(address_v4())
|
|
|
|
: address(address_v6());
|
|
|
|
ret.push_back(r);
|
|
|
|
continue;
|
2020-01-16 05:25:47 +01:00
|
|
|
}
|
|
|
|
|
2020-01-17 01:09:23 +01:00
|
|
|
if (family == AF_INET6
|
|
|
|
&& unicast->OnLinkPrefixLength == 128
|
|
|
|
&& (unicast->PrefixOrigin == IpPrefixOriginDhcp
|
|
|
|
|| unicast->SuffixOrigin == IpSuffixOriginRandom))
|
2020-01-16 05:25:47 +01:00
|
|
|
{
|
|
|
|
// DHCPv6 does not specify a subnet mask (it should be taken from the RA)
|
|
|
|
// but apparently MS didn't get the memo and incorrectly reports a
|
|
|
|
// prefix length of 128 for DHCPv6 assigned addresses
|
|
|
|
// 128 is also reported for privacy addresses despite claiming to
|
2020-01-17 01:09:23 +01:00
|
|
|
// have gotten the prefix length from the RA *shrug*
|
2020-01-16 05:25:47 +01:00
|
|
|
// use a 64 bit prefix in these cases since that is likely to be
|
|
|
|
// the correct value, or at least less wrong than 128
|
|
|
|
r.netmask = build_netmask(64, family);
|
|
|
|
}
|
2020-01-17 01:09:23 +01:00
|
|
|
else if (unicast->OnLinkPrefixLength <= max_prefix_len)
|
|
|
|
{
|
|
|
|
r.netmask = build_netmask(unicast->OnLinkPrefixLength, family);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// we don't know what the netmask is
|
|
|
|
r.netmask = (family == AF_INET)
|
|
|
|
? address(address_v4())
|
|
|
|
: address(address_v6());
|
|
|
|
}
|
|
|
|
|
2016-02-05 05:58:50 +01:00
|
|
|
ret.push_back(r);
|
|
|
|
}
|
2010-11-29 02:33:05 +01:00
|
|
|
}
|
2016-02-05 05:58:50 +01:00
|
|
|
|
|
|
|
return ret;
|
2010-11-29 02:33:05 +01:00
|
|
|
}
|
2010-12-01 06:47:18 +01:00
|
|
|
#endif
|
2010-11-29 02:33:05 +01:00
|
|
|
|
2017-09-12 23:10:11 +02:00
|
|
|
SOCKET s = ::socket(AF_INET, SOCK_DGRAM, 0);
|
2016-12-09 14:23:54 +01:00
|
|
|
if (int(s) == SOCKET_ERROR)
|
2007-09-10 01:52:34 +02:00
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(WSAGetLastError(), system_category());
|
2007-09-10 01:52:34 +02:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
INTERFACE_INFO buffer[30];
|
|
|
|
DWORD size;
|
2015-05-18 07:04:55 +02:00
|
|
|
|
2007-09-10 01:52:34 +02:00
|
|
|
if (WSAIoctl(s, SIO_GET_INTERFACE_LIST, 0, 0, buffer,
|
|
|
|
sizeof(buffer), &size, 0, 0) != 0)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(WSAGetLastError(), system_category());
|
2007-09-10 01:52:34 +02:00
|
|
|
closesocket(s);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
closesocket(s);
|
|
|
|
|
|
|
|
int n = size / sizeof(INTERFACE_INFO);
|
|
|
|
|
|
|
|
for (int i = 0; i < n; ++i)
|
|
|
|
{
|
2020-01-04 22:49:16 +01:00
|
|
|
ip_interface iface;
|
2008-01-11 07:49:37 +01:00
|
|
|
iface.interface_address = sockaddr_to_address(&buffer[i].iiAddress.Address);
|
|
|
|
if (iface.interface_address == address_v4::any()) continue;
|
2010-11-29 02:33:05 +01:00
|
|
|
iface.netmask = sockaddr_to_address(&buffer[i].iiNetmask.Address
|
|
|
|
, iface.interface_address.is_v4() ? AF_INET : AF_INET6);
|
2008-01-11 07:49:37 +01:00
|
|
|
ret.push_back(iface);
|
2007-09-10 01:52:34 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
#else
|
2014-11-17 04:41:01 +01:00
|
|
|
|
2020-01-12 22:36:36 +01:00
|
|
|
#error "Don't know how to enumerate network interfaces on this platform"
|
2014-11-17 04:41:01 +01:00
|
|
|
|
2007-09-10 01:52:34 +02:00
|
|
|
#endif
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2020-01-18 11:03:58 +01:00
|
|
|
boost::optional<address> get_gateway(ip_interface const& iface, span<ip_route const> routes)
|
|
|
|
{
|
|
|
|
bool const v4 = iface.interface_address.is_v4();
|
|
|
|
|
|
|
|
// local IPv6 addresses can never be used to reach the internet
|
|
|
|
if (!v4 && is_local(iface.interface_address)) return {};
|
|
|
|
|
|
|
|
auto const it = std::find_if(routes.begin(), routes.end()
|
|
|
|
, [&](ip_route const& r) -> bool
|
|
|
|
{
|
|
|
|
return r.destination.is_unspecified()
|
|
|
|
&& r.destination.is_v4() == iface.interface_address.is_v4()
|
|
|
|
&& !r.gateway.is_unspecified()
|
|
|
|
// IPv6 gateways aren't addressed in the same network as the
|
|
|
|
// interface, but they are addressed by the local network address
|
|
|
|
// space. So this check only works for IPv4.
|
2020-02-08 21:11:39 +01:00
|
|
|
&& (!v4 || match_addr_mask(r.gateway, iface.interface_address, r.netmask))
|
2020-01-19 23:22:39 +01:00
|
|
|
// in case there are multiple networks on the same networking
|
|
|
|
// device, the source hint may be the only thing telling them
|
|
|
|
// apart
|
|
|
|
&& (r.source_hint.is_unspecified() || r.source_hint == iface.interface_address)
|
2020-01-18 11:03:58 +01:00
|
|
|
&& strcmp(r.name, iface.name) == 0;
|
|
|
|
});
|
|
|
|
if (it != routes.end()) return it->gateway;
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2015-08-09 21:01:01 +02:00
|
|
|
std::vector<ip_route> enum_routes(io_service& ios, error_code& ec)
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
|
|
|
std::vector<ip_route> ret;
|
2015-08-18 16:42:03 +02:00
|
|
|
TORRENT_UNUSED(ios);
|
2018-02-04 01:57:54 +01:00
|
|
|
TORRENT_UNUSED(ec);
|
2015-05-18 07:04:55 +02:00
|
|
|
|
2015-08-09 21:01:01 +02:00
|
|
|
#ifdef TORRENT_BUILD_SIMULATOR
|
|
|
|
|
2015-08-21 14:03:16 +02:00
|
|
|
TORRENT_UNUSED(ec);
|
|
|
|
|
2015-10-24 21:57:22 +02:00
|
|
|
std::vector<address> ips = ios.get_ips();
|
|
|
|
|
2017-04-03 00:45:46 +02:00
|
|
|
for (auto const& ip : ips)
|
2015-10-24 21:57:22 +02:00
|
|
|
{
|
|
|
|
ip_route r;
|
2017-04-03 00:45:46 +02:00
|
|
|
if (ip.is_v4())
|
2015-10-30 04:43:39 +01:00
|
|
|
{
|
|
|
|
r.destination = address_v4();
|
2020-01-07 18:14:36 +01:00
|
|
|
r.netmask = address_v4::from_string("255.0.0.0");
|
2017-04-03 00:45:46 +02:00
|
|
|
address_v4::bytes_type b = ip.to_v4().to_bytes();
|
2015-10-30 04:43:39 +01:00
|
|
|
b[3] = 1;
|
|
|
|
r.gateway = address_v4(b);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
r.destination = address_v6();
|
2020-01-07 18:14:36 +01:00
|
|
|
r.netmask = address_v6::from_string("ffff:ffff:ffff:ffff::0");
|
2017-04-03 00:45:46 +02:00
|
|
|
address_v6::bytes_type b = ip.to_v6().to_bytes();
|
2015-10-30 04:43:39 +01:00
|
|
|
b[14] = 1;
|
|
|
|
r.gateway = address_v6(b);
|
|
|
|
}
|
2017-08-16 02:13:32 +02:00
|
|
|
std::strcpy(r.name, "eth0");
|
2017-04-03 00:45:46 +02:00
|
|
|
r.mtu = ios.sim().config().path_mtu(ip, ip);
|
2015-10-24 21:57:22 +02:00
|
|
|
ret.push_back(r);
|
|
|
|
}
|
2015-08-09 21:01:01 +02:00
|
|
|
|
|
|
|
#elif TORRENT_USE_SYSCTL
|
2008-04-28 02:20:59 +02:00
|
|
|
/*
|
2008-01-11 10:38:05 +01:00
|
|
|
struct rt_msg
|
|
|
|
{
|
|
|
|
rt_msghdr m_rtm;
|
|
|
|
char buf[512];
|
|
|
|
};
|
|
|
|
|
|
|
|
rt_msg m;
|
|
|
|
int len = sizeof(rt_msg);
|
|
|
|
bzero(&m, len);
|
|
|
|
m.m_rtm.rtm_type = RTM_GET;
|
|
|
|
m.m_rtm.rtm_flags = RTF_UP | RTF_GATEWAY;
|
|
|
|
m.m_rtm.rtm_version = RTM_VERSION;
|
2008-04-28 02:20:59 +02:00
|
|
|
m.m_rtm.rtm_addrs = RTA_DST | RTA_GATEWAY | RTA_NETMASK;
|
2008-01-11 10:38:05 +01:00
|
|
|
m.m_rtm.rtm_seq = 0;
|
|
|
|
m.m_rtm.rtm_msglen = len;
|
|
|
|
|
2017-09-12 23:10:11 +02:00
|
|
|
int s = ::socket(PF_ROUTE, SOCK_RAW, AF_UNSPEC);
|
2008-01-11 10:38:05 +01:00
|
|
|
if (s == -1)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
2008-01-11 10:38:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
int n = write(s, &m, len);
|
|
|
|
if (n == -1)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
2008-01-11 10:38:05 +01:00
|
|
|
}
|
|
|
|
else if (n != len)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
2008-01-11 10:38:05 +01:00
|
|
|
}
|
|
|
|
bzero(&m, len);
|
|
|
|
|
|
|
|
n = read(s, &m, len);
|
|
|
|
if (n == -1)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
2008-01-11 10:38:05 +01:00
|
|
|
}
|
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
for (rt_msghdr* ptr = &m.m_rtm; (char*)ptr < ((char*)&m.m_rtm) + n; ptr = (rt_msghdr*)(((char*)ptr) + ptr->rtm_msglen))
|
2008-01-11 10:38:05 +01:00
|
|
|
{
|
2008-04-28 02:20:59 +02:00
|
|
|
std::cout << " rtm_msglen: " << ptr->rtm_msglen << std::endl;
|
|
|
|
std::cout << " rtm_type: " << ptr->rtm_type << std::endl;
|
|
|
|
if (ptr->rtm_errno)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(ptr->rtm_errno, system_category());
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
if (m.m_rtm.rtm_flags & RTF_UP == 0
|
|
|
|
|| m.m_rtm.rtm_flags & RTF_GATEWAY == 0)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2008-04-28 02:20:59 +02:00
|
|
|
return address_v4::any();
|
|
|
|
}
|
|
|
|
if (ptr->rtm_addrs & RTA_DST == 0
|
|
|
|
|| ptr->rtm_addrs & RTA_GATEWAY == 0
|
|
|
|
|| ptr->rtm_addrs & RTA_NETMASK == 0)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
if (ptr->rtm_msglen > len - ((char*)ptr - ((char*)&m.m_rtm)))
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
int min_len = sizeof(rt_msghdr) + 2 * sizeof(sockaddr_in);
|
|
|
|
if (m.m_rtm.rtm_msglen < min_len)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
2008-01-11 10:38:05 +01:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
ip_route r;
|
|
|
|
// destination
|
|
|
|
char* p = m.buf;
|
|
|
|
sockaddr_in* sin = (sockaddr_in*)p;
|
|
|
|
r.destination = sockaddr_to_address((sockaddr*)p);
|
2008-01-11 10:38:05 +01:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
// gateway
|
|
|
|
p += sin->sin_len;
|
|
|
|
sin = (sockaddr_in*)p;
|
|
|
|
r.gateway = sockaddr_to_address((sockaddr*)p);
|
|
|
|
|
|
|
|
// netmask
|
|
|
|
p += sin->sin_len;
|
|
|
|
sin = (sockaddr_in*)p;
|
|
|
|
r.netmask = sockaddr_to_address((sockaddr*)p);
|
|
|
|
ret.push_back(r);
|
2008-01-11 10:38:05 +01:00
|
|
|
}
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2008-04-28 02:20:59 +02:00
|
|
|
*/
|
2017-01-14 00:27:09 +01:00
|
|
|
int mib[6] = {CTL_NET, PF_ROUTE, 0, AF_UNSPEC, NET_RT_DUMP, 0};
|
2008-01-11 10:38:05 +01:00
|
|
|
|
2017-01-14 00:27:09 +01:00
|
|
|
std::size_t needed = 0;
|
2012-09-24 18:13:57 +02:00
|
|
|
#ifdef TORRENT_OS2
|
|
|
|
if (__libsocket_sysctl(mib, 6, 0, &needed, 0, 0) < 0)
|
|
|
|
#else
|
2016-07-09 22:26:26 +02:00
|
|
|
if (sysctl(mib, 6, nullptr, &needed, nullptr, 0) < 0)
|
2012-09-24 18:13:57 +02:00
|
|
|
#endif
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
2008-01-11 10:38:05 +01:00
|
|
|
|
2018-11-26 18:42:20 +01:00
|
|
|
if (needed == 0)
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
|
2016-09-01 15:43:53 +02:00
|
|
|
std::unique_ptr<char[]> buf(new (std::nothrow) char[needed]);
|
2018-01-11 01:35:15 +01:00
|
|
|
if (buf == nullptr)
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::no_memory;
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
|
2012-09-24 18:13:57 +02:00
|
|
|
#ifdef TORRENT_OS2
|
|
|
|
if (__libsocket_sysctl(mib, 6, buf.get(), &needed, 0, 0) < 0)
|
|
|
|
#else
|
2016-07-09 22:26:26 +02:00
|
|
|
if (sysctl(mib, 6, buf.get(), &needed, nullptr, 0) < 0)
|
2012-09-24 18:13:57 +02:00
|
|
|
#endif
|
2008-04-28 02:20:59 +02:00
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
|
|
|
|
char* end = buf.get() + needed;
|
|
|
|
|
2017-09-12 23:10:11 +02:00
|
|
|
int s = ::socket(AF_INET, SOCK_DGRAM, 0);
|
2010-11-29 02:33:05 +01:00
|
|
|
if (s < 0)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2010-11-29 02:33:05 +01:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
2008-04-28 02:20:59 +02:00
|
|
|
rt_msghdr* rtm;
|
|
|
|
for (char* next = buf.get(); next < end; next += rtm->rtm_msglen)
|
|
|
|
{
|
2015-08-18 15:33:00 +02:00
|
|
|
rtm = reinterpret_cast<rt_msghdr*>(next);
|
2016-06-22 01:05:22 +02:00
|
|
|
if (rtm->rtm_version != RTM_VERSION
|
2017-05-22 05:21:02 +02:00
|
|
|
|| (rtm->rtm_type != RTM_ADD
|
|
|
|
&& rtm->rtm_type != RTM_GET))
|
2016-06-22 01:05:22 +02:00
|
|
|
{
|
2008-04-28 02:20:59 +02:00
|
|
|
continue;
|
2016-06-22 01:05:22 +02:00
|
|
|
}
|
2015-05-18 07:04:55 +02:00
|
|
|
|
2008-04-28 02:20:59 +02:00
|
|
|
ip_route r;
|
2010-11-29 02:33:05 +01:00
|
|
|
if (parse_route(s, rtm, &r)) ret.push_back(r);
|
2008-04-28 02:20:59 +02:00
|
|
|
}
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(s);
|
2015-05-18 07:04:55 +02:00
|
|
|
|
2011-04-09 05:49:46 +02:00
|
|
|
#elif TORRENT_USE_GETIPFORWARDTABLE
|
2010-11-29 02:33:05 +01:00
|
|
|
/*
|
|
|
|
move this to enum_net_interfaces
|
2007-10-01 19:21:19 +02:00
|
|
|
// Get GetAdaptersInfo() pointer
|
2018-03-22 17:01:38 +01:00
|
|
|
using GetAdaptersInfo_t = DWORD (WINAPI*)(PIP_ADAPTER_INFO, PULONG);
|
2016-12-27 07:45:48 +01:00
|
|
|
GetAdaptersInfo_t GetAdaptersInfo = get_library_procedure<iphlpapi, GetAdaptersInfo_t>("GetAdaptersInfo");
|
|
|
|
if (GetAdaptersInfo == nullptr)
|
2007-10-01 19:21:19 +02:00
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
2007-10-01 19:21:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
PIP_ADAPTER_INFO adapter_info = 0;
|
|
|
|
ULONG out_buf_size = 0;
|
|
|
|
if (GetAdaptersInfo(adapter_info, &out_buf_size) != ERROR_BUFFER_OVERFLOW)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
2007-10-01 19:21:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
adapter_info = (IP_ADAPTER_INFO*)malloc(out_buf_size);
|
|
|
|
if (!adapter_info)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::no_memory;
|
2008-04-28 02:20:59 +02:00
|
|
|
return std::vector<ip_route>();
|
2007-10-01 19:21:19 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (GetAdaptersInfo(adapter_info, &out_buf_size) == NO_ERROR)
|
|
|
|
{
|
2008-01-11 10:38:05 +01:00
|
|
|
for (PIP_ADAPTER_INFO adapter = adapter_info;
|
|
|
|
adapter != 0; adapter = adapter->Next)
|
2007-10-01 19:21:19 +02:00
|
|
|
{
|
2008-04-28 02:20:59 +02:00
|
|
|
|
|
|
|
ip_route r;
|
2008-05-06 21:13:59 +02:00
|
|
|
r.destination = address::from_string(adapter->IpAddressList.IpAddress.String, ec);
|
2008-04-28 02:20:59 +02:00
|
|
|
r.gateway = address::from_string(adapter->GatewayList.IpAddress.String, ec);
|
|
|
|
r.netmask = address::from_string(adapter->IpAddressList.IpMask.String, ec);
|
2020-02-15 11:08:04 +01:00
|
|
|
strncpy(r.name, adapter->AdapterName, sizeof(r.name) - 1);
|
|
|
|
r.name[sizeof(r.name) - 1] = '\0';
|
2008-04-28 02:20:59 +02:00
|
|
|
|
2008-01-11 10:38:05 +01:00
|
|
|
if (ec)
|
|
|
|
{
|
2008-05-03 18:05:42 +02:00
|
|
|
ec = error_code();
|
2008-01-11 10:38:05 +01:00
|
|
|
continue;
|
|
|
|
}
|
2008-04-28 02:20:59 +02:00
|
|
|
ret.push_back(r);
|
2007-10-01 19:21:19 +02:00
|
|
|
}
|
|
|
|
}
|
2010-11-29 02:33:05 +01:00
|
|
|
|
2007-10-01 19:21:19 +02:00
|
|
|
// Free memory
|
|
|
|
free(adapter_info);
|
2010-11-29 02:33:05 +01:00
|
|
|
*/
|
2007-10-01 19:21:19 +02:00
|
|
|
|
2018-03-22 17:01:38 +01:00
|
|
|
using GetIfEntry_t = DWORD (WINAPI *)(PMIB_IFROW pIfRow);
|
|
|
|
auto GetIfEntry = aux::get_library_procedure<aux::iphlpapi, GetIfEntry_t>(
|
|
|
|
"GetIfEntry");
|
2016-12-27 07:45:48 +01:00
|
|
|
|
|
|
|
if (GetIfEntry == nullptr)
|
2011-04-10 05:45:13 +02:00
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2011-04-10 05:45:13 +02:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
|
2010-12-01 06:47:18 +01:00
|
|
|
#if _WIN32_WINNT >= 0x0600
|
2018-03-22 17:01:38 +01:00
|
|
|
using GetIpForwardTable2_t = DWORD (WINAPI *)(
|
2010-11-29 02:33:05 +01:00
|
|
|
ADDRESS_FAMILY, PMIB_IPFORWARD_TABLE2*);
|
2018-03-22 17:01:38 +01:00
|
|
|
using FreeMibTable_t = void (WINAPI *)(PVOID Memory);
|
2015-05-18 07:04:55 +02:00
|
|
|
|
2016-12-28 19:12:20 +01:00
|
|
|
auto GetIpForwardTable2 = aux::get_library_procedure<aux::iphlpapi, GetIpForwardTable2_t>("GetIpForwardTable2");
|
|
|
|
auto FreeMibTable = aux::get_library_procedure<aux::iphlpapi, FreeMibTable_t>("FreeMibTable");
|
2016-12-27 07:45:48 +01:00
|
|
|
if (GetIpForwardTable2 != nullptr && FreeMibTable != nullptr)
|
2010-11-29 02:33:05 +01:00
|
|
|
{
|
2016-06-20 17:32:06 +02:00
|
|
|
MIB_IPFORWARD_TABLE2* routes = nullptr;
|
2010-11-29 02:33:05 +01:00
|
|
|
int res = GetIpForwardTable2(AF_UNSPEC, &routes);
|
|
|
|
if (res == NO_ERROR)
|
|
|
|
{
|
2016-12-09 14:23:54 +01:00
|
|
|
for (int i = 0; i < int(routes->NumEntries); ++i)
|
2010-11-29 02:33:05 +01:00
|
|
|
{
|
|
|
|
ip_route r;
|
|
|
|
r.gateway = sockaddr_to_address((const sockaddr*)&routes->Table[i].NextHop);
|
2018-05-28 23:07:34 +02:00
|
|
|
// 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())
|
|
|
|
{
|
|
|
|
address_v6 gateway6 = r.gateway.to_v6();
|
|
|
|
gateway6.scope_id(routes->Table[i].InterfaceIndex);
|
|
|
|
r.gateway = gateway6;
|
|
|
|
}
|
2010-11-29 02:33:05 +01:00
|
|
|
r.destination = sockaddr_to_address(
|
|
|
|
(const sockaddr*)&routes->Table[i].DestinationPrefix.Prefix);
|
2018-05-20 06:29:07 +02:00
|
|
|
r.netmask = build_netmask(routes->Table[i].DestinationPrefix.PrefixLength
|
2010-11-29 02:33:05 +01:00
|
|
|
, routes->Table[i].DestinationPrefix.Prefix.si_family);
|
|
|
|
MIB_IFROW ifentry;
|
|
|
|
ifentry.dwIndex = routes->Table[i].InterfaceIndex;
|
|
|
|
if (GetIfEntry(&ifentry) == NO_ERROR)
|
|
|
|
{
|
2018-05-27 02:09:04 +02:00
|
|
|
WCHAR* name = ifentry.wszName;
|
|
|
|
// strip UNC prefix to match the names returned by enum_net_interfaces
|
|
|
|
if (wcsncmp(name, L"\\DEVICE\\TCPIP_", wcslen(L"\\DEVICE\\TCPIP_")) == 0)
|
|
|
|
{
|
|
|
|
name += wcslen(L"\\DEVICE\\TCPIP_");
|
|
|
|
}
|
2020-02-15 11:08:04 +01:00
|
|
|
wcstombs(r.name, name, sizeof(r.name) - 1);
|
|
|
|
r.name[sizeof(r.name) - 1] = '\0';
|
2010-11-29 02:33:05 +01:00
|
|
|
r.mtu = ifentry.dwMtu;
|
|
|
|
ret.push_back(r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (routes) FreeMibTable(routes);
|
|
|
|
return ret;
|
|
|
|
}
|
2010-12-01 06:47:18 +01:00
|
|
|
#endif
|
2010-11-29 02:33:05 +01:00
|
|
|
|
|
|
|
// Get GetIpForwardTable() pointer
|
2018-03-22 17:01:38 +01:00
|
|
|
using GetIpForwardTable_t = DWORD (WINAPI*)(PMIB_IPFORWARDTABLE pIpForwardTable,PULONG pdwSize,BOOL bOrder);
|
2015-05-18 07:04:55 +02:00
|
|
|
|
2016-12-28 19:12:20 +01:00
|
|
|
auto GetIpForwardTable = aux::get_library_procedure<aux::iphlpapi, GetIpForwardTable_t>("GetIpForwardTable");
|
2016-12-27 07:45:48 +01:00
|
|
|
if (GetIpForwardTable == nullptr)
|
2010-11-29 02:33:05 +01:00
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2010-11-29 02:33:05 +01:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
|
2016-06-20 17:32:06 +02:00
|
|
|
MIB_IPFORWARDTABLE* routes = nullptr;
|
2010-11-29 02:33:05 +01:00
|
|
|
ULONG out_buf_size = 0;
|
|
|
|
if (GetIpForwardTable(routes, &out_buf_size, FALSE) != ERROR_INSUFFICIENT_BUFFER)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::operation_not_supported;
|
2010-11-29 02:33:05 +01:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
|
|
|
|
routes = (MIB_IPFORWARDTABLE*)malloc(out_buf_size);
|
|
|
|
if (!routes)
|
|
|
|
{
|
2015-06-06 07:22:53 +02:00
|
|
|
ec = boost::asio::error::no_memory;
|
2010-11-29 02:33:05 +01:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (GetIpForwardTable(routes, &out_buf_size, FALSE) == NO_ERROR)
|
|
|
|
{
|
2016-12-09 14:23:54 +01:00
|
|
|
for (int i = 0; i < int(routes->dwNumEntries); ++i)
|
2010-11-29 02:33:05 +01:00
|
|
|
{
|
|
|
|
ip_route r;
|
2020-01-04 21:20:41 +01:00
|
|
|
r.destination = inaddr_to_address(&routes->table[i].dwForwardDest);
|
|
|
|
r.netmask = inaddr_to_address(&routes->table[i].dwForwardMask);
|
|
|
|
r.gateway = inaddr_to_address(&routes->table[i].dwForwardNextHop);
|
2010-11-29 02:33:05 +01:00
|
|
|
MIB_IFROW ifentry;
|
|
|
|
ifentry.dwIndex = routes->table[i].dwForwardIfIndex;
|
|
|
|
if (GetIfEntry(&ifentry) == NO_ERROR)
|
|
|
|
{
|
2020-02-15 11:08:04 +01:00
|
|
|
wcstombs(r.name, ifentry.wszName, sizeof(r.name) - 1);
|
|
|
|
r.name[sizeof(r.name) - 1] = '\0';
|
2010-11-29 02:33:05 +01:00
|
|
|
r.mtu = ifentry.dwMtu;
|
|
|
|
ret.push_back(r);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Free memory
|
|
|
|
free(routes);
|
2011-04-09 05:49:46 +02:00
|
|
|
#elif TORRENT_USE_NETLINK
|
2017-09-12 23:10:11 +02:00
|
|
|
int sock = ::socket(PF_ROUTE, SOCK_DGRAM, NETLINK_ROUTE);
|
2008-04-25 07:51:21 +02:00
|
|
|
if (sock < 0)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2008-04-28 03:23:11 +02:00
|
|
|
return std::vector<ip_route>();
|
2008-04-25 07:51:21 +02:00
|
|
|
}
|
|
|
|
|
2017-03-18 13:49:19 +01:00
|
|
|
std::uint32_t seq = 0;
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2017-06-27 06:34:24 +02:00
|
|
|
char msg[NL_BUFSIZE] = {};
|
2016-08-03 06:35:40 +02:00
|
|
|
nlmsghdr* nl_msg = reinterpret_cast<nlmsghdr*>(msg);
|
2017-06-27 06:34:24 +02:00
|
|
|
int len = nl_dump_request(sock, RTM_GETROUTE, seq++, AF_UNSPEC, msg, sizeof(rtmsg));
|
2008-04-25 07:51:21 +02:00
|
|
|
if (len < 0)
|
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(sock);
|
2008-04-28 03:23:11 +02:00
|
|
|
return std::vector<ip_route>();
|
2008-04-25 07:51:21 +02:00
|
|
|
}
|
|
|
|
|
2018-04-02 23:17:11 +02:00
|
|
|
close(sock);
|
2018-04-04 19:48:26 +02:00
|
|
|
sock = ::socket(AF_INET, SOCK_DGRAM, 0);
|
2018-04-02 23:17:11 +02:00
|
|
|
if (sock < 0)
|
2010-11-29 02:33:05 +01:00
|
|
|
{
|
2016-02-05 05:58:50 +01:00
|
|
|
ec = error_code(errno, system_category());
|
2010-11-29 02:33:05 +01:00
|
|
|
return std::vector<ip_route>();
|
|
|
|
}
|
2016-08-03 06:35:40 +02:00
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic push
|
|
|
|
#pragma clang diagnostic ignored "-Wcast-align"
|
2016-12-18 16:59:41 +01:00
|
|
|
// NLMSG_OK uses signed/unsigned compare in the same expression
|
|
|
|
#pragma clang diagnostic ignored "-Wsign-compare"
|
2016-08-03 06:35:40 +02:00
|
|
|
#endif
|
2008-04-25 07:51:21 +02:00
|
|
|
for (; NLMSG_OK(nl_msg, len); nl_msg = NLMSG_NEXT(nl_msg, len))
|
|
|
|
{
|
2008-04-28 02:20:59 +02:00
|
|
|
ip_route r;
|
2018-04-02 23:17:11 +02:00
|
|
|
if (parse_route(sock, nl_msg, &r)) ret.push_back(r);
|
2008-04-25 07:51:21 +02:00
|
|
|
}
|
2016-08-03 06:35:40 +02:00
|
|
|
#ifdef __clang__
|
|
|
|
#pragma clang diagnostic pop
|
|
|
|
#endif
|
2017-09-12 23:10:11 +02:00
|
|
|
::close(sock);
|
2008-04-25 07:51:21 +02:00
|
|
|
|
2020-01-12 22:36:36 +01:00
|
|
|
#else
|
|
|
|
#error "don't know how to enumerate network routes on this platform"
|
2007-10-01 19:21:19 +02:00
|
|
|
#endif
|
2008-04-28 02:20:59 +02:00
|
|
|
return ret;
|
2007-10-01 19:21:19 +02:00
|
|
|
}
|
|
|
|
|
2014-07-06 21:18:00 +02:00
|
|
|
// returns the device name whose local address is ``addr``. If
|
|
|
|
// no such device is found, an empty string is returned.
|
|
|
|
std::string device_for_address(address addr, io_service& ios, error_code& ec)
|
|
|
|
{
|
|
|
|
std::vector<ip_interface> ifs = enum_net_interfaces(ios, ec);
|
2018-11-26 15:16:39 +01:00
|
|
|
if (ec) return {};
|
2014-07-06 21:18:00 +02:00
|
|
|
|
2018-11-26 15:16:39 +01:00
|
|
|
auto const iter = std::find_if(ifs.begin(), ifs.end()
|
|
|
|
, [&addr](ip_interface const& iface)
|
|
|
|
{ return iface.interface_address == addr; });
|
|
|
|
return (iter == ifs.end()) ? std::string() : iter->name;
|
2014-07-06 21:18:00 +02:00
|
|
|
}
|
2007-09-10 01:52:34 +02:00
|
|
|
}
|