Merge "Nat464Xlat: rely on netd events being called on handler thread." into main
diff --git a/bpf_progs/netd.c b/bpf_progs/netd.c
index c3258e9..0054d4a 100644
--- a/bpf_progs/netd.c
+++ b/bpf_progs/netd.c
@@ -401,11 +401,6 @@
return true; // disallowed interface
}
-// DROP_IF_SET is set of rules that DROP if rule is globally enabled, and per-uid bit is set
-#define DROP_IF_SET (STANDBY_MATCH | OEM_DENY_1_MATCH | OEM_DENY_2_MATCH | OEM_DENY_3_MATCH)
-// DROP_IF_UNSET is set of rules that should DROP if globally enabled, and per-uid bit is NOT set
-#define DROP_IF_UNSET (DOZABLE_MATCH | POWERSAVE_MATCH | RESTRICTED_MATCH | LOW_POWER_STANDBY_MATCH)
-
static __always_inline inline int bpf_owner_match(struct __sk_buff* skb, uint32_t uid,
bool egress, const unsigned kver) {
if (is_system_uid(uid)) return PASS;
@@ -418,12 +413,7 @@
uint32_t uidRules = uidEntry ? uidEntry->rule : 0;
uint32_t allowed_iif = uidEntry ? uidEntry->iif : 0;
- // Warning: funky bit-wise arithmetic: in parallel, for all DROP_IF_SET/UNSET rules
- // check whether the rules are globally enabled, and if so whether the rules are
- // set/unset for the specific uid. DROP if that is the case for ANY of the rules.
- // We achieve this by masking out only the bits/rules we're interested in checking,
- // and negating (via bit-wise xor) the bits/rules that should drop if unset.
- if (enabledRules & (DROP_IF_SET | DROP_IF_UNSET) & (uidRules ^ DROP_IF_UNSET)) return DROP;
+ if (isBlockedByUidRules(enabledRules, uidRules)) return DROP;
if (!egress && skb->ifindex != 1) {
if (ingress_should_discard(skb, kver)) return DROP;
diff --git a/bpf_progs/netd.h b/bpf_progs/netd.h
index 6e9acaa..dd27bf9 100644
--- a/bpf_progs/netd.h
+++ b/bpf_progs/netd.h
@@ -235,3 +235,17 @@
#define CURRENT_STATS_MAP_CONFIGURATION_KEY 1
#undef STRUCT_SIZE
+
+// DROP_IF_SET is set of rules that DROP if rule is globally enabled, and per-uid bit is set
+#define DROP_IF_SET (STANDBY_MATCH | OEM_DENY_1_MATCH | OEM_DENY_2_MATCH | OEM_DENY_3_MATCH)
+// DROP_IF_UNSET is set of rules that should DROP if globally enabled, and per-uid bit is NOT set
+#define DROP_IF_UNSET (DOZABLE_MATCH | POWERSAVE_MATCH | RESTRICTED_MATCH | LOW_POWER_STANDBY_MATCH)
+
+// Warning: funky bit-wise arithmetic: in parallel, for all DROP_IF_SET/UNSET rules
+// check whether the rules are globally enabled, and if so whether the rules are
+// set/unset for the specific uid. DROP if that is the case for ANY of the rules.
+// We achieve this by masking out only the bits/rules we're interested in checking,
+// and negating (via bit-wise xor) the bits/rules that should drop if unset.
+static inline bool isBlockedByUidRules(BpfConfig enabledRules, uint32_t uidRules) {
+ return enabledRules & (DROP_IF_SET | DROP_IF_UNSET) & (uidRules ^ DROP_IF_UNSET);
+}
diff --git a/framework-t/Android.bp b/framework-t/Android.bp
index ba0d4d9..d177ea9 100644
--- a/framework-t/Android.bp
+++ b/framework-t/Android.bp
@@ -51,7 +51,7 @@
":framework-connectivity-tiramisu-updatable-sources",
":framework-nearby-java-sources",
":framework-thread-sources",
- ] + framework_remoteauth_srcs,
+ ],
libs: [
"unsupportedappusage",
"app-compat-annotations",
@@ -126,7 +126,6 @@
"enable-framework-connectivity-t-targets",
"FlaggedApiDefaults",
],
- api_srcs: framework_remoteauth_api_srcs,
// Do not add static_libs to this library: put them in framework-connectivity instead.
// The jarjar rules are only so that references to jarjared utils in
// framework-connectivity-pre-jarjar match at runtime.
@@ -143,10 +142,8 @@
"android.net",
"android.net.nsd",
"android.nearby",
- "android.remoteauth",
"com.android.connectivity",
"com.android.nearby",
- "com.android.remoteauth",
],
hidden_api: {
diff --git a/remoteauth/service/Android.bp b/remoteauth/service/Android.bp
index 6e7b8d2..98ed2b2 100644
--- a/remoteauth/service/Android.bp
+++ b/remoteauth/service/Android.bp
@@ -18,7 +18,7 @@
filegroup {
name: "remoteauth-service-srcs",
- srcs: ["java/**/*.java"],
+ srcs: [],
}
// Main lib for remoteauth services.
@@ -40,14 +40,10 @@
"framework-statsd",
],
static_libs: [
- "guava",
- "libprotobuf-java-lite",
- "fast-pair-lite-protos",
"modules-utils-build",
"modules-utils-handlerexecutor",
"modules-utils-preconditions",
"modules-utils-backgroundthread",
- "presence-lite-protos",
"uwb_androidx_backend",
],
sdk_version: "system_server_current",
diff --git a/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingParameters.java b/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingParameters.java
index 923730c..4b5874b 100644
--- a/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingParameters.java
+++ b/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingParameters.java
@@ -15,5 +15,67 @@
*/
package com.android.server.remoteauth.ranging;
-/** The set of parameters to start ranging. */
-public class RangingParameters {}
+import androidx.core.uwb.backend.impl.internal.UwbAddress;
+
+/** The set of parameters to initiate {@link RangingSession#start}. */
+public class RangingParameters {
+
+ /** Parameters for {@link UwbRangingSession}. */
+ private final UwbAddress mUwbLocalAddress;
+
+ private final androidx.core.uwb.backend.impl.internal.RangingParameters mUwbRangingParameters;
+
+ public UwbAddress getUwbLocalAddress() {
+ return mUwbLocalAddress;
+ }
+
+ public androidx.core.uwb.backend.impl.internal.RangingParameters getUwbRangingParameters() {
+ return mUwbRangingParameters;
+ }
+
+ private RangingParameters(
+ UwbAddress uwbLocalAddress,
+ androidx.core.uwb.backend.impl.internal.RangingParameters uwbRangingParameters) {
+ mUwbLocalAddress = uwbLocalAddress;
+ mUwbRangingParameters = uwbRangingParameters;
+ }
+
+ /** Builder class for {@link RangingParameters}. */
+ public static final class Builder {
+ private UwbAddress mUwbLocalAddress;
+ private androidx.core.uwb.backend.impl.internal.RangingParameters mUwbRangingParameters;
+
+ /**
+ * Sets the uwb local address.
+ *
+ * <p>Only required if {@link SessionParameters#getRangingMethod}=={@link
+ * RANGING_METHOD_UWB} and {@link SessionParameters#getAutoDeriveParams} == false
+ */
+ public Builder setUwbLocalAddress(UwbAddress uwbLocalAddress) {
+ mUwbLocalAddress = uwbLocalAddress;
+ return this;
+ }
+
+ /**
+ * Sets the uwb ranging parameters.
+ *
+ * <p>Only required if {@link SessionParameters#getRangingMethod}=={@link
+ * RANGING_METHOD_UWB}.
+ *
+ * <p>If {@link SessionParameters#getAutoDeriveParams} == true, all required uwb parameters
+ * including uwbLocalAddress, complexChannel, peerAddresses, and sessionKeyInfo will be
+ * automatically derived, so unnecessary to provide and the other uwb parameters are
+ * optional.
+ */
+ public Builder setUwbRangingParameters(
+ androidx.core.uwb.backend.impl.internal.RangingParameters uwbRangingParameters) {
+ mUwbRangingParameters = uwbRangingParameters;
+ return this;
+ }
+
+ /** Builds {@link RangingParameters}. */
+ public RangingParameters build() {
+ return new RangingParameters(mUwbLocalAddress, mUwbRangingParameters);
+ }
+ }
+}
diff --git a/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingSession.java b/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingSession.java
index adb36c5..a922168 100644
--- a/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingSession.java
+++ b/remoteauth/service/java/com/android/server/remoteauth/ranging/RangingSession.java
@@ -37,7 +37,8 @@
* <p>A session can be started and stopped multiple times. After starting, updates ({@link
* RangingReport}, {@link RangingError}, etc) will be reported via the provided {@link
* RangingCallback}. BaseKey and SyncData are used for auto derivation of supported ranging
- * parameters, which will be implementation specific.
+ * parameters, which will be implementation specific. All session creation shall only be conducted
+ * via {@link RangingManager#createSession}.
*
* <p>Ranging method specific implementation shall be implemented in the extended class.
*/
diff --git a/remoteauth/service/java/com/android/server/remoteauth/ranging/UwbRangingSession.java b/remoteauth/service/java/com/android/server/remoteauth/ranging/UwbRangingSession.java
index 2015b66..62463e1 100644
--- a/remoteauth/service/java/com/android/server/remoteauth/ranging/UwbRangingSession.java
+++ b/remoteauth/service/java/com/android/server/remoteauth/ranging/UwbRangingSession.java
@@ -15,30 +15,219 @@
*/
package com.android.server.remoteauth.ranging;
-import android.annotation.NonNull;
-import android.content.Context;
+import static androidx.core.uwb.backend.impl.internal.RangingDevice.SESSION_ID_UNSET;
+import static androidx.core.uwb.backend.impl.internal.Utils.STATUS_OK;
+import static androidx.core.uwb.backend.impl.internal.Utils.SUPPORTED_BPRF_PREAMBLE_INDEX;
+import static androidx.core.uwb.backend.impl.internal.UwbAddress.SHORT_ADDRESS_LENGTH;
+import static com.android.server.remoteauth.ranging.RangingReport.PROXIMITY_STATE_INSIDE;
+import static com.android.server.remoteauth.ranging.RangingReport.PROXIMITY_STATE_OUTSIDE;
+import static com.android.server.remoteauth.ranging.SessionParameters.DEVICE_ROLE_INITIATOR;
+
+import static com.google.uwb.support.fira.FiraParams.UWB_CHANNEL_9;
+
+import android.annotation.NonNull;
+import android.annotation.RequiresApi;
+import android.content.Context;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.core.uwb.backend.impl.internal.RangingController;
+import androidx.core.uwb.backend.impl.internal.RangingDevice;
+import androidx.core.uwb.backend.impl.internal.RangingPosition;
+import androidx.core.uwb.backend.impl.internal.RangingSessionCallback;
+import androidx.core.uwb.backend.impl.internal.RangingSessionCallback.RangingSuspendedReason;
+import androidx.core.uwb.backend.impl.internal.UwbAddress;
+import androidx.core.uwb.backend.impl.internal.UwbComplexChannel;
+import androidx.core.uwb.backend.impl.internal.UwbDevice;
import androidx.core.uwb.backend.impl.internal.UwbServiceImpl;
-import java.util.concurrent.Executor;
+import com.android.internal.util.Preconditions;
-/** UWB (ultra wide-band) implementation of {@link RangingSession}. */
+import java.nio.ByteBuffer;
+import java.util.List;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+/** UWB (ultra wide-band) specific implementation of {@link RangingSession}. */
+@RequiresApi(Build.VERSION_CODES.VANILLA_ICE_CREAM)
public class UwbRangingSession extends RangingSession {
- private static final int DERIVED_DATA_LENGTH = 1;
+ private static final String TAG = "UwbRangingSession";
+
+ private static final int COMPLEX_CHANNEL_LENGTH = 1;
+ private static final int STS_KEY_LENGTH = 16;
+ private static final int DERIVED_DATA_LENGTH =
+ COMPLEX_CHANNEL_LENGTH + SHORT_ADDRESS_LENGTH + SHORT_ADDRESS_LENGTH + STS_KEY_LENGTH;
+
+ private final UwbServiceImpl mUwbServiceImpl;
+ private final RangingDevice mRangingDevice;
+
+ private Executor mExecutor;
+ private RangingCallback mRangingCallback;
public UwbRangingSession(
@NonNull Context context,
@NonNull SessionParameters sessionParameters,
@NonNull UwbServiceImpl uwbServiceImpl) {
super(context, sessionParameters, DERIVED_DATA_LENGTH);
+ Preconditions.checkNotNull(uwbServiceImpl);
+ mUwbServiceImpl = uwbServiceImpl;
+ if (sessionParameters.getDeviceRole() == DEVICE_ROLE_INITIATOR) {
+ mRangingDevice = (RangingDevice) mUwbServiceImpl.getController(context);
+ } else {
+ mRangingDevice = (RangingDevice) mUwbServiceImpl.getControlee(context);
+ }
}
@Override
public void start(
@NonNull RangingParameters rangingParameters,
@NonNull Executor executor,
- @NonNull RangingCallback rangingCallback) {}
+ @NonNull RangingCallback rangingCallback) {
+ Preconditions.checkNotNull(rangingParameters, "rangingParameters must not be null");
+ Preconditions.checkNotNull(executor, "executor must not be null");
+ Preconditions.checkNotNull(rangingCallback, "rangingCallback must not be null");
+
+ setUwbRangingParameters(rangingParameters);
+ int status =
+ mRangingDevice.startRanging(
+ convertCallback(rangingCallback, executor),
+ Executors.newSingleThreadExecutor());
+ if (status != STATUS_OK) {
+ Log.w(TAG, String.format("Uwb ranging start failed with status %d", status));
+ executor.execute(
+ () -> rangingCallback.onError(mSessionInfo, RANGING_ERROR_FAILED_TO_START));
+ return;
+ }
+ mExecutor = executor;
+ mRangingCallback = rangingCallback;
+ Log.i(TAG, "start");
+ }
@Override
- public void stop() {}
+ public void stop() {
+ if (mRangingCallback == null) {
+ Log.w(TAG, String.format("Failed to stop unstarted session"));
+ return;
+ }
+ int status = mRangingDevice.stopRanging();
+ if (status != STATUS_OK) {
+ Log.w(TAG, String.format("Uwb ranging stop failed with status %d", status));
+ mExecutor.execute(
+ () -> mRangingCallback.onError(mSessionInfo, RANGING_ERROR_FAILED_TO_STOP));
+ return;
+ }
+ mRangingCallback = null;
+ Log.i(TAG, "stop");
+ }
+
+ private void setUwbRangingParameters(RangingParameters rangingParameters) {
+ androidx.core.uwb.backend.impl.internal.RangingParameters params =
+ rangingParameters.getUwbRangingParameters();
+ Preconditions.checkNotNull(params, "uwbRangingParameters must not be null");
+ if (mAutoDeriveParams) {
+ Preconditions.checkArgument(mDerivedData.length == DERIVED_DATA_LENGTH);
+ ByteBuffer buffer = ByteBuffer.wrap(mDerivedData);
+
+ byte complexChannelByte = buffer.get();
+ int preambleIndex =
+ SUPPORTED_BPRF_PREAMBLE_INDEX.get(
+ Math.abs(complexChannelByte) % SUPPORTED_BPRF_PREAMBLE_INDEX.size());
+ // Selecting channel 9 since it's the only mandatory channel.
+ UwbComplexChannel complexChannel = new UwbComplexChannel(UWB_CHANNEL_9, preambleIndex);
+
+ byte[] localAddress = new byte[SHORT_ADDRESS_LENGTH];
+ byte[] peerAddress = new byte[SHORT_ADDRESS_LENGTH];
+ if (mRangingDevice instanceof RangingController) {
+ ((RangingController) mRangingDevice).setComplexChannel(complexChannel);
+ buffer.get(localAddress);
+ buffer.get(peerAddress);
+ } else {
+ buffer.get(peerAddress);
+ buffer.get(localAddress);
+ }
+ byte[] stsKey = new byte[STS_KEY_LENGTH];
+ buffer.get(stsKey);
+
+ mRangingDevice.setLocalAddress(UwbAddress.fromBytes(localAddress));
+ mRangingDevice.setRangingParameters(
+ new androidx.core.uwb.backend.impl.internal.RangingParameters(
+ params.getUwbConfigId(),
+ SESSION_ID_UNSET,
+ /* subSessionId= */ SESSION_ID_UNSET,
+ stsKey,
+ /* subSessionInfo= */ new byte[] {},
+ complexChannel,
+ List.of(UwbAddress.fromBytes(peerAddress)),
+ params.getRangingUpdateRate(),
+ params.getUwbRangeDataNtfConfig(),
+ params.getSlotDuration(),
+ params.isAoaDisabled()));
+ } else {
+ UwbAddress localAddress = rangingParameters.getUwbLocalAddress();
+ Preconditions.checkNotNull(localAddress, "localAddress must not be null");
+ UwbComplexChannel complexChannel = params.getComplexChannel();
+ Preconditions.checkNotNull(complexChannel, "complexChannel must not be null");
+ mRangingDevice.setLocalAddress(localAddress);
+ if (mRangingDevice instanceof RangingController) {
+ ((RangingController) mRangingDevice).setComplexChannel(complexChannel);
+ }
+ mRangingDevice.setRangingParameters(params);
+ }
+ }
+
+ private RangingSessionCallback convertCallback(RangingCallback callback, Executor executor) {
+ return new RangingSessionCallback() {
+
+ @Override
+ public void onRangingInitialized(UwbDevice device) {
+ Log.i(TAG, "onRangingInitialized");
+ }
+
+ @Override
+ public void onRangingResult(UwbDevice device, RangingPosition position) {
+ float distanceM = position.getDistance().getValue();
+ int proximityState =
+ (mLowerProximityBoundaryM <= distanceM
+ && distanceM <= mUpperProximityBoundaryM)
+ ? PROXIMITY_STATE_INSIDE
+ : PROXIMITY_STATE_OUTSIDE;
+ position.getDistance().getValue();
+ RangingReport rangingReport =
+ new RangingReport.Builder()
+ .setDistanceM(distanceM)
+ .setProximityState(proximityState)
+ .build();
+ executor.execute(() -> callback.onRangingReport(mSessionInfo, rangingReport));
+ }
+
+ @Override
+ public void onRangingSuspended(UwbDevice device, @RangingSuspendedReason int reason) {
+ executor.execute(() -> callback.onError(mSessionInfo, convertError(reason)));
+ }
+ };
+ }
+
+ @RangingError
+ private static int convertError(@RangingSuspendedReason int reason) {
+ if (reason == RangingSessionCallback.REASON_WRONG_PARAMETERS) {
+ return RANGING_ERROR_INVALID_PARAMETERS;
+ }
+ if (reason == RangingSessionCallback.REASON_STOP_RANGING_CALLED) {
+ return RANGING_ERROR_STOPPED_BY_REQUEST;
+ }
+ if (reason == RangingSessionCallback.REASON_STOPPED_BY_PEER) {
+ return RANGING_ERROR_STOPPED_BY_PEER;
+ }
+ if (reason == RangingSessionCallback.REASON_FAILED_TO_START) {
+ return RANGING_ERROR_FAILED_TO_START;
+ }
+ if (reason == RangingSessionCallback.REASON_SYSTEM_POLICY) {
+ return RANGING_ERROR_SYSTEM_ERROR;
+ }
+ if (reason == RangingSessionCallback.REASON_MAX_RANGING_ROUND_RETRY_REACHED) {
+ return RANGING_ERROR_SYSTEM_TIMEOUT;
+ }
+ return RANGING_ERROR_UNKNOWN;
+ }
}
diff --git a/remoteauth/tests/unit/Android.bp b/remoteauth/tests/unit/Android.bp
index 37c78c7..16a8242 100644
--- a/remoteauth/tests/unit/Android.bp
+++ b/remoteauth/tests/unit/Android.bp
@@ -26,7 +26,7 @@
min_sdk_version: "31",
// Include all test java files.
- srcs: ["src/**/*.java"],
+ srcs: [],
libs: [
"android.test.base",
diff --git a/remoteauth/tests/unit/src/com/android/server/remoteauth/ranging/RangingParametersTest.java b/remoteauth/tests/unit/src/com/android/server/remoteauth/ranging/RangingParametersTest.java
new file mode 100644
index 0000000..3be5e70
--- /dev/null
+++ b/remoteauth/tests/unit/src/com/android/server/remoteauth/ranging/RangingParametersTest.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2023 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.remoteauth.ranging;
+
+import static androidx.core.uwb.backend.impl.internal.RangingDevice.SESSION_ID_UNSET;
+import static androidx.core.uwb.backend.impl.internal.Utils.CONFIG_PROVISIONED_UNICAST_DS_TWR;
+import static androidx.core.uwb.backend.impl.internal.Utils.DURATION_1_MS;
+import static androidx.core.uwb.backend.impl.internal.Utils.NORMAL;
+
+import static com.google.uwb.support.fira.FiraParams.UWB_CHANNEL_9;
+
+import static org.junit.Assert.assertEquals;
+
+import androidx.core.uwb.backend.impl.internal.UwbAddress;
+import androidx.core.uwb.backend.impl.internal.UwbComplexChannel;
+import androidx.core.uwb.backend.impl.internal.UwbRangeDataNtfConfig;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+
+/** Unit test for {@link RangingParameters}. */
+@RunWith(AndroidJUnit4.class)
+public class RangingParametersTest {
+
+ private static final UwbAddress TEST_UWB_LOCAL_ADDRESS =
+ UwbAddress.fromBytes(new byte[] {0x00, 0x01});
+ private static final androidx.core.uwb.backend.impl.internal.RangingParameters
+ TEST_UWB_RANGING_PARAMETERS =
+ new androidx.core.uwb.backend.impl.internal.RangingParameters(
+ CONFIG_PROVISIONED_UNICAST_DS_TWR,
+ /* sessionId= */ SESSION_ID_UNSET,
+ /* subSessionId= */ SESSION_ID_UNSET,
+ /* SessionInfo= */ new byte[] {},
+ /* subSessionInfo= */ new byte[] {},
+ new UwbComplexChannel(UWB_CHANNEL_9, /* preambleIndex= */ 9),
+ List.of(UwbAddress.fromBytes(new byte[] {0x00, 0x02})),
+ /* rangingUpdateRate= */ NORMAL,
+ new UwbRangeDataNtfConfig.Builder().build(),
+ /* slotDuration= */ DURATION_1_MS,
+ /* isAoaDisabled= */ false);
+
+ @Test
+ public void testBuildingRangingParameters_success() {
+ final RangingParameters rangingParameters =
+ new RangingParameters.Builder()
+ .setUwbLocalAddress(TEST_UWB_LOCAL_ADDRESS)
+ .setUwbRangingParameters(TEST_UWB_RANGING_PARAMETERS)
+ .build();
+
+ assertEquals(rangingParameters.getUwbLocalAddress(), TEST_UWB_LOCAL_ADDRESS);
+ assertEquals(rangingParameters.getUwbRangingParameters(), TEST_UWB_RANGING_PARAMETERS);
+ }
+}
diff --git a/remoteauth/tests/unit/src/com/android/server/remoteauth/ranging/UwbRangingSessionTest.java b/remoteauth/tests/unit/src/com/android/server/remoteauth/ranging/UwbRangingSessionTest.java
new file mode 100644
index 0000000..91198ab
--- /dev/null
+++ b/remoteauth/tests/unit/src/com/android/server/remoteauth/ranging/UwbRangingSessionTest.java
@@ -0,0 +1,375 @@
+/*
+ * Copyright (C) 2023 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.remoteauth.ranging;
+
+import static androidx.core.uwb.backend.impl.internal.RangingDevice.SESSION_ID_UNSET;
+import static androidx.core.uwb.backend.impl.internal.RangingMeasurement.CONFIDENCE_HIGH;
+import static androidx.core.uwb.backend.impl.internal.Utils.CONFIG_PROVISIONED_UNICAST_DS_TWR;
+import static androidx.core.uwb.backend.impl.internal.Utils.DURATION_1_MS;
+import static androidx.core.uwb.backend.impl.internal.Utils.NORMAL;
+import static androidx.core.uwb.backend.impl.internal.Utils.STATUS_ERROR;
+import static androidx.core.uwb.backend.impl.internal.Utils.STATUS_OK;
+
+import static com.android.server.remoteauth.ranging.RangingCapabilities.RANGING_METHOD_UWB;
+import static com.android.server.remoteauth.ranging.RangingReport.PROXIMITY_STATE_INSIDE;
+import static com.android.server.remoteauth.ranging.RangingSession.RANGING_ERROR_FAILED_TO_START;
+import static com.android.server.remoteauth.ranging.RangingSession.RANGING_ERROR_FAILED_TO_STOP;
+import static com.android.server.remoteauth.ranging.SessionParameters.DEVICE_ROLE_INITIATOR;
+import static com.android.server.remoteauth.ranging.SessionParameters.DEVICE_ROLE_RESPONDER;
+
+import static com.google.uwb.support.fira.FiraParams.UWB_CHANNEL_9;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+
+import androidx.core.uwb.backend.impl.internal.RangingControlee;
+import androidx.core.uwb.backend.impl.internal.RangingController;
+import androidx.core.uwb.backend.impl.internal.RangingMeasurement;
+import androidx.core.uwb.backend.impl.internal.RangingPosition;
+import androidx.core.uwb.backend.impl.internal.RangingSessionCallback;
+import androidx.core.uwb.backend.impl.internal.UwbAddress;
+import androidx.core.uwb.backend.impl.internal.UwbComplexChannel;
+import androidx.core.uwb.backend.impl.internal.UwbDevice;
+import androidx.core.uwb.backend.impl.internal.UwbRangeDataNtfConfig;
+import androidx.core.uwb.backend.impl.internal.UwbServiceImpl;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.server.remoteauth.ranging.RangingCapabilities.RangingMethod;
+import com.android.server.remoteauth.ranging.RangingSession.RangingCallback;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.util.List;
+import java.util.concurrent.Executor;
+
+/** Unit test for {@link UwbRangingSession}. */
+@RunWith(AndroidJUnit4.class)
+public class UwbRangingSessionTest {
+
+ private static final String TEST_DEVICE_ID = "test_device_id";
+ @RangingMethod private static final int TEST_RANGING_METHOD = RANGING_METHOD_UWB;
+ private static final float TEST_LOWER_PROXIMITY_BOUNDARY_M = 1.0f;
+ private static final float TEST_UPPER_PROXIMITY_BOUNDARY_M = 2.5f;
+ private static final boolean TEST_AUTO_DERIVE_PARAMS = true;
+ private static final byte[] TEST_BASE_KEY =
+ new byte[] {
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
+ 0x0e, 0x0f
+ };
+ private static final byte[] TEST_SYNC_DATA =
+ new byte[] {
+ 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+ 0x0f, 0x00
+ };
+ private static final SessionParameters TEST_SESSION_PARAMETER_INITIATOR =
+ new SessionParameters.Builder()
+ .setDeviceId(TEST_DEVICE_ID)
+ .setRangingMethod(TEST_RANGING_METHOD)
+ .setDeviceRole(DEVICE_ROLE_INITIATOR)
+ .setLowerProximityBoundaryM(TEST_LOWER_PROXIMITY_BOUNDARY_M)
+ .setUpperProximityBoundaryM(TEST_UPPER_PROXIMITY_BOUNDARY_M)
+ .build();
+ private static final SessionParameters TEST_SESSION_PARAMETER_RESPONDER =
+ new SessionParameters.Builder()
+ .setDeviceId(TEST_DEVICE_ID)
+ .setRangingMethod(TEST_RANGING_METHOD)
+ .setDeviceRole(DEVICE_ROLE_RESPONDER)
+ .setLowerProximityBoundaryM(TEST_LOWER_PROXIMITY_BOUNDARY_M)
+ .setUpperProximityBoundaryM(TEST_UPPER_PROXIMITY_BOUNDARY_M)
+ .build();
+ private static final SessionParameters TEST_SESSION_PARAMETER_INITIATOR_W_AD =
+ new SessionParameters.Builder()
+ .setDeviceId(TEST_DEVICE_ID)
+ .setRangingMethod(TEST_RANGING_METHOD)
+ .setDeviceRole(DEVICE_ROLE_INITIATOR)
+ .setLowerProximityBoundaryM(TEST_LOWER_PROXIMITY_BOUNDARY_M)
+ .setUpperProximityBoundaryM(TEST_UPPER_PROXIMITY_BOUNDARY_M)
+ .setAutoDeriveParams(TEST_AUTO_DERIVE_PARAMS)
+ .setBaseKey(TEST_BASE_KEY)
+ .setSyncData(TEST_SYNC_DATA)
+ .build();
+ private static final UwbAddress TEST_UWB_LOCAL_ADDRESS =
+ UwbAddress.fromBytes(new byte[] {0x00, 0x01});
+ private static final UwbAddress TEST_UWB_PEER_ADDRESS =
+ UwbAddress.fromBytes(new byte[] {0x00, 0x02});
+ private static final UwbComplexChannel TEST_UWB_COMPLEX_CHANNEL =
+ new UwbComplexChannel(UWB_CHANNEL_9, /* preambleIndex= */ 9);
+ private static final androidx.core.uwb.backend.impl.internal.RangingParameters
+ TEST_UWB_RANGING_PARAMETERS =
+ new androidx.core.uwb.backend.impl.internal.RangingParameters(
+ CONFIG_PROVISIONED_UNICAST_DS_TWR,
+ /* sessionId= */ SESSION_ID_UNSET,
+ /* subSessionId= */ SESSION_ID_UNSET,
+ /* SessionInfo= */ new byte[] {},
+ /* subSessionInfo= */ new byte[] {},
+ TEST_UWB_COMPLEX_CHANNEL,
+ List.of(TEST_UWB_PEER_ADDRESS),
+ NORMAL,
+ new UwbRangeDataNtfConfig.Builder().build(),
+ DURATION_1_MS,
+ /* isAoaDisabled= */ false);
+ private static final RangingParameters TEST_RANGING_PARAMETERS =
+ new RangingParameters.Builder()
+ .setUwbLocalAddress(TEST_UWB_LOCAL_ADDRESS)
+ .setUwbRangingParameters(TEST_UWB_RANGING_PARAMETERS)
+ .build();
+ private static final UwbAddress TEST_DERIVED_UWB_LOCAL_ADDRESS =
+ UwbAddress.fromBytes(new byte[] {0x4C, (byte) 0xB4});
+ private static final UwbAddress TEST_DERIVED_UWB_PEER_ADDRESS =
+ UwbAddress.fromBytes(new byte[] {(byte) 0xAE, 0x2E});
+ private static final UwbComplexChannel TEST_DERIVED_UWB_COMPLEX_CHANNEL =
+ new UwbComplexChannel(UWB_CHANNEL_9, /* preambleIndex= */ 12);
+ private static final byte[] TEST_DERIVED_STS_KEY =
+ new byte[] {
+ 0x76,
+ (byte) 0xD7,
+ (byte) 0xB6,
+ 0x1A,
+ (byte) 0x8D,
+ 0x29,
+ 0x1A,
+ 0x52,
+ (byte) 0xBB,
+ (byte) 0xBF,
+ (byte) 0xE6,
+ 0x28,
+ (byte) 0xAD,
+ 0x44,
+ (byte) 0xFB,
+ 0x2E
+ };
+
+ private static final UwbDevice TEST_UWB_DEVICE =
+ UwbDevice.createForAddress(TEST_UWB_PEER_ADDRESS.toBytes());
+ private static final float TEST_DISTANCE = 1.5f;
+ private static final RangingMeasurement TEST_RANGING_MEASUREMENT =
+ new RangingMeasurement(
+ /* confidence= */ CONFIDENCE_HIGH,
+ /* value= */ TEST_DISTANCE,
+ /* valid= */ true);
+ private static final RangingPosition TEST_RANGING_POSITION =
+ new RangingPosition(
+ TEST_RANGING_MEASUREMENT,
+ /* azimuth= */ null,
+ /* elevation= */ null,
+ /* dlTdoaMeasurement= */ null,
+ /* elapsedRealtimeNanos= */ 0,
+ /* rssi= */ 0);
+
+ @Mock private Context mContext;
+ @Mock private UwbServiceImpl mUwbServiceImpl;
+ @Mock private RangingController mRangingController;
+ @Mock private RangingControlee mRangingControlee;
+ @Mock private RangingCallback mRangingCallback;
+ @Mock private Executor mCallbackExecutor;
+
+ private UwbRangingSession mUwbRangingSession;
+
+ @Before
+ public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+
+ when(mUwbServiceImpl.getController(mContext)).thenReturn(mRangingController);
+ when(mUwbServiceImpl.getControlee(mContext)).thenReturn(mRangingControlee);
+ when(mRangingController.startRanging(any(), any())).thenReturn(STATUS_OK);
+ when(mRangingControlee.startRanging(any(), any())).thenReturn(STATUS_OK);
+ doAnswer(
+ invocation -> {
+ Runnable t = invocation.getArgument(0);
+ t.run();
+ return true;
+ })
+ .when(mCallbackExecutor)
+ .execute(any(Runnable.class));
+ }
+
+ @Test
+ public void testConstruction_nullArgument() {
+ assertThrows(
+ NullPointerException.class,
+ () ->
+ new UwbRangingSession(
+ null, TEST_SESSION_PARAMETER_INITIATOR, mUwbServiceImpl));
+ assertThrows(
+ NullPointerException.class,
+ () -> new UwbRangingSession(mContext, null, mUwbServiceImpl));
+ assertThrows(
+ NullPointerException.class,
+ () -> new UwbRangingSession(mContext, TEST_SESSION_PARAMETER_INITIATOR, null));
+ }
+
+ @Test
+ public void testConstruction_initiatorSuccess() {
+ mUwbRangingSession =
+ new UwbRangingSession(mContext, TEST_SESSION_PARAMETER_INITIATOR, mUwbServiceImpl);
+ verify(mUwbServiceImpl, times(1)).getController(mContext);
+ }
+
+ @Test
+ public void testConstruction_responderSuccess() {
+ mUwbRangingSession =
+ new UwbRangingSession(mContext, TEST_SESSION_PARAMETER_RESPONDER, mUwbServiceImpl);
+ verify(mUwbServiceImpl, times(1)).getControlee(mContext);
+ }
+
+ @Test
+ public void testStart_nullArgument() {
+ mUwbRangingSession =
+ new UwbRangingSession(mContext, TEST_SESSION_PARAMETER_INITIATOR, mUwbServiceImpl);
+
+ assertThrows(
+ NullPointerException.class,
+ () -> mUwbRangingSession.start(TEST_RANGING_PARAMETERS, mCallbackExecutor, null));
+ assertThrows(
+ NullPointerException.class,
+ () -> mUwbRangingSession.start(null, mCallbackExecutor, mRangingCallback));
+ assertThrows(
+ NullPointerException.class,
+ () -> mUwbRangingSession.start(TEST_RANGING_PARAMETERS, null, mRangingCallback));
+ assertThrows(
+ NullPointerException.class,
+ () ->
+ mUwbRangingSession.start(
+ new RangingParameters.Builder().build(),
+ mCallbackExecutor,
+ mRangingCallback));
+ }
+
+ @Test
+ public void testStart_initiatorWithoutADFailed() {
+ when(mRangingController.startRanging(any(), any())).thenReturn(STATUS_ERROR);
+
+ mUwbRangingSession =
+ new UwbRangingSession(mContext, TEST_SESSION_PARAMETER_INITIATOR, mUwbServiceImpl);
+ mUwbRangingSession.start(TEST_RANGING_PARAMETERS, mCallbackExecutor, mRangingCallback);
+
+ verify(mRangingController, times(1)).setComplexChannel(TEST_UWB_COMPLEX_CHANNEL);
+ verify(mRangingController, times(1)).setLocalAddress(TEST_UWB_LOCAL_ADDRESS);
+ verify(mRangingController, times(1)).setRangingParameters(TEST_UWB_RANGING_PARAMETERS);
+ verify(mRangingController, times(1)).startRanging(any(), any());
+ ArgumentCaptor<SessionInfo> captor = ArgumentCaptor.forClass(SessionInfo.class);
+ verify(mRangingCallback, times(1))
+ .onError(captor.capture(), eq(RANGING_ERROR_FAILED_TO_START));
+ assertEquals(captor.getValue().getDeviceId(), TEST_DEVICE_ID);
+ }
+
+ private void testRangingCallback() {
+ Answer startRangingResponse =
+ new Answer() {
+ public Object answer(InvocationOnMock invocation) {
+ Object[] args = invocation.getArguments();
+ RangingSessionCallback cb = (RangingSessionCallback) args[0];
+ cb.onRangingInitialized(TEST_UWB_DEVICE);
+ cb.onRangingResult(TEST_UWB_DEVICE, TEST_RANGING_POSITION);
+ return STATUS_OK;
+ }
+ };
+ doAnswer(startRangingResponse)
+ .when(mRangingController)
+ .startRanging(any(RangingSessionCallback.class), any());
+ }
+
+ @Test
+ public void testStart_initiatorWithADSucceed() {
+ testRangingCallback();
+ mUwbRangingSession =
+ new UwbRangingSession(
+ mContext, TEST_SESSION_PARAMETER_INITIATOR_W_AD, mUwbServiceImpl);
+ mUwbRangingSession.start(TEST_RANGING_PARAMETERS, mCallbackExecutor, mRangingCallback);
+
+ verify(mRangingController, times(1)).setComplexChannel(TEST_DERIVED_UWB_COMPLEX_CHANNEL);
+ verify(mRangingController, times(1)).setLocalAddress(TEST_DERIVED_UWB_LOCAL_ADDRESS);
+ ArgumentCaptor<androidx.core.uwb.backend.impl.internal.RangingParameters> captor =
+ ArgumentCaptor.forClass(
+ androidx.core.uwb.backend.impl.internal.RangingParameters.class);
+ verify(mRangingController, times(1)).setRangingParameters(captor.capture());
+ assertEquals(
+ captor.getValue().getUwbConfigId(), TEST_UWB_RANGING_PARAMETERS.getUwbConfigId());
+ assertEquals(captor.getValue().getSessionId(), SESSION_ID_UNSET);
+ assertEquals(captor.getValue().getSubSessionId(), SESSION_ID_UNSET);
+ assertArrayEquals(captor.getValue().getSessionKeyInfo(), TEST_DERIVED_STS_KEY);
+ assertArrayEquals(captor.getValue().getSubSessionKeyInfo(), new byte[] {});
+ assertEquals(captor.getValue().getComplexChannel(), TEST_DERIVED_UWB_COMPLEX_CHANNEL);
+ assertEquals(captor.getValue().getPeerAddresses().get(0), TEST_DERIVED_UWB_PEER_ADDRESS);
+ assertEquals(
+ captor.getValue().getRangingUpdateRate(),
+ TEST_UWB_RANGING_PARAMETERS.getRangingUpdateRate());
+ assertEquals(
+ captor.getValue().getUwbRangeDataNtfConfig(),
+ TEST_UWB_RANGING_PARAMETERS.getUwbRangeDataNtfConfig());
+ assertEquals(
+ captor.getValue().getSlotDuration(), TEST_UWB_RANGING_PARAMETERS.getSlotDuration());
+ assertEquals(
+ captor.getValue().isAoaDisabled(), TEST_UWB_RANGING_PARAMETERS.isAoaDisabled());
+ verify(mRangingController, times(1)).startRanging(any(), any());
+ ArgumentCaptor<SessionInfo> captor2 = ArgumentCaptor.forClass(SessionInfo.class);
+ ArgumentCaptor<RangingReport> captor3 = ArgumentCaptor.forClass(RangingReport.class);
+ verify(mRangingCallback, times(1)).onRangingReport(captor2.capture(), captor3.capture());
+ assertEquals(captor2.getValue().getDeviceId(), TEST_DEVICE_ID);
+ RangingReport rangingReport = captor3.getValue();
+ assertEquals(rangingReport.getDistanceM(), TEST_DISTANCE, 0.0f);
+ assertEquals(rangingReport.getProximityState(), PROXIMITY_STATE_INSIDE);
+ }
+
+ @Test
+ public void testStop_sessionNotStarted() {
+ when(mRangingController.stopRanging()).thenReturn(STATUS_ERROR);
+
+ mUwbRangingSession =
+ new UwbRangingSession(mContext, TEST_SESSION_PARAMETER_INITIATOR, mUwbServiceImpl);
+ mUwbRangingSession.stop();
+
+ verifyZeroInteractions(mRangingController);
+ verifyZeroInteractions(mRangingCallback);
+ }
+
+ @Test
+ public void testStop_failed() {
+ when(mRangingController.stopRanging()).thenReturn(STATUS_ERROR);
+
+ mUwbRangingSession =
+ new UwbRangingSession(mContext, TEST_SESSION_PARAMETER_INITIATOR, mUwbServiceImpl);
+ mUwbRangingSession.start(TEST_RANGING_PARAMETERS, mCallbackExecutor, mRangingCallback);
+ mUwbRangingSession.stop();
+
+ verify(mRangingController, times(1)).setComplexChannel(any());
+ verify(mRangingController, times(1)).setLocalAddress(any());
+ verify(mRangingController, times(1)).setRangingParameters(any());
+ verify(mRangingController, times(1)).startRanging(any(), any());
+ verify(mRangingController, times(1)).stopRanging();
+ ArgumentCaptor<SessionInfo> captor = ArgumentCaptor.forClass(SessionInfo.class);
+ verify(mRangingCallback, times(1))
+ .onError(captor.capture(), eq(RANGING_ERROR_FAILED_TO_STOP));
+ assertEquals(captor.getValue().getDeviceId(), TEST_DEVICE_ID);
+ }
+}
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
index ec63e41..9b1b72d 100644
--- a/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandler.cpp
@@ -18,6 +18,7 @@
#include "netdbpf/NetworkTraceHandler.h"
+#include <android-base/macros.h>
#include <arpa/inet.h>
#include <bpf/BpfUtils.h>
#include <log/log.h>
@@ -75,9 +76,35 @@
uint32_t bytes = 0;
};
-#define AGG_FIELDS(x) \
- (x).ifindex, (x).uid, (x).tag, (x).sport, (x).dport, (x).egress, \
- (x).ipProto, (x).tcpFlags
+BundleKey::BundleKey(const PacketTrace& pkt)
+ : ifindex(pkt.ifindex),
+ uid(pkt.uid),
+ tag(pkt.tag),
+ egress(pkt.egress),
+ ipProto(pkt.ipProto),
+ ipVersion(pkt.ipVersion) {
+ switch (ipProto) {
+ case IPPROTO_TCP:
+ tcpFlags = pkt.tcpFlags;
+ FALLTHROUGH_INTENDED;
+ case IPPROTO_DCCP:
+ case IPPROTO_UDP:
+ case IPPROTO_UDPLITE:
+ case IPPROTO_SCTP:
+ localPort = ntohs(pkt.egress ? pkt.sport : pkt.dport);
+ remotePort = ntohs(pkt.egress ? pkt.dport : pkt.sport);
+ break;
+ case IPPROTO_ICMP:
+ case IPPROTO_ICMPV6:
+ icmpType = ntohs(pkt.sport);
+ icmpCode = ntohs(pkt.dport);
+ break;
+ }
+}
+
+#define AGG_FIELDS(x) \
+ (x).ifindex, (x).uid, (x).tag, (x).egress, (x).ipProto, (x).ipVersion, \
+ (x).tcpFlags, (x).localPort, (x).remotePort, (x).icmpType, (x).icmpCode
std::size_t BundleHash::operator()(const BundleKey& a) const {
std::size_t seed = 0;
@@ -179,7 +206,7 @@
dst->set_timestamp(pkt.timestampNs);
auto* event = dst->set_network_packet();
event->set_length(pkt.length);
- Fill(pkt, event);
+ Fill(BundleKey(pkt), event);
}
return;
}
@@ -187,14 +214,13 @@
uint64_t minTs = std::numeric_limits<uint64_t>::max();
std::unordered_map<BundleKey, BundleDetails, BundleHash, BundleEq> bundles;
for (const PacketTrace& pkt : packets) {
- BundleKey key = pkt;
+ BundleKey key(pkt);
// Dropping fields should remove them from the output and remove them from
- // the aggregation key. In order to do the latter without changing the hash
- // function, set the dropped fields to zero.
- if (mDropTcpFlags) key.tcpFlags = 0;
- if (mDropLocalPort) (key.egress ? key.sport : key.dport) = 0;
- if (mDropRemotePort) (key.egress ? key.dport : key.sport) = 0;
+ // the aggregation key. Reset the optionals to indicate omission.
+ if (mDropTcpFlags) key.tcpFlags.reset();
+ if (mDropLocalPort) key.localPort.reset();
+ if (mDropRemotePort) key.remotePort.reset();
minTs = std::min(minTs, pkt.timestampNs);
@@ -245,22 +271,18 @@
}
}
-void NetworkTraceHandler::Fill(const PacketTrace& src,
+void NetworkTraceHandler::Fill(const BundleKey& src,
NetworkPacketEvent* event) {
event->set_direction(src.egress ? TrafficDirection::DIR_EGRESS
: TrafficDirection::DIR_INGRESS);
event->set_uid(src.uid);
event->set_tag(src.tag);
- if (!mDropLocalPort) {
- event->set_local_port(ntohs(src.egress ? src.sport : src.dport));
- }
- if (!mDropRemotePort) {
- event->set_remote_port(ntohs(src.egress ? src.dport : src.sport));
- }
- if (!mDropTcpFlags) {
- event->set_tcp_flags(src.tcpFlags);
- }
+ if (src.tcpFlags.has_value()) event->set_tcp_flags(*src.tcpFlags);
+ if (src.localPort.has_value()) event->set_local_port(*src.localPort);
+ if (src.remotePort.has_value()) event->set_remote_port(*src.remotePort);
+ if (src.icmpType.has_value()) event->set_icmp_type(*src.icmpType);
+ if (src.icmpCode.has_value()) event->set_icmp_code(*src.icmpCode);
event->set_ip_proto(src.ipProto);
diff --git a/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
index f2c1a86..0c4f049 100644
--- a/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
+++ b/service-t/native/libs/libnetworkstats/NetworkTraceHandlerTest.cpp
@@ -113,7 +113,7 @@
.length = 100,
.uid = 10,
.tag = 123,
- .ipProto = 6,
+ .ipProto = IPPROTO_TCP,
.tcpFlags = 1,
},
};
@@ -138,12 +138,14 @@
.sport = htons(8080),
.dport = htons(443),
.egress = true,
+ .ipProto = IPPROTO_TCP,
},
PacketTrace{
.timestampNs = 2,
.sport = htons(443),
.dport = htons(8080),
.egress = false,
+ .ipProto = IPPROTO_TCP,
},
};
@@ -161,6 +163,42 @@
TrafficDirection::DIR_INGRESS);
}
+TEST_F(NetworkTraceHandlerTest, WriteIcmpTypeAndCode) {
+ std::vector<PacketTrace> input = {
+ PacketTrace{
+ .timestampNs = 1,
+ .sport = htons(11), // type
+ .dport = htons(22), // code
+ .egress = true,
+ .ipProto = IPPROTO_ICMP,
+ },
+ PacketTrace{
+ .timestampNs = 2,
+ .sport = htons(33), // type
+ .dport = htons(44), // code
+ .egress = false,
+ .ipProto = IPPROTO_ICMPV6,
+ },
+ };
+
+ std::vector<TracePacket> events;
+ ASSERT_TRUE(TraceAndSortPackets(input, &events));
+
+ ASSERT_EQ(events.size(), 2);
+ EXPECT_FALSE(events[0].network_packet().has_local_port());
+ EXPECT_FALSE(events[0].network_packet().has_remote_port());
+ EXPECT_THAT(events[0].network_packet().icmp_type(), 11);
+ EXPECT_THAT(events[0].network_packet().icmp_code(), 22);
+ EXPECT_THAT(events[0].network_packet().direction(),
+ TrafficDirection::DIR_EGRESS);
+ EXPECT_FALSE(events[1].network_packet().local_port());
+ EXPECT_FALSE(events[1].network_packet().remote_port());
+ EXPECT_THAT(events[1].network_packet().icmp_type(), 33);
+ EXPECT_THAT(events[1].network_packet().icmp_code(), 44);
+ EXPECT_THAT(events[1].network_packet().direction(),
+ TrafficDirection::DIR_INGRESS);
+}
+
TEST_F(NetworkTraceHandlerTest, BasicBundling) {
// TODO: remove this once bundling becomes default. Until then, set arbitrary
// aggregation threshold to enable bundling.
@@ -168,12 +206,12 @@
config.set_aggregation_threshold(10);
std::vector<PacketTrace> input = {
- PacketTrace{.uid = 123, .timestampNs = 2, .length = 200},
- PacketTrace{.uid = 123, .timestampNs = 1, .length = 100},
- PacketTrace{.uid = 123, .timestampNs = 4, .length = 300},
+ PacketTrace{.timestampNs = 2, .length = 200, .uid = 123},
+ PacketTrace{.timestampNs = 1, .length = 100, .uid = 123},
+ PacketTrace{.timestampNs = 4, .length = 300, .uid = 123},
- PacketTrace{.uid = 456, .timestampNs = 2, .length = 400},
- PacketTrace{.uid = 456, .timestampNs = 4, .length = 100},
+ PacketTrace{.timestampNs = 2, .length = 400, .uid = 456},
+ PacketTrace{.timestampNs = 4, .length = 100, .uid = 456},
};
std::vector<TracePacket> events;
@@ -203,12 +241,12 @@
config.set_aggregation_threshold(3);
std::vector<PacketTrace> input = {
- PacketTrace{.uid = 123, .timestampNs = 2, .length = 200},
- PacketTrace{.uid = 123, .timestampNs = 1, .length = 100},
- PacketTrace{.uid = 123, .timestampNs = 4, .length = 300},
+ PacketTrace{.timestampNs = 2, .length = 200, .uid = 123},
+ PacketTrace{.timestampNs = 1, .length = 100, .uid = 123},
+ PacketTrace{.timestampNs = 4, .length = 300, .uid = 123},
- PacketTrace{.uid = 456, .timestampNs = 2, .length = 400},
- PacketTrace{.uid = 456, .timestampNs = 4, .length = 100},
+ PacketTrace{.timestampNs = 2, .length = 400, .uid = 456},
+ PacketTrace{.timestampNs = 4, .length = 100, .uid = 456},
};
std::vector<TracePacket> events;
@@ -239,12 +277,17 @@
__be16 b = htons(10001);
std::vector<PacketTrace> input = {
// Recall that local is `src` for egress and `dst` for ingress.
- PacketTrace{.timestampNs = 1, .length = 2, .egress = true, .sport = a},
- PacketTrace{.timestampNs = 2, .length = 4, .egress = false, .dport = a},
- PacketTrace{.timestampNs = 3, .length = 6, .egress = true, .sport = b},
- PacketTrace{.timestampNs = 4, .length = 8, .egress = false, .dport = b},
+ PacketTrace{.timestampNs = 1, .length = 2, .sport = a, .egress = true},
+ PacketTrace{.timestampNs = 2, .length = 4, .dport = a, .egress = false},
+ PacketTrace{.timestampNs = 3, .length = 6, .sport = b, .egress = true},
+ PacketTrace{.timestampNs = 4, .length = 8, .dport = b, .egress = false},
};
+ // Set common fields.
+ for (PacketTrace& pkt : input) {
+ pkt.ipProto = IPPROTO_TCP;
+ }
+
std::vector<TracePacket> events;
ASSERT_TRUE(TraceAndSortPackets(input, &events, config));
ASSERT_EQ(events.size(), 2);
@@ -274,12 +317,17 @@
__be16 b = htons(80);
std::vector<PacketTrace> input = {
// Recall that remote is `dst` for egress and `src` for ingress.
- PacketTrace{.timestampNs = 1, .length = 2, .egress = true, .dport = a},
- PacketTrace{.timestampNs = 2, .length = 4, .egress = false, .sport = a},
- PacketTrace{.timestampNs = 3, .length = 6, .egress = true, .dport = b},
- PacketTrace{.timestampNs = 4, .length = 8, .egress = false, .sport = b},
+ PacketTrace{.timestampNs = 1, .length = 2, .dport = a, .egress = true},
+ PacketTrace{.timestampNs = 2, .length = 4, .sport = a, .egress = false},
+ PacketTrace{.timestampNs = 3, .length = 6, .dport = b, .egress = true},
+ PacketTrace{.timestampNs = 4, .length = 8, .sport = b, .egress = false},
};
+ // Set common fields.
+ for (PacketTrace& pkt : input) {
+ pkt.ipProto = IPPROTO_TCP;
+ }
+
std::vector<TracePacket> events;
ASSERT_TRUE(TraceAndSortPackets(input, &events, config));
ASSERT_EQ(events.size(), 2);
@@ -306,12 +354,17 @@
config.set_aggregation_threshold(10);
std::vector<PacketTrace> input = {
- PacketTrace{.timestampNs = 1, .uid = 123, .length = 1, .tcpFlags = 1},
- PacketTrace{.timestampNs = 2, .uid = 123, .length = 2, .tcpFlags = 2},
- PacketTrace{.timestampNs = 3, .uid = 456, .length = 3, .tcpFlags = 1},
- PacketTrace{.timestampNs = 4, .uid = 456, .length = 4, .tcpFlags = 2},
+ PacketTrace{.timestampNs = 1, .length = 1, .uid = 123, .tcpFlags = 1},
+ PacketTrace{.timestampNs = 2, .length = 2, .uid = 123, .tcpFlags = 2},
+ PacketTrace{.timestampNs = 3, .length = 3, .uid = 456, .tcpFlags = 1},
+ PacketTrace{.timestampNs = 4, .length = 4, .uid = 456, .tcpFlags = 2},
};
+ // Set common fields.
+ for (PacketTrace& pkt : input) {
+ pkt.ipProto = IPPROTO_TCP;
+ }
+
std::vector<TracePacket> events;
ASSERT_TRUE(TraceAndSortPackets(input, &events, config));
diff --git a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
index bc10e68..6bf186a 100644
--- a/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
+++ b/service-t/native/libs/libnetworkstats/include/netdbpf/NetworkTraceHandler.h
@@ -30,15 +30,33 @@
namespace android {
namespace bpf {
-// BundleKeys are PacketTraces where timestamp and length are ignored.
-using BundleKey = PacketTrace;
+// BundleKey encodes a PacketTrace minus timestamp and length. The key should
+// match many packets over time for interning. For convenience, sport/dport
+// are parsed here as either local/remote port or icmp type/code.
+struct BundleKey {
+ explicit BundleKey(const PacketTrace& pkt);
-// BundleKeys are hashed using all fields except timestamp/length.
+ uint32_t ifindex;
+ uint32_t uid;
+ uint32_t tag;
+
+ bool egress;
+ uint8_t ipProto;
+ uint8_t ipVersion;
+
+ std::optional<uint8_t> tcpFlags;
+ std::optional<uint16_t> localPort;
+ std::optional<uint16_t> remotePort;
+ std::optional<uint8_t> icmpType;
+ std::optional<uint8_t> icmpCode;
+};
+
+// BundleKeys are hashed using a simple hash combine.
struct BundleHash {
std::size_t operator()(const BundleKey& a) const;
};
-// BundleKeys are equal if all fields except timestamp/length are equal.
+// BundleKeys are equal if all fields are equal.
struct BundleEq {
bool operator()(const BundleKey& a, const BundleKey& b) const;
};
@@ -84,13 +102,13 @@
NetworkTraceHandler::TraceContext& ctx);
private:
- // Convert a PacketTrace into a Perfetto trace packet.
- void Fill(const PacketTrace& src,
+ // Fills in contextual information from a bundle without interning.
+ void Fill(const BundleKey& src,
::perfetto::protos::pbzero::NetworkPacketEvent* event);
// Fills in contextual information either inline or via interning.
::perfetto::protos::pbzero::NetworkPacketBundle* FillWithInterning(
- NetworkTraceState* state, const BundleKey& key,
+ NetworkTraceState* state, const BundleKey& src,
::perfetto::protos::pbzero::TracePacket* dst);
static internal::NetworkTracePoller sPoller;
diff --git a/service-t/src/com/android/server/ConnectivityServiceInitializer.java b/service-t/src/com/android/server/ConnectivityServiceInitializer.java
index 003ec8c..1ac2f6e 100644
--- a/service-t/src/com/android/server/ConnectivityServiceInitializer.java
+++ b/service-t/src/com/android/server/ConnectivityServiceInitializer.java
@@ -28,7 +28,6 @@
import com.android.server.ethernet.EthernetService;
import com.android.server.ethernet.EthernetServiceImpl;
import com.android.server.nearby.NearbyService;
-import com.android.server.remoteauth.RemoteAuthService;
import com.android.server.thread.ThreadNetworkService;
/**
@@ -43,7 +42,6 @@
private final NsdService mNsdService;
private final NearbyService mNearbyService;
private final EthernetServiceImpl mEthernetServiceImpl;
- private final RemoteAuthService mRemoteAuthService;
private final ThreadNetworkService mThreadNetworkService;
public ConnectivityServiceInitializer(Context context) {
@@ -56,7 +54,6 @@
mConnectivityNative = createConnectivityNativeService(context);
mNsdService = createNsdService(context);
mNearbyService = createNearbyService(context);
- mRemoteAuthService = createRemoteAuthService(context);
mThreadNetworkService = createThreadNetworkService(context);
}
@@ -94,12 +91,6 @@
/* allowIsolated= */ false);
}
- if (mRemoteAuthService != null) {
- Log.i(TAG, "Registering " + RemoteAuthService.SERVICE_NAME);
- publishBinderService(RemoteAuthService.SERVICE_NAME, mRemoteAuthService,
- /* allowIsolated= */ false);
- }
-
if (mThreadNetworkService != null) {
Log.i(TAG, "Registering " + ThreadNetworkManager.SERVICE_NAME);
publishBinderService(ThreadNetworkManager.SERVICE_NAME, mThreadNetworkService,
@@ -164,19 +155,6 @@
}
}
- /** Return RemoteAuth service instance */
- private RemoteAuthService createRemoteAuthService(final Context context) {
- if (!SdkLevel.isAtLeastV()) return null;
- try {
- return new RemoteAuthService(context);
- } catch (UnsupportedOperationException e) {
- // RemoteAuth is not yet supported in all branches
- // TODO: remove catch clause when it is available.
- Log.i(TAG, "Skipping unsupported service " + RemoteAuthService.SERVICE_NAME);
- return null;
- }
- }
-
/**
* Return EthernetServiceImpl instance or null if current SDK is lower than T or Ethernet
* service isn't necessary.
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index c2da84d..3ae3e2d 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -97,14 +97,12 @@
import static android.system.OsConstants.ETH_P_ALL;
import static android.system.OsConstants.IPPROTO_TCP;
import static android.system.OsConstants.IPPROTO_UDP;
-
import static com.android.net.module.util.NetworkMonitorUtils.isPrivateDnsValidationRequired;
import static com.android.net.module.util.PermissionUtils.checkAnyPermissionOf;
import static com.android.net.module.util.PermissionUtils.enforceAnyPermissionOf;
import static com.android.net.module.util.PermissionUtils.enforceNetworkStackPermission;
import static com.android.net.module.util.PermissionUtils.enforceNetworkStackPermissionOr;
import static com.android.server.ConnectivityStatsLog.CONNECTIVITY_STATE_SAMPLE;
-
import static java.util.Map.Entry;
import android.Manifest;
@@ -10614,6 +10612,16 @@
err.getFileDescriptor(), args);
}
+ private Boolean parseBooleanArgument(final String arg) {
+ if ("true".equals(arg)) {
+ return true;
+ } else if ("false".equals(arg)) {
+ return false;
+ } else {
+ return null;
+ }
+ }
+
private class ShellCmd extends BasicShellCommandHandler {
@Override
public int onCommand(String cmd) {
@@ -10643,6 +10651,54 @@
onHelp();
return -1;
}
+ case "set-chain3-enabled": {
+ final Boolean enabled = parseBooleanArgument(getNextArg());
+ if (null == enabled) {
+ onHelp();
+ return -1;
+ }
+ Log.i(TAG, (enabled ? "En" : "Dis") + "abled FIREWALL_CHAIN_OEM_DENY_3");
+ setFirewallChainEnabled(ConnectivityManager.FIREWALL_CHAIN_OEM_DENY_3,
+ enabled);
+ return 0;
+ }
+ case "get-chain3-enabled": {
+ final boolean chainEnabled = getFirewallChainEnabled(
+ ConnectivityManager.FIREWALL_CHAIN_OEM_DENY_3);
+ pw.println("chain:" + (chainEnabled ? "enabled" : "disabled"));
+ return 0;
+ }
+ case "set-package-networking-enabled": {
+ final Boolean enabled = parseBooleanArgument(getNextArg());
+ final String packageName = getNextArg();
+ if (null == enabled || null == packageName) {
+ onHelp();
+ return -1;
+ }
+ // Throws NameNotFound if the package doesn't exist.
+ final int appId = setPackageFirewallRule(
+ ConnectivityManager.FIREWALL_CHAIN_OEM_DENY_3,
+ packageName, enabled ? FIREWALL_RULE_DEFAULT : FIREWALL_RULE_DENY);
+ final String msg = (enabled ? "Enabled" : "Disabled")
+ + " networking for " + packageName + ", appId " + appId;
+ Log.i(TAG, msg);
+ pw.println(msg);
+ return 0;
+ }
+ case "get-package-networking-enabled": {
+ final String packageName = getNextArg();
+ final int rule = getPackageFirewallRule(
+ ConnectivityManager.FIREWALL_CHAIN_OEM_DENY_3, packageName);
+ if (FIREWALL_RULE_ALLOW == rule || FIREWALL_RULE_DEFAULT == rule) {
+ pw.println(packageName + ":" + "allow");
+ } else if (FIREWALL_RULE_DENY == rule) {
+ pw.println(packageName + ":" + "deny");
+ } else {
+ throw new IllegalStateException("Unknown rule " + rule + " for package "
+ + packageName);
+ }
+ return 0;
+ }
case "reevaluate":
// Usage : adb shell cmd connectivity reevaluate <netId>
// If netId is omitted, then reevaluate the default network
@@ -10683,6 +10739,15 @@
pw.println(" Turn airplane mode on or off.");
pw.println(" airplane-mode");
pw.println(" Get airplane mode.");
+ pw.println(" set-chain3-enabled [true|false]");
+ pw.println(" Enable or disable FIREWALL_CHAIN_OEM_DENY_3 for debugging.");
+ pw.println(" get-chain3-enabled");
+ pw.println(" Returns whether FIREWALL_CHAIN_OEM_DENY_3 is enabled.");
+ pw.println(" set-package-networking-enabled [true|false] [package name]");
+ pw.println(" Set the deny bit in FIREWALL_CHAIN_OEM_DENY_3 to package. This has\n"
+ + " no effect if the chain is disabled.");
+ pw.println(" get-package-networking-enabled [package name]");
+ pw.println(" Get the deny bit in FIREWALL_CHAIN_OEM_DENY_3 for package.");
}
}
@@ -12418,6 +12483,21 @@
}
}
+ private int setPackageFirewallRule(final int chain, final String packageName, final int rule)
+ throws PackageManager.NameNotFoundException {
+ final PackageManager pm = mContext.getPackageManager();
+ final int appId = UserHandle.getAppId(pm.getPackageUid(packageName, 0 /* flags */));
+ if (appId < Process.FIRST_APPLICATION_UID) {
+ throw new RuntimeException("Can't set package firewall rule for system app "
+ + packageName + " with appId " + appId);
+ }
+ for (final UserHandle uh : mUserManager.getUserHandles(false /* excludeDying */)) {
+ final int uid = uh.getUid(appId);
+ setUidFirewallRule(chain, uid, rule);
+ }
+ return appId;
+ }
+
@Override
public void setUidFirewallRule(final int chain, final int uid, final int rule) {
enforceNetworkStackOrSettingsPermission();
@@ -12436,6 +12516,13 @@
}
}
+ private int getPackageFirewallRule(final int chain, final String packageName)
+ throws PackageManager.NameNotFoundException {
+ final PackageManager pm = mContext.getPackageManager();
+ final int appId = UserHandle.getAppId(pm.getPackageUid(packageName, 0 /* flags */));
+ return getUidFirewallRule(chain, appId);
+ }
+
@Override
public int getUidFirewallRule(final int chain, final int uid) {
enforceNetworkStackOrSettingsPermission();
diff --git a/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java b/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java
index 4325763..88aa329 100644
--- a/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java
+++ b/service/src/com/android/server/connectivity/CarrierPrivilegeAuthenticator.java
@@ -35,6 +35,7 @@
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import android.util.Log;
+import android.util.SparseIntArray;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
@@ -63,7 +64,7 @@
private final TelephonyManagerShim mTelephonyManagerShim;
private final TelephonyManager mTelephonyManager;
@GuardedBy("mLock")
- private int[] mCarrierServiceUid;
+ private final SparseIntArray mCarrierServiceUid = new SparseIntArray(2 /* initialCapacity */);
@GuardedBy("mLock")
private int mModemCount = 0;
private final Object mLock = new Object();
@@ -75,7 +76,7 @@
public CarrierPrivilegeAuthenticator(@NonNull final Context c,
@NonNull final TelephonyManager t,
- @NonNull final TelephonyManagerShimImpl telephonyManagerShim) {
+ @NonNull final TelephonyManagerShim telephonyManagerShim) {
mContext = c;
mTelephonyManager = t;
mTelephonyManagerShim = telephonyManagerShim;
@@ -91,17 +92,7 @@
public CarrierPrivilegeAuthenticator(@NonNull final Context c,
@NonNull final TelephonyManager t) {
- mContext = c;
- mTelephonyManager = t;
- mTelephonyManagerShim = TelephonyManagerShimImpl.newInstance(mTelephonyManager);
- mThread = new HandlerThread(TAG);
- mThread.start();
- mHandler = new Handler(mThread.getLooper()) {};
- synchronized (mLock) {
- mModemCount = mTelephonyManager.getActiveModemCount();
- registerForCarrierChanges();
- updateCarrierServiceUid();
- }
+ this(c, t, TelephonyManagerShimImpl.newInstance(t));
}
/**
@@ -233,9 +224,9 @@
@VisibleForTesting
void updateCarrierServiceUid() {
synchronized (mLock) {
- mCarrierServiceUid = new int[mModemCount];
+ mCarrierServiceUid.clear();
for (int i = 0; i < mModemCount; i++) {
- mCarrierServiceUid[i] = getCarrierServicePackageUidForSlot(i);
+ mCarrierServiceUid.put(i, getCarrierServicePackageUidForSlot(i));
}
}
}
@@ -244,11 +235,8 @@
int getCarrierServiceUidForSubId(int subId) {
final int slotId = getSlotIndex(subId);
synchronized (mLock) {
- if (slotId != SubscriptionManager.INVALID_SIM_SLOT_INDEX && slotId < mModemCount) {
- return mCarrierServiceUid[slotId];
- }
+ return mCarrierServiceUid.get(slotId, Process.INVALID_UID);
}
- return Process.INVALID_UID;
}
@VisibleForTesting
diff --git a/service/src/com/android/server/connectivity/NetworkDiagnostics.java b/service/src/com/android/server/connectivity/NetworkDiagnostics.java
index e1e2585..3db37e5 100644
--- a/service/src/com/android/server/connectivity/NetworkDiagnostics.java
+++ b/service/src/com/android/server/connectivity/NetworkDiagnostics.java
@@ -340,8 +340,9 @@
@TargetApi(Build.VERSION_CODES.S)
private int getMtuForTarget(InetAddress target) {
final int family = target instanceof Inet4Address ? AF_INET : AF_INET6;
+ FileDescriptor socket = null;
try {
- final FileDescriptor socket = Os.socket(family, SOCK_DGRAM, 0);
+ socket = Os.socket(family, SOCK_DGRAM, 0);
mNetwork.bindSocket(socket);
Os.connect(socket, target, 0);
if (family == AF_INET) {
@@ -352,6 +353,8 @@
} catch (ErrnoException | IOException e) {
Log.e(TAG, "Can't get MTU for destination " + target, e);
return -1;
+ } finally {
+ IoUtils.closeQuietly(socket);
}
}
diff --git a/staticlibs/Android.bp b/staticlibs/Android.bp
index ee79ef2..59a63f2 100644
--- a/staticlibs/Android.bp
+++ b/staticlibs/Android.bp
@@ -48,7 +48,7 @@
// "src_devicecommon/**/*.kt",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
target_sdk_version: "30",
apex_available: [
"//apex_available:anyapex",
@@ -128,7 +128,7 @@
"framework/com/android/net/module/util/HexDump.java",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
visibility: [
"//packages/modules/Connectivity:__subpackages__",
"//packages/modules/NetworkStack:__subpackages__",
@@ -153,7 +153,7 @@
"device/com/android/net/module/util/structs/*.java",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
visibility: [
"//packages/modules/Connectivity:__subpackages__",
"//packages/modules/NetworkStack:__subpackages__",
@@ -178,7 +178,7 @@
"device/com/android/net/module/util/netlink/*.java",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
visibility: [
"//packages/modules/Connectivity:__subpackages__",
"//packages/modules/NetworkStack:__subpackages__",
@@ -204,7 +204,7 @@
"device/com/android/net/module/util/ip/*.java",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
visibility: [
"//packages/modules/Connectivity:__subpackages__",
"//packages/modules/NetworkStack:__subpackages__",
@@ -232,7 +232,7 @@
":net-utils-framework-common-srcs",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
libs: [
"androidx.annotation_annotation",
"framework-annotations-lib",
@@ -310,7 +310,7 @@
"device/com/android/net/module/util/async/*.java",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
visibility: [
"//packages/modules/Connectivity:__subpackages__",
],
@@ -332,7 +332,7 @@
"device/com/android/net/module/util/wear/*.java",
],
sdk_version: "module_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
visibility: [
"//packages/modules/Connectivity:__subpackages__",
],
diff --git a/staticlibs/client-libs/Android.bp b/staticlibs/client-libs/Android.bp
index c560045..c938dd6 100644
--- a/staticlibs/client-libs/Android.bp
+++ b/staticlibs/client-libs/Android.bp
@@ -6,7 +6,7 @@
name: "netd-client",
srcs: ["netd/**/*"],
sdk_version: "system_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
apex_available: [
"//apex_available:platform",
"com.android.tethering",
diff --git a/staticlibs/client-libs/tests/unit/Android.bp b/staticlibs/client-libs/tests/unit/Android.bp
index 220a6c1..03e3e70 100644
--- a/staticlibs/client-libs/tests/unit/Android.bp
+++ b/staticlibs/client-libs/tests/unit/Android.bp
@@ -8,7 +8,7 @@
"src/**/*.java",
"src/**/*.kt",
],
- min_sdk_version: "29",
+ min_sdk_version: "30",
static_libs: [
"androidx.test.rules",
"mockito-target-extended-minus-junit4",
diff --git a/staticlibs/native/bpf_headers/include/bpf/BpfMap.h b/staticlibs/native/bpf_headers/include/bpf/BpfMap.h
index 847083e..3be7067 100644
--- a/staticlibs/native/bpf_headers/include/bpf/BpfMap.h
+++ b/staticlibs/native/bpf_headers/include/bpf/BpfMap.h
@@ -18,10 +18,10 @@
#include <linux/bpf.h>
+#include <android/log.h>
#include <android-base/result.h>
#include <android-base/stringprintf.h>
#include <android-base/unique_fd.h>
-#include <utils/Log.h>
#include "BpfSyscallWrappers.h"
#include "bpf/BpfUtils.h"
diff --git a/staticlibs/native/netjniutils/Android.bp b/staticlibs/native/netjniutils/Android.bp
index 22fd1fa..ca3bbbc 100644
--- a/staticlibs/native/netjniutils/Android.bp
+++ b/staticlibs/native/netjniutils/Android.bp
@@ -31,8 +31,8 @@
"-Werror",
"-Wno-unused-parameter",
],
- sdk_version: "29",
- min_sdk_version: "29",
+ sdk_version: "30",
+ min_sdk_version: "30",
apex_available: [
"//apex_available:anyapex",
"//apex_available:platform",
diff --git a/staticlibs/netd/Android.bp b/staticlibs/netd/Android.bp
index d135a1c..65b3b09 100644
--- a/staticlibs/netd/Android.bp
+++ b/staticlibs/netd/Android.bp
@@ -19,7 +19,7 @@
java_library {
name: "netd_aidl_interface-lateststable-java",
sdk_version: "system_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
static_libs: [
"netd_aidl_interface-V13-java",
],
@@ -38,7 +38,7 @@
apex_available: [
"com.android.resolv",
],
- min_sdk_version: "29",
+ min_sdk_version: "30",
}
cc_library_static {
@@ -50,7 +50,7 @@
"com.android.resolv",
"com.android.tethering",
],
- min_sdk_version: "29",
+ min_sdk_version: "30",
}
cc_defaults {
@@ -96,17 +96,17 @@
"com.android.tethering",
"com.android.wifi",
],
- // this is part of updatable modules(NetworkStack) which targets 29(Q)
- min_sdk_version: "29",
+ // this is part of updatable modules(NetworkStack) which targets 30(R)
+ min_sdk_version: "30",
},
ndk: {
apex_available: [
"//apex_available:platform",
"com.android.tethering",
],
- // This is necessary for the DnsResovler tests to run in Android Q.
- // Soong would recognize this value and produce the Q compatible aidl library.
- min_sdk_version: "29",
+ // This is necessary for the DnsResovler tests to run in Android R.
+ // Soong would recognize this value and produce the R compatible aidl library.
+ min_sdk_version: "30",
},
},
versions_with_info: [
@@ -170,7 +170,7 @@
java_library {
name: "netd_event_listener_interface-lateststable-java",
sdk_version: "system_current",
- min_sdk_version: "29",
+ min_sdk_version: "30",
static_libs: [
"netd_event_listener_interface-V1-java",
],
@@ -194,7 +194,7 @@
"//apex_available:platform",
"com.android.resolv",
],
- min_sdk_version: "29",
+ min_sdk_version: "30",
},
java: {
apex_available: [
@@ -202,7 +202,7 @@
"com.android.wifi",
"com.android.tethering",
],
- min_sdk_version: "29",
+ min_sdk_version: "30",
},
},
versions_with_info: [
diff --git a/staticlibs/netd/libnetdutils/Android.bp b/staticlibs/netd/libnetdutils/Android.bp
index 3169033..fdb9380 100644
--- a/staticlibs/netd/libnetdutils/Android.bp
+++ b/staticlibs/netd/libnetdutils/Android.bp
@@ -40,7 +40,7 @@
"com.android.resolv",
"com.android.tethering",
],
- min_sdk_version: "29",
+ min_sdk_version: "30",
}
cc_test {
diff --git a/staticlibs/tests/unit/Android.bp b/staticlibs/tests/unit/Android.bp
index 40371e6..031e52f 100644
--- a/staticlibs/tests/unit/Android.bp
+++ b/staticlibs/tests/unit/Android.bp
@@ -9,7 +9,7 @@
android_library {
name: "NetworkStaticLibTestsLib",
srcs: ["src/**/*.java","src/**/*.kt"],
- min_sdk_version: "29",
+ min_sdk_version: "30",
defaults: ["framework-connectivity-test-defaults"],
static_libs: [
"androidx.test.rules",
diff --git a/staticlibs/testutils/app/connectivitychecker/Android.bp b/staticlibs/testutils/app/connectivitychecker/Android.bp
index f7118cf..049ec9e 100644
--- a/staticlibs/testutils/app/connectivitychecker/Android.bp
+++ b/staticlibs/testutils/app/connectivitychecker/Android.bp
@@ -20,9 +20,9 @@
name: "ConnectivityTestPreparer",
srcs: ["src/**/*.kt"],
sdk_version: "system_current",
- // Allow running the test on any device with SDK Q+, even when built from a branch that uses
+ // Allow running the test on any device with SDK R+, even when built from a branch that uses
// an unstable SDK, by targeting a stable SDK regardless of the build SDK.
- min_sdk_version: "29",
+ min_sdk_version: "30",
target_sdk_version: "30",
static_libs: [
"androidx.test.rules",
diff --git a/staticlibs/testutils/host/com/android/testutils/ConnectivityTestTargetPreparer.kt b/staticlibs/testutils/host/com/android/testutils/ConnectivityTestTargetPreparer.kt
index 3fc74aa..eb94781 100644
--- a/staticlibs/testutils/host/com/android/testutils/ConnectivityTestTargetPreparer.kt
+++ b/staticlibs/testutils/host/com/android/testutils/ConnectivityTestTargetPreparer.kt
@@ -32,6 +32,10 @@
private const val CONNECTIVITY_CHECK_RUNNER_NAME = "androidx.test.runner.AndroidJUnitRunner"
private const val IGNORE_CONN_CHECK_OPTION = "ignore-connectivity-check"
+// The default updater package names, which might be updating packages while the CTS
+// are running
+private val UPDATER_PKGS = arrayOf("com.google.android.gms", "com.android.vending")
+
/**
* A target preparer that sets up and verifies a device for connectivity tests.
*
@@ -45,35 +49,42 @@
@Option(name = IGNORE_CONN_CHECK_OPTION,
description = "Disables the check for mobile data and wifi")
private var ignoreConnectivityCheck = false
+ // The default value is never used, but false is a reasonable default
+ private var originalTestChainEnabled = false
+ private val originalUpdaterPkgsStatus = HashMap<String, Boolean>()
- override fun setUp(testInformation: TestInformation) {
+ override fun setUp(testInfo: TestInformation) {
if (isDisabled) return
- disableGmsUpdate(testInformation)
- runPreparerApk(testInformation)
+ disableGmsUpdate(testInfo)
+ originalTestChainEnabled = getTestChainEnabled(testInfo)
+ originalUpdaterPkgsStatus.putAll(getUpdaterPkgsStatus(testInfo))
+ setUpdaterNetworkingEnabled(testInfo, enableChain = true,
+ enablePkgs = UPDATER_PKGS.associateWith { false })
+ runPreparerApk(testInfo)
}
- private fun runPreparerApk(testInformation: TestInformation) {
+ private fun runPreparerApk(testInfo: TestInformation) {
installer.setCleanApk(true)
installer.addTestFileName(CONNECTIVITY_CHECKER_APK)
installer.setShouldGrantPermission(true)
- installer.setUp(testInformation)
+ installer.setUp(testInfo)
val runner = DefaultRemoteAndroidTestRunner(
CONNECTIVITY_PKG_NAME,
CONNECTIVITY_CHECK_RUNNER_NAME,
- testInformation.device.iDevice)
+ testInfo.device.iDevice)
runner.runOptions = "--no-hidden-api-checks"
val receiver = CollectingTestListener()
- if (!testInformation.device.runInstrumentationTests(runner, receiver)) {
+ if (!testInfo.device.runInstrumentationTests(runner, receiver)) {
throw TargetSetupError("Device state check failed to complete",
- testInformation.device.deviceDescriptor)
+ testInfo.device.deviceDescriptor)
}
val runResult = receiver.currentRunResults
if (runResult.isRunFailure) {
throw TargetSetupError("Failed to check device state before the test: " +
- runResult.runFailureMessage, testInformation.device.deviceDescriptor)
+ runResult.runFailureMessage, testInfo.device.deviceDescriptor)
}
val ignoredTestClasses = mutableSetOf<String>()
@@ -92,25 +103,50 @@
if (errorMsg.isBlank()) return
throw TargetSetupError("Device setup checks failed. Check the test bench: \n$errorMsg",
- testInformation.device.deviceDescriptor)
+ testInfo.device.deviceDescriptor)
}
- private fun disableGmsUpdate(testInformation: TestInformation) {
+ private fun disableGmsUpdate(testInfo: TestInformation) {
// This will be a no-op on devices without root (su) or not using gservices, but that's OK.
- testInformation.device.executeShellCommand("su 0 am broadcast " +
+ testInfo.exec("su 0 am broadcast " +
"-a com.google.gservices.intent.action.GSERVICES_OVERRIDE " +
"-e finsky.play_services_auto_update_enabled false")
}
- private fun clearGmsUpdateOverride(testInformation: TestInformation) {
- testInformation.device.executeShellCommand("su 0 am broadcast " +
+ private fun clearGmsUpdateOverride(testInfo: TestInformation) {
+ testInfo.exec("su 0 am broadcast " +
"-a com.google.gservices.intent.action.GSERVICES_OVERRIDE " +
"--esn finsky.play_services_auto_update_enabled")
}
- override fun tearDown(testInformation: TestInformation, e: Throwable?) {
+ private fun setUpdaterNetworkingEnabled(
+ testInfo: TestInformation,
+ enableChain: Boolean,
+ enablePkgs: Map<String, Boolean>
+ ) {
+ // Build.VERSION_CODES.S = 31 where this is not available, then do nothing.
+ if (testInfo.device.getApiLevel() < 31) return
+ testInfo.exec("cmd connectivity set-chain3-enabled $enableChain")
+ enablePkgs.forEach { (pkg, allow) ->
+ testInfo.exec("cmd connectivity set-package-networking-enabled $pkg $allow")
+ }
+ }
+
+ private fun getTestChainEnabled(testInfo: TestInformation) =
+ testInfo.exec("cmd connectivity get-chain3-enabled").contains("chain:enabled")
+
+ private fun getUpdaterPkgsStatus(testInfo: TestInformation) =
+ UPDATER_PKGS.associateWith { pkg ->
+ !testInfo.exec("cmd connectivity get-package-networking-enabled $pkg")
+ .contains(":deny")
+ }
+
+ override fun tearDown(testInfo: TestInformation, e: Throwable?) {
if (isTearDownDisabled) return
- installer.tearDown(testInformation, e)
- clearGmsUpdateOverride(testInformation)
+ installer.tearDown(testInfo, e)
+ setUpdaterNetworkingEnabled(testInfo,
+ enableChain = originalTestChainEnabled,
+ enablePkgs = originalUpdaterPkgsStatus)
+ clearGmsUpdateOverride(testInfo)
}
}
diff --git a/staticlibs/testutils/host/com/android/testutils/DisableConfigSyncTargetPreparer.kt b/staticlibs/testutils/host/com/android/testutils/DisableConfigSyncTargetPreparer.kt
index 63f05a6..bc00f3c 100644
--- a/staticlibs/testutils/host/com/android/testutils/DisableConfigSyncTargetPreparer.kt
+++ b/staticlibs/testutils/host/com/android/testutils/DisableConfigSyncTargetPreparer.kt
@@ -58,4 +58,4 @@
}
}
-private fun TestInformation.exec(cmd: String) = this.device.executeShellCommand(cmd)
\ No newline at end of file
+fun TestInformation.exec(cmd: String) = this.device.executeShellCommand(cmd)
diff --git a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
index 59aefa5..d2c9481 100644
--- a/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
+++ b/tests/cts/net/src/android/net/cts/ConnectivityManagerTest.java
@@ -2723,7 +2723,8 @@
// the network with the TEST transport. Also wait for validation here, in case there
// is a bug that's only visible when the network is validated.
setWifiMeteredStatusAndWait(ssid, true /* isMetered */, true /* waitForValidation */);
- defaultCallback.expect(CallbackEntry.LOST, wifiNetwork, NETWORK_CALLBACK_TIMEOUT_MS);
+ defaultCallback.eventuallyExpect(CallbackEntry.LOST, NETWORK_CALLBACK_TIMEOUT_MS,
+ l -> l.getNetwork().equals(wifiNetwork));
waitForAvailable(defaultCallback, tnt.getNetwork());
// Depending on if this device has cellular connectivity or not, multiple available
// callbacks may be received. Eventually, metered Wi-Fi should be the final available
diff --git a/tests/cts/net/src/android/net/cts/MdnsTestUtils.kt b/tests/cts/net/src/android/net/cts/MdnsTestUtils.kt
index bc13442..eef3f87 100644
--- a/tests/cts/net/src/android/net/cts/MdnsTestUtils.kt
+++ b/tests/cts/net/src/android/net/cts/MdnsTestUtils.kt
@@ -233,46 +233,51 @@
}
}
+private fun getMdnsPayload(packet: ByteArray) = packet.copyOfRange(
+ ETHER_HEADER_LEN + IPV6_HEADER_LEN + UDP_HEADER_LEN, packet.size)
+
fun TapPacketReader.pollForMdnsPacket(
timeoutMs: Long = MDNS_REGISTRATION_TIMEOUT_MS,
predicate: (TestDnsPacket) -> Boolean
-): ByteArray? {
+): TestDnsPacket? {
val mdnsProbeFilter = IPv6UdpFilter(srcPort = MDNS_PORT, dstPort = MDNS_PORT).and {
- val mdnsPayload = it.copyOfRange(
- ETHER_HEADER_LEN + IPV6_HEADER_LEN + UDP_HEADER_LEN, it.size
- )
+ val mdnsPayload = getMdnsPayload(it)
try {
predicate(TestDnsPacket(mdnsPayload))
} catch (e: DnsPacket.ParseException) {
false
}
}
- return poll(timeoutMs, mdnsProbeFilter)
+ return poll(timeoutMs, mdnsProbeFilter)?.let { TestDnsPacket(getMdnsPayload(it)) }
}
fun TapPacketReader.pollForProbe(
serviceName: String,
serviceType: String,
timeoutMs: Long = MDNS_REGISTRATION_TIMEOUT_MS
-): ByteArray? = pollForMdnsPacket(timeoutMs) { it.isProbeFor("$serviceName.$serviceType.local") }
+): TestDnsPacket? = pollForMdnsPacket(timeoutMs) {
+ it.isProbeFor("$serviceName.$serviceType.local")
+}
fun TapPacketReader.pollForAdvertisement(
serviceName: String,
serviceType: String,
timeoutMs: Long = MDNS_REGISTRATION_TIMEOUT_MS
-): ByteArray? = pollForMdnsPacket(timeoutMs) { it.isReplyFor("$serviceName.$serviceType.local") }
+): TestDnsPacket? = pollForMdnsPacket(timeoutMs) {
+ it.isReplyFor("$serviceName.$serviceType.local")
+}
fun TapPacketReader.pollForQuery(
recordName: String,
- recordType: Int,
+ vararg requiredTypes: Int,
timeoutMs: Long = MDNS_REGISTRATION_TIMEOUT_MS
-): ByteArray? = pollForMdnsPacket(timeoutMs) { it.isQueryFor(recordName, recordType) }
+): TestDnsPacket? = pollForMdnsPacket(timeoutMs) { it.isQueryFor(recordName, *requiredTypes) }
fun TapPacketReader.pollForReply(
serviceName: String,
serviceType: String,
timeoutMs: Long = MDNS_REGISTRATION_TIMEOUT_MS
-): ByteArray? = pollForMdnsPacket(timeoutMs) {
+): TestDnsPacket? = pollForMdnsPacket(timeoutMs) {
it.isReplyFor("$serviceName.$serviceType.local")
}
@@ -289,7 +294,9 @@
it.dName == name && it.nsType == DnsResolver.TYPE_SRV
}
- fun isQueryFor(name: String, type: Int): Boolean = mRecords[QDSECTION].any {
- it.dName == name && it.nsType == type
+ fun isQueryFor(name: String, vararg requiredTypes: Int): Boolean = requiredTypes.all { type ->
+ mRecords[QDSECTION].any {
+ it.dName == name && it.nsType == type
+ }
}
}
diff --git a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
index 27bd5d3..9c44a3e 100644
--- a/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
+++ b/tests/cts/net/src/android/net/cts/NsdManagerTest.kt
@@ -20,6 +20,7 @@
import android.app.compat.CompatChanges
import android.net.ConnectivityManager
import android.net.ConnectivityManager.NetworkCallback
+import android.net.DnsResolver
import android.net.InetAddresses.parseNumericAddress
import android.net.LinkAddress
import android.net.LinkProperties
@@ -87,6 +88,7 @@
import com.android.testutils.TestableNetworkAgent
import com.android.testutils.TestableNetworkAgent.CallbackEntry.OnNetworkCreated
import com.android.testutils.TestableNetworkCallback
+import com.android.testutils.assertEmpty
import com.android.testutils.filters.CtsNetTestCasesMaxTargetSdk30
import com.android.testutils.filters.CtsNetTestCasesMaxTargetSdk33
import com.android.testutils.runAsShell
@@ -424,11 +426,7 @@
@Test
fun testNsdManager_DiscoverOnNetwork() {
- val si = NsdServiceInfo()
- si.serviceType = serviceType
- si.serviceName = this.serviceName
- si.port = 12345 // Test won't try to connect so port does not matter
-
+ val si = makeTestServiceInfo()
val registrationRecord = NsdRegistrationRecord()
val registeredInfo = registerService(registrationRecord, si)
@@ -455,11 +453,7 @@
@Test
fun testNsdManager_DiscoverWithNetworkRequest() {
- val si = NsdServiceInfo()
- si.serviceType = serviceType
- si.serviceName = this.serviceName
- si.port = 12345 // Test won't try to connect so port does not matter
-
+ val si = makeTestServiceInfo()
val handler = Handler(handlerThread.looper)
val executor = Executor { handler.post(it) }
@@ -524,11 +518,6 @@
@Test
fun testNsdManager_DiscoverWithNetworkRequest_NoMatchingNetwork() {
- val si = NsdServiceInfo()
- si.serviceType = serviceType
- si.serviceName = this.serviceName
- si.port = 12345 // Test won't try to connect so port does not matter
-
val handler = Handler(handlerThread.looper)
val executor = Executor { handler.post(it) }
@@ -568,11 +557,7 @@
@Test
fun testNsdManager_ResolveOnNetwork() {
- val si = NsdServiceInfo()
- si.serviceType = serviceType
- si.serviceName = this.serviceName
- si.port = 12345 // Test won't try to connect so port does not matter
-
+ val si = makeTestServiceInfo()
val registrationRecord = NsdRegistrationRecord()
val registeredInfo = registerService(registrationRecord, si)
tryTest {
@@ -610,12 +595,7 @@
@Test
fun testNsdManager_RegisterOnNetwork() {
- val si = NsdServiceInfo()
- si.serviceType = serviceType
- si.serviceName = this.serviceName
- si.network = testNetwork1.network
- si.port = 12345 // Test won't try to connect so port does not matter
-
+ val si = makeTestServiceInfo(testNetwork1.network)
// Register service on testNetwork1
val registrationRecord = NsdRegistrationRecord()
registerService(registrationRecord, si)
@@ -889,11 +869,7 @@
@Test
fun testStopServiceResolution() {
- val si = NsdServiceInfo()
- si.serviceType = this@NsdManagerTest.serviceType
- si.serviceName = this@NsdManagerTest.serviceName
- si.port = 12345 // Test won't try to connect so port does not matter
-
+ val si = makeTestServiceInfo()
val resolveRecord = NsdResolveRecord()
// Try to resolve an unknown service then stop it immediately.
// Expected ResolutionStopped callback.
@@ -911,12 +887,7 @@
val addresses = lp.addresses
assertFalse(addresses.isEmpty())
- val si = NsdServiceInfo().apply {
- serviceType = this@NsdManagerTest.serviceType
- serviceName = this@NsdManagerTest.serviceName
- network = testNetwork1.network
- port = 12345 // Test won't try to connect so port does not matter
- }
+ val si = makeTestServiceInfo(testNetwork1.network)
// Register service on the network
val registrationRecord = NsdRegistrationRecord()
@@ -1022,11 +993,7 @@
// This test requires shims supporting T+ APIs (NsdServiceInfo.network)
assumeTrue(TestUtils.shouldTestTApis())
- val si = NsdServiceInfo()
- si.serviceType = serviceType
- si.serviceName = serviceName
- si.network = testNetwork1.network
- si.port = 12345 // Test won't try to connect so port does not matter
+ val si = makeTestServiceInfo(testNetwork1.network)
val packetReader = TapPacketReader(Handler(handlerThread.looper),
testNetwork1.iface.fileDescriptor.fileDescriptor, 1500 /* maxPacketSize */)
@@ -1063,11 +1030,7 @@
// This test requires shims supporting T+ APIs (NsdServiceInfo.network)
assumeTrue(TestUtils.shouldTestTApis())
- val si = NsdServiceInfo()
- si.serviceType = serviceType
- si.serviceName = serviceName
- si.network = testNetwork1.network
- si.port = 12345 // Test won't try to connect so port does not matter
+ val si = makeTestServiceInfo(testNetwork1.network)
// Register service on testNetwork1
val registrationRecord = NsdRegistrationRecord()
@@ -1137,6 +1100,127 @@
}
}
+ // Test that even if only a PTR record is received as a reply when discovering, without the
+ // SRV, TXT, address records as recommended (but not mandated) by RFC 6763 12, the service can
+ // still be discovered.
+ @Test
+ fun testDiscoveryWithPtrOnlyResponse_ServiceIsFound() {
+ // Register service on testNetwork1
+ val discoveryRecord = NsdDiscoveryRecord()
+ val packetReader = TapPacketReader(Handler(handlerThread.looper),
+ testNetwork1.iface.fileDescriptor.fileDescriptor, 1500 /* maxPacketSize */)
+ packetReader.startAsyncForTest()
+ handlerThread.waitForIdle(TIMEOUT_MS)
+
+ nsdManager.discoverServices(serviceType, NsdManager.PROTOCOL_DNS_SD,
+ testNetwork1.network, { it.run() }, discoveryRecord)
+
+ tryTest {
+ discoveryRecord.expectCallback<DiscoveryStarted>()
+ assertNotNull(packetReader.pollForQuery("$serviceType.local", DnsResolver.TYPE_PTR))
+ /*
+ Generated with:
+ scapy.raw(scapy.DNS(rd=0, qr=1, aa=1, qd = None, an =
+ scapy.DNSRR(rrname='_nmt123456789._tcp.local', type='PTR', ttl=120,
+ rdata='NsdTest123456789._nmt123456789._tcp.local'))).hex()
+ */
+ val ptrResponsePayload = HexDump.hexStringToByteArray("0000840000000001000000000d5f6e" +
+ "6d74313233343536373839045f746370056c6f63616c00000c000100000078002b104e736454" +
+ "6573743132333435363738390d5f6e6d74313233343536373839045f746370056c6f63616c00")
+
+ replaceServiceNameAndTypeWithTestSuffix(ptrResponsePayload)
+ packetReader.sendResponse(buildMdnsPacket(ptrResponsePayload))
+
+ val serviceFound = discoveryRecord.expectCallback<ServiceFound>()
+ serviceFound.serviceInfo.let {
+ assertEquals(serviceName, it.serviceName)
+ // Discovered service types have a dot at the end
+ assertEquals("$serviceType.", it.serviceType)
+ assertEquals(testNetwork1.network, it.network)
+ // ServiceFound does not provide port, address or attributes (only information
+ // available in the PTR record is included in that callback, regardless of whether
+ // other records exist).
+ assertEquals(0, it.port)
+ assertEmpty(it.hostAddresses)
+ assertEquals(0, it.attributes.size)
+ }
+ } cleanup {
+ nsdManager.stopServiceDiscovery(discoveryRecord)
+ discoveryRecord.expectCallback<DiscoveryStopped>()
+ }
+ }
+
+ // Test RFC 6763 12. "Clients MUST be capable of functioning correctly with DNS servers [...]
+ // that fail to generate these additional records automatically, by issuing subsequent queries
+ // for any further record(s) they require"
+ @Test
+ fun testResolveWhenServerSendsNoAdditionalRecord() {
+ // Resolve service on testNetwork1
+ val resolveRecord = NsdResolveRecord()
+ val packetReader = TapPacketReader(Handler(handlerThread.looper),
+ testNetwork1.iface.fileDescriptor.fileDescriptor, 1500 /* maxPacketSize */)
+ packetReader.startAsyncForTest()
+ handlerThread.waitForIdle(TIMEOUT_MS)
+
+ val si = makeTestServiceInfo(testNetwork1.network)
+ nsdManager.resolveService(si, { it.run() }, resolveRecord)
+
+ val serviceFullName = "$serviceName.$serviceType.local"
+ // The query should ask for ANY, since both SRV and TXT are requested. Note legacy
+ // mdnsresponder will ask for SRV and TXT separately, and will not proceed to asking for
+ // address records without an answer for both.
+ val srvTxtQuery = packetReader.pollForQuery(serviceFullName, DnsResolver.TYPE_ANY)
+ assertNotNull(srvTxtQuery)
+
+ /*
+ Generated with:
+ scapy.raw(scapy.dns_compress(scapy.DNS(rd=0, qr=1, aa=1, qd = None, an =
+ scapy.DNSRRSRV(rrname='NsdTest123456789._nmt123456789._tcp.local',
+ rclass=0x8001, port=31234, target='testhost.local', ttl=120) /
+ scapy.DNSRR(rrname='NsdTest123456789._nmt123456789._tcp.local', type='TXT', ttl=120,
+ rdata='testkey=testvalue')
+ ))).hex()
+ */
+ val srvTxtResponsePayload = HexDump.hexStringToByteArray("000084000000000200000000104" +
+ "e7364546573743132333435363738390d5f6e6d74313233343536373839045f746370056c6f6" +
+ "3616c0000218001000000780011000000007a020874657374686f7374c030c00c00100001000" +
+ "00078001211746573746b65793d7465737476616c7565")
+ replaceServiceNameAndTypeWithTestSuffix(srvTxtResponsePayload)
+ packetReader.sendResponse(buildMdnsPacket(srvTxtResponsePayload))
+
+ val testHostname = "testhost.local"
+ val addressQuery = packetReader.pollForQuery(testHostname,
+ DnsResolver.TYPE_A, DnsResolver.TYPE_AAAA)
+ assertNotNull(addressQuery)
+
+ /*
+ Generated with:
+ scapy.raw(scapy.dns_compress(scapy.DNS(rd=0, qr=1, aa=1, qd = None, an =
+ scapy.DNSRR(rrname='testhost.local', type='A', ttl=120,
+ rdata='192.0.2.123') /
+ scapy.DNSRR(rrname='testhost.local', type='AAAA', ttl=120,
+ rdata='2001:db8::123')
+ ))).hex()
+ */
+ val addressPayload = HexDump.hexStringToByteArray("0000840000000002000000000874657374" +
+ "686f7374056c6f63616c0000010001000000780004c000027bc00c001c000100000078001020" +
+ "010db8000000000000000000000123")
+ packetReader.sendResponse(buildMdnsPacket(addressPayload))
+
+ val serviceResolved = resolveRecord.expectCallback<ServiceResolved>()
+ serviceResolved.serviceInfo.let {
+ assertEquals(serviceName, it.serviceName)
+ assertEquals(".$serviceType", it.serviceType)
+ assertEquals(testNetwork1.network, it.network)
+ assertEquals(31234, it.port)
+ assertEquals(1, it.attributes.size)
+ assertArrayEquals("testvalue".encodeToByteArray(), it.attributes["testkey"])
+ }
+ assertEquals(
+ setOf(parseNumericAddress("192.0.2.123"), parseNumericAddress("2001:db8::123")),
+ serviceResolved.serviceInfo.hostAddresses.toSet())
+ }
+
private fun buildConflictingAnnouncement(): ByteBuffer {
/*
Generated with:
@@ -1148,21 +1232,37 @@
val mdnsPayload = HexDump.hexStringToByteArray("000084000000000100000000104e736454657" +
"3743132333435363738390d5f6e6d74313233343536373839045f746370056c6f63616c00002" +
"18001000000780016000000007a0208636f6e666c696374056c6f63616c00")
- val packetBuffer = ByteBuffer.wrap(mdnsPayload)
- // Replace service name and types in the packet with the random ones used in the test.
+ replaceServiceNameAndTypeWithTestSuffix(mdnsPayload)
+
+ return buildMdnsPacket(mdnsPayload)
+ }
+
+ /**
+ * Replaces occurrences of "NsdTest123456789" and "_nmt123456789" in mDNS payload with the
+ * actual random name and type that are used by the test.
+ */
+ private fun replaceServiceNameAndTypeWithTestSuffix(mdnsPayload: ByteArray) {
// Test service name and types have consistent length and are always ASCII
val testPacketName = "NsdTest123456789".encodeToByteArray()
val testPacketTypePrefix = "_nmt123456789".encodeToByteArray()
val encodedServiceName = serviceName.encodeToByteArray()
val encodedTypePrefix = serviceType.split('.')[0].encodeToByteArray()
- assertEquals(testPacketName.size, encodedServiceName.size)
- assertEquals(testPacketTypePrefix.size, encodedTypePrefix.size)
- packetBuffer.position(mdnsPayload.indexOf(testPacketName))
- packetBuffer.put(encodedServiceName)
- packetBuffer.position(mdnsPayload.indexOf(testPacketTypePrefix))
- packetBuffer.put(encodedTypePrefix)
- return buildMdnsPacket(mdnsPayload)
+ val packetBuffer = ByteBuffer.wrap(mdnsPayload)
+ replaceAll(packetBuffer, testPacketName, encodedServiceName)
+ replaceAll(packetBuffer, testPacketTypePrefix, encodedTypePrefix)
+ }
+
+ private tailrec fun replaceAll(buffer: ByteBuffer, source: ByteArray, replacement: ByteArray) {
+ assertEquals(source.size, replacement.size)
+ val index = buffer.array().indexOf(source)
+ if (index < 0) return
+
+ val origPosition = buffer.position()
+ buffer.position(index)
+ buffer.put(replacement)
+ buffer.position(origPosition)
+ replaceAll(buffer, source, replacement)
}
private fun buildMdnsPacket(mdnsPayload: ByteArray): ByteBuffer {
diff --git a/tests/unit/AndroidManifest.xml b/tests/unit/AndroidManifest.xml
index 5d4bdf7..2853f31 100644
--- a/tests/unit/AndroidManifest.xml
+++ b/tests/unit/AndroidManifest.xml
@@ -49,6 +49,9 @@
<uses-permission android:name="android.permission.NETWORK_FACTORY" />
<uses-permission android:name="android.permission.NETWORK_STATS_PROVIDER" />
<uses-permission android:name="android.permission.CONTROL_OEM_PAID_NETWORK_PREFERENCE" />
+ <!-- Workaround for flakes where the launcher package is not found despite the <queries> tag
+ below (b/286550950). -->
+ <uses-permission android:name="android.permission.QUERY_ALL_PACKAGES" />
<!-- Declare the intent that the test intends to query. This is necessary for
UiDevice.getLauncherPackageName which is used in NetworkNotificationManagerTest