diff --git a/cmake/scripts/darwin_embedded/ArchSetup.cmake b/cmake/scripts/darwin_embedded/ArchSetup.cmake index 495fa41c49252..fd1f750ed7783 100644 --- a/cmake/scripts/darwin_embedded/ArchSetup.cmake +++ b/cmake/scripts/darwin_embedded/ArchSetup.cmake @@ -12,7 +12,7 @@ else() list(APPEND ARCH_DEFINES -DTARGET_DARWIN_IOS) endif() set(SYSTEM_DEFINES -D_REENTRANT -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE - -D__STDC_CONSTANT_MACROS -DHAS_LINUX_NETWORK -DHAS_ZEROCONF) + -D__STDC_CONSTANT_MACROS -DHAS_IOS_NETWORK -DHAS_ZEROCONF) set(PLATFORM_DIR platform/darwin) set(PLATFORMDEFS_DIR platform/posix) set(CMAKE_SYSTEM_NAME Darwin) @@ -38,7 +38,7 @@ list(APPEND DEPLIBS "-framework CoreFoundation" "-framework CoreVideo" "-framework CFNetwork" "-framework CoreGraphics" "-framework Foundation" "-framework UIKit" "-framework CoreMedia" "-framework AVFoundation" - "-framework VideoToolbox") + "-framework VideoToolbox" "-lresolv") set(ENABLE_OPTICAL OFF CACHE BOOL "" FORCE) diff --git a/cmake/treedata/darwin_embedded/subdirs.txt b/cmake/treedata/darwin_embedded/subdirs.txt index c67c154bfa66f..8a60dc490c646 100644 --- a/cmake/treedata/darwin_embedded/subdirs.txt +++ b/cmake/treedata/darwin_embedded/subdirs.txt @@ -2,9 +2,9 @@ xbmc/input/touch input/touch xbmc/input/touch/generic input/touch/generic xbmc/platform/darwin platform/darwin xbmc/platform/darwin/ios-common platform/ios-common +xbmc/platform/darwin/ios-common/network platform/ios-common/network xbmc/platform/darwin/ios-common/storage platform/ios-common/storage xbmc/platform/darwin/network platform/darwin/network xbmc/platform/posix posix xbmc/platform/posix/filesystem platform/posix/filesystem -xbmc/platform/posix/network platform/posix/network xbmc/platform/posix/utils platform/posix/utils diff --git a/xbmc/network/Network.h b/xbmc/network/Network.h index 70bbab62860a0..0bdb157f35e38 100644 --- a/xbmc/network/Network.h +++ b/xbmc/network/Network.h @@ -120,6 +120,8 @@ class CNetworkBase #include "platform/win32/network/NetworkWin32.h" #elif defined(HAS_WIN10_NETWORK) #include "platform/win10/network/NetworkWin10.h" +#elif defined(HAS_IOS_NETWORK) +#include "platform/darwin/ios-common/network/NetworkIOS.h" #else using CNetwork = CNetworkBase; #endif diff --git a/xbmc/platform/darwin/ios-common/network/CMakeLists.txt b/xbmc/platform/darwin/ios-common/network/CMakeLists.txt new file mode 100644 index 0000000000000..58f56181218fc --- /dev/null +++ b/xbmc/platform/darwin/ios-common/network/CMakeLists.txt @@ -0,0 +1,6 @@ +set(SOURCES NetworkIOS.mm) + +set(HEADERS NetworkIOS.h + route.h) + +core_add_library(platform_ios_network) diff --git a/xbmc/platform/darwin/ios-common/network/NetworkIOS.h b/xbmc/platform/darwin/ios-common/network/NetworkIOS.h new file mode 100644 index 0000000000000..ce21c5c8b23fc --- /dev/null +++ b/xbmc/platform/darwin/ios-common/network/NetworkIOS.h @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#pragma once + +#include "network/Network.h" + +#include +#include + +class CNetworkIOS; + +class CNetworkInterfaceIOS : public CNetworkInterface +{ +public: + CNetworkInterfaceIOS(CNetworkIOS* network, std::string interfaceName); + ~CNetworkInterfaceIOS() override; + + bool IsEnabled() const override; + bool IsConnected() const override; + + std::string GetMacAddress() const override; + void GetMacAddressRaw(char rawMac[6]) const override; + + bool GetHostMacAddress(unsigned long host, std::string& mac) const override; + + std::string GetCurrentIPAddress() const override; + std::string GetCurrentNetmask() const override; + std::string GetCurrentDefaultGateway() const override; + + std::string GetInterfaceName() const; + +private: + std::string m_interfaceName; + CNetworkIOS* m_network; +}; + +class CNetworkIOS : public CNetworkBase +{ +public: + CNetworkIOS(); + ~CNetworkIOS() override; + + // Return the list of interfaces + std::vector& GetInterfaceList() override; + CNetworkInterface* GetFirstConnectedInterface() override; + + // Ping remote host + bool PingHost(unsigned long host, unsigned int timeout_ms = 2000) override; + + // Get/set the nameserver(s) + std::vector GetNameServers() override; + + friend class CNetworkInterfaceIOS; + +private: + int GetSocket() { return m_sock; } + void queryInterfaceList(); + std::vector m_interfaces; + int m_sock; +}; + +using CNetwork = CNetworkIOS; diff --git a/xbmc/platform/darwin/ios-common/network/NetworkIOS.mm b/xbmc/platform/darwin/ios-common/network/NetworkIOS.mm new file mode 100644 index 0000000000000..003c9916abcc0 --- /dev/null +++ b/xbmc/platform/darwin/ios-common/network/NetworkIOS.mm @@ -0,0 +1,413 @@ +/* + * Copyright (C) 2005-2018 Team Kodi + * This file is part of Kodi - https://kodi.tv + * + * SPDX-License-Identifier: GPL-2.0-or-later + * See LICENSES/README.md for more information. + */ + +#import "NetworkIOS.h" + +#import "utils/StringUtils.h" +#import "utils/log.h" + +#import "platform/darwin/ios-common/network/route.h" + +#import + +#import +#import +#import +#import +#import +#import +#import +#import +#import +#import +#import +#import + +CNetworkInterfaceIOS::CNetworkInterfaceIOS(CNetworkIOS* network, std::string interfaceName) + : m_interfaceName(interfaceName) + , m_network(network) +{ +} + +CNetworkInterfaceIOS::~CNetworkInterfaceIOS() = default; + +std::string CNetworkInterfaceIOS::GetInterfaceName() const +{ + return m_interfaceName; +} + +bool CNetworkInterfaceIOS::IsEnabled() const +{ + struct ifreq ifr; + strcpy(ifr.ifr_name, m_interfaceName.c_str()); + if (ioctl(m_network->GetSocket(), SIOCGIFFLAGS, &ifr) < 0) + return false; + + return ((ifr.ifr_flags & IFF_UP) == IFF_UP); +} + +bool CNetworkInterfaceIOS::IsConnected() const +{ + struct ifaddrs* interfaces = nullptr; + + if (getifaddrs(&interfaces) != 0) + return false; + + for (struct ifaddrs* iface = interfaces; iface != nullptr; iface = iface->ifa_next) + { + if (StringUtils::StartsWith(iface->ifa_name, m_interfaceName)) + { + if ((iface->ifa_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING) && + iface->ifa_dstaddr != nullptr) + { + if (interfaces != nullptr) + freeifaddrs(interfaces); + return true; + } + } + } + + if (interfaces != nullptr) + freeifaddrs(interfaces); + + return false; +} + +std::string CNetworkInterfaceIOS::GetMacAddress() const +{ + //! @todo Unable to retrieve MAC address of an interface/ARP table from ios11 onwards. + return ""; +} + +void CNetworkInterfaceIOS::GetMacAddressRaw(char rawMac[6]) const +{ + //! @todo Unable to retrieve MAC address of an interface/ARP table from ios11 onwards. + memset(&rawMac[0], 0, 6); +} + +std::string CNetworkInterfaceIOS::GetCurrentIPAddress() const +{ + std::string address; + struct ifaddrs* interfaces = nullptr; + + if (getifaddrs(&interfaces) != 0) + return ""; + + for (struct ifaddrs* iface = interfaces; iface != nullptr; iface = iface->ifa_next) + { + if (StringUtils::StartsWith(iface->ifa_name, m_interfaceName)) + { + if ((iface->ifa_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING) && + iface->ifa_dstaddr != nullptr) + { + switch (iface->ifa_addr->sa_family) + { + case AF_INET: + char str4[INET_ADDRSTRLEN]; + inet_ntop(AF_INET, &((reinterpret_cast(iface->ifa_addr))->sin_addr), + str4, INET_ADDRSTRLEN); + address = str4; + break; + case AF_INET6: + char str6[INET6_ADDRSTRLEN]; + inet_ntop(AF_INET6, + &((reinterpret_cast(iface->ifa_addr))->sin6_addr), str6, + INET6_ADDRSTRLEN); + address = str6; + break; + default: + break; + } + } + } + } + + if (interfaces != nullptr) + freeifaddrs(interfaces); + + return address; +} + +std::string CNetworkInterfaceIOS::GetCurrentNetmask() const +{ + std::string netmask; + struct ifaddrs* interfaces = nullptr; + + if (getifaddrs(&interfaces) != 0) + return ""; + + for (struct ifaddrs* iface = interfaces; iface != nullptr; iface = iface->ifa_next) + { + if (StringUtils::StartsWith(iface->ifa_name, m_interfaceName)) + { + if ((iface->ifa_flags & (IFF_UP | IFF_RUNNING)) == (IFF_UP | IFF_RUNNING) && + iface->ifa_dstaddr != nullptr) + { + switch (iface->ifa_addr->sa_family) + { + case AF_INET: + char mask4[INET_ADDRSTRLEN]; + inet_ntop(AF_INET, + &((reinterpret_cast(iface->ifa_netmask))->sin_addr), mask4, + INET_ADDRSTRLEN); + netmask = mask4; + break; + case AF_INET6: + char mask6[INET6_ADDRSTRLEN]; + inet_ntop(AF_INET6, + &((reinterpret_cast(iface->ifa_netmask))->sin6_addr), + mask6, INET6_ADDRSTRLEN); + netmask = mask6; + break; + default: + break; + } + } + } + } + + if (interfaces != nullptr) + freeifaddrs(interfaces); + + return netmask; +} + +std::string CNetworkInterfaceIOS::GetCurrentDefaultGateway() const +{ + std::string gateway; + int mib[] = {CTL_NET, PF_ROUTE, 0, 0, NET_RT_FLAGS, RTF_GATEWAY}; + int afinet_type[] = {AF_INET, AF_INET6}; + + for (int ip_type = 0; ip_type <= 1; ip_type++) + { + mib[3] = afinet_type[ip_type]; + + size_t needed = 0; + if (sysctl(mib, sizeof(mib) / sizeof(int), nullptr, &needed, nullptr, 0) < 0) + return ""; + + char* buf; + if ((buf = new char[needed]) == 0) + return ""; + + if (sysctl(mib, sizeof(mib) / sizeof(int), buf, &needed, nullptr, 0) < 0) + { + CLog::Log(LOGERROR, "sysctl: net.route.0.0.dump"); + delete[] buf; + return gateway; + } + + struct rt_msghdr* rt; + for (char* p = buf; p < buf + needed; p += rt->rtm_msglen) + { + rt = reinterpret_cast(p); + struct sockaddr* sa = reinterpret_cast(rt + 1); + struct sockaddr* sa_tab[RTAX_MAX]; + for (int i = 0; i < RTAX_MAX; i++) + { + if (rt->rtm_addrs & (1 << i)) + { + sa_tab[i] = sa; + sa = reinterpret_cast( + reinterpret_cast(sa) + + ((sa->sa_len) > 0 ? (1 + (((sa->sa_len) - 1) | (sizeof(long) - 1))) : sizeof(long))); + } + else + { + sa_tab[i] = nullptr; + } + } + + if (((rt->rtm_addrs & (RTA_DST | RTA_GATEWAY)) == (RTA_DST | RTA_GATEWAY)) && + sa_tab[RTAX_DST]->sa_family == afinet_type[ip_type] && + sa_tab[RTAX_GATEWAY]->sa_family == afinet_type[ip_type]) + { + if (afinet_type[ip_type] == AF_INET) + { + if ((reinterpret_cast(sa_tab[RTAX_DST]))->sin_addr.s_addr == 0) + { + char dstStr4[INET_ADDRSTRLEN]; + char srcStr4[INET_ADDRSTRLEN]; + memcpy(srcStr4, + &(reinterpret_cast(sa_tab[RTAX_GATEWAY]))->sin_addr, + sizeof(struct in_addr)); + if (inet_ntop(AF_INET, srcStr4, dstStr4, INET_ADDRSTRLEN) != nullptr) + gateway = dstStr4; + break; + } + } + else if (afinet_type[ip_type] == AF_INET6) + { + if ((reinterpret_cast(sa_tab[RTAX_DST]))->sin_addr.s_addr == 0) + { + char dstStr6[INET6_ADDRSTRLEN]; + char srcStr6[INET6_ADDRSTRLEN]; + memcpy(srcStr6, + &(reinterpret_cast(sa_tab[RTAX_GATEWAY]))->sin6_addr, + sizeof(struct in6_addr)); + if (inet_ntop(AF_INET6, srcStr6, dstStr6, INET6_ADDRSTRLEN) != nullptr) + gateway = dstStr6; + break; + } + } + } + } + free(buf); + } + + return gateway; +} + + +CNetworkIOS::CNetworkIOS() + : CNetworkBase() +{ + m_sock = socket(AF_INET, SOCK_DGRAM, 0); + queryInterfaceList(); +} + +CNetworkIOS::~CNetworkIOS() +{ + if (m_sock != -1) + close(CNetworkIOS::m_sock); + + for (std::vector::iterator it = m_interfaces.begin(); + it != m_interfaces.end();) + { + CNetworkInterfaceIOS* nInt = *it; + delete nInt; + it = m_interfaces.erase(it); + } +} + +std::vector& CNetworkIOS::GetInterfaceList() +{ + return reinterpret_cast&>(m_interfaces); +} + +CNetworkInterface* CNetworkIOS::GetFirstConnectedInterface() +{ + // Renew m_interfaces to be able to handle hard interface changes (adapters removed/added) + // This allows interfaces to be discovered if none are available at start eg. (Airplane mode on) + queryInterfaceList(); + std::vector& ifaces = m_interfaces; + + CNetworkInterface* ifVPN = nullptr; + CNetworkInterface* ifWired = nullptr; + CNetworkInterface* ifWifi = nullptr; + CNetworkInterface* ifCell = nullptr; + +#if defined(TARGET_DARWIN_IOS) + std::string ifWifiName = "en0"; + // Unsure interface number for lightning to ethernet adapter, need to confirm + std::string ifWiredName = "en1"; +#else // defined(TARGET_DARWIN_TVOS) + std::string ifWifiName = "en1"; + std::string ifWiredName = "en0"; +#endif + + for (auto iteriface : ifaces) + { + if (iteriface && iteriface->IsConnected()) + { + // VPN interface + if (StringUtils::StartsWith(iteriface->GetInterfaceName(), "utun")) + ifVPN = static_cast(iteriface); + // Wired interface + else if (StringUtils::StartsWith(iteriface->GetInterfaceName(), ifWiredName)) + ifWired = static_cast(iteriface); + // Wifi interface + else if (StringUtils::StartsWith(iteriface->GetInterfaceName(), ifWifiName)) + ifWifi = static_cast(iteriface); + // Cellular interface + else if (StringUtils::StartsWith(iteriface->GetInterfaceName(), "pdp_ip")) + ifCell = static_cast(iteriface); + } + } + + // Priority = VPN -> Wired -> Wifi -> Cell + if (ifVPN != nullptr) + return ifVPN; + else if (ifWired != nullptr) + return ifWired; + else if (ifWifi != nullptr) + return ifWifi; + else if (ifCell != nullptr) + return ifCell; + else + return nullptr; +} + +void CNetworkIOS::queryInterfaceList() +{ + m_interfaces.clear(); + + struct ifaddrs* list; + if (getifaddrs(&list) < 0) + return; + + for (struct ifaddrs* cur = list; cur != nullptr; cur = cur->ifa_next) + { + if (cur->ifa_addr->sa_family != AF_INET || (cur->ifa_flags & IFF_LOOPBACK) == IFF_LOOPBACK) + continue; + + m_interfaces.push_back(new CNetworkInterfaceIOS(this, cur->ifa_name)); + } + + freeifaddrs(list); +} + +std::vector CNetworkIOS::GetNameServers() +{ + std::vector nameServers; + res_state res = static_cast(malloc(sizeof(struct __res_state))); + int result = res_ninit(res); + + if (result != 0) + { + CLog::Log(LOGERROR, "GetNameServers - no nameservers could be fetched (error %d)", result); + free(res); + return nameServers; + } + + union res_sockaddr_union servers[NI_MAXSERV]; + int serversFound = res_9_getservers(res, servers, NI_MAXSERV); + + for (int i = 0; i < serversFound; i++) + { + union res_sockaddr_union s = servers[i]; + if (s.sin.sin_len > 0) + { + char hostBuffer[NI_MAXHOST]; + if (getnameinfo(reinterpret_cast(&s.sin), + static_cast(s.sin.sin_len), static_cast(hostBuffer), + sizeof(hostBuffer), nullptr, 0, NI_NUMERICHOST) == 0) + { + nameServers.push_back(hostBuffer); + } + } + } + + res_ndestroy(res); + return nameServers; +} + +bool CNetworkIOS::PingHost(unsigned long remote_ip, unsigned int timeout_ms) +{ + /*! @todo ARP table is not accessible from iOS11 on. Was initially deprecated in iOS7 + * WOL/WakeOnAccess can not work without MAC addresses, so was no need to implement + * this at this stage. + */ + return false; +} + +bool CNetworkInterfaceIOS::GetHostMacAddress(unsigned long host_ip, std::string& mac) const +{ + //! @todo Unable to retrieve MAC address of an interface/ARP table from ios11 onwards. + return false; +} diff --git a/xbmc/platform/darwin/ios-common/network/route.h b/xbmc/platform/darwin/ios-common/network/route.h new file mode 100644 index 0000000000000..87a1222a2dcff --- /dev/null +++ b/xbmc/platform/darwin/ios-common/network/route.h @@ -0,0 +1,251 @@ +/* + * Copyright (c) 2000-2016 Apple Inc. All rights reserved. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ + * + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. + * + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, + * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. + * + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ + */ +/* + * Copyright (c) 1980, 1986, 1993 + * The Regents of the University of California. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. 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. + * 3. All advertising materials mentioning features or use of this software + * must display the following acknowledgement: + * This product includes software developed by the University of + * California, Berkeley and its contributors. + * 4. Neither the name of the University 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 REGENTS 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 REGENTS 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. + * + * @(#)route.h 8.3 (Berkeley) 4/19/94 + * $FreeBSD: src/sys/net/route.h,v 1.36.2.1 2000/08/16 06:14:23 jayanth Exp $ + */ + +#ifndef _NET_ROUTE_H_ +#define _NET_ROUTE_H_ +#include +#include +#include +#include + +/* + * These numbers are used by reliable protocols for determining + * retransmission behavior and are included in the routing structure. + */ +struct rt_metrics +{ + u_int32_t rmx_locks; /* Kernel leaves these values alone */ + u_int32_t rmx_mtu; /* MTU for this path */ + u_int32_t rmx_hopcount; /* max hops expected */ + int32_t rmx_expire; /* lifetime for route, e.g. redirect */ + u_int32_t rmx_recvpipe; /* inbound delay-bandwidth product */ + u_int32_t rmx_sendpipe; /* outbound delay-bandwidth product */ + u_int32_t rmx_ssthresh; /* outbound gateway buffer limit */ + u_int32_t rmx_rtt; /* estimated round trip time */ + u_int32_t rmx_rttvar; /* estimated rtt variance */ + u_int32_t rmx_pksent; /* packets sent using this route */ + u_int32_t rmx_filler[4]; /* will be used for T/TCP later */ +}; + +/* + * rmx_rtt and rmx_rttvar are stored as microseconds; + */ +#define RTM_RTTUNIT 1000000 /* units for rtt, rttvar, as units per sec */ + +#define RTF_UP 0x1 /* route usable */ +#define RTF_GATEWAY 0x2 /* destination is a gateway */ +#define RTF_HOST 0x4 /* host entry (net otherwise) */ +#define RTF_REJECT 0x8 /* host or net unreachable */ +#define RTF_DYNAMIC 0x10 /* created dynamically (by redirect) */ +#define RTF_MODIFIED 0x20 /* modified dynamically (by redirect) */ +#define RTF_DONE 0x40 /* message confirmed */ +#define RTF_DELCLONE 0x80 /* delete cloned route */ +#define RTF_CLONING 0x100 /* generate new routes on use */ +#define RTF_XRESOLVE 0x200 /* external daemon resolves name */ +#define RTF_LLINFO 0x400 /* generated by link layer (e.g. ARP) */ +#define RTF_STATIC 0x800 /* manually added */ +#define RTF_BLACKHOLE 0x1000 /* just discard pkts (during updates) */ +#define RTF_NOIFREF 0x2000 /* not eligible for RTF_IFREF */ +#define RTF_PROTO2 0x4000 /* protocol specific routing flag */ +#define RTF_PROTO1 0x8000 /* protocol specific routing flag */ + +#define RTF_PRCLONING 0x10000 /* protocol requires cloning */ +#define RTF_WASCLONED 0x20000 /* route generated through cloning */ +#define RTF_PROTO3 0x40000 /* protocol specific routing flag */ + /* 0x80000 unused */ +#define RTF_PINNED 0x100000 /* future use */ +#define RTF_LOCAL 0x200000 /* route represents a local address */ +#define RTF_BROADCAST 0x400000 /* route represents a bcast address */ +#define RTF_MULTICAST 0x800000 /* route represents a mcast address */ +#define RTF_IFSCOPE 0x1000000 /* has valid interface scope */ +#define RTF_CONDEMNED 0x2000000 /* defunct; no longer modifiable */ +#define RTF_IFREF 0x4000000 /* route holds a ref to interface */ +#define RTF_PROXY 0x8000000 /* proxying, no interface scope */ +#define RTF_ROUTER 0x10000000 /* host is a router */ + /* 0x20000000 and up unassigned */ + +#define RTF_BITS \ + "\020\1UP\2GATEWAY\3HOST\4REJECT\5DYNAMIC\6MODIFIED\7DONE" \ + "\10DELCLONE\11CLONING\12XRESOLVE\13LLINFO\14STATIC\15BLACKHOLE" \ + "\16NOIFREF\17PROTO2\20PROTO1\21PRCLONING\22WASCLONED\23PROTO3" \ + "\25PINNED\26LOCAL\27BROADCAST\30MULTICAST\31IFSCOPE\32CONDEMNED" \ + "\33IFREF\34PROXY\35ROUTER" + +/* + * Routing statistics. + */ +struct rtstat +{ + short rts_badredirect; /* bogus redirect calls */ + short rts_dynamic; /* routes created by redirects */ + short rts_newgateway; /* routes modified by redirects */ + short rts_unreach; /* lookups which failed */ + short rts_wildcard; /* lookups satisfied by a wildcard */ +}; + +/* + * Structures for routing messages. + */ +struct rt_msghdr +{ + u_short rtm_msglen; /* to skip over non-understood messages */ + u_char rtm_version; /* future binary compatibility */ + u_char rtm_type; /* message type */ + u_short rtm_index; /* index for associated ifp */ + int rtm_flags; /* flags, incl. kern & message, e.g. DONE */ + int rtm_addrs; /* bitmask identifying sockaddrs in msg */ + pid_t rtm_pid; /* identify sender */ + int rtm_seq; /* for sender to identify action */ + int rtm_errno; /* why failed */ + int rtm_use; /* from rtentry */ + u_int32_t rtm_inits; /* which metrics we are initializing */ + struct rt_metrics rtm_rmx; /* metrics themselves */ +}; + +struct rt_msghdr2 +{ + u_short rtm_msglen; /* to skip over non-understood messages */ + u_char rtm_version; /* future binary compatibility */ + u_char rtm_type; /* message type */ + u_short rtm_index; /* index for associated ifp */ + int rtm_flags; /* flags, incl. kern & message, e.g. DONE */ + int rtm_addrs; /* bitmask identifying sockaddrs in msg */ + int32_t rtm_refcnt; /* reference count */ + int rtm_parentflags; /* flags of the parent route */ + int rtm_reserved; /* reserved field set to 0 */ + int rtm_use; /* from rtentry */ + u_int32_t rtm_inits; /* which metrics we are initializing */ + struct rt_metrics rtm_rmx; /* metrics themselves */ +}; + +#define RTM_VERSION 5 /* Up the ante and ignore older versions */ + +/* + * Message types. + */ +#define RTM_ADD 0x1 /* Add Route */ +#define RTM_DELETE 0x2 /* Delete Route */ +#define RTM_CHANGE 0x3 /* Change Metrics or flags */ +#define RTM_GET 0x4 /* Report Metrics */ +#define RTM_LOSING \ + 0x5 /* RTM_LOSING is no longer generated by xnu + and is deprecated */ +#define RTM_REDIRECT 0x6 /* Told to use different route */ +#define RTM_MISS 0x7 /* Lookup failed on this address */ +#define RTM_LOCK 0x8 /* fix specified metrics */ +#define RTM_OLDADD 0x9 /* caused by SIOCADDRT */ +#define RTM_OLDDEL 0xa /* caused by SIOCDELRT */ +#define RTM_RESOLVE 0xb /* req to resolve dst to LL addr */ +#define RTM_NEWADDR 0xc /* address being added to iface */ +#define RTM_DELADDR 0xd /* address being removed from iface */ +#define RTM_IFINFO 0xe /* iface going up/down etc. */ +#define RTM_NEWMADDR 0xf /* mcast group membership being added to if */ +#define RTM_DELMADDR 0x10 /* mcast group membership being deleted */ +#define RTM_IFINFO2 0x12 /* */ +#define RTM_NEWMADDR2 0x13 /* */ +#define RTM_GET2 0x14 /* */ + +/* + * Bitmask values for rtm_inits and rmx_locks. + */ +#define RTV_MTU 0x1 /* init or lock _mtu */ +#define RTV_HOPCOUNT 0x2 /* init or lock _hopcount */ +#define RTV_EXPIRE 0x4 /* init or lock _expire */ +#define RTV_RPIPE 0x8 /* init or lock _recvpipe */ +#define RTV_SPIPE 0x10 /* init or lock _sendpipe */ +#define RTV_SSTHRESH 0x20 /* init or lock _ssthresh */ +#define RTV_RTT 0x40 /* init or lock _rtt */ +#define RTV_RTTVAR 0x80 /* init or lock _rttvar */ + +/* + * Bitmask values for rtm_addrs. + */ +#define RTA_DST 0x1 /* destination sockaddr present */ +#define RTA_GATEWAY 0x2 /* gateway sockaddr present */ +#define RTA_NETMASK 0x4 /* netmask sockaddr present */ +#define RTA_GENMASK 0x8 /* cloning mask sockaddr present */ +#define RTA_IFP 0x10 /* interface name sockaddr present */ +#define RTA_IFA 0x20 /* interface addr sockaddr present */ +#define RTA_AUTHOR 0x40 /* sockaddr for author of redirect */ +#define RTA_BRD 0x80 /* for NEWADDR, broadcast or p-p dest addr */ + +/* + * Index offsets for sockaddr array for alternate internal encoding. + */ +#define RTAX_DST 0 /* destination sockaddr present */ +#define RTAX_GATEWAY 1 /* gateway sockaddr present */ +#define RTAX_NETMASK 2 /* netmask sockaddr present */ +#define RTAX_GENMASK 3 /* cloning mask sockaddr present */ +#define RTAX_IFP 4 /* interface name sockaddr present */ +#define RTAX_IFA 5 /* interface addr sockaddr present */ +#define RTAX_AUTHOR 6 /* sockaddr for author of redirect */ +#define RTAX_BRD 7 /* for NEWADDR, broadcast or p-p dest addr */ +#define RTAX_MAX 8 /* size of array to allocate */ + +struct rt_addrinfo +{ + int rti_addrs; + struct sockaddr* rti_info[RTAX_MAX]; +}; + +#endif /* _NET_ROUTE_H_ */ diff --git a/xbmc/platform/darwin/network/CMakeLists.txt b/xbmc/platform/darwin/network/CMakeLists.txt index 53c9e418bd794..e50b6b0c35889 100644 --- a/xbmc/platform/darwin/network/CMakeLists.txt +++ b/xbmc/platform/darwin/network/CMakeLists.txt @@ -1,8 +1,7 @@ set(SOURCES ZeroconfBrowserDarwin.cpp ZeroconfDarwin.cpp) -set(HEADERS ioshacks.h - ZeroconfBrowserDarwin.h +set(HEADERS ZeroconfBrowserDarwin.h ZeroconfDarwin.h) core_add_library(platform_darwin_network) diff --git a/xbmc/platform/darwin/network/ioshacks.h b/xbmc/platform/darwin/network/ioshacks.h deleted file mode 100644 index 294c7830faf65..0000000000000 --- a/xbmc/platform/darwin/network/ioshacks.h +++ /dev/null @@ -1,58 +0,0 @@ -/* - * Copyright (C) 2013-2018 Team Kodi - * This file is part of Kodi - https://kodi.tv - * - * SPDX-License-Identifier: GPL-2.0-or-later - * See LICENSES/README.md for more information. - */ - -// needed for CNetworkInterfaceLinux::GetHostMacAddress and taken from osx sdk -// net/if_types.h net/route.h netinet/if_ether.h - -/* - * These numbers are used by reliable protocols for determining - * retransmission behavior and are included in the routing structure. - */ -struct rt_metrics { - u_int32_t rmx_locks; /* Kernel must leave these values alone */ - u_int32_t rmx_mtu; /* MTU for this path */ - u_int32_t rmx_hopcount; /* max hops expected */ - int32_t rmx_expire; /* lifetime for route, e.g. redirect */ - u_int32_t rmx_recvpipe; /* inbound delay-bandwidth product */ - u_int32_t rmx_sendpipe; /* outbound delay-bandwidth product */ - u_int32_t rmx_ssthresh; /* outbound gateway buffer limit */ - u_int32_t rmx_rtt; /* estimated round trip time */ - u_int32_t rmx_rttvar; /* estimated rtt variance */ - u_int32_t rmx_pksent; /* packets sent using this route */ - u_int32_t rmx_filler[4]; /* will be used for T/TCP later */ -}; - -/* - * Structures for routing messages. - */ -struct rt_msghdr { - u_short rtm_msglen; /* to skip over non-understood messages */ - u_char rtm_version; /* future binary compatibility */ - u_char rtm_type; /* message type */ - u_short rtm_index; /* index for associated ifp */ - int rtm_flags; /* flags, incl. kern & message, e.g. DONE */ - int rtm_addrs; /* bitmask identifying sockaddrs in msg */ - pid_t rtm_pid; /* identify sender */ - int rtm_seq; /* for sender to identify action */ - int rtm_errno; /* why failed */ - int rtm_use; /* from rtentry */ - u_int32_t rtm_inits; /* which metrics we are initializing */ - struct rt_metrics rtm_rmx; /* metrics themselves */ -}; -struct sockaddr_inarp { - u_char sin_len; - u_char sin_family; - u_short sin_port; - struct in_addr sin_addr; - struct in_addr sin_srcaddr; - u_short sin_tos; - u_short sin_other; -#define SIN_PROXY 1 -}; -#define RTF_LLINFO 0x400 /* generated by link layer (e.g. ARP) */ -// --- END diff --git a/xbmc/platform/posix/network/NetworkLinux.cpp b/xbmc/platform/posix/network/NetworkLinux.cpp index d479198007a0f..5c5cee53bbad0 100644 --- a/xbmc/platform/posix/network/NetworkLinux.cpp +++ b/xbmc/platform/posix/network/NetworkLinux.cpp @@ -29,13 +29,9 @@ #include #include #include -#if defined(TARGET_DARWIN_OSX) #include #include #include -#else //IOS - #include "platform/darwin/network/ioshacks.h" -#endif #include #elif defined(TARGET_FREEBSD) #include @@ -484,9 +480,7 @@ bool CNetworkLinux::PingHost(unsigned long remote_ip, unsigned int timeout_ms) #endif int status = -1; -#if !defined (TARGET_DARWIN_EMBEDDED) // no system calls allowed since ios11 status = system (cmd_line); -#endif int result = WIFEXITED(status) ? WEXITSTATUS(status) : -1; // http://linux.about.com/od/commands/l/blcmdl8_ping.htm ;