Merge "Remove unnecessary cts tag." into udc-dev
diff --git a/Cronet/tests/cts/Android.bp b/Cronet/tests/cts/Android.bp
index 44b3364..a0b2434 100644
--- a/Cronet/tests/cts/Android.bp
+++ b/Cronet/tests/cts/Android.bp
@@ -37,6 +37,7 @@
"junit",
"kotlin-test",
"mockito-target",
+ "net-tests-utils",
"truth",
],
libs: [
@@ -53,7 +54,9 @@
defaults: [
"cts_defaults",
],
+ enforce_default_target_sdk_version: true,
sdk_version: "test_current",
+ min_sdk_version: "30",
static_libs: ["CtsNetHttpTestsLib"],
// Tag this as a cts test artifact
test_suites: [
diff --git a/Cronet/tests/cts/src/android/net/http/cts/BidirectionalStreamTest.kt b/Cronet/tests/cts/src/android/net/http/cts/BidirectionalStreamTest.kt
index bead1f8..0760e68 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/BidirectionalStreamTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/BidirectionalStreamTest.kt
@@ -23,8 +23,10 @@
import android.net.http.cts.util.TestBidirectionalStreamCallback.ResponseStep
import android.net.http.cts.util.assumeOKStatusCode
import android.net.http.cts.util.skipIfNoInternetConnection
+import android.os.Build
import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import kotlin.test.Test
import kotlin.test.assertEquals
import org.hamcrest.MatcherAssert
@@ -39,7 +41,8 @@
* This tests uses a non-hermetic server. Instead of asserting, assume the next callback. This way,
* if the request were to fail, the test would just be skipped instead of failing.
*/
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class BidirectionalStreamTest {
private val context: Context = ApplicationProvider.getApplicationContext()
private val callback = TestBidirectionalStreamCallback()
diff --git a/Cronet/tests/cts/src/android/net/http/cts/CallbackExceptionTest.kt b/Cronet/tests/cts/src/android/net/http/cts/CallbackExceptionTest.kt
index 749389e..1405ed9 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/CallbackExceptionTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/CallbackExceptionTest.kt
@@ -23,8 +23,10 @@
import android.net.http.cts.util.TestUrlRequestCallback
import android.net.http.cts.util.TestUrlRequestCallback.FailureType
import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep
+import android.os.Build
import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertIs
@@ -32,7 +34,8 @@
import kotlin.test.assertTrue
import org.junit.runner.RunWith
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class CallbackExceptionTest {
@Test
diff --git a/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
index 219db61..10c7f3c 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/ConnectionMigrationOptionsTest.kt
@@ -19,12 +19,15 @@
import android.net.http.ConnectionMigrationOptions
import android.net.http.ConnectionMigrationOptions.MIGRATION_OPTION_ENABLED
import android.net.http.ConnectionMigrationOptions.MIGRATION_OPTION_UNSPECIFIED
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import android.os.Build
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import kotlin.test.Test
import kotlin.test.assertEquals
import org.junit.runner.RunWith
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class ConnectionMigrationOptionsTest {
@Test
diff --git a/Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt
index 6f4a979..56802c6 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/DnsOptionsTest.kt
@@ -19,7 +19,9 @@
import android.net.http.DnsOptions
import android.net.http.DnsOptions.DNS_OPTION_ENABLED
import android.net.http.DnsOptions.DNS_OPTION_UNSPECIFIED
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import android.os.Build
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import java.time.Duration
import kotlin.test.Test
import kotlin.test.assertEquals
@@ -27,7 +29,8 @@
import kotlin.test.assertNull
import org.junit.runner.RunWith
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class DnsOptionsTest {
@Test
diff --git a/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java b/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
index 31990fb..9fc4389 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/HttpEngineTest.java
@@ -40,9 +40,12 @@
import android.net.http.cts.util.HttpCtsTestServer;
import android.net.http.cts.util.TestUrlRequestCallback;
import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
+import android.os.Build;
import androidx.test.core.app.ApplicationProvider;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.testutils.DevSdkIgnoreRule;
+import com.android.testutils.DevSdkIgnoreRunner;
import org.junit.After;
import org.junit.Before;
@@ -55,7 +58,8 @@
import java.util.Calendar;
import java.util.Set;
-@RunWith(AndroidJUnit4.class)
+@RunWith(DevSdkIgnoreRunner.class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
public class HttpEngineTest {
private static final String HOST = "source.android.com";
private static final String URL = "https://" + HOST;
diff --git a/Cronet/tests/cts/src/android/net/http/cts/NetworkExceptionTest.kt b/Cronet/tests/cts/src/android/net/http/cts/NetworkExceptionTest.kt
index dd4cf0d..cff54b3 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/NetworkExceptionTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/NetworkExceptionTest.kt
@@ -19,8 +19,10 @@
import android.net.http.HttpEngine
import android.net.http.NetworkException
import android.net.http.cts.util.TestUrlRequestCallback
+import android.os.Build
import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import kotlin.test.assertEquals
import kotlin.test.assertIs
import kotlin.test.assertSame
@@ -28,7 +30,8 @@
import org.junit.Test
import org.junit.runner.RunWith
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class NetworkExceptionTest {
@Test
diff --git a/Cronet/tests/cts/src/android/net/http/cts/QuicExceptionTest.kt b/Cronet/tests/cts/src/android/net/http/cts/QuicExceptionTest.kt
index 4b7aa14..2705fc3 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/QuicExceptionTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/QuicExceptionTest.kt
@@ -17,12 +17,15 @@
package android.net.http.cts
import android.net.http.QuicException
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import android.os.Build
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import kotlin.test.Test
import kotlin.test.assertEquals
import org.junit.runner.RunWith
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class QuicExceptionTest {
@Test
diff --git a/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt b/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt
index 0b02aa7..da0b15c 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/QuicOptionsTest.kt
@@ -16,7 +16,9 @@
package android.net.http.cts
import android.net.http.QuicOptions
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import android.os.Build
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import com.google.common.truth.Truth.assertThat
import java.time.Duration
import kotlin.test.assertFailsWith
@@ -25,7 +27,8 @@
import org.junit.Test
import org.junit.runner.RunWith
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class QuicOptionsTest {
@Test
fun testQuicOptions_defaultValues() {
diff --git a/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
index 422f4d5..07e7d45 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
+++ b/Cronet/tests/cts/src/android/net/http/cts/UrlRequestTest.java
@@ -42,12 +42,15 @@
import android.net.http.cts.util.TestUrlRequestCallback;
import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep;
import android.net.http.cts.util.UploadDataProviders;
+import android.os.Build;
import android.webkit.cts.CtsTestServer;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.test.core.app.ApplicationProvider;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.testutils.DevSdkIgnoreRule;
+import com.android.testutils.DevSdkIgnoreRunner;
import com.google.common.base.Strings;
@@ -70,7 +73,8 @@
import java.util.stream.Collectors;
import java.util.stream.Stream;
-@RunWith(AndroidJUnit4.class)
+@RunWith(DevSdkIgnoreRunner.class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
public class UrlRequestTest {
private static final Executor DIRECT_EXECUTOR = Runnable::run;
diff --git a/Cronet/tests/cts/src/android/net/http/cts/UrlResponseInfoTest.kt b/Cronet/tests/cts/src/android/net/http/cts/UrlResponseInfoTest.kt
index 38da9c5..f1b57c6 100644
--- a/Cronet/tests/cts/src/android/net/http/cts/UrlResponseInfoTest.kt
+++ b/Cronet/tests/cts/src/android/net/http/cts/UrlResponseInfoTest.kt
@@ -21,15 +21,18 @@
import android.net.http.cts.util.HttpCtsTestServer
import android.net.http.cts.util.TestUrlRequestCallback
import android.net.http.cts.util.TestUrlRequestCallback.ResponseStep
+import android.os.Build
import androidx.test.core.app.ApplicationProvider
-import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.testutils.DevSdkIgnoreRule
+import com.android.testutils.DevSdkIgnoreRunner
import kotlin.test.Test
import kotlin.test.assertEquals
import kotlin.test.assertFalse
import kotlin.test.assertTrue
import org.junit.runner.RunWith
-@RunWith(AndroidJUnit4::class)
+@RunWith(DevSdkIgnoreRunner::class)
+@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.R)
class UrlResponseInfoTest {
@Test
diff --git a/framework/src/android/net/ProxyInfo.java b/framework/src/android/net/ProxyInfo.java
index 0deda37..adf2376 100644
--- a/framework/src/android/net/ProxyInfo.java
+++ b/framework/src/android/net/ProxyInfo.java
@@ -47,6 +47,8 @@
private final int mPort;
private final String mExclusionList;
private final String[] mParsedExclusionList;
+ // Uri.EMPTY if none.
+ @NonNull
private final Uri mPacFileUrl;
/**
@@ -256,6 +258,14 @@
return proxy;
}
+ /**
+ * @hide
+ * @return whether this proxy uses a Proxy Auto Configuration URL.
+ */
+ public boolean isPacProxy() {
+ return !Uri.EMPTY.equals(mPacFileUrl);
+ }
+
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 5e225c1..f85f336 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -34,6 +34,7 @@
import static android.net.ConnectivityManager.BLOCKED_METERED_REASON_MASK;
import static android.net.ConnectivityManager.BLOCKED_REASON_LOCKDOWN_VPN;
import static android.net.ConnectivityManager.BLOCKED_REASON_NONE;
+import static android.net.ConnectivityManager.CALLBACK_IP_CHANGED;
import static android.net.ConnectivityManager.CONNECTIVITY_ACTION;
import static android.net.ConnectivityManager.FIREWALL_RULE_ALLOW;
import static android.net.ConnectivityManager.FIREWALL_RULE_DEFAULT;
@@ -552,7 +553,7 @@
/**
* PAC manager has received new port.
*/
- private static final int EVENT_PROXY_HAS_CHANGED = 16;
+ private static final int EVENT_PAC_PROXY_HAS_CHANGED = 16;
/**
* used internally when registering NetworkProviders
@@ -865,8 +866,7 @@
// A helper object to track the current default HTTP proxy. ConnectivityService needs to tell
// the world when it changes.
- @VisibleForTesting
- protected final ProxyTracker mProxyTracker;
+ private final ProxyTracker mProxyTracker;
final private SettingsObserver mSettingsObserver;
@@ -1327,7 +1327,7 @@
*/
public ProxyTracker makeProxyTracker(@NonNull Context context,
@NonNull Handler connServiceHandler) {
- return new ProxyTracker(context, connServiceHandler, EVENT_PROXY_HAS_CHANGED);
+ return new ProxyTracker(context, connServiceHandler, EVENT_PAC_PROXY_HAS_CHANGED);
}
/**
@@ -1893,6 +1893,13 @@
mHandler.sendEmptyMessage(EVENT_INGRESS_RATE_LIMIT_CHANGED);
}
+ @VisibleForTesting
+ void simulateUpdateProxyInfo(@Nullable final Network network,
+ @NonNull final ProxyInfo proxyInfo) {
+ Message.obtain(mHandler, EVENT_PAC_PROXY_HAS_CHANGED,
+ new Pair<>(network, proxyInfo)).sendToTarget();
+ }
+
private void handleAlwaysOnNetworkRequest(
NetworkRequest networkRequest, String settingName, boolean defaultValue) {
final boolean enable = toBool(Settings.Global.getInt(
@@ -4677,6 +4684,21 @@
rematchAllNetworksAndRequests();
mLingerMonitor.noteDisconnect(nai);
+ if (null == getDefaultNetwork() && nai.linkProperties.getHttpProxy() != null) {
+ // The obvious place to do this would be in makeDefault(), however makeDefault() is
+ // not called by the rematch in this case. This is because the code above unset
+ // this network from the default request's satisfier, and that is what the rematch
+ // is using as its source data to know what the old satisfier was. So as far as the
+ // rematch above is concerned, the old default network was null.
+ // Therefore if there is no new default, the default network was null and is still
+ // null, thus there was no change so makeDefault() is not called. So if the old
+ // network had a proxy and there is no new default, the proxy tracker should be told
+ // that there is no longer a default proxy.
+ // Strictly speaking this is not essential because having a proxy setting when
+ // there is no network is harmless, but it's still counter-intuitive so reset to null.
+ mProxyTracker.setDefaultProxy(null);
+ }
+
// Immediate teardown.
if (nai.teardownDelayMs == 0) {
destroyNetwork(nai);
@@ -5699,9 +5721,9 @@
mProxyTracker.loadDeprecatedGlobalHttpProxy();
break;
}
- case EVENT_PROXY_HAS_CHANGED: {
+ case EVENT_PAC_PROXY_HAS_CHANGED: {
final Pair<Network, ProxyInfo> arg = (Pair<Network, ProxyInfo>) msg.obj;
- handleApplyDefaultProxy(arg.second);
+ handlePacProxyServiceStarted(arg.first, arg.second);
break;
}
case EVENT_REGISTER_NETWORK_PROVIDER: {
@@ -6156,12 +6178,19 @@
return mProxyTracker.getGlobalProxy();
}
- private void handleApplyDefaultProxy(@Nullable ProxyInfo proxy) {
- if (proxy != null && TextUtils.isEmpty(proxy.getHost())
- && Uri.EMPTY.equals(proxy.getPacFileUrl())) {
- proxy = null;
- }
+ private void handlePacProxyServiceStarted(@Nullable Network net, @Nullable ProxyInfo proxy) {
mProxyTracker.setDefaultProxy(proxy);
+ final NetworkAgentInfo nai = getDefaultNetwork();
+ // TODO : this method should check that net == nai.network, unfortunately at this point
+ // 'net' is always null in practice (see PacProxyService#sendPacBroadcast). PAC proxy
+ // is only ever installed on the default network so in practice this is okay.
+ if (null == nai) return;
+ // PAC proxies only work on the default network. Therefore, only the default network
+ // should have its link properties fixed up for PAC proxies.
+ mProxyTracker.updateDefaultNetworkProxyPortForPAC(nai.linkProperties, nai.network);
+ if (nai.everConnected()) {
+ notifyNetworkCallbacks(nai, ConnectivityManager.CALLBACK_IP_CHANGED);
+ }
}
// If the proxy has changed from oldLp to newLp, resend proxy broadcast. This method gets called
@@ -7987,6 +8016,7 @@
// updateMtu(lp, null);
// }
if (isDefaultNetwork(networkAgent)) {
+ mProxyTracker.updateDefaultNetworkProxyPortForPAC(newLp, null);
updateTcpBufferSizes(newLp.getTcpBufferSizes());
}
@@ -7999,7 +8029,7 @@
mDnsManager.updatePrivateDnsStatus(netId, newLp);
if (isDefaultNetwork(networkAgent)) {
- handleApplyDefaultProxy(newLp.getHttpProxy());
+ mProxyTracker.setDefaultProxy(newLp.getHttpProxy());
} else if (networkAgent.everConnected()) {
updateProxy(newLp, oldLp);
}
@@ -9053,6 +9083,17 @@
}
}
+ private void resetHttpProxyForNonDefaultNetwork(NetworkAgentInfo oldDefaultNetwork) {
+ if (null == oldDefaultNetwork) return;
+ // The network stopped being the default. If it was using a PAC proxy, then the
+ // proxy needs to be reset, otherwise HTTP requests on this network may be sent
+ // to the local proxy server, which would forward them over the newly default network.
+ final ProxyInfo proxyInfo = oldDefaultNetwork.linkProperties.getHttpProxy();
+ if (null == proxyInfo || !proxyInfo.isPacProxy()) return;
+ oldDefaultNetwork.linkProperties.setHttpProxy(new ProxyInfo(proxyInfo.getPacFileUrl()));
+ notifyNetworkCallbacks(oldDefaultNetwork, CALLBACK_IP_CHANGED);
+ }
+
private void makeDefault(@NonNull final NetworkRequestInfo nri,
@Nullable final NetworkAgentInfo oldDefaultNetwork,
@Nullable final NetworkAgentInfo newDefaultNetwork) {
@@ -9078,8 +9119,9 @@
mLingerMonitor.noteLingerDefaultNetwork(oldDefaultNetwork, newDefaultNetwork);
}
mNetworkActivityTracker.updateDataActivityTracking(newDefaultNetwork, oldDefaultNetwork);
- handleApplyDefaultProxy(null != newDefaultNetwork
+ mProxyTracker.setDefaultProxy(null != newDefaultNetwork
? newDefaultNetwork.linkProperties.getHttpProxy() : null);
+ resetHttpProxyForNonDefaultNetwork(oldDefaultNetwork);
updateTcpBufferSizes(null != newDefaultNetwork
? newDefaultNetwork.linkProperties.getTcpBufferSizes() : null);
notifyIfacesChangedForNetworkStats();
diff --git a/service/src/com/android/server/connectivity/ProxyTracker.java b/service/src/com/android/server/connectivity/ProxyTracker.java
index bc0929c..bda4b8f 100644
--- a/service/src/com/android/server/connectivity/ProxyTracker.java
+++ b/service/src/com/android/server/connectivity/ProxyTracker.java
@@ -27,6 +27,7 @@
import android.content.ContentResolver;
import android.content.Context;
import android.content.Intent;
+import android.net.LinkProperties;
import android.net.Network;
import android.net.PacProxyManager;
import android.net.Proxy;
@@ -95,6 +96,7 @@
}
public void onPacProxyInstalled(@Nullable Network network, @NonNull ProxyInfo proxy) {
+ Log.i(TAG, "PAC proxy installed on network " + network + " : " + proxy);
mConnectivityServiceHandler
.sendMessage(mConnectivityServiceHandler
.obtainMessage(mEvent, new Pair<>(network, proxy)));
@@ -328,9 +330,15 @@
* @param proxyInfo the proxy spec, or null for no proxy.
*/
public void setDefaultProxy(@Nullable ProxyInfo proxyInfo) {
+ // The code has been accepting empty proxy objects forever, so for backward
+ // compatibility it should continue doing so.
+ if (proxyInfo != null && TextUtils.isEmpty(proxyInfo.getHost())
+ && Uri.EMPTY.equals(proxyInfo.getPacFileUrl())) {
+ proxyInfo = null;
+ }
synchronized (mProxyLock) {
if (Objects.equals(mDefaultProxy, proxyInfo)) return;
- if (proxyInfo != null && !proxyInfo.isValid()) {
+ if (proxyInfo != null && !proxyInfo.isValid()) {
if (DBG) Log.d(TAG, "Invalid proxy properties, ignoring: " + proxyInfo);
return;
}
@@ -355,4 +363,51 @@
}
}
}
+
+ private boolean isPacProxy(@Nullable final ProxyInfo info) {
+ return null != info && info.isPacProxy();
+ }
+
+ /**
+ * Adjust the proxy in the link properties if necessary.
+ *
+ * It is necessary when the proxy in the passed property is for PAC, and the default proxy
+ * is also for PAC. This is because the original LinkProperties from the network agent don't
+ * include the port for the local proxy as it's not known at creation time, but this class
+ * knows it after the proxy service is started.
+ *
+ * This is safe because there can only ever be one proxy service running on the device, so
+ * if the ProxyInfo in the LinkProperties is for PAC, then the port is necessarily the one
+ * ProxyTracker knows about.
+ *
+ * @param lp the LinkProperties to fix up.
+ * @param network the network of the local proxy server.
+ */
+ // TODO: Leave network unused to support local proxy server per network in the future.
+ public void updateDefaultNetworkProxyPortForPAC(@NonNull final LinkProperties lp,
+ @Nullable Network network) {
+ final ProxyInfo defaultProxy = getDefaultProxy();
+ if (isPacProxy(lp.getHttpProxy()) && isPacProxy(defaultProxy)) {
+ synchronized (mProxyLock) {
+ // At this time, this method can only be called for the default network's LP.
+ // Therefore the PAC file URL in the LP must match the one in the default proxy,
+ // and we just update the port.
+ // Note that the global proxy, if any, is set out of band by the DPM and becomes
+ // the default proxy (it overrides it, see {@link getDefaultProxy}). The PAC URL
+ // in the global proxy might not be the one in the LP of the default
+ // network, so discount this case.
+ if (null == mGlobalProxy && !lp.getHttpProxy().getPacFileUrl()
+ .equals(defaultProxy.getPacFileUrl())) {
+ throw new IllegalStateException("Unexpected discrepancy between proxy in LP of "
+ + "default network and default proxy. The former has a PAC URL of "
+ + lp.getHttpProxy().getPacFileUrl() + " while the latter has "
+ + defaultProxy.getPacFileUrl());
+ }
+ }
+ // If this network has a PAC proxy and proxy tracker already knows about
+ // it, now is the right time to patch it in. If proxy tracker does not know
+ // about it yet, then it will be patched in when it learns about it.
+ lp.setHttpProxy(defaultProxy);
+ }
+ }
}
diff --git a/tests/unit/java/com/android/server/ConnectivityServiceTest.java b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
index cdb0f15..43c6225 100755
--- a/tests/unit/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
@@ -2505,10 +2505,14 @@
}
private ExpectedBroadcast expectProxyChangeAction(ProxyInfo proxy) {
+ return expectProxyChangeAction(actualProxy -> proxy.equals(actualProxy));
+ }
+
+ private ExpectedBroadcast expectProxyChangeAction(Predicate<ProxyInfo> tester) {
return registerBroadcastReceiverThat(PROXY_CHANGE_ACTION, 1, intent -> {
final ProxyInfo actualProxy = (ProxyInfo) intent.getExtra(Proxy.EXTRA_PROXY_INFO,
ProxyInfo.buildPacProxy(Uri.EMPTY));
- return proxy.equals(actualProxy);
+ return tester.test(actualProxy);
});
}
@@ -11331,6 +11335,278 @@
assertEquals(testProxyInfo, mService.getProxyForNetwork(null));
}
+ /*
+ * Note for maintainers about how PAC proxies are implemented in Android.
+ *
+ * Generally, a proxy is just a hostname and a port to which requests are sent, instead of
+ * sending them directly. Most HTTP libraries know to use this protocol, and the Java
+ * language has properties to help handling these :
+ * https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html
+ * Unfortunately these properties are very old and do not take multi-networking into account.
+ *
+ * A PAC proxy consists of a javascript file stored on a server, and the client is expected to
+ * download the file and interpret the javascript for each HTTP request to know where to direct
+ * it. The device must therefore run code (namely, a javascript interpreter) to interpret the
+ * PAC file correctly. Most HTTP libraries do not know how to do this, since they do not
+ * embark a javascript interpreter (and it would be generally unreasonable for them to do
+ * so). Some apps, notably browsers, do know how to do this, but they are the exception rather
+ * than the rule.
+ * So to support most apps, Android embarks the javascript interpreter. When a network is
+ * configured to have a PAC proxy, Android will first set the ProxyInfo object to an object
+ * that contains the PAC URL (to communicate that to apps that know how to use it), then
+ * download the PAC file and start a native process which will open a server on localhost,
+ * and uses the interpreter inside WebView to interpret the PAC file. This server takes
+ * a little bit of time to start and will listen on a random port. When the port is known,
+ * the framework receives a notification and it updates the ProxyInfo in LinkProperties
+ * as well as send a broadcast to inform apps. This new ProxyInfo still contains the PAC URL,
+ * but it also contains "localhost" as the host and the port that the server listens to as
+ * the port. This will let HTTP libraries that don't have a javascript interpreter work,
+ * because they'll send the requests to this server running on localhost on the correct port,
+ * and this server will do what is appropriate with each request according to the PAC file.
+ *
+ * Note that at the time of this writing, Android does not support starting multiple local
+ * PAC servers, though this would be possible in theory by just starting multiple instances
+ * of this process running their server on different ports. As a stopgap measure, Android
+ * keeps one local server which is always the one for the default network. If a non-default
+ * network has a PAC proxy, it will have a LinkProperties with a port of -1, which means it
+ * could still be used by apps that know how to use the PAC URL directly, but not by HTTP
+ * libs that don't know how to do that. When a network with a PAC proxy becomes the default,
+ * the local server is started. When a network without a PAC proxy becomes the default, the
+ * local server is stopped if it is running (and the LP for the old default network should
+ * be reset to have a port of -1).
+ *
+ * In principle, each network can be configured with a different proxy (typically in the
+ * network settings for a Wi-Fi network). These end up exposed in the LinkProperties of the
+ * relevant network.
+ * Android also exposes ConnectivityManager#getDefaultProxy, which is simply the proxy for
+ * the default network. This was retrofitted from a time where Android did not support multiple
+ * concurrent networks, hence the difficult architecture.
+ * Note that there is also a "global" proxy that can be set by the DPM. When this is set,
+ * it overrides the proxy settings for every single network at the same time – that is, the
+ * system behaves as if the global proxy is the configured proxy for each network.
+ *
+ * Generally there are four ways for apps to look up the proxy.
+ * - Looking up the ProxyInfo in the LinkProperties for a network.
+ * - Listening to the PROXY_CHANGED_ACTION broadcast
+ * - Calling ConnectivityManager#getDefaultProxy, or ConnectivityManager#getProxyForNetwork
+ * which can be used to retrieve the proxy for any given network or the default network by
+ * passing null.
+ * - Reading the standard JVM properties (http{s,}.proxy{Host,Port}). See the Java
+ * distribution documentation for details on how these are supposed to work :
+ * https://docs.oracle.com/javase/8/docs/technotes/guides/net/proxies.html
+ * In Android, these are set by ActivityThread in each process in response to the broadcast.
+ * Many apps actually use these, and it's important they work because it's part of the
+ * Java standard, meaning they need to be set for existing Java libs to work on Android.
+ */
+ @Test
+ public void testPacProxy() throws Exception {
+ final Uri pacUrl = Uri.parse("https://pac-url");
+
+ final TestNetworkCallback cellCallback = new TestNetworkCallback();
+ final NetworkRequest cellRequest = new NetworkRequest.Builder()
+ .addTransportType(TRANSPORT_CELLULAR).build();
+ // Request cell to make sure it doesn't disconnect at an arbitrary point in the test,
+ // which would make testing the callbacks on it difficult.
+ mCm.requestNetwork(cellRequest, cellCallback);
+ mCellAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellAgent.connect(true);
+ cellCallback.expectAvailableThenValidatedCallbacks(mCellAgent);
+
+ final TestNetworkCallback wifiCallback = new TestNetworkCallback();
+ final NetworkRequest wifiRequest = new NetworkRequest.Builder()
+ .addTransportType(TRANSPORT_WIFI).build();
+ mCm.registerNetworkCallback(wifiRequest, wifiCallback);
+
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI);
+ mWiFiAgent.connect(true);
+ wifiCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+ cellCallback.assertNoCallback();
+
+ final ProxyInfo initialProxyInfo = ProxyInfo.buildPacProxy(pacUrl);
+ final LinkProperties testLinkProperties = new LinkProperties();
+ testLinkProperties.setHttpProxy(initialProxyInfo);
+ mWiFiAgent.sendLinkProperties(testLinkProperties);
+ wifiCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mWiFiAgent);
+ cellCallback.assertNoCallback();
+
+ // At first the local PAC proxy server is unstarted (see the description of what the local
+ // server is in the comment at the top of this method). It will contain the PAC URL and a
+ // port of -1 because it is unstarted. Check that all ways of getting that proxy info
+ // returns the same object that was initially created.
+ final ProxyInfo unstartedDefaultProxyInfo = mService.getProxyForNetwork(null);
+ final ProxyInfo unstartedWifiProxyInfo = mService.getProxyForNetwork(
+ mWiFiAgent.getNetwork());
+ final LinkProperties unstartedLp =
+ mService.getLinkProperties(mWiFiAgent.getNetwork());
+
+ assertEquals(initialProxyInfo, unstartedDefaultProxyInfo);
+ assertEquals(initialProxyInfo, unstartedWifiProxyInfo);
+ assertEquals(initialProxyInfo, unstartedLp.getHttpProxy());
+
+ // Make sure the cell network is unaffected. The LP are per-network and each network has
+ // its own configuration. The default proxy and broadcast are system-wide, and the JVM
+ // properties are per-process, and therefore can have only one value at any given time,
+ // so the code sets them to the proxy of the default network (TODO : really, since the
+ // default process is per-network, the JVM properties (http.proxyHost family – see
+ // the comment at the top of the method for details about these) also should be per-network
+ // and even the broadcast contents should be but none of this is implemented). The LP are
+ // still per-network, and a process that wants to use a non-default network is supposed to
+ // look up the proxy in its LP and it has to be correct.
+ assertNull(mService.getLinkProperties(mCellAgent.getNetwork()).getHttpProxy());
+ assertNull(mService.getProxyForNetwork(mCellAgent.getNetwork()));
+
+ // Simulate PacManager sending the notification that the local server has started
+ final ProxyInfo servingProxyInfo = new ProxyInfo(pacUrl, 2097);
+ final ExpectedBroadcast servingProxyBroadcast = expectProxyChangeAction(servingProxyInfo);
+ mService.simulateUpdateProxyInfo(mWiFiAgent.getNetwork(), servingProxyInfo);
+ wifiCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mWiFiAgent);
+ cellCallback.assertNoCallback();
+ servingProxyBroadcast.expectBroadcast();
+
+ final ProxyInfo startedDefaultProxyInfo = mService.getProxyForNetwork(null);
+ final ProxyInfo startedWifiProxyInfo = mService.getProxyForNetwork(
+ mWiFiAgent.getNetwork());
+ final LinkProperties startedLp = mService.getLinkProperties(mWiFiAgent.getNetwork());
+ assertEquals(servingProxyInfo, startedDefaultProxyInfo);
+ assertEquals(servingProxyInfo, startedWifiProxyInfo);
+ assertEquals(servingProxyInfo, startedLp.getHttpProxy());
+ // Make sure the cell network is still unaffected
+ assertNull(mService.getLinkProperties(mCellAgent.getNetwork()).getHttpProxy());
+ assertNull(mService.getProxyForNetwork(mCellAgent.getNetwork()));
+
+ // Start an ethernet network which will become the default, in order to test what happens
+ // to the proxy of wifi while manipulating the proxy of ethernet.
+ final Uri ethPacUrl = Uri.parse("https://ethernet-pac-url");
+ final TestableNetworkCallback ethernetCallback = new TestableNetworkCallback();
+ final NetworkRequest ethernetRequest = new NetworkRequest.Builder()
+ .addTransportType(TRANSPORT_ETHERNET).build();
+ mEthernetAgent = new TestNetworkAgentWrapper(TRANSPORT_ETHERNET);
+ mCm.registerNetworkCallback(ethernetRequest, ethernetCallback);
+ mEthernetAgent.connect(true);
+ ethernetCallback.expectAvailableThenValidatedCallbacks(mEthernetAgent);
+
+ // Wifi is no longer the default, so it should get a callback to LP changed with a PAC
+ // proxy but a port of -1 (since the local proxy doesn't serve wifi now)
+ wifiCallback.expect(LINK_PROPERTIES_CHANGED, mWiFiAgent,
+ lp -> lp.getLp().getHttpProxy().getPort() == -1
+ && lp.getLp().getHttpProxy().isPacProxy());
+ // Wifi is lingered as it was the default but is no longer serving any request.
+ wifiCallback.expect(CallbackEntry.LOSING, mWiFiAgent);
+
+ // Now arrange for Ethernet to have a PAC proxy.
+ final ProxyInfo ethProxy = ProxyInfo.buildPacProxy(ethPacUrl);
+ final LinkProperties ethLinkProperties = new LinkProperties();
+ ethLinkProperties.setHttpProxy(ethProxy);
+ mEthernetAgent.sendLinkProperties(ethLinkProperties);
+ ethernetCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mEthernetAgent);
+ // Default network is Ethernet
+ assertEquals(ethProxy, mService.getProxyForNetwork(null));
+ assertEquals(ethProxy, mService.getProxyForNetwork(mEthernetAgent.getNetwork()));
+ // Proxy info for WiFi ideally should be the old one with the old server still running,
+ // but as the PAC code only handles one server at any given time, this can't work. Wifi
+ // having null as a proxy also won't work (apps using WiFi will try to access the network
+ // without proxy) but is not as bad as having the new proxy (that would send requests
+ // over the default network).
+ assertEquals(initialProxyInfo, mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
+ assertNull(mService.getProxyForNetwork(mCellAgent.getNetwork()));
+
+ // Expect the local PAC proxy server starts to serve the proxy on Ethernet. Use
+ // simulateUpdateProxyInfo to simulate this, and check that the callback is called to
+ // inform apps of the port and that the various networks have the expected proxies in
+ // their link properties.
+ final ProxyInfo servingEthProxy = new ProxyInfo(ethPacUrl, 2099);
+ final ExpectedBroadcast servingEthProxyBroadcast = expectProxyChangeAction(servingEthProxy);
+ final ExpectedBroadcast servingProxyBroadcast2 = expectProxyChangeAction(servingProxyInfo);
+ mService.simulateUpdateProxyInfo(mEthernetAgent.getNetwork(), servingEthProxy);
+ ethernetCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mEthernetAgent);
+ assertEquals(servingEthProxy, mService.getProxyForNetwork(null));
+ assertEquals(servingEthProxy, mService.getProxyForNetwork(mEthernetAgent.getNetwork()));
+ assertEquals(initialProxyInfo, mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
+ assertNull(mService.getProxyForNetwork(mCellAgent.getNetwork()));
+ servingEthProxyBroadcast.expectBroadcast();
+
+ // Ethernet disconnects, back to WiFi
+ mEthernetAgent.disconnect();
+ ethernetCallback.expect(CallbackEntry.LOST, mEthernetAgent);
+
+ // WiFi is now the default network again. However, the local proxy server does not serve
+ // WiFi at this time, so at this time a proxy with port -1 is still the correct value.
+ // In time, the local proxy server for ethernet will be downed and the local proxy server
+ // for WiFi will be restarted, and WiFi will see an update to its LP with the new port,
+ // but in this test this won't happen until the test simulates the local proxy starting
+ // up for WiFi (which is done just a few lines below). This is therefore the perfect place
+ // to check that WiFi is unaffected until the new local proxy starts up.
+ wifiCallback.assertNoCallback();
+ assertEquals(initialProxyInfo, mService.getProxyForNetwork(null));
+ assertEquals(initialProxyInfo, mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
+ assertNull(mService.getProxyForNetwork(mCellAgent.getNetwork()));
+ // Note : strictly speaking, for correctness here apps should expect a broadcast with a
+ // port of -1, since that's the current default proxy. The code does not send this
+ // broadcast. In practice though, not sending it is more useful since the new proxy will
+ // start momentarily, so broadcasting and getting all apps to update and retry once now
+ // and again in 250ms is kind of counter-productive, so don't fix this bug.
+
+ // After a while the PAC file for wifi is resolved again and the local proxy server
+ // starts up. This should cause a LP event to inform clients of the port to access the
+ // proxy server for wifi.
+ mService.simulateUpdateProxyInfo(mWiFiAgent.getNetwork(), servingProxyInfo);
+ wifiCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mWiFiAgent);
+ assertEquals(servingProxyInfo, mService.getProxyForNetwork(null));
+ assertEquals(servingProxyInfo, mService.getProxyForNetwork(mWiFiAgent.getNetwork()));
+ assertNull(mService.getProxyForNetwork(mCellAgent.getNetwork()));
+ servingProxyBroadcast2.expectBroadcast();
+
+ // Expect a broadcast for an empty proxy after wifi disconnected, because cell is now
+ // the default network and it doesn't have a proxy. Whether "no proxy" is a null pointer
+ // or a ProxyInfo with an empty host doesn't matter because both are correct, so this test
+ // accepts both.
+ final ExpectedBroadcast emptyProxyBroadcast = expectProxyChangeAction(
+ proxy -> proxy == null || TextUtils.isEmpty(proxy.getHost()));
+ mWiFiAgent.disconnect();
+ emptyProxyBroadcast.expectBroadcast();
+ wifiCallback.expect(CallbackEntry.LOST, mWiFiAgent);
+ assertNull(mService.getProxyForNetwork(null));
+ assertNull(mService.getLinkProperties(mCellAgent.getNetwork()).getHttpProxy());
+ assertNull(mService.getGlobalProxy());
+
+ mCm.unregisterNetworkCallback(cellCallback);
+ }
+
+ @Test
+ public void testPacProxy_NetworkDisconnects_BroadcastSent() throws Exception {
+ // Make a WiFi network with a PAC URI.
+ final Uri pacUrl = Uri.parse("https://pac-url");
+ final ProxyInfo initialProxyInfo = ProxyInfo.buildPacProxy(pacUrl);
+ final LinkProperties testLinkProperties = new LinkProperties();
+ testLinkProperties.setHttpProxy(initialProxyInfo);
+
+ final TestNetworkCallback wifiCallback = new TestNetworkCallback();
+ final NetworkRequest wifiRequest = new NetworkRequest.Builder()
+ .addTransportType(TRANSPORT_WIFI).build();
+ mCm.registerNetworkCallback(wifiRequest, wifiCallback);
+
+ mWiFiAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, testLinkProperties);
+ mWiFiAgent.connect(true);
+ // Wifi is up, but the local proxy server hasn't started yet.
+ wifiCallback.expectAvailableThenValidatedCallbacks(mWiFiAgent);
+
+ // Simulate PacManager sending the notification that the local server has started
+ final ProxyInfo servingProxyInfo = new ProxyInfo(pacUrl, 2097);
+ final ExpectedBroadcast servingProxyBroadcast = expectProxyChangeAction(servingProxyInfo);
+ mService.simulateUpdateProxyInfo(mWiFiAgent.getNetwork(), servingProxyInfo);
+ wifiCallback.expect(CallbackEntry.LINK_PROPERTIES_CHANGED, mWiFiAgent);
+ servingProxyBroadcast.expectBroadcast();
+
+ // Now disconnect Wi-Fi and make sure there is a broadcast for some empty proxy. Whether
+ // the "empty" proxy is a null pointer or a ProxyInfo with an empty host doesn't matter
+ // because both are correct, so this test accepts both.
+ final ExpectedBroadcast emptyProxyBroadcast = expectProxyChangeAction(
+ proxy -> proxy == null || TextUtils.isEmpty(proxy.getHost()));
+ mWiFiAgent.disconnect();
+ wifiCallback.expect(CallbackEntry.LOST, mWiFiAgent);
+ emptyProxyBroadcast.expectBroadcast();
+ }
+
@Test
public void testGetProxyForVPN() throws Exception {
final ProxyInfo testProxyInfo = ProxyInfo.buildDirectProxy("test", 8888);