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

Commit baacc6ce authored by Chalard Jean's avatar Chalard Jean
Browse files

Remove the old version of RouteUtils. 

Test: m
Change-Id: Iaee315d4e7bf8df2de09025ad39631fbe9175b7f
parent 25ee83bc

common/moduleutils/Android.bp

+0 −3
Original line number Diff line number Diff line
@@ -26,7 +26,6 @@ filegroup { 
    name: "net-module-utils-srcs",

    srcs: [

        "src/android/net/shared/NetdUtils.java",

        "src/android/net/shared/RouteUtils.java",

        "src/android/net/util/InterfaceParams.java",

        "src/android/net/util/SharedLog.java",

    ],
@@ -41,7 +40,6 @@ filegroup { 
        "src/android/net/util/SharedLog.java",

        "src/android/net/shared/NetdUtils.java",

        "src/android/net/shared/NetworkMonitorUtils.java",

        "src/android/net/shared/RouteUtils.java",

    ],

    visibility: [

        "//packages/modules/Connectivity/service",
@@ -65,7 +63,6 @@ filegroup { 
        "src/android/net/ip/IpNeighborMonitor.java",

        "src/android/net/ip/NetlinkMonitor.java",

        "src/android/net/shared/NetdUtils.java",

        "src/android/net/shared/RouteUtils.java",

        "src/android/net/util/InterfaceParams.java",

        "src/android/net/util/SharedLog.java",

    ],

common/moduleutils/src/android/net/shared/NetdUtils.java

+0 −23
Original line number Diff line number Diff line
@@ -16,21 +16,15 @@ 


package android.net.shared;



import static android.net.RouteInfo.RTN_UNICAST;

import static android.system.OsConstants.EBUSY;



import android.net.INetd;

import android.net.IpPrefix;

import android.net.RouteInfo;

import android.net.TetherConfigParcel;

import android.os.RemoteException;

import android.os.ServiceSpecificException;

import android.os.SystemClock;

import android.util.Log;



import java.util.ArrayList;

import java.util.List;



/**

 * Implements common operations on INetd

 * @hide
@@ -47,23 +41,6 @@ public class NetdUtils { 
        netd.tetherStartWithConfiguration(config);

    }



    /** Setup interface for tethering. */

    public static void tetherInterface(final INetd netd, final String iface, final IpPrefix dest)

            throws RemoteException, ServiceSpecificException {

        tetherInterface(netd, iface, dest, 20 /* maxAttempts */, 50 /* pollingIntervalMs */);

    }



    /** Setup interface with configurable retries for tethering. */

    public static void tetherInterface(final INetd netd, final String iface, final IpPrefix dest,

            int maxAttempts, int pollingIntervalMs)

            throws RemoteException, ServiceSpecificException {

        netd.tetherInterfaceAdd(iface);

        networkAddInterface(netd, iface, maxAttempts, pollingIntervalMs);

        List<RouteInfo> routes = new ArrayList<>();

        routes.add(new RouteInfo(dest, null, iface, RTN_UNICAST));

        RouteUtils.addRoutesToLocalNetwork(netd, iface, routes);

    }



    /**

     * Retry Netd#networkAddInterface for EBUSY error code.

     * If the same interface (e.g., wlan0) is in client mode and then switches to tethered mode.

common/moduleutils/src/android/net/shared/RouteUtils.java

deleted100644 → 0
+0 −115
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

package android.net.shared;



import static android.net.RouteInfo.RTN_THROW;

import static android.net.RouteInfo.RTN_UNICAST;

import static android.net.RouteInfo.RTN_UNREACHABLE;



import android.net.INetd;

import android.net.IpPrefix;

import android.net.RouteInfo;

import android.os.RemoteException;

import android.os.ServiceSpecificException;



import java.util.List;



/** @hide*/

public class RouteUtils {



    /** Used to modify the specified route. */

    public enum ModifyOperation {

        ADD,

        REMOVE,

    }



    private static String findNextHop(final RouteInfo route) {

        final String nextHop;

        switch (route.getType()) {

            case RTN_UNICAST:

                if (route.hasGateway()) {

                    nextHop = route.getGateway().getHostAddress();

                } else {

                    nextHop = INetd.NEXTHOP_NONE;

                }

                break;

            case RTN_UNREACHABLE:

                nextHop = INetd.NEXTHOP_UNREACHABLE;

                break;

            case RTN_THROW:

                nextHop = INetd.NEXTHOP_THROW;

                break;

            default:

                nextHop = INetd.NEXTHOP_NONE;

                break;

        }

        return nextHop;

    }



    /** Add |routes| to local network. */

    public static void addRoutesToLocalNetwork(final INetd netd, final String iface,

            final List<RouteInfo> routes) {



        for (RouteInfo route : routes) {

            if (!route.isDefaultRoute()) {

                modifyRoute(netd, ModifyOperation.ADD, INetd.LOCAL_NET_ID, route);

            }

        }



        // IPv6 link local should be activated always.

        modifyRoute(netd, ModifyOperation.ADD, INetd.LOCAL_NET_ID,

                new RouteInfo(new IpPrefix("fe80::/64"), null, iface, RTN_UNICAST));

    }



    /** Remove routes from local network. */

    public static int removeRoutesFromLocalNetwork(final INetd netd, final List<RouteInfo> routes) {

        int failures = 0;



        for (RouteInfo route : routes) {

            try {

                modifyRoute(netd, ModifyOperation.REMOVE, INetd.LOCAL_NET_ID, route);

            } catch (IllegalStateException e) {

                failures++;

            }

        }



        return failures;

    }



    /** Add or remove |route|. */

    public static void modifyRoute(final INetd netd, final ModifyOperation op, final int netId,

            final RouteInfo route) {

        final String ifName = route.getInterface();

        final String dst = route.getDestination().toString();

        final String nextHop = findNextHop(route);



        try {

            switch(op) {

                case ADD:

                    netd.networkAddRoute(netId, ifName, dst, nextHop);

                    break;

                case REMOVE:

                    netd.networkRemoveRoute(netId, ifName, dst, nextHop);

                    break;

                default:

                    throw new IllegalStateException("Unsupported modify operation:" + op);

            }

        } catch (RemoteException | ServiceSpecificException e) {

            throw new IllegalStateException(e);

        }

    }



}

tests/unit/src/android/net/shared/NetdUtilsTest.java

deleted100644 → 0
+0 −162
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package android.net.shared;



import static android.net.INetd.LOCAL_NET_ID;

import static android.system.OsConstants.EBUSY;



import static org.junit.Assert.assertEquals;

import static org.junit.Assert.fail;

import static org.mockito.Matchers.any;

import static org.mockito.Matchers.anyInt;

import static org.mockito.Matchers.anyString;

import static org.mockito.Matchers.eq;

import static org.mockito.Mockito.doAnswer;

import static org.mockito.Mockito.never;

import static org.mockito.Mockito.reset;

import static org.mockito.Mockito.times;

import static org.mockito.Mockito.verify;

import static org.mockito.Mockito.verifyNoMoreInteractions;



import android.net.INetd;

import android.net.IpPrefix;

import android.os.RemoteException;

import android.os.ServiceSpecificException;



import androidx.test.filters.SmallTest;

import androidx.test.runner.AndroidJUnit4;



import org.junit.Before;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.mockito.Mock;

import org.mockito.MockitoAnnotations;



@RunWith(AndroidJUnit4.class)

@SmallTest

public final class NetdUtilsTest {

    private static final String IFACE_NAME = "testnet1";

    private static final IpPrefix TEST_IPPREFIX = new IpPrefix("192.168.42.1/24");



    @Mock private INetd mNetd;



    @Before public void setUp() throws Exception {

        MockitoAnnotations.initMocks(this);

    }



    private void setNetworkAddInterfaceOutcome(final Exception cause, int numLoops)

            throws Exception {

        // This cannot be an int because local variables referenced from a lambda expression must

        // be final or effectively final.

        final Counter myCounter = new Counter();

        doAnswer((invocation) -> {

            myCounter.count();

            if (myCounter.isCounterReached(numLoops)) {

                if (cause == null) return null;



                throw cause;

            }



            throw new ServiceSpecificException(EBUSY);

        }).when(mNetd).networkAddInterface(LOCAL_NET_ID, IFACE_NAME);

    }



    class Counter {

        private int mValue = 0;



        private void count() {

            mValue++;

        }



        private boolean isCounterReached(int target) {

            return mValue >= target;

        }

    }



    private void verifyTetherInterfaceSucceeds(int expectedTries) throws Exception {

        setNetworkAddInterfaceOutcome(null, expectedTries);



        NetdUtils.tetherInterface(mNetd, IFACE_NAME, TEST_IPPREFIX);

        verify(mNetd).tetherInterfaceAdd(IFACE_NAME);

        verify(mNetd, times(expectedTries)).networkAddInterface(LOCAL_NET_ID, IFACE_NAME);

        verify(mNetd, times(2)).networkAddRoute(eq(LOCAL_NET_ID), eq(IFACE_NAME), any(), any());

        verifyNoMoreInteractions(mNetd);

        reset(mNetd);

    }



    @Test

    public void testTetherInterfaceSuccessful() throws Exception {

        // Expect #networkAddInterface successful at first tries.

        verifyTetherInterfaceSucceeds(1);



        // Expect #networkAddInterface successful after 10 tries.

        verifyTetherInterfaceSucceeds(10);

    }



    private void runTetherInterfaceWithServiceSpecificException(int expectedTries,

            int expectedCode) throws Exception {

        setNetworkAddInterfaceOutcome(new ServiceSpecificException(expectedCode), expectedTries);



        try {

            NetdUtils.tetherInterface(mNetd, IFACE_NAME, TEST_IPPREFIX, 20, 0);

            fail("Expect throw ServiceSpecificException");

        } catch (ServiceSpecificException e) {

            assertEquals(e.errorCode, expectedCode);

        }



        verifyNetworkAddInterfaceFails(expectedTries);

        reset(mNetd);

    }



    private void runTetherInterfaceWithRemoteException(int expectedTries) throws Exception {

        setNetworkAddInterfaceOutcome(new RemoteException(), expectedTries);



        try {

            NetdUtils.tetherInterface(mNetd, IFACE_NAME, TEST_IPPREFIX, 20, 0);

            fail("Expect throw RemoteException");

        } catch (RemoteException e) { }



        verifyNetworkAddInterfaceFails(expectedTries);

        reset(mNetd);

    }



    private void verifyNetworkAddInterfaceFails(int expectedTries) throws Exception {

        verify(mNetd).tetherInterfaceAdd(IFACE_NAME);

        verify(mNetd, times(expectedTries)).networkAddInterface(LOCAL_NET_ID, IFACE_NAME);

        verify(mNetd, never()).networkAddRoute(anyInt(), anyString(), any(), any());

        verifyNoMoreInteractions(mNetd);

    }



    @Test

    public void testTetherInterfaceFailOnNetworkAddInterface() throws Exception {

        // Test throwing ServiceSpecificException with EBUSY failure.

        runTetherInterfaceWithServiceSpecificException(20, EBUSY);



        // Test throwing ServiceSpecificException with unexpectedError.

        final int unexpectedError = 999;

        runTetherInterfaceWithServiceSpecificException(1, unexpectedError);



        // Test throwing ServiceSpecificException with unexpectedError after 7 tries.

        runTetherInterfaceWithServiceSpecificException(7, unexpectedError);



        // Test throwing RemoteException.

        runTetherInterfaceWithRemoteException(1);



        // Test throwing RemoteException after 3 tries.

        runTetherInterfaceWithRemoteException(3);

    }

}