NetworkMonitor.java revision d7b6ca91e9ecac15949a4484d560cfab5833a431
1/* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package com.android.server.connectivity; 18 19import android.app.AlarmManager; 20import android.app.PendingIntent; 21import android.content.BroadcastReceiver; 22import android.content.ComponentName; 23import android.content.Context; 24import android.content.Intent; 25import android.content.IntentFilter; 26import android.net.ConnectivityManager; 27import android.net.NetworkRequest; 28import android.net.ProxyInfo; 29import android.net.TrafficStats; 30import android.net.Uri; 31import android.net.wifi.WifiInfo; 32import android.net.wifi.WifiManager; 33import android.os.Handler; 34import android.os.Message; 35import android.os.Process; 36import android.os.SystemClock; 37import android.os.SystemProperties; 38import android.os.UserHandle; 39import android.provider.Settings; 40import android.telephony.CellIdentityCdma; 41import android.telephony.CellIdentityGsm; 42import android.telephony.CellIdentityLte; 43import android.telephony.CellIdentityWcdma; 44import android.telephony.CellInfo; 45import android.telephony.CellInfoCdma; 46import android.telephony.CellInfoGsm; 47import android.telephony.CellInfoLte; 48import android.telephony.CellInfoWcdma; 49import android.telephony.TelephonyManager; 50import android.util.Log; 51 52import com.android.internal.annotations.VisibleForTesting; 53import com.android.internal.util.Protocol; 54import com.android.internal.util.State; 55import com.android.internal.util.StateMachine; 56import com.android.server.connectivity.NetworkAgentInfo; 57 58import java.io.IOException; 59import java.net.HttpURLConnection; 60import java.net.URL; 61import java.util.List; 62import java.util.Random; 63 64/** 65 * {@hide} 66 */ 67public class NetworkMonitor extends StateMachine { 68 private static final boolean DBG = true; 69 private static final String TAG = "NetworkMonitor"; 70 private static final String DEFAULT_SERVER = "connectivitycheck.android.com"; 71 private static final int SOCKET_TIMEOUT_MS = 10000; 72 public static final String ACTION_NETWORK_CONDITIONS_MEASURED = 73 "android.net.conn.NETWORK_CONDITIONS_MEASURED"; 74 public static final String EXTRA_CONNECTIVITY_TYPE = "extra_connectivity_type"; 75 public static final String EXTRA_NETWORK_TYPE = "extra_network_type"; 76 public static final String EXTRA_RESPONSE_RECEIVED = "extra_response_received"; 77 public static final String EXTRA_IS_CAPTIVE_PORTAL = "extra_is_captive_portal"; 78 public static final String EXTRA_CELL_ID = "extra_cellid"; 79 public static final String EXTRA_SSID = "extra_ssid"; 80 public static final String EXTRA_BSSID = "extra_bssid"; 81 /** real time since boot */ 82 public static final String EXTRA_REQUEST_TIMESTAMP_MS = "extra_request_timestamp_ms"; 83 public static final String EXTRA_RESPONSE_TIMESTAMP_MS = "extra_response_timestamp_ms"; 84 85 private static final String PERMISSION_ACCESS_NETWORK_CONDITIONS = 86 "android.permission.ACCESS_NETWORK_CONDITIONS"; 87 88 // After a network has been tested this result can be sent with EVENT_NETWORK_TESTED. 89 // The network should be used as a default internet connection. It was found to be: 90 // 1. a functioning network providing internet access, or 91 // 2. a captive portal and the user decided to use it as is. 92 public static final int NETWORK_TEST_RESULT_VALID = 0; 93 // After a network has been tested this result can be sent with EVENT_NETWORK_TESTED. 94 // The network should not be used as a default internet connection. It was found to be: 95 // 1. a captive portal and the user is prompted to sign-in, or 96 // 2. a captive portal and the user did not want to use it, or 97 // 3. a broken network (e.g. DNS failed, connect failed, HTTP request failed). 98 public static final int NETWORK_TEST_RESULT_INVALID = 1; 99 100 private static final int BASE = Protocol.BASE_NETWORK_MONITOR; 101 102 /** 103 * Inform NetworkMonitor that their network is connected. 104 * Initiates Network Validation. 105 */ 106 public static final int CMD_NETWORK_CONNECTED = BASE + 1; 107 108 /** 109 * Inform ConnectivityService that the network has been tested. 110 * obj = NetworkAgentInfo 111 * arg1 = One of the NETWORK_TESTED_RESULT_* constants. 112 */ 113 public static final int EVENT_NETWORK_TESTED = BASE + 2; 114 115 /** 116 * Inform NetworkMonitor to linger a network. The Monitor should 117 * start a timer and/or start watching for zero live connections while 118 * moving towards LINGER_COMPLETE. After the Linger period expires 119 * (or other events mark the end of the linger state) the LINGER_COMPLETE 120 * event should be sent and the network will be shut down. If a 121 * CMD_NETWORK_CONNECTED happens before the LINGER completes 122 * it indicates further desire to keep the network alive and so 123 * the LINGER is aborted. 124 */ 125 public static final int CMD_NETWORK_LINGER = BASE + 3; 126 127 /** 128 * Message to self indicating linger delay has expired. 129 * arg1 = Token to ignore old messages. 130 */ 131 private static final int CMD_LINGER_EXPIRED = BASE + 4; 132 133 /** 134 * Inform ConnectivityService that the network LINGER period has 135 * expired. 136 * obj = NetworkAgentInfo 137 */ 138 public static final int EVENT_NETWORK_LINGER_COMPLETE = BASE + 5; 139 140 /** 141 * Message to self indicating it's time to evaluate a network's connectivity. 142 * arg1 = Token to ignore old messages. 143 */ 144 private static final int CMD_REEVALUATE = BASE + 6; 145 146 /** 147 * Inform NetworkMonitor that the network has disconnected. 148 */ 149 public static final int CMD_NETWORK_DISCONNECTED = BASE + 7; 150 151 /** 152 * Force evaluation even if it has succeeded in the past. 153 * arg1 = UID responsible for requesting this reeval. Will be billed for data. 154 */ 155 public static final int CMD_FORCE_REEVALUATION = BASE + 8; 156 157 /** 158 * Message to self indicating captive portal app finished. 159 * arg1 = one of: CAPTIVE_PORTAL_APP_RETURN_DISMISSED, 160 * CAPTIVE_PORTAL_APP_RETURN_UNWANTED, 161 * CAPTIVE_PORTAL_APP_RETURN_WANTED_AS_IS 162 * obj = mCaptivePortalLoggedInResponseToken as String 163 */ 164 public static final int CMD_CAPTIVE_PORTAL_APP_FINISHED = BASE + 9; 165 166 /** 167 * Request ConnectivityService display provisioning notification. 168 * arg1 = Whether to make the notification visible. 169 * arg2 = NetID. 170 * obj = Intent to be launched when notification selected by user, null if !arg1. 171 */ 172 public static final int EVENT_PROVISIONING_NOTIFICATION = BASE + 10; 173 174 /** 175 * Message to self indicating sign-in app should be launched. 176 * Sent by mLaunchCaptivePortalAppBroadcastReceiver when the 177 * user touches the sign in notification. 178 */ 179 private static final int CMD_LAUNCH_CAPTIVE_PORTAL_APP = BASE + 11; 180 181 private static final String LINGER_DELAY_PROPERTY = "persist.netmon.linger"; 182 // Default to 30s linger time-out. Modifyable only for testing. 183 private static int DEFAULT_LINGER_DELAY_MS = 30000; 184 private final int mLingerDelayMs; 185 private int mLingerToken = 0; 186 187 // Start mReevaluateDelayMs at this value and double. 188 private static final int INITIAL_REEVALUATE_DELAY_MS = 1000; 189 private static final int MAX_REEVALUATE_DELAY_MS = 10*60*1000; 190 // Before network has been evaluated this many times, ignore repeated reevaluate requests. 191 private static final int IGNORE_REEVALUATE_ATTEMPTS = 5; 192 private int mReevaluateToken = 0; 193 private static final int INVALID_UID = -1; 194 private int mUidResponsibleForReeval = INVALID_UID; 195 // Stop blaming UID that requested re-evaluation after this many attempts. 196 private static final int BLAME_FOR_EVALUATION_ATTEMPTS = 5; 197 198 private final Context mContext; 199 private final Handler mConnectivityServiceHandler; 200 private final NetworkAgentInfo mNetworkAgentInfo; 201 private final TelephonyManager mTelephonyManager; 202 private final WifiManager mWifiManager; 203 private final AlarmManager mAlarmManager; 204 private final NetworkRequest mDefaultRequest; 205 206 private String mServer; 207 private boolean mIsCaptivePortalCheckEnabled = false; 208 209 // Set if the user explicitly selected "Do not use this network" in captive portal sign-in app. 210 private boolean mUserDoesNotWant = false; 211 // Avoids surfacing "Sign in to network" notification. 212 private boolean mDontDisplaySigninNotification = false; 213 214 public boolean systemReady = false; 215 216 private final State mDefaultState = new DefaultState(); 217 private final State mValidatedState = new ValidatedState(); 218 private final State mMaybeNotifyState = new MaybeNotifyState(); 219 private final State mEvaluatingState = new EvaluatingState(); 220 private final State mCaptivePortalState = new CaptivePortalState(); 221 private final State mLingeringState = new LingeringState(); 222 223 private CustomIntentReceiver mLaunchCaptivePortalAppBroadcastReceiver = null; 224 private String mCaptivePortalLoggedInResponseToken = null; 225 226 public NetworkMonitor(Context context, Handler handler, NetworkAgentInfo networkAgentInfo, 227 NetworkRequest defaultRequest) { 228 // Add suffix indicating which NetworkMonitor we're talking about. 229 super(TAG + networkAgentInfo.name()); 230 231 mContext = context; 232 mConnectivityServiceHandler = handler; 233 mNetworkAgentInfo = networkAgentInfo; 234 mTelephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); 235 mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE); 236 mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); 237 mDefaultRequest = defaultRequest; 238 239 addState(mDefaultState); 240 addState(mValidatedState, mDefaultState); 241 addState(mMaybeNotifyState, mDefaultState); 242 addState(mEvaluatingState, mMaybeNotifyState); 243 addState(mCaptivePortalState, mMaybeNotifyState); 244 addState(mLingeringState, mDefaultState); 245 setInitialState(mDefaultState); 246 247 mServer = Settings.Global.getString(mContext.getContentResolver(), 248 Settings.Global.CAPTIVE_PORTAL_SERVER); 249 if (mServer == null) mServer = DEFAULT_SERVER; 250 251 mLingerDelayMs = SystemProperties.getInt(LINGER_DELAY_PROPERTY, DEFAULT_LINGER_DELAY_MS); 252 253 mIsCaptivePortalCheckEnabled = Settings.Global.getInt(mContext.getContentResolver(), 254 Settings.Global.CAPTIVE_PORTAL_DETECTION_ENABLED, 1) == 1; 255 256 mCaptivePortalLoggedInResponseToken = String.valueOf(new Random().nextLong()); 257 258 start(); 259 } 260 261 @Override 262 protected void log(String s) { 263 Log.d(TAG + "/" + mNetworkAgentInfo.name(), s); 264 } 265 266 // DefaultState is the parent of all States. It exists only to handle CMD_* messages but 267 // does not entail any real state (hence no enter() or exit() routines). 268 private class DefaultState extends State { 269 @Override 270 public boolean processMessage(Message message) { 271 if (DBG) log(getName() + message.toString()); 272 switch (message.what) { 273 case CMD_NETWORK_LINGER: 274 if (DBG) log("Lingering"); 275 transitionTo(mLingeringState); 276 return HANDLED; 277 case CMD_NETWORK_CONNECTED: 278 if (DBG) log("Connected"); 279 transitionTo(mEvaluatingState); 280 return HANDLED; 281 case CMD_NETWORK_DISCONNECTED: 282 if (DBG) log("Disconnected - quitting"); 283 if (mLaunchCaptivePortalAppBroadcastReceiver != null) { 284 mContext.unregisterReceiver(mLaunchCaptivePortalAppBroadcastReceiver); 285 mLaunchCaptivePortalAppBroadcastReceiver = null; 286 } 287 quit(); 288 return HANDLED; 289 case CMD_FORCE_REEVALUATION: 290 if (DBG) log("Forcing reevaluation"); 291 mUidResponsibleForReeval = message.arg1; 292 transitionTo(mEvaluatingState); 293 return HANDLED; 294 case CMD_CAPTIVE_PORTAL_APP_FINISHED: 295 if (!mCaptivePortalLoggedInResponseToken.equals((String)message.obj)) 296 return HANDLED; 297 // Previous token was sent out, come up with a new one. 298 mCaptivePortalLoggedInResponseToken = String.valueOf(new Random().nextLong()); 299 switch (message.arg1) { 300 case ConnectivityManager.CAPTIVE_PORTAL_APP_RETURN_DISMISSED: 301 sendMessage(CMD_FORCE_REEVALUATION, 0 /* no UID */, 0); 302 break; 303 case ConnectivityManager.CAPTIVE_PORTAL_APP_RETURN_WANTED_AS_IS: 304 mDontDisplaySigninNotification = true; 305 // TODO: Distinguish this from a network that actually validates. 306 // Displaying the "!" on the system UI icon may still be a good idea. 307 transitionTo(mValidatedState); 308 break; 309 case ConnectivityManager.CAPTIVE_PORTAL_APP_RETURN_UNWANTED: 310 mDontDisplaySigninNotification = true; 311 mUserDoesNotWant = true; 312 mConnectivityServiceHandler.sendMessage(obtainMessage( 313 EVENT_NETWORK_TESTED, NETWORK_TEST_RESULT_INVALID, 0, 314 mNetworkAgentInfo)); 315 // TODO: Should teardown network. 316 mUidResponsibleForReeval = 0; 317 transitionTo(mEvaluatingState); 318 break; 319 } 320 return HANDLED; 321 default: 322 return HANDLED; 323 } 324 } 325 } 326 327 // Being in the ValidatedState State indicates a Network is: 328 // - Successfully validated, or 329 // - Wanted "as is" by the user, or 330 // - Does not satsify the default NetworkRequest and so validation has been skipped. 331 private class ValidatedState extends State { 332 @Override 333 public void enter() { 334 if (DBG) log("Validated"); 335 mConnectivityServiceHandler.sendMessage(obtainMessage(EVENT_NETWORK_TESTED, 336 NETWORK_TEST_RESULT_VALID, 0, mNetworkAgentInfo)); 337 } 338 339 @Override 340 public boolean processMessage(Message message) { 341 if (DBG) log(getName() + message.toString()); 342 switch (message.what) { 343 case CMD_NETWORK_CONNECTED: 344 transitionTo(mValidatedState); 345 return HANDLED; 346 default: 347 return NOT_HANDLED; 348 } 349 } 350 } 351 352 // Being in the MaybeNotifyState State indicates the user may have been notified that sign-in 353 // is required. This State takes care to clear the notification upon exit from the State. 354 private class MaybeNotifyState extends State { 355 @Override 356 public boolean processMessage(Message message) { 357 if (DBG) log(getName() + message.toString()); 358 switch (message.what) { 359 case CMD_LAUNCH_CAPTIVE_PORTAL_APP: 360 final Intent intent = new Intent( 361 ConnectivityManager.ACTION_CAPTIVE_PORTAL_SIGN_IN); 362 intent.putExtra(ConnectivityManager.EXTRA_NETWORK, mNetworkAgentInfo.network); 363 intent.putExtra(ConnectivityManager.EXTRA_CAPTIVE_PORTAL_TOKEN, 364 mCaptivePortalLoggedInResponseToken); 365 intent.setFlags( 366 Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT | Intent.FLAG_ACTIVITY_NEW_TASK); 367 mContext.startActivityAsUser(intent, UserHandle.CURRENT); 368 return HANDLED; 369 default: 370 return NOT_HANDLED; 371 } 372 } 373 374 @Override 375 public void exit() { 376 Message message = obtainMessage(EVENT_PROVISIONING_NOTIFICATION, 0, 377 mNetworkAgentInfo.network.netId, null); 378 mConnectivityServiceHandler.sendMessage(message); 379 } 380 } 381 382 // Being in the EvaluatingState State indicates the Network is being evaluated for internet 383 // connectivity, or that the user has indicated that this network is unwanted. 384 private class EvaluatingState extends State { 385 private int mReevaluateDelayMs; 386 private int mAttempts; 387 388 @Override 389 public void enter() { 390 sendMessage(CMD_REEVALUATE, ++mReevaluateToken, 0); 391 if (mUidResponsibleForReeval != INVALID_UID) { 392 TrafficStats.setThreadStatsUid(mUidResponsibleForReeval); 393 mUidResponsibleForReeval = INVALID_UID; 394 } 395 mReevaluateDelayMs = INITIAL_REEVALUATE_DELAY_MS; 396 mAttempts = 0; 397 } 398 399 @Override 400 public boolean processMessage(Message message) { 401 if (DBG) log(getName() + message.toString()); 402 switch (message.what) { 403 case CMD_REEVALUATE: 404 if (message.arg1 != mReevaluateToken || mUserDoesNotWant) 405 return HANDLED; 406 // Don't bother validating networks that don't satisify the default request. 407 // This includes: 408 // - VPNs which can be considered explicitly desired by the user and the 409 // user's desire trumps whether the network validates. 410 // - Networks that don't provide internet access. It's unclear how to 411 // validate such networks. 412 // - Untrusted networks. It's unsafe to prompt the user to sign-in to 413 // such networks and the user didn't express interest in connecting to 414 // such networks (an app did) so the user may be unhappily surprised when 415 // asked to sign-in to a network they didn't want to connect to in the 416 // first place. Validation could be done to adjust the network scores 417 // however these networks are app-requested and may not be intended for 418 // general usage, in which case general validation may not be an accurate 419 // measure of the network's quality. Only the app knows how to evaluate 420 // the network so don't bother validating here. Furthermore sending HTTP 421 // packets over the network may be undesirable, for example an extremely 422 // expensive metered network, or unwanted leaking of the User Agent string. 423 if (!mDefaultRequest.networkCapabilities.satisfiedByNetworkCapabilities( 424 mNetworkAgentInfo.networkCapabilities)) { 425 transitionTo(mValidatedState); 426 return HANDLED; 427 } 428 mAttempts++; 429 // Note: This call to isCaptivePortal() could take up to a minute. Resolving the 430 // server's IP addresses could hit the DNS timeout, and attempting connections 431 // to each of the server's several IP addresses (currently one IPv4 and one 432 // IPv6) could each take SOCKET_TIMEOUT_MS. During this time this StateMachine 433 // will be unresponsive. isCaptivePortal() could be executed on another Thread 434 // if this is found to cause problems. 435 int httpResponseCode = isCaptivePortal(); 436 if (httpResponseCode == 204) { 437 transitionTo(mValidatedState); 438 } else if (httpResponseCode >= 200 && httpResponseCode <= 399) { 439 transitionTo(mCaptivePortalState); 440 } else { 441 final Message msg = obtainMessage(CMD_REEVALUATE, ++mReevaluateToken, 0); 442 sendMessageDelayed(msg, mReevaluateDelayMs); 443 mConnectivityServiceHandler.sendMessage(obtainMessage( 444 EVENT_NETWORK_TESTED, NETWORK_TEST_RESULT_INVALID, 0, 445 mNetworkAgentInfo)); 446 if (mAttempts >= BLAME_FOR_EVALUATION_ATTEMPTS) { 447 // Don't continue to blame UID forever. 448 TrafficStats.clearThreadStatsUid(); 449 } 450 mReevaluateDelayMs *= 2; 451 if (mReevaluateDelayMs > MAX_REEVALUATE_DELAY_MS) { 452 mReevaluateDelayMs = MAX_REEVALUATE_DELAY_MS; 453 } 454 } 455 return HANDLED; 456 case CMD_FORCE_REEVALUATION: 457 // Before IGNORE_REEVALUATE_ATTEMPTS attempts are made, 458 // ignore any re-evaluation requests. After, restart the 459 // evaluation process via EvaluatingState#enter. 460 return mAttempts < IGNORE_REEVALUATE_ATTEMPTS ? HANDLED : NOT_HANDLED; 461 default: 462 return NOT_HANDLED; 463 } 464 } 465 466 @Override 467 public void exit() { 468 TrafficStats.clearThreadStatsUid(); 469 } 470 } 471 472 // BroadcastReceiver that waits for a particular Intent and then posts a message. 473 private class CustomIntentReceiver extends BroadcastReceiver { 474 private final int mToken; 475 private final int mWhat; 476 private final String mAction; 477 CustomIntentReceiver(String action, int token, int what) { 478 mToken = token; 479 mWhat = what; 480 mAction = action + "_" + mNetworkAgentInfo.network.netId + "_" + token; 481 mContext.registerReceiver(this, new IntentFilter(mAction)); 482 } 483 public PendingIntent getPendingIntent() { 484 final Intent intent = new Intent(mAction); 485 intent.setPackage(mContext.getPackageName()); 486 return PendingIntent.getBroadcast(mContext, 0, intent, 0); 487 } 488 @Override 489 public void onReceive(Context context, Intent intent) { 490 if (intent.getAction().equals(mAction)) sendMessage(obtainMessage(mWhat, mToken)); 491 } 492 } 493 494 // Being in the CaptivePortalState State indicates a captive portal was detected and the user 495 // has been shown a notification to sign-in. 496 private class CaptivePortalState extends State { 497 private static final String ACTION_LAUNCH_CAPTIVE_PORTAL_APP = 498 "android.net.netmon.launchCaptivePortalApp"; 499 500 @Override 501 public void enter() { 502 mConnectivityServiceHandler.sendMessage(obtainMessage(EVENT_NETWORK_TESTED, 503 NETWORK_TEST_RESULT_INVALID, 0, mNetworkAgentInfo)); 504 // Don't annoy user with sign-in notifications. 505 if (mDontDisplaySigninNotification) return; 506 // Create a CustomIntentReceiver that sends us a 507 // CMD_LAUNCH_CAPTIVE_PORTAL_APP message when the user 508 // touches the notification. 509 if (mLaunchCaptivePortalAppBroadcastReceiver == null) { 510 // Wait for result. 511 mLaunchCaptivePortalAppBroadcastReceiver = new CustomIntentReceiver( 512 ACTION_LAUNCH_CAPTIVE_PORTAL_APP, new Random().nextInt(), 513 CMD_LAUNCH_CAPTIVE_PORTAL_APP); 514 } 515 // Display the sign in notification. 516 Message message = obtainMessage(EVENT_PROVISIONING_NOTIFICATION, 1, 517 mNetworkAgentInfo.network.netId, 518 mLaunchCaptivePortalAppBroadcastReceiver.getPendingIntent()); 519 mConnectivityServiceHandler.sendMessage(message); 520 } 521 522 @Override 523 public boolean processMessage(Message message) { 524 if (DBG) log(getName() + message.toString()); 525 return NOT_HANDLED; 526 } 527 } 528 529 // Being in the LingeringState State indicates a Network's validated bit is true and it once 530 // was the highest scoring Network satisfying a particular NetworkRequest, but since then 531 // another Network satsified the NetworkRequest with a higher score and hence this Network 532 // is "lingered" for a fixed period of time before it is disconnected. This period of time 533 // allows apps to wrap up communication and allows for seamless reactivation if the other 534 // higher scoring Network happens to disconnect. 535 private class LingeringState extends State { 536 private static final String ACTION_LINGER_EXPIRED = "android.net.netmon.lingerExpired"; 537 538 private CustomIntentReceiver mBroadcastReceiver; 539 private PendingIntent mIntent; 540 541 @Override 542 public void enter() { 543 mLingerToken = new Random().nextInt(); 544 mBroadcastReceiver = new CustomIntentReceiver(ACTION_LINGER_EXPIRED, mLingerToken, 545 CMD_LINGER_EXPIRED); 546 mIntent = mBroadcastReceiver.getPendingIntent(); 547 long wakeupTime = SystemClock.elapsedRealtime() + mLingerDelayMs; 548 mAlarmManager.setWindow(AlarmManager.ELAPSED_REALTIME_WAKEUP, wakeupTime, 549 // Give a specific window so we aren't subject to unknown inexactitude. 550 mLingerDelayMs / 6, mIntent); 551 } 552 553 @Override 554 public boolean processMessage(Message message) { 555 if (DBG) log(getName() + message.toString()); 556 switch (message.what) { 557 case CMD_NETWORK_CONNECTED: 558 // Go straight to active as we've already evaluated. 559 transitionTo(mValidatedState); 560 return HANDLED; 561 case CMD_LINGER_EXPIRED: 562 if (message.arg1 != mLingerToken) 563 return HANDLED; 564 mConnectivityServiceHandler.sendMessage( 565 obtainMessage(EVENT_NETWORK_LINGER_COMPLETE, mNetworkAgentInfo)); 566 return HANDLED; 567 case CMD_FORCE_REEVALUATION: 568 // Ignore reevaluation attempts when lingering. A reevaluation could result 569 // in a transition to the validated state which would abort the linger 570 // timeout. Lingering is the result of score assessment; validity is 571 // irrelevant. 572 return HANDLED; 573 case CMD_CAPTIVE_PORTAL_APP_FINISHED: 574 // Ignore user network determination as this could abort linger timeout. 575 // Networks are only lingered once validated because: 576 // - Unvalidated networks are never lingered (see rematchNetworkAndRequests). 577 // - Once validated, a Network's validated bit is never cleared. 578 // Since networks are only lingered after being validated a user's 579 // determination will not change the death sentence that lingering entails: 580 // - If the user wants to use the network or bypasses the captive portal, 581 // the network's score will not be increased beyond its current value 582 // because it is already validated. Without a score increase there is no 583 // chance of reactivation (i.e. aborting linger timeout). 584 // - If the user does not want the network, lingering will disconnect the 585 // network anyhow. 586 return HANDLED; 587 default: 588 return NOT_HANDLED; 589 } 590 } 591 592 @Override 593 public void exit() { 594 mAlarmManager.cancel(mIntent); 595 mContext.unregisterReceiver(mBroadcastReceiver); 596 } 597 } 598 599 /** 600 * Do a URL fetch on a known server to see if we get the data we expect. 601 * Returns HTTP response code. 602 */ 603 private int isCaptivePortal() { 604 if (!mIsCaptivePortalCheckEnabled) return 204; 605 606 HttpURLConnection urlConnection = null; 607 int httpResponseCode = 599; 608 try { 609 URL url = new URL("http", mServer, "/generate_204"); 610 // On networks with a PAC instead of fetching a URL that should result in a 204 611 // reponse, we instead simply fetch the PAC script. This is done for a few reasons: 612 // 1. At present our PAC code does not yet handle multiple PACs on multiple networks 613 // until something like https://android-review.googlesource.com/#/c/115180/ lands. 614 // Network.openConnection() will ignore network-specific PACs and instead fetch 615 // using NO_PROXY. If a PAC is in place, the only fetch we know will succeed with 616 // NO_PROXY is the fetch of the PAC itself. 617 // 2. To proxy the generate_204 fetch through a PAC would require a number of things 618 // happen before the fetch can commence, namely: 619 // a) the PAC script be fetched 620 // b) a PAC script resolver service be fired up and resolve mServer 621 // Network validation could be delayed until these prerequisities are satisifed or 622 // could simply be left to race them. Neither is an optimal solution. 623 // 3. PAC scripts are sometimes used to block or restrict Internet access and may in 624 // fact block fetching of the generate_204 URL which would lead to false negative 625 // results for network validation. 626 boolean fetchPac = false; 627 { 628 final ProxyInfo proxyInfo = mNetworkAgentInfo.linkProperties.getHttpProxy(); 629 if (proxyInfo != null && !Uri.EMPTY.equals(proxyInfo.getPacFileUrl())) { 630 url = new URL(proxyInfo.getPacFileUrl().toString()); 631 fetchPac = true; 632 } 633 } 634 if (DBG) { 635 log("Checking " + url.toString() + " on " + 636 mNetworkAgentInfo.networkInfo.getExtraInfo()); 637 } 638 urlConnection = (HttpURLConnection) mNetworkAgentInfo.network.openConnection(url); 639 urlConnection.setInstanceFollowRedirects(fetchPac); 640 urlConnection.setConnectTimeout(SOCKET_TIMEOUT_MS); 641 urlConnection.setReadTimeout(SOCKET_TIMEOUT_MS); 642 urlConnection.setUseCaches(false); 643 644 // Time how long it takes to get a response to our request 645 long requestTimestamp = SystemClock.elapsedRealtime(); 646 647 urlConnection.getInputStream(); 648 649 // Time how long it takes to get a response to our request 650 long responseTimestamp = SystemClock.elapsedRealtime(); 651 652 httpResponseCode = urlConnection.getResponseCode(); 653 if (DBG) { 654 log("isCaptivePortal: ret=" + httpResponseCode + 655 " headers=" + urlConnection.getHeaderFields()); 656 } 657 // NOTE: We may want to consider an "HTTP/1.0 204" response to be a captive 658 // portal. The only example of this seen so far was a captive portal. For 659 // the time being go with prior behavior of assuming it's not a captive 660 // portal. If it is considered a captive portal, a different sign-in URL 661 // is needed (i.e. can't browse a 204). This could be the result of an HTTP 662 // proxy server. 663 664 // Consider 200 response with "Content-length=0" to not be a captive portal. 665 // There's no point in considering this a captive portal as the user cannot 666 // sign-in to an empty page. Probably the result of a broken transparent proxy. 667 // See http://b/9972012. 668 if (httpResponseCode == 200 && urlConnection.getContentLength() == 0) { 669 if (DBG) log("Empty 200 response interpreted as 204 response."); 670 httpResponseCode = 204; 671 } 672 673 if (httpResponseCode == 200 && fetchPac) { 674 if (DBG) log("PAC fetch 200 response interpreted as 204 response."); 675 httpResponseCode = 204; 676 } 677 678 sendNetworkConditionsBroadcast(true /* response received */, 679 httpResponseCode != 204 /* isCaptivePortal */, 680 requestTimestamp, responseTimestamp); 681 } catch (IOException e) { 682 if (DBG) log("Probably not a portal: exception " + e); 683 if (httpResponseCode == 599) { 684 // TODO: Ping gateway and DNS server and log results. 685 } 686 } finally { 687 if (urlConnection != null) { 688 urlConnection.disconnect(); 689 } 690 } 691 return httpResponseCode; 692 } 693 694 /** 695 * @param responseReceived - whether or not we received a valid HTTP response to our request. 696 * If false, isCaptivePortal and responseTimestampMs are ignored 697 * TODO: This should be moved to the transports. The latency could be passed to the transports 698 * along with the captive portal result. Currently the TYPE_MOBILE broadcasts appear unused so 699 * perhaps this could just be added to the WiFi transport only. 700 */ 701 private void sendNetworkConditionsBroadcast(boolean responseReceived, boolean isCaptivePortal, 702 long requestTimestampMs, long responseTimestampMs) { 703 if (Settings.Global.getInt(mContext.getContentResolver(), 704 Settings.Global.WIFI_SCAN_ALWAYS_AVAILABLE, 0) == 0) { 705 if (DBG) log("Don't send network conditions - lacking user consent."); 706 return; 707 } 708 709 if (systemReady == false) return; 710 711 Intent latencyBroadcast = new Intent(ACTION_NETWORK_CONDITIONS_MEASURED); 712 switch (mNetworkAgentInfo.networkInfo.getType()) { 713 case ConnectivityManager.TYPE_WIFI: 714 WifiInfo currentWifiInfo = mWifiManager.getConnectionInfo(); 715 if (currentWifiInfo != null) { 716 // NOTE: getSSID()'s behavior changed in API 17; before that, SSIDs were not 717 // surrounded by double quotation marks (thus violating the Javadoc), but this 718 // was changed to match the Javadoc in API 17. Since clients may have started 719 // sanitizing the output of this method since API 17 was released, we should 720 // not change it here as it would become impossible to tell whether the SSID is 721 // simply being surrounded by quotes due to the API, or whether those quotes 722 // are actually part of the SSID. 723 latencyBroadcast.putExtra(EXTRA_SSID, currentWifiInfo.getSSID()); 724 latencyBroadcast.putExtra(EXTRA_BSSID, currentWifiInfo.getBSSID()); 725 } else { 726 if (DBG) logw("network info is TYPE_WIFI but no ConnectionInfo found"); 727 return; 728 } 729 break; 730 case ConnectivityManager.TYPE_MOBILE: 731 latencyBroadcast.putExtra(EXTRA_NETWORK_TYPE, mTelephonyManager.getNetworkType()); 732 List<CellInfo> info = mTelephonyManager.getAllCellInfo(); 733 if (info == null) return; 734 int numRegisteredCellInfo = 0; 735 for (CellInfo cellInfo : info) { 736 if (cellInfo.isRegistered()) { 737 numRegisteredCellInfo++; 738 if (numRegisteredCellInfo > 1) { 739 if (DBG) log("more than one registered CellInfo. Can't " + 740 "tell which is active. Bailing."); 741 return; 742 } 743 if (cellInfo instanceof CellInfoCdma) { 744 CellIdentityCdma cellId = ((CellInfoCdma) cellInfo).getCellIdentity(); 745 latencyBroadcast.putExtra(EXTRA_CELL_ID, cellId); 746 } else if (cellInfo instanceof CellInfoGsm) { 747 CellIdentityGsm cellId = ((CellInfoGsm) cellInfo).getCellIdentity(); 748 latencyBroadcast.putExtra(EXTRA_CELL_ID, cellId); 749 } else if (cellInfo instanceof CellInfoLte) { 750 CellIdentityLte cellId = ((CellInfoLte) cellInfo).getCellIdentity(); 751 latencyBroadcast.putExtra(EXTRA_CELL_ID, cellId); 752 } else if (cellInfo instanceof CellInfoWcdma) { 753 CellIdentityWcdma cellId = ((CellInfoWcdma) cellInfo).getCellIdentity(); 754 latencyBroadcast.putExtra(EXTRA_CELL_ID, cellId); 755 } else { 756 if (DBG) logw("Registered cellinfo is unrecognized"); 757 return; 758 } 759 } 760 } 761 break; 762 default: 763 return; 764 } 765 latencyBroadcast.putExtra(EXTRA_CONNECTIVITY_TYPE, mNetworkAgentInfo.networkInfo.getType()); 766 latencyBroadcast.putExtra(EXTRA_RESPONSE_RECEIVED, responseReceived); 767 latencyBroadcast.putExtra(EXTRA_REQUEST_TIMESTAMP_MS, requestTimestampMs); 768 769 if (responseReceived) { 770 latencyBroadcast.putExtra(EXTRA_IS_CAPTIVE_PORTAL, isCaptivePortal); 771 latencyBroadcast.putExtra(EXTRA_RESPONSE_TIMESTAMP_MS, responseTimestampMs); 772 } 773 mContext.sendBroadcastAsUser(latencyBroadcast, UserHandle.CURRENT, 774 PERMISSION_ACCESS_NETWORK_CONDITIONS); 775 } 776 777 // Allow tests to override linger time. 778 @VisibleForTesting 779 public static void SetDefaultLingerTime(int time_ms) { 780 if (Process.myUid() == Process.SYSTEM_UID) { 781 throw new SecurityException("SetDefaultLingerTime only for internal testing."); 782 } 783 DEFAULT_LINGER_DELAY_MS = time_ms; 784 } 785} 786