Merge "Tethering: ensure downstream prefix do not conflict with upstream" into... (220190cb) · Commits · e / os / android_frameworks_base

packages/Tethering/src/android/net/ip/IpServer.java

+80 −89

Original line number	Diff line number	Diff line
		@@ -16,14 +16,13 @@

		package android.net.ip;

		import static android.net.InetAddresses.parseNumericAddress;
		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.FF;
		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;

		@@ -66,11 +65,11 @@ import androidx.annotation.Nullable;
		import com.android.internal.util.MessageUtils;
		import com.android.internal.util.State;
		import com.android.internal.util.StateMachine;
		import com.android.networkstack.tethering.PrivateAddressCoordinator;

		import java.io.IOException;
		import java.net.Inet4Address;
		import java.net.Inet6Address;
		import java.net.InetAddress;
		import java.net.NetworkInterface;
		import java.net.UnknownHostException;
		import java.util.ArrayList;
		@@ -108,27 +107,8 @@ public class IpServer extends StateMachine {

		private static final byte DOUG_ADAMS = (byte) 42;

		private static final String USB_NEAR_IFACE_ADDR = "192.168.42.129";
		private static final int USB_PREFIX_LENGTH = 24;
		private static final String WIFI_HOST_IFACE_ADDR = "192.168.43.1";
		private static final int WIFI_HOST_IFACE_PREFIX_LENGTH = 24;
		private static final String WIFI_P2P_IFACE_ADDR = "192.168.49.1";
		private static final int WIFI_P2P_IFACE_PREFIX_LENGTH = 24;
		private static final String ETHERNET_IFACE_ADDR = "192.168.50.1";
		private static final int ETHERNET_IFACE_PREFIX_LENGTH = 24;

		// TODO: remove this constant after introducing PrivateAddressCoordinator.
		private static final List<IpPrefix> NCM_PREFIXES = Collections.unmodifiableList(
		Arrays.asList(
		new IpPrefix("192.168.42.0/24"),
		new IpPrefix("192.168.51.0/24"),
		new IpPrefix("192.168.52.0/24"),
		new IpPrefix("192.168.53.0/24")
		));

		// TODO: have PanService use some visible version of this constant
		private static final String BLUETOOTH_IFACE_ADDR = "192.168.44.1";
		private static final int BLUETOOTH_DHCP_PREFIX_LENGTH = 24;
		private static final String BLUETOOTH_IFACE_ADDR = "192.168.44.1/24";

		// TODO: have this configurable
		private static final int DHCP_LEASE_TIME_SECS = 3600;
		@@ -167,6 +147,14 @@ public class IpServer extends StateMachine {
		* Notify that the DHCP leases changed in one of the IpServers.
		*/
		public void dhcpLeasesChanged() { }

		/**
		* Request Tethering change.
		*
		* @param tetheringType the downstream type of this IpServer.
		* @param enabled enable or disable tethering.
		*/
		public void requestEnableTethering(int tetheringType, boolean enabled) { }
		}

		/** Capture IpServer dependencies, for injection. */
		@@ -196,6 +184,7 @@ public class IpServer extends StateMachine {
		return 0;
		}
		}

		/** Create a DhcpServer instance to be used by IpServer. */
		public abstract void makeDhcpServer(String ifName, DhcpServingParamsParcel params,
		DhcpServerCallbacks cb);
		@@ -225,16 +214,20 @@ public class IpServer extends StateMachine {
		public static final int CMD_NEIGHBOR_EVENT = BASE_IPSERVER + 11;
		// request from DHCP server that it wants to have a new prefix
		public static final int CMD_NEW_PREFIX_REQUEST = BASE_IPSERVER + 12;
		// request from PrivateAddressCoordinator to restart tethering.
		public static final int CMD_NOTIFY_PREFIX_CONFLICT = BASE_IPSERVER + 13;

		private final State mInitialState;
		private final State mLocalHotspotState;
		private final State mTetheredState;
		private final State mUnavailableState;
		private final State mWaitingForRestartState;

		private final SharedLog mLog;
		private final INetd mNetd;
		private final Callback mCallback;
		private final InterfaceController mInterfaceCtrl;
		private final PrivateAddressCoordinator mPrivateAddressCoordinator;

		private final String mIfaceName;
		private final int mInterfaceType;
		@@ -261,7 +254,6 @@ public class IpServer extends StateMachine {
		private int mDhcpServerStartIndex = 0;
		private IDhcpServer mDhcpServer;
		private RaParams mLastRaParams;
		private LinkAddress mIpv4Address;

		private LinkAddress mStaticIpv4ServerAddr;
		private LinkAddress mStaticIpv4ClientAddr;
		@@ -316,12 +308,14 @@ public class IpServer extends StateMachine {

		private final IpNeighborMonitor mIpNeighborMonitor;

		private LinkAddress mIpv4Address;

		// TODO: Add a dependency object to pass the data members or variables from the tethering
		// object. It helps to reduce the arguments of the constructor.
		public IpServer(
		String ifaceName, Looper looper, int interfaceType, SharedLog log,
		INetd netd, Callback callback, boolean usingLegacyDhcp, boolean usingBpfOffload,
		Dependencies deps) {
		PrivateAddressCoordinator addressCoordinator, Dependencies deps) {
		super(ifaceName, looper);
		mLog = log.forSubComponent(ifaceName);
		mNetd = netd;
		@@ -332,6 +326,7 @@ public class IpServer extends StateMachine {
		mLinkProperties = new LinkProperties();
		mUsingLegacyDhcp = usingLegacyDhcp;
		mUsingBpfOffload = usingBpfOffload;
		mPrivateAddressCoordinator = addressCoordinator;
		mDeps = deps;
		resetLinkProperties();
		mLastError = TetheringManager.TETHER_ERROR_NO_ERROR;
		@@ -352,9 +347,11 @@ public class IpServer extends StateMachine {
		mLocalHotspotState = new LocalHotspotState();
		mTetheredState = new TetheredState();
		mUnavailableState = new UnavailableState();
		mWaitingForRestartState = new WaitingForRestartState();
		addState(mInitialState);
		addState(mLocalHotspotState);
		addState(mTetheredState);
		addState(mWaitingForRestartState, mTetheredState);
		addState(mUnavailableState);

		setInitialState(mInitialState);
		@@ -387,6 +384,11 @@ public class IpServer extends StateMachine {
		return new LinkProperties(mLinkProperties);
		}

		/** The address which IpServer is using. */
		public LinkAddress getAddress() {
		return mIpv4Address;
		}

		/**
		* Get the latest list of DHCP leases that was reported. Must be called on the IpServer looper
		* thread.
		@@ -617,6 +619,7 @@ public class IpServer extends StateMachine {
		// NOTE: All of configureIPv4() will be refactored out of existence
		// into calls to InterfaceController, shared with startIPv4().
		mInterfaceCtrl.clearIPv4Address();
		mPrivateAddressCoordinator.releaseDownstream(this);
		mIpv4Address = null;
		mStaticIpv4ServerAddr = null;
		mStaticIpv4ClientAddr = null;
		@@ -625,42 +628,23 @@ public class IpServer extends StateMachine {
		private boolean configureIPv4(boolean enabled) {
		if (VDBG) Log.d(TAG, "configureIPv4(" + enabled + ")");

		// TODO: Replace this hard-coded information with dynamically selected
		// config passed down to us by a higher layer IP-coordinating element.
		final Inet4Address srvAddr;
		int prefixLen = 0;
		try {
		if (mStaticIpv4ServerAddr != null) {
		srvAddr = (Inet4Address) mStaticIpv4ServerAddr.getAddress();
		prefixLen = mStaticIpv4ServerAddr.getPrefixLength();
		} else if (mInterfaceType == TetheringManager.TETHERING_USB
		\|\| mInterfaceType == TetheringManager.TETHERING_NCM) {
		srvAddr = (Inet4Address) parseNumericAddress(USB_NEAR_IFACE_ADDR);
		prefixLen = USB_PREFIX_LENGTH;
		} else if (mInterfaceType == TetheringManager.TETHERING_WIFI) {
		srvAddr = (Inet4Address) parseNumericAddress(getRandomWifiIPv4Address());
		prefixLen = WIFI_HOST_IFACE_PREFIX_LENGTH;
		} else if (mInterfaceType == TetheringManager.TETHERING_WIFI_P2P) {
		srvAddr = (Inet4Address) parseNumericAddress(WIFI_P2P_IFACE_ADDR);
		prefixLen = WIFI_P2P_IFACE_PREFIX_LENGTH;
		} else if (mInterfaceType == TetheringManager.TETHERING_ETHERNET) {
		// TODO: randomize address for tethering too, similarly to wifi
		srvAddr = (Inet4Address) parseNumericAddress(ETHERNET_IFACE_ADDR);
		prefixLen = ETHERNET_IFACE_PREFIX_LENGTH;
		} else {
		if (enabled) {
		mIpv4Address = requestIpv4Address();
		}

		if (mIpv4Address == null) {
		mLog.e("No available ipv4 address");
		return false;
		}

		if (mInterfaceType == TetheringManager.TETHERING_BLUETOOTH) {
		// BT configures the interface elsewhere: only start DHCP.
		// TODO: make all tethering types behave the same way, and delete the bluetooth
		// code that calls into NetworkManagementService directly.
		srvAddr = (Inet4Address) parseNumericAddress(BLUETOOTH_IFACE_ADDR);
		mIpv4Address = new LinkAddress(srvAddr, BLUETOOTH_DHCP_PREFIX_LENGTH);
		return configureDhcp(enabled, mIpv4Address, null /* clientAddress */);
		}
		mIpv4Address = new LinkAddress(srvAddr, prefixLen);
		} catch (IllegalArgumentException e) {
		mLog.e("Error selecting ipv4 address", e);
		if (!enabled) stopDhcp();
		return false;
		}

		final IpPrefix ipv4Prefix = asIpPrefix(mIpv4Address);

		final Boolean setIfaceUp;
		if (mInterfaceType == TetheringManager.TETHERING_WIFI
		@@ -688,21 +672,14 @@ public class IpServer extends StateMachine {
		return configureDhcp(enabled, mIpv4Address, mStaticIpv4ClientAddr);
		}

		private Inet4Address getRandomIPv4Address(@NonNull final byte[] rawAddr) {
		final byte[] ipv4Addr = rawAddr;
		ipv4Addr[3] = getRandomSanitizedByte(DOUG_ADAMS, asByte(0), asByte(1), FF);
		try {
		return (Inet4Address) InetAddress.getByAddress(ipv4Addr);
		} catch (UnknownHostException e) {
		mLog.e("Failed to construct Inet4Address from raw IPv4 addr");
		return null;
		}
		private LinkAddress requestIpv4Address() {
		if (mStaticIpv4ServerAddr != null) return mStaticIpv4ServerAddr;

		if (mInterfaceType == TetheringManager.TETHERING_BLUETOOTH) {
		return new LinkAddress(BLUETOOTH_IFACE_ADDR);
		}

		private String getRandomWifiIPv4Address() {
		final Inet4Address ipv4Addr =
		getRandomIPv4Address(parseNumericAddress(WIFI_HOST_IFACE_ADDR).getAddress());
		return ipv4Addr != null ? ipv4Addr.getHostAddress() : WIFI_HOST_IFACE_ADDR;
		return mPrivateAddressCoordinator.requestDownstreamAddress(this);
		}

		private boolean startIPv6() {
		@@ -978,19 +955,6 @@ public class IpServer extends StateMachine {
		}
		}

		// TODO: call PrivateAddressCoordinator.requestDownstreamAddress instead of this temporary
		// logic.
		private Inet4Address requestDownstreamAddress(@NonNull final IpPrefix currentPrefix) {
		final int oldIndex = NCM_PREFIXES.indexOf(currentPrefix);
		if (oldIndex == -1) {
		mLog.e("current prefix isn't supported for NCM link: " + currentPrefix);
		return null;
		}

		final IpPrefix newPrefix = NCM_PREFIXES.get((oldIndex + 1) % NCM_PREFIXES.size());
		return getRandomIPv4Address(newPrefix.getRawAddress());
		}

		private void handleNewPrefixRequest(@NonNull final IpPrefix currentPrefix) {
		if (!currentPrefix.contains(mIpv4Address.getAddress())
		\|\| currentPrefix.getPrefixLength() != mIpv4Address.getPrefixLength()) {
		@@ -999,12 +963,12 @@ public class IpServer extends StateMachine {
		}

		final LinkAddress deprecatedLinkAddress = mIpv4Address;
		final Inet4Address srvAddr = requestDownstreamAddress(currentPrefix);
		if (srvAddr == null) {
		mIpv4Address = requestIpv4Address();
		if (mIpv4Address == null) {
		mLog.e("Fail to request a new downstream prefix");
		return;
		}
		mIpv4Address = new LinkAddress(srvAddr, currentPrefix.getPrefixLength());
		final Inet4Address srvAddr = (Inet4Address) mIpv4Address.getAddress();

		// Add new IPv4 address on the interface.
		if (!mInterfaceCtrl.addAddress(srvAddr, currentPrefix.getPrefixLength())) {
		@@ -1162,7 +1126,7 @@ public class IpServer extends StateMachine {
		}

		try {
		NetdUtils.tetherInterface(mNetd, mIfaceName, PrefixUtils.asIpPrefix(mIpv4Address));
		NetdUtils.tetherInterface(mNetd, mIfaceName, asIpPrefix(mIpv4Address));
		} catch (RemoteException \| ServiceSpecificException \| IllegalStateException e) {
		mLog.e("Error Tethering", e);
		mLastError = TetheringManager.TETHER_ERROR_TETHER_IFACE_ERROR;
		@@ -1222,6 +1186,11 @@ public class IpServer extends StateMachine {
		case CMD_NEW_PREFIX_REQUEST:
		handleNewPrefixRequest((IpPrefix) message.obj);
		break;
		case CMD_NOTIFY_PREFIX_CONFLICT:
		mLog.i("restart tethering: " + mInterfaceType);
		mCallback.requestEnableTethering(mInterfaceType, false /* enabled */);
		transitionTo(mWaitingForRestartState);
		break;
		default:
		return false;
		}
		@@ -1403,6 +1372,28 @@ public class IpServer extends StateMachine {
		}
		}

		class WaitingForRestartState extends State {
		@Override
		public boolean processMessage(Message message) {
		logMessage(this, message.what);
		switch (message.what) {
		case CMD_TETHER_UNREQUESTED:
		transitionTo(mInitialState);
		mLog.i("Untethered (unrequested) and restarting " + mIfaceName);
		mCallback.requestEnableTethering(mInterfaceType, true /* enabled */);
		break;
		case CMD_INTERFACE_DOWN:
		transitionTo(mUnavailableState);
		mLog.i("Untethered (interface down) and restarting" + mIfaceName);
		mCallback.requestEnableTethering(mInterfaceType, true /* enabled */);
		break;
		default:
		return false;
		}
		return true;
		}
		}

		// Accumulate routes representing "prefixes to be assigned to the local
		// interface", for subsequent modification of local_network routing.
		private static ArrayList<RouteInfo> getLocalRoutesFor(

packages/Tethering/src/com/android/networkstack/tethering/PrivateAddressCoordinator.java

0 → 100644

+254 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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 com.android.networkstack.tethering;

		import android.content.Context;
		import android.net.ConnectivityManager;
		import android.net.IpPrefix;
		import android.net.LinkAddress;
		import android.net.LinkProperties;
		import android.net.Network;
		import android.net.ip.IpServer;
		import android.net.util.PrefixUtils;
		import android.util.ArrayMap;
		import android.util.ArraySet;

		import androidx.annotation.Nullable;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.util.IndentingPrintWriter;

		import java.net.InetAddress;
		import java.net.UnknownHostException;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.List;
		import java.util.Random;

		/**
		* This class coordinate IP addresses conflict problem.
		*
		* Tethering downstream IP addresses may conflict with network assigned addresses. This
		* coordinator is responsible for recording all of network assigned addresses and dispatched
		* free address to downstream interfaces.
		*
		* This class is not thread-safe and should be accessed on the same tethering internal thread.
		* @hide
		*/
		public class PrivateAddressCoordinator {
		public static final int PREFIX_LENGTH = 24;

		private static final int MAX_UBYTE = 256;
		private static final int BYTE_MASK = 0xff;
		// reserved for bluetooth tethering.
		private static final int BLUETOOTH_RESERVED = 44;
		private static final byte DEFAULT_ID = (byte) 42;

		// Upstream monitor would be stopped when tethering is down. When tethering restart, downstream
		// address may be requested before coordinator get current upstream notification. To ensure
		// coordinator do not select conflict downstream prefix, mUpstreamPrefixMap would not be cleared
		// when tethering is down. Instead coordinator would remove all depcreted upstreams from
		// mUpstreamPrefixMap when tethering is starting. See #maybeRemoveDeprectedUpstreams().
		private final ArrayMap<Network, List<IpPrefix>> mUpstreamPrefixMap;
		private final ArraySet<IpServer> mDownstreams;
		// IANA has reserved the following three blocks of the IP address space for private intranets:
		// 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16
		// Tethering use 192.168.0.0/16 that has 256 contiguous class C network numbers.
		private static final String DEFAULT_TETHERING_PREFIX = "192.168.0.0/16";
		private final IpPrefix mTetheringPrefix;
		private final ConnectivityManager mConnectivityMgr;

		public PrivateAddressCoordinator(Context context) {
		mDownstreams = new ArraySet<>();
		mUpstreamPrefixMap = new ArrayMap<>();
		mTetheringPrefix = new IpPrefix(DEFAULT_TETHERING_PREFIX);
		mConnectivityMgr = (ConnectivityManager) context.getSystemService(
		Context.CONNECTIVITY_SERVICE);
		}

		/**
		* Record a new upstream IpPrefix which may conflict with tethering downstreams.
		* The downstreams will be notified if a conflict is found.
		*/
		public void updateUpstreamPrefix(final Network network, final LinkProperties lp) {
		final ArrayList<IpPrefix> ipv4Prefixes = getIpv4Prefixes(lp.getAllLinkAddresses());
		if (ipv4Prefixes.isEmpty()) {
		removeUpstreamPrefix(network);
		return;
		}

		mUpstreamPrefixMap.put(network, ipv4Prefixes);
		handleMaybePrefixConflict(ipv4Prefixes);
		}

		private ArrayList<IpPrefix> getIpv4Prefixes(final List<LinkAddress> linkAddresses) {
		final ArrayList<IpPrefix> list = new ArrayList<>();
		for (LinkAddress address : linkAddresses) {
		if (!address.isIpv4()) continue;

		list.add(PrefixUtils.asIpPrefix(address));
		}

		return list;
		}

		private void handleMaybePrefixConflict(final List<IpPrefix> prefixes) {
		for (IpServer downstream : mDownstreams) {
		final IpPrefix target = getDownstreamPrefix(downstream);
		if (target == null) continue;

		for (IpPrefix source : prefixes) {
		if (isConflictPrefix(source, target)) {
		downstream.sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT);
		break;
		}
		}
		}
		}

		/** Remove IpPrefix records corresponding to input network. */
		public void removeUpstreamPrefix(final Network network) {
		mUpstreamPrefixMap.remove(network);
		}

		private void maybeRemoveDeprectedUpstreams() {
		if (!mDownstreams.isEmpty() \|\| mUpstreamPrefixMap.isEmpty()) return;

		final ArrayList<Network> toBeRemoved = new ArrayList<>();
		List<Network> allNetworks = Arrays.asList(mConnectivityMgr.getAllNetworks());
		for (int i = 0; i < mUpstreamPrefixMap.size(); i++) {
		final Network network = mUpstreamPrefixMap.keyAt(i);
		if (!allNetworks.contains(network)) toBeRemoved.add(network);
		}

		mUpstreamPrefixMap.removeAll(toBeRemoved);
		}

		/**
		* Pick a random available address and mark its prefix as in use for the provided IpServer,
		* returns null if there is no available address.
		*/
		@Nullable
		public LinkAddress requestDownstreamAddress(final IpServer ipServer) {
		maybeRemoveDeprectedUpstreams();

		// Address would be 192.168.[subAddress]/24.
		final byte[] bytes = mTetheringPrefix.getRawAddress();
		final int subAddress = getRandomSubAddr();
		final int subNet = (subAddress >> 8) & BYTE_MASK;
		bytes[3] = getSanitizedAddressSuffix(subAddress, (byte) 0, (byte) 1, (byte) 0xff);
		for (int i = 0; i < MAX_UBYTE; i++) {
		final int newSubNet = (subNet + i) & BYTE_MASK;
		if (newSubNet == BLUETOOTH_RESERVED) continue;

		bytes[2] = (byte) newSubNet;
		final InetAddress addr;
		try {
		addr = InetAddress.getByAddress(bytes);
		} catch (UnknownHostException e) {
		throw new IllegalStateException("Invalid address, shouldn't happen.", e);
		}

		final IpPrefix prefix = new IpPrefix(addr, PREFIX_LENGTH);
		// Check whether this prefix is in use.
		if (isDownstreamPrefixInUse(prefix)) continue;
		// Check whether this prefix is conflict with any current upstream network.
		if (isConflictWithUpstream(prefix)) continue;

		mDownstreams.add(ipServer);
		return new LinkAddress(addr, PREFIX_LENGTH);
		}

		// No available address.
		return null;
		}

		/** Get random sub address value. Return value is in 0 ~ 0xffff. */
		@VisibleForTesting
		public int getRandomSubAddr() {
		return ((new Random()).nextInt()) & 0xffff; // subNet is in 0 ~ 0xffff.
		}

		private byte getSanitizedAddressSuffix(final int source, byte... excluded) {
		final byte subId = (byte) (source & BYTE_MASK);
		for (byte value : excluded) {
		if (subId == value) return DEFAULT_ID;
		}

		return subId;
		}

		/** Release downstream record for IpServer. */
		public void releaseDownstream(final IpServer ipServer) {
		mDownstreams.remove(ipServer);
		}

		/** Clear current upstream prefixes records. */
		public void clearUpstreamPrefixes() {
		mUpstreamPrefixMap.clear();
		}

		private boolean isConflictWithUpstream(final IpPrefix source) {
		for (int i = 0; i < mUpstreamPrefixMap.size(); i++) {
		final List<IpPrefix> list = mUpstreamPrefixMap.valueAt(i);
		for (IpPrefix target : list) {
		if (isConflictPrefix(source, target)) return true;
		}
		}
		return false;
		}

		private boolean isConflictPrefix(final IpPrefix prefix1, final IpPrefix prefix2) {
		if (prefix2.getPrefixLength() < prefix1.getPrefixLength()) {
		return prefix2.contains(prefix1.getAddress());
		}

		return prefix1.contains(prefix2.getAddress());
		}

		private boolean isDownstreamPrefixInUse(final IpPrefix source) {
		// This class always generates downstream prefixes with the same prefix length, so
		// prefixes cannot be contained in each other. They can only be equal to each other.
		for (IpServer downstream : mDownstreams) {
		final IpPrefix prefix = getDownstreamPrefix(downstream);
		if (source.equals(prefix)) return true;
		}
		return false;
		}

		private IpPrefix getDownstreamPrefix(final IpServer downstream) {
		final LinkAddress address = downstream.getAddress();
		if (address == null) return null;

		return PrefixUtils.asIpPrefix(address);
		}

		void dump(final IndentingPrintWriter pw) {
		pw.decreaseIndent();
		pw.println("mUpstreamPrefixMap:");
		pw.increaseIndent();
		for (int i = 0; i < mUpstreamPrefixMap.size(); i++) {
		pw.println(mUpstreamPrefixMap.keyAt(i) + " - " + mUpstreamPrefixMap.valueAt(i));
		}
		pw.decreaseIndent();
		pw.println("mDownstreams:");
		pw.increaseIndent();
		for (IpServer ipServer : mDownstreams) {
		pw.println(ipServer.interfaceType() + " - " + ipServer.getAddress());
		}
		pw.decreaseIndent();
		}
		}

packages/Tethering/src/com/android/networkstack/tethering/Tethering.java

+31 −1

File changed.

Preview size limit exceeded, changes collapsed.

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

+43 −24

File changed.

Preview size limit exceeded, changes collapsed.

packages/Tethering/tests/unit/src/com/android/networkstack/tethering/PrivateAddressCoordinatorTest.java

0 → 100644

+254 −0

File added.

Preview size limit exceeded, changes collapsed.