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.net.InetAddress; 20 import java.net.Inet4Address; 21 import java.net.Inet6Address; 22 import java.net.UnknownHostException; 23 import java.util.Collection; 24 import java.util.Locale; 25 26 import android.util.Log; 27 28 /** 29 * Native methods for managing network interfaces. 30 * 31 * {@hide} 32 */ 33 public class NetworkUtils { 34 35 private static final String TAG = "NetworkUtils"; 36 37 /** Bring the named network interface up. */ enableInterface(String interfaceName)38 public native static int enableInterface(String interfaceName); 39 40 /** Bring the named network interface down. */ disableInterface(String interfaceName)41 public native static int disableInterface(String interfaceName); 42 43 /** Setting bit 0 indicates reseting of IPv4 addresses required */ 44 public static final int RESET_IPV4_ADDRESSES = 0x01; 45 46 /** Setting bit 1 indicates reseting of IPv4 addresses required */ 47 public static final int RESET_IPV6_ADDRESSES = 0x02; 48 49 /** Reset all addresses */ 50 public static final int RESET_ALL_ADDRESSES = RESET_IPV4_ADDRESSES | RESET_IPV6_ADDRESSES; 51 52 /** 53 * Reset IPv6 or IPv4 sockets that are connected via the named interface. 54 * 55 * @param interfaceName is the interface to reset 56 * @param mask {@see #RESET_IPV4_ADDRESSES} and {@see #RESET_IPV6_ADDRESSES} 57 */ resetConnections(String interfaceName, int mask)58 public native static int resetConnections(String interfaceName, int mask); 59 60 /** 61 * Start the DHCP client daemon, in order to have it request addresses 62 * for the named interface, and then configure the interface with those 63 * addresses. This call blocks until it obtains a result (either success 64 * or failure) from the daemon. 65 * @param interfaceName the name of the interface to configure 66 * @param dhcpResults if the request succeeds, this object is filled in with 67 * the IP address information. 68 * @return {@code true} for success, {@code false} for failure 69 */ runDhcp(String interfaceName, DhcpResults dhcpResults)70 public native static boolean runDhcp(String interfaceName, DhcpResults dhcpResults); 71 72 /** 73 * Initiate renewal on the Dhcp client daemon. This call blocks until it obtains 74 * a result (either success or failure) from the daemon. 75 * @param interfaceName the name of the interface to configure 76 * @param dhcpResults if the request succeeds, this object is filled in with 77 * the IP address information. 78 * @return {@code true} for success, {@code false} for failure 79 */ runDhcpRenew(String interfaceName, DhcpResults dhcpResults)80 public native static boolean runDhcpRenew(String interfaceName, DhcpResults dhcpResults); 81 82 /** 83 * Shut down the DHCP client daemon. 84 * @param interfaceName the name of the interface for which the daemon 85 * should be stopped 86 * @return {@code true} for success, {@code false} for failure 87 */ stopDhcp(String interfaceName)88 public native static boolean stopDhcp(String interfaceName); 89 90 /** 91 * Release the current DHCP lease. 92 * @param interfaceName the name of the interface for which the lease should 93 * be released 94 * @return {@code true} for success, {@code false} for failure 95 */ releaseDhcpLease(String interfaceName)96 public native static boolean releaseDhcpLease(String interfaceName); 97 98 /** 99 * Return the last DHCP-related error message that was recorded. 100 * <p/>NOTE: This string is not localized, but currently it is only 101 * used in logging. 102 * @return the most recent error message, if any 103 */ getDhcpError()104 public native static String getDhcpError(); 105 106 /** 107 * Set the SO_MARK of {@code socketfd} to {@code mark} 108 */ markSocket(int socketfd, int mark)109 public native static void markSocket(int socketfd, int mark); 110 111 /** 112 * Convert a IPv4 address from an integer to an InetAddress. 113 * @param hostAddress an int corresponding to the IPv4 address in network byte order 114 */ intToInetAddress(int hostAddress)115 public static InetAddress intToInetAddress(int hostAddress) { 116 byte[] addressBytes = { (byte)(0xff & hostAddress), 117 (byte)(0xff & (hostAddress >> 8)), 118 (byte)(0xff & (hostAddress >> 16)), 119 (byte)(0xff & (hostAddress >> 24)) }; 120 121 try { 122 return InetAddress.getByAddress(addressBytes); 123 } catch (UnknownHostException e) { 124 throw new AssertionError(); 125 } 126 } 127 128 /** 129 * Convert a IPv4 address from an InetAddress to an integer 130 * @param inetAddr is an InetAddress corresponding to the IPv4 address 131 * @return the IP address as an integer in network byte order 132 */ inetAddressToInt(Inet4Address inetAddr)133 public static int inetAddressToInt(Inet4Address inetAddr) 134 throws IllegalArgumentException { 135 byte [] addr = inetAddr.getAddress(); 136 return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) | 137 ((addr[1] & 0xff) << 8) | (addr[0] & 0xff); 138 } 139 140 /** 141 * Convert a network prefix length to an IPv4 netmask integer 142 * @param prefixLength 143 * @return the IPv4 netmask as an integer in network byte order 144 */ prefixLengthToNetmaskInt(int prefixLength)145 public static int prefixLengthToNetmaskInt(int prefixLength) 146 throws IllegalArgumentException { 147 if (prefixLength < 0 || prefixLength > 32) { 148 throw new IllegalArgumentException("Invalid prefix length (0 <= prefix <= 32)"); 149 } 150 int value = 0xffffffff << (32 - prefixLength); 151 return Integer.reverseBytes(value); 152 } 153 154 /** 155 * Convert a IPv4 netmask integer to a prefix length 156 * @param netmask as an integer in network byte order 157 * @return the network prefix length 158 */ netmaskIntToPrefixLength(int netmask)159 public static int netmaskIntToPrefixLength(int netmask) { 160 return Integer.bitCount(netmask); 161 } 162 163 /** 164 * Create an InetAddress from a string where the string must be a standard 165 * representation of a V4 or V6 address. Avoids doing a DNS lookup on failure 166 * but it will throw an IllegalArgumentException in that case. 167 * @param addrString 168 * @return the InetAddress 169 * @hide 170 */ numericToInetAddress(String addrString)171 public static InetAddress numericToInetAddress(String addrString) 172 throws IllegalArgumentException { 173 return InetAddress.parseNumericAddress(addrString); 174 } 175 176 /** 177 * Get InetAddress masked with prefixLength. Will never return null. 178 * @param IP address which will be masked with specified prefixLength 179 * @param prefixLength the prefixLength used to mask the IP 180 */ getNetworkPart(InetAddress address, int prefixLength)181 public static InetAddress getNetworkPart(InetAddress address, int prefixLength) { 182 if (address == null) { 183 throw new RuntimeException("getNetworkPart doesn't accept null address"); 184 } 185 186 byte[] array = address.getAddress(); 187 188 if (prefixLength < 0 || prefixLength > array.length * 8) { 189 throw new RuntimeException("getNetworkPart - bad prefixLength"); 190 } 191 192 int offset = prefixLength / 8; 193 int reminder = prefixLength % 8; 194 byte mask = (byte)(0xFF << (8 - reminder)); 195 196 if (offset < array.length) array[offset] = (byte)(array[offset] & mask); 197 198 offset++; 199 200 for (; offset < array.length; offset++) { 201 array[offset] = 0; 202 } 203 204 InetAddress netPart = null; 205 try { 206 netPart = InetAddress.getByAddress(array); 207 } catch (UnknownHostException e) { 208 throw new RuntimeException("getNetworkPart error - " + e.toString()); 209 } 210 return netPart; 211 } 212 213 /** 214 * Check if IP address type is consistent between two InetAddress. 215 * @return true if both are the same type. False otherwise. 216 */ addressTypeMatches(InetAddress left, InetAddress right)217 public static boolean addressTypeMatches(InetAddress left, InetAddress right) { 218 return (((left instanceof Inet4Address) && (right instanceof Inet4Address)) || 219 ((left instanceof Inet6Address) && (right instanceof Inet6Address))); 220 } 221 222 /** 223 * Convert a 32 char hex string into a Inet6Address. 224 * throws a runtime exception if the string isn't 32 chars, isn't hex or can't be 225 * made into an Inet6Address 226 * @param addrHexString a 32 character hex string representing an IPv6 addr 227 * @return addr an InetAddress representation for the string 228 */ hexToInet6Address(String addrHexString)229 public static InetAddress hexToInet6Address(String addrHexString) 230 throws IllegalArgumentException { 231 try { 232 return numericToInetAddress(String.format(Locale.US, "%s:%s:%s:%s:%s:%s:%s:%s", 233 addrHexString.substring(0,4), addrHexString.substring(4,8), 234 addrHexString.substring(8,12), addrHexString.substring(12,16), 235 addrHexString.substring(16,20), addrHexString.substring(20,24), 236 addrHexString.substring(24,28), addrHexString.substring(28,32))); 237 } catch (Exception e) { 238 Log.e("NetworkUtils", "error in hexToInet6Address(" + addrHexString + "): " + e); 239 throw new IllegalArgumentException(e); 240 } 241 } 242 243 /** 244 * Create a string array of host addresses from a collection of InetAddresses 245 * @param addrs a Collection of InetAddresses 246 * @return an array of Strings containing their host addresses 247 */ makeStrings(Collection<InetAddress> addrs)248 public static String[] makeStrings(Collection<InetAddress> addrs) { 249 String[] result = new String[addrs.size()]; 250 int i = 0; 251 for (InetAddress addr : addrs) { 252 result[i++] = addr.getHostAddress(); 253 } 254 return result; 255 } 256 257 /** 258 * Trim leading zeros from IPv4 address strings 259 * Our base libraries will interpret that as octel.. 260 * Must leave non v4 addresses and host names alone. 261 * For example, 192.168.000.010 -> 192.168.0.10 262 * TODO - fix base libraries and remove this function 263 * @param addr a string representing an ip addr 264 * @return a string propertly trimmed 265 */ trimV4AddrZeros(String addr)266 public static String trimV4AddrZeros(String addr) { 267 if (addr == null) return null; 268 String[] octets = addr.split("\\."); 269 if (octets.length != 4) return addr; 270 StringBuilder builder = new StringBuilder(16); 271 String result = null; 272 for (int i = 0; i < 4; i++) { 273 try { 274 if (octets[i].length() > 3) return addr; 275 builder.append(Integer.parseInt(octets[i])); 276 } catch (NumberFormatException e) { 277 return addr; 278 } 279 if (i < 3) builder.append('.'); 280 } 281 result = builder.toString(); 282 return result; 283 } 284 } 285