henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | /* |
| 2 | * libjingle |
| 3 | * Copyright 2012, Google Inc. |
| 4 | * |
| 5 | * Redistribution and use in source and binary forms, with or without |
| 6 | * modification, are permitted provided that the following conditions are met: |
| 7 | * |
| 8 | * 1. Redistributions of source code must retain the above copyright notice, |
| 9 | * this list of conditions and the following disclaimer. |
| 10 | * 2. Redistributions in binary form must reproduce the above copyright notice, |
| 11 | * this list of conditions and the following disclaimer in the documentation |
| 12 | * and/or other materials provided with the distribution. |
| 13 | * 3. The name of the author may not be used to endorse or promote products |
| 14 | * derived from this software without specific prior written permission. |
| 15 | * |
| 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED |
| 17 | * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF |
| 18 | * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO |
| 19 | * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| 20 | * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| 21 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; |
| 22 | * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, |
| 23 | * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR |
| 24 | * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF |
| 25 | * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 26 | */ |
| 27 | |
| 28 | #if defined(ANDROID) |
| 29 | #include "talk/base/ifaddrs-android.h" |
| 30 | #include <stdlib.h> |
| 31 | #include <string.h> |
| 32 | #include <sys/types.h> |
| 33 | #include <sys/socket.h> |
| 34 | #include <sys/utsname.h> |
| 35 | #include <sys/ioctl.h> |
| 36 | #include <netinet/in.h> |
| 37 | #include <net/if.h> |
| 38 | #include <unistd.h> |
| 39 | #include <errno.h> |
| 40 | #include <linux/netlink.h> |
| 41 | #include <linux/rtnetlink.h> |
| 42 | |
| 43 | struct netlinkrequest { |
| 44 | nlmsghdr header; |
| 45 | ifaddrmsg msg; |
| 46 | }; |
| 47 | |
| 48 | namespace { |
| 49 | const int kMaxReadSize = 4096; |
| 50 | }; |
| 51 | |
| 52 | int set_ifname(struct ifaddrs* ifaddr, int interface) { |
| 53 | char buf[IFNAMSIZ] = {0}; |
| 54 | char* name = if_indextoname(interface, buf); |
| 55 | if (name == NULL) { |
| 56 | return -1; |
| 57 | } |
| 58 | ifaddr->ifa_name = new char[strlen(name) + 1]; |
| 59 | strncpy(ifaddr->ifa_name, name, strlen(name) + 1); |
| 60 | return 0; |
| 61 | } |
| 62 | |
| 63 | int set_flags(struct ifaddrs* ifaddr) { |
| 64 | int fd = socket(AF_INET, SOCK_DGRAM, 0); |
| 65 | if (fd == -1) { |
| 66 | return -1; |
| 67 | } |
| 68 | ifreq ifr; |
| 69 | memset(&ifr, 0, sizeof(ifr)); |
| 70 | strncpy(ifr.ifr_name, ifaddr->ifa_name, IFNAMSIZ - 1); |
| 71 | int rc = ioctl(fd, SIOCGIFFLAGS, &ifr); |
| 72 | close(fd); |
| 73 | if (rc == -1) { |
| 74 | return -1; |
| 75 | } |
| 76 | ifaddr->ifa_flags = ifr.ifr_flags; |
| 77 | return 0; |
| 78 | } |
| 79 | |
| 80 | int set_addresses(struct ifaddrs* ifaddr, ifaddrmsg* msg, void* data, |
| 81 | size_t len) { |
| 82 | if (msg->ifa_family == AF_INET) { |
| 83 | sockaddr_in* sa = new sockaddr_in; |
| 84 | sa->sin_family = AF_INET; |
| 85 | memcpy(&sa->sin_addr, data, len); |
| 86 | ifaddr->ifa_addr = reinterpret_cast<sockaddr*>(sa); |
| 87 | } else if (msg->ifa_family == AF_INET6) { |
| 88 | sockaddr_in6* sa = new sockaddr_in6; |
| 89 | sa->sin6_family = AF_INET6; |
| 90 | sa->sin6_scope_id = msg->ifa_index; |
| 91 | memcpy(&sa->sin6_addr, data, len); |
| 92 | ifaddr->ifa_addr = reinterpret_cast<sockaddr*>(sa); |
| 93 | } else { |
| 94 | return -1; |
| 95 | } |
| 96 | return 0; |
| 97 | } |
| 98 | |
| 99 | int make_prefixes(struct ifaddrs* ifaddr, int family, int prefixlen) { |
| 100 | char* prefix = NULL; |
| 101 | if (family == AF_INET) { |
| 102 | sockaddr_in* mask = new sockaddr_in; |
| 103 | mask->sin_family = AF_INET; |
| 104 | memset(&mask->sin_addr, 0, sizeof(in_addr)); |
| 105 | ifaddr->ifa_netmask = reinterpret_cast<sockaddr*>(mask); |
| 106 | if (prefixlen > 32) { |
| 107 | prefixlen = 32; |
| 108 | } |
| 109 | prefix = reinterpret_cast<char*>(&mask->sin_addr); |
| 110 | } else if (family == AF_INET6) { |
| 111 | sockaddr_in6* mask = new sockaddr_in6; |
| 112 | mask->sin6_family = AF_INET6; |
| 113 | memset(&mask->sin6_addr, 0, sizeof(in6_addr)); |
| 114 | ifaddr->ifa_netmask = reinterpret_cast<sockaddr*>(mask); |
| 115 | if (prefixlen > 128) { |
| 116 | prefixlen = 128; |
| 117 | } |
| 118 | prefix = reinterpret_cast<char*>(&mask->sin6_addr); |
| 119 | } else { |
| 120 | return -1; |
| 121 | } |
| 122 | for (int i = 0; i < (prefixlen / 8); i++) { |
| 123 | *prefix++ = 0xFF; |
| 124 | } |
| 125 | char remainder = 0xff; |
| 126 | remainder <<= (8 - prefixlen % 8); |
| 127 | *prefix = remainder; |
| 128 | return 0; |
| 129 | } |
| 130 | |
| 131 | int populate_ifaddrs(struct ifaddrs* ifaddr, ifaddrmsg* msg, void* bytes, |
| 132 | size_t len) { |
| 133 | if (set_ifname(ifaddr, msg->ifa_index) != 0) { |
| 134 | return -1; |
| 135 | } |
| 136 | if (set_flags(ifaddr) != 0) { |
| 137 | return -1; |
| 138 | } |
| 139 | if (set_addresses(ifaddr, msg, bytes, len) != 0) { |
| 140 | return -1; |
| 141 | } |
| 142 | if (make_prefixes(ifaddr, msg->ifa_family, msg->ifa_prefixlen) != 0) { |
| 143 | return -1; |
| 144 | } |
| 145 | return 0; |
| 146 | } |
| 147 | |
| 148 | int getifaddrs(struct ifaddrs** result) { |
| 149 | int fd = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); |
| 150 | if (fd < 0) { |
| 151 | return -1; |
| 152 | } |
| 153 | |
| 154 | netlinkrequest ifaddr_request; |
| 155 | memset(&ifaddr_request, 0, sizeof(ifaddr_request)); |
| 156 | ifaddr_request.header.nlmsg_flags = NLM_F_ROOT | NLM_F_REQUEST; |
| 157 | ifaddr_request.header.nlmsg_type = RTM_GETADDR; |
| 158 | ifaddr_request.header.nlmsg_len = NLMSG_LENGTH(sizeof(ifaddrmsg)); |
| 159 | |
| 160 | ssize_t count = send(fd, &ifaddr_request, ifaddr_request.header.nlmsg_len, 0); |
| 161 | if (static_cast<size_t>(count) != ifaddr_request.header.nlmsg_len) { |
| 162 | close(fd); |
| 163 | return -1; |
| 164 | } |
| 165 | struct ifaddrs* start = NULL; |
| 166 | struct ifaddrs* current = NULL; |
| 167 | char buf[kMaxReadSize]; |
| 168 | ssize_t amount_read = recv(fd, &buf, kMaxReadSize, 0); |
| 169 | while (amount_read > 0) { |
| 170 | nlmsghdr* header = reinterpret_cast<nlmsghdr*>(&buf[0]); |
| 171 | size_t header_size = static_cast<size_t>(amount_read); |
| 172 | for ( ; NLMSG_OK(header, header_size); |
| 173 | header = NLMSG_NEXT(header, header_size)) { |
| 174 | switch (header->nlmsg_type) { |
| 175 | case NLMSG_DONE: |
| 176 | // Success. Return. |
| 177 | *result = start; |
| 178 | close(fd); |
| 179 | return 0; |
| 180 | case NLMSG_ERROR: |
| 181 | close(fd); |
| 182 | freeifaddrs(start); |
| 183 | return -1; |
| 184 | case RTM_NEWADDR: { |
| 185 | ifaddrmsg* address_msg = |
| 186 | reinterpret_cast<ifaddrmsg*>(NLMSG_DATA(header)); |
| 187 | rtattr* rta = IFA_RTA(address_msg); |
| 188 | ssize_t payload_len = IFA_PAYLOAD(header); |
| 189 | while (RTA_OK(rta, payload_len)) { |
| 190 | if (rta->rta_type == IFA_ADDRESS) { |
| 191 | int family = address_msg->ifa_family; |
| 192 | if (family == AF_INET || family == AF_INET6) { |
| 193 | ifaddrs* newest = new ifaddrs; |
| 194 | memset(newest, 0, sizeof(ifaddrs)); |
| 195 | if (current) { |
| 196 | current->ifa_next = newest; |
| 197 | } else { |
| 198 | start = newest; |
| 199 | } |
| 200 | if (populate_ifaddrs(newest, address_msg, RTA_DATA(rta), |
| 201 | RTA_PAYLOAD(rta)) != 0) { |
| 202 | freeifaddrs(start); |
| 203 | *result = NULL; |
| 204 | return -1; |
| 205 | } |
| 206 | current = newest; |
| 207 | } |
| 208 | } |
| 209 | rta = RTA_NEXT(rta, payload_len); |
| 210 | } |
| 211 | break; |
| 212 | } |
| 213 | } |
| 214 | } |
| 215 | amount_read = recv(fd, &buf, kMaxReadSize, 0); |
| 216 | } |
| 217 | close(fd); |
| 218 | freeifaddrs(start); |
| 219 | return -1; |
| 220 | } |
| 221 | |
| 222 | void freeifaddrs(struct ifaddrs* addrs) { |
| 223 | struct ifaddrs* last = NULL; |
| 224 | struct ifaddrs* cursor = addrs; |
| 225 | while (cursor) { |
| 226 | delete[] cursor->ifa_name; |
| 227 | delete cursor->ifa_addr; |
| 228 | delete cursor->ifa_netmask; |
| 229 | last = cursor; |
| 230 | cursor = cursor->ifa_next; |
| 231 | delete last; |
| 232 | } |
| 233 | } |
| 234 | #endif // defined(ANDROID) |