1 /* 2 * Copyright (C) 2008 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 package android.net; 18 19 import java.io.FileDescriptor; 20 import java.net.InetAddress; 21 import java.net.Inet4Address; 22 import java.net.Inet6Address; 23 import java.net.SocketException; 24 import java.net.UnknownHostException; 25 import java.util.Collection; 26 import java.util.Locale; 27 28 import android.os.Parcel; 29 import android.util.Log; 30 import android.util.Pair; 31 32 33 /** 34 * Native methods for managing network interfaces. 35 * 36 * {@hide} 37 */ 38 public class NetworkUtils { 39 40 private static final String TAG = "NetworkUtils"; 41 42 /** 43 * Attaches a socket filter that accepts DHCP packets to the given socket. 44 */ 45 public native static void attachDhcpFilter(FileDescriptor fd) throws SocketException; 46 47 /** 48 * Attaches a socket filter that accepts ICMPv6 router advertisements to the given socket. 49 * @param fd the socket's {@link FileDescriptor}. 50 * @param packetType the hardware address type, one of ARPHRD_*. 51 */ 52 public native static void attachRaFilter(FileDescriptor fd, int packetType) throws SocketException; 53 54 /** 55 * Attaches a socket filter that accepts L2-L4 signaling traffic required for IP connectivity. 56 * 57 * This includes: all ARP, ICMPv6 RS/RA/NS/NA messages, and DHCPv4 exchanges. 58 * 59 * @param fd the socket's {@link FileDescriptor}. 60 * @param packetType the hardware address type, one of ARPHRD_*. 61 */ 62 public native static void attachControlPacketFilter(FileDescriptor fd, int packetType) 63 throws SocketException; 64 65 /** 66 * Configures a socket for receiving ICMPv6 router solicitations and sending advertisements. 67 * @param fd the socket's {@link FileDescriptor}. 68 * @param ifIndex the interface index. 69 */ 70 public native static void setupRaSocket(FileDescriptor fd, int ifIndex) throws SocketException; 71 72 /** 73 * Binds the current process to the network designated by {@code netId}. All sockets created 74 * in the future (and not explicitly bound via a bound {@link SocketFactory} (see 75 * {@link Network#getSocketFactory}) will be bound to this network. Note that if this 76 * {@code Network} ever disconnects all sockets created in this way will cease to work. This 77 * is by design so an application doesn't accidentally use sockets it thinks are still bound to 78 * a particular {@code Network}. Passing NETID_UNSET clears the binding. 79 */ 80 public native static boolean bindProcessToNetwork(int netId); 81 82 /** 83 * Return the netId last passed to {@link #bindProcessToNetwork}, or NETID_UNSET if 84 * {@link #unbindProcessToNetwork} has been called since {@link #bindProcessToNetwork}. 85 */ 86 public native static int getBoundNetworkForProcess(); 87 88 /** 89 * Binds host resolutions performed by this process to the network designated by {@code netId}. 90 * {@link #bindProcessToNetwork} takes precedence over this setting. Passing NETID_UNSET clears 91 * the binding. 92 * 93 * @deprecated This is strictly for legacy usage to support startUsingNetworkFeature(). 94 */ 95 @Deprecated 96 public native static boolean bindProcessToNetworkForHostResolution(int netId); 97 98 /** 99 * Explicitly binds {@code socketfd} to the network designated by {@code netId}. This 100 * overrides any binding via {@link #bindProcessToNetwork}. 101 * @return 0 on success or negative errno on failure. 102 */ 103 public native static int bindSocketToNetwork(int socketfd, int netId); 104 105 /** 106 * Protect {@code fd} from VPN connections. After protecting, data sent through 107 * this socket will go directly to the underlying network, so its traffic will not be 108 * forwarded through the VPN. 109 */ 110 public static boolean protectFromVpn(FileDescriptor fd) { 111 return protectFromVpn(fd.getInt$()); 112 } 113 114 /** 115 * Protect {@code socketfd} from VPN connections. After protecting, data sent through 116 * this socket will go directly to the underlying network, so its traffic will not be 117 * forwarded through the VPN. 118 */ 119 public native static boolean protectFromVpn(int socketfd); 120 121 /** 122 * Determine if {@code uid} can access network designated by {@code netId}. 123 * @return {@code true} if {@code uid} can access network, {@code false} otherwise. 124 */ 125 public native static boolean queryUserAccess(int uid, int netId); 126 127 /** 128 * Convert a IPv4 address from an integer to an InetAddress. 129 * @param hostAddress an int corresponding to the IPv4 address in network byte order 130 */ 131 public static InetAddress intToInetAddress(int hostAddress) { 132 byte[] addressBytes = { (byte)(0xff & hostAddress), 133 (byte)(0xff & (hostAddress >> 8)), 134 (byte)(0xff & (hostAddress >> 16)), 135 (byte)(0xff & (hostAddress >> 24)) }; 136 137 try { 138 return InetAddress.getByAddress(addressBytes); 139 } catch (UnknownHostException e) { 140 throw new AssertionError(); 141 } 142 } 143 144 /** 145 * Convert a IPv4 address from an InetAddress to an integer 146 * @param inetAddr is an InetAddress corresponding to the IPv4 address 147 * @return the IP address as an integer in network byte order 148 */ 149 public static int inetAddressToInt(Inet4Address inetAddr) 150 throws IllegalArgumentException { 151 byte [] addr = inetAddr.getAddress(); 152 return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) | 153 ((addr[1] & 0xff) << 8) | (addr[0] & 0xff); 154 } 155 156 /** 157 * Convert a network prefix length to an IPv4 netmask integer 158 * @param prefixLength 159 * @return the IPv4 netmask as an integer in network byte order 160 */ 161 public static int prefixLengthToNetmaskInt(int prefixLength) 162 throws IllegalArgumentException { 163 if (prefixLength < 0 || prefixLength > 32) { 164 throw new IllegalArgumentException("Invalid prefix length (0 <= prefix <= 32)"); 165 } 166 int value = 0xffffffff << (32 - prefixLength); 167 return Integer.reverseBytes(value); 168 } 169 170 /** 171 * Convert a IPv4 netmask integer to a prefix length 172 * @param netmask as an integer in network byte order 173 * @return the network prefix length 174 */ 175 public static int netmaskIntToPrefixLength(int netmask) { 176 return Integer.bitCount(netmask); 177 } 178 179 /** 180 * Convert an IPv4 netmask to a prefix length, checking that the netmask is contiguous. 181 * @param netmask as a {@code Inet4Address}. 182 * @return the network prefix length 183 * @throws IllegalArgumentException the specified netmask was not contiguous. 184 * @hide 185 */ 186 public static int netmaskToPrefixLength(Inet4Address netmask) { 187 // inetAddressToInt returns an int in *network* byte order. 188 int i = Integer.reverseBytes(inetAddressToInt(netmask)); 189 int prefixLength = Integer.bitCount(i); 190 int trailingZeros = Integer.numberOfTrailingZeros(i); 191 if (trailingZeros != 32 - prefixLength) { 192 throw new IllegalArgumentException("Non-contiguous netmask: " + Integer.toHexString(i)); 193 } 194 return prefixLength; 195 } 196 197 198 /** 199 * Create an InetAddress from a string where the string must be a standard 200 * representation of a V4 or V6 address. Avoids doing a DNS lookup on failure 201 * but it will throw an IllegalArgumentException in that case. 202 * @param addrString 203 * @return the InetAddress 204 * @hide 205 */ 206 public static InetAddress numericToInetAddress(String addrString) 207 throws IllegalArgumentException { 208 return InetAddress.parseNumericAddress(addrString); 209 } 210 211 /** 212 * Writes an InetAddress to a parcel. The address may be null. This is likely faster than 213 * calling writeSerializable. 214 */ 215 protected static void parcelInetAddress(Parcel parcel, InetAddress address, int flags) { 216 byte[] addressArray = (address != null) ? address.getAddress() : null; 217 parcel.writeByteArray(addressArray); 218 } 219 220 /** 221 * Reads an InetAddress from a parcel. Returns null if the address that was written was null 222 * or if the data is invalid. 223 */ 224 protected static InetAddress unparcelInetAddress(Parcel in) { 225 byte[] addressArray = in.createByteArray(); 226 if (addressArray == null) { 227 return null; 228 } 229 try { 230 return InetAddress.getByAddress(addressArray); 231 } catch (UnknownHostException e) { 232 return null; 233 } 234 } 235 236 237 /** 238 * Masks a raw IP address byte array with the specified prefix length. 239 */ 240 public static void maskRawAddress(byte[] array, int prefixLength) { 241 if (prefixLength < 0 || prefixLength > array.length * 8) { 242 throw new RuntimeException("IP address with " + array.length + 243 " bytes has invalid prefix length " + prefixLength); 244 } 245 246 int offset = prefixLength / 8; 247 int remainder = prefixLength % 8; 248 byte mask = (byte)(0xFF << (8 - remainder)); 249 250 if (offset < array.length) array[offset] = (byte)(array[offset] & mask); 251 252 offset++; 253 254 for (; offset < array.length; offset++) { 255 array[offset] = 0; 256 } 257 } 258 259 /** 260 * Get InetAddress masked with prefixLength. Will never return null. 261 * @param address the IP address to mask with 262 * @param prefixLength the prefixLength used to mask the IP 263 */ 264 public static InetAddress getNetworkPart(InetAddress address, int prefixLength) { 265 byte[] array = address.getAddress(); 266 maskRawAddress(array, prefixLength); 267 268 InetAddress netPart = null; 269 try { 270 netPart = InetAddress.getByAddress(array); 271 } catch (UnknownHostException e) { 272 throw new RuntimeException("getNetworkPart error - " + e.toString()); 273 } 274 return netPart; 275 } 276 277 /** 278 * Returns the implicit netmask of an IPv4 address, as was the custom before 1993. 279 */ 280 public static int getImplicitNetmask(Inet4Address address) { 281 int firstByte = address.getAddress()[0] & 0xff; // Convert to an unsigned value. 282 if (firstByte < 128) { 283 return 8; 284 } else if (firstByte < 192) { 285 return 16; 286 } else if (firstByte < 224) { 287 return 24; 288 } else { 289 return 32; // Will likely not end well for other reasons. 290 } 291 } 292 293 /** 294 * Utility method to parse strings such as "192.0.2.5/24" or "2001:db8::cafe:d00d/64". 295 * @hide 296 */ 297 public static Pair<InetAddress, Integer> parseIpAndMask(String ipAndMaskString) { 298 InetAddress address = null; 299 int prefixLength = -1; 300 try { 301 String[] pieces = ipAndMaskString.split("/", 2); 302 prefixLength = Integer.parseInt(pieces[1]); 303 address = InetAddress.parseNumericAddress(pieces[0]); 304 } catch (NullPointerException e) { // Null string. 305 } catch (ArrayIndexOutOfBoundsException e) { // No prefix length. 306 } catch (NumberFormatException e) { // Non-numeric prefix. 307 } catch (IllegalArgumentException e) { // Invalid IP address. 308 } 309 310 if (address == null || prefixLength == -1) { 311 throw new IllegalArgumentException("Invalid IP address and mask " + ipAndMaskString); 312 } 313 314 return new Pair<InetAddress, Integer>(address, prefixLength); 315 } 316 317 /** 318 * Check if IP address type is consistent between two InetAddress. 319 * @return true if both are the same type. False otherwise. 320 */ 321 public static boolean addressTypeMatches(InetAddress left, InetAddress right) { 322 return (((left instanceof Inet4Address) && (right instanceof Inet4Address)) || 323 ((left instanceof Inet6Address) && (right instanceof Inet6Address))); 324 } 325 326 /** 327 * Convert a 32 char hex string into a Inet6Address. 328 * throws a runtime exception if the string isn't 32 chars, isn't hex or can't be 329 * made into an Inet6Address 330 * @param addrHexString a 32 character hex string representing an IPv6 addr 331 * @return addr an InetAddress representation for the string 332 */ 333 public static InetAddress hexToInet6Address(String addrHexString) 334 throws IllegalArgumentException { 335 try { 336 return numericToInetAddress(String.format(Locale.US, "%s:%s:%s:%s:%s:%s:%s:%s", 337 addrHexString.substring(0,4), addrHexString.substring(4,8), 338 addrHexString.substring(8,12), addrHexString.substring(12,16), 339 addrHexString.substring(16,20), addrHexString.substring(20,24), 340 addrHexString.substring(24,28), addrHexString.substring(28,32))); 341 } catch (Exception e) { 342 Log.e("NetworkUtils", "error in hexToInet6Address(" + addrHexString + "): " + e); 343 throw new IllegalArgumentException(e); 344 } 345 } 346 347 /** 348 * Create a string array of host addresses from a collection of InetAddresses 349 * @param addrs a Collection of InetAddresses 350 * @return an array of Strings containing their host addresses 351 */ 352 public static String[] makeStrings(Collection<InetAddress> addrs) { 353 String[] result = new String[addrs.size()]; 354 int i = 0; 355 for (InetAddress addr : addrs) { 356 result[i++] = addr.getHostAddress(); 357 } 358 return result; 359 } 360 361 /** 362 * Trim leading zeros from IPv4 address strings 363 * Our base libraries will interpret that as octel.. 364 * Must leave non v4 addresses and host names alone. 365 * For example, 192.168.000.010 -> 192.168.0.10 366 * TODO - fix base libraries and remove this function 367 * @param addr a string representing an ip addr 368 * @return a string propertly trimmed 369 */ 370 public static String trimV4AddrZeros(String addr) { 371 if (addr == null) return null; 372 String[] octets = addr.split("\\."); 373 if (octets.length != 4) return addr; 374 StringBuilder builder = new StringBuilder(16); 375 String result = null; 376 for (int i = 0; i < 4; i++) { 377 try { 378 if (octets[i].length() > 3) return addr; 379 builder.append(Integer.parseInt(octets[i])); 380 } catch (NumberFormatException e) { 381 return addr; 382 } 383 if (i < 3) builder.append('.'); 384 } 385 result = builder.toString(); 386 return result; 387 } 388 } 389
