1 /* 2 * Copyright (C) 2015 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <gtest/gtest.h> 18 19 #include <ifaddrs.h> 20 21 #include <dirent.h> 22 #include <fcntl.h> 23 #include <linux/if_packet.h> 24 #include <net/ethernet.h> 25 #include <net/if.h> 26 #include <netdb.h> 27 #include <netinet/in.h> 28 #include <sys/ioctl.h> 29 30 #include <algorithm> 31 #include <map> 32 #include <thread> 33 #include <vector> 34 35 TEST(ifaddrs, freeifaddrs_null) { 36 freeifaddrs(nullptr); 37 } 38 39 // We can't statically say much about what network interfaces are available, but we can be pretty 40 // sure there's a loopback interface, and that it has IPv4, IPv6, and AF_PACKET entries. 41 TEST(ifaddrs, getifaddrs_lo) { 42 ifaddrs* addrs = nullptr; 43 44 ASSERT_EQ(0, getifaddrs(&addrs)); 45 ASSERT_TRUE(addrs != nullptr); 46 47 ifaddrs* lo_inet4 = nullptr; 48 ifaddrs* lo_inet6 = nullptr; 49 ifaddrs* lo_packet = nullptr; 50 for (ifaddrs* addr = addrs; addr != nullptr; addr = addr->ifa_next) { 51 if (addr->ifa_name && strcmp(addr->ifa_name, "lo") == 0) { 52 if (addr->ifa_addr && addr->ifa_addr->sa_family == AF_INET) lo_inet4 = addr; 53 else if (addr->ifa_addr && addr->ifa_addr->sa_family == AF_INET6) lo_inet6 = addr; 54 else if (addr->ifa_addr && addr->ifa_addr->sa_family == AF_PACKET) lo_packet = addr; 55 } 56 } 57 58 // Does the IPv4 entry look right? 59 ASSERT_TRUE(lo_inet4 != nullptr); 60 const sockaddr_in* sa_inet4 = reinterpret_cast<const sockaddr_in*>(lo_inet4->ifa_addr); 61 ASSERT_TRUE(ntohl(sa_inet4->sin_addr.s_addr) == INADDR_LOOPBACK); 62 63 // Does the IPv6 entry look right? 64 ASSERT_TRUE(lo_inet6 != nullptr); 65 const sockaddr_in6* sa_inet6 = reinterpret_cast<const sockaddr_in6*>(lo_inet6->ifa_addr); 66 ASSERT_TRUE(IN6_IS_ADDR_LOOPBACK(&sa_inet6->sin6_addr)); 67 68 // Does the AF_PACKET entry look right? 69 ASSERT_TRUE(lo_packet != nullptr); 70 const sockaddr_ll* sa_ll = reinterpret_cast<const sockaddr_ll*>(lo_packet->ifa_addr); 71 ASSERT_EQ(6, sa_ll->sll_halen); 72 73 freeifaddrs(addrs); 74 } 75 76 // Check that getifaddrs sees the same list of interfaces as /sys/class/net. 77 TEST(ifaddrs, getifaddrs_interfaces) { 78 std::vector<std::string> ifaddrs_socks; 79 { 80 ifaddrs* addrs; 81 ASSERT_EQ(0, getifaddrs(&addrs)); 82 83 for (ifaddrs* addr = addrs; addr != nullptr; addr = addr->ifa_next) { 84 int family = addr->ifa_addr ? addr->ifa_addr->sa_family : 85 addr->ifa_broadaddr ? addr->ifa_broadaddr->sa_family : 86 AF_UNSPEC; 87 88 if (family == AF_PACKET || family == AF_UNSPEC) { 89 ifaddrs_socks.push_back(std::string(addr->ifa_name)); 90 } 91 } 92 93 freeifaddrs(addrs); 94 } 95 96 std::vector<std::string> sys_class_net; 97 { 98 std::unique_ptr<DIR, decltype(&closedir)> d(opendir("/sys/class/net"), closedir); 99 ASSERT_TRUE(d != nullptr); 100 dirent* dir; 101 while ((dir = readdir(d.get())) != nullptr) { 102 if (dir->d_type == DT_LNK) { 103 sys_class_net.push_back(std::string(dir->d_name)); 104 } 105 } 106 } 107 108 ASSERT_TRUE(std::is_permutation(ifaddrs_socks.begin(), ifaddrs_socks.end(), 109 sys_class_net.begin())); 110 } 111 112 static void CheckAddressIsInSet(const std::string& if_name, bool unicast, 113 const std::set<in_addr_t>& addrs) { 114 ifreq ifr; 115 memset(&ifr, 0, sizeof(ifr)); 116 ifr.ifr_addr.sa_family = AF_INET; 117 if_name.copy(ifr.ifr_name, IFNAMSIZ - 1); 118 119 int fd = socket(AF_INET, SOCK_DGRAM, 0); 120 ASSERT_TRUE(fd != -1); 121 122 int request = SIOCGIFADDR; 123 if (!unicast) { 124 // For non-unicast, the specific ioctl to use depends on whether the IFF_BROADCAST flag is set. 125 ASSERT_EQ(0, ioctl(fd, SIOCGIFFLAGS, &ifr)) << if_name << ' ' << strerror(errno); 126 request = ((ifr.ifr_flags & IFF_BROADCAST) != 0) ? SIOCGIFBRDADDR : SIOCGIFDSTADDR; 127 } 128 129 ASSERT_EQ(0, ioctl(fd, request, &ifr)) << if_name << ' ' << strerror(errno); 130 close(fd); 131 132 sockaddr_in* sock = reinterpret_cast<sockaddr_in*>(&ifr.ifr_addr); 133 in_addr_t addr = sock->sin_addr.s_addr; 134 135 EXPECT_TRUE(addrs.find(addr) != addrs.end()) << if_name << ' ' << std::hex << ntohl(addr); 136 } 137 138 TEST(ifaddrs, getifaddrs_INET) { 139 std::map<std::string, std::set<in_addr_t>> inet_addrs; 140 std::map<std::string, std::set<in_addr_t>> broad_addrs; 141 142 // Collect the IPv4 addresses for each interface. 143 ifaddrs* addrs; 144 ASSERT_EQ(0, getifaddrs(&addrs)); 145 for (ifaddrs* addr = addrs; addr != nullptr; addr = addr->ifa_next) { 146 if (addr->ifa_name && addr->ifa_addr && addr->ifa_addr->sa_family == AF_INET) { 147 auto sock = reinterpret_cast<sockaddr_in*>(addr->ifa_addr); 148 inet_addrs[addr->ifa_name].insert(sock->sin_addr.s_addr); 149 } 150 if (addr->ifa_name && addr->ifa_broadaddr && addr->ifa_broadaddr->sa_family == AF_INET) { 151 auto sock = reinterpret_cast<sockaddr_in*>(addr->ifa_broadaddr); 152 broad_addrs[addr->ifa_name].insert(sock->sin_addr.s_addr); 153 } 154 } 155 freeifaddrs(addrs); 156 157 // Check that the addresses returned by the SIOCGIFADDR and SIOCGIFBRDADDR/SIOCGIFDSTADDR ioctls 158 // are in our collections. 159 for (const auto& it : inet_addrs) CheckAddressIsInSet(it.first, true, it.second); 160 for (const auto& it : broad_addrs) CheckAddressIsInSet(it.first, false, it.second); 161 } 162 163 static void print_sockaddr_ll(const char* what, const sockaddr* p) { 164 const sockaddr_ll* s = reinterpret_cast<const sockaddr_ll*>(p); 165 printf("\t\t%s\t", what); 166 for (int i = 0; i < s->sll_halen; ++i) { 167 if (i > 0) printf(":"); 168 printf("%02X", s->sll_addr[i]); 169 } 170 printf(" (%d bytes)\n", s->sll_halen); 171 } 172 173 static void print_sockaddr_inet(const char* what, const sockaddr* addr) { 174 char host[NI_MAXHOST]; 175 int family = addr->sa_family; 176 int error = getnameinfo(addr, 177 (family == AF_INET) ? sizeof(sockaddr_in) : sizeof(sockaddr_in6), 178 host, NI_MAXHOST, nullptr, 0, NI_NUMERICHOST); 179 if (error != 0) { 180 printf("%d getnameinfo() failed: %s\n", family, gai_strerror(error)); 181 strcpy(host, "???"); 182 } 183 printf("\t\t%s: <%s>\n", what, host); 184 } 185 186 static const char* FamilyToName(int family) { 187 if (family == AF_INET) return "AF_INET"; 188 if (family == AF_INET6) return "AF_INET6"; 189 if (family == AF_PACKET) return "AF_PACKET"; 190 if (family == AF_UNSPEC) return "AF_UNSPEC"; 191 return "?"; 192 } 193 194 static std::string FlagsToString(short flags) { 195 std::string result; 196 if ((flags & IFF_UP) != 0) result += " UP"; 197 if ((flags & IFF_BROADCAST) != 0) result += " BROADCAST"; 198 if ((flags & IFF_DEBUG) != 0) result += " DEBUG"; 199 if ((flags & IFF_LOOPBACK) != 0) result += " LOOPBACK"; 200 if ((flags & IFF_POINTOPOINT) != 0) result += " POINTOPOINT"; 201 if ((flags & IFF_NOTRAILERS) != 0) result += " NOTRAILERS"; 202 if ((flags & IFF_RUNNING) != 0) result += " RUNNING"; 203 if ((flags & IFF_NOARP) != 0) result += " NOARP"; 204 if ((flags & IFF_PROMISC) != 0) result += " PROMISC"; 205 if ((flags & IFF_ALLMULTI) != 0) result += " ALLMULTI"; 206 if ((flags & IFF_MASTER) != 0) result += " MASTER"; 207 if ((flags & IFF_SLAVE) != 0) result += " SLAVE"; 208 if ((flags & IFF_MULTICAST) != 0) result += " MULTICAST"; 209 if ((flags & IFF_PORTSEL) != 0) result += " PORTSEL"; 210 if ((flags & IFF_AUTOMEDIA) != 0) result += " AUTOMEDIA"; 211 if ((flags & IFF_DYNAMIC) != 0) result += " DYNAMIC"; 212 #if defined(IFF_LOWER_UP) 213 if ((flags & IFF_LOWER_UP) != 0) result += " LOWER_UP"; 214 #endif 215 #if defined(IFF_DORMANT) 216 if ((flags & IFF_DORMANT) != 0) result += " DORMANT"; 217 #endif 218 #if defined(IFF_ECHO) 219 if ((flags & IFF_ECHO) != 0) result += " ECHO"; 220 #endif 221 return result; 222 } 223 224 // Not really a test, but a useful debugging tool. 225 TEST(ifaddrs, dump) { 226 ifaddrs* addrs; 227 ASSERT_EQ(0, getifaddrs(&addrs)); 228 229 for (ifaddrs* ifa = addrs; ifa != nullptr; ifa = ifa->ifa_next) { 230 int family = ifa->ifa_addr ? ifa->ifa_addr->sa_family : 231 ifa->ifa_broadaddr ? ifa->ifa_broadaddr->sa_family : AF_UNSPEC; 232 233 printf("\t%s\n" 234 "\t\t%s (%d) flags=%#x%s\n", 235 ifa->ifa_name, FamilyToName(family), family, 236 ifa->ifa_flags, FlagsToString(ifa->ifa_flags).c_str()); 237 238 if (family == AF_PACKET) { 239 if (ifa->ifa_addr) print_sockaddr_ll("hwaddr", ifa->ifa_addr); 240 if (ifa->ifa_broadaddr) print_sockaddr_ll("hwbroad", ifa->ifa_addr); 241 } else if (family == AF_INET || family == AF_INET6) { 242 if (ifa->ifa_addr) print_sockaddr_inet("address", ifa->ifa_addr); 243 if (ifa->ifa_broadaddr && (ifa->ifa_flags & (IFF_BROADCAST | IFF_POINTOPOINT)) != 0) { 244 print_sockaddr_inet((ifa->ifa_flags & IFF_BROADCAST) ? "broadcast" : "destination", 245 ifa->ifa_broadaddr); 246 } 247 } 248 249 fflush(stdout); 250 } 251 252 freeifaddrs(addrs); 253 } 254 255 TEST(ifaddrs, inet6_scope_ids) { 256 ifaddrs* addrs; 257 ASSERT_EQ(0, getifaddrs(&addrs)); 258 259 for (ifaddrs* ifa = addrs; ifa != nullptr; ifa = ifa->ifa_next) { 260 if (ifa->ifa_addr && ifa->ifa_addr->sa_family == AF_INET6) { 261 sockaddr_in6* sa6 = reinterpret_cast<sockaddr_in6*>(ifa->ifa_addr); 262 // Any link-local IPv6 address should have a scope id. (http://b/27219454.) 263 // 0 isn't a valid interface index, so that would mean the scope id wasn't set. 264 if (IN6_IS_ADDR_LINKLOCAL(&sa6->sin6_addr) || IN6_IS_ADDR_MC_LINKLOCAL(&sa6->sin6_addr)) { 265 ASSERT_NE(sa6->sin6_scope_id, 0U); 266 } 267 } 268 } 269 270 freeifaddrs(addrs); 271 } 272 273 TEST(ifaddrs, kernel_bug_31038971) { 274 // Some kernels had a bug that would lead to an NLMSG_ERROR response, 275 // but bionic wasn't setting errno based on the value in the message. 276 // This is the test for the kernel bug, but on a device with a bad 277 // kernel this test was also useful for testing the bionic errno fix. 278 std::vector<std::thread*> threads; 279 for (size_t i = 0; i < 128; ++i) { 280 threads.push_back(new std::thread([]() { 281 ifaddrs* addrs = nullptr; 282 ASSERT_EQ(0, getifaddrs(&addrs)) << strerror(errno); 283 freeifaddrs(addrs); 284 })); 285 } 286 for (auto& t : threads) { 287 t->join(); 288 delete t; 289 } 290 } 291 292 TEST(ifaddrs, errno_EMFILE) { 293 std::vector<int> fds; 294 while (true) { 295 int fd = open("/dev/null", O_RDONLY|O_CLOEXEC); 296 if (fd == -1) { 297 ASSERT_EQ(EMFILE, errno); 298 break; 299 } 300 fds.push_back(fd); 301 } 302 303 ifaddrs* addrs; 304 EXPECT_EQ(-1, getifaddrs(&addrs)); 305 EXPECT_EQ(EMFILE, errno); 306 307 for (int fd : fds) close(fd); 308 } 309
