Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5cf5b309 authored by Chalard Jean's avatar Chalard Jean Committed by Gerrit Code Review
Browse files

Merge changes I0613c23f,Ibeab8d0a,I8bd668ad,I7d3a16be 

* changes:
  [NS A14] Move code notifying battery stats in its right place
  [NS A13] Move legacy broadcast handling after rematch.
  [NS A12] Move some legacy type tracker handling to a function
  Add tests for ConnectivityService → BatteryStats messages
parents 89deaefd bbaa33e1

services/core/java/com/android/server/ConnectivityService.java

+61 −61
Original line number Diff line number Diff line
@@ -925,6 +925,10 @@ public class ConnectivityService extends IConnectivityManager.Stub 
            return IIpConnectivityMetrics.Stub.asInterface(

                    ServiceManager.getService(IpConnectivityLog.SERVICE_NAME));

        }



        public IBatteryStats getBatteryStatsService() {

            return BatteryStatsService.getService();

        }

    }



    public ConnectivityService(Context context, INetworkManagementService netManager,
@@ -2144,7 +2148,7 @@ public class ConnectivityService extends IConnectivityManager.Stub 
                    opts.setMaxManifestReceiverApiLevel(Build.VERSION_CODES.M);

                    options = opts.toBundle();

                }

                final IBatteryStats bs = BatteryStatsService.getService();

                final IBatteryStats bs = mDeps.getBatteryStatsService();

                try {

                    bs.noteConnectivityChanged(intent.getIntExtra(

                            ConnectivityManager.EXTRA_NETWORK_TYPE, ConnectivityManager.TYPE_NONE),
@@ -5628,7 +5632,8 @@ public class ConnectivityService extends IConnectivityManager.Stub 
        // are accurate.

        networkAgent.clatd.fixupLinkProperties(oldLp, newLp);



        updateInterfaces(newLp, oldLp, netId, networkAgent.networkCapabilities);

        updateInterfaces(newLp, oldLp, netId, networkAgent.networkCapabilities,

                networkAgent.networkInfo.getType());



        // update filtering rules, need to happen after the interface update so netd knows about the

        // new interface (the interface name -> index map becomes initialized)
@@ -5707,21 +5712,26 @@ public class ConnectivityService extends IConnectivityManager.Stub 


    }



    private void updateInterfaces(LinkProperties newLp, LinkProperties oldLp, int netId,

                                  NetworkCapabilities caps) {

        CompareResult<String> interfaceDiff = new CompareResult<>(

    private void updateInterfaces(final @Nullable LinkProperties newLp,

            final @Nullable LinkProperties oldLp, final int netId,

            final @Nullable NetworkCapabilities caps, final int legacyType) {

        final CompareResult<String> interfaceDiff = new CompareResult<>(

                oldLp != null ? oldLp.getAllInterfaceNames() : null,

                newLp != null ? newLp.getAllInterfaceNames() : null);

        for (String iface : interfaceDiff.added) {

        if (!interfaceDiff.added.isEmpty()) {

            final IBatteryStats bs = mDeps.getBatteryStatsService();

            for (final String iface : interfaceDiff.added) {

                try {

                    if (DBG) log("Adding iface " + iface + " to network " + netId);

                    mNMS.addInterfaceToNetwork(iface, netId);

                    wakeupModifyInterface(iface, caps, true);

                    bs.noteNetworkInterfaceType(iface, legacyType);

                } catch (Exception e) {

                    loge("Exception adding interface: " + e);

                }

            }

        for (String iface : interfaceDiff.removed) {

        }

        for (final String iface : interfaceDiff.removed) {

            try {

                if (DBG) log("Removing iface " + iface + " from network " + netId);

                wakeupModifyInterface(iface, caps, false);
@@ -6480,54 +6490,6 @@ public class ConnectivityService extends IConnectivityManager.Stub 
            mLegacyTypeTracker.add(newNetwork.networkInfo.getType(), newNetwork);

            notifyLockdownVpn(newNetwork);

        }



        if (reassignedRequests.containsValue(newNetwork) || newNetwork.isVPN()) {

            // Notify battery stats service about this network, both the normal

            // interface and any stacked links.

            // TODO: Avoid redoing this; this must only be done once when a network comes online.

            try {

                final IBatteryStats bs = BatteryStatsService.getService();

                final int type = newNetwork.networkInfo.getType();



                final String baseIface = newNetwork.linkProperties.getInterfaceName();

                bs.noteNetworkInterfaceType(baseIface, type);

                for (LinkProperties stacked : newNetwork.linkProperties.getStackedLinks()) {

                    final String stackedIface = stacked.getInterfaceName();

                    bs.noteNetworkInterfaceType(stackedIface, type);

                }

            } catch (RemoteException ignored) {

            }



            // This has to happen after the notifyNetworkCallbacks as that tickles each

            // ConnectivityManager instance so that legacy requests correctly bind dns

            // requests to this network.  The legacy users are listening for this broadcast

            // and will generally do a dns request so they can ensureRouteToHost and if

            // they do that before the callbacks happen they'll use the default network.

            //

            // TODO: Is there still a race here? We send the broadcast

            // after sending the callback, but if the app can receive the

            // broadcast before the callback, it might still break.

            //

            // This *does* introduce a race where if the user uses the new api

            // (notification callbacks) and then uses the old api (getNetworkInfo(type))

            // they may get old info.  Reverse this after the old startUsing api is removed.

            // This is on top of the multiple intent sequencing referenced in the todo above.

            for (int i = 0; i < newNetwork.numNetworkRequests(); i++) {

                NetworkRequest nr = newNetwork.requestAt(i);

                if (nr.legacyType != TYPE_NONE && nr.isRequest()) {

                    // legacy type tracker filters out repeat adds

                    mLegacyTypeTracker.add(nr.legacyType, newNetwork);

                }

            }



            // A VPN generally won't get added to the legacy tracker in the "for (nri)" loop above,

            // because usually there are no NetworkRequests it satisfies (e.g., mDefaultRequest

            // wants the NOT_VPN capability, so it will never be satisfied by a VPN). So, add the

            // newNetwork to the tracker explicitly (it's a no-op if it has already been added).

            if (newNetwork.isVPN()) {

                mLegacyTypeTracker.add(TYPE_VPN, newNetwork);

            }

        }

    }



    /**
@@ -6550,6 +6512,26 @@ public class ConnectivityService extends IConnectivityManager.Stub 
        for (NetworkAgentInfo nai : nais) {

            rematchNetworkAndRequests(nai, now);

        }



        // Now that all the callbacks have been sent, send the legacy network broadcasts

        // as needed. This is necessary so that legacy requests correctly bind dns

        // requests to this network. The legacy users are listening for this broadcast

        // and will generally do a dns request so they can ensureRouteToHost and if

        // they do that before the callbacks happen they'll use the default network.

        //

        // TODO: Is there still a race here? The legacy broadcast will be sent after sending

        // callbacks, but if apps can receive the broadcast before the callback, they still might

        // have an inconsistent view of networking.

        //

        // This *does* introduce a race where if the user uses the new api

        // (notification callbacks) and then uses the old api (getNetworkInfo(type))

        // they may get old info. Reverse this after the old startUsing api is removed.

        // This is on top of the multiple intent sequencing referenced in the todo above.

        for (NetworkAgentInfo nai : nais) {

            addNetworkToLegacyTypeTracker(nai);

        }



        // Tear down all unneeded networks.

        for (NetworkAgentInfo nai : mNetworkAgentInfos.values()) {

            if (unneeded(nai, UnneededFor.TEARDOWN)) {

                if (nai.getLingerExpiry() > 0) {
@@ -6569,6 +6551,24 @@ public class ConnectivityService extends IConnectivityManager.Stub 
        }

    }



    private void addNetworkToLegacyTypeTracker(@NonNull final NetworkAgentInfo nai) {

        for (int i = 0; i < nai.numNetworkRequests(); i++) {

            NetworkRequest nr = nai.requestAt(i);

            if (nr.legacyType != TYPE_NONE && nr.isRequest()) {

                // legacy type tracker filters out repeat adds

                mLegacyTypeTracker.add(nr.legacyType, nai);

            }

        }



        // A VPN generally won't get added to the legacy tracker in the "for (nri)" loop above,

        // because usually there are no NetworkRequests it satisfies (e.g., mDefaultRequest

        // wants the NOT_VPN capability, so it will never be satisfied by a VPN). So, add the

        // newNetwork to the tracker explicitly (it's a no-op if it has already been added).

        if (nai.isVPN()) {

            mLegacyTypeTracker.add(TYPE_VPN, nai);

        }

    }



    private void updateInetCondition(NetworkAgentInfo nai) {

        // Don't bother updating until we've graduated to validated at least once.

        if (!nai.everValidated) return;

tests/net/java/com/android/server/ConnectivityServiceTest.java

+50 −3
Original line number Diff line number Diff line
@@ -96,6 +96,7 @@ import static org.junit.Assert.fail; 
import static org.mockito.ArgumentMatchers.anyLong;

import static org.mockito.ArgumentMatchers.anyString;

import static org.mockito.ArgumentMatchers.eq;

import static org.mockito.ArgumentMatchers.startsWith;

import static org.mockito.Matchers.anyInt;

import static org.mockito.Mockito.any;

import static org.mockito.Mockito.atLeastOnce;
@@ -198,6 +199,7 @@ import androidx.test.filters.FlakyTest; 
import androidx.test.filters.SmallTest;

import androidx.test.runner.AndroidJUnit4;



import com.android.internal.app.IBatteryStats;

import com.android.internal.net.VpnConfig;

import com.android.internal.net.VpnInfo;

import com.android.internal.util.ArrayUtils;
@@ -305,6 +307,7 @@ public class ConnectivityServiceTest { 
    @Mock DefaultNetworkMetrics mDefaultNetworkMetrics;

    @Mock INetworkManagementService mNetworkManagementService;

    @Mock INetworkStatsService mStatsService;

    @Mock IBatteryStats mBatteryStatsService;

    @Mock INetworkPolicyManager mNpm;

    @Mock IDnsResolver mMockDnsResolver;

    @Mock INetd mMockNetd;
@@ -1135,6 +1138,7 @@ public class ConnectivityServiceTest { 
        doReturn(mMetricsService).when(deps).getMetricsLogger();

        doReturn(true).when(deps).queryUserAccess(anyInt(), anyInt());

        doReturn(mIpConnectivityMetrics).when(deps).getIpConnectivityMetrics();

        doReturn(mBatteryStatsService).when(deps).getBatteryStatsService();

        doReturn(true).when(deps).hasService(Context.ETHERNET_SERVICE);

        doAnswer(inv -> {

            mPolicyTracker = new WrappedMultinetworkPolicyTracker(
@@ -5640,6 +5644,36 @@ public class ConnectivityServiceTest { 
        mCm.unregisterNetworkCallback(defaultCallback);

    }



    @Test

    public final void testBatteryStatsNetworkType() throws Exception {

        final LinkProperties cellLp = new LinkProperties();

        cellLp.setInterfaceName("cell0");

        mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);

        mCellNetworkAgent.connect(true);

        waitForIdle();

        verify(mBatteryStatsService).noteNetworkInterfaceType(cellLp.getInterfaceName(),

                TYPE_MOBILE);

        reset(mBatteryStatsService);



        final LinkProperties wifiLp = new LinkProperties();

        wifiLp.setInterfaceName("wifi0");

        mWiFiNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_WIFI, wifiLp);

        mWiFiNetworkAgent.connect(true);

        waitForIdle();

        verify(mBatteryStatsService).noteNetworkInterfaceType(wifiLp.getInterfaceName(),

                TYPE_WIFI);

        reset(mBatteryStatsService);



        mCellNetworkAgent.disconnect();



        cellLp.setInterfaceName("wifi0");

        mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);

        mCellNetworkAgent.connect(true);

        waitForIdle();

        verify(mBatteryStatsService).noteNetworkInterfaceType(cellLp.getInterfaceName(),

                TYPE_MOBILE);

    }



    /**

     * Make simulated InterfaceConfig for Nat464Xlat to query clat lower layer info.

     */
@@ -5680,25 +5714,28 @@ public class ConnectivityServiceTest { 
        mCm.registerNetworkCallback(networkRequest, networkCallback);



        // Prepare ipv6 only link properties.

        mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR);

        final int cellNetId = mCellNetworkAgent.getNetwork().netId;

        final LinkProperties cellLp = new LinkProperties();

        cellLp.setInterfaceName(MOBILE_IFNAME);

        cellLp.addLinkAddress(myIpv6);

        cellLp.addRoute(new RouteInfo((IpPrefix) null, myIpv6.getAddress(), MOBILE_IFNAME));

        cellLp.addRoute(new RouteInfo(myIpv6, null, MOBILE_IFNAME));

        mCellNetworkAgent = new TestNetworkAgentWrapper(TRANSPORT_CELLULAR, cellLp);

        reset(mNetworkManagementService);

        reset(mMockDnsResolver);

        reset(mMockNetd);

        reset(mBatteryStatsService);

        when(mNetworkManagementService.getInterfaceConfig(CLAT_PREFIX + MOBILE_IFNAME))

                .thenReturn(getClatInterfaceConfig(myIpv4));



        // Connect with ipv6 link properties. Expect prefix discovery to be started.

        mCellNetworkAgent.sendLinkProperties(cellLp);

        mCellNetworkAgent.connect(true);

        final int cellNetId = mCellNetworkAgent.getNetwork().netId;

        waitForIdle();



        verify(mMockNetd, times(1)).networkCreatePhysical(eq(cellNetId), anyInt());

        verify(mMockDnsResolver, times(1)).createNetworkCache(eq(cellNetId));

        verify(mBatteryStatsService).noteNetworkInterfaceType(cellLp.getInterfaceName(),

                TYPE_MOBILE);



        networkCallback.expectAvailableThenValidatedCallbacks(mCellNetworkAgent);

        verify(mMockDnsResolver, times(1)).startPrefix64Discovery(cellNetId);
@@ -5714,6 +5751,11 @@ public class ConnectivityServiceTest { 
        verify(mMockDnsResolver, times(1)).stopPrefix64Discovery(cellNetId);

        verify(mMockDnsResolver, atLeastOnce()).setResolverConfiguration(any());



        // Make sure BatteryStats was not told about any v4- interfaces, as none should have

        // come online yet.

        waitForIdle();

        verify(mBatteryStatsService, never()).noteNetworkInterfaceType(startsWith("v4-"), anyInt());



        verifyNoMoreInteractions(mMockNetd);

        verifyNoMoreInteractions(mMockDnsResolver);

        reset(mMockNetd);
@@ -5760,6 +5802,11 @@ public class ConnectivityServiceTest { 
        assertEquals(1, resolvrParams.servers.length);

        assertTrue(ArrayUtils.contains(resolvrParams.servers, "8.8.8.8"));



        for (final LinkProperties stackedLp : stackedLpsAfterChange) {

            verify(mBatteryStatsService).noteNetworkInterfaceType(stackedLp.getInterfaceName(),

                    TYPE_MOBILE);

        }



        // Add ipv4 address, expect that clatd and prefix discovery are stopped and stacked

        // linkproperties are cleaned up.

        cellLp.addLinkAddress(myIpv4);