Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Move NetworkUtils used by NetworkStack"

Browse Source
This commit is contained in:
Remi NGUYEN VAN
2019-01-28 09:06:20 +00:00
committed by Gerrit Code Review
parent 375b3c075d e88516f13b
commit b8bbc48dee
15 changed files with 469 additions and 349 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
Android.bp
View File

@@ -852,6 +852,27 @@ aidl_interface {
api_dir: "aidl/networkstack",
}
filegroup {
name: "framework-networkstack-shared-srcs",
srcs: [
// TODO: remove these annotations as soon as we can use andoid.support.annotations.*
"core/java/android/annotation/NonNull.java",
"core/java/android/annotation/Nullable.java",
"core/java/android/annotation/IntDef.java",
"core/java/android/annotation/UnsupportedAppUsage.java",
"core/java/android/util/LocalLog.java",
"core/java/com/android/internal/annotations/VisibleForTesting.java",
"core/java/com/android/internal/util/HexDump.java",
"core/java/com/android/internal/util/IState.java",
"core/java/com/android/internal/util/MessageUtils.java",
"core/java/com/android/internal/util/Preconditions.java",
"core/java/com/android/internal/util/State.java",
"core/java/com/android/internal/util/StateMachine.java",
"core/java/com/android/internal/util/WakeupMessage.java",
"core/java/android/net/shared/*.java",
]
}
// Build ext.jar
// ============================================================
java_library {

156
core/java/android/net/NetworkUtils.java
View File

@@ -17,8 +17,10 @@
package android.net;
import android.annotation.UnsupportedAppUsage;
import android.net.shared.Inet4AddressUtils;
import android.os.Build;
import android.os.Parcel;
import android.system.ErrnoException;
import android.util.Log;
import android.util.Pair;
@@ -34,8 +36,6 @@ import java.util.Collection;
import java.util.Locale;
import java.util.TreeSet;
import android.system.ErrnoException;
/**
* Native methods for managing network interfaces.
*
@@ -172,119 +172,37 @@ public class NetworkUtils {
FileDescriptor fd) throws IOException;
/**
* @see #intToInet4AddressHTL(int)
* @deprecated Use either {@link #intToInet4AddressHTH(int)}
* or {@link #intToInet4AddressHTL(int)}
* @see Inet4AddressUtils#intToInet4AddressHTL(int)
* @deprecated Use either {@link Inet4AddressUtils#intToInet4AddressHTH(int)}
* or {@link Inet4AddressUtils#intToInet4AddressHTL(int)}
*/
@Deprecated
@UnsupportedAppUsage
public static InetAddress intToInetAddress(int hostAddress) {
return intToInet4AddressHTL(hostAddress);
return Inet4AddressUtils.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 Inet4Address 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 Inet4Address intToInet4AddressHTH(int hostAddress) {
byte[] addressBytes = { (byte) (0xff & (hostAddress >> 24)),
(byte) (0xff & (hostAddress >> 16)),
(byte) (0xff & (hostAddress >> 8)),
(byte) (0xff & hostAddress) };
try {
return (Inet4Address) InetAddress.getByAddress(addressBytes);
} catch (UnknownHostException e) {
throw new AssertionError();
}
}
/**
* @see #inet4AddressToIntHTL(Inet4Address)
* @deprecated Use either {@link #inet4AddressToIntHTH(Inet4Address)}
* or {@link #inet4AddressToIntHTL(Inet4Address)}
* @see Inet4AddressUtils#inet4AddressToIntHTL(Inet4Address)
* @deprecated Use either {@link Inet4AddressUtils#inet4AddressToIntHTH(Inet4Address)}
* or {@link Inet4AddressUtils#inet4AddressToIntHTL(Inet4Address)}
*/
@Deprecated
public static int inetAddressToInt(Inet4Address inetAddr)
throws IllegalArgumentException {
return inet4AddressToIntHTL(inetAddr);
return Inet4AddressUtils.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[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));
}
/**
* @see #prefixLengthToV4NetmaskIntHTL(int)
* @deprecated Use either {@link #prefixLengthToV4NetmaskIntHTH(int)}
* or {@link #prefixLengthToV4NetmaskIntHTL(int)}
* @see Inet4AddressUtils#prefixLengthToV4NetmaskIntHTL(int)
* @deprecated Use either {@link Inet4AddressUtils#prefixLengthToV4NetmaskIntHTH(int)}
* or {@link Inet4AddressUtils#prefixLengthToV4NetmaskIntHTL(int)}
*/
@Deprecated
@UnsupportedAppUsage
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)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));
return Inet4AddressUtils.prefixLengthToV4NetmaskIntHTL(prefixLength);
}
/**
@@ -302,17 +220,13 @@ public class NetworkUtils {
* @return the network prefix length
* @throws IllegalArgumentException the specified netmask was not contiguous.
* @hide
* @deprecated use {@link Inet4AddressUtils#netmaskToPrefixLength(Inet4Address)}
*/
@UnsupportedAppUsage
@Deprecated
public static int netmaskToPrefixLength(Inet4Address netmask) {
// inetAddressToInt returns an int in *network* byte order.
int i = Integer.reverseBytes(inetAddressToInt(netmask));
int prefixLength = Integer.bitCount(i);
int trailingZeros = Integer.numberOfTrailingZeros(i);
if (trailingZeros != 32 - prefixLength) {
throw new IllegalArgumentException("Non-contiguous netmask: " + Integer.toHexString(i));
}
return prefixLength;
// This is only here because some apps seem to be using it (@UnsupportedAppUsage).
return Inet4AddressUtils.netmaskToPrefixLength(netmask);
}
@@ -403,16 +317,8 @@ public class NetworkUtils {
*/
@UnsupportedAppUsage
public static int getImplicitNetmask(Inet4Address address) {
int firstByte = address.getAddress()[0] & 0xff; // Convert to an unsigned value.
if (firstByte < 128) {
return 8;
} else if (firstByte < 192) {
return 16;
} else if (firstByte < 224) {
return 24;
} else {
return 32; // Will likely not end well for other reasons.
}
// Only here because it seems to be used by apps
return Inet4AddressUtils.getImplicitNetmask(address);
}
/**
@@ -439,28 +345,6 @@ public class NetworkUtils {
return new Pair<InetAddress, Integer>(address, prefixLength);
}
/**
* Get a prefix mask as Inet4Address for a given prefix length.
*
* <p>For example 20 -> 255.255.240.0
*/
public static Inet4Address getPrefixMaskAsInet4Address(int prefixLength)
throws IllegalArgumentException {
return intToInet4AddressHTH(prefixLengthToV4NetmaskIntHTH(prefixLength));
}
/**
* Get the broadcast address for a given prefix.
*
* <p>For example 192.168.0.1/24 -> 192.168.0.255
*/
public static Inet4Address getBroadcastAddress(Inet4Address addr, int prefixLength)
throws IllegalArgumentException {
final int intBroadcastAddr = inet4AddressToIntHTH(addr)
| ~prefixLengthToV4NetmaskIntHTH(prefixLength);
return intToInet4AddressHTH(intBroadcastAddr);
}
/**
* Check if IP address type is consistent between two InetAddress.
* @return true if both are the same type. False otherwise.

166
core/java/android/net/shared/Inet4AddressUtils.java Normal file
View File

@@ -0,0 +1,166 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.net.shared;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* Collection of utilities to work with IPv4 addresses.
* @hide
*/
public class Inet4AddressUtils {
/**
* 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 Inet4Address 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 Inet4Address intToInet4AddressHTH(int hostAddress) {
byte[] addressBytes = { (byte) (0xff & (hostAddress >> 24)),
(byte) (0xff & (hostAddress >> 16)),
(byte) (0xff & (hostAddress >> 8)),
(byte) (0xff & hostAddress) };
try {
return (Inet4Address) InetAddress.getByAddress(addressBytes);
} catch (UnknownHostException e) {
throw new AssertionError();
}
}
/**
* 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[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 (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)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 an IPv4 netmask to a prefix length, checking that the netmask is contiguous.
* @param netmask as a {@code Inet4Address}.
* @return the network prefix length
* @throws IllegalArgumentException the specified netmask was not contiguous.
* @hide
*/
public static int netmaskToPrefixLength(Inet4Address netmask) {
// inetAddressToInt returns an int in *network* byte order.
int i = inet4AddressToIntHTH(netmask);
int prefixLength = Integer.bitCount(i);
int trailingZeros = Integer.numberOfTrailingZeros(i);
if (trailingZeros != 32 - prefixLength) {
throw new IllegalArgumentException("Non-contiguous netmask: " + Integer.toHexString(i));
}
return prefixLength;
}
/**
* Returns the implicit netmask of an IPv4 address, as was the custom before 1993.
*/
public static int getImplicitNetmask(Inet4Address address) {
int firstByte = address.getAddress()[0] & 0xff; // Convert to an unsigned value.
if (firstByte < 128) {
return 8;
} else if (firstByte < 192) {
return 16;
} else if (firstByte < 224) {
return 24;
} else {
return 32; // Will likely not end well for other reasons.
}
}
/**
* Get the broadcast address for a given prefix.
*
* <p>For example 192.168.0.1/24 -> 192.168.0.255
*/
public static Inet4Address getBroadcastAddress(Inet4Address addr, int prefixLength)
throws IllegalArgumentException {
final int intBroadcastAddr = inet4AddressToIntHTH(addr)
| ~prefixLengthToV4NetmaskIntHTH(prefixLength);
return intToInet4AddressHTH(intBroadcastAddr);
}
/**
* Get a prefix mask as Inet4Address for a given prefix length.
*
* <p>For example 20 -> 255.255.240.0
*/
public static Inet4Address getPrefixMaskAsInet4Address(int prefixLength)
throws IllegalArgumentException {
return intToInet4AddressHTH(prefixLengthToV4NetmaskIntHTH(prefixLength));
}
}

1
packages/NetworkStack/Android.bp
View File

@@ -21,6 +21,7 @@ java_library {
installable: true,
srcs: [
"src/**/*.java",
":framework-networkstack-shared-srcs",
":services-networkstack-shared-srcs",
],
static_libs: [

6
packages/NetworkStack/src/android/net/dhcp/DhcpLeaseRepository.java
View File

@@ -16,11 +16,11 @@
package android.net.dhcp;
import static android.net.NetworkUtils.inet4AddressToIntHTH;
import static android.net.NetworkUtils.intToInet4AddressHTH;
import static android.net.NetworkUtils.prefixLengthToV4NetmaskIntHTH;
import static android.net.dhcp.DhcpLease.EXPIRATION_NEVER;
import static android.net.dhcp.DhcpLease.inet4AddrToString;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTH;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import static android.net.shared.Inet4AddressUtils.prefixLengthToV4NetmaskIntHTH;
import static com.android.server.util.NetworkStackConstants.IPV4_ADDR_BITS;

6
packages/NetworkStack/src/android/net/dhcp/DhcpPacket.java
View File

@@ -3,8 +3,8 @@ package android.net.dhcp;
import android.annotation.Nullable;
import android.net.DhcpResults;
import android.net.LinkAddress;
import android.net.NetworkUtils;
import android.net.metrics.DhcpErrorEvent;
import android.net.shared.Inet4AddressUtils;
import android.os.Build;
import android.os.SystemProperties;
import android.system.OsConstants;
@@ -1222,13 +1222,13 @@ public abstract class DhcpPacket {
int prefixLength;
if (mSubnetMask != null) {
try {
prefixLength = NetworkUtils.netmaskToPrefixLength(mSubnetMask);
prefixLength = Inet4AddressUtils.netmaskToPrefixLength(mSubnetMask);
} catch (IllegalArgumentException e) {
// Non-contiguous netmask.
return null;
}
} else {
prefixLength = NetworkUtils.getImplicitNetmask(ipAddress);
prefixLength = Inet4AddressUtils.getImplicitNetmask(ipAddress);
}
DhcpResults results = new DhcpResults();

4
packages/NetworkStack/src/android/net/dhcp/DhcpServer.java
View File

@@ -16,8 +16,6 @@
package android.net.dhcp;
import static android.net.NetworkUtils.getBroadcastAddress;
import static android.net.NetworkUtils.getPrefixMaskAsInet4Address;
import static android.net.TrafficStats.TAG_SYSTEM_DHCP_SERVER;
import static android.net.dhcp.DhcpPacket.DHCP_CLIENT;
import static android.net.dhcp.DhcpPacket.DHCP_HOST_NAME;
@@ -25,6 +23,8 @@ import static android.net.dhcp.DhcpPacket.DHCP_SERVER;
import static android.net.dhcp.DhcpPacket.ENCAP_BOOTP;
import static android.net.dhcp.IDhcpServer.STATUS_INVALID_ARGUMENT;
import static android.net.dhcp.IDhcpServer.STATUS_SUCCESS;
import static android.net.shared.Inet4AddressUtils.getBroadcastAddress;
import static android.net.shared.Inet4AddressUtils.getPrefixMaskAsInet4Address;
import static android.system.OsConstants.AF_INET;
import static android.system.OsConstants.IPPROTO_UDP;
import static android.system.OsConstants.SOCK_DGRAM;

9
packages/NetworkStack/src/android/net/dhcp/DhcpServingParams.java
View File

@@ -16,8 +16,8 @@
package android.net.dhcp;
import static android.net.NetworkUtils.getPrefixMaskAsInet4Address;
import static android.net.NetworkUtils.intToInet4AddressHTH;
import static android.net.shared.Inet4AddressUtils.getPrefixMaskAsInet4Address;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import static com.android.server.util.NetworkStackConstants.INFINITE_LEASE;
import static com.android.server.util.NetworkStackConstants.IPV4_MAX_MTU;
@@ -29,7 +29,7 @@ import android.annotation.NonNull;
import android.annotation.Nullable;
import android.net.IpPrefix;
import android.net.LinkAddress;
import android.net.NetworkUtils;
import android.net.shared.Inet4AddressUtils;
import android.util.ArraySet;
import java.net.Inet4Address;
@@ -164,7 +164,8 @@ public class DhcpServingParams {
*/
@NonNull
public Inet4Address getBroadcastAddress() {
return NetworkUtils.getBroadcastAddress(getServerInet4Addr(), serverAddr.getPrefixLength());
return Inet4AddressUtils.getBroadcastAddress(
getServerInet4Addr(), serverAddr.getPrefixLength());
}
/**

34
packages/NetworkStack/tests/src/android/net/dhcp/DhcpPacketTest.java
View File

@@ -16,9 +16,27 @@
package android.net.dhcp;
import static android.net.NetworkUtils.getBroadcastAddress;
import static android.net.NetworkUtils.getPrefixMaskAsInet4Address;
import static android.net.dhcp.DhcpPacket.*;
import static android.net.dhcp.DhcpPacket.DHCP_BROADCAST_ADDRESS;
import static android.net.dhcp.DhcpPacket.DHCP_DNS_SERVER;
import static android.net.dhcp.DhcpPacket.DHCP_DOMAIN_NAME;
import static android.net.dhcp.DhcpPacket.DHCP_LEASE_TIME;
import static android.net.dhcp.DhcpPacket.DHCP_MESSAGE_TYPE_ACK;
import static android.net.dhcp.DhcpPacket.DHCP_MESSAGE_TYPE_OFFER;
import static android.net.dhcp.DhcpPacket.DHCP_MTU;
import static android.net.dhcp.DhcpPacket.DHCP_REBINDING_TIME;
import static android.net.dhcp.DhcpPacket.DHCP_RENEWAL_TIME;
import static android.net.dhcp.DhcpPacket.DHCP_ROUTER;
import static android.net.dhcp.DhcpPacket.DHCP_SUBNET_MASK;
import static android.net.dhcp.DhcpPacket.DHCP_VENDOR_INFO;
import static android.net.dhcp.DhcpPacket.ENCAP_BOOTP;
import static android.net.dhcp.DhcpPacket.ENCAP_L2;
import static android.net.dhcp.DhcpPacket.ENCAP_L3;
import static android.net.dhcp.DhcpPacket.INADDR_ANY;
import static android.net.dhcp.DhcpPacket.INFINITE_LEASE;
import static android.net.dhcp.DhcpPacket.ParseException;
import static android.net.shared.Inet4AddressUtils.getBroadcastAddress;
import static android.net.shared.Inet4AddressUtils.getPrefixMaskAsInet4Address;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
@@ -30,11 +48,15 @@ import android.net.DhcpResults;
import android.net.LinkAddress;
import android.net.NetworkUtils;
import android.net.metrics.DhcpErrorEvent;
import android.support.test.runner.AndroidJUnit4;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
import com.android.internal.util.HexDump;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.io.ByteArrayOutputStream;
import java.net.Inet4Address;
import java.nio.ByteBuffer;
@@ -44,10 +66,6 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Random;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@RunWith(AndroidJUnit4.class)
@SmallTest
public class DhcpPacketTest {

6
packages/NetworkStack/tests/src/android/net/dhcp/DhcpServingParamsTest.java
View File

@@ -17,8 +17,8 @@
package android.net.dhcp;
import static android.net.InetAddresses.parseNumericAddress;
import static android.net.NetworkUtils.inet4AddressToIntHTH;
import static android.net.dhcp.DhcpServingParams.MTU_UNSET;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTH;
import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertFalse;
@@ -27,8 +27,8 @@ import static junit.framework.Assert.assertTrue;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.net.LinkAddress;
import android.net.NetworkUtils;
import android.net.dhcp.DhcpServingParams.InvalidParameterException;
import android.net.shared.Inet4AddressUtils;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
@@ -200,7 +200,7 @@ public class DhcpServingParamsTest {
}
private static int[] toIntArray(Collection<Inet4Address> addrs) {
return addrs.stream().mapToInt(NetworkUtils::inet4AddressToIntHTH).toArray();
return addrs.stream().mapToInt(Inet4AddressUtils::inet4AddressToIntHTH).toArray();
}
private static <T> void assertContains(@NonNull Set<T> set, @NonNull Set<T> subset) {

8
services/ipmemorystore/java/com/android/server/net/ipmemorystore/IpMemoryStoreDatabase.java
View File

@@ -16,6 +16,9 @@
package com.android.server.net.ipmemorystore;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTH;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import android.annotation.NonNull;
import android.annotation.Nullable;
import android.content.ContentValues;
@@ -27,7 +30,6 @@ import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.database.sqlite.SQLiteOpenHelper;
import android.database.sqlite.SQLiteQuery;
import android.net.NetworkUtils;
import android.net.ipmemorystore.NetworkAttributes;
import android.net.ipmemorystore.Status;
import android.util.Log;
@@ -200,7 +202,7 @@ public class IpMemoryStoreDatabase {
if (null == attributes) return values;
if (null != attributes.assignedV4Address) {
values.put(NetworkAttributesContract.COLNAME_ASSIGNEDV4ADDRESS,
NetworkUtils.inet4AddressToIntHTH(attributes.assignedV4Address));
inet4AddressToIntHTH(attributes.assignedV4Address));
}
if (null != attributes.groupHint) {
values.put(NetworkAttributesContract.COLNAME_GROUPHINT, attributes.groupHint);
@@ -254,7 +256,7 @@ public class IpMemoryStoreDatabase {
getBlob(cursor, NetworkAttributesContract.COLNAME_DNSADDRESSES);
final int mtu = getInt(cursor, NetworkAttributesContract.COLNAME_MTU, -1);
if (0 != assignedV4AddressInt) {
builder.setAssignedV4Address(NetworkUtils.intToInet4AddressHTH(assignedV4AddressInt));
builder.setAssignedV4Address(intToInet4AddressHTH(assignedV4AddressInt));
}
builder.setGroupHint(groupHint);
if (null != dnsAddressesBlob) {

2
services/net/java/android/net/dhcp/DhcpServingParamsParcelExt.java
View File

@@ -16,7 +16,7 @@
package android.net.dhcp;
import static android.net.NetworkUtils.inet4AddressToIntHTH;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTH;
import android.annotation.NonNull;
import android.net.LinkAddress;

188
tests/net/java/android/net/NetworkUtilsTest.java
View File

@@ -16,161 +16,19 @@
package android.net;
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 android.net.NetworkUtils.getBroadcastAddress;
import static android.net.NetworkUtils.getPrefixMaskAsInet4Address;
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 org.junit.Test;
import org.junit.runner.RunWith;
import java.math.BigInteger;
import java.util.TreeSet;
@RunWith(AndroidJUnit4.class)
@android.support.test.filters.SmallTest
public class NetworkUtilsTest {
private InetAddress Address(String addr) {
return InetAddress.parseNumericAddress(addr);
}
private Inet4Address IPv4Address(String addr) {
return (Inet4Address) Address(addr);
}
@Test
public void testGetImplicitNetmask() {
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 {
netmaskToPrefixLength(addr);
fail("Invalid netmask " + addr.getHostAddress() + " did not cause exception");
} catch (IllegalArgumentException expected) {
}
}
@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, 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"));
}
@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());
@@ -267,44 +125,4 @@ public class NetworkUtilsTest {
assertEquals(BigInteger.valueOf(7l - 4 + 4 + 16 + 65536),
NetworkUtils.routedIPv6AddressCount(set));
}
@Test
public void testGetPrefixMaskAsAddress() {
assertEquals("255.255.240.0", getPrefixMaskAsInet4Address(20).getHostAddress());
assertEquals("255.0.0.0", getPrefixMaskAsInet4Address(8).getHostAddress());
assertEquals("0.0.0.0", getPrefixMaskAsInet4Address(0).getHostAddress());
assertEquals("255.255.255.255", getPrefixMaskAsInet4Address(32).getHostAddress());
}
@Test(expected = IllegalArgumentException.class)
public void testGetPrefixMaskAsAddress_PrefixTooLarge() {
getPrefixMaskAsInet4Address(33);
}
@Test(expected = IllegalArgumentException.class)
public void testGetPrefixMaskAsAddress_NegativePrefix() {
getPrefixMaskAsInet4Address(-1);
}
@Test
public void testGetBroadcastAddress() {
assertEquals("192.168.15.255",
getBroadcastAddress(IPv4Address("192.168.0.123"), 20).getHostAddress());
assertEquals("192.255.255.255",
getBroadcastAddress(IPv4Address("192.168.0.123"), 8).getHostAddress());
assertEquals("192.168.0.123",
getBroadcastAddress(IPv4Address("192.168.0.123"), 32).getHostAddress());
assertEquals("255.255.255.255",
getBroadcastAddress(IPv4Address("192.168.0.123"), 0).getHostAddress());
}
@Test(expected = IllegalArgumentException.class)
public void testGetBroadcastAddress_PrefixTooLarge() {
getBroadcastAddress(IPv4Address("192.168.0.123"), 33);
}
@Test(expected = IllegalArgumentException.class)
public void testGetBroadcastAddress_NegativePrefix() {
getBroadcastAddress(IPv4Address("192.168.0.123"), -1);
}
}

2
tests/net/java/android/net/ip/IpServerTest.java
View File

@@ -22,11 +22,11 @@ import static android.net.ConnectivityManager.TETHERING_WIFI;
import static android.net.ConnectivityManager.TETHER_ERROR_ENABLE_NAT_ERROR;
import static android.net.ConnectivityManager.TETHER_ERROR_NO_ERROR;
import static android.net.ConnectivityManager.TETHER_ERROR_TETHER_IFACE_ERROR;
import static android.net.NetworkUtils.intToInet4AddressHTH;
import static android.net.dhcp.IDhcpServer.STATUS_SUCCESS;
import static android.net.ip.IpServer.STATE_AVAILABLE;
import static android.net.ip.IpServer.STATE_TETHERED;
import static android.net.ip.IpServer.STATE_UNAVAILABLE;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

209
tests/net/java/android/net/shared/Inet4AddressUtilsTest.java Normal file
View File

@@ -0,0 +1,209 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package android.net.shared;
import static android.net.shared.Inet4AddressUtils.getBroadcastAddress;
import static android.net.shared.Inet4AddressUtils.getImplicitNetmask;
import static android.net.shared.Inet4AddressUtils.getPrefixMaskAsInet4Address;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTH;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTL;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTL;
import static android.net.shared.Inet4AddressUtils.netmaskToPrefixLength;
import static android.net.shared.Inet4AddressUtils.prefixLengthToV4NetmaskIntHTH;
import static android.net.shared.Inet4AddressUtils.prefixLengthToV4NetmaskIntHTL;
import static junit.framework.Assert.assertEquals;
import static org.junit.Assert.fail;
import android.net.InetAddresses;
import android.support.test.filters.SmallTest;
import android.support.test.runner.AndroidJUnit4;
import org.junit.Test;
import org.junit.runner.RunWith;
import java.net.Inet4Address;
@RunWith(AndroidJUnit4.class)
@SmallTest
public class Inet4AddressUtilsTest {
@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 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 testGetImplicitNetmask() {
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 {
netmaskToPrefixLength(addr);
fail("Invalid netmask " + addr.getHostAddress() + " did not cause exception");
} catch (IllegalArgumentException expected) {
}
}
@Test
public void testNetmaskToPrefixLength() {
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"));
}
@Test
public void testGetPrefixMaskAsAddress() {
assertEquals("255.255.240.0", getPrefixMaskAsInet4Address(20).getHostAddress());
assertEquals("255.0.0.0", getPrefixMaskAsInet4Address(8).getHostAddress());
assertEquals("0.0.0.0", getPrefixMaskAsInet4Address(0).getHostAddress());
assertEquals("255.255.255.255", getPrefixMaskAsInet4Address(32).getHostAddress());
}
@Test
public void testGetBroadcastAddress() {
assertEquals("192.168.15.255",
getBroadcastAddress(ipv4Address("192.168.0.123"), 20).getHostAddress());
assertEquals("192.255.255.255",
getBroadcastAddress(ipv4Address("192.168.0.123"), 8).getHostAddress());
assertEquals("192.168.0.123",
getBroadcastAddress(ipv4Address("192.168.0.123"), 32).getHostAddress());
assertEquals("255.255.255.255",
getBroadcastAddress(ipv4Address("192.168.0.123"), 0).getHostAddress());
}
@Test(expected = IllegalArgumentException.class)
public void testGetBroadcastAddress_PrefixTooLarge() {
getBroadcastAddress(ipv4Address("192.168.0.123"), 33);
}
@Test(expected = IllegalArgumentException.class)
public void testGetBroadcastAddress_NegativePrefix() {
getBroadcastAddress(ipv4Address("192.168.0.123"), -1);
}
@Test(expected = IllegalArgumentException.class)
public void testGetPrefixMaskAsAddress_PrefixTooLarge() {
getPrefixMaskAsInet4Address(33);
}
@Test(expected = IllegalArgumentException.class)
public void testGetPrefixMaskAsAddress_NegativePrefix() {
getPrefixMaskAsInet4Address(-1);
}
private Inet4Address ipv4Address(String addr) {
return (Inet4Address) InetAddresses.parseNumericAddress(addr);
}
}