Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 0a56b25b authored by Remi NGUYEN VAN's avatar Remi NGUYEN VAN Committed by android-build-merger
Browse files

Merge "Add utils to convert Inet4Address <-> int" am: 5caebe34 am: 2595e681 

am: 004c3347

Change-Id: I8dac87304c9e7487715109b52fb8a43b948094e6
parents d4e9007e 004c3347

core/java/android/net/NetworkUtils.java

+90 −19
Original line number Diff line number Diff line
@@ -126,14 +126,36 @@ public class NetworkUtils { 
    public native static boolean queryUserAccess(int uid, int netId);



    /**

     * Convert a IPv4 address from an integer to an InetAddress.

     * @param hostAddress an int corresponding to the IPv4 address in network byte order

     * @see #intToInet4AddressHTL(int)

     * @deprecated Use either {@link #intToInet4AddressHTH(int)}

     *             or {@link #intToInet4AddressHTL(int)}

     */

    @Deprecated

    public static InetAddress intToInetAddress(int hostAddress) {

        byte[] addressBytes = { (byte)(0xff & hostAddress),

                                (byte)(0xff & (hostAddress >> 8)),

        return intToInet4AddressHTL(hostAddress);

    }



    /**

     * Convert a IPv4 address from an integer to an InetAddress (0x04030201 -> 1.2.3.4)

     *

     * <p>This method uses the higher-order int bytes as the lower-order IPv4 address bytes,

     * which is an unusual convention. Consider {@link #intToInet4AddressHTH(int)} instead.

     * @param hostAddress an int coding for an IPv4 address, where higher-order int byte is

     *                    lower-order IPv4 address byte

     */

    public static InetAddress intToInet4AddressHTL(int hostAddress) {

        return intToInet4AddressHTH(Integer.reverseBytes(hostAddress));

    }



    /**

     * Convert a IPv4 address from an integer to an InetAddress (0x01020304 -> 1.2.3.4)

     * @param hostAddress an int coding for an IPv4 address

     */

    public static InetAddress intToInet4AddressHTH(int hostAddress) {

        byte[] addressBytes = { (byte) (0xff & (hostAddress >> 24)),

                (byte) (0xff & (hostAddress >> 16)),

                                (byte)(0xff & (hostAddress >> 24)) };

                (byte) (0xff & (hostAddress >> 8)),

                (byte) (0xff & hostAddress) };



        try {

            return InetAddress.getByAddress(addressBytes);
@@ -143,34 +165,83 @@ public class NetworkUtils { 
    }



    /**

     * Convert a IPv4 address from an InetAddress to an integer

     * @param inetAddr is an InetAddress corresponding to the IPv4 address

     * @return the IP address as an integer in network byte order

     * @see #inet4AddressToIntHTL(Inet4Address)

     * @deprecated Use either {@link #inet4AddressToIntHTH(Inet4Address)}

     *             or {@link #inet4AddressToIntHTL(Inet4Address)}

     */

    @Deprecated

    public static int inetAddressToInt(Inet4Address inetAddr)

            throws IllegalArgumentException {

        return inet4AddressToIntHTL(inetAddr);

    }



    /**

     * Convert an IPv4 address from an InetAddress to an integer (1.2.3.4 -> 0x01020304)

     *

     * <p>This conversion can help order IP addresses: considering the ordering

     * 192.0.2.1 < 192.0.2.2 < ..., resulting ints will follow that ordering if read as unsigned

     * integers with {@link Integer#toUnsignedLong}.

     * @param inetAddr is an InetAddress corresponding to the IPv4 address

     * @return the IP address as integer

     */

    public static int inet4AddressToIntHTH(Inet4Address inetAddr)

            throws IllegalArgumentException {

        byte [] addr = inetAddr.getAddress();

        return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) |

                ((addr[1] & 0xff) << 8) | (addr[0] & 0xff);

        return ((addr[0] & 0xff) << 24) | ((addr[1] & 0xff) << 16)

                | ((addr[2] & 0xff) << 8) | (addr[3] & 0xff);

    }



    /**

     * Convert a IPv4 address from an InetAddress to an integer (1.2.3.4 -> 0x04030201)

     *

     * <p>This method stores the higher-order IPv4 address bytes in the lower-order int bytes,

     * which is an unusual convention. Consider {@link #inet4AddressToIntHTH(Inet4Address)} instead.

     * @param inetAddr is an InetAddress corresponding to the IPv4 address

     * @return the IP address as integer

     */

    public static int inet4AddressToIntHTL(Inet4Address inetAddr) {

        return Integer.reverseBytes(inet4AddressToIntHTH(inetAddr));

    }



    /**

     * Convert a network prefix length to an IPv4 netmask integer

     * @param prefixLength

     * @return the IPv4 netmask as an integer in network byte order

     * @see #prefixLengthToV4NetmaskIntHTL(int)

     * @deprecated Use either {@link #prefixLengthToV4NetmaskIntHTH(int)}

     *             or {@link #prefixLengthToV4NetmaskIntHTL(int)}

     */

    @Deprecated

    public static int prefixLengthToNetmaskInt(int prefixLength)

            throws IllegalArgumentException {

        return prefixLengthToV4NetmaskIntHTL(prefixLength);

    }



    /**

     * Convert a network prefix length to an IPv4 netmask integer (prefixLength 17 -> 0xffff8000)

     * @return the IPv4 netmask as an integer

     */

    public static int prefixLengthToV4NetmaskIntHTH(int prefixLength)

            throws IllegalArgumentException {

        if (prefixLength < 0 || prefixLength > 32) {

            throw new IllegalArgumentException("Invalid prefix length (0 <= prefix <= 32)");

        }

        int value = 0xffffffff << (32 - prefixLength);

        return Integer.reverseBytes(value);

        // (int)a << b is equivalent to a << (b & 0x1f): can't shift by 32 (-1 << 32 == -1)

        return prefixLength == 0 ? 0 : 0xffffffff << (32 - prefixLength);

    }



    /**

     * Convert a network prefix length to an IPv4 netmask integer (prefixLength 17 -> 0x0080ffff).

     *

     * <p>This method stores the higher-order IPv4 address bytes in the lower-order int bytes,

     * which is an unusual convention. Consider {@link #prefixLengthToV4NetmaskIntHTH(int)} instead.

     * @return the IPv4 netmask as an integer

     */

    public static int prefixLengthToV4NetmaskIntHTL(int prefixLength)

            throws IllegalArgumentException {

        return Integer.reverseBytes(prefixLengthToV4NetmaskIntHTH(prefixLength));

    }



    /**

     * Convert a IPv4 netmask integer to a prefix length

     * @param netmask as an integer in network byte order

     * @param netmask as an integer (0xff000000 for a /8 subnet)

     * @return the network prefix length

     */

    public static int netmaskIntToPrefixLength(int netmask) {

tests/net/java/android/net/NetworkUtilsTest.java

+123 −23
Original line number Diff line number Diff line
@@ -16,17 +16,32 @@ 


package android.net;



import android.net.NetworkUtils;

import android.test.suitebuilder.annotation.SmallTest;

import static android.net.NetworkUtils.getImplicitNetmask;

import static android.net.NetworkUtils.inet4AddressToIntHTH;

import static android.net.NetworkUtils.inet4AddressToIntHTL;

import static android.net.NetworkUtils.intToInet4AddressHTH;

import static android.net.NetworkUtils.intToInet4AddressHTL;

import static android.net.NetworkUtils.netmaskToPrefixLength;

import static android.net.NetworkUtils.prefixLengthToV4NetmaskIntHTH;

import static android.net.NetworkUtils.prefixLengthToV4NetmaskIntHTL;



import static junit.framework.Assert.assertEquals;



import static org.junit.Assert.fail;



import android.support.test.runner.AndroidJUnit4;



import java.math.BigInteger;

import java.net.Inet4Address;

import java.net.InetAddress;

import java.util.TreeSet;



import junit.framework.TestCase;

import org.junit.Test;

import org.junit.runner.RunWith;



public class NetworkUtilsTest extends TestCase {

@RunWith(AndroidJUnit4.class)

@android.support.test.filters.SmallTest

public class NetworkUtilsTest {



    private InetAddress Address(String addr) {

        return InetAddress.parseNumericAddress(addr);
@@ -36,41 +51,126 @@ public class NetworkUtilsTest extends TestCase { 
        return (Inet4Address) Address(addr);

    }



    @SmallTest

    @Test

    public void testGetImplicitNetmask() {

        assertEquals(8, NetworkUtils.getImplicitNetmask(IPv4Address("4.2.2.2")));

        assertEquals(8, NetworkUtils.getImplicitNetmask(IPv4Address("10.5.6.7")));

        assertEquals(16, NetworkUtils.getImplicitNetmask(IPv4Address("173.194.72.105")));

        assertEquals(16, NetworkUtils.getImplicitNetmask(IPv4Address("172.23.68.145")));

        assertEquals(24, NetworkUtils.getImplicitNetmask(IPv4Address("192.0.2.1")));

        assertEquals(24, NetworkUtils.getImplicitNetmask(IPv4Address("192.168.5.1")));

        assertEquals(32, NetworkUtils.getImplicitNetmask(IPv4Address("224.0.0.1")));

        assertEquals(32, NetworkUtils.getImplicitNetmask(IPv4Address("255.6.7.8")));

        assertEquals(8, getImplicitNetmask(IPv4Address("4.2.2.2")));

        assertEquals(8, getImplicitNetmask(IPv4Address("10.5.6.7")));

        assertEquals(16, getImplicitNetmask(IPv4Address("173.194.72.105")));

        assertEquals(16, getImplicitNetmask(IPv4Address("172.23.68.145")));

        assertEquals(24, getImplicitNetmask(IPv4Address("192.0.2.1")));

        assertEquals(24, getImplicitNetmask(IPv4Address("192.168.5.1")));

        assertEquals(32, getImplicitNetmask(IPv4Address("224.0.0.1")));

        assertEquals(32, getImplicitNetmask(IPv4Address("255.6.7.8")));

    }



    private void assertInvalidNetworkMask(Inet4Address addr) {

        try {

            NetworkUtils.netmaskToPrefixLength(addr);

            netmaskToPrefixLength(addr);

            fail("Invalid netmask " + addr.getHostAddress() + " did not cause exception");

        } catch (IllegalArgumentException expected) {

        }

    }



    @SmallTest

    @Test

    public void testInet4AddressToIntHTL() {

        assertEquals(0, inet4AddressToIntHTL(IPv4Address("0.0.0.0")));

        assertEquals(0x000080ff, inet4AddressToIntHTL(IPv4Address("255.128.0.0")));

        assertEquals(0x0080ff0a, inet4AddressToIntHTL(IPv4Address("10.255.128.0")));

        assertEquals(0x00feff0a, inet4AddressToIntHTL(IPv4Address("10.255.254.0")));

        assertEquals(0xfeffa8c0, inet4AddressToIntHTL(IPv4Address("192.168.255.254")));

        assertEquals(0xffffa8c0, inet4AddressToIntHTL(IPv4Address("192.168.255.255")));

    }



    @Test

    public void testIntToInet4AddressHTL() {

        assertEquals(IPv4Address("0.0.0.0"), intToInet4AddressHTL(0));

        assertEquals(IPv4Address("255.128.0.0"), intToInet4AddressHTL(0x000080ff));

        assertEquals(IPv4Address("10.255.128.0"), intToInet4AddressHTL(0x0080ff0a));

        assertEquals(IPv4Address("10.255.254.0"), intToInet4AddressHTL(0x00feff0a));

        assertEquals(IPv4Address("192.168.255.254"), intToInet4AddressHTL(0xfeffa8c0));

        assertEquals(IPv4Address("192.168.255.255"), intToInet4AddressHTL(0xffffa8c0));

    }



    @Test

    public void testInet4AddressToIntHTH() {

        assertEquals(0, inet4AddressToIntHTH(IPv4Address("0.0.0.0")));

        assertEquals(0xff800000, inet4AddressToIntHTH(IPv4Address("255.128.0.0")));

        assertEquals(0x0aff8000, inet4AddressToIntHTH(IPv4Address("10.255.128.0")));

        assertEquals(0x0afffe00, inet4AddressToIntHTH(IPv4Address("10.255.254.0")));

        assertEquals(0xc0a8fffe, inet4AddressToIntHTH(IPv4Address("192.168.255.254")));

        assertEquals(0xc0a8ffff, inet4AddressToIntHTH(IPv4Address("192.168.255.255")));

    }



    @Test

    public void testIntToInet4AddressHTH() {

        assertEquals(IPv4Address("0.0.0.0"), intToInet4AddressHTH(0));

        assertEquals(IPv4Address("255.128.0.0"), intToInet4AddressHTH(0xff800000));

        assertEquals(IPv4Address("10.255.128.0"), intToInet4AddressHTH(0x0aff8000));

        assertEquals(IPv4Address("10.255.254.0"), intToInet4AddressHTH(0x0afffe00));

        assertEquals(IPv4Address("192.168.255.254"), intToInet4AddressHTH(0xc0a8fffe));

        assertEquals(IPv4Address("192.168.255.255"), intToInet4AddressHTH(0xc0a8ffff));

    }



    @Test

    public void testNetmaskToPrefixLength() {

        assertEquals(0, NetworkUtils.netmaskToPrefixLength(IPv4Address("0.0.0.0")));

        assertEquals(9, NetworkUtils.netmaskToPrefixLength(IPv4Address("255.128.0.0")));

        assertEquals(17, NetworkUtils.netmaskToPrefixLength(IPv4Address("255.255.128.0")));

        assertEquals(23, NetworkUtils.netmaskToPrefixLength(IPv4Address("255.255.254.0")));

        assertEquals(31, NetworkUtils.netmaskToPrefixLength(IPv4Address("255.255.255.254")));

        assertEquals(32, NetworkUtils.netmaskToPrefixLength(IPv4Address("255.255.255.255")));

        assertEquals(0, netmaskToPrefixLength(IPv4Address("0.0.0.0")));

        assertEquals(9, netmaskToPrefixLength(IPv4Address("255.128.0.0")));

        assertEquals(17, netmaskToPrefixLength(IPv4Address("255.255.128.0")));

        assertEquals(23, netmaskToPrefixLength(IPv4Address("255.255.254.0")));

        assertEquals(31, netmaskToPrefixLength(IPv4Address("255.255.255.254")));

        assertEquals(32, netmaskToPrefixLength(IPv4Address("255.255.255.255")));



        assertInvalidNetworkMask(IPv4Address("0.0.0.1"));

        assertInvalidNetworkMask(IPv4Address("255.255.255.253"));

        assertInvalidNetworkMask(IPv4Address("255.255.0.255"));

    }



    @SmallTest



    @Test

    public void testPrefixLengthToV4NetmaskIntHTL() {

        assertEquals(0, prefixLengthToV4NetmaskIntHTL(0));

        assertEquals(0x000080ff /* 255.128.0.0 */, prefixLengthToV4NetmaskIntHTL(9));

        assertEquals(0x0080ffff /* 255.255.128.0 */, prefixLengthToV4NetmaskIntHTL(17));

        assertEquals(0x00feffff /* 255.255.254.0 */, prefixLengthToV4NetmaskIntHTL(23));

        assertEquals(0xfeffffff /* 255.255.255.254 */, prefixLengthToV4NetmaskIntHTL(31));

        assertEquals(0xffffffff /* 255.255.255.255 */, prefixLengthToV4NetmaskIntHTL(32));

    }



    @Test

    public void testPrefixLengthToV4NetmaskIntHTH() {

        assertEquals(0, prefixLengthToV4NetmaskIntHTH(0));

        assertEquals(0xff800000 /* 255.128.0.0 */, prefixLengthToV4NetmaskIntHTH(9));

        assertEquals(0xffff8000 /* 255.255.128.0 */, prefixLengthToV4NetmaskIntHTH(17));

        assertEquals(0xfffffe00 /* 255.255.254.0 */, prefixLengthToV4NetmaskIntHTH(23));

        assertEquals(0xfffffffe /* 255.255.255.254 */, prefixLengthToV4NetmaskIntHTH(31));

        assertEquals(0xffffffff /* 255.255.255.255 */, prefixLengthToV4NetmaskIntHTH(32));

    }



    @Test(expected = IllegalArgumentException.class)

    public void testPrefixLengthToV4NetmaskIntHTH_NegativeLength() {

        prefixLengthToV4NetmaskIntHTH(-1);

    }



    @Test(expected = IllegalArgumentException.class)

    public void testPrefixLengthToV4NetmaskIntHTH_LengthTooLarge() {

        prefixLengthToV4NetmaskIntHTH(33);

    }



    private void checkAddressMasking(String expectedAddr, String addr, int prefixLength) {

        final int prefix = prefixLengthToV4NetmaskIntHTH(prefixLength);

        final int addrInt = inet4AddressToIntHTH(IPv4Address(addr));

        assertEquals(IPv4Address(expectedAddr), intToInet4AddressHTH(prefix & addrInt));

    }



    @Test

    public void testPrefixLengthToV4NetmaskIntHTH_MaskAddr() {

        checkAddressMasking("192.168.0.0", "192.168.128.1", 16);

        checkAddressMasking("255.240.0.0", "255.255.255.255", 12);

        checkAddressMasking("255.255.255.255", "255.255.255.255", 32);

        checkAddressMasking("0.0.0.0", "255.255.255.255", 0);

    }



    @Test

    public void testRoutedIPv4AddressCount() {

        final TreeSet<IpPrefix> set = new TreeSet<>(IpPrefix.lengthComparator());

        // No routes routes to no addresses.
@@ -118,7 +218,7 @@ public class NetworkUtilsTest extends TestCase { 
        assertEquals(7l - 4 + 4 + 16 + 65536, NetworkUtils.routedIPv4AddressCount(set));

    }



    @SmallTest

    @Test

    public void testRoutedIPv6AddressCount() {

        final TreeSet<IpPrefix> set = new TreeSet<>(IpPrefix.lengthComparator());

        // No routes routes to no addresses.