Java tutorial
/* * Copyright (C) 2008 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; import android.annotation.UnsupportedAppUsage; import android.net.shared.Inet4AddressUtils; import android.os.Build; import android.system.ErrnoException; import android.util.Log; import android.util.Pair; import java.io.FileDescriptor; import java.math.BigInteger; import java.net.Inet4Address; import java.net.Inet6Address; import java.net.InetAddress; import java.net.SocketException; import java.net.UnknownHostException; import java.util.Collection; import java.util.Locale; import java.util.TreeSet; /** * Native methods for managing network interfaces. * * {@hide} */ public class NetworkUtils { private static final String TAG = "NetworkUtils"; /** * Attaches a socket filter that drops all of incoming packets. * @param fd the socket's {@link FileDescriptor}. */ public static native void attachDropAllBPFFilter(FileDescriptor fd) throws SocketException; /** * Detaches a socket filter. * @param fd the socket's {@link FileDescriptor}. */ public static native void detachBPFFilter(FileDescriptor fd) throws SocketException; /** * Configures a socket for receiving ICMPv6 router solicitations and sending advertisements. * @param fd the socket's {@link FileDescriptor}. * @param ifIndex the interface index. */ public native static void setupRaSocket(FileDescriptor fd, int ifIndex) throws SocketException; /** * Binds the current process to the network designated by {@code netId}. All sockets created * in the future (and not explicitly bound via a bound {@link SocketFactory} (see * {@link Network#getSocketFactory}) will be bound to this network. Note that if this * {@code Network} ever disconnects all sockets created in this way will cease to work. This * is by design so an application doesn't accidentally use sockets it thinks are still bound to * a particular {@code Network}. Passing NETID_UNSET clears the binding. */ public native static boolean bindProcessToNetwork(int netId); /** * Return the netId last passed to {@link #bindProcessToNetwork}, or NETID_UNSET if * {@link #unbindProcessToNetwork} has been called since {@link #bindProcessToNetwork}. */ public native static int getBoundNetworkForProcess(); /** * Binds host resolutions performed by this process to the network designated by {@code netId}. * {@link #bindProcessToNetwork} takes precedence over this setting. Passing NETID_UNSET clears * the binding. * * @deprecated This is strictly for legacy usage to support startUsingNetworkFeature(). */ @Deprecated public native static boolean bindProcessToNetworkForHostResolution(int netId); /** * Explicitly binds {@code socketfd} to the network designated by {@code netId}. This * overrides any binding via {@link #bindProcessToNetwork}. * @return 0 on success or negative errno on failure. */ public native static int bindSocketToNetwork(int socketfd, int netId); /** * Protect {@code fd} from VPN connections. After protecting, data sent through * this socket will go directly to the underlying network, so its traffic will not be * forwarded through the VPN. */ @UnsupportedAppUsage public static boolean protectFromVpn(FileDescriptor fd) { return protectFromVpn(fd.getInt$()); } /** * Protect {@code socketfd} from VPN connections. After protecting, data sent through * this socket will go directly to the underlying network, so its traffic will not be * forwarded through the VPN. */ public native static boolean protectFromVpn(int socketfd); /** * Determine if {@code uid} can access network designated by {@code netId}. * @return {@code true} if {@code uid} can access network, {@code false} otherwise. */ public native static boolean queryUserAccess(int uid, int netId); /** * DNS resolver series jni method. * Issue the query {@code msg} on the network designated by {@code netId}. * {@code flags} is an additional config to control actual querying behavior. * @return a file descriptor to watch for read events */ public static native FileDescriptor resNetworkSend(int netId, byte[] msg, int msglen, int flags) throws ErrnoException; /** * DNS resolver series jni method. * Look up the {@code nsClass} {@code nsType} Resource Record (RR) associated * with Domain Name {@code dname} on the network designated by {@code netId}. * {@code flags} is an additional config to control actual querying behavior. * @return a file descriptor to watch for read events */ public static native FileDescriptor resNetworkQuery(int netId, String dname, int nsClass, int nsType, int flags) throws ErrnoException; /** * DNS resolver series jni method. * Read a result for the query associated with the {@code fd}. * @return DnsResponse containing blob answer and rcode */ public static native DnsResolver.DnsResponse resNetworkResult(FileDescriptor fd) throws ErrnoException; /** * DNS resolver series jni method. * Attempts to cancel the in-progress query associated with the {@code fd}. */ public static native void resNetworkCancel(FileDescriptor fd); /** * DNS resolver series jni method. * Attempts to get network which resolver will use if no network is explicitly selected. */ public static native Network getDnsNetwork() throws ErrnoException; /** * Get the tcp repair window associated with the {@code fd}. * * @param fd the tcp socket's {@link FileDescriptor}. * @return a {@link TcpRepairWindow} object indicates tcp window size. */ public static native TcpRepairWindow getTcpRepairWindow(FileDescriptor fd) throws ErrnoException; /** * @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 Inet4AddressUtils.intToInet4AddressHTL(hostAddress); } /** * @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 Inet4AddressUtils.inet4AddressToIntHTL(inetAddr); } /** * @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 Inet4AddressUtils.prefixLengthToV4NetmaskIntHTL(prefixLength); } /** * Convert a IPv4 netmask integer to a prefix length * @param netmask as an integer (0xff000000 for a /8 subnet) * @return the network prefix length */ public static int netmaskIntToPrefixLength(int netmask) { return Integer.bitCount(netmask); } /** * 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 * @deprecated use {@link Inet4AddressUtils#netmaskToPrefixLength(Inet4Address)} */ @UnsupportedAppUsage @Deprecated public static int netmaskToPrefixLength(Inet4Address netmask) { // This is only here because some apps seem to be using it (@UnsupportedAppUsage). return Inet4AddressUtils.netmaskToPrefixLength(netmask); } /** * Create an InetAddress from a string where the string must be a standard * representation of a V4 or V6 address. Avoids doing a DNS lookup on failure * but it will throw an IllegalArgumentException in that case. * @param addrString * @return the InetAddress * @hide * @deprecated Use {@link InetAddresses#parseNumericAddress(String)}, if possible. */ @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P) @Deprecated public static InetAddress numericToInetAddress(String addrString) throws IllegalArgumentException { return InetAddress.parseNumericAddress(addrString); } /** * Masks a raw IP address byte array with the specified prefix length. */ public static void maskRawAddress(byte[] array, int prefixLength) { if (prefixLength < 0 || prefixLength > array.length * 8) { throw new RuntimeException( "IP address with " + array.length + " bytes has invalid prefix length " + prefixLength); } int offset = prefixLength / 8; int remainder = prefixLength % 8; byte mask = (byte) (0xFF << (8 - remainder)); if (offset < array.length) array[offset] = (byte) (array[offset] & mask); offset++; for (; offset < array.length; offset++) { array[offset] = 0; } } /** * Get InetAddress masked with prefixLength. Will never return null. * @param address the IP address to mask with * @param prefixLength the prefixLength used to mask the IP */ public static InetAddress getNetworkPart(InetAddress address, int prefixLength) { byte[] array = address.getAddress(); maskRawAddress(array, prefixLength); InetAddress netPart = null; try { netPart = InetAddress.getByAddress(array); } catch (UnknownHostException e) { throw new RuntimeException("getNetworkPart error - " + e.toString()); } return netPart; } /** * Returns the implicit netmask of an IPv4 address, as was the custom before 1993. */ @UnsupportedAppUsage public static int getImplicitNetmask(Inet4Address address) { // Only here because it seems to be used by apps return Inet4AddressUtils.getImplicitNetmask(address); } /** * Utility method to parse strings such as "192.0.2.5/24" or "2001:db8::cafe:d00d/64". * @hide */ public static Pair<InetAddress, Integer> parseIpAndMask(String ipAndMaskString) { InetAddress address = null; int prefixLength = -1; try { String[] pieces = ipAndMaskString.split("/", 2); prefixLength = Integer.parseInt(pieces[1]); address = InetAddress.parseNumericAddress(pieces[0]); } catch (NullPointerException e) { // Null string. } catch (ArrayIndexOutOfBoundsException e) { // No prefix length. } catch (NumberFormatException e) { // Non-numeric prefix. } catch (IllegalArgumentException e) { // Invalid IP address. } if (address == null || prefixLength == -1) { throw new IllegalArgumentException("Invalid IP address and mask " + ipAndMaskString); } return new Pair<InetAddress, Integer>(address, prefixLength); } /** * Check if IP address type is consistent between two InetAddress. * @return true if both are the same type. False otherwise. */ public static boolean addressTypeMatches(InetAddress left, InetAddress right) { return (((left instanceof Inet4Address) && (right instanceof Inet4Address)) || ((left instanceof Inet6Address) && (right instanceof Inet6Address))); } /** * Convert a 32 char hex string into a Inet6Address. * throws a runtime exception if the string isn't 32 chars, isn't hex or can't be * made into an Inet6Address * @param addrHexString a 32 character hex string representing an IPv6 addr * @return addr an InetAddress representation for the string */ public static InetAddress hexToInet6Address(String addrHexString) throws IllegalArgumentException { try { return numericToInetAddress(String.format(Locale.US, "%s:%s:%s:%s:%s:%s:%s:%s", addrHexString.substring(0, 4), addrHexString.substring(4, 8), addrHexString.substring(8, 12), addrHexString.substring(12, 16), addrHexString.substring(16, 20), addrHexString.substring(20, 24), addrHexString.substring(24, 28), addrHexString.substring(28, 32))); } catch (Exception e) { Log.e("NetworkUtils", "error in hexToInet6Address(" + addrHexString + "): " + e); throw new IllegalArgumentException(e); } } /** * Create a string array of host addresses from a collection of InetAddresses * @param addrs a Collection of InetAddresses * @return an array of Strings containing their host addresses */ public static String[] makeStrings(Collection<InetAddress> addrs) { String[] result = new String[addrs.size()]; int i = 0; for (InetAddress addr : addrs) { result[i++] = addr.getHostAddress(); } return result; } /** * Trim leading zeros from IPv4 address strings * Our base libraries will interpret that as octel.. * Must leave non v4 addresses and host names alone. * For example, 192.168.000.010 -> 192.168.0.10 * TODO - fix base libraries and remove this function * @param addr a string representing an ip addr * @return a string propertly trimmed */ @UnsupportedAppUsage public static String trimV4AddrZeros(String addr) { if (addr == null) return null; String[] octets = addr.split("\\."); if (octets.length != 4) return addr; StringBuilder builder = new StringBuilder(16); String result = null; for (int i = 0; i < 4; i++) { try { if (octets[i].length() > 3) return addr; builder.append(Integer.parseInt(octets[i])); } catch (NumberFormatException e) { return addr; } if (i < 3) builder.append('.'); } result = builder.toString(); return result; } /** * Returns a prefix set without overlaps. * * This expects the src set to be sorted from shorter to longer. Results are undefined * failing this condition. The returned prefix set is sorted in the same order as the * passed set, with the same comparator. */ private static TreeSet<IpPrefix> deduplicatePrefixSet(final TreeSet<IpPrefix> src) { final TreeSet<IpPrefix> dst = new TreeSet<>(src.comparator()); // Prefixes match addresses that share their upper part up to their length, therefore // the only kind of possible overlap in two prefixes is strict inclusion of the longer // (more restrictive) in the shorter (including equivalence if they have the same // length). // Because prefixes in the src set are sorted from shorter to longer, deduplicating // is done by simply iterating in order, and not adding any longer prefix that is // already covered by a shorter one. newPrefixes: for (IpPrefix newPrefix : src) { for (IpPrefix existingPrefix : dst) { if (existingPrefix.containsPrefix(newPrefix)) { continue newPrefixes; } } dst.add(newPrefix); } return dst; } /** * Returns how many IPv4 addresses match any of the prefixes in the passed ordered set. * * Obviously this returns an integral value between 0 and 2**32. * The behavior is undefined if any of the prefixes is not an IPv4 prefix or if the * set is not ordered smallest prefix to longer prefix. * * @param prefixes the set of prefixes, ordered by length */ public static long routedIPv4AddressCount(final TreeSet<IpPrefix> prefixes) { long routedIPCount = 0; for (final IpPrefix prefix : deduplicatePrefixSet(prefixes)) { if (!prefix.isIPv4()) { Log.wtf(TAG, "Non-IPv4 prefix in routedIPv4AddressCount"); } int rank = 32 - prefix.getPrefixLength(); routedIPCount += 1L << rank; } return routedIPCount; } /** * Returns how many IPv6 addresses match any of the prefixes in the passed ordered set. * * This returns a BigInteger between 0 and 2**128. * The behavior is undefined if any of the prefixes is not an IPv6 prefix or if the * set is not ordered smallest prefix to longer prefix. */ public static BigInteger routedIPv6AddressCount(final TreeSet<IpPrefix> prefixes) { BigInteger routedIPCount = BigInteger.ZERO; for (final IpPrefix prefix : deduplicatePrefixSet(prefixes)) { if (!prefix.isIPv6()) { Log.wtf(TAG, "Non-IPv6 prefix in routedIPv6AddressCount"); } int rank = 128 - prefix.getPrefixLength(); routedIPCount = routedIPCount.add(BigInteger.ONE.shiftLeft(rank)); } return routedIPCount; } }