Merge "Fix kotlin lint errors" into main
diff --git a/bpf/loader/NetBpfLoad.cpp b/bpf/loader/NetBpfLoad.cpp
index b9ef766..28cb09e 100644
--- a/bpf/loader/NetBpfLoad.cpp
+++ b/bpf/loader/NetBpfLoad.cpp
@@ -17,6 +17,7 @@
#define LOG_TAG "NetBpfLoad"
#include <arpa/inet.h>
+#include <bpf/btf.h>
#include <bpf/libbpf.h>
#include <dirent.h>
#include <elf.h>
@@ -51,6 +52,7 @@
#include <android-base/logging.h>
#include <android-base/macros.h>
#include <android-base/properties.h>
+#include <android-base/scopeguard.h>
#include <android-base/stringprintf.h>
#include <android-base/strings.h>
#include <android-base/unique_fd.h>
@@ -649,10 +651,185 @@
return false;
}
+static int setBtfDatasecSize(ifstream &elfFile, struct btf *btf,
+ struct btf_type *bt) {
+ const char *name = btf__name_by_offset(btf, bt->name_off);
+ if (!name) {
+ ALOGE("Couldn't resolve section name, errno: %d", errno);
+ return -errno;
+ }
+
+ vector<char> data;
+ int ret = readSectionByName(name, elfFile, data);
+ if (ret) {
+ ALOGE("Couldn't read section %s, ret: %d", name, ret);
+ return ret;
+ }
+ bt->size = data.size();
+ return 0;
+}
+
+static int getSymOffsetByName(ifstream &elfFile, const char *name, int *off) {
+ vector<Elf64_Sym> symtab;
+ int ret = readSymTab(elfFile, 1 /* sort */, symtab);
+ if (ret) return ret;
+ for (int i = 0; i < (int)symtab.size(); i++) {
+ string s;
+ ret = getSymName(elfFile, symtab[i].st_name, s);
+ if (ret) continue;
+ if (!strcmp(s.c_str(), name)) {
+ *off = symtab[i].st_value;
+ return 0;
+ }
+ }
+ return -1;
+}
+
+static int setBtfVarOffset(ifstream &elfFile, struct btf *btf,
+ struct btf_type *datasecBt) {
+ int i, vars = btf_vlen(datasecBt);
+ struct btf_var_secinfo *vsi;
+ const char *datasecName = btf__name_by_offset(btf, datasecBt->name_off);
+ if (!datasecName) {
+ ALOGE("Couldn't resolve section name, errno: %d", errno);
+ return -errno;
+ }
+
+ for (i = 0, vsi = btf_var_secinfos(datasecBt); i < vars; i++, vsi++) {
+ const struct btf_type *varBt = btf__type_by_id(btf, vsi->type);
+ if (!varBt || !btf_is_var(varBt)) {
+ ALOGE("Found non VAR kind btf_type, section: %s id: %d", datasecName,
+ vsi->type);
+ return -1;
+ }
+
+ const struct btf_var *var = btf_var(varBt);
+ if (var->linkage == BTF_VAR_STATIC) continue;
+
+ const char *varName = btf__name_by_offset(btf, varBt->name_off);
+ if (!varName) {
+ ALOGE("Failed to resolve var name, section: %s", datasecName);
+ return -1;
+ }
+
+ int off;
+ int ret = getSymOffsetByName(elfFile, varName, &off);
+ if (ret) {
+ ALOGE("No offset found in symbol table, section: %s, var: %s, ret: %d",
+ datasecName, varName, ret);
+ return ret;
+ }
+ vsi->offset = off;
+ }
+ return 0;
+}
+
+static int loadBtf(ifstream &elfFile, struct btf *btf) {
+ int ret;
+ for (unsigned int i = 1; i < btf__type_cnt(btf); ++i) {
+ struct btf_type *bt = (struct btf_type *)btf__type_by_id(btf, i);
+ if (!btf_is_datasec(bt)) continue;
+ ret = setBtfDatasecSize(elfFile, btf, bt);
+ if (ret) return ret;
+ ret = setBtfVarOffset(elfFile, btf, bt);
+ if (ret) return ret;
+ }
+
+ ret = btf__load_into_kernel(btf);
+ if (ret) {
+ if (errno != EINVAL) {
+ ALOGE("btf__load_into_kernel failed, errno: %d", errno);
+ return ret;
+ };
+ // For BTF_KIND_FUNC, newer kernels can read the BTF_INFO_VLEN bits of
+ // struct btf_type to distinguish static vs. global vs. extern
+ // functions, but older kernels enforce that only the BTF_INFO_KIND bits
+ // can be set. Retry with non-BTF_INFO_KIND bits zeroed out to handle
+ // this case.
+ for (unsigned int i = 1; i < btf__type_cnt(btf); ++i) {
+ struct btf_type *bt = (struct btf_type *)btf__type_by_id(btf, i);
+ if (btf_is_func(bt)) {
+ bt->info = (BTF_INFO_KIND(bt->info)) << 24;
+ }
+ }
+ ret = btf__load_into_kernel(btf);
+ if (ret) {
+ ALOGE("btf__load_into_kernel retry failed, errno: %d", errno);
+ return ret;
+ };
+ }
+ return 0;
+}
+
+int getKeyValueTids(const struct btf *btf, const char *mapName,
+ uint32_t expectedKeySize, uint32_t expectedValueSize,
+ uint32_t *keyTypeId, uint32_t *valueTypeId) {
+ const struct btf_type *kvBt;
+ const struct btf_member *key, *value;
+ const size_t max_name = 256;
+ char kvTypeName[max_name];
+ int64_t keySize, valueSize;
+ uint32_t kvId;
+
+ if (snprintf(kvTypeName, max_name, "____btf_map_%s", mapName) == max_name) {
+ ALOGE("____btf_map_%s is too long", mapName);
+ return -1;
+ }
+
+ kvId = btf__find_by_name(btf, kvTypeName);
+ if (kvId < 0) {
+ ALOGE("section not found, map: %s typeName: %s", mapName, kvTypeName);
+ return -1;
+ }
+
+ kvBt = btf__type_by_id(btf, kvId);
+ if (!kvBt) {
+ ALOGE("Couldn't find BTF type, map: %s id: %u", mapName, kvId);
+ return -1;
+ }
+
+ if (!btf_is_struct(kvBt) || btf_vlen(kvBt) < 2) {
+ ALOGE("Non Struct kind or invalid vlen, map: %s id: %u", mapName, kvId);
+ return -1;
+ }
+
+ key = btf_members(kvBt);
+ value = key + 1;
+
+ keySize = btf__resolve_size(btf, key->type);
+ if (keySize < 0) {
+ ALOGE("Couldn't get key size, map: %s errno: %d", mapName, errno);
+ return -1;
+ }
+
+ valueSize = btf__resolve_size(btf, value->type);
+ if (valueSize < 0) {
+ ALOGE("Couldn't get value size, map: %s errno: %d", mapName, errno);
+ return -1;
+ }
+
+ if (expectedKeySize != keySize || expectedValueSize != valueSize) {
+ ALOGE("Key value size mismatch, map: %s key size: %d expected key size: "
+ "%d value size: %d expected value size: %d",
+ mapName, (uint32_t)keySize, expectedKeySize, (uint32_t)valueSize,
+ expectedValueSize);
+ return -1;
+ }
+
+ *keyTypeId = key->type;
+ *valueTypeId = value->type;
+
+ return 0;
+}
+
+static bool isBtfSupported(enum bpf_map_type type) {
+ return type != BPF_MAP_TYPE_DEVMAP_HASH && type != BPF_MAP_TYPE_RINGBUF;
+}
+
static int createMaps(const char* elfPath, ifstream& elfFile, vector<unique_fd>& mapFds,
const char* prefix, const unsigned int bpfloader_ver) {
int ret;
- vector<char> mdData;
+ vector<char> mdData, btfData;
vector<struct bpf_map_def> md;
vector<string> mapNames;
string objName = pathToObjName(string(elfPath));
@@ -679,6 +856,21 @@
ret = getSectionSymNames(elfFile, "maps", mapNames);
if (ret) return ret;
+ ret = readSectionByName(".BTF", elfFile, btfData);
+ if (ret) {
+ ALOGE("Failed to read .BTF section, ret:%d", ret);
+ return ret;
+ }
+ struct btf *btf = btf__new(btfData.data(), btfData.size());
+ if (btf == NULL) {
+ ALOGE("btf__new failed, errno: %d", errno);
+ return -errno;
+ }
+ auto scopeGuard = base::make_scope_guard([btf] { btf__free(btf); });
+
+ ret = loadBtf(elfFile, btf);
+ if (ret) return ret;
+
unsigned kvers = kernelVersion();
for (int i = 0; i < (int)mapNames.size(); i++) {
@@ -804,12 +996,26 @@
};
if (isAtLeastKernelVersion(4, 15, 0))
strlcpy(req.map_name, mapNames[i].c_str(), sizeof(req.map_name));
+
+ if (isBtfSupported(type)) {
+ uint32_t kTid, vTid;
+ ret = getKeyValueTids(btf, mapNames[i].c_str(), md[i].key_size,
+ md[i].value_size, &kTid, &vTid);
+ if (ret) return ret;
+ req.btf_fd = btf__fd(btf);
+ req.btf_key_type_id = kTid;
+ req.btf_value_type_id = vTid;
+ ALOGI("Create map with BTF, map: %s", mapNames[i].c_str());
+ } else {
+ ALOGI("Create map without BTF, map: %s", mapNames[i].c_str());
+ }
+
fd.reset(bpf(BPF_MAP_CREATE, req));
saved_errno = errno;
if (fd.ok()) {
- ALOGD("bpf_create_map[%s] -> %d", mapNames[i].c_str(), fd.get());
+ ALOGD("bpf_create_map[%s] -> %d", mapNames[i].c_str(), fd.get());
} else {
- ALOGE("bpf_create_map[%s] -> %d errno:%d", mapNames[i].c_str(), fd.get(), saved_errno);
+ ALOGE("bpf_create_map[%s] -> %d errno:%d", mapNames[i].c_str(), fd.get(), saved_errno);
}
}
@@ -1414,6 +1620,29 @@
return wear;
}
+static int libbpfPrint(enum libbpf_print_level lvl, const char *const formatStr,
+ va_list argList) {
+ int32_t prio;
+ switch (lvl) {
+ case LIBBPF_WARN:
+ prio = ANDROID_LOG_WARN;
+ break;
+ case LIBBPF_INFO:
+ prio = ANDROID_LOG_INFO;
+ break;
+ case LIBBPF_DEBUG:
+ prio = ANDROID_LOG_DEBUG;
+ break;
+ }
+ char *s = strdup(formatStr ?: "(no format string)");
+ int len = strlen(s);
+ if (len && s[len - 1] == '\n')
+ s[len - 1] = 0;
+ LOG_PRI_VA(prio, LOG_TAG, s, argList);
+ free(s);
+ return 0;
+}
+
static int doLoad(char** argv, char * const envp[]) {
if (!isAtLeastS) {
ALOGE("Impossible - not reachable on Android <S.");
@@ -1421,6 +1650,7 @@
// for any possible busted 'optimized' start everything vendor init hacks on R
return 0;
}
+ libbpf_set_print(libbpfPrint);
const bool runningAsRoot = !getuid(); // true iff U QPR3 or V+
diff --git a/framework/src/android/net/ConnectivityManager.java b/framework/src/android/net/ConnectivityManager.java
index 4f18fa2..f8a1293 100644
--- a/framework/src/android/net/ConnectivityManager.java
+++ b/framework/src/android/net/ConnectivityManager.java
@@ -1200,11 +1200,14 @@
/** @hide */
public static final long FEATURE_USE_DECLARED_METHODS_FOR_CALLBACKS = 1L;
+ /** @hide */
+ public static final long FEATURE_QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER = 1L << 1;
/** @hide */
@Retention(RetentionPolicy.SOURCE)
@LongDef(flag = true, prefix = "FEATURE_", value = {
- FEATURE_USE_DECLARED_METHODS_FOR_CALLBACKS
+ FEATURE_USE_DECLARED_METHODS_FOR_CALLBACKS,
+ FEATURE_QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER
})
public @interface ConnectivityManagerFeature {}
@@ -4881,7 +4884,8 @@
return 0;
}
- private boolean isFeatureEnabled(@ConnectivityManagerFeature long connectivityManagerFeature) {
+ /** @hide */
+ public boolean isFeatureEnabled(@ConnectivityManagerFeature long connectivityManagerFeature) {
synchronized (mEnabledConnectivityManagerFeaturesLock) {
if (mEnabledConnectivityManagerFeatures == null) {
try {
diff --git a/framework/src/android/net/NetworkAgent.java b/framework/src/android/net/NetworkAgent.java
index 08f5ecd..95b45ce 100644
--- a/framework/src/android/net/NetworkAgent.java
+++ b/framework/src/android/net/NetworkAgent.java
@@ -37,6 +37,7 @@
import android.telephony.data.NrQosSessionAttributes;
import android.util.Log;
+import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;
import com.android.net.module.util.FrameworkConnectivityStatsLog;
@@ -116,15 +117,33 @@
private final ArrayList<RegistryAction> mPreConnectedQueue = new ArrayList<>();
private volatile long mLastBwRefreshTime = 0;
private static final long BW_REFRESH_MIN_WIN_MS = 500;
+
+ private final boolean mQueueRemoved;
+
private boolean mBandwidthUpdateScheduled = false;
private AtomicBoolean mBandwidthUpdatePending = new AtomicBoolean(false);
@NonNull
private NetworkInfo mNetworkInfo;
@NonNull
private final Object mRegisterLock = new Object();
- // TODO : move the preconnected queue to the system server and remove this
+ // TODO : when ConnectivityFlags.QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER is
+ // not chickened out this is never read. Remove when retiring this flag.
private boolean mConnected = false;
+ /** @hide */
+ @Retention(RetentionPolicy.SOURCE)
+ @IntDef(prefix = { "STATE_" }, value = {
+ STATE_CREATED,
+ STATE_REGISTERED,
+ STATE_UNREGISTERED
+ })
+ public @interface NetworkAgentState {}
+ private static final int STATE_CREATED = 0;
+ private static final int STATE_REGISTERED = 1;
+ private static final int STATE_UNREGISTERED = 2;
+ @GuardedBy("mRegisterLock")
+ private int mState = STATE_CREATED;
+
/**
* The ID of the {@link NetworkProvider} that created this object, or
* {@link NetworkProvider#ID_NONE} if unknown.
@@ -506,6 +525,18 @@
return ni;
}
+ /**
+ * Returns whether a given ConnectivityManager feature is enabled.
+ *
+ * Tests can override this.
+ * @hide
+ */
+ @VisibleForTesting
+ public boolean isFeatureEnabled(@NonNull Context context,
+ @ConnectivityManager.ConnectivityManagerFeature long feature) {
+ return context.getSystemService(ConnectivityManager.class).isFeatureEnabled(feature);
+ }
+
// Temporary backward compatibility constructor
public NetworkAgent(@NonNull Context context, @NonNull Looper looper, @NonNull String logTag,
@NonNull NetworkCapabilities nc, @NonNull LinkProperties lp, int score,
@@ -588,6 +619,10 @@
@Nullable LocalNetworkConfig localNetworkConfig, @NonNull NetworkScore score,
@NonNull NetworkAgentConfig config, int providerId, @NonNull NetworkInfo ni) {
mHandler = new NetworkAgentHandler(looper);
+ // If the feature is enabled, then events are queued in the system
+ // server, and it's removed from this NetworkAgent.
+ mQueueRemoved = isFeatureEnabled(context,
+ ConnectivityManager.FEATURE_QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER);
LOG_TAG = logTag;
mNetworkInfo = new NetworkInfo(ni);
this.providerId = providerId;
@@ -609,24 +644,31 @@
public void handleMessage(Message msg) {
switch (msg.what) {
case EVENT_AGENT_CONNECTED: {
- // TODO : move the pre-connected queue to the system server, and remove
- // handling this EVENT_AGENT_CONNECTED message.
- synchronized (mPreConnectedQueue) {
- if (mConnected) {
- log("Received new connection while already connected!");
- } else {
- if (VDBG) log("NetworkAgent fully connected");
- for (RegistryAction a : mPreConnectedQueue) {
- try {
- a.execute(mRegistry);
- } catch (RemoteException e) {
- Log.wtf(LOG_TAG, "Communication error with registry", e);
- // Fall through
+ if (mQueueRemoved) {
+ // No handling. This message is legacy from a time where the
+ // agent had to wait until the registry was sent to it, which
+ // would only happen after the corresponding NetworkMonitor
+ // was created.
+ mConnected = true; // never read, but mConnected = false would be confusing
+ } else {
+ // Feature chickened out, keep the old queueing behavior
+ synchronized (mRegisterLock) {
+ if (mConnected) {
+ log("Received new connection while already connected!");
+ } else {
+ if (VDBG) log("NetworkAgent fully connected");
+ for (RegistryAction a : mPreConnectedQueue) {
+ try {
+ a.execute(mRegistry);
+ } catch (RemoteException e) {
+ Log.wtf(LOG_TAG, "Communication error with registry", e);
+ // Fall through
+ }
}
+ mPreConnectedQueue.clear();
}
- mPreConnectedQueue.clear();
+ mConnected = true;
}
- mConnected = true;
}
break;
}
@@ -634,7 +676,8 @@
if (DBG) log("NetworkAgent channel lost");
// let the client know CS is done with us.
onNetworkUnwanted();
- synchronized (mPreConnectedQueue) {
+ synchronized (mRegisterLock) {
+ mState = STATE_UNREGISTERED;
mConnected = false;
}
break;
@@ -757,8 +800,19 @@
public Network register() {
if (VDBG) log("Registering NetworkAgent");
synchronized (mRegisterLock) {
- if (mNetwork != null) {
- throw new IllegalStateException("Agent already registered");
+ if (mQueueRemoved) {
+ switch (mState) {
+ case STATE_REGISTERED:
+ throw new IllegalStateException("Agent already registered");
+ case STATE_UNREGISTERED:
+ throw new IllegalStateException("Agent already unregistered");
+ default: // CREATED, this is the normal case
+ }
+ } else {
+ // Feature is chickened out, do the old processing
+ if (mNetwork != null) {
+ throw new IllegalStateException("Agent already registered");
+ }
}
final ConnectivityManager cm = (ConnectivityManager) mInitialConfiguration.context
.getSystemService(Context.CONNECTIVITY_SERVICE);
@@ -787,6 +841,7 @@
} else {
mNetwork = result.network;
mRegistry = result.registry;
+ mState = STATE_REGISTERED;
}
mInitialConfiguration = null; // All this memory can now be GC'd
}
@@ -936,6 +991,7 @@
mNetwork = network;
mInitialConfiguration = null;
mRegistry = registry;
+ mState = STATE_REGISTERED;
}
return new NetworkAgentBinder(mHandler);
}
@@ -961,30 +1017,49 @@
return mNetwork;
}
- private void queueOrSendMessage(@NonNull RegistryAction action) {
- synchronized (mPreConnectedQueue) {
- if (mNetwork == null && !Process.isApplicationUid(Process.myUid())) {
- // Theoretically, it should not be valid to queue messages here before
- // registering the NetworkAgent. However, practically, with the way
- // queueing works right now, it ends up working out just fine.
- // Log a statistic so that we know if this is happening in the
- // wild. The check for isApplicationUid is to prevent logging the
- // metric from test code.
+ private void logTerribleErrorMessageBeforeConnect() {
+ FrameworkConnectivityStatsLog.write(
+ FrameworkConnectivityStatsLog.CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED,
+ FrameworkConnectivityStatsLog.CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED__ERROR_TYPE__TYPE_MESSAGE_QUEUED_BEFORE_CONNECT
+ );
+ }
- FrameworkConnectivityStatsLog.write(
- FrameworkConnectivityStatsLog.CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED,
- FrameworkConnectivityStatsLog.CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED__ERROR_TYPE__TYPE_MESSAGE_QUEUED_BEFORE_CONNECT
- );
- }
- if (mConnected) {
- try {
- action.execute(mRegistry);
- } catch (RemoteException e) {
- Log.wtf(LOG_TAG, "Error executing registry action", e);
- // Fall through: the channel is asynchronous and does not report errors back
+ private void send(@NonNull RegistryAction action) {
+ synchronized (mRegisterLock) {
+ if (mQueueRemoved) {
+ if (mState <= STATE_CREATED) {
+ // Log a terrible error. There is nothing to do with this message
+ // so drop it.
+ logTerribleErrorMessageBeforeConnect();
+ Log.e(LOG_TAG, "Agent not yet registered, ignoring command");
+ return;
+ }
+ if (mState >= STATE_UNREGISTERED) {
+ // This should not crash for two reasons : first, the agent may
+ // be disconnected by ConnectivityService at any time and the message
+ // typically arrives on another thread, so it's not feasible for
+ // apps to check before sending, they'd have to always catch. Second,
+ // historically this hasn't thrown and some code may be relying on
+ // the historical behavior.
+ Log.e(LOG_TAG, "Agent already unregistered, ignoring command");
+ return;
}
} else {
- mPreConnectedQueue.add(action);
+ if (null == mNetwork) {
+ // Log a terrible error but still enqueue the message for backward
+ // compatibility.
+ logTerribleErrorMessageBeforeConnect();
+ }
+ if (!mConnected) {
+ mPreConnectedQueue.add(action);
+ return;
+ }
+ }
+ try {
+ action.execute(mRegistry);
+ } catch (RemoteException e) {
+ Log.wtf(LOG_TAG, "Error executing registry action", e);
+ // Fall through: the channel is asynchronous and does not report errors back
}
}
}
@@ -995,8 +1070,9 @@
*/
public void sendLinkProperties(@NonNull LinkProperties linkProperties) {
Objects.requireNonNull(linkProperties);
- final LinkProperties lp = new LinkProperties(linkProperties);
- queueOrSendMessage(reg -> reg.sendLinkProperties(lp));
+ // Copy the object because if the agent is running in the system server
+ // then the same instance will be seen by the registry
+ send(reg -> reg.sendLinkProperties(new LinkProperties(linkProperties)));
}
/**
@@ -1022,7 +1098,7 @@
@SuppressLint("NullableCollection") @Nullable List<Network> underlyingNetworks) {
final ArrayList<Network> underlyingArray = (underlyingNetworks != null)
? new ArrayList<>(underlyingNetworks) : null;
- queueOrSendMessage(reg -> reg.sendUnderlyingNetworks(underlyingArray));
+ send(reg -> reg.sendUnderlyingNetworks(underlyingArray));
}
/**
@@ -1032,7 +1108,7 @@
public void markConnected() {
mNetworkInfo.setDetailedState(NetworkInfo.DetailedState.CONNECTED, null /* reason */,
mNetworkInfo.getExtraInfo());
- queueOrSendNetworkInfo(mNetworkInfo);
+ sendNetworkInfo(mNetworkInfo);
}
/**
@@ -1045,7 +1121,12 @@
// When unregistering an agent nobody should use the extrainfo (or reason) any more.
mNetworkInfo.setDetailedState(NetworkInfo.DetailedState.DISCONNECTED, null /* reason */,
null /* extraInfo */);
- queueOrSendNetworkInfo(mNetworkInfo);
+ synchronized (mRegisterLock) {
+ if (mState >= STATE_REGISTERED) {
+ sendNetworkInfo(mNetworkInfo);
+ }
+ mState = STATE_UNREGISTERED;
+ }
}
/**
@@ -1068,7 +1149,7 @@
*/
public void setTeardownDelayMillis(
@IntRange(from = 0, to = MAX_TEARDOWN_DELAY_MS) int teardownDelayMillis) {
- queueOrSendMessage(reg -> reg.sendTeardownDelayMs(teardownDelayMillis));
+ send(reg -> reg.sendTeardownDelayMs(teardownDelayMillis));
}
/**
@@ -1107,7 +1188,7 @@
*/
public void unregisterAfterReplacement(
@IntRange(from = 0, to = MAX_TEARDOWN_DELAY_MS) int timeoutMillis) {
- queueOrSendMessage(reg -> reg.sendUnregisterAfterReplacement(timeoutMillis));
+ send(reg -> reg.sendUnregisterAfterReplacement(timeoutMillis));
}
/**
@@ -1125,7 +1206,7 @@
@SystemApi
public void setLegacySubtype(final int legacySubtype, @NonNull final String legacySubtypeName) {
mNetworkInfo.setSubtype(legacySubtype, legacySubtypeName);
- queueOrSendNetworkInfo(mNetworkInfo);
+ sendNetworkInfo(mNetworkInfo);
}
/**
@@ -1147,7 +1228,7 @@
@Deprecated
public void setLegacyExtraInfo(@Nullable final String extraInfo) {
mNetworkInfo.setExtraInfo(extraInfo);
- queueOrSendNetworkInfo(mNetworkInfo);
+ sendNetworkInfo(mNetworkInfo);
}
/**
@@ -1155,13 +1236,9 @@
* @hide TODO: expose something better.
*/
@UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
- public final void sendNetworkInfo(NetworkInfo networkInfo) {
- queueOrSendNetworkInfo(networkInfo);
- }
-
- private void queueOrSendNetworkInfo(NetworkInfo networkInfo) {
+ private void sendNetworkInfo(final NetworkInfo networkInfo) {
final NetworkInfo ni = new NetworkInfo(networkInfo);
- queueOrSendMessage(reg -> reg.sendNetworkInfo(ni));
+ send(reg -> reg.sendNetworkInfo(ni));
}
/**
@@ -1174,7 +1251,7 @@
mLastBwRefreshTime = System.currentTimeMillis();
final NetworkCapabilities nc =
new NetworkCapabilities(networkCapabilities, NetworkCapabilities.REDACT_NONE);
- queueOrSendMessage(reg -> reg.sendNetworkCapabilities(nc));
+ send(reg -> reg.sendNetworkCapabilities(nc));
}
/**
@@ -1186,7 +1263,7 @@
Objects.requireNonNull(config);
// If the agent doesn't have NET_CAPABILITY_LOCAL_NETWORK, this will be ignored by
// ConnectivityService with a Log.wtf.
- queueOrSendMessage(reg -> reg.sendLocalNetworkConfig(config));
+ send(reg -> reg.sendLocalNetworkConfig(config));
}
/**
@@ -1196,7 +1273,7 @@
*/
public void sendNetworkScore(@NonNull NetworkScore score) {
Objects.requireNonNull(score);
- queueOrSendMessage(reg -> reg.sendScore(score));
+ send(reg -> reg.sendScore(score));
}
/**
@@ -1246,8 +1323,7 @@
* @hide should move to NetworkAgentConfig.
*/
public void explicitlySelected(boolean explicitlySelected, boolean acceptUnvalidated) {
- queueOrSendMessage(reg -> reg.sendExplicitlySelected(
- explicitlySelected, acceptUnvalidated));
+ send(reg -> reg.sendExplicitlySelected(explicitlySelected, acceptUnvalidated));
}
/**
@@ -1387,7 +1463,7 @@
*/
public final void sendSocketKeepaliveEvent(int slot,
@SocketKeepalive.KeepaliveEvent int event) {
- queueOrSendMessage(reg -> reg.sendSocketKeepaliveEvent(slot, event));
+ send(reg -> reg.sendSocketKeepaliveEvent(slot, event));
}
/** @hide TODO delete once callers have moved to sendSocketKeepaliveEvent */
public void onSocketKeepaliveEvent(int slot, int reason) {
@@ -1493,11 +1569,11 @@
@NonNull final QosSessionAttributes attributes) {
Objects.requireNonNull(attributes, "The attributes must be non-null");
if (attributes instanceof EpsBearerQosSessionAttributes) {
- queueOrSendMessage(ra -> ra.sendEpsQosSessionAvailable(qosCallbackId,
+ send(reg -> reg.sendEpsQosSessionAvailable(qosCallbackId,
new QosSession(sessionId, QosSession.TYPE_EPS_BEARER),
(EpsBearerQosSessionAttributes)attributes));
} else if (attributes instanceof NrQosSessionAttributes) {
- queueOrSendMessage(ra -> ra.sendNrQosSessionAvailable(qosCallbackId,
+ send(reg -> reg.sendNrQosSessionAvailable(qosCallbackId,
new QosSession(sessionId, QosSession.TYPE_NR_BEARER),
(NrQosSessionAttributes)attributes));
}
@@ -1512,7 +1588,7 @@
*/
public final void sendQosSessionLost(final int qosCallbackId,
final int sessionId, final int qosSessionType) {
- queueOrSendMessage(ra -> ra.sendQosSessionLost(qosCallbackId,
+ send(reg -> reg.sendQosSessionLost(qosCallbackId,
new QosSession(sessionId, qosSessionType)));
}
@@ -1526,7 +1602,7 @@
*/
public final void sendQosCallbackError(final int qosCallbackId,
@QosCallbackException.ExceptionType final int exceptionType) {
- queueOrSendMessage(ra -> ra.sendQosCallbackError(qosCallbackId, exceptionType));
+ send(reg -> reg.sendQosCallbackError(qosCallbackId, exceptionType));
}
/**
@@ -1543,7 +1619,7 @@
throw new IllegalArgumentException("Duration must be within ["
+ MIN_LINGER_TIMER_MS + "," + Integer.MAX_VALUE + "]ms");
}
- queueOrSendMessage(ra -> ra.sendLingerDuration((int) durationMs));
+ send(reg -> reg.sendLingerDuration((int) durationMs));
}
/**
@@ -1552,7 +1628,7 @@
*/
public void sendAddDscpPolicy(@NonNull final DscpPolicy policy) {
Objects.requireNonNull(policy);
- queueOrSendMessage(ra -> ra.sendAddDscpPolicy(policy));
+ send(reg -> reg.sendAddDscpPolicy(policy));
}
/**
@@ -1560,14 +1636,14 @@
* @param policyId the ID corresponding to a specific DSCP Policy.
*/
public void sendRemoveDscpPolicy(final int policyId) {
- queueOrSendMessage(ra -> ra.sendRemoveDscpPolicy(policyId));
+ send(reg -> reg.sendRemoveDscpPolicy(policyId));
}
/**
* Remove all the DSCP policies on this network.
*/
public void sendRemoveAllDscpPolicies() {
- queueOrSendMessage(ra -> ra.sendRemoveAllDscpPolicies());
+ send(reg -> reg.sendRemoveAllDscpPolicies());
}
/** @hide */
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 329b338..dc4a35b 100644
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -158,6 +158,7 @@
import static com.android.server.connectivity.ConnectivityFlags.INGRESS_TO_VPN_ADDRESS_FILTERING;
import static com.android.server.connectivity.ConnectivityFlags.NAMESPACE_TETHERING_BOOT;
import static com.android.server.connectivity.ConnectivityFlags.QUEUE_CALLBACKS_FOR_FROZEN_APPS;
+import static com.android.server.connectivity.ConnectivityFlags.QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER;
import static com.android.server.connectivity.ConnectivityFlags.REQUEST_RESTRICTED_WIFI;
import static com.android.server.connectivity.ConnectivityFlags.WIFI_DATA_INACTIVITY_TIMEOUT;
@@ -4696,6 +4697,10 @@
// If the network has been destroyed, the only thing that it can do is disconnect.
if (nai.isDestroyed() && !isDisconnectRequest(msg)) {
+ if (DBG) {
+ log("Message " + eventName(msg.what) + " from destroyed agent with netId "
+ + nai.network.netId);
+ }
return;
}
@@ -4704,6 +4709,10 @@
// when registration is complete. It does this by sending all the
// messages in the order received immediately after the
// EVENT_AGENT_REGISTERED message.
+ if (DBG) {
+ log("Message " + eventName(msg.what) + " enqueued for agent with netId "
+ + nai.network.netId);
+ }
return;
}
@@ -9418,10 +9427,11 @@
if (DBG) log("registerNetworkAgent " + nai);
mDeps.getNetworkStack().makeNetworkMonitor(
nai.network, name, new NetworkMonitorCallbacks(nai));
- // NetworkAgentInfo registration will finish when the NetworkMonitor is created.
- // If the network disconnects or sends any other event before that, messages are deferred by
- // NetworkAgent until nai.connect(), which will be called when finalizing the
- // registration. TODO : have NetworkAgentInfo defer them instead.
+ // NetworkAgentInfo registration is done, but CS will only accept messages when the
+ // NetworkMonitor is created. If the network disconnects or sends any other event
+ // before that, messages are deferred by the Tracker Handler until it is (by asking
+ // NetworkAgentInfo to do it). The window is very small unless the NetworkStack
+ // doesn't reply immediately, which would mean a broken system anyway.
final NetworkAndAgentRegistryParcelable result = new NetworkAndAgentRegistryParcelable();
result.network = nai.network;
result.registry = nai.getRegistry();
@@ -9455,6 +9465,7 @@
NetworkInfo networkInfo = nai.networkInfo;
updateNetworkInfo(nai, networkInfo);
updateVpnUids(nai, null, nai.networkCapabilities);
+ nai.processEnqueuedMessages(mTrackerHandler::handleMessage);
}
private class NetworkOfferInfo implements IBinder.DeathRecipient {
@@ -15048,6 +15059,9 @@
if (mUseDeclaredMethodsForCallbacksEnabled) {
features |= ConnectivityManager.FEATURE_USE_DECLARED_METHODS_FOR_CALLBACKS;
}
+ if (mQueueNetworkAgentEventsInSystemServer) {
+ features |= ConnectivityManager.FEATURE_QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER;
+ }
return features;
}
@@ -15056,6 +15070,8 @@
switch (featureFlag) {
case INGRESS_TO_VPN_ADDRESS_FILTERING:
return mIngressToVpnAddressFiltering;
+ case QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER:
+ return mQueueNetworkAgentEventsInSystemServer;
default:
throw new IllegalArgumentException("Unknown flag: " + featureFlag);
}
diff --git a/service/src/com/android/server/connectivity/NetworkAgentInfo.java b/service/src/com/android/server/connectivity/NetworkAgentInfo.java
index 4540f02..abab6ab 100644
--- a/service/src/com/android/server/connectivity/NetworkAgentInfo.java
+++ b/service/src/com/android/server/connectivity/NetworkAgentInfo.java
@@ -25,8 +25,8 @@
import static android.net.NetworkCapabilities.TRANSPORT_TEST;
import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
import static android.net.NetworkCapabilities.transportNamesOf;
-import static android.system.OsConstants.EIO;
import static android.system.OsConstants.EEXIST;
+import static android.system.OsConstants.EIO;
import static android.system.OsConstants.ENOENT;
import static com.android.net.module.util.FrameworkConnectivityStatsLog.CORE_NETWORKING_TERRIBLE_ERROR_OCCURRED;
@@ -93,6 +93,7 @@
import java.util.Objects;
import java.util.SortedSet;
import java.util.TreeSet;
+import java.util.function.Consumer;
/**
* A bag class used by ConnectivityService for holding a collection of most recent
@@ -717,8 +718,20 @@
}
mHandler.obtainMessage(EVENT_AGENT_REGISTERED, ARG_AGENT_SUCCESS, 0, this).sendToTarget();
+ }
+
+ /**
+ * Pass all enqueued messages to the message processor argument, and clear the queue.
+ *
+ * This is called by ConnectivityService when it is ready to receive messages for this
+ * network agent. The processor may process the messages synchronously or asynchronously
+ * at its option.
+ *
+ * @param messageProcessor a function to process the messages
+ */
+ public void processEnqueuedMessages(final Consumer<Message> messageProcessor) {
for (final Message enqueued : mMessagesPendingRegistration) {
- mHandler.sendMessage(enqueued);
+ messageProcessor.accept(enqueued);
}
mMessagesPendingRegistration.clear();
}
diff --git a/staticlibs/testutils/devicetests/com/android/testutils/TestableNetworkAgent.kt b/staticlibs/testutils/devicetests/com/android/testutils/TestableNetworkAgent.kt
index bfbbc34..0413ed4 100644
--- a/staticlibs/testutils/devicetests/com/android/testutils/TestableNetworkAgent.kt
+++ b/staticlibs/testutils/devicetests/com/android/testutils/TestableNetworkAgent.kt
@@ -17,6 +17,7 @@
package com.android.testutils
import android.content.Context
+import android.net.ConnectivityManager.FEATURE_QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER
import android.net.InetAddresses.parseNumericAddress
import android.net.KeepalivePacketData
import android.net.LinkAddress
@@ -28,6 +29,7 @@
import android.net.NetworkCapabilities.TRANSPORT_TEST
import android.net.NetworkProvider
import android.net.NetworkRequest
+import android.net.NetworkScore
import android.net.QosFilter
import android.net.Uri
import android.os.Looper
@@ -64,16 +66,21 @@
import kotlin.test.assertNotNull
import kotlin.test.assertNull
import kotlin.test.assertTrue
+import kotlin.test.fail
import org.junit.Assert.assertArrayEquals
// Any legal score (0~99) for the test network would do, as it is going to be kept up by the
// requests filed by the test and should never match normal internet requests. 70 is the default
// score of Ethernet networks, it's as good a value as any other.
-private const val TEST_NETWORK_SCORE = 70
+private val TEST_NETWORK_SCORE = NetworkScore.Builder().setLegacyInt(70).build()
private class Provider(context: Context, looper: Looper) :
NetworkProvider(context, looper, "NetworkAgentTest NetworkProvider")
+private val enabledFeatures = mutableMapOf(
+ FEATURE_QUEUE_NETWORK_AGENT_EVENTS_IN_SYSTEM_SERVER to true
+)
+
public open class TestableNetworkAgent(
context: Context,
looper: Looper,
@@ -81,8 +88,17 @@
val lp: LinkProperties,
conf: NetworkAgentConfig
) : NetworkAgent(context, looper, TestableNetworkAgent::class.java.simpleName /* tag */,
- nc, lp, TEST_NETWORK_SCORE, conf, Provider(context, looper)) {
+ nc, lp, TEST_NETWORK_SCORE, conf, Provider(context, looper)) {
+
+ override fun isFeatureEnabled(context: Context, feature: Long): Boolean {
+ when (val it = enabledFeatures.get(feature)) {
+ null -> fail("Unmocked feature $feature, see TestableNetworkAgent.enabledFeatures")
+ else -> return it
+ }
+ }
+
companion object {
+ fun setFeatureEnabled(flag: Long, enabled: Boolean) = enabledFeatures.set(flag, enabled)
/**
* Convenience method to create a [NetworkRequest] matching [TestableNetworkAgent]s from
diff --git a/tests/cts/multidevices/apfv6_test.py b/tests/cts/multidevices/apfv6_test.py
index b82a3be..fb45f4a 100644
--- a/tests/cts/multidevices/apfv6_test.py
+++ b/tests/cts/multidevices/apfv6_test.py
@@ -14,6 +14,7 @@
from mobly import asserts
from scapy.layers.inet import IP, ICMP, IPOption_Router_Alert
+from scapy.layers.inet6 import IPv6, ICMPv6EchoRequest, ICMPv6EchoReply
from scapy.layers.l2 import Ether
from scapy.contrib.igmpv3 import IGMPv3, IGMPv3mq, IGMPv3mr, IGMPv3gr
from net_tests_utils.host.python import apf_test_base, apf_utils, adb_utils, assert_utils, packet_utils
@@ -102,6 +103,22 @@
)
@apf_utils.at_least_B()
+ def test_ipv6_icmp_echo_request_offload(self):
+ eth = Ether(src=self.server_mac_address, dst=self.client_mac_address)
+ ip = IPv6(src=self.server_ipv6_addresses[0], dst=self.client_ipv6_addresses[0])
+ icmp = ICMPv6EchoRequest(id=1, seq=123)
+ echo_request = bytes(eth/ip/icmp/b"hello").hex()
+
+ eth = Ether(src=self.client_mac_address, dst=self.server_mac_address)
+ ip = IPv6(src=self.client_ipv6_addresses[0], dst=self.server_ipv6_addresses[0])
+ icmp = ICMPv6EchoReply(id=1, seq=123)
+ expected_echo_reply = bytes(eth/ip/icmp/b"hello").hex()
+
+ self.send_packet_and_expect_reply_received(
+ echo_request, "DROPPED_IPV6_ICMP6_ECHO_REQUEST_REPLIED", expected_echo_reply
+ )
+
+ @apf_utils.at_least_B()
def test_igmpv3_general_query_offload(self):
ether = Ether(src=self.server_mac_address, dst='01:00:5e:00:00:01')
ip = IP(
diff --git a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
index 1fa9e3a..bd9bd2a 100644
--- a/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
+++ b/tests/cts/net/src/android/net/cts/NetworkAgentTest.kt
@@ -384,9 +384,9 @@
initialLp = lp,
initialNc = nc
)
- agent.setTeardownDelayMillis(0)
// Connect the agent and verify initial status callbacks.
agent.register()
+ agent.setTeardownDelayMillis(0)
agent.markConnected()
agent.expectCallback<OnNetworkCreated>()
agent.expectPostConnectionCallbacks(expectedInitSignalStrengthThresholds)
@@ -1934,4 +1934,19 @@
// VPN networks are always created as soon as the agent is registered.
doTestNativeNetworkCreation(expectCreatedImmediately = true, intArrayOf(TRANSPORT_VPN))
}
+
+ @Test(expected = IllegalStateException::class)
+ fun testRegisterAgain() {
+ val agent = createNetworkAgent()
+ agent.register()
+ agent.unregister()
+ agent.register()
+ }
+
+ @Test
+ fun testUnregisterBeforeRegister() {
+ // For backward compatibility, this shouldn't crash.
+ val agent = createNetworkAgent()
+ agent.unregister()
+ }
}