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

   1 /*
   2  * Copyright (C) 2008 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
  17 package com.android.server;
  18
  19 import android.bluetooth.BluetoothTetheringDataTracker;
  20 import android.content.ContentResolver;
  21 import android.content.Context;
  22 import android.content.Intent;
  23 import android.content.pm.PackageManager;
  24 import android.database.ContentObserver;
  25 import android.net.ConnectivityManager;
  26 import android.net.DummyDataStateTracker;
  27 import android.net.EthernetDataTracker;
  28 import android.net.IConnectivityManager;
  29 import android.net.LinkAddress;
  30 import android.net.LinkProperties;
  31 import android.net.MobileDataStateTracker;
  32 import android.net.NetworkConfig;
  33 import android.net.NetworkInfo;
  34 import android.net.NetworkStateTracker;
  35 import android.net.NetworkUtils;
  36 import android.net.Proxy;
  37 import android.net.ProxyProperties;
  38 import android.net.RouteInfo;
  39 import android.net.vpn.VpnManager;
  40 import android.net.wifi.WifiStateTracker;
  41 import android.os.Binder;
  42 import android.os.Handler;
  43 import android.os.HandlerThread;
  44 import android.os.IBinder;
  45 import android.os.INetworkManagementService;
  46 import android.os.Looper;
  47 import android.os.Message;
  48 import android.os.PowerManager;
  49 import android.os.RemoteException;
  50 import android.os.ServiceManager;
  51 import android.os.SystemProperties;
  52 import android.provider.Settings;
  53 import android.text.TextUtils;
  54 import android.util.EventLog;
  55 import android.util.Slog;
  56
  57 import com.android.internal.telephony.Phone;
  58 import com.android.server.connectivity.Tethering;
  59
  60 import java.io.FileDescriptor;
  61 import java.io.FileWriter;
  62 import java.io.IOException;
  63 import java.io.PrintWriter;
  64 import java.net.InetAddress;
  65 import java.net.Inet4Address;
  66 import java.net.UnknownHostException;
  67 import java.util.ArrayList;
  68 import java.util.Collection;
  69 import java.util.concurrent.atomic.AtomicBoolean;
  70 import java.util.GregorianCalendar;
  71 import java.util.List;
  72
  73 /**
  74  * @hide
  75  */
  76 public class ConnectivityService extends IConnectivityManager.Stub {
  77
  78     private static final boolean DBG = true;
  79     private static final String TAG = "ConnectivityService";
  80
  81     // how long to wait before switching back to a radio's default network
  82     private static final int RESTORE_DEFAULT_NETWORK_DELAY = 1 * 60 * 1000;
  83     // system property that can override the above value
  84     private static final String NETWORK_RESTORE_DELAY_PROP_NAME =
  85             "android.telephony.apn-restore";
  86
  87     // used in recursive route setting to add gateways for the host for which
  88     // a host route was requested.
  89     private static final int MAX_HOSTROUTE_CYCLE_COUNT = 10;
  90
  91     private Tethering mTethering;
  92     private boolean mTetheringConfigValid = false;
  93
  94     /**
  95      * Sometimes we want to refer to the individual network state
  96      * trackers separately, and sometimes we just want to treat them
  97      * abstractly.
  98      */
  99     private NetworkStateTracker mNetTrackers[];
 100
 101     /**
 102      * A per Net list of the PID's that requested access to the net
 103      * used both as a refcount and for per-PID DNS selection
 104      */
 105     private List mNetRequestersPids[];
 106
 107     private WifiWatchdogService mWifiWatchdogService;
 108
 109     // priority order of the nettrackers
 110     // (excluding dynamically set mNetworkPreference)
 111     // TODO - move mNetworkTypePreference into this
 112     private int[] mPriorityList;
 113
 114     private Context mContext;
 115     private int mNetworkPreference;
 116     private int mActiveDefaultNetwork = -1;
 117     // 0 is full bad, 100 is full good
 118     private int mDefaultInetCondition = 0;
 119     private int mDefaultInetConditionPublished = 0;
 120     private boolean mInetConditionChangeInFlight = false;
 121     private int mDefaultConnectionSequence = 0;
 122
 123     private int mNumDnsEntries;
 124
 125     private boolean mTestMode;
 126     private static ConnectivityService sServiceInstance;
 127
 128     private AtomicBoolean mBackgroundDataEnabled = new AtomicBoolean(true);
 129
 130     private INetworkManagementService mNetd;
 131
 132     private static final int ENABLED  = 1;
 133     private static final int DISABLED = 0;
 134
 135     // Share the event space with NetworkStateTracker (which can't see this
 136     // internal class but sends us events).  If you change these, change
 137     // NetworkStateTracker.java too.
 138     private static final int MIN_NETWORK_STATE_TRACKER_EVENT = 1;
 139     private static final int MAX_NETWORK_STATE_TRACKER_EVENT = 100;
 140
 141     /**
 142      * used internally as a delayed event to make us switch back to the
 143      * default network
 144      */
 145     private static final int EVENT_RESTORE_DEFAULT_NETWORK =
 146             MAX_NETWORK_STATE_TRACKER_EVENT + 1;
 147
 148     /**
 149      * used internally to change our mobile data enabled flag
 150      */
 151     private static final int EVENT_CHANGE_MOBILE_DATA_ENABLED =
 152             MAX_NETWORK_STATE_TRACKER_EVENT + 2;
 153
 154     /**
 155      * used internally to change our network preference setting
 156      * arg1 = networkType to prefer
 157      */
 158     private static final int EVENT_SET_NETWORK_PREFERENCE =
 159             MAX_NETWORK_STATE_TRACKER_EVENT + 3;
 160
 161     /**
 162      * used internally to synchronize inet condition reports
 163      * arg1 = networkType
 164      * arg2 = condition (0 bad, 100 good)
 165      */
 166     private static final int EVENT_INET_CONDITION_CHANGE =
 167             MAX_NETWORK_STATE_TRACKER_EVENT + 4;
 168
 169     /**
 170      * used internally to mark the end of inet condition hold periods
 171      * arg1 = networkType
 172      */
 173     private static final int EVENT_INET_CONDITION_HOLD_END =
 174             MAX_NETWORK_STATE_TRACKER_EVENT + 5;
 175
 176     /**
 177      * used internally to set the background data preference
 178      * arg1 = TRUE for enabled, FALSE for disabled
 179      */
 180     private static final int EVENT_SET_BACKGROUND_DATA =
 181             MAX_NETWORK_STATE_TRACKER_EVENT + 6;
 182
 183     /**
 184      * used internally to set enable/disable cellular data
 185      * arg1 = ENBALED or DISABLED
 186      */
 187     private static final int EVENT_SET_MOBILE_DATA =
 188             MAX_NETWORK_STATE_TRACKER_EVENT + 7;
 189
 190     /**
 191      * used internally to clear a wakelock when transitioning
 192      * from one net to another
 193      */
 194     private static final int EVENT_CLEAR_NET_TRANSITION_WAKELOCK =
 195             MAX_NETWORK_STATE_TRACKER_EVENT + 8;
 196
 197     /**
 198      * used internally to reload global proxy settings
 199      */
 200     private static final int EVENT_APPLY_GLOBAL_HTTP_PROXY =
 201             MAX_NETWORK_STATE_TRACKER_EVENT + 9;
 202
 203     /**
 204      * used internally to set external dependency met/unmet
 205      * arg1 = ENABLED (met) or DISABLED (unmet)
 206      * arg2 = NetworkType
 207      */
 208     private static final int EVENT_SET_DEPENDENCY_MET =
 209             MAX_NETWORK_STATE_TRACKER_EVENT + 10;
 210
 211     private Handler mHandler;
 212
 213     // list of DeathRecipients used to make sure features are turned off when
 214     // a process dies
 215     private List mFeatureUsers;
 216
 217     private boolean mSystemReady;
 218     private Intent mInitialBroadcast;
 219
 220     private PowerManager.WakeLock mNetTransitionWakeLock;
 221     private String mNetTransitionWakeLockCausedBy = "";
 222     private int mNetTransitionWakeLockSerialNumber;
 223     private int mNetTransitionWakeLockTimeout;
 224
 225     private InetAddress mDefaultDns;
 226
 227     // used in DBG mode to track inet condition reports
 228     private static final int INET_CONDITION_LOG_MAX_SIZE = 15;
 229     private ArrayList mInetLog;
 230
 231     // track the current default http proxy - tell the world if we get a new one (real change)
 232     private ProxyProperties mDefaultProxy = null;
 233     // track the global proxy.
 234     private ProxyProperties mGlobalProxy = null;
 235     private final Object mGlobalProxyLock = new Object();
 236
 237     private SettingsObserver mSettingsObserver;
 238
 239     NetworkConfig[] mNetConfigs;
 240     int mNetworksDefined;
 241
 242     private static class RadioAttributes {
 243         public int mSimultaneity;
 244         public int mType;
 245         public RadioAttributes(String init) {
 246             String fragments[] = init.split(",");
 247             mType = Integer.parseInt(fragments[0]);
 248             mSimultaneity = Integer.parseInt(fragments[1]);
 249         }
 250     }
 251     RadioAttributes[] mRadioAttributes;
 252
 253     // the set of network types that can only be enabled by system/sig apps
 254     List mProtectedNetworks;
 255
 256     public static synchronized ConnectivityService getInstance(Context context) {
 257         if (sServiceInstance == null) {
 258             sServiceInstance = new ConnectivityService(context);
 259         }
 260         return sServiceInstance;
 261     }
 262
 263     private ConnectivityService(Context context) {
 264         if (DBG) log("ConnectivityService starting up");
 265
 266         HandlerThread handlerThread = new HandlerThread("ConnectivityServiceThread");
 267         handlerThread.start();
 268         mHandler = new MyHandler(handlerThread.getLooper());
 269
 270         mBackgroundDataEnabled.set(Settings.Secure.getInt(context.getContentResolver(),
 271                 Settings.Secure.BACKGROUND_DATA, 1) == 1);
 272
 273         // setup our unique device name
 274         if (TextUtils.isEmpty(SystemProperties.get("net.hostname"))) {
 275             String id = Settings.Secure.getString(context.getContentResolver(),
 276                     Settings.Secure.ANDROID_ID);
 277             if (id != null && id.length() > 0) {
 278                 String name = new String("android_").concat(id);
 279                 SystemProperties.set("net.hostname", name);
 280             }
 281         }
 282
 283         // read our default dns server ip
 284         String dns = Settings.Secure.getString(context.getContentResolver(),
 285                 Settings.Secure.DEFAULT_DNS_SERVER);
 286         if (dns == null || dns.length() == 0) {
 287             dns = context.getResources().getString(
 288                     com.android.internal.R.string.config_default_dns_server);
 289         }
 290         try {
 291             mDefaultDns = NetworkUtils.numericToInetAddress(dns);
 292         } catch (IllegalArgumentException e) {
 293             loge("Error setting defaultDns using " + dns);
 294         }
 295
 296         mContext = context;
 297
 298         PowerManager powerManager = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
 299         mNetTransitionWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
 300         mNetTransitionWakeLockTimeout = mContext.getResources().getInteger(
 301                 com.android.internal.R.integer.config_networkTransitionTimeout);
 302
 303         mNetTrackers = new NetworkStateTracker[
 304                 ConnectivityManager.MAX_NETWORK_TYPE+1];
 305
 306         mNetworkPreference = getPersistedNetworkPreference();
 307
 308         mRadioAttributes = new RadioAttributes[ConnectivityManager.MAX_RADIO_TYPE+1];
 309         mNetConfigs = new NetworkConfig[ConnectivityManager.MAX_NETWORK_TYPE+1];
 310
 311         // Load device network attributes from resources
 312         String[] raStrings = context.getResources().getStringArray(
 313                 com.android.internal.R.array.radioAttributes);
 314         for (String raString : raStrings) {
 315             RadioAttributes r = new RadioAttributes(raString);
 316             if (r.mType > ConnectivityManager.MAX_RADIO_TYPE) {
 317                 loge("Error in radioAttributes - ignoring attempt to define type " + r.mType);
 318                 continue;
 319             }
 320             if (mRadioAttributes[r.mType] != null) {
 321                 loge("Error in radioAttributes - ignoring attempt to redefine type " +
 322                         r.mType);
 323                 continue;
 324             }
 325             mRadioAttributes[r.mType] = r;
 326         }
 327
 328         String[] naStrings = context.getResources().getStringArray(
 329                 com.android.internal.R.array.networkAttributes);
 330         for (String naString : naStrings) {
 331             try {
 332                 NetworkConfig n = new NetworkConfig(naString);
 333                 if (n.type > ConnectivityManager.MAX_NETWORK_TYPE) {
 334                     loge("Error in networkAttributes - ignoring attempt to define type " +
 335                             n.type);
 336                     continue;
 337                 }
 338                 if (mNetConfigs[n.type] != null) {
 339                     loge("Error in networkAttributes - ignoring attempt to redefine type " +
 340                             n.type);
 341                     continue;
 342                 }
 343                 if (mRadioAttributes[n.radio] == null) {
 344                     loge("Error in networkAttributes - ignoring attempt to use undefined " +
 345                             "radio " + n.radio + " in network type " + n.type);
 346                     continue;
 347                 }
 348                 mNetConfigs[n.type] = n;
 349                 mNetworksDefined++;
 350             } catch(Exception e) {
 351                 // ignore it - leave the entry null
 352             }
 353         }
 354
 355         mProtectedNetworks = new ArrayList<Integer>();
 356         int[] protectedNetworks = context.getResources().getIntArray(
 357                 com.android.internal.R.array.config_protectedNetworks);
 358         for (int p : protectedNetworks) {
 359             if ((mNetConfigs[p] != null) && (mProtectedNetworks.contains(p) == false)) {
 360                 mProtectedNetworks.add(p);
 361             } else {
 362                 if (DBG) loge("Ignoring protectedNetwork " + p);
 363             }
 364         }
 365
 366         // high priority first
 367         mPriorityList = new int[mNetworksDefined];
 368         {
 369             int insertionPoint = mNetworksDefined-1;
 370             int currentLowest = 0;
 371             int nextLowest = 0;
 372             while (insertionPoint > -1) {
 373                 for (NetworkConfig na : mNetConfigs) {
 374                     if (na == null) continue;
 375                     if (na.priority < currentLowest) continue;
 376                     if (na.priority > currentLowest) {
 377                         if (na.priority < nextLowest || nextLowest == 0) {
 378                             nextLowest = na.priority;
 379                         }
 380                         continue;
 381                     }
 382                     mPriorityList[insertionPoint--] = na.type;
 383                 }
 384                 currentLowest = nextLowest;
 385                 nextLowest = 0;
 386             }
 387         }
 388
 389         mNetRequestersPids = new ArrayList[ConnectivityManager.MAX_NETWORK_TYPE+1];
 390         for (int i : mPriorityList) {
 391             mNetRequestersPids[i] = new ArrayList();
 392         }
 393
 394         mFeatureUsers = new ArrayList();
 395
 396         mNumDnsEntries = 0;
 397
 398         mTestMode = SystemProperties.get("cm.test.mode").equals("true")
 399                 && SystemProperties.get("ro.build.type").equals("eng");
 400         /*
 401          * Create the network state trackers for Wi-Fi and mobile
 402          * data. Maybe this could be done with a factory class,
 403          * but it's not clear that it's worth it, given that
 404          * the number of different network types is not going
 405          * to change very often.
 406          */
 407         for (int netType : mPriorityList) {
 408             switch (mNetConfigs[netType].radio) {
 409             case ConnectivityManager.TYPE_WIFI:
 410                 if (DBG) log("Starting Wifi Service.");
 411                 WifiStateTracker wst = new WifiStateTracker();
 412                 WifiService wifiService = new WifiService(context);
 413                 ServiceManager.addService(Context.WIFI_SERVICE, wifiService);
 414                 wifiService.checkAndStartWifi();
 415                 mNetTrackers[ConnectivityManager.TYPE_WIFI] = wst;
 416                 wst.startMonitoring(context, mHandler);
 417
 418                 //TODO: as part of WWS refactor, create only when needed
 419                 mWifiWatchdogService = new WifiWatchdogService(context);
 420
 421                 break;
 422             case ConnectivityManager.TYPE_MOBILE:
 423                 mNetTrackers[netType] = new MobileDataStateTracker(netType,
 424                         mNetConfigs[netType].name);
 425                 mNetTrackers[netType].startMonitoring(context, mHandler);
 426                 break;
 427             case ConnectivityManager.TYPE_DUMMY:
 428                 mNetTrackers[netType] = new DummyDataStateTracker(netType,
 429                         mNetConfigs[netType].name);
 430                 mNetTrackers[netType].startMonitoring(context, mHandler);
 431                 break;
 432             case ConnectivityManager.TYPE_BLUETOOTH:
 433                 mNetTrackers[netType] = BluetoothTetheringDataTracker.getInstance();
 434                 mNetTrackers[netType].startMonitoring(context, mHandler);
 435                 break;
 436             case ConnectivityManager.TYPE_ETHERNET:
 437                 mNetTrackers[netType] = EthernetDataTracker.getInstance();
 438                 mNetTrackers[netType].startMonitoring(context, mHandler);
 439                 break;
 440             default:
 441                 loge("Trying to create a DataStateTracker for an unknown radio type " +
 442                         mNetConfigs[netType].radio);
 443                 continue;
 444             }
 445         }
 446
 447         mTethering = new Tethering(mContext, mHandler.getLooper());
 448         mTetheringConfigValid = ((mTethering.getTetherableUsbRegexs().length != 0 ||
 449                                   mTethering.getTetherableWifiRegexs().length != 0 ||
 450                                   mTethering.getTetherableBluetoothRegexs().length != 0) &&
 451                                  mTethering.getUpstreamIfaceTypes().length != 0);
 452
 453         if (DBG) {
 454             mInetLog = new ArrayList();
 455         }
 456
 457         mSettingsObserver = new SettingsObserver(mHandler, EVENT_APPLY_GLOBAL_HTTP_PROXY);
 458         mSettingsObserver.observe(mContext);
 459
 460         loadGlobalProxy();
 461
 462         VpnManager.startVpnService(context);
 463     }
 464
 465
 466     /**
 467      * Sets the preferred network.
 468      * @param preference the new preference
 469      */
 470     public void setNetworkPreference(int preference) {
 471         enforceChangePermission();
 472
 473         mHandler.sendMessage(mHandler.obtainMessage(EVENT_SET_NETWORK_PREFERENCE, preference, 0));
 474     }
 475
 476     public int getNetworkPreference() {
 477         enforceAccessPermission();
 478         int preference;
 479         synchronized(this) {
 480             preference = mNetworkPreference;
 481         }
 482         return preference;
 483     }
 484
 485     private void handleSetNetworkPreference(int preference) {
 486         if (ConnectivityManager.isNetworkTypeValid(preference) &&
 487                 mNetConfigs[preference] != null &&
 488                 mNetConfigs[preference].isDefault()) {
 489             if (mNetworkPreference != preference) {
 490                 final ContentResolver cr = mContext.getContentResolver();
 491                 Settings.Secure.putInt(cr, Settings.Secure.NETWORK_PREFERENCE, preference);
 492                 synchronized(this) {
 493                     mNetworkPreference = preference;
 494                 }
 495                 enforcePreference();
 496             }
 497         }
 498     }
 499
 500     private int getPersistedNetworkPreference() {
 501         final ContentResolver cr = mContext.getContentResolver();
 502
 503         final int networkPrefSetting = Settings.Secure
 504                 .getInt(cr, Settings.Secure.NETWORK_PREFERENCE, -1);
 505         if (networkPrefSetting != -1) {
 506             return networkPrefSetting;
 507         }
 508
 509         return ConnectivityManager.DEFAULT_NETWORK_PREFERENCE;
 510     }
 511
 512     /**
 513      * Make the state of network connectivity conform to the preference settings
 514      * In this method, we only tear down a non-preferred network. Establishing
 515      * a connection to the preferred network is taken care of when we handle
 516      * the disconnect event from the non-preferred network
 517      * (see {@link #handleDisconnect(NetworkInfo)}).
 518      */
 519     private void enforcePreference() {
 520         if (mNetTrackers[mNetworkPreference].getNetworkInfo().isConnected())
 521             return;
 522
 523         if (!mNetTrackers[mNetworkPreference].isAvailable())
 524             return;
 525
 526         for (int t=0; t <= ConnectivityManager.MAX_RADIO_TYPE; t++) {
 527             if (t != mNetworkPreference && mNetTrackers[t] != null &&
 528                     mNetTrackers[t].getNetworkInfo().isConnected()) {
 529                 if (DBG) {
 530                     log("tearing down " + mNetTrackers[t].getNetworkInfo() +
 531                             " in enforcePreference");
 532                 }
 533                 teardown(mNetTrackers[t]);
 534             }
 535         }
 536     }
 537
 538     private boolean teardown(NetworkStateTracker netTracker) {
 539         if (netTracker.teardown()) {
 540             netTracker.setTeardownRequested(true);
 541             return true;
 542         } else {
 543             return false;
 544         }
 545     }
 546
 547     /**
 548      * Return NetworkInfo for the active (i.e., connected) network interface.
 549      * It is assumed that at most one network is active at a time. If more
 550      * than one is active, it is indeterminate which will be returned.
 551      * @return the info for the active network, or {@code null} if none is
 552      * active
 553      */
 554     public NetworkInfo getActiveNetworkInfo() {
 555         return getNetworkInfo(mActiveDefaultNetwork);
 556     }
 557
 558     public NetworkInfo getNetworkInfo(int networkType) {
 559         enforceAccessPermission();
 560         if (ConnectivityManager.isNetworkTypeValid(networkType)) {
 561             NetworkStateTracker t = mNetTrackers[networkType];
 562             if (t != null)
 563                 return t.getNetworkInfo();
 564         }
 565         return null;
 566     }
 567
 568     public NetworkInfo[] getAllNetworkInfo() {
 569         enforceAccessPermission();
 570         NetworkInfo[] result = new NetworkInfo[mNetworksDefined];
 571         int i = 0;
 572         for (NetworkStateTracker t : mNetTrackers) {
 573             if(t != null) result[i++] = t.getNetworkInfo();
 574         }
 575         return result;
 576     }
 577
 578     /**
 579      * Return LinkProperties for the active (i.e., connected) default
 580      * network interface.  It is assumed that at most one default network
 581      * is active at a time. If more than one is active, it is indeterminate
 582      * which will be returned.
 583      * @return the ip properties for the active network, or {@code null} if
 584      * none is active
 585      */
 586     public LinkProperties getActiveLinkProperties() {
 587         return getLinkProperties(mActiveDefaultNetwork);
 588     }
 589
 590     public LinkProperties getLinkProperties(int networkType) {
 591         enforceAccessPermission();
 592         if (ConnectivityManager.isNetworkTypeValid(networkType)) {
 593             NetworkStateTracker t = mNetTrackers[networkType];
 594             if (t != null) return t.getLinkProperties();
 595         }
 596         return null;
 597     }
 598
 599     public boolean setRadios(boolean turnOn) {
 600         boolean result = true;
 601         enforceChangePermission();
 602         for (NetworkStateTracker t : mNetTrackers) {
 603             if (t != null) result = t.setRadio(turnOn) && result;
 604         }
 605         return result;
 606     }
 607
 608     public boolean setRadio(int netType, boolean turnOn) {
 609         enforceChangePermission();
 610         if (!ConnectivityManager.isNetworkTypeValid(netType)) {
 611             return false;
 612         }
 613         NetworkStateTracker tracker = mNetTrackers[netType];
 614         return tracker != null && tracker.setRadio(turnOn);
 615     }
 616
 617     /**
 618      * Used to notice when the calling process dies so we can self-expire
 619      *
 620      * Also used to know if the process has cleaned up after itself when
 621      * our auto-expire timer goes off.  The timer has a link to an object.
 622      *
 623      */
 624     private class FeatureUser implements IBinder.DeathRecipient {
 625         int mNetworkType;
 626         String mFeature;
 627         IBinder mBinder;
 628         int mPid;
 629         int mUid;
 630         long mCreateTime;
 631
 632         FeatureUser(int type, String feature, IBinder binder) {
 633             super();
 634             mNetworkType = type;
 635             mFeature = feature;
 636             mBinder = binder;
 637             mPid = getCallingPid();
 638             mUid = getCallingUid();
 639             mCreateTime = System.currentTimeMillis();
 640
 641             try {
 642                 mBinder.linkToDeath(this, 0);
 643             } catch (RemoteException e) {
 644                 binderDied();
 645             }
 646         }
 647
 648         void unlinkDeathRecipient() {
 649             mBinder.unlinkToDeath(this, 0);
 650         }
 651
 652         public void binderDied() {
 653             log("ConnectivityService FeatureUser binderDied(" +
 654                     mNetworkType + ", " + mFeature + ", " + mBinder + "), created " +
 655                     (System.currentTimeMillis() - mCreateTime) + " mSec ago");
 656             stopUsingNetworkFeature(this, false);
 657         }
 658
 659         public void expire() {
 660             log("ConnectivityService FeatureUser expire(" +
 661                     mNetworkType + ", " + mFeature + ", " + mBinder +"), created " +
 662                     (System.currentTimeMillis() - mCreateTime) + " mSec ago");
 663             stopUsingNetworkFeature(this, false);
 664         }
 665
 666         public String toString() {
 667             return "FeatureUser("+mNetworkType+","+mFeature+","+mPid+","+mUid+"), created " +
 668                     (System.currentTimeMillis() - mCreateTime) + " mSec ago";
 669         }
 670     }
 671
 672     // javadoc from interface
 673     public int startUsingNetworkFeature(int networkType, String feature,
 674             IBinder binder) {
 675         if (DBG) {
 676             log("startUsingNetworkFeature for net " + networkType + ": " + feature);
 677         }
 678         enforceChangePermission();
 679         if (!ConnectivityManager.isNetworkTypeValid(networkType) ||
 680                 mNetConfigs[networkType] == null) {
 681             return Phone.APN_REQUEST_FAILED;
 682         }
 683
 684         FeatureUser f = new FeatureUser(networkType, feature, binder);
 685
 686         // TODO - move this into the MobileDataStateTracker
 687         int usedNetworkType = networkType;
 688         if(networkType == ConnectivityManager.TYPE_MOBILE) {
 689             usedNetworkType = convertFeatureToNetworkType(feature);
 690             if (usedNetworkType < 0) {
 691                 Slog.e(TAG, "Can't match any netTracker!");
 692                 usedNetworkType = networkType;
 693             }
 694         }
 695
 696         if (mProtectedNetworks.contains(usedNetworkType)) {
 697             enforceConnectivityInternalPermission();
 698         }
 699
 700         NetworkStateTracker network = mNetTrackers[usedNetworkType];
 701         if (network != null) {
 702             Integer currentPid = new Integer(getCallingPid());
 703             if (usedNetworkType != networkType) {
 704                 NetworkStateTracker radio = mNetTrackers[networkType];
 705                 NetworkInfo ni = network.getNetworkInfo();
 706
 707                 if (ni.isAvailable() == false) {
 708                     if (DBG) log("special network not available");
 709                     if (!TextUtils.equals(feature,Phone.FEATURE_ENABLE_DUN_ALWAYS)) {
 710                         return Phone.APN_TYPE_NOT_AVAILABLE;
 711                     } else {
 712                         // else make the attempt anyway - probably giving REQUEST_STARTED below
 713                     }
 714                 }
 715
 716                 synchronized(this) {
 717                     mFeatureUsers.add(f);
 718                     if (!mNetRequestersPids[usedNetworkType].contains(currentPid)) {
 719                         // this gets used for per-pid dns when connected
 720                         mNetRequestersPids[usedNetworkType].add(currentPid);
 721                     }
 722                 }
 723
 724                 int restoreTimer = getRestoreDefaultNetworkDelay(usedNetworkType);
 725
 726                 if (restoreTimer >= 0) {
 727                     mHandler.sendMessageDelayed(
 728                             mHandler.obtainMessage(EVENT_RESTORE_DEFAULT_NETWORK, f), restoreTimer);
 729                 }
 730
 731                 if ((ni.isConnectedOrConnecting() == true) &&
 732                         !network.isTeardownRequested()) {
 733                     if (ni.isConnected() == true) {
 734                         // add the pid-specific dns
 735                         handleDnsConfigurationChange(networkType);
 736                         if (DBG) log("special network already active");
 737                         return Phone.APN_ALREADY_ACTIVE;
 738                     }
 739                     if (DBG) log("special network already connecting");
 740                     return Phone.APN_REQUEST_STARTED;
 741                 }
 742
 743                 // check if the radio in play can make another contact
 744                 // assume if cannot for now
 745
 746                 if (DBG) log("reconnecting to special network");
 747                 network.reconnect();
 748                 return Phone.APN_REQUEST_STARTED;
 749             } else {
 750                 // need to remember this unsupported request so we respond appropriately on stop
 751                 synchronized(this) {
 752                     mFeatureUsers.add(f);
 753                     if (!mNetRequestersPids[usedNetworkType].contains(currentPid)) {
 754                         // this gets used for per-pid dns when connected
 755                         mNetRequestersPids[usedNetworkType].add(currentPid);
 756                     }
 757                 }
 758                 return -1;
 759             }
 760         }
 761         return Phone.APN_TYPE_NOT_AVAILABLE;
 762     }
 763
 764     // javadoc from interface
 765     public int stopUsingNetworkFeature(int networkType, String feature) {
 766         enforceChangePermission();
 767
 768         int pid = getCallingPid();
 769         int uid = getCallingUid();
 770
 771         FeatureUser u = null;
 772         boolean found = false;
 773
 774         synchronized(this) {
 775             for (int i = 0; i < mFeatureUsers.size() ; i++) {
 776                 u = (FeatureUser)mFeatureUsers.get(i);
 777                 if (uid == u.mUid && pid == u.mPid &&
 778                         networkType == u.mNetworkType &&
 779                         TextUtils.equals(feature, u.mFeature)) {
 780                     found = true;
 781                     break;
 782                 }
 783             }
 784         }
 785         if (found && u != null) {
 786             // stop regardless of how many other time this proc had called start
 787             return stopUsingNetworkFeature(u, true);
 788         } else {
 789             // none found!
 790             if (DBG) log("ignoring stopUsingNetworkFeature - not a live request");
 791             return 1;
 792         }
 793     }
 794
 795     private int stopUsingNetworkFeature(FeatureUser u, boolean ignoreDups) {
 796         int networkType = u.mNetworkType;
 797         String feature = u.mFeature;
 798         int pid = u.mPid;
 799         int uid = u.mUid;
 800
 801         NetworkStateTracker tracker = null;
 802         boolean callTeardown = false;  // used to carry our decision outside of sync block
 803
 804         if (DBG) {
 805             log("stopUsingNetworkFeature for net " + networkType +
 806                     ": " + feature);
 807         }
 808
 809         if (!ConnectivityManager.isNetworkTypeValid(networkType)) {
 810             return -1;
 811         }
 812
 813         // need to link the mFeatureUsers list with the mNetRequestersPids state in this
 814         // sync block
 815         synchronized(this) {
 816             // check if this process still has an outstanding start request
 817             if (!mFeatureUsers.contains(u)) {
 818                 if (DBG) log("ignoring - this process has no outstanding requests");
 819                 return 1;
 820             }
 821             u.unlinkDeathRecipient();
 822             mFeatureUsers.remove(mFeatureUsers.indexOf(u));
 823             // If we care about duplicate requests, check for that here.
 824             //
 825             // This is done to support the extension of a request - the app
 826             // can request we start the network feature again and renew the
 827             // auto-shutoff delay.  Normal "stop" calls from the app though
 828             // do not pay attention to duplicate requests - in effect the
 829             // API does not refcount and a single stop will counter multiple starts.
 830             if (ignoreDups == false) {
 831                 for (int i = 0; i < mFeatureUsers.size() ; i++) {
 832                     FeatureUser x = (FeatureUser)mFeatureUsers.get(i);
 833                     if (x.mUid == u.mUid && x.mPid == u.mPid &&
 834                             x.mNetworkType == u.mNetworkType &&
 835                             TextUtils.equals(x.mFeature, u.mFeature)) {
 836                         if (DBG) log("ignoring stopUsingNetworkFeature as dup is found");
 837                         return 1;
 838                     }
 839                 }
 840             }
 841
 842             // TODO - move to MobileDataStateTracker
 843             int usedNetworkType = networkType;
 844             if (networkType == ConnectivityManager.TYPE_MOBILE) {
 845                 usedNetworkType = convertFeatureToNetworkType(feature);
 846                 if (usedNetworkType < 0) {
 847                     usedNetworkType = networkType;
 848                 }
 849             }
 850             tracker =  mNetTrackers[usedNetworkType];
 851             if (tracker == null) {
 852                 if (DBG) log("ignoring - no known tracker for net type " + usedNetworkType);
 853                 return -1;
 854             }
 855             if (usedNetworkType != networkType) {
 856                 Integer currentPid = new Integer(pid);
 857                 mNetRequestersPids[usedNetworkType].remove(currentPid);
 858                 reassessPidDns(pid, true);
 859                 if (mNetRequestersPids[usedNetworkType].size() != 0) {
 860                     if (DBG) log("not tearing down special network - " +
 861                            "others still using it");
 862                     return 1;
 863                 }
 864                 callTeardown = true;
 865             } else {
 866                 if (DBG) log("not a known feature - dropping");
 867             }
 868         }
 869         if (DBG) log("Doing network teardown");
 870         if (callTeardown) {
 871             tracker.teardown();
 872             return 1;
 873         } else {
 874             return -1;
 875         }
 876     }
 877
 878     /**
 879      * @deprecated use requestRouteToHostAddress instead
 880      *
 881      * Ensure that a network route exists to deliver traffic to the specified
 882      * host via the specified network interface.
 883      * @param networkType the type of the network over which traffic to the
 884      * specified host is to be routed
 885      * @param hostAddress the IP address of the host to which the route is
 886      * desired
 887      * @return {@code true} on success, {@code false} on failure
 888      */
 889     public boolean requestRouteToHost(int networkType, int hostAddress) {
 890         InetAddress inetAddress = NetworkUtils.intToInetAddress(hostAddress);
 891
 892         if (inetAddress == null) {
 893             return false;
 894         }
 895
 896         return requestRouteToHostAddress(networkType, inetAddress.getAddress());
 897     }
 898
 899     /**
 900      * Ensure that a network route exists to deliver traffic to the specified
 901      * host via the specified network interface.
 902      * @param networkType the type of the network over which traffic to the
 903      * specified host is to be routed
 904      * @param hostAddress the IP address of the host to which the route is
 905      * desired
 906      * @return {@code true} on success, {@code false} on failure
 907      */
 908     public boolean requestRouteToHostAddress(int networkType, byte[] hostAddress) {
 909         enforceChangePermission();
 910         if (mProtectedNetworks.contains(networkType)) {
 911             enforceConnectivityInternalPermission();
 912         }
 913
 914         if (!ConnectivityManager.isNetworkTypeValid(networkType)) {
 915             return false;
 916         }
 917         NetworkStateTracker tracker = mNetTrackers[networkType];
 918
 919         if (tracker == null || !tracker.getNetworkInfo().isConnected() ||
 920                 tracker.isTeardownRequested()) {
 921             if (DBG) {
 922                 log("requestRouteToHostAddress on down network " +
 923                            "(" + networkType + ") - dropped");
 924             }
 925             return false;
 926         }
 927         try {
 928             InetAddress addr = InetAddress.getByAddress(hostAddress);
 929             return addHostRoute(tracker, addr, 0);
 930         } catch (UnknownHostException e) {}
 931         return false;
 932     }
 933
 934     /**
 935      * Ensure that a network route exists to deliver traffic to the specified
 936      * host via the mobile data network.
 937      * @param hostAddress the IP address of the host to which the route is desired,
 938      * in network byte order.
 939      * TODO - deprecate
 940      * @return {@code true} on success, {@code false} on failure
 941      */
 942     private boolean addHostRoute(NetworkStateTracker nt, InetAddress hostAddress, int cycleCount) {
 943         LinkProperties lp = nt.getLinkProperties();
 944         if ((lp == null) || (hostAddress == null)) return false;
 945
 946         String interfaceName = lp.getInterfaceName();
 947         if (DBG) {
 948             log("Requested host route to " + hostAddress + "(" + interfaceName + "), cycleCount=" +
 949                     cycleCount);
 950         }
 951         if (interfaceName == null) {
 952             if (DBG) loge("addHostRoute failed due to null interface name");
 953             return false;
 954         }
 955
 956         RouteInfo bestRoute = RouteInfo.selectBestRoute(lp.getRoutes(), hostAddress);
 957         InetAddress gatewayAddress = null;
 958         if (bestRoute != null) {
 959             gatewayAddress = bestRoute.getGateway();
 960             // if the best route is ourself, don't relf-reference, just add the host route
 961             if (hostAddress.equals(gatewayAddress)) gatewayAddress = null;
 962         }
 963         if (gatewayAddress != null) {
 964             if (cycleCount > MAX_HOSTROUTE_CYCLE_COUNT) {
 965                 loge("Error adding hostroute - too much recursion");
 966                 return false;
 967             }
 968             if (!addHostRoute(nt, gatewayAddress, cycleCount+1)) return false;
 969         }
 970
 971         RouteInfo route = RouteInfo.makeHostRoute(hostAddress, gatewayAddress);
 972
 973         try {
 974             mNetd.addRoute(interfaceName, route);
 975             return true;
 976         } catch (Exception ex) {
 977             return false;
 978         }
 979     }
 980
 981     // TODO support the removal of single host routes.  Keep a ref count of them so we
 982     // aren't over-zealous
 983     private boolean removeHostRoute(NetworkStateTracker nt, InetAddress hostAddress) {
 984         return false;
 985     }
 986
 987     /**
 988      * @see ConnectivityManager#getBackgroundDataSetting()
 989      */
 990     public boolean getBackgroundDataSetting() {
 991         return mBackgroundDataEnabled.get();
 992     }
 993
 994     /**
 995      * @see ConnectivityManager#setBackgroundDataSetting(boolean)
 996      */
 997     public void setBackgroundDataSetting(boolean allowBackgroundDataUsage) {
 998         mContext.enforceCallingOrSelfPermission(
 999                 android.Manifest.permission.CHANGE_BACKGROUND_DATA_SETTING,
1000                 "ConnectivityService");
1001
1002         mBackgroundDataEnabled.set(allowBackgroundDataUsage);
1003
1004         mHandler.sendMessage(mHandler.obtainMessage(EVENT_SET_BACKGROUND_DATA,
1005                 (allowBackgroundDataUsage ? ENABLED : DISABLED), 0));
1006     }
1007
1008     private void handleSetBackgroundData(boolean enabled) {
1009         Settings.Secure.putInt(mContext.getContentResolver(),
1010                 Settings.Secure.BACKGROUND_DATA, enabled ? 1 : 0);
1011         Intent broadcast = new Intent(
1012                 ConnectivityManager.ACTION_BACKGROUND_DATA_SETTING_CHANGED);
1013         mContext.sendBroadcast(broadcast);
1014     }
1015
1016     /**
1017      * @see ConnectivityManager#getMobileDataEnabled()
1018      */
1019     public boolean getMobileDataEnabled() {
1020         // TODO: This detail should probably be in DataConnectionTracker's
1021         //       which is where we store the value and maybe make this
1022         //       asynchronous.
1023         enforceAccessPermission();
1024         boolean retVal = Settings.Secure.getInt(mContext.getContentResolver(),
1025                 Settings.Secure.MOBILE_DATA, 1) == 1;
1026         if (DBG) log("getMobileDataEnabled returning " + retVal);
1027         return retVal;
1028     }
1029
1030     public void setDataDependency(int networkType, boolean met) {
1031         enforceConnectivityInternalPermission();
1032
1033         if (DBG) {
1034             log("setDataDependency(" + networkType + ", " + met + ")");
1035         }
1036         mHandler.sendMessage(mHandler.obtainMessage(EVENT_SET_DEPENDENCY_MET,
1037                 (met ? ENABLED : DISABLED), networkType));
1038     }
1039
1040     private void handleSetDependencyMet(int networkType, boolean met) {
1041         if (mNetTrackers[networkType] != null) {
1042             if (DBG) {
1043                 log("handleSetDependencyMet(" + networkType + ", " + met + ")");
1044             }
1045             mNetTrackers[networkType].setDependencyMet(met);
1046         }
1047     }
1048
1049     /**
1050      * @see ConnectivityManager#setMobileDataEnabled(boolean)
1051      */
1052     public void setMobileDataEnabled(boolean enabled) {
1053         enforceChangePermission();
1054         if (DBG) log("setMobileDataEnabled(" + enabled + ")");
1055
1056         mHandler.sendMessage(mHandler.obtainMessage(EVENT_SET_MOBILE_DATA,
1057                 (enabled ? ENABLED : DISABLED), 0));
1058     }
1059
1060     private void handleSetMobileData(boolean enabled) {
1061         if (mNetTrackers[ConnectivityManager.TYPE_MOBILE] != null) {
1062             if (DBG) {
1063                 Slog.d(TAG, mNetTrackers[ConnectivityManager.TYPE_MOBILE].toString() + enabled);
1064             }
1065             mNetTrackers[ConnectivityManager.TYPE_MOBILE].setDataEnable(enabled);
1066         }
1067     }
1068
1069     private void enforceAccessPermission() {
1070         mContext.enforceCallingOrSelfPermission(
1071                 android.Manifest.permission.ACCESS_NETWORK_STATE,
1072                 "ConnectivityService");
1073     }
1074
1075     private void enforceChangePermission() {
1076         mContext.enforceCallingOrSelfPermission(
1077                 android.Manifest.permission.CHANGE_NETWORK_STATE,
1078                 "ConnectivityService");
1079     }
1080
1081     // TODO Make this a special check when it goes public
1082     private void enforceTetherChangePermission() {
1083         mContext.enforceCallingOrSelfPermission(
1084                 android.Manifest.permission.CHANGE_NETWORK_STATE,
1085                 "ConnectivityService");
1086     }
1087
1088     private void enforceTetherAccessPermission() {
1089         mContext.enforceCallingOrSelfPermission(
1090                 android.Manifest.permission.ACCESS_NETWORK_STATE,
1091                 "ConnectivityService");
1092     }
1093
1094     private void enforceConnectivityInternalPermission() {
1095         mContext.enforceCallingOrSelfPermission(
1096                 android.Manifest.permission.CONNECTIVITY_INTERNAL,
1097                 "ConnectivityService");
1098     }
1099
1100     /**
1101      * Handle a {@code DISCONNECTED} event. If this pertains to the non-active
1102      * network, we ignore it. If it is for the active network, we send out a
1103      * broadcast. But first, we check whether it might be possible to connect
1104      * to a different network.
1105      * @param info the {@code NetworkInfo} for the network
1106      */
1107     private void handleDisconnect(NetworkInfo info) {
1108
1109         int prevNetType = info.getType();
1110
1111         mNetTrackers[prevNetType].setTeardownRequested(false);
1112         /*
1113          * If the disconnected network is not the active one, then don't report
1114          * this as a loss of connectivity. What probably happened is that we're
1115          * getting the disconnect for a network that we explicitly disabled
1116          * in accordance with network preference policies.
1117          */
1118         if (!mNetConfigs[prevNetType].isDefault()) {
1119             List pids = mNetRequestersPids[prevNetType];
1120             for (int i = 0; i<pids.size(); i++) {
1121                 Integer pid = (Integer)pids.get(i);
1122                 // will remove them because the net's no longer connected
1123                 // need to do this now as only now do we know the pids and
1124                 // can properly null things that are no longer referenced.
1125                 reassessPidDns(pid.intValue(), false);
1126             }
1127         }
1128
1129         Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
1130         intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, info);
1131         if (info.isFailover()) {
1132             intent.putExtra(ConnectivityManager.EXTRA_IS_FAILOVER, true);
1133             info.setFailover(false);
1134         }
1135         if (info.getReason() != null) {
1136             intent.putExtra(ConnectivityManager.EXTRA_REASON, info.getReason());
1137         }
1138         if (info.getExtraInfo() != null) {
1139             intent.putExtra(ConnectivityManager.EXTRA_EXTRA_INFO,
1140                     info.getExtraInfo());
1141         }
1142
1143         if (mNetConfigs[prevNetType].isDefault()) {
1144             tryFailover(prevNetType);
1145             if (mActiveDefaultNetwork != -1) {
1146                 NetworkInfo switchTo = mNetTrackers[mActiveDefaultNetwork].getNetworkInfo();
1147                 intent.putExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO, switchTo);
1148             } else {
1149                 mDefaultInetConditionPublished = 0; // we're not connected anymore
1150                 intent.putExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, true);
1151             }
1152         }
1153         intent.putExtra(ConnectivityManager.EXTRA_INET_CONDITION, mDefaultInetConditionPublished);
1154
1155         // Reset interface if no other connections are using the same interface
1156         boolean doReset = true;
1157         LinkProperties linkProperties = mNetTrackers[prevNetType].getLinkProperties();
1158         if (linkProperties != null) {
1159             String oldIface = linkProperties.getInterfaceName();
1160             if (TextUtils.isEmpty(oldIface) == false) {
1161                 for (NetworkStateTracker networkStateTracker : mNetTrackers) {
1162                     if (networkStateTracker == null) continue;
1163                     NetworkInfo networkInfo = networkStateTracker.getNetworkInfo();
1164                     if (networkInfo.isConnected() && networkInfo.getType() != prevNetType) {
1165                         LinkProperties l = networkStateTracker.getLinkProperties();
1166                         if (l == null) continue;
1167                         if (oldIface.equals(l.getInterfaceName())) {
1168                             doReset = false;
1169                             break;
1170                         }
1171                     }
1172                 }
1173             }
1174         }
1175
1176         // do this before we broadcast the change
1177         handleConnectivityChange(prevNetType, doReset);
1178
1179         sendStickyBroadcast(intent);
1180         /*
1181          * If the failover network is already connected, then immediately send
1182          * out a followup broadcast indicating successful failover
1183          */
1184         if (mActiveDefaultNetwork != -1) {
1185             sendConnectedBroadcast(mNetTrackers[mActiveDefaultNetwork].getNetworkInfo());
1186         }
1187     }
1188
1189     private void tryFailover(int prevNetType) {
1190         /*
1191          * If this is a default network, check if other defaults are available.
1192          * Try to reconnect on all available and let them hash it out when
1193          * more than one connects.
1194          */
1195         if (mNetConfigs[prevNetType].isDefault()) {
1196             if (mActiveDefaultNetwork == prevNetType) {
1197                 mActiveDefaultNetwork = -1;
1198             }
1199
1200             // don't signal a reconnect for anything lower or equal priority than our
1201             // current connected default
1202             // TODO - don't filter by priority now - nice optimization but risky
1203 //            int currentPriority = -1;
1204 //            if (mActiveDefaultNetwork != -1) {
1205 //                currentPriority = mNetConfigs[mActiveDefaultNetwork].mPriority;
1206 //            }
1207             for (int checkType=0; checkType <= ConnectivityManager.MAX_NETWORK_TYPE; checkType++) {
1208                 if (checkType == prevNetType) continue;
1209                 if (mNetConfigs[checkType] == null) continue;
1210                 if (!mNetConfigs[checkType].isDefault()) continue;
1211
1212 // Enabling the isAvailable() optimization caused mobile to not get
1213 // selected if it was in the middle of error handling. Specifically
1214 // a moble connection that took 30 seconds to complete the DEACTIVATE_DATA_CALL
1215 // would not be available and we wouldn't get connected to anything.
1216 // So removing the isAvailable() optimization below for now. TODO: This
1217 // optimization should work and we need to investigate why it doesn't work.
1218 // This could be related to how DEACTIVATE_DATA_CALL is reporting its
1219 // complete before it is really complete.
1220 //                if (!mNetTrackers[checkType].isAvailable()) continue;
1221
1222 //                if (currentPriority >= mNetConfigs[checkType].mPriority) continue;
1223
1224                 NetworkStateTracker checkTracker = mNetTrackers[checkType];
1225                 NetworkInfo checkInfo = checkTracker.getNetworkInfo();
1226                 if (!checkInfo.isConnectedOrConnecting() || checkTracker.isTeardownRequested()) {
1227                     checkInfo.setFailover(true);
1228                     checkTracker.reconnect();
1229                 }
1230                 if (DBG) log("Attempting to switch to " + checkInfo.getTypeName());
1231             }
1232         }
1233     }
1234
1235     private void sendConnectedBroadcast(NetworkInfo info) {
1236         sendGeneralBroadcast(info, ConnectivityManager.CONNECTIVITY_ACTION);
1237     }
1238
1239     private void sendInetConditionBroadcast(NetworkInfo info) {
1240         sendGeneralBroadcast(info, ConnectivityManager.INET_CONDITION_ACTION);
1241     }
1242
1243     private void sendGeneralBroadcast(NetworkInfo info, String bcastType) {
1244         Intent intent = new Intent(bcastType);
1245         intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, info);
1246         if (info.isFailover()) {
1247             intent.putExtra(ConnectivityManager.EXTRA_IS_FAILOVER, true);
1248             info.setFailover(false);
1249         }
1250         if (info.getReason() != null) {
1251             intent.putExtra(ConnectivityManager.EXTRA_REASON, info.getReason());
1252         }
1253         if (info.getExtraInfo() != null) {
1254             intent.putExtra(ConnectivityManager.EXTRA_EXTRA_INFO,
1255                     info.getExtraInfo());
1256         }
1257         intent.putExtra(ConnectivityManager.EXTRA_INET_CONDITION, mDefaultInetConditionPublished);
1258         sendStickyBroadcast(intent);
1259     }
1260
1261     /**
1262      * Called when an attempt to fail over to another network has failed.
1263      * @param info the {@link NetworkInfo} for the failed network
1264      */
1265     private void handleConnectionFailure(NetworkInfo info) {
1266         mNetTrackers[info.getType()].setTeardownRequested(false);
1267
1268         String reason = info.getReason();
1269         String extraInfo = info.getExtraInfo();
1270
1271         String reasonText;
1272         if (reason == null) {
1273             reasonText = ".";
1274         } else {
1275             reasonText = " (" + reason + ").";
1276         }
1277         loge("Attempt to connect to " + info.getTypeName() + " failed" + reasonText);
1278
1279         Intent intent = new Intent(ConnectivityManager.CONNECTIVITY_ACTION);
1280         intent.putExtra(ConnectivityManager.EXTRA_NETWORK_INFO, info);
1281         if (getActiveNetworkInfo() == null) {
1282             intent.putExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, true);
1283         }
1284         if (reason != null) {
1285             intent.putExtra(ConnectivityManager.EXTRA_REASON, reason);
1286         }
1287         if (extraInfo != null) {
1288             intent.putExtra(ConnectivityManager.EXTRA_EXTRA_INFO, extraInfo);
1289         }
1290         if (info.isFailover()) {
1291             intent.putExtra(ConnectivityManager.EXTRA_IS_FAILOVER, true);
1292             info.setFailover(false);
1293         }
1294
1295         if (mNetConfigs[info.getType()].isDefault()) {
1296             tryFailover(info.getType());
1297             if (mActiveDefaultNetwork != -1) {
1298                 NetworkInfo switchTo = mNetTrackers[mActiveDefaultNetwork].getNetworkInfo();
1299                 intent.putExtra(ConnectivityManager.EXTRA_OTHER_NETWORK_INFO, switchTo);
1300             } else {
1301                 mDefaultInetConditionPublished = 0;
1302                 intent.putExtra(ConnectivityManager.EXTRA_NO_CONNECTIVITY, true);
1303             }
1304         }
1305
1306         intent.putExtra(ConnectivityManager.EXTRA_INET_CONDITION, mDefaultInetConditionPublished);
1307         sendStickyBroadcast(intent);
1308         /*
1309          * If the failover network is already connected, then immediately send
1310          * out a followup broadcast indicating successful failover
1311          */
1312         if (mActiveDefaultNetwork != -1) {
1313             sendConnectedBroadcast(mNetTrackers[mActiveDefaultNetwork].getNetworkInfo());
1314         }
1315     }
1316
1317     private void sendStickyBroadcast(Intent intent) {
1318         synchronized(this) {
1319             if (!mSystemReady) {
1320                 mInitialBroadcast = new Intent(intent);
1321             }
1322             intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
1323             mContext.sendStickyBroadcast(intent);
1324         }
1325     }
1326
1327     void systemReady() {
1328         IBinder b = ServiceManager.getService(Context.NETWORKMANAGEMENT_SERVICE);
1329         mNetd = INetworkManagementService.Stub.asInterface(b);
1330
1331         synchronized(this) {
1332             mSystemReady = true;
1333             if (mInitialBroadcast != null) {
1334                 mContext.sendStickyBroadcast(mInitialBroadcast);
1335                 mInitialBroadcast = null;
1336             }
1337         }
1338         // load the global proxy at startup
1339         mHandler.sendMessage(mHandler.obtainMessage(EVENT_APPLY_GLOBAL_HTTP_PROXY));
1340     }
1341
1342     private void handleConnect(NetworkInfo info) {
1343         int type = info.getType();
1344
1345         // snapshot isFailover, because sendConnectedBroadcast() resets it
1346         boolean isFailover = info.isFailover();
1347         NetworkStateTracker thisNet = mNetTrackers[type];
1348
1349         // if this is a default net and other default is running
1350         // kill the one not preferred
1351         if (mNetConfigs[type].isDefault()) {
1352             if (mActiveDefaultNetwork != -1 && mActiveDefaultNetwork != type) {
1353                 if ((type != mNetworkPreference &&
1354                         mNetConfigs[mActiveDefaultNetwork].priority >
1355                         mNetConfigs[type].priority) ||
1356                         mNetworkPreference == mActiveDefaultNetwork) {
1357                         // don't accept this one
1358                         if (DBG) {
1359                             log("Not broadcasting CONNECT_ACTION " +
1360                                 "to torn down network " + info.getTypeName());
1361                         }
1362                         teardown(thisNet);
1363                         return;
1364                 } else {
1365                     // tear down the other
1366                     NetworkStateTracker otherNet =
1367                             mNetTrackers[mActiveDefaultNetwork];
1368                     if (DBG) {
1369                         log("Policy requires " + otherNet.getNetworkInfo().getTypeName() +
1370                             " teardown");
1371                     }
1372                     if (!teardown(otherNet)) {
1373                         loge("Network declined teardown request");
1374                         return;
1375                     }
1376                 }
1377             }
1378             synchronized (ConnectivityService.this) {
1379                 // have a new default network, release the transition wakelock in a second
1380                 // if it's held.  The second pause is to allow apps to reconnect over the
1381                 // new network
1382                 if (mNetTransitionWakeLock.isHeld()) {
1383                     mHandler.sendMessageDelayed(mHandler.obtainMessage(
1384                             EVENT_CLEAR_NET_TRANSITION_WAKELOCK,
1385                             mNetTransitionWakeLockSerialNumber, 0),
1386                             1000);
1387                 }
1388             }
1389             mActiveDefaultNetwork = type;
1390             // this will cause us to come up initially as unconnected and switching
1391             // to connected after our normal pause unless somebody reports us as reall
1392             // disconnected
1393             mDefaultInetConditionPublished = 0;
1394             mDefaultConnectionSequence++;
1395             mInetConditionChangeInFlight = false;
1396             // Don't do this - if we never sign in stay, grey
1397             //reportNetworkCondition(mActiveDefaultNetwork, 100);
1398         }
1399         thisNet.setTeardownRequested(false);
1400         updateNetworkSettings(thisNet);
1401         handleConnectivityChange(type, false);
1402         sendConnectedBroadcast(info);
1403     }
1404
1405     /**
1406      * After a change in the connectivity state of a network. We're mainly
1407      * concerned with making sure that the list of DNS servers is set up
1408      * according to which networks are connected, and ensuring that the
1409      * right routing table entries exist.
1410      */
1411     private void handleConnectivityChange(int netType, boolean doReset) {
1412         /*
1413          * If a non-default network is enabled, add the host routes that
1414          * will allow it's DNS servers to be accessed.
1415          */
1416         handleDnsConfigurationChange(netType);
1417
1418         if (mNetTrackers[netType].getNetworkInfo().isConnected()) {
1419             if (mNetConfigs[netType].isDefault()) {
1420                 handleApplyDefaultProxy(netType);
1421                 addDefaultRoute(mNetTrackers[netType]);
1422             } else {
1423                 addPrivateDnsRoutes(mNetTrackers[netType]);
1424             }
1425         } else {
1426             if (mNetConfigs[netType].isDefault()) {
1427                 removeDefaultRoute(mNetTrackers[netType]);
1428             } else {
1429                 removePrivateDnsRoutes(mNetTrackers[netType]);
1430             }
1431         }
1432
1433         if (doReset) {
1434             LinkProperties linkProperties = mNetTrackers[netType].getLinkProperties();
1435             if (linkProperties != null) {
1436                 String iface = linkProperties.getInterfaceName();
1437                 if (TextUtils.isEmpty(iface) == false) {
1438                     if (DBG) {
1439                         log("resetConnections(" + iface + ", NetworkUtils.RESET_ALL_ADDRESSES)");
1440                     }
1441                     NetworkUtils.resetConnections(iface, NetworkUtils.RESET_ALL_ADDRESSES);
1442                 }
1443             }
1444         }
1445
1446         // TODO: Temporary notifying upstread change to Tethering.
1447         //       @see bug/4455071
1448         /** Notify TetheringService if interface name has been changed. */
1449         if (TextUtils.equals(mNetTrackers[netType].getNetworkInfo().getReason(),
1450                              Phone.REASON_LINK_PROPERTIES_CHANGED)) {
1451             if (isTetheringSupported()) {
1452                 mTethering.handleTetherIfaceChange();
1453             }
1454         }
1455     }
1456
1457     private void addPrivateDnsRoutes(NetworkStateTracker nt) {
1458         boolean privateDnsRouteSet = nt.isPrivateDnsRouteSet();
1459         LinkProperties p = nt.getLinkProperties();
1460         if (p == null) return;
1461         String interfaceName = p.getInterfaceName();
1462
1463         if (DBG) {
1464             log("addPrivateDnsRoutes for " + nt +
1465                     "(" + interfaceName + ") - mPrivateDnsRouteSet = " + privateDnsRouteSet);
1466         }
1467         if (interfaceName != null && !privateDnsRouteSet) {
1468             Collection<InetAddress> dnsList = p.getDnses();
1469             for (InetAddress dns : dnsList) {
1470                 addHostRoute(nt, dns, 0);
1471             }
1472             nt.privateDnsRouteSet(true);
1473         }
1474     }
1475
1476     private void removePrivateDnsRoutes(NetworkStateTracker nt) {
1477         LinkProperties p = nt.getLinkProperties();
1478         if (p == null) return;
1479         String interfaceName = p.getInterfaceName();
1480         boolean privateDnsRouteSet = nt.isPrivateDnsRouteSet();
1481         if (interfaceName != null && privateDnsRouteSet) {
1482             if (DBG) {
1483                 log("removePrivateDnsRoutes for " + nt.getNetworkInfo().getTypeName() +
1484                         " (" + interfaceName + ")");
1485             }
1486
1487             Collection<InetAddress> dnsList = p.getDnses();
1488             for (InetAddress dns : dnsList) {
1489                 if (DBG) log("  removing " + dns);
1490                 RouteInfo route = RouteInfo.makeHostRoute(dns);
1491                 try {
1492                     mNetd.removeRoute(interfaceName, route);
1493                 } catch (Exception ex) {
1494                     loge("error (" + ex + ") removing dns route " + route);
1495                 }
1496             }
1497             nt.privateDnsRouteSet(false);
1498         }
1499     }
1500
1501
1502     private void addDefaultRoute(NetworkStateTracker nt) {
1503         LinkProperties p = nt.getLinkProperties();
1504         if (p == null) return;
1505         String interfaceName = p.getInterfaceName();
1506         if (TextUtils.isEmpty(interfaceName)) return;
1507
1508         for (RouteInfo route : p.getRoutes()) {
1509             //TODO - handle non-default routes
1510             if (route.isDefaultRoute()) {
1511                 if (DBG) log("adding default route " + route);
1512                 InetAddress gateway = route.getGateway();
1513                 if (addHostRoute(nt, gateway, 0)) {
1514                     try {
1515                         mNetd.addRoute(interfaceName, route);
1516                     } catch (Exception e) {
1517                         loge("error adding default route " + route);
1518                         continue;
1519                     }
1520                     if (DBG) {
1521                         NetworkInfo networkInfo = nt.getNetworkInfo();
1522                         log("addDefaultRoute for " + networkInfo.getTypeName() +
1523                                 " (" + interfaceName + "), GatewayAddr=" +
1524                                 gateway.getHostAddress());
1525                     }
1526                 } else {
1527                     loge("error adding host route for default route " + route);
1528                 }
1529             }
1530         }
1531     }
1532
1533
1534     public void removeDefaultRoute(NetworkStateTracker nt) {
1535         LinkProperties p = nt.getLinkProperties();
1536         if (p == null) return;
1537         String interfaceName = p.getInterfaceName();
1538
1539         if (interfaceName == null) return;
1540
1541         for (RouteInfo route : p.getRoutes()) {
1542             //TODO - handle non-default routes
1543             if (route.isDefaultRoute()) {
1544                 try {
1545                     mNetd.removeRoute(interfaceName, route);
1546                 } catch (Exception ex) {
1547                     loge("error (" + ex + ") removing default route " + route);
1548                     continue;
1549                 }
1550                 if (DBG) {
1551                     NetworkInfo networkInfo = nt.getNetworkInfo();
1552                     log("removeDefaultRoute for " + networkInfo.getTypeName() + " (" +
1553                             interfaceName + ")");
1554                 }
1555             }
1556         }
1557     }
1558
1559    /**
1560      * Reads the network specific TCP buffer sizes from SystemProperties
1561      * net.tcp.buffersize.[default|wifi|umts|edge|gprs] and set them for system
1562      * wide use
1563      */
1564    public void updateNetworkSettings(NetworkStateTracker nt) {
1565         String key = nt.getTcpBufferSizesPropName();
1566         String bufferSizes = SystemProperties.get(key);
1567
1568         if (bufferSizes.length() == 0) {
1569             loge(key + " not found in system properties. Using defaults");
1570
1571             // Setting to default values so we won't be stuck to previous values
1572             key = "net.tcp.buffersize.default";
1573             bufferSizes = SystemProperties.get(key);
1574         }
1575
1576         // Set values in kernel
1577         if (bufferSizes.length() != 0) {
1578             if (DBG) {
1579                 log("Setting TCP values: [" + bufferSizes
1580                         + "] which comes from [" + key + "]");
1581             }
1582             setBufferSize(bufferSizes);
1583         }
1584     }
1585
1586    /**
1587      * Writes TCP buffer sizes to /sys/kernel/ipv4/tcp_[r/w]mem_[min/def/max]
1588      * which maps to /proc/sys/net/ipv4/tcp_rmem and tcpwmem
1589      *
1590      * @param bufferSizes in the format of "readMin, readInitial, readMax,
1591      *        writeMin, writeInitial, writeMax"
1592      */
1593     private void setBufferSize(String bufferSizes) {
1594         try {
1595             String[] values = bufferSizes.split(",");
1596
1597             if (values.length == 6) {
1598               final String prefix = "/sys/kernel/ipv4/tcp_";
1599                 stringToFile(prefix + "rmem_min", values[0]);
1600                 stringToFile(prefix + "rmem_def", values[1]);
1601                 stringToFile(prefix + "rmem_max", values[2]);
1602                 stringToFile(prefix + "wmem_min", values[3]);
1603                 stringToFile(prefix + "wmem_def", values[4]);
1604                 stringToFile(prefix + "wmem_max", values[5]);
1605             } else {
1606                 loge("Invalid buffersize string: " + bufferSizes);
1607             }
1608         } catch (IOException e) {
1609             loge("Can't set tcp buffer sizes:" + e);
1610         }
1611     }
1612
1613    /**
1614      * Writes string to file. Basically same as "echo -n $string > $filename"
1615      *
1616      * @param filename
1617      * @param string
1618      * @throws IOException
1619      */
1620     private void stringToFile(String filename, String string) throws IOException {
1621         FileWriter out = new FileWriter(filename);
1622         try {
1623             out.write(string);
1624         } finally {
1625             out.close();
1626         }
1627     }
1628
1629
1630     /**
1631      * Adjust the per-process dns entries (net.dns<x>.<pid>) based
1632      * on the highest priority active net which this process requested.
1633      * If there aren't any, clear it out
1634      */
1635     private void reassessPidDns(int myPid, boolean doBump)
1636     {
1637         if (DBG) log("reassessPidDns for pid " + myPid);
1638         for(int i : mPriorityList) {
1639             if (mNetConfigs[i].isDefault()) {
1640                 continue;
1641             }
1642             NetworkStateTracker nt = mNetTrackers[i];
1643             if (nt.getNetworkInfo().isConnected() &&
1644                     !nt.isTeardownRequested()) {
1645                 LinkProperties p = nt.getLinkProperties();
1646                 if (p == null) continue;
1647                 List pids = mNetRequestersPids[i];
1648                 for (int j=0; j<pids.size(); j++) {
1649                     Integer pid = (Integer)pids.get(j);
1650                     if (pid.intValue() == myPid) {
1651                         Collection<InetAddress> dnses = p.getDnses();
1652                         writePidDns(dnses, myPid);
1653                         if (doBump) {
1654                             bumpDns();
1655                         }
1656                         return;
1657                     }
1658                 }
1659            }
1660         }
1661         // nothing found - delete
1662         for (int i = 1; ; i++) {
1663             String prop = "net.dns" + i + "." + myPid;
1664             if (SystemProperties.get(prop).length() == 0) {
1665                 if (doBump) {
1666                     bumpDns();
1667                 }
1668                 return;
1669             }
1670             SystemProperties.set(prop, "");
1671         }
1672     }
1673
1674     // return true if results in a change
1675     private boolean writePidDns(Collection <InetAddress> dnses, int pid) {
1676         int j = 1;
1677         boolean changed = false;
1678         for (InetAddress dns : dnses) {
1679             String dnsString = dns.getHostAddress();
1680             if (changed || !dnsString.equals(SystemProperties.get("net.dns" + j + "." + pid))) {
1681                 changed = true;
1682                 SystemProperties.set("net.dns" + j++ + "." + pid, dns.getHostAddress());
1683             }
1684         }
1685         return changed;
1686     }
1687
1688     private void bumpDns() {
1689         /*
1690          * Bump the property that tells the name resolver library to reread
1691          * the DNS server list from the properties.
1692          */
1693         String propVal = SystemProperties.get("net.dnschange");
1694         int n = 0;
1695         if (propVal.length() != 0) {
1696             try {
1697                 n = Integer.parseInt(propVal);
1698             } catch (NumberFormatException e) {}
1699         }
1700         SystemProperties.set("net.dnschange", "" + (n+1));
1701         /*
1702          * Tell the VMs to toss their DNS caches
1703          */
1704         Intent intent = new Intent(Intent.ACTION_CLEAR_DNS_CACHE);
1705         intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING);
1706         /*
1707          * Connectivity events can happen before boot has completed ...
1708          */
1709         intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
1710         mContext.sendBroadcast(intent);
1711     }
1712
1713     private void handleDnsConfigurationChange(int netType) {
1714         // add default net's dns entries
1715         NetworkStateTracker nt = mNetTrackers[netType];
1716         if (nt != null && nt.getNetworkInfo().isConnected() && !nt.isTeardownRequested()) {
1717             LinkProperties p = nt.getLinkProperties();
1718             if (p == null) return;
1719             Collection<InetAddress> dnses = p.getDnses();
1720             boolean changed = false;
1721             if (mNetConfigs[netType].isDefault()) {
1722                 int j = 1;
1723                 if (dnses.size() == 0 && mDefaultDns != null) {
1724                     String dnsString = mDefaultDns.getHostAddress();
1725                     if (!dnsString.equals(SystemProperties.get("net.dns1"))) {
1726                         if (DBG) {
1727                             log("no dns provided - using " + dnsString);
1728                         }
1729                         changed = true;
1730                         SystemProperties.set("net.dns1", dnsString);
1731                     }
1732                     j++;
1733                 } else {
1734                     for (InetAddress dns : dnses) {
1735                         String dnsString = dns.getHostAddress();
1736                         if (!changed && dnsString.equals(SystemProperties.get("net.dns" + j))) {
1737                             j++;
1738                             continue;
1739                         }
1740                         if (DBG) {
1741                             log("adding dns " + dns + " for " +
1742                                     nt.getNetworkInfo().getTypeName());
1743                         }
1744                         changed = true;
1745                         SystemProperties.set("net.dns" + j++, dnsString);
1746                     }
1747                 }
1748                 for (int k=j ; k<mNumDnsEntries; k++) {
1749                     if (changed || !TextUtils.isEmpty(SystemProperties.get("net.dns" + k))) {
1750                         if (DBG) log("erasing net.dns" + k);
1751                         changed = true;
1752                         SystemProperties.set("net.dns" + k, "");
1753                     }
1754                 }
1755                 mNumDnsEntries = j;
1756             } else {
1757                 // set per-pid dns for attached secondary nets
1758                 List pids = mNetRequestersPids[netType];
1759                 for (int y=0; y< pids.size(); y++) {
1760                     Integer pid = (Integer)pids.get(y);
1761                     changed = writePidDns(dnses, pid.intValue());
1762                 }
1763             }
1764             if (changed) bumpDns();
1765         }
1766     }
1767
1768     private int getRestoreDefaultNetworkDelay(int networkType) {
1769         String restoreDefaultNetworkDelayStr = SystemProperties.get(
1770                 NETWORK_RESTORE_DELAY_PROP_NAME);
1771         if(restoreDefaultNetworkDelayStr != null &&
1772                 restoreDefaultNetworkDelayStr.length() != 0) {
1773             try {
1774                 return Integer.valueOf(restoreDefaultNetworkDelayStr);
1775             } catch (NumberFormatException e) {
1776             }
1777         }
1778         // if the system property isn't set, use the value for the apn type
1779         int ret = RESTORE_DEFAULT_NETWORK_DELAY;
1780
1781         if ((networkType <= ConnectivityManager.MAX_NETWORK_TYPE) &&
1782                 (mNetConfigs[networkType] != null)) {
1783             ret = mNetConfigs[networkType].restoreTime;
1784         }
1785         return ret;
1786     }
1787
1788     @Override
1789     protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
1790         if (mContext.checkCallingOrSelfPermission(
1791                 android.Manifest.permission.DUMP)
1792                 != PackageManager.PERMISSION_GRANTED) {
1793             pw.println("Permission Denial: can't dump ConnectivityService " +
1794                     "from from pid=" + Binder.getCallingPid() + ", uid=" +
1795                     Binder.getCallingUid());
1796             return;
1797         }
1798         pw.println();
1799         for (NetworkStateTracker nst : mNetTrackers) {
1800             if (nst != null) {
1801                 if (nst.getNetworkInfo().isConnected()) {
1802                     pw.println("Active network: " + nst.getNetworkInfo().
1803                             getTypeName());
1804                 }
1805                 pw.println(nst.getNetworkInfo());
1806                 pw.println(nst);
1807                 pw.println();
1808             }
1809         }
1810
1811         pw.println("Network Requester Pids:");
1812         for (int net : mPriorityList) {
1813             String pidString = net + ": ";
1814             for (Object pid : mNetRequestersPids[net]) {
1815                 pidString = pidString + pid.toString() + ", ";
1816             }
1817             pw.println(pidString);
1818         }
1819         pw.println();
1820
1821         pw.println("FeatureUsers:");
1822         for (Object requester : mFeatureUsers) {
1823             pw.println(requester.toString());
1824         }
1825         pw.println();
1826
1827         synchronized (this) {
1828             pw.println("NetworkTranstionWakeLock is currently " +
1829                     (mNetTransitionWakeLock.isHeld() ? "" : "not ") + "held.");
1830             pw.println("It was last requested for "+mNetTransitionWakeLockCausedBy);
1831         }
1832         pw.println();
1833
1834         mTethering.dump(fd, pw, args);
1835
1836         if (mInetLog != null) {
1837             pw.println();
1838             pw.println("Inet condition reports:");
1839             for(int i = 0; i < mInetLog.size(); i++) {
1840                 pw.println(mInetLog.get(i));
1841             }
1842         }
1843     }
1844
1845     // must be stateless - things change under us.
1846     private class MyHandler extends Handler {
1847         public MyHandler(Looper looper) {
1848             super(looper);
1849         }
1850
1851         @Override
1852         public void handleMessage(Message msg) {
1853             NetworkInfo info;
1854             switch (msg.what) {
1855                 case NetworkStateTracker.EVENT_STATE_CHANGED:
1856                     info = (NetworkInfo) msg.obj;
1857                     int type = info.getType();
1858                     NetworkInfo.State state = info.getState();
1859
1860                     if (DBG) log("ConnectivityChange for " +
1861                             info.getTypeName() + ": " +
1862                             state + "/" + info.getDetailedState());
1863
1864                     // Connectivity state changed:
1865                     // [31-13] Reserved for future use
1866                     // [12-9] Network subtype (for mobile network, as defined
1867                     //         by TelephonyManager)
1868                     // [8-3] Detailed state ordinal (as defined by
1869                     //         NetworkInfo.DetailedState)
1870                     // [2-0] Network type (as defined by ConnectivityManager)
1871                     int eventLogParam = (info.getType() & 0x7) |
1872                             ((info.getDetailedState().ordinal() & 0x3f) << 3) |
1873                             (info.getSubtype() << 9);
1874                     EventLog.writeEvent(EventLogTags.CONNECTIVITY_STATE_CHANGED,
1875                             eventLogParam);
1876
1877                     if (info.getDetailedState() ==
1878                             NetworkInfo.DetailedState.FAILED) {
1879                         handleConnectionFailure(info);
1880                     } else if (state == NetworkInfo.State.DISCONNECTED) {
1881                         handleDisconnect(info);
1882                     } else if (state == NetworkInfo.State.SUSPENDED) {
1883                         // TODO: need to think this over.
1884                         // the logic here is, handle SUSPENDED the same as
1885                         // DISCONNECTED. The only difference being we are
1886                         // broadcasting an intent with NetworkInfo that's
1887                         // suspended. This allows the applications an
1888                         // opportunity to handle DISCONNECTED and SUSPENDED
1889                         // differently, or not.
1890                         handleDisconnect(info);
1891                     } else if (state == NetworkInfo.State.CONNECTED) {
1892                         handleConnect(info);
1893                     }
1894                     break;
1895                 case NetworkStateTracker.EVENT_CONFIGURATION_CHANGED:
1896                     info = (NetworkInfo) msg.obj;
1897                     // TODO: Temporary allowing network configuration
1898                     //       change not resetting sockets.
1899                     //       @see bug/4455071
1900                     handleConnectivityChange(info.getType(), false);
1901                     break;
1902                 case EVENT_CLEAR_NET_TRANSITION_WAKELOCK:
1903                     String causedBy = null;
1904                     synchronized (ConnectivityService.this) {
1905                         if (msg.arg1 == mNetTransitionWakeLockSerialNumber &&
1906                                 mNetTransitionWakeLock.isHeld()) {
1907                             mNetTransitionWakeLock.release();
1908                             causedBy = mNetTransitionWakeLockCausedBy;
1909                         }
1910                     }
1911                     if (causedBy != null) {
1912                         log("NetTransition Wakelock for " + causedBy + " released by timeout");
1913                     }
1914                     break;
1915                 case EVENT_RESTORE_DEFAULT_NETWORK:
1916                     FeatureUser u = (FeatureUser)msg.obj;
1917                     u.expire();
1918                     break;
1919                 case EVENT_INET_CONDITION_CHANGE:
1920                 {
1921                     int netType = msg.arg1;
1922                     int condition = msg.arg2;
1923                     handleInetConditionChange(netType, condition);
1924                     break;
1925                 }
1926                 case EVENT_INET_CONDITION_HOLD_END:
1927                 {
1928                     int netType = msg.arg1;
1929                     int sequence = msg.arg2;
1930                     handleInetConditionHoldEnd(netType, sequence);
1931                     break;
1932                 }
1933                 case EVENT_SET_NETWORK_PREFERENCE:
1934                 {
1935                     int preference = msg.arg1;
1936                     handleSetNetworkPreference(preference);
1937                     break;
1938                 }
1939                 case EVENT_SET_BACKGROUND_DATA:
1940                 {
1941                     boolean enabled = (msg.arg1 == ENABLED);
1942                     handleSetBackgroundData(enabled);
1943                     break;
1944                 }
1945                 case EVENT_SET_MOBILE_DATA:
1946                 {
1947                     boolean enabled = (msg.arg1 == ENABLED);
1948                     handleSetMobileData(enabled);
1949                     break;
1950                 }
1951                 case EVENT_APPLY_GLOBAL_HTTP_PROXY:
1952                 {
1953                     handleDeprecatedGlobalHttpProxy();
1954                     break;
1955                 }
1956                 case EVENT_SET_DEPENDENCY_MET:
1957                 {
1958                     boolean met = (msg.arg1 == ENABLED);
1959                     handleSetDependencyMet(msg.arg2, met);
1960                     break;
1961                 }
1962             }
1963         }
1964     }
1965
1966     // javadoc from interface
1967     public int tether(String iface) {
1968         enforceTetherChangePermission();
1969
1970         if (isTetheringSupported()) {
1971             return mTethering.tether(iface);
1972         } else {
1973             return ConnectivityManager.TETHER_ERROR_UNSUPPORTED;
1974         }
1975     }
1976
1977     // javadoc from interface
1978     public int untether(String iface) {
1979         enforceTetherChangePermission();
1980
1981         if (isTetheringSupported()) {
1982             return mTethering.untether(iface);
1983         } else {
1984             return ConnectivityManager.TETHER_ERROR_UNSUPPORTED;
1985         }
1986     }
1987
1988     // javadoc from interface
1989     public int getLastTetherError(String iface) {
1990         enforceTetherAccessPermission();
1991
1992         if (isTetheringSupported()) {
1993             return mTethering.getLastTetherError(iface);
1994         } else {
1995             return ConnectivityManager.TETHER_ERROR_UNSUPPORTED;
1996         }
1997     }
1998
1999     // TODO - proper iface API for selection by property, inspection, etc
2000     public String[] getTetherableUsbRegexs() {
2001         enforceTetherAccessPermission();
2002         if (isTetheringSupported()) {
2003             return mTethering.getTetherableUsbRegexs();
2004         } else {
2005             return new String[0];
2006         }
2007     }
2008
2009     public String[] getTetherableWifiRegexs() {
2010         enforceTetherAccessPermission();
2011         if (isTetheringSupported()) {
2012             return mTethering.getTetherableWifiRegexs();
2013         } else {
2014             return new String[0];
2015         }
2016     }
2017
2018     public String[] getTetherableBluetoothRegexs() {
2019         enforceTetherAccessPermission();
2020         if (isTetheringSupported()) {
2021             return mTethering.getTetherableBluetoothRegexs();
2022         } else {
2023             return new String[0];
2024         }
2025     }
2026
2027     // TODO - move iface listing, queries, etc to new module
2028     // javadoc from interface
2029     public String[] getTetherableIfaces() {
2030         enforceTetherAccessPermission();
2031         return mTethering.getTetherableIfaces();
2032     }
2033
2034     public String[] getTetheredIfaces() {
2035         enforceTetherAccessPermission();
2036         return mTethering.getTetheredIfaces();
2037     }
2038
2039     public String[] getTetheringErroredIfaces() {
2040         enforceTetherAccessPermission();
2041         return mTethering.getErroredIfaces();
2042     }
2043
2044     // if ro.tether.denied = true we default to no tethering
2045     // gservices could set the secure setting to 1 though to enable it on a build where it
2046     // had previously been turned off.
2047     public boolean isTetheringSupported() {
2048         enforceTetherAccessPermission();
2049         int defaultVal = (SystemProperties.get("ro.tether.denied").equals("true") ? 0 : 1);
2050         boolean tetherEnabledInSettings = (Settings.Secure.getInt(mContext.getContentResolver(),
2051                 Settings.Secure.TETHER_SUPPORTED, defaultVal) != 0);
2052         return tetherEnabledInSettings && mTetheringConfigValid;
2053     }
2054
2055     // An API NetworkStateTrackers can call when they lose their network.
2056     // This will automatically be cleared after X seconds or a network becomes CONNECTED,
2057     // whichever happens first.  The timer is started by the first caller and not
2058     // restarted by subsequent callers.
2059     public void requestNetworkTransitionWakelock(String forWhom) {
2060         enforceConnectivityInternalPermission();
2061         synchronized (this) {
2062             if (mNetTransitionWakeLock.isHeld()) return;
2063             mNetTransitionWakeLockSerialNumber++;
2064             mNetTransitionWakeLock.acquire();
2065             mNetTransitionWakeLockCausedBy = forWhom;
2066         }
2067         mHandler.sendMessageDelayed(mHandler.obtainMessage(
2068                 EVENT_CLEAR_NET_TRANSITION_WAKELOCK,
2069                 mNetTransitionWakeLockSerialNumber, 0),
2070                 mNetTransitionWakeLockTimeout);
2071         return;
2072     }
2073
2074     // 100 percent is full good, 0 is full bad.
2075     public void reportInetCondition(int networkType, int percentage) {
2076         if (DBG) log("reportNetworkCondition(" + networkType + ", " + percentage + ")");
2077         mContext.enforceCallingOrSelfPermission(
2078                 android.Manifest.permission.STATUS_BAR,
2079                 "ConnectivityService");
2080
2081         if (DBG) {
2082             int pid = getCallingPid();
2083             int uid = getCallingUid();
2084             String s = pid + "(" + uid + ") reports inet is " +
2085                 (percentage > 50 ? "connected" : "disconnected") + " (" + percentage + ") on " +
2086                 "network Type " + networkType + " at " + GregorianCalendar.getInstance().getTime();
2087             mInetLog.add(s);
2088             while(mInetLog.size() > INET_CONDITION_LOG_MAX_SIZE) {
2089                 mInetLog.remove(0);
2090             }
2091         }
2092         mHandler.sendMessage(mHandler.obtainMessage(
2093             EVENT_INET_CONDITION_CHANGE, networkType, percentage));
2094     }
2095
2096     private void handleInetConditionChange(int netType, int condition) {
2097         if (DBG) {
2098             log("Inet connectivity change, net=" +
2099                     netType + ", condition=" + condition +
2100                     ",mActiveDefaultNetwork=" + mActiveDefaultNetwork);
2101         }
2102         if (mActiveDefaultNetwork == -1) {
2103             if (DBG) log("no active default network - aborting");
2104             return;
2105         }
2106         if (mActiveDefaultNetwork != netType) {
2107             if (DBG) log("given net not default - aborting");
2108             return;
2109         }
2110         mDefaultInetCondition = condition;
2111         int delay;
2112         if (mInetConditionChangeInFlight == false) {
2113             if (DBG) log("starting a change hold");
2114             // setup a new hold to debounce this
2115             if (mDefaultInetCondition > 50) {
2116                 delay = Settings.Secure.getInt(mContext.getContentResolver(),
2117                         Settings.Secure.INET_CONDITION_DEBOUNCE_UP_DELAY, 500);
2118             } else {
2119                 delay = Settings.Secure.getInt(mContext.getContentResolver(),
2120                 Settings.Secure.INET_CONDITION_DEBOUNCE_DOWN_DELAY, 3000);
2121             }
2122             mInetConditionChangeInFlight = true;
2123             mHandler.sendMessageDelayed(mHandler.obtainMessage(EVENT_INET_CONDITION_HOLD_END,
2124                     mActiveDefaultNetwork, mDefaultConnectionSequence), delay);
2125         } else {
2126             // we've set the new condition, when this hold ends that will get
2127             // picked up
2128             if (DBG) log("currently in hold - not setting new end evt");
2129         }
2130     }
2131
2132     private void handleInetConditionHoldEnd(int netType, int sequence) {
2133         if (DBG) {
2134             log("Inet hold end, net=" + netType +
2135                     ", condition =" + mDefaultInetCondition +
2136                     ", published condition =" + mDefaultInetConditionPublished);
2137         }
2138         mInetConditionChangeInFlight = false;
2139
2140         if (mActiveDefaultNetwork == -1) {
2141             if (DBG) log("no active default network - aborting");
2142             return;
2143         }
2144         if (mDefaultConnectionSequence != sequence) {
2145             if (DBG) log("event hold for obsolete network - aborting");
2146             return;
2147         }
2148         if (mDefaultInetConditionPublished == mDefaultInetCondition) {
2149             if (DBG) log("no change in condition - aborting");
2150             return;
2151         }
2152         NetworkInfo networkInfo = mNetTrackers[mActiveDefaultNetwork].getNetworkInfo();
2153         if (networkInfo.isConnected() == false) {
2154             if (DBG) log("default network not connected - aborting");
2155             return;
2156         }
2157         mDefaultInetConditionPublished = mDefaultInetCondition;
2158         sendInetConditionBroadcast(networkInfo);
2159         return;
2160     }
2161
2162     public synchronized ProxyProperties getProxy() {
2163         if (mGlobalProxy != null) return mGlobalProxy;
2164         if (mDefaultProxy != null) return mDefaultProxy;
2165         return null;
2166     }
2167
2168     public void setGlobalProxy(ProxyProperties proxyProperties) {
2169         enforceChangePermission();
2170         synchronized (mGlobalProxyLock) {
2171             if (proxyProperties == mGlobalProxy) return;
2172             if (proxyProperties != null && proxyProperties.equals(mGlobalProxy)) return;
2173             if (mGlobalProxy != null && mGlobalProxy.equals(proxyProperties)) return;
2174
2175             String host = "";
2176             int port = 0;
2177             String exclList = "";
2178             if (proxyProperties != null && !TextUtils.isEmpty(proxyProperties.getHost())) {
2179                 mGlobalProxy = new ProxyProperties(proxyProperties);
2180                 host = mGlobalProxy.getHost();
2181                 port = mGlobalProxy.getPort();
2182                 exclList = mGlobalProxy.getExclusionList();
2183             } else {
2184                 mGlobalProxy = null;
2185             }
2186             ContentResolver res = mContext.getContentResolver();
2187             Settings.Secure.putString(res, Settings.Secure.GLOBAL_HTTP_PROXY_HOST, host);
2188             Settings.Secure.putInt(res, Settings.Secure.GLOBAL_HTTP_PROXY_PORT, port);
2189             Settings.Secure.putString(res, Settings.Secure.GLOBAL_HTTP_PROXY_EXCLUSION_LIST,
2190                     exclList);
2191         }
2192
2193         if (mGlobalProxy == null) {
2194             proxyProperties = mDefaultProxy;
2195         }
2196         sendProxyBroadcast(proxyProperties);
2197     }
2198
2199     private void loadGlobalProxy() {
2200         ContentResolver res = mContext.getContentResolver();
2201         String host = Settings.Secure.getString(res, Settings.Secure.GLOBAL_HTTP_PROXY_HOST);
2202         int port = Settings.Secure.getInt(res, Settings.Secure.GLOBAL_HTTP_PROXY_PORT, 0);
2203         String exclList = Settings.Secure.getString(res,
2204                 Settings.Secure.GLOBAL_HTTP_PROXY_EXCLUSION_LIST);
2205         if (!TextUtils.isEmpty(host)) {
2206             ProxyProperties proxyProperties = new ProxyProperties(host, port, exclList);
2207             synchronized (mGlobalProxyLock) {
2208                 mGlobalProxy = proxyProperties;
2209             }
2210         }
2211     }
2212
2213     public ProxyProperties getGlobalProxy() {
2214         synchronized (mGlobalProxyLock) {
2215             return mGlobalProxy;
2216         }
2217     }
2218
2219     private void handleApplyDefaultProxy(int type) {
2220         // check if new default - push it out to all VM if so
2221         ProxyProperties proxy = mNetTrackers[type].getLinkProperties().getHttpProxy();
2222         synchronized (this) {
2223             if (mDefaultProxy != null && mDefaultProxy.equals(proxy)) return;
2224             if (mDefaultProxy == proxy) return;
2225             if (!TextUtils.isEmpty(proxy.getHost())) {
2226                 mDefaultProxy = proxy;
2227             } else {
2228                 mDefaultProxy = null;
2229             }
2230         }
2231         if (DBG) log("changing default proxy to " + proxy);
2232         if ((proxy == null && mGlobalProxy == null) || proxy.equals(mGlobalProxy)) return;
2233         if (mGlobalProxy != null) return;
2234         sendProxyBroadcast(proxy);
2235     }
2236
2237     private void handleDeprecatedGlobalHttpProxy() {
2238         String proxy = Settings.Secure.getString(mContext.getContentResolver(),
2239                 Settings.Secure.HTTP_PROXY);
2240         if (!TextUtils.isEmpty(proxy)) {
2241             String data[] = proxy.split(":");
2242             String proxyHost =  data[0];
2243             int proxyPort = 8080;
2244             if (data.length > 1) {
2245                 try {
2246                     proxyPort = Integer.parseInt(data[1]);
2247                 } catch (NumberFormatException e) {
2248                     return;
2249                 }
2250             }
2251             ProxyProperties p = new ProxyProperties(data[0], proxyPort, "");
2252             setGlobalProxy(p);
2253         }
2254     }
2255
2256     private void sendProxyBroadcast(ProxyProperties proxy) {
2257         if (proxy == null) proxy = new ProxyProperties("", 0, "");
2258         log("sending Proxy Broadcast for " + proxy);
2259         Intent intent = new Intent(Proxy.PROXY_CHANGE_ACTION);
2260         intent.addFlags(Intent.FLAG_RECEIVER_REPLACE_PENDING |
2261             Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
2262         intent.putExtra(Proxy.EXTRA_PROXY_INFO, proxy);
2263         mContext.sendStickyBroadcast(intent);
2264     }
2265
2266     private static class SettingsObserver extends ContentObserver {
2267         private int mWhat;
2268         private Handler mHandler;
2269         SettingsObserver(Handler handler, int what) {
2270             super(handler);
2271             mHandler = handler;
2272             mWhat = what;
2273         }
2274
2275         void observe(Context context) {
2276             ContentResolver resolver = context.getContentResolver();
2277             resolver.registerContentObserver(Settings.Secure.getUriFor(
2278                     Settings.Secure.HTTP_PROXY), false, this);
2279         }
2280
2281         @Override
2282         public void onChange(boolean selfChange) {
2283             mHandler.obtainMessage(mWhat).sendToTarget();
2284         }
2285     }
2286
2287     private void log(String s) {
2288         Slog.d(TAG, s);
2289     }
2290
2291     private void loge(String s) {
2292         Slog.e(TAG, s);
2293     }
2294     int convertFeatureToNetworkType(String feature){
2295         int networkType = -1;
2296         if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_MMS)) {
2297             networkType = ConnectivityManager.TYPE_MOBILE_MMS;
2298         } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_SUPL)) {
2299             networkType = ConnectivityManager.TYPE_MOBILE_SUPL;
2300         } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_DUN) ||
2301                 TextUtils.equals(feature, Phone.FEATURE_ENABLE_DUN_ALWAYS)) {
2302             networkType = ConnectivityManager.TYPE_MOBILE_DUN;
2303         } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_HIPRI)) {
2304             networkType = ConnectivityManager.TYPE_MOBILE_HIPRI;
2305         } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_FOTA)) {
2306             networkType = ConnectivityManager.TYPE_MOBILE_FOTA;
2307         } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_IMS)) {
2308             networkType = ConnectivityManager.TYPE_MOBILE_IMS;
2309         } else if (TextUtils.equals(feature, Phone.FEATURE_ENABLE_CBS)) {
2310             networkType = ConnectivityManager.TYPE_MOBILE_CBS;
2311         }
2312         return networkType;
2313     }
2314 }