/* * Copyright (C) 2015 The Android Open Source Project * 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. * * 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. */ #include #include #include #include #include #include #include #include #include #include #include "private/ErrnoRestorer.h" #include "bionic_netlink.h" // The public ifaddrs struct is full of pointers. Rather than track several // different allocations, we use a maximally-sized structure with the public // part at offset 0, and pointers into its hidden tail. struct ifaddrs_storage { // Must come first, so that `ifaddrs_storage` is-a `ifaddrs`. ifaddrs ifa; // The interface index, so we can match RTM_NEWADDR messages with // earlier RTM_NEWLINK messages (to copy the interface flags). int interface_index; // Storage for the pointers in `ifa`. sockaddr_storage addr; sockaddr_storage netmask; sockaddr_storage ifa_ifu; char name[IFNAMSIZ + 1]; ifaddrs_storage(ifaddrs** list) { memset(this, 0, sizeof(*this)); // push_front onto `list`. ifa.ifa_next = *list; *list = reinterpret_cast(this); } void SetAddress(int family, const void* data, size_t byteCount) { // The kernel currently uses the order IFA_ADDRESS, IFA_LOCAL, IFA_BROADCAST // in inet_fill_ifaddr, but let's not assume that will always be true... if (ifa.ifa_addr == nullptr) { // This is an IFA_ADDRESS and haven't seen an IFA_LOCAL yet, so assume this is the // local address. SetLocalAddress will fix things if we later see an IFA_LOCAL. ifa.ifa_addr = CopyAddress(family, data, byteCount, &addr); } else { // We already saw an IFA_LOCAL, which implies this is a destination address. ifa.ifa_dstaddr = CopyAddress(family, data, byteCount, &ifa_ifu); } } void SetBroadcastAddress(int family, const void* data, size_t byteCount) { // ifa_broadaddr and ifa_dstaddr overlap in a union. Unfortunately, it's possible // to have an interface with both. Keeping the last thing the kernel gives us seems // to be glibc 2.19's behavior too, so our choice is being source compatible with // badly-written code that assumes ifa_broadaddr and ifa_dstaddr are interchangeable // or supporting interfaces with both addresses configured. My assumption is that // bad code is more common than weird network interfaces... ifa.ifa_broadaddr = CopyAddress(family, data, byteCount, &ifa_ifu); } void SetLocalAddress(int family, const void* data, size_t byteCount) { // The kernel source says "for point-to-point IFA_ADDRESS is DESTINATION address, // local address is supplied in IFA_LOCAL attribute". // -- http://lxr.free-electrons.com/source/include/uapi/linux/if_addr.h#L17 // So copy any existing IFA_ADDRESS into ifa_dstaddr... if (ifa.ifa_addr != nullptr) { ifa.ifa_dstaddr = reinterpret_cast(memcpy(&ifa_ifu, &addr, sizeof(addr))); } // ...and then put this IFA_LOCAL into ifa_addr. ifa.ifa_addr = CopyAddress(family, data, byteCount, &addr); } // Netlink gives us the prefix length as a bit count. We need to turn // that into a BSD-compatible netmask represented by a sockaddr*. void SetNetmask(int family, size_t prefix_length) { // ...and work out the netmask from the prefix length. netmask.ss_family = family; uint8_t* dst = SockaddrBytes(family, &netmask); memset(dst, 0xff, prefix_length / 8); if ((prefix_length % 8) != 0) { dst[prefix_length/8] = (0xff << (8 - (prefix_length % 8))); } ifa.ifa_netmask = reinterpret_cast(&netmask); } void SetPacketAttributes(int ifindex, unsigned short hatype, unsigned char halen) { sockaddr_ll* sll = reinterpret_cast(&addr); sll->sll_ifindex = ifindex; sll->sll_hatype = hatype; sll->sll_halen = halen; } private: sockaddr* CopyAddress(int family, const void* data, size_t byteCount, sockaddr_storage* ss) { // Netlink gives us the address family in the header, and the // sockaddr_in or sockaddr_in6 bytes as the payload. We need to // stitch the two bits together into the sockaddr that's part of // our portable interface. ss->ss_family = family; memcpy(SockaddrBytes(family, ss), data, byteCount); // For IPv6 we might also have to set the scope id. if (family == AF_INET6 && (IN6_IS_ADDR_LINKLOCAL(data) || IN6_IS_ADDR_MC_LINKLOCAL(data))) { reinterpret_cast(ss)->sin6_scope_id = interface_index; } return reinterpret_cast(ss); } // Returns a pointer to the first byte in the address data (which is // stored in network byte order). uint8_t* SockaddrBytes(int family, sockaddr_storage* ss) { if (family == AF_INET) { sockaddr_in* ss4 = reinterpret_cast(ss); return reinterpret_cast(&ss4->sin_addr); } else if (family == AF_INET6) { sockaddr_in6* ss6 = reinterpret_cast(ss); return reinterpret_cast(&ss6->sin6_addr); } else if (family == AF_PACKET) { sockaddr_ll* sll = reinterpret_cast(ss); return reinterpret_cast(&sll->sll_addr); } return nullptr; } }; static void __getifaddrs_callback(void* context, nlmsghdr* hdr) { ifaddrs** out = reinterpret_cast(context); if (hdr->nlmsg_type == RTM_NEWLINK) { ifinfomsg* ifi = reinterpret_cast(NLMSG_DATA(hdr)); // Create a new ifaddr entry, and set the interface index and flags. ifaddrs_storage* new_addr = new ifaddrs_storage(out); new_addr->interface_index = ifi->ifi_index; new_addr->ifa.ifa_flags = ifi->ifi_flags; // Go through the various bits of information and find the name. rtattr* rta = IFLA_RTA(ifi); size_t rta_len = IFLA_PAYLOAD(hdr); while (RTA_OK(rta, rta_len)) { if (rta->rta_type == IFLA_ADDRESS) { if (RTA_PAYLOAD(rta) < sizeof(new_addr->addr)) { new_addr->SetAddress(AF_PACKET, RTA_DATA(rta), RTA_PAYLOAD(rta)); new_addr->SetPacketAttributes(ifi->ifi_index, ifi->ifi_type, RTA_PAYLOAD(rta)); } } else if (rta->rta_type == IFLA_BROADCAST) { if (RTA_PAYLOAD(rta) < sizeof(new_addr->ifa_ifu)) { new_addr->SetBroadcastAddress(AF_PACKET, RTA_DATA(rta), RTA_PAYLOAD(rta)); new_addr->SetPacketAttributes(ifi->ifi_index, ifi->ifi_type, RTA_PAYLOAD(rta)); } } else if (rta->rta_type == IFLA_IFNAME) { if (RTA_PAYLOAD(rta) < sizeof(new_addr->name)) { memcpy(new_addr->name, RTA_DATA(rta), RTA_PAYLOAD(rta)); new_addr->ifa.ifa_name = new_addr->name; } } rta = RTA_NEXT(rta, rta_len); } } else if (hdr->nlmsg_type == RTM_NEWADDR) { ifaddrmsg* msg = reinterpret_cast(NLMSG_DATA(hdr)); // We should already know about this from an RTM_NEWLINK message. const ifaddrs_storage* addr = reinterpret_cast(*out); while (addr != nullptr && addr->interface_index != static_cast(msg->ifa_index)) { addr = reinterpret_cast(addr->ifa.ifa_next); } // If this is an unknown interface, ignore whatever we're being told about it. if (addr == nullptr) return; // Create a new ifaddr entry and copy what we already know. ifaddrs_storage* new_addr = new ifaddrs_storage(out); // We can just copy the name rather than look for IFA_LABEL. strcpy(new_addr->name, addr->name); new_addr->ifa.ifa_name = new_addr->name; new_addr->ifa.ifa_flags = addr->ifa.ifa_flags; new_addr->interface_index = addr->interface_index; // Go through the various bits of information and find the address // and any broadcast/destination address. rtattr* rta = IFA_RTA(msg); size_t rta_len = IFA_PAYLOAD(hdr); while (RTA_OK(rta, rta_len)) { if (rta->rta_type == IFA_ADDRESS) { if (msg->ifa_family == AF_INET || msg->ifa_family == AF_INET6) { new_addr->SetAddress(msg->ifa_family, RTA_DATA(rta), RTA_PAYLOAD(rta)); new_addr->SetNetmask(msg->ifa_family, msg->ifa_prefixlen); } } else if (rta->rta_type == IFA_BROADCAST) { if (msg->ifa_family == AF_INET) { new_addr->SetBroadcastAddress(msg->ifa_family, RTA_DATA(rta), RTA_PAYLOAD(rta)); } } else if (rta->rta_type == IFA_LOCAL) { if (msg->ifa_family == AF_INET || msg->ifa_family == AF_INET6) { new_addr->SetLocalAddress(msg->ifa_family, RTA_DATA(rta), RTA_PAYLOAD(rta)); } } rta = RTA_NEXT(rta, rta_len); } } } int getifaddrs(ifaddrs** out) { // We construct the result directly into `out`, so terminate the list. *out = nullptr; // Open the netlink socket and ask for all the links and addresses. NetlinkConnection nc; bool okay = nc.SendRequest(RTM_GETLINK) && nc.ReadResponses(__getifaddrs_callback, out) && nc.SendRequest(RTM_GETADDR) && nc.ReadResponses(__getifaddrs_callback, out); if (!okay) { freeifaddrs(*out); // Ensure that callers crash if they forget to check for success. *out = nullptr; return -1; } return 0; } void freeifaddrs(ifaddrs* list) { while (list != nullptr) { ifaddrs* current = list; list = list->ifa_next; free(current); } }