1 /* 2 * Copyright (C) 2019 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.shared; 18 19 import java.net.Inet4Address; 20 import java.net.InetAddress; 21 import java.net.UnknownHostException; 22 23 /** 24 * Collection of utilities to work with IPv4 addresses. 25 * @hide 26 */ 27 public class Inet4AddressUtils { 28 29 /** 30 * Convert a IPv4 address from an integer to an InetAddress (0x04030201 -> 1.2.3.4) 31 * 32 * <p>This method uses the higher-order int bytes as the lower-order IPv4 address bytes, 33 * which is an unusual convention. Consider {@link #intToInet4AddressHTH(int)} instead. 34 * @param hostAddress an int coding for an IPv4 address, where higher-order int byte is 35 * lower-order IPv4 address byte 36 */ intToInet4AddressHTL(int hostAddress)37 public static Inet4Address intToInet4AddressHTL(int hostAddress) { 38 return intToInet4AddressHTH(Integer.reverseBytes(hostAddress)); 39 } 40 41 /** 42 * Convert a IPv4 address from an integer to an InetAddress (0x01020304 -> 1.2.3.4) 43 * @param hostAddress an int coding for an IPv4 address 44 */ intToInet4AddressHTH(int hostAddress)45 public static Inet4Address intToInet4AddressHTH(int hostAddress) { 46 byte[] addressBytes = { (byte) (0xff & (hostAddress >> 24)), 47 (byte) (0xff & (hostAddress >> 16)), 48 (byte) (0xff & (hostAddress >> 8)), 49 (byte) (0xff & hostAddress) }; 50 51 try { 52 return (Inet4Address) InetAddress.getByAddress(addressBytes); 53 } catch (UnknownHostException e) { 54 throw new AssertionError(); 55 } 56 } 57 58 /** 59 * Convert an IPv4 address from an InetAddress to an integer (1.2.3.4 -> 0x01020304) 60 * 61 * <p>This conversion can help order IP addresses: considering the ordering 62 * 192.0.2.1 < 192.0.2.2 < ..., resulting ints will follow that ordering if read as unsigned 63 * integers with {@link Integer#toUnsignedLong}. 64 * @param inetAddr is an InetAddress corresponding to the IPv4 address 65 * @return the IP address as integer 66 */ inet4AddressToIntHTH(Inet4Address inetAddr)67 public static int inet4AddressToIntHTH(Inet4Address inetAddr) 68 throws IllegalArgumentException { 69 byte [] addr = inetAddr.getAddress(); 70 return ((addr[0] & 0xff) << 24) | ((addr[1] & 0xff) << 16) 71 | ((addr[2] & 0xff) << 8) | (addr[3] & 0xff); 72 } 73 74 /** 75 * Convert a IPv4 address from an InetAddress to an integer (1.2.3.4 -> 0x04030201) 76 * 77 * <p>This method stores the higher-order IPv4 address bytes in the lower-order int bytes, 78 * which is an unusual convention. Consider {@link #inet4AddressToIntHTH(Inet4Address)} instead. 79 * @param inetAddr is an InetAddress corresponding to the IPv4 address 80 * @return the IP address as integer 81 */ inet4AddressToIntHTL(Inet4Address inetAddr)82 public static int inet4AddressToIntHTL(Inet4Address inetAddr) { 83 return Integer.reverseBytes(inet4AddressToIntHTH(inetAddr)); 84 } 85 86 /** 87 * Convert a network prefix length to an IPv4 netmask integer (prefixLength 17 -> 0xffff8000) 88 * @return the IPv4 netmask as an integer 89 */ prefixLengthToV4NetmaskIntHTH(int prefixLength)90 public static int prefixLengthToV4NetmaskIntHTH(int prefixLength) 91 throws IllegalArgumentException { 92 if (prefixLength < 0 || prefixLength > 32) { 93 throw new IllegalArgumentException("Invalid prefix length (0 <= prefix <= 32)"); 94 } 95 // (int)a << b is equivalent to a << (b & 0x1f): can't shift by 32 (-1 << 32 == -1) 96 return prefixLength == 0 ? 0 : 0xffffffff << (32 - prefixLength); 97 } 98 99 /** 100 * Convert a network prefix length to an IPv4 netmask integer (prefixLength 17 -> 0x0080ffff). 101 * 102 * <p>This method stores the higher-order IPv4 address bytes in the lower-order int bytes, 103 * which is an unusual convention. Consider {@link #prefixLengthToV4NetmaskIntHTH(int)} instead. 104 * @return the IPv4 netmask as an integer 105 */ prefixLengthToV4NetmaskIntHTL(int prefixLength)106 public static int prefixLengthToV4NetmaskIntHTL(int prefixLength) 107 throws IllegalArgumentException { 108 return Integer.reverseBytes(prefixLengthToV4NetmaskIntHTH(prefixLength)); 109 } 110 111 /** 112 * Convert an IPv4 netmask to a prefix length, checking that the netmask is contiguous. 113 * @param netmask as a {@code Inet4Address}. 114 * @return the network prefix length 115 * @throws IllegalArgumentException the specified netmask was not contiguous. 116 * @hide 117 */ netmaskToPrefixLength(Inet4Address netmask)118 public static int netmaskToPrefixLength(Inet4Address netmask) { 119 // inetAddressToInt returns an int in *network* byte order. 120 int i = inet4AddressToIntHTH(netmask); 121 int prefixLength = Integer.bitCount(i); 122 int trailingZeros = Integer.numberOfTrailingZeros(i); 123 if (trailingZeros != 32 - prefixLength) { 124 throw new IllegalArgumentException("Non-contiguous netmask: " + Integer.toHexString(i)); 125 } 126 return prefixLength; 127 } 128 129 /** 130 * Returns the implicit netmask of an IPv4 address, as was the custom before 1993. 131 */ getImplicitNetmask(Inet4Address address)132 public static int getImplicitNetmask(Inet4Address address) { 133 int firstByte = address.getAddress()[0] & 0xff; // Convert to an unsigned value. 134 if (firstByte < 128) { 135 return 8; 136 } else if (firstByte < 192) { 137 return 16; 138 } else if (firstByte < 224) { 139 return 24; 140 } else { 141 return 32; // Will likely not end well for other reasons. 142 } 143 } 144 145 /** 146 * Get the broadcast address for a given prefix. 147 * 148 * <p>For example 192.168.0.1/24 -> 192.168.0.255 149 */ getBroadcastAddress(Inet4Address addr, int prefixLength)150 public static Inet4Address getBroadcastAddress(Inet4Address addr, int prefixLength) 151 throws IllegalArgumentException { 152 final int intBroadcastAddr = inet4AddressToIntHTH(addr) 153 | ~prefixLengthToV4NetmaskIntHTH(prefixLength); 154 return intToInet4AddressHTH(intBroadcastAddr); 155 } 156 157 /** 158 * Get a prefix mask as Inet4Address for a given prefix length. 159 * 160 * <p>For example 20 -> 255.255.240.0 161 */ getPrefixMaskAsInet4Address(int prefixLength)162 public static Inet4Address getPrefixMaskAsInet4Address(int prefixLength) 163 throws IllegalArgumentException { 164 return intToInet4AddressHTH(prefixLengthToV4NetmaskIntHTH(prefixLength)); 165 } 166 } 167