UserManagerService.java revision 5c0ecfdb37b082bd6bd490270193b676ecb481c2
1/* 2 * Copyright (C) 2011 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.pm; 18 19import static android.content.Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS; 20import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK; 21 22import android.Manifest; 23import android.annotation.NonNull; 24import android.annotation.Nullable; 25import android.annotation.UserIdInt; 26import android.app.Activity; 27import android.app.ActivityManager; 28import android.app.ActivityManagerInternal; 29import android.app.ActivityManagerNative; 30import android.app.AppGlobals; 31import android.app.IActivityManager; 32import android.app.IStopUserCallback; 33import android.app.KeyguardManager; 34import android.app.PendingIntent; 35import android.content.BroadcastReceiver; 36import android.content.Context; 37import android.content.Intent; 38import android.content.IntentFilter; 39import android.content.IntentSender; 40import android.content.pm.PackageManager; 41import android.content.pm.PackageManager.NameNotFoundException; 42import android.content.pm.UserInfo; 43import android.content.res.Resources; 44import android.graphics.Bitmap; 45import android.os.Binder; 46import android.os.Build; 47import android.os.Bundle; 48import android.os.Debug; 49import android.os.Environment; 50import android.os.FileUtils; 51import android.os.Handler; 52import android.os.IBinder; 53import android.os.IUserManager; 54import android.os.Message; 55import android.os.ParcelFileDescriptor; 56import android.os.Parcelable; 57import android.os.PersistableBundle; 58import android.os.Process; 59import android.os.RemoteException; 60import android.os.ResultReceiver; 61import android.os.SELinux; 62import android.os.ServiceManager; 63import android.os.ShellCallback; 64import android.os.ShellCommand; 65import android.os.SystemProperties; 66import android.os.UserHandle; 67import android.os.UserManager; 68import android.os.UserManager.EnforcingUser; 69import android.os.UserManagerInternal; 70import android.os.UserManagerInternal.UserRestrictionsListener; 71import android.os.storage.StorageManager; 72import android.security.GateKeeper; 73import android.service.gatekeeper.IGateKeeperService; 74import android.system.ErrnoException; 75import android.system.Os; 76import android.system.OsConstants; 77import android.text.TextUtils; 78import android.util.AtomicFile; 79import android.util.IntArray; 80import android.util.Log; 81import android.util.Slog; 82import android.util.SparseArray; 83import android.util.SparseBooleanArray; 84import android.util.SparseIntArray; 85import android.util.TimeUtils; 86import android.util.Xml; 87 88import com.android.internal.annotations.GuardedBy; 89import com.android.internal.annotations.VisibleForTesting; 90import com.android.internal.app.IAppOpsService; 91import com.android.internal.logging.MetricsLogger; 92import com.android.internal.util.FastXmlSerializer; 93import com.android.internal.util.Preconditions; 94import com.android.internal.util.XmlUtils; 95import com.android.internal.widget.LockPatternUtils; 96import com.android.server.LocalServices; 97import com.android.server.SystemService; 98import com.android.server.am.UserState; 99import com.android.server.storage.DeviceStorageMonitorInternal; 100 101import libcore.io.IoUtils; 102import libcore.util.Objects; 103 104import org.xmlpull.v1.XmlPullParser; 105import org.xmlpull.v1.XmlPullParserException; 106import org.xmlpull.v1.XmlSerializer; 107 108import java.io.BufferedOutputStream; 109import java.io.File; 110import java.io.FileDescriptor; 111import java.io.FileInputStream; 112import java.io.FileNotFoundException; 113import java.io.FileOutputStream; 114import java.io.InputStream; 115import java.io.OutputStream; 116import java.io.IOException; 117import java.io.PrintWriter; 118import java.nio.charset.StandardCharsets; 119import java.util.ArrayList; 120import java.util.Collections; 121import java.util.LinkedList; 122import java.util.List; 123 124/** 125 * Service for {@link UserManager}. 126 * 127 * Method naming convention: 128 * <ul> 129 * <li> Methods suffixed with "LP" should be called within the {@link #mPackagesLock} lock. 130 * <li> Methods suffixed with "LR" should be called within the {@link #mRestrictionsLock} lock. 131 * <li> Methods suffixed with "LU" should be called within the {@link #mUsersLock} lock. 132 * </ul> 133 */ 134public class UserManagerService extends IUserManager.Stub { 135 136 private static final String LOG_TAG = "UserManagerService"; 137 static final boolean DBG = false; // DO NOT SUBMIT WITH TRUE 138 private static final boolean DBG_WITH_STACKTRACE = false; // DO NOT SUBMIT WITH TRUE 139 // Can be used for manual testing of id recycling 140 private static final boolean RELEASE_DELETED_USER_ID = false; // DO NOT SUBMIT WITH TRUE 141 142 private static final String TAG_NAME = "name"; 143 private static final String TAG_ACCOUNT = "account"; 144 private static final String ATTR_FLAGS = "flags"; 145 private static final String ATTR_ICON_PATH = "icon"; 146 private static final String ATTR_ID = "id"; 147 private static final String ATTR_CREATION_TIME = "created"; 148 private static final String ATTR_LAST_LOGGED_IN_TIME = "lastLoggedIn"; 149 private static final String ATTR_LAST_LOGGED_IN_FINGERPRINT = "lastLoggedInFingerprint"; 150 private static final String ATTR_SERIAL_NO = "serialNumber"; 151 private static final String ATTR_NEXT_SERIAL_NO = "nextSerialNumber"; 152 private static final String ATTR_PARTIAL = "partial"; 153 private static final String ATTR_GUEST_TO_REMOVE = "guestToRemove"; 154 private static final String ATTR_USER_VERSION = "version"; 155 private static final String ATTR_PROFILE_GROUP_ID = "profileGroupId"; 156 private static final String ATTR_PROFILE_BADGE = "profileBadge"; 157 private static final String ATTR_RESTRICTED_PROFILE_PARENT_ID = "restrictedProfileParentId"; 158 private static final String ATTR_SEED_ACCOUNT_NAME = "seedAccountName"; 159 private static final String ATTR_SEED_ACCOUNT_TYPE = "seedAccountType"; 160 private static final String TAG_GUEST_RESTRICTIONS = "guestRestrictions"; 161 private static final String TAG_USERS = "users"; 162 private static final String TAG_USER = "user"; 163 private static final String TAG_RESTRICTIONS = "restrictions"; 164 private static final String TAG_DEVICE_POLICY_RESTRICTIONS = "device_policy_restrictions"; 165 private static final String TAG_DEVICE_POLICY_GLOBAL_RESTRICTIONS = 166 "device_policy_global_restrictions"; 167 /** Legacy name for device owner id tag. */ 168 private static final String TAG_GLOBAL_RESTRICTION_OWNER_ID = "globalRestrictionOwnerUserId"; 169 private static final String TAG_DEVICE_OWNER_USER_ID = "deviceOwnerUserId"; 170 private static final String TAG_ENTRY = "entry"; 171 private static final String TAG_VALUE = "value"; 172 private static final String TAG_SEED_ACCOUNT_OPTIONS = "seedAccountOptions"; 173 private static final String ATTR_KEY = "key"; 174 private static final String ATTR_VALUE_TYPE = "type"; 175 private static final String ATTR_MULTIPLE = "m"; 176 177 private static final String ATTR_TYPE_STRING_ARRAY = "sa"; 178 private static final String ATTR_TYPE_STRING = "s"; 179 private static final String ATTR_TYPE_BOOLEAN = "b"; 180 private static final String ATTR_TYPE_INTEGER = "i"; 181 private static final String ATTR_TYPE_BUNDLE = "B"; 182 private static final String ATTR_TYPE_BUNDLE_ARRAY = "BA"; 183 184 private static final String USER_INFO_DIR = "system" + File.separator + "users"; 185 private static final String USER_LIST_FILENAME = "userlist.xml"; 186 private static final String USER_PHOTO_FILENAME = "photo.png"; 187 private static final String USER_PHOTO_FILENAME_TMP = USER_PHOTO_FILENAME + ".tmp"; 188 189 private static final String RESTRICTIONS_FILE_PREFIX = "res_"; 190 private static final String XML_SUFFIX = ".xml"; 191 192 private static final int ALLOWED_FLAGS_FOR_CREATE_USERS_PERMISSION = 193 UserInfo.FLAG_MANAGED_PROFILE 194 | UserInfo.FLAG_EPHEMERAL 195 | UserInfo.FLAG_RESTRICTED 196 | UserInfo.FLAG_GUEST 197 | UserInfo.FLAG_DEMO; 198 199 @VisibleForTesting 200 static final int MIN_USER_ID = 10; 201 // We need to keep process uid within Integer.MAX_VALUE. 202 @VisibleForTesting 203 static final int MAX_USER_ID = Integer.MAX_VALUE / UserHandle.PER_USER_RANGE; 204 205 // Max size of the queue of recently removed users 206 @VisibleForTesting 207 static final int MAX_RECENTLY_REMOVED_IDS_SIZE = 100; 208 209 private static final int USER_VERSION = 7; 210 211 private static final long EPOCH_PLUS_30_YEARS = 30L * 365 * 24 * 60 * 60 * 1000L; // ms 212 213 // Maximum number of managed profiles permitted per user is 1. This cannot be increased 214 // without first making sure that the rest of the framework is prepared for it. 215 @VisibleForTesting 216 static final int MAX_MANAGED_PROFILES = 1; 217 218 static final int WRITE_USER_MSG = 1; 219 static final int WRITE_USER_DELAY = 2*1000; // 2 seconds 220 221 private static final String XATTR_SERIAL = "user.serial"; 222 223 // Tron counters 224 private static final String TRON_GUEST_CREATED = "users_guest_created"; 225 private static final String TRON_USER_CREATED = "users_user_created"; 226 227 private final Context mContext; 228 private final PackageManagerService mPm; 229 private final Object mPackagesLock; 230 private final UserDataPreparer mUserDataPreparer; 231 // Short-term lock for internal state, when interaction/sync with PM is not required 232 private final Object mUsersLock = new Object(); 233 private final Object mRestrictionsLock = new Object(); 234 235 private final Handler mHandler; 236 237 private final File mUsersDir; 238 private final File mUserListFile; 239 240 private static final IBinder mUserRestriconToken = new Binder(); 241 242 /** 243 * User-related information that is used for persisting to flash. Only UserInfo is 244 * directly exposed to other system apps. 245 */ 246 @VisibleForTesting 247 static class UserData { 248 // Basic user information and properties 249 UserInfo info; 250 // Account name used when there is a strong association between a user and an account 251 String account; 252 // Account information for seeding into a newly created user. This could also be 253 // used for login validation for an existing user, for updating their credentials. 254 // In the latter case, data may not need to be persisted as it is only valid for the 255 // current login session. 256 String seedAccountName; 257 String seedAccountType; 258 PersistableBundle seedAccountOptions; 259 // Whether to perist the seed account information to be available after a boot 260 boolean persistSeedData; 261 262 void clearSeedAccountData() { 263 seedAccountName = null; 264 seedAccountType = null; 265 seedAccountOptions = null; 266 persistSeedData = false; 267 } 268 } 269 270 @GuardedBy("mUsersLock") 271 private final SparseArray<UserData> mUsers = new SparseArray<>(); 272 273 /** 274 * User restrictions set via UserManager. This doesn't include restrictions set by 275 * device owner / profile owners. Only non-empty restriction bundles are stored. 276 * 277 * DO NOT Change existing {@link Bundle} in it. When changing a restriction for a user, 278 * a new {@link Bundle} should always be created and set. This is because a {@link Bundle} 279 * maybe shared between {@link #mBaseUserRestrictions} and 280 * {@link #mCachedEffectiveUserRestrictions}, but they should always updated separately. 281 * (Otherwise we won't be able to detect what restrictions have changed in 282 * {@link #updateUserRestrictionsInternalLR}. 283 */ 284 @GuardedBy("mRestrictionsLock") 285 private final SparseArray<Bundle> mBaseUserRestrictions = new SparseArray<>(); 286 287 /** 288 * Cached user restrictions that are in effect -- i.e. {@link #mBaseUserRestrictions} combined 289 * with device / profile owner restrictions. We'll initialize it lazily; use 290 * {@link #getEffectiveUserRestrictions} to access it. 291 * 292 * DO NOT Change existing {@link Bundle} in it. When changing a restriction for a user, 293 * a new {@link Bundle} should always be created and set. This is because a {@link Bundle} 294 * maybe shared between {@link #mBaseUserRestrictions} and 295 * {@link #mCachedEffectiveUserRestrictions}, but they should always updated separately. 296 * (Otherwise we won't be able to detect what restrictions have changed in 297 * {@link #updateUserRestrictionsInternalLR}. 298 */ 299 @GuardedBy("mRestrictionsLock") 300 private final SparseArray<Bundle> mCachedEffectiveUserRestrictions = new SparseArray<>(); 301 302 /** 303 * User restrictions that have already been applied in 304 * {@link #updateUserRestrictionsInternalLR(Bundle, int)}. We use it to detect restrictions 305 * that have changed since the last 306 * {@link #updateUserRestrictionsInternalLR(Bundle, int)} call. 307 */ 308 @GuardedBy("mRestrictionsLock") 309 private final SparseArray<Bundle> mAppliedUserRestrictions = new SparseArray<>(); 310 311 /** 312 * User restrictions set by {@link com.android.server.devicepolicy.DevicePolicyManagerService} 313 * that should be applied to all users, including guests. Only non-empty restriction bundles are 314 * stored. 315 */ 316 @GuardedBy("mRestrictionsLock") 317 private final SparseArray<Bundle> mDevicePolicyGlobalUserRestrictions = new SparseArray<>(); 318 319 /** 320 * Id of the user that set global restrictions. 321 */ 322 @GuardedBy("mRestrictionsLock") 323 private int mDeviceOwnerUserId = UserHandle.USER_NULL; 324 325 /** 326 * User restrictions set by {@link com.android.server.devicepolicy.DevicePolicyManagerService} 327 * for each user. Only non-empty restriction bundles are stored. 328 */ 329 @GuardedBy("mRestrictionsLock") 330 private final SparseArray<Bundle> mDevicePolicyLocalUserRestrictions = new SparseArray<>(); 331 332 @GuardedBy("mGuestRestrictions") 333 private final Bundle mGuestRestrictions = new Bundle(); 334 335 /** 336 * Set of user IDs being actively removed. Removed IDs linger in this set 337 * for several seconds to work around a VFS caching issue. 338 * Use {@link #addRemovingUserIdLocked(int)} to add elements to this array 339 */ 340 @GuardedBy("mUsersLock") 341 private final SparseBooleanArray mRemovingUserIds = new SparseBooleanArray(); 342 343 /** 344 * Queue of recently removed userIds. Used for recycling of userIds 345 */ 346 @GuardedBy("mUsersLock") 347 private final LinkedList<Integer> mRecentlyRemovedIds = new LinkedList<>(); 348 349 @GuardedBy("mUsersLock") 350 private int[] mUserIds; 351 @GuardedBy("mPackagesLock") 352 private int mNextSerialNumber; 353 private int mUserVersion = 0; 354 355 private IAppOpsService mAppOpsService; 356 357 private final LocalService mLocalService; 358 359 @GuardedBy("mUsersLock") 360 private boolean mIsDeviceManaged; 361 362 @GuardedBy("mUsersLock") 363 private final SparseBooleanArray mIsUserManaged = new SparseBooleanArray(); 364 365 @GuardedBy("mUserRestrictionsListeners") 366 private final ArrayList<UserRestrictionsListener> mUserRestrictionsListeners = 367 new ArrayList<>(); 368 369 private final LockPatternUtils mLockPatternUtils; 370 371 private final String ACTION_DISABLE_QUIET_MODE_AFTER_UNLOCK = 372 "com.android.server.pm.DISABLE_QUIET_MODE_AFTER_UNLOCK"; 373 374 private final BroadcastReceiver mDisableQuietModeCallback = new BroadcastReceiver() { 375 @Override 376 public void onReceive(Context context, Intent intent) { 377 if (ACTION_DISABLE_QUIET_MODE_AFTER_UNLOCK.equals(intent.getAction())) { 378 final IntentSender target = intent.getParcelableExtra(Intent.EXTRA_INTENT); 379 final int userHandle = intent.getIntExtra(Intent.EXTRA_USER_ID, 0); 380 setQuietModeEnabled(userHandle, false); 381 if (target != null) { 382 try { 383 mContext.startIntentSender(target, null, 0, 0, 0); 384 } catch (IntentSender.SendIntentException e) { 385 /* ignore */ 386 } 387 } 388 } 389 } 390 }; 391 392 /** 393 * Whether all users should be created ephemeral. 394 */ 395 @GuardedBy("mUsersLock") 396 private boolean mForceEphemeralUsers; 397 398 @GuardedBy("mUserStates") 399 private final SparseIntArray mUserStates = new SparseIntArray(); 400 401 private static UserManagerService sInstance; 402 403 public static UserManagerService getInstance() { 404 synchronized (UserManagerService.class) { 405 return sInstance; 406 } 407 } 408 409 public static class LifeCycle extends SystemService { 410 411 private UserManagerService mUms; 412 413 /** 414 * @param context 415 */ 416 public LifeCycle(Context context) { 417 super(context); 418 } 419 420 @Override 421 public void onStart() { 422 mUms = UserManagerService.getInstance(); 423 publishBinderService(Context.USER_SERVICE, mUms); 424 } 425 426 @Override 427 public void onBootPhase(int phase) { 428 if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY) { 429 mUms.cleanupPartialUsers(); 430 } 431 } 432 } 433 434 // TODO b/28848102 Add support for test dependencies injection 435 @VisibleForTesting 436 UserManagerService(Context context) { 437 this(context, null, null, new Object(), context.getCacheDir()); 438 } 439 440 /** 441 * Called by package manager to create the service. This is closely 442 * associated with the package manager, and the given lock is the 443 * package manager's own lock. 444 */ 445 UserManagerService(Context context, PackageManagerService pm, UserDataPreparer userDataPreparer, 446 Object packagesLock) { 447 this(context, pm, userDataPreparer, packagesLock, Environment.getDataDirectory()); 448 } 449 450 private UserManagerService(Context context, PackageManagerService pm, 451 UserDataPreparer userDataPreparer, Object packagesLock, File dataDir) { 452 mContext = context; 453 mPm = pm; 454 mPackagesLock = packagesLock; 455 mHandler = new MainHandler(); 456 mUserDataPreparer = userDataPreparer; 457 synchronized (mPackagesLock) { 458 mUsersDir = new File(dataDir, USER_INFO_DIR); 459 mUsersDir.mkdirs(); 460 // Make zeroth user directory, for services to migrate their files to that location 461 File userZeroDir = new File(mUsersDir, String.valueOf(UserHandle.USER_SYSTEM)); 462 userZeroDir.mkdirs(); 463 FileUtils.setPermissions(mUsersDir.toString(), 464 FileUtils.S_IRWXU | FileUtils.S_IRWXG | FileUtils.S_IROTH | FileUtils.S_IXOTH, 465 -1, -1); 466 mUserListFile = new File(mUsersDir, USER_LIST_FILENAME); 467 initDefaultGuestRestrictions(); 468 readUserListLP(); 469 sInstance = this; 470 } 471 mLocalService = new LocalService(); 472 LocalServices.addService(UserManagerInternal.class, mLocalService); 473 mLockPatternUtils = new LockPatternUtils(mContext); 474 mUserStates.put(UserHandle.USER_SYSTEM, UserState.STATE_BOOTING); 475 } 476 477 void systemReady() { 478 mAppOpsService = IAppOpsService.Stub.asInterface( 479 ServiceManager.getService(Context.APP_OPS_SERVICE)); 480 481 synchronized (mRestrictionsLock) { 482 applyUserRestrictionsLR(UserHandle.USER_SYSTEM); 483 } 484 485 UserInfo currentGuestUser = findCurrentGuestUser(); 486 if (currentGuestUser != null && !hasUserRestriction( 487 UserManager.DISALLOW_CONFIG_WIFI, currentGuestUser.id)) { 488 // If a guest user currently exists, apply the DISALLOW_CONFIG_WIFI option 489 // to it, in case this guest was created in a previous version where this 490 // user restriction was not a default guest restriction. 491 setUserRestriction(UserManager.DISALLOW_CONFIG_WIFI, true, currentGuestUser.id); 492 } 493 494 mContext.registerReceiver(mDisableQuietModeCallback, 495 new IntentFilter(ACTION_DISABLE_QUIET_MODE_AFTER_UNLOCK), 496 null, mHandler); 497 } 498 499 void cleanupPartialUsers() { 500 // Prune out any partially created, partially removed and ephemeral users. 501 ArrayList<UserInfo> partials = new ArrayList<>(); 502 synchronized (mUsersLock) { 503 final int userSize = mUsers.size(); 504 for (int i = 0; i < userSize; i++) { 505 UserInfo ui = mUsers.valueAt(i).info; 506 if ((ui.partial || ui.guestToRemove || ui.isEphemeral()) && i != 0) { 507 partials.add(ui); 508 addRemovingUserIdLocked(ui.id); 509 ui.partial = true; 510 } 511 } 512 } 513 final int partialsSize = partials.size(); 514 for (int i = 0; i < partialsSize; i++) { 515 UserInfo ui = partials.get(i); 516 Slog.w(LOG_TAG, "Removing partially created user " + ui.id 517 + " (name=" + ui.name + ")"); 518 removeUserState(ui.id); 519 } 520 } 521 522 @Override 523 public String getUserAccount(int userId) { 524 checkManageUserAndAcrossUsersFullPermission("get user account"); 525 synchronized (mUsersLock) { 526 return mUsers.get(userId).account; 527 } 528 } 529 530 @Override 531 public void setUserAccount(int userId, String accountName) { 532 checkManageUserAndAcrossUsersFullPermission("set user account"); 533 UserData userToUpdate = null; 534 synchronized (mPackagesLock) { 535 synchronized (mUsersLock) { 536 final UserData userData = mUsers.get(userId); 537 if (userData == null) { 538 Slog.e(LOG_TAG, "User not found for setting user account: u" + userId); 539 return; 540 } 541 String currentAccount = userData.account; 542 if (!Objects.equal(currentAccount, accountName)) { 543 userData.account = accountName; 544 userToUpdate = userData; 545 } 546 } 547 548 if (userToUpdate != null) { 549 writeUserLP(userToUpdate); 550 } 551 } 552 } 553 554 @Override 555 public UserInfo getPrimaryUser() { 556 checkManageUsersPermission("query users"); 557 synchronized (mUsersLock) { 558 final int userSize = mUsers.size(); 559 for (int i = 0; i < userSize; i++) { 560 UserInfo ui = mUsers.valueAt(i).info; 561 if (ui.isPrimary() && !mRemovingUserIds.get(ui.id)) { 562 return ui; 563 } 564 } 565 } 566 return null; 567 } 568 569 @Override 570 public @NonNull List<UserInfo> getUsers(boolean excludeDying) { 571 checkManageOrCreateUsersPermission("query users"); 572 synchronized (mUsersLock) { 573 ArrayList<UserInfo> users = new ArrayList<UserInfo>(mUsers.size()); 574 final int userSize = mUsers.size(); 575 for (int i = 0; i < userSize; i++) { 576 UserInfo ui = mUsers.valueAt(i).info; 577 if (ui.partial) { 578 continue; 579 } 580 if (!excludeDying || !mRemovingUserIds.get(ui.id)) { 581 users.add(userWithName(ui)); 582 } 583 } 584 return users; 585 } 586 } 587 588 @Override 589 public List<UserInfo> getProfiles(int userId, boolean enabledOnly) { 590 boolean returnFullInfo = true; 591 if (userId != UserHandle.getCallingUserId()) { 592 checkManageOrCreateUsersPermission("getting profiles related to user " + userId); 593 } else { 594 returnFullInfo = hasManageUsersPermission(); 595 } 596 final long ident = Binder.clearCallingIdentity(); 597 try { 598 synchronized (mUsersLock) { 599 return getProfilesLU(userId, enabledOnly, returnFullInfo); 600 } 601 } finally { 602 Binder.restoreCallingIdentity(ident); 603 } 604 } 605 606 @Override 607 public int[] getProfileIds(int userId, boolean enabledOnly) { 608 if (userId != UserHandle.getCallingUserId()) { 609 checkManageOrCreateUsersPermission("getting profiles related to user " + userId); 610 } 611 final long ident = Binder.clearCallingIdentity(); 612 try { 613 synchronized (mUsersLock) { 614 return getProfileIdsLU(userId, enabledOnly).toArray(); 615 } 616 } finally { 617 Binder.restoreCallingIdentity(ident); 618 } 619 } 620 621 /** Assume permissions already checked and caller's identity cleared */ 622 private List<UserInfo> getProfilesLU(int userId, boolean enabledOnly, boolean fullInfo) { 623 IntArray profileIds = getProfileIdsLU(userId, enabledOnly); 624 ArrayList<UserInfo> users = new ArrayList<>(profileIds.size()); 625 for (int i = 0; i < profileIds.size(); i++) { 626 int profileId = profileIds.get(i); 627 UserInfo userInfo = mUsers.get(profileId).info; 628 // If full info is not required - clear PII data to prevent 3P apps from reading it 629 if (!fullInfo) { 630 userInfo = new UserInfo(userInfo); 631 userInfo.name = null; 632 userInfo.iconPath = null; 633 } else { 634 userInfo = userWithName(userInfo); 635 } 636 users.add(userInfo); 637 } 638 return users; 639 } 640 641 /** 642 * Assume permissions already checked and caller's identity cleared 643 */ 644 private IntArray getProfileIdsLU(int userId, boolean enabledOnly) { 645 UserInfo user = getUserInfoLU(userId); 646 IntArray result = new IntArray(mUsers.size()); 647 if (user == null) { 648 // Probably a dying user 649 return result; 650 } 651 final int userSize = mUsers.size(); 652 for (int i = 0; i < userSize; i++) { 653 UserInfo profile = mUsers.valueAt(i).info; 654 if (!isProfileOf(user, profile)) { 655 continue; 656 } 657 if (enabledOnly && !profile.isEnabled()) { 658 continue; 659 } 660 if (mRemovingUserIds.get(profile.id)) { 661 continue; 662 } 663 if (profile.partial) { 664 continue; 665 } 666 result.add(profile.id); 667 } 668 return result; 669 } 670 671 @Override 672 public int getCredentialOwnerProfile(int userHandle) { 673 checkManageUsersPermission("get the credential owner"); 674 if (!mLockPatternUtils.isSeparateProfileChallengeEnabled(userHandle)) { 675 synchronized (mUsersLock) { 676 UserInfo profileParent = getProfileParentLU(userHandle); 677 if (profileParent != null) { 678 return profileParent.id; 679 } 680 } 681 } 682 683 return userHandle; 684 } 685 686 @Override 687 public boolean isSameProfileGroup(int userId, int otherUserId) { 688 if (userId == otherUserId) return true; 689 checkManageUsersPermission("check if in the same profile group"); 690 return isSameProfileGroupNoChecks(userId, otherUserId); 691 } 692 693 private boolean isSameProfileGroupNoChecks(int userId, int otherUserId) { 694 synchronized (mUsersLock) { 695 UserInfo userInfo = getUserInfoLU(userId); 696 if (userInfo == null || userInfo.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID) { 697 return false; 698 } 699 UserInfo otherUserInfo = getUserInfoLU(otherUserId); 700 if (otherUserInfo == null 701 || otherUserInfo.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID) { 702 return false; 703 } 704 return userInfo.profileGroupId == otherUserInfo.profileGroupId; 705 } 706 } 707 708 @Override 709 public UserInfo getProfileParent(int userHandle) { 710 checkManageUsersPermission("get the profile parent"); 711 synchronized (mUsersLock) { 712 return getProfileParentLU(userHandle); 713 } 714 } 715 716 private UserInfo getProfileParentLU(int userHandle) { 717 UserInfo profile = getUserInfoLU(userHandle); 718 if (profile == null) { 719 return null; 720 } 721 int parentUserId = profile.profileGroupId; 722 if (parentUserId == userHandle || parentUserId == UserInfo.NO_PROFILE_GROUP_ID) { 723 return null; 724 } else { 725 return getUserInfoLU(parentUserId); 726 } 727 } 728 729 private static boolean isProfileOf(UserInfo user, UserInfo profile) { 730 return user.id == profile.id || 731 (user.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID 732 && user.profileGroupId == profile.profileGroupId); 733 } 734 735 private void broadcastProfileAvailabilityChanges(UserHandle profileHandle, 736 UserHandle parentHandle, boolean inQuietMode) { 737 Intent intent = new Intent(); 738 if (inQuietMode) { 739 intent.setAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE); 740 } else { 741 intent.setAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE); 742 } 743 intent.putExtra(Intent.EXTRA_QUIET_MODE, inQuietMode); 744 intent.putExtra(Intent.EXTRA_USER, profileHandle); 745 intent.putExtra(Intent.EXTRA_USER_HANDLE, profileHandle.getIdentifier()); 746 intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 747 mContext.sendBroadcastAsUser(intent, parentHandle); 748 } 749 750 @Override 751 public void setQuietModeEnabled(int userHandle, boolean enableQuietMode) { 752 checkManageUsersPermission("silence profile"); 753 boolean changed = false; 754 UserInfo profile, parent; 755 synchronized (mPackagesLock) { 756 synchronized (mUsersLock) { 757 profile = getUserInfoLU(userHandle); 758 parent = getProfileParentLU(userHandle); 759 760 } 761 if (profile == null || !profile.isManagedProfile()) { 762 throw new IllegalArgumentException("User " + userHandle + " is not a profile"); 763 } 764 if (profile.isQuietModeEnabled() != enableQuietMode) { 765 profile.flags ^= UserInfo.FLAG_QUIET_MODE; 766 writeUserLP(getUserDataLU(profile.id)); 767 changed = true; 768 } 769 } 770 if (changed) { 771 long identity = Binder.clearCallingIdentity(); 772 try { 773 if (enableQuietMode) { 774 ActivityManager.getService().stopUser(userHandle, /* force */true, null); 775 LocalServices.getService(ActivityManagerInternal.class) 776 .killForegroundAppsForUser(userHandle); 777 } else { 778 ActivityManager.getService().startUserInBackground(userHandle); 779 } 780 } catch (RemoteException e) { 781 Slog.e(LOG_TAG, "fail to start/stop user for quiet mode", e); 782 } finally { 783 Binder.restoreCallingIdentity(identity); 784 } 785 786 broadcastProfileAvailabilityChanges(profile.getUserHandle(), parent.getUserHandle(), 787 enableQuietMode); 788 } 789 } 790 791 @Override 792 public boolean isQuietModeEnabled(int userHandle) { 793 synchronized (mPackagesLock) { 794 UserInfo info; 795 synchronized (mUsersLock) { 796 info = getUserInfoLU(userHandle); 797 } 798 if (info == null || !info.isManagedProfile()) { 799 return false; 800 } 801 return info.isQuietModeEnabled(); 802 } 803 } 804 805 @Override 806 public boolean trySetQuietModeDisabled(int userHandle, IntentSender target) { 807 checkManageUsersPermission("silence profile"); 808 if (StorageManager.isUserKeyUnlocked(userHandle) 809 || !mLockPatternUtils.isSecure(userHandle)) { 810 // if the user is already unlocked, no need to show a profile challenge 811 setQuietModeEnabled(userHandle, false); 812 return true; 813 } 814 815 long identity = Binder.clearCallingIdentity(); 816 try { 817 // otherwise, we show a profile challenge to trigger decryption of the user 818 final KeyguardManager km = (KeyguardManager) mContext.getSystemService( 819 Context.KEYGUARD_SERVICE); 820 // We should use userHandle not credentialOwnerUserId here, as even if it is unified 821 // lock, confirm screenlock page will know and show personal challenge, and unlock 822 // work profile when personal challenge is correct 823 final Intent unlockIntent = km.createConfirmDeviceCredentialIntent(null, null, 824 userHandle); 825 if (unlockIntent == null) { 826 return false; 827 } 828 final Intent callBackIntent = new Intent( 829 ACTION_DISABLE_QUIET_MODE_AFTER_UNLOCK); 830 if (target != null) { 831 callBackIntent.putExtra(Intent.EXTRA_INTENT, target); 832 } 833 callBackIntent.putExtra(Intent.EXTRA_USER_ID, userHandle); 834 callBackIntent.setPackage(mContext.getPackageName()); 835 callBackIntent.addFlags(Intent.FLAG_RECEIVER_FOREGROUND); 836 final PendingIntent pendingIntent = PendingIntent.getBroadcast( 837 mContext, 838 0, 839 callBackIntent, 840 PendingIntent.FLAG_CANCEL_CURRENT | 841 PendingIntent.FLAG_ONE_SHOT | 842 PendingIntent.FLAG_IMMUTABLE); 843 // After unlocking the challenge, it will disable quiet mode and run the original 844 // intentSender 845 unlockIntent.putExtra(Intent.EXTRA_INTENT, pendingIntent.getIntentSender()); 846 unlockIntent.setFlags(FLAG_ACTIVITY_NEW_TASK | FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); 847 mContext.startActivity(unlockIntent); 848 } finally { 849 Binder.restoreCallingIdentity(identity); 850 } 851 return false; 852 } 853 854 @Override 855 public void setUserEnabled(int userId) { 856 checkManageUsersPermission("enable user"); 857 synchronized (mPackagesLock) { 858 UserInfo info; 859 synchronized (mUsersLock) { 860 info = getUserInfoLU(userId); 861 } 862 if (info != null && !info.isEnabled()) { 863 info.flags ^= UserInfo.FLAG_DISABLED; 864 writeUserLP(getUserDataLU(info.id)); 865 } 866 } 867 } 868 869 /** 870 * Evicts a user's CE key by stopping and restarting the user. 871 * 872 * The key is evicted automatically by the user controller when the user has stopped. 873 */ 874 @Override 875 public void evictCredentialEncryptionKey(@UserIdInt int userId) { 876 checkManageUsersPermission("evict CE key"); 877 final IActivityManager am = ActivityManagerNative.getDefault(); 878 final long identity = Binder.clearCallingIdentity(); 879 try { 880 am.restartUserInBackground(userId); 881 } catch (RemoteException re) { 882 throw re.rethrowAsRuntimeException(); 883 } finally { 884 Binder.restoreCallingIdentity(identity); 885 } 886 } 887 888 @Override 889 public UserInfo getUserInfo(int userId) { 890 checkManageOrCreateUsersPermission("query user"); 891 synchronized (mUsersLock) { 892 return userWithName(getUserInfoLU(userId)); 893 } 894 } 895 896 /** 897 * Returns a UserInfo object with the name filled in, for Owner, or the original 898 * if the name is already set. 899 */ 900 private UserInfo userWithName(UserInfo orig) { 901 if (orig != null && orig.name == null && orig.id == UserHandle.USER_SYSTEM) { 902 UserInfo withName = new UserInfo(orig); 903 withName.name = getOwnerName(); 904 return withName; 905 } else { 906 return orig; 907 } 908 } 909 910 @Override 911 public int getManagedProfileBadge(@UserIdInt int userId) { 912 int callingUserId = UserHandle.getCallingUserId(); 913 if (callingUserId != userId && !hasManageUsersPermission()) { 914 if (!isSameProfileGroupNoChecks(callingUserId, userId)) { 915 throw new SecurityException( 916 "You need MANAGE_USERS permission to: check if specified user a " + 917 "managed profile outside your profile group"); 918 } 919 } 920 synchronized (mUsersLock) { 921 UserInfo userInfo = getUserInfoLU(userId); 922 return userInfo != null ? userInfo.profileBadge : 0; 923 } 924 } 925 926 @Override 927 public boolean isManagedProfile(int userId) { 928 int callingUserId = UserHandle.getCallingUserId(); 929 if (callingUserId != userId && !hasManageUsersPermission()) { 930 if (!isSameProfileGroupNoChecks(callingUserId, userId)) { 931 throw new SecurityException( 932 "You need MANAGE_USERS permission to: check if specified user a " + 933 "managed profile outside your profile group"); 934 } 935 } 936 synchronized (mUsersLock) { 937 UserInfo userInfo = getUserInfoLU(userId); 938 return userInfo != null && userInfo.isManagedProfile(); 939 } 940 } 941 942 @Override 943 public boolean isUserUnlockingOrUnlocked(int userId) { 944 checkManageOrInteractPermIfCallerInOtherProfileGroup(userId, "isUserUnlockingOrUnlocked"); 945 return mLocalService.isUserUnlockingOrUnlocked(userId); 946 } 947 948 @Override 949 public boolean isUserUnlocked(int userId) { 950 checkManageOrInteractPermIfCallerInOtherProfileGroup(userId, "isUserUnlocked"); 951 return mLocalService.isUserUnlockingOrUnlocked(userId); 952 } 953 954 @Override 955 public boolean isUserRunning(int userId) { 956 checkManageOrInteractPermIfCallerInOtherProfileGroup(userId, "isUserRunning"); 957 return mLocalService.isUserRunning(userId); 958 } 959 960 private void checkManageOrInteractPermIfCallerInOtherProfileGroup(int userId, String name) { 961 int callingUserId = UserHandle.getCallingUserId(); 962 if (callingUserId == userId || isSameProfileGroupNoChecks(callingUserId, userId) || 963 hasManageUsersPermission()) { 964 return; 965 } 966 if (ActivityManager.checkComponentPermission(Manifest.permission.INTERACT_ACROSS_USERS, 967 Binder.getCallingUid(), -1, true) != PackageManager.PERMISSION_GRANTED) { 968 throw new SecurityException("You need INTERACT_ACROSS_USERS or MANAGE_USERS permission " 969 + "to: check " + name); 970 } 971 } 972 973 @Override 974 public boolean isDemoUser(int userId) { 975 int callingUserId = UserHandle.getCallingUserId(); 976 if (callingUserId != userId && !hasManageUsersPermission()) { 977 throw new SecurityException("You need MANAGE_USERS permission to query if u=" + userId 978 + " is a demo user"); 979 } 980 synchronized (mUsersLock) { 981 UserInfo userInfo = getUserInfoLU(userId); 982 return userInfo != null && userInfo.isDemo(); 983 } 984 } 985 986 @Override 987 public boolean isRestricted() { 988 synchronized (mUsersLock) { 989 return getUserInfoLU(UserHandle.getCallingUserId()).isRestricted(); 990 } 991 } 992 993 @Override 994 public boolean canHaveRestrictedProfile(int userId) { 995 checkManageUsersPermission("canHaveRestrictedProfile"); 996 synchronized (mUsersLock) { 997 final UserInfo userInfo = getUserInfoLU(userId); 998 if (userInfo == null || !userInfo.canHaveProfile()) { 999 return false; 1000 } 1001 if (!userInfo.isAdmin()) { 1002 return false; 1003 } 1004 // restricted profile can be created if there is no DO set and the admin user has no PO; 1005 return !mIsDeviceManaged && !mIsUserManaged.get(userId); 1006 } 1007 } 1008 1009 /* 1010 * Should be locked on mUsers before calling this. 1011 */ 1012 private UserInfo getUserInfoLU(int userId) { 1013 final UserData userData = mUsers.get(userId); 1014 // If it is partial and not in the process of being removed, return as unknown user. 1015 if (userData != null && userData.info.partial && !mRemovingUserIds.get(userId)) { 1016 Slog.w(LOG_TAG, "getUserInfo: unknown user #" + userId); 1017 return null; 1018 } 1019 return userData != null ? userData.info : null; 1020 } 1021 1022 private UserData getUserDataLU(int userId) { 1023 final UserData userData = mUsers.get(userId); 1024 // If it is partial and not in the process of being removed, return as unknown user. 1025 if (userData != null && userData.info.partial && !mRemovingUserIds.get(userId)) { 1026 return null; 1027 } 1028 return userData; 1029 } 1030 1031 /** 1032 * Obtains {@link #mUsersLock} and return UserInfo from mUsers. 1033 * <p>No permissions checking or any addition checks are made</p> 1034 */ 1035 private UserInfo getUserInfoNoChecks(int userId) { 1036 synchronized (mUsersLock) { 1037 final UserData userData = mUsers.get(userId); 1038 return userData != null ? userData.info : null; 1039 } 1040 } 1041 1042 /** 1043 * Obtains {@link #mUsersLock} and return UserData from mUsers. 1044 * <p>No permissions checking or any addition checks are made</p> 1045 */ 1046 private UserData getUserDataNoChecks(int userId) { 1047 synchronized (mUsersLock) { 1048 return mUsers.get(userId); 1049 } 1050 } 1051 1052 /** Called by PackageManagerService */ 1053 public boolean exists(int userId) { 1054 return getUserInfoNoChecks(userId) != null; 1055 } 1056 1057 @Override 1058 public void setUserName(int userId, String name) { 1059 checkManageUsersPermission("rename users"); 1060 boolean changed = false; 1061 synchronized (mPackagesLock) { 1062 UserData userData = getUserDataNoChecks(userId); 1063 if (userData == null || userData.info.partial) { 1064 Slog.w(LOG_TAG, "setUserName: unknown user #" + userId); 1065 return; 1066 } 1067 if (name != null && !name.equals(userData.info.name)) { 1068 userData.info.name = name; 1069 writeUserLP(userData); 1070 changed = true; 1071 } 1072 } 1073 if (changed) { 1074 sendUserInfoChangedBroadcast(userId); 1075 } 1076 } 1077 1078 @Override 1079 public void setUserIcon(int userId, Bitmap bitmap) { 1080 checkManageUsersPermission("update users"); 1081 if (hasUserRestriction(UserManager.DISALLOW_SET_USER_ICON, userId)) { 1082 Log.w(LOG_TAG, "Cannot set user icon. DISALLOW_SET_USER_ICON is enabled."); 1083 return; 1084 } 1085 mLocalService.setUserIcon(userId, bitmap); 1086 } 1087 1088 1089 1090 private void sendUserInfoChangedBroadcast(int userId) { 1091 Intent changedIntent = new Intent(Intent.ACTION_USER_INFO_CHANGED); 1092 changedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 1093 changedIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 1094 mContext.sendBroadcastAsUser(changedIntent, UserHandle.ALL); 1095 } 1096 1097 @Override 1098 public ParcelFileDescriptor getUserIcon(int targetUserId) { 1099 String iconPath; 1100 synchronized (mPackagesLock) { 1101 UserInfo targetUserInfo = getUserInfoNoChecks(targetUserId); 1102 if (targetUserInfo == null || targetUserInfo.partial) { 1103 Slog.w(LOG_TAG, "getUserIcon: unknown user #" + targetUserId); 1104 return null; 1105 } 1106 1107 final int callingUserId = UserHandle.getCallingUserId(); 1108 final int callingGroupId = getUserInfoNoChecks(callingUserId).profileGroupId; 1109 final int targetGroupId = targetUserInfo.profileGroupId; 1110 final boolean sameGroup = (callingGroupId != UserInfo.NO_PROFILE_GROUP_ID 1111 && callingGroupId == targetGroupId); 1112 if ((callingUserId != targetUserId) && !sameGroup) { 1113 checkManageUsersPermission("get the icon of a user who is not related"); 1114 } 1115 1116 if (targetUserInfo.iconPath == null) { 1117 return null; 1118 } 1119 iconPath = targetUserInfo.iconPath; 1120 } 1121 1122 try { 1123 return ParcelFileDescriptor.open( 1124 new File(iconPath), ParcelFileDescriptor.MODE_READ_ONLY); 1125 } catch (FileNotFoundException e) { 1126 Log.e(LOG_TAG, "Couldn't find icon file", e); 1127 } 1128 return null; 1129 } 1130 1131 public void makeInitialized(int userId) { 1132 checkManageUsersPermission("makeInitialized"); 1133 boolean scheduleWriteUser = false; 1134 UserData userData; 1135 synchronized (mUsersLock) { 1136 userData = mUsers.get(userId); 1137 if (userData == null || userData.info.partial) { 1138 Slog.w(LOG_TAG, "makeInitialized: unknown user #" + userId); 1139 return; 1140 } 1141 if ((userData.info.flags & UserInfo.FLAG_INITIALIZED) == 0) { 1142 userData.info.flags |= UserInfo.FLAG_INITIALIZED; 1143 scheduleWriteUser = true; 1144 } 1145 } 1146 if (scheduleWriteUser) { 1147 scheduleWriteUser(userData); 1148 } 1149 } 1150 1151 /** 1152 * If default guest restrictions haven't been initialized yet, add the basic 1153 * restrictions. 1154 */ 1155 private void initDefaultGuestRestrictions() { 1156 synchronized (mGuestRestrictions) { 1157 if (mGuestRestrictions.isEmpty()) { 1158 mGuestRestrictions.putBoolean(UserManager.DISALLOW_CONFIG_WIFI, true); 1159 mGuestRestrictions.putBoolean(UserManager.DISALLOW_INSTALL_UNKNOWN_SOURCES, true); 1160 mGuestRestrictions.putBoolean(UserManager.DISALLOW_OUTGOING_CALLS, true); 1161 mGuestRestrictions.putBoolean(UserManager.DISALLOW_SMS, true); 1162 } 1163 } 1164 } 1165 1166 @Override 1167 public Bundle getDefaultGuestRestrictions() { 1168 checkManageUsersPermission("getDefaultGuestRestrictions"); 1169 synchronized (mGuestRestrictions) { 1170 return new Bundle(mGuestRestrictions); 1171 } 1172 } 1173 1174 @Override 1175 public void setDefaultGuestRestrictions(Bundle restrictions) { 1176 checkManageUsersPermission("setDefaultGuestRestrictions"); 1177 synchronized (mGuestRestrictions) { 1178 mGuestRestrictions.clear(); 1179 mGuestRestrictions.putAll(restrictions); 1180 } 1181 synchronized (mPackagesLock) { 1182 writeUserListLP(); 1183 } 1184 } 1185 1186 /** 1187 * See {@link UserManagerInternal#setDevicePolicyUserRestrictions} 1188 */ 1189 private void setDevicePolicyUserRestrictionsInner(int userId, @Nullable Bundle restrictions, 1190 boolean isDeviceOwner, int cameraRestrictionScope) { 1191 final Bundle global = new Bundle(); 1192 final Bundle local = new Bundle(); 1193 1194 // Sort restrictions into local and global ensuring they don't overlap. 1195 UserRestrictionsUtils.sortToGlobalAndLocal(restrictions, isDeviceOwner, 1196 cameraRestrictionScope, global, local); 1197 1198 boolean globalChanged, localChanged; 1199 synchronized (mRestrictionsLock) { 1200 // Update global and local restrictions if they were changed. 1201 globalChanged = updateRestrictionsIfNeededLR( 1202 userId, global, mDevicePolicyGlobalUserRestrictions); 1203 localChanged = updateRestrictionsIfNeededLR( 1204 userId, local, mDevicePolicyLocalUserRestrictions); 1205 1206 if (isDeviceOwner) { 1207 // Remember the global restriction owner userId to be able to make a distinction 1208 // in getUserRestrictionSource on who set local policies. 1209 mDeviceOwnerUserId = userId; 1210 } else { 1211 if (mDeviceOwnerUserId == userId) { 1212 // When profile owner sets restrictions it passes null global bundle and we 1213 // reset global restriction owner userId. 1214 // This means this user used to have DO, but now the DO is gone and the user 1215 // instead has PO. 1216 mDeviceOwnerUserId = UserHandle.USER_NULL; 1217 } 1218 } 1219 } 1220 if (DBG) { 1221 Log.d(LOG_TAG, "setDevicePolicyUserRestrictions: userId=" + userId 1222 + " global=" + global + (globalChanged ? " (changed)" : "") 1223 + " local=" + local + (localChanged ? " (changed)" : "") 1224 ); 1225 } 1226 // Don't call them within the mRestrictionsLock. 1227 synchronized (mPackagesLock) { 1228 if (localChanged || globalChanged) { 1229 writeUserLP(getUserDataNoChecks(userId)); 1230 } 1231 } 1232 1233 synchronized (mRestrictionsLock) { 1234 if (globalChanged) { 1235 applyUserRestrictionsForAllUsersLR(); 1236 } else if (localChanged) { 1237 applyUserRestrictionsLR(userId); 1238 } 1239 } 1240 } 1241 1242 /** 1243 * Updates restriction bundle for a given user in a given restriction array. If new bundle is 1244 * empty, record is removed from the array. 1245 * @return whether restrictions bundle is different from the old one. 1246 */ 1247 private boolean updateRestrictionsIfNeededLR(int userId, @Nullable Bundle restrictions, 1248 SparseArray<Bundle> restrictionsArray) { 1249 final boolean changed = 1250 !UserRestrictionsUtils.areEqual(restrictionsArray.get(userId), restrictions); 1251 if (changed) { 1252 if (!UserRestrictionsUtils.isEmpty(restrictions)) { 1253 restrictionsArray.put(userId, restrictions); 1254 } else { 1255 restrictionsArray.delete(userId); 1256 } 1257 } 1258 return changed; 1259 } 1260 1261 @GuardedBy("mRestrictionsLock") 1262 private Bundle computeEffectiveUserRestrictionsLR(int userId) { 1263 final Bundle baseRestrictions = 1264 UserRestrictionsUtils.nonNull(mBaseUserRestrictions.get(userId)); 1265 final Bundle global = UserRestrictionsUtils.mergeAll(mDevicePolicyGlobalUserRestrictions); 1266 final Bundle local = mDevicePolicyLocalUserRestrictions.get(userId); 1267 1268 if (UserRestrictionsUtils.isEmpty(global) && UserRestrictionsUtils.isEmpty(local)) { 1269 // Common case first. 1270 return baseRestrictions; 1271 } 1272 final Bundle effective = UserRestrictionsUtils.clone(baseRestrictions); 1273 UserRestrictionsUtils.merge(effective, global); 1274 UserRestrictionsUtils.merge(effective, local); 1275 1276 return effective; 1277 } 1278 1279 @GuardedBy("mRestrictionsLock") 1280 private void invalidateEffectiveUserRestrictionsLR(int userId) { 1281 if (DBG) { 1282 Log.d(LOG_TAG, "invalidateEffectiveUserRestrictions userId=" + userId); 1283 } 1284 mCachedEffectiveUserRestrictions.remove(userId); 1285 } 1286 1287 private Bundle getEffectiveUserRestrictions(int userId) { 1288 synchronized (mRestrictionsLock) { 1289 Bundle restrictions = mCachedEffectiveUserRestrictions.get(userId); 1290 if (restrictions == null) { 1291 restrictions = computeEffectiveUserRestrictionsLR(userId); 1292 mCachedEffectiveUserRestrictions.put(userId, restrictions); 1293 } 1294 return restrictions; 1295 } 1296 } 1297 1298 /** @return a specific user restriction that's in effect currently. */ 1299 @Override 1300 public boolean hasUserRestriction(String restrictionKey, int userId) { 1301 if (!UserRestrictionsUtils.isValidRestriction(restrictionKey)) { 1302 return false; 1303 } 1304 Bundle restrictions = getEffectiveUserRestrictions(userId); 1305 return restrictions != null && restrictions.getBoolean(restrictionKey); 1306 } 1307 1308 /** 1309 * @hide 1310 * 1311 * Returns who set a user restriction on a user. 1312 * Requires {@link android.Manifest.permission#MANAGE_USERS} permission. 1313 * @param restrictionKey the string key representing the restriction 1314 * @param userId the id of the user for whom to retrieve the restrictions. 1315 * @return The source of user restriction. Any combination of 1316 * {@link UserManager#RESTRICTION_NOT_SET}, 1317 * {@link UserManager#RESTRICTION_SOURCE_SYSTEM}, 1318 * {@link UserManager#RESTRICTION_SOURCE_DEVICE_OWNER} 1319 * and {@link UserManager#RESTRICTION_SOURCE_PROFILE_OWNER} 1320 */ 1321 @Override 1322 public int getUserRestrictionSource(String restrictionKey, int userId) { 1323 List<EnforcingUser> enforcingUsers = getUserRestrictionSources(restrictionKey, userId); 1324 // Get "bitwise or" of restriction sources for all enforcing users. 1325 int result = UserManager.RESTRICTION_NOT_SET; 1326 for (int i = enforcingUsers.size() - 1; i >= 0; i--) { 1327 result |= enforcingUsers.get(i).getUserRestrictionSource(); 1328 } 1329 return result; 1330 } 1331 1332 @Override 1333 public List<EnforcingUser> getUserRestrictionSources( 1334 String restrictionKey, @UserIdInt int userId) { 1335 checkManageUsersPermission("getUserRestrictionSource"); 1336 1337 // Shortcut for the most common case 1338 if (!hasUserRestriction(restrictionKey, userId)) { 1339 return Collections.emptyList(); 1340 } 1341 1342 final List<EnforcingUser> result = new ArrayList<>(); 1343 1344 // Check if it is base restriction. 1345 if (hasBaseUserRestriction(restrictionKey, userId)) { 1346 result.add(new EnforcingUser( 1347 UserHandle.USER_NULL, UserManager.RESTRICTION_SOURCE_SYSTEM)); 1348 } 1349 1350 synchronized (mRestrictionsLock) { 1351 // Check if it is set by profile owner. 1352 Bundle profileOwnerRestrictions = mDevicePolicyLocalUserRestrictions.get(userId); 1353 if (UserRestrictionsUtils.contains(profileOwnerRestrictions, restrictionKey)) { 1354 result.add(getEnforcingUserLocked(userId)); 1355 } 1356 1357 // Iterate over all users who enforce global restrictions. 1358 for (int i = mDevicePolicyGlobalUserRestrictions.size() - 1; i >= 0; i--) { 1359 Bundle globalRestrictions = mDevicePolicyGlobalUserRestrictions.valueAt(i); 1360 int profileUserId = mDevicePolicyGlobalUserRestrictions.keyAt(i); 1361 if (UserRestrictionsUtils.contains(globalRestrictions, restrictionKey)) { 1362 result.add(getEnforcingUserLocked(profileUserId)); 1363 } 1364 } 1365 } 1366 return result; 1367 } 1368 1369 private EnforcingUser getEnforcingUserLocked(@UserIdInt int userId) { 1370 int source = mDeviceOwnerUserId == userId ? UserManager.RESTRICTION_SOURCE_DEVICE_OWNER 1371 : UserManager.RESTRICTION_SOURCE_PROFILE_OWNER; 1372 return new EnforcingUser(userId, source); 1373 } 1374 1375 /** 1376 * @return UserRestrictions that are in effect currently. This always returns a new 1377 * {@link Bundle}. 1378 */ 1379 @Override 1380 public Bundle getUserRestrictions(int userId) { 1381 return UserRestrictionsUtils.clone(getEffectiveUserRestrictions(userId)); 1382 } 1383 1384 @Override 1385 public boolean hasBaseUserRestriction(String restrictionKey, int userId) { 1386 checkManageUsersPermission("hasBaseUserRestriction"); 1387 if (!UserRestrictionsUtils.isValidRestriction(restrictionKey)) { 1388 return false; 1389 } 1390 synchronized (mRestrictionsLock) { 1391 Bundle bundle = mBaseUserRestrictions.get(userId); 1392 return (bundle != null && bundle.getBoolean(restrictionKey, false)); 1393 } 1394 } 1395 1396 @Override 1397 public void setUserRestriction(String key, boolean value, int userId) { 1398 checkManageUsersPermission("setUserRestriction"); 1399 if (!UserRestrictionsUtils.isValidRestriction(key)) { 1400 return; 1401 } 1402 synchronized (mRestrictionsLock) { 1403 // Note we can't modify Bundles stored in mBaseUserRestrictions directly, so create 1404 // a copy. 1405 final Bundle newRestrictions = UserRestrictionsUtils.clone( 1406 mBaseUserRestrictions.get(userId)); 1407 newRestrictions.putBoolean(key, value); 1408 1409 updateUserRestrictionsInternalLR(newRestrictions, userId); 1410 } 1411 } 1412 1413 /** 1414 * Optionally updating user restrictions, calculate the effective user restrictions and also 1415 * propagate to other services and system settings. 1416 * 1417 * @param newBaseRestrictions User restrictions to set. 1418 * If null, will not update user restrictions and only does the propagation. 1419 * @param userId target user ID. 1420 */ 1421 @GuardedBy("mRestrictionsLock") 1422 private void updateUserRestrictionsInternalLR( 1423 @Nullable Bundle newBaseRestrictions, int userId) { 1424 final Bundle prevAppliedRestrictions = UserRestrictionsUtils.nonNull( 1425 mAppliedUserRestrictions.get(userId)); 1426 1427 // Update base restrictions. 1428 if (newBaseRestrictions != null) { 1429 // If newBaseRestrictions == the current one, it's probably a bug. 1430 final Bundle prevBaseRestrictions = mBaseUserRestrictions.get(userId); 1431 1432 Preconditions.checkState(prevBaseRestrictions != newBaseRestrictions); 1433 Preconditions.checkState(mCachedEffectiveUserRestrictions.get(userId) 1434 != newBaseRestrictions); 1435 1436 if (updateRestrictionsIfNeededLR(userId, newBaseRestrictions, mBaseUserRestrictions)) { 1437 scheduleWriteUser(getUserDataNoChecks(userId)); 1438 } 1439 } 1440 1441 final Bundle effective = computeEffectiveUserRestrictionsLR(userId); 1442 1443 mCachedEffectiveUserRestrictions.put(userId, effective); 1444 1445 // Apply the new restrictions. 1446 if (DBG) { 1447 debug("Applying user restrictions: userId=" + userId 1448 + " new=" + effective + " prev=" + prevAppliedRestrictions); 1449 } 1450 1451 if (mAppOpsService != null) { // We skip it until system-ready. 1452 mHandler.post(new Runnable() { 1453 @Override 1454 public void run() { 1455 try { 1456 mAppOpsService.setUserRestrictions(effective, mUserRestriconToken, userId); 1457 } catch (RemoteException e) { 1458 Log.w(LOG_TAG, "Unable to notify AppOpsService of UserRestrictions"); 1459 } 1460 } 1461 }); 1462 } 1463 1464 propagateUserRestrictionsLR(userId, effective, prevAppliedRestrictions); 1465 1466 mAppliedUserRestrictions.put(userId, new Bundle(effective)); 1467 } 1468 1469 private void propagateUserRestrictionsLR(final int userId, 1470 Bundle newRestrictions, Bundle prevRestrictions) { 1471 // Note this method doesn't touch any state, meaning it doesn't require mRestrictionsLock 1472 // actually, but we still need some kind of synchronization otherwise we might end up 1473 // calling listeners out-of-order, thus "LR". 1474 1475 if (UserRestrictionsUtils.areEqual(newRestrictions, prevRestrictions)) { 1476 return; 1477 } 1478 1479 final Bundle newRestrictionsFinal = new Bundle(newRestrictions); 1480 final Bundle prevRestrictionsFinal = new Bundle(prevRestrictions); 1481 1482 mHandler.post(new Runnable() { 1483 @Override 1484 public void run() { 1485 UserRestrictionsUtils.applyUserRestrictions( 1486 mContext, userId, newRestrictionsFinal, prevRestrictionsFinal); 1487 1488 final UserRestrictionsListener[] listeners; 1489 synchronized (mUserRestrictionsListeners) { 1490 listeners = new UserRestrictionsListener[mUserRestrictionsListeners.size()]; 1491 mUserRestrictionsListeners.toArray(listeners); 1492 } 1493 for (int i = 0; i < listeners.length; i++) { 1494 listeners[i].onUserRestrictionsChanged(userId, 1495 newRestrictionsFinal, prevRestrictionsFinal); 1496 } 1497 } 1498 }); 1499 } 1500 1501 // Package private for the inner class. 1502 void applyUserRestrictionsLR(int userId) { 1503 updateUserRestrictionsInternalLR(null, userId); 1504 } 1505 1506 @GuardedBy("mRestrictionsLock") 1507 // Package private for the inner class. 1508 void applyUserRestrictionsForAllUsersLR() { 1509 if (DBG) { 1510 debug("applyUserRestrictionsForAllUsersLR"); 1511 } 1512 // First, invalidate all cached values. 1513 mCachedEffectiveUserRestrictions.clear(); 1514 1515 // We don't want to call into ActivityManagerService while taking a lock, so we'll call 1516 // it on a handler. 1517 final Runnable r = new Runnable() { 1518 @Override 1519 public void run() { 1520 // Then get the list of running users. 1521 final int[] runningUsers; 1522 try { 1523 runningUsers = ActivityManager.getService().getRunningUserIds(); 1524 } catch (RemoteException e) { 1525 Log.w(LOG_TAG, "Unable to access ActivityManagerService"); 1526 return; 1527 } 1528 // Then re-calculate the effective restrictions and apply, only for running users. 1529 // It's okay if a new user has started after the getRunningUserIds() call, 1530 // because we'll do the same thing (re-calculate the restrictions and apply) 1531 // when we start a user. 1532 synchronized (mRestrictionsLock) { 1533 for (int i = 0; i < runningUsers.length; i++) { 1534 applyUserRestrictionsLR(runningUsers[i]); 1535 } 1536 } 1537 } 1538 }; 1539 mHandler.post(r); 1540 } 1541 1542 /** 1543 * Check if we've hit the limit of how many users can be created. 1544 */ 1545 private boolean isUserLimitReached() { 1546 int count; 1547 synchronized (mUsersLock) { 1548 count = getAliveUsersExcludingGuestsCountLU(); 1549 } 1550 return count >= UserManager.getMaxSupportedUsers(); 1551 } 1552 1553 @Override 1554 public boolean canAddMoreManagedProfiles(int userId, boolean allowedToRemoveOne) { 1555 checkManageUsersPermission("check if more managed profiles can be added."); 1556 if (ActivityManager.isLowRamDeviceStatic()) { 1557 return false; 1558 } 1559 if (!mContext.getPackageManager().hasSystemFeature( 1560 PackageManager.FEATURE_MANAGED_USERS)) { 1561 return false; 1562 } 1563 // Limit number of managed profiles that can be created 1564 final int managedProfilesCount = getProfiles(userId, false).size() - 1; 1565 final int profilesRemovedCount = managedProfilesCount > 0 && allowedToRemoveOne ? 1 : 0; 1566 if (managedProfilesCount - profilesRemovedCount >= getMaxManagedProfiles()) { 1567 return false; 1568 } 1569 synchronized(mUsersLock) { 1570 UserInfo userInfo = getUserInfoLU(userId); 1571 if (userInfo == null || !userInfo.canHaveProfile()) { 1572 return false; 1573 } 1574 int usersCountAfterRemoving = getAliveUsersExcludingGuestsCountLU() 1575 - profilesRemovedCount; 1576 // We allow creating a managed profile in the special case where there is only one user. 1577 return usersCountAfterRemoving == 1 1578 || usersCountAfterRemoving < UserManager.getMaxSupportedUsers(); 1579 } 1580 } 1581 1582 private int getAliveUsersExcludingGuestsCountLU() { 1583 int aliveUserCount = 0; 1584 final int totalUserCount = mUsers.size(); 1585 // Skip over users being removed 1586 for (int i = 0; i < totalUserCount; i++) { 1587 UserInfo user = mUsers.valueAt(i).info; 1588 if (!mRemovingUserIds.get(user.id) && !user.isGuest()) { 1589 aliveUserCount++; 1590 } 1591 } 1592 return aliveUserCount; 1593 } 1594 1595 /** 1596 * Enforces that only the system UID or root's UID or apps that have the 1597 * {@link android.Manifest.permission#MANAGE_USERS MANAGE_USERS} and 1598 * {@link android.Manifest.permission#INTERACT_ACROSS_USERS_FULL INTERACT_ACROSS_USERS_FULL} 1599 * permissions can make certain calls to the UserManager. 1600 * 1601 * @param message used as message if SecurityException is thrown 1602 * @throws SecurityException if the caller does not have enough privilege. 1603 */ 1604 private static final void checkManageUserAndAcrossUsersFullPermission(String message) { 1605 final int uid = Binder.getCallingUid(); 1606 if (uid != Process.SYSTEM_UID && uid != 0 1607 && ActivityManager.checkComponentPermission( 1608 Manifest.permission.MANAGE_USERS, 1609 uid, -1, true) != PackageManager.PERMISSION_GRANTED 1610 && ActivityManager.checkComponentPermission( 1611 Manifest.permission.INTERACT_ACROSS_USERS_FULL, 1612 uid, -1, true) != PackageManager.PERMISSION_GRANTED) { 1613 throw new SecurityException( 1614 "You need MANAGE_USERS and INTERACT_ACROSS_USERS_FULL permission to: " 1615 + message); 1616 } 1617 } 1618 1619 /** 1620 * Enforces that only the system UID or root's UID or apps that have the 1621 * {@link android.Manifest.permission#MANAGE_USERS MANAGE_USERS} 1622 * permission can make certain calls to the UserManager. 1623 * 1624 * @param message used as message if SecurityException is thrown 1625 * @throws SecurityException if the caller is not system or root 1626 * @see #hasManageUsersPermission() 1627 */ 1628 private static final void checkManageUsersPermission(String message) { 1629 if (!hasManageUsersPermission()) { 1630 throw new SecurityException("You need MANAGE_USERS permission to: " + message); 1631 } 1632 } 1633 1634 /** 1635 * Enforces that only the system UID or root's UID or apps that have the 1636 * {@link android.Manifest.permission#MANAGE_USERS MANAGE_USERS} or 1637 * {@link android.Manifest.permission#CREATE_USERS CREATE_USERS} 1638 * can make certain calls to the UserManager. 1639 * 1640 * @param message used as message if SecurityException is thrown 1641 * @throws SecurityException if the caller is not system or root 1642 * @see #hasManageOrCreateUsersPermission() 1643 */ 1644 private static final void checkManageOrCreateUsersPermission(String message) { 1645 if (!hasManageOrCreateUsersPermission()) { 1646 throw new SecurityException( 1647 "You either need MANAGE_USERS or CREATE_USERS permission to: " + message); 1648 } 1649 } 1650 1651 /** 1652 * Similar to {@link #checkManageOrCreateUsersPermission(String)} but when the caller is tries 1653 * to create user/profiles other than what is allowed for 1654 * {@link android.Manifest.permission#CREATE_USERS CREATE_USERS} permission, then it will only 1655 * allow callers with {@link android.Manifest.permission#MANAGE_USERS MANAGE_USERS} permission. 1656 */ 1657 private static final void checkManageOrCreateUsersPermission(int creationFlags) { 1658 if ((creationFlags & ~ALLOWED_FLAGS_FOR_CREATE_USERS_PERMISSION) == 0) { 1659 if (!hasManageOrCreateUsersPermission()) { 1660 throw new SecurityException("You either need MANAGE_USERS or CREATE_USERS " 1661 + "permission to create an user with flags: " + creationFlags); 1662 } 1663 } else if (!hasManageUsersPermission()) { 1664 throw new SecurityException("You need MANAGE_USERS permission to create an user " 1665 + " with flags: " + creationFlags); 1666 } 1667 } 1668 1669 /** 1670 * @return whether the calling UID is system UID or root's UID or the calling app has the 1671 * {@link android.Manifest.permission#MANAGE_USERS MANAGE_USERS}. 1672 */ 1673 private static final boolean hasManageUsersPermission() { 1674 final int callingUid = Binder.getCallingUid(); 1675 return UserHandle.isSameApp(callingUid, Process.SYSTEM_UID) 1676 || callingUid == Process.ROOT_UID 1677 || ActivityManager.checkComponentPermission( 1678 android.Manifest.permission.MANAGE_USERS, 1679 callingUid, -1, true) == PackageManager.PERMISSION_GRANTED; 1680 } 1681 1682 /** 1683 * @return whether the calling UID is system UID or root's UID or the calling app has the 1684 * {@link android.Manifest.permission#MANAGE_USERS MANAGE_USERS} or 1685 * {@link android.Manifest.permission#CREATE_USERS CREATE_USERS}. 1686 */ 1687 private static final boolean hasManageOrCreateUsersPermission() { 1688 final int callingUid = Binder.getCallingUid(); 1689 return UserHandle.isSameApp(callingUid, Process.SYSTEM_UID) 1690 || callingUid == Process.ROOT_UID 1691 || ActivityManager.checkComponentPermission( 1692 android.Manifest.permission.MANAGE_USERS, 1693 callingUid, -1, true) == PackageManager.PERMISSION_GRANTED 1694 || ActivityManager.checkComponentPermission( 1695 android.Manifest.permission.CREATE_USERS, 1696 callingUid, -1, true) == PackageManager.PERMISSION_GRANTED; 1697 } 1698 1699 /** 1700 * Enforces that only the system UID or root's UID (on any user) can make certain calls to the 1701 * UserManager. 1702 * 1703 * @param message used as message if SecurityException is thrown 1704 * @throws SecurityException if the caller is not system or root 1705 */ 1706 private static void checkSystemOrRoot(String message) { 1707 final int uid = Binder.getCallingUid(); 1708 if (!UserHandle.isSameApp(uid, Process.SYSTEM_UID) && uid != Process.ROOT_UID) { 1709 throw new SecurityException("Only system may: " + message); 1710 } 1711 } 1712 1713 private void writeBitmapLP(UserInfo info, Bitmap bitmap) { 1714 try { 1715 File dir = new File(mUsersDir, Integer.toString(info.id)); 1716 File file = new File(dir, USER_PHOTO_FILENAME); 1717 File tmp = new File(dir, USER_PHOTO_FILENAME_TMP); 1718 if (!dir.exists()) { 1719 dir.mkdir(); 1720 FileUtils.setPermissions( 1721 dir.getPath(), 1722 FileUtils.S_IRWXU|FileUtils.S_IRWXG|FileUtils.S_IXOTH, 1723 -1, -1); 1724 } 1725 FileOutputStream os; 1726 if (bitmap.compress(Bitmap.CompressFormat.PNG, 100, os = new FileOutputStream(tmp)) 1727 && tmp.renameTo(file) && SELinux.restorecon(file)) { 1728 info.iconPath = file.getAbsolutePath(); 1729 } 1730 try { 1731 os.close(); 1732 } catch (IOException ioe) { 1733 // What the ... ! 1734 } 1735 tmp.delete(); 1736 } catch (FileNotFoundException e) { 1737 Slog.w(LOG_TAG, "Error setting photo for user ", e); 1738 } 1739 } 1740 1741 /** 1742 * Returns an array of user ids. This array is cached here for quick access, so do not modify or 1743 * cache it elsewhere. 1744 * @return the array of user ids. 1745 */ 1746 public int[] getUserIds() { 1747 synchronized (mUsersLock) { 1748 return mUserIds; 1749 } 1750 } 1751 1752 private void readUserListLP() { 1753 if (!mUserListFile.exists()) { 1754 fallbackToSingleUserLP(); 1755 return; 1756 } 1757 FileInputStream fis = null; 1758 AtomicFile userListFile = new AtomicFile(mUserListFile); 1759 try { 1760 fis = userListFile.openRead(); 1761 XmlPullParser parser = Xml.newPullParser(); 1762 parser.setInput(fis, StandardCharsets.UTF_8.name()); 1763 int type; 1764 while ((type = parser.next()) != XmlPullParser.START_TAG 1765 && type != XmlPullParser.END_DOCUMENT) { 1766 // Skip 1767 } 1768 1769 if (type != XmlPullParser.START_TAG) { 1770 Slog.e(LOG_TAG, "Unable to read user list"); 1771 fallbackToSingleUserLP(); 1772 return; 1773 } 1774 1775 mNextSerialNumber = -1; 1776 if (parser.getName().equals(TAG_USERS)) { 1777 String lastSerialNumber = parser.getAttributeValue(null, ATTR_NEXT_SERIAL_NO); 1778 if (lastSerialNumber != null) { 1779 mNextSerialNumber = Integer.parseInt(lastSerialNumber); 1780 } 1781 String versionNumber = parser.getAttributeValue(null, ATTR_USER_VERSION); 1782 if (versionNumber != null) { 1783 mUserVersion = Integer.parseInt(versionNumber); 1784 } 1785 } 1786 1787 // Pre-O global user restriction were stored as a single bundle (as opposed to per-user 1788 // currently), take care of it in case of upgrade. 1789 Bundle oldDevicePolicyGlobalUserRestrictions = null; 1790 1791 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT) { 1792 if (type == XmlPullParser.START_TAG) { 1793 final String name = parser.getName(); 1794 if (name.equals(TAG_USER)) { 1795 String id = parser.getAttributeValue(null, ATTR_ID); 1796 1797 UserData userData = readUserLP(Integer.parseInt(id)); 1798 1799 if (userData != null) { 1800 synchronized (mUsersLock) { 1801 mUsers.put(userData.info.id, userData); 1802 if (mNextSerialNumber < 0 1803 || mNextSerialNumber <= userData.info.id) { 1804 mNextSerialNumber = userData.info.id + 1; 1805 } 1806 } 1807 } 1808 } else if (name.equals(TAG_GUEST_RESTRICTIONS)) { 1809 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT 1810 && type != XmlPullParser.END_TAG) { 1811 if (type == XmlPullParser.START_TAG) { 1812 if (parser.getName().equals(TAG_RESTRICTIONS)) { 1813 synchronized (mGuestRestrictions) { 1814 mGuestRestrictions.putAll( 1815 UserRestrictionsUtils.readRestrictions(parser)); 1816 } 1817 } 1818 break; 1819 } 1820 } 1821 } else if (name.equals(TAG_DEVICE_OWNER_USER_ID) 1822 // Legacy name, should only be encountered when upgrading from pre-O. 1823 || name.equals(TAG_GLOBAL_RESTRICTION_OWNER_ID)) { 1824 String ownerUserId = parser.getAttributeValue(null, ATTR_ID); 1825 if (ownerUserId != null) { 1826 mDeviceOwnerUserId = Integer.parseInt(ownerUserId); 1827 } 1828 } else if (name.equals(TAG_DEVICE_POLICY_RESTRICTIONS)) { 1829 // Should only happen when upgrading from pre-O (version < 7). 1830 oldDevicePolicyGlobalUserRestrictions = 1831 UserRestrictionsUtils.readRestrictions(parser); 1832 } 1833 } 1834 } 1835 1836 updateUserIds(); 1837 upgradeIfNecessaryLP(oldDevicePolicyGlobalUserRestrictions); 1838 } catch (IOException | XmlPullParserException e) { 1839 fallbackToSingleUserLP(); 1840 } finally { 1841 IoUtils.closeQuietly(fis); 1842 } 1843 } 1844 1845 /** 1846 * Upgrade steps between versions, either for fixing bugs or changing the data format. 1847 * @param oldGlobalUserRestrictions Pre-O global device policy restrictions. 1848 */ 1849 private void upgradeIfNecessaryLP(Bundle oldGlobalUserRestrictions) { 1850 final int originalVersion = mUserVersion; 1851 int userVersion = mUserVersion; 1852 if (userVersion < 1) { 1853 // Assign a proper name for the owner, if not initialized correctly before 1854 UserData userData = getUserDataNoChecks(UserHandle.USER_SYSTEM); 1855 if ("Primary".equals(userData.info.name)) { 1856 userData.info.name = 1857 mContext.getResources().getString(com.android.internal.R.string.owner_name); 1858 scheduleWriteUser(userData); 1859 } 1860 userVersion = 1; 1861 } 1862 1863 if (userVersion < 2) { 1864 // Owner should be marked as initialized 1865 UserData userData = getUserDataNoChecks(UserHandle.USER_SYSTEM); 1866 if ((userData.info.flags & UserInfo.FLAG_INITIALIZED) == 0) { 1867 userData.info.flags |= UserInfo.FLAG_INITIALIZED; 1868 scheduleWriteUser(userData); 1869 } 1870 userVersion = 2; 1871 } 1872 1873 1874 if (userVersion < 4) { 1875 userVersion = 4; 1876 } 1877 1878 if (userVersion < 5) { 1879 initDefaultGuestRestrictions(); 1880 userVersion = 5; 1881 } 1882 1883 if (userVersion < 6) { 1884 final boolean splitSystemUser = UserManager.isSplitSystemUser(); 1885 synchronized (mUsersLock) { 1886 for (int i = 0; i < mUsers.size(); i++) { 1887 UserData userData = mUsers.valueAt(i); 1888 // In non-split mode, only user 0 can have restricted profiles 1889 if (!splitSystemUser && userData.info.isRestricted() 1890 && (userData.info.restrictedProfileParentId 1891 == UserInfo.NO_PROFILE_GROUP_ID)) { 1892 userData.info.restrictedProfileParentId = UserHandle.USER_SYSTEM; 1893 scheduleWriteUser(userData); 1894 } 1895 } 1896 } 1897 userVersion = 6; 1898 } 1899 1900 if (userVersion < 7) { 1901 // Previously only one user could enforce global restrictions, now it is per-user. 1902 synchronized (mRestrictionsLock) { 1903 if (!UserRestrictionsUtils.isEmpty(oldGlobalUserRestrictions) 1904 && mDeviceOwnerUserId != UserHandle.USER_NULL) { 1905 mDevicePolicyGlobalUserRestrictions.put( 1906 mDeviceOwnerUserId, oldGlobalUserRestrictions); 1907 } 1908 // ENSURE_VERIFY_APPS is now enforced globally even if put by profile owner, so move 1909 // it from local to global bundle for all users who set it. 1910 UserRestrictionsUtils.moveRestriction(UserManager.ENSURE_VERIFY_APPS, 1911 mDevicePolicyLocalUserRestrictions, mDevicePolicyGlobalUserRestrictions 1912 ); 1913 } 1914 userVersion = 7; 1915 } 1916 1917 if (userVersion < USER_VERSION) { 1918 Slog.w(LOG_TAG, "User version " + mUserVersion + " didn't upgrade as expected to " 1919 + USER_VERSION); 1920 } else { 1921 mUserVersion = userVersion; 1922 1923 if (originalVersion < mUserVersion) { 1924 writeUserListLP(); 1925 } 1926 } 1927 } 1928 1929 private void fallbackToSingleUserLP() { 1930 int flags = UserInfo.FLAG_INITIALIZED; 1931 // In split system user mode, the admin and primary flags are assigned to the first human 1932 // user. 1933 if (!UserManager.isSplitSystemUser()) { 1934 flags |= UserInfo.FLAG_ADMIN | UserInfo.FLAG_PRIMARY; 1935 } 1936 // Create the system user 1937 UserInfo system = new UserInfo(UserHandle.USER_SYSTEM, null, null, flags); 1938 UserData userData = putUserInfo(system); 1939 mNextSerialNumber = MIN_USER_ID; 1940 mUserVersion = USER_VERSION; 1941 1942 Bundle restrictions = new Bundle(); 1943 try { 1944 final String[] defaultFirstUserRestrictions = mContext.getResources().getStringArray( 1945 com.android.internal.R.array.config_defaultFirstUserRestrictions); 1946 for (String userRestriction : defaultFirstUserRestrictions) { 1947 if (UserRestrictionsUtils.isValidRestriction(userRestriction)) { 1948 restrictions.putBoolean(userRestriction, true); 1949 } 1950 } 1951 } catch (Resources.NotFoundException e) { 1952 Log.e(LOG_TAG, "Couldn't find resource: config_defaultFirstUserRestrictions", e); 1953 } 1954 1955 if (!restrictions.isEmpty()) { 1956 synchronized (mRestrictionsLock) { 1957 mBaseUserRestrictions.append(UserHandle.USER_SYSTEM, restrictions); 1958 } 1959 } 1960 1961 updateUserIds(); 1962 initDefaultGuestRestrictions(); 1963 1964 writeUserLP(userData); 1965 writeUserListLP(); 1966 } 1967 1968 private String getOwnerName() { 1969 return mContext.getResources().getString(com.android.internal.R.string.owner_name); 1970 } 1971 1972 private void scheduleWriteUser(UserData UserData) { 1973 if (DBG) { 1974 debug("scheduleWriteUser"); 1975 } 1976 // No need to wrap it within a lock -- worst case, we'll just post the same message 1977 // twice. 1978 if (!mHandler.hasMessages(WRITE_USER_MSG, UserData)) { 1979 Message msg = mHandler.obtainMessage(WRITE_USER_MSG, UserData); 1980 mHandler.sendMessageDelayed(msg, WRITE_USER_DELAY); 1981 } 1982 } 1983 1984 private void writeUserLP(UserData userData) { 1985 if (DBG) { 1986 debug("writeUserLP " + userData); 1987 } 1988 FileOutputStream fos = null; 1989 AtomicFile userFile = new AtomicFile(new File(mUsersDir, userData.info.id + XML_SUFFIX)); 1990 try { 1991 fos = userFile.startWrite(); 1992 final BufferedOutputStream bos = new BufferedOutputStream(fos); 1993 writeUserLP(userData, bos); 1994 userFile.finishWrite(fos); 1995 } catch (Exception ioe) { 1996 Slog.e(LOG_TAG, "Error writing user info " + userData.info.id, ioe); 1997 userFile.failWrite(fos); 1998 } 1999 } 2000 2001 /* 2002 * Writes the user file in this format: 2003 * 2004 * <user flags="20039023" id="0"> 2005 * <name>Primary</name> 2006 * </user> 2007 */ 2008 @VisibleForTesting 2009 void writeUserLP(UserData userData, OutputStream os) 2010 throws IOException, XmlPullParserException { 2011 // XmlSerializer serializer = XmlUtils.serializerInstance(); 2012 final XmlSerializer serializer = new FastXmlSerializer(); 2013 serializer.setOutput(os, StandardCharsets.UTF_8.name()); 2014 serializer.startDocument(null, true); 2015 serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); 2016 2017 final UserInfo userInfo = userData.info; 2018 serializer.startTag(null, TAG_USER); 2019 serializer.attribute(null, ATTR_ID, Integer.toString(userInfo.id)); 2020 serializer.attribute(null, ATTR_SERIAL_NO, Integer.toString(userInfo.serialNumber)); 2021 serializer.attribute(null, ATTR_FLAGS, Integer.toString(userInfo.flags)); 2022 serializer.attribute(null, ATTR_CREATION_TIME, Long.toString(userInfo.creationTime)); 2023 serializer.attribute(null, ATTR_LAST_LOGGED_IN_TIME, 2024 Long.toString(userInfo.lastLoggedInTime)); 2025 if (userInfo.lastLoggedInFingerprint != null) { 2026 serializer.attribute(null, ATTR_LAST_LOGGED_IN_FINGERPRINT, 2027 userInfo.lastLoggedInFingerprint); 2028 } 2029 if (userInfo.iconPath != null) { 2030 serializer.attribute(null, ATTR_ICON_PATH, userInfo.iconPath); 2031 } 2032 if (userInfo.partial) { 2033 serializer.attribute(null, ATTR_PARTIAL, "true"); 2034 } 2035 if (userInfo.guestToRemove) { 2036 serializer.attribute(null, ATTR_GUEST_TO_REMOVE, "true"); 2037 } 2038 if (userInfo.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID) { 2039 serializer.attribute(null, ATTR_PROFILE_GROUP_ID, 2040 Integer.toString(userInfo.profileGroupId)); 2041 } 2042 serializer.attribute(null, ATTR_PROFILE_BADGE, 2043 Integer.toString(userInfo.profileBadge)); 2044 if (userInfo.restrictedProfileParentId != UserInfo.NO_PROFILE_GROUP_ID) { 2045 serializer.attribute(null, ATTR_RESTRICTED_PROFILE_PARENT_ID, 2046 Integer.toString(userInfo.restrictedProfileParentId)); 2047 } 2048 // Write seed data 2049 if (userData.persistSeedData) { 2050 if (userData.seedAccountName != null) { 2051 serializer.attribute(null, ATTR_SEED_ACCOUNT_NAME, userData.seedAccountName); 2052 } 2053 if (userData.seedAccountType != null) { 2054 serializer.attribute(null, ATTR_SEED_ACCOUNT_TYPE, userData.seedAccountType); 2055 } 2056 } 2057 if (userInfo.name != null) { 2058 serializer.startTag(null, TAG_NAME); 2059 serializer.text(userInfo.name); 2060 serializer.endTag(null, TAG_NAME); 2061 } 2062 synchronized (mRestrictionsLock) { 2063 UserRestrictionsUtils.writeRestrictions(serializer, 2064 mBaseUserRestrictions.get(userInfo.id), TAG_RESTRICTIONS); 2065 UserRestrictionsUtils.writeRestrictions(serializer, 2066 mDevicePolicyLocalUserRestrictions.get(userInfo.id), 2067 TAG_DEVICE_POLICY_RESTRICTIONS); 2068 UserRestrictionsUtils.writeRestrictions(serializer, 2069 mDevicePolicyGlobalUserRestrictions.get(userInfo.id), 2070 TAG_DEVICE_POLICY_GLOBAL_RESTRICTIONS); 2071 } 2072 2073 if (userData.account != null) { 2074 serializer.startTag(null, TAG_ACCOUNT); 2075 serializer.text(userData.account); 2076 serializer.endTag(null, TAG_ACCOUNT); 2077 } 2078 2079 if (userData.persistSeedData && userData.seedAccountOptions != null) { 2080 serializer.startTag(null, TAG_SEED_ACCOUNT_OPTIONS); 2081 userData.seedAccountOptions.saveToXml(serializer); 2082 serializer.endTag(null, TAG_SEED_ACCOUNT_OPTIONS); 2083 } 2084 2085 serializer.endTag(null, TAG_USER); 2086 2087 serializer.endDocument(); 2088 } 2089 2090 /* 2091 * Writes the user list file in this format: 2092 * 2093 * <users nextSerialNumber="3"> 2094 * <user id="0"></user> 2095 * <user id="2"></user> 2096 * </users> 2097 */ 2098 private void writeUserListLP() { 2099 if (DBG) { 2100 debug("writeUserList"); 2101 } 2102 FileOutputStream fos = null; 2103 AtomicFile userListFile = new AtomicFile(mUserListFile); 2104 try { 2105 fos = userListFile.startWrite(); 2106 final BufferedOutputStream bos = new BufferedOutputStream(fos); 2107 2108 // XmlSerializer serializer = XmlUtils.serializerInstance(); 2109 final XmlSerializer serializer = new FastXmlSerializer(); 2110 serializer.setOutput(bos, StandardCharsets.UTF_8.name()); 2111 serializer.startDocument(null, true); 2112 serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); 2113 2114 serializer.startTag(null, TAG_USERS); 2115 serializer.attribute(null, ATTR_NEXT_SERIAL_NO, Integer.toString(mNextSerialNumber)); 2116 serializer.attribute(null, ATTR_USER_VERSION, Integer.toString(mUserVersion)); 2117 2118 serializer.startTag(null, TAG_GUEST_RESTRICTIONS); 2119 synchronized (mGuestRestrictions) { 2120 UserRestrictionsUtils 2121 .writeRestrictions(serializer, mGuestRestrictions, TAG_RESTRICTIONS); 2122 } 2123 serializer.endTag(null, TAG_GUEST_RESTRICTIONS); 2124 serializer.startTag(null, TAG_DEVICE_OWNER_USER_ID); 2125 serializer.attribute(null, ATTR_ID, Integer.toString(mDeviceOwnerUserId)); 2126 serializer.endTag(null, TAG_DEVICE_OWNER_USER_ID); 2127 int[] userIdsToWrite; 2128 synchronized (mUsersLock) { 2129 userIdsToWrite = new int[mUsers.size()]; 2130 for (int i = 0; i < userIdsToWrite.length; i++) { 2131 UserInfo user = mUsers.valueAt(i).info; 2132 userIdsToWrite[i] = user.id; 2133 } 2134 } 2135 for (int id : userIdsToWrite) { 2136 serializer.startTag(null, TAG_USER); 2137 serializer.attribute(null, ATTR_ID, Integer.toString(id)); 2138 serializer.endTag(null, TAG_USER); 2139 } 2140 2141 serializer.endTag(null, TAG_USERS); 2142 2143 serializer.endDocument(); 2144 userListFile.finishWrite(fos); 2145 } catch (Exception e) { 2146 userListFile.failWrite(fos); 2147 Slog.e(LOG_TAG, "Error writing user list"); 2148 } 2149 } 2150 2151 private UserData readUserLP(int id) { 2152 FileInputStream fis = null; 2153 try { 2154 AtomicFile userFile = 2155 new AtomicFile(new File(mUsersDir, Integer.toString(id) + XML_SUFFIX)); 2156 fis = userFile.openRead(); 2157 return readUserLP(id, fis); 2158 } catch (IOException ioe) { 2159 Slog.e(LOG_TAG, "Error reading user list"); 2160 } catch (XmlPullParserException pe) { 2161 Slog.e(LOG_TAG, "Error reading user list"); 2162 } finally { 2163 IoUtils.closeQuietly(fis); 2164 } 2165 return null; 2166 } 2167 2168 @VisibleForTesting 2169 UserData readUserLP(int id, InputStream is) throws IOException, 2170 XmlPullParserException { 2171 int flags = 0; 2172 int serialNumber = id; 2173 String name = null; 2174 String account = null; 2175 String iconPath = null; 2176 long creationTime = 0L; 2177 long lastLoggedInTime = 0L; 2178 String lastLoggedInFingerprint = null; 2179 int profileGroupId = UserInfo.NO_PROFILE_GROUP_ID; 2180 int profileBadge = 0; 2181 int restrictedProfileParentId = UserInfo.NO_PROFILE_GROUP_ID; 2182 boolean partial = false; 2183 boolean guestToRemove = false; 2184 boolean persistSeedData = false; 2185 String seedAccountName = null; 2186 String seedAccountType = null; 2187 PersistableBundle seedAccountOptions = null; 2188 Bundle baseRestrictions = null; 2189 Bundle localRestrictions = null; 2190 Bundle globalRestrictions = null; 2191 2192 XmlPullParser parser = Xml.newPullParser(); 2193 parser.setInput(is, StandardCharsets.UTF_8.name()); 2194 int type; 2195 while ((type = parser.next()) != XmlPullParser.START_TAG 2196 && type != XmlPullParser.END_DOCUMENT) { 2197 // Skip 2198 } 2199 2200 if (type != XmlPullParser.START_TAG) { 2201 Slog.e(LOG_TAG, "Unable to read user " + id); 2202 return null; 2203 } 2204 2205 if (type == XmlPullParser.START_TAG && parser.getName().equals(TAG_USER)) { 2206 int storedId = readIntAttribute(parser, ATTR_ID, -1); 2207 if (storedId != id) { 2208 Slog.e(LOG_TAG, "User id does not match the file name"); 2209 return null; 2210 } 2211 serialNumber = readIntAttribute(parser, ATTR_SERIAL_NO, id); 2212 flags = readIntAttribute(parser, ATTR_FLAGS, 0); 2213 iconPath = parser.getAttributeValue(null, ATTR_ICON_PATH); 2214 creationTime = readLongAttribute(parser, ATTR_CREATION_TIME, 0); 2215 lastLoggedInTime = readLongAttribute(parser, ATTR_LAST_LOGGED_IN_TIME, 0); 2216 lastLoggedInFingerprint = parser.getAttributeValue(null, 2217 ATTR_LAST_LOGGED_IN_FINGERPRINT); 2218 profileGroupId = readIntAttribute(parser, ATTR_PROFILE_GROUP_ID, 2219 UserInfo.NO_PROFILE_GROUP_ID); 2220 profileBadge = readIntAttribute(parser, ATTR_PROFILE_BADGE, 0); 2221 restrictedProfileParentId = readIntAttribute(parser, 2222 ATTR_RESTRICTED_PROFILE_PARENT_ID, UserInfo.NO_PROFILE_GROUP_ID); 2223 String valueString = parser.getAttributeValue(null, ATTR_PARTIAL); 2224 if ("true".equals(valueString)) { 2225 partial = true; 2226 } 2227 valueString = parser.getAttributeValue(null, ATTR_GUEST_TO_REMOVE); 2228 if ("true".equals(valueString)) { 2229 guestToRemove = true; 2230 } 2231 2232 seedAccountName = parser.getAttributeValue(null, ATTR_SEED_ACCOUNT_NAME); 2233 seedAccountType = parser.getAttributeValue(null, ATTR_SEED_ACCOUNT_TYPE); 2234 if (seedAccountName != null || seedAccountType != null) { 2235 persistSeedData = true; 2236 } 2237 2238 int outerDepth = parser.getDepth(); 2239 while ((type = parser.next()) != XmlPullParser.END_DOCUMENT 2240 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) { 2241 if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) { 2242 continue; 2243 } 2244 String tag = parser.getName(); 2245 if (TAG_NAME.equals(tag)) { 2246 type = parser.next(); 2247 if (type == XmlPullParser.TEXT) { 2248 name = parser.getText(); 2249 } 2250 } else if (TAG_RESTRICTIONS.equals(tag)) { 2251 baseRestrictions = UserRestrictionsUtils.readRestrictions(parser); 2252 } else if (TAG_DEVICE_POLICY_RESTRICTIONS.equals(tag)) { 2253 localRestrictions = UserRestrictionsUtils.readRestrictions(parser); 2254 } else if (TAG_DEVICE_POLICY_GLOBAL_RESTRICTIONS.equals(tag)) { 2255 globalRestrictions = UserRestrictionsUtils.readRestrictions(parser); 2256 } else if (TAG_ACCOUNT.equals(tag)) { 2257 type = parser.next(); 2258 if (type == XmlPullParser.TEXT) { 2259 account = parser.getText(); 2260 } 2261 } else if (TAG_SEED_ACCOUNT_OPTIONS.equals(tag)) { 2262 seedAccountOptions = PersistableBundle.restoreFromXml(parser); 2263 persistSeedData = true; 2264 } 2265 } 2266 } 2267 2268 // Create the UserInfo object that gets passed around 2269 UserInfo userInfo = new UserInfo(id, name, iconPath, flags); 2270 userInfo.serialNumber = serialNumber; 2271 userInfo.creationTime = creationTime; 2272 userInfo.lastLoggedInTime = lastLoggedInTime; 2273 userInfo.lastLoggedInFingerprint = lastLoggedInFingerprint; 2274 userInfo.partial = partial; 2275 userInfo.guestToRemove = guestToRemove; 2276 userInfo.profileGroupId = profileGroupId; 2277 userInfo.profileBadge = profileBadge; 2278 userInfo.restrictedProfileParentId = restrictedProfileParentId; 2279 2280 // Create the UserData object that's internal to this class 2281 UserData userData = new UserData(); 2282 userData.info = userInfo; 2283 userData.account = account; 2284 userData.seedAccountName = seedAccountName; 2285 userData.seedAccountType = seedAccountType; 2286 userData.persistSeedData = persistSeedData; 2287 userData.seedAccountOptions = seedAccountOptions; 2288 2289 synchronized (mRestrictionsLock) { 2290 if (baseRestrictions != null) { 2291 mBaseUserRestrictions.put(id, baseRestrictions); 2292 } 2293 if (localRestrictions != null) { 2294 mDevicePolicyLocalUserRestrictions.put(id, localRestrictions); 2295 } 2296 if (globalRestrictions != null) { 2297 mDevicePolicyGlobalUserRestrictions.put(id, globalRestrictions); 2298 } 2299 } 2300 return userData; 2301 } 2302 2303 private int readIntAttribute(XmlPullParser parser, String attr, int defaultValue) { 2304 String valueString = parser.getAttributeValue(null, attr); 2305 if (valueString == null) return defaultValue; 2306 try { 2307 return Integer.parseInt(valueString); 2308 } catch (NumberFormatException nfe) { 2309 return defaultValue; 2310 } 2311 } 2312 2313 private long readLongAttribute(XmlPullParser parser, String attr, long defaultValue) { 2314 String valueString = parser.getAttributeValue(null, attr); 2315 if (valueString == null) return defaultValue; 2316 try { 2317 return Long.parseLong(valueString); 2318 } catch (NumberFormatException nfe) { 2319 return defaultValue; 2320 } 2321 } 2322 2323 /** 2324 * Removes the app restrictions file for a specific package and user id, if it exists. 2325 */ 2326 private void cleanAppRestrictionsForPackage(String pkg, int userId) { 2327 synchronized (mPackagesLock) { 2328 File dir = Environment.getUserSystemDirectory(userId); 2329 File resFile = new File(dir, packageToRestrictionsFileName(pkg)); 2330 if (resFile.exists()) { 2331 resFile.delete(); 2332 } 2333 } 2334 } 2335 2336 @Override 2337 public UserInfo createProfileForUser(String name, int flags, int userId, 2338 String[] disallowedPackages) { 2339 checkManageOrCreateUsersPermission(flags); 2340 return createUserInternal(name, flags, userId, disallowedPackages); 2341 } 2342 2343 @Override 2344 public UserInfo createProfileForUserEvenWhenDisallowed(String name, int flags, int userId, 2345 String[] disallowedPackages) { 2346 checkManageOrCreateUsersPermission(flags); 2347 return createUserInternalUnchecked(name, flags, userId, disallowedPackages); 2348 } 2349 2350 @Override 2351 public boolean removeUserEvenWhenDisallowed(@UserIdInt int userHandle) { 2352 checkManageOrCreateUsersPermission("Only the system can remove users"); 2353 return removeUserUnchecked(userHandle); 2354 } 2355 2356 @Override 2357 public UserInfo createUser(String name, int flags) { 2358 checkManageOrCreateUsersPermission(flags); 2359 return createUserInternal(name, flags, UserHandle.USER_NULL); 2360 } 2361 2362 private UserInfo createUserInternal(String name, int flags, int parentId) { 2363 return createUserInternal(name, flags, parentId, null); 2364 } 2365 2366 private UserInfo createUserInternal(String name, int flags, int parentId, 2367 String[] disallowedPackages) { 2368 String restriction = ((flags & UserInfo.FLAG_MANAGED_PROFILE) != 0) 2369 ? UserManager.DISALLOW_ADD_MANAGED_PROFILE 2370 : UserManager.DISALLOW_ADD_USER; 2371 if (hasUserRestriction(restriction, UserHandle.getCallingUserId())) { 2372 Log.w(LOG_TAG, "Cannot add user. " + restriction + " is enabled."); 2373 return null; 2374 } 2375 return createUserInternalUnchecked(name, flags, parentId, disallowedPackages); 2376 } 2377 2378 private UserInfo createUserInternalUnchecked(String name, int flags, int parentId, 2379 String[] disallowedPackages) { 2380 DeviceStorageMonitorInternal dsm = LocalServices 2381 .getService(DeviceStorageMonitorInternal.class); 2382 if (dsm.isMemoryLow()) { 2383 Log.w(LOG_TAG, "Cannot add user. Not enough space on disk."); 2384 return null; 2385 } 2386 if (ActivityManager.isLowRamDeviceStatic()) { 2387 return null; 2388 } 2389 final boolean isGuest = (flags & UserInfo.FLAG_GUEST) != 0; 2390 final boolean isManagedProfile = (flags & UserInfo.FLAG_MANAGED_PROFILE) != 0; 2391 final boolean isRestricted = (flags & UserInfo.FLAG_RESTRICTED) != 0; 2392 final boolean isDemo = (flags & UserInfo.FLAG_DEMO) != 0; 2393 final long ident = Binder.clearCallingIdentity(); 2394 UserInfo userInfo; 2395 UserData userData; 2396 final int userId; 2397 try { 2398 synchronized (mPackagesLock) { 2399 UserData parent = null; 2400 if (parentId != UserHandle.USER_NULL) { 2401 synchronized (mUsersLock) { 2402 parent = getUserDataLU(parentId); 2403 } 2404 if (parent == null) return null; 2405 } 2406 if (isManagedProfile && !canAddMoreManagedProfiles(parentId, false)) { 2407 Log.e(LOG_TAG, "Cannot add more managed profiles for user " + parentId); 2408 return null; 2409 } 2410 if (!isGuest && !isManagedProfile && !isDemo && isUserLimitReached()) { 2411 // If we're not adding a guest/demo user or a managed profile and the limit has 2412 // been reached, cannot add a user. 2413 return null; 2414 } 2415 // If we're adding a guest and there already exists one, bail. 2416 if (isGuest && findCurrentGuestUser() != null) { 2417 return null; 2418 } 2419 // In legacy mode, restricted profile's parent can only be the owner user 2420 if (isRestricted && !UserManager.isSplitSystemUser() 2421 && (parentId != UserHandle.USER_SYSTEM)) { 2422 Log.w(LOG_TAG, "Cannot add restricted profile - parent user must be owner"); 2423 return null; 2424 } 2425 if (isRestricted && UserManager.isSplitSystemUser()) { 2426 if (parent == null) { 2427 Log.w(LOG_TAG, "Cannot add restricted profile - parent user must be " 2428 + "specified"); 2429 return null; 2430 } 2431 if (!parent.info.canHaveProfile()) { 2432 Log.w(LOG_TAG, "Cannot add restricted profile - profiles cannot be " 2433 + "created for the specified parent user id " + parentId); 2434 return null; 2435 } 2436 } 2437 if (!UserManager.isSplitSystemUser() && (flags & UserInfo.FLAG_EPHEMERAL) != 0 2438 && (flags & UserInfo.FLAG_DEMO) == 0) { 2439 Log.e(LOG_TAG, 2440 "Ephemeral users are supported on split-system-user systems only."); 2441 return null; 2442 } 2443 // In split system user mode, we assign the first human user the primary flag. 2444 // And if there is no device owner, we also assign the admin flag to primary user. 2445 if (UserManager.isSplitSystemUser() 2446 && !isGuest && !isManagedProfile && getPrimaryUser() == null) { 2447 flags |= UserInfo.FLAG_PRIMARY; 2448 synchronized (mUsersLock) { 2449 if (!mIsDeviceManaged) { 2450 flags |= UserInfo.FLAG_ADMIN; 2451 } 2452 } 2453 } 2454 2455 userId = getNextAvailableId(); 2456 Environment.getUserSystemDirectory(userId).mkdirs(); 2457 boolean ephemeralGuests = Resources.getSystem() 2458 .getBoolean(com.android.internal.R.bool.config_guestUserEphemeral); 2459 2460 synchronized (mUsersLock) { 2461 // Add ephemeral flag to guests/users if required. Also inherit it from parent. 2462 if ((isGuest && ephemeralGuests) || mForceEphemeralUsers 2463 || (parent != null && parent.info.isEphemeral())) { 2464 flags |= UserInfo.FLAG_EPHEMERAL; 2465 } 2466 2467 userInfo = new UserInfo(userId, name, null, flags); 2468 userInfo.serialNumber = mNextSerialNumber++; 2469 long now = System.currentTimeMillis(); 2470 userInfo.creationTime = (now > EPOCH_PLUS_30_YEARS) ? now : 0; 2471 userInfo.partial = true; 2472 userInfo.lastLoggedInFingerprint = Build.FINGERPRINT; 2473 if (isManagedProfile && parentId != UserHandle.USER_NULL) { 2474 userInfo.profileBadge = getFreeProfileBadgeLU(parentId); 2475 } 2476 userData = new UserData(); 2477 userData.info = userInfo; 2478 mUsers.put(userId, userData); 2479 } 2480 writeUserLP(userData); 2481 writeUserListLP(); 2482 if (parent != null) { 2483 if (isManagedProfile) { 2484 if (parent.info.profileGroupId == UserInfo.NO_PROFILE_GROUP_ID) { 2485 parent.info.profileGroupId = parent.info.id; 2486 writeUserLP(parent); 2487 } 2488 userInfo.profileGroupId = parent.info.profileGroupId; 2489 } else if (isRestricted) { 2490 if (parent.info.restrictedProfileParentId == UserInfo.NO_PROFILE_GROUP_ID) { 2491 parent.info.restrictedProfileParentId = parent.info.id; 2492 writeUserLP(parent); 2493 } 2494 userInfo.restrictedProfileParentId = parent.info.restrictedProfileParentId; 2495 } 2496 } 2497 } 2498 final StorageManager storage = mContext.getSystemService(StorageManager.class); 2499 storage.createUserKey(userId, userInfo.serialNumber, userInfo.isEphemeral()); 2500 mUserDataPreparer.prepareUserData(userId, userInfo.serialNumber, 2501 StorageManager.FLAG_STORAGE_DE | StorageManager.FLAG_STORAGE_CE); 2502 mPm.createNewUser(userId, disallowedPackages); 2503 userInfo.partial = false; 2504 synchronized (mPackagesLock) { 2505 writeUserLP(userData); 2506 } 2507 updateUserIds(); 2508 Bundle restrictions = new Bundle(); 2509 if (isGuest) { 2510 synchronized (mGuestRestrictions) { 2511 restrictions.putAll(mGuestRestrictions); 2512 } 2513 } 2514 synchronized (mRestrictionsLock) { 2515 mBaseUserRestrictions.append(userId, restrictions); 2516 } 2517 mPm.onNewUserCreated(userId); 2518 Intent addedIntent = new Intent(Intent.ACTION_USER_ADDED); 2519 addedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userId); 2520 mContext.sendBroadcastAsUser(addedIntent, UserHandle.ALL, 2521 android.Manifest.permission.MANAGE_USERS); 2522 MetricsLogger.count(mContext, isGuest ? TRON_GUEST_CREATED : TRON_USER_CREATED, 1); 2523 } finally { 2524 Binder.restoreCallingIdentity(ident); 2525 } 2526 return userInfo; 2527 } 2528 2529 @VisibleForTesting 2530 UserData putUserInfo(UserInfo userInfo) { 2531 final UserData userData = new UserData(); 2532 userData.info = userInfo; 2533 synchronized (mUsers) { 2534 mUsers.put(userInfo.id, userData); 2535 } 2536 return userData; 2537 } 2538 2539 @VisibleForTesting 2540 void removeUserInfo(int userId) { 2541 synchronized (mUsers) { 2542 mUsers.remove(userId); 2543 } 2544 } 2545 2546 /** 2547 * @hide 2548 */ 2549 @Override 2550 public UserInfo createRestrictedProfile(String name, int parentUserId) { 2551 checkManageOrCreateUsersPermission("setupRestrictedProfile"); 2552 final UserInfo user = createProfileForUser( 2553 name, UserInfo.FLAG_RESTRICTED, parentUserId, null); 2554 if (user == null) { 2555 return null; 2556 } 2557 long identity = Binder.clearCallingIdentity(); 2558 try { 2559 setUserRestriction(UserManager.DISALLOW_MODIFY_ACCOUNTS, true, user.id); 2560 // Change the setting before applying the DISALLOW_SHARE_LOCATION restriction, otherwise 2561 // the putIntForUser() will fail. 2562 android.provider.Settings.Secure.putIntForUser(mContext.getContentResolver(), 2563 android.provider.Settings.Secure.LOCATION_MODE, 2564 android.provider.Settings.Secure.LOCATION_MODE_OFF, user.id); 2565 setUserRestriction(UserManager.DISALLOW_SHARE_LOCATION, true, user.id); 2566 } finally { 2567 Binder.restoreCallingIdentity(identity); 2568 } 2569 return user; 2570 } 2571 2572 /** 2573 * Find the current guest user. If the Guest user is partial, 2574 * then do not include it in the results as it is about to die. 2575 */ 2576 private UserInfo findCurrentGuestUser() { 2577 synchronized (mUsersLock) { 2578 final int size = mUsers.size(); 2579 for (int i = 0; i < size; i++) { 2580 final UserInfo user = mUsers.valueAt(i).info; 2581 if (user.isGuest() && !user.guestToRemove && !mRemovingUserIds.get(user.id)) { 2582 return user; 2583 } 2584 } 2585 } 2586 return null; 2587 } 2588 2589 /** 2590 * Mark this guest user for deletion to allow us to create another guest 2591 * and switch to that user before actually removing this guest. 2592 * @param userHandle the userid of the current guest 2593 * @return whether the user could be marked for deletion 2594 */ 2595 @Override 2596 public boolean markGuestForDeletion(int userHandle) { 2597 checkManageUsersPermission("Only the system can remove users"); 2598 if (getUserRestrictions(UserHandle.getCallingUserId()).getBoolean( 2599 UserManager.DISALLOW_REMOVE_USER, false)) { 2600 Log.w(LOG_TAG, "Cannot remove user. DISALLOW_REMOVE_USER is enabled."); 2601 return false; 2602 } 2603 2604 long ident = Binder.clearCallingIdentity(); 2605 try { 2606 final UserData userData; 2607 synchronized (mPackagesLock) { 2608 synchronized (mUsersLock) { 2609 userData = mUsers.get(userHandle); 2610 if (userHandle == 0 || userData == null || mRemovingUserIds.get(userHandle)) { 2611 return false; 2612 } 2613 } 2614 if (!userData.info.isGuest()) { 2615 return false; 2616 } 2617 // We set this to a guest user that is to be removed. This is a temporary state 2618 // where we are allowed to add new Guest users, even if this one is still not 2619 // removed. This user will still show up in getUserInfo() calls. 2620 // If we don't get around to removing this Guest user, it will be purged on next 2621 // startup. 2622 userData.info.guestToRemove = true; 2623 // Mark it as disabled, so that it isn't returned any more when 2624 // profiles are queried. 2625 userData.info.flags |= UserInfo.FLAG_DISABLED; 2626 writeUserLP(userData); 2627 } 2628 } finally { 2629 Binder.restoreCallingIdentity(ident); 2630 } 2631 return true; 2632 } 2633 2634 /** 2635 * Removes a user and all data directories created for that user. This method should be called 2636 * after the user's processes have been terminated. 2637 * @param userHandle the user's id 2638 */ 2639 @Override 2640 public boolean removeUser(int userHandle) { 2641 Slog.i(LOG_TAG, "removeUser u" + userHandle); 2642 checkManageOrCreateUsersPermission("Only the system can remove users"); 2643 2644 final boolean isManagedProfile; 2645 synchronized (mUsersLock) { 2646 UserInfo userInfo = getUserInfoLU(userHandle); 2647 isManagedProfile = userInfo != null && userInfo.isManagedProfile(); 2648 } 2649 String restriction = isManagedProfile 2650 ? UserManager.DISALLOW_REMOVE_MANAGED_PROFILE : UserManager.DISALLOW_REMOVE_USER; 2651 if (getUserRestrictions(UserHandle.getCallingUserId()).getBoolean(restriction, false)) { 2652 Log.w(LOG_TAG, "Cannot remove user. " + restriction + " is enabled."); 2653 return false; 2654 } 2655 return removeUserUnchecked(userHandle); 2656 } 2657 2658 private boolean removeUserUnchecked(int userHandle) { 2659 long ident = Binder.clearCallingIdentity(); 2660 try { 2661 final UserData userData; 2662 int currentUser = ActivityManager.getCurrentUser(); 2663 if (currentUser == userHandle) { 2664 Log.w(LOG_TAG, "Current user cannot be removed"); 2665 return false; 2666 } 2667 synchronized (mPackagesLock) { 2668 synchronized (mUsersLock) { 2669 userData = mUsers.get(userHandle); 2670 if (userHandle == 0 || userData == null || mRemovingUserIds.get(userHandle)) { 2671 return false; 2672 } 2673 2674 addRemovingUserIdLocked(userHandle); 2675 } 2676 2677 try { 2678 mAppOpsService.removeUser(userHandle); 2679 } catch (RemoteException e) { 2680 Log.w(LOG_TAG, "Unable to notify AppOpsService of removing user", e); 2681 } 2682 // Set this to a partially created user, so that the user will be purged 2683 // on next startup, in case the runtime stops now before stopping and 2684 // removing the user completely. 2685 userData.info.partial = true; 2686 // Mark it as disabled, so that it isn't returned any more when 2687 // profiles are queried. 2688 userData.info.flags |= UserInfo.FLAG_DISABLED; 2689 writeUserLP(userData); 2690 } 2691 2692 if (userData.info.profileGroupId != UserInfo.NO_PROFILE_GROUP_ID 2693 && userData.info.isManagedProfile()) { 2694 // Send broadcast to notify system that the user removed was a 2695 // managed user. 2696 sendProfileRemovedBroadcast(userData.info.profileGroupId, userData.info.id); 2697 } 2698 2699 if (DBG) Slog.i(LOG_TAG, "Stopping user " + userHandle); 2700 int res; 2701 try { 2702 res = ActivityManager.getService().stopUser(userHandle, /* force= */ true, 2703 new IStopUserCallback.Stub() { 2704 @Override 2705 public void userStopped(int userId) { 2706 finishRemoveUser(userId); 2707 } 2708 @Override 2709 public void userStopAborted(int userId) { 2710 } 2711 }); 2712 } catch (RemoteException e) { 2713 return false; 2714 } 2715 return res == ActivityManager.USER_OP_SUCCESS; 2716 } finally { 2717 Binder.restoreCallingIdentity(ident); 2718 } 2719 } 2720 2721 @VisibleForTesting 2722 void addRemovingUserIdLocked(int userId) { 2723 // We remember deleted user IDs to prevent them from being 2724 // reused during the current boot; they can still be reused 2725 // after a reboot or recycling of userIds. 2726 mRemovingUserIds.put(userId, true); 2727 mRecentlyRemovedIds.add(userId); 2728 // Keep LRU queue of recently removed IDs for recycling 2729 if (mRecentlyRemovedIds.size() > MAX_RECENTLY_REMOVED_IDS_SIZE) { 2730 mRecentlyRemovedIds.removeFirst(); 2731 } 2732 } 2733 2734 void finishRemoveUser(final int userHandle) { 2735 if (DBG) Slog.i(LOG_TAG, "finishRemoveUser " + userHandle); 2736 // Let other services shutdown any activity and clean up their state before completely 2737 // wiping the user's system directory and removing from the user list 2738 long ident = Binder.clearCallingIdentity(); 2739 try { 2740 Intent addedIntent = new Intent(Intent.ACTION_USER_REMOVED); 2741 addedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userHandle); 2742 mContext.sendOrderedBroadcastAsUser(addedIntent, UserHandle.ALL, 2743 android.Manifest.permission.MANAGE_USERS, 2744 2745 new BroadcastReceiver() { 2746 @Override 2747 public void onReceive(Context context, Intent intent) { 2748 if (DBG) { 2749 Slog.i(LOG_TAG, 2750 "USER_REMOVED broadcast sent, cleaning up user data " 2751 + userHandle); 2752 } 2753 new Thread() { 2754 @Override 2755 public void run() { 2756 // Clean up any ActivityManager state 2757 LocalServices.getService(ActivityManagerInternal.class) 2758 .onUserRemoved(userHandle); 2759 removeUserState(userHandle); 2760 } 2761 }.start(); 2762 } 2763 }, 2764 2765 null, Activity.RESULT_OK, null, null); 2766 } finally { 2767 Binder.restoreCallingIdentity(ident); 2768 } 2769 } 2770 2771 private void removeUserState(final int userHandle) { 2772 try { 2773 mContext.getSystemService(StorageManager.class).destroyUserKey(userHandle); 2774 } catch (IllegalStateException e) { 2775 // This may be simply because the user was partially created. 2776 Slog.i(LOG_TAG, 2777 "Destroying key for user " + userHandle + " failed, continuing anyway", e); 2778 } 2779 2780 // Cleanup gatekeeper secure user id 2781 try { 2782 final IGateKeeperService gk = GateKeeper.getService(); 2783 if (gk != null) { 2784 gk.clearSecureUserId(userHandle); 2785 } 2786 } catch (Exception ex) { 2787 Slog.w(LOG_TAG, "unable to clear GK secure user id"); 2788 } 2789 2790 // Cleanup package manager settings 2791 mPm.cleanUpUser(this, userHandle); 2792 2793 // Clean up all data before removing metadata 2794 mUserDataPreparer.destroyUserData(userHandle, 2795 StorageManager.FLAG_STORAGE_DE | StorageManager.FLAG_STORAGE_CE); 2796 2797 // Remove this user from the list 2798 synchronized (mUsersLock) { 2799 mUsers.remove(userHandle); 2800 mIsUserManaged.delete(userHandle); 2801 } 2802 synchronized (mUserStates) { 2803 mUserStates.delete(userHandle); 2804 } 2805 synchronized (mRestrictionsLock) { 2806 mBaseUserRestrictions.remove(userHandle); 2807 mAppliedUserRestrictions.remove(userHandle); 2808 mCachedEffectiveUserRestrictions.remove(userHandle); 2809 mDevicePolicyLocalUserRestrictions.remove(userHandle); 2810 if (mDevicePolicyGlobalUserRestrictions.get(userHandle) != null) { 2811 mDevicePolicyGlobalUserRestrictions.remove(userHandle); 2812 applyUserRestrictionsForAllUsersLR(); 2813 } 2814 } 2815 // Update the user list 2816 synchronized (mPackagesLock) { 2817 writeUserListLP(); 2818 } 2819 // Remove user file 2820 AtomicFile userFile = new AtomicFile(new File(mUsersDir, userHandle + XML_SUFFIX)); 2821 userFile.delete(); 2822 updateUserIds(); 2823 if (RELEASE_DELETED_USER_ID) { 2824 synchronized (mUsers) { 2825 mRemovingUserIds.delete(userHandle); 2826 } 2827 } 2828 } 2829 2830 private void sendProfileRemovedBroadcast(int parentUserId, int removedUserId) { 2831 Intent managedProfileIntent = new Intent(Intent.ACTION_MANAGED_PROFILE_REMOVED); 2832 managedProfileIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY | 2833 Intent.FLAG_RECEIVER_FOREGROUND); 2834 managedProfileIntent.putExtra(Intent.EXTRA_USER, new UserHandle(removedUserId)); 2835 managedProfileIntent.putExtra(Intent.EXTRA_USER_HANDLE, removedUserId); 2836 mContext.sendBroadcastAsUser(managedProfileIntent, new UserHandle(parentUserId), null); 2837 } 2838 2839 @Override 2840 public Bundle getApplicationRestrictions(String packageName) { 2841 return getApplicationRestrictionsForUser(packageName, UserHandle.getCallingUserId()); 2842 } 2843 2844 @Override 2845 public Bundle getApplicationRestrictionsForUser(String packageName, int userId) { 2846 if (UserHandle.getCallingUserId() != userId 2847 || !UserHandle.isSameApp(Binder.getCallingUid(), getUidForPackage(packageName))) { 2848 checkSystemOrRoot("get application restrictions for other user/app " + packageName); 2849 } 2850 synchronized (mPackagesLock) { 2851 // Read the restrictions from XML 2852 return readApplicationRestrictionsLP(packageName, userId); 2853 } 2854 } 2855 2856 @Override 2857 public void setApplicationRestrictions(String packageName, Bundle restrictions, 2858 int userId) { 2859 checkSystemOrRoot("set application restrictions"); 2860 if (restrictions != null) { 2861 restrictions.setDefusable(true); 2862 } 2863 synchronized (mPackagesLock) { 2864 if (restrictions == null || restrictions.isEmpty()) { 2865 cleanAppRestrictionsForPackage(packageName, userId); 2866 } else { 2867 // Write the restrictions to XML 2868 writeApplicationRestrictionsLP(packageName, restrictions, userId); 2869 } 2870 } 2871 2872 // Notify package of changes via an intent - only sent to explicitly registered receivers. 2873 Intent changeIntent = new Intent(Intent.ACTION_APPLICATION_RESTRICTIONS_CHANGED); 2874 changeIntent.setPackage(packageName); 2875 changeIntent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY); 2876 mContext.sendBroadcastAsUser(changeIntent, UserHandle.of(userId)); 2877 } 2878 2879 private int getUidForPackage(String packageName) { 2880 long ident = Binder.clearCallingIdentity(); 2881 try { 2882 return mContext.getPackageManager().getApplicationInfo(packageName, 2883 PackageManager.MATCH_ANY_USER).uid; 2884 } catch (NameNotFoundException nnfe) { 2885 return -1; 2886 } finally { 2887 Binder.restoreCallingIdentity(ident); 2888 } 2889 } 2890 2891 private Bundle readApplicationRestrictionsLP(String packageName, int userId) { 2892 AtomicFile restrictionsFile = 2893 new AtomicFile(new File(Environment.getUserSystemDirectory(userId), 2894 packageToRestrictionsFileName(packageName))); 2895 return readApplicationRestrictionsLP(restrictionsFile); 2896 } 2897 2898 @VisibleForTesting 2899 static Bundle readApplicationRestrictionsLP(AtomicFile restrictionsFile) { 2900 final Bundle restrictions = new Bundle(); 2901 final ArrayList<String> values = new ArrayList<>(); 2902 if (!restrictionsFile.getBaseFile().exists()) { 2903 return restrictions; 2904 } 2905 2906 FileInputStream fis = null; 2907 try { 2908 fis = restrictionsFile.openRead(); 2909 XmlPullParser parser = Xml.newPullParser(); 2910 parser.setInput(fis, StandardCharsets.UTF_8.name()); 2911 XmlUtils.nextElement(parser); 2912 if (parser.getEventType() != XmlPullParser.START_TAG) { 2913 Slog.e(LOG_TAG, "Unable to read restrictions file " 2914 + restrictionsFile.getBaseFile()); 2915 return restrictions; 2916 } 2917 while (parser.next() != XmlPullParser.END_DOCUMENT) { 2918 readEntry(restrictions, values, parser); 2919 } 2920 } catch (IOException|XmlPullParserException e) { 2921 Log.w(LOG_TAG, "Error parsing " + restrictionsFile.getBaseFile(), e); 2922 } finally { 2923 IoUtils.closeQuietly(fis); 2924 } 2925 return restrictions; 2926 } 2927 2928 private static void readEntry(Bundle restrictions, ArrayList<String> values, 2929 XmlPullParser parser) throws XmlPullParserException, IOException { 2930 int type = parser.getEventType(); 2931 if (type == XmlPullParser.START_TAG && parser.getName().equals(TAG_ENTRY)) { 2932 String key = parser.getAttributeValue(null, ATTR_KEY); 2933 String valType = parser.getAttributeValue(null, ATTR_VALUE_TYPE); 2934 String multiple = parser.getAttributeValue(null, ATTR_MULTIPLE); 2935 if (multiple != null) { 2936 values.clear(); 2937 int count = Integer.parseInt(multiple); 2938 while (count > 0 && (type = parser.next()) != XmlPullParser.END_DOCUMENT) { 2939 if (type == XmlPullParser.START_TAG 2940 && parser.getName().equals(TAG_VALUE)) { 2941 values.add(parser.nextText().trim()); 2942 count--; 2943 } 2944 } 2945 String [] valueStrings = new String[values.size()]; 2946 values.toArray(valueStrings); 2947 restrictions.putStringArray(key, valueStrings); 2948 } else if (ATTR_TYPE_BUNDLE.equals(valType)) { 2949 restrictions.putBundle(key, readBundleEntry(parser, values)); 2950 } else if (ATTR_TYPE_BUNDLE_ARRAY.equals(valType)) { 2951 final int outerDepth = parser.getDepth(); 2952 ArrayList<Bundle> bundleList = new ArrayList<>(); 2953 while (XmlUtils.nextElementWithin(parser, outerDepth)) { 2954 Bundle childBundle = readBundleEntry(parser, values); 2955 bundleList.add(childBundle); 2956 } 2957 restrictions.putParcelableArray(key, 2958 bundleList.toArray(new Bundle[bundleList.size()])); 2959 } else { 2960 String value = parser.nextText().trim(); 2961 if (ATTR_TYPE_BOOLEAN.equals(valType)) { 2962 restrictions.putBoolean(key, Boolean.parseBoolean(value)); 2963 } else if (ATTR_TYPE_INTEGER.equals(valType)) { 2964 restrictions.putInt(key, Integer.parseInt(value)); 2965 } else { 2966 restrictions.putString(key, value); 2967 } 2968 } 2969 } 2970 } 2971 2972 private static Bundle readBundleEntry(XmlPullParser parser, ArrayList<String> values) 2973 throws IOException, XmlPullParserException { 2974 Bundle childBundle = new Bundle(); 2975 final int outerDepth = parser.getDepth(); 2976 while (XmlUtils.nextElementWithin(parser, outerDepth)) { 2977 readEntry(childBundle, values, parser); 2978 } 2979 return childBundle; 2980 } 2981 2982 private void writeApplicationRestrictionsLP(String packageName, 2983 Bundle restrictions, int userId) { 2984 AtomicFile restrictionsFile = new AtomicFile( 2985 new File(Environment.getUserSystemDirectory(userId), 2986 packageToRestrictionsFileName(packageName))); 2987 writeApplicationRestrictionsLP(restrictions, restrictionsFile); 2988 } 2989 2990 @VisibleForTesting 2991 static void writeApplicationRestrictionsLP(Bundle restrictions, AtomicFile restrictionsFile) { 2992 FileOutputStream fos = null; 2993 try { 2994 fos = restrictionsFile.startWrite(); 2995 final BufferedOutputStream bos = new BufferedOutputStream(fos); 2996 2997 final XmlSerializer serializer = new FastXmlSerializer(); 2998 serializer.setOutput(bos, StandardCharsets.UTF_8.name()); 2999 serializer.startDocument(null, true); 3000 serializer.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true); 3001 3002 serializer.startTag(null, TAG_RESTRICTIONS); 3003 writeBundle(restrictions, serializer); 3004 serializer.endTag(null, TAG_RESTRICTIONS); 3005 3006 serializer.endDocument(); 3007 restrictionsFile.finishWrite(fos); 3008 } catch (Exception e) { 3009 restrictionsFile.failWrite(fos); 3010 Slog.e(LOG_TAG, "Error writing application restrictions list", e); 3011 } 3012 } 3013 3014 private static void writeBundle(Bundle restrictions, XmlSerializer serializer) 3015 throws IOException { 3016 for (String key : restrictions.keySet()) { 3017 Object value = restrictions.get(key); 3018 serializer.startTag(null, TAG_ENTRY); 3019 serializer.attribute(null, ATTR_KEY, key); 3020 3021 if (value instanceof Boolean) { 3022 serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_BOOLEAN); 3023 serializer.text(value.toString()); 3024 } else if (value instanceof Integer) { 3025 serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_INTEGER); 3026 serializer.text(value.toString()); 3027 } else if (value == null || value instanceof String) { 3028 serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_STRING); 3029 serializer.text(value != null ? (String) value : ""); 3030 } else if (value instanceof Bundle) { 3031 serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_BUNDLE); 3032 writeBundle((Bundle) value, serializer); 3033 } else if (value instanceof Parcelable[]) { 3034 serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_BUNDLE_ARRAY); 3035 Parcelable[] array = (Parcelable[]) value; 3036 for (Parcelable parcelable : array) { 3037 if (!(parcelable instanceof Bundle)) { 3038 throw new IllegalArgumentException("bundle-array can only hold Bundles"); 3039 } 3040 serializer.startTag(null, TAG_ENTRY); 3041 serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_BUNDLE); 3042 writeBundle((Bundle) parcelable, serializer); 3043 serializer.endTag(null, TAG_ENTRY); 3044 } 3045 } else { 3046 serializer.attribute(null, ATTR_VALUE_TYPE, ATTR_TYPE_STRING_ARRAY); 3047 String[] values = (String[]) value; 3048 serializer.attribute(null, ATTR_MULTIPLE, Integer.toString(values.length)); 3049 for (String choice : values) { 3050 serializer.startTag(null, TAG_VALUE); 3051 serializer.text(choice != null ? choice : ""); 3052 serializer.endTag(null, TAG_VALUE); 3053 } 3054 } 3055 serializer.endTag(null, TAG_ENTRY); 3056 } 3057 } 3058 3059 @Override 3060 public int getUserSerialNumber(int userHandle) { 3061 synchronized (mUsersLock) { 3062 if (!exists(userHandle)) return -1; 3063 return getUserInfoLU(userHandle).serialNumber; 3064 } 3065 } 3066 3067 @Override 3068 public int getUserHandle(int userSerialNumber) { 3069 synchronized (mUsersLock) { 3070 for (int userId : mUserIds) { 3071 UserInfo info = getUserInfoLU(userId); 3072 if (info != null && info.serialNumber == userSerialNumber) return userId; 3073 } 3074 // Not found 3075 return -1; 3076 } 3077 } 3078 3079 @Override 3080 public long getUserCreationTime(int userHandle) { 3081 int callingUserId = UserHandle.getCallingUserId(); 3082 UserInfo userInfo = null; 3083 synchronized (mUsersLock) { 3084 if (callingUserId == userHandle) { 3085 userInfo = getUserInfoLU(userHandle); 3086 } else { 3087 UserInfo parent = getProfileParentLU(userHandle); 3088 if (parent != null && parent.id == callingUserId) { 3089 userInfo = getUserInfoLU(userHandle); 3090 } 3091 } 3092 } 3093 if (userInfo == null) { 3094 throw new SecurityException("userHandle can only be the calling user or a managed " 3095 + "profile associated with this user"); 3096 } 3097 return userInfo.creationTime; 3098 } 3099 3100 /** 3101 * Caches the list of user ids in an array, adjusting the array size when necessary. 3102 */ 3103 private void updateUserIds() { 3104 int num = 0; 3105 synchronized (mUsersLock) { 3106 final int userSize = mUsers.size(); 3107 for (int i = 0; i < userSize; i++) { 3108 if (!mUsers.valueAt(i).info.partial) { 3109 num++; 3110 } 3111 } 3112 final int[] newUsers = new int[num]; 3113 int n = 0; 3114 for (int i = 0; i < userSize; i++) { 3115 if (!mUsers.valueAt(i).info.partial) { 3116 newUsers[n++] = mUsers.keyAt(i); 3117 } 3118 } 3119 mUserIds = newUsers; 3120 } 3121 } 3122 3123 /** 3124 * Called right before a user is started. This gives us a chance to prepare 3125 * app storage and apply any user restrictions. 3126 */ 3127 public void onBeforeStartUser(int userId) { 3128 UserInfo userInfo = getUserInfo(userId); 3129 if (userInfo == null) { 3130 return; 3131 } 3132 final int userSerial = userInfo.serialNumber; 3133 // Migrate only if build fingerprints mismatch 3134 boolean migrateAppsData = !Build.FINGERPRINT.equals(userInfo.lastLoggedInFingerprint); 3135 mUserDataPreparer.prepareUserData(userId, userSerial, StorageManager.FLAG_STORAGE_DE); 3136 mPm.reconcileAppsData(userId, StorageManager.FLAG_STORAGE_DE, migrateAppsData); 3137 3138 if (userId != UserHandle.USER_SYSTEM) { 3139 synchronized (mRestrictionsLock) { 3140 applyUserRestrictionsLR(userId); 3141 } 3142 } 3143 } 3144 3145 /** 3146 * Called right before a user is unlocked. This gives us a chance to prepare 3147 * app storage. 3148 */ 3149 public void onBeforeUnlockUser(@UserIdInt int userId) { 3150 UserInfo userInfo = getUserInfo(userId); 3151 if (userInfo == null) { 3152 return; 3153 } 3154 final int userSerial = userInfo.serialNumber; 3155 // Migrate only if build fingerprints mismatch 3156 boolean migrateAppsData = !Build.FINGERPRINT.equals(userInfo.lastLoggedInFingerprint); 3157 mUserDataPreparer.prepareUserData(userId, userSerial, StorageManager.FLAG_STORAGE_CE); 3158 mPm.reconcileAppsData(userId, StorageManager.FLAG_STORAGE_CE, migrateAppsData); 3159 } 3160 3161 /** 3162 * Make a note of the last started time of a user and do some cleanup. 3163 * This is called with ActivityManagerService lock held. 3164 * @param userId the user that was just foregrounded 3165 */ 3166 public void onUserLoggedIn(@UserIdInt int userId) { 3167 UserData userData = getUserDataNoChecks(userId); 3168 if (userData == null || userData.info.partial) { 3169 Slog.w(LOG_TAG, "userForeground: unknown user #" + userId); 3170 return; 3171 } 3172 3173 final long now = System.currentTimeMillis(); 3174 if (now > EPOCH_PLUS_30_YEARS) { 3175 userData.info.lastLoggedInTime = now; 3176 } 3177 userData.info.lastLoggedInFingerprint = Build.FINGERPRINT; 3178 scheduleWriteUser(userData); 3179 } 3180 3181 /** 3182 * Returns the next available user id, filling in any holes in the ids. 3183 */ 3184 @VisibleForTesting 3185 int getNextAvailableId() { 3186 int nextId; 3187 synchronized (mUsersLock) { 3188 nextId = scanNextAvailableIdLocked(); 3189 if (nextId >= 0) { 3190 return nextId; 3191 } 3192 // All ids up to MAX_USER_ID were used. Remove all mRemovingUserIds, 3193 // except most recently removed 3194 if (mRemovingUserIds.size() > 0) { 3195 Slog.i(LOG_TAG, "All available IDs are used. Recycling LRU ids."); 3196 mRemovingUserIds.clear(); 3197 for (Integer recentlyRemovedId : mRecentlyRemovedIds) { 3198 mRemovingUserIds.put(recentlyRemovedId, true); 3199 } 3200 nextId = scanNextAvailableIdLocked(); 3201 } 3202 } 3203 if (nextId < 0) { 3204 throw new IllegalStateException("No user id available!"); 3205 } 3206 return nextId; 3207 } 3208 3209 private int scanNextAvailableIdLocked() { 3210 for (int i = MIN_USER_ID; i < MAX_USER_ID; i++) { 3211 if (mUsers.indexOfKey(i) < 0 && !mRemovingUserIds.get(i)) { 3212 return i; 3213 } 3214 } 3215 return -1; 3216 } 3217 3218 private String packageToRestrictionsFileName(String packageName) { 3219 return RESTRICTIONS_FILE_PREFIX + packageName + XML_SUFFIX; 3220 } 3221 3222 /** 3223 * Enforce that serial number stored in user directory inode matches the 3224 * given expected value. Gracefully sets the serial number if currently 3225 * undefined. 3226 * 3227 * @throws IOException when problem extracting serial number, or serial 3228 * number is mismatched. 3229 */ 3230 public static void enforceSerialNumber(File file, int serialNumber) throws IOException { 3231 if (StorageManager.isFileEncryptedEmulatedOnly()) { 3232 // When we're emulating FBE, the directory may have been chmod 3233 // 000'ed, meaning we can't read the serial number to enforce it; 3234 // instead of destroying the user, just log a warning. 3235 Slog.w(LOG_TAG, "Device is emulating FBE; assuming current serial number is valid"); 3236 return; 3237 } 3238 3239 final int foundSerial = getSerialNumber(file); 3240 Slog.v(LOG_TAG, "Found " + file + " with serial number " + foundSerial); 3241 3242 if (foundSerial == -1) { 3243 Slog.d(LOG_TAG, "Serial number missing on " + file + "; assuming current is valid"); 3244 try { 3245 setSerialNumber(file, serialNumber); 3246 } catch (IOException e) { 3247 Slog.w(LOG_TAG, "Failed to set serial number on " + file, e); 3248 } 3249 3250 } else if (foundSerial != serialNumber) { 3251 throw new IOException("Found serial number " + foundSerial 3252 + " doesn't match expected " + serialNumber); 3253 } 3254 } 3255 3256 /** 3257 * Set serial number stored in user directory inode. 3258 * 3259 * @throws IOException if serial number was already set 3260 */ 3261 private static void setSerialNumber(File file, int serialNumber) 3262 throws IOException { 3263 try { 3264 final byte[] buf = Integer.toString(serialNumber).getBytes(StandardCharsets.UTF_8); 3265 Os.setxattr(file.getAbsolutePath(), XATTR_SERIAL, buf, OsConstants.XATTR_CREATE); 3266 } catch (ErrnoException e) { 3267 throw e.rethrowAsIOException(); 3268 } 3269 } 3270 3271 /** 3272 * Return serial number stored in user directory inode. 3273 * 3274 * @return parsed serial number, or -1 if not set 3275 */ 3276 private static int getSerialNumber(File file) throws IOException { 3277 try { 3278 final byte[] buf = Os.getxattr(file.getAbsolutePath(), XATTR_SERIAL); 3279 final String serial = new String(buf); 3280 try { 3281 return Integer.parseInt(serial); 3282 } catch (NumberFormatException e) { 3283 throw new IOException("Bad serial number: " + serial); 3284 } 3285 } catch (ErrnoException e) { 3286 if (e.errno == OsConstants.ENODATA) { 3287 return -1; 3288 } else { 3289 throw e.rethrowAsIOException(); 3290 } 3291 } 3292 } 3293 3294 @Override 3295 public void setSeedAccountData(int userId, String accountName, String accountType, 3296 PersistableBundle accountOptions, boolean persist) { 3297 checkManageUsersPermission("Require MANAGE_USERS permission to set user seed data"); 3298 synchronized (mPackagesLock) { 3299 final UserData userData; 3300 synchronized (mUsersLock) { 3301 userData = getUserDataLU(userId); 3302 if (userData == null) { 3303 Slog.e(LOG_TAG, "No such user for settings seed data u=" + userId); 3304 return; 3305 } 3306 userData.seedAccountName = accountName; 3307 userData.seedAccountType = accountType; 3308 userData.seedAccountOptions = accountOptions; 3309 userData.persistSeedData = persist; 3310 } 3311 if (persist) { 3312 writeUserLP(userData); 3313 } 3314 } 3315 } 3316 3317 @Override 3318 public String getSeedAccountName() throws RemoteException { 3319 checkManageUsersPermission("Cannot get seed account information"); 3320 synchronized (mUsersLock) { 3321 UserData userData = getUserDataLU(UserHandle.getCallingUserId()); 3322 return userData.seedAccountName; 3323 } 3324 } 3325 3326 @Override 3327 public String getSeedAccountType() throws RemoteException { 3328 checkManageUsersPermission("Cannot get seed account information"); 3329 synchronized (mUsersLock) { 3330 UserData userData = getUserDataLU(UserHandle.getCallingUserId()); 3331 return userData.seedAccountType; 3332 } 3333 } 3334 3335 @Override 3336 public PersistableBundle getSeedAccountOptions() throws RemoteException { 3337 checkManageUsersPermission("Cannot get seed account information"); 3338 synchronized (mUsersLock) { 3339 UserData userData = getUserDataLU(UserHandle.getCallingUserId()); 3340 return userData.seedAccountOptions; 3341 } 3342 } 3343 3344 @Override 3345 public void clearSeedAccountData() throws RemoteException { 3346 checkManageUsersPermission("Cannot clear seed account information"); 3347 synchronized (mPackagesLock) { 3348 UserData userData; 3349 synchronized (mUsersLock) { 3350 userData = getUserDataLU(UserHandle.getCallingUserId()); 3351 if (userData == null) return; 3352 userData.clearSeedAccountData(); 3353 } 3354 writeUserLP(userData); 3355 } 3356 } 3357 3358 @Override 3359 public boolean someUserHasSeedAccount(String accountName, String accountType) 3360 throws RemoteException { 3361 checkManageUsersPermission("Cannot check seed account information"); 3362 synchronized (mUsersLock) { 3363 final int userSize = mUsers.size(); 3364 for (int i = 0; i < userSize; i++) { 3365 final UserData data = mUsers.valueAt(i); 3366 if (data.info.isInitialized()) continue; 3367 if (data.seedAccountName == null || !data.seedAccountName.equals(accountName)) { 3368 continue; 3369 } 3370 if (data.seedAccountType == null || !data.seedAccountType.equals(accountType)) { 3371 continue; 3372 } 3373 return true; 3374 } 3375 } 3376 return false; 3377 } 3378 3379 @Override 3380 public void onShellCommand(FileDescriptor in, FileDescriptor out, 3381 FileDescriptor err, String[] args, ShellCallback callback, 3382 ResultReceiver resultReceiver) { 3383 (new Shell()).exec(this, in, out, err, args, callback, resultReceiver); 3384 } 3385 3386 int onShellCommand(Shell shell, String cmd) { 3387 if (cmd == null) { 3388 return shell.handleDefaultCommands(cmd); 3389 } 3390 3391 final PrintWriter pw = shell.getOutPrintWriter(); 3392 try { 3393 switch(cmd) { 3394 case "list": 3395 return runList(pw); 3396 } 3397 } catch (RemoteException e) { 3398 pw.println("Remote exception: " + e); 3399 } 3400 return -1; 3401 } 3402 3403 private int runList(PrintWriter pw) throws RemoteException { 3404 final IActivityManager am = ActivityManager.getService(); 3405 final List<UserInfo> users = getUsers(false); 3406 if (users == null) { 3407 pw.println("Error: couldn't get users"); 3408 return 1; 3409 } else { 3410 pw.println("Users:"); 3411 for (int i = 0; i < users.size(); i++) { 3412 String running = am.isUserRunning(users.get(i).id, 0) ? " running" : ""; 3413 pw.println("\t" + users.get(i).toString() + running); 3414 } 3415 return 0; 3416 } 3417 } 3418 3419 @Override 3420 protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { 3421 if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP) 3422 != PackageManager.PERMISSION_GRANTED) { 3423 pw.println("Permission Denial: can't dump UserManager from from pid=" 3424 + Binder.getCallingPid() 3425 + ", uid=" + Binder.getCallingUid() 3426 + " without permission " 3427 + android.Manifest.permission.DUMP); 3428 return; 3429 } 3430 3431 long now = System.currentTimeMillis(); 3432 StringBuilder sb = new StringBuilder(); 3433 synchronized (mPackagesLock) { 3434 synchronized (mUsersLock) { 3435 pw.println("Users:"); 3436 for (int i = 0; i < mUsers.size(); i++) { 3437 UserData userData = mUsers.valueAt(i); 3438 if (userData == null) { 3439 continue; 3440 } 3441 UserInfo userInfo = userData.info; 3442 final int userId = userInfo.id; 3443 pw.print(" "); pw.print(userInfo); 3444 pw.print(" serialNo="); pw.print(userInfo.serialNumber); 3445 if (mRemovingUserIds.get(userId)) { 3446 pw.print(" <removing> "); 3447 } 3448 if (userInfo.partial) { 3449 pw.print(" <partial>"); 3450 } 3451 pw.println(); 3452 pw.print(" Created: "); 3453 if (userInfo.creationTime == 0) { 3454 pw.println("<unknown>"); 3455 } else { 3456 sb.setLength(0); 3457 TimeUtils.formatDuration(now - userInfo.creationTime, sb); 3458 sb.append(" ago"); 3459 pw.println(sb); 3460 } 3461 pw.print(" Last logged in: "); 3462 if (userInfo.lastLoggedInTime == 0) { 3463 pw.println("<unknown>"); 3464 } else { 3465 sb.setLength(0); 3466 TimeUtils.formatDuration(now - userInfo.lastLoggedInTime, sb); 3467 sb.append(" ago"); 3468 pw.println(sb); 3469 } 3470 pw.print(" Last logged in fingerprint: "); 3471 pw.println(userInfo.lastLoggedInFingerprint); 3472 pw.print(" Has profile owner: "); 3473 pw.println(mIsUserManaged.get(userId)); 3474 pw.println(" Restrictions:"); 3475 synchronized (mRestrictionsLock) { 3476 UserRestrictionsUtils.dumpRestrictions( 3477 pw, " ", mBaseUserRestrictions.get(userInfo.id)); 3478 pw.println(" Device policy global restrictions:"); 3479 UserRestrictionsUtils.dumpRestrictions( 3480 pw, " ", mDevicePolicyGlobalUserRestrictions.get(userInfo.id)); 3481 pw.println(" Device policy local restrictions:"); 3482 UserRestrictionsUtils.dumpRestrictions( 3483 pw, " ", mDevicePolicyLocalUserRestrictions.get(userInfo.id)); 3484 pw.println(" Effective restrictions:"); 3485 UserRestrictionsUtils.dumpRestrictions( 3486 pw, " ", mCachedEffectiveUserRestrictions.get(userInfo.id)); 3487 } 3488 3489 if (userData.account != null) { 3490 pw.print(" Account name: " + userData.account); 3491 pw.println(); 3492 } 3493 3494 if (userData.seedAccountName != null) { 3495 pw.print(" Seed account name: " + userData.seedAccountName); 3496 pw.println(); 3497 if (userData.seedAccountType != null) { 3498 pw.print(" account type: " + userData.seedAccountType); 3499 pw.println(); 3500 } 3501 if (userData.seedAccountOptions != null) { 3502 pw.print(" account options exist"); 3503 pw.println(); 3504 } 3505 } 3506 } 3507 } 3508 pw.println(); 3509 pw.println(" Device owner id:" + mDeviceOwnerUserId); 3510 pw.println(); 3511 pw.println(" Guest restrictions:"); 3512 synchronized (mGuestRestrictions) { 3513 UserRestrictionsUtils.dumpRestrictions(pw, " ", mGuestRestrictions); 3514 } 3515 synchronized (mUsersLock) { 3516 pw.println(); 3517 pw.println(" Device managed: " + mIsDeviceManaged); 3518 if (mRemovingUserIds.size() > 0) { 3519 pw.println(); 3520 pw.println(" Recently removed userIds: " + mRecentlyRemovedIds); 3521 } 3522 } 3523 synchronized (mUserStates) { 3524 pw.println(" Started users state: " + mUserStates); 3525 } 3526 // Dump some capabilities 3527 pw.println(); 3528 pw.println(" Max users: " + UserManager.getMaxSupportedUsers()); 3529 pw.println(" Supports switchable users: " + UserManager.supportsMultipleUsers()); 3530 pw.println(" All guests ephemeral: " + Resources.getSystem().getBoolean( 3531 com.android.internal.R.bool.config_guestUserEphemeral)); 3532 } 3533 } 3534 3535 final class MainHandler extends Handler { 3536 3537 @Override 3538 public void handleMessage(Message msg) { 3539 switch (msg.what) { 3540 case WRITE_USER_MSG: 3541 removeMessages(WRITE_USER_MSG, msg.obj); 3542 synchronized (mPackagesLock) { 3543 int userId = ((UserData) msg.obj).info.id; 3544 UserData userData = getUserDataNoChecks(userId); 3545 if (userData != null) { 3546 writeUserLP(userData); 3547 } 3548 } 3549 } 3550 } 3551 } 3552 3553 /** 3554 * @param userId 3555 * @return whether the user has been initialized yet 3556 */ 3557 boolean isInitialized(int userId) { 3558 return (getUserInfo(userId).flags & UserInfo.FLAG_INITIALIZED) != 0; 3559 } 3560 3561 private class LocalService extends UserManagerInternal { 3562 @Override 3563 public void setDevicePolicyUserRestrictions(int userId, @Nullable Bundle restrictions, 3564 boolean isDeviceOwner, int cameraRestrictionScope) { 3565 UserManagerService.this.setDevicePolicyUserRestrictionsInner(userId, restrictions, 3566 isDeviceOwner, cameraRestrictionScope); 3567 } 3568 3569 @Override 3570 public Bundle getBaseUserRestrictions(int userId) { 3571 synchronized (mRestrictionsLock) { 3572 return mBaseUserRestrictions.get(userId); 3573 } 3574 } 3575 3576 @Override 3577 public void setBaseUserRestrictionsByDpmsForMigration( 3578 int userId, Bundle baseRestrictions) { 3579 synchronized (mRestrictionsLock) { 3580 if (updateRestrictionsIfNeededLR( 3581 userId, new Bundle(baseRestrictions), mBaseUserRestrictions)) { 3582 invalidateEffectiveUserRestrictionsLR(userId); 3583 } 3584 } 3585 3586 final UserData userData = getUserDataNoChecks(userId); 3587 synchronized (mPackagesLock) { 3588 if (userData != null) { 3589 writeUserLP(userData); 3590 } else { 3591 Slog.w(LOG_TAG, "UserInfo not found for " + userId); 3592 } 3593 } 3594 } 3595 3596 @Override 3597 public boolean getUserRestriction(int userId, String key) { 3598 return getUserRestrictions(userId).getBoolean(key); 3599 } 3600 3601 @Override 3602 public void addUserRestrictionsListener(UserRestrictionsListener listener) { 3603 synchronized (mUserRestrictionsListeners) { 3604 mUserRestrictionsListeners.add(listener); 3605 } 3606 } 3607 3608 @Override 3609 public void removeUserRestrictionsListener(UserRestrictionsListener listener) { 3610 synchronized (mUserRestrictionsListeners) { 3611 mUserRestrictionsListeners.remove(listener); 3612 } 3613 } 3614 3615 @Override 3616 public void setDeviceManaged(boolean isManaged) { 3617 synchronized (mUsersLock) { 3618 mIsDeviceManaged = isManaged; 3619 } 3620 } 3621 3622 @Override 3623 public void setUserManaged(int userId, boolean isManaged) { 3624 synchronized (mUsersLock) { 3625 mIsUserManaged.put(userId, isManaged); 3626 } 3627 } 3628 3629 @Override 3630 public void setUserIcon(int userId, Bitmap bitmap) { 3631 long ident = Binder.clearCallingIdentity(); 3632 try { 3633 synchronized (mPackagesLock) { 3634 UserData userData = getUserDataNoChecks(userId); 3635 if (userData == null || userData.info.partial) { 3636 Slog.w(LOG_TAG, "setUserIcon: unknown user #" + userId); 3637 return; 3638 } 3639 writeBitmapLP(userData.info, bitmap); 3640 writeUserLP(userData); 3641 } 3642 sendUserInfoChangedBroadcast(userId); 3643 } finally { 3644 Binder.restoreCallingIdentity(ident); 3645 } 3646 } 3647 3648 @Override 3649 public void setForceEphemeralUsers(boolean forceEphemeralUsers) { 3650 synchronized (mUsersLock) { 3651 mForceEphemeralUsers = forceEphemeralUsers; 3652 } 3653 } 3654 3655 @Override 3656 public void removeAllUsers() { 3657 if (UserHandle.USER_SYSTEM == ActivityManager.getCurrentUser()) { 3658 // Remove the non-system users straight away. 3659 removeNonSystemUsers(); 3660 } else { 3661 // Switch to the system user first and then remove the other users. 3662 BroadcastReceiver userSwitchedReceiver = new BroadcastReceiver() { 3663 @Override 3664 public void onReceive(Context context, Intent intent) { 3665 int userId = 3666 intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL); 3667 if (userId != UserHandle.USER_SYSTEM) { 3668 return; 3669 } 3670 mContext.unregisterReceiver(this); 3671 removeNonSystemUsers(); 3672 } 3673 }; 3674 IntentFilter userSwitchedFilter = new IntentFilter(); 3675 userSwitchedFilter.addAction(Intent.ACTION_USER_SWITCHED); 3676 mContext.registerReceiver( 3677 userSwitchedReceiver, userSwitchedFilter, null, mHandler); 3678 3679 // Switch to the system user. 3680 ActivityManager am = 3681 (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE); 3682 am.switchUser(UserHandle.USER_SYSTEM); 3683 } 3684 } 3685 3686 @Override 3687 public void onEphemeralUserStop(int userId) { 3688 synchronized (mUsersLock) { 3689 UserInfo userInfo = getUserInfoLU(userId); 3690 if (userInfo != null && userInfo.isEphemeral()) { 3691 // Do not allow switching back to the ephemeral user again as the user is going 3692 // to be deleted. 3693 userInfo.flags |= UserInfo.FLAG_DISABLED; 3694 if (userInfo.isGuest()) { 3695 // Indicate that the guest will be deleted after it stops. 3696 userInfo.guestToRemove = true; 3697 } 3698 } 3699 } 3700 } 3701 3702 @Override 3703 public UserInfo createUserEvenWhenDisallowed(String name, int flags) { 3704 UserInfo user = createUserInternalUnchecked(name, flags, UserHandle.USER_NULL, null); 3705 // Keep this in sync with UserManager.createUser 3706 if (user != null && !user.isAdmin()) { 3707 setUserRestriction(UserManager.DISALLOW_SMS, true, user.id); 3708 setUserRestriction(UserManager.DISALLOW_OUTGOING_CALLS, true, user.id); 3709 } 3710 return user; 3711 } 3712 3713 @Override 3714 public boolean removeUserEvenWhenDisallowed(int userId) { 3715 return removeUserUnchecked(userId); 3716 } 3717 3718 @Override 3719 public boolean isUserRunning(int userId) { 3720 synchronized (mUserStates) { 3721 return mUserStates.get(userId, -1) >= 0; 3722 } 3723 } 3724 3725 @Override 3726 public void setUserState(int userId, int userState) { 3727 synchronized (mUserStates) { 3728 mUserStates.put(userId, userState); 3729 } 3730 } 3731 3732 @Override 3733 public void removeUserState(int userId) { 3734 synchronized (mUserStates) { 3735 mUserStates.delete(userId); 3736 } 3737 } 3738 3739 @Override 3740 public boolean isUserUnlockingOrUnlocked(int userId) { 3741 synchronized (mUserStates) { 3742 int state = mUserStates.get(userId, -1); 3743 return (state == UserState.STATE_RUNNING_UNLOCKING) 3744 || (state == UserState.STATE_RUNNING_UNLOCKED); 3745 } 3746 } 3747 3748 @Override 3749 public boolean isUserUnlocked(int userId) { 3750 synchronized (mUserStates) { 3751 int state = mUserStates.get(userId, -1); 3752 return state == UserState.STATE_RUNNING_UNLOCKED; 3753 } 3754 } 3755 } 3756 3757 /* Remove all the users except of the system one. */ 3758 private void removeNonSystemUsers() { 3759 ArrayList<UserInfo> usersToRemove = new ArrayList<>(); 3760 synchronized (mUsersLock) { 3761 final int userSize = mUsers.size(); 3762 for (int i = 0; i < userSize; i++) { 3763 UserInfo ui = mUsers.valueAt(i).info; 3764 if (ui.id != UserHandle.USER_SYSTEM) { 3765 usersToRemove.add(ui); 3766 } 3767 } 3768 } 3769 for (UserInfo ui: usersToRemove) { 3770 removeUser(ui.id); 3771 } 3772 } 3773 3774 private class Shell extends ShellCommand { 3775 @Override 3776 public int onCommand(String cmd) { 3777 return onShellCommand(this, cmd); 3778 } 3779 3780 @Override 3781 public void onHelp() { 3782 final PrintWriter pw = getOutPrintWriter(); 3783 pw.println("User manager (user) commands:"); 3784 pw.println(" help"); 3785 pw.println(" Print this help text."); 3786 pw.println(""); 3787 pw.println(" list"); 3788 pw.println(" Prints all users on the system."); 3789 } 3790 } 3791 3792 private static void debug(String message) { 3793 Log.d(LOG_TAG, message + 3794 (DBG_WITH_STACKTRACE ? " called at\n" + Debug.getCallers(10, " ") : "")); 3795 } 3796 3797 @VisibleForTesting 3798 static int getMaxManagedProfiles() { 3799 // Allow overriding max managed profiles on debuggable builds for testing 3800 // of multiple profiles. 3801 if (!Build.IS_DEBUGGABLE) { 3802 return MAX_MANAGED_PROFILES; 3803 } else { 3804 return SystemProperties.getInt("persist.sys.max_profiles", 3805 MAX_MANAGED_PROFILES); 3806 } 3807 } 3808 3809 @VisibleForTesting 3810 int getFreeProfileBadgeLU(int parentUserId) { 3811 int maxManagedProfiles = getMaxManagedProfiles(); 3812 boolean[] usedBadges = new boolean[maxManagedProfiles]; 3813 final int userSize = mUsers.size(); 3814 for (int i = 0; i < userSize; i++) { 3815 UserInfo ui = mUsers.valueAt(i).info; 3816 // Check which badge indexes are already used by this profile group. 3817 if (ui.isManagedProfile() 3818 && ui.profileGroupId == parentUserId 3819 && !mRemovingUserIds.get(ui.id) 3820 && ui.profileBadge < maxManagedProfiles) { 3821 usedBadges[ui.profileBadge] = true; 3822 } 3823 } 3824 for (int i = 0; i < maxManagedProfiles; i++) { 3825 if (!usedBadges[i]) { 3826 return i; 3827 } 3828 } 3829 return 0; 3830 } 3831 3832 /** 3833 * Checks if the given user has a managed profile associated with it. 3834 * @param userId The parent user 3835 * @return 3836 */ 3837 boolean hasManagedProfile(int userId) { 3838 synchronized (mUsersLock) { 3839 UserInfo userInfo = getUserInfoLU(userId); 3840 final int userSize = mUsers.size(); 3841 for (int i = 0; i < userSize; i++) { 3842 UserInfo profile = mUsers.valueAt(i).info; 3843 if (userId != profile.id && isProfileOf(userInfo, profile)) { 3844 return true; 3845 } 3846 } 3847 return false; 3848 } 3849 } 3850} 3851