LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Fix miss tracking downstream problem in PrivateAddressCoordinator"

Browse Source
This commit is contained in:
Mark Chien
2020-10-15 12:07:19 +00:00
committed by Gerrit Code Review
parent 87b8363cb9 634f0a8ec1
commit 8565b0244a
2 changed files with 87 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Tethering/src/com/android/networkstack/tethering/PrivateAddressCoordinator.java
View File

@@ -36,6 +36,7 @@ import android.util.ArrayMap;
import android.util.ArraySet; import android.util.ArraySet;
import android.util.SparseArray; import android.util.SparseArray;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable; import androidx.annotation.Nullable;
import com.android.internal.annotations.VisibleForTesting; import com.android.internal.annotations.VisibleForTesting;
@@ -135,7 +136,6 @@ public class PrivateAddressCoordinator {
private void handleMaybePrefixConflict(final List<IpPrefix> prefixes) { private void handleMaybePrefixConflict(final List<IpPrefix> prefixes) {
for (IpServer downstream : mDownstreams) { for (IpServer downstream : mDownstreams) {
final IpPrefix target = getDownstreamPrefix(downstream); final IpPrefix target = getDownstreamPrefix(downstream);
if (target == null) continue;
for (IpPrefix source : prefixes) { for (IpPrefix source : prefixes) {
if (isConflictPrefix(source, target)) { if (isConflictPrefix(source, target)) {
@@ -179,6 +179,7 @@ public class PrivateAddressCoordinator {
final LinkAddress cachedAddress = mCachedAddresses.get(ipServer.interfaceType()); final LinkAddress cachedAddress = mCachedAddresses.get(ipServer.interfaceType());
if (useLastAddress && cachedAddress != null if (useLastAddress && cachedAddress != null
&& !isConflictWithUpstream(asIpPrefix(cachedAddress))) { && !isConflictWithUpstream(asIpPrefix(cachedAddress))) {
mDownstreams.add(ipServer);
return cachedAddress; return cachedAddress;
} }
@@ -370,7 +371,6 @@ public class PrivateAddressCoordinator {
// in mCachedAddresses. // in mCachedAddresses.
for (IpServer downstream : mDownstreams) { for (IpServer downstream : mDownstreams) {
final IpPrefix target = getDownstreamPrefix(downstream); final IpPrefix target = getDownstreamPrefix(downstream);
if (target == null) continue;
if (isConflictPrefix(prefix, target)) return target; if (isConflictPrefix(prefix, target)) return target;
} }
@@ -378,9 +378,9 @@ public class PrivateAddressCoordinator {
return null; return null;
} }
@NonNull
private IpPrefix getDownstreamPrefix(final IpServer downstream) { private IpPrefix getDownstreamPrefix(final IpServer downstream) {
final LinkAddress address = downstream.getAddress(); final LinkAddress address = downstream.getAddress();
if (address == null) return null;
return asIpPrefix(address); return asIpPrefix(address);
} }

192
Tethering/tests/unit/src/com/android/networkstack/tethering/PrivateAddressCoordinatorTest.java
View File

@@ -104,24 +104,30 @@ public final class PrivateAddressCoordinatorTest {
mTetheringPrefixes)); mTetheringPrefixes));
} }
private LinkAddress requestDownstreamAddress(final IpServer ipServer, boolean useLastAddress) {
final LinkAddress address = mPrivateAddressCoordinator.requestDownstreamAddress(
ipServer, useLastAddress);
when(ipServer.getAddress()).thenReturn(address);
return address;
}
@Test @Test
public void testRequestDownstreamAddressWithoutUsingLastAddress() throws Exception { public void testRequestDownstreamAddressWithoutUsingLastAddress() throws Exception {
final IpPrefix bluetoothPrefix = asIpPrefix(mBluetoothAddress); final IpPrefix bluetoothPrefix = asIpPrefix(mBluetoothAddress);
final LinkAddress address = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress address = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, false /* useLastAddress */); false /* useLastAddress */);
final IpPrefix hotspotPrefix = asIpPrefix(address); final IpPrefix hotspotPrefix = asIpPrefix(address);
assertNotEquals(hotspotPrefix, bluetoothPrefix); assertNotEquals(hotspotPrefix, bluetoothPrefix);
when(mHotspotIpServer.getAddress()).thenReturn(address);
final LinkAddress newAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress newAddress = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, false /* useLastAddress */); false /* useLastAddress */);
final IpPrefix testDupRequest = asIpPrefix(newAddress); final IpPrefix testDupRequest = asIpPrefix(newAddress);
assertNotEquals(hotspotPrefix, testDupRequest); assertNotEquals(hotspotPrefix, testDupRequest);
assertNotEquals(bluetoothPrefix, testDupRequest); assertNotEquals(bluetoothPrefix, testDupRequest);
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
final LinkAddress usbAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress usbAddress = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, false /* useLastAddress */); false /* useLastAddress */);
final IpPrefix usbPrefix = asIpPrefix(usbAddress); final IpPrefix usbPrefix = asIpPrefix(usbAddress);
assertNotEquals(usbPrefix, bluetoothPrefix); assertNotEquals(usbPrefix, bluetoothPrefix);
assertNotEquals(usbPrefix, hotspotPrefix); assertNotEquals(usbPrefix, hotspotPrefix);
@@ -132,29 +138,26 @@ public final class PrivateAddressCoordinatorTest {
public void testSanitizedAddress() throws Exception { public void testSanitizedAddress() throws Exception {
int fakeSubAddr = 0x2b00; // 43.0. int fakeSubAddr = 0x2b00; // 43.0.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr);
LinkAddress actualAddress = mPrivateAddressCoordinator.requestDownstreamAddress( LinkAddress actualAddress = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, false /* useLastAddress */); false /* useLastAddress */);
assertEquals(new LinkAddress("192.168.43.2/24"), actualAddress); assertEquals(new LinkAddress("192.168.43.2/24"), actualAddress);
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
fakeSubAddr = 0x2d01; // 45.1. fakeSubAddr = 0x2d01; // 45.1.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr);
actualAddress = mPrivateAddressCoordinator.requestDownstreamAddress( actualAddress = requestDownstreamAddress(mHotspotIpServer, false /* useLastAddress */);
mHotspotIpServer, false /* useLastAddress */);
assertEquals(new LinkAddress("192.168.45.2/24"), actualAddress); assertEquals(new LinkAddress("192.168.45.2/24"), actualAddress);
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
fakeSubAddr = 0x2eff; // 46.255. fakeSubAddr = 0x2eff; // 46.255.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr);
actualAddress = mPrivateAddressCoordinator.requestDownstreamAddress( actualAddress = requestDownstreamAddress(mHotspotIpServer, false /* useLastAddress */);
mHotspotIpServer, false /* useLastAddress */);
assertEquals(new LinkAddress("192.168.46.254/24"), actualAddress); assertEquals(new LinkAddress("192.168.46.254/24"), actualAddress);
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
fakeSubAddr = 0x2f05; // 47.5. fakeSubAddr = 0x2f05; // 47.5.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeSubAddr);
actualAddress = mPrivateAddressCoordinator.requestDownstreamAddress( actualAddress = requestDownstreamAddress(mHotspotIpServer, false /* useLastAddress */);
mHotspotIpServer, false /* useLastAddress */);
assertEquals(new LinkAddress("192.168.47.5/24"), actualAddress); assertEquals(new LinkAddress("192.168.47.5/24"), actualAddress);
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
} }
@@ -164,8 +167,8 @@ public final class PrivateAddressCoordinatorTest {
// - Test bluetooth prefix is reserved. // - Test bluetooth prefix is reserved.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn( when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(
getSubAddress(mBluetoothAddress.getAddress().getAddress())); getSubAddress(mBluetoothAddress.getAddress().getAddress()));
final LinkAddress hotspotAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress hotspotAddress = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, false /* useLastAddress */); false /* useLastAddress */);
final IpPrefix hotspotPrefix = asIpPrefix(hotspotAddress); final IpPrefix hotspotPrefix = asIpPrefix(hotspotAddress);
assertNotEquals(asIpPrefix(mBluetoothAddress), hotspotPrefix); assertNotEquals(asIpPrefix(mBluetoothAddress), hotspotPrefix);
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
@@ -173,8 +176,8 @@ public final class PrivateAddressCoordinatorTest {
// - Test previous enabled hotspot prefix(cached prefix) is reserved. // - Test previous enabled hotspot prefix(cached prefix) is reserved.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn( when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(
getSubAddress(hotspotAddress.getAddress().getAddress())); getSubAddress(hotspotAddress.getAddress().getAddress()));
final LinkAddress usbAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress usbAddress = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, false /* useLastAddress */); false /* useLastAddress */);
final IpPrefix usbPrefix = asIpPrefix(usbAddress); final IpPrefix usbPrefix = asIpPrefix(usbAddress);
assertNotEquals(asIpPrefix(mBluetoothAddress), usbPrefix); assertNotEquals(asIpPrefix(mBluetoothAddress), usbPrefix);
assertNotEquals(hotspotPrefix, usbPrefix); assertNotEquals(hotspotPrefix, usbPrefix);
@@ -183,8 +186,8 @@ public final class PrivateAddressCoordinatorTest {
// - Test wifi p2p prefix is reserved. // - Test wifi p2p prefix is reserved.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn( when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(
getSubAddress(mLegacyWifiP2pAddress.getAddress().getAddress())); getSubAddress(mLegacyWifiP2pAddress.getAddress().getAddress()));
final LinkAddress etherAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress etherAddress = requestDownstreamAddress(mEthernetIpServer,
mEthernetIpServer, false /* useLastAddress */); false /* useLastAddress */);
final IpPrefix etherPrefix = asIpPrefix(etherAddress); final IpPrefix etherPrefix = asIpPrefix(etherAddress);
assertNotEquals(asIpPrefix(mLegacyWifiP2pAddress), etherPrefix); assertNotEquals(asIpPrefix(mLegacyWifiP2pAddress), etherPrefix);
assertNotEquals(asIpPrefix(mBluetoothAddress), etherPrefix); assertNotEquals(asIpPrefix(mBluetoothAddress), etherPrefix);
@@ -196,13 +199,12 @@ public final class PrivateAddressCoordinatorTest {
public void testRequestLastDownstreamAddress() throws Exception { public void testRequestLastDownstreamAddress() throws Exception {
final int fakeHotspotSubAddr = 0x2b05; // 43.5 final int fakeHotspotSubAddr = 0x2b05; // 43.5
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeHotspotSubAddr); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeHotspotSubAddr);
final LinkAddress hotspotAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress hotspotAddress = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true /* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong wifi prefix: ", new LinkAddress("192.168.43.5/24"), hotspotAddress); assertEquals("Wrong wifi prefix: ", new LinkAddress("192.168.43.5/24"), hotspotAddress);
when(mHotspotIpServer.getAddress()).thenReturn(hotspotAddress);
final LinkAddress usbAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress usbAddress = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, true /* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong wifi prefix: ", new LinkAddress("192.168.45.5/24"), usbAddress); assertEquals("Wrong wifi prefix: ", new LinkAddress("192.168.45.5/24"), usbAddress);
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
@@ -211,24 +213,19 @@ public final class PrivateAddressCoordinatorTest {
final int newFakeSubAddr = 0x3c05; final int newFakeSubAddr = 0x3c05;
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeHotspotSubAddr); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeHotspotSubAddr);
final LinkAddress newHotspotAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress newHotspotAddress = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true /* useLastAddress */); true /* useLastAddress */);
assertEquals(hotspotAddress, newHotspotAddress); assertEquals(hotspotAddress, newHotspotAddress);
final LinkAddress newUsbAddress = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress newUsbAddress = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, true /* useLastAddress */); true /* useLastAddress */);
assertEquals(usbAddress, newUsbAddress); assertEquals(usbAddress, newUsbAddress);
// BUG: the code should detect a conflict, but it doesn't.
// Regression introduced in r.android.com/168169687.
// Ensure conflict notification works when using cached address.
when(mHotspotIpServer.getAddress()).thenReturn(newHotspotAddress);
when(mUsbIpServer.getAddress()).thenReturn(usbAddress);
final UpstreamNetworkState wifiUpstream = buildUpstreamNetworkState(mWifiNetwork, final UpstreamNetworkState wifiUpstream = buildUpstreamNetworkState(mWifiNetwork,
new LinkAddress("192.168.88.23/16"), null, new LinkAddress("192.168.88.23/16"), null,
makeNetworkCapabilities(TRANSPORT_WIFI)); makeNetworkCapabilities(TRANSPORT_WIFI));
mPrivateAddressCoordinator.updateUpstreamPrefix(wifiUpstream); mPrivateAddressCoordinator.updateUpstreamPrefix(wifiUpstream);
verify(mHotspotIpServer, never()).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT); verify(mHotspotIpServer).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT);
verify(mUsbIpServer, never()).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT); verify(mUsbIpServer).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT);
} }
private UpstreamNetworkState buildUpstreamNetworkState(final Network network, private UpstreamNetworkState buildUpstreamNetworkState(final Network network,
@@ -259,11 +256,10 @@ public final class PrivateAddressCoordinatorTest {
// Force always get subAddress "43.5" for conflict testing. // Force always get subAddress "43.5" for conflict testing.
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeHotspotSubAddr); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(fakeHotspotSubAddr);
// - Enable hotspot with prefix 192.168.43.0/24 // - Enable hotspot with prefix 192.168.43.0/24
final LinkAddress hotspotAddr = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress hotspotAddr = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true /* useLastAddress */); true /* useLastAddress */);
final IpPrefix hotspotPrefix = asIpPrefix(hotspotAddr); final IpPrefix hotspotPrefix = asIpPrefix(hotspotAddr);
assertEquals("Wrong wifi prefix: ", predefinedPrefix, hotspotPrefix); assertEquals("Wrong wifi prefix: ", predefinedPrefix, hotspotPrefix);
when(mHotspotIpServer.getAddress()).thenReturn(hotspotAddr);
// - test mobile network with null NetworkCapabilities. Ideally this should not happen // - test mobile network with null NetworkCapabilities. Ideally this should not happen
// because NetworkCapabilities update should always happen before LinkProperties update // because NetworkCapabilities update should always happen before LinkProperties update
// and the UpstreamNetworkState update, just make sure no crash in this case. // and the UpstreamNetworkState update, just make sure no crash in this case.
@@ -314,24 +310,22 @@ public final class PrivateAddressCoordinatorTest {
reset(mHotspotIpServer); reset(mHotspotIpServer);
// - Restart hotspot again and its prefix is different previous. // - Restart hotspot again and its prefix is different previous.
mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer); mPrivateAddressCoordinator.releaseDownstream(mHotspotIpServer);
final LinkAddress hotspotAddr2 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress hotspotAddr2 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true /* useLastAddress */); true /* useLastAddress */);
final IpPrefix hotspotPrefix2 = asIpPrefix(hotspotAddr2); final IpPrefix hotspotPrefix2 = asIpPrefix(hotspotAddr2);
assertNotEquals(hotspotPrefix, hotspotPrefix2); assertNotEquals(hotspotPrefix, hotspotPrefix2);
when(mHotspotIpServer.getAddress()).thenReturn(hotspotAddr2);
mPrivateAddressCoordinator.updateUpstreamPrefix(v4OnlyWifi); mPrivateAddressCoordinator.updateUpstreamPrefix(v4OnlyWifi);
verify(mHotspotIpServer, never()).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT); verify(mHotspotIpServer, never()).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT);
// - Usb tethering can be enabled and its prefix is different with conflict one. // - Usb tethering can be enabled and its prefix is different with conflict one.
final LinkAddress usbAddr = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress usbAddr = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, true /* useLastAddress */); true /* useLastAddress */);
final IpPrefix usbPrefix = asIpPrefix(usbAddr); final IpPrefix usbPrefix = asIpPrefix(usbAddr);
assertNotEquals(predefinedPrefix, usbPrefix); assertNotEquals(predefinedPrefix, usbPrefix);
assertNotEquals(hotspotPrefix2, usbPrefix); assertNotEquals(hotspotPrefix2, usbPrefix);
when(mUsbIpServer.getAddress()).thenReturn(usbAddr);
// - Disable wifi upstream, then wifi's prefix can be selected again. // - Disable wifi upstream, then wifi's prefix can be selected again.
mPrivateAddressCoordinator.removeUpstreamPrefix(mWifiNetwork); mPrivateAddressCoordinator.removeUpstreamPrefix(mWifiNetwork);
final LinkAddress ethAddr = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress ethAddr = requestDownstreamAddress(mEthernetIpServer,
mEthernetIpServer, true /* useLastAddress */); true /* useLastAddress */);
final IpPrefix ethPrefix = asIpPrefix(ethAddr); final IpPrefix ethPrefix = asIpPrefix(ethAddr);
assertEquals(predefinedPrefix, ethPrefix); assertEquals(predefinedPrefix, ethPrefix);
} }
@@ -340,21 +334,19 @@ public final class PrivateAddressCoordinatorTest {
public void testChooseAvailablePrefix() throws Exception { public void testChooseAvailablePrefix() throws Exception {
final int randomAddress = 0x8605; // 134.5 final int randomAddress = 0x8605; // 134.5
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(randomAddress); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(randomAddress);
final LinkAddress addr0 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr0 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
// Check whether return address is prefix 192.168.0.0/16 + subAddress 0.0.134.5. // Check whether return address is prefix 192.168.0.0/16 + subAddress 0.0.134.5.
assertEquals("Wrong prefix: ", new LinkAddress("192.168.134.5/24"), addr0); assertEquals("Wrong prefix: ", new LinkAddress("192.168.134.5/24"), addr0);
when(mHotspotIpServer.getAddress()).thenReturn(addr0);
final UpstreamNetworkState wifiUpstream = buildUpstreamNetworkState(mWifiNetwork, final UpstreamNetworkState wifiUpstream = buildUpstreamNetworkState(mWifiNetwork,
new LinkAddress("192.168.134.13/26"), null, new LinkAddress("192.168.134.13/26"), null,
makeNetworkCapabilities(TRANSPORT_WIFI)); makeNetworkCapabilities(TRANSPORT_WIFI));
mPrivateAddressCoordinator.updateUpstreamPrefix(wifiUpstream); mPrivateAddressCoordinator.updateUpstreamPrefix(wifiUpstream);
// Check whether return address is next prefix of 192.168.134.0/24. // Check whether return address is next prefix of 192.168.134.0/24.
final LinkAddress addr1 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr1 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.135.5/24"), addr1); assertEquals("Wrong prefix: ", new LinkAddress("192.168.135.5/24"), addr1);
when(mHotspotIpServer.getAddress()).thenReturn(addr1);
final UpstreamNetworkState wifiUpstream2 = buildUpstreamNetworkState(mWifiNetwork, final UpstreamNetworkState wifiUpstream2 = buildUpstreamNetworkState(mWifiNetwork,
new LinkAddress("192.168.149.16/19"), null, new LinkAddress("192.168.149.16/19"), null,
makeNetworkCapabilities(TRANSPORT_WIFI)); makeNetworkCapabilities(TRANSPORT_WIFI));
@@ -362,10 +354,9 @@ public final class PrivateAddressCoordinatorTest {
// The conflict range is 128 ~ 159, so the address is 192.168.160.5/24. // The conflict range is 128 ~ 159, so the address is 192.168.160.5/24.
final LinkAddress addr2 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr2 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.160.5/24"), addr2); assertEquals("Wrong prefix: ", new LinkAddress("192.168.160.5/24"), addr2);
when(mHotspotIpServer.getAddress()).thenReturn(addr2);
final UpstreamNetworkState mobileUpstream = buildUpstreamNetworkState(mMobileNetwork, final UpstreamNetworkState mobileUpstream = buildUpstreamNetworkState(mMobileNetwork,
new LinkAddress("192.168.129.53/18"), null, new LinkAddress("192.168.129.53/18"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -378,10 +369,9 @@ public final class PrivateAddressCoordinatorTest {
mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream2); mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream2);
// The conflict range are 128 ~ 159 and 159 ~ 191, so the address is 192.168.192.5/24. // The conflict range are 128 ~ 159 and 159 ~ 191, so the address is 192.168.192.5/24.
final LinkAddress addr3 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr3 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.192.5/24"), addr3); assertEquals("Wrong prefix: ", new LinkAddress("192.168.192.5/24"), addr3);
when(mHotspotIpServer.getAddress()).thenReturn(addr3);
final UpstreamNetworkState mobileUpstream3 = buildUpstreamNetworkState(mMobileNetwork3, final UpstreamNetworkState mobileUpstream3 = buildUpstreamNetworkState(mMobileNetwork3,
new LinkAddress("192.168.188.133/17"), null, new LinkAddress("192.168.188.133/17"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -389,20 +379,18 @@ public final class PrivateAddressCoordinatorTest {
// Conflict range: 128 ~ 255. The next available address is 192.168.0.5 because // Conflict range: 128 ~ 255. The next available address is 192.168.0.5 because
// 192.168.134/24 ~ 192.168.255.255/24 is not available. // 192.168.134/24 ~ 192.168.255.255/24 is not available.
final LinkAddress addr4 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr4 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.0.5/24"), addr4); assertEquals("Wrong prefix: ", new LinkAddress("192.168.0.5/24"), addr4);
when(mHotspotIpServer.getAddress()).thenReturn(addr4);
final UpstreamNetworkState mobileUpstream4 = buildUpstreamNetworkState(mMobileNetwork4, final UpstreamNetworkState mobileUpstream4 = buildUpstreamNetworkState(mMobileNetwork4,
new LinkAddress("192.168.3.59/21"), null, new LinkAddress("192.168.3.59/21"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream4); mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream4);
// Conflict ranges: 128 ~ 255 and 0 ~ 7, so the address is 192.168.8.5/24. // Conflict ranges: 128 ~ 255 and 0 ~ 7, so the address is 192.168.8.5/24.
final LinkAddress addr5 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr5 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.8.5/24"), addr5); assertEquals("Wrong prefix: ", new LinkAddress("192.168.8.5/24"), addr5);
when(mHotspotIpServer.getAddress()).thenReturn(addr5);
final UpstreamNetworkState mobileUpstream5 = buildUpstreamNetworkState(mMobileNetwork5, final UpstreamNetworkState mobileUpstream5 = buildUpstreamNetworkState(mMobileNetwork5,
new LinkAddress("192.168.68.43/21"), null, new LinkAddress("192.168.68.43/21"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -410,41 +398,37 @@ public final class PrivateAddressCoordinatorTest {
// Update an upstream that does *not* conflict, check whether return the same address // Update an upstream that does *not* conflict, check whether return the same address
// 192.168.5/24. // 192.168.5/24.
final LinkAddress addr6 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr6 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.8.5/24"), addr6); assertEquals("Wrong prefix: ", new LinkAddress("192.168.8.5/24"), addr6);
when(mHotspotIpServer.getAddress()).thenReturn(addr6);
final UpstreamNetworkState mobileUpstream6 = buildUpstreamNetworkState(mMobileNetwork6, final UpstreamNetworkState mobileUpstream6 = buildUpstreamNetworkState(mMobileNetwork6,
new LinkAddress("192.168.10.97/21"), null, new LinkAddress("192.168.10.97/21"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream6); mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream6);
// Conflict ranges: 0 ~ 15 and 128 ~ 255, so the address is 192.168.16.5/24. // Conflict ranges: 0 ~ 15 and 128 ~ 255, so the address is 192.168.16.5/24.
final LinkAddress addr7 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr7 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.16.5/24"), addr7); assertEquals("Wrong prefix: ", new LinkAddress("192.168.16.5/24"), addr7);
when(mHotspotIpServer.getAddress()).thenReturn(addr7);
final UpstreamNetworkState mobileUpstream7 = buildUpstreamNetworkState(mMobileNetwork6, final UpstreamNetworkState mobileUpstream7 = buildUpstreamNetworkState(mMobileNetwork6,
new LinkAddress("192.168.0.0/17"), null, new LinkAddress("192.168.0.0/17"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream7); mPrivateAddressCoordinator.updateUpstreamPrefix(mobileUpstream7);
// Choose prefix from next range(172.16.0.0/12) when no available prefix in 192.168.0.0/16. // Choose prefix from next range(172.16.0.0/12) when no available prefix in 192.168.0.0/16.
final LinkAddress addr8 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress addr8 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("172.16.134.5/24"), addr8); assertEquals("Wrong prefix: ", new LinkAddress("172.16.134.5/24"), addr8);
when(mHotspotIpServer.getAddress()).thenReturn(addr6);
} }
@Test @Test
public void testChoosePrefixFromDifferentRanges() throws Exception { public void testChoosePrefixFromDifferentRanges() throws Exception {
final int randomAddress = 0x1f2b2a; // 31.43.42 final int randomAddress = 0x1f2b2a; // 31.43.42
when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(randomAddress); when(mPrivateAddressCoordinator.getRandomInt()).thenReturn(randomAddress);
final LinkAddress classC1 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classC1 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
// Check whether return address is prefix 192.168.0.0/16 + subAddress 0.0.43.42. // Check whether return address is prefix 192.168.0.0/16 + subAddress 0.0.43.42.
assertEquals("Wrong prefix: ", new LinkAddress("192.168.43.42/24"), classC1); assertEquals("Wrong prefix: ", new LinkAddress("192.168.43.42/24"), classC1);
when(mHotspotIpServer.getAddress()).thenReturn(classC1);
final UpstreamNetworkState wifiUpstream = buildUpstreamNetworkState(mWifiNetwork, final UpstreamNetworkState wifiUpstream = buildUpstreamNetworkState(mWifiNetwork,
new LinkAddress("192.168.88.23/17"), null, new LinkAddress("192.168.88.23/17"), null,
makeNetworkCapabilities(TRANSPORT_WIFI)); makeNetworkCapabilities(TRANSPORT_WIFI));
@@ -452,10 +436,9 @@ public final class PrivateAddressCoordinatorTest {
verifyNotifyConflictAndRelease(mHotspotIpServer); verifyNotifyConflictAndRelease(mHotspotIpServer);
// Check whether return address is next address of prefix 192.168.128.0/17. // Check whether return address is next address of prefix 192.168.128.0/17.
final LinkAddress classC2 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classC2 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("192.168.128.42/24"), classC2); assertEquals("Wrong prefix: ", new LinkAddress("192.168.128.42/24"), classC2);
when(mHotspotIpServer.getAddress()).thenReturn(classC2);
final UpstreamNetworkState mobileUpstream = buildUpstreamNetworkState(mMobileNetwork, final UpstreamNetworkState mobileUpstream = buildUpstreamNetworkState(mMobileNetwork,
new LinkAddress("192.1.2.3/8"), null, new LinkAddress("192.1.2.3/8"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -463,10 +446,9 @@ public final class PrivateAddressCoordinatorTest {
verifyNotifyConflictAndRelease(mHotspotIpServer); verifyNotifyConflictAndRelease(mHotspotIpServer);
// Check whether return address is under prefix 172.16.0.0/12. // Check whether return address is under prefix 172.16.0.0/12.
final LinkAddress classB1 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classB1 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("172.31.43.42/24"), classB1); assertEquals("Wrong prefix: ", new LinkAddress("172.31.43.42/24"), classB1);
when(mHotspotIpServer.getAddress()).thenReturn(classB1);
final UpstreamNetworkState mobileUpstream2 = buildUpstreamNetworkState(mMobileNetwork2, final UpstreamNetworkState mobileUpstream2 = buildUpstreamNetworkState(mMobileNetwork2,
new LinkAddress("172.28.123.100/14"), null, new LinkAddress("172.28.123.100/14"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -475,16 +457,14 @@ public final class PrivateAddressCoordinatorTest {
// 172.28.0.0 ~ 172.31.255.255 is not available. // 172.28.0.0 ~ 172.31.255.255 is not available.
// Check whether return address is next address of prefix 172.16.0.0/14. // Check whether return address is next address of prefix 172.16.0.0/14.
final LinkAddress classB2 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classB2 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("172.16.0.42/24"), classB2); assertEquals("Wrong prefix: ", new LinkAddress("172.16.0.42/24"), classB2);
when(mHotspotIpServer.getAddress()).thenReturn(classB2);
// Check whether new downstream is next address of address 172.16.0.42/24. // Check whether new downstream is next address of address 172.16.0.42/24.
final LinkAddress classB3 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classB3 = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("172.16.1.42/24"), classB3); assertEquals("Wrong prefix: ", new LinkAddress("172.16.1.42/24"), classB3);
when(mUsbIpServer.getAddress()).thenReturn(classB3);
final UpstreamNetworkState mobileUpstream3 = buildUpstreamNetworkState(mMobileNetwork3, final UpstreamNetworkState mobileUpstream3 = buildUpstreamNetworkState(mMobileNetwork3,
new LinkAddress("172.16.0.1/24"), null, new LinkAddress("172.16.0.1/24"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -493,10 +473,9 @@ public final class PrivateAddressCoordinatorTest {
verify(mUsbIpServer, never()).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT); verify(mUsbIpServer, never()).sendMessage(IpServer.CMD_NOTIFY_PREFIX_CONFLICT);
// Check whether return address is next address of prefix 172.16.1.42/24. // Check whether return address is next address of prefix 172.16.1.42/24.
final LinkAddress classB4 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classB4 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("172.16.2.42/24"), classB4); assertEquals("Wrong prefix: ", new LinkAddress("172.16.2.42/24"), classB4);
when(mHotspotIpServer.getAddress()).thenReturn(classB4);
final UpstreamNetworkState mobileUpstream4 = buildUpstreamNetworkState(mMobileNetwork4, final UpstreamNetworkState mobileUpstream4 = buildUpstreamNetworkState(mMobileNetwork4,
new LinkAddress("172.16.0.1/13"), null, new LinkAddress("172.16.0.1/13"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -505,15 +484,13 @@ public final class PrivateAddressCoordinatorTest {
verifyNotifyConflictAndRelease(mUsbIpServer); verifyNotifyConflictAndRelease(mUsbIpServer);
// Check whether return address is next address of prefix 172.16.0.1/13. // Check whether return address is next address of prefix 172.16.0.1/13.
final LinkAddress classB5 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classB5 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("172.24.0.42/24"), classB5); assertEquals("Wrong prefix: ", new LinkAddress("172.24.0.42/24"), classB5);
when(mHotspotIpServer.getAddress()).thenReturn(classB5);
// Check whether return address is next address of prefix 172.24.0.42/24. // Check whether return address is next address of prefix 172.24.0.42/24.
final LinkAddress classB6 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classB6 = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("172.24.1.42/24"), classB6); assertEquals("Wrong prefix: ", new LinkAddress("172.24.1.42/24"), classB6);
when(mUsbIpServer.getAddress()).thenReturn(classB6);
final UpstreamNetworkState mobileUpstream5 = buildUpstreamNetworkState(mMobileNetwork5, final UpstreamNetworkState mobileUpstream5 = buildUpstreamNetworkState(mMobileNetwork5,
new LinkAddress("172.24.0.1/12"), null, new LinkAddress("172.24.0.1/12"), null,
makeNetworkCapabilities(TRANSPORT_CELLULAR)); makeNetworkCapabilities(TRANSPORT_CELLULAR));
@@ -522,13 +499,12 @@ public final class PrivateAddressCoordinatorTest {
verifyNotifyConflictAndRelease(mUsbIpServer); verifyNotifyConflictAndRelease(mUsbIpServer);
// Check whether return address is prefix 10.0.0.0/8 + subAddress 0.31.43.42. // Check whether return address is prefix 10.0.0.0/8 + subAddress 0.31.43.42.
final LinkAddress classA1 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classA1 = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("10.31.43.42/24"), classA1); assertEquals("Wrong prefix: ", new LinkAddress("10.31.43.42/24"), classA1);
when(mHotspotIpServer.getAddress()).thenReturn(classA1);
// Check whether new downstream is next address of address 10.31.43.42/24. // Check whether new downstream is next address of address 10.31.43.42/24.
final LinkAddress classA2 = mPrivateAddressCoordinator.requestDownstreamAddress( final LinkAddress classA2 = requestDownstreamAddress(mUsbIpServer,
mUsbIpServer, true/* useLastAddress */); true /* useLastAddress */);
assertEquals("Wrong prefix: ", new LinkAddress("10.31.44.42/24"), classA2); assertEquals("Wrong prefix: ", new LinkAddress("10.31.44.42/24"), classA2);
} }
@@ -547,8 +523,8 @@ public final class PrivateAddressCoordinatorTest {
} }
private void assertReseveredWifiP2pPrefix() throws Exception { private void assertReseveredWifiP2pPrefix() throws Exception {
LinkAddress address = mPrivateAddressCoordinator.requestDownstreamAddress( LinkAddress address = requestDownstreamAddress(mHotspotIpServer,
mHotspotIpServer, true /* useLastAddress */); true /* useLastAddress */);
final IpPrefix hotspotPrefix = asIpPrefix(address); final IpPrefix hotspotPrefix = asIpPrefix(address);
final IpPrefix legacyWifiP2pPrefix = asIpPrefix(mLegacyWifiP2pAddress); final IpPrefix legacyWifiP2pPrefix = asIpPrefix(mLegacyWifiP2pAddress);
assertNotEquals(legacyWifiP2pPrefix, hotspotPrefix); assertNotEquals(legacyWifiP2pPrefix, hotspotPrefix);
@@ -567,8 +543,8 @@ public final class PrivateAddressCoordinatorTest {
assertReseveredWifiP2pPrefix(); assertReseveredWifiP2pPrefix();
// If #shouldEnableWifiP2pDedicatedIp() is enabled, wifi P2P gets the configured address. // If #shouldEnableWifiP2pDedicatedIp() is enabled, wifi P2P gets the configured address.
LinkAddress address = mPrivateAddressCoordinator.requestDownstreamAddress( LinkAddress address = requestDownstreamAddress(mWifiP2pIpServer,
mWifiP2pIpServer, true /* useLastAddress */); true /* useLastAddress */);
assertEquals(mLegacyWifiP2pAddress, address); assertEquals(mLegacyWifiP2pAddress, address);
mPrivateAddressCoordinator.releaseDownstream(mWifiP2pIpServer); mPrivateAddressCoordinator.releaseDownstream(mWifiP2pIpServer);
} }