1/*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package com.android.server;
18
19import static android.net.ConnectivityManager.CONNECTIVITY_ACTION_IMMEDIATE;
20import static android.net.ConnectivityManager.TYPE_MOBILE;
21import static android.net.ConnectivityManager.TYPE_WIFI;
22import static android.net.ConnectivityManager.getNetworkTypeName;
23import static android.net.NetworkStateTracker.EVENT_STATE_CHANGED;
24import static org.mockito.Matchers.anyInt;
25import static org.mockito.Matchers.eq;
26import static org.mockito.Matchers.isA;
27import static org.mockito.Mockito.doNothing;
28import static org.mockito.Mockito.doReturn;
29import static org.mockito.Mockito.doThrow;
30import static org.mockito.Mockito.mock;
31import static org.mockito.Mockito.reset;
32import static org.mockito.Mockito.verify;
33
34import android.content.Context;
35import android.net.INetworkPolicyManager;
36import android.net.INetworkStatsService;
37import android.net.LinkProperties;
38import android.net.NetworkConfig;
39import android.net.NetworkInfo;
40import android.net.NetworkInfo.DetailedState;
41import android.net.NetworkStateTracker;
42import android.net.RouteInfo;
43import android.os.Handler;
44import android.os.INetworkManagementService;
45import android.test.AndroidTestCase;
46import android.test.suitebuilder.annotation.LargeTest;
47import android.util.Log;
48import android.util.LogPrinter;
49
50import org.mockito.ArgumentCaptor;
51
52import java.net.InetAddress;
53import java.util.concurrent.Future;
54
55/**
56 * Tests for {@link ConnectivityService}.
57 */
58@LargeTest
59public class ConnectivityServiceTest extends AndroidTestCase {
60    private static final String TAG = "ConnectivityServiceTest";
61
62    private static final String MOBILE_IFACE = "rmnet3";
63    private static final String WIFI_IFACE = "wlan6";
64
65    private static final RouteInfo MOBILE_ROUTE_V4 = RouteInfo.makeHostRoute(parse("10.0.0.33"),
66                                                                             MOBILE_IFACE);
67    private static final RouteInfo MOBILE_ROUTE_V6 = RouteInfo.makeHostRoute(parse("fd00::33"),
68                                                                             MOBILE_IFACE);
69
70    private static final RouteInfo WIFI_ROUTE_V4 = RouteInfo.makeHostRoute(parse("192.168.0.66"),
71                                                                           parse("192.168.0.1"),
72                                                                           WIFI_IFACE);
73    private static final RouteInfo WIFI_ROUTE_V6 = RouteInfo.makeHostRoute(parse("fd00::66"),
74                                                                           parse("fd00::"),
75                                                                           WIFI_IFACE);
76
77    private INetworkManagementService mNetManager;
78    private INetworkStatsService mStatsService;
79    private INetworkPolicyManager mPolicyService;
80    private ConnectivityService.NetworkFactory mNetFactory;
81
82    private BroadcastInterceptingContext mServiceContext;
83    private ConnectivityService mService;
84
85    private MockNetwork mMobile;
86    private MockNetwork mWifi;
87
88    private Handler mTrackerHandler;
89
90    private static class MockNetwork {
91        public NetworkStateTracker tracker;
92        public NetworkInfo info;
93        public LinkProperties link;
94
95        public MockNetwork(int type) {
96            tracker = mock(NetworkStateTracker.class);
97            info = new NetworkInfo(type, -1, getNetworkTypeName(type), null);
98            link = new LinkProperties();
99        }
100
101        public void doReturnDefaults() {
102            // TODO: eventually CS should make defensive copies
103            doReturn(new NetworkInfo(info)).when(tracker).getNetworkInfo();
104            doReturn(new LinkProperties(link)).when(tracker).getLinkProperties();
105
106            // fallback to default TCP buffers
107            doReturn("").when(tracker).getTcpBufferSizesPropName();
108        }
109    }
110
111    @Override
112    public void setUp() throws Exception {
113        super.setUp();
114
115        mServiceContext = new BroadcastInterceptingContext(getContext());
116
117        mNetManager = mock(INetworkManagementService.class);
118        mStatsService = mock(INetworkStatsService.class);
119        mPolicyService = mock(INetworkPolicyManager.class);
120        mNetFactory = mock(ConnectivityService.NetworkFactory.class);
121
122        mMobile = new MockNetwork(TYPE_MOBILE);
123        mWifi = new MockNetwork(TYPE_WIFI);
124
125        // omit most network trackers
126        doThrow(new IllegalArgumentException("Not supported in test environment"))
127                .when(mNetFactory).createTracker(anyInt(), isA(NetworkConfig.class));
128
129        doReturn(mMobile.tracker)
130                .when(mNetFactory).createTracker(eq(TYPE_MOBILE), isA(NetworkConfig.class));
131        doReturn(mWifi.tracker)
132                .when(mNetFactory).createTracker(eq(TYPE_WIFI), isA(NetworkConfig.class));
133
134        final ArgumentCaptor<Handler> trackerHandler = ArgumentCaptor.forClass(Handler.class);
135        doNothing().when(mMobile.tracker)
136                .startMonitoring(isA(Context.class), trackerHandler.capture());
137
138        mService = new ConnectivityService(
139                mServiceContext, mNetManager, mStatsService, mPolicyService, mNetFactory);
140        mService.systemReady();
141
142        mTrackerHandler = trackerHandler.getValue();
143        mTrackerHandler.getLooper().setMessageLogging(new LogPrinter(Log.INFO, TAG));
144    }
145
146    @Override
147    public void tearDown() throws Exception {
148        super.tearDown();
149    }
150
151    public void testMobileConnectedAddedRoutes() throws Exception {
152        Future<?> nextConnBroadcast;
153
154        // bring up mobile network
155        mMobile.info.setDetailedState(DetailedState.CONNECTED, null, null);
156        mMobile.link.setInterfaceName(MOBILE_IFACE);
157        mMobile.link.addRoute(MOBILE_ROUTE_V4);
158        mMobile.link.addRoute(MOBILE_ROUTE_V6);
159        mMobile.doReturnDefaults();
160
161        nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
162        mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
163        nextConnBroadcast.get();
164
165        // verify that both routes were added and DNS was flushed
166        verify(mNetManager).addRoute(eq(MOBILE_IFACE), eq(MOBILE_ROUTE_V4));
167        verify(mNetManager).addRoute(eq(MOBILE_IFACE), eq(MOBILE_ROUTE_V6));
168        verify(mNetManager).flushInterfaceDnsCache(MOBILE_IFACE);
169
170    }
171
172    public void testMobileWifiHandoff() throws Exception {
173        Future<?> nextConnBroadcast;
174
175        // bring up mobile network
176        mMobile.info.setDetailedState(DetailedState.CONNECTED, null, null);
177        mMobile.link.setInterfaceName(MOBILE_IFACE);
178        mMobile.link.addRoute(MOBILE_ROUTE_V4);
179        mMobile.link.addRoute(MOBILE_ROUTE_V6);
180        mMobile.doReturnDefaults();
181
182        nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
183        mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
184        nextConnBroadcast.get();
185
186        reset(mNetManager);
187
188        // now bring up wifi network
189        mWifi.info.setDetailedState(DetailedState.CONNECTED, null, null);
190        mWifi.link.setInterfaceName(WIFI_IFACE);
191        mWifi.link.addRoute(WIFI_ROUTE_V4);
192        mWifi.link.addRoute(WIFI_ROUTE_V6);
193        mWifi.doReturnDefaults();
194
195        // expect that mobile will be torn down
196        doReturn(true).when(mMobile.tracker).teardown();
197
198        nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
199        mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mWifi.info).sendToTarget();
200        nextConnBroadcast.get();
201
202        // verify that wifi routes added, and teardown requested
203        verify(mNetManager).addRoute(eq(WIFI_IFACE), eq(WIFI_ROUTE_V4));
204        verify(mNetManager).addRoute(eq(WIFI_IFACE), eq(WIFI_ROUTE_V6));
205        verify(mNetManager).flushInterfaceDnsCache(WIFI_IFACE);
206        verify(mMobile.tracker).teardown();
207
208        reset(mNetManager, mMobile.tracker);
209
210        // tear down mobile network, as requested
211        mMobile.info.setDetailedState(DetailedState.DISCONNECTED, null, null);
212        mMobile.link.clear();
213        mMobile.doReturnDefaults();
214
215        nextConnBroadcast = mServiceContext.nextBroadcastIntent(CONNECTIVITY_ACTION_IMMEDIATE);
216        mTrackerHandler.obtainMessage(EVENT_STATE_CHANGED, mMobile.info).sendToTarget();
217        nextConnBroadcast.get();
218
219        verify(mNetManager).removeRoute(eq(MOBILE_IFACE), eq(MOBILE_ROUTE_V4));
220        verify(mNetManager).removeRoute(eq(MOBILE_IFACE), eq(MOBILE_ROUTE_V6));
221
222    }
223
224    private static InetAddress parse(String addr) {
225        return InetAddress.parseNumericAddress(addr);
226    }
227}
228