services/core/java/com/android/server/connectivity/PermissionMonitor.java

   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
  17 package com.android.server.connectivity;
  18
  19 import static android.Manifest.permission.CHANGE_NETWORK_STATE;
  20 import static android.Manifest.permission.CONNECTIVITY_INTERNAL;
  21 import static android.Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS;
  22 import static android.Manifest.permission.INTERNET;
  23 import static android.Manifest.permission.NETWORK_STACK;
  24 import static android.Manifest.permission.UPDATE_DEVICE_STATS;
  25 import static android.content.pm.PackageInfo.REQUESTED_PERMISSION_GRANTED;
  26 import static android.content.pm.PackageManager.GET_PERMISSIONS;
  27 import static android.content.pm.PackageManager.MATCH_ANY_USER;
  28 import static android.os.Process.INVALID_UID;
  29 import static android.os.Process.SYSTEM_UID;
  30
  31 import android.annotation.NonNull;
  32 import android.content.Context;
  33 import android.content.pm.ApplicationInfo;
  34 import android.content.pm.PackageInfo;
  35 import android.content.pm.PackageManager;
  36 import android.content.pm.PackageManager.NameNotFoundException;
  37 import android.content.pm.PackageManagerInternal;
  38 import android.content.pm.UserInfo;
  39 import android.net.INetd;
  40 import android.net.UidRange;
  41 import android.os.Build;
  42 import android.os.RemoteException;
  43 import android.os.ServiceSpecificException;
  44 import android.os.UserHandle;
  45 import android.os.UserManager;
  46 import android.system.OsConstants;
  47 import android.util.ArraySet;
  48 import android.util.Log;
  49 import android.util.SparseArray;
  50 import android.util.SparseIntArray;
  51
  52 import com.android.internal.annotations.GuardedBy;
  53 import com.android.internal.annotations.VisibleForTesting;
  54 import com.android.internal.util.ArrayUtils;
  55 import com.android.internal.util.IndentingPrintWriter;
  56 import com.android.server.LocalServices;
  57 import com.android.server.SystemConfig;
  58
  59 import java.util.ArrayList;
  60 import java.util.Collection;
  61 import java.util.HashMap;
  62 import java.util.HashSet;
  63 import java.util.List;
  64 import java.util.Map;
  65 import java.util.Map.Entry;
  66 import java.util.Set;
  67
  68
  69 /**
  70  * A utility class to inform Netd of UID permisisons.
  71  * Does a mass update at boot and then monitors for app install/remove.
  72  *
  73  * @hide
  74  */
  75 public class PermissionMonitor {
  76     private static final String TAG = "PermissionMonitor";
  77     private static final boolean DBG = true;
  78     protected static final Boolean SYSTEM = Boolean.TRUE;
  79     protected static final Boolean NETWORK = Boolean.FALSE;
  80     private static final int VERSION_Q = Build.VERSION_CODES.Q;
  81
  82     private final PackageManager mPackageManager;
  83     private final UserManager mUserManager;
  84     private final INetd mNetd;
  85
  86     // Values are User IDs.
  87     @GuardedBy("this")
  88     private final Set<Integer> mUsers = new HashSet<>();
  89
  90     // Keys are app uids. Values are true for SYSTEM permission and false for NETWORK permission.
  91     @GuardedBy("this")
  92     private final Map<Integer, Boolean> mApps = new HashMap<>();
  93
  94     // Keys are active non-bypassable and fully-routed VPN's interface name, Values are uid ranges
  95     // for apps under the VPN
  96     @GuardedBy("this")
  97     private final Map<String, Set<UidRange>> mVpnUidRanges = new HashMap<>();
  98
  99     // A set of appIds for apps across all users on the device. We track appIds instead of uids
 100     // directly to reduce its size and also eliminate the need to update this set when user is
 101     // added/removed.
 102     @GuardedBy("this")
 103     private final Set<Integer> mAllApps = new HashSet<>();
 104
 105     private class PackageListObserver implements PackageManagerInternal.PackageListObserver {
 106
 107         private int getPermissionForUid(int uid) {
 108             int permission = 0;
 109             // Check all the packages for this UID. The UID has the permission if any of the
 110             // packages in it has the permission.
 111             String[] packages = mPackageManager.getPackagesForUid(uid);
 112             if (packages != null && packages.length > 0) {
 113                 for (String name : packages) {
 114                     final PackageInfo app = getPackageInfo(name);
 115                     if (app != null && app.requestedPermissions != null) {
 116                         permission |= getNetdPermissionMask(app.requestedPermissions,
 117                               app.requestedPermissionsFlags);
 118                     }
 119                 }
 120             } else {
 121                 // The last package of this uid is removed from device. Clean the package up.
 122                 permission = INetd.PERMISSION_UNINSTALLED;
 123             }
 124             return permission;
 125         }
 126
 127         @Override
 128         public void onPackageAdded(String packageName, int uid) {
 129             sendPackagePermissionsForUid(uid, getPermissionForUid(uid));
 130         }
 131
 132         @Override
 133         public void onPackageChanged(@NonNull String packageName, int uid) {
 134             sendPackagePermissionsForUid(uid, getPermissionForUid(uid));
 135         }
 136
 137         @Override
 138         public void onPackageRemoved(String packageName, int uid) {
 139             sendPackagePermissionsForUid(uid, getPermissionForUid(uid));
 140         }
 141     }
 142
 143     public PermissionMonitor(Context context, INetd netd) {
 144         mPackageManager = context.getPackageManager();
 145         mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
 146         mNetd = netd;
 147     }
 148
 149     // Intended to be called only once at startup, after the system is ready. Installs a broadcast
 150     // receiver to monitor ongoing UID changes, so this shouldn't/needn't be called again.
 151     public synchronized void startMonitoring() {
 152         log("Monitoring");
 153
 154         PackageManagerInternal pmi = LocalServices.getService(PackageManagerInternal.class);
 155         if (pmi != null) {
 156             pmi.getPackageList(new PackageListObserver());
 157         } else {
 158             loge("failed to get the PackageManagerInternal service");
 159         }
 160         List<PackageInfo> apps = mPackageManager.getInstalledPackages(GET_PERMISSIONS
 161                 | MATCH_ANY_USER);
 162         if (apps == null) {
 163             loge("No apps");
 164             return;
 165         }
 166
 167         SparseIntArray netdPermsUids = new SparseIntArray();
 168
 169         for (PackageInfo app : apps) {
 170             int uid = app.applicationInfo != null ? app.applicationInfo.uid : INVALID_UID;
 171             if (uid < 0) {
 172                 continue;
 173             }
 174             mAllApps.add(UserHandle.getAppId(uid));
 175
 176             boolean isNetwork = hasNetworkPermission(app);
 177             boolean hasRestrictedPermission = hasRestrictedNetworkPermission(app);
 178
 179             if (isNetwork || hasRestrictedPermission) {
 180                 Boolean permission = mApps.get(uid);
 181                 // If multiple packages share a UID (cf: android:sharedUserId) and ask for different
 182                 // permissions, don't downgrade (i.e., if it's already SYSTEM, leave it as is).
 183                 if (permission == null || permission == NETWORK) {
 184                     mApps.put(uid, hasRestrictedPermission);
 185                 }
 186             }
 187
 188             //TODO: unify the management of the permissions into one codepath.
 189             int otherNetdPerms = getNetdPermissionMask(app.requestedPermissions,
 190                     app.requestedPermissionsFlags);
 191             netdPermsUids.put(uid, netdPermsUids.get(uid) | otherNetdPerms);
 192         }
 193
 194         List<UserInfo> users = mUserManager.getUsers(true);  // exclude dying users
 195         if (users != null) {
 196             for (UserInfo user : users) {
 197                 mUsers.add(user.id);
 198             }
 199         }
 200
 201         final SparseArray<ArraySet<String>> systemPermission =
 202                 SystemConfig.getInstance().getSystemPermissions();
 203         for (int i = 0; i < systemPermission.size(); i++) {
 204             ArraySet<String> perms = systemPermission.valueAt(i);
 205             int uid = systemPermission.keyAt(i);
 206             int netdPermission = 0;
 207             // Get the uids of native services that have UPDATE_DEVICE_STATS or INTERNET permission.
 208             if (perms != null) {
 209                 netdPermission |= perms.contains(UPDATE_DEVICE_STATS)
 210                         ? INetd.PERMISSION_UPDATE_DEVICE_STATS : 0;
 211                 netdPermission |= perms.contains(INTERNET)
 212                         ? INetd.PERMISSION_INTERNET : 0;
 213             }
 214             netdPermsUids.put(uid, netdPermsUids.get(uid) | netdPermission);
 215         }
 216         log("Users: " + mUsers.size() + ", Apps: " + mApps.size());
 217         update(mUsers, mApps, true);
 218         sendPackagePermissionsToNetd(netdPermsUids);
 219     }
 220
 221     @VisibleForTesting
 222     static boolean isVendorApp(@NonNull ApplicationInfo appInfo) {
 223         return appInfo.isVendor() || appInfo.isOem() || appInfo.isProduct();
 224     }
 225
 226     @VisibleForTesting
 227     protected int getDeviceFirstSdkInt() {
 228         return Build.VERSION.FIRST_SDK_INT;
 229     }
 230
 231     @VisibleForTesting
 232     boolean hasPermission(@NonNull final PackageInfo app, @NonNull final String permission) {
 233         if (app.requestedPermissions == null || app.requestedPermissionsFlags == null) {
 234             return false;
 235         }
 236         final int index = ArrayUtils.indexOf(app.requestedPermissions, permission);
 237         if (index < 0 || index >= app.requestedPermissionsFlags.length) return false;
 238         return (app.requestedPermissionsFlags[index] & REQUESTED_PERMISSION_GRANTED) != 0;
 239     }
 240
 241     @VisibleForTesting
 242     boolean hasNetworkPermission(@NonNull final PackageInfo app) {
 243         return hasPermission(app, CHANGE_NETWORK_STATE);
 244     }
 245
 246     @VisibleForTesting
 247     boolean hasRestrictedNetworkPermission(@NonNull final PackageInfo app) {
 248         // TODO : remove this check in the future(b/31479477). All apps should just
 249         // request the appropriate permission for their use case since android Q.
 250         if (app.applicationInfo != null) {
 251             // Backward compatibility for b/114245686, on devices that launched before Q daemons
 252             // and apps running as the system UID are exempted from this check.
 253             if (app.applicationInfo.uid == SYSTEM_UID && getDeviceFirstSdkInt() < VERSION_Q) {
 254                 return true;
 255             }
 256
 257             if (app.applicationInfo.targetSdkVersion < VERSION_Q
 258                     && isVendorApp(app.applicationInfo)) {
 259                 return true;
 260             }
 261         }
 262         return hasPermission(app, CONNECTIVITY_INTERNAL)
 263                 || hasPermission(app, NETWORK_STACK)
 264                 || hasPermission(app, CONNECTIVITY_USE_RESTRICTED_NETWORKS);
 265     }
 266
 267     /** Returns whether the given uid has using background network permission. */
 268     public synchronized boolean hasUseBackgroundNetworksPermission(final int uid) {
 269         // Apps with any of the CHANGE_NETWORK_STATE, NETWORK_STACK, CONNECTIVITY_INTERNAL or
 270         // CONNECTIVITY_USE_RESTRICTED_NETWORKS permission has the permission to use background
 271         // networks. mApps contains the result of checks for both hasNetworkPermission and
 272         // hasRestrictedNetworkPermission. If uid is in the mApps list that means uid has one of
 273         // permissions at least.
 274         return mApps.containsKey(uid);
 275     }
 276
 277     private int[] toIntArray(Collection<Integer> list) {
 278         int[] array = new int[list.size()];
 279         int i = 0;
 280         for (Integer item : list) {
 281             array[i++] = item;
 282         }
 283         return array;
 284     }
 285
 286     private void update(Set<Integer> users, Map<Integer, Boolean> apps, boolean add) {
 287         List<Integer> network = new ArrayList<>();
 288         List<Integer> system = new ArrayList<>();
 289         for (Entry<Integer, Boolean> app : apps.entrySet()) {
 290             List<Integer> list = app.getValue() ? system : network;
 291             for (int user : users) {
 292                 list.add(UserHandle.getUid(user, app.getKey()));
 293             }
 294         }
 295         try {
 296             if (add) {
 297                 mNetd.networkSetPermissionForUser(INetd.PERMISSION_NETWORK, toIntArray(network));
 298                 mNetd.networkSetPermissionForUser(INetd.PERMISSION_SYSTEM, toIntArray(system));
 299             } else {
 300                 mNetd.networkClearPermissionForUser(toIntArray(network));
 301                 mNetd.networkClearPermissionForUser(toIntArray(system));
 302             }
 303         } catch (RemoteException e) {
 304             loge("Exception when updating permissions: " + e);
 305         }
 306     }
 307
 308     /**
 309      * Called when a user is added. See {link #ACTION_USER_ADDED}.
 310      *
 311      * @param user The integer userHandle of the added user. See {@link #EXTRA_USER_HANDLE}.
 312      *
 313      * @hide
 314      */
 315     public synchronized void onUserAdded(int user) {
 316         if (user < 0) {
 317             loge("Invalid user in onUserAdded: " + user);
 318             return;
 319         }
 320         mUsers.add(user);
 321
 322         Set<Integer> users = new HashSet<>();
 323         users.add(user);
 324         update(users, mApps, true);
 325     }
 326
 327     /**
 328      * Called when an user is removed. See {link #ACTION_USER_REMOVED}.
 329      *
 330      * @param user The integer userHandle of the removed user. See {@link #EXTRA_USER_HANDLE}.
 331      *
 332      * @hide
 333      */
 334     public synchronized void onUserRemoved(int user) {
 335         if (user < 0) {
 336             loge("Invalid user in onUserRemoved: " + user);
 337             return;
 338         }
 339         mUsers.remove(user);
 340
 341         Set<Integer> users = new HashSet<>();
 342         users.add(user);
 343         update(users, mApps, false);
 344     }
 345
 346     @VisibleForTesting
 347     protected Boolean highestPermissionForUid(Boolean currentPermission, String name) {
 348         if (currentPermission == SYSTEM) {
 349             return currentPermission;
 350         }
 351         try {
 352             final PackageInfo app = mPackageManager.getPackageInfo(name, GET_PERMISSIONS);
 353             final boolean isNetwork = hasNetworkPermission(app);
 354             final boolean hasRestrictedPermission = hasRestrictedNetworkPermission(app);
 355             if (isNetwork || hasRestrictedPermission) {
 356                 currentPermission = hasRestrictedPermission;
 357             }
 358         } catch (NameNotFoundException e) {
 359             // App not found.
 360             loge("NameNotFoundException " + name);
 361         }
 362         return currentPermission;
 363     }
 364
 365     /**
 366      * Called when a package is added. See {link #ACTION_PACKAGE_ADDED}.
 367      *
 368      * @param packageName The name of the new package.
 369      * @param uid The uid of the new package.
 370      *
 371      * @hide
 372      */
 373     public synchronized void onPackageAdded(String packageName, int uid) {
 374         // If multiple packages share a UID (cf: android:sharedUserId) and ask for different
 375         // permissions, don't downgrade (i.e., if it's already SYSTEM, leave it as is).
 376         final Boolean permission = highestPermissionForUid(mApps.get(uid), packageName);
 377         if (permission != mApps.get(uid)) {
 378             mApps.put(uid, permission);
 379
 380             Map<Integer, Boolean> apps = new HashMap<>();
 381             apps.put(uid, permission);
 382             update(mUsers, apps, true);
 383         }
 384
 385         // If the newly-installed package falls within some VPN's uid range, update Netd with it.
 386         // This needs to happen after the mApps update above, since removeBypassingUids() depends
 387         // on mApps to check if the package can bypass VPN.
 388         for (Map.Entry<String, Set<UidRange>> vpn : mVpnUidRanges.entrySet()) {
 389             if (UidRange.containsUid(vpn.getValue(), uid)) {
 390                 final Set<Integer> changedUids = new HashSet<>();
 391                 changedUids.add(uid);
 392                 removeBypassingUids(changedUids, /* vpnAppUid */ -1);
 393                 updateVpnUids(vpn.getKey(), changedUids, true);
 394             }
 395         }
 396         mAllApps.add(UserHandle.getAppId(uid));
 397     }
 398
 399     /**
 400      * Called when a package is removed. See {link #ACTION_PACKAGE_REMOVED}.
 401      *
 402      * @param uid containing the integer uid previously assigned to the package.
 403      *
 404      * @hide
 405      */
 406     public synchronized void onPackageRemoved(int uid) {
 407         // If the newly-removed package falls within some VPN's uid range, update Netd with it.
 408         // This needs to happen before the mApps update below, since removeBypassingUids() depends
 409         // on mApps to check if the package can bypass VPN.
 410         for (Map.Entry<String, Set<UidRange>> vpn : mVpnUidRanges.entrySet()) {
 411             if (UidRange.containsUid(vpn.getValue(), uid)) {
 412                 final Set<Integer> changedUids = new HashSet<>();
 413                 changedUids.add(uid);
 414                 removeBypassingUids(changedUids, /* vpnAppUid */ -1);
 415                 updateVpnUids(vpn.getKey(), changedUids, false);
 416             }
 417         }
 418         // If the package has been removed from all users on the device, clear it form mAllApps.
 419         if (mPackageManager.getNameForUid(uid) == null) {
 420             mAllApps.remove(UserHandle.getAppId(uid));
 421         }
 422
 423         Map<Integer, Boolean> apps = new HashMap<>();
 424         Boolean permission = null;
 425         String[] packages = mPackageManager.getPackagesForUid(uid);
 426         if (packages != null && packages.length > 0) {
 427             for (String name : packages) {
 428                 permission = highestPermissionForUid(permission, name);
 429                 if (permission == SYSTEM) {
 430                     // An app with this UID still has the SYSTEM permission.
 431                     // Therefore, this UID must already have the SYSTEM permission.
 432                     // Nothing to do.
 433                     return;
 434                 }
 435             }
 436         }
 437         if (permission == mApps.get(uid)) {
 438             // The permissions of this UID have not changed. Nothing to do.
 439             return;
 440         } else if (permission != null) {
 441             mApps.put(uid, permission);
 442             apps.put(uid, permission);
 443             update(mUsers, apps, true);
 444         } else {
 445             mApps.remove(uid);
 446             apps.put(uid, NETWORK);  // doesn't matter which permission we pick here
 447             update(mUsers, apps, false);
 448         }
 449     }
 450
 451     private static int getNetdPermissionMask(String[] requestedPermissions,
 452                                              int[] requestedPermissionsFlags) {
 453         int permissions = 0;
 454         if (requestedPermissions == null || requestedPermissionsFlags == null) return permissions;
 455         for (int i = 0; i < requestedPermissions.length; i++) {
 456             if (requestedPermissions[i].equals(INTERNET)
 457                     && ((requestedPermissionsFlags[i] & REQUESTED_PERMISSION_GRANTED) != 0)) {
 458                 permissions |= INetd.PERMISSION_INTERNET;
 459             }
 460             if (requestedPermissions[i].equals(UPDATE_DEVICE_STATS)
 461                     && ((requestedPermissionsFlags[i] & REQUESTED_PERMISSION_GRANTED) != 0)) {
 462                 permissions |= INetd.PERMISSION_UPDATE_DEVICE_STATS;
 463             }
 464         }
 465         return permissions;
 466     }
 467
 468     private PackageInfo getPackageInfo(String packageName) {
 469         try {
 470             PackageInfo app = mPackageManager.getPackageInfo(packageName, GET_PERMISSIONS
 471                     | MATCH_ANY_USER);
 472             return app;
 473         } catch (NameNotFoundException e) {
 474             return null;
 475         }
 476     }
 477
 478     /**
 479      * Called when a new set of UID ranges are added to an active VPN network
 480      *
 481      * @param iface The active VPN network's interface name
 482      * @param rangesToAdd The new UID ranges to be added to the network
 483      * @param vpnAppUid The uid of the VPN app
 484      */
 485     public synchronized void onVpnUidRangesAdded(@NonNull String iface, Set<UidRange> rangesToAdd,
 486             int vpnAppUid) {
 487         // Calculate the list of new app uids under the VPN due to the new UID ranges and update
 488         // Netd about them. Because mAllApps only contains appIds instead of uids, the result might
 489         // be an overestimation if an app is not installed on the user on which the VPN is running,
 490         // but that's safe.
 491         final Set<Integer> changedUids = intersectUids(rangesToAdd, mAllApps);
 492         removeBypassingUids(changedUids, vpnAppUid);
 493         updateVpnUids(iface, changedUids, true);
 494         if (mVpnUidRanges.containsKey(iface)) {
 495             mVpnUidRanges.get(iface).addAll(rangesToAdd);
 496         } else {
 497             mVpnUidRanges.put(iface, new HashSet<UidRange>(rangesToAdd));
 498         }
 499     }
 500
 501     /**
 502      * Called when a set of UID ranges are removed from an active VPN network
 503      *
 504      * @param iface The VPN network's interface name
 505      * @param rangesToRemove Existing UID ranges to be removed from the VPN network
 506      * @param vpnAppUid The uid of the VPN app
 507      */
 508     public synchronized void onVpnUidRangesRemoved(@NonNull String iface,
 509             Set<UidRange> rangesToRemove, int vpnAppUid) {
 510         // Calculate the list of app uids that are no longer under the VPN due to the removed UID
 511         // ranges and update Netd about them.
 512         final Set<Integer> changedUids = intersectUids(rangesToRemove, mAllApps);
 513         removeBypassingUids(changedUids, vpnAppUid);
 514         updateVpnUids(iface, changedUids, false);
 515         Set<UidRange> existingRanges = mVpnUidRanges.getOrDefault(iface, null);
 516         if (existingRanges == null) {
 517             loge("Attempt to remove unknown vpn uid Range iface = " + iface);
 518             return;
 519         }
 520         existingRanges.removeAll(rangesToRemove);
 521         if (existingRanges.size() == 0) {
 522             mVpnUidRanges.remove(iface);
 523         }
 524     }
 525
 526     /**
 527      * Compute the intersection of a set of UidRanges and appIds. Returns a set of uids
 528      * that satisfies:
 529      *   1. falls into one of the UidRange
 530      *   2. matches one of the appIds
 531      */
 532     private Set<Integer> intersectUids(Set<UidRange> ranges, Set<Integer> appIds) {
 533         Set<Integer> result = new HashSet<>();
 534         for (UidRange range : ranges) {
 535             for (int userId = range.getStartUser(); userId <= range.getEndUser(); userId++) {
 536                 for (int appId : appIds) {
 537                     final int uid = UserHandle.getUid(userId, appId);
 538                     if (range.contains(uid)) {
 539                         result.add(uid);
 540                     }
 541                 }
 542             }
 543         }
 544         return result;
 545     }
 546
 547     /**
 548      * Remove all apps which can elect to bypass the VPN from the list of uids
 549      *
 550      * An app can elect to bypass the VPN if it hold SYSTEM permission, or if its the active VPN
 551      * app itself.
 552      *
 553      * @param uids The list of uids to operate on
 554      * @param vpnAppUid The uid of the VPN app
 555      */
 556     private void removeBypassingUids(Set<Integer> uids, int vpnAppUid) {
 557         uids.remove(vpnAppUid);
 558         uids.removeIf(uid -> mApps.getOrDefault(uid, NETWORK) == SYSTEM);
 559     }
 560
 561     /**
 562      * Update netd about the list of uids that are under an active VPN connection which they cannot
 563      * bypass.
 564      *
 565      * This is to instruct netd to set up appropriate filtering rules for these uids, such that they
 566      * can only receive ingress packets from the VPN's tunnel interface (and loopback).
 567      *
 568      * @param iface the interface name of the active VPN connection
 569      * @param add {@code true} if the uids are to be added to the interface, {@code false} if they
 570      *        are to be removed from the interface.
 571      */
 572     private void updateVpnUids(String iface, Set<Integer> uids, boolean add) {
 573         if (uids.size() == 0) {
 574             return;
 575         }
 576         try {
 577             if (add) {
 578                 mNetd.firewallAddUidInterfaceRules(iface, toIntArray(uids));
 579             } else {
 580                 mNetd.firewallRemoveUidInterfaceRules(toIntArray(uids));
 581             }
 582         } catch (ServiceSpecificException e) {
 583             // Silently ignore exception when device does not support eBPF, otherwise just log
 584             // the exception and do not crash
 585             if (e.errorCode != OsConstants.EOPNOTSUPP) {
 586                 loge("Exception when updating permissions: ", e);
 587             }
 588         } catch (RemoteException e) {
 589             loge("Exception when updating permissions: ", e);
 590         }
 591     }
 592
 593     /**
 594      * Called by PackageListObserver when a package is installed/uninstalled. Send the updated
 595      * permission information to netd.
 596      *
 597      * @param uid the app uid of the package installed
 598      * @param permissions the permissions the app requested and netd cares about.
 599      *
 600      * @hide
 601      */
 602     @VisibleForTesting
 603     void sendPackagePermissionsForUid(int uid, int permissions) {
 604         SparseIntArray netdPermissionsAppIds = new SparseIntArray();
 605         netdPermissionsAppIds.put(uid, permissions);
 606         sendPackagePermissionsToNetd(netdPermissionsAppIds);
 607     }
 608
 609     /**
 610      * Called by packageManagerService to send IPC to netd. Grant or revoke the INTERNET
 611      * and/or UPDATE_DEVICE_STATS permission of the uids in array.
 612      *
 613      * @param netdPermissionsAppIds integer pairs of uids and the permission granted to it. If the
 614      * permission is 0, revoke all permissions of that uid.
 615      *
 616      * @hide
 617      */
 618     @VisibleForTesting
 619     void sendPackagePermissionsToNetd(SparseIntArray netdPermissionsAppIds) {
 620         if (mNetd == null) {
 621             Log.e(TAG, "Failed to get the netd service");
 622             return;
 623         }
 624         ArrayList<Integer> allPermissionAppIds = new ArrayList<>();
 625         ArrayList<Integer> internetPermissionAppIds = new ArrayList<>();
 626         ArrayList<Integer> updateStatsPermissionAppIds = new ArrayList<>();
 627         ArrayList<Integer> noPermissionAppIds = new ArrayList<>();
 628         ArrayList<Integer> uninstalledAppIds = new ArrayList<>();
 629         for (int i = 0; i < netdPermissionsAppIds.size(); i++) {
 630             int permissions = netdPermissionsAppIds.valueAt(i);
 631             switch(permissions) {
 632                 case (INetd.PERMISSION_INTERNET | INetd.PERMISSION_UPDATE_DEVICE_STATS):
 633                     allPermissionAppIds.add(netdPermissionsAppIds.keyAt(i));
 634                     break;
 635                 case INetd.PERMISSION_INTERNET:
 636                     internetPermissionAppIds.add(netdPermissionsAppIds.keyAt(i));
 637                     break;
 638                 case INetd.PERMISSION_UPDATE_DEVICE_STATS:
 639                     updateStatsPermissionAppIds.add(netdPermissionsAppIds.keyAt(i));
 640                     break;
 641                 case INetd.PERMISSION_NONE:
 642                     noPermissionAppIds.add(netdPermissionsAppIds.keyAt(i));
 643                     break;
 644                 case INetd.PERMISSION_UNINSTALLED:
 645                     uninstalledAppIds.add(netdPermissionsAppIds.keyAt(i));
 646                 default:
 647                     Log.e(TAG, "unknown permission type: " + permissions + "for uid: "
 648                             + netdPermissionsAppIds.keyAt(i));
 649             }
 650         }
 651         try {
 652             // TODO: add a lock inside netd to protect IPC trafficSetNetPermForUids()
 653             if (allPermissionAppIds.size() != 0) {
 654                 mNetd.trafficSetNetPermForUids(
 655                         INetd.PERMISSION_INTERNET | INetd.PERMISSION_UPDATE_DEVICE_STATS,
 656                         ArrayUtils.convertToIntArray(allPermissionAppIds));
 657             }
 658             if (internetPermissionAppIds.size() != 0) {
 659                 mNetd.trafficSetNetPermForUids(INetd.PERMISSION_INTERNET,
 660                         ArrayUtils.convertToIntArray(internetPermissionAppIds));
 661             }
 662             if (updateStatsPermissionAppIds.size() != 0) {
 663                 mNetd.trafficSetNetPermForUids(INetd.PERMISSION_UPDATE_DEVICE_STATS,
 664                         ArrayUtils.convertToIntArray(updateStatsPermissionAppIds));
 665             }
 666             if (noPermissionAppIds.size() != 0) {
 667                 mNetd.trafficSetNetPermForUids(INetd.PERMISSION_NONE,
 668                         ArrayUtils.convertToIntArray(noPermissionAppIds));
 669             }
 670             if (uninstalledAppIds.size() != 0) {
 671                 mNetd.trafficSetNetPermForUids(INetd.PERMISSION_UNINSTALLED,
 672                         ArrayUtils.convertToIntArray(uninstalledAppIds));
 673             }
 674         } catch (RemoteException e) {
 675             Log.e(TAG, "Pass appId list of special permission failed." + e);
 676         }
 677     }
 678
 679     /** Should only be used by unit tests */
 680     @VisibleForTesting
 681     public Set<UidRange> getVpnUidRanges(String iface) {
 682         return mVpnUidRanges.get(iface);
 683     }
 684
 685     /** Dump info to dumpsys */
 686     public void dump(IndentingPrintWriter pw) {
 687         pw.println("Interface filtering rules:");
 688         pw.increaseIndent();
 689         for (Map.Entry<String, Set<UidRange>> vpn : mVpnUidRanges.entrySet()) {
 690             pw.println("Interface: " + vpn.getKey());
 691             pw.println("UIDs: " + vpn.getValue().toString());
 692             pw.println();
 693         }
 694         pw.decreaseIndent();
 695     }
 696
 697     private static void log(String s) {
 698         if (DBG) {
 699             Log.d(TAG, s);
 700         }
 701     }
 702
 703     private static void loge(String s) {
 704         Log.e(TAG, s);
 705     }
 706
 707     private static void loge(String s, Throwable e) {
 708         Log.e(TAG, s, e);
 709     }
 710 }