blob: 923e4c02afb5c2dfcd47b0fa10369df2ee505391 [file] [log] [blame]
// Copyright 2017 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "starboard/socket.h"
#if SB_API_VERSION >= 4
#include <arpa/inet.h>
#include <ifaddrs.h>
#include <linux/if.h>
#include <linux/if_addr.h>
#include <netdb.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include "starboard/byte_swap.h"
#include "starboard/log.h"
#include "starboard/memory.h"
#include "starboard/shared/posix/socket_internal.h"
namespace sbposix = starboard::shared::posix;
namespace {
// TODO: Move this constant to socket.h.
const int kIPv6AddressSize = 16;
bool IsAnyAddress(const SbSocketAddress& address) {
switch (address.type) {
case kSbSocketAddressTypeIpv4:
return (address.address[0] == 0 && address.address[1] == 0 &&
address.address[2] == 0 && address.address[3] == 0);
#if SB_HAS(IPV6)
case kSbSocketAddressTypeIpv6: {
bool found_nonzero = false;
for (std::size_t i = 0; i != kIPv6AddressSize; ++i) {
found_nonzero |= (address.address[i] != 0);
}
return !found_nonzero;
}
#endif
default:
SB_NOTREACHED() << "Invalid address type " << address.type;
break;
}
return false;
}
template <typename T, int source_size>
void CopyIntoObjectFromArray(T* out_destination,
const unsigned char(&source)[source_size]) {
SB_COMPILE_ASSERT(sizeof(T) <= source_size, destination_is_too_small);
SbMemoryCopy(out_destination, source, sizeof(T));
}
bool GetPotentialMatch(const sockaddr* input_addr,
const in_addr** out_interface_addr) {
if (!input_addr || input_addr->sa_family != AF_INET) {
*out_interface_addr = NULL;
return false;
}
const sockaddr_in* v4input_addr =
reinterpret_cast<const sockaddr_in*>(input_addr);
*out_interface_addr = &(v4input_addr->sin_addr);
return true;
}
bool GetPotentialMatch(const sockaddr* input_addr,
const in6_addr** out_interface_addr) {
if (!input_addr || input_addr->sa_family != AF_INET6) {
*out_interface_addr = NULL;
return false;
}
const sockaddr_in6* v6input_addr =
reinterpret_cast<const sockaddr_in6*>(input_addr);
*out_interface_addr = &(v6input_addr->sin6_addr);
return true;
}
template <typename in_addr_type>
bool GetNetmaskForInterfaceAddress(const SbSocketAddress& interface_address,
SbSocketAddress* out_netmask) {
SB_DCHECK(interface_address.type == kSbSocketAddressTypeIpv4);
struct ifaddrs* interface_addrs = NULL;
int retval = getifaddrs(&interface_addrs);
if (retval != 0) {
return false;
}
in_addr_type to_match;
CopyIntoObjectFromArray(&to_match, interface_address.address);
bool found_netmask = false;
for (struct ifaddrs* interface = interface_addrs; interface != NULL;
interface = interface->ifa_next) {
if (!(IFF_UP & interface->ifa_flags) ||
(IFF_LOOPBACK & interface->ifa_flags)) {
continue;
}
const in_addr_type* potential_match;
if (!GetPotentialMatch(interface->ifa_addr, &potential_match))
continue;
if (SbMemoryCompare(&to_match, potential_match, sizeof(in_addr_type)) !=
0) {
continue;
}
sbposix::SockAddr sock_addr;
sock_addr.FromSockaddr(interface->ifa_addr);
if (sock_addr.ToSbSocketAddress(out_netmask)) {
found_netmask = true;
break;
}
}
freeifaddrs(interface_addrs);
return found_netmask;
}
bool GetNetMaskForIPv4InterfaceAddress(const SbSocketAddress& interface_address,
SbSocketAddress* out_netmask) {
return GetNetmaskForInterfaceAddress<in_addr>(interface_address, out_netmask);
}
#if SB_HAS(IPV6)
bool GetNetMaskForIPv6InterfaceAddress(const SbSocketAddress& interface_address,
SbSocketAddress* out_netmask) {
return GetNetmaskForInterfaceAddress<in6_addr>(interface_address,
out_netmask);
}
#endif
bool GetNetMaskForInterfaceAddress(const SbSocketAddress& interface_address,
SbSocketAddress* out_netmask) {
SB_DCHECK(out_netmask);
switch (interface_address.type) {
case kSbSocketAddressTypeIpv4:
return GetNetMaskForIPv4InterfaceAddress(interface_address, out_netmask);
#if SB_HAS(IPV6)
case kSbSocketAddressTypeIpv6:
return GetNetMaskForIPv6InterfaceAddress(interface_address, out_netmask);
#endif
default:
SB_NOTREACHED() << "Invalid address type " << interface_address.type;
break;
}
return false;
}
bool FindIPv4InterfaceIP(SbSocketAddress* out_interface_ip,
SbSocketAddress* out_netmask) {
if (out_interface_ip == NULL) {
SB_NOTREACHED() << "out_interface_ip must be specified";
return false;
}
struct ifaddrs* interface_addrs = NULL;
int retval = getifaddrs(&interface_addrs);
if (retval != 0) {
return false;
}
bool success = false;
for (struct ifaddrs* interface = interface_addrs; interface != NULL;
interface = interface->ifa_next) {
if (!(IFF_UP & interface->ifa_flags) ||
(IFF_LOOPBACK & interface->ifa_flags)) {
continue;
}
const struct sockaddr* addr = interface->ifa_addr;
const struct sockaddr* netmask = interface->ifa_netmask;
if (!addr || !netmask || (addr->sa_family != AF_INET)) {
// IPv4 addresses only.
continue;
}
sbposix::SockAddr sock_addr;
sock_addr.FromSockaddr(addr);
if (sock_addr.ToSbSocketAddress(out_interface_ip)) {
if (out_netmask) {
sbposix::SockAddr netmask_addr;
netmask_addr.FromSockaddr(netmask);
if (!netmask_addr.ToSbSocketAddress(out_netmask)) {
continue;
}
}
success = true;
break;
}
}
freeifaddrs(interface_addrs);
return success;
}
#if SB_HAS(IPV6)
bool IsUniqueLocalAddress(const unsigned char ip[16]) {
// Unique Local Addresses are in fd08::/8.
return ip[0] == 0xfd && ip[1] == 0x08;
}
bool FindIPv6InterfaceIP(SbSocketAddress* out_interface_ip,
SbSocketAddress* out_netmask) {
if (!out_interface_ip) {
SB_NOTREACHED() << "out_interface_ip must be specified";
return false;
}
struct ifaddrs* interface_addrs = NULL;
int retval = getifaddrs(&interface_addrs);
if (retval != 0) {
return false;
}
int max_scope_interface_value = -1;
bool ip_found = false;
SbSocketAddress temp_interface_ip;
SbSocketAddress temp_netmask;
for (struct ifaddrs* interface = interface_addrs; interface != NULL;
interface = interface->ifa_next) {
if (!(IFF_UP & interface->ifa_flags) ||
(IFF_LOOPBACK & interface->ifa_flags)) {
continue;
}
const struct sockaddr* addr = interface->ifa_addr;
const struct sockaddr* netmask = interface->ifa_netmask;
if (!addr || !netmask || addr->sa_family != AF_INET6) {
// IPv6 addresses only.
continue;
}
const in6_addr* potential_match;
if (!GetPotentialMatch(interface->ifa_addr, &potential_match))
continue;
// Check the IP for loopback again, just in case flags were incorrect.
if (IN6_IS_ADDR_LOOPBACK(potential_match) ||
IN6_IS_ADDR_LINKLOCAL(potential_match)) {
continue;
}
const sockaddr_in6* v6addr =
reinterpret_cast<const sockaddr_in6*>(interface->ifa_addr);
if (!v6addr) {
continue;
}
int current_interface_scope = v6addr->sin6_scope_id;
if (IsUniqueLocalAddress(v6addr->sin6_addr.s6_addr)) {
// ULAs have global scope, but not globally routable. So prefer
// non ULA addresses with global scope by adjusting their "scope"
current_interface_scope -= 1;
}
if (current_interface_scope <= max_scope_interface_value) {
continue;
}
max_scope_interface_value = current_interface_scope;
sbposix::SockAddr sock_addr;
sock_addr.FromSockaddr(addr);
if (sock_addr.ToSbSocketAddress(&temp_interface_ip)) {
if (netmask) {
sbposix::SockAddr netmask_addr;
netmask_addr.FromSockaddr(netmask);
if (!netmask_addr.ToSbSocketAddress(&temp_netmask)) {
continue;
}
}
ip_found = true;
}
}
freeifaddrs(interface_addrs);
if (!ip_found) {
return false;
}
SbMemoryCopy(out_interface_ip, &temp_interface_ip, sizeof(SbSocketAddress));
if (out_netmask != NULL) {
SbMemoryCopy(out_netmask, &temp_netmask, sizeof(SbSocketAddress));
}
return true;
}
#endif
bool FindInterfaceIP(const SbSocketAddressType type,
SbSocketAddress* out_interface_ip,
SbSocketAddress* out_netmask) {
switch (type) {
case kSbSocketAddressTypeIpv4:
return FindIPv4InterfaceIP(out_interface_ip, out_netmask);
#if SB_HAS(IPV6)
case kSbSocketAddressTypeIpv6:
return FindIPv6InterfaceIP(out_interface_ip, out_netmask);
#endif
default:
SB_NOTREACHED() << "Invalid socket address type " << type;
}
return false;
}
bool FindSourceAddressForDestination(const SbSocketAddress& destination,
SbSocketAddress* out_source_address) {
SbSocket socket = SbSocketCreate(destination.type, kSbSocketProtocolUdp);
if (!SbSocketIsValid(socket)) {
return false;
}
SbSocketError connect_retval = SbSocketConnect(socket, &destination);
if (connect_retval != kSbSocketOk) {
bool socket_destroyed = SbSocketDestroy(socket);
SB_DCHECK(socket_destroyed);
return false;
}
bool success = SbSocketGetLocalAddress(socket, out_source_address);
bool socket_destroyed = SbSocketDestroy(socket);
SB_DCHECK(socket_destroyed);
return success;
}
} // namespace
bool SbSocketGetInterfaceAddress(const SbSocketAddress* const destination,
SbSocketAddress* out_source_address,
SbSocketAddress* out_netmask) {
if (!out_source_address) {
return false;
}
if (destination == NULL) {
#if SB_HAS(IPV6)
// Return either a v4 or a v6 address. Per spec.
return (FindIPv4InterfaceIP(out_source_address, out_netmask) ||
FindIPv6InterfaceIP(out_source_address, out_netmask));
#else
return FindIPv4InterfaceIP(out_source_address, out_netmask);
#endif
} else if (IsAnyAddress(*destination)) {
return FindInterfaceIP(destination->type, out_source_address, out_netmask);
} else {
return (FindSourceAddressForDestination(*destination, out_source_address) &&
GetNetMaskForInterfaceAddress(*out_source_address, out_netmask));
}
return false;
}
#endif // SB_API_VERSION >= 4