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 17package com.android.internal.telephony.mocks; 18 19import static android.Manifest.permission.RECEIVE_DATA_ACTIVITY_CHANGE; 20import static android.net.ConnectivityManager.CONNECTIVITY_ACTION; 21import static android.net.ConnectivityManager.NETID_UNSET; 22import static android.net.ConnectivityManager.TYPE_NONE; 23import static android.net.ConnectivityManager.TYPE_VPN; 24import static android.net.ConnectivityManager.getNetworkTypeName; 25import static android.net.ConnectivityManager.isNetworkTypeValid; 26import static android.net.NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL; 27import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET; 28import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_METERED; 29import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED; 30import static android.net.NetworkCapabilities.NET_CAPABILITY_VALIDATED; 31import static android.net.NetworkPolicyManager.RULE_ALLOW_ALL; 32import static android.net.NetworkPolicyManager.RULE_REJECT_ALL; 33import static android.net.NetworkPolicyManager.RULE_REJECT_METERED; 34 35import android.annotation.Nullable; 36import android.app.AlarmManager; 37import android.app.BroadcastOptions; 38import android.app.Notification; 39import android.app.NotificationManager; 40import android.app.PendingIntent; 41import android.content.BroadcastReceiver; 42import android.content.ContentResolver; 43import android.content.Context; 44import android.content.Intent; 45import android.content.IntentFilter; 46import android.content.pm.PackageManager; 47import android.content.res.Configuration; 48import android.content.res.Resources; 49import android.database.ContentObserver; 50import android.net.ConnectivityManager; 51import android.net.ConnectivityManager.PacketKeepalive; 52import android.net.IConnectivityManager; 53import android.net.INetworkManagementEventObserver; 54import android.net.INetworkPolicyListener; 55import android.net.INetworkPolicyManager; 56import android.net.INetworkStatsService; 57import android.net.LinkProperties; 58import android.net.LinkProperties.CompareResult; 59import android.net.Network; 60import android.net.NetworkAgent; 61import android.net.NetworkCapabilities; 62import android.net.NetworkConfig; 63import android.net.NetworkInfo; 64import android.net.NetworkInfo.DetailedState; 65import android.net.NetworkMisc; 66import android.net.NetworkQuotaInfo; 67import android.net.NetworkRequest; 68import android.net.NetworkState; 69import android.net.NetworkUtils; 70import android.net.Proxy; 71import android.net.ProxyInfo; 72import android.net.RouteInfo; 73import android.net.UidRange; 74import android.net.Uri; 75import android.os.Binder; 76import android.os.Build; 77import android.os.Bundle; 78import android.os.FileUtils; 79import android.os.Handler; 80import android.os.HandlerThread; 81import android.os.IBinder; 82import android.os.INetworkManagementService; 83import android.os.Looper; 84import android.os.Message; 85import android.os.Messenger; 86import android.os.ParcelFileDescriptor; 87import android.os.PowerManager; 88import android.os.Process; 89import android.os.RemoteException; 90import android.os.ResultReceiver; 91import android.os.SystemClock; 92import android.os.SystemProperties; 93import android.os.UserHandle; 94import android.os.UserManager; 95import android.provider.Settings; 96import android.security.Credentials; 97import android.security.KeyStore; 98import android.telephony.TelephonyManager; 99import android.text.TextUtils; 100import android.util.LocalLog; 101import android.util.LocalLog.ReadOnlyLocalLog; 102import android.util.Pair; 103import android.util.Slog; 104import android.util.SparseArray; 105import android.util.SparseBooleanArray; 106import android.util.SparseIntArray; 107import android.util.Xml; 108 109import com.android.internal.R; 110import com.android.internal.annotations.GuardedBy; 111import com.android.internal.annotations.VisibleForTesting; 112import com.android.internal.net.LegacyVpnInfo; 113import com.android.internal.net.VpnConfig; 114import com.android.internal.net.VpnInfo; 115import com.android.internal.net.VpnProfile; 116import com.android.internal.util.AsyncChannel; 117import com.android.server.connectivity.NetworkAgentInfo; 118import com.android.server.connectivity.NetworkMonitor; 119 120import java.io.File; 121import java.io.FileDescriptor; 122import java.io.FileNotFoundException; 123import java.io.FileReader; 124import java.io.IOException; 125import java.io.PrintWriter; 126import java.net.Inet4Address; 127import java.net.InetAddress; 128import java.net.UnknownHostException; 129import java.util.ArrayDeque; 130import java.util.ArrayList; 131import java.util.Arrays; 132import java.util.Collection; 133import java.util.HashMap; 134import java.util.HashSet; 135import java.util.SortedSet; 136import java.util.TreeSet; 137import java.util.Iterator; 138import java.util.List; 139import java.util.Map; 140import java.util.Objects; 141import java.util.concurrent.atomic.AtomicInteger; 142 143/** 144 * @hide 145 */ 146public class ConnectivityServiceMock extends IConnectivityManager.Stub 147 implements PendingIntent.OnFinished { 148 private static final String TAG = "ConnectivityServiceMock"; 149 private static final boolean DBG = true; 150 private static final boolean VDBG = true; 151 152 /** 153 * used internally when registering NetworkFactories 154 * obj = NetworkFactoryInfo 155 */ 156 private static final int EVENT_REGISTER_NETWORK_FACTORY = 17; 157 158 /** 159 * used internally when registering NetworkAgents 160 * obj = Messenger 161 */ 162 private static final int EVENT_REGISTER_NETWORK_AGENT = 18; 163 164 /** 165 * used to add a network request 166 * includes a NetworkRequestInfo 167 */ 168 private static final int EVENT_REGISTER_NETWORK_REQUEST = 19; 169 170 /** 171 * used to add a network listener - no request 172 * includes a NetworkRequestInfo 173 */ 174 private static final int EVENT_REGISTER_NETWORK_LISTENER = 21; 175 176 /** 177 * used to remove a network request, either a listener or a real request 178 * arg1 = UID of caller 179 * obj = NetworkRequest 180 */ 181 private static final int EVENT_RELEASE_NETWORK_REQUEST = 22; 182 183 /** 184 * used internally when registering NetworkFactories 185 * obj = Messenger 186 */ 187 private static final int EVENT_UNREGISTER_NETWORK_FACTORY = 23; 188 189 190 private final HandlerThread mHandlerThread; 191 /** Handler used for internal events. */ 192 final private InternalHandler mHandler; 193 /** Handler used for incoming {@link NetworkStateTracker} events. */ 194 final private NetworkStateTrackerHandler mTrackerHandler; 195 196 final private Context mContext; 197 198 public ConnectivityServiceMock(Context context) { 199 if (DBG) log("starting up"); 200 201 mContext = context; 202 mHandlerThread = new HandlerThread("ConnectivityServiceMock"); 203 mHandlerThread.start(); 204 mHandler = new InternalHandler(mHandlerThread.getLooper()); 205 mTrackerHandler = new NetworkStateTrackerHandler(mHandlerThread.getLooper()); 206 } 207 208 public void die() { 209 // clean up threads/handlers 210 } 211 212 private class InternalHandler extends Handler { 213 public InternalHandler(Looper looper) { 214 super(looper); 215 } 216 217 @Override 218 public void handleMessage(Message msg) { 219 switch (msg.what) { 220 case EVENT_REGISTER_NETWORK_FACTORY: { 221 handleRegisterNetworkFactory((NetworkFactoryInfo)msg.obj); 222 break; 223 } 224 case EVENT_UNREGISTER_NETWORK_FACTORY: { 225 handleUnregisterNetworkFactory((Messenger)msg.obj); 226 break; 227 } 228 case EVENT_REGISTER_NETWORK_AGENT: { 229 handleRegisterNetworkAgent((NetworkAgentInfo)msg.obj); 230 break; 231 } 232 case EVENT_REGISTER_NETWORK_REQUEST: 233 case EVENT_REGISTER_NETWORK_LISTENER: { 234 handleRegisterNetworkRequest((NetworkRequestInfo) msg.obj); 235 break; 236 } 237 case EVENT_RELEASE_NETWORK_REQUEST: { 238 handleReleaseNetworkRequest((NetworkRequest) msg.obj, msg.arg1); 239 break; 240 } 241 } 242 } 243 } 244 245 private class NetworkStateTrackerHandler extends Handler { 246 public NetworkStateTrackerHandler(Looper looper) { 247 super(looper); 248 } 249 250 @Override 251 public void handleMessage(Message msg) { 252 NetworkInfo info; 253 switch (msg.what) { 254 case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED: { 255 handleAsyncChannelHalfConnect(msg); 256 break; 257 } 258 case AsyncChannel.CMD_CHANNEL_DISCONNECT: { 259 NetworkAgentInfo nai = mNetworkAgentInfos.get(msg.replyTo); 260 if (nai != null) nai.asyncChannel.disconnect(); 261 break; 262 } 263 case AsyncChannel.CMD_CHANNEL_DISCONNECTED: { 264 handleAsyncChannelDisconnected(msg); 265 break; 266 } 267 } 268 } 269 } 270 271 private boolean isRequest(NetworkRequest request) { 272 return mNetworkRequests.get(request).isRequest; 273 } 274 275 private void handleAsyncChannelHalfConnect(Message msg) { 276 AsyncChannel ac = (AsyncChannel) msg.obj; 277 if (mNetworkFactoryInfos.containsKey(msg.replyTo)) { 278 if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) { 279 if (VDBG) log("NetworkFactory connected"); 280 // A network factory has connected. Send it all current NetworkRequests. 281 for (NetworkRequestInfo nri : mNetworkRequests.values()) { 282 if (nri.isRequest == false) continue; 283 //NetworkAgentInfo nai = mNetworkForRequestId.get(nri.request.requestId); 284 NetworkAgentInfo nai = null; 285 ac.sendMessage(android.net.NetworkFactory.CMD_REQUEST_NETWORK, 286 (nai != null ? nai.getCurrentScore() : 0), 0, nri.request); 287 } 288 } else { 289 loge("Error connecting NetworkFactory"); 290 mNetworkFactoryInfos.remove(msg.obj); 291 } 292 } else if (mNetworkAgentInfos.containsKey(msg.replyTo)) { 293 if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) { 294 if (VDBG) log("NetworkAgent connected"); 295 // A network agent has requested a connection. Establish the connection. 296 mNetworkAgentInfos.get(msg.replyTo).asyncChannel. 297 sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION); 298 } else { 299 loge("Error connecting NetworkAgent"); 300 NetworkAgentInfo nai = mNetworkAgentInfos.remove(msg.replyTo); 301 //if (nai != null) { 302 // final boolean wasDefault = isDefaultNetwork(nai); 303 // synchronized (mNetworkForNetId) { 304 // mNetworkForNetId.remove(nai.network.netId); 305 // mNetIdInUse.delete(nai.network.netId); 306 // } 307 // // Just in case. 308 // mLegacyTypeTracker.remove(nai, wasDefault); 309 //} 310 } 311 } 312 } 313 314 private void handleAsyncChannelDisconnected(Message msg) { 315 NetworkAgentInfo nai = mNetworkAgentInfos.get(msg.replyTo); 316 if (nai != null) { 317 if (DBG) { 318 log(nai.name() + " got DISCONNECTED, was satisfying " + nai.numNetworkRequests()); 319 } 320 // A network agent has disconnected. 321 // TODO - if we move the logic to the network agent (have them disconnect 322 // because they lost all their requests or because their score isn't good) 323 // then they would disconnect organically, report their new state and then 324 // disconnect the channel. 325 //if (nai.networkInfo.isConnected()) { 326 // nai.networkInfo.setDetailedState(NetworkInfo.DetailedState.DISCONNECTED, 327 // null, null); 328 //} 329 //final boolean wasDefault = isDefaultNetwork(nai); 330 //if (wasDefault) { 331 // mDefaultInetConditionPublished = 0; 332 //} 333 //notifyIfacesChanged(); 334 // TODO - we shouldn't send CALLBACK_LOST to requests that can be satisfied 335 // by other networks that are already connected. Perhaps that can be done by 336 // sending all CALLBACK_LOST messages (for requests, not listens) at the end 337 // of rematchAllNetworksAndRequests 338 //notifyNetworkCallbacks(nai, ConnectivityManager.CALLBACK_LOST); 339 //mKeepaliveTracker.handleStopAllKeepalives(nai, 340 // ConnectivityManager.PacketKeepalive.ERROR_INVALID_NETWORK); 341 nai.networkMonitor.sendMessage(NetworkMonitor.CMD_NETWORK_DISCONNECTED); 342 mNetworkAgentInfos.remove(msg.replyTo); 343 //updateClat(null, nai.linkProperties, nai); 344 //synchronized (mNetworkForNetId) { 345 // // Remove the NetworkAgent, but don't mark the netId as 346 // // available until we've told netd to delete it below. 347 // mNetworkForNetId.remove(nai.network.netId); 348 //} 349 // Remove all previously satisfied requests. 350 //for (int i = 0; i < nai.networkRequests.size(); i++) { 351 // NetworkRequest request = nai.networkRequests.valueAt(i); 352 // NetworkAgentInfo currentNetwork = mNetworkForRequestId.get(request.requestId); 353 // if (currentNetwork != null && currentNetwork.network.netId == nai.network.netId) { 354 // mNetworkForRequestId.remove(request.requestId); 355 // sendUpdatedScoreToFactories(request, 0); 356 // } 357 //} 358 //if (nai.networkRequests.get(mDefaultRequest.requestId) != null) { 359 // removeDataActivityTracking(nai); 360 // notifyLockdownVpn(nai); 361 // requestNetworkTransitionWakelock(nai.name()); 362 //} 363 //mLegacyTypeTracker.remove(nai, wasDefault); 364 //rematchAllNetworksAndRequests(null, 0); 365 //if (nai.created) { 366 // // Tell netd to clean up the configuration for this network 367 // // (routing rules, DNS, etc). 368 // // This may be slow as it requires a lot of netd shelling out to ip and 369 // // ip[6]tables to flush routes and remove the incoming packet mark rule, so do it 370 // // after we've rematched networks with requests which should make a potential 371 // // fallback network the default or requested a new network from the 372 // // NetworkFactories, so network traffic isn't interrupted for an unnecessarily 373 // // long time. 374 // try { 375 // mNetd.removeNetwork(nai.network.netId); 376 // } catch (Exception e) { 377 // loge("Exception removing network: " + e); 378 // } 379 //} 380 //synchronized (mNetworkForNetId) { 381 // mNetIdInUse.delete(nai.network.netId); 382 //} 383 } else { 384 NetworkFactoryInfo nfi = mNetworkFactoryInfos.remove(msg.replyTo); 385 if (DBG && nfi != null) log("unregisterNetworkFactory for " + nfi.name); 386 } 387 } 388 389 private void log(String str) { 390 Slog.d(TAG, str); 391 } 392 private void loge(String str) { 393 Slog.e(TAG, str); 394 } 395 396 // NetworkAgentInfo keyed off its connecting messenger 397 // TODO - eval if we can reduce the number of lists/hashmaps/sparsearrays 398 // NOTE: Only should be accessed on ConnectivityServiceThread, except dump(). 399 private final HashMap<Messenger, NetworkAgentInfo> mNetworkAgentInfos = 400 new HashMap<Messenger, NetworkAgentInfo>(); 401 private final HashMap<Messenger, NetworkFactoryInfo> mNetworkFactoryInfos = 402 new HashMap<Messenger, NetworkFactoryInfo>(); 403 private final HashMap<NetworkRequest, NetworkRequestInfo> mNetworkRequests = 404 new HashMap<NetworkRequest, NetworkRequestInfo>(); 405 406 private static class NetworkFactoryInfo { 407 public final String name; 408 public final Messenger messenger; 409 public final AsyncChannel asyncChannel; 410 411 public NetworkFactoryInfo(String name, Messenger messenger, AsyncChannel asyncChannel) { 412 this.name = name; 413 this.messenger = messenger; 414 this.asyncChannel = asyncChannel; 415 } 416 } 417 418 private class NetworkRequestInfo implements IBinder.DeathRecipient { 419 static final boolean REQUEST = true; 420 static final boolean LISTEN = false; 421 422 final NetworkRequest request; 423 final PendingIntent mPendingIntent; 424 boolean mPendingIntentSent; 425 private final IBinder mBinder; 426 final int mPid; 427 final int mUid; 428 final Messenger messenger; 429 final boolean isRequest; 430 431 NetworkRequestInfo(NetworkRequest r, PendingIntent pi, boolean isRequest) { 432 request = r; 433 mPendingIntent = pi; 434 messenger = null; 435 mBinder = null; 436 mPid = getCallingPid(); 437 mUid = getCallingUid(); 438 this.isRequest = isRequest; 439 } 440 441 NetworkRequestInfo(Messenger m, NetworkRequest r, IBinder binder, boolean isRequest) { 442 super(); 443 messenger = m; 444 request = r; 445 mBinder = binder; 446 mPid = getCallingPid(); 447 mUid = getCallingUid(); 448 this.isRequest = isRequest; 449 mPendingIntent = null; 450 451 try { 452 mBinder.linkToDeath(this, 0); 453 } catch (RemoteException e) { 454 binderDied(); 455 } 456 } 457 458 void unlinkDeathRecipient() { 459 if (mBinder != null) { 460 mBinder.unlinkToDeath(this, 0); 461 } 462 } 463 464 public void binderDied() { 465 log("ConnectivityService NetworkRequestInfo binderDied(" + 466 request + ", " + mBinder + ")"); 467 releaseNetworkRequest(request); 468 } 469 470 public String toString() { 471 return (isRequest ? "Request" : "Listen") + 472 " from uid/pid:" + mUid + "/" + mPid + 473 " for " + request + 474 (mPendingIntent == null ? "" : " to trigger " + mPendingIntent); 475 } 476 } 477 478 479 // sequence number of NetworkRequests 480 private int mNextNetworkRequestId = 1; 481 private synchronized int nextNetworkRequestId() { 482 return mNextNetworkRequestId++; 483 } 484 485 @Override 486 public NetworkInfo getActiveNetworkInfo() { 487 throw new RuntimeException("not implemented"); 488 } 489 490 @Override 491 public Network getActiveNetwork() { 492 throw new RuntimeException("not implemented"); 493 } 494 495 @Override 496 public Network getActiveNetworkForUid(int uid, boolean ignoreBlocked) { 497 throw new RuntimeException("not implemented"); 498 } 499 500 public NetworkInfo getActiveNetworkInfoUnfiltered() { 501 throw new RuntimeException("not implemented"); 502 } 503 504 @Override 505 public NetworkInfo getActiveNetworkInfoForUid(int uid, boolean ignoreBlocked) { 506 throw new RuntimeException("not implemented"); 507 } 508 509 @Override 510 public NetworkInfo getNetworkInfo(int networkType) { 511 throw new RuntimeException("not implemented"); 512 } 513 514 @Override 515 public NetworkInfo getNetworkInfoForUid(Network network, int uid, boolean ignoreBlocked) { 516 throw new RuntimeException("not implemented"); 517 } 518 519 @Override 520 public NetworkInfo[] getAllNetworkInfo() { 521 throw new RuntimeException("not implemented"); 522 } 523 524 @Override 525 public Network getNetworkForType(int networkType) { 526 throw new RuntimeException("not implemented"); 527 } 528 529 @Override 530 public Network[] getAllNetworks() { 531 throw new RuntimeException("not implemented"); 532 } 533 534 @Override 535 public NetworkCapabilities[] getDefaultNetworkCapabilitiesForUser(int userId) { 536 throw new RuntimeException("not implemented"); 537 } 538 539 @Override 540 public boolean isNetworkSupported(int networkType) { 541 throw new RuntimeException("not implemented"); 542 } 543 544 @Override 545 public LinkProperties getActiveLinkProperties() { 546 throw new RuntimeException("not implemented"); 547 } 548 549 @Override 550 public LinkProperties getLinkPropertiesForType(int networkType) { 551 throw new RuntimeException("not implemented"); 552 } 553 554 @Override 555 public LinkProperties getLinkProperties(Network network) { 556 throw new RuntimeException("not implemented"); 557 } 558 559 @Override 560 public void requestLinkProperties(NetworkRequest networkRequest) { 561 throw new RuntimeException("not implemented"); 562 } 563 564 @Override 565 public NetworkCapabilities getNetworkCapabilities(Network network) { 566 throw new RuntimeException("not implemented"); 567 } 568 569 @Override 570 public void requestNetworkCapabilities(NetworkRequest networkRequest) { 571 throw new RuntimeException("not implemented"); 572 } 573 574 @Override 575 public NetworkState[] getAllNetworkState() { 576 throw new RuntimeException("not implemented"); 577 } 578 579 @Override 580 public NetworkQuotaInfo getActiveNetworkQuotaInfo() { 581 throw new RuntimeException("not implemented"); 582 } 583 584 @Override 585 public boolean isActiveNetworkMetered() { 586 throw new RuntimeException("not implemented"); 587 } 588 589 public boolean requestRouteToHostAddress(int networkType, byte[] hostAddress) { 590 throw new RuntimeException("not implemented"); 591 } 592 593 @Override 594 public int getRestoreDefaultNetworkDelay(int networkType) { 595 throw new RuntimeException("not implemented"); 596 } 597 598 @Override 599 protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) { 600 throw new RuntimeException("not implemented"); 601 } 602 603 public void setAcceptUnvalidated(Network network, boolean accept, boolean always) { 604 throw new RuntimeException("not implemented"); 605 } 606 607 public void setAvoidUnvalidated(Network network) { 608 throw new RuntimeException("not implemented"); 609 } 610 611 public int tether(String iface) { 612 throw new RuntimeException("not implemented"); 613 } 614 615 public int untether(String iface) { 616 throw new RuntimeException("not implemented"); 617 } 618 619 public int getLastTetherError(String iface) { 620 throw new RuntimeException("not implemented"); 621 } 622 623 public String[] getTetherableUsbRegexs() { 624 throw new RuntimeException("not implemented"); 625 } 626 627 public String[] getTetherableWifiRegexs() { 628 throw new RuntimeException("not implemented"); 629 } 630 631 public String[] getTetherableBluetoothRegexs() { 632 throw new RuntimeException("not implemented"); 633 } 634 635 public int setUsbTethering(boolean enable) { 636 throw new RuntimeException("not implemented"); 637 } 638 639 public String[] getTetherableIfaces() { 640 throw new RuntimeException("not implemented"); 641 } 642 643 public String[] getTetheredIfaces() { 644 throw new RuntimeException("not implemented"); 645 } 646 647 public String[] getTetheringErroredIfaces() { 648 throw new RuntimeException("not implemented"); 649 } 650 651 public String[] getTetheredDhcpRanges() { 652 throw new RuntimeException("not implemented"); 653 } 654 655 @Override 656 public boolean isTetheringSupported() { 657 throw new RuntimeException("not implemented"); 658 } 659 660 @Override 661 public void startTethering(int type, ResultReceiver receiver, boolean showProvisioningUi) { 662 throw new RuntimeException("not implemented"); 663 } 664 665 @Override 666 public void stopTethering(int type) { 667 throw new RuntimeException("not implemented"); 668 } 669 670 671 public void reportInetCondition(int networkType, int percentage) { 672 throw new RuntimeException("not implemented"); 673 } 674 675 public void reportNetworkConnectivity(Network network, boolean hasConnectivity) { 676 throw new RuntimeException("not implemented"); 677 } 678 679 public ProxyInfo getProxyForNetwork(Network network) { 680 throw new RuntimeException("not implemented"); 681 } 682 683 public void setGlobalProxy(ProxyInfo proxyProperties) { 684 throw new RuntimeException("not implemented"); 685 } 686 687 public ProxyInfo getGlobalProxy() { 688 throw new RuntimeException("not implemented"); 689 } 690 691 @Override 692 public boolean prepareVpn(@Nullable String oldPackage, @Nullable String newPackage, 693 int userId) { 694 throw new RuntimeException("not implemented"); 695 } 696 697 public void setVpnPackageAuthorization(String packageName, int userId, boolean authorized) { 698 throw new RuntimeException("not implemented"); 699 } 700 701 @Override 702 public ParcelFileDescriptor establishVpn(VpnConfig config) { 703 throw new RuntimeException("not implemented"); 704 } 705 706 @Override 707 public void startLegacyVpn(VpnProfile profile) { 708 throw new RuntimeException("not implemented"); 709 } 710 711 @Override 712 public LegacyVpnInfo getLegacyVpnInfo(int userId) { 713 throw new RuntimeException("not implemented"); 714 } 715 716 @Override 717 public VpnInfo[] getAllVpnInfo() { 718 throw new RuntimeException("not implemented"); 719 } 720 721 @Override 722 public VpnConfig getVpnConfig(int userId) { 723 throw new RuntimeException("not implemented"); 724 } 725 726 @Override 727 public boolean updateLockdownVpn() { 728 throw new RuntimeException("not implemented"); 729 } 730 731 @Override 732 public boolean setAlwaysOnVpnPackage(int userId, String packageName, boolean lockdownEnabled) { 733 throw new RuntimeException("not implemented"); 734 } 735 736 @Override 737 public String getAlwaysOnVpnPackage(int userId) { 738 throw new RuntimeException("not implemented"); 739 } 740 741 @Override 742 public int checkMobileProvisioning(int suggestedTimeOutMs) { 743 throw new RuntimeException("not implemented"); 744 } 745 746 @Override 747 public String getMobileProvisioningUrl() { 748 throw new RuntimeException("not implemented"); 749 } 750 751 @Override 752 public void setProvisioningNotificationVisible(boolean visible, int networkType, 753 String action) { 754 throw new RuntimeException("not implemented"); 755 } 756 757 @Override 758 public void setAirplaneMode(boolean enable) { 759 throw new RuntimeException("not implemented"); 760 } 761 762 @Override 763 public NetworkRequest requestNetwork(NetworkCapabilities networkCapabilities, 764 Messenger messenger, int timeoutMs, IBinder binder, int legacyType) { 765 networkCapabilities = new NetworkCapabilities(networkCapabilities); 766 767 if (timeoutMs < 0 || timeoutMs > ConnectivityManager.MAX_NETWORK_REQUEST_TIMEOUT_MS) { 768 throw new IllegalArgumentException("Bad timeout specified"); 769 } 770 771 NetworkRequest networkRequest = new NetworkRequest(networkCapabilities, legacyType, 772 nextNetworkRequestId(), NetworkRequest.Type.REQUEST); 773 NetworkRequestInfo nri = new NetworkRequestInfo(messenger, networkRequest, binder, true); 774 if (DBG) log("requestNetwork for " + nri); 775 776 mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_REQUEST, nri)); 777 778 return networkRequest; 779 } 780 781 @Override 782 public boolean requestBandwidthUpdate(Network network) { 783 throw new RuntimeException("not implemented"); 784 } 785 786 787 @Override 788 public NetworkRequest pendingRequestForNetwork(NetworkCapabilities networkCapabilities, 789 PendingIntent operation) { 790 throw new RuntimeException("not implemented"); 791 } 792 793 @Override 794 public void releasePendingNetworkRequest(PendingIntent operation) { 795 throw new RuntimeException("not implemented"); 796 } 797 798 @Override 799 public NetworkRequest listenForNetwork(NetworkCapabilities networkCapabilities, 800 Messenger messenger, IBinder binder) { 801 throw new RuntimeException("not implemented"); 802 } 803 804 @Override 805 public void pendingListenForNetwork(NetworkCapabilities networkCapabilities, 806 PendingIntent operation) { 807 throw new RuntimeException("not implemented"); 808 } 809 810 @Override 811 public void releaseNetworkRequest(NetworkRequest networkRequest) { 812 mHandler.sendMessage(mHandler.obtainMessage(EVENT_RELEASE_NETWORK_REQUEST, getCallingUid(), 813 0, networkRequest)); 814 } 815 816 @Override 817 public void registerNetworkFactory(Messenger messenger, String name) { 818 NetworkFactoryInfo nfi = new NetworkFactoryInfo(name, messenger, new AsyncChannel()); 819 mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_FACTORY, nfi)); 820 } 821 822 private void handleRegisterNetworkFactory(NetworkFactoryInfo nfi) { 823 if (DBG) log("Got NetworkFactory Messenger for " + nfi.name); 824 mNetworkFactoryInfos.put(nfi.messenger, nfi); 825 nfi.asyncChannel.connect(mContext, mTrackerHandler, nfi.messenger); 826 } 827 828 @Override 829 public void unregisterNetworkFactory(Messenger messenger) { 830 mHandler.sendMessage(mHandler.obtainMessage(EVENT_UNREGISTER_NETWORK_FACTORY, messenger)); 831 } 832 833 private void handleUnregisterNetworkFactory(Messenger messenger) { 834 NetworkFactoryInfo nfi = mNetworkFactoryInfos.remove(messenger); 835 if (nfi == null) { 836 loge("Failed to find Messenger in unregisterNetworkFactory"); 837 return; 838 } 839 if (DBG) log("unregisterNetworkFactory for " + nfi.name); 840 } 841 842 public int registerNetworkAgent(Messenger messenger, NetworkInfo networkInfo, 843 LinkProperties linkProperties, NetworkCapabilities networkCapabilities, 844 int currentScore, NetworkMisc networkMisc) { 845// final NetworkAgentInfo nai = new NetworkAgentInfo(messenger, new AsyncChannel(), 846// new Network(reserveNetId()), new NetworkInfo(networkInfo), new LinkProperties( 847// linkProperties), new NetworkCapabilities(networkCapabilities), currentScore, 848// mContext, mTrackerHandler, new NetworkMisc(networkMisc), mDefaultRequest, this); 849// synchronized (this) { 850// nai.networkMonitor.systemReady = mSystemReady; 851// } 852// mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_AGENT, nai)); 853// return nai.network.netId; 854 throw new RuntimeException("not implemented"); 855 } 856 857 private void handleRegisterNetworkAgent(NetworkAgentInfo na) { 858 if (VDBG) log("Got NetworkAgent Messenger"); 859// mNetworkAgentInfos.put(na.messenger, na); 860// synchronized (mNetworkForNetId) { 861// mNetworkForNetId.put(na.network.netId, na); 862// } 863// na.asyncChannel.connect(mContext, mTrackerHandler, na.messenger); 864// NetworkInfo networkInfo = na.networkInfo; 865// na.networkInfo = null; 866// updateNetworkInfo(na, networkInfo); 867 } 868 869 870 private void handleRegisterNetworkRequest(NetworkRequestInfo nri) { 871 mNetworkRequests.put(nri.request, nri); 872 if (!nri.isRequest) { 873 for (NetworkAgentInfo network : mNetworkAgentInfos.values()) { 874 if (nri.request.networkCapabilities.hasSignalStrength() && 875 network.satisfiesImmutableCapabilitiesOf(nri.request)) { 876 } 877 } 878 } 879 rematchAllNetworksAndRequests(null, 0); 880 if (nri.isRequest) { 881 sendUpdatedScoreToFactories(nri.request, 0); 882 } 883 } 884 885 private void handleReleaseNetworkRequest(NetworkRequest request, int callingUid) { 886 NetworkRequestInfo nri = mNetworkRequests.get(request); 887 if (nri != null) { 888 if (DBG) log("releasing NetworkRequest " + request); 889 nri.unlinkDeathRecipient(); 890 mNetworkRequests.remove(request); 891 if (nri.isRequest) { 892 // Find all networks that are satisfying this request and remove the request 893 // from their request lists. 894 // TODO - it's my understanding that for a request there is only a single 895 // network satisfying it, so this loop is wasteful 896 //boolean wasKept = false; 897 //for (NetworkAgentInfo nai : mNetworkAgentInfos.values()) { 898 // if (nai.networkRequests.get(nri.request.requestId) != null) { 899 // nai.networkRequests.remove(nri.request.requestId); 900 // if (DBG) { 901 // log(" Removing from current network " + nai.name() + 902 // ", leaving " + nai.networkRequests.size() + 903 // " requests."); 904 // } 905 // if (unneeded(nai)) { 906 // if (DBG) log("no live requests for " + nai.name() + "; disconnecting"); 907 // teardownUnneededNetwork(nai); 908 // } else { 909 // // suspect there should only be one pass through here 910 // // but if any were kept do the check below 911 // wasKept |= true; 912 // } 913 // } 914 //} 915 916 //NetworkAgentInfo nai = mNetworkForRequestId.get(nri.request.requestId); 917 //if (nai != null) { 918 // mNetworkForRequestId.remove(nri.request.requestId); 919 //} 920 // Maintain the illusion. When this request arrived, we might have pretended 921 // that a network connected to serve it, even though the network was already 922 // connected. Now that this request has gone away, we might have to pretend 923 // that the network disconnected. LegacyTypeTracker will generate that 924 // phantom disconnect for this type. 925 //if (nri.request.legacyType != TYPE_NONE && nai != null) { 926 // boolean doRemove = true; 927 // if (wasKept) { 928 // // check if any of the remaining requests for this network are for the 929 // // same legacy type - if so, don't remove the nai 930 // for (int i = 0; i < nai.networkRequests.size(); i++) { 931 // NetworkRequest otherRequest = nai.networkRequests.valueAt(i); 932 // if (otherRequest.legacyType == nri.request.legacyType && 933 // isRequest(otherRequest)) { 934 // if (DBG) log(" still have other legacy request - leaving"); 935 // doRemove = false; 936 // } 937 // } 938 // } 939 // 940 // if (doRemove) { 941 // mLegacyTypeTracker.remove(nri.request.legacyType, nai, false); 942 // } 943 //} 944 945 for (NetworkFactoryInfo nfi : mNetworkFactoryInfos.values()) { 946 nfi.asyncChannel.sendMessage(android.net.NetworkFactory.CMD_CANCEL_REQUEST, 947 nri.request); 948 } 949 } else { 950 // listens don't have a singular affectedNetwork. Check all networks to see 951 // if this listen request applies and remove it. 952 //for (NetworkAgentInfo nai : mNetworkAgentInfos.values()) { 953 // nai.networkRequests.remove(nri.request.requestId); 954 // if (nri.request.networkCapabilities.hasSignalStrength() && 955 // nai.satisfiesImmutableCapabilitiesOf(nri.request)) { 956 // updateSignalStrengthThresholds(nai, "RELEASE", nri.request); 957 // } 958 //} 959 } 960 //callCallbackForRequest(nri, null, ConnectivityManager.CALLBACK_RELEASED); 961 } 962 } 963 964 private void sendUpdatedScoreToFactories(NetworkAgentInfo nai) { 965 for (int i = 0; i < nai.numNetworkRequests(); i++) { 966 NetworkRequest nr = nai.requestAt(i); 967 // Don't send listening requests to factories. b/17393458 968 if (!isRequest(nr)) continue; 969 sendUpdatedScoreToFactories(nr, nai.getCurrentScore()); 970 } 971 } 972 973 private void sendUpdatedScoreToFactories(NetworkRequest networkRequest, int score) { 974 if (VDBG) log("sending new Min Network Score(" + score + "): " + networkRequest.toString()); 975 for (NetworkFactoryInfo nfi : mNetworkFactoryInfos.values()) { 976 nfi.asyncChannel.sendMessage(android.net.NetworkFactory.CMD_REQUEST_NETWORK, score, 0, 977 networkRequest); 978 } 979 } 980 981 private void rematchAllNetworksAndRequests(NetworkAgentInfo changed, int oldScore) { 982 } 983 984 @Override 985 public void onSendFinished(PendingIntent pendingIntent, Intent intent, int resultCode, 986 String resultData, Bundle resultExtras) { 987 throw new RuntimeException("not implemented"); 988 } 989 990 @Override 991 public boolean addVpnAddress(String address, int prefixLength) { 992 throw new RuntimeException("not implemented"); 993 } 994 995 @Override 996 public boolean removeVpnAddress(String address, int prefixLength) { 997 throw new RuntimeException("not implemented"); 998 } 999 1000 @Override 1001 public boolean setUnderlyingNetworksForVpn(Network[] networks) { 1002 throw new RuntimeException("not implemented"); 1003 } 1004 1005 @Override 1006 public String getCaptivePortalServerUrl() { 1007 throw new RuntimeException("not implemented"); 1008 } 1009 1010 @Override 1011 public void startNattKeepalive(Network network, int intervalSeconds, Messenger messenger, 1012 IBinder binder, String srcAddr, int srcPort, String dstAddr) { 1013 throw new RuntimeException("not implemented"); 1014 } 1015 1016 @Override 1017 public void stopKeepalive(Network network, int slot) { 1018 throw new RuntimeException("not implemented"); 1019 } 1020 1021 @Override 1022 public void factoryReset() { 1023 throw new RuntimeException("not implemented"); 1024 } 1025 1026 @VisibleForTesting 1027 public NetworkMonitor createNetworkMonitor(Context context, Handler handler, 1028 NetworkAgentInfo nai, NetworkRequest defaultRequest) { 1029 throw new RuntimeException("not implemented"); 1030 } 1031 1032 @VisibleForTesting 1033 public NetworkRequest defaultRequest = null; 1034 @VisibleForTesting 1035 public synchronized void addDefaultRequest() { 1036 if (defaultRequest != null) return; 1037 NetworkCapabilities netCap = new NetworkCapabilities(); 1038 netCap.addCapability(NET_CAPABILITY_INTERNET); 1039 netCap.addCapability(NET_CAPABILITY_NOT_RESTRICTED); 1040 defaultRequest = requestNetwork(netCap, null, 0, new Binder(), 1041 ConnectivityManager.TYPE_NONE); 1042 } 1043 1044 @VisibleForTesting 1045 public synchronized void setCurrentScoreForRequest(NetworkRequest nr, int score) { 1046 sendUpdatedScoreToFactories(nr, score); 1047 } 1048 1049 @VisibleForTesting 1050 public synchronized void removeDefaultRequest() { 1051 if (defaultRequest == null) return; 1052 releaseNetworkRequest(defaultRequest); 1053 defaultRequest = null; 1054 } 1055 1056 1057} 1058