Merge "Now that Multidex is testonly, drop android-support-multidex"
diff --git a/framework-t/api/system-current.txt b/framework-t/api/system-current.txt
index c2d245c..87b0a64 100644
--- a/framework-t/api/system-current.txt
+++ b/framework-t/api/system-current.txt
@@ -260,6 +260,7 @@
public class IpSecManager {
method @RequiresPermission(android.Manifest.permission.MANAGE_IPSEC_TUNNELS) public void applyTunnelModeTransform(@NonNull android.net.IpSecManager.IpSecTunnelInterface, int, @NonNull android.net.IpSecTransform) throws java.io.IOException;
method @NonNull @RequiresPermission(android.Manifest.permission.MANAGE_IPSEC_TUNNELS) public android.net.IpSecManager.IpSecTunnelInterface createIpSecTunnelInterface(@NonNull java.net.InetAddress, @NonNull java.net.InetAddress, @NonNull android.net.Network) throws java.io.IOException, android.net.IpSecManager.ResourceUnavailableException;
+ method @RequiresPermission(android.Manifest.permission.MANAGE_IPSEC_TUNNELS) public void startTunnelModeTransformMigration(@NonNull android.net.IpSecTransform, @NonNull java.net.InetAddress, @NonNull java.net.InetAddress);
}
public static final class IpSecManager.IpSecTunnelInterface implements java.lang.AutoCloseable {
diff --git a/framework-t/src/android/net/IpSecManager.java b/framework-t/src/android/net/IpSecManager.java
index ff021d6..c8469b1 100644
--- a/framework-t/src/android/net/IpSecManager.java
+++ b/framework-t/src/android/net/IpSecManager.java
@@ -823,16 +823,18 @@
* Update the underlying network for this IpSecTunnelInterface.
*
* <p>This new underlying network will be used for all transforms applied AFTER this call is
- * complete. Before new {@link IpSecTransform}(s) with matching addresses are applied to
- * this tunnel interface, traffic will still use the old SA, and be routed on the old
+ * complete. Before {@link IpSecTransform}(s) with matching addresses are applied to this
+ * tunnel interface, traffic will still use the old transform, and be routed on the old
* underlying network.
*
* <p>To migrate IPsec tunnel mode traffic, a caller should:
*
* <ol>
* <li>Update the IpSecTunnelInterface’s underlying network.
- * <li>Apply {@link IpSecTransform}(s) with matching addresses to this
- * IpSecTunnelInterface.
+ * <li>Apply the new {@link IpSecTransform}(s) to this IpSecTunnelInterface. These can be
+ * new {@link IpSecTransform}(s) with matching addresses, or {@link IpSecTransform}(s)
+ * that have started migration (see {@link
+ * IpSecManager#startTunnelModeTransformMigration}).
* </ol>
*
* @param underlyingNetwork the new {@link Network} that will carry traffic for this tunnel.
@@ -841,7 +843,6 @@
* method will throw an {@link IllegalArgumentException}. If the IpSecTunnelInterface is
* later added to this network, all outbound traffic will be blackholed.
*/
- // TODO: b/169171001 Update the documentation when transform migration is supported.
// The purpose of making updating network and applying transforms separate is to leave open
// the possibility to support lossless migration procedures. To do that, Android platform
// will need to support multiple inbound tunnel mode transforms, just like it can support
@@ -1033,9 +1034,10 @@
* @param newDestinationAddress the new destination address
* @hide
*/
+ @SystemApi
@RequiresFeature(FEATURE_IPSEC_TUNNEL_MIGRATION)
@RequiresPermission(android.Manifest.permission.MANAGE_IPSEC_TUNNELS)
- public void startMigration(
+ public void startTunnelModeTransformMigration(
@NonNull IpSecTransform transform,
@NonNull InetAddress newSourceAddress,
@NonNull InetAddress newDestinationAddress) {
diff --git a/framework/api/module-lib-current.txt b/framework/api/module-lib-current.txt
index 7669e0e..f623b05 100644
--- a/framework/api/module-lib-current.txt
+++ b/framework/api/module-lib-current.txt
@@ -63,6 +63,7 @@
field public static final int FIREWALL_RULE_DENY = 2; // 0x2
field public static final int PROFILE_NETWORK_PREFERENCE_DEFAULT = 0; // 0x0
field public static final int PROFILE_NETWORK_PREFERENCE_ENTERPRISE = 1; // 0x1
+ field public static final int PROFILE_NETWORK_PREFERENCE_ENTERPRISE_BLOCKING = 3; // 0x3
field public static final int PROFILE_NETWORK_PREFERENCE_ENTERPRISE_NO_FALLBACK = 2; // 0x2
}
diff --git a/framework/src/android/net/ConnectivityManager.java b/framework/src/android/net/ConnectivityManager.java
index 60bc68c..40defd4 100644
--- a/framework/src/android/net/ConnectivityManager.java
+++ b/framework/src/android/net/ConnectivityManager.java
@@ -1232,16 +1232,19 @@
}
/**
- * Preference for {@link ProfileNetworkPreference#setPreference(int)}.
+ * Preference for {@link ProfileNetworkPreference.Builder#setPreference(int)}.
* See {@link #setProfileNetworkPreferences(UserHandle, List, Executor, Runnable)}
- * Specify that the traffic for this user should by follow the default rules.
+ * Specify that the traffic for this user should by follow the default rules:
+ * applications in the profile designated by the UserHandle behave like any
+ * other application and use the system default network as their default
+ * network. Compare other PROFILE_NETWORK_PREFERENCE_* settings.
* @hide
*/
@SystemApi(client = MODULE_LIBRARIES)
public static final int PROFILE_NETWORK_PREFERENCE_DEFAULT = 0;
/**
- * Preference for {@link ProfileNetworkPreference#setPreference(int)}.
+ * Preference for {@link ProfileNetworkPreference.Builder#setPreference(int)}.
* See {@link #setProfileNetworkPreferences(UserHandle, List, Executor, Runnable)}
* Specify that the traffic for this user should by default go on a network with
* {@link NetworkCapabilities#NET_CAPABILITY_ENTERPRISE}, and on the system default network
@@ -1252,16 +1255,38 @@
public static final int PROFILE_NETWORK_PREFERENCE_ENTERPRISE = 1;
/**
- * Preference for {@link ProfileNetworkPreference#setPreference(int)}.
+ * Preference for {@link ProfileNetworkPreference.Builder#setPreference(int)}.
* See {@link #setProfileNetworkPreferences(UserHandle, List, Executor, Runnable)}
* Specify that the traffic for this user should by default go on a network with
* {@link NetworkCapabilities#NET_CAPABILITY_ENTERPRISE} and if no such network is available
- * should not go on the system default network
+ * should not have a default network at all (that is, network accesses that
+ * do not specify a network explicitly terminate with an error), even if there
+ * is a system default network available to apps outside this preference.
+ * The apps can still use a non-enterprise network if they request it explicitly
+ * provided that specific network doesn't require any specific permission they
+ * do not hold.
* @hide
*/
@SystemApi(client = MODULE_LIBRARIES)
public static final int PROFILE_NETWORK_PREFERENCE_ENTERPRISE_NO_FALLBACK = 2;
+ /**
+ * Preference for {@link ProfileNetworkPreference.Builder#setPreference(int)}.
+ * See {@link #setProfileNetworkPreferences(UserHandle, List, Executor, Runnable)}
+ * Specify that the traffic for this user should by default go on a network with
+ * {@link NetworkCapabilities#NET_CAPABILITY_ENTERPRISE}.
+ * If there is no such network, the apps will have no default
+ * network at all, even if there are available non-enterprise networks on the
+ * device (that is, network accesses that do not specify a network explicitly
+ * terminate with an error). Additionally, the designated apps should be
+ * blocked from using any non-enterprise network even if they specify it
+ * explicitly, unless they hold specific privilege overriding this (see
+ * {@link android.Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS}).
+ * @hide
+ */
+ @SystemApi(client = MODULE_LIBRARIES)
+ public static final int PROFILE_NETWORK_PREFERENCE_ENTERPRISE_BLOCKING = 3;
+
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@IntDef(value = {
diff --git a/service-t/src/com/android/server/net/NetworkStatsService.java b/service-t/src/com/android/server/net/NetworkStatsService.java
index 3a17bdd..6206d83 100644
--- a/service-t/src/com/android/server/net/NetworkStatsService.java
+++ b/service-t/src/com/android/server/net/NetworkStatsService.java
@@ -2817,7 +2817,7 @@
return;
}
if (map.isEmpty()) {
- pw.println("No entries");
+ pw.println("");
return;
}
// If there is a concurrent entry deletion, value could be null. http://b/220084230.
diff --git a/service/Android.bp b/service/Android.bp
index 224fa19..8fa6436 100644
--- a/service/Android.bp
+++ b/service/Android.bp
@@ -206,6 +206,7 @@
libs: [
"framework-annotations-lib",
"framework-connectivity-pre-jarjar",
+ "framework-connectivity-t-pre-jarjar",
"framework-tethering",
"framework-wifi",
"service-connectivity-pre-jarjar",
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsAdvertiser.java b/service/mdns/com/android/server/connectivity/mdns/MdnsAdvertiser.java
index dee78fd..185fac1 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsAdvertiser.java
+++ b/service/mdns/com/android/server/connectivity/mdns/MdnsAdvertiser.java
@@ -16,14 +16,401 @@
package com.android.server.connectivity.mdns;
+import android.annotation.NonNull;
+import android.annotation.Nullable;
+import android.net.LinkAddress;
+import android.net.Network;
+import android.net.nsd.NsdManager;
+import android.net.nsd.NsdServiceInfo;
+import android.os.Looper;
+import android.util.ArrayMap;
import android.util.Log;
+import android.util.SparseArray;
+
+import com.android.internal.annotations.VisibleForTesting;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
/**
* MdnsAdvertiser manages advertising services per {@link com.android.server.NsdService} requests.
*
- * TODO: implement
+ * All methods except the constructor must be called on the looper thread.
*/
public class MdnsAdvertiser {
private static final String TAG = MdnsAdvertiser.class.getSimpleName();
- public static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+ static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
+
+ private final Looper mLooper;
+ private final AdvertiserCallback mCb;
+
+ // Max-sized buffers to be used as temporary buffer to read/build packets. May be used by
+ // multiple components, but only for self-contained operations in the looper thread, so not
+ // concurrently.
+ // TODO: set according to MTU. 1300 should fit for ethernet MTU 1500 with some overhead.
+ private final byte[] mPacketCreationBuffer = new byte[1300];
+
+ private final MdnsSocketProvider mSocketProvider;
+ private final ArrayMap<Network, InterfaceAdvertiserRequest> mAdvertiserRequests =
+ new ArrayMap<>();
+ private final ArrayMap<MdnsInterfaceSocket, MdnsInterfaceAdvertiser> mAllAdvertisers =
+ new ArrayMap<>();
+ private final SparseArray<Registration> mRegistrations = new SparseArray<>();
+ private final Dependencies mDeps;
+
+ /**
+ * Dependencies for {@link MdnsAdvertiser}, useful for testing.
+ */
+ @VisibleForTesting
+ public static class Dependencies {
+ /**
+ * @see MdnsInterfaceAdvertiser
+ */
+ public MdnsInterfaceAdvertiser makeAdvertiser(@NonNull MdnsInterfaceSocket socket,
+ @NonNull List<LinkAddress> initialAddresses,
+ @NonNull Looper looper, @NonNull byte[] packetCreationBuffer,
+ @NonNull MdnsInterfaceAdvertiser.Callback cb) {
+ // Note NetworkInterface is final and not mockable
+ final String logTag = socket.getInterface().getName();
+ return new MdnsInterfaceAdvertiser(logTag, socket, initialAddresses, looper,
+ packetCreationBuffer, cb);
+ }
+ }
+
+ private final MdnsInterfaceAdvertiser.Callback mInterfaceAdvertiserCb =
+ new MdnsInterfaceAdvertiser.Callback() {
+ @Override
+ public void onRegisterServiceSucceeded(
+ @NonNull MdnsInterfaceAdvertiser advertiser, int serviceId) {
+ // Wait for all current interfaces to be done probing before notifying of success.
+ if (anyAdvertiser(a -> a.isProbing(serviceId))) return;
+ // The service may still be unregistered/renamed if a conflict is found on a later added
+ // interface, or if a conflicting announcement/reply is detected (RFC6762 9.)
+
+ final Registration registration = mRegistrations.get(serviceId);
+ if (registration == null) {
+ Log.wtf(TAG, "Register succeeded for unknown registration");
+ return;
+ }
+ if (!registration.mNotifiedRegistrationSuccess) {
+ mCb.onRegisterServiceSucceeded(serviceId, registration.getServiceInfo());
+ registration.mNotifiedRegistrationSuccess = true;
+ }
+ }
+
+ @Override
+ public void onServiceConflict(@NonNull MdnsInterfaceAdvertiser advertiser, int serviceId) {
+ // TODO: handle conflicts found after registration (during or after probing)
+ }
+
+ @Override
+ public void onDestroyed(@NonNull MdnsInterfaceSocket socket) {
+ for (int i = mAdvertiserRequests.size() - 1; i >= 0; i--) {
+ if (mAdvertiserRequests.valueAt(i).onAdvertiserDestroyed(socket)) {
+ mAdvertiserRequests.removeAt(i);
+ }
+ }
+ mAllAdvertisers.remove(socket);
+ }
+ };
+
+ /**
+ * A request for a {@link MdnsInterfaceAdvertiser}.
+ *
+ * This class tracks services to be advertised on all sockets provided via a registered
+ * {@link MdnsSocketProvider.SocketCallback}.
+ */
+ private class InterfaceAdvertiserRequest implements MdnsSocketProvider.SocketCallback {
+ /** Registrations to add to newer MdnsInterfaceAdvertisers when sockets are created. */
+ @NonNull
+ private final SparseArray<Registration> mPendingRegistrations = new SparseArray<>();
+ @NonNull
+ private final ArrayMap<MdnsInterfaceSocket, MdnsInterfaceAdvertiser> mAdvertisers =
+ new ArrayMap<>();
+
+ InterfaceAdvertiserRequest(@Nullable Network requestedNetwork) {
+ mSocketProvider.requestSocket(requestedNetwork, this);
+ }
+
+ /**
+ * Called when an advertiser was destroyed, after all services were unregistered and it sent
+ * exit announcements, or the interface is gone.
+ *
+ * @return true if this {@link InterfaceAdvertiserRequest} should now be deleted.
+ */
+ boolean onAdvertiserDestroyed(@NonNull MdnsInterfaceSocket socket) {
+ mAdvertisers.remove(socket);
+ if (mAdvertisers.size() == 0 && mPendingRegistrations.size() == 0) {
+ // No advertiser is using sockets from this request anymore (in particular for exit
+ // announcements), and there is no registration so newer sockets will not be
+ // necessary, so the request can be unregistered.
+ mSocketProvider.unrequestSocket(this);
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Get the ID of a conflicting service, or -1 if none.
+ */
+ int getConflictingService(@NonNull NsdServiceInfo info) {
+ for (int i = 0; i < mPendingRegistrations.size(); i++) {
+ final NsdServiceInfo other = mPendingRegistrations.valueAt(i).getServiceInfo();
+ if (info.getServiceName().equals(other.getServiceName())
+ && info.getServiceType().equals(other.getServiceType())) {
+ return mPendingRegistrations.keyAt(i);
+ }
+ }
+ return -1;
+ }
+
+ void addService(int id, Registration registration)
+ throws NameConflictException {
+ final int conflicting = getConflictingService(registration.getServiceInfo());
+ if (conflicting >= 0) {
+ throw new NameConflictException(conflicting);
+ }
+
+ mPendingRegistrations.put(id, registration);
+ for (int i = 0; i < mAdvertisers.size(); i++) {
+ mAdvertisers.valueAt(i).addService(id, registration.getServiceInfo());
+ }
+ }
+
+ void removeService(int id) {
+ mPendingRegistrations.remove(id);
+ for (int i = 0; i < mAdvertisers.size(); i++) {
+ mAdvertisers.valueAt(i).removeService(id);
+ }
+ }
+
+ @Override
+ public void onSocketCreated(@NonNull Network network,
+ @NonNull MdnsInterfaceSocket socket,
+ @NonNull List<LinkAddress> addresses) {
+ MdnsInterfaceAdvertiser advertiser = mAllAdvertisers.get(socket);
+ if (advertiser == null) {
+ advertiser = mDeps.makeAdvertiser(socket, addresses, mLooper, mPacketCreationBuffer,
+ mInterfaceAdvertiserCb);
+ mAllAdvertisers.put(socket, advertiser);
+ advertiser.start();
+ }
+ mAdvertisers.put(socket, advertiser);
+ for (int i = 0; i < mPendingRegistrations.size(); i++) {
+ try {
+ advertiser.addService(mPendingRegistrations.keyAt(i),
+ mPendingRegistrations.valueAt(i).getServiceInfo());
+ } catch (NameConflictException e) {
+ Log.wtf(TAG, "Name conflict adding services that should have unique names", e);
+ }
+ }
+ }
+
+ @Override
+ public void onInterfaceDestroyed(@NonNull Network network,
+ @NonNull MdnsInterfaceSocket socket) {
+ final MdnsInterfaceAdvertiser advertiser = mAdvertisers.get(socket);
+ if (advertiser != null) advertiser.destroyNow();
+ }
+
+ @Override
+ public void onAddressesChanged(@NonNull Network network,
+ @NonNull MdnsInterfaceSocket socket, @NonNull List<LinkAddress> addresses) {
+ final MdnsInterfaceAdvertiser advertiser = mAdvertisers.get(socket);
+ if (advertiser != null) advertiser.updateAddresses(addresses);
+ }
+ }
+
+ private static class Registration {
+ @NonNull
+ final String mOriginalName;
+ boolean mNotifiedRegistrationSuccess;
+ private int mConflictCount;
+ @NonNull
+ private NsdServiceInfo mServiceInfo;
+
+ private Registration(@NonNull NsdServiceInfo serviceInfo) {
+ this.mOriginalName = serviceInfo.getServiceName();
+ this.mServiceInfo = serviceInfo;
+ }
+
+ /**
+ * Update the registration to use a different service name, after a conflict was found.
+ *
+ * If a name conflict was found during probing or because different advertising requests
+ * used the same name, the registration is attempted again with a new name (here using
+ * a number suffix, (1), (2) etc). Registration success is notified once probing succeeds
+ * with a new name. This matches legacy behavior based on mdnsresponder, and appendix D of
+ * RFC6763.
+ * @return The new service info with the updated name.
+ */
+ @NonNull
+ private NsdServiceInfo updateForConflict() {
+ mConflictCount++;
+ // In case of conflict choose a different service name. After the first conflict use
+ // "Name (2)", then "Name (3)" etc.
+ // TODO: use a hidden method in NsdServiceInfo once MdnsAdvertiser is moved to service-t
+ final NsdServiceInfo newInfo = new NsdServiceInfo();
+ newInfo.setServiceName(mOriginalName + " (" + (mConflictCount + 1) + ")");
+ newInfo.setServiceType(mServiceInfo.getServiceType());
+ for (Map.Entry<String, byte[]> attr : mServiceInfo.getAttributes().entrySet()) {
+ newInfo.setAttribute(attr.getKey(), attr.getValue());
+ }
+ newInfo.setHost(mServiceInfo.getHost());
+ newInfo.setPort(mServiceInfo.getPort());
+ newInfo.setNetwork(mServiceInfo.getNetwork());
+ // interfaceIndex is not set when registering
+
+ mServiceInfo = newInfo;
+ return mServiceInfo;
+ }
+
+ @NonNull
+ public NsdServiceInfo getServiceInfo() {
+ return mServiceInfo;
+ }
+ }
+
+ /**
+ * Callbacks for advertising services.
+ *
+ * Every method is called on the MdnsAdvertiser looper thread.
+ */
+ public interface AdvertiserCallback {
+ /**
+ * Called when a service was successfully registered, after probing.
+ *
+ * @param serviceId ID of the service provided when registering.
+ * @param registeredInfo Registered info, which may be different from the requested info,
+ * after probing and possibly choosing alternative service names.
+ */
+ void onRegisterServiceSucceeded(int serviceId, NsdServiceInfo registeredInfo);
+
+ /**
+ * Called when service registration failed.
+ *
+ * @param serviceId ID of the service provided when registering.
+ * @param errorCode One of {@code NsdManager.FAILURE_*}
+ */
+ void onRegisterServiceFailed(int serviceId, int errorCode);
+
+ // Unregistration is notified immediately as success in NsdService so no callback is needed
+ // here.
+ }
+
+ public MdnsAdvertiser(@NonNull Looper looper, @NonNull MdnsSocketProvider socketProvider,
+ @NonNull AdvertiserCallback cb) {
+ this(looper, socketProvider, cb, new Dependencies());
+ }
+
+ @VisibleForTesting
+ MdnsAdvertiser(@NonNull Looper looper, @NonNull MdnsSocketProvider socketProvider,
+ @NonNull AdvertiserCallback cb, @NonNull Dependencies deps) {
+ mLooper = looper;
+ mCb = cb;
+ mSocketProvider = socketProvider;
+ mDeps = deps;
+ }
+
+ private void checkThread() {
+ if (Thread.currentThread() != mLooper.getThread()) {
+ throw new IllegalStateException("This must be called on the looper thread");
+ }
+ }
+
+ /**
+ * Add a service to advertise.
+ * @param id A unique ID for the service.
+ * @param service The service info to advertise.
+ */
+ public void addService(int id, NsdServiceInfo service) {
+ checkThread();
+ if (mRegistrations.get(id) != null) {
+ Log.e(TAG, "Adding duplicate registration for " + service);
+ // TODO (b/264986328): add a more specific error code
+ mCb.onRegisterServiceFailed(id, NsdManager.FAILURE_INTERNAL_ERROR);
+ return;
+ }
+
+ if (DBG) {
+ Log.i(TAG, "Adding service " + service + " with ID " + id);
+ }
+
+ try {
+ final Registration registration = new Registration(service);
+ while (!tryAddRegistration(id, registration)) {
+ registration.updateForConflict();
+ }
+
+ mRegistrations.put(id, registration);
+ } catch (IOException e) {
+ Log.e(TAG, "Error adding service " + service, e);
+ removeService(id);
+ // TODO (b/264986328): add a more specific error code
+ mCb.onRegisterServiceFailed(id, NsdManager.FAILURE_INTERNAL_ERROR);
+ }
+ }
+
+ private boolean tryAddRegistration(int id, @NonNull Registration registration)
+ throws IOException {
+ final NsdServiceInfo serviceInfo = registration.getServiceInfo();
+ final Network network = serviceInfo.getNetwork();
+ try {
+ InterfaceAdvertiserRequest advertiser = mAdvertiserRequests.get(network);
+ if (advertiser == null) {
+ advertiser = new InterfaceAdvertiserRequest(network);
+ mAdvertiserRequests.put(network, advertiser);
+ }
+ advertiser.addService(id, registration);
+ } catch (NameConflictException e) {
+ if (DBG) {
+ Log.i(TAG, "Service name conflicts: " + serviceInfo.getServiceName());
+ }
+ removeService(id);
+ return false;
+ }
+
+ // When adding a service to a specific network, check that it does not conflict with other
+ // registrations advertising on all networks
+ final InterfaceAdvertiserRequest allNetworksAdvertiser = mAdvertiserRequests.get(null);
+ if (network != null && allNetworksAdvertiser != null
+ && allNetworksAdvertiser.getConflictingService(serviceInfo) >= 0) {
+ if (DBG) {
+ Log.i(TAG, "Service conflicts with advertisement on all networks: "
+ + serviceInfo.getServiceName());
+ }
+ removeService(id);
+ return false;
+ }
+
+ mRegistrations.put(id, registration);
+ return true;
+ }
+
+ /**
+ * Remove a previously added service.
+ * @param id ID used when registering.
+ */
+ public void removeService(int id) {
+ checkThread();
+ if (DBG) {
+ Log.i(TAG, "Removing service with ID " + id);
+ }
+ for (int i = mAdvertiserRequests.size() - 1; i >= 0; i--) {
+ final InterfaceAdvertiserRequest advertiser = mAdvertiserRequests.valueAt(i);
+ advertiser.removeService(id);
+ }
+ mRegistrations.remove(id);
+ }
+
+ private boolean anyAdvertiser(@NonNull Predicate<MdnsInterfaceAdvertiser> predicate) {
+ for (int i = 0; i < mAllAdvertisers.size(); i++) {
+ if (predicate.test(mAllAdvertisers.valueAt(i))) {
+ return true;
+ }
+ }
+ return false;
+ }
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java b/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
new file mode 100644
index 0000000..644bdad
--- /dev/null
+++ b/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceAdvertiser.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright (C) 2022 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.server.connectivity.mdns;
+
+import android.annotation.NonNull;
+import android.net.LinkAddress;
+import android.net.nsd.NsdServiceInfo;
+import android.os.Looper;
+
+import java.util.List;
+
+/**
+ * A class that handles advertising services on a {@link MdnsInterfaceSocket} tied to an interface.
+ */
+public class MdnsInterfaceAdvertiser {
+ private static final boolean DBG = MdnsAdvertiser.DBG;
+ @NonNull
+ private final String mTag;
+ @NonNull
+ private final ProbingCallback mProbingCallback = new ProbingCallback();
+ @NonNull
+ private final AnnouncingCallback mAnnouncingCallback = new AnnouncingCallback();
+ @NonNull
+ private final Callback mCb;
+ @NonNull
+ private final MdnsInterfaceSocket mSocket;
+ @NonNull
+ private final MdnsAnnouncer mAnnouncer;
+ @NonNull
+ private final MdnsProber mProber;
+ @NonNull
+ private final MdnsReplySender mReplySender;
+
+ /**
+ * Callbacks called by {@link MdnsInterfaceAdvertiser} to report status updates.
+ */
+ interface Callback {
+ /**
+ * Called by the advertiser after it successfully registered a service, after probing.
+ */
+ void onRegisterServiceSucceeded(@NonNull MdnsInterfaceAdvertiser advertiser, int serviceId);
+
+ /**
+ * Called by the advertiser when a conflict was found, during or after probing.
+ *
+ * If a conflict is found during probing, the {@link #renameServiceForConflict} must be
+ * called to restart probing and attempt registration with a different name.
+ */
+ void onServiceConflict(@NonNull MdnsInterfaceAdvertiser advertiser, int serviceId);
+
+ /**
+ * Called by the advertiser when it destroyed itself.
+ *
+ * This can happen after a call to {@link #destroyNow()}, or after all services were
+ * unregistered and the advertiser finished sending exit announcements.
+ */
+ void onDestroyed(@NonNull MdnsInterfaceSocket socket);
+ }
+
+ /**
+ * Callbacks from {@link MdnsProber}.
+ */
+ private class ProbingCallback implements
+ MdnsPacketRepeater.PacketRepeaterCallback<MdnsProber.ProbingInfo> {
+ @Override
+ public void onFinished(MdnsProber.ProbingInfo info) {
+ // TODO: probing finished, start announcements
+ }
+ }
+
+ /**
+ * Callbacks from {@link MdnsAnnouncer}.
+ */
+ private class AnnouncingCallback
+ implements MdnsPacketRepeater.PacketRepeaterCallback<MdnsAnnouncer.AnnouncementInfo> {
+ // TODO: implement
+ }
+
+ public MdnsInterfaceAdvertiser(@NonNull String logTag,
+ @NonNull MdnsInterfaceSocket socket, @NonNull List<LinkAddress> initialAddresses,
+ @NonNull Looper looper, @NonNull byte[] packetCreationBuffer, @NonNull Callback cb) {
+ mTag = MdnsInterfaceAdvertiser.class.getSimpleName() + "/" + logTag;
+ mSocket = socket;
+ mCb = cb;
+ mReplySender = new MdnsReplySender(looper, socket, packetCreationBuffer);
+ mAnnouncer = new MdnsAnnouncer(logTag, looper, mReplySender,
+ mAnnouncingCallback);
+ mProber = new MdnsProber(logTag, looper, mReplySender, mProbingCallback);
+ }
+
+ /**
+ * Start the advertiser.
+ *
+ * The advertiser will stop itself when all services are removed and exit announcements sent,
+ * notifying via {@link Callback#onDestroyed}. This can also be triggered manually via
+ * {@link #destroyNow()}.
+ */
+ public void start() {
+ // TODO: implement
+ }
+
+ /**
+ * Start advertising a service.
+ *
+ * @throws NameConflictException There is already a service being advertised with that name.
+ */
+ public void addService(int id, NsdServiceInfo service) throws NameConflictException {
+ // TODO: implement
+ }
+
+ /**
+ * Stop advertising a service.
+ *
+ * This will trigger exit announcements for the service.
+ */
+ public void removeService(int id) {
+ // TODO: implement
+ }
+
+ /**
+ * Update interface addresses used to advertise.
+ *
+ * This causes new address records to be announced.
+ */
+ public void updateAddresses(@NonNull List<LinkAddress> newAddresses) {
+ // TODO: implement
+ }
+
+ /**
+ * Destroy the advertiser immediately, not sending any exit announcement.
+ *
+ * <p>Useful when the underlying network went away. This will trigger an onDestroyed callback.
+ */
+ public void destroyNow() {
+ // TODO: implement
+ }
+
+ /**
+ * Reset a service to the probing state due to a conflict found on the network.
+ */
+ public void restartProbingForConflict(int serviceId) {
+ // TODO: implement
+ }
+
+ /**
+ * Rename a service following a conflict found on the network, and restart probing.
+ */
+ public void renameServiceForConflict(int serviceId, NsdServiceInfo newInfo) {
+ // TODO: implement
+ }
+
+ /**
+ * Indicates whether probing is in progress for the given service on this interface.
+ *
+ * Also returns false if the specified service is not registered.
+ */
+ public boolean isProbing(int serviceId) {
+ // TODO: implement
+ return true;
+ }
+}
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java b/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
index 6090415..67c893d 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
+++ b/service/mdns/com/android/server/connectivity/mdns/MdnsInterfaceSocket.java
@@ -154,13 +154,12 @@
}
/**
- * Returns the index of the network interface that this socket is bound to. If the interface
- * cannot be determined, returns -1.
+ * Returns the network interface that this socket is bound to.
*
* <p>This method could be used on any thread.
*/
- public int getInterfaceIndex() {
- return mNetworkInterface.getIndex();
+ public NetworkInterface getInterface() {
+ return mNetworkInterface;
}
/*** Returns whether this socket has joined IPv4 group */
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsReplySender.java b/service/mdns/com/android/server/connectivity/mdns/MdnsReplySender.java
index 1fdbc5c..adf6f4d 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsReplySender.java
+++ b/service/mdns/com/android/server/connectivity/mdns/MdnsReplySender.java
@@ -32,14 +32,14 @@
*/
public class MdnsReplySender {
@NonNull
- private final MulticastSocket mSocket;
+ private final MdnsInterfaceSocket mSocket;
@NonNull
private final Looper mLooper;
@NonNull
private final byte[] mPacketCreationBuffer;
public MdnsReplySender(@NonNull Looper looper,
- @NonNull MulticastSocket socket, @NonNull byte[] packetCreationBuffer) {
+ @NonNull MdnsInterfaceSocket socket, @NonNull byte[] packetCreationBuffer) {
mLooper = looper;
mSocket = socket;
mPacketCreationBuffer = packetCreationBuffer;
diff --git a/service/mdns/com/android/server/connectivity/mdns/MdnsSocketProvider.java b/service/mdns/com/android/server/connectivity/mdns/MdnsSocketProvider.java
index b8c324e..d3bf060 100644
--- a/service/mdns/com/android/server/connectivity/mdns/MdnsSocketProvider.java
+++ b/service/mdns/com/android/server/connectivity/mdns/MdnsSocketProvider.java
@@ -244,7 +244,7 @@
// Try to join the group again.
socketInfo.mSocket.joinGroup(addresses);
- notifyAddressesChanged(network, lp);
+ notifyAddressesChanged(network, socketInfo.mSocket, lp);
}
}
@@ -355,12 +355,13 @@
}
}
- private void notifyAddressesChanged(Network network, LinkProperties lp) {
+ private void notifyAddressesChanged(Network network, MdnsInterfaceSocket socket,
+ LinkProperties lp) {
for (int i = 0; i < mCallbacksToRequestedNetworks.size(); i++) {
final Network requestedNetwork = mCallbacksToRequestedNetworks.valueAt(i);
if (isNetworkMatched(requestedNetwork, network)) {
mCallbacksToRequestedNetworks.keyAt(i)
- .onAddressesChanged(network, lp.getLinkAddresses());
+ .onAddressesChanged(network, socket, lp.getLinkAddresses());
}
}
}
@@ -455,6 +456,6 @@
@NonNull MdnsInterfaceSocket socket) {}
/*** Notify the addresses is changed on the network */
default void onAddressesChanged(@NonNull Network network,
- @NonNull List<LinkAddress> addresses) {}
+ @NonNull MdnsInterfaceSocket socket, @NonNull List<LinkAddress> addresses) {}
}
}
diff --git a/service/mdns/com/android/server/connectivity/mdns/NameConflictException.java b/service/mdns/com/android/server/connectivity/mdns/NameConflictException.java
new file mode 100644
index 0000000..c123d02
--- /dev/null
+++ b/service/mdns/com/android/server/connectivity/mdns/NameConflictException.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2022 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.server.connectivity.mdns;
+
+/**
+ * An exception thrown when a service name conflicts with an existing service.
+ */
+public class NameConflictException extends Exception {
+ /**
+ * ID of the existing service that conflicted.
+ */
+ public final int conflictingServiceId;
+ public NameConflictException(int conflictingServiceId) {
+ this.conflictingServiceId = conflictingServiceId;
+ }
+}
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 004b4d2..8107be3 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -4366,6 +4366,9 @@
mNetworkForNetId.remove(nai.network.getNetId());
}
propagateUnderlyingNetworkCapabilities(nai.network);
+ // Update allowed network lists in netd. This should be called after removing nai
+ // from mNetworkAgentInfos.
+ updateProfileAllowedNetworks();
// Remove all previously satisfied requests.
for (int i = 0; i < nai.numNetworkRequests(); i++) {
final NetworkRequest request = nai.requestAt(i);
@@ -4800,6 +4803,7 @@
}
}
}
+
nri.mPerUidCounter.decrementCount(nri.mUid);
mNetworkRequestInfoLogs.log("RELEASE " + nri);
checkNrisConsistency(nri);
@@ -6166,12 +6170,16 @@
if (mOemNetworkPreferences.getNetworkPreferences().size() > 0) {
handleSetOemNetworkPreference(mOemNetworkPreferences, null);
}
+ if (!mProfileNetworkPreferences.isEmpty()) {
+ updateProfileAllowedNetworks();
+ }
}
private void onUserRemoved(@NonNull final UserHandle user) {
// If there was a network preference for this user, remove it.
handleSetProfileNetworkPreference(
- List.of(new ProfileNetworkPreferenceInfo(user, null, true)),
+ List.of(new ProfileNetworkPreferenceInfo(user, null, true,
+ false /* blockingNonEnterprise */)),
null /* listener */);
if (mOemNetworkPreferences.getNetworkPreferences().size() > 0) {
handleSetOemNetworkPreference(mOemNetworkPreferences, null);
@@ -8688,6 +8696,73 @@
}
}
+ /**
+ * Collect restricted uid ranges for the given network and UserHandle, these uids
+ * are not restricted for matched enterprise networks but being restricted for non-matched
+ * enterprise networks and non-enterprise networks.
+ */
+ @NonNull
+ private ArraySet<UidRange> getRestrictedUidRangesForEnterpriseBlocking(
+ @NonNull NetworkAgentInfo nai, @NonNull UserHandle user) {
+ final ArraySet<UidRange> restrictedUidRanges = new ArraySet<>();
+ for (final ProfileNetworkPreferenceInfo pref : mProfileNetworkPreferences) {
+ if (!pref.user.equals(user) || !pref.blockingNonEnterprise) continue;
+
+ if (nai.networkCapabilities.hasCapability(NET_CAPABILITY_ENTERPRISE)) {
+ // The NC is built from a `ProfileNetworkPreference` which has only one
+ // enterprise ID, so it's guaranteed to have exactly one.
+ final int prefId = pref.capabilities.getEnterpriseIds()[0];
+ if (nai.networkCapabilities.hasEnterpriseId(prefId)) {
+ continue;
+ }
+ }
+
+ if (UidRangeUtils.doesRangeSetOverlap(restrictedUidRanges,
+ pref.capabilities.getUidRanges())) {
+ throw new IllegalArgumentException(
+ "Overlapping uid range in preference: " + pref);
+ }
+ restrictedUidRanges.addAll(pref.capabilities.getUidRanges());
+ }
+ return restrictedUidRanges;
+ }
+
+ private void updateProfileAllowedNetworks() {
+ ensureRunningOnConnectivityServiceThread();
+ final ArrayList<NativeUidRangeConfig> configs = new ArrayList<>();
+ final List<UserHandle> users = mContext.getSystemService(UserManager.class)
+ .getUserHandles(true /* excludeDying */);
+ if (users.isEmpty()) {
+ throw new IllegalStateException("No user is available");
+ }
+
+ for (final NetworkAgentInfo nai : mNetworkAgentInfos) {
+ ArraySet<UidRange> allowedUidRanges = new ArraySet<>();
+ for (final UserHandle user : users) {
+ final ArraySet<UidRange> restrictedUidRanges =
+ getRestrictedUidRangesForEnterpriseBlocking(nai, user);
+ allowedUidRanges.addAll(UidRangeUtils.removeRangeSetFromUidRange(
+ UidRange.createForUser(user), restrictedUidRanges));
+ }
+
+ final UidRangeParcel[] rangesParcel = toUidRangeStableParcels(allowedUidRanges);
+ configs.add(new NativeUidRangeConfig(
+ nai.network.netId, rangesParcel, 0 /* subPriority */));
+ }
+
+ // The netd API replaces the previous configs with the current configs.
+ // Thus, for network disconnection or preference removal, no need to
+ // unset previous config. Instead, collecting all currently needed
+ // configs and issue to netd.
+ try {
+ mNetd.setNetworkAllowlist(configs.toArray(new NativeUidRangeConfig[0]));
+ } catch (ServiceSpecificException e) {
+ // Has the interface disappeared since the network was built?
+ } catch (RemoteException e) {
+ // Netd died. This usually causes a runtime restart anyway.
+ }
+ }
+
private void makeDefaultNetwork(@Nullable final NetworkAgentInfo newDefaultNetwork) {
try {
if (null != newDefaultNetwork) {
@@ -9320,6 +9395,7 @@
networkAgent.setCreated();
networkAgent.onNetworkCreated();
updateAllowedUids(networkAgent, null, networkAgent.networkCapabilities);
+ updateProfileAllowedNetworks();
}
if (!networkAgent.everConnected() && state == NetworkInfo.State.CONNECTED) {
@@ -10856,6 +10932,7 @@
for (final ProfileNetworkPreference preference : preferences) {
final NetworkCapabilities nc;
boolean allowFallback = true;
+ boolean blockingNonEnterprise = false;
switch (preference.getPreference()) {
case ConnectivityManager.PROFILE_NETWORK_PREFERENCE_DEFAULT:
nc = null;
@@ -10865,6 +10942,9 @@
"Invalid enterprise identifier in setProfileNetworkPreferences");
}
break;
+ case ConnectivityManager.PROFILE_NETWORK_PREFERENCE_ENTERPRISE_BLOCKING:
+ blockingNonEnterprise = true;
+ // continue to process the enterprise preference.
case ConnectivityManager.PROFILE_NETWORK_PREFERENCE_ENTERPRISE_NO_FALLBACK:
allowFallback = false;
// continue to process the enterprise preference.
@@ -10898,7 +10978,8 @@
throw new IllegalArgumentException(
"Invalid preference in setProfileNetworkPreferences");
}
- preferenceList.add(new ProfileNetworkPreferenceInfo(profile, nc, allowFallback));
+ preferenceList.add(new ProfileNetworkPreferenceInfo(
+ profile, nc, allowFallback, blockingNonEnterprise));
if (hasDefaultPreference && preferenceList.size() > 1) {
throw new IllegalArgumentException(
"Default profile preference should not be set along with other preference");
@@ -11011,6 +11092,7 @@
removeDefaultNetworkRequestsForPreference(PREFERENCE_ORDER_PROFILE);
addPerAppDefaultNetworkRequests(
createNrisFromProfileNetworkPreferences(mProfileNetworkPreferences));
+ updateProfileAllowedNetworks();
// Finally, rematch.
rematchAllNetworksAndRequests();
diff --git a/service/src/com/android/server/connectivity/ProfileNetworkPreferenceInfo.java b/service/src/com/android/server/connectivity/ProfileNetworkPreferenceInfo.java
index 10f3886..7679660 100644
--- a/service/src/com/android/server/connectivity/ProfileNetworkPreferenceInfo.java
+++ b/service/src/com/android/server/connectivity/ProfileNetworkPreferenceInfo.java
@@ -32,13 +32,15 @@
@Nullable
public final NetworkCapabilities capabilities;
public final boolean allowFallback;
+ public final boolean blockingNonEnterprise;
public ProfileNetworkPreferenceInfo(@NonNull final UserHandle user,
@Nullable final NetworkCapabilities capabilities,
- final boolean allowFallback) {
+ final boolean allowFallback, final boolean blockingNonEnterprise) {
this.user = user;
this.capabilities = null == capabilities ? null : new NetworkCapabilities(capabilities);
this.allowFallback = allowFallback;
+ this.blockingNonEnterprise = blockingNonEnterprise;
}
@Override
@@ -57,6 +59,7 @@
return "[ProfileNetworkPreference user=" + user
+ " caps=" + capabilities
+ " allowFallback=" + allowFallback
+ + " blockingNonEnterprise=" + blockingNonEnterprise
+ "]";
}
}
diff --git a/tests/cts/OWNERS b/tests/cts/OWNERS
index 50842a8..8388cb7 100644
--- a/tests/cts/OWNERS
+++ b/tests/cts/OWNERS
@@ -2,9 +2,5 @@
set noparent
file:platform/packages/modules/Connectivity:master:/OWNERS_core_networking_xts
-# Only temporary ownership to improve ethernet code quality (b/236280707)
-# TODO: remove by 12/31/2022
-per-file net/src/android/net/cts/EthernetManagerTest.kt = prohr@google.com #{LAST_RESORT_SUGGESTION}
-
# IPsec
per-file **IpSec* = benedictwong@google.com, nharold@google.com
diff --git a/tests/cts/net/src/android/net/cts/RateLimitTest.java b/tests/cts/net/src/android/net/cts/RateLimitTest.java
index 28cec1a..36b98fc 100644
--- a/tests/cts/net/src/android/net/cts/RateLimitTest.java
+++ b/tests/cts/net/src/android/net/cts/RateLimitTest.java
@@ -301,29 +301,32 @@
public void testIngressRateLimit_testLimit() throws Exception {
assumeKernelSupport();
+ // These tests are not very precise, especially on lower-end devices.
+ // Add 30% tolerance to reduce test flakiness. Burst size is constant at 128KiB.
+ final double toleranceFactor = 1.3;
+
// If this value is too low, this test might become flaky because of the burst value that
// allows to send at a higher data rate for a short period of time. The faster the data rate
// and the longer the test, the less this test will be affected.
final long dataLimitInBytesPerSecond = 2_000_000; // 2MB/s
long resultInBytesPerSecond = runIngressDataRateMeasurement(Duration.ofSeconds(1));
assertGreaterThan("Failed initial test with rate limit disabled", resultInBytesPerSecond,
- dataLimitInBytesPerSecond);
+ (long) (dataLimitInBytesPerSecond * toleranceFactor));
// enable rate limit and wait until the tc filter is installed before starting the test.
ConnectivitySettingsManager.setIngressRateLimitInBytesPerSecond(mContext,
dataLimitInBytesPerSecond);
waitForTcPoliceFilterInstalled(Duration.ofSeconds(1));
- resultInBytesPerSecond = runIngressDataRateMeasurement(Duration.ofSeconds(10));
- // Add 10% tolerance to reduce test flakiness. Burst size is constant at 128KiB.
+ resultInBytesPerSecond = runIngressDataRateMeasurement(Duration.ofSeconds(15));
assertLessThan("Failed test with rate limit enabled", resultInBytesPerSecond,
- (long) (dataLimitInBytesPerSecond * 1.1));
+ (long) (dataLimitInBytesPerSecond * toleranceFactor));
ConnectivitySettingsManager.setIngressRateLimitInBytesPerSecond(mContext, -1);
resultInBytesPerSecond = runIngressDataRateMeasurement(Duration.ofSeconds(1));
assertGreaterThan("Failed test with rate limit disabled", resultInBytesPerSecond,
- dataLimitInBytesPerSecond);
+ (long) (dataLimitInBytesPerSecond * toleranceFactor));
}
@Test
diff --git a/tests/unit/java/android/net/IpSecTransformTest.java b/tests/unit/java/android/net/IpSecTransformTest.java
index ec59064..8bc1bbd 100644
--- a/tests/unit/java/android/net/IpSecTransformTest.java
+++ b/tests/unit/java/android/net/IpSecTransformTest.java
@@ -143,8 +143,9 @@
@Test
@DevSdkIgnoreRule.IgnoreUpTo(Build.VERSION_CODES.TIRAMISU)
- public void testStartMigration() throws Exception {
- mIpSecManager.startMigration(buildTestTransform(), SRC_ADDRESS_V6, DST_ADDRESS_V6);
+ public void testStartTransformMigration() throws Exception {
+ mIpSecManager.startTunnelModeTransformMigration(
+ buildTestTransform(), SRC_ADDRESS_V6, DST_ADDRESS_V6);
verify(mMockIpSecService)
.migrateTransform(
anyInt(),
@@ -155,9 +156,10 @@
@Test
@DevSdkIgnoreRule.IgnoreAfter(Build.VERSION_CODES.TIRAMISU)
- public void testStartMigrationOnSdkBeforeU() throws Exception {
+ public void testStartTransformMigrationOnSdkBeforeU() throws Exception {
try {
- mIpSecManager.startMigration(buildTestTransform(), SRC_ADDRESS_V6, DST_ADDRESS_V6);
+ mIpSecManager.startTunnelModeTransformMigration(
+ buildTestTransform(), SRC_ADDRESS_V6, DST_ADDRESS_V6);
fail("Expect to fail since migration is not supported before U");
} catch (UnsupportedOperationException expected) {
}
diff --git a/tests/unit/java/com/android/server/ConnectivityServiceTest.java b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
index edc1775..ca6a14b 100755
--- a/tests/unit/java/com/android/server/ConnectivityServiceTest.java
+++ b/tests/unit/java/com/android/server/ConnectivityServiceTest.java
@@ -64,6 +64,7 @@
import static android.net.ConnectivityManager.FIREWALL_RULE_DENY;
import static android.net.ConnectivityManager.PROFILE_NETWORK_PREFERENCE_DEFAULT;
import static android.net.ConnectivityManager.PROFILE_NETWORK_PREFERENCE_ENTERPRISE;
+import static android.net.ConnectivityManager.PROFILE_NETWORK_PREFERENCE_ENTERPRISE_BLOCKING;
import static android.net.ConnectivityManager.PROFILE_NETWORK_PREFERENCE_ENTERPRISE_NO_FALLBACK;
import static android.net.ConnectivityManager.TYPE_ETHERNET;
import static android.net.ConnectivityManager.TYPE_MOBILE;
@@ -10428,6 +10429,7 @@
verify(mMockNetd, times(1)).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
verify(mMockNetd).networkDestroy(cellNetId);
+ verify(mMockNetd).setNetworkAllowlist(any());
verifyNoMoreInteractions(mMockNetd);
verifyNoMoreInteractions(mClatCoordinator);
reset(mMockNetd);
@@ -10468,6 +10470,7 @@
verify(mMockNetd).idletimerRemoveInterface(eq(MOBILE_IFNAME), anyInt(),
eq(Integer.toString(TRANSPORT_CELLULAR)));
verify(mMockNetd).networkDestroy(cellNetId);
+ verify(mMockNetd).setNetworkAllowlist(any());
verifyNoMoreInteractions(mMockNetd);
verifyNoMoreInteractions(mClatCoordinator);
@@ -15779,6 +15782,171 @@
PREFERENCE_ORDER_PROFILE));
}
+ @Test
+ public void testProfileNetworkPreferenceBlocking_changePreference() throws Exception {
+ final InOrder inOrder = inOrder(mMockNetd);
+ final UserHandle testHandle = setupEnterpriseNetwork();
+ doReturn(asList(PRIMARY_USER_HANDLE, testHandle))
+ .when(mUserManager).getUserHandles(anyBoolean());
+
+ // Start with 1 default network and 1 enterprise network, both networks should
+ // not be restricted since the blocking preference is not set yet.
+ mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellNetworkAgent.connect(true);
+
+ // Verify uid ranges 0~99999, 200000~299999 are all allowed for cellular.
+ final UidRange profileUidRange =
+ UidRange.createForUser(UserHandle.of(TEST_WORK_PROFILE_USER_ID));
+ ArraySet<UidRange> allowedAllUidRanges = new ArraySet<>();
+ allowedAllUidRanges.add(PRIMARY_UIDRANGE);
+ allowedAllUidRanges.add(profileUidRange);
+ final UidRangeParcel[] allowAllUidRangesParcel = toUidRangeStableParcels(
+ allowedAllUidRanges);
+ final NativeUidRangeConfig cellAllAllowedConfig = new NativeUidRangeConfig(
+ mCellNetworkAgent.getNetwork().netId,
+ allowAllUidRangesParcel,
+ 0 /* subPriority */);
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellAllAllowedConfig});
+
+ // Verify the same uid ranges are also applied for enterprise network.
+ final TestNetworkAgentWrapper enterpriseAgent = makeEnterpriseNetworkAgent(
+ NET_ENTERPRISE_ID_1);
+ enterpriseAgent.connect(true);
+ final NativeUidRangeConfig enterpriseAllAllowedConfig = new NativeUidRangeConfig(
+ enterpriseAgent.getNetwork().netId,
+ allowAllUidRangesParcel,
+ 0 /* subPriority */);
+ // Network agents are stored in an ArraySet which does not guarantee the order and
+ // making the order of the list undeterministic. Thus, verify this in order insensitive way.
+ final ArgumentCaptor<NativeUidRangeConfig[]> configsCaptor = ArgumentCaptor.forClass(
+ NativeUidRangeConfig[].class);
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(cellAllAllowedConfig, enterpriseAllAllowedConfig));
+
+ // Setup profile preference which only applies to test app uid on the managed profile.
+ ProfileNetworkPreference.Builder prefBuilder = new ProfileNetworkPreference.Builder();
+ prefBuilder.setPreference(PROFILE_NETWORK_PREFERENCE_ENTERPRISE_BLOCKING)
+ .setIncludedUids(new int[]{testHandle.getUid(TEST_WORK_PROFILE_APP_UID)})
+ .setPreferenceEnterpriseId(NET_ENTERPRISE_ID_1);
+ final TestOnCompleteListener listener = new TestOnCompleteListener();
+ mCm.setProfileNetworkPreferences(testHandle,
+ List.of(prefBuilder.build()),
+ r -> r.run(), listener);
+ listener.expectOnComplete();
+
+ // Verify Netd is called for the preferences changed.
+ // Cell: 0~99999, 200000~TEST_APP_UID-1, TEST_APP_UID+1~299999
+ // Enterprise: 0~99999, 200000~299999
+ final ArraySet<UidRange> excludeAppRanges = new ArraySet<>();
+ excludeAppRanges.add(PRIMARY_UIDRANGE);
+ excludeAppRanges.addAll(UidRangeUtils.removeRangeSetFromUidRange(
+ profileUidRange,
+ new ArraySet(new UidRange[]{
+ (new UidRange(TEST_WORK_PROFILE_APP_UID, TEST_WORK_PROFILE_APP_UID))})
+ ));
+ final UidRangeParcel[] excludeAppRangesParcel = toUidRangeStableParcels(excludeAppRanges);
+ final NativeUidRangeConfig cellExcludeAppConfig = new NativeUidRangeConfig(
+ mCellNetworkAgent.getNetwork().netId,
+ excludeAppRangesParcel,
+ 0 /* subPriority */);
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(cellExcludeAppConfig, enterpriseAllAllowedConfig));
+
+ // Verify unset by giving all allowed set for all users when the preference got removed.
+ mCm.setProfileNetworkPreference(testHandle, PROFILE_NETWORK_PREFERENCE_ENTERPRISE,
+ r -> r.run(), listener);
+ listener.expectOnComplete();
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(cellAllAllowedConfig, enterpriseAllAllowedConfig));
+
+ // Verify issuing with cellular set only when a network with enterprise capability
+ // disconnects.
+ enterpriseAgent.disconnect();
+ waitForIdle();
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellAllAllowedConfig});
+ }
+
+ @Test
+ public void testProfileNetworkPreferenceBlocking_networkChanges() throws Exception {
+ final InOrder inOrder = inOrder(mMockNetd);
+ final UserHandle testHandle = setupEnterpriseNetwork();
+ doReturn(asList(PRIMARY_USER_HANDLE, testHandle))
+ .when(mUserManager).getUserHandles(anyBoolean());
+
+ // Setup profile preference which only applies to test app uid on the managed profile.
+ ProfileNetworkPreference.Builder prefBuilder = new ProfileNetworkPreference.Builder();
+ prefBuilder.setPreference(PROFILE_NETWORK_PREFERENCE_ENTERPRISE_BLOCKING)
+ .setIncludedUids(new int[]{testHandle.getUid(TEST_WORK_PROFILE_APP_UID)})
+ .setPreferenceEnterpriseId(NET_ENTERPRISE_ID_1);
+ final TestOnCompleteListener listener = new TestOnCompleteListener();
+ mCm.setProfileNetworkPreferences(testHandle,
+ List.of(prefBuilder.build()),
+ r -> r.run(), listener);
+ listener.expectOnComplete();
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
+
+ // Start with 1 default network, which should be restricted since the blocking
+ // preference is already set.
+ mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);
+ mCellNetworkAgent.connect(true);
+
+ // Verify cellular network applies to the allow list.
+ // Cell: 0~99999, 200000~TEST_APP_UID-1, TEST_APP_UID+1~299999
+ // Enterprise: 0~99999, 200000~299999
+ final ArraySet<UidRange> excludeAppRanges = new ArraySet<>();
+ final UidRange profileUidRange =
+ UidRange.createForUser(UserHandle.of(TEST_WORK_PROFILE_USER_ID));
+ excludeAppRanges.add(PRIMARY_UIDRANGE);
+ excludeAppRanges.addAll(UidRangeUtils.removeRangeSetFromUidRange(
+ profileUidRange,
+ new ArraySet(new UidRange[]{
+ (new UidRange(TEST_WORK_PROFILE_APP_UID, TEST_WORK_PROFILE_APP_UID))})
+ ));
+ final UidRangeParcel[] excludeAppRangesParcel = toUidRangeStableParcels(excludeAppRanges);
+ final NativeUidRangeConfig cellExcludeAppConfig = new NativeUidRangeConfig(
+ mCellNetworkAgent.getNetwork().netId,
+ excludeAppRangesParcel,
+ 0 /* subPriority */);
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellExcludeAppConfig});
+
+ // Verify enterprise network is not blocked for test app.
+ final TestNetworkAgentWrapper enterpriseAgent = makeEnterpriseNetworkAgent(
+ NET_ENTERPRISE_ID_1);
+ enterpriseAgent.connect(true);
+ ArraySet<UidRange> allowedAllUidRanges = new ArraySet<>();
+ allowedAllUidRanges.add(PRIMARY_UIDRANGE);
+ allowedAllUidRanges.add(profileUidRange);
+ final UidRangeParcel[] allowAllUidRangesParcel = toUidRangeStableParcels(
+ allowedAllUidRanges);
+ final NativeUidRangeConfig enterpriseAllAllowedConfig = new NativeUidRangeConfig(
+ enterpriseAgent.getNetwork().netId,
+ allowAllUidRangesParcel,
+ 0 /* subPriority */);
+ // Network agents are stored in an ArraySet which does not guarantee the order and
+ // making the order of the list undeterministic. Thus, verify this in order insensitive way.
+ final ArgumentCaptor<NativeUidRangeConfig[]> configsCaptor = ArgumentCaptor.forClass(
+ NativeUidRangeConfig[].class);
+ inOrder.verify(mMockNetd).setNetworkAllowlist(configsCaptor.capture());
+ assertContainsAll(List.of(configsCaptor.getValue()),
+ List.of(enterpriseAllAllowedConfig, cellExcludeAppConfig));
+
+ // Verify issuing with cellular set only when enterprise network disconnects.
+ enterpriseAgent.disconnect();
+ waitForIdle();
+ inOrder.verify(mMockNetd).setNetworkAllowlist(
+ new NativeUidRangeConfig[]{cellExcludeAppConfig});
+
+ mCellNetworkAgent.disconnect();
+ waitForIdle();
+ inOrder.verify(mMockNetd).setNetworkAllowlist(new NativeUidRangeConfig[]{});
+ }
+
/**
* Make sure wrong preferences for per-profile default networking are rejected.
*/
@@ -15789,7 +15957,7 @@
ProfileNetworkPreference.Builder profileNetworkPreferenceBuilder =
new ProfileNetworkPreference.Builder();
profileNetworkPreferenceBuilder.setPreference(
- PROFILE_NETWORK_PREFERENCE_ENTERPRISE_NO_FALLBACK + 1);
+ PROFILE_NETWORK_PREFERENCE_ENTERPRISE_BLOCKING + 1);
profileNetworkPreferenceBuilder.setPreferenceEnterpriseId(NET_ENTERPRISE_ID_1);
assertThrows("Should not be able to set an illegal preference",
IllegalArgumentException.class,
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
new file mode 100644
index 0000000..e2babb1
--- /dev/null
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAdvertiserTest.kt
@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2022 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.server.connectivity.mdns
+
+import android.net.InetAddresses.parseNumericAddress
+import android.net.LinkAddress
+import android.net.Network
+import android.net.nsd.NsdServiceInfo
+import android.os.Build
+import android.os.Handler
+import android.os.HandlerThread
+import com.android.server.connectivity.mdns.MdnsAdvertiser.AdvertiserCallback
+import com.android.server.connectivity.mdns.MdnsSocketProvider.SocketCallback
+import com.android.testutils.DevSdkIgnoreRule.IgnoreUpTo
+import com.android.testutils.DevSdkIgnoreRunner
+import com.android.testutils.waitForIdle
+import java.util.Objects
+import org.junit.After
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.ArgumentCaptor
+import org.mockito.ArgumentMatchers.eq
+import org.mockito.Mockito.any
+import org.mockito.Mockito.anyInt
+import org.mockito.Mockito.argThat
+import org.mockito.Mockito.doReturn
+import org.mockito.Mockito.mock
+import org.mockito.Mockito.never
+import org.mockito.Mockito.verify
+
+private const val SERVICE_ID_1 = 1
+private const val SERVICE_ID_2 = 2
+private const val TIMEOUT_MS = 10_000L
+private val TEST_ADDR = parseNumericAddress("2001:db8::123")
+private val TEST_LINKADDR = LinkAddress(TEST_ADDR, 64 /* prefixLength */)
+private val TEST_NETWORK_1 = mock(Network::class.java)
+private val TEST_NETWORK_2 = mock(Network::class.java)
+
+private val SERVICE_1 = NsdServiceInfo("TestServiceName", "_advertisertest._tcp").apply {
+ port = 12345
+ host = TEST_ADDR
+ network = TEST_NETWORK_1
+}
+
+private val ALL_NETWORKS_SERVICE = NsdServiceInfo("TestServiceName", "_advertisertest._tcp").apply {
+ port = 12345
+ host = TEST_ADDR
+ network = null
+}
+
+@RunWith(DevSdkIgnoreRunner::class)
+@IgnoreUpTo(Build.VERSION_CODES.S_V2)
+class MdnsAdvertiserTest {
+ private val thread = HandlerThread(MdnsAdvertiserTest::class.simpleName)
+ private val handler by lazy { Handler(thread.looper) }
+ private val socketProvider = mock(MdnsSocketProvider::class.java)
+ private val cb = mock(AdvertiserCallback::class.java)
+
+ private val mockSocket1 = mock(MdnsInterfaceSocket::class.java)
+ private val mockSocket2 = mock(MdnsInterfaceSocket::class.java)
+ private val mockInterfaceAdvertiser1 = mock(MdnsInterfaceAdvertiser::class.java)
+ private val mockInterfaceAdvertiser2 = mock(MdnsInterfaceAdvertiser::class.java)
+ private val mockDeps = mock(MdnsAdvertiser.Dependencies::class.java)
+
+ @Before
+ fun setUp() {
+ thread.start()
+ doReturn(mockInterfaceAdvertiser1).`when`(mockDeps).makeAdvertiser(eq(mockSocket1),
+ any(), any(), any(), any())
+ doReturn(mockInterfaceAdvertiser2).`when`(mockDeps).makeAdvertiser(eq(mockSocket2),
+ any(), any(), any(), any())
+ doReturn(true).`when`(mockInterfaceAdvertiser1).isProbing(anyInt())
+ doReturn(true).`when`(mockInterfaceAdvertiser2).isProbing(anyInt())
+ }
+
+ @After
+ fun tearDown() {
+ thread.quitSafely()
+ }
+
+ @Test
+ fun testAddService_OneNetwork() {
+ val advertiser = MdnsAdvertiser(thread.looper, socketProvider, cb, mockDeps)
+ postSync { advertiser.addService(SERVICE_ID_1, SERVICE_1) }
+
+ val socketCbCaptor = ArgumentCaptor.forClass(SocketCallback::class.java)
+ verify(socketProvider).requestSocket(eq(TEST_NETWORK_1), socketCbCaptor.capture())
+
+ val socketCb = socketCbCaptor.value
+ postSync { socketCb.onSocketCreated(TEST_NETWORK_1, mockSocket1, listOf(TEST_LINKADDR)) }
+
+ val intAdvCbCaptor = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
+ verify(mockDeps).makeAdvertiser(eq(mockSocket1),
+ eq(listOf(TEST_LINKADDR)), eq(thread.looper), any(), intAdvCbCaptor.capture())
+
+ doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_1)
+ postSync { intAdvCbCaptor.value.onRegisterServiceSucceeded(
+ mockInterfaceAdvertiser1, SERVICE_ID_1) }
+ verify(cb).onRegisterServiceSucceeded(eq(SERVICE_ID_1), argThat { it.matches(SERVICE_1) })
+
+ postSync { socketCb.onInterfaceDestroyed(TEST_NETWORK_1, mockSocket1) }
+ verify(mockInterfaceAdvertiser1).destroyNow()
+ }
+
+ @Test
+ fun testAddService_AllNetworks() {
+ val advertiser = MdnsAdvertiser(thread.looper, socketProvider, cb, mockDeps)
+ postSync { advertiser.addService(SERVICE_ID_1, ALL_NETWORKS_SERVICE) }
+
+ val socketCbCaptor = ArgumentCaptor.forClass(SocketCallback::class.java)
+ verify(socketProvider).requestSocket(eq(ALL_NETWORKS_SERVICE.network),
+ socketCbCaptor.capture())
+
+ val socketCb = socketCbCaptor.value
+ postSync { socketCb.onSocketCreated(TEST_NETWORK_1, mockSocket1, listOf(TEST_LINKADDR)) }
+ postSync { socketCb.onSocketCreated(TEST_NETWORK_2, mockSocket2, listOf(TEST_LINKADDR)) }
+
+ val intAdvCbCaptor1 = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
+ val intAdvCbCaptor2 = ArgumentCaptor.forClass(MdnsInterfaceAdvertiser.Callback::class.java)
+ verify(mockDeps).makeAdvertiser(eq(mockSocket1), eq(listOf(TEST_LINKADDR)),
+ eq(thread.looper), any(), intAdvCbCaptor1.capture())
+ verify(mockDeps).makeAdvertiser(eq(mockSocket2), eq(listOf(TEST_LINKADDR)),
+ eq(thread.looper), any(), intAdvCbCaptor2.capture())
+
+ doReturn(false).`when`(mockInterfaceAdvertiser1).isProbing(SERVICE_ID_1)
+ postSync { intAdvCbCaptor1.value.onRegisterServiceSucceeded(
+ mockInterfaceAdvertiser1, SERVICE_ID_1) }
+
+ // Need both advertisers to finish probing and call onRegisterServiceSucceeded
+ verify(cb, never()).onRegisterServiceSucceeded(anyInt(), any())
+ doReturn(false).`when`(mockInterfaceAdvertiser2).isProbing(SERVICE_ID_1)
+ postSync { intAdvCbCaptor2.value.onRegisterServiceSucceeded(
+ mockInterfaceAdvertiser2, SERVICE_ID_1) }
+ verify(cb).onRegisterServiceSucceeded(eq(SERVICE_ID_1),
+ argThat { it.matches(ALL_NETWORKS_SERVICE) })
+
+ // Unregister the service
+ postSync { advertiser.removeService(SERVICE_ID_1) }
+ verify(mockInterfaceAdvertiser1).removeService(SERVICE_ID_1)
+ verify(mockInterfaceAdvertiser2).removeService(SERVICE_ID_1)
+
+ // Interface advertisers call onDestroyed after sending exit announcements
+ postSync { intAdvCbCaptor1.value.onDestroyed(mockSocket1) }
+ verify(socketProvider, never()).unrequestSocket(any())
+ postSync { intAdvCbCaptor2.value.onDestroyed(mockSocket2) }
+ verify(socketProvider).unrequestSocket(socketCb)
+ }
+
+ private fun postSync(r: () -> Unit) {
+ handler.post(r)
+ handler.waitForIdle(TIMEOUT_MS)
+ }
+}
+
+// NsdServiceInfo does not implement equals; this is useful to use in argument matchers
+private fun NsdServiceInfo.matches(other: NsdServiceInfo): Boolean {
+ return Objects.equals(serviceName, other.serviceName) &&
+ Objects.equals(serviceType, other.serviceType) &&
+ Objects.equals(attributes, other.attributes) &&
+ Objects.equals(host, other.host) &&
+ port == other.port &&
+ Objects.equals(network, other.network)
+}
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt
index e9325d5..2051e0c 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsAnnouncerTest.kt
@@ -28,7 +28,6 @@
import java.net.Inet6Address
import java.net.InetAddress
import java.net.InetSocketAddress
-import java.net.MulticastSocket
import kotlin.test.assertEquals
import kotlin.test.assertTrue
import org.junit.After
@@ -55,7 +54,7 @@
class MdnsAnnouncerTest {
private val thread = HandlerThread(MdnsAnnouncerTest::class.simpleName)
- private val socket = mock(MulticastSocket::class.java)
+ private val socket = mock(MdnsInterfaceSocket::class.java)
private val buffer = ByteArray(1500)
@Before
@@ -71,8 +70,7 @@
private class TestAnnouncementInfo(
announcedRecords: List<MdnsRecord>,
additionalRecords: List<MdnsRecord>
- )
- : AnnouncementInfo(announcedRecords, additionalRecords, destinationsSupplier) {
+ ) : AnnouncementInfo(announcedRecords, additionalRecords, destinationsSupplier) {
override fun getDelayMs(nextIndex: Int) =
if (nextIndex < FIRST_ANNOUNCES_COUNT) {
FIRST_ANNOUNCES_DELAY
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt b/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt
index 419121c..a98a4b2 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsProberTest.kt
@@ -26,7 +26,6 @@
import com.android.testutils.DevSdkIgnoreRunner
import java.net.DatagramPacket
import java.net.InetSocketAddress
-import java.net.MulticastSocket
import java.util.concurrent.CompletableFuture
import java.util.concurrent.TimeUnit
import kotlin.test.assertEquals
@@ -57,7 +56,7 @@
@IgnoreUpTo(Build.VERSION_CODES.S_V2)
class MdnsProberTest {
private val thread = HandlerThread(MdnsProberTest::class.simpleName)
- private val socket = mock(MulticastSocket::class.java)
+ private val socket = mock(MdnsInterfaceSocket::class.java)
@Suppress("UNCHECKED_CAST")
private val cb = mock(MdnsPacketRepeater.PacketRepeaterCallback::class.java)
as MdnsPacketRepeater.PacketRepeaterCallback<ProbingInfo>
diff --git a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
index 2bb61a6a..ef73030 100644
--- a/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
+++ b/tests/unit/java/com/android/server/connectivity/mdns/MdnsSocketProviderTest.java
@@ -159,7 +159,8 @@
}
@Override
- public void onAddressesChanged(Network network, List<LinkAddress> addresses) {
+ public void onAddressesChanged(Network network, MdnsInterfaceSocket socket,
+ List<LinkAddress> addresses) {
mHistory.add(new AddressesChangedEvent(network, addresses));
}
diff --git a/tools/gn2bp/Android.bp.swp b/tools/gn2bp/Android.bp.swp
index f96d39f..804c2a4 100644
--- a/tools/gn2bp/Android.bp.swp
+++ b/tools/gn2bp/Android.bp.swp
@@ -382,7 +382,9 @@
"--input_file " +
"java/lang/Runtime.class " +
"--javap " +
- "$$(find out/.path -name javap)",
+ "$$(find out/.path -name javap) " +
+ "--package_prefix " +
+ "android.net.http.internal",
out: [
"base/android_runtime_jni_headers/Runnable_jni.h",
"base/android_runtime_jni_headers/Runtime_jni.h",
@@ -1274,7 +1276,9 @@
"--input_file " +
"$(location base/android/java/src/org/chromium/base/task/PostTask.java) " +
"--input_file " +
- "$(location base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java)",
+ "$(location base/android/java/src/org/chromium/base/task/TaskRunnerImpl.java) " +
+ "--package_prefix " +
+ "android.net.http.internal",
out: [
"base/base_jni_headers/ApkAssets_jni.h",
"base/base_jni_headers/ApplicationStatus_jni.h",
@@ -2506,7 +2510,9 @@
"--input_file " +
"$(location components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequest.java) " +
"--input_file " +
- "$(location components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java)",
+ "$(location components/cronet/android/java/src/org/chromium/net/impl/CronetUrlRequestContext.java) " +
+ "--package_prefix " +
+ "android.net.http.internal",
out: [
"components/cronet/android/cronet_jni_headers/CronetBidirectionalStream_jni.h",
"components/cronet/android/cronet_jni_headers/CronetLibraryLoader_jni.h",
@@ -2775,6 +2781,8 @@
"--header-path " +
"$(genDir)/components/cronet/android/cronet_jni_registration.h " +
"--manual_jni_registration " +
+ "--package_prefix " +
+ "android.net.http.internal " +
";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' " +
"$(genDir)/components/cronet/android/cronet_jni_registration.h",
out: [
@@ -3042,6 +3050,8 @@
"--header-path " +
"$(genDir)/components/cronet/android/cronet_jni_registration.h " +
"--manual_jni_registration " +
+ "--package_prefix " +
+ "android.net.http.internal " +
";sed -i -e 's/OUT_SOONG_.TEMP_SBOX_.*_OUT/GEN/g' " +
"$(genDir)/components/cronet/android/cronet_jni_registration.h",
out: [
@@ -3880,7 +3890,9 @@
"--output_name " +
"PrefService_jni.h " +
"--input_file " +
- "$(location components/prefs/android/java/src/org/chromium/components/prefs/PrefService.java)",
+ "$(location components/prefs/android/java/src/org/chromium/components/prefs/PrefService.java) " +
+ "--package_prefix " +
+ "android.net.http.internal",
out: [
"components/prefs/android/jni_headers/PrefService_jni.h",
],
@@ -4433,6 +4445,7 @@
sdk_version: "module_current",
javacflags: [
"-Aorg.chromium.chrome.skipGenJni",
+ "-Apackage_prefix=android.net.http.internal",
],
}
@@ -5838,7 +5851,9 @@
"--input_file " +
"$(location net/android/java/src/org/chromium/net/ProxyChangeListener.java) " +
"--input_file " +
- "$(location net/android/java/src/org/chromium/net/X509Util.java)",
+ "$(location net/android/java/src/org/chromium/net/X509Util.java) " +
+ "--package_prefix " +
+ "android.net.http.internal",
out: [
"net/net_jni_headers/AndroidCertVerifyResult_jni.h",
"net/net_jni_headers/AndroidKeyStore_jni.h",
@@ -10840,7 +10855,9 @@
"--input_file " +
"$(location url/android/java/src/org/chromium/url/IDNStringUtil.java) " +
"--input_file " +
- "$(location url/android/java/src/org/chromium/url/Origin.java)",
+ "$(location url/android/java/src/org/chromium/url/Origin.java) " +
+ "--package_prefix " +
+ "android.net.http.internal",
out: [
"url/url_jni_headers/IDNStringUtil_jni.h",
"url/url_jni_headers/Origin_jni.h",
diff --git a/tools/gn2bp/gen_android_bp b/tools/gn2bp/gen_android_bp
index 571c468..380e08d 100755
--- a/tools/gn2bp/gen_android_bp
+++ b/tools/gn2bp/gen_android_bp
@@ -962,6 +962,7 @@
self._delete_value_arg('--prev_output_dir', False)
self._update_list_arg('--input_file', self._sanitize_filepath)
self._update_list_arg('--input_file', self._add_location_tag_to_filepath)
+ self._append_arg('--package_prefix', 'android.net.http.internal')
super()._sanitize_args()
def _sanitize_outputs(self):
@@ -992,6 +993,7 @@
# update_jni_registration_module removes them from the srcs of the module
# It might be better to remove sources by '--sources-exclusions'
self._delete_value_arg('--sources-exclusions')
+ self._append_arg('--package_prefix', 'android.net.http.internal')
super()._sanitize_args()
def get_cmd(self):
@@ -1536,6 +1538,7 @@
# would be less likely to conflict with upstream changes if the revert is not
# accepted.
module.javacflags.add("-Aorg.chromium.chrome.skipGenJni")
+ module.javacflags.add("-Apackage_prefix=android.net.http.internal")
for dep in get_non_api_java_actions(gn):
target = gn.get_target(dep)
if target.script == '//build/android/gyp/gcc_preprocess.py':