drgreen/android_frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Move Inet[4]AddressUtils to libs/net" into rvc-dev

Browse Source
This commit is contained in:
Remi NGUYEN VAN 2020-06-19 00:49:29 +00:00 committed by Android (Google) Code Review
commit 6555756e90
15 changed files with 26 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Android.bp
View File

@ -701,7 +701,6 @@ filegroup {
"core/java/com/android/internal/util/TrafficStatsConstants.java",
"core/java/com/android/internal/util/WakeupMessage.java",
"core/java/com/android/internal/util/TokenBucket.java",
"core/java/android/net/shared/*.java",
],
}
@ -709,7 +708,6 @@ filegroup {
name: "framework-services-net-module-wifi-shared-srcs",
srcs: [
"core/java/android/net/DhcpResults.java",
"core/java/android/net/shared/InetAddressUtils.java",
"core/java/android/net/util/IpUtils.java",
"core/java/android/util/LocalLog.java",
],
@ -726,7 +724,6 @@ filegroup {
"core/java/com/android/internal/util/State.java",
"core/java/com/android/internal/util/StateMachine.java",
"core/java/com/android/internal/util/TrafficStatsConstants.java",
"core/java/android/net/shared/Inet4AddressUtils.java",
],
}
@ -1163,7 +1160,6 @@ java_library {
srcs: [
"core/java/android/content/pm/BaseParceledListSlice.java",
"core/java/android/content/pm/ParceledListSlice.java",
"core/java/android/net/shared/Inet4AddressUtils.java",
"core/java/android/os/HandlerExecutor.java",
"core/java/com/android/internal/util/AsyncChannel.java",
"core/java/com/android/internal/util/AsyncService.java",

3
core/java/android/net/DhcpResults.java
View File

@ -18,12 +18,13 @@ package android.net;
import android.annotation.Nullable;
import android.compat.annotation.UnsupportedAppUsage;
import android.net.shared.InetAddressUtils;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.TextUtils;
import android.util.Log;
import com.android.net.module.util.InetAddressUtils;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.util.ArrayList;

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

@ -21,13 +21,14 @@ import static android.system.OsConstants.AF_INET6;
import android.annotation.NonNull;
import android.compat.annotation.UnsupportedAppUsage;
import android.net.shared.Inet4AddressUtils;
import android.os.Build;
import android.system.ErrnoException;
import android.system.Os;
import android.util.Log;
import android.util.Pair;
import com.android.net.module.util.Inet4AddressUtils;
import java.io.FileDescriptor;
import java.math.BigInteger;
import java.net.Inet4Address;

2
core/java/android/net/StaticIpConfiguration.java
View File

@ -21,11 +21,11 @@ import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.annotation.TestApi;
import android.compat.annotation.UnsupportedAppUsage;
import android.net.shared.InetAddressUtils;
import android.os.Parcel;
import android.os.Parcelable;
import com.android.internal.util.Preconditions;
import com.android.net.module.util.InetAddressUtils;
import java.net.InetAddress;
import java.util.ArrayList;

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

@ -1,166 +0,0 @@
/*
* 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));
}
}

58
core/java/android/net/shared/InetAddressUtils.java
View File

@ -1,58 +0,0 @@
/*
* Copyright (C) 2012 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 android.os.Parcel;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* Collection of utilities to interact with {@link InetAddress}
* @hide
*/
public class InetAddressUtils {
/**
* Writes an InetAddress to a parcel. The address may be null. This is likely faster than
* calling writeSerializable.
* @hide
*/
public static void parcelInetAddress(Parcel parcel, InetAddress address, int flags) {
byte[] addressArray = (address != null) ? address.getAddress() : null;
parcel.writeByteArray(addressArray);
}
/**
* Reads an InetAddress from a parcel. Returns null if the address that was written was null
* or if the data is invalid.
* @hide
*/
public static InetAddress unparcelInetAddress(Parcel in) {
byte[] addressArray = in.createByteArray();
if (addressArray == null) {
return null;
}
try {
return InetAddress.getByAddress(addressArray);
} catch (UnknownHostException e) {
return null;
}
}
private InetAddressUtils() {}
}

15
packages/Tethering/jarjar-rules.txt
View File

@ -1,17 +1,8 @@
# These must be kept in sync with the framework-tethering-shared-srcs filegroup.
# If there are files in that filegroup that do not appear here, the classes in the
# Classes from the framework-tethering-shared-srcs filegroup.
# If there are files in that filegroup that are not covered below, the classes in the
# module will be overwritten by the ones in the framework.
# Don't jar-jar the entire package because tethering still use some internal classes
# (like TrafficStatsConstants in com.android.internal.util)
# TODO: simply these when tethering is built as system_current.
rule com.android.internal.util.BitUtils* com.android.networkstack.tethering.util.BitUtils@1
rule com.android.internal.util.IndentingPrintWriter.java* com.android.networkstack.tethering.util.IndentingPrintWriter.java@1
rule com.android.internal.util.IState.java* com.android.networkstack.tethering.util.IState.java@1
rule com.android.internal.util.MessageUtils* com.android.networkstack.tethering.util.MessageUtils@1
rule com.android.internal.util.State* com.android.networkstack.tethering.util.State@1
rule com.android.internal.util.StateMachine* com.android.networkstack.tethering.util.StateMachine@1
rule com.android.internal.util.TrafficStatsConstants* com.android.networkstack.tethering.util.TrafficStatsConstants@1
rule com.android.internal.util.** com.android.networkstack.tethering.util.@1
rule android.net.LocalLog* com.android.networkstack.tethering.LocalLog@1
rule android.net.shared.Inet4AddressUtils* com.android.networkstack.tethering.shared.Inet4AddressUtils@1

2
packages/Tethering/src/android/net/dhcp/DhcpServingParamsParcelExt.java
View File

@ -16,7 +16,7 @@
package android.net.dhcp;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTH;
import static com.android.net.module.util.Inet4AddressUtils.inet4AddressToIntHTH;
import android.net.LinkAddress;
import android.util.ArraySet;

3
packages/Tethering/src/android/net/ip/IpServer.java
View File

@ -19,13 +19,14 @@ package android.net.ip;
import static android.net.RouteInfo.RTN_UNICAST;
import static android.net.TetheringManager.TetheringRequest.checkStaticAddressConfiguration;
import static android.net.dhcp.IDhcpServer.STATUS_SUCCESS;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import static android.net.util.NetworkConstants.RFC7421_PREFIX_LENGTH;
import static android.net.util.NetworkConstants.asByte;
import static android.net.util.PrefixUtils.asIpPrefix;
import static android.net.util.TetheringMessageBase.BASE_IPSERVER;
import static android.system.OsConstants.RT_SCOPE_UNIVERSE;
import static com.android.net.module.util.Inet4AddressUtils.intToInet4AddressHTH;
import android.net.INetd;
import android.net.INetworkStackStatusCallback;
import android.net.IpPrefix;

3
packages/Tethering/tests/unit/src/android/net/ip/IpServerTest.java
View File

@ -36,7 +36,8 @@ import static android.net.netlink.NetlinkConstants.RTM_NEWNEIGH;
import static android.net.netlink.StructNdMsg.NUD_FAILED;
import static android.net.netlink.StructNdMsg.NUD_REACHABLE;
import static android.net.netlink.StructNdMsg.NUD_STALE;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import static com.android.net.module.util.Inet4AddressUtils.intToInet4AddressHTH;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;

2
packages/Tethering/tests/unit/src/com/android/networkstack/tethering/TetheringTest.java
View File

@ -40,7 +40,6 @@ import static android.net.TetheringManager.TETHER_HARDWARE_OFFLOAD_FAILED;
import static android.net.TetheringManager.TETHER_HARDWARE_OFFLOAD_STARTED;
import static android.net.TetheringManager.TETHER_HARDWARE_OFFLOAD_STOPPED;
import static android.net.dhcp.IDhcpServer.STATUS_SUCCESS;
import static android.net.shared.Inet4AddressUtils.intToInet4AddressHTH;
import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_INTERFACE_NAME;
import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_MODE;
import static android.net.wifi.WifiManager.EXTRA_WIFI_AP_STATE;
@ -49,6 +48,7 @@ import static android.net.wifi.WifiManager.IFACE_IP_MODE_TETHERED;
import static android.net.wifi.WifiManager.WIFI_AP_STATE_ENABLED;
import static android.telephony.SubscriptionManager.INVALID_SUBSCRIPTION_ID;
import static com.android.net.module.util.Inet4AddressUtils.intToInet4AddressHTH;
import static com.android.networkstack.tethering.TetheringNotificationUpdater.DOWNSTREAM_NONE;
import static com.android.networkstack.tethering.UpstreamNetworkMonitor.EVENT_ON_CAPABILITIES;

13
services/net/java/android/net/ip/IpClientCallbacks.java
View File

@ -68,12 +68,13 @@ public class IpClientCallbacks {
*/
public void onNewDhcpResults(DhcpResultsParcelable dhcpResults) {
// In general callbacks would not use a parcelable directly (DhcpResultsParcelable), and
// would use a wrapper instead. But there are already two classes in the tree for DHCP
// information: DhcpInfo and DhcpResults, and each of them do not expose an appropriate API
// (they are bags of mutable fields and can't be changed because they are public API and
// @UnsupportedAppUsage). Adding a third class would cost more than the gain considering
// that the only client of this callback is WiFi, which will end up converting the results
// to DhcpInfo anyway.
// would use a wrapper instead, because of the lack of safety of stable parcelables. But
// there are already two classes in the tree for DHCP information: DhcpInfo and DhcpResults,
// and neither of them exposes an appropriate API (they are bags of mutable fields and can't
// be changed because they are public API and @UnsupportedAppUsage, being no better than the
// stable parcelable). Adding a third class would cost more than the gain considering that
// the only client of this callback is WiFi, which will end up converting the results to
// DhcpInfo anyway.
}
/**

3
tests/net/common/java/android/net/DhcpInfoTest.java
View File

@ -16,8 +16,7 @@
package android.net;
import static android.net.shared.Inet4AddressUtils.inet4AddressToIntHTL;
import static com.android.net.module.util.Inet4AddressUtils.inet4AddressToIntHTL;
import static com.android.testutils.MiscAssertsKt.assertFieldCountEquals;
import static com.android.testutils.ParcelUtilsKt.parcelingRoundTrip;

3
wifi/jarjar-rules.txt
View File

@ -114,7 +114,6 @@ rule fi.iki.elonen.** com.android.wifi.x.@0
## used by both framework-wifi and service-wifi ##
rule android.content.pm.BaseParceledListSlice* com.android.wifi.x.@0
rule android.content.pm.ParceledListSlice* com.android.wifi.x.@0
rule android.net.shared.Inet4AddressUtils* com.android.wifi.x.@0
rule android.net.util.MacAddressUtils* com.android.wifi.x.@0
rule android.net.util.nsd.DnsSdTxtRecord* com.android.wifi.x.@0
rule android.os.HandlerExecutor* com.android.wifi.x.@0
@ -123,3 +122,5 @@ rule com.android.internal.util.AsyncChannel* com.android.wifi.x.@0
rule com.android.internal.util.AsyncService* com.android.wifi.x.@0
rule com.android.internal.util.Preconditions* com.android.wifi.x.@0
rule com.android.internal.util.Protocol* com.android.wifi.x.@0
rule com.android.net.module.util.** com.android.wifi.x.@0

3
wifi/java/android/net/wifi/WifiInfo.java
View File

@ -22,12 +22,13 @@ import android.annotation.Nullable;
import android.annotation.SystemApi;
import android.compat.annotation.UnsupportedAppUsage;
import android.net.NetworkInfo.DetailedState;
import android.net.shared.Inet4AddressUtils;
import android.os.Build;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.TextUtils;
import com.android.net.module.util.Inet4AddressUtils;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;