Android源码第十一章:ConnectivityService 与网络通信——一次请求怎样往返

7 阅读1小时+

手机明明显示已联网,应用为什么还会解析域名失败?一段 HTTP 请求已经写进 Socket,为什么还可能读不到响应?把同一轮日志中的网络回调、DNS、连接和读写分开看,就能知道请求停在哪一步。

本例先向 ConnectivityService 登记网络需求,再用回调交付的 Network 解析域名、连接服务器。ConnectivityService 负责匹配网络和通知状态。应用写进 Socket 的业务字节经系统调用交给 Linux 内核。 如果日志已有 AVAILABLE,却在 DNS 阶段失败,先查所选网络的解析。如果已有 WRITE_RETURN,就沿同一个连接查响应有没有读回来。11.11 汇总了各阶段的判断依据。

手机显示联网,应用在等待请求结果

11.1 分清控制与数据

网络控制、配置和数据收发

先沿整体架构图的蓝线看网络怎样交给应用,再沿绿线看业务字节怎样进出内核。紫线标出系统设置路由和 DNS 的配置动作,橙线标出应用调用 DNS 和 fwmark 的本地辅助协议。图中分层表示职责,进程和线程由框内标注。

整体架构:Android 分层中的网络控制、配置、DNS、选网与数据通路

应用发出的 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 调用也可能交错。

全章时序:应用三类线程、ConnectivityService、netd、Linux 和设备路径

图中展示一条连接成功的路径。关闭 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 / CAPSnetwork 与 validated,观察可用网络和验证状态目标域名或 TCP 必定成功
DNS_END同轮域名解析取得的地址列表一定发出了线上 DNS 包;缓存可命中
CONNECTEDlocal/remote 的实际端点,连接操作成功HTTP 服务已返回有效业务
WRITE_RETURN本轮请求长度写入返回对端应用已经读取,或读响应完成
RESPONSE字节数、eof 与 first 状态行只看到字节就等于完整页面或 200
DONEhttpStatusLine=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结果

动画只走 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 继续存在。

通过临时fd引用给同一socket设置网络N

这里演示应用有权使用 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 的最终结果

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=falseNetworkMonitor/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",
}

参考资料