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