手机明明显示已联网,应用为什么还会解析域名失败?一段 HTTP 请求已经写进 Socket,为什么还可能读不到响应?把同一轮日志中的网络回调、DNS、连接和读写分开看,就能知道请求停在哪一步。
本例先向 ConnectivityService 登记网络需求,再用回调交付的 Network 解析域名、连接服务器。ConnectivityService 负责匹配网络和通知状态。应用写进 Socket 的业务字节经系统调用交给 Linux 内核。 如果日志已有 AVAILABLE,却在 DNS 阶段失败,先查所选网络的解析。如果已有 WRITE_RETURN,就沿同一个连接查响应有没有读回来。11.11 汇总了各阶段的判断依据。
11.1 分清控制与数据
网络控制、配置和数据收发
先沿整体架构图的蓝线看网络怎样交给应用,再沿绿线看业务字节怎样进出内核。紫线标出系统设置路由和 DNS 的配置动作,橙线标出应用调用 DNS 和 fwmark 的本地辅助协议。图中分层表示职责,进程和线程由框内标注。
应用发出的 Binder 请求由 system_server 中的 ConnectivityService 接收,服务端 Handler 完成匹配后再把结果发到应用指定的回调线程。IpClient 把 IP 配置结果交给接入供应方,后者通过 NetworkAgent 上报。NetworkMonitor 经 INetworkMonitorCallbacks 回传验证结果。ConnectivityService 通过 INetd 配置网络和路由,经 IDnsResolver 配置 DNS。
应用的 libcore、JNI 和 Bionic 在工作线程上执行网络操作。DNS 和选网可调用 netd 进程中的辅助服务。选网成功时,内核 socket 上的标记影响后续路由决策。Socket 的业务字节由内核 TCP/IP 网络栈处理,直接从 Native 系统调用进入内核。Wi-Fi、蜂窝的接入由各自的 HAL 和服务协作。本章用 VirtIO/QEMU Slirp 说明一种设备路径,实际后端随设备和启动参数而变。
一次请求的整体流程
流程从应用提出网络需求开始。接入和网络配置可以在请求前就已完成。尤其要分清两个等待点。一直没有匹配网络,可能收到 onUnavailable。已有匹配网络但仍未 VALIDATED 时,本例继续等能力更新,这时可以既没有 onUnavailable,也没有 DNS_BEGIN。
一次请求的核心总时序
沿时序图从上往下看。同一工作线程使用回调交付的 Network 完成 DNS 和选网,随后在同一个 socket 上连接、发送并读回字节。服务端匹配和 Binder 返回可以并行,应用分派依赖回调登记完成。设备发包与 write 返回、响应入队与 read 调用也可能交错。
图中展示一条连接成功的路径。关闭 socket 释放连接引用,注销回调则释放之前登记的网络需求。11.3~11.9 分别展开消息、fd 和字节怎样在各层交接。
对象怎样对应
NetworkRequest 是需求,例如“我要支持 INTERNET 的网络”;它不装业务数据。NetworkCapabilities 描述能力和传输属性,例如 INTERNET、VALIDATED、WIFI。INTERNET 表示网络声明能提供互联网接入;VALIDATED 是系统验证得出的动态状态。拿到前者不等于验证成功,更不保证目标服务器可达。VALIDATED 不是应用可以请求保持不变的能力,本例在回调中观察它。
Network 是某个网络的可传递标识,内部有 netId;同一个网络在不同进程中可以有不同 Java 包装。它不是网卡,也不是已经连上的 TCP 连接。LinkProperties 保存该网络的接口、地址、路由、DNS 等链路信息。例如同一设备可以同时有 Wifi 和蜂窝网络,各自有一组 LinkProperties;“系统默认”与“当前应用默认”还可能因 VPN/按 UID 策略而不同。
Socket 表示端点,Java 的 FileDescriptor 包装应用进程中的整数 fd。Kernel 中 fd 关联 file、socket 和协议状态 sock;TCP 层用连接状态、序号及队列管理字节流。fd 值只在所属进程有意义,不能拿应用的 fd=57 去 netd 进程查询同号文件来当作同一个对象。
sk_buff 是 Kernel 保存网络包及其元信息的载体;virtqueue 是 guest Driver 与虚拟设备交换描述符的队列。Java byte[]、Native 临时缓冲、TCP 的发送/重传数据与设备描述符不是一块永久不变的内存。本例的普通发送路径涉及复制、分段、排队与回收,不能把整条链笼统称作零拷贝。
11.2 用日志识别一次请求
目标是让日志中同一个 run 连接起:登记 → 网络可用 → 能力更新 → DNS → 绑定 socket → connect → write → read → 关闭。本例用 Java Socket 手写最小 HTTP/1.0 请求,便于看到字节边界。选 example.com:80 作为无凭据的公共示例,实际服务可拒绝、重定向或变化;HTTP 状态行可以是 2xx、3xx、4xx,并不预先要求 200。清单保留 usesCleartextTraffic=true。本例使用原始 Java Socket 手写 HTTP,这个声明并不控制该 Socket 能否发送明文。生产 HTTPS 还要在 TCP 上完成 TLS,且库可能连接复用或使用 QUIC/自带 DNS,本链不能无条件套用。
完整源码在示例/ProbeActivity.java,工程声明在Android.bp和AndroidManifest.xml。附录保留同一份完整实现,可以直接对照正文阅读。目标为 API 26 以上,targetSdk 35;三项权限是 INTERNET、ACCESS_NETWORK_STATE、CHANGE_NETWORK_STATE。NetworkRequest 不限定传输类型,系统可以匹配允许应用使用的不同网络,不能看到 Wifi 图标就预设选中 Wifi。
先看决定实验行为的片段,以下是本章示例,非 AOSP 摘录:
NetworkRequest request = new NetworkRequest.Builder()
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build();
cm.requestNetwork(request, callback, new Handler(callbacks.getLooper()), 10000);
10 秒限制的是尚未满足的网络请求,不是 DNS/HTTP 总耗时。 得到网络后系统会取消相应匹配超时。INTERNET 网络即使一直未 VALIDATED,也可能已经满足请求,所以“没有 DNS_BEGIN、也没有 UNAVAILABLE”不一定是回调丢了;先检查 CAPS 中的 validated=false。
示例 onAvailable 只记录;onCapabilitiesChanged 看到 INTERNET 和 VALIDATED 后,借助 AtomicBoolean 仅提交一次工作。阻塞 DNS、连接与读写放在 probe-io,不占 UI,也不阻塞回调线程。onBlockedStatusChanged 在 API 29 起独立记录策略阻塞,不作为本例启动工作线程的条件。Android 8 和 9 可以运行本例,但不会交付这一回调。
InetAddress[] addresses = network.getAllByName(host);
try (Socket socket = network.getSocketFactory().createSocket()) {
socket.connect(new InetSocketAddress(address, 80), 4000);
socket.setSoTimeout(4000);
socket.getOutputStream().write(request);
int count = socket.getInputStream().read(buffer);
}
这里 address 来自 addresses 的逐项尝试;完整实现逐次关闭失败的 socket,再尝试下一地址。这个地址循环也会接住 WRITE/READ 的 IOException:如果前一地址的 GET 已发出而读响应失败,换地址可能再次发送 GET,因此一个 run 只提交一项任务,却不保证只发一次 HTTP。其他业务是否允许重试应依据幂等性及已发生的副作用判断。无参工厂先创建并绑定,再由示例显式 connect,保留 4 秒连接超时。直接用工厂的 createSocket(host,port) 重载虽然也会在该 Network 上 DNS 和连接,却不提供本例使用的 connect 超时参数,不能把两个重载混为同一实验。
示例读到 EOF、64 KiB 上限、读超时或取消就结束;15 秒响应窗口在每次 read 前检查,单次阻塞仍受 4 秒 SO_TIMEOUT 限制,故它不是严格的 15 秒整体硬截止。SO_TIMEOUT 不限制同步 DNS 或输出流 write。Activity 退出前台时注销回调、关闭当前 socket、请求结束工作线程并退出回调 Looper;同步 DNS 不保证被 shutdownNow() 立即打断,晚返回结果会检查 stopped,不再发起连接。详细状态与完整代码见同文附录“示例的完整实现”。
在自己的环境里怎样跟做
以下命令供读者在自己的 AOSP 构建环境和测试设备上执行。先将示例目录复制到源码树的 development/samples/ConnectivityProbe,在 AOSP 根目录完成 lunch。从 adb devices 选择自己的设备,再在同一个 Bash 终端执行下面的步骤。把 emulator-5554 替换为实际序列号。
SERIAL=emulator-5554
probe_run_dir=$(mktemp -d "${TMPDIR:-/tmp}/connectivity-probe.XXXXXXXX")
(
set -e
: "${SERIAL:?请先设置设备序列号}" "${ANDROID_PRODUCT_OUT:?请先执行 lunch}"
: "${probe_run_dir:?请先建立本轮记录目录}"
adb -s "$SERIAL" get-state
m ConnectivityProbe
probe_apk="$ANDROID_PRODUCT_OUT/system/app/ConnectivityProbe/ConnectivityProbe.apk"
test -s "$probe_apk"
sha256sum "$probe_apk" > "$probe_run_dir/apk.sha256"
adb -s "$SERIAL" install -r "$probe_apk" > "$probe_run_dir/install.txt" 2>&1
cat "$probe_run_dir/install.txt"
grep -q '^Success[[:space:]]*$' "$probe_run_dir/install.txt"
touch "$probe_run_dir/install-ok"
)
install-ok 只会在本轮构建和安装成功后生成。若路径不同,在 $ANDROID_PRODUCT_OUT/module-info.json 中查 ConnectivityProbe 的 installed 字段,核对实际 APK 路径后重跑。若安装失败,先查看本轮目录里的 install.txt。用 printf '%s\n' "$probe_run_dir" 查看记录目录,下一步仍用这个终端的变量。
启动前先保存只读快照。权限受限的快照保留错误信息,不能据此判定设备没有相应网络或规则。随后显式停止测试包的旧实例,记录设备时间,再启动 Activity。启动成功仍需用同轮日志判断 DNS、连接和响应。
(
set -e
test -f "${probe_run_dir:?}/install-ok"
adb -s "$SERIAL" shell getprop ro.build.fingerprint > "$probe_run_dir/fingerprint.txt"
adb -s "$SERIAL" shell uname -a > "$probe_run_dir/kernel.txt"
adb -s "$SERIAL" shell getprop ro.product.cpu.abi > "$probe_run_dir/abi.txt"
adb -s "$SERIAL" shell dumpsys connectivity > "$probe_run_dir/connectivity-before.txt" 2>&1 || true
adb -s "$SERIAL" shell dumpsys dnsresolver > "$probe_run_dir/dnsresolver-before.txt" 2>&1 || true
adb -s "$SERIAL" shell ip rule show > "$probe_run_dir/ip-rule-before.txt" 2>&1 || true
adb -s "$SERIAL" shell ip route show table all > "$probe_run_dir/ip-route-before.txt" 2>&1 || true
adb -s "$SERIAL" shell am force-stop com.example.connectivityprobe
probe_since=$(adb -s "$SERIAL" shell 'date "+%m-%d %H:%M:%S.000"' | tr -d '\r')
test -n "$probe_since"
printf '%s\n' "$probe_since" > "$probe_run_dir/device-start-time.txt"
adb -s "$SERIAL" shell am start -W -n com.example.connectivityprobe/.ProbeActivity \
> "$probe_run_dir/activity-start.txt" 2>&1
cat "$probe_run_dir/activity-start.txt"
grep -q '^Status: ok[[:space:]]*$' "$probe_run_dir/activity-start.txt"
)
看到 Status: ok 后,让 Activity 保持前台并开始读取日志。用 tee 保存,观察到 IO_END、UNAVAILABLE 或确认一直未 VALIDATED 后,可返回上一页触发 onStop。记录 STOP 后按 Ctrl+C 结束日志收集。日志窗口从设备时间的整秒开始,判据以本轮 run 为准。
adb -s "$SERIAL" logcat -T "$(cat "$probe_run_dir/device-start-time.txt")" \
-v threadtime -s ConnectivityProbe:I '*:S' | tee "$probe_run_dir/probe.log"
如需卸载,用 adb -s "$SERIAL" uninstall com.example.connectivityprobe 清理自己安装的测试包。卸载会删除该包的数据。本文示例已静态核对,未在设备上执行上述命令。
日志要证明到哪一步
以下为字段格式说明,没有伪造实际运行记录。run 为 Session 创建时 elapsedRealtimeNanos 的标识;它用于本进程轮次关联,不是跨设备统一时钟或时延测量。REGISTERED 与 AVAILABLE 可能因线程调度交错打印,不能把日志打印顺序当作 Binder 完成的全局顺序。
| stage | 字段与成功含义 | 不能推出什么 |
|---|---|---|
| AVAILABLE / CAPS | network 与 validated,观察可用网络和验证状态 | 目标域名或 TCP 必定成功 |
| DNS_END | 同轮域名解析取得的地址列表 | 一定发出了线上 DNS 包;缓存可命中 |
| CONNECTED | local/remote 的实际端点,连接操作成功 | HTTP 服务已返回有效业务 |
| WRITE_RETURN | 本轮请求长度写入返回 | 对端应用已经读取,或读响应完成 |
| RESPONSE | 字节数、eof 与 first 状态行 | 只看到字节就等于完整页面或 200 |
| DONE | httpStatusLine=true 表示首行以 HTTP/ 开始 | 严格 HTTP 解析/全部正文/全链性能验证 |
| ATTEMPT_FAIL / FAIL | 当前 stage、地址和异常 | 所有网络都坏了,或直接判定 Driver 问题 |
| CANCEL / STOP / IO_END | 取消、停止请求、socket 最终关闭 | STOP 一出现 DNS 线程已经终止 |
先找到本次启动对应的 run 和 DNS_END,再从一次 CONNECT_BEGIN 往下核对 CONNECTED、WRITE_RETURN、RESPONSE 及 DONE 的 httpStatusLine=true,最后确认该 run 有 IO_END。遇到 ATTEMPT_FAIL 或新的 CONNECT_BEGIN,就重新划分地址尝试。收到 HTTP 首行可证明这次尝试读回了响应的一部分。退出 Activity 后另看 STOP;若同时出现 LOST,按具体的地址尝试判断是否失败,保留实际发生的读回结果。
11.3 登记请求,等回调交付网络
创建请求与回调入口
从这里开始,源码块摘录自链接所指的固定提交。删节用代码内的注释标出,编译时使用仓库中的完整文件。附录另有可直接构建的实验代码。
公共重载 requestNetwork(request, callback, handler, timeoutMs) 先检查正超时,把用户 Handler 的 Looper 包进 CallbackHandler,再进入统一登记函数。这个公开重载返回 void,NetworkRequest 身份由 Framework 内部保存;六参 sendRequestForNetwork 以 Process.INVALID_UID 补齐 asUid,再转入下文七参版本:
来源:packages/modules/Connectivity/framework/src/android/net/ConnectivityManager.java,ConnectivityManager.requestNetwork(NetworkRequest, NetworkCallback, Handler, int),固定提交 347fbd34b368,方法范围 L5142~L5148。固定源码(L5142)。
public void requestNetwork(@NonNull NetworkRequest request,
@NonNull NetworkCallback networkCallback, @NonNull Handler handler, int timeoutMs) {
checkTimeout(timeoutMs);
CallbackHandler cbHandler = new CallbackHandler(handler);
NetworkCapabilities nc = request.networkCapabilities;
sendRequestForNetwork(nc, networkCallback, timeoutMs, REQUEST, TYPE_NONE, cbHandler);
}
传入 Handler 决定回调执行线程;JNI 不会自动替你换线程。 本例 Handler 属于名为 probe-callback 的 HandlerThread;发起请求的 UI 线程在 Binder 调用返回后继续执行。
sendRequestForNetwork 在应用内创建 Messenger(handler) 作为反向消息目标,并创建 Binder 作为服务端死亡监听令牌;sCallbacks 保存返回的 NetworkRequest 到用户回调实例的映射。它们用途不同,不要把 Binder 令牌当 HTTP 通道。
来源:packages/modules/Connectivity/framework/src/android/net/ConnectivityManager.java,ConnectivityManager.sendRequestForNetwork(int, NetworkCapabilities, NetworkCallback, int, NetworkRequest.Type, int, CallbackHandler),固定提交 347fbd34b368,方法范围 L4741~L4791。固定源码(L4741)。
private NetworkRequest sendRequestForNetwork(int asUid, NetworkCapabilities need,
NetworkCallback callback, int timeoutMs, NetworkRequest.Type reqType, int legacyType,
CallbackHandler handler) {
printStackTrace();
checkCallbackNotNull(callback);
if (reqType != TRACK_DEFAULT && reqType != TRACK_SYSTEM_DEFAULT && need == null) {
throw new IllegalArgumentException("null NetworkCapabilities");
}
final boolean useDeclaredMethods = isFeatureEnabled(
FEATURE_USE_DECLARED_METHODS_FOR_CALLBACKS);
int declaredMethodsFlag = useDeclaredMethods
? tryGetDeclaredMethodsFlag(callback)
: NetworkCallback.DECLARED_METHODS_ALL;
final NetworkRequest request;
final String callingPackageName = mContext.getOpPackageName();
try {
synchronized(sCallbacks) {
// 省略:已登记callback的重复注册日志检查;仍在sCallbacks锁内。
Messenger messenger = new Messenger(handler);
Binder binder = new Binder();
final int callbackFlags = callback.mFlags;
if (reqType == LISTEN) {
request = mService.listenForNetwork(
need, messenger, binder, callbackFlags, callingPackageName,
mContext.getAttributionTag(), declaredMethodsFlag);
} else {
request = mService.requestNetwork(
asUid, need, reqType.ordinal(), messenger, timeoutMs, binder,
legacyType, callbackFlags, callingPackageName,
mContext.getAttributionTag(), declaredMethodsFlag);
}
if (request != null) {
sCallbacks.put(request, callback);
}
callback.networkRequest = request;
}
} catch (RemoteException e) {
throw e.rethrowFromSystemServer();
} catch (ServiceSpecificException e) {
throw convertServiceException(e);
}
return request;
}
mService.requestNetwork 是控制 Binder;sCallbacks.put 让收到的 request 标识找到原回调。 同步调用在锁内完成登记,接收端处理映射也用同一把锁,避免回调查表早于登记;此锁不保护你的 socket 工作线程或业务 byte[]。
服务端登记,再匹配候选
ConnectivityService 的 Binder 入口检查调用 UID、权限、请求类型、能力与超时;建立新的 NetworkRequest 和 NetworkRequestInfo。NetworkRequestInfo 记住需求、Messenger、Binder、UID、回调属性,并登记 Binder 死亡。入口投递注册工作,不在 Binder 线程上完成所有匹配:
来源:packages/modules/Connectivity/service/src/com/android/server/ConnectivityService.java,ConnectivityService.requestNetwork(int, NetworkCapabilities, int, Messenger, int, IBinder, int, int, String, String, int),固定提交 347fbd34b368,方法范围 L9415~L9540。固定源码(L9415)。
public NetworkRequest requestNetwork(int asUid, NetworkCapabilities networkCapabilities,
int reqTypeInt, Messenger messenger, int timeoutMs, final IBinder binder,
int legacyType, int callbackFlags, @NonNull String callingPackageName,
@Nullable String callingAttributionTag, int declaredMethodsFlag) {
// 省略:声明回调标志兼容、legacyType权限与其他前置检查。
final int callingUid = mDeps.getCallingUid();
if (asUid != Process.INVALID_UID) {
enforceSettingsPermission();
} else {
asUid = callingUid;
}
final NetworkRequest.Type reqType;
try {
reqType = NetworkRequest.Type.values()[reqTypeInt];
} catch (ArrayIndexOutOfBoundsException e) {
throw new IllegalArgumentException("Unsupported request type " + reqTypeInt);
}
switch (reqType) {
// 省略:TRACK_DEFAULT、TRACK_SYSTEM_DEFAULT、BACKGROUND_REQUEST等其他case。
case REQUEST:
case RESERVATION:
networkCapabilities = new NetworkCapabilities(networkCapabilities);
enforceNetworkRequestPermissions(networkCapabilities, callingPackageName,
callingAttributionTag, callingUid);
enforceMeteredApnPolicy(networkCapabilities);
maybeDisableLocalNetworkMatching(networkCapabilities, callingUid);
break;
default:
throw new IllegalArgumentException("Unsupported request type " + reqType);
}
ensureRequestableCapabilities(networkCapabilities);
ensureSufficientPermissionsForRequest(networkCapabilities,
Binder.getCallingPid(), callingUid, callingPackageName, callingAttributionTag,
(callbackFlags & NetworkCallback.FLAG_INCLUDE_LOCATION_INFO) != 0);
// 省略:LISTEN_FOR_BEST后台限制;本例为REQUEST。
restrictRequestUidsForCallerAndSetRequestorInfo(networkCapabilities,
callingUid, callingPackageName);
if (timeoutMs < 0) {
throw new IllegalArgumentException("Bad timeout specified");
}
// 省略:TRACK_SYSTEM_DEFAULT的能力一致性检查,本例不走该分支。
final NetworkRequest networkRequest = new NetworkRequest(networkCapabilities, legacyType,
nextNetworkRequestId(), reqType);
final NetworkRequestInfo nri = getNriToRegister(
asUid, networkRequest, messenger, binder, callbackFlags,
callingAttributionTag, declaredMethodsFlag);
// 省略:调试日志与网络匹配指标记录。
trackUidAndRegisterNetworkRequest(EVENT_REGISTER_NETWORK_REQUEST, nri);
if (timeoutMs > 0) {
mHandler.sendMessageDelayed(mHandler.obtainMessage(EVENT_TIMEOUT_NETWORK_REQUEST,
nri), timeoutMs);
}
return networkRequest;
}
返回的 networkRequest 是登记身份;实际 Network 要等异步回调。 trackUidAndRegisterNetworkRequest 在需要时先完成 UID 跟踪,再把事件送往 mHandler;其 EVENT_REGISTER_NETWORK_REQUEST 分支调用 handleRegisterNetworkRequest。该处理把请求放入服务端表,按当前 feature flag 只重匹配新请求或重匹配全部请求,并向 NetworkOffer 供应方表达尚未满足的需求。
把请求登记与网络交付分开,意味着调用者不必把 UI 线程留在一次可能持续数秒的网络匹配中。另一种接口可以让调用者同步等待最终 Network,但那仍要解决等待线程、超时和宿主退出问题;本例的回调接口把这些阶段显式分开,代价是应用要管理回调存活、重复通知与注销。这里是依据执行顺序作的设计分析,不是对历史设计动机的引述。
候选网络对应的 NetworkAgentInfo 在网络登记时建立:Wifi、蜂窝或其他供应方创建 NetworkAgent,经 registerNetworkAgent 进入 ConnectivityService;服务分配 Network/netId,构造 NetworkAgentInfo 保存能力、LinkProperties、分数和连接信息,并创建 NetworkMonitor 的异步接口。requestNetwork 是给这些供应能力提需求,不是每次请求都新造一块网卡或新做 DHCP。
匹配器先过滤满足要求的候选,再按政策排名:
来源:packages/modules/Connectivity/service/src/com/android/server/connectivity/NetworkRanker.java,NetworkRanker.getBestNetwork(NetworkRequest, Collection<NetworkAgentInfo>, NetworkAgentInfo),固定提交 347fbd34b368,方法范围 L112~L120。固定源码(L112)。
@Nullable
public NetworkAgentInfo getBestNetwork(@NonNull final NetworkRequest request,
@NonNull final Collection<NetworkAgentInfo> nais,
@Nullable final NetworkAgentInfo currentSatisfier) {
final ArrayList<NetworkAgentInfo> candidates = filter(nais, nai -> nai.satisfies(request));
if (candidates.size() == 1) return candidates.get(0); // Only one potential satisfier
if (candidates.size() <= 0) return null; // No network can satisfy this request
return getBestNetworkByPolicy(candidates, currentSatisfier);
}
“满足能力”与“在候选中最好”是两步。 当前 NetworkRanker 考虑验证、用户选择、允许未验证网络、传输偏好及当前满足者等政策;不能简化成数值分最高、永远 Wifi 优先,或只有 VALIDATED 才会 onAvailable。没有候选时请求可以继续等待;超时处理只在请求尚未满足时通知 onUnavailable。系统判定请求无法满足时,也可提前释放请求并通知 onUnavailable,因此回调本身不能证明已经等满 10 秒。匹配转移也会重新通知应用,旧连接不会因此被改写成新网络上的连接。
消息回到应用 Looper
computeNetworkReassignment → applyNetworkReassignment 更新满足关系、默认网络等相关状态,再调用 notifyNetworkAvailable。这里取消对应匹配超时,构造带 Network、能力、LinkProperties、NetworkRequest 等的 Bundle;Messenger 指向应用先前提供的目标。
来源:packages/modules/Connectivity/service/src/com/android/server/ConnectivityService.java,ConnectivityService.callCallbackForRequest(NetworkRequestInfo, int, Bundle, int),固定提交 347fbd34b368,方法范围 L12580~L12598。固定源码(L12580)。
private void callCallbackForRequest(@NonNull final NetworkRequestInfo nri, int notificationType,
Bundle bundle, int arg1) {
Message msg = Message.obtain();
msg.arg1 = arg1;
msg.what = notificationType;
msg.setData(bundle);
try {
if (VDBG) {
String notification = ConnectivityManager.getCallbackName(notificationType);
log("sending notification " + notification + " for "
+ nri.getNetworkRequestForCallback());
}
nri.mMessenger.send(msg);
} catch (RemoteException e) {
// may occur naturally in the race of binder death.
loge("RemoteException caught trying to send a callback msg for "
+ nri.getNetworkRequestForCallback());
}
}
Binder 在此传的是带 Parcelable 状态的消息。 应用 Messenger 接收后交给 CallbackHandler 的 Looper;其 handleMessage 用 NetworkRequest 从 sCallbacks 找出用户对象,再按消息类型分派:
来源:packages/modules/Connectivity/framework/src/android/net/ConnectivityManager.java,ConnectivityManager.CallbackHandler.handleMessage(Message),固定提交 347fbd34b368,方法范围 L4637~L4722。固定源码(L4637)。
@Override
public void handleMessage(Message message) {
// 省略:EXPIRE_LEGACY_REQUEST的专用早退分支。
final NetworkRequest request = getObject(message, NetworkRequest.class);
final Network network = getObject(message, Network.class);
final NetworkCallback callback;
synchronized (sCallbacks) {
callback = sCallbacks.get(request);
if (callback == null) {
Log.w(TAG,
"callback not found for " + getCallbackName(message.what) + " message");
return;
}
// 省略:CALLBACK_UNAVAIL时移除登记并标记注销。
}
switch (message.what) {
// 省略:RESERVED与PRECHECK等其他消息case。
case CALLBACK_AVAILABLE: {
NetworkCapabilities cap = getObject(message, NetworkCapabilities.class);
LinkProperties lp = getObject(message, LinkProperties.class);
LocalNetworkInfo lni = getObject(message, LocalNetworkInfo.class);
callback.onAvailable(network, cap, lp, lni, message.arg1);
break;
}
// 省略:其余CALLBACK_*分派分支。
}
}
这一内部多参数 onAvailable 会调用用户 onAvailable,并按 API 的内部实现顺序继续交付能力、链路与阻塞状态。应用应使用 onCapabilitiesChanged/onLinkPropertiesChanged 随消息拿到的信息。在 onAvailable 里同步查询,可能拿到更新前后的另一份快照。本例正是在能力回调中判断 VALIDATED,再投递 Network 到 Executor。
观察需求怎样形成 R、R 怎样进入 Framework 回调表,再看消息中的 N 怎样更新回调状态并进入 Task。动画的初态已准备好需求、Messenger 与存活令牌,只演示匹配成功、随后观察到 VALIDATED 的分支;回调 C、请求 R 和任务是三个不同对象。
末态保留 R 到 callback C 的登记和 Task 持有的 N;任务开始不会自动注销网络请求。图中选取一种 Binder 返回与 Handler 处理的编排,不规定所有线程的全局日志顺序。
这是机制示意,不是实测 Trace;服务线程可在主线程打印 REGISTERED 之前或之后被调度。
11.4 回看网络准备
应用已经拿到 Network。先回看它怎样成为候选,再接上工作线程的 DNS。接入供应方先取得链路配置,向 ConnectivityService 报告能力和 LinkProperties;系统据此配置逻辑网络、路由与 DNS,并结合验证结果参与匹配。它可以早于 11.3 的请求发生,也会在请求存活期间更新。
NetworkStack 是可更新模块,不是 ConnectivityService 的别名。IpClient 以接口为目标运行状态机,和 DhcpClient、netlink 监测等合作,向接入技术的回调交付 IP 配置结果。NetworkStackService 接受 makeIpClient,创建实例并用 IIpClientCallbacks 返回它的连接器:
来源:packages/modules/NetworkStack/src/com/android/server/NetworkStackService.java,NetworkStackService.NetworkStackConnector.makeIpClient(String, IIpClientCallbacks),固定提交 928a826ae488,方法范围 L387~L406。固定源码(L387)。
@Override
public void makeIpClient(String ifName, IIpClientCallbacks cb) throws RemoteException {
mPermChecker.enforceNetworkStackCallingPermission();
updateNetworkStackAidlVersion(cb.getInterfaceVersion(), cb.getInterfaceHash());
final IpClient ipClient = mDeps.makeIpClient(
mContext, ifName, cb, this);
synchronized (mIpClients) {
final Iterator<WeakReference<IpClient>> it = mIpClients.iterator();
while (it.hasNext()) {
final IpClient ipc = it.next().get();
if (ipc == null) {
it.remove();
}
}
mIpClients.add(new WeakReference<>(ipClient));
}
cb.onIpClientCreated(ipClient.makeConnector());
}
随后 cb.onIpClientCreated(ipClient.makeConnector()) 返回可调用控制端;IpClient onProvisioningSuccess(newLp) 通过回调送出 LinkProperties。接入供应方据此更新 NetworkAgent 的链路信息。NetworkMonitor 则由 makeNetworkMonitor 创建,测试 DNS/HTTP/HTTPS 等探测条件,使用 INetworkMonitorCallbacks 送回 NetworkTestResult;ConnectivityService 将验证结果纳入能力与排名。系统探测成功只说明探测目标满足该验证规则,不等于 example.com 这次请求成功。
当 Agent 进入建网阶段,ConnectivityService.createNativeNetwork 区分 VPN 虚拟网络与普通物理网络,构造 NativeNetworkConfig,再调用 INetd 与 IDnsResolver:
来源:packages/modules/Connectivity/service/src/com/android/server/ConnectivityService.java,ConnectivityService.createNativeNetwork(NetworkAgentInfo),固定提交 347fbd34b368,方法范围 L6359~L6390。固定源码(L6359)。
// 省略:空行与说明性原注释;本方法所有执行语句保留。
private boolean createNativeNetwork(@NonNull NetworkAgentInfo nai) {
try {
final NativeNetworkConfig config;
if (nai.isVPN()) {
if (getVpnType(nai) == VpnManager.TYPE_VPN_NONE) {
Log.wtf(TAG, "Unable to get VPN type from network " + nai.toShortString());
return false;
}
config = new NativeNetworkConfig(nai.network.getNetId(), NativeNetworkType.VIRTUAL,
INetd.PERMISSION_NONE,
!nai.networkAgentConfig.allowBypass /* secure */,
getVpnType(nai), nai.networkAgentConfig.excludeLocalRouteVpn);
} else {
config = new NativeNetworkConfig(nai.network.getNetId(),
nai.isLocalNetwork() ? NativeNetworkType.PHYSICAL_LOCAL
: NativeNetworkType.PHYSICAL,
getNetworkPermission(nai.networkCapabilities),
false /* secure */,
VpnManager.TYPE_VPN_NONE,
false /* excludeLocalRoutes */);
}
mNetd.networkCreate(config);
mDnsResolver.createNetworkCache(nai.network.getNetId());
mDnsManager.updateCapabilitiesForNetwork(nai.network.getNetId(),
nai.networkCapabilities);
return true;
} catch (RemoteException | ServiceSpecificException e) {
loge("Error creating network " + nai.toShortString() + ": " + e.getMessage());
return false;
}
}
networkCreate 建的是 netd 的逻辑网络与策略环境;createNetworkCache 给 DNS 建立按网络的缓存容器。 异常使函数返回 false,后续连接状态处理还要接住这个失败;不能因为源码中有建网调用,就假定网络已经就绪。
LinkProperties 更新时按 updateInterfaces → updateRoutes → updateDnses 等动作将变化应用。INetd 的 networkAddInterface、路由 Parcel 等由 netd 的 NetworkController、PhysicalNetwork/VirtualNetwork、RouteController 接住;RouteController 选择接口路由表,把 RTM_NEWROUTE/RTM_NEWRULE 等 Netlink 请求送到 Kernel 并接收确认错误。netId 用于 Android 的网络身份,Kernel 查找的是实际规则、标记、表与路由,不能把 netId 直接等同一个固定 Linux table 数字。
DNS 配置走 DnsManager,按 netId 取 LinkProperties 和能力,填 ResolverParamsParcel:servers/domains 来自链路,TLS 名称/服务器与 DoH 参数来自私有 DNS 政策,再调用 mDnsResolver.setResolverConfiguration(paramsParcel)。这是 Binder 配置接口,与下一节应用的同步 DNS 查询协议分开。
IPv4 路由最终还会考虑 socket mark、UID 规则、目的地址、策略优先级和 VPN 等;默认路由不只是 main 表。Network namespace 隔离接口、路由等网络资源,本例没有创建或切换 namespace;多个 Android netId 通常不能推断为每个网络各有一个 namespace。netfilter 和 BPF 可以按挂点过滤、记账或重写,运行中是否挂载了什么程序、规则,另用真实状态确认。
11.5 在指定网络解析域名
工作线程拿到回调交付的 Network 后,先解析目标域名。Java 缓存命中时直接取回地址。未命中且需要代理查询时,才进入 netd 中的 Resolver worker。
先看 (host,N) 对应的缓存槽位,再看未命中后才形成的 hints、查询工作对象和结果记录。返回地址分别在 netd 和应用侧组成链表;Java 数组与按网缓存保留结果,两侧 Native 链表及工作引用各自结束。
动画只走 Java 缓存未命中且 Resolver 成功的分支,addr1/addr2 表示地址记录,不是测得的服务器地址;正缓存、负缓存及失败行为仍按下文分别判断。
先查带 netId 的缓存
示例的 network 来自回调,先调用 getAllByName(host):
来源:packages/modules/Connectivity/framework/src/android/net/Network.java,Network.getAllByName(String),固定提交 347fbd34b368,方法范围 L140~L142。固定源码(L140)。
public InetAddress[] getAllByName(String host) throws UnknownHostException {
return InetAddress.getAllByNameOnNet(host, getNetIdForResolv());
}
域名必须在选定网络解析,随后 socket 也绑定同一个 Network。 若先用无网络限定的 InetAddress.getAllByName,再把 socket 绑到另一个 Network,可能拿到另一网络的分视 DNS 答案。Network.getNetIdForResolv 还编码私有 DNS bypass 标志;本例使用正常实例,不请求绕过私有 DNS。
InetAddress.getAllByNameOnNet 交给 Inet6AddressImpl.lookupAllHostAddr。空名称和数值 IP 有自己的快路径,不需要真实 DNS 查询;普通域名进入 lookupHostByName:
来源:libcore/ojluni/src/main/java/java/net/Inet6AddressImpl.java,Inet6AddressImpl.lookupHostByName(String, int),固定提交 4ebfb391ee01,方法范围 L113~L158。固定源码(L113)。以下为方法原文(仅去除外层缩进),省略部分不代表原实现没有相应检查。
private static InetAddress[] lookupHostByName(String host, int netId)
throws UnknownHostException {
BlockGuard.getThreadPolicy().onNetwork();
// Do we have a result cached?
Object cachedResult = addressCache.get(host, netId);
if (cachedResult != null) {
if (cachedResult instanceof InetAddress[]) {
// A cached positive result.
return (InetAddress[]) cachedResult;
} else {
// A cached negative result.
throw new UnknownHostException((String) cachedResult);
}
}
try {
StructAddrinfo hints = new StructAddrinfo();
hints.ai_flags = AI_ADDRCONFIG;
hints.ai_family = AF_UNSPEC;
// If we don't specify a socket type, every address will appear twice, once
// for SOCK_STREAM and one for SOCK_DGRAM. Since we do not return the family
// anyway, just pick one.
hints.ai_socktype = SOCK_STREAM;
InetAddress[] addresses = Libcore.os.android_getaddrinfo(host, hints, netId);
// TODO: should getaddrinfo set the hostname of the InetAddresses it returns?
for (InetAddress address : addresses) {
address.holder().hostName = host;
address.holder().originalHostName = host;
}
addressCache.put(host, netId, addresses);
return addresses;
} catch (GaiException gaiException) {
// If the failure appears to have been a lack of INTERNET permission, throw a clear
// SecurityException to aid in debugging this common mistake.
// http://code.google.com/p/android/issues/detail?id=15722
if (gaiException.getCause() instanceof ErrnoException) {
int errno = ((ErrnoException) gaiException.getCause()).errno;
if (errno == EACCES || errno == EPERM) {
throw new SecurityException("Permission denied (missing INTERNET permission?)", gaiException);
}
}
// Otherwise, throw an UnknownHostException.
String detailMessage = "Unable to resolve host \"" + host + "\": " + Libcore.os.gai_strerror(gaiException.error);
addressCache.putUnknownHost(host, netId, detailMessage);
throw gaiException.rethrowAsUnknownHostException(detailMessage);
}
}
缓存键包含 host 和 netId;正缓存返回地址,负缓存也能直接抛 UnknownHostException。
如果只按 host 缓存,就可能把网络 A 的答案用于网络 B,丢失网络作用域。把 netId 放入键能隔开这两类答案;缓存本身仍要面对有效期内答案变化的问题。负缓存可以复用失败结果,也会使后续失败不再对应一次新的线上查询。排查时因此要先确认网络身份和缓存分支,再用抓包判断是否发起了查询;不能从异常次数推算 DNS 包数。DNS_END 不保证有新 DNS 包,失败也不保证本次访问过服务器。未命中时才创建 StructAddrinfo,指定 AF_UNSPEC、SOCK_STREAM 等,再调用 Libcore.os。
Libcore.os 的包装链最终进入 Linux 实现的 Native 方法,BlockGuard 等包装负责策略检查;JNI 在同一个 probe-io 线程读取 hints 字段,把 Java host 转成 C 字符串。
来源:libcore/luni/src/main/native/libcore_io_Linux.cpp,Linux_android_getaddrinfo(JNIEnv*, jobject, jstring, jobject, jint),固定提交 4ebfb391ee01,方法范围 L1402~L1466。固定源码(L1402)。
// 省略:空行及完整原注释;所有执行语句保留。
static jobjectArray Linux_android_getaddrinfo(JNIEnv* env, jobject, jstring javaNode,
jobject javaHints, jint netId) {
ScopedUtfChars node(env, javaNode);
if (node.c_str() == NULL) {
return NULL;
}
static jfieldID flagsFid = env->GetFieldID(JniConstants::GetStructAddrinfoClass(env), "ai_flags", "I");
static jfieldID familyFid = env->GetFieldID(JniConstants::GetStructAddrinfoClass(env), "ai_family", "I");
static jfieldID socktypeFid = env->GetFieldID(JniConstants::GetStructAddrinfoClass(env), "ai_socktype", "I");
static jfieldID protocolFid = env->GetFieldID(JniConstants::GetStructAddrinfoClass(env), "ai_protocol", "I");
addrinfo hints= {};
hints.ai_flags = env->GetIntField(javaHints, flagsFid);
hints.ai_family = env->GetIntField(javaHints, familyFid);
hints.ai_socktype = env->GetIntField(javaHints, socktypeFid);
hints.ai_protocol = env->GetIntField(javaHints, protocolFid);
addrinfo* addressList = NULL;
errno = 0;
int rc = android_getaddrinfofornet(node.c_str(), NULL, &hints, netId, 0, &addressList);
std::unique_ptr<addrinfo, decltype(&freeaddrinfo)> addressListDeleter(addressList, freeaddrinfo);
if (rc != 0) {
throwGaiException(env, "android_getaddrinfo", rc);
return NULL;
}
int addressCount = 0;
for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) {
if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) {
++addressCount;
} else {
ALOGE("android_getaddrinfo unexpected ai_family %i", ai->ai_family);
}
}
if (addressCount == 0) {
return NULL;
}
jobjectArray result = env->NewObjectArray(addressCount, JniConstants::GetInetAddressClass(env), NULL);
if (result == NULL) {
return NULL;
}
int index = 0;
for (addrinfo* ai = addressList; ai != NULL; ai = ai->ai_next) {
if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) {
ALOGE("android_getaddrinfo unexpected ai_family %i", ai->ai_family);
continue;
}
ScopedLocalRef<jobject> inetAddress(env, sockaddrToInetAddress(env, ai->ai_addr, NULL));
if (inetAddress.get() == NULL) {
return NULL;
}
env->SetObjectArrayElement(result, index, inetAddress.get());
++index;
}
return result;
}
Native 得到 addrinfo 链表后,逐项创建 Java InetAddress,填入 Java 数组;作用域 deleter 会 freeaddrinfo。 数组返回 Inet6AddressImpl,写入按网络缓存,再回到示例的 addresses;它不是指向 netd 内存的借用指针。
代理查询,再逐层还原结果
Bionic 的 android_getaddrinfofornet → android_getaddrinfofornetcontext 在适用分支调用 android_getaddrinfo_proxy;它通过 dnsOpenProxy 建立 /dev/socket/dnsproxyd 本地流连接。Bionic 可动态装入 libnetd_client 改写调度函数;若不可用存在默认/回退分支,所以要按本例平台环境阅读,不能宣称所有 libc 都走 Android 代理。
来源:bionic/libc/dns/net/getaddrinfo.c,android_getaddrinfo_proxy(const char*, const char*, const addrinfo*, addrinfo**, unsigned),固定提交 06356e41c5ed,方法范围 L405~L558。固定源码(L405)。
static int
android_getaddrinfo_proxy(
const char *hostname, const char *servname,
const struct addrinfo *hints, struct addrinfo **res, unsigned netid)
{
int success = 0;
*res = NULL;
// 省略:对不可序列化的hostname/servname字符做校验,失败返回EAI_NODATA。
FILE* proxy = fdopen(__netdClientDispatch.dnsOpenProxy(), "r+");
if (proxy == NULL) {
return EAI_SYSTEM;
}
netid = __netdClientDispatch.netIdForResolv(netid);
if (fprintf(proxy, "getaddrinfo %s %s %d %d %d %d %u",
hostname == NULL ? "^" : hostname,
servname == NULL ? "^" : servname,
hints == NULL ? -1 : hints->ai_flags,
hints == NULL ? -1 : hints->ai_family,
hints == NULL ? -1 : hints->ai_socktype,
hints == NULL ? -1 : hints->ai_protocol,
netid) < 0) {
goto exit;
}
if (fputc(0, proxy) == EOF ||
fflush(proxy) != 0) {
goto exit;
}
// 省略:读取并检查代理结果码,逐字段重建*res链表;读到have_more==0才把success置1。
exit:
if (proxy != NULL) {
fclose(proxy);
}
if (success) {
return 0;
}
if (*res) {
freeaddrinfo(*res);
*res = NULL;
}
return EAI_NODATA;
}
请求文本含 host、service、hints 和 netId,再以 NUL 终止并 flush;业务 HTTP 请求没有被写进这个通道。 netd 的 main.initDnsResolver 调 resolv_init,启动来自 DnsResolver 模块的监听及服务。本固定配置中 DnsResolver 实现在 netd 进程,不能把模块名自动当成独立进程名。
DnsProxyListener.GetAddrInfoCmd 解析参数,按客户端 UID 和请求 netId 取得 android_net_context,剥离/设置本地 DNS 标志,创建查询工作对象并 spawn:
来源:packages/modules/DnsResolver/DnsProxyListener.cpp,DnsProxyListener::GetAddrInfoCmd::runCommand(SocketClient*, int, char**),固定提交 0aeaf9d222ec,方法范围 L968~L1017。固定源码(L968)。
// 省略:空行及说明性原注释;参数校验、context/hints准备和spawn全部保留。
int DnsProxyListener::GetAddrInfoCmd::runCommand(SocketClient* cli, int argc, char** argv) {
logArguments(argc, argv);
int ai_flags = 0;
int ai_family = 0;
int ai_socktype = 0;
int ai_protocol = 0;
unsigned netId = 0;
std::string strErr = "GetAddrInfoCmd::runCommand: ";
if (argc != 8) {
strErr = strErr + "invalid number of arguments: " + std::to_string(argc);
return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, 0, NULL);
}
const std::string name = argv[1];
const std::string service = argv[2];
if (!ParseInt(argv[3], &ai_flags))
return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
if (!ParseInt(argv[4], &ai_family))
return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
if (!ParseInt(argv[5], &ai_socktype))
return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
if (!ParseInt(argv[6], &ai_protocol))
return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
if (!ParseUint(argv[7], &netId))
return HandleArgumentError(cli, ResponseCode::CommandParameterError, strErr, argc, argv);
const bool useLocalNameservers = checkAndClearUseLocalNameserversFlag(&netId);
const uid_t uid = cli->getUid();
android_net_context netcontext;
gResNetdCallbacks.get_network_context(netId, uid, &netcontext);
if (useLocalNameservers) {
netcontext.flags |= NET_CONTEXT_FLAG_USE_LOCAL_NAMESERVERS;
}
std::unique_ptr<addrinfo> hints;
if (ai_flags != -1 || ai_family != -1 || ai_socktype != -1 || ai_protocol != -1) {
hints.reset((addrinfo*)calloc(1, sizeof(addrinfo)));
hints->ai_flags = ai_flags;
hints->ai_family = ai_family;
hints->ai_socktype = ai_socktype;
hints->ai_protocol = ai_protocol;
}
(new GetAddrInfoHandler(cli, name, service, std::move(hints), netcontext))->spawn();
return 0;
}
监听接收与 DNS 工作线程分开。GetAddrInfoHandler 保存客户端连接引用、域名、hints 和网络上下文;worker.run 检查 UID 查询并发限制/域名策略,执行 resolv_getaddrinfo,必要时 DNS64 合成,再序列化结果。Resolver 内还有按网络缓存、私有 DNS/传输与服务器选择:普通 UDP、截断后的 TCP、TLS/DoH 等是条件分支,不是本例每次都按顺序经过的步骤。
来源:packages/modules/DnsResolver/DnsProxyListener.cpp,DnsProxyListener::GetAddrInfoHandler::run(),固定提交 0aeaf9d222ec,方法范围 L881~L943。固定源码(L881)。
void DnsProxyListener::GetAddrInfoHandler::run() {
LOG(INFO) << "GetAddrInfoHandler::run: {" << mNetContext.toString() << "}";
addrinfo* result = nullptr;
maybeFixupNetContext(&mNetContext, mClient->getPid());
const uid_t uid = mClient->getUid();
int32_t rv = 0;
NetworkDnsEventReported event;
initDnsEvent(&event, mNetContext);
const bool isUidBlocked = isUidNetworkingBlocked(mNetContext.uid, mNetContext.dns_netid);
if (isUidBlocked) {
LOG(INFO) << "GetAddrInfoHandler::run: network access blocked";
rv = EAI_FAIL;
} else if (startQueryLimiter(uid)) {
const char* host = mHost.starts_with('^') ? nullptr : mHost.c_str();
const char* service = mService.starts_with('^') ? nullptr : mService.c_str();
if (gResNetdCallbacks.evaluate_domain_name(mNetContext, host)) {
rv = resolv_getaddrinfo(host, service, mHints.get(), &mNetContext, mClient->getSocket(),
&result, &event);
doDns64Synthesis(&rv, &result, &event);
} else {
rv = EAI_SYSTEM;
}
endQueryLimiter(uid);
} else {
rv = EAI_MEMORY;
}
// 省略:查询限额失败日志,以及查询耗时/事件字段统计。
bool success = true;
if (rv) {
success = !mClient->sendBinaryMsg(ResponseCode::DnsProxyOperationFailed, &rv, sizeof(rv));
} else {
success = !mClient->sendCode(ResponseCode::DnsProxyQueryResult);
addrinfo* ai = result;
while (ai && success) {
success = sendBE32(mClient, 1) && sendaddrinfo(mClient, ai);
ai = ai->ai_next;
}
success = success && sendBE32(mClient, 0);
}
// 省略:发送失败日志与DNS事件上报;结果内存仍在下方释放。
freeaddrinfo(result);
}
成功返回的是地址记录及结束标记,失败返回错误码;Bionic 读回后重建自己的 addrinfo。 Bionic 的代理错误并不把服务端所有详细 rv 原样透传,一些失败收敛为 EAI_NODATA;JNI 封装 GaiException,Java 通常转为 UnknownHostException,缺 INTERNET 权限相关 EACCES/EPERM 则另有 SecurityException 分支。报错时结合 stage、权限、网络身份、Resolver 状态判断,不能只靠 Java 异常名分清超时/NXDOMAIN/策略拒绝。代理流、工作对象和结果链表在各自路径结束时关闭/释放,缓存条目由自己的有效期和网络生命周期管理。
11.6 绑定 Socket,再连接
这一阶段建立两种联系:Java Socket 的 fd 指向 Kernel 端点,Network 的选择通过 fwmark 写到该端点。绑定成功后再连接远端;绑定不创建 HTTP 会话。
从原 fd 已经存在的状态开始,观察临时引用何时建立、网络 N 怎样随控制请求传入,以及 SO_MARK 怎样写到同一个内核 socket。接收端先关闭自己的临时 fd,再沿控制连接返回状态;应用侧临时 dup 随调用作用域结束,原 fd 继续存在。
这里演示应用有权使用 N 且设置成功的路径,N 对应本章选定 Network 的 netId;没有展开权限拒绝、VPN 保护判定和连接 fwmarkd 失败却兼容返回 0 的支线,正文仍保留这些限制。
创建端点,保留原 fd
Network.getSocketFactory 在该 Network 上惰性创建并缓存 NetworkBoundSocketFactory。无参工厂创建普通 Socket,调用 bindSocket,失败则关闭:
来源:packages/modules/Connectivity/framework/src/android/net/Network.java,Network.NetworkBoundSocketFactory.createSocket(),固定提交 347fbd34b368,方法范围 L272~L283。固定源码(L272)。
@Override
public Socket createSocket() throws IOException {
Socket socket = new Socket();
boolean failed = true;
try {
bindSocket(socket);
failed = false;
} finally {
if (failed) IoUtils.closeQuietly(socket);
}
return socket;
}
Java new Socket() 默认保存 SocksSocketImpl,它继承 PlainSocketImpl/AbstractPlainSocketImpl;通过延迟初始化建立底层端点。本例按未使用 SOCKS 代理的普通分支阅读;bindSocket 先查 socket 属性,确保底层 fd 存在:
来源:packages/modules/Connectivity/framework/src/android/net/Network.java,Network.bindSocket(Socket),固定提交 347fbd34b368,方法范围 L408~L419。固定源码(L408)。
public void bindSocket(Socket socket) throws IOException {
// Query a property of the underlying socket to ensure that the socket's file descriptor
// exists, is available to bind to a network and is not closed.
socket.getReuseAddress();
// ParcelFileDescriptor.fromSocket() creates a dup of the original fd. The original and
// the dup share the underlying socket in the kernel. The socket is never truly closed
// until the last fd pointing to the socket being closed. Try and eventually close the dup
// one after binding the socket to control the lifetime of the dup fd.
try (ParcelFileDescriptor pfd = ParcelFileDescriptor.fromSocket(socket)) {
bindSocket(pfd.getFileDescriptor());
}
}
ParcelFileDescriptor.fromSocket 建的是 dup fd;在绑定完成后关闭这个 dup,不会关闭应用仍持有的原 socket。 两个 fd 指向同一个 Kernel socket,所以后面设置的 mark 对原 socket 有效。PlainSocketImpl.socketCreate 用 IoBridge.socket(AF_INET6, SOCK_STREAM,0) 得到 fd 并保存到既有 FileDescriptor 包装,支持 IPv4 映射;Socket、Java fd 包装和内核端点因此连起来。Network.bindSocket(FileDescriptor) 用 getpeername 检查不能已经连接、只支持 AF_INET/AF_INET6,最后调用 NetworkUtils。
继续追:NetworkUtils.bindSocketToNetwork 将 netId 编成 NetworkHandle → JNI bindSocketToNetworkHandle 取 fd → frameworks/base Native android_setsocknetwork 解码 handle → libnetd_client.setNetworkForSocket:
来源:system/netd/client/NetdClient.cpp,setNetworkForSocket(unsigned, int),固定提交 43c893c7f33d,方法范围 L466~L471。固定源码(L466)。
extern "C" int setNetworkForSocket(unsigned netId, int socketFd) {
CHECK_SOCKET_IS_MARKABLE(socketFd);
netId &= ~NETID_USE_LOCAL_NAMESERVERS;
FwmarkCommand command = {FwmarkCommand::SELECT_NETWORK, netId, 0, 0};
return FwmarkClient().send(&command, socketFd, nullptr);
}
本地 FwmarkCommand::SELECT_NETWORK 连同这个 socket 的 fd 一起发给 fwmarkd。 FwmarkClient 用 AF_UNIX /dev/socket/fwmarkd,通过 sendmsg 的 SCM_RIGHTS 传递 fd。netd 收到的是自己进程中新建的 fd 引用,仍指向同一个 Kernel socket,不是把一个数字跨进程照抄。
如果只发送整数 57,netd 只能把它解释为自己文件表里的 57,无法据此取得应用的端点。SCM_RIGHTS 让服务获得同一内核对象的受控引用,可以完成权限相关的设置,再关闭临时引用;应用继续负责原 fd 的读写和关闭。这样无需让 netd 代转每块 HTTP 数据,但也多出本地控制连接与 fd 引用的生命周期,不能据此称整条数据链为零拷贝。
检查权限,设置 SO_MARK
FwmarkServer 根据请求、客户端凭据和原 mark 合成结果:
来源:system/netd/server/FwmarkServer.cpp,FwmarkServer::processClient(SocketClient*, int*),SELECT_NETWORK分支,固定提交 43c893c7f33d,方法范围 L81~L322。固定源码(L81)。
int FwmarkServer::processClient(SocketClient* client, int* socketFd) {
struct {
FwmarkCommand command;
FwmarkConnectInfo connectInfo;
} buf;
std::vector<unique_fd> received_fds;
ssize_t messageLength =
ReceiveFileDescriptorVector(client->getSocket(), &buf, sizeof(buf), 1, &received_fds);
// 省略:接收错误、报文长度、权限查询命令和fd数量检查;失败返回负错误码。
const FwmarkCommand &command = buf.command;
Permission permission = mNetworkController->getPermissionForUser(client->getUid());
*socketFd = received_fds[0].release();
// 省略:SO_DOMAIN与受支持地址族检查。
Fwmark fwmark;
socklen_t fwmarkLen = sizeof(fwmark.intValue);
if (getsockopt(*socketFd, SOL_SOCKET, SO_MARK, &fwmark.intValue, &fwmarkLen) == -1) {
return -errno;
}
switch (command.cmdId) {
// 省略:ON_ACCEPT、ON_CONNECT等其他命令case。
case FwmarkCommand::SELECT_NETWORK: {
fwmark.netId = command.netId;
if (command.netId == NETID_UNSET) {
fwmark.explicitlySelected = false;
fwmark.protectedFromVpn = false;
permission = PERMISSION_NONE;
} else {
if (int ret = mNetworkController->checkUserNetworkAccess(client->getUid(),
command.netId)) {
return ret;
}
fwmark.explicitlySelected = true;
fwmark.protectedFromVpn =
mNetworkController->canProtect(client->getUid(), command.netId);
}
break;
}
// 省略:其余命令case;本例SELECT_NETWORK的break退出switch后继续公共收尾。
}
fwmark.permission = permission;
if (setsockopt(*socketFd, SOL_SOCKET, SO_MARK, &fwmark.intValue,
sizeof(fwmark.intValue)) == -1) {
return -errno;
}
return 0;
}
非零 netId 要通过 checkUserNetworkAccess,成功后设置 explicitlySelected,并根据 canProtect 决定 protectedFromVpn。权限检查和 VPN 保护不是应用自己随意置位;本例不能保证绕开 always-on/lockdown VPN。SELECT_NETWORK 的 break 只退出 switch,后面还要把 permission 合入同一个 fwmark,再调用 setsockopt(SO_MARK);成功才返回 0,失败返回负错误码。
SO_MARK 保存在 Kernel socket;路由阶段据此和其他策略选路,不需要每写一块数据重新请求 ConnectivityService。 FwmarkClient 收整数错误,销毁时关闭本地控制连接;FwmarkServer 关闭接收的 dup fd,应用原 fd 继续持有该 socket。Java 的非零返回会转为 SocketException;本版本 Native C API 与 Java 包装的 errno 处理层次不同,不能仅凭最外层异常文本还原服务端所有错误细节。
本固定 FwmarkClient 在“连接 fwmark server 失败”分支返回 0,源码注释明确提醒可能误路由;因此绑定接口无异常不足以单独证明实际出口。需要把应用端点、网络 LinkProperties、规则/mark 或抓包证据关联起来。不能因为这里有一个兼容分支就断言本例必然走错路。
等待 connect 的最终结果
示例显式 socket.connect(InetSocketAddress,4000) 经继承的 AbstractPlainSocketImpl.doConnect 到 PlainSocketImpl.socketConnect:
来源:libcore/ojluni/src/main/java/java/net/PlainSocketImpl.java,PlainSocketImpl.socketConnect(InetAddress, int, int),固定提交 4ebfb391ee01,方法范围 L137~L155。固定源码(L137)。
void socketConnect(InetAddress address, int port, int timeout) throws IOException {
if (fd == null || !fd.valid()) {
throw new SocketException("Socket closed");
}
IoBridge.connect(fd, address, port, timeout);
this.address = address;
this.port = port;
if (localport == 0) {
// If socket is pending close, fd becomes an AF_UNIX socket and calling
// getLocalInetSocketAddress will fail.
// http://b/34645743
if (!isClosedOrPending()) {
localport = IoBridge.getLocalInetSocketAddress(fd).getPort();
}
}
}
IoBridge.connectErrno 的正超时分支将 fd 暂设非阻塞,发起 Libcore.os.connect;EINPROGRESS 表示连接在进行,随后 poll 等写就绪,并检查 SO_ERROR:
来源:libcore/luni/src/main/java/libcore/io/IoBridge.java,IoBridge.isConnected(FileDescriptor, InetAddress, int, int, int),固定提交 4ebfb391ee01,方法范围 L318~L348。固定源码(L318)。
// 省略:空行及说明性原注释;poll、SO_ERROR和异常返回路径完整保留。
@UnsupportedAppUsage
public static boolean isConnected(FileDescriptor fd, InetAddress inetAddress, int port,
int timeoutMs, int remainingTimeoutMs) throws IOException {
ErrnoException cause;
try {
StructPollfd[] pollFds = new StructPollfd[] { new StructPollfd() };
pollFds[0].fd = fd;
pollFds[0].events = (short) POLLOUT;
int rc = Libcore.os.poll(pollFds, remainingTimeoutMs);
if (rc == 0) {
return false; // Timeout.
}
int connectError = Libcore.os.getsockoptInt(fd, SOL_SOCKET, SO_ERROR);
if (connectError == 0) {
return true; // Success!
}
throw new ErrnoException("isConnected", connectError); // The connect(2) failed.
} catch (ErrnoException errnoException) {
if (!fd.valid()) {
throw new SocketException("Socket closed");
}
cause = errnoException;
}
String detail = createMessageForException(fd, inetAddress, port, timeoutMs, cause);
if (cause.errno == ETIMEDOUT) {
SocketTimeoutException e = new SocketTimeoutException(detail);
e.initCause(cause);
throw e;
}
throw new ConnectException(detail, cause);
}
可写事件之后还要看 SO_ERROR;poll 返回不是 TCP 成功的充分条件。 成功后恢复阻塞并回到 Java,填 address、port 与本地端口。本版本异常/超时分支由调用方关闭失败 socket,示例 try-with-resources 保证这一点;不要把“会恢复阻塞”不加条件地扩大到每个失败路径。
Bionic 的 connect 调度到 libnetd_client.netdClientConnect。在 markable INET socket 条件下,它先发送 ON_CONNECT,netd 检查/保持显式选择或为未显式 socket 选默认网络,然后调用真实 libcConnect;真实 libcConnect 返回后在同一调用线程保存 errno、同步发送 ON_CONNECT_COMPLETE 统计,再恢复 errno 返回。此例的非阻塞连接可以先报告 EINPROGRESS,这条统计不是 TCP 握手完成通知,最终连接结果仍看 IoBridge 的 poll/SO_ERROR。这次辅助 IPC 是 connect 阶段的元信息控制,不是把后续 HTTP 流交给 netd 转发。 TCP 的 SYN/SYN-ACK/ACK 在 Kernel 协议栈完成,连接建立也不表示 HTTP 服务业务已处理。
11.7 把字节送到设备
发送的数据从应用数组进入 Native,再交给 TCP。动画先展示 W 的副本、TCP 状态和 TX 描述符,再展示 V 经 RX buffer、接收队列和用户缓冲回到 Java 数组。观察一个阶段结束后哪些对象仍持有结果,尤其区分 WRITE_RETURN、used、TCP ACK 和 read 返回。
W/V 只标示本轮收发中的一段字节,重复的标记表示不同层的副本或描述范围,不表示永久共享同一块内存,也不保证一段用户数据只对应一个 TCP 包。图中选取 ACK 先于业务响应到达的一条成功编排;真实分段、合并及确认时机由协议状态决定。
复制字节,处理短写
getOutputStream 创建/返回与同一 SocketImpl 关联的 SocketOutputStream。write(byte[]) 进入 socketWrite,acquireFD 在本次操作期间保持底层 fd 可用,finally releaseFD;BlockGuard 检查网络线程策略后 JNI socketWrite0 取数组片段:
来源:libcore/ojluni/src/main/native/SocketOutputStream.c,SocketOutputStream_socketWrite0(JNIEnv*, jobject, jobject, jbyteArray, jint, jint),固定提交 4ebfb391ee01,方法范围 L54~L129。固定源码(L54)。
JNIEXPORT void JNICALL
SocketOutputStream_socketWrite0(JNIEnv *env, jobject this,
jobject fdObj,
jbyteArray data,
jint off, jint len) {
char *bufP;
char BUF[MAX_BUFFER_LEN];
int buflen;
int fd;
if (IS_NULL(fdObj)) {
JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
return;
} else {
fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
if (fd == -1) {
JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
return;
}
}
if (len <= MAX_BUFFER_LEN) {
bufP = BUF;
buflen = MAX_BUFFER_LEN;
} else {
buflen = min(MAX_HEAP_BUFFER_LEN, len);
bufP = (char *)malloc((size_t)buflen);
if (bufP == NULL) {
bufP = BUF;
buflen = MAX_BUFFER_LEN;
}
}
while(len > 0) {
int loff = 0;
int chunkLen = min(buflen, len);
int llen = chunkLen;
(*env)->GetByteArrayRegion(env, data, off, chunkLen, (jbyte *)bufP);
while(llen > 0) {
int n = NET_Send(fd, bufP + loff, llen, 0);
if (n > 0) {
llen -= n;
loff += n;
continue;
}
// 省略:把JVM_IO_INTR、ECONNRESET等写错误转成对应Java异常。
if (bufP != BUF) {
free(bufP);
}
return;
}
len -= chunkLen;
off += chunkLen;
}
if (bufP != BUF) {
free(bufP);
}
}
GetByteArrayRegion 将 Java 请求复制到 Native 缓冲,NET_Send 的正数返回会推进偏移,短写要继续。 若 ECONNRESET 等出错,Native 抛 Java 网络异常并清理临时缓冲;成功写完本次长度,才回到示例 WRITE_RETURN。公开 Java write 返回 void,低层正数字节数由内部循环消费,而不是原样成为 Java 返回值。
来源:libcore/ojluni/src/main/native/linux_close.cpp,NET_Send(int, void*, int, unsigned int),固定提交 4ebfb391ee01,方法范围 L147~L149。固定源码(L147)。
int NET_Send(int s, void *msg, int len, unsigned int flags) {
BLOCKING_IO_RETURN_INT( s, send(s, msg, len, flags) );
}
NET_Send 的实际 C send 在 Bionic 上对应 sendto 系统调用包装;libnetd_client 的 sendto hook 可按属性参与未连接发送等元信息辅助,本例已连接 TCP 仍由内核发送业务字节。Kernel __sys_sendto 用 fd 查 socket,将用户缓冲导入 msg_iter,调用 socket 协议发送操作;INET/INET6 的协议分派汇入 TCP 的发送函数。
来源:kernel/net/ipv4/tcp.c,tcp_sendmsg(struct sock*, struct msghdr*, size_t),固定提交 ccafb60de224,方法范围 L1355~L1365。固定源码(L1355)。
int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
{
int ret;
trace_android_rvh_tcp_sendmsg(sk, msg, size);
lock_sock(sk);
ret = tcp_sendmsg_locked(sk, msg, size);
release_sock(sk);
return ret;
}
lock_sock 保护这次对 TCP socket 状态的处理,release_sock 后返回给系统调用方;它不是一把覆盖 Java 数组、netd 和 Driver 的全局锁。 tcp_sendmsg_locked 根据连接状态、可用内存、发送窗口等等待或将数据装入 skb。空间不足可进入 sk_stream_wait_memory,复制后的数据经 tcp_push 触发发送:
来源:kernel/net/ipv4/tcp.c,tcp_sendmsg_locked(struct sock*, struct msghdr*, size_t),out/out_nopush/do_error/out_err,固定提交 ccafb60de224,方法范围 L1052~L1352。固定源码(L1052)。
int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
{
struct tcp_sock *tp = tcp_sk(sk);
struct ubuf_info *uarg = NULL;
struct sk_buff *skb;
struct sockcm_cookie sockc;
int flags, err, copied = 0;
int mss_now = 0, size_goal, copied_syn = 0;
int process_backlog = 0;
int zc = 0;
long timeo;
flags = msg->msg_flags;
// 省略:FastOpen/zero-copy/splice/repair特殊路径与连接状态等待;本例展开普通发送的返回收尾。
sockcm_init(&sockc, sk);
// 省略:附加控制消息检查、发送状态检查与循环入口。
mss_now = tcp_send_mss(sk, &size_goal, flags);
// 省略:循环复用或分配skb,从msg_iter接受数据并累加copied;等待内存失败转do_error。
out:
if (copied) {
tcp_tx_timestamp(sk, sockc.tsflags);
tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
}
out_nopush:
if (uarg && !msg->msg_ubuf)
net_zcopy_put(uarg);
return copied + copied_syn;
do_error:
tcp_remove_empty_skb(sk);
if (copied + copied_syn)
goto out;
out_err:
if (uarg && !msg->msg_ubuf)
net_zcopy_put_abort(uarg, true);
err = sk_stream_error(sk, flags, err);
if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) {
sk->sk_write_space(sk);
tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
}
return err;
}
return copied + copied_syn 报告该次调用接受的字节数量。 本例不是 TCP Fast Open 示例,不把 copied_syn 当每次都会产生的行为。发送队列、拥塞窗口、Nagle、GSO 等可使字节稍后才发出;重传还会使用保留的数据。Java write 返回、设备完成描述符、TCP ACK、HTTP 响应是四个不同里程碑。
假如 write 必须等到对端业务处理完才能返回,它还需要认识 HTTP 响应或业务确认,便不能只靠 TCP 的发送接口给出结论。现在的层次由 TCP 接受并管理字节流,上层按协议读取响应;代价是 write 成功后仍要处理后续超时、重置和部分响应。需要“远端业务已完成”的应用,应以自己的协议结果判断,不能把本地写入成功换算成远端成功。
沿 IPv4 输出路径发送
对于选择了 IPv4 地址且未走 VPN/CLAT 的普通 TCP 分支:TCP 发送队列经 tcp_write_xmit/tcp_transmit_skb,icsk_af_ops->queue_xmit 分派到 ip_queue_xmit。后者把目的地址、源地址、socket mark 等放入路由查询,或者复用仍有效的目标缓存;不能推断每个包都从头遍历所有规则。IPv6 使用 inet6_csk_xmit 等对应分支;双栈 Socket 可以承载 IPv4 映射目的地址。
IPv4 的输出经 ip_local_out、netfilter LOCAL_OUT/POST_ROUTING 等挂点、分片/分段与邻居输出;邻居层补链路信息,再进入 dev_queue_xmit/__dev_queue_xmit。这里选设备发送队列并经过相应 qdisc 路径,或者走设备 noqueue 等直接发送分支;不是所有设备都必须在一个传统 qdisc 队列停留。sch_direct_xmit/dev_hard_start_xmit 最终调用 net_device_ops.ndo_start_xmit。
netfilter 是可插规则的检查框架,BPF 是可附着程序的机制;两者都不是一台必经的用户态转发服务器。 本地输出、转发和接收经过的 hook 不同。某个抓包点看不到包,也可能是前一层拦截、重用缓存/连接或观察位置不对,不能直接归因驱动。
VirtIO 分支交付描述符
本章选择阅读 virtio_net.c 中普通 skb 发送分支。net_device_ops 把 ndo_start_xmit 关联到 start_xmit,驱动选 send_queue,先回收旧 used buffer,再调用 xmit_skb:
来源:kernel/drivers/net/virtio_net.c,virtnet start_xmit(struct sk_buff*, struct net_device*),固定提交 ccafb60de224,方法范围 L3133~L3191。固定源码(L3133)。
static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
{
struct virtnet_info *vi = netdev_priv(dev);
int qnum = skb_get_queue_mapping(skb);
struct send_queue *sq = &vi->sq[qnum];
int err;
struct netdev_queue *txq = netdev_get_tx_queue(dev, qnum);
bool xmit_more = netdev_xmit_more();
bool use_napi = sq->napi.weight;
bool kick;
// 省略:按use_napi条件关闭/恢复队列callback,并free_old_xmit回收此前完成的buffer。
skb_tx_timestamp(skb);
err = xmit_skb(sq, skb, !use_napi);
if (unlikely(err)) {
DEV_STATS_INC(dev, tx_fifo_errors);
// 省略:速率限制后的错误日志。
DEV_STATS_INC(dev, tx_dropped);
dev_kfree_skb_any(skb);
return NETDEV_TX_OK;
}
if (!use_napi) {
skb_orphan(skb);
nf_reset_ct(skb);
}
check_sq_full_and_disable(vi, dev, sq);
kick = use_napi ? __netdev_tx_sent_queue(txq, skb->len, xmit_more) :
!xmit_more || netif_xmit_stopped(txq);
if (kick) {
if (virtqueue_kick_prepare(sq->vq) && virtqueue_notify(sq->vq)) {
u64_stats_update_begin(&sq->stats.syncp);
u64_stats_inc(&sq->stats.kicks);
u64_stats_update_end(&sq->stats.syncp);
}
}
return NETDEV_TX_OK;
}
xmit_skb 给 skb 添加/关联 VirtIO 网络头,构造 scatter-gather 段并入队:
来源:kernel/drivers/net/virtio_net.c,virtnet xmit_skb(struct send_queue*, struct sk_buff*, bool),固定提交 ccafb60de224,方法范围 L3085~L3131。固定源码(L3085)。
// 省略:空行、调试打印及说明性原注释;header和sg准备的分支仍保留。
static int xmit_skb(struct send_queue *sq, struct sk_buff *skb, bool orphan)
{
struct virtio_net_hdr_mrg_rxbuf *hdr;
const unsigned char *dest = ((struct ethhdr *)skb->data)->h_dest;
struct virtnet_info *vi = sq->vq->vdev->priv;
int num_sg;
unsigned hdr_len = vi->hdr_len;
bool can_push;
can_push = vi->any_header_sg &&
!((unsigned long)skb->data & (__alignof__(*hdr) - 1)) &&
!skb_header_cloned(skb) && skb_headroom(skb) >= hdr_len;
if (can_push)
hdr = (struct virtio_net_hdr_mrg_rxbuf *)(skb->data - hdr_len);
else
hdr = &skb_vnet_common_hdr(skb)->mrg_hdr;
if (virtio_net_hdr_from_skb(skb, &hdr->hdr,
virtio_is_little_endian(vi->vdev), false,
0))
return -EPROTO;
if (vi->mergeable_rx_bufs)
hdr->num_buffers = 0;
sg_init_table(sq->sg, skb_shinfo(skb)->nr_frags + (can_push ? 1 : 2));
if (can_push) {
__skb_push(skb, hdr_len);
num_sg = skb_to_sgvec(skb, sq->sg, 0, skb->len);
if (unlikely(num_sg < 0))
return num_sg;
__skb_pull(skb, hdr_len);
} else {
sg_set_buf(sq->sg, hdr, hdr_len);
num_sg = skb_to_sgvec(skb, sq->sg + 1, 0, skb->len);
if (unlikely(num_sg < 0))
return num_sg;
num_sg++;
}
return virtqueue_add_outbuf(sq->vq, sq->sg, num_sg,
skb_to_ptr(skb, orphan), GFP_ATOMIC);
}
virtqueue_add_outbuf 交付可供 Host 读取的描述符及 guest buffer;符合批处理条件才 kick/notify。 start_xmit 失败分支增加 tx_dropped、释放 skb,再返回 NETDEV_TX_OK,表示 Driver 已接管并消费该 skb,不表示已经送达网络。正常发送的 used 描述符随后由 free_old_xmit 等回收,可能在后续发送或 NAPI 中发生。
这条分支的材料依据:2026-10-19 历史日志中 virtio_net 已加载;已有材料对预编译 virtio_net.ko 的只读检查显示,scmversion 为 gccafb60de224,vermagic 与历史 6.12.58 一致。历史 kernel.config 中 CONFIG_VIRTIO_NET 未设置,但 goldfish_modules 有单独构建的 virtio_net.ko,基础 Kernel config 不能覆盖另编模块是否存在/已加载。这些材料支持选择固定 common virtio_net 阅读,不证明某次 HTTP 经哪块接口、哪条 TX/RX 队列,也没有本轮设备端模块摘要或 sysfs 绑定核对。
要判断自己的实例是否使用该 Driver,先从选中 Network 的 LinkProperties 找接口,再在设备有权限的 shell 中读 ip -d link、/sys/class/net/<接口>/device/driver、模块链接与路由;虚拟 Wifi 还可能有 virt_wifi 叠层,不能仅看到 wlan0 就跳到 virtio_net。接口名和模块加载是导航证据,仍需请求/抓包关联。
Host 后端接过帧
为读通 guest/host 边界,本文采用已保存的 Android 官方 external/qemu 可读分支固定提交 ae9d18d2b6261179fbd57fffec720a04f7bfb053,阅读 hw/net/virtio-net.c、net/net.c 和 net/slirp.c。它不是已证明对应本机 Emulator 36.3.10 预编译包的源码。 选择的是 VirtIO + 用户网络 Slirp 分支,具体启动配置也可能使用其他后端。
Host 设备模型处理 TX virtqueue 后调用:
来源:qemu/hw/net/virtio-net.c,QEMU virtio_net_flush_tx(VirtIONetQueue*),固定提交 ae9d18d2b626,方法范围 L1327~L1420。固定源码(L1327)。
static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
{
VirtIONet *n = q->n;
VirtIODevice *vdev = VIRTIO_DEVICE(n);
VirtQueueElement *elem;
int32_t num_packets = 0;
int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
return num_packets;
}
if (q->async_tx.elem) {
virtio_queue_set_notification(q->tx_vq, 0);
return num_packets;
}
for (;;) {
ssize_t ret;
unsigned int out_num;
struct iovec sg[VIRTQUEUE_MAX_SIZE], sg2[VIRTQUEUE_MAX_SIZE + 1], *out_sg;
elem = virtqueue_pop(q->tx_vq, sizeof(VirtQueueElement));
if (!elem) {
break;
}
out_num = elem->out_num;
out_sg = elem->out_sg;
if (out_num < 1) {
virtio_error(vdev, "virtio-net header not in first element");
virtqueue_detach_element(q->tx_vq, elem, 0);
g_free(elem);
return -EINVAL;
}
// 省略:验证/转换VirtIO header,按host/guest header长度调整out_sg/out_num;无效header可丢弃或返回错误。
ret = qemu_sendv_packet_async(qemu_get_subqueue(n->nic, queue_index),
out_sg, out_num, virtio_net_tx_complete);
if (ret == 0) {
virtio_queue_set_notification(q->tx_vq, 0);
q->async_tx.elem = elem;
return -EBUSY;
}
drop:
virtqueue_push(q->tx_vq, elem, 0);
virtio_notify(vdev, q->tx_vq);
g_free(elem);
if (++num_packets >= n->tx_burst) {
break;
}
}
return num_packets;
}
qemu_sendv_packet_async 把散段交给所连网络后端;ret==0 保留异步 elem,完成回调之后再返还描述符。 非异步路径会 virtqueue_push 并 notify guest。Slirp 后端的 receive 调到 net_slirp_receive_raw → slirp_input;对外连接由 Host 用户网络栈与 Host socket/网络环境完成,外部收到的端点可以经过转换,不能把 guest TCP 四元组当成 Host 线上四元组。本文在公开 Slirp 接口与 Host OS 网络边界止步,未取得并证明当前运行器精确构建中 Slirp/Host socket 的逐调用和物理网卡路径。
反向时 Slirp 输出经 net_slirp_output_raw → qemu_send_packet,设备模型把帧写入 guest 提供的 RX 描述符,标记 used 并通知 guest;通知可以合并或抑制,不能画成每个包都单独产生一次硬中断。本段是固定可读分支机制,不是当前实例的抓包结果。
11.8 让响应回到数组
guest VirtIO net 的接收队列预先提供可写 buffer。中断/通知配合 NAPI 调度,virtnet_poll 从 used queue 取出数据,经 receive_buf 的不同大小/XDP 等分支构造 skb、设置协议,交给 GRO 与协议栈。receive_buf 的普通分支可由 receive_small 构造 skb,再汇合到 virtnet_receive_done;下面展示 virtnet_receive_done 中汇合后的上送步骤:
来源:kernel/drivers/net/virtio_net.c,virtnet_receive_done(struct virtnet_info*, struct receive_queue*, struct sk_buff*, u8),固定提交 ccafb60de224,方法范围 L2408~L2440。固定源码(L2408)。
// 省略:空行及调试打印;此方法为virtnet_receive_done,receive_buf先形成skb后才调用它。
static void virtnet_receive_done(struct virtnet_info *vi, struct receive_queue *rq,
struct sk_buff *skb, u8 flags)
{
struct virtio_net_common_hdr *hdr;
struct net_device *dev = vi->dev;
hdr = skb_vnet_common_hdr(skb);
if (dev->features & NETIF_F_RXHASH && vi->has_rss_hash_report)
virtio_skb_set_hash(&hdr->hash_v1_hdr, skb);
if (flags & VIRTIO_NET_HDR_F_DATA_VALID)
skb->ip_summed = CHECKSUM_UNNECESSARY;
if (virtio_net_hdr_to_skb(skb, &hdr->hdr,
virtio_is_little_endian(vi->vdev))) {
net_warn_ratelimited("%s: bad gso: type: %u, size: %u\n",
dev->name, hdr->hdr.gso_type,
hdr->hdr.gso_size);
goto frame_err;
}
skb_record_rx_queue(skb, vq2rxq(rq->vq));
skb->protocol = eth_type_trans(skb, dev);
napi_gro_receive(&rq->napi, skb);
return;
frame_err:
DEV_STATS_INC(dev, rx_frame_errors);
dev_kfree_skb(skb);
}
napi_gro_receive 上送的是 Kernel skb;它不直接调用应用的 Java read。 IPv4 在协议栈经 ip_rcv、路由与 LOCAL_IN 等处理,分派到 tcp_v4_rcv。TCP 按连接标识找到 sock,检查序号、处理 ACK/重排/接收数据,经 tcp_data_queue 等把可交付字节纳入接收状态;数据就绪调用 sk_data_ready,通常落到 sock_def_readable:
来源:kernel/net/core/sock.c,sock_def_readable(struct sock*),固定提交 ccafb60de224,方法范围 L3477~L3500。固定源码(L3477)。
// 省略:空行及说明性原注释;等待者条件、hook和RCU收尾保留。
void sock_def_readable(struct sock *sk)
{
struct socket_wq *wq;
trace_sk_data_ready(sk);
rcu_read_lock();
wq = rcu_dereference(sk->sk_wq);
if (skwq_has_sleeper(wq)) {
int done = 0;
trace_android_vh_do_wake_up_sync(&wq->wait, &done, sk);
if (done)
goto out;
wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
EPOLLRDNORM | EPOLLRDBAND);
}
out:
sk_wake_async_rcu(sk, SOCK_WAKE_WAITD, POLL_IN);
rcu_read_unlock();
}
唤醒只让等待者具备运行条件,不表示 probe-io 已立即执行,更不是调用 NetworkCallback。 TCP 快慢路径、backlog 与软中断/进程上下文会改变实际处理时机,所以不能把所有接收步骤归为一个固定 Driver 线程。
应用 InputStream.read 调 SocketInputStream.read,保持同一 fd,Native socketRead0 按 timeout 先 poll/等待,再经 NET_Read → recv → Kernel socket receive 操作进入 tcp_recvmsg。若已缓存足够数据,不必等新的设备中断;不够时在 socket 等待队列上等数据或错误。TCP 从 skb 将目标字节拷入用户提供缓冲,返回实际字节数。Native 成功路径再填回 Java 数组:
来源:libcore/ojluni/src/main/native/SocketInputStream.c,SocketInputStream_socketRead0(JNIEnv*, jobject, jobject, jbyteArray, jint, jint, jint),固定提交 4ebfb391ee01,方法范围 L53~L154。固定源码(L53)。
JNIEXPORT jint JNICALL
SocketInputStream_socketRead0(JNIEnv *env, jobject this,
jobject fdObj, jbyteArray data,
jint off, jint len, jint timeout)
{
char BUF[MAX_BUFFER_LEN];
char *bufP;
jint fd, nread;
if (IS_NULL(fdObj)) {
JNU_ThrowByName(env, JNU_JAVANETPKG "SocketException",
"Socket closed");
return -1;
} else {
fd = (*env)->GetIntField(env, fdObj, IO_fd_fdID);
if (fd == -1) {
JNU_ThrowByName(env, "java/net/SocketException", "Socket closed");
return -1;
}
}
if (len > MAX_BUFFER_LEN) {
if (len > MAX_HEAP_BUFFER_LEN) {
len = MAX_HEAP_BUFFER_LEN;
}
bufP = (char *)malloc((size_t)len);
if (bufP == NULL) {
bufP = BUF;
len = MAX_BUFFER_LEN;
}
} else {
bufP = BUF;
}
if (timeout) {
nread = NET_Timeout(fd, timeout);
if (nread <= 0) {
// 省略:nread==0抛SocketTimeoutException;负数等待错误转为关闭/中断等对应异常。
if (bufP != BUF) {
free(bufP);
}
return -1;
}
}
nread = NET_Read(fd, bufP, len);
if (nread <= 0) {
if (nread < 0) {
// 省略:nread<0时按errno抛ConnectionReset/SocketException/InterruptedIOException。
}
} else {
(*env)->SetByteArrayRegion(env, data, off, nread, (jbyte *)bufP);
}
if (bufP != BUF) {
free(bufP);
}
return nread;
}
SetByteArrayRegion 把 nread 个字节写回应用传入的 byte[]。 SocketInputStream 将正数返回给示例,示例写入 ByteArrayOutputStream 并继续读取,最后解析首行。一次 read 不保证对应一个 TCP 包或一个完整 HTTP 响应;TCP 是字节流,可能拆分/合并。
内核 recv 返回 0 可表示正常流结束,Java 在检查关闭与重置之后保存 eof 并转为 -1:
来源:libcore/ojluni/src/main/java/java/net/SocketInputStream.java,SocketInputStream.read(byte[], int, int, int),固定提交 4ebfb391ee01,方法范围 L146~L195。固定源码(L146)。
// 省略:空行及完整原注释;所有执行语句保留。
int read(byte b[], int off, int length, int timeout) throws IOException {
int n;
if (eof) {
return -1;
}
if (impl.isConnectionReset()) {
throw new SocketException("Connection reset");
}
if (length <= 0 || off < 0 || length > b.length - off) {
if (length == 0) {
return 0;
}
throw new ArrayIndexOutOfBoundsException("length == " + length
+ " off == " + off + " buffer length == " + b.length);
}
FileDescriptor fd = impl.acquireFD();
try {
BlockGuard.getThreadPolicy().onNetwork();
n = socketRead(fd, b, off, length, timeout);
if (n > 0) {
return n;
}
} catch (ConnectionResetException rstExc) {
impl.setConnectionReset();
} finally {
impl.releaseFD();
}
if (impl.isClosedOrPending()) {
throw new SocketException("Socket closed");
}
if (impl.isConnectionReset()) {
throw new SocketException("Connection reset");
}
eof = true;
return -1;
}
正常 EOF、Socket closed、Connection reset 和读超时是不同终点。 收到部分响应后再断开也不能自动认定业务成功。示例只报告首行和上限/EOF,不做 Content-Length、chunked 或 TLS 校验。
回看 11.7 的同一段动画:RX 描述符先容纳 V,协议栈再把可交付字节放进 S 的接收状态;唤醒之后还要等 probe-io 获调度,recv 才能复制数据。Native 读缓冲结束后,V 仍留在 Java 数组中。
时序为概念示意:write 返回与实际设备发送、read 调用与响应入队之间可以交错;通知、ACK 与业务响应不能合并成一条“返回”。
11.9 关闭连接,释放请求
读完响应后,先看应用怎样归还连接和网络需求。
正常结束有两种独立责任。try-with-resources 关闭 Java Socket,SocketImpl 处理 fd 使用计数、唤醒可能阻塞的操作并最终关闭;Kernel 端 TCP 状态可能还走 FIN、重传、TIME_WAIT 等,用户 fd 关闭不等于所有协议状态立即消失。网络需求则在 Activity.onStop 注销,unregisterNetworkCallback 经 releaseNetworkRequest 让服务端移除请求、死亡监听和满足关系;若其他需求仍使用该网络,网络不会因为本例注销就一定被拆掉。
系统重新匹配请求可能交付一个新的 Network。已经绑定旧 Network 的 socket 不会自动迁移。 onLost 表示旧 Network 已不再满足本次回调对应的使用关系,不能仅凭这个回调断言物理链路已断开。若切换到新的 Network,应用需要在新网络上重新解析域名并创建连接,再按业务的幂等性决定是否重试。本例每个 Session 只提交一次工作任务,不因新 onAvailable 再提交;任务内部仍可能按 11.2 的地址循环重发 GET。更佳网络接替原匹配时,旧网络仍可能可用,应用未必收到旧网络的 onLost。本例收到选中网络的 onLost 时只关闭当时持有的 socket。若当时还在等 DNS,晚返回的工作仍可能尝试建连。退出 Activity 时设置的 stopped 才会阻止后续尝试。要验证切换,另做两组:未绑定的默认网络新连接,与显式绑定旧 Network 的旧/新连接,不能把两组混成一条迁移证据。
把 Socket 与 NetworkRequest 绑成同一个生命周期会遇到两个反例:一次网络需求可以支持多个连接,一个网络也可以同时满足多个应用。分别管理可以支持这些复用关系,应用也要分别负责关闭连接和注销订阅。进程死亡只能提供异常兜底,不能代替及时释放;同步 DNS 晚返回时,还需要 stopped 这类状态门阻止新连接继续产生。
匹配超时或系统判定请求无法满足,都可能触发 onUnavailable;按该回调的契约,Framework 在交付回调前已经释放请求。本例最终仍调用注销以统一资源退出,当前 API 对已因 onUnavailable 移除的 callback 有明确处理;示例捕获 IllegalArgumentException 只记录清理竞态,不把所有注销异常当成请求曾成功。
宿主退出时 Binder 令牌的死亡另触发清理:
来源:packages/modules/Connectivity/service/src/com/android/server/ConnectivityService.java,ConnectivityService.NetworkRequestInfo.binderDied(),固定提交 347fbd34b368,方法范围 L9181~L9190。固定源码(L9181)。
@Override
public void binderDied() {
// As an immutable collection, mRequests cannot change by the time the
// lambda is evaluated on the handler thread so calling .get() from a binder thread
// is acceptable. Use handleReleaseNetworkRequest and not directly
// handleRemoveNetworkRequest so as to force a lookup in the requests map, in case
// the app already unregistered the request.
mHandler.post(() -> handleReleaseNetworkRequest(mRequests.get(0),
mUid, false /* callOnUnavailable */));
}
死亡回调将释放工作投递到 ConnectivityService Handler,不能在 Binder 死亡线程随意直接改服务主状态。 应用文件表退出也会关闭残留 socket fd;这是异常兜底,不替代示例的显式关闭。NetworkAgent 断开时另有 destroyNativeNetwork:networkDestroy、销毁 DNS cache、更新 socket/地址和移除策略;它与“一个 HTTP 完成”不属于同一个生命周期。
11.10 辨认条件分支
这些机制会改变网络身份、规则或数据经过的位置,是否进入由配置、API 使用和实际挂点决定。主线没有把它们排成每次请求都必经的流水线;NetworkStack 的准备职责见 11.4。
BPF 按挂点执行策略
本固定主实现位于 Connectivity/bpf/progs/netd.c 与 service/BpfNetMaps.java;system/bpf 仍是基础加载/辅助入口,不能看到目录名就把整个网络策略归给 system/netd 老版 TrafficController。BpfNetMaps 更新 UID 规则、权限与统计等 map;内核 BPF 程序在 cgroup skb、socket、tc 等实际挂点运行。数据包的 UID/cookie 可关联标签/记账与拦截决策。
同一源码文件保留按 Kernel/API 范围选择的多个程序,必须核对本例所选版本和设备实际附着的程序。尤其这里 connect4/connect6 的某些实现直接返回 BPF_ALLOW,不能因函数名带 connect 就推断“它替本例完成了 netId 选路”。静态 map/程序存在、bpffs 文件存在与本次包实际命中是三层证据。没有设备侧附着和计数/trace,本章只解释机制与定位方法。
VPN 引入 TUN 与外层连接
用户态 VpnService 的 Builder.establish 经 VPN 服务管理创建 TUN,返回 ParcelFileDescriptor;VPN 应用从这个 fd 读取 IP 包,封装到自己的外层 socket,再发向 VPN 端点。受 UID 范围、路由、排除与 lockdown 等策略影响,应用默认 Network 可是虚拟网络。VPN 自己的外层 socket 通常需 protect 以避免再次进入隧道,这与给任意应用无条件绕过 VPN 不是一回事。
固定 Vpn.establish 的关键顺序是验证服务权限、adoptFd/jniCreate 创建接口、设置地址、绑定 VPN Service/登记 NetworkAgent;失败时回滚、关闭新 TUN 并恢复旧配置,不能只讲成功的 fd 返回。源码在 frameworks/base/services/core/java/com/android/server/connectivity/Vpn.java;本章不扩展为完整 VPN 客户端教程。
Tethering 处理下游转发
Tethering 通过 IpServer 管理下游接口/地址/DHCP,与上游选择、netd 转发/NAT/规则、BpfCoordinator 的卸载协作。它关注来自另一设备的转发包,普通本机 Socket 是本地输出路径,两者可能使用不同 netfilter hook 和统计口径。硬件 offload 存在接口及实现分支,但不能为本机普通 GET 添加一个 Tethering HAL。停用共享需清理下游、转发、规则/卸载状态;本次没有启动共享或验证 offload。
IPsec 配置 XFRM 变换
IpSecManager/IpSecTransform 管 SPI、算法/密钥、方向与资源句柄。IpSecService 创建 Transform、核对归属和 mode 后,调用 INetd/XfrmController 配置 XFRM state/policy 或把 transport transform 应用到 socket:
来源:packages/modules/Connectivity/service-t/src/com/android/server/IpSecService.java,IpSecService.applyTransportModeTransform(ParcelFileDescriptor, int, int),固定提交 347fbd34b368,方法范围 L1924~L1966。固定源码(L1924)。
// 省略:空行与解释性原注释;权限/所有权/模式检查、netd调用和finally清理完整保留。
@Override
public synchronized void applyTransportModeTransform(
ParcelFileDescriptor socket, int direction, int resourceId) throws RemoteException {
int callingUid = Binder.getCallingUid();
UserRecord userRecord = mUserResourceTracker.getUserRecord(callingUid);
checkDirection(direction);
TransformRecord info = userRecord.mTransformRecords.getResourceOrThrow(resourceId);
if (info.mPid != getCallingPid() || info.mUid != callingUid) {
throw new SecurityException("Only the owner of an IpSec Transform may apply it!");
}
IpSecConfig c = info.getConfig();
Preconditions.checkArgument(
c.getMode() == IpSecTransform.MODE_TRANSPORT,
"Transform mode was not Transport mode; cannot be applied to a socket");
try {
mNetd.ipSecApplyTransportModeTransform(
socket,
callingUid,
direction,
c.getSourceAddress(),
c.getDestinationAddress(),
info.getSpiRecord().getSpi());
} finally {
try {
socket.close();
} catch (IOException e) {
Log.e(TAG, "applyTransportModeTransform close pfd:" + e);
}
}
}
这里的 Binder 是管理变换,实际包在 Kernel XFRM 路径处理;不是每个 Socket 自带 IPsec。 IPsec/IKE 库还涉及协商、重协商与删除;未应用变换的本例不经过它。Transform、SPI、UDP 封装 socket 等资源各需按 API 关闭,不能以 close 一个业务 socket 推断所有安全关联已删除。packages/modules/IPsec 的 IKE 实现与 Connectivity 的 IpSecService、netd 的 XfrmController 是不同职责。
IPv6-only 网络里还可能有 DNS64/NAT64 和 CLAT。DNS64 合成的是地址结果;CLAT 协调 v4- 接口、clatd/可选 BPF 加速,把 IPv4 包与 IPv6 路径衔接。这一版本主要由 Connectivity 模块的 ClatCoordinator 协调,经 JNI 启停 clatd。本例如果实际进入该路径,需要另画翻译前后地址和数据流,不能直接沿用“无 CLAT 的 IPv4 分支”图。
11.11 沿失败终点排查
| 现象/对照 | 先看哪一站 | 能区分的结论 |
|---|---|---|
| REGISTER_FAIL | 权限、请求能力、调用限额、异常 | 请求没有成功登记;不是 DNS 错误 |
| UNAVAILABLE | 请求匹配状态、超时或被判定无法满足、网络提供方/策略 | 仅凭回调不能判断已耗尽 10 秒;与 DNS/HTTP 超时分开 |
| AVAILABLE 后一直 validated=false | NetworkMonitor/Portal/私有 DNS 状态 | 本例未提交 I/O;匹配成功不等验证 |
| DNS 失败或缓存命中 | 同 netId 的域名、缓存、Resolver 配置、Private DNS、UID 策略 | 不拿 ping IP 成功证明 DNS 正常 |
| bind/create 失败 | Network 是否已失效、权限、fd/网络族、fwmark | 接口返回成功仍需出口证据 |
| connect 超时/拒绝 | 目的地址、选网/规则、VPN、SYN/RST 与 SO_ERROR | 建连故障;没有 HTTP 响应并不一定到 read 阶段 |
| write 返回后 read 超时 | HTTP Host/请求、服务器、返回路由、socket 状态 | 本地发送接受不等对端响应 |
| read EOF/重置/部分数据 | 同 run 字节数和异常、服务端关闭、响应完整性 | EOF 是流结束;不自动等业务成功 |
| 切换后新连接成功、旧连接失败 | 新旧 Network、DNS 时间、旧 socket 绑定 | 新连恢复不证明旧 socket 自动迁移 |
受控失败方案供读者另行执行:在示例副本把 host 改为 aosp-connectivity-probe.invalid,重新构建安装该副本,观察 DNS 失败终点;.invalid 是保留无效域名,仍应记录代理/拦截等环境差异。不要只改文档变量却运行旧 APK。连接拒绝/超时对照使用自己控制的服务器与明确端口;不把公共站点某端口当前关闭当稳定实验前提。网络切换需要授权和干净初始状态,本轮没有注入故障。
需要进一步定位时,先取得本轮应用 PID、UID、Network、接口、目的 IP 和时间。可用 userdebug/root 环境的读者再选择 strace/tcpdump/Perfetto 中的相应观察面,先检查工具和权限,系统未提供相应工具时,不能把这项观察当作必经步骤。strace 看见 sendto/recvfrom 是用户/内核边界证据;tcpdump 看见包要注明 guest 接口还是 Host 接口;Driver 事件加描述符才支持设备边界,时间邻近不能替代请求关联。
排查时分别保存源码依据、历史镜像记录、当前静态检查和当前设备观察。本文的固定源码解释机制,2026-10-19 历史记录只支持当时镜像/Kernel/模块线索;本次正文重生成未构建、安装、启动或抓包,设备与线上传输仍待验证,不能据此判定 L3 或整章运行通过。
11.12 回顾与自测
把主线连读一次:NetworkRequest 携 Messenger/存活 Binder 到服务,Handler 按 NetworkAgent 与政策匹配,消息回到应用 callback;应用选定 Network,在同 netId 上 DNS 取得地址,创建 socket,经 dup/SCM_RIGHTS 让 netd 设置 mark;connect 形成 TCP 状态,write 经 JNI/系统调用进入 TCP,按选路与过滤进入设备/虚拟后端;响应经 RX/TCP 接收队列唤醒等待者,recv 的字节回到 Java 数组;close socket 和注销请求分别结束两类资源。
自测一:onAvailable 能否立即证明 HTTP 可达?不能。它是网络匹配通知,VALIDATED、UID 阻塞、DNS、TCP、HTTP 各有单独结果,见 11.2~11.5。
自测二:为什么 DNS 与 socket 都指定同一个 Network?避免分视 DNS 和出口不一致;Network 仍可能丢失,指定并不保证永远可达,见 11.5~11.6。
自测三:fwmarkd 收到 fd=57 后是否操作自己的 57?SCM_RIGHTS 创建接收进程的 fd 引用,数值可以不同,内核 socket 相同;用完接收 dup 要关闭,见 11.6。
自测四:write 完成、TX used、TCP ACK、RESPONSE 各说明什么?分别是本地写接受/循环完成、设备描述符消费、传输确认、应用读到响应。只有最后还要按业务协议判断,见 11.7~11.8。
自测五:网络切换怎样证明自动迁移?不能用一条新请求成功来证明。记录旧绑定网络/旧连接与新网络/新建连接分别的结果,见 11.9。
自测六:CONFIG_VIRTIO_NET 未设置但模块已加载矛盾吗?未必,模块可由另一配置单独构建。仍需模块来源/产物/绑定证据,见 11.7。
| 需要查的问题 | 固定源码入口 |
|---|---|
| 应用注册/消息查表 | ConnectivityManager.requestNetwork/sendRequestForNetwork/CallbackHandler |
| 匹配/回调/死亡 | ConnectivityService、NetworkRanker、NetworkAgentInfo |
| 网络作用域 DNS/绑定工厂 | Network.getAllByName/NetworkBoundSocketFactory/bindSocket |
| Java 到 Native 与数据返回 | Inet6AddressImpl、libcore_io_Linux、PlainSocketImpl、Socket*Stream |
| DNS 本地协议 | Bionic getaddrinfo.c、DnsProxyListener、DnsResolverService |
| 标记、内核配置 | NetdClient、FwmarkClient/Server、RouteController |
| TCP/设备双向 | Kernel socket.c、tcp*.c、ip*.c、dev.c、virtio_net.c |
| Host 可读分支 | QEMU virtio-net.c、net.c、slirp.c |
附录一:示例的完整实现
本附录给出 11.2 日志和 11.9 收尾行为对应的完整实现。正文已讲清创建、选网、工作线程与成功判据;本节保留构建所需的完整文件及异常、取消分支,与示例目录的源文件逐字符同步。这些是示例代码,不是运行日志。
package com.example.connectivityprobe;
import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.util.Log;
import android.widget.TextView;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.atomic.AtomicBoolean;
public final class ProbeActivity extends Activity {
private Session session;
@Override public void onCreate(Bundle state) {
super.onCreate(state);
TextView text = new TextView(this);
text.setText("ConnectivityProbe:保持前台,查看 ConnectivityProbe 日志。每次进入前台只提交一次网络任务,失败时可能尝试下一个地址。");
setContentView(text);
}
@Override public void onStart() {
super.onStart();
session = new Session(getSystemService(ConnectivityManager.class));
session.start();
}
@Override public void onStop() {
if (session != null) { session.close(); session = null; }
super.onStop();
}
private static final class Session {
private final ConnectivityManager cm;
private final HandlerThread callbacks = new HandlerThread("probe-callback");
private final ExecutorService io = Executors.newSingleThreadExecutor(
r -> new Thread(r, "probe-io"));
private final AtomicBoolean started = new AtomicBoolean();
private final Object socketLock = new Object();
private volatile boolean stopped;
private boolean registered;
private Socket activeSocket;
private volatile Network selected;
private final long run = android.os.SystemClock.elapsedRealtimeNanos();
Session(ConnectivityManager manager) { cm = manager; }
private void event(String stage, String detail) {
Log.i("ConnectivityProbe", "run=" + run + " stage=" + stage
+ " thread=" + Thread.currentThread().getName() + " " + detail);
}
private final ConnectivityManager.NetworkCallback callback =
new ConnectivityManager.NetworkCallback() {
@Override public void onAvailable(Network network) {
event("AVAILABLE", "network=" + network);
}
@Override public void onCapabilitiesChanged(Network network,
NetworkCapabilities caps) {
event("CAPS", "network=" + network + " validated="
+ caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED));
if (!stopped
&& caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
&& caps.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)
&& started.compareAndSet(false, true)) {
selected = network;
// Serialize submit with close(), so shutdown cannot race with execute().
synchronized (socketLock) {
if (!stopped) io.execute(() -> probe(network));
}
}
}
@Override public void onBlockedStatusChanged(Network network, boolean blocked) {
event("BLOCKED", "network=" + network + " blocked=" + blocked);
}
@Override public void onLost(Network network) {
event("LOST", "network=" + network);
if (network.equals(selected)) closeSocket();
}
@Override public void onUnavailable() {
event("UNAVAILABLE", "network request unavailable; framework released request");
// The framework has released this request. close() still handles other resources.
}
};
void start() {
callbacks.start();
NetworkRequest request = new NetworkRequest.Builder()
.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET).build();
try {
cm.requestNetwork(request, callback, new Handler(callbacks.getLooper()), 10000);
registered = true;
event("REGISTERED", "timeoutMs=10000");
} catch (RuntimeException error) {
event("REGISTER_FAIL", error.toString());
close();
}
}
private boolean publish(Socket socket) {
synchronized (socketLock) {
if (stopped) return false;
activeSocket = socket;
return true;
}
}
private void forget(Socket socket) {
synchronized (socketLock) {
if (activeSocket == socket) activeSocket = null;
}
}
private void closeSocket() {
synchronized (socketLock) {
if (activeSocket != null) {
try { activeSocket.close(); } catch (IOException ignored) { }
activeSocket = null;
}
}
}
private void probe(Network network) {
final String host = "example.com";
String stage = "DNS";
event("DNS_BEGIN", "network=" + network + " host=" + host);
try {
InetAddress[] addresses = network.getAllByName(host);
event("DNS_END", "addresses=" + java.util.Arrays.toString(addresses));
IOException last = null;
for (InetAddress address : addresses) {
if (stopped) { event("CANCEL", "before connect"); return; }
stage = "CREATE_BIND";
try (Socket socket = network.getSocketFactory().createSocket()) {
if (!publish(socket)) { event("CANCEL", "before publish"); return; }
try {
stage = "CONNECT";
event("CONNECT_BEGIN", "remote=" + address.getHostAddress() + ":80");
socket.connect(new InetSocketAddress(address, 80), 4000);
socket.setSoTimeout(4000);
event("CONNECTED", "local=" + socket.getLocalSocketAddress()
+ " remote=" + socket.getRemoteSocketAddress());
byte[] request = ("GET / HTTP/1.0\r\nHost: " + host
+ "\r\nConnection: close\r\n\r\n")
.getBytes(StandardCharsets.US_ASCII);
stage = "WRITE";
socket.getOutputStream().write(request);
event("WRITE_RETURN", "bytes=" + request.length);
stage = "READ";
ByteArrayOutputStream response = new ByteArrayOutputStream();
byte[] buffer = new byte[2048];
long deadline = android.os.SystemClock.elapsedRealtime() + 15000;
boolean eof = false;
while (response.size() < 65536 && !stopped) {
if (android.os.SystemClock.elapsedRealtime() >= deadline)
throw new IOException("response deadline exceeded");
int count = socket.getInputStream().read(buffer, 0,
Math.min(buffer.length, 65536 - response.size()));
if (count < 0) { eof = true; break; }
response.write(buffer, 0, count);
}
if (stopped) { event("CANCEL", "during read"); return; }
String text = new String(response.toByteArray(), StandardCharsets.ISO_8859_1);
int newline = text.indexOf('\n');
String first = newline < 0 ? text : text.substring(0, newline).trim();
event("RESPONSE", "bytes=" + response.size() + " eof=" + eof
+ " first=" + first);
event("DONE", "httpStatusLine=" + first.startsWith("HTTP/"));
return;
} finally { forget(socket); }
} catch (IOException error) {
last = error;
event(stopped ? "CANCEL" : "ATTEMPT_FAIL", "stage=" + stage
+ " address=" + address.getHostAddress() + " error=" + error);
if (stopped) return;
}
}
event("FAIL", "all addresses failed; last=" + last);
} catch (Exception error) {
event(stopped ? "CANCEL" : "FAIL", "stage=" + stage + " error=" + error);
} finally {
closeSocket();
event("IO_END", "socket closed; request stays until onStop");
}
}
void close() {
synchronized (socketLock) {
if (stopped) return;
stopped = true;
closeSocket();
io.shutdownNow();
}
if (registered) {
try { cm.unregisterNetworkCallback(callback); }
catch (IllegalArgumentException error) { event("UNREGISTER", error.toString()); }
registered = false;
}
callbacks.quitSafely();
event("STOP", "cancel requested; DNS may still finish later");
}
}
}
Manifest 声明三项网络权限,并保留明文流量配置。本例直接使用 Java Socket,明文发送不由此配置控制。
<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.example.connectivityprobe">
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
<application android:label="ConnectivityProbe" android:usesCleartextTraffic="true">
<activity android:name=".ProbeActivity" android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Android.bp 将该文件声明为一个独立普通应用:
android_app {
name: "ConnectivityProbe",
srcs: ["ProbeActivity.java"],
manifest: "AndroidManifest.xml",
sdk_version: "current",
min_sdk_version: "26",
target_sdk_version: "35",
}