mirror of
https://github.com/boykopovar/AnyPS5.git
synced 2026-10-22 08:33:12 -05:00
Federico Marras
792fb27631
getifaddrs listed only the host's IPv4 and IPv6 addresses, so the per-interface AF_LINK entries FreeBSD's getifaddrs puts first were missing, and with them the interface index, hardware address, MTU and counters and every interface without an address. On Linux each interface now starts with an AF_LINK entry, followed by its addresses, as FreeBSD 11.4's getifaddrs orders them. Its address is a sockaddr_dl with the host index, type, name and hardware address (none for a loopback), sized as FreeBSD's if_attach sizes it. Its ifa_data is a 152-byte FreeBSD if_data filled as if_data_copy fills it: type, address and header length, link state, MTU, speed and the host's packet, byte, error, drop and multicast counters from sysfs, or the host list's 32-bit counters when sysfs cannot be read. Fields with no host equivalent are 0 and listed in the debt entry. Windows is unchanged.
380 lines
17 KiB
C++
380 lines
17 KiB
C++
#ifdef _WIN32
|
|
#define WIN32_LEAN_AND_MEAN
|
|
#include <winsock2.h>
|
|
#include <ws2tcpip.h>
|
|
#include <iphlpapi.h>
|
|
#else
|
|
#include <ifaddrs.h>
|
|
#include <linux/if_link.h>
|
|
#include <net/if.h>
|
|
#include <net/if_arp.h>
|
|
#include <netinet/in.h>
|
|
#include <netpacket/packet.h>
|
|
#include <sys/ioctl.h>
|
|
#include <sys/socket.h>
|
|
#include <unistd.h>
|
|
#include <algorithm>
|
|
#include <cerrno>
|
|
#include <fstream>
|
|
#endif
|
|
#include "prx/libc/include/ApplicationHeap.hpp"
|
|
#include "prx/libc/include/general/VabiMacros.hpp"
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <cstring>
|
|
#include <new>
|
|
#include <optional>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
extern "C" int* APS5_VABI __error_nid_postfix();
|
|
|
|
struct GuestInterfaceAddress {
|
|
GuestInterfaceAddress* next;
|
|
char* name;
|
|
std::uint32_t flags;
|
|
void* address;
|
|
void* netmask;
|
|
void* destination;
|
|
void* data;
|
|
};
|
|
static_assert(sizeof(GuestInterfaceAddress) == 56);
|
|
static_assert(offsetof(GuestInterfaceAddress, flags) == 16);
|
|
static_assert(offsetof(GuestInterfaceAddress, address) == 24);
|
|
static_assert(offsetof(GuestInterfaceAddress, destination) == 40);
|
|
static_assert(offsetof(GuestInterfaceAddress, data) == 48);
|
|
|
|
namespace {
|
|
constexpr std::uint32_t guestUp = 0x1;
|
|
constexpr std::uint32_t guestBroadcast = 0x2;
|
|
constexpr std::uint32_t guestLoopback = 0x8;
|
|
constexpr std::uint32_t guestPointToPoint = 0x10;
|
|
constexpr std::uint32_t guestRunning = 0x40;
|
|
constexpr std::uint32_t guestMulticast = 0x8000;
|
|
constexpr std::size_t guestNameCapacity = 16;
|
|
|
|
struct Entry {
|
|
std::string name;
|
|
std::uint32_t flags;
|
|
std::vector<std::uint8_t> address;
|
|
std::vector<std::uint8_t> netmask;
|
|
std::vector<std::uint8_t> destination;
|
|
std::vector<std::uint8_t> data;
|
|
};
|
|
|
|
std::vector<std::uint8_t> GuestIpv4(const std::uint8_t* bytes) {
|
|
std::vector<std::uint8_t> guest(16, 0);
|
|
guest[0] = 16;
|
|
guest[1] = 2;
|
|
std::memcpy(guest.data() + 4, bytes, 4);
|
|
return guest;
|
|
}
|
|
|
|
std::vector<std::uint8_t> GuestIpv6(const std::uint8_t* bytes, std::uint32_t scope) {
|
|
std::vector<std::uint8_t> guest(28, 0);
|
|
guest[0] = 28;
|
|
guest[1] = 28;
|
|
std::memcpy(guest.data() + 8, bytes, 16);
|
|
std::memcpy(guest.data() + 24, &scope, 4);
|
|
return guest;
|
|
}
|
|
|
|
std::vector<std::uint8_t> GuestAddress(const sockaddr* address) {
|
|
if (address->sa_family == AF_INET)
|
|
return GuestIpv4(reinterpret_cast<const std::uint8_t*>(&reinterpret_cast<const sockaddr_in*>(address)->sin_addr));
|
|
const auto* v6 = reinterpret_cast<const sockaddr_in6*>(address);
|
|
return GuestIpv6(reinterpret_cast<const std::uint8_t*>(&v6->sin6_addr), v6->sin6_scope_id);
|
|
}
|
|
|
|
std::string CheckedName(const char* name) {
|
|
const std::string checked(name);
|
|
if (checked.empty() || checked.size() >= guestNameCapacity)
|
|
throw std::runtime_error("getifaddrs: host interface name does not fit the guest's 16-byte limit: " + checked);
|
|
return checked;
|
|
}
|
|
|
|
std::size_t Aligned(std::size_t size) {
|
|
return (size + 7) & ~static_cast<std::size_t>(7);
|
|
}
|
|
|
|
std::vector<std::uint8_t> BroadcastAddress(const std::vector<std::uint8_t>& address, const std::vector<std::uint8_t>& netmask) {
|
|
std::vector<std::uint8_t> broadcast = address;
|
|
for (std::size_t index = 4; index < 8; ++index)
|
|
broadcast[index] = static_cast<std::uint8_t>(address[index] | static_cast<std::uint8_t>(~netmask[index]));
|
|
return broadcast;
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
std::vector<std::uint8_t> PrefixMask(int family, unsigned prefix) {
|
|
const unsigned bits = family == AF_INET ? 32 : 128;
|
|
if (prefix > bits) prefix = bits;
|
|
std::uint8_t mask[16] = {};
|
|
for (unsigned bit = 0; bit < prefix; ++bit) mask[bit / 8] |= static_cast<std::uint8_t>(0x80 >> (bit % 8));
|
|
return family == AF_INET ? GuestIpv4(mask) : GuestIpv6(mask, 0);
|
|
}
|
|
|
|
std::uint32_t InterfaceFlags(const IP_ADAPTER_ADDRESSES* adapter) {
|
|
std::uint32_t flags = 0;
|
|
if (adapter->OperStatus == IfOperStatusUp) flags |= guestUp | guestRunning;
|
|
if (adapter->IfType == IF_TYPE_SOFTWARE_LOOPBACK) flags |= guestLoopback;
|
|
else if (adapter->IfType != IF_TYPE_PPP && adapter->IfType != IF_TYPE_TUNNEL) flags |= guestBroadcast;
|
|
if (!(adapter->Flags & IP_ADAPTER_NO_MULTICAST)) flags |= guestMulticast;
|
|
return flags;
|
|
}
|
|
|
|
std::string InterfaceName(const IP_ADAPTER_ADDRESSES* adapter) {
|
|
char name[NDIS_IF_MAX_STRING_SIZE + 1] = {};
|
|
const auto status = ConvertInterfaceLuidToNameA(&adapter->Luid, name, sizeof(name));
|
|
if (status != NO_ERROR) throw std::runtime_error("getifaddrs: ConvertInterfaceLuidToNameA failed with " + std::to_string(status));
|
|
if (std::strlen(name) < guestNameCapacity) return CheckedName(name);
|
|
return "if" + std::to_string(adapter->IfIndex ? adapter->IfIndex : adapter->Ipv6IfIndex);
|
|
}
|
|
|
|
int HostEntries(std::vector<Entry>& entries) {
|
|
const ULONG options = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST | GAA_FLAG_SKIP_DNS_SERVER;
|
|
ULONG size = 0;
|
|
std::vector<std::uint8_t> storage;
|
|
ULONG result = GetAdaptersAddresses(AF_UNSPEC, options, nullptr, nullptr, &size);
|
|
for (unsigned calls = 1; result == ERROR_BUFFER_OVERFLOW && calls < 4; ++calls) {
|
|
storage.resize(size);
|
|
result = GetAdaptersAddresses(AF_UNSPEC, options, nullptr, reinterpret_cast<IP_ADAPTER_ADDRESSES*>(storage.data()), &size);
|
|
}
|
|
if (result == ERROR_NO_DATA) return 0;
|
|
if (result == ERROR_BUFFER_OVERFLOW) { *__error_nid_postfix() = 55; return -1; }
|
|
if (result == ERROR_NOT_ENOUGH_MEMORY) { *__error_nid_postfix() = 12; return -1; }
|
|
if (result != NO_ERROR) throw std::runtime_error("getifaddrs: GetAdaptersAddresses failed with " + std::to_string(result));
|
|
for (auto* adapter = reinterpret_cast<IP_ADAPTER_ADDRESSES*>(storage.data()); adapter; adapter = adapter->Next) {
|
|
std::string name;
|
|
for (auto* unicast = adapter->FirstUnicastAddress; unicast; unicast = unicast->Next) {
|
|
const sockaddr* address = unicast->Address.lpSockaddr;
|
|
if (!address || (address->sa_family != AF_INET && address->sa_family != AF_INET6)) continue;
|
|
if (name.empty()) name = InterfaceName(adapter);
|
|
Entry entry{name, InterfaceFlags(adapter), GuestAddress(address), PrefixMask(address->sa_family, unicast->OnLinkPrefixLength), {}};
|
|
if (address->sa_family == AF_INET && (entry.flags & guestBroadcast))
|
|
entry.destination = BroadcastAddress(entry.address, entry.netmask);
|
|
entries.push_back(std::move(entry));
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
#else
|
|
constexpr std::uint8_t guestLinkFamily = 18;
|
|
constexpr std::size_t guestLinkNameArea = 8 + 16;
|
|
constexpr std::size_t guestLinkMinimum = 54;
|
|
constexpr std::uint8_t guestTypeOther = 0x1;
|
|
constexpr std::uint8_t guestTypeEthernet = 0x6;
|
|
constexpr std::uint8_t guestTypePpp = 0x17;
|
|
constexpr std::uint8_t guestTypeLoopback = 0x18;
|
|
constexpr std::uint8_t guestLinkStateDown = 1;
|
|
constexpr std::uint8_t guestLinkStateUp = 2;
|
|
constexpr std::size_t guestInterfaceDataSize = 152;
|
|
constexpr unsigned int hostLowerUp = 0x10000;
|
|
|
|
struct HostInterface {
|
|
std::string name;
|
|
bool linked = false;
|
|
Entry link;
|
|
std::vector<Entry> addresses;
|
|
};
|
|
|
|
template<typename TValue>
|
|
void Store(std::vector<std::uint8_t>& bytes, std::size_t offset, TValue value) {
|
|
std::memcpy(bytes.data() + offset, &value, sizeof(value));
|
|
}
|
|
|
|
std::vector<std::uint8_t> GuestLinkAddress(const std::string& name, std::uint16_t index, std::uint8_t type, const std::uint8_t* hardware, std::size_t hardwareLength) {
|
|
std::size_t size = std::max(guestLinkMinimum, guestLinkNameArea + hardwareLength);
|
|
size = Aligned(size);
|
|
if (size > 0xFF) throw std::runtime_error("getifaddrs: link-level address of " + name + " does not fit sockaddr_dl");
|
|
std::vector<std::uint8_t> guest(size, 0);
|
|
guest[0] = static_cast<std::uint8_t>(size);
|
|
guest[1] = guestLinkFamily;
|
|
Store(guest, 2, index);
|
|
guest[4] = type;
|
|
guest[5] = static_cast<std::uint8_t>(name.size());
|
|
guest[6] = static_cast<std::uint8_t>(hardwareLength);
|
|
std::memcpy(guest.data() + 8, name.data(), name.size());
|
|
if (hardwareLength != 0) std::memcpy(guest.data() + 8 + name.size(), hardware, hardwareLength);
|
|
return guest;
|
|
}
|
|
|
|
std::optional<std::uint64_t> ReadSysfsCounter(const std::string& name, const char* file) {
|
|
std::ifstream input("/sys/class/net/" + name + "/" + file);
|
|
long long value = 0;
|
|
if (!(input >> value)) return std::nullopt;
|
|
return static_cast<std::uint64_t>(value);
|
|
}
|
|
|
|
std::uint32_t HostMtu(const std::string& name) {
|
|
const int probe = ::socket(AF_INET, SOCK_DGRAM, 0);
|
|
if (probe < 0) throw std::runtime_error(std::string("getifaddrs: no socket to read the MTU of ") + name + ": " + std::strerror(errno));
|
|
ifreq request{};
|
|
std::memcpy(request.ifr_name, name.c_str(), name.size() + 1);
|
|
const int result = ::ioctl(probe, SIOCGIFMTU, &request);
|
|
const int error = errno;
|
|
::close(probe);
|
|
if (result != 0) throw std::runtime_error(std::string("getifaddrs: SIOCGIFMTU failed on ") + name + ": " + std::strerror(error));
|
|
return static_cast<std::uint32_t>(request.ifr_mtu);
|
|
}
|
|
|
|
std::vector<std::uint8_t> GuestInterfaceData(const std::string& name, unsigned int hostFlags, const void* hostStats, std::uint8_t type, std::uint8_t hardwareLength) {
|
|
std::vector<std::uint8_t> data(guestInterfaceDataSize, 0);
|
|
data[0] = type;
|
|
data[2] = hardwareLength;
|
|
data[3] = type == guestTypeEthernet ? 14 : 0;
|
|
if (type == guestTypeLoopback) data[4] = (hostFlags & IFF_UP) ? guestLinkStateUp : guestLinkStateDown;
|
|
else data[4] = (hostFlags & hostLowerUp) ? guestLinkStateUp : guestLinkStateDown;
|
|
Store(data, 6, static_cast<std::uint16_t>(guestInterfaceDataSize));
|
|
Store(data, 8, HostMtu(name));
|
|
if (const auto speed = ReadSysfsCounter(name, "speed"); speed && static_cast<std::int64_t>(*speed) > 0)
|
|
Store(data, 16, *speed * 1000000u);
|
|
constexpr std::pair<const char*, std::size_t> counters[] = {
|
|
{"statistics/rx_packets", 24}, {"statistics/rx_errors", 32}, {"statistics/tx_packets", 40}, {"statistics/tx_errors", 48},
|
|
{"statistics/collisions", 56}, {"statistics/rx_bytes", 64}, {"statistics/tx_bytes", 72}, {"statistics/multicast", 80},
|
|
{"statistics/rx_dropped", 96}, {"statistics/tx_dropped", 104},
|
|
};
|
|
bool complete = true;
|
|
for (const auto& [file, offset] : counters) {
|
|
const auto value = ReadSysfsCounter(name, file);
|
|
if (!value) { complete = false; break; }
|
|
Store(data, offset, *value);
|
|
}
|
|
if (!complete) {
|
|
if (!hostStats) throw std::runtime_error("getifaddrs: no counters for " + name + " in sysfs or the host list");
|
|
rtnl_link_stats stats{};
|
|
std::memcpy(&stats, hostStats, sizeof(stats));
|
|
const std::pair<std::uint32_t, std::size_t> fallback[] = {
|
|
{stats.rx_packets, 24}, {stats.rx_errors, 32}, {stats.tx_packets, 40}, {stats.tx_errors, 48}, {stats.collisions, 56},
|
|
{stats.rx_bytes, 64}, {stats.tx_bytes, 72}, {stats.multicast, 80}, {stats.rx_dropped, 96}, {stats.tx_dropped, 104},
|
|
};
|
|
for (const auto& [value, offset] : fallback) Store(data, offset, static_cast<std::uint64_t>(value));
|
|
}
|
|
return data;
|
|
}
|
|
|
|
std::uint32_t InterfaceFlags(unsigned int host) {
|
|
constexpr std::pair<unsigned int, std::uint32_t> flags[] = {
|
|
{IFF_UP, guestUp}, {IFF_BROADCAST, guestBroadcast}, {IFF_LOOPBACK, guestLoopback},
|
|
{IFF_POINTOPOINT, guestPointToPoint}, {IFF_RUNNING, guestRunning}, {IFF_NOARP, 0x80},
|
|
{IFF_PROMISC, 0x100}, {IFF_ALLMULTI, 0x200}, {IFF_MULTICAST, guestMulticast},
|
|
};
|
|
std::uint32_t guest = 0;
|
|
for (const auto& [hostFlag, guestFlag] : flags)
|
|
if (host & hostFlag) guest |= guestFlag;
|
|
return guest;
|
|
}
|
|
|
|
int HostEntries(std::vector<Entry>& entries) {
|
|
ifaddrs* host = nullptr;
|
|
if (::getifaddrs(&host) != 0) {
|
|
const int hostError = errno;
|
|
switch (hostError) {
|
|
case ENOMEM: *__error_nid_postfix() = 12; return -1;
|
|
case ENOBUFS: *__error_nid_postfix() = 55; return -1;
|
|
case EMFILE: *__error_nid_postfix() = 24; return -1;
|
|
case ENFILE: *__error_nid_postfix() = 23; return -1;
|
|
default: throw std::runtime_error(std::string("getifaddrs: host enumeration failed: ") + std::strerror(hostError));
|
|
}
|
|
}
|
|
std::vector<HostInterface> interfaces;
|
|
const auto interfaceFor = [&](const std::string& name) -> HostInterface& {
|
|
const auto found = std::find_if(interfaces.begin(), interfaces.end(), [&](const HostInterface& candidate) { return candidate.name == name; });
|
|
if (found != interfaces.end()) return *found;
|
|
interfaces.push_back({name, false, {}, {}});
|
|
return interfaces.back();
|
|
};
|
|
try {
|
|
for (auto* item = host; item; item = item->ifa_next) {
|
|
if (!item->ifa_addr) continue;
|
|
if (item->ifa_addr->sa_family == AF_PACKET) {
|
|
const auto& link = *reinterpret_cast<const sockaddr_ll*>(item->ifa_addr);
|
|
HostInterface& owner = interfaceFor(CheckedName(item->ifa_name));
|
|
if (owner.linked) throw std::runtime_error("getifaddrs: two link-level entries for " + owner.name);
|
|
if (link.sll_ifindex <= 0 || link.sll_ifindex > 0xFFFF) throw std::runtime_error("getifaddrs: interface index of " + owner.name + " does not fit sockaddr_dl");
|
|
const std::uint8_t type = link.sll_hatype == ARPHRD_ETHER ? guestTypeEthernet : link.sll_hatype == ARPHRD_LOOPBACK ? guestTypeLoopback
|
|
: link.sll_hatype == ARPHRD_PPP ? guestTypePpp : guestTypeOther;
|
|
const std::uint8_t hardwareLength = type == guestTypeLoopback ? 0 : std::min<std::uint8_t>(link.sll_halen, sizeof(link.sll_addr));
|
|
owner.link = Entry{owner.name, InterfaceFlags(item->ifa_flags),
|
|
GuestLinkAddress(owner.name, static_cast<std::uint16_t>(link.sll_ifindex), type, link.sll_addr, hardwareLength), {}, {},
|
|
GuestInterfaceData(owner.name, item->ifa_flags, item->ifa_data, type, hardwareLength)};
|
|
owner.linked = true;
|
|
continue;
|
|
}
|
|
if (item->ifa_addr->sa_family != AF_INET && item->ifa_addr->sa_family != AF_INET6) continue;
|
|
if (!item->ifa_netmask) throw std::runtime_error(std::string("getifaddrs: host address without a netmask on ") + item->ifa_name);
|
|
Entry entry{CheckedName(item->ifa_name), InterfaceFlags(item->ifa_flags), GuestAddress(item->ifa_addr), GuestAddress(item->ifa_netmask), {}};
|
|
const int family = item->ifa_addr->sa_family;
|
|
if (item->ifa_flags & IFF_POINTOPOINT) {
|
|
if (item->ifa_dstaddr && item->ifa_dstaddr->sa_family == family) entry.destination = GuestAddress(item->ifa_dstaddr);
|
|
else entry.flags &= ~guestPointToPoint;
|
|
} else if (family == AF_INET && (item->ifa_flags & IFF_BROADCAST)) {
|
|
entry.destination = item->ifa_broadaddr && item->ifa_broadaddr->sa_family == AF_INET
|
|
? GuestAddress(item->ifa_broadaddr) : BroadcastAddress(entry.address, entry.netmask);
|
|
}
|
|
interfaceFor(entry.name).addresses.push_back(std::move(entry));
|
|
}
|
|
} catch (...) {
|
|
::freeifaddrs(host);
|
|
throw;
|
|
}
|
|
::freeifaddrs(host);
|
|
for (auto& owner : interfaces) {
|
|
if (owner.linked) entries.push_back(std::move(owner.link));
|
|
for (auto& address : owner.addresses) entries.push_back(std::move(address));
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
extern "C" {
|
|
|
|
int APS5_VABI getifaddrs_nid_postfix(GuestInterfaceAddress** list) {
|
|
if (!list) { *__error_nid_postfix() = 14; return -1; }
|
|
try {
|
|
std::vector<Entry> entries;
|
|
if (HostEntries(entries) != 0) return -1;
|
|
if (entries.empty()) {
|
|
*list = nullptr;
|
|
return 0;
|
|
}
|
|
std::size_t size = entries.size() * sizeof(GuestInterfaceAddress);
|
|
for (const auto& entry : entries)
|
|
size += Aligned(entry.name.size() + 1) + Aligned(entry.address.size()) + Aligned(entry.netmask.size()) + Aligned(entry.destination.size()) + Aligned(entry.data.size());
|
|
auto* block = static_cast<std::uint8_t*>(ApplicationHeapAllocate_nid_no_patch(size));
|
|
if (!block) {
|
|
*__error_nid_postfix() = 12;
|
|
return -1;
|
|
}
|
|
auto* items = reinterpret_cast<GuestInterfaceAddress*>(block);
|
|
std::size_t offset = entries.size() * sizeof(GuestInterfaceAddress);
|
|
const auto place = [&](const void* source, std::size_t length) {
|
|
void* target = block + offset;
|
|
std::memcpy(target, source, length);
|
|
offset += Aligned(length);
|
|
return target;
|
|
};
|
|
for (std::size_t index = 0; index < entries.size(); ++index) {
|
|
const Entry& entry = entries[index];
|
|
GuestInterfaceAddress& item = items[index];
|
|
item.next = index + 1 < entries.size() ? &items[index + 1] : nullptr;
|
|
item.name = static_cast<char*>(place(entry.name.c_str(), entry.name.size() + 1));
|
|
item.flags = entry.flags;
|
|
item.address = place(entry.address.data(), entry.address.size());
|
|
item.netmask = entry.netmask.empty() ? nullptr : place(entry.netmask.data(), entry.netmask.size());
|
|
item.destination = entry.destination.empty() ? nullptr : place(entry.destination.data(), entry.destination.size());
|
|
item.data = entry.data.empty() ? nullptr : place(entry.data.data(), entry.data.size());
|
|
}
|
|
*list = items;
|
|
return 0;
|
|
} catch (const std::bad_alloc&) { *__error_nid_postfix() = 12; return -1; }
|
|
}
|
|
|
|
void APS5_VABI freeifaddrs_nid_postfix(GuestInterfaceAddress* list) {
|
|
ApplicationHeapFree_nid_no_patch(list);
|
|
}
|
|
|
|
}
|