1/*
2 * Copyright (C) 2010 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 android.net;
18
19import android.content.Context;
20import android.net.NetworkInfo.DetailedState;
21import android.os.Handler;
22import android.os.IBinder;
23import android.os.INetworkManagementService;
24import android.os.Message;
25import android.os.RemoteException;
26import android.os.ServiceManager;
27import android.util.Log;
28
29import java.util.concurrent.atomic.AtomicBoolean;
30import java.util.concurrent.atomic.AtomicInteger;
31
32/**
33 * This class tracks the data connection associated with Ethernet
34 * This is a singleton class and an instance will be created by
35 * ConnectivityService.
36 * @hide
37 */
38public class EthernetDataTracker implements NetworkStateTracker {
39    private static final String NETWORKTYPE = "ETHERNET";
40    private static final String TAG = "Ethernet";
41
42    private AtomicBoolean mTeardownRequested = new AtomicBoolean(false);
43    private AtomicBoolean mPrivateDnsRouteSet = new AtomicBoolean(false);
44    private AtomicInteger mDefaultGatewayAddr = new AtomicInteger(0);
45    private AtomicBoolean mDefaultRouteSet = new AtomicBoolean(false);
46
47    private static boolean mLinkUp;
48    private LinkProperties mLinkProperties;
49    private LinkCapabilities mLinkCapabilities;
50    private NetworkInfo mNetworkInfo;
51    private InterfaceObserver mInterfaceObserver;
52    private String mHwAddr;
53
54    /* For sending events to connectivity service handler */
55    private Handler mCsHandler;
56    private Context mContext;
57
58    private static EthernetDataTracker sInstance;
59    private static String sIfaceMatch = "";
60    private static String mIface = "";
61
62    private INetworkManagementService mNMService;
63
64    private static class InterfaceObserver extends INetworkManagementEventObserver.Stub {
65        private EthernetDataTracker mTracker;
66
67        InterfaceObserver(EthernetDataTracker tracker) {
68            super();
69            mTracker = tracker;
70        }
71
72        public void interfaceStatusChanged(String iface, boolean up) {
73            Log.d(TAG, "Interface status changed: " + iface + (up ? "up" : "down"));
74        }
75
76        public void interfaceLinkStateChanged(String iface, boolean up) {
77            if (mIface.equals(iface) && mLinkUp != up) {
78                Log.d(TAG, "Interface " + iface + " link " + (up ? "up" : "down"));
79                mLinkUp = up;
80                mTracker.mNetworkInfo.setIsAvailable(up);
81
82                // use DHCP
83                if (up) {
84                    mTracker.reconnect();
85                } else {
86                    mTracker.disconnect();
87                }
88            }
89        }
90
91        public void interfaceAdded(String iface) {
92            mTracker.interfaceAdded(iface);
93        }
94
95        public void interfaceRemoved(String iface) {
96            mTracker.interfaceRemoved(iface);
97        }
98
99        public void limitReached(String limitName, String iface) {
100            // Ignored.
101        }
102
103        public void interfaceClassDataActivityChanged(String label, boolean active) {
104            // Ignored.
105        }
106    }
107
108    private EthernetDataTracker() {
109        mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_ETHERNET, 0, NETWORKTYPE, "");
110        mLinkProperties = new LinkProperties();
111        mLinkCapabilities = new LinkCapabilities();
112    }
113
114    private void interfaceAdded(String iface) {
115        if (!iface.matches(sIfaceMatch))
116            return;
117
118        Log.d(TAG, "Adding " + iface);
119
120        synchronized(this) {
121            if(!mIface.isEmpty())
122                return;
123            mIface = iface;
124        }
125
126        // we don't get link status indications unless the iface is up - bring it up
127        try {
128            mNMService.setInterfaceUp(iface);
129        } catch (Exception e) {
130            Log.e(TAG, "Error upping interface " + iface + ": " + e);
131        }
132
133        mNetworkInfo.setIsAvailable(true);
134        Message msg = mCsHandler.obtainMessage(EVENT_CONFIGURATION_CHANGED, mNetworkInfo);
135        msg.sendToTarget();
136    }
137
138    public void disconnect() {
139
140        NetworkUtils.stopDhcp(mIface);
141
142        mLinkProperties.clear();
143        mNetworkInfo.setIsAvailable(false);
144        mNetworkInfo.setDetailedState(DetailedState.DISCONNECTED, null, mHwAddr);
145
146        Message msg = mCsHandler.obtainMessage(EVENT_CONFIGURATION_CHANGED, mNetworkInfo);
147        msg.sendToTarget();
148
149        msg = mCsHandler.obtainMessage(EVENT_STATE_CHANGED, mNetworkInfo);
150        msg.sendToTarget();
151
152        IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
153        INetworkManagementService service = INetworkManagementService.Stub.asInterface(b);
154        try {
155            service.clearInterfaceAddresses(mIface);
156        } catch (Exception e) {
157            Log.e(TAG, "Failed to clear addresses or disable ipv6" + e);
158        }
159    }
160
161    private void interfaceRemoved(String iface) {
162        if (!iface.equals(mIface))
163            return;
164
165        Log.d(TAG, "Removing " + iface);
166        disconnect();
167        mIface = "";
168    }
169
170    private void runDhcp() {
171        Thread dhcpThread = new Thread(new Runnable() {
172            public void run() {
173                DhcpInfoInternal dhcpInfoInternal = new DhcpInfoInternal();
174                if (!NetworkUtils.runDhcp(mIface, dhcpInfoInternal)) {
175                    Log.e(TAG, "DHCP request error:" + NetworkUtils.getDhcpError());
176                    return;
177                }
178                mLinkProperties = dhcpInfoInternal.makeLinkProperties();
179                mLinkProperties.setInterfaceName(mIface);
180
181                mNetworkInfo.setDetailedState(DetailedState.CONNECTED, null, mHwAddr);
182                Message msg = mCsHandler.obtainMessage(EVENT_STATE_CHANGED, mNetworkInfo);
183                msg.sendToTarget();
184            }
185        });
186        dhcpThread.start();
187    }
188
189    public static synchronized EthernetDataTracker getInstance() {
190        if (sInstance == null) sInstance = new EthernetDataTracker();
191        return sInstance;
192    }
193
194    public Object Clone() throws CloneNotSupportedException {
195        throw new CloneNotSupportedException();
196    }
197
198    public void setTeardownRequested(boolean isRequested) {
199        mTeardownRequested.set(isRequested);
200    }
201
202    public boolean isTeardownRequested() {
203        return mTeardownRequested.get();
204    }
205
206    /**
207     * Begin monitoring connectivity
208     */
209    public void startMonitoring(Context context, Handler target) {
210        mContext = context;
211        mCsHandler = target;
212
213        // register for notifications from NetworkManagement Service
214        IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
215        mNMService = INetworkManagementService.Stub.asInterface(b);
216
217        mInterfaceObserver = new InterfaceObserver(this);
218
219        // enable and try to connect to an ethernet interface that
220        // already exists
221        sIfaceMatch = context.getResources().getString(
222            com.android.internal.R.string.config_ethernet_iface_regex);
223        try {
224            final String[] ifaces = mNMService.listInterfaces();
225            for (String iface : ifaces) {
226                if (iface.matches(sIfaceMatch)) {
227                    mIface = iface;
228                    mNMService.setInterfaceUp(iface);
229                    InterfaceConfiguration config = mNMService.getInterfaceConfig(iface);
230                    mLinkUp = config.hasFlag("up");
231                    if (config != null && mHwAddr == null) {
232                        mHwAddr = config.getHardwareAddress();
233                        if (mHwAddr != null) {
234                            mNetworkInfo.setExtraInfo(mHwAddr);
235                        }
236                    }
237
238                    // if a DHCP client had previously been started for this interface, then stop it
239                    NetworkUtils.stopDhcp(mIface);
240
241                    reconnect();
242                    break;
243                }
244            }
245        } catch (RemoteException e) {
246            Log.e(TAG, "Could not get list of interfaces " + e);
247        }
248
249        try {
250            mNMService.registerObserver(mInterfaceObserver);
251        } catch (RemoteException e) {
252            Log.e(TAG, "Could not register InterfaceObserver " + e);
253        }
254    }
255
256    /**
257     * Disable connectivity to a network
258     * TODO: do away with return value after making MobileDataStateTracker async
259     */
260    public boolean teardown() {
261        mTeardownRequested.set(true);
262        NetworkUtils.stopDhcp(mIface);
263        return true;
264    }
265
266    /**
267     * Re-enable connectivity to a network after a {@link #teardown()}.
268     */
269    public boolean reconnect() {
270        if (mLinkUp) {
271            mTeardownRequested.set(false);
272            runDhcp();
273        }
274        return mLinkUp;
275    }
276
277    @Override
278    public void captivePortalCheckComplete() {
279        // not implemented
280    }
281
282    /**
283     * Turn the wireless radio off for a network.
284     * @param turnOn {@code true} to turn the radio on, {@code false}
285     */
286    public boolean setRadio(boolean turnOn) {
287        return true;
288    }
289
290    /**
291     * @return true - If are we currently tethered with another device.
292     */
293    public synchronized boolean isAvailable() {
294        return mNetworkInfo.isAvailable();
295    }
296
297    /**
298     * Tells the underlying networking system that the caller wants to
299     * begin using the named feature. The interpretation of {@code feature}
300     * is completely up to each networking implementation.
301     * @param feature the name of the feature to be used
302     * @param callingPid the process ID of the process that is issuing this request
303     * @param callingUid the user ID of the process that is issuing this request
304     * @return an integer value representing the outcome of the request.
305     * The interpretation of this value is specific to each networking
306     * implementation+feature combination, except that the value {@code -1}
307     * always indicates failure.
308     * TODO: needs to go away
309     */
310    public int startUsingNetworkFeature(String feature, int callingPid, int callingUid) {
311        return -1;
312    }
313
314    /**
315     * Tells the underlying networking system that the caller is finished
316     * using the named feature. The interpretation of {@code feature}
317     * is completely up to each networking implementation.
318     * @param feature the name of the feature that is no longer needed.
319     * @param callingPid the process ID of the process that is issuing this request
320     * @param callingUid the user ID of the process that is issuing this request
321     * @return an integer value representing the outcome of the request.
322     * The interpretation of this value is specific to each networking
323     * implementation+feature combination, except that the value {@code -1}
324     * always indicates failure.
325     * TODO: needs to go away
326     */
327    public int stopUsingNetworkFeature(String feature, int callingPid, int callingUid) {
328        return -1;
329    }
330
331    @Override
332    public void setUserDataEnable(boolean enabled) {
333        Log.w(TAG, "ignoring setUserDataEnable(" + enabled + ")");
334    }
335
336    @Override
337    public void setPolicyDataEnable(boolean enabled) {
338        Log.w(TAG, "ignoring setPolicyDataEnable(" + enabled + ")");
339    }
340
341    /**
342     * Check if private DNS route is set for the network
343     */
344    public boolean isPrivateDnsRouteSet() {
345        return mPrivateDnsRouteSet.get();
346    }
347
348    /**
349     * Set a flag indicating private DNS route is set
350     */
351    public void privateDnsRouteSet(boolean enabled) {
352        mPrivateDnsRouteSet.set(enabled);
353    }
354
355    /**
356     * Fetch NetworkInfo for the network
357     */
358    public synchronized NetworkInfo getNetworkInfo() {
359        return mNetworkInfo;
360    }
361
362    /**
363     * Fetch LinkProperties for the network
364     */
365    public synchronized LinkProperties getLinkProperties() {
366        return new LinkProperties(mLinkProperties);
367    }
368
369   /**
370     * A capability is an Integer/String pair, the capabilities
371     * are defined in the class LinkSocket#Key.
372     *
373     * @return a copy of this connections capabilities, may be empty but never null.
374     */
375    public LinkCapabilities getLinkCapabilities() {
376        return new LinkCapabilities(mLinkCapabilities);
377    }
378
379    /**
380     * Fetch default gateway address for the network
381     */
382    public int getDefaultGatewayAddr() {
383        return mDefaultGatewayAddr.get();
384    }
385
386    /**
387     * Check if default route is set
388     */
389    public boolean isDefaultRouteSet() {
390        return mDefaultRouteSet.get();
391    }
392
393    /**
394     * Set a flag indicating default route is set for the network
395     */
396    public void defaultRouteSet(boolean enabled) {
397        mDefaultRouteSet.set(enabled);
398    }
399
400    /**
401     * Return the system properties name associated with the tcp buffer sizes
402     * for this network.
403     */
404    public String getTcpBufferSizesPropName() {
405        return "net.tcp.buffersize.wifi";
406    }
407
408    public void setDependencyMet(boolean met) {
409        // not supported on this network
410    }
411}
412